ProcessManagementAPI (Bonita BPM Engine 7.3 API)

All Known Subinterfaces:

ProcessAPI, ProcessAPI, ProcessManagementAPI
```
public interface ProcessManagementAPI
```
This API deals with definition objects such as ProcessDefinition, ProcessDeploymentInfo, Category, ... It enables interaction with the lifecycle of the process definition.

Since:

6.0.0

Version:

6.3.5

Author:

Baptiste Mesta, Matthieu Chaffotte, Yanyan Liu, Hongwen Zang, Zhang Bole, Elias Ricken de Medeiros, Celine Souchet, Arthur Freycon, Emmanuel Duchastenier

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addCategoriesToProcess(long processDefinitionId, List<Long> categoryIds)` Associates the categories to the process definition.
`ActorMember`	`addGroupToActor(long actorId, long groupId)` Maps the group to the actor.
`ActorMember`	`addGroupToActor(String actorName, long groupId, ProcessDefinition processDefinition)` Maps the group to the actor of the process definition.
`void`	`addProcessDefinitionsToCategory(long categoryId, List<Long> processDefinitionIds)` Associates a list of process definitions with the category.
`void`	`addProcessDefinitionToCategory(long categoryId, long processDefinitionId)` Associates the process definition with the category.
`ActorMember`	`addRoleAndGroupToActor(long actorId, long roleId, long groupId)` Maps the role and the group to the actor.
`ActorMember`	`addRoleAndGroupToActor(String actorName, ProcessDefinition processDefinition, long roleId, long groupId)` Maps the role and the group to the actor of the process definition.
`ActorMember`	`addRoleToActor(long actorId, long roleId)` Maps the role to the actor.
`ActorMember`	`addRoleToActor(String actorName, ProcessDefinition processDefinition, long roleId)` Maps the role to the actor of the process definition.
`ActorMember`	`addUserToActor(long actorId, long userId)` Maps the user to the actor.
`ActorMember`	`addUserToActor(String actorName, ProcessDefinition processDefinition, long userId)` Maps a user to the actor of the process definition.
`Category`	`createCategory(String name, String description)` Adds a category.
`ProcessSupervisor`	`createProcessSupervisorForGroup(long processDefinitionId, long groupId)` Adds the group as a supervisor of the process.
`ProcessSupervisor`	`createProcessSupervisorForMembership(long processDefinitionId, long groupId, long roleId)` Adds the membership as a supervisor of the process.
`ProcessSupervisor`	`createProcessSupervisorForRole(long processDefinitionId, long roleId)` Adds the role as a supervisor of the process.
`ProcessSupervisor`	`createProcessSupervisorForUser(long processDefinitionId, long userId)` Adds the user as a supervisor of the process.
`void`	`deleteCategory(long categoryId)` Deletes a category and its associations.
`void`	`deleteProcessDefinition(long processDefinitionId)` Deletes a process definition by giving its identifier.
`void`	`deleteProcessDefinitions(List<Long> processDefinitionIds)` Deletes process definitions by giving their identifiers.
`void`	`deleteSupervisor(long supervisorId)` Deletes a process supervisor.
`void`	`deleteSupervisor(Long processDefinitionId, Long userId, Long roleId, Long groupId)` Delete the `ProcessSupervisor` object that is identified by this processDefinitionId, userId, roleId and groupId.
`ProcessDefinition`	`deploy(BusinessArchive businessArchive)` Deploys a `BusinessArchive` which contains a `DesignProcessDefinition` and its dependencies.
`ProcessDefinition`	`deploy(DesignProcessDefinition designProcessDefinition)` Deploys a simple `DesignProcessDefinition` (without any dependencies).
`ProcessDefinition`	`deployAndEnableProcess(BusinessArchive businessArchive)` Deploys and enables a process by giving a `BusinessArchive`.
`ProcessDefinition`	`deployAndEnableProcess(DesignProcessDefinition designProcessDefinition)` Deploys, enables and returns a process.
`void`	`disableAndDeleteProcessDefinition(long processDefinitionId)` Disables and deletes the process.
`void`	`disableProcess(long processDefinitionId)` Disables the process definition by giving its identifier.
`void`	`enableProcess(long processDefinitionId)` Enables the process definition.
`String`	`exportActorMapping(long processDefinitionId)` Exports the actor mapping of the process definition.
`byte[]`	`exportBarProcessContentUnderHome(long processDefinitionId)` Export processes of bar under home by a processDefinition id
`List<DataDefinition>`	`getActivityDataDefinitions(long processDefinitionId, String activityName, int startIndex, int maxResults)` Returns the paged list of data definitions of the activity of the process definition.
`ActorInstance`	`getActor(long actorId)` Returns the actor.
`ActorInstance`	`getActorInitiator(long processDefinitionId)` Returns the actor initiator of the process definition.
`List<ActorMember>`	`getActorMembers(long actorId, int startIndex, int maxResults)` Returns a paged list of members of an actor.
`List<ActorInstance>`	`getActors(long processDefinitionId, int startIndex, int maxResults, ActorCriterion sort)` Returns a paged list of actors in a process.
`Map<Long,ActorInstance>`	`getActorsFromActorIds(List<Long> actorIds)` Returns the actor instances.
`List<Category>`	`getCategories(int startIndex, int maxResults, CategoryCriterion sortCriterion)` Returns a paged list of categories.
`List<Category>`	`getCategoriesOfProcessDefinition(long processDefinitionId, int startIndex, int maxResults, CategoryCriterion sort)` Get categories from process definition
`List<Category>`	`getCategoriesUnrelatedToProcessDefinition(long processDefinitionId, int startIndex, int maxResults, CategoryCriterion sortingCriterion)` Returns a paged list of categories that are not associated with the process definition.
`Category`	`getCategory(long categoryId)` Returns the category.
`ConnectorImplementationDescriptor`	`getConnectorImplementation(long processDefinitionId, String connectorName, String connectorVersion)` Returns the implementation of a connector of the process definition.
`List<ConnectorImplementationDescriptor>`	`getConnectorImplementations(long processDefinitionId, int startIndex, int maxsResults, ConnectorCriterion sortingCriterion)` Returns a paged list of connector implementation descriptors for the process definition.
`DesignProcessDefinition`	`getDesignProcessDefinition(long processDefinitionId)` Returns a specific process definition that include informations such as tasks definition, actors...
`FormMapping`	`getFormMapping(long formMappingId)`
`long`	`getLatestProcessDefinitionId(String processName)` Returns the identifier of the most recently deployed process definition with the given name.
`int`	`getNumberOfActivityDataDefinitions(long processDefinitionId, String activityName)` Counts the number of data definitions of the activity of the process definition.
`long`	`getNumberOfActorMembers(long actorId)` Counts the number of members mapped to the actor.
`int`	`getNumberOfActors(long processDefinitionId)` Returns the number of actors in a process definition.
`long`	`getNumberOfCategories()` Counts the number of categories.
`long`	`getNumberOfCategories(long processDefinitionId)` Counts the number of categories of the process definition, that is, the number of categories to which the process belongs.
`long`	`getNumberOfConnectorImplementations(long processDefinitionId)` Returns the number of connector implementations of the process definition.
`long`	`getNumberOfGroupsOfActor(long actorId)` Counts the number of groups mapped to the actor.
`long`	`getNumberOfMembershipsOfActor(long actorId)` Counts the number of memberships mapped to the actor.
`int`	`getNumberOfParameterInstances(long processDefinitionId)` Gets how many parameters the process definition contains.
`int`	`getNumberOfProcessDataDefinitions(long processDefinitionId)` Counts the number of data definitions of the process definition.
`long`	`getNumberOfProcessDefinitionsOfCategory(long categoryId)` Counts the number of process deployment information entries of the category.
`long`	`getNumberOfProcessDeploymentInfos()` Gets the current number of process definitions in all states.
`long`	`getNumberOfProcessDeploymentInfosUnrelatedToCategory(long categoryId)` Counts the number of process definitions that do not belong to the category.
`long`	`getNumberOfRolesOfActor(long actorId)` Counts the number of roles mapped to the actor.
`long`	`getNumberOfUncategorizedProcessDefinitions()` Counts the number of process definitions which have no category.
`long`	`getNumberOfUsersOfActor(long actorId)` Counts the number of users mapped to the actor.
`ParameterInstance`	`getParameterInstance(long processDefinitionId, String parameterName)` Get a parameter instance by process definition UUID
`List<ParameterInstance>`	`getParameterInstances(long processDefinitionId, int startIndex, int maxResults, ParameterCriterion sort)` Returns the parameters of a process definition or an empty map if the process does not contain any parameter.
`List<User>`	`getPossibleUsersOfHumanTask(long processDefinitionId, String humanTaskName, int startIndex, int maxResults)` Lists the possible users (candidates) of the specified human task definition.
`List<DataDefinition>`	`getProcessDataDefinitions(long processDefinitionId, int startIndex, int maxResults)` Returns the paged list of data definitions of the process definition.
`ProcessDefinition`	`getProcessDefinition(long processDefinitionId)` Returns the process definition by giving its identifier.
`long`	`getProcessDefinitionId(String name, String version)` Returns the identifier of the process definition with the specified name and version.
`ProcessDeploymentInfo`	`getProcessDeploymentInfo(long processDefinitionId)` Gets the deployment information of a process definition by giving the process definition identifier.
`List<ProcessDeploymentInfo>`	`getProcessDeploymentInfos(int startIndex, int maxResults, ProcessDeploymentInfoCriterion sortCriterion)` Returns a paged list of process deployment information for a number of processes.
`Map<Long,ProcessDeploymentInfo>`	`getProcessDeploymentInfosFromArchivedProcessInstanceIds(List<Long> archivedProcessInstantsIds)` Get process deployment information from a list of archived processInstance ids
`Map<Long,ProcessDeploymentInfo>`	`getProcessDeploymentInfosFromIds(List<Long> processDefinitionIds)` Returns the process deployment information of the process definitions.
`Map<Long,ProcessDeploymentInfo>`	`getProcessDeploymentInfosFromProcessInstanceIds(List<Long> processInstanceIds)` Get process deployment information from a list of processInstance id
`List<ProcessDeploymentInfo>`	`getProcessDeploymentInfosOfCategory(long categoryId, int startIndex, int maxResults, ProcessDeploymentInfoCriterion sort)` Returns the paged list of process deployment information items for the category.
`List<ProcessDeploymentInfo>`	`getProcessDeploymentInfosUnrelatedToCategory(long categoryId, int startIndex, int maxResults, ProcessDeploymentInfoCriterion sortingCriterion)` Returns the paginated list of process deployment information items of the category.
`List<ProcessDeploymentInfo>`	`getProcessDeploymentInfosWithActorOnlyForGroup(long groupId, int startIndex, int maxResults, ProcessDeploymentInfoCriterion sortingCriterion)` Returns the processes for which a specified group is the only mapped actor.
`List<ProcessDeploymentInfo>`	`getProcessDeploymentInfosWithActorOnlyForGroups(List<Long> groupIds, int startIndex, int maxResults, ProcessDeploymentInfoCriterion sortingCriterion)` Returns the processes for which one of the listed groups is the only mapped actors.
`List<ProcessDeploymentInfo>`	`getProcessDeploymentInfosWithActorOnlyForRole(long roleId, int startIndex, int maxResults, ProcessDeploymentInfoCriterion sortingCriterion)` Returns the processes for which the role is the only mapped actor.
`List<ProcessDeploymentInfo>`	`getProcessDeploymentInfosWithActorOnlyForRoles(List<Long> roleIds, int startIndex, int maxResults, ProcessDeploymentInfoCriterion sortingCriterion)` Returns the processes for which one of the listed roles is the only mapped actors.
`List<ProcessDeploymentInfo>`	`getProcessDeploymentInfosWithActorOnlyForUser(long userId, int startIndex, int maxResults, ProcessDeploymentInfoCriterion sortingCriterion)` Returns the processes for which the user is the only mapped actor.
`List<ProcessDeploymentInfo>`	`getProcessDeploymentInfosWithActorOnlyForUsers(List<Long> userIds, int startIndex, int maxResults, ProcessDeploymentInfoCriterion sortingCriterion)` Returns the processes for which one of the listed users is the only mapped actor.
`List<Problem>`	`getProcessResolutionProblems(long processDefinitionId)` Returns a list of problems if the process is configured incorrectly or the configuration is incomplete.
`Map<String,byte[]>`	`getProcessResources(long processDefinitionId, String filenamesPattern)` Retrieves resources inside .bar (or `BusinessArchive`) file representing the deployed process.
`List<ProcessDeploymentInfo>`	`getStartableProcessDeploymentInfosForActors(Set<Long> actorIds, int startIndex, int maxResults, ProcessDeploymentInfoCriterion sortingCriterion)` Returns the paged list of process deployment information items that the actors can start.
`Set<String>`	`getSupportedStates(FlowNodeType nodeType)` Returns the states of the flow node type.
`List<ProcessDeploymentInfo>`	`getUncategorizedProcessDeploymentInfos(int startIndex, int maxResults, ProcessDeploymentInfoCriterion sortCriterion)` Returns the paged list of process deployment information items which have no category.
`List<Long>`	`getUserIdsForActor(long processDefinitionId, String actorName, int startIndex, int maxResults)` Retrieves the list of user identifiers for the given actor and process.
`void`	`importActorMapping(long processDefinitionId, byte[] actorMappingXML)` Imports to the process definition, the actor mapping in XML format as a byte array.
`void`	`importActorMapping(long processDefinitionId, String xmlContent)` Imports into the process definition an actor mapping in XML format.
`boolean`	`isAllowedToStartProcess(long processDefinitionId, Set<Long> actorIds)` Checks whether the actors are allowed to start the process definition.
`boolean`	`isUserProcessSupervisor(long processDefinitionId, long userId)` Checks whether the user is the process supervisor.
`void`	`purgeClassLoader(long processDefinitionId)` Purges the classLoader of the process definition.
`void`	`removeActorMember(long actorMemberId)` Deletes the actor member.
`void`	`removeCategoriesFromProcess(long processDefinitionId, List<Long> categoryIds)` Dissociates the categories from the process definition.
`long`	`removeCategoriesFromProcessDefinition(long processDefinitionId, int startIndex, int maxResults)` Deletes the associations of categories related the process definition given as input parameter respecting the pagination parameters.
`long`	`removeProcessDefinitionsFromCategory(long categoryId, int startIndex, int maxResults)` Deletes the associations of all the process definitions related to the category given as input parameter respecting the pagination parameters.
`SearchResult<FormMapping>`	`searchFormMappings(SearchOptions searchOptions)` Search for form mapping
`SearchResult<ProcessDeploymentInfo>`	`searchProcessDeploymentInfos(SearchOptions searchOptions)` Searches for the number and the list of process definitions.
`SearchResult<ProcessDeploymentInfo>`	`searchProcessDeploymentInfosCanBeStartedBy(long userId, SearchOptions searchOptions)` Searches for the number and the list of processes that the user can start.
`SearchResult<ProcessDeploymentInfo>`	`searchProcessDeploymentInfosCanBeStartedByUsersManagedBy(long managerUserId, SearchOptions searchOptions)` Search for process definitions that can be started by users managed by a specific user.
`SearchResult<ProcessDeploymentInfo>`	`searchProcessDeploymentInfosStartedBy(long userId, SearchOptions searchOptions)` Searches for the number and the list of processes which have been recently started by the user.
`SearchResult<ProcessDeploymentInfo>`	`searchProcessDeploymentInfosSupervisedBy(long userId, SearchOptions searchOptions)` Searches the number and the list of processes supervised by the user.
`SearchResult<ProcessSupervisor>`	`searchProcessSupervisors(SearchOptions searchOptions)` Searches for the number and the list of processes supervisors.
`SearchResult<ProcessDeploymentInfo>`	`searchUncategorizedProcessDeploymentInfos(SearchOptions searchOptions)` Searches for the number and the list of uncategorized processes.
`SearchResult<ProcessDeploymentInfo>`	`searchUncategorizedProcessDeploymentInfosCanBeStartedBy(long userId, SearchOptions searchOptions)` Searches the number and the list of processes that the user can start which have no category.
`SearchResult<ProcessDeploymentInfo>`	`searchUncategorizedProcessDeploymentInfosSupervisedBy(long userId, SearchOptions searchOptions)` Searches for the number and the list of uncategorized processes supervised by the user.
`SearchResult<User>`	`searchUsersWhoCanStartProcessDefinition(long processDefinitionId, SearchOptions searchOptions)` Searches for the number and the list of users who can start the process.
`ActorInstance`	`updateActor(long actorId, ActorUpdater actorUpdater)` Updates the actor.
`void`	`updateCategory(long categoryId, CategoryUpdater updater)` Updates the category according to the updater values.
`void`	`updateProcessDeploymentInfo(long processDefinitionId, ProcessDeploymentInfoUpdater processDeploymentInfoUpdater)` Updates the process deployment information for a specified process.

- Method Detail
  - deploy
```
ProcessDefinition deploy(BusinessArchive businessArchive)
                         throws AlreadyExistsException,
                                ProcessDeployException
```
    Deploys a BusinessArchive which contains a DesignProcessDefinition and its dependencies.
    
    Parameters:
    businessArchive - The archive to deploy.
    
    Returns:
    The process definition.
    
    Throws:
    
    AlreadyExistsException - If a process with same name and version is already deployed.
    
    ProcessDeployException - If an exception occurs when deploying the archive.
    Since:
    
    6.0
    
    See Also:
    BusinessArchive
  - deploy
```
ProcessDefinition deploy(DesignProcessDefinition designProcessDefinition)
                         throws AlreadyExistsException,
                                ProcessDeployException
```
    Deploys a simple DesignProcessDefinition (without any dependencies).
    
    Parameters:
    designProcessDefinition - The description of a process definition.
    
    Returns:
    The process definition corresponding of the description.
    
    Throws:
    
    AlreadyExistsException - If a process with same name and version is already deployed.
    
    ProcessDeployException - If an exception occurs when deploying the process.
    Since:
    
    6.0
    
    See Also:
    deploy(BusinessArchive)
  - enableProcess
```
void enableProcess(long processDefinitionId)
                   throws ProcessDefinitionNotFoundException,
                          ProcessEnablementException
```
    Enables the process definition.
    
    Parameters:
    processDefinitionId - The process definition identifier.
    
    Throws:
    
    ProcessDefinitionNotFoundException - If the identifier does not refer to an existing process definition.
    
    ProcessEnablementException - If an exception occurs during the process enablement.
    Since:
    
    6.0
  - disableProcess
```
void disableProcess(long processDefinitionId)
                    throws ProcessDefinitionNotFoundException,
                           ProcessActivationException
```
    Disables the process definition by giving its identifier. A process can only be disabled if it is enabled.
    
    Parameters:
    processDefinitionId - The process definition identifier.
    
    Throws:
    
    ProcessDefinitionNotFoundException - If the identifier does not refer to an existing process definition.
    
    ProcessActivationException - If an exception occurs during the process disablement.
    Since:
    
    6.0
  - getProcessDefinition
```
ProcessDefinition getProcessDefinition(long processDefinitionId)
                                       throws ProcessDefinitionNotFoundException
```
    Returns the process definition by giving its identifier. If the identifier is null, a ProcessDefinitionNotFoundException is thrown.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    
    Returns:
    The process definition referenced by the identifier.
    
    Throws:
    
    ProcessDefinitionNotFoundException - If the identifier does not refer to an existing process definition.
    
    RetrieveException - If an exception occurs when getting the process definition.
    Since:
    
    6.0
  - deleteProcessDefinition
```
void deleteProcessDefinition(long processDefinitionId)
                             throws DeletionException
```
    Deletes a process definition by giving its identifier. A process can only be deleted if it is disabled and it has no more existing process instances.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    
    Throws:
    
    DeletionException - If an exception occurs during process deletion.
    Since:
    
    6.1
  - deleteProcessDefinitions
```
void deleteProcessDefinitions(List<Long> processDefinitionIds)
                              throws DeletionException
```
    Deletes process definitions by giving their identifiers. If any specified identifier does not refer to a real process definition, or if an exception occurs, no process definition is deleted. All instances of given processes must be deleted prior to calling this operation.
    
    Parameters:
    processDefinitionIds - The list of identifiers of process definitions.
    
    Throws:
    
    DeletionException - If an exception occurs during process deletion.
    Since:
    
    6.1
    
    See Also:
    deleteProcessDefinition(long)
  - deployAndEnableProcess
```
ProcessDefinition deployAndEnableProcess(DesignProcessDefinition designProcessDefinition)
                                         throws ProcessDeployException,
                                                ProcessEnablementException,
                                                AlreadyExistsException,
                                                InvalidProcessDefinitionException
```
    Deploys, enables and returns a process.
    
    Parameters:
    designProcessDefinition - The description of a process definition.
    
    Returns:
    ProcessDefinition the process definition corresponding of the description.
    
    Throws:
    
    AlreadyExistsException - If a process with same name and version was already deployed.
    
    ProcessEnablementException - If a process cannot be enabled.
    
    InvalidProcessDefinitionException - If the designProcessDefinition is invalid.
    
    ProcessDeployException - If an exception occurs when deploying the process.
    Since:
    
    6.0
    
    See Also:
    deploy(DesignProcessDefinition), enableProcess(long)
  - deployAndEnableProcess
```
ProcessDefinition deployAndEnableProcess(BusinessArchive businessArchive)
                                         throws ProcessDeployException,
                                                ProcessEnablementException,
                                                AlreadyExistsException
```
    Deploys and enables a process by giving a BusinessArchive.
    
    Parameters:
    businessArchive - The archive ready to deploy.
    
    Returns:
    ProcessDefinition Process definition by given a business archive.
    
    Throws:
    
    ProcessDeployException - If an exception occurs when deploying the archive.
    
    AlreadyExistsException - If a process with same name and same version already exists.
    
    ProcessEnablementException - If a process cannot be enabled.
  - getProcessResolutionProblems
```
List<Problem> getProcessResolutionProblems(long processDefinitionId)
                                           throws ProcessDefinitionNotFoundException
```
    Returns a list of problems if the process is configured incorrectly or the configuration is incomplete.
    
    Parameters:
    processDefinitionId - The process definition identifier.
    
    Returns:
    a list of problems or an empty list.
    
    Throws:
    
    ProcessDefinitionNotFoundException - If the identifier does not refer to an existing process definition.
    
    RetrieveException - If an exception occurs when getting the problems of the process definition.
    Since:
    
    6.0
  - getNumberOfProcessDeploymentInfos
```
long getNumberOfProcessDeploymentInfos()
```
    Gets the current number of process definitions in all states.
    
    Returns:
    The number of process definitions.
    
    Throws:
    
    RetrieveException - If an exception occurs when getting the number of the process definitions.
    Since:
    
    6.0
  - getProcessDeploymentInfo
```
ProcessDeploymentInfo getProcessDeploymentInfo(long processDefinitionId)
                                               throws ProcessDefinitionNotFoundException
```
    Gets the deployment information of a process definition by giving the process definition identifier.
    
    Parameters:
    processDefinitionId - The process definition identifier.
    
    Returns:
    The deployment information of the process definition.
    
    Throws:
    
    ProcessDefinitionNotFoundException - If the identifier does not refer to an existing process definition.
    
    RetrieveException - If an exception occurs when getting the process deployment information.
    Since:
    
    6.0
  - updateProcessDeploymentInfo
```
void updateProcessDeploymentInfo(long processDefinitionId,
                               ProcessDeploymentInfoUpdater processDeploymentInfoUpdater)
                                 throws ProcessDefinitionNotFoundException,
                                        UpdateException
```
    Updates the process deployment information for a specified process.
    
    Parameters:
    processDefinitionId - The process definition identifier.
    processDeploymentInfoUpdater - The description which describe how to update the process deployment information.
    
    Throws:
    
    ProcessDefinitionNotFoundException - If the identifier does not refer to an existing process definition.
    
    UpdateException - If an exception occurs when updating the process deployment information.
    Since:
    
    6.0
  - getProcessDeploymentInfos
```
List<ProcessDeploymentInfo> getProcessDeploymentInfos(int startIndex,
                                                    int maxResults,
                                                    ProcessDeploymentInfoCriterion sortCriterion)
```
    Returns a paged list of process deployment information for a number of processes.
    
    Parameters:
    startIndex - The index of the first result (starting from 0).
    maxResults - The maximum number of process deployment information results per page.
    sortCriterion - The sorting criterion.
    
    Returns:
    The ordered list of process deployment informations.
    
    Throws:
    
    RetrieveException - If an exception occurs when getting the process deployment informations.
    Since:
    
    6.0
  - getNumberOfActors
```
int getNumberOfActors(long processDefinitionId)
                      throws ProcessDefinitionNotFoundException
```
    Returns the number of actors in a process definition.
    
    Parameters:
    processDefinitionId - The process definition identifier.
    
    Returns:
    The number of actors in the process.
    
    Throws:
    
    ProcessDefinitionNotFoundException - If the identifier does not refer to an existing process definition.
    Since:
    
    6.0
  - getActor
```
ActorInstance getActor(long actorId)
                       throws ActorNotFoundException
```
    Returns the actor.
    
    Parameters:
    actorId - The identifier of the actor.
    
    Returns:
    The actor.
    
    Throws:
    
    ActorNotFoundException - If an identifier does not refer to an existing actor.
    Since:
    
    6.0
  - getActors
```
List<ActorInstance> getActors(long processDefinitionId,
                            int startIndex,
                            int maxResults,
                            ActorCriterion sort)
```
    Returns a paged list of actors in a process.
    
    Parameters:
    processDefinitionId - The process definition identifier.
    startIndex - The index of the first result (starting from 0).
    maxResults - The maximum number of actors per page.
    sort - The sorting criterion.
    
    Returns:
    The ordered list of actors.
    Since:
    
    6.0
  - getActorMembers
```
List<ActorMember> getActorMembers(long actorId,
                                int startIndex,
                                int maxResults)
```
    Returns a paged list of members of an actor. An actor member can be a user, a role, a group, or a membership. An actor member is created when a user, role, group, or membership is mapped to the actor. No ordering must be assumed on the list of results.
    
    Parameters:
    actorId - The identifier of the actor.
    startIndex - The index of the first result (starting from 0).
    maxResults - The maximum number of actor members per page.
    
    Returns:
    The list of actor members.
    Since:
    
    6.0
  - getNumberOfActorMembers
```
long getNumberOfActorMembers(long actorId)
```
    Counts the number of members mapped to the actor. An actor member can be a user, a role, a group, or a membership. An actor member is created when a user, role, group, or membership is mapped to the actor.
    
    Parameters:
    actorId - The identifier of the actor.
    
    Returns:
    The number of actors members of the actor
    Since:
    
    6.0
  - getNumberOfUsersOfActor
```
long getNumberOfUsersOfActor(long actorId)
```
    Counts the number of users mapped to the actor.
    
    Parameters:
    actorId - The identifier of the actor.
    
    Returns:
    The number of users mapped to the actor.
    Since:
    
    6.0
  - getNumberOfRolesOfActor
```
long getNumberOfRolesOfActor(long actorId)
```
    Counts the number of roles mapped to the actor.
    
    Parameters:
    actorId - The identifier of the actor.
    
    Returns:
    The number of roles mapped to the actor.
    Since:
    
    6.0
  - getNumberOfGroupsOfActor
```
long getNumberOfGroupsOfActor(long actorId)
```
    Counts the number of groups mapped to the actor.
    
    Parameters:
    actorId - The identifier of the actor.
    
    Returns:
    The number of groups mapped to the actor.
    Since:
    
    6.0
  - getNumberOfMembershipsOfActor
```
long getNumberOfMembershipsOfActor(long actorId)
```
    Counts the number of memberships mapped to the actor.
    
    Parameters:
    actorId - The identifier of the actor.
    
    Returns:
    The total number of user memberships mapped to an actor
    Since:
    
    6.0
  - updateActor
```
ActorInstance updateActor(long actorId,
                        ActorUpdater actorUpdater)
                          throws ActorNotFoundException,
                                 UpdateException
```
    Updates the actor.
    
    Parameters:
    actorId - The identifier of the actor.
    actorUpdater - The descriptor which contains the fields to update.
    
    Returns:
    The actor.
    
    Throws:
    
    ActorNotFoundException - If an identifier does not refer to an existing actor.
    
    UpdateException - If an exception occurs when updating the actor.
    Since:
    
    6.0
  - addUserToActor
```
ActorMember addUserToActor(long actorId,
                         long userId)
                           throws CreationException,
                                  AlreadyExistsException
```
    Maps the user to the actor. The user will be mapped to the actor as an ActorMember.
    
    Parameters:
    actorId - The identifier of the actor.
    userId - The identifier of the user.
    
    Returns:
    The couple actor/user as an actor member.
    
    Throws:
    
    CreationException - If an exception occurs when creating the actor mapping.
    
    AlreadyExistsException - If the association already exists.
    Since:
    
    6.0
    
    See Also:
    UserAPI.getUser(long)
  - addUserToActor
```
ActorMember addUserToActor(String actorName,
                         ProcessDefinition processDefinition,
                         long userId)
                           throws ActorNotFoundException,
                                  CreationException,
                                  AlreadyExistsException
```
    Maps a user to the actor of the process definition. The user will be mapped to the actor as an ActorMember.
    
    Parameters:
    actorName - The name of the actor.
    processDefinition - The process definition.
    userId - The identifier of the user.
    
    Returns:
    The couple actor/user as an actor member.
    
    Throws:
    
    ActorNotFoundException - If the name does not refer to an existing actor of the process definition.
    
    CreationException - If an exception occurs when creating the actor mapping.
    
    AlreadyExistsException - If the association already exists.
    Since:
    
    6.0
    
    See Also:
    UserAPI.getUser(long)
  - addGroupToActor
```
ActorMember addGroupToActor(long actorId,
                          long groupId)
                            throws CreationException,
                                   AlreadyExistsException
```
    Maps the group to the actor.
    
    Parameters:
    actorId - The identifier of the actor.
    groupId - The identifier of the group.
    
    Returns:
    The couple actor/group as an actor member.
    
    Throws:
    
    CreationException - If the exception occurs when creating the actor mapping.
    
    AlreadyExistsException - If the association already exists.
    Since:
    
    6.0
    
    See Also:
    GroupAPI.getGroup(long)
  - addGroupToActor
```
ActorMember addGroupToActor(String actorName,
                          long groupId,
                          ProcessDefinition processDefinition)
                            throws ActorNotFoundException,
                                   CreationException,
                                   AlreadyExistsException
```
    Maps the group to the actor of the process definition.
    
    Parameters:
    actorName - The name of the actor.
    groupId - The identifier of the group.
    processDefinition - The process definition.
    
    Returns:
    The couple actor/group as an actor member.
    
    Throws:
    
    ActorNotFoundException - If the name does not refer to an existing actor of the process definition.
    
    CreationException - If an exception occurs when creating the actor mapping.
    
    AlreadyExistsException - If the association already exists.
    Since:
    
    6.0
  - addRoleToActor
```
ActorMember addRoleToActor(long actorId,
                         long roleId)
                           throws CreationException
```
    Maps the role to the actor.
    
    Parameters:
    actorId - The identifier of the actor.
    roleId - The identifier of the role.
    
    Returns:
    The couple actor/role as an actor member.
    
    Throws:
    
    CreationException - If an exception occurs when creating the actor mapping.
    Since:
    
    6.0
  - addRoleToActor
```
ActorMember addRoleToActor(String actorName,
                         ProcessDefinition processDefinition,
                         long roleId)
                           throws ActorNotFoundException,
                                  CreationException
```
    Maps the role to the actor of the process definition.
    
    Parameters:
    actorName - The name of the actor.
    processDefinition - The process definition.
    roleId - The identifier of the role.
    
    Returns:
    The couple actor/role as an actor member.
    
    Throws:
    
    ActorNotFoundException - If the name does not refer to an existing actor of the process definition.
    
    CreationException - If an exception occurs when creating the actor mapping.
    Since:
    
    6.0
  - addRoleAndGroupToActor
```
ActorMember addRoleAndGroupToActor(long actorId,
                                 long roleId,
                                 long groupId)
                                   throws CreationException
```
    Maps the role and the group to the actor.
    
    Parameters:
    actorId - The identifier of the actor.
    roleId - The identifier of the role.
    groupId - The identifier of the group.
    
    Returns:
    The tuple actor/role/group as an actor member.
    
    Throws:
    
    CreationException - If an exception occurs when creating the actor mapping.
    Since:
    
    6.0
  - addRoleAndGroupToActor
```
ActorMember addRoleAndGroupToActor(String actorName,
                                 ProcessDefinition processDefinition,
                                 long roleId,
                                 long groupId)
                                   throws ActorNotFoundException,
                                          CreationException
```
    Maps the role and the group to the actor of the process definition.
    
    Parameters:
    actorName - The name of the actor.
    processDefinition - The process definition.
    roleId - The identifier of the role.
    groupId - The identifier of the role.
    
    Returns:
    The tuple actor/role/group as an actor member.
    
    Throws:
    
    ActorNotFoundException - If the actor name does not refer to an existing actor in the process definition.
    
    CreationException - If an exception occurs when creating the actor mapping.
    Since:
    
    6.0
  - removeActorMember
```
void removeActorMember(long actorMemberId)
                       throws DeletionException
```
    Deletes the actor member. This removes the mapping between the user, group, role, or membership and the actor. The user, group, role, or membership is not removed from the organization.
    
    Parameters:
    actorMemberId - The identifier of the actor member
    
    Throws:
    
    DeletionException - If an exception occurs when deleting the actor mapping.
    Since:
    
    6.0
  - importActorMapping
```
void importActorMapping(long processDefinitionId,
                      String xmlContent)
                        throws ActorMappingImportException
```
    Imports into the process definition an actor mapping in XML format.
    
    Parameters:
    processDefinitionId - The identifier of the process.
    xmlContent - The XML content of the mapping. If null, nothing is performed.
    
    Throws:
    
    ActorMappingImportException - If an exception occurs when importing the actor mapping.
    Since:
    
    6.0
  - importActorMapping
```
void importActorMapping(long processDefinitionId,
                      byte[] actorMappingXML)
                        throws ActorMappingImportException
```
    Imports to the process definition, the actor mapping in XML format as a byte array.
    
    Parameters:
    processDefinitionId - The identifier of the process.
    actorMappingXML - The XML content of the mapping as a byte array. If null, nothing is performed.
    
    Throws:
    
    ActorMappingImportException - If an exception occurs when importing the actor mapping.
    Since:
    
    6.0
  - exportActorMapping
```
String exportActorMapping(long processDefinitionId)
                          throws ActorMappingExportException
```
    Exports the actor mapping of the process definition. The result contains the mapping in XML format.
    
    Parameters:
    processDefinitionId - The identifier of the process.
    
    Returns:
    The XML content of the mapping.
    
    Throws:
    
    ActorMappingExportException - If an exception occurs when exporting the actor mapping.
    Since:
    
    6.0
  - createCategory
```
Category createCategory(String name,
                      String description)
                        throws AlreadyExistsException,
                               CreationException
```
    Adds a category. A category is a string that can be assigned to processes, to make it easier to identify sets of related processes. For example, you could have a category called hr to identify all HR processes, or a category called finance to identify all processes used in the purchasing and accounts departments.
    
    Parameters:
    name - The name of the category.
    description - The description of the category.
    
    Returns:
    The category.
    
    Throws:
    
    AlreadyExistsException - If a category already exists with the given name.
    
    CreationException - If an exception occurs when creating the category.
    Since:
    
    6.0
  - getNumberOfCategories
```
long getNumberOfCategories()
```
    Counts the number of categories.
    
    Returns:
    The number of categories.
    Since:
    
    6.0
  - getCategories
```
List<Category> getCategories(int startIndex,
                           int maxResults,
                           CategoryCriterion sortCriterion)
```
    Returns a paged list of categories.
    
    Parameters:
    startIndex - The index of the first result (starting from 0).
    maxResults - The maximum number of categories.
    sortCriterion - The sorting criterion.
    
    Returns:
    The ordered list of categories.
    Since:
    
    6.0
  - getCategory
```
Category getCategory(long categoryId)
                     throws CategoryNotFoundException
```
    Returns the category.
    
    Parameters:
    categoryId - The identifier of the category.
    
    Returns:
    The category.
    
    Throws:
    
    CategoryNotFoundException - If the identifier does not refer to an existing category.
    Since:
    
    6.0
  - addProcessDefinitionToCategory
```
void addProcessDefinitionToCategory(long categoryId,
                                  long processDefinitionId)
                                    throws AlreadyExistsException,
                                           CreationException
```
    Associates the process definition with the category.
    
    Parameters:
    categoryId - The identifier of the category.
    processDefinitionId - The identifier of the process definition.
    
    Throws:
    
    AlreadyExistsException - If the association category/process already exists.
    
    CreationException - If an exception occurs while adding the process to the category.
    Since:
    
    6.0
  - addProcessDefinitionsToCategory
```
void addProcessDefinitionsToCategory(long categoryId,
                                   List<Long> processDefinitionIds)
                                     throws AlreadyExistsException,
                                            CreationException
```
    Associates a list of process definitions with the category.
    
    Parameters:
    categoryId - The identifier of the category.
    processDefinitionIds - The identifiers of the process definitions.
    
    Throws:
    
    AlreadyExistsException - If an association category/process already exists.
    
    CreationException - If an exception occurs while adding the process to the category.
    Since:
    
    6.0
  - getNumberOfCategories
```
long getNumberOfCategories(long processDefinitionId)
```
    Counts the number of categories of the process definition, that is, the number of categories to which the process belongs.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    
    Returns:
    The number of categories of the process.
    Since:
    
    6.0
  - getNumberOfProcessDefinitionsOfCategory
```
long getNumberOfProcessDefinitionsOfCategory(long categoryId)
```
    Counts the number of process deployment information entries of the category. This is the number of deployed processes in the specified category.
    
    Parameters:
    categoryId - The identifier of the category.
    
    Returns:
    The number of process deployment informations of the category.
    Since:
    
    6.0
  - getProcessDeploymentInfosOfCategory
```
List<ProcessDeploymentInfo> getProcessDeploymentInfosOfCategory(long categoryId,
                                                              int startIndex,
                                                              int maxResults,
                                                              ProcessDeploymentInfoCriterion sort)
```
    Returns the paged list of process deployment information items for the category.
    
    Parameters:
    categoryId - The identifier of the category.
    startIndex - The index of the first result (starting from 0).
    maxResults - The maximum number of process deployment information.
    sort - The sorting criterion.
    
    Returns:
    The ordered list of process deployment informations of the category.
    Since:
    
    6.0
  - getCategoriesOfProcessDefinition
```
List<Category> getCategoriesOfProcessDefinition(long processDefinitionId,
                                              int startIndex,
                                              int maxResults,
                                              CategoryCriterion sort)
```
    Get categories from process definition
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    startIndex - The index of the first result (starting from 0).
    maxResults - The maximum number of categories.
    sort - The sorting criterion.
    
    Returns:
    The ordered list of categories of the process definition.
    Since:
    
    6.0
  - updateCategory
```
void updateCategory(long categoryId,
                  CategoryUpdater updater)
                    throws CategoryNotFoundException,
                           UpdateException
```
    Updates the category according to the updater values.
    
    Parameters:
    categoryId - The identifier of the category.
    updater - The role updater.
    
    Throws:
    
    CategoryNotFoundException - If the category identifier does not refer to an existing category.
    
    UpdateException - If an exception occurs during the category update.
    Since:
    
    6.0
  - deleteCategory
```
void deleteCategory(long categoryId)
                    throws DeletionException
```
    Deletes a category and its associations. It does not delete the associated process definitions.
    
    Parameters:
    categoryId - The identifier of the category.
    
    Throws:
    
    DeletionException - If an exception occurs when deleting the category.
    Since:
    
    6.0
  - removeProcessDefinitionsFromCategory
```
long removeProcessDefinitionsFromCategory(long categoryId,
                                        int startIndex,
                                        int maxResults)
                                          throws DeletionException
```
    Deletes the associations of all the process definitions related to the category given as input parameter respecting the pagination parameters. It does not delete the associated process definitions.
    
    Parameters:
    categoryId - The identifier of the category.
    startIndex - The index
    maxResults - The max number of elements to retrieve per page
    
    Returns:
    The number of elements that have been removed
    
    Throws:
    
    DeletionException - If an error occurs while removing the process definitions of category.
    Since:
    
    6.1
  - removeCategoriesFromProcessDefinition
```
long removeCategoriesFromProcessDefinition(long processDefinitionId,
                                         int startIndex,
                                         int maxResults)
                                           throws DeletionException
```
    Deletes the associations of categories related the process definition given as input parameter respecting the pagination parameters. The process definition and categories are not deleted, but there is no longer an association between them.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    startIndex - The index
    maxResults - The max number of elements to retrieve per page
    
    Returns:
    The number of elements that have been removed
    
    Throws:
    
    DeletionException - If an error occurs while removing the process definition from category.
    Since:
    
    6.1
  - getNumberOfUncategorizedProcessDefinitions
```
long getNumberOfUncategorizedProcessDefinitions()
```
    Counts the number of process definitions which have no category.
    
    Returns:
    The number of process definitions which have no category.
    Since:
    
    6.0
  - getUncategorizedProcessDeploymentInfos
```
List<ProcessDeploymentInfo> getUncategorizedProcessDeploymentInfos(int startIndex,
                                                                 int maxResults,
                                                                 ProcessDeploymentInfoCriterion sortCriterion)
```
    Returns the paged list of process deployment information items which have no category.
    
    Parameters:
    startIndex - The number of the page (the first page number is 0).
    maxResults - The number of categories.
    sortCriterion - The sorting criterion.
    
    Returns:
    The ordered list of process deployment informations.
    Since:
    
    6.0
  - getActivityDataDefinitions
```
List<DataDefinition> getActivityDataDefinitions(long processDefinitionId,
                                              String activityName,
                                              int startIndex,
                                              int maxResults)
                                                throws ProcessDefinitionNotFoundException,
                                                       ActivityDefinitionNotFoundException
```
    Returns the paged list of data definitions of the activity of the process definition.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    activityName - The name of the activity.
    startIndex - The index of the first result (starting from 0).
    maxResults - The maximum number of data definitions.
    
    Returns:
    The ordered list of data definitions.
    
    Throws:
    
    ProcessDefinitionNotFoundException - If the identifier does not refer to an existing process definition.
    
    ActivityDefinitionNotFoundException - If the name does not refer to an existing activity.
    Since:
    
    6.0
  - getNumberOfActivityDataDefinitions
```
int getNumberOfActivityDataDefinitions(long processDefinitionId,
                                     String activityName)
                                       throws ProcessDefinitionNotFoundException,
                                              ActivityDefinitionNotFoundException
```
    Counts the number of data definitions of the activity of the process definition.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    activityName - The name of the activity.
    
    Returns:
    The number of data definitions of the activity of the process definition.
    
    Throws:
    
    ProcessDefinitionNotFoundException - If the identifier does not refer to an existing process definition.
    
    ActivityDefinitionNotFoundException - If the name does not refer to an existing activity.
    Since:
    
    6.0
  - getProcessDataDefinitions
```
List<DataDefinition> getProcessDataDefinitions(long processDefinitionId,
                                             int startIndex,
                                             int maxResults)
                                               throws ProcessDefinitionNotFoundException
```
    Returns the paged list of data definitions of the process definition.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    startIndex - The index of the first result (starting from 0).
    maxResults - The maximum number of data definitions.
    
    Returns:
    The ordered list of data definitions.
    
    Throws:
    
    ProcessDefinitionNotFoundException - If the identifier does not refer to an existing process definition.
    Since:
    
    6.0
  - getNumberOfProcessDataDefinitions
```
int getNumberOfProcessDataDefinitions(long processDefinitionId)
                                      throws ProcessDefinitionNotFoundException
```
    Counts the number of data definitions of the process definition.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    
    Returns:
    The number of data definitions of the process definition.
    
    Throws:
    
    ProcessDefinitionNotFoundException - If the identifier does not refer to an existing process definition.
    Since:
    
    6.0
  - getProcessResources
```
Map<String,byte[]> getProcessResources(long processDefinitionId,
                                     String filenamesPattern)
                                       throws RetrieveException
```
    Retrieves resources inside .bar (or BusinessArchive) file representing the deployed process. Resources to retrieved are specified with a file names pattern. The pattern format must be relative to the root of the business archive, without starting with a '/' character. The pattern can contain forward slashes after the first character. eg. if you have an image in resources/folder/image.jpg in your bar file, you can call:
```
 processAPI.getProcessResources(processDefinitionId, "resources/folder/image.jpg");
 
```
    to retrieve a map with one entry: the key is the path of the resource, the value is the binary content of the resource.
```
 eg.processAPI().getProcessResources(processDefinitionId, ".*/.\*\.txt")
 
```
    would retrieve all .txt files in a first-level subfolder. The key in the map is the path for each matching resource.
    Note that this method is expensive, as it rebuilds the business archive with all its resources. If you need to retrieve several resources, instead of calling this method several times, consider using the following code:
```
final BusinessArchive businessArchive = BusinessArchiveFactory
          .readBusinessArchive(new ByteArrayInputStream(getProcessAPI().exportBarProcessContentUnderHome(processDefinitionId)));
      // loop here if needed:
      for (String myPattern : myPatterns) {
          Map<String, byte[]> myResources = businessArchive.getResources(myPattern);
          // deal with myResources here
      }

 
 
```
    Parameters:
    processDefinitionId - The identifier of the process definition.
    filenamesPattern - The pattern to retrieve the resources.
    
    Returns:
    The map containing the pairs (name, content) of the matching files.
    
    Throws:
    
    RetrieveException - If an exception occurs when getting the resources of the process definition.
    Since:
    
    6.0
    
    See Also:
    exportBarProcessContentUnderHome(long), BusinessArchive.getResources(String)
  - getLatestProcessDefinitionId
```
long getLatestProcessDefinitionId(String processName)
                                  throws ProcessDefinitionNotFoundException
```
    Returns the identifier of the most recently deployed process definition with the given name. This method does not take into consideration the process version, but only its deployment date.
    
    Parameters:
    processName - The process definition name.
    
    Returns:
    The identifier of the most recently deployed process definition with the given name.
    
    Throws:
    
    ProcessDefinitionNotFoundException - If the identifier does not refer to an existing process definition.
    Since:
    
    6.0
  - getSupportedStates
```
Set<String> getSupportedStates(FlowNodeType nodeType)
```
    Returns the states of the flow node type. Flow nodes are activities, gateways, or events.
    
    Parameters:
    nodeType - The flow node type.
    
    Returns:
    The set of the states of the flow node type.
    Since:
    
    6.0
  - getProcessDefinitionId
```
long getProcessDefinitionId(String name,
                          String version)
                            throws ProcessDefinitionNotFoundException
```
    Returns the identifier of the process definition with the specified name and version.
    
    Parameters:
    name - The name of the process definition.
    version - The version of the process definition.
    
    Returns:
    The identifier of the process definition.
    
    Throws:
    
    ProcessDefinitionNotFoundException - If the name and version do not refer to an existing process definition.
    Since:
    
    6.0
  - getStartableProcessDeploymentInfosForActors
```
List<ProcessDeploymentInfo> getStartableProcessDeploymentInfosForActors(Set<Long> actorIds,
                                                                      int startIndex,
                                                                      int maxResults,
                                                                      ProcessDeploymentInfoCriterion sortingCriterion)
```
    Returns the paged list of process deployment information items that the actors can start.
    
    Parameters:
    actorIds - The identifiers of the actors.
    startIndex - The index of the first result (starting from 0).
    maxResults - The maximum number of process deployment informations.
    sortingCriterion - The sort criterion
    
    Returns:
    The ordered list of process deployment informations.
    Since:
    
    6.0
  - isAllowedToStartProcess
```
boolean isAllowedToStartProcess(long processDefinitionId,
                              Set<Long> actorIds)
```
    Checks whether the actors are allowed to start the process definition.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    actorIds - The identifiers of the actors.
    
    Returns:
    true if the actors are allowed to start the process definition; false otherwise.
    Since:
    
    6.0
  - getActorInitiator
```
ActorInstance getActorInitiator(long processDefinitionId)
                                throws ActorNotFoundException,
                                       ProcessDefinitionNotFoundException
```
    Returns the actor initiator of the process definition.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    
    Returns:
    The actor initiator of the process definition.
    
    Throws:
    
    ActorNotFoundException - If the process definition does not have an actor initiator.
    
    ProcessDefinitionNotFoundException - If the process definition corresponding to the given identifier is not found
    Since:
    
    6.0
  - searchProcessDeploymentInfosStartedBy
```
SearchResult<ProcessDeploymentInfo> searchProcessDeploymentInfosStartedBy(long userId,
                                                                        SearchOptions searchOptions)
                                                                          throws SearchException
```
    Searches for the number and the list of processes which have been recently started by the user.
    
    Parameters:
    userId - The identifier of the user.
    searchOptions - The search criteria.
    
    Returns:
    The number and the list of processes which have been recently started by the user.
    
    Throws:
    
    SearchException - If an exception occurs when getting the processes.
    Since:
    
    6.0
  - searchProcessDeploymentInfosCanBeStartedBy
```
SearchResult<ProcessDeploymentInfo> searchProcessDeploymentInfosCanBeStartedBy(long userId,
                                                                             SearchOptions searchOptions)
                                                                               throws SearchException
```
    Searches for the number and the list of processes that the user can start.
    
    Parameters:
    userId - The identifier of the user.
    searchOptions - The search criteria.
    
    Returns:
    The number and the list of processes that the user can start.
    
    Throws:
    
    SearchException - If an exception occurs when getting the processes.
    Since:
    
    6.3.3
  - searchProcessDeploymentInfos
```
SearchResult<ProcessDeploymentInfo> searchProcessDeploymentInfos(SearchOptions searchOptions)
                                                                 throws SearchException
```
    Searches for the number and the list of process definitions.
    
    Parameters:
    searchOptions - The criterion used to search ProcessDeploymentInfo.
    
    Returns:
    matching process deployment information results.
    
    Throws:
    
    SearchException - If an exception occurs when getting the processes.
    Since:
    
    6.0
  - addCategoriesToProcess
```
void addCategoriesToProcess(long processDefinitionId,
                          List<Long> categoryIds)
                            throws AlreadyExistsException,
                                   CreationException
```
    Associates the categories to the process definition.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    categoryIds - The identifiers of the categories.
    
    Throws:
    
    AlreadyExistsException - If the association category/process has already added.
    
    CreationException - If an exception occurs when associating the process with the categories.
    Since:
    
    6.0
  - removeCategoriesFromProcess
```
void removeCategoriesFromProcess(long processDefinitionId,
                               List<Long> categoryIds)
                                 throws DeletionException
```
    Dissociates the categories from the process definition. The process definition itself is unchanged.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    categoryIds - The identifiers of the categories.
    
    Throws:
    
    DeletionException - If an exception occurs when dissociating the categories from the process definition.
    Since:
    
    6.0
  - searchUncategorizedProcessDeploymentInfos
```
SearchResult<ProcessDeploymentInfo> searchUncategorizedProcessDeploymentInfos(SearchOptions searchOptions)
                                                                              throws SearchException
```
    Searches for the number and the list of uncategorized processes.
    
    Parameters:
    searchOptions - The search criteria.
    
    Returns:
    The number and the list of uncategorized processes.
    
    Throws:
    
    SearchException - If an exception occurs when searching the process deployment information.
    Since:
    
    6.0
  - searchUncategorizedProcessDeploymentInfosSupervisedBy
```
SearchResult<ProcessDeploymentInfo> searchUncategorizedProcessDeploymentInfosSupervisedBy(long userId,
                                                                                        SearchOptions searchOptions)
                                                                                          throws SearchException
```
    Searches for the number and the list of uncategorized processes supervised by the user.
    
    Parameters:
    userId - The identifier of the user.
    searchOptions - The search criteria.
    
    Returns:
    The number and the list of uncategorized processes.
    
    Throws:
    
    SearchException - If an exception occurs when searching the process deployment information.
    Since:
    
    6.0
  - searchUncategorizedProcessDeploymentInfosCanBeStartedBy
```
SearchResult<ProcessDeploymentInfo> searchUncategorizedProcessDeploymentInfosCanBeStartedBy(long userId,
                                                                                          SearchOptions searchOptions)
                                                                                            throws SearchException
```
    Searches the number and the list of processes that the user can start which have no category.
    
    Parameters:
    userId - The identifier of the user.
    searchOptions - The search criteria.
    
    Returns:
    The number and the list of uncategorized processes that the user can start.
    
    Throws:
    
    SearchException - If an exception occurs when searching the process deployment information.
    Since:
    
    6.3.3
  - getProcessDeploymentInfosFromIds
```
Map<Long,ProcessDeploymentInfo> getProcessDeploymentInfosFromIds(List<Long> processDefinitionIds)
```
    Returns the process deployment information of the process definitions.
    
    Parameters:
    processDefinitionIds - The identifiers of the process definitions.
    
    Returns:
    The process deployment information of the process definitions, order by name ascending.
    Since:
    
    6.0
  - getConnectorImplementation
```
ConnectorImplementationDescriptor getConnectorImplementation(long processDefinitionId,
                                                           String connectorName,
                                                           String connectorVersion)
                                                             throws ConnectorNotFoundException
```
    Returns the implementation of a connector of the process definition.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    connectorName - The name of the connector.
    connectorVersion - The version of the connector.
    
    Returns:
    The description of the connector implementation.
    
    Throws:
    
    ConnectorNotFoundException - If an exception occurs when getting the connector implementation.
    Since:
    
    6.0
  - getConnectorImplementations
```
List<ConnectorImplementationDescriptor> getConnectorImplementations(long processDefinitionId,
                                                                  int startIndex,
                                                                  int maxsResults,
                                                                  ConnectorCriterion sortingCriterion)
```
    Returns a paged list of connector implementation descriptors for the process definition.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    startIndex - The index of the first result (starting from 0).
    maxsResults - The maximum number of connector implementations.
    sortingCriterion - The sort criterion.
    
    Returns:
    The ordered list of connector implementation descriptors of the process definition.
    Since:
    
    6.0
  - getNumberOfConnectorImplementations
```
long getNumberOfConnectorImplementations(long processDefinitionId)
```
    Returns the number of connector implementations of the process definition.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    
    Returns:
    The number of connector implementation of the process definition.
    Since:
    
    6.0
  - getActorsFromActorIds
```
Map<Long,ActorInstance> getActorsFromActorIds(List<Long> actorIds)
```
    Returns the actor instances.
    
    Parameters:
    actorIds - The identifiers of the actors.
    
    Returns:
    The actor instances. (key=actorID, value=actor instance)
    Since:
    
    6.0
  - getProcessDeploymentInfosWithActorOnlyForGroup
```
List<ProcessDeploymentInfo> getProcessDeploymentInfosWithActorOnlyForGroup(long groupId,
                                                                         int startIndex,
                                                                         int maxResults,
                                                                         ProcessDeploymentInfoCriterion sortingCriterion)
```
    Returns the processes for which a specified group is the only mapped actor. This is be called before deleting a group from the organization, to make sure that there are no processes that would become unresolved as a result of removing the group. A process that has no actor mapping is unresolved and cannot be started.
    
    Parameters:
    groupId - The identifier of the group.
    startIndex - The index of the first result (starting from 0).
    maxResults - The maximum number of processes.
    sortingCriterion - The sort criterion.
    
    Returns:
    The processes that the group is the last actor.
    Since:
    
    6.0
  - getProcessDeploymentInfosWithActorOnlyForGroups
```
List<ProcessDeploymentInfo> getProcessDeploymentInfosWithActorOnlyForGroups(List<Long> groupIds,
                                                                          int startIndex,
                                                                          int maxResults,
                                                                          ProcessDeploymentInfoCriterion sortingCriterion)
```
    Returns the processes for which one of the listed groups is the only mapped actors. This is be called before deleting a group from the organization, to make sure that there are no processes that would become unresolved as a result of removing one of the listed groups. A process that has no actor mapping is unresolved and cannot be started.
    
    Parameters:
    groupIds - The identifiers of the groups.
    startIndex - The index of the first result (starting from 0).
    maxResults - The maximum number of processes.
    sortingCriterion - The sort criterion.
    
    Returns:
    The processes that the groups are the last actor(s).
    Since:
    
    6.0
  - getProcessDeploymentInfosWithActorOnlyForRole
```
List<ProcessDeploymentInfo> getProcessDeploymentInfosWithActorOnlyForRole(long roleId,
                                                                        int startIndex,
                                                                        int maxResults,
                                                                        ProcessDeploymentInfoCriterion sortingCriterion)
```
    Returns the processes for which the role is the only mapped actor. This is be called before deleting a role from the organization, to make sure that there are no processes that would become unresolved as a result of removing the role. A process that has no actor mapping is unresolved and cannot be started.
    
    Parameters:
    roleId - The identifier of the role.
    startIndex - The index of the first result (starting from 0).
    maxResults - The maximum number of processes.
    sortingCriterion - The sort criterion.
    
    Returns:
    The processes that the role is the last actor.
    Since:
    
    6.0
  - getProcessDeploymentInfosWithActorOnlyForRoles
```
List<ProcessDeploymentInfo> getProcessDeploymentInfosWithActorOnlyForRoles(List<Long> roleIds,
                                                                         int startIndex,
                                                                         int maxResults,
                                                                         ProcessDeploymentInfoCriterion sortingCriterion)
```
    Returns the processes for which one of the listed roles is the only mapped actors. This is be called before deleting a role from the organization, to make sure that there are no processes that would become unresolved as a result of removing one of the listed roles. A process that has no actor mapping is unresolved and cannot be started.
    
    Parameters:
    roleIds - The identifiers of the roles.
    startIndex - The index of the first result (starting from 0).
    maxResults - The maximum number of processes.
    sortingCriterion - The sort criterion.
    
    Returns:
    The processes that the roles are actor(s).
    Since:
    
    6.0
  - getProcessDeploymentInfosWithActorOnlyForUser
```
List<ProcessDeploymentInfo> getProcessDeploymentInfosWithActorOnlyForUser(long userId,
                                                                        int startIndex,
                                                                        int maxResults,
                                                                        ProcessDeploymentInfoCriterion sortingCriterion)
```
    Returns the processes for which the user is the only mapped actor. This is be called before deleting a user from the organization, to make sure that there are no processes that would become unresolved as a result of removing the user. A process that has no actor mapping is unresolved and cannot be started.
    
    Parameters:
    userId - The identifier of the user.
    startIndex - The index of the first result (starting from 0).
    maxResults - The maximum number of processes.
    sortingCriterion - The sort criterion.
    
    Returns:
    The processes that the user is the last actor.
    Since:
    
    6.0
    
    See Also:
    getProcessDeploymentInfosWithActorOnlyForUsers(List, int, int, ProcessDeploymentInfoCriterion)
  - getProcessDeploymentInfosWithActorOnlyForUsers
```
List<ProcessDeploymentInfo> getProcessDeploymentInfosWithActorOnlyForUsers(List<Long> userIds,
                                                                         int startIndex,
                                                                         int maxResults,
                                                                         ProcessDeploymentInfoCriterion sortingCriterion)
```
    Returns the processes for which one of the listed users is the only mapped actor.
    
    Parameters:
    userIds - The identifiers of the users.
    startIndex - The index of the first result (starting from 0).
    maxResults - The maximum number of processes.
    sortingCriterion - The sort criterion.
    
    Returns:
    The processes that the users are the last actor(s).
    Since:
    
    6.0
    
    See Also:
    getProcessDeploymentInfosWithActorOnlyForUser(long, int, int, ProcessDeploymentInfoCriterion)
  - getDesignProcessDefinition
```
DesignProcessDefinition getDesignProcessDefinition(long processDefinitionId)
                                                   throws ProcessDefinitionNotFoundException
```
    Returns a specific process definition that include informations such as tasks definition, actors...
    
    Parameters:
    processDefinitionId - Identifier of process definition
    
    Returns:
    The corresponding process definition with informations.
    
    Throws:
    
    ProcessDefinitionNotFoundException - If the process definition doesn't exist.
    Since:
    
    6.1
  - searchProcessDeploymentInfosSupervisedBy
```
SearchResult<ProcessDeploymentInfo> searchProcessDeploymentInfosSupervisedBy(long userId,
                                                                           SearchOptions searchOptions)
                                                                             throws SearchException
```
    Searches the number and the list of processes supervised by the user.
    
    Parameters:
    userId - The identifier of the user.
    searchOptions - The search criterion.
    
    Returns:
    The number and the list of processes supervised by the user.
    
    Throws:
    
    SearchException - If an exception occurs when getting the process deployment information.
  - searchProcessDeploymentInfosCanBeStartedByUsersManagedBy
```
SearchResult<ProcessDeploymentInfo> searchProcessDeploymentInfosCanBeStartedByUsersManagedBy(long managerUserId,
                                                                                           SearchOptions searchOptions)
                                                                                             throws SearchException
```
    Search for process definitions that can be started by users managed by a specific user.
    
    Parameters:
    managerUserId - The identifier of the manager.
    searchOptions - The search criteria.
    
    Returns:
    The list of process definitions that have at least one initiator who is mapped to a user to who reports to the specified manager.
    
    Throws:
    
    SearchException - If an exception occurs when getting the process deployment information.
    Since:
    
    6.3.3
  - createProcessSupervisorForUser
```
ProcessSupervisor createProcessSupervisorForUser(long processDefinitionId,
                                               long userId)
                                                 throws CreationException,
                                                        AlreadyExistsException
```
    Adds the user as a supervisor of the process. A supervisor of a process is responsible for what happens to the process. A supervisor can see the tasks in the process, and can carry out process administration. A supervisor is defined in a ProcessSupervisor object as a mapping of users, groups, or roles to the process supervisor (similar to actor mapping). A process has one ProcessSupervisor; however, as this can be mapped to several users, either explicitly or by mapping groups or roles, the process can be supervised by several people.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    userId - The identifier of the user.
    
    Returns:
    The user as a process supervisor.
    
    Throws:
    
    CreationException - If an exception occurs when creating the process supervisor.
    
    AlreadyExistsException - If the user is already the process supervisor.
    Since:
    
    6.0
  - createProcessSupervisorForRole
```
ProcessSupervisor createProcessSupervisorForRole(long processDefinitionId,
                                               long roleId)
                                                 throws CreationException,
                                                        AlreadyExistsException
```
    Adds the role as a supervisor of the process. A supervisor of a process is responsible for what happens to the process. A supervisor can see the tasks in the process, and can carry out process administration. A supervisor is defined in a ProcessSupervisor object as a mapping of users, groups, or roles to the process supervisor (similar to actor mapping). A process has one ProcessSupervisor; however, as this can be mapped to several users, either explicitly or by mapping groups or roles, the process can be supervised by several people.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    roleId - The identifier of the role.
    
    Returns:
    The role as a supervisor of the process.
    
    Throws:
    
    CreationException - If an exception occurs when creating the process supervisor.
    
    AlreadyExistsException - If the provided role is already a supervisor for the provided process.
    Since:
    
    6.0
  - createProcessSupervisorForGroup
```
ProcessSupervisor createProcessSupervisorForGroup(long processDefinitionId,
                                                long groupId)
                                                  throws CreationException,
                                                         AlreadyExistsException
```
    Adds the group as a supervisor of the process. A supervisor of a process is responsible for what happens to the process. A supervisor can see the tasks in the process, and can carry out process administration. A supervisor is defined in a ProcessSupervisor object as a mapping of users, groups, or roles to the process supervisor (similar to actor mapping). A process has one ProcessSupervisor; however, as this can be mapped to several users, either explicitly or by mapping groups or roles, the process can be supervised by several people.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    groupId - The identifier of the group.
    
    Returns:
    The group as a supervisor of the process.
    
    Throws:
    
    CreationException - If an exception occurs when creating the process supervisor.
    
    AlreadyExistsException - If the provided group is already a supervisor for the provided process.
    Since:
    
    6.0
  - createProcessSupervisorForMembership
```
ProcessSupervisor createProcessSupervisorForMembership(long processDefinitionId,
                                                     long groupId,
                                                     long roleId)
                                                       throws CreationException,
                                                              AlreadyExistsException
```
    Adds the membership as a supervisor of the process. A supervisor of a process is responsible for what happens to the process. A supervisor can see the tasks in the process, and can carry out process administration. A supervisor is defined in a ProcessSupervisor object as a mapping of users, groups, or roles to the process supervisor (similar to actor mapping). A process has one ProcessSupervisor; however, as this can be mapped to several users, either explicitly or by mapping groups or roles, the process can be supervised by several people.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    groupId - The identifier of the group.
    roleId - The identifier of the role.
    
    Returns:
    The membership as a supervisor of the process.
    
    Throws:
    
    CreationException - If an exception occurs when creating the process supervisor.
    
    AlreadyExistsException - If the provided membership (group + role) is already a supervisor for the provided process.
    Since:
    
    6.0
  - isUserProcessSupervisor
```
boolean isUserProcessSupervisor(long processDefinitionId,
                              long userId)
```
    Checks whether the user is the process supervisor.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    userId - The identifier of the user.
    
    Returns:
    true if the user is currently a supervisor of the process; false otherwise.
    Since:
    
    6.0
  - deleteSupervisor
```
void deleteSupervisor(long supervisorId)
                      throws DeletionException
```
    Deletes a process supervisor.
    
    Parameters:
    supervisorId - The identifier of the ProcessSupervisor.
    
    Throws:
    
    DeletionException - If an exception occurs when deleting the process supervisor.
    Since:
    
    6.0
  - deleteSupervisor
```
void deleteSupervisor(Long processDefinitionId,
                    Long userId,
                    Long roleId,
                    Long groupId)
                      throws DeletionException
```
    Delete the ProcessSupervisor object that is identified by this processDefinitionId, userId, roleId and groupId.
    e.g. to delete the process supervisor that is set for userId 12 and process id 255 call deleteSupervisor(255, 12, null, null)
    be careful if the user is supervisor because he is in e.g. a group of super visor calling this method with the userId will do nothing, you must find the ProcessSupervisor that link the user to the process
    
    Parameters:
    processDefinitionId - The Identifier of the process definition to delete the supervisor for.
    userId - The Id of the user used as a supervisor for the given process. Can be null.
    roleId - The Id of the role used as a supervisor for the given process. Can be null.
    groupId - The Id of the group used as a supervisor for the given process. Can be null.
    
    Throws:
    
    DeletionException - If a problem occurs while deleting the supervisor for the given process.
    Since:
    
    6.0
  - searchProcessSupervisors
```
SearchResult<ProcessSupervisor> searchProcessSupervisors(SearchOptions searchOptions)
                                                         throws SearchException
```
    Searches for the number and the list of processes supervisors.
    
    Parameters:
    searchOptions - The search criteria.
    
    Returns:
    The number and the list of processes supervisors.
    
    Throws:
    
    SearchException - If an exception occurs when getting the processes supervisors.
    Since:
    
    6.0
  - getCategoriesUnrelatedToProcessDefinition
```
List<Category> getCategoriesUnrelatedToProcessDefinition(long processDefinitionId,
                                                       int startIndex,
                                                       int maxResults,
                                                       CategoryCriterion sortingCriterion)
```
    Returns a paged list of categories that are not associated with the process definition.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    startIndex - The number of the page (the first page number is 0).
    maxResults - The maximum number of categories.
    sortingCriterion - The sort criterion.
    
    Returns:
    The categories that are not associated with the process definition.
  - getNumberOfProcessDeploymentInfosUnrelatedToCategory
```
long getNumberOfProcessDeploymentInfosUnrelatedToCategory(long categoryId)
```
    Counts the number of process definitions that do not belong to the category.
    
    Parameters:
    categoryId - The identifier of the category.
    
    Returns:
    The number of process definitions that have not the category.
  - getProcessDeploymentInfosUnrelatedToCategory
```
List<ProcessDeploymentInfo> getProcessDeploymentInfosUnrelatedToCategory(long categoryId,
                                                                       int startIndex,
                                                                       int maxResults,
                                                                       ProcessDeploymentInfoCriterion sortingCriterion)
```
    Returns the paginated list of process deployment information items of the category.
    
    Parameters:
    categoryId - The identifier of the category.
    startIndex - The number of the page (the first page number is 0).
    maxResults - The number of process deployment informations.
    sortingCriterion - The sort criterion.
    
    Returns:
    A list of process unrelated to the category which has categoryId as id
    Since:
    
    6.0
  - searchUsersWhoCanStartProcessDefinition
```
SearchResult<User> searchUsersWhoCanStartProcessDefinition(long processDefinitionId,
                                                         SearchOptions searchOptions)
                                                           throws SearchException
```
    Searches for the number and the list of users who can start the process. Note: managerUserId is a possible filter.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    searchOptions - The search criteria.
    
    Returns:
    The number and the list of users who can start the process.
    
    Throws:
    
    SearchException - If an exception occurs when getting the users.
    Since:
    
    6.0
  - getProcessDeploymentInfosFromProcessInstanceIds
```
Map<Long,ProcessDeploymentInfo> getProcessDeploymentInfosFromProcessInstanceIds(List<Long> processInstanceIds)
```
    Get process deployment information from a list of processInstance id
    
    Parameters:
    processInstanceIds - Identifier of the processInstance
    
    Returns:
    A map of <processInstantsIds,ProcessDeploymentInfos>, ordered by the name of the process ascending
    Since:
    
    6.0
  - getProcessDeploymentInfosFromArchivedProcessInstanceIds
```
Map<Long,ProcessDeploymentInfo> getProcessDeploymentInfosFromArchivedProcessInstanceIds(List<Long> archivedProcessInstantsIds)
```
    Get process deployment information from a list of archived processInstance ids
    
    Parameters:
    archivedProcessInstantsIds - Identifier of the archived process instance
    
    Returns:
    A map of <archivedProcessInstantsIds,ProcessDeploymentInfos>
    Since:
    
    6.0
  - exportBarProcessContentUnderHome
```
byte[] exportBarProcessContentUnderHome(long processDefinitionId)
                                        throws ProcessExportException
```
    Export processes of bar under home by a processDefinition id
    
    Parameters:
    processDefinitionId - Identifier of the processDefinition
    
    Returns:
    An array of byte
    
    Throws:
    
    ProcessExportException - If an export problem occurs
    Since:
    
    6.0
  - disableAndDeleteProcessDefinition
```
void disableAndDeleteProcessDefinition(long processDefinitionId)
                                       throws ProcessDefinitionNotFoundException,
                                              ProcessActivationException,
                                              DeletionException
```
    Disables and deletes the process. Wrapping method for methods disableProcess(long) and deleteProcessDefinition(long);
    
    Parameters:
    processDefinitionId - The process definition identifier.
    
    Throws:
    
    ProcessDefinitionNotFoundException - If the identifier does not refer to an existing process definition.
    
    ProcessActivationException - If an exception occurs while disabling the process.
    
    DeletionException - If an exception occurs while deleting the process.
    Since:
    
    6.1
    
    See Also:
    disableProcess(long), deleteProcessDefinition(long)
  - getPossibleUsersOfHumanTask
```
List<User> getPossibleUsersOfHumanTask(long processDefinitionId,
                                     String humanTaskName,
                                     int startIndex,
                                     int maxResults)
```
    Lists the possible users (candidates) of the specified human task definition.
    If the task contains a user filter, it is not executed. Users are ordered by user name. An empty list is returned if: - the task or the process does not exist - the flow node is not a human task
    
    Parameters:
    processDefinitionId - The identifier of process definition
    humanTaskName - The name of the human task
    startIndex - The start index
    maxResults - The list of users
    
    Returns:
    The list of users.
    
    Throws:
    
    InvalidSessionException - If the session is invalid (expired, unknown, ...)
    
    RetrieveException - If an exception occurs while retrieving the users
    Since:
    
    6.1
  - getUserIdsForActor
```
List<Long> getUserIdsForActor(long processDefinitionId,
                            String actorName,
                            int startIndex,
                            int maxResults)
```
    Retrieves the list of user identifiers for the given actor and process.
    
    Parameters:
    processDefinitionId - The process definition identifier
    actorName - The actor name
    startIndex - The start index (the first valid value is zero)
    maxResults - The max number of user identifiers to be retrieved
    
    Returns:
    Retrieves the list of user identifiers for the given actor and process.
    Since:
    
    6.3.2
  - purgeClassLoader
```
void purgeClassLoader(long processDefinitionId)
                      throws ProcessDefinitionNotFoundException,
                             UpdateException
```
    Purges the classLoader of the process definition. The process must be disable and no instances should run, otherwise an UpdateException is thrown.
    
    Parameters:
    processDefinitionId - The identifier of the process definition.
    
    Throws:
    
    ProcessDefinitionNotFoundException - If the identifier does not refer to an existing process definition.
    
    UpdateException - If the process is not disable or if instances are still running
    Since:
    
    6.4.0
  - getNumberOfParameterInstances
```
int getNumberOfParameterInstances(long processDefinitionId)
```
    Gets how many parameters the process definition contains.
    
    Parameters:
    processDefinitionId - The identifier of the processDefinition
    
    Returns:
    The number of parameters of a process definition
    
    Throws:
    
    InvalidSessionException - Generic exception thrown if API Session is invalid, e.g session has expired.
    Since:
    
    7.0.0
  - getParameterInstance
```
ParameterInstance getParameterInstance(long processDefinitionId,
                                     String parameterName)
                                       throws NotFoundException
```
    Get a parameter instance by process definition UUID
    
    Parameters:
    processDefinitionId - The identifier of the processDefinition
    parameterName - The parameter name for get ParameterInstance
    
    Returns:
    The ParameterInstance of the process with processDefinitionUUID and name parameterName
    
    Throws:
    
    NotFoundException - Error thrown if the given parameter is not found.
    
    InvalidSessionException - Generic exception thrown if API Session is invalid, e.g session has expired.
    Since:
    
    7.0.0
  - getParameterInstances
```
List<ParameterInstance> getParameterInstances(long processDefinitionId,
                                            int startIndex,
                                            int maxResults,
                                            ParameterCriterion sort)
```
    Returns the parameters of a process definition or an empty map if the process does not contain any parameter.
    
    Parameters:
    processDefinitionId - The identifier of the processDefinition
    startIndex - The index of the page to be returned. First page has index 0.
    maxResults - The number of result per page. Maximum number of result returned.
    sort - The criterion to sort the result
    
    Returns:
    The ordered list of parameter instances
    
    Throws:
    
    InvalidSessionException - Generic exception thrown if API Session is invalid, e.g session has expired.
    Since:
    
    7.0.0
  - searchFormMappings
```
SearchResult<FormMapping> searchFormMappings(SearchOptions searchOptions)
                                             throws SearchException
```
    Search for form mapping
    
    Parameters:
    searchOptions - search options to search for form mapping
    
    Returns:
    the result of the search
    
    Throws:
    
    SearchException
    Since:
    
    7.0.0
    
    See Also:
    FormMappingSearchDescriptor, FormMappingType
  - getFormMapping
```
FormMapping getFormMapping(long formMappingId)
                           throws FormMappingNotFoundException
```
    Parameters:
    formMappingId - the id of the form mapping to get
    
    Returns:
    the form mapping
    
    Throws:
    
    FormMappingNotFoundException
    Since:
    
    7.0.0

Interface ProcessManagementAPI

Method Summary

Method Detail

deploy

deploy

enableProcess

disableProcess

getProcessDefinition

deleteProcessDefinition

deleteProcessDefinitions

deployAndEnableProcess

deployAndEnableProcess

getProcessResolutionProblems

getNumberOfProcessDeploymentInfos

getProcessDeploymentInfo

updateProcessDeploymentInfo

getProcessDeploymentInfos

getNumberOfActors

getActor

getActors

getActorMembers

getNumberOfActorMembers

getNumberOfUsersOfActor

getNumberOfRolesOfActor

getNumberOfGroupsOfActor

getNumberOfMembershipsOfActor

updateActor

addUserToActor

addUserToActor

addGroupToActor

addGroupToActor

addRoleToActor

addRoleToActor

addRoleAndGroupToActor

addRoleAndGroupToActor

removeActorMember

importActorMapping

importActorMapping

exportActorMapping

createCategory

getNumberOfCategories

getCategories

getCategory

addProcessDefinitionToCategory

addProcessDefinitionsToCategory

getNumberOfCategories

getNumberOfProcessDefinitionsOfCategory

getProcessDeploymentInfosOfCategory

getCategoriesOfProcessDefinition

updateCategory

deleteCategory

removeProcessDefinitionsFromCategory

removeCategoriesFromProcessDefinition

getNumberOfUncategorizedProcessDefinitions

getUncategorizedProcessDeploymentInfos

getActivityDataDefinitions

getNumberOfActivityDataDefinitions

getProcessDataDefinitions

getNumberOfProcessDataDefinitions

getProcessResources

getLatestProcessDefinitionId

getSupportedStates

getProcessDefinitionId

getStartableProcessDeploymentInfosForActors

isAllowedToStartProcess

getActorInitiator

searchProcessDeploymentInfosStartedBy

searchProcessDeploymentInfosCanBeStartedBy

searchProcessDeploymentInfos

addCategoriesToProcess

removeCategoriesFromProcess

searchUncategorizedProcessDeploymentInfos

searchUncategorizedProcessDeploymentInfosSupervisedBy

searchUncategorizedProcessDeploymentInfosCanBeStartedBy

getProcessDeploymentInfosFromIds

getConnectorImplementation

getConnectorImplementations

getNumberOfConnectorImplementations

getActorsFromActorIds

getProcessDeploymentInfosWithActorOnlyForGroup