public RestVariable getVariableFromRequest(
      String taskId, String variableName, String scope, boolean includeBinary) {

    boolean variableFound = false;
    Object value = null;
    RestVariableScope variableScope = RestVariable.getScopeFromString(scope);
    if (variableScope == null) {
      // First, check local variables (which have precedence when no scope is supplied)
      if (taskService.hasVariableLocal(taskId, variableName)) {
        value = taskService.getVariableLocal(taskId, variableName);
        variableScope = RestVariableScope.LOCAL;
        variableFound = true;
      } else {
        // Revert to execution-variable when not present local on the task
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        if (task.getExecutionId() != null
            && runtimeService.hasVariable(task.getExecutionId(), variableName)) {
          value = runtimeService.getVariable(task.getExecutionId(), variableName);
          variableScope = RestVariableScope.GLOBAL;
          variableFound = true;
        }
      }

    } else if (variableScope == RestVariableScope.GLOBAL) {
      Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
      if (task.getExecutionId() != null
          && runtimeService.hasVariable(task.getExecutionId(), variableName)) {
        value = runtimeService.getVariable(task.getExecutionId(), variableName);
        variableFound = true;
      }

    } else if (variableScope == RestVariableScope.LOCAL) {
      if (taskService.hasVariableLocal(taskId, variableName)) {
        value = taskService.getVariableLocal(taskId, variableName);
        variableFound = true;
      }
    }

    if (!variableFound) {
      throw new ActivitiObjectNotFoundException(
          "Task '" + taskId + "' doesn't have a variable with name: '" + variableName + "'.",
          VariableInstanceEntity.class);
    } else {
      return restResponseFactory.createRestVariable(
          variableName,
          value,
          variableScope,
          taskId,
          RestResponseFactory.VARIABLE_TASK,
          includeBinary);
    }
  }
  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
    RestVariableScope scope = restVariable.getVariableScope();
    if (scope == null) {
      scope = RestVariableScope.LOCAL;
    }

    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);
  }
  protected RestVariable setBinaryVariable(
      MultipartHttpServletRequest request, Task task, boolean isNew) {

    // Validate input and set defaults
    if (request.getFileMap().size() == 0) {
      throw new ActivitiIllegalArgumentException("No file content was found in request body.");
    }

    // Get first file in the map, ignore possible other files
    MultipartFile file = request.getFile(request.getFileMap().keySet().iterator().next());

    if (file == null) {
      throw new ActivitiIllegalArgumentException("No file content was found in request body.");
    }

    String variableScope = null;
    String variableName = null;
    String variableType = null;

    Map<String, String[]> paramMap = request.getParameterMap();
    for (String parameterName : paramMap.keySet()) {

      if (paramMap.get(parameterName).length > 0) {

        if (parameterName.equalsIgnoreCase("scope")) {
          variableScope = paramMap.get(parameterName)[0];

        } else if (parameterName.equalsIgnoreCase("name")) {
          variableName = paramMap.get(parameterName)[0];

        } else if (parameterName.equalsIgnoreCase("type")) {
          variableType = paramMap.get(parameterName)[0];
        }
      }
    }

    try {

      if (variableName == null) {
        throw new ActivitiIllegalArgumentException("No variable name was found in request body.");
      }

      if (variableType != null) {
        if (!RestResponseFactory.BYTE_ARRAY_VARIABLE_TYPE.equals(variableType)
            && !RestResponseFactory.SERIALIZABLE_VARIABLE_TYPE.equals(variableType)) {
          throw new ActivitiIllegalArgumentException(
              "Only 'binary' and 'serializable' are supported as variable type.");
        }
      } else {
        variableType = RestResponseFactory.BYTE_ARRAY_VARIABLE_TYPE;
      }

      RestVariableScope scope = RestVariableScope.LOCAL;
      if (variableScope != null) {
        scope = RestVariable.getScopeFromString(variableScope);
      }

      if (variableType.equals(RestResponseFactory.BYTE_ARRAY_VARIABLE_TYPE)) {
        // Use raw bytes as variable value
        byte[] variableBytes = IOUtils.toByteArray(file.getInputStream());
        setVariable(task, variableName, variableBytes, scope, isNew);

      } else if (isSerializableVariableAllowed) {
        // Try deserializing the object
        ObjectInputStream stream = new ObjectInputStream(file.getInputStream());
        Object value = stream.readObject();
        setVariable(task, variableName, value, scope, isNew);
        stream.close();
      } else {
        throw new ActivitiContentNotSupportedException("Serialized objects are not allowed");
      }

      return restResponseFactory.createBinaryRestVariable(
          variableName, scope, variableType, task.getId(), null, null);

    } catch (IOException ioe) {
      throw new ActivitiIllegalArgumentException("Error getting binary variable", ioe);
    } catch (ClassNotFoundException ioe) {
      throw new ActivitiContentNotSupportedException(
          "The provided body contains a serialized object for which the class is nog found: "
              + ioe.getMessage());
    }
  }