org.jbpm.kie.services.impl.admin

## Class UserTaskAdminServiceImpl

- java.lang.Object
- - org.jbpm.kie.services.impl.admin.UserTaskAdminServiceImpl

- All Implemented Interfaces:
    UserTaskAdminService

      public class UserTaskAdminServiceImpl
      extends Object
      implements UserTaskAdminService

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static int` | `ADMIN`
    `static int` | `EXCL_OWNER`
    `static int` | `POT_OWNER`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `UserTaskAdminServiceImpl()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `acknowledgeError(String... errorId)` Acknowledge given error that it was reviewed and understood
    `void` | `addBusinessAdmins(long taskId, boolean removeExisting, org.kie.api.task.model.OrganizationalEntity... orgEntities)` Adds new business admin for a given task.
    `void` | `addExcludedOwners(long taskId, boolean removeExisting, org.kie.api.task.model.OrganizationalEntity... orgEntities)` Adds new excluded owners for a given task.
    `protected void` | `addPeopleAssignment(long taskId, boolean removeExisting, int type, org.kie.api.task.model.OrganizationalEntity... orgEntities)`
    `void` | `addPotentialOwners(long taskId, boolean removeExisting, org.kie.api.task.model.OrganizationalEntity... orgEntities)` Adds new potential owners for a given task.
    `void` | `addTaskInput(long taskId, String name, Object value)` Adds new item to task input variables.
    `void` | `addTaskInputs(long taskId, Map<String,Object> data)` Adds new items to task input variables.
    `protected void` | `applyQueryContext(Map<String,Object> params, org.kie.api.runtime.query.QueryContext queryContext)`
    `org.kie.internal.task.api.model.EmailNotification` | `buildEmailNotification(String subjectStr, List<org.kie.api.task.model.OrganizationalEntity> recipients, String bodyStr, String fromStr, String replyToStr)` Builds email notification based on given parameters that can be used as argument for notifyWhenNotStarted and notifyWhenNotCompleted methods
    `void` | `cancelNotification(long taskId, long notificationId)` Cancels given notification on a task
    `void` | `cancelReassignment(long taskId, long reassignmentId)` Cancels given reassignment on a task
    `protected List<Boolean>` | `getAckMode(boolean includeAcknowledged)`
    `org.kie.internal.runtime.error.ExecutionError` | `getError(String errorId)` Returns execution error identified by given error id
    `List<org.kie.internal.runtime.error.ExecutionError>` | `getErrors(boolean includeAcknowledged, org.kie.api.runtime.query.QueryContext queryContext)` Returns execution errors that are classified as task type errors
    `List<org.kie.internal.runtime.error.ExecutionError>` | `getErrorsByTaskId(long taskId, boolean includeAcknowledged, org.kie.api.runtime.query.QueryContext queryContext)` Returns execution errors for given task id
    `List<org.kie.internal.runtime.error.ExecutionError>` | `getErrorsByTaskName(String taskName, boolean includeAcknowledged, org.kie.api.runtime.query.QueryContext queryContext)` Returns execution errors for given task name
    `List<org.kie.internal.runtime.error.ExecutionError>` | `getErrorsByTaskName(String processId, String taskName, boolean includeAcknowledged, org.kie.api.runtime.query.QueryContext queryContext)` Returns execution errors for given task name and process id
    `List<org.kie.internal.runtime.error.ExecutionError>` | `getErrorsByTaskName(String deploymentId, String processId, String taskName, boolean includeAcknowledged, org.kie.api.runtime.query.QueryContext queryContext)` Returns execution errors for given task name, process id and deployment id
    `Collection<TaskNotification>` | `getTaskNotifications(long taskId, boolean activeOnly)` Returns task notifications scheduled for given task
    `Collection<TaskReassignment>` | `getTaskReassignments(long taskId, boolean activeOnly)` Returns task reassignments scheduled for given task
    `protected Long` | `notify(long taskId, String timeExpression, org.kie.internal.task.api.TaskDeadlinesService.DeadlineType type, org.kie.internal.task.api.model.Notification notification)`
    `Long` | `notifyWhenNotCompleted(long taskId, String timeExpression, org.kie.internal.task.api.model.Notification notification)` Sends notification (of notification type) to given recipients in case task was not completed before time given as timeExpression elapses.
    `Long` | `notifyWhenNotStarted(long taskId, String timeExpression, org.kie.internal.task.api.model.Notification notification)` Sends notification (of notification type) to given recipients in case task was not started before time given as timeExpression elapses.
    `protected Long` | `reassign(long taskId, String timeExpression, org.kie.internal.task.api.TaskDeadlinesService.DeadlineType type, org.kie.api.task.model.OrganizationalEntity... orgEntities)`
    `Long` | `reassignWhenNotCompleted(long taskId, String timeExpression, org.kie.api.task.model.OrganizationalEntity... orgEntities)` Reassign automatically a task in case it was not completed before time given as timeExpression elapses.
    `Long` | `reassignWhenNotStarted(long taskId, String timeExpression, org.kie.api.task.model.OrganizationalEntity... orgEntities)` Reassign automatically a task in case it was not started before time given as timeExpression elapses.
    `void` | `removeBusinessAdmins(long taskId, org.kie.api.task.model.OrganizationalEntity... orgEntities)` Remove existing business admin from given task.
    `void` | `removeExcludedOwners(long taskId, org.kie.api.task.model.OrganizationalEntity... orgEntities)` Remove existing excluded owners from given task.
    `protected void` | `removePeopleAssignment(long taskId, int type, org.kie.api.task.model.OrganizationalEntity... orgEntities)`
    `void` | `removePotentialOwners(long taskId, org.kie.api.task.model.OrganizationalEntity... orgEntities)` Remove existing potential owners from given task.
    `void` | `removeTaskInputs(long taskId, String... name)` Removes one or more input variables from a task.
    `void` | `removeTaskOutputs(long taskId, String... name)` Removes one or more output variables from a task.
    `void` | `setCommandService(TransactionalCommandService commandService)`
    `void` | `setIdentityProvider(org.kie.internal.identity.IdentityProvider identityProvider)`
    `void` | `setRuntimeDataService(RuntimeDataService runtimeDataService)`
    `void` | `setUserTaskService(UserTaskService userTaskService)`

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

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

- - ### Field Detail

    - #### POT_OWNER

          public static final int POT_OWNER

      See Also:
        Constant Field Values

    - #### EXCL_OWNER

          public static final int EXCL_OWNER

      See Also:
        Constant Field Values

    - #### ADMIN

          public static final int ADMIN

      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### UserTaskAdminServiceImpl

          public UserTaskAdminServiceImpl()

  - ### Method Detail

    - #### setUserTaskService

          public void setUserTaskService(UserTaskService userTaskService)

    - #### setRuntimeDataService

          public void setRuntimeDataService(RuntimeDataService runtimeDataService)

    - #### setIdentityProvider

          public void setIdentityProvider(org.kie.internal.identity.IdentityProvider identityProvider)

    - #### setCommandService

          public void setCommandService(TransactionalCommandService commandService)

    - #### addPotentialOwners

          public void addPotentialOwners(long taskId,
                                         boolean removeExisting,
                                         org.kie.api.task.model.OrganizationalEntity... orgEntities)
                                  throws TaskNotFoundException

      Description copied from interface: `UserTaskAdminService`
      Adds new potential owners for a given task. Can be instructed to remove existing potential owners which means that the task will be released in case it was claimed already. Task must be in active state.
      Specified by:
        `addPotentialOwners` in interface `UserTaskAdminService`
      Parameters:
        `taskId` - unique task id
        `removeExisting` - specifies if existing potential owners should be removed
        `orgEntities` - one or more potential owner to be added to a task
      Throws:
        `TaskNotFoundException` - thrown when there is no task with given id

    - #### addExcludedOwners

          public void addExcludedOwners(long taskId,
                                        boolean removeExisting,
                                        org.kie.api.task.model.OrganizationalEntity... orgEntities)
                                 throws TaskNotFoundException

      Description copied from interface: `UserTaskAdminService`
      Adds new excluded owners for a given task. Can be instructed to remove existing excluded owners. Task must be in active state.
      Specified by:
        `addExcludedOwners` in interface `UserTaskAdminService`
      Parameters:
        `taskId` - unique task id
        `removeExisting` - specifies if existing excluded owners should be removed
        `orgEntities` - one or more excluded owner to be added to a task
      Throws:
        `TaskNotFoundException` - thrown when there is no task with given id

    - #### addBusinessAdmins

          public void addBusinessAdmins(long taskId,
                                        boolean removeExisting,
                                        org.kie.api.task.model.OrganizationalEntity... orgEntities)
                                 throws TaskNotFoundException

      Description copied from interface: `UserTaskAdminService`
      Adds new business admin for a given task. Can be instructed to remove existing business admins. Task must be in active state.
      Specified by:
        `addBusinessAdmins` in interface `UserTaskAdminService`
      Parameters:
        `taskId` - unique task id
        `removeExisting` - specifies if existing business admins should be removed
        `orgEntities` - one or more business admin to be added to a task
      Throws:
        `TaskNotFoundException` - thrown when there is no task with given id

    - #### removePotentialOwners

          public void removePotentialOwners(long taskId,
                                            org.kie.api.task.model.OrganizationalEntity... orgEntities)
                                     throws TaskNotFoundException

      Description copied from interface: `UserTaskAdminService`
      Remove existing potential owners from given task. Task must be in active state.
      Specified by:
        `removePotentialOwners` in interface `UserTaskAdminService`
      Parameters:
        `taskId` - unique task id
        `orgEntities` - one or more potential owner to be removed from a task
      Throws:
        `TaskNotFoundException` - thrown when there is no task with given id

    - #### removeExcludedOwners

          public void removeExcludedOwners(long taskId,
                                           org.kie.api.task.model.OrganizationalEntity... orgEntities)
                                    throws TaskNotFoundException

      Description copied from interface: `UserTaskAdminService`
      Remove existing excluded owners from given task. Task must be in active state.
      Specified by:
        `removeExcludedOwners` in interface `UserTaskAdminService`
      Parameters:
        `taskId` - unique task id
        `orgEntities` - one or more excluded owner to be removed from a task
      Throws:
        `TaskNotFoundException` - thrown when there is no task with given id

    - #### removeBusinessAdmins

          public void removeBusinessAdmins(long taskId,
                                           org.kie.api.task.model.OrganizationalEntity... orgEntities)
                                    throws TaskNotFoundException,
                                           IllegalStateException

      Description copied from interface: `UserTaskAdminService`
      Remove existing business admin from given task. Task must be in active state.
      Specified by:
        `removeBusinessAdmins` in interface `UserTaskAdminService`
      Parameters:
        `taskId` - unique task id
        `orgEntities` - one or more business admin to be removed from a task
      Throws:
        `TaskNotFoundException` - thrown when there is no task with given id
        `IllegalStateException` - in case there are no business admins left on a task - there must be at least one business admin

    - #### addTaskInput

          public void addTaskInput(long taskId,
                                   String name,
                                   Object value)
                            throws TaskNotFoundException

      Description copied from interface: `UserTaskAdminService`
      Adds new item to task input variables.
      Specified by:
        `addTaskInput` in interface `UserTaskAdminService`
      Parameters:
        `taskId` - unique task id
        `name` - name of the input variable to be added
        `value` - value of the input variable
      Throws:
        `TaskNotFoundException` - thrown when there is no task with given id

    - #### addTaskInputs

          public void addTaskInputs(long taskId,
                                    Map<String,Object> data)
                             throws TaskNotFoundException

      Description copied from interface: `UserTaskAdminService`
      Adds new items to task input variables.
      Specified by:
        `addTaskInputs` in interface `UserTaskAdminService`
      Parameters:
        `taskId` - unique task id
        `data` - map of key (name of the variable) and value (value of the variable)
      Throws:
        `TaskNotFoundException` - thrown when there is no task with given id

    - #### removeTaskInputs

          public void removeTaskInputs(long taskId,
                                       String... name)
                                throws TaskNotFoundException

      Description copied from interface: `UserTaskAdminService`
      Removes one or more input variables from a task.
      Specified by:
        `removeTaskInputs` in interface `UserTaskAdminService`
      Parameters:
        `taskId` - unique task id
        `name` - name(s) of the input variables to be removed
      Throws:
        `TaskNotFoundException` - thrown when there is no task with given id

    - #### removeTaskOutputs

          public void removeTaskOutputs(long taskId,
                                        String... name)
                                 throws TaskNotFoundException

      Description copied from interface: `UserTaskAdminService`
      Removes one or more output variables from a task.
      Specified by:
        `removeTaskOutputs` in interface `UserTaskAdminService`
      Parameters:
        `taskId` - unique task id
        `name` - name(s) of the output variables to be removed
      Throws:
        `TaskNotFoundException` - thrown when there is no task with given id

    - #### reassignWhenNotStarted

          public Long reassignWhenNotStarted(long taskId,
                                             String timeExpression,
                                             org.kie.api.task.model.OrganizationalEntity... orgEntities)
                                      throws TaskNotFoundException

      Description copied from interface: `UserTaskAdminService`
      Reassign automatically a task in case it was not started before time given as timeExpression elapses.
      Specified by:
        `reassignWhenNotStarted` in interface `UserTaskAdminService`
      Parameters:
        `taskId` - unique task id
        `timeExpression` - time expression in duration format as 2s, 5h, 7d
        `orgEntities` - users/groups that will be reassigned to after conditions are met
      Throws:
        `TaskNotFoundException` - thrown when there is no task with given id

    - #### reassignWhenNotCompleted

          public Long reassignWhenNotCompleted(long taskId,
                                               String timeExpression,
                                               org.kie.api.task.model.OrganizationalEntity... orgEntities)
                                        throws TaskNotFoundException

      Description copied from interface: `UserTaskAdminService`
      Reassign automatically a task in case it was not completed before time given as timeExpression elapses.
      Specified by:
        `reassignWhenNotCompleted` in interface `UserTaskAdminService`
      Parameters:
        `taskId` - unique task id
        `timeExpression` - time expression in duration format as 2s, 5h, 7d
        `orgEntities` - users/groups that will be reassigned to after conditions are met
      Throws:
        `TaskNotFoundException` - thrown when there is no task with given id

    - #### notifyWhenNotStarted

          public Long notifyWhenNotStarted(long taskId,
                                           String timeExpression,
                                           org.kie.internal.task.api.model.Notification notification)
                                    throws TaskNotFoundException

      Description copied from interface: `UserTaskAdminService`
      Sends notification (of notification type) to given recipients in case task was not started before time given as timeExpression elapses.
      Specified by:
        `notifyWhenNotStarted` in interface `UserTaskAdminService`
      Parameters:
        `taskId` - unique task id
        `timeExpression` - time expression in duration format as 2s, 5h, 7d
        `notification` - actual notification to be sent
      Throws:
        `TaskNotFoundException` - thrown when there is no task with given id

    - #### notifyWhenNotCompleted

          public Long notifyWhenNotCompleted(long taskId,
                                             String timeExpression,
                                             org.kie.internal.task.api.model.Notification notification)
                                      throws TaskNotFoundException

      Description copied from interface: `UserTaskAdminService`
      Sends notification (of notification type) to given recipients in case task was not completed before time given as timeExpression elapses.
      Specified by:
        `notifyWhenNotCompleted` in interface `UserTaskAdminService`
      Parameters:
        `taskId` - unique task id
        `timeExpression` - time expression in duration format as 2s, 5h, 7d
        `notification` - actual notification to be sent
      Throws:
        `TaskNotFoundException` - thrown when there is no task with given id

    - #### getTaskReassignments

          public Collection<TaskReassignment> getTaskReassignments(long taskId,
                                                                   boolean activeOnly)
                                                            throws TaskNotFoundException

      Description copied from interface: `UserTaskAdminService`
      Returns task reassignments scheduled for given task
      Specified by:
        `getTaskReassignments` in interface `UserTaskAdminService`
      Parameters:
        `taskId` - unique task id
        `activeOnly` - determines if only active (not yet fired) should be returned
      Returns:
        returns list of task reassignments for given task
      Throws:
        `TaskNotFoundException` - thrown when there is no task with given id

    - #### getTaskNotifications

          public Collection<TaskNotification> getTaskNotifications(long taskId,
                                                                   boolean activeOnly)
                                                            throws TaskNotFoundException

      Description copied from interface: `UserTaskAdminService`
      Returns task notifications scheduled for given task
      Specified by:
        `getTaskNotifications` in interface `UserTaskAdminService`
      Parameters:
        `taskId` - unique task id
        `activeOnly` - determines if only active (not yet fired) should be returned
      Returns:
        returns list of task notifications for given task
      Throws:
        `TaskNotFoundException` - thrown when there is no task with given id

    - #### cancelNotification

          public void cancelNotification(long taskId,
                                         long notificationId)
                                  throws TaskNotFoundException

      Description copied from interface: `UserTaskAdminService`
      Cancels given notification on a task
      Specified by:
        `cancelNotification` in interface `UserTaskAdminService`
      Parameters:
        `taskId` - unique task id
        `notificationId` - unique notification id
      Throws:
        `TaskNotFoundException` - thrown when there is no task with given id

    - #### cancelReassignment

          public void cancelReassignment(long taskId,
                                         long reassignmentId)
                                  throws TaskNotFoundException

      Description copied from interface: `UserTaskAdminService`
      Cancels given reassignment on a task
      Specified by:
        `cancelReassignment` in interface `UserTaskAdminService`
      Parameters:
        `taskId` - unique task id
        `reassignmentId` - unique reassignment id
      Throws:
        `TaskNotFoundException` - thrown when there is no task with given id

    - #### buildEmailNotification

          public org.kie.internal.task.api.model.EmailNotification buildEmailNotification(String subjectStr,
                                                                                          List<org.kie.api.task.model.OrganizationalEntity> recipients,
                                                                                          String bodyStr,
                                                                                          String fromStr,
                                                                                          String replyToStr)

      Description copied from interface: `UserTaskAdminService`
      Builds email notification based on given parameters that can be used as argument for notifyWhenNotStarted and notifyWhenNotCompleted methods
      Specified by:
        `buildEmailNotification` in interface `UserTaskAdminService`
      Parameters:
        `subjectStr` - email subject
        `recipients` - list of recipients to be included in the notification, must be at least one
        `bodyStr` - email body, can reference task variables
        `fromStr` - user who sends the email
        `replyToStr` - optional reply to address
      Returns:
        completely configured email notification instance

    - #### getErrors

          public List<org.kie.internal.runtime.error.ExecutionError> getErrors(boolean includeAcknowledged,
                                                                               org.kie.api.runtime.query.QueryContext queryContext)

      Description copied from interface: `UserTaskAdminService`
      Returns execution errors that are classified as task type errors
      Specified by:
        `getErrors` in interface `UserTaskAdminService`
      Parameters:
        `includeAcknowledged` - indicates whether to include acknowledged errors or not
        `queryContext` - control parameters for pagination
      Returns:
        list of found errors

    - #### getErrorsByTaskId

          public List<org.kie.internal.runtime.error.ExecutionError> getErrorsByTaskId(long taskId,
                                                                                       boolean includeAcknowledged,
                                                                                       org.kie.api.runtime.query.QueryContext queryContext)

      Description copied from interface: `UserTaskAdminService`
      Returns execution errors for given task id
      Specified by:
        `getErrorsByTaskId` in interface `UserTaskAdminService`
      Parameters:
        `taskId` - unique task id
        `includeAcknowledged` - indicates whether to include acknowledged errors or not
        `queryContext` - control parameters for pagination
      Returns:
        list of found errors

    - #### getErrorsByTaskName

          public List<org.kie.internal.runtime.error.ExecutionError> getErrorsByTaskName(String taskName,
                                                                                         boolean includeAcknowledged,
                                                                                         org.kie.api.runtime.query.QueryContext queryContext)

      Description copied from interface: `UserTaskAdminService`
      Returns execution errors for given task name
      Specified by:
        `getErrorsByTaskName` in interface `UserTaskAdminService`
      Parameters:
        `taskName` - name of the task
        `includeAcknowledged` - indicates whether to include acknowledged errors or not
        `queryContext` - control parameters for pagination
      Returns:
        list of found errors

    - #### getErrorsByTaskName

          public List<org.kie.internal.runtime.error.ExecutionError> getErrorsByTaskName(String processId,
                                                                                         String taskName,
                                                                                         boolean includeAcknowledged,
                                                                                         org.kie.api.runtime.query.QueryContext queryContext)

      Description copied from interface: `UserTaskAdminService`
      Returns execution errors for given task name and process id
      Specified by:
        `getErrorsByTaskName` in interface `UserTaskAdminService`
      Parameters:
        `processId` - process id of the process that task belongs to
        `taskName` - name of the task
        `includeAcknowledged` - indicates whether to include acknowledged errors or not
        `queryContext` - control parameters for pagination
      Returns:
        list of found errors

    - #### getErrorsByTaskName

          public List<org.kie.internal.runtime.error.ExecutionError> getErrorsByTaskName(String deploymentId,
                                                                                         String processId,
                                                                                         String taskName,
                                                                                         boolean includeAcknowledged,
                                                                                         org.kie.api.runtime.query.QueryContext queryContext)

      Description copied from interface: `UserTaskAdminService`
      Returns execution errors for given task name, process id and deployment id
      Specified by:
        `getErrorsByTaskName` in interface `UserTaskAdminService`
      Parameters:
        `deploymentId` - deployment id that contains given process
        `processId` - process id of the process that task belongs to
        `taskName` - name of the task
        `includeAcknowledged` - indicates whether to include acknowledged errors or not
        `queryContext` - control parameters for pagination
      Returns:
        list of found errors

    - #### acknowledgeError

          public void acknowledgeError(String... errorId)
                                throws ExecutionErrorNotFoundException

      Description copied from interface: `UserTaskAdminService`
      Acknowledge given error that it was reviewed and understood
      Specified by:
        `acknowledgeError` in interface `UserTaskAdminService`
      Parameters:
        `errorId` - unique id of the error
      Throws:
        `ExecutionErrorNotFoundException` - thrown when there is no unacknowledged error with that id

    - #### getError

          public org.kie.internal.runtime.error.ExecutionError getError(String errorId)
                                                                 throws ExecutionErrorNotFoundException

      Description copied from interface: `UserTaskAdminService`
      Returns execution error identified by given error id
      Specified by:
        `getError` in interface `UserTaskAdminService`
      Parameters:
        `errorId` - unique id of the error
      Returns:
        returns execution error instance
      Throws:
        `ExecutionErrorNotFoundException` - is thrown in case no error was found for given error id

    - #### addPeopleAssignment

          protected void addPeopleAssignment(long taskId,
                                             boolean removeExisting,
                                             int type,
                                             org.kie.api.task.model.OrganizationalEntity... orgEntities)
                                      throws TaskNotFoundException

      Throws:
        `TaskNotFoundException`

    - #### removePeopleAssignment

          protected void removePeopleAssignment(long taskId,
                                                int type,
                                                org.kie.api.task.model.OrganizationalEntity... orgEntities)
                                         throws TaskNotFoundException

      Throws:
        `TaskNotFoundException`

    - #### reassign

          protected Long reassign(long taskId,
                                  String timeExpression,
                                  org.kie.internal.task.api.TaskDeadlinesService.DeadlineType type,
                                  org.kie.api.task.model.OrganizationalEntity... orgEntities)
                           throws TaskNotFoundException

      Throws:
        `TaskNotFoundException`

    - #### notify

          protected Long notify(long taskId,
                                String timeExpression,
                                org.kie.internal.task.api.TaskDeadlinesService.DeadlineType type,
                                org.kie.internal.task.api.model.Notification notification)
                         throws TaskNotFoundException

      Throws:
        `TaskNotFoundException`

    - #### applyQueryContext

          protected void applyQueryContext(Map<String,Object> params,
                                           org.kie.api.runtime.query.QueryContext queryContext)

    - #### getAckMode

          protected List<Boolean> getAckMode(boolean includeAcknowledged)

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