Xinwen Deng / aem-src

/*
 * Decompiled with CFR 0_118.
 * 
 * Could not load the following classes:
 *  com.adobe.granite.workflow.WorkflowException
 *  com.adobe.granite.workflow.WorkflowSession
 *  com.adobe.granite.workflow.collection.util.ResultSet
 *  com.adobe.granite.workflow.exec.HistoryItem
 *  com.adobe.granite.workflow.exec.Participant
 *  com.adobe.granite.workflow.exec.Route
 *  com.adobe.granite.workflow.exec.WorkItem
 *  com.adobe.granite.workflow.exec.Workflow
 *  com.adobe.granite.workflow.exec.WorkflowData
 *  com.adobe.granite.workflow.exec.filter.WorkItemFilter
 *  com.adobe.granite.workflow.metadata.MetaDataMap
 *  com.adobe.granite.workflow.model.VersionException
 *  com.adobe.granite.workflow.model.WorkflowModel
 *  com.adobe.granite.workflow.model.WorkflowModelFilter
 *  com.day.cq.workflow.WorkflowException
 *  com.day.cq.workflow.WorkflowService
 *  com.day.cq.workflow.WorkflowSession
 *  com.day.cq.workflow.collection.util.ResultSet
 *  com.day.cq.workflow.exec.HistoryItem
 *  com.day.cq.workflow.exec.Route
 *  com.day.cq.workflow.exec.WorkItem
 *  com.day.cq.workflow.exec.Workflow
 *  com.day.cq.workflow.exec.WorkflowData
 *  com.day.cq.workflow.exec.filter.WorkItemFilter
 *  com.day.cq.workflow.metadata.MetaDataMap
 *  com.day.cq.workflow.model.WorkflowModel
 *  com.day.cq.workflow.model.WorkflowModelFilter
 *  javax.jcr.RepositoryException
 *  javax.jcr.Session
 *  javax.jcr.version.VersionException
 *  org.apache.jackrabbit.api.security.user.Authorizable
 *  org.apache.jackrabbit.api.security.user.UserManager
 *  org.slf4j.Logger
 *  org.slf4j.LoggerFactory
 */
package com.day.cq.workflow.impl;

import com.adobe.granite.workflow.exec.Participant;
import com.adobe.granite.workflow.exec.WorkflowData;
import com.adobe.granite.workflow.exec.filter.WorkItemFilter;
import com.adobe.granite.workflow.metadata.MetaDataMap;
import com.adobe.granite.workflow.model.VersionException;
import com.day.cq.workflow.WorkflowException;
import com.day.cq.workflow.WorkflowService;
import com.day.cq.workflow.WorkflowSession;
import com.day.cq.workflow.collection.util.ResultSet;
import com.day.cq.workflow.exec.HistoryItem;
import com.day.cq.workflow.exec.Route;
import com.day.cq.workflow.exec.WorkItem;
import com.day.cq.workflow.exec.Workflow;
import com.day.cq.workflow.impl.CQWorkflowService;
import com.day.cq.workflow.impl.GraniteWorkItemFilter;
import com.day.cq.workflow.impl.exec.CQHistoryItemWrapper;
import com.day.cq.workflow.impl.exec.CQRouteWrapper;
import com.day.cq.workflow.impl.exec.CQWorkItemWrapper;
import com.day.cq.workflow.impl.exec.CQWorkflowDataWrapper;
import com.day.cq.workflow.impl.exec.CQWorkflowWrapper;
import com.day.cq.workflow.impl.metadata.CQMetaDataMap;
import com.day.cq.workflow.impl.model.CQWorkflowModelWrapper;
import com.day.cq.workflow.impl.util.CQResultSet;
import com.day.cq.workflow.model.WorkflowModel;
import com.day.cq.workflow.model.WorkflowModelFilter;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.security.AccessControlException;
import java.util.ArrayList;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import org.apache.jackrabbit.api.security.user.Authorizable;
import org.apache.jackrabbit.api.security.user.UserManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class CQWorkflowSessionWrapper
implements WorkflowSession {
    private static final Logger log = LoggerFactory.getLogger(CQWorkflowSessionWrapper.class);
    private com.adobe.granite.workflow.WorkflowSession graniteWorkflowSession;
    private WorkflowService workflowService;

    public CQWorkflowSessionWrapper(WorkflowService workflowService, com.adobe.granite.workflow.WorkflowSession graniteWorkflowSession) {
        if (workflowService == null || graniteWorkflowSession == null) {
            throw new RuntimeException("Workflow Wrappers cannot be instantiated with null values");
        }
        this.graniteWorkflowSession = graniteWorkflowSession;
        this.workflowService = workflowService;
    }

    public WorkflowService getWorkflowService() {
        return this.workflowService;
    }

    public Session getSession() {
        return (Session)this.graniteWorkflowSession.adaptTo(Session.class);
    }

    private UserManager getUserManager() {
        if (this.workflowService instanceof CQWorkflowService) {
            return ((CQWorkflowService)this.workflowService).getUserManager();
        }
        throw new RuntimeException("Unknown version of CQ UserManager: " + this.workflowService.getClass());
    }

    public Authorizable getUser() {
        Authorizable auth = null;
        try {
            auth = this.getUserManager().getAuthorizable(((Session)this.graniteWorkflowSession.adaptTo(Session.class)).getUserID());
        }
        catch (RepositoryException e) {
            log.error("Unable to lookup the User.", (Throwable)e);
        }
        return auth;
    }

    public WorkflowData translate(com.day.cq.workflow.exec.WorkflowData data) {
        WorkflowData graniteData = this.graniteWorkflowSession.newWorkflowData(data.getPayloadType(), data.getPayload());
        graniteData.getMetaDataMap().putAll((Map)data.getMetaDataMap());
        return graniteData;
    }

    public boolean evaluate(com.day.cq.workflow.exec.WorkflowData data, String rule) {
        WorkflowData graniteData = this.translate(data);
        try {
            Method method = this.graniteWorkflowSession.getClass().getMethod("evaluate", WorkflowData.class, String.class);
            if (method != null) {
                boolean result = (Boolean)method.invoke((Object)this.graniteWorkflowSession, new Object[]{graniteData, rule});
                return result;
            }
        }
        catch (NoSuchMethodException e) {
            log.warn("Error calling evaluate", (Throwable)e);
        }
        catch (InvocationTargetException e) {
            log.warn("Error calling evaluate", (Throwable)e);
        }
        catch (IllegalAccessException e) {
            log.warn("Error calling evaluate", (Throwable)e);
        }
        throw new UnsupportedOperationException("not supported");
    }

    public void deployModel(WorkflowModel model) throws WorkflowException {
        if (model instanceof CQWorkflowModelWrapper) {
            try {
                this.graniteWorkflowSession.deployModel(((CQWorkflowModelWrapper)model).getGraniteModel());
            }
            catch (com.adobe.granite.workflow.WorkflowException e) {
                throw new WorkflowException(e.getMessage(), e.getCause());
            }
        } else {
            throw new UnsupportedOperationException("invalid type of workflowModel: " + model.getClass());
        }
    }

    public WorkflowModel createNewModel(String title) throws WorkflowException {
        try {
            return new CQWorkflowModelWrapper(this.graniteWorkflowSession.createNewModel(title, null));
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public WorkflowModel createNewModel(String title, String id) throws WorkflowException {
        try {
            return new CQWorkflowModelWrapper(this.graniteWorkflowSession.createNewModel(title, id));
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public void deleteModel(String id) throws WorkflowException {
        try {
            this.graniteWorkflowSession.deleteModel(id);
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public WorkflowModel[] getModels() throws WorkflowException {
        return (WorkflowModel[])this.getModels(0, -1).getItems();
    }

    public WorkflowModel[] getModels(WorkflowModelFilter filter) throws WorkflowException {
        return (WorkflowModel[])this.getModels(0, -1, filter).getItems();
    }

    public ResultSet<WorkflowModel> getModels(long start, long limit) throws WorkflowException {
        return this.getModels(start, limit, new WorkflowModelFilter(){

            public boolean doInclude(WorkflowModel arg0) {
                return true;
            }
        });
    }

    public ResultSet<WorkflowModel> getModels(long start, long limit, WorkflowModelFilter filter) throws WorkflowException {
        try {
            com.adobe.granite.workflow.collection.util.ResultSet models = this.graniteWorkflowSession.getModels(start, limit, new com.adobe.granite.workflow.model.WorkflowModelFilter(){

                public boolean doInclude(com.adobe.granite.workflow.model.WorkflowModel workflowModel) {
                    return true;
                }
            });
            CQResultSet<WorkflowModel> resultSet = new CQResultSet<WorkflowModel>((T[])new WorkflowModel[((com.adobe.granite.workflow.model.WorkflowModel[])models.getItems()).length], models.getTotalSize());
            for (int i = 0; i < ((com.adobe.granite.workflow.model.WorkflowModel[])models.getItems()).length; ++i) {
                if (((com.adobe.granite.workflow.model.WorkflowModel[])models.getItems())[i] == null) continue;
                resultSet.getItems()[i] = new CQWorkflowModelWrapper(((com.adobe.granite.workflow.model.WorkflowModel[])models.getItems())[i]);
            }
            return resultSet;
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public WorkflowModel getModel(String id) throws WorkflowException {
        try {
            com.adobe.granite.workflow.model.WorkflowModel graniteModel = this.graniteWorkflowSession.getModel(id);
            if (graniteModel != null) {
                return new CQWorkflowModelWrapper(graniteModel);
            }
            return null;
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public WorkflowModel getModel(String id, String version) throws WorkflowException, javax.jcr.version.VersionException {
        try {
            com.adobe.granite.workflow.model.WorkflowModel graniteModel = this.graniteWorkflowSession.getModel(id, version);
            if (graniteModel != null) {
                return new CQWorkflowModelWrapper(graniteModel);
            }
            return null;
        }
        catch (VersionException ve) {
            throw new javax.jcr.version.VersionException((Throwable)ve);
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public Workflow startWorkflow(WorkflowModel model, com.day.cq.workflow.exec.WorkflowData data) throws WorkflowException {
        return this.startWorkflow(model, data, new CQMetaDataMap());
    }

    public Workflow startWorkflow(WorkflowModel model, com.day.cq.workflow.exec.WorkflowData data, Dictionary<String, String> metaData) throws WorkflowException {
        if (!(model instanceof CQWorkflowModelWrapper)) {
            throw new UnsupportedOperationException("invalid type of workflowModel: " + model.getClass());
        }
        com.adobe.granite.workflow.model.WorkflowModel graniteModel = ((CQWorkflowModelWrapper)model).getGraniteModel();
        try {
            com.adobe.granite.workflow.exec.Workflow workflow = this.graniteWorkflowSession.startWorkflow(graniteModel, this.translate(data), this.translateMetaData(metaData));
            if (workflow != null) {
                return new CQWorkflowWrapper(workflow);
            }
            return null;
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    protected Map<String, Object> translateMetaData(Dictionary<String, String> metaData) {
        HashMap<String, String> translatedMetaData = null;
        if (metaData != null) {
            translatedMetaData = new HashMap<String, String>();
            Enumeration<String> enumeration = metaData.keys();
            while (enumeration.hasMoreElements()) {
                String key = enumeration.nextElement();
                String value = metaData.get(key);
                translatedMetaData.put(key, value);
            }
        }
        return translatedMetaData;
    }

    public Workflow startWorkflow(WorkflowModel model, com.day.cq.workflow.exec.WorkflowData data, Map<String, Object> metaData) throws WorkflowException {
        if (!(model instanceof CQWorkflowModelWrapper)) {
            throw new UnsupportedOperationException("invalid type of workflowModel: " + model.getClass());
        }
        com.adobe.granite.workflow.model.WorkflowModel graniteModel = ((CQWorkflowModelWrapper)model).getGraniteModel();
        try {
            com.adobe.granite.workflow.exec.Workflow workflow = this.graniteWorkflowSession.startWorkflow(graniteModel, this.translate(data), metaData);
            if (workflow != null) {
                return new CQWorkflowWrapper(workflow);
            }
            return null;
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public void terminateWorkflow(Workflow instance) throws WorkflowException {
        if (!(instance instanceof CQWorkflowWrapper)) {
            throw new UnsupportedOperationException("invalid type of workflow: " + instance.getClass());
        }
        com.adobe.granite.workflow.exec.Workflow graniteWorkflow = ((CQWorkflowWrapper)instance).getGraniteWorkflow(this.graniteWorkflowSession);
        try {
            this.graniteWorkflowSession.terminateWorkflow(graniteWorkflow);
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public void resumeWorkflow(Workflow instance) throws WorkflowException {
        if (!(instance instanceof CQWorkflowWrapper)) {
            throw new UnsupportedOperationException("invalid type of workflow: " + instance.getClass());
        }
        com.adobe.granite.workflow.exec.Workflow graniteWorkflow = ((CQWorkflowWrapper)instance).getGraniteWorkflow(this.graniteWorkflowSession);
        try {
            this.graniteWorkflowSession.resumeWorkflow(graniteWorkflow);
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public void suspendWorkflow(Workflow instance) throws WorkflowException {
        if (!(instance instanceof CQWorkflowWrapper)) {
            throw new UnsupportedOperationException("invalid type of workflow: " + instance.getClass());
        }
        com.adobe.granite.workflow.exec.Workflow graniteWorkflow = ((CQWorkflowWrapper)instance).getGraniteWorkflow(this.graniteWorkflowSession);
        try {
            this.graniteWorkflowSession.suspendWorkflow(graniteWorkflow);
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public WorkItem[] getActiveWorkItems() throws WorkflowException {
        try {
            return this.translate(this.graniteWorkflowSession.getActiveWorkItems());
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public ResultSet<WorkItem> getActiveWorkItems(long start, long limit) throws WorkflowException {
        try {
            return this.translate(this.graniteWorkflowSession.getActiveWorkItems(start, limit));
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public ResultSet<WorkItem> getActiveWorkItems(long start, long limit, com.day.cq.workflow.exec.filter.WorkItemFilter filter) throws WorkflowException {
        GraniteWorkItemFilter graniteFilter = new GraniteWorkItemFilter(filter);
        ResultSet<WorkItem> cqResult = null;
        try {
            com.adobe.granite.workflow.collection.util.ResultSet tempResult = this.graniteWorkflowSession.getActiveWorkItems(start, limit, (WorkItemFilter)graniteFilter);
            cqResult = this.translate(tempResult);
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
        return cqResult;
    }

    private ResultSet<WorkItem> translate(com.adobe.granite.workflow.collection.util.ResultSet<com.adobe.granite.workflow.exec.WorkItem> tempResult) {
        if (tempResult == null) {
            return null;
        }
        com.adobe.granite.workflow.exec.WorkItem[] graniteWorkItems = (com.adobe.granite.workflow.exec.WorkItem[])tempResult.getItems();
        WorkItem[] items = this.translate(graniteWorkItems);
        return new CQResultSet<WorkItem>((T[])items, tempResult.getTotalSize());
    }

    private WorkItem[] translate(com.adobe.granite.workflow.exec.WorkItem[] graniteWorkItems) {
        ArrayList<CQWorkItemWrapper> active = new ArrayList<CQWorkItemWrapper>();
        for (com.adobe.granite.workflow.exec.WorkItem graniteWorkItem : graniteWorkItems) {
            if (graniteWorkItem == null) continue;
            CQWorkItemWrapper cqWorkItem = new CQWorkItemWrapper(graniteWorkItem);
            active.add(cqWorkItem);
        }
        WorkItem[] items = active.toArray((T[])new WorkItem[active.size()]);
        return items;
    }

    public WorkItem[] getAllWorkItems() throws WorkflowException {
        try {
            return this.translate(this.graniteWorkflowSession.getAllWorkItems());
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public ResultSet<WorkItem> getAllWorkItems(long start, long limit) throws WorkflowException {
        try {
            ResultSet<WorkItem> workitems = this.translate(this.graniteWorkflowSession.getAllWorkItems(start, limit));
            return workitems;
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public WorkItem getWorkItem(String id) throws WorkflowException {
        try {
            com.adobe.granite.workflow.exec.WorkItem graniteWorkItem = this.graniteWorkflowSession.getWorkItem(id);
            if (graniteWorkItem != null) {
                return new CQWorkItemWrapper(graniteWorkItem);
            }
            return null;
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    private Workflow[] translate(com.adobe.granite.workflow.exec.Workflow[] workflows) {
        ArrayList<CQWorkflowWrapper> active = new ArrayList<CQWorkflowWrapper>(workflows.length);
        for (com.adobe.granite.workflow.exec.Workflow graniteWorkflow : workflows) {
            if (graniteWorkflow == null || graniteWorkflow == null) continue;
            CQWorkflowWrapper cqWorkItem = new CQWorkflowWrapper(graniteWorkflow);
            active.add(cqWorkItem);
        }
        Workflow[] items = active.toArray((T[])new Workflow[active.size()]);
        return items;
    }

    public Workflow[] getWorkflows(String[] states) throws WorkflowException {
        try {
            return this.translate(this.graniteWorkflowSession.getWorkflows(states));
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public ResultSet<Workflow> getWorkflows(String[] states, long start, long limit) throws WorkflowException {
        try {
            com.adobe.granite.workflow.collection.util.ResultSet graniteWorkflows = this.graniteWorkflowSession.getWorkflows(states, start, limit);
            return new CQResultSet<Workflow>((T[])this.translate((com.adobe.granite.workflow.exec.Workflow[])graniteWorkflows.getItems()), graniteWorkflows.getTotalSize());
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public Workflow[] getAllWorkflows() throws WorkflowException {
        try {
            return this.translate(this.graniteWorkflowSession.getAllWorkflows());
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public Workflow getWorkflow(String id) throws WorkflowException {
        try {
            com.adobe.granite.workflow.exec.Workflow graniteWorkflow = this.graniteWorkflowSession.getWorkflow(id);
            if (graniteWorkflow != null) {
                return new CQWorkflowWrapper(graniteWorkflow);
            }
            return null;
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public void complete(WorkItem item, Route route) throws WorkflowException {
        if (!(item instanceof CQWorkItemWrapper)) {
            throw new UnsupportedOperationException("invalid type of workflowModel: " + item.getClass());
        }
        com.adobe.granite.workflow.exec.WorkItem graniteItem = ((CQWorkItemWrapper)item).getGraniteWorkItem();
        if (!(route instanceof CQRouteWrapper)) {
            throw new UnsupportedOperationException("invalid type of route: " + route.getClass());
        }
        com.adobe.granite.workflow.exec.Route graniteRoute = ((CQRouteWrapper)route).getGraniteRoute();
        try {
            this.graniteWorkflowSession.complete(graniteItem, graniteRoute);
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public List<Route> getRoutes(WorkItem item) throws WorkflowException {
        if (!(item instanceof CQWorkItemWrapper)) {
            throw new UnsupportedOperationException("invalid type of WorkItem: " + item.getClass());
        }
        com.adobe.granite.workflow.exec.WorkItem graniteItem = ((CQWorkItemWrapper)item).getGraniteWorkItem();
        try {
            List routes = this.graniteWorkflowSession.getRoutes(graniteItem, false);
            return this.translate(routes);
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    private List<Route> translate(List<com.adobe.granite.workflow.exec.Route> graniteRoutes) {
        if (graniteRoutes != null) {
            ArrayList<Route> routes = new ArrayList<Route>(graniteRoutes.size());
            for (com.adobe.granite.workflow.exec.Route route : graniteRoutes) {
                if (route == null) continue;
                routes.add(new CQRouteWrapper(route));
            }
            return routes;
        }
        return null;
    }

    public List<Route> getRoutes(WorkItem item, boolean expand) throws WorkflowException {
        if (!(item instanceof CQWorkItemWrapper)) {
            throw new UnsupportedOperationException("invalid type of WorkItem: " + item.getClass());
        }
        com.adobe.granite.workflow.exec.WorkItem graniteItem = ((CQWorkItemWrapper)item).getGraniteWorkItem();
        try {
            List routes = this.graniteWorkflowSession.getRoutes(graniteItem, expand);
            return this.translate(routes);
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public List<Route> getBackRoutes(WorkItem item) throws WorkflowException {
        if (!(item instanceof CQWorkItemWrapper)) {
            throw new UnsupportedOperationException("invalid type of workItem: " + item.getClass());
        }
        com.adobe.granite.workflow.exec.WorkItem graniteItem = ((CQWorkItemWrapper)item).getGraniteWorkItem();
        try {
            List routes = this.graniteWorkflowSession.getBackRoutes(graniteItem, false);
            return this.translate(routes);
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public List<Route> getBackRoutes(WorkItem item, boolean expand) throws WorkflowException {
        if (!(item instanceof CQWorkItemWrapper)) {
            throw new UnsupportedOperationException("invalid type of workItem: " + item.getClass());
        }
        com.adobe.granite.workflow.exec.WorkItem graniteItem = ((CQWorkItemWrapper)item).getGraniteWorkItem();
        try {
            List routes = this.graniteWorkflowSession.getBackRoutes(graniteItem, expand);
            return this.translate(routes);
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public com.day.cq.workflow.exec.WorkflowData newWorkflowData(String payloadType, Object payload) {
        WorkflowData workflowData = this.graniteWorkflowSession.newWorkflowData(payloadType, payload);
        return new CQWorkflowDataWrapper(workflowData);
    }

    public List<Authorizable> getDelegatees(WorkItem item) throws WorkflowException {
        if (!(item instanceof CQWorkItemWrapper)) {
            throw new UnsupportedOperationException("invalid type of workflowModel: " + item.getClass());
        }
        com.adobe.granite.workflow.exec.WorkItem graniteItem = ((CQWorkItemWrapper)item).getGraniteWorkItem();
        try {
            Iterator graniteDelegates = this.graniteWorkflowSession.getDelegates(graniteItem);
            ArrayList<Authorizable> delegates = new ArrayList<Authorizable>();
            UserManager userManager = this.getUserManager();
            while (graniteDelegates.hasNext()) {
                String id = ((Participant)graniteDelegates.next()).getID();
                try {
                    delegates.add(userManager.getAuthorizable(id));
                }
                catch (RepositoryException e) {
                    log.error("Unable to lookup Authorizable with ID [{}].", (Object)id, (Object)e);
                }
            }
            return delegates;
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            WorkflowException we = new WorkflowException(e.getMessage(), e.getCause());
            we.setStackTrace(e.getStackTrace());
            throw we;
        }
    }

    public void delegateWorkItem(WorkItem item, Authorizable participant) throws WorkflowException, AccessControlException {
        if (!(item instanceof CQWorkItemWrapper)) {
            throw new UnsupportedOperationException("invalid type of workflowModel: " + item.getClass());
        }
        com.adobe.granite.workflow.exec.WorkItem graniteItem = ((CQWorkItemWrapper)item).getGraniteWorkItem();
        try {
            Iterator delegatees = this.graniteWorkflowSession.getDelegates(((CQWorkItemWrapper)item).getGraniteWorkItem());
            while (delegatees.hasNext()) {
                Participant delegatee = (Participant)delegatees.next();
                if (!delegatee.getID().equals(participant.getID())) continue;
                this.graniteWorkflowSession.delegateWorkItem(graniteItem, delegatee);
                break;
            }
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
        catch (RepositoryException e) {
            throw new WorkflowException("Unable to look up participant's ID", (Throwable)e);
        }
    }

    public List<HistoryItem> getHistory(Workflow instance) throws WorkflowException {
        if (!(instance instanceof CQWorkflowWrapper)) {
            throw new UnsupportedOperationException("invalid type of workflow: " + instance.getClass());
        }
        com.adobe.granite.workflow.exec.Workflow graniteWorkflow = ((CQWorkflowWrapper)instance).getGraniteWorkflow(this.graniteWorkflowSession);
        try {
            List graniteHistoryItems = this.graniteWorkflowSession.getHistory(graniteWorkflow);
            ArrayList<HistoryItem> items = new ArrayList<HistoryItem>(graniteHistoryItems.size());
            for (com.adobe.granite.workflow.exec.HistoryItem item : graniteHistoryItems) {
                if (item == null) continue;
                items.add(new CQHistoryItemWrapper(item));
            }
            return items;
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException(e.getMessage(), e.getCause());
        }
    }

    public void updateWorkflowData(Workflow instance, com.day.cq.workflow.exec.WorkflowData data) {
        com.adobe.granite.workflow.exec.Workflow graniteWorkflow;
        if (instance instanceof CQWorkflowWrapper) {
            try {
                graniteWorkflow = ((CQWorkflowWrapper)instance).getGraniteWorkflow(this.graniteWorkflowSession);
            }
            catch (WorkflowException e) {
                throw new RuntimeException("Unable to update workflow data.", (Throwable)e);
            }
        } else {
            throw new UnsupportedOperationException("invalid type of workflow: " + instance.getClass());
        }
        this.graniteWorkflowSession.updateWorkflowData(graniteWorkflow, this.translate(data));
    }

    public void logout() {
        if (this.graniteWorkflowSession != null) {
            this.graniteWorkflowSession.logout();
        }
    }

    public boolean isSuperuser() {
        return this.graniteWorkflowSession.isSuperuser();
    }

    public void restartWorkflow(Workflow workflow) throws WorkflowException {
        if (!(workflow instanceof CQWorkflowWrapper)) {
            throw new UnsupportedOperationException("invalid type of workflow: " + workflow.getClass());
        }
        com.adobe.granite.workflow.exec.Workflow graniteWorkflow = ((CQWorkflowWrapper)workflow).getGraniteWorkflow(this.graniteWorkflowSession);
        try {
            this.graniteWorkflowSession.restartWorkflow(graniteWorkflow);
        }
        catch (com.adobe.granite.workflow.WorkflowException e) {
            throw new WorkflowException((Throwable)e);
        }
    }

}