Example #1
0
  @Delete
  public void deleteTask() {
    if (!authenticate()) {
      return;
    }

    Form query = getQuery();
    Boolean cascadeHistory = getQueryParameterAsBoolean("cascadeHistory", query);
    String deleteReason = getQueryParameter("deleteReason", query);

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

    if (cascadeHistory != null) {
      // Ignore delete-reason since the task-history (where the reason is recorded) will be deleted
      // anyway
      ActivitiUtil.getTaskService().deleteTask(taskToDelete.getId(), cascadeHistory);
    } else {
      // Delete with delete-reason
      ActivitiUtil.getTaskService().deleteTask(taskToDelete.getId(), deleteReason);
    }
    getResponse().setStatus(Status.SUCCESS_NO_CONTENT);
  }
Example #2
0
  @Put
  public TaskResponse updateTask(TaskRequest taskRequest) {
    if (!authenticate()) {
      return null;
    }

    if (taskRequest == null) {
      throw new ResourceException(
          new Status(
              Status.CLIENT_ERROR_UNSUPPORTED_MEDIA_TYPE.getCode(),
              "A request body was expected when updating the task.",
              null,
              null));
    }

    Task task = getTaskFromRequest();

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

    // 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
    ActivitiUtil.getTaskService().saveTask(task);
    task = ActivitiUtil.getTaskService().createTaskQuery().taskId(task.getId()).singleResult();

    return getApplication(ActivitiRestServicesApplication.class)
        .getRestResponseFactory()
        .createTaskReponse(this, task);
  }
  public RestVariable getVariableFromRequest(boolean includeBinary) {
    String taskId = getAttribute("taskId");
    if (taskId == null) {
      throw new ActivitiIllegalArgumentException("The taskId cannot be null");
    }

    String variableName = getAttribute("variableName");
    if (variableName == null) {
      throw new ActivitiIllegalArgumentException("The variableName cannot be null");
    }

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

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

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

    if (!variableFound) {
      throw new ActivitiObjectNotFoundException(
          "Task '" + taskId + "' doesn't have a variable with name: '" + variableName + "'.",
          VariableInstanceEntity.class);
    } else {
      return getApplication(ActivitiRestServicesApplication.class)
          .getRestResponseFactory()
          .createRestVariable(
              this, variableName, value, variableScope, taskId, null, null, includeBinary);
    }
  }
  @Post
  public ProcessInstanceResponse createProcessInstance(ProcessInstanceCreateRequest request) {

    if (request.getProcessDefinitionId() == null
        && request.getProcessDefinitionKey() == null
        && request.getMessage() == null) {
      throw new ActivitiIllegalArgumentException(
          "Either processDefinitionId, processDefinitionKey or message is required.");
    }

    int paramsSet =
        ((request.getProcessDefinitionId() != null) ? 1 : 0)
            + ((request.getProcessDefinitionKey() != null) ? 1 : 0)
            + ((request.getMessage() != null) ? 1 : 0);

    if (paramsSet > 1) {
      throw new ActivitiIllegalArgumentException(
          "Only one of processDefinitionId, processDefinitionKey or message should be set.");
    }

    RestResponseFactory factory =
        getApplication(ActivitiRestServicesApplication.class).getRestResponseFactory();

    Map<String, Object> startVariables = null;
    if (request.getVariables() != null) {
      startVariables = new HashMap<String, Object>();
      for (RestVariable variable : request.getVariables()) {
        startVariables.put(variable.getName(), factory.getVariableValue(variable));
      }
    }

    // Actually start the instance based on key or id
    try {
      ProcessInstance instance = null;
      if (request.getProcessDefinitionId() != null) {
        instance =
            ActivitiUtil.getRuntimeService()
                .startProcessInstanceById(
                    request.getProcessDefinitionId(), request.getBusinessKey(), startVariables);
      } else if (request.getProcessDefinitionKey() != null) {
        instance =
            ActivitiUtil.getRuntimeService()
                .startProcessInstanceByKey(
                    request.getProcessDefinitionKey(), request.getBusinessKey(), startVariables);
      } else {
        instance =
            ActivitiUtil.getRuntimeService()
                .startProcessInstanceByMessage(
                    request.getMessage(), request.getBusinessKey(), startVariables);
      }

      setStatus(Status.SUCCESS_CREATED);
      return factory.createProcessInstanceResponse(this, instance);
    } catch (ActivitiObjectNotFoundException aonfe) {
      throw new ActivitiIllegalArgumentException(aonfe.getMessage(), aonfe);
    }
  }
  @Put
  public AttachmentResponse addAttachment(Representation entity) {
    if (authenticate() == false) return null;

    String taskId = (String) getRequest().getAttributes().get("taskId");

    try {
      RestletFileUpload upload = new RestletFileUpload(new DiskFileItemFactory());
      List<FileItem> items = upload.parseRepresentation(entity);

      FileItem uploadItem = null;
      for (FileItem fileItem : items) {
        if (fileItem.getName() != null) {
          uploadItem = fileItem;
        }
      }

      String fileName = uploadItem.getName();

      Attachment attachment =
          ActivitiUtil.getTaskService()
              .createAttachment(
                  uploadItem.getContentType(),
                  taskId,
                  null,
                  fileName,
                  fileName,
                  uploadItem.getInputStream());

      return new AttachmentResponse(attachment);

    } catch (Exception e) {
      throw new ActivitiException("Unable to add new attachment to task " + taskId);
    }
  }
  protected boolean hasVariableOnScope(Task task, String variableName, RestVariableScope scope) {
    boolean variableFound = false;

    if (scope == RestVariableScope.GLOBAL) {
      if (task.getExecutionId() != null
          && ActivitiUtil.getRuntimeService().hasVariable(task.getExecutionId(), variableName)) {
        variableFound = true;
      }

    } else if (scope == RestVariableScope.LOCAL) {
      if (ActivitiUtil.getTaskService().hasVariableLocal(task.getId(), variableName)) {
        variableFound = true;
      }
    }
    return variableFound;
  }
Example #7
0
  @Get
  public DataResponse getTasks() {
    if (authenticate() == false) return null;

    String personalTaskUserId = getQuery().getValues("assignee");
    String ownerTaskUserId = getQuery().getValues("owner");
    String involvedTaskUserId = getQuery().getValues("involved");
    String candidateTaskUserId = getQuery().getValues("candidate");
    String candidateGroupId = getQuery().getValues("candidate-group");

    String strPriority = getQuery().getValues("priority");
    String strMinPriority = getQuery().getValues("minPriority");
    String strMaxPriority = getQuery().getValues("maxPriority");

    String strDueDate = getQuery().getValues("dueDate");
    String strMinDueDate = getQuery().getValues("minDueDate");
    String strMaxDueDate = getQuery().getValues("maxDueDate");

    TaskQuery taskQuery = ActivitiUtil.getTaskService().createTaskQuery();
    if (personalTaskUserId != null) {
      taskQuery.taskAssignee(personalTaskUserId);
    } else if (ownerTaskUserId != null) {
      taskQuery.taskOwner(ownerTaskUserId);
    } else if (involvedTaskUserId != null) {
      taskQuery.taskInvolvedUser(involvedTaskUserId);
    } else if (candidateTaskUserId != null) {
      taskQuery.taskCandidateUser(candidateTaskUserId);
    } else if (candidateGroupId != null) {
      taskQuery.taskCandidateGroup(candidateGroupId);
    } else {
      throw new ActivitiIllegalArgumentException(
          "Tasks must be filtered with 'assignee', 'owner', 'involved', 'candidate' or 'candidate-group'");
    }

    if (strPriority != null) {
      taskQuery.taskPriority(RequestUtil.parseToInteger(strPriority));
    } else if (strMinPriority != null) {
      taskQuery.taskMinPriority(RequestUtil.parseToInteger(strMinPriority));
    } else if (strMaxPriority != null) {
      taskQuery.taskMaxPriority(RequestUtil.parseToInteger(strMaxPriority));
    }

    if (strDueDate != null) {
      taskQuery.dueDate(RequestUtil.parseToDate(strDueDate));
    } else if (strMinDueDate != null) {
      taskQuery.dueAfter(RequestUtil.parseToDate(strMinDueDate));
    } else if (strMaxDueDate != null) {
      taskQuery.dueBefore(RequestUtil.parseToDate(strMaxDueDate));
    }

    DataResponse dataResponse =
        new TasksPaginateList().paginateList(getQuery(), taskQuery, "id", properties);
    return dataResponse;
  }
Example #8
0
  protected void completeTask(Task task, TaskActionRequest actionRequest) {
    if (actionRequest.getVariables() != null) {
      Map<String, Object> variablesToSet = new HashMap<String, Object>();
      for (RestVariable var : actionRequest.getVariables()) {
        if (var.getName() == null) {
          throw new ActivitiIllegalArgumentException("Variable name is required");
        }

        Object actualVariableValue =
            getApplication(ActivitiRestServicesApplication.class)
                .getRestResponseFactory()
                .getVariableValue(var);

        variablesToSet.put(var.getName(), actualVariableValue);
      }

      ActivitiUtil.getTaskService().complete(task.getId(), variablesToSet);
    } else {
      ActivitiUtil.getTaskService().complete(task.getId());
    }
  }
  @Delete
  public void delegteAttachment() {
    if (!authenticate()) return;

    Task task = getTaskFromRequest();

    String attachmentId = getAttribute("attachmentId");
    if (attachmentId == null) {
      throw new ActivitiIllegalArgumentException("AttachmentId is required.");
    }

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

    ActivitiUtil.getTaskService().deleteAttachment(attachmentId);
    setStatus(Status.SUCCESS_NO_CONTENT);
  }
  protected void setVariable(
      Task task, String name, Object value, RestVariableScope scope, boolean isNew) {
    // Create can only be done on new variables. Existing variables should be updated using PUT
    boolean hasVariable = hasVariableOnScope(task, name, scope);
    if (isNew && hasVariable) {
      throw new ResourceException(
          new Status(
              Status.CLIENT_ERROR_CONFLICT.getCode(),
              "Variable '" + name + "' is already present on task '" + task.getId() + "'.",
              null,
              null));
    }

    if (!isNew && !hasVariable) {
      throw new ResourceException(
          new Status(
              Status.CLIENT_ERROR_NOT_FOUND.getCode(),
              "Task '" + task.getId() + "' doesn't have a variable with name: '" + name + "'.",
              null,
              null));
    }

    if (scope == RestVariableScope.LOCAL) {
      ActivitiUtil.getTaskService().setVariableLocal(task.getId(), name, value);
    } else {
      if (task.getExecutionId() != null) {
        // Explicitly set on execution, setting non-local variable on task will override
        // local-variable if exists
        ActivitiUtil.getRuntimeService().setVariable(task.getExecutionId(), name, value);
      } else {
        // Standalone task, no global variables possible
        throw new ActivitiIllegalArgumentException(
            "Cannot set global variable '"
                + name
                + "' on task '"
                + task.getId()
                + "', task is not part of process.");
      }
    }
  }
  @Get
  public List<AttachmentResponse> getAttachments() {
    if (!authenticate()) return null;

    List<AttachmentResponse> result = new ArrayList<AttachmentResponse>();
    RestResponseFactory responseFactory =
        getApplication(ActivitiRestServicesApplication.class).getRestResponseFactory();
    Task task = getTaskFromRequest();

    for (Attachment attachment : ActivitiUtil.getTaskService().getTaskAttachments(task.getId())) {
      result.add(responseFactory.createAttachmentResponse(this, attachment));
    }

    return result;
  }
  /** Get valid execution from request, in this case a {@link ProcessInstance}. */
  protected Execution getExecutionFromRequest() {
    String processInstanceId = getAttribute("processInstanceId");

    if (processInstanceId == null) {
      throw new ActivitiIllegalArgumentException("The processInstanceId cannot be null");
    }

    Execution execution =
        ActivitiUtil.getRuntimeService()
            .createProcessInstanceQuery()
            .processInstanceId(processInstanceId)
            .singleResult();
    if (execution == null) {
      throw new ActivitiObjectNotFoundException(
          "Could not find a process instance with id '" + processInstanceId + "'.",
          ProcessInstance.class);
    }
    return execution;
  }
  protected AttachmentResponse createBinaryAttachment(Representation representation, Task task)
      throws FileUploadException, IOException {
    RestletFileUpload upload = new RestletFileUpload(new DiskFileItemFactory());
    List<FileItem> items = upload.parseRepresentation(representation);

    String name = null;
    String description = null;
    String type = null;
    FileItem uploadItem = null;

    for (FileItem fileItem : items) {
      if (fileItem.isFormField()) {
        if ("name".equals(fileItem.getFieldName())) {
          name = fileItem.getString("UTF-8");
        } else if ("description".equals(fileItem.getFieldName())) {
          description = fileItem.getString("UTF-8");
        } else if ("type".equals(fileItem.getFieldName())) {
          type = fileItem.getString("UTF-8");
        }
      } else if (fileItem.getName() != null) {
        uploadItem = fileItem;
      }
    }

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

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

    Attachment createdAttachment =
        ActivitiUtil.getTaskService()
            .createAttachment(
                type, task.getId(), null, name, description, uploadItem.getInputStream());

    setStatus(Status.SUCCESS_CREATED);
    return getApplication(ActivitiRestServicesApplication.class)
        .getRestResponseFactory()
        .createAttachmentResponse(this, createdAttachment);
  }
  // For process instance there's only one scope. Using the local variables method for that
  protected void addLocalVariables(Execution execution, Map<String, RestVariable> variableMap) {
    Map<String, Object> rawVariables =
        ActivitiUtil.getRuntimeService().getVariables(execution.getId());
    List<RestVariable> globalVariables =
        getApplication(ActivitiRestServicesApplication.class)
            .getRestResponseFactory()
            .createRestVariables(
                this,
                rawVariables,
                execution.getId(),
                RestResponseFactory.VARIABLE_PROCESS,
                RestVariableScope.LOCAL);

    // Overlay global variables over local ones. In case they are present the values are not
    // overridden,
    // since local variables get precedence over global ones at all times.
    for (RestVariable var : globalVariables) {
      if (!variableMap.containsKey(var.getName())) {
        variableMap.put(var.getName(), var);
      }
    }
  }
  protected AttachmentResponse createSimpleAttachment(Representation representation, Task task)
      throws IOException {
    AttachmentRequest req =
        getConverterService().toObject(representation, AttachmentRequest.class, this);
    if (req.getName() == null) {
      throw new ActivitiIllegalArgumentException("Attachment name is required.");
    }

    Attachment createdAttachment =
        ActivitiUtil.getTaskService()
            .createAttachment(
                req.getType(),
                task.getId(),
                null,
                req.getName(),
                req.getDescription(),
                req.getExternalUrl());

    return getApplication(ActivitiRestServicesApplication.class)
        .getRestResponseFactory()
        .createAttachmentResponse(this, createdAttachment);
  }
  @Get
  public AttachmentResponse getAttachment() {
    if (!authenticate()) return null;

    Task task = getTaskFromRequest();

    String attachmentId = getAttribute("attachmentId");
    if (attachmentId == null) {
      throw new ActivitiIllegalArgumentException("AttachmentId is required.");
    }

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

    return getApplication(ActivitiRestServicesApplication.class)
        .getRestResponseFactory()
        .createAttachmentResponse(this, attachment);
  }
Example #17
0
 protected void claimTask(Task task, TaskActionRequest actionRequest) {
   // In case the task is already claimed, a ActivitiTaskAlreadyClaimedException is thown and
   // converted to
   // a CONFLICT response by the StatusService
   ActivitiUtil.getTaskService().claim(task.getId(), actionRequest.getAssignee());
 }
Example #18
0
 protected void delegateTask(Task task, TaskActionRequest actionRequest) {
   if (actionRequest.getAssignee() == null) {
     throw new ActivitiIllegalArgumentException("An assignee is required when delegating a task.");
   }
   ActivitiUtil.getTaskService().delegateTask(task.getId(), actionRequest.getAssignee());
 }
Example #19
0
 protected void resolveTask(Task task, TaskActionRequest actionRequest) {
   ActivitiUtil.getTaskService().resolveTask(task.getId());
 }