org.jbpm.kie.services.impl

## Class UserTaskServiceImpl

- java.lang.Object
- - org.jbpm.kie.services.impl.UserTaskServiceImpl

- All Implemented Interfaces:
    VariablesAware, UserTaskService
  Direct Known Subclasses:
    UserTaskServiceCDIImpl, UserTaskServiceEJBImpl

      public class UserTaskServiceImpl
      extends Object
      implements UserTaskService, VariablesAware

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `UserTaskServiceImpl()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `activate(Long taskId, String userId)` Activate the task, i.e. set the task to status Ready.
    `Long` | `addAttachment(Long taskId, String userId, String name, Object attachment)` Add attachment to a task
    `Long` | `addComment(Long taskId, String text, String addedBy, Date addedOn)` Add comment to a task
    `void` | `claim(Long taskId, String userId)` Claim responsibility for a task, i.e. set the task to status Reserved
    `void` | `complete(Long taskId, String userId, Map<String,Object> params)` Complete a task with the given data
    `void` | `completeAutoProgress(Long taskId, String userId, Map<String,Object> params)` Complete a task with the given data.
    `void` | `delegate(Long taskId, String userId, String targetUserId)` Delegate a task from userId to targetUserId
    `void` | `deleteAttachment(Long taskId, Long attachmentId)` Delete attachment from a task
    `void` | `deleteComment(Long taskId, Long commentId)` Deletes comment from a task
    `void` | `deleteContent(Long taskId, Long contentId)` Deletes content given by `contentId` from given task
    `protected void` | `disposeRuntimeEngine(org.kie.api.runtime.manager.RuntimeManager manager, org.kie.api.runtime.manager.RuntimeEngine engine)`
    `<T> T` | `execute(String deploymentId, org.kie.api.command.Command<T> command)` Executes provided command on the underlying command executor
    `<T> T` | `execute(String deploymentId, org.kie.api.runtime.manager.Context<?> context, org.kie.api.command.Command<T> command)` Executes provided command on the underlying command executor
    `void` | `exit(Long taskId, String userId)` Requesting application is no longer interested in the task output
    `void` | `fail(Long taskId, String userId, Map<String,Object> faultData)` Actual owner completes the execution of the task raising a fault.
    `void` | `forward(Long taskId, String userId, String targetEntityId)` Forward the task to another organization entity.
    `org.kie.api.task.model.Attachment` | `getAttachmentById(Long taskId, Long attachmentId)` Get attachment by identifier
    `Object` | `getAttachmentContentById(Long taskId, Long attachmentId)` Get attachment's content by identifier
    `List<org.kie.api.task.model.Attachment>` | `getAttachmentsByTaskId(Long taskId)` Get attachments for a task
    `org.kie.api.task.model.Comment` | `getCommentById(Long taskId, Long commentId)` Get comment by identifier
    `List<org.kie.api.task.model.Comment>` | `getCommentsByTaskId(Long taskId)` Get comments for a task
    `protected org.kie.internal.task.api.InternalTaskService` | `getInternalTaskService()`
    `protected org.kie.api.runtime.manager.RuntimeManager` | `getRuntimeManager(String deploymentId, org.kie.api.command.Command<?> command)`
    `protected org.kie.api.runtime.manager.RuntimeManager` | `getRuntimeManager(UserTaskInstanceDesc task)`
    `org.kie.api.task.model.Task` | `getTask(Long taskId)` Returns task instance
    `Map<String,Object>` | `getTaskInputContentByTaskId(Long taskId)` Returns task input data of a task
    `Map<String,Object>` | `getTaskOutputContentByTaskId(Long taskId)` Returns task output data currently stored, might be null of no data is stored
    `void` | `nominate(Long taskId, String userId, List<org.kie.api.task.model.OrganizationalEntity> potentialOwners)` Nominate a task to be handled by potentialOwners
    `<T> T` | `process(T variables, ClassLoader cl)` Generic processing method that might be simply returning same instance of variables if no processing is required.
    `void` | `release(Long taskId, String userId)` Release a previously claimed task
    `void` | `resume(Long taskId, String userId)` Resume a previously suspended task
    `Long` | `saveContent(Long taskId, Map<String,Object> values)` Saves gives values as content of a task, applies to task output as input cannot be altered
    `void` | `setDataService(RuntimeDataService dataService)`
    `void` | `setDeploymentService(DeploymentService deploymentService)`
    `void` | `setDescription(Long taskId, String description)` Sets description of the task
    `void` | `setExpirationDate(Long taskId, Date date)` Sets expiration date of a task to given value
    `void` | `setName(Long taskId, String name)` Sets name of the task
    `void` | `setNonProcessScopedTaskService(org.kie.internal.task.api.InternalTaskService nonProcessScopedTaskService)`
    `void` | `setPriority(Long taskId, int priority)` Sets priority of a task to given value
    `void` | `setSkipable(Long taskId, boolean skipable)` Sets skipable property of a task to given value
    `void` | `skip(Long taskId, String userId)` Skip a claimed task
    `void` | `start(Long taskId, String userId)` Start the execution of the task, i.e. set the task to status InProgress.
    `void` | `stop(Long taskId, String userId)` Cancel/stop the processing of the task.
    `void` | `suspend(Long taskId, String userId)` Suspend a claimed task.

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

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

- - ### Constructor Detail

    - #### UserTaskServiceImpl

          public UserTaskServiceImpl()

  - ### Method Detail

    - #### setDeploymentService

          public void setDeploymentService(DeploymentService deploymentService)

    - #### setDataService

          public void setDataService(RuntimeDataService dataService)

    - #### setNonProcessScopedTaskService

          public void setNonProcessScopedTaskService(org.kie.internal.task.api.InternalTaskService nonProcessScopedTaskService)

    - #### getInternalTaskService

          protected org.kie.internal.task.api.InternalTaskService getInternalTaskService()

    - #### getRuntimeManager

          protected org.kie.api.runtime.manager.RuntimeManager getRuntimeManager(UserTaskInstanceDesc task)

    - #### getRuntimeManager

          protected org.kie.api.runtime.manager.RuntimeManager getRuntimeManager(String deploymentId,
                                                                                 org.kie.api.command.Command<?> command)

    - #### activate

          public void activate(Long taskId,
                               String userId)

      Description copied from interface: `UserTaskService`
      Activate the task, i.e. set the task to status Ready.
      Specified by:
        `activate` in interface `UserTaskService`

    - #### claim

          public void claim(Long taskId,
                            String userId)

      Description copied from interface: `UserTaskService`
      Claim responsibility for a task, i.e. set the task to status Reserved
      Specified by:
        `claim` in interface `UserTaskService`

    - #### complete

          public void complete(Long taskId,
                               String userId,
                               Map<String,Object> params)

      Description copied from interface: `UserTaskService`
      Complete a task with the given data
      Specified by:
        `complete` in interface `UserTaskService`

    - #### completeAutoProgress

          public void completeAutoProgress(Long taskId,
                                           String userId,
                                           Map<String,Object> params)

      Description copied from interface: `UserTaskService`
      Complete a task with the given data. If needed, the task is automatically claimed and/or started.
      Specified by:
        `completeAutoProgress` in interface `UserTaskService`

    - #### delegate

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

      Description copied from interface: `UserTaskService`
      Delegate a task from userId to targetUserId
      Specified by:
        `delegate` in interface `UserTaskService`

    - #### exit

          public void exit(Long taskId,
                           String userId)

      Description copied from interface: `UserTaskService`
      Requesting application is no longer interested in the task output
      Specified by:
        `exit` in interface `UserTaskService`

    - #### fail

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

      Description copied from interface: `UserTaskService`
      Actual owner completes the execution of the task raising a fault. The fault illegalOperationFault is returned if the task interface defines no faults. If fault name or fault data is not set the operation returns illegalArgumentFault.
      Specified by:
        `fail` in interface `UserTaskService`

    - #### forward

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

      Description copied from interface: `UserTaskService`
      Forward the task to another organization entity. The caller has to specify the receiving organizational entity. Potential owners can only forward a task while the task is in the Ready state. For details on forwarding human tasks refer to section 4.7.3 in WS-HumanTask_v1.pdf
      Specified by:
        `forward` in interface `UserTaskService`

    - #### release

          public void release(Long taskId,
                              String userId)

      Description copied from interface: `UserTaskService`
      Release a previously claimed task
      Specified by:
        `release` in interface `UserTaskService`

    - #### resume

          public void resume(Long taskId,
                             String userId)

      Description copied from interface: `UserTaskService`
      Resume a previously suspended task
      Specified by:
        `resume` in interface `UserTaskService`

    - #### skip

          public void skip(Long taskId,
                           String userId)

      Description copied from interface: `UserTaskService`
      Skip a claimed task
      Specified by:
        `skip` in interface `UserTaskService`

    - #### start

          public void start(Long taskId,
                            String userId)

      Description copied from interface: `UserTaskService`
      Start the execution of the task, i.e. set the task to status InProgress.
      Specified by:
        `start` in interface `UserTaskService`

    - #### stop

          public void stop(Long taskId,
                           String userId)

      Description copied from interface: `UserTaskService`
      Cancel/stop the processing of the task. The task returns to the Reserved state.
      Specified by:
        `stop` in interface `UserTaskService`

    - #### suspend

          public void suspend(Long taskId,
                              String userId)

      Description copied from interface: `UserTaskService`
      Suspend a claimed task.
      Specified by:
        `suspend` in interface `UserTaskService`

    - #### nominate

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

      Description copied from interface: `UserTaskService`
      Nominate a task to be handled by potentialOwners
      Specified by:
        `nominate` in interface `UserTaskService`

    - #### setPriority

          public void setPriority(Long taskId,
                                  int priority)

      Description copied from interface: `UserTaskService`
      Sets priority of a task to given value
      Specified by:
        `setPriority` in interface `UserTaskService`

    - #### setExpirationDate

          public void setExpirationDate(Long taskId,
                                        Date date)

      Description copied from interface: `UserTaskService`
      Sets expiration date of a task to given value
      Specified by:
        `setExpirationDate` in interface `UserTaskService`

    - #### setSkipable

          public void setSkipable(Long taskId,
                                  boolean skipable)

      Description copied from interface: `UserTaskService`
      Sets skipable property of a task to given value
      Specified by:
        `setSkipable` in interface `UserTaskService`

    - #### setName

          public void setName(Long taskId,
                              String name)

      Description copied from interface: `UserTaskService`
      Sets name of the task
      Specified by:
        `setName` in interface `UserTaskService`

    - #### setDescription

          public void setDescription(Long taskId,
                                     String description)

      Description copied from interface: `UserTaskService`
      Sets description of the task
      Specified by:
        `setDescription` in interface `UserTaskService`

    - #### saveContent

          public Long saveContent(Long taskId,
                                  Map<String,Object> values)

      Description copied from interface: `UserTaskService`
      Saves gives values as content of a task, applies to task output as input cannot be altered
      Specified by:
        `saveContent` in interface `UserTaskService`
      Returns:

    - #### deleteContent

          public void deleteContent(Long taskId,
                                    Long contentId)

      Description copied from interface: `UserTaskService`
      Deletes content given by `contentId` from given task
      Specified by:
        `deleteContent` in interface `UserTaskService`

    - #### getTaskOutputContentByTaskId

          public Map<String,Object> getTaskOutputContentByTaskId(Long taskId)

      Description copied from interface: `UserTaskService`
      Returns task output data currently stored, might be null of no data is stored
      Specified by:
        `getTaskOutputContentByTaskId` in interface `UserTaskService`
      Returns:

    - #### getTaskInputContentByTaskId

          public Map<String,Object> getTaskInputContentByTaskId(Long taskId)

      Description copied from interface: `UserTaskService`
      Returns task input data of a task
      Specified by:
        `getTaskInputContentByTaskId` in interface `UserTaskService`
      Returns:

    - #### addComment

          public Long addComment(Long taskId,
                                 String text,
                                 String addedBy,
                                 Date addedOn)

      Description copied from interface: `UserTaskService`
      Add comment to a task
      Specified by:
        `addComment` in interface `UserTaskService`
      Returns:

    - #### deleteComment

          public void deleteComment(Long taskId,
                                    Long commentId)

      Description copied from interface: `UserTaskService`
      Deletes comment from a task
      Specified by:
        `deleteComment` in interface `UserTaskService`

    - #### getCommentsByTaskId

          public List<org.kie.api.task.model.Comment> getCommentsByTaskId(Long taskId)

      Description copied from interface: `UserTaskService`
      Get comments for a task
      Specified by:
        `getCommentsByTaskId` in interface `UserTaskService`
      Returns:

    - #### getCommentById

          public org.kie.api.task.model.Comment getCommentById(Long taskId,
                                                               Long commentId)

      Description copied from interface: `UserTaskService`
      Get comment by identifier
      Specified by:
        `getCommentById` in interface `UserTaskService`
      Returns:

    - #### addAttachment

          public Long addAttachment(Long taskId,
                                    String userId,
                                    String name,
                                    Object attachment)

      Description copied from interface: `UserTaskService`
      Add attachment to a task
      Specified by:
        `addAttachment` in interface `UserTaskService`
      Returns:

    - #### deleteAttachment

          public void deleteAttachment(Long taskId,
                                       Long attachmentId)

      Description copied from interface: `UserTaskService`
      Delete attachment from a task
      Specified by:
        `deleteAttachment` in interface `UserTaskService`

    - #### getAttachmentById

          public org.kie.api.task.model.Attachment getAttachmentById(Long taskId,
                                                                     Long attachmentId)

      Description copied from interface: `UserTaskService`
      Get attachment by identifier
      Specified by:
        `getAttachmentById` in interface `UserTaskService`
      Returns:

    - #### getAttachmentContentById

          public Object getAttachmentContentById(Long taskId,
                                                 Long attachmentId)

      Description copied from interface: `UserTaskService`
      Get attachment's content by identifier
      Specified by:
        `getAttachmentContentById` in interface `UserTaskService`
      Returns:

    - #### getAttachmentsByTaskId

          public List<org.kie.api.task.model.Attachment> getAttachmentsByTaskId(Long taskId)

      Description copied from interface: `UserTaskService`
      Get attachments for a task
      Specified by:
        `getAttachmentsByTaskId` in interface `UserTaskService`
      Returns:

    - #### execute

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

      Description copied from interface: `UserTaskService`
      Executes provided command on the underlying command executor
      Specified by:
        `execute` in interface `UserTaskService`
      Parameters:
        `deploymentId` - identifier of the deployment that engine should be used for execution
        `command` - actual command for execution
      Returns:
        results of command execution

    - #### execute

          public <T> T execute(String deploymentId,
                               org.kie.api.runtime.manager.Context<?> context,
                               org.kie.api.command.Command<T> command)

      Description copied from interface: `UserTaskService`
      Executes provided command on the underlying command executor
      Specified by:
        `execute` in interface `UserTaskService`
      Parameters:
        `deploymentId` - identifier of the deployment that engine should be used for execution
        `context` - context implementation to be used for getting runtime engine
        `command` - actual command for execution
      Returns:
        results of command execution

    - #### getTask

          public org.kie.api.task.model.Task getTask(Long taskId)

      Description copied from interface: `UserTaskService`
      Returns task instance
      Specified by:
        `getTask` in interface `UserTaskService`
      Returns:

    - #### process

          public <T> T process(T variables,
                               ClassLoader cl)

      Description copied from interface: `VariablesAware`
      Generic processing method that might be simply returning same instance of variables if no processing is required.
      Specified by:
        `process` in interface `VariablesAware`
      Parameters:
        `variables` - object that holds varialble(s)
        `cl` - classloader that shall be used to operate on the variables e.g. project class loader
      Returns:

    - #### disposeRuntimeEngine

          protected void disposeRuntimeEngine(org.kie.api.runtime.manager.RuntimeManager manager,
                                              org.kie.api.runtime.manager.RuntimeEngine engine)

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