WorkflowTaskService.java

/**
 * Copyright (c) 2015 WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
 * <p/>
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * <p/>
 * http://www.apache.org/licenses/LICENSE-2.0
 * <p/>
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.wso2.carbon.bpmn.rest.service.runtime;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.activiti.engine.*;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.impl.persistence.entity.TaskEntity;
import org.activiti.engine.impl.persistence.entity.VariableInstanceEntity;
import org.activiti.engine.task.*;
import org.apache.commons.io.IOUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.cxf.jaxrs.ext.multipart.MultipartBody;
import org.wso2.carbon.bpmn.rest.common.RequestUtil;
import org.wso2.carbon.bpmn.rest.common.RestResponseFactory;
import org.wso2.carbon.bpmn.rest.common.RestUrls;
import org.wso2.carbon.bpmn.rest.common.exception.BPMNConflictException;
import org.wso2.carbon.bpmn.rest.common.exception.BPMNForbiddenException;
import org.wso2.carbon.bpmn.rest.common.utils.BPMNOSGIService;
import org.wso2.carbon.bpmn.rest.common.utils.Utils;
import org.wso2.carbon.bpmn.rest.engine.variable.RestVariable;
import org.wso2.carbon.bpmn.rest.model.common.DataResponse;
import org.wso2.carbon.bpmn.rest.model.common.RestIdentityLink;
import org.wso2.carbon.bpmn.rest.model.runtime.*;
import org.wso2.carbon.bpmn.rest.service.base.BaseTaskService;

import javax.activation.DataHandler;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.ws.rs.*;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriInfo;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import java.io.*;
import java.util.*;

@Path("/tasks")
public class WorkflowTaskService extends BaseTaskService {

    private static final Log log = LogFactory.getLog(WorkflowTaskService.class);
    @Context
    UriInfo uriInfo;


    @GET
    @Path("/")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response getTasks() {

        // Create a Task query request
        TaskQueryRequest request = new TaskQueryRequest();

        Map<String, String> requestParams = new HashMap<>();

        for (String property : allPropertiesList) {
            String value = uriInfo.getQueryParameters().getFirst(property);

            if (value != null) {
                requestParams.put(property, value);
            }
        }

        // Populate filter-parameters
        if (requestParams.containsKey("name")) {
            request.setName(requestParams.get("name"));
        }

        if (requestParams.containsKey("nameLike")) {
            request.setNameLike(requestParams.get("nameLike"));
        }

        if (requestParams.containsKey("description")) {
            request.setDescription(requestParams.get("description"));
        }

        if (requestParams.containsKey("descriptionLike")) {
            request.setDescriptionLike(requestParams.get("descriptionLike"));
        }

        if (requestParams.containsKey("priority")) {
            request.setPriority(Integer.valueOf(requestParams.get("priority")));
        }

        if (requestParams.containsKey("minimumPriority")) {
            request.setMinimumPriority(Integer.valueOf(requestParams.get("minimumPriority")));
        }

        if (requestParams.containsKey("maximumPriority")) {
            request.setMaximumPriority(Integer.valueOf(requestParams.get("maximumPriority")));
        }

        if (requestParams.containsKey("assignee")) {
            request.setAssignee(requestParams.get("assignee"));
        }

        if (requestParams.containsKey("owner")) {
            request.setOwner(requestParams.get("owner"));
        }

        if (requestParams.containsKey("unassigned")) {
            request.setUnassigned(Boolean.valueOf(requestParams.get("unassigned")));
        }

        if (requestParams.containsKey("delegationState")) {
            request.setDelegationState(requestParams.get("delegationState"));
        }

        if (requestParams.containsKey("candidateUser")) {
            request.setCandidateUser(requestParams.get("candidateUser"));
        }

        if (requestParams.containsKey("involvedUser")) {
            request.setInvolvedUser(requestParams.get("involvedUser"));
        }

        if (requestParams.containsKey("candidateGroup")) {
            request.setCandidateGroup(requestParams.get("candidateGroup"));
        }

        if (requestParams.containsKey("candidateGroups")) {
            String[] candidateGroups = requestParams.get("candidateGroups").split(",");
            List<String> groups = new ArrayList<String>(candidateGroups.length);
            for (String candidateGroup : candidateGroups) {
                groups.add(candidateGroup);
            }
            request.setCandidateGroupIn(groups);
        }

        if (requestParams.containsKey("processDefinitionKey")) {
            request.setProcessDefinitionKey(requestParams.get("processDefinitionKey"));
        }

        if (requestParams.containsKey("processDefinitionKeyLike")) {
            request.setProcessDefinitionKeyLike(requestParams.get("processDefinitionKeyLike"));
        }

        if (requestParams.containsKey("processDefinitionName")) {
            request.setProcessDefinitionName(requestParams.get("processDefinitionName"));
        }

        if (requestParams.containsKey("processDefinitionNameLike")) {
            request.setProcessDefinitionNameLike(requestParams.get("processDefinitionNameLike"));
        }

        if (requestParams.containsKey("processInstanceId")) {
            request.setProcessInstanceId(requestParams.get("processInstanceId"));
        }

        if (requestParams.containsKey("processInstanceBusinessKey")) {
            request.setProcessInstanceBusinessKey(requestParams.get("processInstanceBusinessKey"));
        }

        if (requestParams.containsKey("executionId")) {
            request.setExecutionId(requestParams.get("executionId"));
        }

        if (requestParams.containsKey("createdOn")) {
            request.setCreatedOn(RequestUtil.getDate(requestParams, "createdOn"));
        }

        if (requestParams.containsKey("createdBefore")) {
            request.setCreatedBefore(RequestUtil.getDate(requestParams, "createdBefore"));
        }

        if (requestParams.containsKey("createdAfter")) {
            request.setCreatedAfter(RequestUtil.getDate(requestParams, "createdAfter"));
        }

        if (requestParams.containsKey("excludeSubTasks")) {
            request.setExcludeSubTasks(Boolean.valueOf(requestParams.get("excludeSubTasks")));
        }

        if (requestParams.containsKey("taskDefinitionKey")) {
            request.setTaskDefinitionKey(requestParams.get("taskDefinitionKey"));
        }

        if (requestParams.containsKey("taskDefinitionKeyLike")) {
            request.setTaskDefinitionKeyLike(requestParams.get("taskDefinitionKeyLike"));
        }

        if (requestParams.containsKey("dueDate")) {
            request.setDueDate(RequestUtil.getDate(requestParams, "dueDate"));
        }

        if (requestParams.containsKey("dueBefore")) {
            request.setDueBefore(RequestUtil.getDate(requestParams, "dueBefore"));
        }

        if (requestParams.containsKey("dueAfter")) {
            request.setDueAfter(RequestUtil.getDate(requestParams, "dueAfter"));
        }

        if (requestParams.containsKey("active")) {
            request.setActive(Boolean.valueOf(requestParams.get("active")));
        }

        if (requestParams.containsKey("includeTaskLocalVariables")) {
            request.setIncludeTaskLocalVariables(Boolean.valueOf(requestParams.get("includeTaskLocalVariables")));
        }

        if (requestParams.containsKey("includeProcessVariables")) {
            request.setIncludeProcessVariables(Boolean.valueOf(requestParams.get("includeProcessVariables")));
        }

        if (requestParams.containsKey("tenantId")) {
            request.setTenantId(requestParams.get("tenantId"));
        }

        if (requestParams.containsKey("tenantIdLike")) {
            request.setTenantIdLike(requestParams.get("tenantIdLike"));
        }

        if (requestParams.containsKey("withoutTenantId") && Boolean.valueOf(requestParams.get("withoutTenantId"))) {
            request.setWithoutTenantId(Boolean.TRUE);
        }

        if (requestParams.containsKey("candidateOrAssigned")) {
            request.setCandidateOrAssigned(requestParams.get("candidateOrAssigned"));
        }

        DataResponse dataResponse = getTasksFromQueryRequest(request, uriInfo, requestParams);
        return Response.ok().entity(dataResponse).build();
        //return getTasksFromQueryRequest(request, requestParams);
    }

    /**
     * Create a new task instance for a process instance.
     * @param taskRequest
     * @return
     */
    @POST
    @Path("/")
    @Consumes({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response createTask(TaskRequest taskRequest) {
        TaskService taskService = BPMNOSGIService.getTaskService();
        Task task = taskService.newTask();

        // Populate the task properties based on the request
        populateTaskFromRequest(task, taskRequest);
        if (taskRequest.isTenantIdSet()) {
            ((TaskEntity) task).setTenantId(taskRequest.getTenantId());
        }
        taskService.saveTask(task);
        return Response.ok().entity(new RestResponseFactory().createTaskResponse(task, uriInfo.getBaseUri().toString())).build();
    }

    @GET
    @Path("/{taskId}")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response getTask(@PathParam("taskId") String taskId) {
        TaskResponse taskResponse = new RestResponseFactory().createTaskResponse(getTaskFromRequest(taskId), uriInfo
                .getBaseUri()
                .toString());

        return Response.ok().entity(taskResponse).build();
    }

    @PUT
    @Path("/{taskId}")
    @Consumes({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response updateTask(@PathParam("taskId") String taskId,
                               TaskRequest taskRequest) {

        if (taskRequest == null) {
            throw new ActivitiException("A request body was expected when updating the task.");
        }

        Task task = getTaskFromRequest(taskId);

        // Populate the task properties based on the request
        populateTaskFromRequest(task, taskRequest);

        TaskService taskService = BPMNOSGIService.getTaskService();

        // Save the task and fetch agian, it's possible that an assignment-listener has updated
        // fields after it was saved so we can't use the in-memory task
        taskService.saveTask(task);
        task = taskService.createTaskQuery().taskId(task.getId()).singleResult();

        return Response.ok().entity(new RestResponseFactory().createTaskResponse(task, uriInfo.getBaseUri().toString())).build();
    }

    @POST
    @Path("/{taskId}")
    @Consumes({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response executeTaskAction(@PathParam("taskId") String taskId, TaskActionRequest actionRequest) {
        if (actionRequest == null) {
            throw new ActivitiException("A request body was expected when executing a task action.");
        }

        Task task = getTaskFromRequest(taskId);

        TaskService taskService = BPMNOSGIService.getTaskService();

        if (TaskActionRequest.ACTION_COMPLETE.equals(actionRequest.getAction())) {
            completeTask(task, actionRequest, taskService);

        } else if (TaskActionRequest.ACTION_CLAIM.equals(actionRequest.getAction())) {
            claimTask(task, actionRequest, taskService);

        } else if (TaskActionRequest.ACTION_DELEGATE.equals(actionRequest.getAction())) {
            delegateTask(task, actionRequest, taskService);

        } else if (TaskActionRequest.ACTION_RESOLVE.equals(actionRequest.getAction())) {
            resolveTask(task, taskService);

        } else {
            throw new ActivitiIllegalArgumentException("Invalid action: '" + actionRequest.getAction() + "'.");
        }

        return Response.ok().status(Response.Status.OK).build();
    }

    @DELETE
    @Path("/{taskId}")
    public Response deleteTask(@PathParam("taskId") String taskId) {

        Boolean cascadeHistory = false;

        if (uriInfo.getQueryParameters().getFirst("cascadeHistory") != null) {
            cascadeHistory = Boolean.valueOf(uriInfo.getQueryParameters().getFirst("cascadeHistory"));
        }
        String deleteReason = uriInfo.getQueryParameters().getFirst("deleteReason");


        Task taskToDelete = getTaskFromRequest(taskId);
        if (taskToDelete.getExecutionId() != null) {
            // Can't delete a task that is part of a process instance
            throw new BPMNForbiddenException("Cannot delete a task that is part of a process-instance.");
        }

        TaskService taskService = BPMNOSGIService.getTaskService();

        if (cascadeHistory != null) {
            // Ignore delete-reason since the task-history (where the reason is recorded) will be deleted anyway
            taskService.deleteTask(taskToDelete.getId(), cascadeHistory);
        } else {
            // Delete with delete-reason
            taskService.deleteTask(taskToDelete.getId(), deleteReason);
        }
        return Response.ok().status(Response.Status.NO_CONTENT).build();
    }

    @GET
    @Path("/{taskId}/variables")
    @Consumes({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response getVariables(@PathParam("taskId") String taskId) {

        String scope = uriInfo.getQueryParameters().getFirst("scope");

        List<RestVariable> result = new ArrayList<>();
        Map<String, RestVariable> variableMap = new HashMap<String, RestVariable>();

        // Check if it's a valid task to get the variables for
        Task task = getTaskFromRequest(taskId);

        RestVariable.RestVariableScope variableScope = RestVariable.getScopeFromString(scope);
        if (variableScope == null) {
            // Use both local and global variables
            addLocalVariables(task, variableMap, uriInfo.getBaseUri().toString());
            addGlobalVariables(task, variableMap, uriInfo.getBaseUri().toString());

        } else if (variableScope == RestVariable.RestVariableScope.GLOBAL) {
            addGlobalVariables(task, variableMap, uriInfo.getBaseUri().toString());

        } else if (variableScope == RestVariable.RestVariableScope.LOCAL) {
            addLocalVariables(task, variableMap, uriInfo.getBaseUri().toString());
        }

        // Get unique variables from map
        result.addAll(variableMap.values());

        RestVariableCollection restVariableCollection = new RestVariableCollection();
        restVariableCollection.setRestVariables(result);
        return Response.ok().entity(restVariableCollection).build();
    }

    @GET
    @Path("/{taskId}/variables/{variableName}")
    @Consumes({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public RestVariable getVariable(@PathParam("taskId") String taskId,
                                    @PathParam("variableName") String variableName) {

        String scope = uriInfo.getQueryParameters().getFirst("scope");
        return getVariableFromRequest(taskId, variableName, scope, false, uriInfo.getBaseUri().toString());
    }

    @GET
    @Path("/{taskId}/variables/{variableName}/data")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response getVariableData(@PathParam("taskId") String taskId, @PathParam("variableName") String
            variableName) {

        String scope = uriInfo.getQueryParameters().getFirst("scope");
        Response.ResponseBuilder responseBuilder = Response.ok();
        try {
            byte[] result = null;

            RestVariable variable = getVariableFromRequest(taskId, variableName, scope, true, uriInfo.getBaseUri().toString());
            if (RestResponseFactory.BYTE_ARRAY_VARIABLE_TYPE.equals(variable.getType())) {
                result = (byte[]) variable.getValue();
                responseBuilder.type(MediaType.APPLICATION_OCTET_STREAM);

            } else if (RestResponseFactory.SERIALIZABLE_VARIABLE_TYPE.equals(variable.getType())) {
                ByteArrayOutputStream buffer = new ByteArrayOutputStream();
                ObjectOutputStream outputStream = new ObjectOutputStream(buffer);
                outputStream.writeObject(variable.getValue());
                outputStream.close();
                result = buffer.toByteArray();
                responseBuilder.type("application/x-java-serialized-object");

            } else {
                throw new ActivitiObjectNotFoundException("The variable does not have a binary data stream.", null);
            }
            return responseBuilder.entity(result).build();
        } catch (IOException ioe) {
            // Re-throw IOException
            throw new ActivitiException("Unexpected error getting variable data", ioe);
        }
    }

    @POST
    @Path("/{taskId}/variables")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    @Consumes(MediaType.MULTIPART_FORM_DATA)
    public Response createBinaryTaskVariable(@PathParam("taskId") String taskId, MultipartBody multipartBody) {

        Task task = getTaskFromRequest(taskId);
        Object result = null;
        try {
            result = setBinaryVariable(multipartBody, task, true, uriInfo);
        } catch (IOException e) {
            throw new ActivitiIllegalArgumentException("Error Reading variable attachment", e);
        }

        if (result != null) {
            return Response.ok().status(Response.Status.CREATED).build();
        } else {
            throw new ActivitiIllegalArgumentException("Binary Task variable creation failed");
        }

    }

    @POST
    @Path("/{taskId}/variables")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    @Consumes({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response createTaskVariable(@PathParam("taskId") String taskId, @Context HttpServletRequest
            httpServletRequest) {

        Task task = getTaskFromRequest(taskId);
        List<RestVariable> inputVariables = new ArrayList<>();
        List<RestVariable> resultVariables = new ArrayList<>();
        Response.ResponseBuilder responseBuilder = Response.ok();

        try {
            if (Utils.isApplicationJsonRequest(httpServletRequest)) {
                try {
                    @SuppressWarnings("unchecked")
                    List<Object> variableObjects = (List<Object>) new ObjectMapper().readValue(httpServletRequest.getInputStream(),
                            List.class);
                    for (Object restObject : variableObjects) {
                        RestVariable restVariable = new ObjectMapper().convertValue(restObject, RestVariable.class);
                        inputVariables.add(restVariable);
                    }
                } catch (IOException e) {
                    throw new ActivitiIllegalArgumentException("request body could not be transformed to a RestVariable " +
                            "instance.", e);
                }

            } else if (Utils.isApplicationXmlRequest(httpServletRequest)) {

                JAXBContext jaxbContext = null;
                try {
                    jaxbContext = JAXBContext.newInstance(RestVariableCollection.class);
                    Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
                    RestVariableCollection restVariableCollection = (RestVariableCollection) jaxbUnmarshaller.
                            unmarshal(httpServletRequest.getInputStream());
                    if (restVariableCollection == null) {
                        throw new ActivitiIllegalArgumentException("xml request body could not be transformed to a " +
                                "RestVariable Collection instance.");
                    }
                    List<RestVariable> restVariableList = restVariableCollection.getRestVariables();

                    if (restVariableList.size() == 0) {
                        throw new ActivitiIllegalArgumentException("xml request body could not identify any rest " +
                                "variables to be updated");
                    }
                    for (RestVariable restVariable : restVariableList) {
                        inputVariables.add(restVariable);
                    }

                } catch (JAXBException | IOException e) {
                    throw new ActivitiIllegalArgumentException("xml request body could not be transformed to a " +
                            "RestVariable instance.", e);
                }
            }


        } catch (Exception e) {
            throw new ActivitiIllegalArgumentException("Failed to serialize to a RestVariable instance", e);
        }

        if (inputVariables.size() == 0) {
            throw new ActivitiIllegalArgumentException("Request didn't contain a list of variables to create.");
        }

        RestVariable.RestVariableScope sharedScope = null;
        RestVariable.RestVariableScope varScope = null;
        Map<String, Object> variablesToSet = new HashMap<>();

        RestResponseFactory restResponseFactory = new RestResponseFactory();

        for (RestVariable var : inputVariables) {
            // Validate if scopes match
            varScope = var.getVariableScope();
            if (var.getName() == null) {
                throw new ActivitiIllegalArgumentException("Variable name is required");
            }

            if (varScope == null) {
                varScope = RestVariable.RestVariableScope.LOCAL;
            }
            if (sharedScope == null) {
                sharedScope = varScope;
            }
            if (varScope != sharedScope) {
                throw new ActivitiIllegalArgumentException("Only allowed to update multiple variables in the same scope.");
            }

            if (hasVariableOnScope(task, var.getName(), varScope)) {
                throw new BPMNConflictException("Variable '" + var.getName() + "' is already present on task '" + task.getId() +
                        "'.");
            }

            Object actualVariableValue = restResponseFactory.getVariableValue(var);
            variablesToSet.put(var.getName(), actualVariableValue);
            resultVariables.add(restResponseFactory.createRestVariable(var.getName(), actualVariableValue, varScope,
                    task.getId(), RestResponseFactory.VARIABLE_TASK, false, uriInfo.getBaseUri().toString()));
        }

        RuntimeService runtimeService = BPMNOSGIService.getRuntimeService();

        TaskService taskService = BPMNOSGIService.getTaskService();

        if (!variablesToSet.isEmpty()) {
            if (sharedScope == RestVariable.RestVariableScope.LOCAL) {
                taskService.setVariablesLocal(task.getId(), variablesToSet);
            } else {
                if (task.getExecutionId() != null) {
                    // Explicitly set on execution, setting non-local variables on task will override local-variables if exists
                    runtimeService.setVariables(task.getExecutionId(), variablesToSet);
                } else {
                    // Standalone task, no global variables possible
                    throw new ActivitiIllegalArgumentException("Cannot set global variables on task '" + task.getId() + "', task is not part of process.");
                }
            }
        }

        RestVariableCollection restVariableCollection = new RestVariableCollection();
        restVariableCollection.setRestVariables(resultVariables);
        responseBuilder.entity(restVariableCollection);

        return responseBuilder.status(Response.Status.CREATED).build();
    }

    @PUT
    @Path("/{taskId}/variables/{variableName}")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    @Consumes(MediaType.MULTIPART_FORM_DATA)
    public Response updateBinaryTaskVariable(@PathParam("taskId") String taskId, @PathParam("variableName") String variableName,
                                             MultipartBody multipartBody) {
        Task task = getTaskFromRequest(taskId);
        RestVariable result = null;
        try {
            result = setBinaryVariable(multipartBody, task, false, uriInfo);
        } catch (IOException e) {
            throw new ActivitiIllegalArgumentException("Error Reading variable attachment", e);
        }
        if (result != null) {
            if (!result.getName().equals(variableName)) {
                throw new ActivitiIllegalArgumentException("Variable name in the body should be equal to the name used in the requested URL.");
            }
        }

        return Response.ok().entity(result).build();
    }

    @PUT
    @Path("/{taskId}/variables/{variableName}")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    @Consumes({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response updateTaskVariable(@PathParam("taskId") String taskId,
                                       @PathParam("variableName") String variableName, @Context HttpServletRequest httpServletRequest) {
        Task task = getTaskFromRequest(taskId);

        RestVariable restVariable = null;

        if (Utils.isApplicationJsonRequest(httpServletRequest)) {
            try {
                restVariable = new ObjectMapper().readValue(httpServletRequest.getInputStream(), RestVariable.class);
            } catch (Exception e) {
                throw new ActivitiIllegalArgumentException("Error converting request body to RestVariable instance", e);
            }
        } else if (Utils.isApplicationXmlRequest(httpServletRequest)) {
            JAXBContext jaxbContext = null;
            try {
                jaxbContext = JAXBContext.newInstance(RestVariable.class);
                Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
                restVariable = (RestVariable) jaxbUnmarshaller.
                        unmarshal(httpServletRequest.getInputStream());

            } catch (JAXBException | IOException e) {
                throw new ActivitiIllegalArgumentException("xml request body could not be transformed to a " +
                        "Rest Variable instance.", e);
            }
        }
        if (restVariable == null) {
            throw new ActivitiException("Invalid body was supplied");
        }
        if (!restVariable.getName().equals(variableName)) {
            throw new ActivitiIllegalArgumentException("Variable name in the body should be equal to the name used in the requested URL.");
        }

        RestVariable result = setSimpleVariable(restVariable, task, false);
        return Response.ok().entity(result).build();
    }

    @DELETE
    @Path("/{taskId}/variables/{variableName}")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response deleteVariable(@PathParam("taskId") String taskId,
                                   @PathParam("variableName") String variableName) {
        String scopeString = uriInfo.getQueryParameters().getFirst("scope");
        Task task = getTaskFromRequest(taskId);

        // Determine scope
        RestVariable.RestVariableScope scope = RestVariable.RestVariableScope.LOCAL;
        if (scopeString != null) {
            scope = RestVariable.getScopeFromString(scopeString);
        }

        if (!hasVariableOnScope(task, variableName, scope)) {
            throw new ActivitiObjectNotFoundException("Task '" + task.getId() + "' doesn't have a variable '" +
                    variableName + "' in scope " + scope.name().toLowerCase(), VariableInstanceEntity.class);
        }

        RuntimeService runtimeService = BPMNOSGIService.getRuntimeService();

        TaskService taskService = BPMNOSGIService.getTaskService();

        if (scope == RestVariable.RestVariableScope.LOCAL) {
            taskService.removeVariableLocal(task.getId(), variableName);
        } else {
            // Safe to use executionId, as the hasVariableOnScope whould have stopped a global-var update on standalone task
            runtimeService.removeVariable(task.getExecutionId(), variableName);
        }

        return Response.ok().status(Response.Status.NO_CONTENT).build();
    }

    @DELETE
    @Path("/{taskId}/variables")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response deleteAllLocalTaskVariables(@PathParam("taskId") String taskId) {
        TaskService taskService = BPMNOSGIService.getTaskService();

        Task task = getTaskFromRequest(taskId);
        Collection<String> currentVariables = taskService.getVariablesLocal(task.getId()).keySet();
        taskService.removeVariablesLocal(task.getId(), currentVariables);

        return Response.ok().status(Response.Status.NO_CONTENT).build();
    }

    @GET
    @Path("/{taskId}/identitylinks")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response getIdentityLinks(@PathParam("taskId") String taskId) {
        Task task = getTaskFromRequest(taskId);
        TaskService taskService = BPMNOSGIService.getTaskService();

        List<RestIdentityLink> restIdentityLinks = new RestResponseFactory().createRestIdentityLinks(taskService.getIdentityLinksForTask(task.getId()),
                uriInfo.getBaseUri().toString());
        RestIdentityLinkCollection restIdentityLinkCollection = new RestIdentityLinkCollection();
        restIdentityLinkCollection.setRestIdentityLinks(restIdentityLinks);
        return Response.ok().entity(restIdentityLinkCollection).build();
    }

    @GET
    @Path("/{taskId}/identitylinks/{family}")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response getIdentityLinksForFamily(@PathParam("taskId") String taskId,
                                              @PathParam("family") String family) {

        Task task = getTaskFromRequest(taskId);

        TaskService taskService = BPMNOSGIService.getTaskService();

        if (family == null || (!RestUrls.SEGMENT_IDENTITYLINKS_FAMILY_GROUPS.equals(family)
                && !RestUrls.SEGMENT_IDENTITYLINKS_FAMILY_USERS.equals(family))) {
            throw new ActivitiIllegalArgumentException("Identity link family should be 'users' or 'groups'.");
        }

        boolean isUser = family.equals(RestUrls.SEGMENT_IDENTITYLINKS_FAMILY_USERS);
        List<RestIdentityLink> results = new ArrayList<RestIdentityLink>();

        List<IdentityLink> allLinks = taskService.getIdentityLinksForTask(task.getId());
        for (IdentityLink link : allLinks) {
            boolean match = false;
            if (isUser) {
                match = link.getUserId() != null;
            } else {
                match = link.getGroupId() != null;
            }

            if (match) {
                results.add(new RestResponseFactory().createRestIdentityLink(link, uriInfo.getBaseUri().toString()));
            }
        }
        RestIdentityLinkCollection restIdentityLinkCollection = new RestIdentityLinkCollection();
        restIdentityLinkCollection.setRestIdentityLinks(results);
        return Response.ok().entity(restIdentityLinkCollection).build();
    }

    @GET
    @Path("/{taskId}/identitylinks/{family}/{identityId}/{type}")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response getIdentityLink(@PathParam("taskId") String taskId,
                                    @PathParam("family") String family, @PathParam("identityId") String identityId,
                                    @PathParam("type") String type,
                                    @Context HttpServletRequest httpServletRequest) {

        Task task = getTaskFromRequest(taskId);
        validateIdentityLinkArguments(family, identityId, type);

        IdentityLink link = getIdentityLink(family, identityId, type, task.getId());

        return Response.ok().entity(new RestResponseFactory().createRestIdentityLink(link, uriInfo.getBaseUri().toString()))
                .build();
    }

    @DELETE
    @Path("/{taskId}/identitylinks/{family}/{identityId}/{type}")
    public Response deleteIdentityLink(@PathParam("taskId") String taskId,
                                       @PathParam("family") String family, @PathParam("identityId") String identityId,
                                       @PathParam("type") String type) {

        Task task = getTaskFromRequest(taskId);

        validateIdentityLinkArguments(family, identityId, type);

        // Check if identitylink to delete exists
        getIdentityLink(family, identityId, type, task.getId());


        TaskService taskService = BPMNOSGIService.getTaskService();

        if (RestUrls.SEGMENT_IDENTITYLINKS_FAMILY_USERS.equals(family)) {
            taskService.deleteUserIdentityLink(task.getId(), identityId, type);
        } else {
            taskService.deleteGroupIdentityLink(task.getId(), identityId, type);
        }

        return Response.ok().status(Response.Status.NO_CONTENT).build();
    }

    @POST
    @Path("/{taskId}/identitylinks")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response createIdentityLink(@PathParam("taskId") String taskId,
                                       RestIdentityLink identityLink) {

        Task task = getTaskFromRequest(taskId);

        if (identityLink.getGroup() == null && identityLink.getUser() == null) {
            throw new ActivitiIllegalArgumentException("A group or a user is required to create an identity link.");
        }

        if (identityLink.getGroup() != null && identityLink.getUser() != null) {
            throw new ActivitiIllegalArgumentException("Only one of user or group can be used to create an identity link.");
        }

        if (identityLink.getType() == null) {
            throw new ActivitiIllegalArgumentException("The identity link type is required.");
        }
        TaskService taskService = BPMNOSGIService.getTaskService();

        if (identityLink.getGroup() != null) {
            taskService.addGroupIdentityLink(task.getId(), identityLink.getGroup(), identityLink.getType());
        } else {
            taskService.addUserIdentityLink(task.getId(), identityLink.getUser(), identityLink.getType());
        }

        RestIdentityLink restIdentityLink = new RestResponseFactory().createRestIdentityLink(identityLink.getType(),
                identityLink.getUser(),
                identityLink.getGroup(), task.getId(), null, null, uriInfo.getBaseUri().toString());

        return Response.ok().status(Response.Status.CREATED).entity(restIdentityLink).build();
    }

    @POST
    @Path("/{taskId}/attachments")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    @Consumes(MediaType.MULTIPART_FORM_DATA)
    public Response createAttachmentForBinary(@PathParam("taskId") String taskId, MultipartBody multipartBody,
                                              @Context HttpServletRequest httpServletRequest) {

        boolean debugEnabled = log.isDebugEnabled();
        List<org.apache.cxf.jaxrs.ext.multipart.Attachment> attachments = multipartBody.getAllAttachments();

        int attachmentSize = attachments.size();

        if (attachmentSize <= 0) {
            throw new ActivitiIllegalArgumentException("No Attachments found with the request body");
        }
        AttachmentDataHolder attachmentDataHolder = new AttachmentDataHolder();

        for (int i = 0; i < attachmentSize; i++) {
            org.apache.cxf.jaxrs.ext.multipart.Attachment attachment = attachments.get(i);

            String contentDispositionHeaderValue = attachment.getHeader("Content-Disposition");
            String contentType = attachment.getHeader("Content-Type");

            if (debugEnabled) {
                log.debug("Going to iterate:" + i);
                log.debug("contentDisposition:" + contentDispositionHeaderValue);
            }

            if (contentDispositionHeaderValue != null) {
                contentDispositionHeaderValue = contentDispositionHeaderValue.trim();

                Map<String, String> contentDispositionHeaderValueMap = Utils.processContentDispositionHeader
                        (contentDispositionHeaderValue);
                String dispositionName = contentDispositionHeaderValueMap.get("name");
                DataHandler dataHandler = attachment.getDataHandler();

                OutputStream outputStream = null;

                if ("name".equals(dispositionName)) {
                    try {
                        outputStream = Utils.getAttachmentStream(dataHandler.getInputStream());
                    } catch (IOException e) {
                        throw new ActivitiIllegalArgumentException("Attachment Name Reading error occured", e);
                    }

                    if (outputStream != null) {
                        String fileName = outputStream.toString();
                        attachmentDataHolder.setName(fileName);
                    }


                } else if ("type".equals(dispositionName)) {
                    try {
                        outputStream = Utils.getAttachmentStream(dataHandler.getInputStream());
                    } catch (IOException e) {
                        throw new ActivitiIllegalArgumentException("Attachment Type Reading error occured", e);
                    }

                    if (outputStream != null) {
                        String typeName = outputStream.toString();
                        attachmentDataHolder.setType(typeName);
                    }


                } else if ("description".equals(dispositionName)) {
                    try {
                        outputStream = Utils.getAttachmentStream(dataHandler.getInputStream());
                    } catch (IOException e) {
                        throw new ActivitiIllegalArgumentException("Attachment Description Reading error occured", e);
                    }

                    if (outputStream != null) {
                        String description = outputStream.toString();
                        attachmentDataHolder.setDescription(description);
                    }
                }

                if (contentType != null) {
                    if ("file".equals(dispositionName)) {

                        InputStream inputStream = null;
                        try {
                            inputStream = dataHandler.getInputStream();
                        } catch (IOException e) {
                            throw new ActivitiIllegalArgumentException("Error Occured During processing empty body.",
                                    e);
                        }

                        if (inputStream != null) {
                            attachmentDataHolder.setContentType(contentType);
                            byte[] attachmentArray = new byte[0];
                            try {
                                attachmentArray = IOUtils.toByteArray(inputStream);
                            } catch (IOException e) {
                                throw new ActivitiIllegalArgumentException("Processing Attachment Body Failed.", e);
                            }
                            attachmentDataHolder.setAttachmentArray(attachmentArray);
                        }
                    }
                }
            }
        }


        attachmentDataHolder.printDebug();

        if (attachmentDataHolder.getName() == null) {
            throw new ActivitiIllegalArgumentException("Attachment name is required.");
        }

        if (attachmentDataHolder.getAttachmentArray() == null) {
            throw new ActivitiIllegalArgumentException("Empty attachment body was found in request body after " +
                    "decoding the request" +
                    ".");
        }

        TaskService taskService = BPMNOSGIService.getTaskService();
        Task task = getTaskFromRequest(taskId);
        Response.ResponseBuilder responseBuilder = Response.ok();

        AttachmentResponse result = null;
        try {

            InputStream inputStream = new ByteArrayInputStream(attachmentDataHolder.getAttachmentArray());
            Attachment createdAttachment = taskService.createAttachment(attachmentDataHolder.getContentType(), task.getId(), task
                    .getProcessInstanceId(), attachmentDataHolder.getName(), attachmentDataHolder
                    .getDescription(), inputStream);

            responseBuilder.status(Response.Status.CREATED);
            result = new RestResponseFactory().createAttachmentResponse(createdAttachment, uriInfo.getBaseUri()
                    .toString
                            ());
        } catch (Exception e) {
            throw new ActivitiException("Error creating attachment response", e);
        }

        return responseBuilder.status(Response.Status.CREATED).entity(result).build();
    }

    @POST
    @Path("/{taskId}/attachments")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    @Consumes({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response createAttachmentForNonBinary(@PathParam("taskId") String taskId, @Context HttpServletRequest
            httpServletRequest, AttachmentRequest attachmentRequest) {

        AttachmentResponse result = null;
        Task task = getTaskFromRequest(taskId);
        Response.ResponseBuilder responseBuilder = Response.ok();
        if (attachmentRequest == null) {
            throw new ActivitiIllegalArgumentException("AttachmentRequest properties not found in request");
        }

        result = createSimpleAttachment(attachmentRequest, task);
        return responseBuilder.status(Response.Status.CREATED).entity(result).build();
    }


    @GET
    @Path("/{taskId}/attachments")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response getAttachments(@PathParam("taskId") String taskId) {
        List<AttachmentResponse> result = new ArrayList<AttachmentResponse>();
        HistoricTaskInstance task = getHistoricTaskFromRequest(taskId);

        TaskService taskService = BPMNOSGIService.getTaskService();

        RestResponseFactory restResponseFactory = new RestResponseFactory();
        String baseUri = uriInfo.getBaseUri().toString();

        for (Attachment attachment : taskService.getProcessInstanceAttachments(task.getProcessInstanceId())) {
            result.add(restResponseFactory.createAttachmentResponse(attachment, baseUri));
        }

        AttachmentResponseCollection attachmentResponseCollection = new AttachmentResponseCollection();
        attachmentResponseCollection.setAttachmentResponseList(result);

        return Response.ok().entity(attachmentResponseCollection).build();
    }

    @GET
    @Path("/{taskId}/attachments/{attachmentId}")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response getAttachment(@PathParam("taskId") String taskId,
                                  @PathParam("attachmentId") String attachmentId) {

        HistoricTaskInstance task = getHistoricTaskFromRequest(taskId);
        TaskService taskService = BPMNOSGIService.getTaskService();

        Attachment attachment = taskService.getAttachment(attachmentId);
        if (attachment == null) {
            throw new ActivitiObjectNotFoundException("Task '" + task.getId() + "' doesn't have an attachment with id '" + attachmentId + "'.", Comment.class);
        }

        return Response.ok().entity(new RestResponseFactory().createAttachmentResponse(attachment, uriInfo.getBaseUri
                ().toString())).build();
    }

    @DELETE
    @Path("/{taskId}/attachments/{attachmentId}")
    public Response deleteAttachment(@PathParam("taskId") String taskId,
                                     @PathParam("attachmentId") String attachmentId) {

        Task task = getTaskFromRequest(taskId);
        TaskService taskService = BPMNOSGIService.getTaskService();
        Attachment attachment = taskService.getAttachment(attachmentId);
        if (attachment == null) {
            throw new ActivitiObjectNotFoundException("Task '" + task.getId() + "' doesn't have an attachment with id '" + attachmentId + "'.", Comment.class);
        }

        taskService.deleteAttachment(attachmentId);

        return Response.ok().status(Response.Status.NO_CONTENT).build();
    }

    @GET
    @Path("/{taskId}/attachments/{attachmentId}/content")
    public Response getAttachmentContent(@PathParam("taskId") String taskId,
                                         @PathParam("attachmentId") String attachmentId) {

        TaskService taskService = BPMNOSGIService.getTaskService();
        HistoricTaskInstance task = getHistoricTaskFromRequest(taskId);
        Attachment attachment = taskService.getAttachment(attachmentId);

        if (attachment == null) {
            throw new ActivitiObjectNotFoundException("Task '" + task.getId() + "' doesn't have an attachment with id '" + attachmentId + "'.", Attachment.class);
        }

        InputStream attachmentStream = taskService.getAttachmentContent(attachmentId);
        if (attachmentStream == null) {
            throw new ActivitiObjectNotFoundException("Attachment with id '" + attachmentId +
                    "' doesn't have content associated with it.", Attachment.class);
        }

        Response.ResponseBuilder responseBuilder = Response.ok();

        String type = attachment.getType();
        MediaType mediaType = MediaType.valueOf(type);
        if (mediaType != null) {
            responseBuilder.type(mediaType);
        } else {
            responseBuilder.type("application/octet-stream");
        }

        byte[] attachmentArray;
        try {
            attachmentArray = IOUtils.toByteArray(attachmentStream);
        } catch (IOException e) {
            throw new ActivitiException("Error creating attachment data", e);
        }
        String dispositionValue = "inline; filename=\"" + attachment.getName() + "\"";
        responseBuilder.header("Content-Disposition", dispositionValue);
        return responseBuilder.entity(attachmentArray).build();
    }


    @GET
    @Path("/{taskId}/comments")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response getComments(@PathParam("taskId") String taskId) {
        HistoricTaskInstance task = getHistoricTaskFromRequest(taskId);
        TaskService taskService = BPMNOSGIService.getTaskService();
        List<CommentResponse> commentResponseList = new RestResponseFactory().createRestCommentList(taskService
                .getTaskComments(task.getId()), uriInfo.getBaseUri().toString());
        CommentResponseCollection commentResponseCollection = new CommentResponseCollection();
        commentResponseCollection.setCommentResponseList(commentResponseList);

        return Response.ok().entity(commentResponseCollection).build();
    }

    @POST
    @Path("/{taskId}/comments")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    @Consumes({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response createComment(@PathParam("taskId") String taskId, CommentRequest comment) {

        Task task = getTaskFromRequest(taskId);

        if (comment.getMessage() == null) {
            throw new ActivitiIllegalArgumentException("Comment text is required.");
        }

        String processInstanceId = null;
        TaskService taskService = BPMNOSGIService.getTaskService();
        if (comment.isSaveProcessInstanceId()) {
            Task taskEntity = taskService.createTaskQuery().taskId(task.getId()).singleResult();
            processInstanceId = taskEntity.getProcessInstanceId();
        }
        Comment createdComment = taskService.addComment(task.getId(), processInstanceId, comment.getMessage());

        CommentResponse commentResponse = new RestResponseFactory().createRestComment(createdComment, uriInfo
                .getBaseUri().toString());
        return Response.ok().status(Response.Status.CREATED).entity(commentResponse).build();
    }

    @GET
    @Path("/{taskId}/comments/{commentId}")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response getComment(@PathParam("taskId") String taskId,
                               @PathParam("commentId") String commentId) {

        HistoricTaskInstance task = getHistoricTaskFromRequest(taskId);
        TaskService taskService = BPMNOSGIService.getTaskService();
        Comment comment = taskService.getComment(commentId);
        if (comment == null || !task.getId().equals(comment.getTaskId())) {
            throw new ActivitiObjectNotFoundException("Task '" + task.getId() + "' doesn't have a comment with id '" + commentId + "'.", Comment.class);
        }

        return Response.ok().entity(new RestResponseFactory().createRestComment(comment, uriInfo.getBaseUri()
                .toString())).build();
    }

    @DELETE
    @Path("/{taskId}/comments/{commentId}")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response deleteComment(@PathParam("taskId") String taskId,
                                  @PathParam("commentId") String commentId) {

        // Check if task exists
        Task task = getTaskFromRequest(taskId);
        TaskService taskService = BPMNOSGIService.getTaskService();

        Comment comment = taskService.getComment(commentId);
        if (comment == null || comment.getTaskId() == null || !comment.getTaskId().equals(task.getId())) {
            throw new ActivitiObjectNotFoundException("Task '" + task.getId() + "' doesn't have a comment with id '" + commentId + "'.", Comment.class);
        }

        taskService.deleteComment(commentId);
        return Response.ok().status(Response.Status.NO_CONTENT).build();
    }

    @GET
    @Path("/{taskId}/events")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response getEvents(@PathParam("taskId") String taskId) {
        HistoricTaskInstance task = getHistoricTaskFromRequest(taskId);
        TaskService taskService = BPMNOSGIService.getTaskService();
        List<EventResponse> eventResponseList = new RestResponseFactory().createEventResponseList(taskService
                .getTaskEvents(task.getId()), uriInfo.getBaseUri().toString());

        EventResponseCollection eventResponseCollection = new EventResponseCollection();
        eventResponseCollection.setEventResponseList(eventResponseList);

        return Response.ok().entity(eventResponseCollection).build();
    }

    @GET
    @Path("/{taskId}/events/{eventId}")
    @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
    public Response getEvent(@PathParam("taskId") String taskId,
                             @PathParam("eventId") String eventId) {

        HistoricTaskInstance task = getHistoricTaskFromRequest(taskId);
        TaskService taskService = BPMNOSGIService.getTaskService();

        Event event = taskService.getEvent(eventId);
        if (event == null || !task.getId().equals(event.getTaskId())) {
            throw new ActivitiObjectNotFoundException("Task '" + task.getId() + "' doesn't have an event with id '" + eventId + "'.", Event.class);
        }

        EventResponse eventResponse = new RestResponseFactory().createEventResponse(event, uriInfo.getBaseUri()
                .toString());
        return Response.ok().entity(eventResponse).build();
    }

    @DELETE
    @Path("/{taskd}/events/{eventId}")
    public Response deleteEvent(@PathParam("taskId") String taskId,
                                @PathParam("eventId") String eventId) {

        // Check if task exists
        Task task = getTaskFromRequest(taskId);
        TaskService taskService = BPMNOSGIService.getTaskService();
        Event event = taskService.getEvent(eventId);
        if (event == null || event.getTaskId() == null || !event.getTaskId().equals(task.getId())) {
            throw new ActivitiObjectNotFoundException("Task '" + task.getId() + "' doesn't have an event with id '" + event + "'.", Event.class);
        }

        taskService.deleteComment(eventId);
        return Response.ok().status(Response.Status.NO_CONTENT).build();
    }

    protected HistoricTaskInstance getHistoricTaskFromRequest(String taskId) {

        HistoryService historyService = BPMNOSGIService.getHistoryService();

        HistoricTaskInstance task = historyService.createHistoricTaskInstanceQuery().taskId(taskId).singleResult();
        if (task == null) {
            throw new ActivitiObjectNotFoundException("Could not find a task with id '" + taskId + "'.", Task.class);
        }
        return task;
    }


    protected AttachmentResponse createSimpleAttachment(AttachmentRequest attachmentRequest, Task task) {

        if (attachmentRequest.getName() == null) {
            throw new ActivitiIllegalArgumentException("Attachment name is required.");
        }

        TaskService taskService = BPMNOSGIService.getTaskService();

        Attachment createdAttachment = taskService.createAttachment(attachmentRequest.getType(), task.getId(),
                task.getProcessInstanceId(), attachmentRequest.getName(), attachmentRequest.getDescription(), attachmentRequest.getExternalUrl());

        return new RestResponseFactory().createAttachmentResponse(createdAttachment, uriInfo.getBaseUri().toString());
    }

/*    protected AttachmentResponse createBinaryAttachment(HttpServletRequest httpServletRequest, Task task, Response.ResponseBuilder responseBuilder) throws
            IOException {

        String name = uriInfo.getQueryParameters().getFirst("name");
        String description = uriInfo.getQueryParameters().getFirst("description");
        String type = uriInfo.getQueryParameters().getFirst("type");


        byte[] byteArray = Utils.processMultiPartFile(httpServletRequest, "Attachment content");
        if (byteArray == null) {
            throw new ActivitiIllegalArgumentException("Empty attachment body was found in request body after " +
                    "decoding the request" +
                    ".");
        }

        if (name == null) {
            throw new ActivitiIllegalArgumentException("Attachment name is required.");
        }


        TaskService taskService = BPMNOSGIService.getTaskService();

        try {
            InputStream inputStream = new ByteArrayInputStream(byteArray);
            Attachment createdAttachment = taskService.createAttachment(type, task.getId(), task.getProcessInstanceId(), name,
                    description, inputStream);

            responseBuilder.status(Response.Status.CREATED);
            return new RestResponseFactory().createAttachmentResponse(createdAttachment, uriInfo.getBaseUri().toString());

        } catch (Exception e) {
            throw new ActivitiException("Error creating attachment response", e);
        }
    }*/

    protected IdentityLink getIdentityLink(String family, String identityId, String type, String taskId) {
        boolean isUser = family.equals(RestUrls.SEGMENT_IDENTITYLINKS_FAMILY_USERS);

        TaskService taskService = BPMNOSGIService.getTaskService();
        // Perhaps it would be better to offer getting a single identitylink from the API
        List<IdentityLink> allLinks = taskService.getIdentityLinksForTask(taskId);
        for (IdentityLink link : allLinks) {
            boolean rightIdentity = false;
            if (isUser) {
                rightIdentity = identityId.equals(link.getUserId());
            } else {
                rightIdentity = identityId.equals(link.getGroupId());
            }

            if (rightIdentity && link.getType().equals(type)) {
                return link;
            }
        }
        throw new ActivitiObjectNotFoundException("Could not find the requested identity link.", IdentityLink.class);
    }

    protected void validateIdentityLinkArguments(String family, String identityId, String type) {
        if (family == null || (!RestUrls.SEGMENT_IDENTITYLINKS_FAMILY_GROUPS.equals(family)
                && !RestUrls.SEGMENT_IDENTITYLINKS_FAMILY_USERS.equals(family))) {
            throw new ActivitiIllegalArgumentException("Identity link family should be 'users' or 'groups'.");
        }
        if (identityId == null) {
            throw new ActivitiIllegalArgumentException("IdentityId is required.");
        }
        if (type == null) {
            throw new ActivitiIllegalArgumentException("Type is required.");
        }
    }

    protected RestVariable setSimpleVariable(RestVariable restVariable, Task task, boolean isNew) {
        if (restVariable.getName() == null) {
            throw new ActivitiIllegalArgumentException("Variable name is required");
        }

        // Figure out scope, revert to local is omitted
        RestVariable.RestVariableScope scope = restVariable.getVariableScope();
        if (scope == null) {
            scope = RestVariable.RestVariableScope.LOCAL;
        }

        RestResponseFactory restResponseFactory = new RestResponseFactory();
        Object actualVariableValue = restResponseFactory.getVariableValue(restVariable);
        setVariable(task, restVariable.getName(), actualVariableValue, scope, isNew);

        return restResponseFactory.createRestVariable(restVariable.getName(), actualVariableValue, scope,
                task.getId(), RestResponseFactory.VARIABLE_TASK, false, uriInfo.getBaseUri().toString());
    }


    protected void completeTask(Task task, TaskActionRequest actionRequest, TaskService taskService) {

        if (actionRequest.getVariables() != null) {
            Map<String, Object> variablesToSet = new HashMap<String, Object>();

            RestResponseFactory restResponseFactory = new RestResponseFactory();
            for (RestVariable var : actionRequest.getVariables()) {
                if (var.getName() == null) {
                    throw new ActivitiIllegalArgumentException("Variable name is required");
                }

                Object actualVariableValue = restResponseFactory.getVariableValue(var);
                variablesToSet.put(var.getName(), actualVariableValue);
            }

            taskService.complete(task.getId(), variablesToSet);
        } else {
            taskService.complete(task.getId());
        }

    }

    protected void claimTask(Task task, TaskActionRequest actionRequest, TaskService taskService) {
        // In case the task is already claimed, a ActivitiTaskAlreadyClaimedException is thrown and converted to
        // a CONFLICT response by the ExceptionHandlerAdvice
        List list = taskService.createTaskQuery().taskId(task.getId()).taskCandidateUser(actionRequest.getAssignee()).list();
        if (list == null || list.isEmpty()) {//user is not a candidate
            throw new BPMNForbiddenException("The user:" + actionRequest.getAssignee() + " is not a candidate user of this task");
        } else {
            taskService.claim(task.getId(), actionRequest.getAssignee());
        }

    }

    protected void delegateTask(Task task, TaskActionRequest actionRequest, TaskService taskService) {
        if (actionRequest.getAssignee() == null) {
            throw new ActivitiIllegalArgumentException("An assignee is required when delegating a task.");
        }

        taskService.delegateTask(task.getId(), actionRequest.getAssignee());
    }

    protected void resolveTask(Task task, TaskService taskService) {
        taskService.resolveTask(task.getId());
    }

    protected void populateTaskFromRequest(Task task, TaskRequest taskRequest) {
        if (taskRequest.isNameSet()) {
            task.setName(taskRequest.getName());
        }
        if (taskRequest.isAssigneeSet()) {
            task.setAssignee(taskRequest.getAssignee());
        }
        if (taskRequest.isDescriptionSet()) {
            task.setDescription(taskRequest.getDescription());
        }
        if (taskRequest.isDuedateSet()) {
            task.setDueDate(taskRequest.getDueDate());
        }
        if (taskRequest.isOwnerSet()) {
            task.setOwner(taskRequest.getOwner());
        }
        if (taskRequest.isParentTaskIdSet()) {
            task.setParentTaskId(taskRequest.getParentTaskId());
        }
        if (taskRequest.isPrioritySet()) {
            task.setPriority(taskRequest.getPriority());
        }
        if (taskRequest.isCategorySet()) {
            task.setCategory(taskRequest.getCategory());
        }
        if (taskRequest.isTenantIdSet()) {
            task.setTenantId(taskRequest.getTenantId());
        }
        if (taskRequest.isFormKeySet()) {
            task.setFormKey(taskRequest.getFormKey());
        }

        if (taskRequest.isDelegationStateSet()) {
            DelegationState delegationState = getDelegationState(taskRequest.getDelegationState());
            task.setDelegationState(delegationState);
        }
    }
}