org.jbpm.services.ejb.impl

## Class TaskServiceEJBImpl

- java.lang.Object
- - org.jbpm.services.ejb.impl.TaskServiceEJBImpl

- All Implemented Interfaces:
    TaskServiceEJBLocal, org.kie.api.runtime.CommandExecutor, org.kie.api.task.TaskService, org.kie.internal.task.api.InternalTaskService

      public class TaskServiceEJBImpl
      extends Object
      implements org.kie.internal.task.api.InternalTaskService, org.kie.api.task.TaskService, TaskServiceEJBLocal

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `TaskServiceEJBImpl()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `activate(long taskId, String userId)`
    `long` | `addAttachment(long taskId, org.kie.api.task.model.Attachment attachment, org.kie.api.task.model.Content content)`
    `Long` | `addComment(long taskId, org.kie.api.task.model.Comment comment)`
    `Long` | `addComment(long taskId, String addedByUserId, String commentText)`
    `long` | `addContent(long taskId, org.kie.api.task.model.Content content)`
    `long` | `addContent(long taskId, Map<String,Object> params)`
    `long` | `addContentFromUser(long taskId, String userId, Map<String,Object> params)`
    `void` | `addGroup(org.kie.api.task.model.Group group)`
    `void` | `addMarshallerContext(String ownerId, org.kie.internal.task.api.ContentMarshallerContext context)`
    `long` | `addOutputContentFromUser(long taskId, String userId, Map<String,Object> params)`
    `long` | `addTask(org.kie.api.task.model.Task task, org.kie.internal.task.api.model.ContentData data)`
    `long` | `addTask(org.kie.api.task.model.Task task, Map<String,Object> params)`
    `void` | `addUser(org.kie.api.task.model.User user)`
    `void` | `addUsersAndGroups(Map<String,org.kie.api.task.model.User> users, Map<String,org.kie.api.task.model.Group> groups)`
    `int` | `archiveTasks(List<org.kie.api.task.model.TaskSummary> tasks)`
    `void` | `claim(long taskId, String userId)`
    `void` | `claimNextAvailable(String userId, String language)`
    `void` | `complete(long taskId, String userId, Map<String,Object> data)`
    `void` | `configureDelegate()`
    `void` | `delegate(long taskId, String userId, String targetUserId)`
    `void` | `deleteAttachment(long taskId, long attachmentId)`
    `void` | `deleteComment(long taskId, long commentId)`
    `void` | `deleteContent(long taskId, long contentId)`
    `void` | `deleteFault(long taskId, String userId)`
    `void` | `deleteOutput(long taskId, String userId)`
    `void` | `deployTaskDef(org.kie.internal.task.api.model.TaskDef def)`
    `<T> T` | `execute(org.kie.api.command.Command<T> command)`
    `void` | `executeReminderForTask(long taskId, String initiator)`
    `void` | `exit(long taskId, String userId)`
    `void` | `fail(long taskId, String userId, Map<String,Object> faultData)`
    `void` | `forward(long taskId, String userId, String targetEntityId)`
    `List<org.kie.api.task.model.TaskSummary>` | `getActiveTasks()`
    `List<org.kie.api.task.model.TaskSummary>` | `getActiveTasks(Date since)`
    `List<org.kie.api.task.model.Attachment>` | `getAllAttachmentsByTaskId(long taskId)`
    `List<org.kie.api.task.model.Comment>` | `getAllCommentsByTaskId(long taskId)`
    `List<org.kie.api.task.model.Content>` | `getAllContentByTaskId(long taskId)`
    `List<org.kie.internal.task.api.model.TaskDef>` | `getAllTaskDef(String filter)`
    `List<org.kie.api.task.model.TaskSummary>` | `getArchivedTasks()`
    `org.kie.api.task.model.Attachment` | `getAttachmentById(long attachId)`
    `org.kie.api.task.model.Comment` | `getCommentById(long commentId)`
    `int` | `getCompletedTaskByUserId(String userId)`
    `List<org.kie.api.task.model.TaskSummary>` | `getCompletedTasks()`
    `List<org.kie.api.task.model.TaskSummary>` | `getCompletedTasks(Date since)`
    `List<org.kie.api.task.model.TaskSummary>` | `getCompletedTasksByProcessId(Long processId)`
    `org.kie.api.task.model.Content` | `getContentById(long contentId)`
    `org.kie.api.task.model.Content` | `getContentByIdForUser(long contentId, String userId)`
    `List<org.kie.api.task.model.I18NText>` | `getDescriptions(long taskId)`
    `Date` | `getExpirationDate(long taskId)`
    `org.kie.api.task.model.Group` | `getGroupById(String groupId)`
    `List<org.kie.api.task.model.Group>` | `getGroups()`
    `org.kie.internal.task.api.ContentMarshallerContext` | `getMarshallerContext(org.kie.api.task.model.Task task)`
    `org.kie.api.task.model.OrganizationalEntity` | `getOrganizationalEntityById(String entityId)`
    `Map<String,Object>` | `getOutputContentMapForUser(long taskId, String userId)`
    `int` | `getPendingSubTasksByParent(long parentId)`
    `int` | `getPendingTaskByUserId(String userId)`
    `Map<Long,List<org.kie.api.task.model.OrganizationalEntity>>` | `getPotentialOwnersForTaskIds(List<Long> taskIds)`
    `int` | `getPriority(long taskId)`
    `List<org.kie.api.task.model.TaskSummary>` | `getSubTasksAssignedAsPotentialOwner(long parentId, String userId)`
    `List<org.kie.api.task.model.TaskSummary>` | `getSubTasksByParent(long parentId)`
    `org.kie.internal.task.api.model.SubTasksStrategy` | `getSubTaskStrategy(long taskId)`
    `org.kie.api.task.model.Task` | `getTaskById(long taskId)`
    `org.kie.api.task.model.Task` | `getTaskByWorkItemId(long workItemId)`
    `Map<String,Object>` | `getTaskContent(long taskId)`
    `org.kie.internal.task.api.model.TaskDef` | `getTaskDefById(String id)`
    `List<org.kie.internal.task.api.model.TaskEvent>` | `getTaskEventsById(long taskId)`
    `org.kie.api.task.model.Task` | `getTaskInstanceById(long taskId)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksAssignedAsBusinessAdministrator(String userId, String language)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksAssignedAsBusinessAdministratorByStatus(String userId, String language, List<org.kie.api.task.model.Status> statuses)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksAssignedAsExcludedOwner(String userId)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksAssignedAsPotentialOwner(String userId, List<String> groupIds)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksAssignedAsPotentialOwner(String userId, List<String> groupIds, List<org.kie.api.task.model.Status> status, org.kie.internal.query.QueryFilter filter)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksAssignedAsPotentialOwner(String userId, List<String> groupIds, String language, int firstResult, int maxResults)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksAssignedAsPotentialOwner(String userId, String language)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksAssignedAsPotentialOwnerByExpirationDate(String userId, List<org.kie.api.task.model.Status> statuses, Date expirationDate)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksAssignedAsPotentialOwnerByExpirationDateOptional(String userId, List<org.kie.api.task.model.Status> statuses, Date expirationDate)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksAssignedAsPotentialOwnerByProcessId(String userId, String processId)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksAssignedAsPotentialOwnerByStatus(String userId, List<org.kie.api.task.model.Status> status, String language)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksAssignedAsPotentialOwnerByStatusByGroup(String userId, List<String> groupIds, List<org.kie.api.task.model.Status> status)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksAssignedAsRecipient(String userId)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksAssignedAsTaskInitiator(String userId)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksAssignedAsTaskStakeholder(String userId)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksAssignedByGroup(String groupId)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksAssignedByGroups(List<String> groupIds)`
    `List<Long>` | `getTasksByProcessInstanceId(long processInstanceId)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksByStatusByProcessInstanceId(long processInstanceId, List<org.kie.api.task.model.Status> status, String language)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksByStatusByProcessInstanceIdByTaskName(long processInstanceId, List<org.kie.api.task.model.Status> status, String taskName)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksOwned(String userId, List<org.kie.api.task.model.Status> status, org.kie.internal.query.QueryFilter filter)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksOwned(String userId, String language)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksOwnedByExpirationDate(String userId, List<org.kie.api.task.model.Status> statuses, Date expirationDate)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksOwnedByExpirationDateBeforeSpecifiedDate(String userId, List<org.kie.api.task.model.Status> status, Date date)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksOwnedByExpirationDateOptional(String userId, List<org.kie.api.task.model.Status> statuses, Date expirationDate)`
    `List<org.kie.api.task.model.TaskSummary>` | `getTasksOwnedByStatus(String userId, List<org.kie.api.task.model.Status> status, String language)`
    `org.kie.api.task.model.User` | `getUserById(String userId)`
    `org.kie.internal.task.api.UserInfo` | `getUserInfo()`
    `List<org.kie.api.task.model.User>` | `getUsers()`
    `boolean` | `isSkipable(long taskId)`
    `void` | `nominate(long taskId, String userId, List<org.kie.api.task.model.OrganizationalEntity> potentialOwners)`
    `void` | `release(long taskId, String userId)`
    `void` | `remove(long taskId, String userId)`
    `int` | `removeAllTasks()`
    `void` | `removeGroup(String groupId)`
    `void` | `removeMarshallerContext(String ownerId)`
    `void` | `removeTaskEventsById(long taskId)`
    `int` | `removeTasks(List<org.kie.api.task.model.TaskSummary> tasks)`
    `void` | `removeUser(String userId)`
    `void` | `resume(long taskId, String userId)`
    `void` | `setDescriptions(long taskId, List<org.kie.api.task.model.I18NText> descriptions)`
    `long` | `setDocumentContentFromUser(long taskId, String userId, byte[] byteContent)`
    `void` | `setExpirationDate(long taskId, Date date)`
    `void` | `setFault(long taskId, String userId, org.kie.internal.task.api.model.FaultData fault)`
    `void` | `setOutput(long taskId, String userId, Object outputContentData)`
    `void` | `setPriority(long taskId, int priority)`
    `void` | `setSkipable(long taskId, boolean skipable)`
    `void` | `setSubTaskStrategy(long taskId, org.kie.internal.task.api.model.SubTasksStrategy strategy)`
    `void` | `setTaskNames(long taskId, List<org.kie.api.task.model.I18NText> taskNames)`
    `void` | `setUserInfo(org.kie.internal.task.api.UserInfo userInfo)`
    `void` | `skip(long taskId, String userId)`
    `void` | `start(long taskId, String userId)`
    `void` | `stop(long taskId, String userId)`
    `void` | `suspend(long taskId, String userId)`
    `org.kie.internal.task.query.TaskSummaryQueryBuilder` | `taskSummaryQuery(String userId)`
    `void` | `undeployTaskDef(String id)`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### TaskServiceEJBImpl

          public TaskServiceEJBImpl()

  - ### Method Detail

    - #### configureDelegate

          @PostConstruct
          public void configureDelegate()

    - #### getTasksAssignedAsBusinessAdministrator

          public List<org.kie.api.task.model.TaskSummary> getTasksAssignedAsBusinessAdministrator(String userId,
                                                                                                  String language)

      Specified by:
        `getTasksAssignedAsBusinessAdministrator` in interface `org.kie.api.task.TaskService`

    - #### getTasksAssignedAsBusinessAdministratorByStatus

          public List<org.kie.api.task.model.TaskSummary> getTasksAssignedAsBusinessAdministratorByStatus(String userId,
                                                                                                          String language,
                                                                                                          List<org.kie.api.task.model.Status> statuses)

      Specified by:
        `getTasksAssignedAsBusinessAdministratorByStatus` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTasksAssignedAsPotentialOwner

          public List<org.kie.api.task.model.TaskSummary> getTasksAssignedAsPotentialOwner(String userId,
                                                                                           String language)

      Specified by:
        `getTasksAssignedAsPotentialOwner` in interface `org.kie.api.task.TaskService`

    - #### getTasksAssignedAsPotentialOwnerByStatus

          public List<org.kie.api.task.model.TaskSummary> getTasksAssignedAsPotentialOwnerByStatus(String userId,
                                                                                                   List<org.kie.api.task.model.Status> status,
                                                                                                   String language)

      Specified by:
        `getTasksAssignedAsPotentialOwnerByStatus` in interface `org.kie.api.task.TaskService`

    - #### getTasksOwned

          public List<org.kie.api.task.model.TaskSummary> getTasksOwned(String userId,
                                                                        String language)

      Specified by:
        `getTasksOwned` in interface `org.kie.api.task.TaskService`

    - #### getTasksOwnedByStatus

          public List<org.kie.api.task.model.TaskSummary> getTasksOwnedByStatus(String userId,
                                                                                List<org.kie.api.task.model.Status> status,
                                                                                String language)

      Specified by:
        `getTasksOwnedByStatus` in interface `org.kie.api.task.TaskService`

    - #### getTasksByStatusByProcessInstanceId

          public List<org.kie.api.task.model.TaskSummary> getTasksByStatusByProcessInstanceId(long processInstanceId,
                                                                                              List<org.kie.api.task.model.Status> status,
                                                                                              String language)

      Specified by:
        `getTasksByStatusByProcessInstanceId` in interface `org.kie.api.task.TaskService`

    - #### getTasksByProcessInstanceId

          public List<Long> getTasksByProcessInstanceId(long processInstanceId)

      Specified by:
        `getTasksByProcessInstanceId` in interface `org.kie.api.task.TaskService`

    - #### getActiveTasks

          public List<org.kie.api.task.model.TaskSummary> getActiveTasks()

      Specified by:
        `getActiveTasks` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getActiveTasks

          public List<org.kie.api.task.model.TaskSummary> getActiveTasks(Date since)

      Specified by:
        `getActiveTasks` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTasksOwned

          public List<org.kie.api.task.model.TaskSummary> getTasksOwned(String userId,
                                                                        List<org.kie.api.task.model.Status> status,
                                                                        org.kie.internal.query.QueryFilter filter)

      Specified by:
        `getTasksOwned` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTasksAssignedAsPotentialOwner

          public List<org.kie.api.task.model.TaskSummary> getTasksAssignedAsPotentialOwner(String userId,
                                                                                           List<String> groupIds,
                                                                                           List<org.kie.api.task.model.Status> status,
                                                                                           org.kie.internal.query.QueryFilter filter)

      Specified by:
        `getTasksAssignedAsPotentialOwner` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getArchivedTasks

          public List<org.kie.api.task.model.TaskSummary> getArchivedTasks()

      Specified by:
        `getArchivedTasks` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getCompletedTasks

          public List<org.kie.api.task.model.TaskSummary> getCompletedTasks()

      Specified by:
        `getCompletedTasks` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getCompletedTasks

          public List<org.kie.api.task.model.TaskSummary> getCompletedTasks(Date since)

      Specified by:
        `getCompletedTasks` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getCompletedTasksByProcessId

          public List<org.kie.api.task.model.TaskSummary> getCompletedTasksByProcessId(Long processId)

      Specified by:
        `getCompletedTasksByProcessId` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getSubTasksAssignedAsPotentialOwner

          public List<org.kie.api.task.model.TaskSummary> getSubTasksAssignedAsPotentialOwner(long parentId,
                                                                                              String userId)

      Specified by:
        `getSubTasksAssignedAsPotentialOwner` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getSubTasksByParent

          public List<org.kie.api.task.model.TaskSummary> getSubTasksByParent(long parentId)

      Specified by:
        `getSubTasksByParent` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getPendingSubTasksByParent

          public int getPendingSubTasksByParent(long parentId)

      Specified by:
        `getPendingSubTasksByParent` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTasksAssignedAsPotentialOwnerByExpirationDate

          public List<org.kie.api.task.model.TaskSummary> getTasksAssignedAsPotentialOwnerByExpirationDate(String userId,
                                                                                                           List<org.kie.api.task.model.Status> statuses,
                                                                                                           Date expirationDate)

      Specified by:
        `getTasksAssignedAsPotentialOwnerByExpirationDate` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTasksAssignedAsPotentialOwnerByExpirationDateOptional

          public List<org.kie.api.task.model.TaskSummary> getTasksAssignedAsPotentialOwnerByExpirationDateOptional(String userId,
                                                                                                                   List<org.kie.api.task.model.Status> statuses,
                                                                                                                   Date expirationDate)

      Specified by:
        `getTasksAssignedAsPotentialOwnerByExpirationDateOptional` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTasksOwnedByExpirationDate

          public List<org.kie.api.task.model.TaskSummary> getTasksOwnedByExpirationDate(String userId,
                                                                                        List<org.kie.api.task.model.Status> statuses,
                                                                                        Date expirationDate)

      Specified by:
        `getTasksOwnedByExpirationDate` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTasksOwnedByExpirationDateOptional

          public List<org.kie.api.task.model.TaskSummary> getTasksOwnedByExpirationDateOptional(String userId,
                                                                                                List<org.kie.api.task.model.Status> statuses,
                                                                                                Date expirationDate)

      Specified by:
        `getTasksOwnedByExpirationDateOptional` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTasksAssignedAsExcludedOwner

          public List<org.kie.api.task.model.TaskSummary> getTasksAssignedAsExcludedOwner(String userId)

      Specified by:
        `getTasksAssignedAsExcludedOwner` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTasksAssignedAsPotentialOwner

          public List<org.kie.api.task.model.TaskSummary> getTasksAssignedAsPotentialOwner(String userId,
                                                                                           List<String> groupIds)

      Specified by:
        `getTasksAssignedAsPotentialOwner` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTasksAssignedAsPotentialOwner

          public List<org.kie.api.task.model.TaskSummary> getTasksAssignedAsPotentialOwner(String userId,
                                                                                           List<String> groupIds,
                                                                                           String language,
                                                                                           int firstResult,
                                                                                           int maxResults)

      Specified by:
        `getTasksAssignedAsPotentialOwner` in interface `org.kie.api.task.TaskService`

    - #### getTasksAssignedAsPotentialOwnerByStatusByGroup

          public List<org.kie.api.task.model.TaskSummary> getTasksAssignedAsPotentialOwnerByStatusByGroup(String userId,
                                                                                                          List<String> groupIds,
                                                                                                          List<org.kie.api.task.model.Status> status)

      Specified by:
        `getTasksAssignedAsPotentialOwnerByStatusByGroup` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTasksAssignedAsPotentialOwnerByProcessId

          public List<org.kie.api.task.model.TaskSummary> getTasksAssignedAsPotentialOwnerByProcessId(String userId,
                                                                                                      String processId)

      Specified by:
        `getTasksAssignedAsPotentialOwnerByProcessId` in interface `org.kie.api.task.TaskService`

    - #### getTasksAssignedAsRecipient

          public List<org.kie.api.task.model.TaskSummary> getTasksAssignedAsRecipient(String userId)

      Specified by:
        `getTasksAssignedAsRecipient` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTasksAssignedAsTaskInitiator

          public List<org.kie.api.task.model.TaskSummary> getTasksAssignedAsTaskInitiator(String userId)

      Specified by:
        `getTasksAssignedAsTaskInitiator` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTasksAssignedAsTaskStakeholder

          public List<org.kie.api.task.model.TaskSummary> getTasksAssignedAsTaskStakeholder(String userId)

      Specified by:
        `getTasksAssignedAsTaskStakeholder` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTasksOwnedByExpirationDateBeforeSpecifiedDate

          public List<org.kie.api.task.model.TaskSummary> getTasksOwnedByExpirationDateBeforeSpecifiedDate(String userId,
                                                                                                           List<org.kie.api.task.model.Status> status,
                                                                                                           Date date)

      Specified by:
        `getTasksOwnedByExpirationDateBeforeSpecifiedDate` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTasksByStatusByProcessInstanceIdByTaskName

          public List<org.kie.api.task.model.TaskSummary> getTasksByStatusByProcessInstanceIdByTaskName(long processInstanceId,
                                                                                                        List<org.kie.api.task.model.Status> status,
                                                                                                        String taskName)

      Specified by:
        `getTasksByStatusByProcessInstanceIdByTaskName` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getPotentialOwnersForTaskIds

          public Map<Long,List<org.kie.api.task.model.OrganizationalEntity>> getPotentialOwnersForTaskIds(List<Long> taskIds)

      Specified by:
        `getPotentialOwnersForTaskIds` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTasksAssignedByGroup

          public List<org.kie.api.task.model.TaskSummary> getTasksAssignedByGroup(String groupId)

      Specified by:
        `getTasksAssignedByGroup` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTasksAssignedByGroups

          public List<org.kie.api.task.model.TaskSummary> getTasksAssignedByGroups(List<String> groupIds)

      Specified by:
        `getTasksAssignedByGroups` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### activate

          public void activate(long taskId,
                               String userId)

      Specified by:
        `activate` in interface `org.kie.api.task.TaskService`

    - #### claim

          public void claim(long taskId,
                            String userId)

      Specified by:
        `claim` in interface `org.kie.api.task.TaskService`

    - #### claimNextAvailable

          public void claimNextAvailable(String userId,
                                         String language)

      Specified by:
        `claimNextAvailable` in interface `org.kie.api.task.TaskService`

    - #### complete

          public void complete(long taskId,
                               String userId,
                               Map<String,Object> data)

      Specified by:
        `complete` in interface `org.kie.api.task.TaskService`

    - #### delegate

          public void delegate(long taskId,
                               String userId,
                               String targetUserId)

      Specified by:
        `delegate` in interface `org.kie.api.task.TaskService`

    - #### exit

          public void exit(long taskId,
                           String userId)

      Specified by:
        `exit` in interface `org.kie.api.task.TaskService`

    - #### fail

          public void fail(long taskId,
                           String userId,
                           Map<String,Object> faultData)

      Specified by:
        `fail` in interface `org.kie.api.task.TaskService`

    - #### forward

          public void forward(long taskId,
                              String userId,
                              String targetEntityId)

      Specified by:
        `forward` in interface `org.kie.api.task.TaskService`

    - #### getTaskByWorkItemId

          public org.kie.api.task.model.Task getTaskByWorkItemId(long workItemId)

      Specified by:
        `getTaskByWorkItemId` in interface `org.kie.api.task.TaskService`

    - #### getTaskById

          public org.kie.api.task.model.Task getTaskById(long taskId)

      Specified by:
        `getTaskById` in interface `org.kie.api.task.TaskService`

    - #### addTask

          public long addTask(org.kie.api.task.model.Task task,
                              Map<String,Object> params)

      Specified by:
        `addTask` in interface `org.kie.api.task.TaskService`

    - #### release

          public void release(long taskId,
                              String userId)

      Specified by:
        `release` in interface `org.kie.api.task.TaskService`

    - #### resume

          public void resume(long taskId,
                             String userId)

      Specified by:
        `resume` in interface `org.kie.api.task.TaskService`

    - #### skip

          public void skip(long taskId,
                           String userId)

      Specified by:
        `skip` in interface `org.kie.api.task.TaskService`

    - #### start

          public void start(long taskId,
                            String userId)

      Specified by:
        `start` in interface `org.kie.api.task.TaskService`

    - #### stop

          public void stop(long taskId,
                           String userId)

      Specified by:
        `stop` in interface `org.kie.api.task.TaskService`

    - #### suspend

          public void suspend(long taskId,
                              String userId)

      Specified by:
        `suspend` in interface `org.kie.api.task.TaskService`

    - #### nominate

          public void nominate(long taskId,
                               String userId,
                               List<org.kie.api.task.model.OrganizationalEntity> potentialOwners)

      Specified by:
        `nominate` in interface `org.kie.api.task.TaskService`

    - #### getContentById

          public org.kie.api.task.model.Content getContentById(long contentId)

      Specified by:
        `getContentById` in interface `org.kie.api.task.TaskService`

    - #### getAttachmentById

          public org.kie.api.task.model.Attachment getAttachmentById(long attachId)

      Specified by:
        `getAttachmentById` in interface `org.kie.api.task.TaskService`

    - #### getTaskContent

          public Map<String,Object> getTaskContent(long taskId)

      Specified by:
        `getTaskContent` in interface `org.kie.api.task.TaskService`

    - #### execute

          public <T> T execute(org.kie.api.command.Command<T> command)

      Specified by:
        `execute` in interface `org.kie.api.runtime.CommandExecutor`

    - #### addGroup

          public void addGroup(org.kie.api.task.model.Group group)

      Specified by:
        `addGroup` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### addUser

          public void addUser(org.kie.api.task.model.User user)

      Specified by:
        `addUser` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### archiveTasks

          public int archiveTasks(List<org.kie.api.task.model.TaskSummary> tasks)

      Specified by:
        `archiveTasks` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### deleteFault

          public void deleteFault(long taskId,
                                  String userId)

      Specified by:
        `deleteFault` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### deleteOutput

          public void deleteOutput(long taskId,
                                   String userId)

      Specified by:
        `deleteOutput` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### deployTaskDef

          public void deployTaskDef(org.kie.internal.task.api.model.TaskDef def)

      Specified by:
        `deployTaskDef` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getAllTaskDef

          public List<org.kie.internal.task.api.model.TaskDef> getAllTaskDef(String filter)

      Specified by:
        `getAllTaskDef` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getGroupById

          public org.kie.api.task.model.Group getGroupById(String groupId)

      Specified by:
        `getGroupById` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getGroups

          public List<org.kie.api.task.model.Group> getGroups()

      Specified by:
        `getGroups` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTaskDefById

          public org.kie.internal.task.api.model.TaskDef getTaskDefById(String id)

      Specified by:
        `getTaskDefById` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getUserById

          public org.kie.api.task.model.User getUserById(String userId)

      Specified by:
        `getUserById` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getUsers

          public List<org.kie.api.task.model.User> getUsers()

      Specified by:
        `getUsers` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### addTask

          public long addTask(org.kie.api.task.model.Task task,
                              org.kie.internal.task.api.model.ContentData data)

      Specified by:
        `addTask` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### remove

          public void remove(long taskId,
                             String userId)

      Specified by:
        `remove` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### removeGroup

          public void removeGroup(String groupId)

      Specified by:
        `removeGroup` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### removeTasks

          public int removeTasks(List<org.kie.api.task.model.TaskSummary> tasks)

      Specified by:
        `removeTasks` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### removeUser

          public void removeUser(String userId)

      Specified by:
        `removeUser` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### setFault

          public void setFault(long taskId,
                               String userId,
                               org.kie.internal.task.api.model.FaultData fault)

      Specified by:
        `setFault` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### setOutput

          public void setOutput(long taskId,
                                String userId,
                                Object outputContentData)

      Specified by:
        `setOutput` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### setPriority

          public void setPriority(long taskId,
                                  int priority)

      Specified by:
        `setPriority` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### setTaskNames

          public void setTaskNames(long taskId,
                                   List<org.kie.api.task.model.I18NText> taskNames)

      Specified by:
        `setTaskNames` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### undeployTaskDef

          public void undeployTaskDef(String id)

      Specified by:
        `undeployTaskDef` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTaskEventsById

          public List<org.kie.internal.task.api.model.TaskEvent> getTaskEventsById(long taskId)

      Specified by:
        `getTaskEventsById` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getUserInfo

          public org.kie.internal.task.api.UserInfo getUserInfo()

      Specified by:
        `getUserInfo` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### setUserInfo

          public void setUserInfo(org.kie.internal.task.api.UserInfo userInfo)

      Specified by:
        `setUserInfo` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### addUsersAndGroups

          public void addUsersAndGroups(Map<String,org.kie.api.task.model.User> users,
                                        Map<String,org.kie.api.task.model.Group> groups)

      Specified by:
        `addUsersAndGroups` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### removeAllTasks

          public int removeAllTasks()

      Specified by:
        `removeAllTasks` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### addContent

          public long addContent(long taskId,
                                 org.kie.api.task.model.Content content)

      Specified by:
        `addContent` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### addContent

          public long addContent(long taskId,
                                 Map<String,Object> params)

      Specified by:
        `addContent` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### deleteContent

          public void deleteContent(long taskId,
                                    long contentId)

      Specified by:
        `deleteContent` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getAllContentByTaskId

          public List<org.kie.api.task.model.Content> getAllContentByTaskId(long taskId)

      Specified by:
        `getAllContentByTaskId` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### addAttachment

          public long addAttachment(long taskId,
                                    org.kie.api.task.model.Attachment attachment,
                                    org.kie.api.task.model.Content content)

      Specified by:
        `addAttachment` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### deleteAttachment

          public void deleteAttachment(long taskId,
                                       long attachmentId)

      Specified by:
        `deleteAttachment` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getAllAttachmentsByTaskId

          public List<org.kie.api.task.model.Attachment> getAllAttachmentsByTaskId(long taskId)

      Specified by:
        `getAllAttachmentsByTaskId` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### removeTaskEventsById

          public void removeTaskEventsById(long taskId)

      Specified by:
        `removeTaskEventsById` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getOrganizationalEntityById

          public org.kie.api.task.model.OrganizationalEntity getOrganizationalEntityById(String entityId)

      Specified by:
        `getOrganizationalEntityById` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### setExpirationDate

          public void setExpirationDate(long taskId,
                                        Date date)

      Specified by:
        `setExpirationDate` in interface `org.kie.api.task.TaskService`

    - #### setDescriptions

          public void setDescriptions(long taskId,
                                      List<org.kie.api.task.model.I18NText> descriptions)

      Specified by:
        `setDescriptions` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### setSkipable

          public void setSkipable(long taskId,
                                  boolean skipable)

      Specified by:
        `setSkipable` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### setSubTaskStrategy

          public void setSubTaskStrategy(long taskId,
                                         org.kie.internal.task.api.model.SubTasksStrategy strategy)

      Specified by:
        `setSubTaskStrategy` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getPriority

          public int getPriority(long taskId)

      Specified by:
        `getPriority` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getExpirationDate

          public Date getExpirationDate(long taskId)

      Specified by:
        `getExpirationDate` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getDescriptions

          public List<org.kie.api.task.model.I18NText> getDescriptions(long taskId)

      Specified by:
        `getDescriptions` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### isSkipable

          public boolean isSkipable(long taskId)

      Specified by:
        `isSkipable` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getSubTaskStrategy

          public org.kie.internal.task.api.model.SubTasksStrategy getSubTaskStrategy(long taskId)

      Specified by:
        `getSubTaskStrategy` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getTaskInstanceById

          public org.kie.api.task.model.Task getTaskInstanceById(long taskId)

      Specified by:
        `getTaskInstanceById` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getCompletedTaskByUserId

          public int getCompletedTaskByUserId(String userId)

      Specified by:
        `getCompletedTaskByUserId` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getPendingTaskByUserId

          public int getPendingTaskByUserId(String userId)

      Specified by:
        `getPendingTaskByUserId` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### addComment

          public Long addComment(long taskId,
                                 org.kie.api.task.model.Comment comment)

      Specified by:
        `addComment` in interface `org.kie.api.task.TaskService`

    - #### deleteComment

          public void deleteComment(long taskId,
                                    long commentId)

      Specified by:
        `deleteComment` in interface `org.kie.api.task.TaskService`

    - #### getAllCommentsByTaskId

          public List<org.kie.api.task.model.Comment> getAllCommentsByTaskId(long taskId)

      Specified by:
        `getAllCommentsByTaskId` in interface `org.kie.api.task.TaskService`

    - #### getCommentById

          public org.kie.api.task.model.Comment getCommentById(long commentId)

      Specified by:
        `getCommentById` in interface `org.kie.api.task.TaskService`

    - #### addMarshallerContext

          public void addMarshallerContext(String ownerId,
                                           org.kie.internal.task.api.ContentMarshallerContext context)

      Specified by:
        `addMarshallerContext` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### removeMarshallerContext

          public void removeMarshallerContext(String ownerId)

      Specified by:
        `removeMarshallerContext` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getMarshallerContext

          public org.kie.internal.task.api.ContentMarshallerContext getMarshallerContext(org.kie.api.task.model.Task task)

      Specified by:
        `getMarshallerContext` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### taskSummaryQuery

          public org.kie.internal.task.query.TaskSummaryQueryBuilder taskSummaryQuery(String userId)

      Specified by:
        `taskSummaryQuery` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### executeReminderForTask

          public void executeReminderForTask(long taskId,
                                             String initiator)

      Specified by:
        `executeReminderForTask` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### addComment

          public Long addComment(long taskId,
                                 String addedByUserId,
                                 String commentText)

      Specified by:
        `addComment` in interface `org.kie.api.task.TaskService`

    - #### setDocumentContentFromUser

          public long setDocumentContentFromUser(long taskId,
                                                 String userId,
                                                 byte[] byteContent)

      Specified by:
        `setDocumentContentFromUser` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### addOutputContentFromUser

          public long addOutputContentFromUser(long taskId,
                                               String userId,
                                               Map<String,Object> params)

      Specified by:
        `addOutputContentFromUser` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getContentByIdForUser

          public org.kie.api.task.model.Content getContentByIdForUser(long contentId,
                                                                      String userId)

      Specified by:
        `getContentByIdForUser` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### getOutputContentMapForUser

          public Map<String,Object> getOutputContentMapForUser(long taskId,
                                                               String userId)

      Specified by:
        `getOutputContentMapForUser` in interface `org.kie.internal.task.api.InternalTaskService`

    - #### addContentFromUser

          public long addContentFromUser(long taskId,
                                         String userId,
                                         Map<String,Object> params)

      Specified by:
        `addContentFromUser` in interface `org.kie.internal.task.api.InternalTaskService`

Copyright © 2001–2021 JBoss by Red Hat. All rights reserved.