|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
public interface WorkflowService
The WorkflowService provides all functionality for workflow operations in a CARNOT runtime environment.
This includes:
| Field Summary | |
|---|---|
static String |
ACTIVATE_NEXT_ACTIVITY_INSTANCE_RETRIES
retry n times until receiving an activity instance defined by the query default is 5 times |
static int |
FLAG_ACTIVATE_NEXT_ACTIVITY_INSTANCE
If a synchronous interactive successor activity instance exists and can be activated by the calling user, it will be immediately activated an returned. |
| Method Summary | |
|---|---|
ActivityInstance |
abortActivityInstance(long activityInstanceOID)
Aborts the specified activity instance, effectively aborting the whole process instance hierarchy this activity instance belongs to. |
ActivityInstance |
abortActivityInstance(long activityInstanceOid,
AbortScope abortScope)
Aborts the specified activity instance, effectively aborting the whole process instance hierarchy this activity instance belongs to. |
ProcessInstance |
abortProcessInstance(long processInstanceOid,
AbortScope abortScope)
Aborts the specified process instance. |
ActivityInstance |
activate(long activityInstanceOID)
Activates the interactive activity instance identified by the activityInstanceOID. |
ActivityInstance |
activateAndComplete(long activityInstanceOID,
String context,
Map<String,?> outData)
Activates and completes the interactive activity instance identified by the activityInstanceOID on the behalf of the currently logged-in user. |
ActivityCompletionLog |
activateAndComplete(long activityInstanceOID,
String context,
Map<String,?> outData,
int flags)
Activates and completes the interactive activity instance identified by the activityInstanceOID on the behalf of the currently logged-in user. |
ActivityInstance |
activateNextActivityInstance(long activityInstanceOID)
Activates the next activity instance after the specified one in the same process instance. |
ActivityInstance |
activateNextActivityInstance(WorklistQuery query)
Activates the next activity instance from the given worklist query if any. |
ActivityInstance |
activateNextActivityInstanceForProcessInstance(long processInstanceOID)
Activates the next activity instance for the specified process instance. |
ActivityInstance |
bindActivityEventHandler(long activityInstanceOID,
EventHandlerBinding eventHandler)
Binds an event handler to the specified activity instance. |
ActivityInstance |
bindActivityEventHandler(long activityInstanceOID,
String handler)
Binds an event handler to the specified activity instance. |
ProcessInstance |
bindProcessEventHandler(long processInstanceOID,
EventHandlerBinding eventHandler)
Binds an event handler to the specified process instance. |
ProcessInstance |
bindProcessEventHandler(long processInstanceOID,
String handler)
Binds an event handler to the specified process instance. |
ActivityInstance |
complete(long activityInstanceOID,
String context,
Map<String,?> outData)
Completes the interactive activity instance identified by the activityInstanceOID on the behalf of the currently logged-in user. |
ActivityCompletionLog |
complete(long activityInstanceOID,
String context,
Map<String,?> outData,
int flags)
Completes the interactive activity instance identified by the activityInstanceOID on the behalf of the currently logged-in user. |
org.eclipse.stardust.engine.api.runtime.BusinessObject |
createBusinessObjectInstance(String qualifiedBusinessObjectId,
Object initialValue)
Creates a new business object instance if it does not exist. |
ProcessInstance |
createCase(String name,
String description,
long[] memberOids)
Creates a case process instance which groups the specified members as subprocesses. |
ProcessInstance |
delegateCase(long caseOid,
ParticipantInfo participant)
Delegates the case process instance to the specified participant. |
ActivityInstance |
delegateToDefaultPerformer(long activityInstanceOID)
Delegates the specified activitiy instance to the default worklist of the corresponding activity. |
ActivityInstance |
delegateToParticipant(long activityInstanceOID,
ParticipantInfo participant)
Delegates the activity instance to the specified participant as follows: if the participant is null, then delegates the activity to the default performer. if the participant is an instance of a UserInfo, then delegates the activity to the specified user. if the participant is an instance of a UserGroupInfo, then delegates the activity to the specified user group. if the participant is an instance of a ModelParticipantInfo, then delegates the activity to the specified model participant. |
ActivityInstance |
delegateToParticipant(long activityInstanceOID,
String performer)
Delegates the specified activity instance to a specific performer. |
ActivityInstance |
delegateToUser(long activityInstanceOID,
long userOID)
Delegates the specified activity instance to a specific performer. |
void |
deleteBusinessObjectInstance(String qualifiedBusinessObjectId,
Object primaryKey)
Deletes a business object instance. |
Serializable |
execute(ServiceCommand serviceCmd)
Executes a ServiceCommand in a single engine transaction. |
ActivityInstance |
getActivityInstance(long activityInstanceOID)
Retrieves the specified ActivityInstance. |
EventHandlerBinding |
getActivityInstanceEventHandler(long activityInstanceOID,
String handler)
Gets the binding state of an event handler for the specified activity instance. |
List<TransitionTarget> |
getAdHocTransitionTargets(long activityInstanceOid,
TransitionOptions options,
ScanDirection direction)
Retrieves the possible targets for forward transitions starting from the specified activity instance. |
Object |
getInDataPath(long processInstanceOID,
String id)
Retrieves an IN data path on a process instance as specified in the corresponding process definition. |
Map<String,Serializable> |
getInDataPaths(long processInstanceOID,
Set<String> ids)
Retrieves multiple IN data paths from a process instance as specified in the corresponding process definition. |
Serializable |
getInDataValue(long activityInstanceOID,
String context,
String id)
Retrieves all evaluated IN data mappings that match the provided application context for the specified activity. |
Map<String,Serializable> |
getInDataValues(long activityInstanceOID,
String context,
Set<String> ids)
Retrieves all evaluated IN data mappings that match the provided application context for the specified activity. |
DeployedModel |
getModel()
Deprecated. Retrieves the active model. |
List<Permission> |
getPermissions()
Retrieves all permissions the current user has on this service. |
ProcessInstance |
getProcessInstance(long processInstanceOID)
Retrieves the specified process instance. |
EventHandlerBinding |
getProcessInstanceEventHandler(long processInstanceOID,
String handler)
Gets the binding state of an event handler for the specified process instance. |
Map<String,Serializable> |
getProcessResults(long processInstanceOID)
Process instances can declare or implement process interfaces. |
List<ProcessDefinition> |
getStartableProcessDefinitions()
Retrieves the list of process definitions that can be started by the current user. |
User |
getUser()
Retrieves information on the current user. |
Worklist |
getWorklist(WorklistQuery query)
Retrieves (parts of) the worklist of the currently logged-in user. |
ActivityInstance |
hibernate(long activityInstanceOID)
Change the state of the specified activity instance to HIBERNATED. |
ProcessInstance |
joinCase(long caseOid,
long[] memberOids)
Adds the process instances referenced by the specified memberOids to the specified case process instance. |
ProcessInstance |
joinProcessInstance(long processInstanceOid,
long targetProcessInstanceOid,
String comment)
Aborts the specified process instance and joins the data into the specified target process instance. |
ProcessInstance |
leaveCase(long caseOid,
long[] memberOids)
Removes the process instances referenced by the specified memberOids from the specified case process instance. |
ProcessInstance |
mergeCases(long targetCaseOid,
long[] sourceCaseOids,
String comment)
Merges the specified source case process instances into the target case process instance by adding all case members of the source case process instances as members of the target case process instance. |
ActivityInstance |
performAdHocTransition(long activityInstanceOid,
TransitionTarget target,
boolean complete)
Deprecated. replaced with performAdHocTransition(TransitionTarget, boolean) |
TransitionReport |
performAdHocTransition(TransitionTarget target,
boolean complete)
Performs the transition from the specified activity instance to the specified target. |
void |
setActivityInstanceAttributes(ActivityInstanceAttributes attributes)
Sets attributes for an activity instance |
void |
setOutDataPath(long processInstanceOID,
String id,
Object object)
Sets an OUT data path on a process instance as specified in the corresponding process definition. |
void |
setOutDataPaths(long processInstanceOID,
Map<String,?> values)
Sets multiple OUT data paths on a process instance as specified in the corresponding process definition. |
void |
setProcessInstanceAttributes(ProcessInstanceAttributes attributes)
Sets specific attributes of a process instance. |
ProcessInstance |
spawnPeerProcessInstance(long processInstanceOid,
String spawnProcessID,
boolean copyData,
Map<String,? extends Serializable> data,
boolean abortProcessInstance,
String comment)
Deprecated. use spawnPeerProcessInstance(long, String, SpawnOptions) |
ProcessInstance |
spawnPeerProcessInstance(long processInstanceOid,
String spawnProcessID,
SpawnOptions options)
Spawns a new root process and creates a link of type PredefinedProcessInstanceLinkTypes.SWITCH to the specified process instance.Optionally existing data from the specified process instance can be copied to the newly spawned process. |
ProcessInstance |
spawnSubprocessInstance(long parentProcessInstanceOid,
String spawnProcessID,
boolean copyData,
Map<String,?> data)
Spawns a process as subprocess of the specified process instance. |
List<ProcessInstance> |
spawnSubprocessInstances(long parentProcessInstanceOid,
List<SubprocessSpawnInfo> subprocessSpawnInfo)
Spawns multiple processes as subprocesses of the specified process instance. |
ProcessInstance |
startProcess(String id,
Map<String,?> data,
boolean synchronously)
Starts the process specified by the given ID using the provided data
and returns the OID of the newly created process instance. |
ProcessInstance |
startProcess(String id,
org.eclipse.stardust.engine.api.runtime.StartOptions options)
|
ActivityInstance |
suspend(long activityInstanceOID,
ContextData outData)
Suspends the specified activity instance. |
ActivityInstance |
suspendToDefaultPerformer(long activityInstanceOID)
Suspends the specified activity instance. |
ActivityInstance |
suspendToDefaultPerformer(long activityInstanceOID,
String context,
Map<String,?> outData)
Suspends the specified activity instance. |
ActivityInstance |
suspendToParticipant(long activityInstanceOID,
ParticipantInfo participant,
ContextData outData)
Suspends the activity instance and, if the participant is not null, delegates it to the specified participant. |
ActivityInstance |
suspendToParticipant(long activityInstanceOID,
String participant)
Suspends the specified activity instance. |
ActivityInstance |
suspendToParticipant(long activityInstanceOID,
String participant,
String context,
Map<String,?> outData)
Suspends the specified activity instance. |
ActivityInstance |
suspendToUser(long activityInstanceOID)
Suspends the specified activity instance. |
ActivityInstance |
suspendToUser(long activityInstanceOID,
long userOID)
Suspends the specified activity instance. |
ActivityInstance |
suspendToUser(long activityInstanceOID,
long userOID,
String context,
Map<String,?> outData)
Suspends the specified activity instance. |
ActivityInstance |
suspendToUser(long activityInstanceOID,
String context,
Map<String,?> outData)
Suspends the specified activity instance. |
ActivityInstance |
unbindActivityEventHandler(long activityInstanceOID,
String handler)
Unbinds an event handler from the specified activity instance. |
ProcessInstance |
unbindProcessEventHandler(long processInstanceOID,
String handler)
Unbinds an event handler from the specified process instance. |
org.eclipse.stardust.engine.api.runtime.BusinessObject |
updateBusinessObjectInstance(String qualifiedBusinessObjectId,
Object newValue)
Updates the value of a business object instance. |
void |
writeLogEntry(LogType logType,
ContextKind contextType,
long contextOid,
String message,
Throwable throwable)
Logs an audit trail event of type LogCode.EXTERNAL. |
| Field Detail |
|---|
static final String ACTIVATE_NEXT_ACTIVITY_INSTANCE_RETRIES
activateNextActivityInstance(WorklistQuery query),
Constant Field Valuesstatic final int FLAG_ACTIVATE_NEXT_ACTIVITY_INSTANCE
activateNextActivityInstance(long),
Constant Field Values| Method Detail |
|---|
@ExecutionPermission(id=performActivity,
scope=activity,
defaults=OWNER,
changeable=false,
administratorOverride=false)
ActivityInstance activate(long activityInstanceOID)
throws org.eclipse.stardust.common.error.ConcurrencyException,
org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.AccessForbiddenException
activityInstanceOID.
Activating means:
State changes:
activityInstanceOID - the OID of the activity to be activated.
ActivityInstance that was activated.
org.eclipse.stardust.common.error.ConcurrencyException - if the same activity instance is being processed by another user.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
org.eclipse.stardust.common.error.AccessForbiddenException - if the current user is not valid or is not granted to execute the
activity instance. Also thrown if the activity instance is already
terminated.
IllegalOperationException - if the specified activity instance is a quality assurance instance QualityAssuranceState.IS_QUALITY_ASSURANCE and the current user is the
one who worked on the previous workflow instance.activateAndComplete(long, java.lang.String, java.util.Map)
@ExecutionPermission(id=performActivity,
scope=activity,
defaults=OWNER,
changeable=false,
administratorOverride=false)
ActivityInstance complete(long activityInstanceOID,
String context,
Map<String,?> outData)
throws org.eclipse.stardust.common.error.ConcurrencyException,
IllegalStateChangeException,
org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.InvalidValueException,
org.eclipse.stardust.common.error.AccessForbiddenException,
org.eclipse.stardust.common.error.InvalidArgumentException
activityInstanceOID on the behalf of the currently logged-in user.
State Changes:
activityInstanceOID - the OID of the activity to be completed.context - the ID of the context on which the data mapping will be performed.outData - a map with the values of the out access points.
ActivityInstance that was completed.
org.eclipse.stardust.common.error.ConcurrencyException - if the activity instance is exclusively locked by another thread.
IllegalStateChangeException - if that state change is not permitted, i.e. the activity is not active.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
org.eclipse.stardust.common.error.InvalidValueException - if one of the outData values to be written is invalid,
most probably as of a type conflict in case of statically typed data.
org.eclipse.stardust.common.error.AccessForbiddenException - if the current user is not allowed to complete the activity.
IllegalOperationException - if the specified activity instance is a quality assurance instance and no
ActivityInstanceAttributes has been set before.
org.eclipse.stardust.common.error.InvalidArgumentExceptionactivateAndComplete(long, String, java.util.Map),
complete(long, String, java.util.Map, int),
setActivityInstanceAttributes(org.eclipse.stardust.engine.api.dto.ActivityInstanceAttributes)
@ExecutionPermission(id=performActivity,
scope=activity,
defaults=OWNER,
changeable=false,
administratorOverride=false)
ActivityCompletionLog complete(long activityInstanceOID,
String context,
Map<String,?> outData,
int flags)
throws org.eclipse.stardust.common.error.ConcurrencyException,
IllegalStateChangeException,
org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.InvalidValueException,
org.eclipse.stardust.common.error.AccessForbiddenException,
org.eclipse.stardust.common.error.InvalidArgumentException
activityInstanceOID on the behalf of the currently logged-in user.
State Changes:
activityInstanceOID - the OID of the activity to be completed.context - the ID of the context on which the data mapping will be performed.outData - a map with the values of the out access points.flags - Optional adjustment to some details of operation. Supported values are
WorkflowService.FLAG_ACTIVATE_NEXT_ACTIVITY_INSTANCE.
org.eclipse.stardust.common.error.ConcurrencyException - if the same activity instance is being processed by another user.
IllegalStateChangeException - if that state change is not permitted, i.e. the activity is not active.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
org.eclipse.stardust.common.error.InvalidValueException - if one of the outData values to be written is invalid,
most probably as of a type conflict in case of statically typed data.
org.eclipse.stardust.common.error.AccessForbiddenException - if the activity instance is already terminated.
IllegalOperationException - if the specified activity instance is a quality assurance instance and no
ActivityInstanceAttributes has been set before.
org.eclipse.stardust.common.error.InvalidArgumentExceptioncomplete(long, String, java.util.Map),
activateAndComplete(long, String, java.util.Map),
setActivityInstanceAttributes(org.eclipse.stardust.engine.api.dto.ActivityInstanceAttributes)
@ExecutionPermission(id=performActivity,
scope=activity,
defaults=OWNER,
changeable=false,
administratorOverride=false)
ActivityInstance activateAndComplete(long activityInstanceOID,
String context,
Map<String,?> outData)
throws org.eclipse.stardust.common.error.ConcurrencyException,
org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.InvalidValueException,
org.eclipse.stardust.common.error.AccessForbiddenException
activityInstanceOID on the behalf of the currently logged-in user.
If the activity is activated to be immediately completed, this method is more
efficient than invoking activate(...) and complete(...) separately.
activityInstanceOID - the OID of the activity to be completed.context - the ID of the context on which the data mapping will be performed. The
value null will be interpreted as the default context.outData - a map with the values of the out access points.
ActivityInstance that was completed.
org.eclipse.stardust.common.error.ConcurrencyException - if the same activity instance is being processed by another user.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
org.eclipse.stardust.common.error.InvalidValueException - if one of the outData values to be written is invalid, most
probably as of a type conflict in case of statically typed data.
org.eclipse.stardust.common.error.AccessForbiddenException - if the current user is not valid or is not granted to execute the
activity instance. Also thrown if the activity instance is already
terminated.
IllegalOperationException - if the specified activity instance is a quality assurance instance
QualityAssuranceState.IS_QUALITY_ASSURANCE and the current user
is the one who worked on the previous workflow instance
IllegalOperationException - if the specified activity instance is a quality assurance instance and no
ActivityInstanceAttributes has been set before.activate(long),
complete(long, String, java.util.Map),
activateAndComplete(long, String, java.util.Map, int),
setActivityInstanceAttributes(org.eclipse.stardust.engine.api.dto.ActivityInstanceAttributes)
@ExecutionPermission(id=performActivity,
scope=activity,
defaults=OWNER,
changeable=false,
administratorOverride=false)
ActivityCompletionLog activateAndComplete(long activityInstanceOID,
String context,
Map<String,?> outData,
int flags)
throws org.eclipse.stardust.common.error.ConcurrencyException,
org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.InvalidValueException,
org.eclipse.stardust.common.error.AccessForbiddenException
activityInstanceOID on the behalf of the currently logged-in user.
If the activity is activated to be immediately completed, this method is more
efficient than invoking activate(...) and complete(...) separately.
activityInstanceOID - the OID of the activity to be completed.context - the ID of the context on which the data mapping will be performed. The
value null will be interpreted as the default context.outData - a map with the values of the out access points.flags - Optional adjustment to some details of operation. Supported values are
WorkflowService.FLAG_ACTIVATE_NEXT_ACTIVITY_INSTANCE.
org.eclipse.stardust.common.error.ConcurrencyException - if the same activity instance is being processed by another user.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
org.eclipse.stardust.common.error.InvalidValueException - if one of the outData values to be written is invalid,
most probably as of a type conflict in case of statically typed data.
IllegalOperationException - if the specified activity instance is a quality assurance instance
QualityAssuranceState.IS_QUALITY_ASSURANCE and the current user
is the one who worked on the previous workflow instance
org.eclipse.stardust.common.error.AccessForbiddenException - if the current user is not valid or is not granted to execute the
activity instance. Also thrown if the activity instance is already
terminated.
IllegalOperationException - if the specified activity instance is a quality assurance instance and no
ActivityInstanceAttributes has been set before.activateAndComplete(long, String, java.util.Map),
activate(long),
complete(long, String, java.util.Map),
setActivityInstanceAttributes(org.eclipse.stardust.engine.api.dto.ActivityInstanceAttributes)
@ExecutionPermission(id=readActivityInstanceData,
scope=activity,
defaults=ALL,
fixed=OWNER)
Serializable getInDataValue(long activityInstanceOID,
String context,
String id)
throws org.eclipse.stardust.common.error.ObjectNotFoundException
activityInstanceOID - the OID of the activity for which the data mappings are to be retrieved.context - the application context for which the mappings are retrieved. The value
null will be interpreted as the default context.id - The ID of the data mapping to be retrieved.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID or there is no
mapping with the given ID under the given context.getInDataValues(long, String, java.util.Set)
@ExecutionPermission(id=readActivityInstanceData,
scope=activity,
defaults=ALL,
fixed=OWNER)
Map<String,Serializable> getInDataValues(long activityInstanceOID,
String context,
Set<String> ids)
throws org.eclipse.stardust.common.error.ObjectNotFoundException
activityInstanceOID - the OID of the activity for which the data mappings are to be retrieved.context - the application context for which the mappings are retrieved. The value
null will be interpreted as the default context.ids - the set of data mapping IDs designating the values to be retrieved. If
null is passed, all IN data mappings for the context are
retrieved.
Serializable.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID or not all
mapping IDs can be resolved in the given context.getInDataValue(long, String, String)
@ExecutionPermission(id=performActivity,
scope=activity,
defaults=OWNER,
changeable=false,
administratorOverride=false)
ActivityInstance suspend(long activityInstanceOID,
ContextData outData)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.AccessForbiddenException,
org.eclipse.stardust.common.error.InvalidArgumentException
State changes:
activityInstanceOID - the OID of the activity to be suspended.outData - the context data containing values of out access points to be stored.
ActivityInstance that was suspended.
org.eclipse.stardust.common.error.AccessForbiddenException - if the activity instance is already terminated or is currently processed
by another user or the current user does not have the required
permission.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
org.eclipse.stardust.common.error.InvalidArgumentExceptionsuspendToDefaultPerformer(long, String, java.util.Map)
@ExecutionPermission(id=performActivity,
scope=activity,
defaults=OWNER,
changeable=false,
administratorOverride=false)
ActivityInstance suspendToDefaultPerformer(long activityInstanceOID)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.ConcurrencyException,
org.eclipse.stardust.common.error.AccessForbiddenException
State changes:
activityInstanceOID - the OID of the activity to be suspended.
ActivityInstance that was suspended.
org.eclipse.stardust.common.error.ConcurrencyException - if the same activity instance is being processed by another user.
org.eclipse.stardust.common.error.AccessForbiddenException - if the activity instance is already terminated.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.suspendToDefaultPerformer(long, String, java.util.Map)
@ExecutionPermission(id=performActivity,
scope=activity,
defaults=OWNER,
changeable=false,
administratorOverride=false)
ActivityInstance suspendToDefaultPerformer(long activityInstanceOID,
String context,
Map<String,?> outData)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.ConcurrencyException,
org.eclipse.stardust.common.error.AccessForbiddenException,
org.eclipse.stardust.common.error.InvalidArgumentException
State changes:
activityInstanceOID - the OID of the activity to be suspended.context - the ID of the context on which the data mapping will be performed.outData - a map with values of out access points to be stored.
ActivityInstance that was suspended.
org.eclipse.stardust.common.error.ConcurrencyException - if the same activity instance is being processed by another user.
org.eclipse.stardust.common.error.AccessForbiddenException - if the activity instance is already terminated.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
org.eclipse.stardust.common.error.InvalidArgumentExceptionsuspendToDefaultPerformer(long)
@ExecutionPermission(id=performActivity,
scope=activity,
defaults=OWNER,
changeable=false,
administratorOverride=false)
ActivityInstance suspendToUser(long activityInstanceOID)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.ConcurrencyException,
org.eclipse.stardust.common.error.AccessForbiddenException
State changes:
activityInstanceOID - the OID of the activity to be suspended.
ActivityInstance that was suspended.
org.eclipse.stardust.common.error.ConcurrencyException - if the same activity instance is being processed by another user.
org.eclipse.stardust.common.error.AccessForbiddenException - if the delegation target is not granted to execute the activity instance
or if the activity instance is already terminated.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.suspendToUser(long, String, java.util.Map)
@ExecutionPermission(id=performActivity,
scope=activity,
defaults=OWNER,
changeable=false,
administratorOverride=false)
ActivityInstance suspendToUser(long activityInstanceOID,
String context,
Map<String,?> outData)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.ConcurrencyException,
org.eclipse.stardust.common.error.AccessForbiddenException,
org.eclipse.stardust.common.error.InvalidArgumentException
State changes:
activityInstanceOID - the OID of the activity to be suspended.context - the ID of the context on which the data mapping will be performed.outData - a map with values of out access points to be stored.
ActivityInstance that was suspended.
org.eclipse.stardust.common.error.ConcurrencyException - if the same activity instance is being processed by another user.
org.eclipse.stardust.common.error.AccessForbiddenException - if the delegation target is not granted to execute the activity instance
or if the activity instance is already terminated.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
org.eclipse.stardust.common.error.InvalidArgumentExceptionsuspendToUser(long)
@ExecutionPermission(id=performActivity,
scope=activity,
defaults=OWNER,
changeable=false,
administratorOverride=false,
implied={delegateToOther,delegateToDepartment})
ActivityInstance suspendToUser(long activityInstanceOID,
long userOID)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.ConcurrencyException,
org.eclipse.stardust.common.error.AccessForbiddenException,
org.eclipse.stardust.common.error.InvalidArgumentException
State changes:
activityInstanceOID - the OID of the activity to be suspended.userOID - the OID of the user.
ActivityInstance that was suspended.
org.eclipse.stardust.common.error.ConcurrencyException - if the same activity instance is being processed by another user.
org.eclipse.stardust.common.error.AccessForbiddenException - if the delegation target is not granted to execute the activity instance
or if the activity instance is already terminated.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
IllegalOperationException - if the specified activity instance is a quality assurance instance
QualityAssuranceState.IS_QUALITY_ASSURANCE and the specified user
is the one who worked on the previous workflow instance
org.eclipse.stardust.common.error.InvalidArgumentExceptionsuspendToUser(long, long, String, java.util.Map)
@ExecutionPermission(id=performActivity,
scope=activity,
defaults=OWNER,
changeable=false,
administratorOverride=false,
implied={delegateToOther,delegateToDepartment})
ActivityInstance suspendToUser(long activityInstanceOID,
long userOID,
String context,
Map<String,?> outData)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.ConcurrencyException,
org.eclipse.stardust.common.error.AccessForbiddenException,
org.eclipse.stardust.common.error.InvalidArgumentException
State changes:
activityInstanceOID - the OID of the activity to be suspended.userOID - the OID of the user.context - the ID of the context on which the data mapping will be performed.outData - a map with values of out access points to be stored.
ActivityInstance that was suspended.
org.eclipse.stardust.common.error.ConcurrencyException - if the same activity instance is being processed by another user.
org.eclipse.stardust.common.error.AccessForbiddenException - if the delegation target is not granted to execute the activity instance
or if the activity instance is already terminated.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
IllegalOperationException - if the specified activity instance is a quality assurance instance
QualityAssuranceState.IS_QUALITY_ASSURANCE and the specified user
is the one who worked on the previous workflow instance
org.eclipse.stardust.common.error.InvalidArgumentExceptionsuspendToUser(long, long)
@ExecutionPermission(id=performActivity,
scope=activity,
defaults=OWNER,
changeable=false,
administratorOverride=false,
implied={delegateToOther,delegateToDepartment})
ActivityInstance suspendToParticipant(long activityInstanceOID,
String participant)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.ConcurrencyException,
org.eclipse.stardust.common.error.AccessForbiddenException
State changes:
activityInstanceOID - the OID of the activity to be suspended.participant - the ID of the performer.
ActivityInstance that was suspended.
org.eclipse.stardust.common.error.ConcurrencyException - if the same activity instance is being processed by another user.
org.eclipse.stardust.common.error.AccessForbiddenException - if the delegation target is not granted to execute the activity instance
or if the activity instance is already terminated.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.suspendToParticipant(long, String, String, java.util.Map)
@ExecutionPermission(id=performActivity,
scope=activity,
defaults=OWNER,
changeable=false,
administratorOverride=false,
implied={delegateToOther,delegateToDepartment})
ActivityInstance suspendToParticipant(long activityInstanceOID,
String participant,
String context,
Map<String,?> outData)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.ConcurrencyException,
org.eclipse.stardust.common.error.AccessForbiddenException,
org.eclipse.stardust.common.error.InvalidArgumentException
State changes:
activityInstanceOID - the OID of the activity to be suspended.participant - the ID of the performer.context - the ID of the context on which the data mapping will be performed.outData - a map with values of out access points to be stored.
ActivityInstance that was suspended.
org.eclipse.stardust.common.error.ConcurrencyException - if the same activity instance is being processed by another user.
org.eclipse.stardust.common.error.AccessForbiddenException - if the delegation target is not granted to execute the activity instance
or if the activity instance is already terminated.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
org.eclipse.stardust.common.error.InvalidArgumentExceptionsuspendToParticipant(long, String)
@ExecutionPermission(id=performActivity,
scope=activity,
defaults=OWNER,
changeable=false,
administratorOverride=false,
implied={delegateToOther,delegateToDepartment})
ActivityInstance suspendToParticipant(long activityInstanceOID,
ParticipantInfo participant,
ContextData outData)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.AccessForbiddenException,
org.eclipse.stardust.common.error.InvalidArgumentException
State changes:
activityInstanceOID - the OID of the activity instance.participant - the participant (model participant, user or user group) to which the
activity instance will be delegated.outData - the context data containing values of out access points to be stored.
ActivityInstance that was suspended.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID or if the
participant is not null and could not be resolved to an actual user user
group or model participant.
org.eclipse.stardust.common.error.AccessForbiddenException - if the activity instance is already terminated or is currently processed
by another user or the current user does not have the required permission
or if the delegation target is not granted to execute the activity
instance or if the activity instance is already terminated.
IllegalOperationException - if the specified activity instance is a quality assurance instance
QualityAssuranceState.IS_QUALITY_ASSURANCE and the passed
participant is a user who worked on the previous workflow instance
org.eclipse.stardust.common.error.InvalidArgumentException
@ExecutionPermission(id=delegateToOther,
scope=activity,
defaults=ALL)
ActivityInstance hibernate(long activityInstanceOID)
throws IllegalStateChangeException,
org.eclipse.stardust.common.error.ObjectNotFoundException
activityInstanceOID - the OID of the activity to be hibernated.
ActivityInstance that was hibernated.
IllegalStateChangeException - if that state change is not permitted, i.e. the activity is already
completed or aborted.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
@ExecutionPermission(id=startProcesses,
scope=processDefinition,
defaults=ALL)
ProcessInstance startProcess(String id,
Map<String,?> data,
boolean synchronously)
throws org.eclipse.stardust.common.error.ObjectNotFoundException
ID using the provided data
and returns the OID of the newly created process instance.
State changes:
id - The ID of the process to be started. If multiple models with different IDs
are deployed then the process definition id needs to be qualified with
model id, e.g. "{modelId}processDefinitionId"data - Contains data IDs as keyset and corresponding data values to be set as
values.synchronously - Determines whether the process will be started synchronously or
asynchronously.
ProcessInstance that was started.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no process with the specified ID in the active model or an
invalid data id was specified.
@ExecutionPermission(id=startProcesses,
scope=processDefinition,
defaults=ALL)
ProcessInstance startProcess(String id,
org.eclipse.stardust.engine.api.runtime.StartOptions options)
@ExecutionPermission(id=spawnSubProcessInstance,
defaults=ALL)
ProcessInstance spawnSubprocessInstance(long parentProcessInstanceOid,
String spawnProcessID,
boolean copyData,
Map<String,?> data)
throws IllegalOperationException,
org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.ConcurrencyException
parentProcessInstanceOid - The oid of the process to spawn from.spawnProcessID - The id of the process definition to spawn as a subprocess.copyData - Defines if data of the parent process definition should be copied to the
spawned process.data - Contains data IDs as keyset and corresponding data values to be set as
values.
ProcessInstance that was spawned.
IllegalOperationException - if the process instance is not a case process instance, is not active or
if the process definition is from a different model.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no process instance with the specified oid or if there is no
process definition with the specified id.
org.eclipse.stardust.common.error.ConcurrencyException - if a lock on transitions or process instances cannot be obtained. This
can happen while the process hierarchy is currently locked because of
case operations or subprocess creation.
@ExecutionPermission(id=spawnSubProcessInstance,
defaults=ALL)
List<ProcessInstance> spawnSubprocessInstances(long parentProcessInstanceOid,
List<SubprocessSpawnInfo> subprocessSpawnInfo)
throws IllegalOperationException,
org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.ConcurrencyException
parentProcessInstanceOid - The oid of the process to spawn from.subprocessSpawnInfo - A List of SubprocessSpawnInfo holding information about the subprocesses to be
spawned.
ProcessInstance that were spawned.
IllegalOperationException - if the process instance is not a case process instance, is not active or
if the process definition is from a different model.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no process instance with the specified oid or if there is no
process definition with the specified id.
org.eclipse.stardust.common.error.ConcurrencyException - if a lock on transitions or process instances cannot be obtained. This
can happen while the process hierarchy is currently locked because of
case operations or subprocess creation.
@ExecutionPermission(id=spawnPeerProcessInstance,
defaults=ALL)
@Deprecated
ProcessInstance spawnPeerProcessInstance(long processInstanceOid,
String spawnProcessID,
boolean copyData,
Map<String,? extends Serializable> data,
boolean abortProcessInstance,
String comment)
throws IllegalOperationException,
org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.InvalidArgumentException,
org.eclipse.stardust.common.error.ConcurrencyException
spawnPeerProcessInstance(long, String, SpawnOptions)
PredefinedProcessInstanceLinkTypes.SWITCH to the specified process instance.
Please note that currently the specified process instance has to be aborted by
setting abortProcessInstance to true.
processInstanceOid - The oid of the process to spawn from.spawnProcessID - The id of the process definition to spawn as a new root process. By default the
model version of originating process instance will be used. If the specified
process ID is fully qualified, i.e. contains the model ID, the active model version
for that model will be used instead.copyData - Defines if data of the parent process definition should be copied to the
spawned process.data - Contains data IDs as keyset and corresponding data values to be set as
values.abortProcessInstance - whether the originating process instance should be aborted. Currently
has to be true.comment - Allows to specify a comment for the link that is created.
ProcessInstance that was spawned.
IllegalOperationException - if the process instance is terminated or not a root process instance. if
the process instance and the process definition are from different
models. if the process instances process definition is the same as the
specified process definition.
org.eclipse.stardust.common.error.ObjectNotFoundException - if the process instance for the specified oid or the process definition
for the specified process id is not found.
org.eclipse.stardust.common.error.InvalidArgumentException - if abortProcessInstance is false (currently not
implemented).
org.eclipse.stardust.common.error.ConcurrencyException - if a lock on process instances cannot be obtained.
@ExecutionPermission(id=spawnPeerProcessInstance,
defaults=ALL)
ProcessInstance spawnPeerProcessInstance(long processInstanceOid,
String spawnProcessID,
SpawnOptions options)
throws IllegalOperationException,
org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.InvalidArgumentException,
org.eclipse.stardust.common.error.ConcurrencyException
PredefinedProcessInstanceLinkTypes.SWITCH to the specified process instance.
Please note that currently the specified process instance has to be aborted by
setting abortProcessInstance to true.
processInstanceOid - The oid of the process to spawn from.spawnProcessID - The id of the process definition to spawn as a new root process. By default the
model version of originating process instance will be used. If the specified
process ID is fully qualified, i.e. contains the model ID, the active model version
for that model will be used instead.options - Options that controls how the spawning operation has to be performed.
ProcessInstance that was spawned.
IllegalOperationException - if the process instance is terminated or not a root process instance. if
the process instance and the process definition are from different
models. if the process instances process definition is the same as the
specified process definition.
org.eclipse.stardust.common.error.ObjectNotFoundException - if the process instance for the specified oid or the process definition
for the specified process id is not found.
org.eclipse.stardust.common.error.InvalidArgumentException - if abortProcessInstance is false (currently not
implemented).
org.eclipse.stardust.common.error.ConcurrencyException - if a lock on process instances cannot be obtained.
@ExecutionPermission(id=createCase,
defaults=ALL)
ProcessInstance createCase(String name,
String description,
long[] memberOids)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
IllegalOperationException,
org.eclipse.stardust.common.error.InvalidArgumentException,
org.eclipse.stardust.common.error.ConcurrencyException
name - The name of the case.description - A description for the case.memberOids - The oids of the process instances which should become members of the case.
org.eclipse.stardust.common.error.ObjectNotFoundException - if one of the process instances referenced by memberOids is
not found.
IllegalOperationException - if memberOids contains a process instance which is not a
root process.
org.eclipse.stardust.common.error.InvalidArgumentException - if memberOids is empty or null.
org.eclipse.stardust.common.error.ConcurrencyException - if a lock on transitions or process instances cannot be obtained. This
can happen while the process hierarchy is currently locked because of
case operations or subprocess creation.ProcessInstance.isCaseProcessInstance()
@ExecutionPermission(id=modifyCase,
scope=processDefinition,
defaults=OWNER,
changeable=false)
ProcessInstance joinCase(long caseOid,
long[] memberOids)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
IllegalOperationException,
org.eclipse.stardust.common.error.AccessForbiddenException,
org.eclipse.stardust.common.error.ConcurrencyException
caseOid - The oid of the case process instance.memberOids - The oids of the process instances which should become members of the case.
org.eclipse.stardust.common.error.ObjectNotFoundException - if one of the process instances referenced by memberOids is
not found.
IllegalOperationException - if memberOids contains a process instance which is not a
root process or is already a member of the case.
org.eclipse.stardust.common.error.AccessForbiddenException - if the user is not the owner of the case.
org.eclipse.stardust.common.error.ConcurrencyException - if a lock on transitions or process instances cannot be obtained. This
can happen while the process hierarchy is currently locked because of
case operations or subprocess creation.
@ExecutionPermission(id=modifyCase,
scope=processDefinition,
defaults=OWNER,
changeable=false)
ProcessInstance leaveCase(long caseOid,
long[] memberOids)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
IllegalOperationException,
org.eclipse.stardust.common.error.AccessForbiddenException,
org.eclipse.stardust.common.error.ConcurrencyException
caseOid - The oid of the case process instance.memberOids - The oids of the process instances which should be removed from the case.
org.eclipse.stardust.common.error.ObjectNotFoundException - if one of the process instances referenced by memberOids is
not found.
IllegalOperationException - if memberOids contains a process instance which is not a
root process or is not a member of the case.
org.eclipse.stardust.common.error.AccessForbiddenException - if the user is not the owner of the case.
org.eclipse.stardust.common.error.ConcurrencyException - if a lock on transitions or process instances cannot be obtained. This
can happen while the process hierarchy is currently locked because of
case operations or subprocess creation.
@ExecutionPermission(id=modifyCase,
scope=processDefinition,
defaults=OWNER,
changeable=false)
ProcessInstance mergeCases(long targetCaseOid,
long[] sourceCaseOids,
String comment)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
IllegalOperationException,
org.eclipse.stardust.common.error.AccessForbiddenException,
org.eclipse.stardust.common.error.ConcurrencyException
targetCaseOid - The target case process instancesourceCaseOids - The source case process instances.comment - Allows to specify a comment
org.eclipse.stardust.common.error.ObjectNotFoundException - if one of the process instances referenced by sourceCaseOids
is not found.
IllegalOperationException - if sourceCaseOids contains a process instance which is not a
case process instance. if sourceCaseOids contains a process
instance which is not active. if sourceCaseOids contains a
process instance which equals the targetCaseOid. if
targetCaseOid is not a case process instance.
org.eclipse.stardust.common.error.AccessForbiddenException - if the user is not the owner of the case.
org.eclipse.stardust.common.error.ConcurrencyException - if a lock on transitions or process instances cannot be obtained. This
can happen while the process hierarchy is currently locked because of
case operations or subprocess creation.
@ExecutionPermission(id=delegateToOther,
scope=processDefinition,
defaults=OWNER,
changeable=false,
implied=delegateToDepartment)
ProcessInstance delegateCase(long caseOid,
ParticipantInfo participant)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
IllegalOperationException,
org.eclipse.stardust.common.error.AccessForbiddenException
caseOid - The case process instance to delegate.participant - The targetParticipant.
org.eclipse.stardust.common.error.ObjectNotFoundException - if one of the process instances referenced by caseOid is not
found.
IllegalOperationException - if caseOid is not a case process instance.
org.eclipse.stardust.common.error.AccessForbiddenException - if the user is not the owner of the case.
IllegalOperationException - if the specified activity instance is a quality assurance instance
QualityAssuranceState.IS_QUALITY_ASSURANCE and the specified user
is the one who worked on the previous workflow instance
@ExecutionPermission(id=joinProcessInstance,
defaults=ALL)
ProcessInstance joinProcessInstance(long processInstanceOid,
long targetProcessInstanceOid,
String comment)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
IllegalOperationException
processInstanceOid - The oid of the process instance which should be aborted and joined into
the target process instance.targetProcessInstanceOid - The oid of the process instance that should be the target of the join.comment - Allows specifying a comment.
org.eclipse.stardust.common.error.ObjectNotFoundException - if the process instance referenced by processInstanceOid or
targetProcessInstanceOid do not exist.
IllegalOperationException - if the source and target are identical.
@ExecutionPermission(id=abortActivityInstances,
scope=activity,
defaults=OWNER)
ActivityInstance abortActivityInstance(long activityInstanceOID)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.ConcurrencyException,
org.eclipse.stardust.common.error.AccessForbiddenException
abortActivityInstance(long, AbortScope) using AbortScope.RootHierarchy
.
Note: Abort is performed asynchronously.
State changes
activityInstanceOID - The OID of the activity instance to be aborted.
ActivityInstance that was aborted.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID in the audit
trail.
org.eclipse.stardust.common.error.ConcurrencyException - if the same activity instance is being processed by another user.
org.eclipse.stardust.common.error.AccessForbiddenException - if the current user is not valid or is not granted access to the activity
instance. Also thrown if the activity instance is already terminated or
if the activity is not allowed to be aborted.AdministrationService.abortProcessInstance(long),
abortActivityInstance(long,
org.eclipse.stardust.engine.core.runtime.beans.AbortScope)
@ExecutionPermission(id=abortActivityInstances,
scope=activity,
defaults=OWNER)
ActivityInstance abortActivityInstance(long activityInstanceOid,
AbortScope abortScope)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.ConcurrencyException,
org.eclipse.stardust.common.error.AccessForbiddenException
Activity.isAbortable()). Additionally it is required that the
aborting user is a valid performing participant for this activity.
Note: Abort is performed asynchronously.
State changes
activityInstanceOid - The OID of the activity instance to be aborted.abortScope - The scope of abortion. You can either choose the current activity or the
entire process hierarchy. AbortScope.SubHierarchy then the specified
activity instance is set to state
ActivityInstanceState.Aborting. The abort itself is performed
asynchronously. If activity instance is a subprocess then the complete
subprocess hierarchy will be aborted. AbortScope.RootHierarchy abortion is done
starting at the root process instance for specified activity instance. The
specified activity instance will be returned unchanged. The state of the
root process instance will be set to
ProcessInstanceState.Aborting. Abort itself will be performed
asynchronously.
ActivityInstance that was aborted.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID in the audit
trail.
org.eclipse.stardust.common.error.ConcurrencyException - if the same activity instance is being processed by another user.
org.eclipse.stardust.common.error.AccessForbiddenException - if the current user is not valid or is not granted access to the activity
instance. Also thrown if the activity instance is already terminated or
if the activity is not allowed to be aborted.AdministrationService.abortProcessInstance(long),
abortActivityInstance(long)
@ExecutionPermission(id=abortProcessInstances,
scope=processDefinition)
ProcessInstance abortProcessInstance(long processInstanceOid,
AbortScope abortScope)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.AccessForbiddenException
State changes:
processInstanceOid - The OID of the process instance to be aborted.abortScope - The scope of abortion. You can abort either the spawned process instance
or the entire process hierarchy.
ProcessInstance that was aborted.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no process instance with the specified OID in the audit
trail.
org.eclipse.stardust.common.error.AccessForbiddenException - if the current user is not valid or is not granted access to abort the
process instance.
@ExecutionPermission(id=readModelData,
defaults=ALL)
DeployedModel getModel()
throws org.eclipse.stardust.common.error.ObjectNotFoundException
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no active model.
@TransientState
@ExecutionPermission(id=readActivityInstanceData,
scope=workitem,
defer=true,
defaults=ALL,
fixed=OWNER,
changeable=false,
administratorOverride=false)
Worklist getWorklist(WorklistQuery query)
query - An instance of class
WorklistQuery
describing the requested view on the worklist.
Worklist making up the requested view on the current user's worklist.
@ExecutionPermission(id=performActivity,
scope=workitem,
defaults=OWNER,
changeable=false,
administratorOverride=false)
ActivityInstance activateNextActivityInstance(WorklistQuery query)
query - worklist query.
ActivityInstance that was activated.
IllegalOperationException - if the specified activity instance is a quality assurance instance
QualityAssuranceState.IS_QUALITY_ASSURANCE and the current user
is the one who worked on the previous workflow instance
@ExecutionPermission(id=performActivity,
scope=activity,
defer=true,
defaults=OWNER,
changeable=false,
administratorOverride=false)
ActivityInstance activateNextActivityInstance(long activityInstanceOID)
throws org.eclipse.stardust.common.error.ObjectNotFoundException
activityInstanceOID - the OID of the last completed activity instance.
ActivityInstance that was activated.
IllegalOperationException - if the specified activity instance is a quality assurance instance
QualityAssuranceState.IS_QUALITY_ASSURANCE and the current user
is the one who worked on the previous workflow instance
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
@ExecutionPermission(id=performActivity,
scope=activity,
defer=true,
defaults=OWNER,
changeable=false,
administratorOverride=false)
ActivityInstance activateNextActivityInstanceForProcessInstance(long processInstanceOID)
throws org.eclipse.stardust.common.error.ObjectNotFoundException
processInstanceOID - the OID of the process instance.
ActivityInstance that was activated.
IllegalOperationException - if the specified activity instance is a quality assurance instance
QualityAssuranceState.IS_QUALITY_ASSURANCE and the current user
is the one who worked on the previous workflow instance
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no process instance with the specified OID.
@ExecutionPermission(id=readProcessInstanceData,
scope=processDefinition,
defaults=ALL)
void setOutDataPath(long processInstanceOID,
String id,
Object object)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.InvalidValueException
processInstanceOID - the OID of the process instance.id - the ID of the data path as defined in the model.object - the value to set on the data path.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no process instance with the specified OID, if there is no
data path with the specified id or if the underlying data is not found.
org.eclipse.stardust.common.error.InvalidValueException - if the object to be written represents an invalid value,
most probably as of a type conflict in case of statically typed data.setOutDataPaths(long, java.util.Map)
@ExecutionPermission(id=readProcessInstanceData,
scope=processDefinition,
defaults=ALL)
void setOutDataPaths(long processInstanceOID,
Map<String,?> values)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.InvalidValueException
processInstanceOID - the OID of the process instance.values - A map of (id, value) pairs to be set, where every ID has to designate a
valid data path as defined in the model.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no process instance with the specified OID, if there is no
data path with the specified id or if the underlying data is not found.
org.eclipse.stardust.common.error.InvalidValueException - if one of the values to be written represents is invalid,
most probably as of a type conflict in case of statically typed data.setOutDataPath(long, String, Object)
@ExecutionPermission(id=readProcessInstanceData,
scope=processDefinition,
defaults=ALL)
Object getInDataPath(long processInstanceOID,
String id)
throws org.eclipse.stardust.common.error.ObjectNotFoundException
processInstanceOID - the OID of the process instance.id - the ID of the data path as defined in the model.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no process instance with the specified OID, if there is no
data path with the specified id or if the underlying data is not found.getInDataPaths(long, java.util.Set)
@ExecutionPermission(id=readProcessInstanceData,
scope=processDefinition,
defaults=ALL)
Map<String,Serializable> getInDataPaths(long processInstanceOID,
Set<String> ids)
throws org.eclipse.stardust.common.error.ObjectNotFoundException
processInstanceOID - the OID of the process instance.ids - the set of data path IDs designating the values to be retrieved. If
null is passed, all IN data paths for the process instance
are retrieved.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no process instance with the specified OID, if there is no
data path with the specified id or if the underlying data is not found.getInDataPath(long, String)
@ExecutionPermission(id=delegateToOther,
scope=activity,
defaults=ALL,
implied=delegateToDepartment)
ActivityInstance delegateToDefaultPerformer(long activityInstanceOID)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.ConcurrencyException,
org.eclipse.stardust.common.error.AccessForbiddenException
activityInstanceOID - the OID of the activity instance.
ActivityInstance that was delegated.
org.eclipse.stardust.common.error.ConcurrencyException - if the same activity instance is being processed by another user.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
org.eclipse.stardust.common.error.AccessForbiddenException - if the activity instance is already terminated.
@ExecutionPermission(id=delegateToOther,
scope=activity,
defaults=ALL,
implied=delegateToDepartment)
ActivityInstance delegateToUser(long activityInstanceOID,
long userOID)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.ConcurrencyException,
org.eclipse.stardust.common.error.AccessForbiddenException,
org.eclipse.stardust.common.error.InvalidArgumentException
activityInstanceOID - the OID of the activity instance.userOID - the OID of the user to which the activity instance will be delegated.
ActivityInstance that was delegated.
org.eclipse.stardust.common.error.ConcurrencyException - if the same activity instance is being processed by another user.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance or user with the specified OIDs.
org.eclipse.stardust.common.error.AccessForbiddenException - if the delegation target is not granted to execute the activity instance
or if the activity instance is already terminated.
org.eclipse.stardust.common.error.AccessForbiddenException - if the delegation target is not granted to execute the activity instance
or if the activity instance is already terminated.
IllegalOperationException - if the specified activity instance is a quality assurance instance
QualityAssuranceState.IS_QUALITY_ASSURANCE and the specified user
is the one who worked on the previous workflow instance
org.eclipse.stardust.common.error.InvalidArgumentException
@ExecutionPermission(id=delegateToOther,
scope=activity,
defaults=ALL,
implied=delegateToDepartment)
ActivityInstance delegateToParticipant(long activityInstanceOID,
String performer)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.ConcurrencyException,
org.eclipse.stardust.common.error.AccessForbiddenException
activityInstanceOID - the OID of the activity instance.performer - the ID of the performer to which the activity instance will be delegated.
ActivityInstance that was delegated.
org.eclipse.stardust.common.error.ConcurrencyException - if the same activity instance is being processed by another user.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
org.eclipse.stardust.common.error.AccessForbiddenException - if the delegation target is not granted to execute the activity instance
or if the activity instance is already terminated.
@ExecutionPermission(id=delegateToOther,
scope=activity,
defaults=ALL,
implied=delegateToDepartment)
ActivityInstance delegateToParticipant(long activityInstanceOID,
ParticipantInfo participant)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.AccessForbiddenException,
org.eclipse.stardust.common.error.InvalidArgumentException
activityInstanceOID - the OID of the activity instance.participant - the participant (model participant, user or user group) to which the
activity instance will be delegated.
ActivityInstance that was delegated.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID or if the
participant is not null and could not be resolved to an actual user user
group or model participant.
org.eclipse.stardust.common.error.AccessForbiddenException - if the activity instance is already terminated or is currently processed
by another user or the current user does not have the required permission
or if the delegation target is not granted to execute the activity
instance or if the activity instance is already terminated.
IllegalOperationException - if the specified activity instance is a quality assurance instance
QualityAssuranceState.IS_QUALITY_ASSURANCE and the specified user
is the one who worked on the previous workflow instance
org.eclipse.stardust.common.error.InvalidArgumentException
@ExecutionPermission(id=readActivityInstanceData,
scope=activity,
defaults=ALL,
fixed=OWNER)
ActivityInstance getActivityInstance(long activityInstanceOID)
throws org.eclipse.stardust.common.error.ObjectNotFoundException
activityInstanceOID - the OID of the activity instance.
ActivityInstance.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
@ExecutionPermission(id=readProcessInstanceData,
scope=processDefinition,
defaults=ALL)
ProcessInstance getProcessInstance(long processInstanceOID)
throws org.eclipse.stardust.common.error.ObjectNotFoundException
processInstanceOID - the OID of the process instance.
ProcessInstance.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no process instance with the specified OID.
@ExecutionPermission(id=readProcessInstanceData,
scope=processDefinition,
defaults=ALL)
Map<String,Serializable> getProcessResults(long processInstanceOID)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.AccessForbiddenException
processInstanceOID - the OID of the process instance.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no process instance with the specified OID.
org.eclipse.stardust.common.error.AccessForbiddenException - if the process instance is not completed, is no scope process instance or
the user does not have the permission to access this process.
@ExecutionPermission(id=manageEventHandlers,
scope=activity,
defaults=ALL)
ActivityInstance bindActivityEventHandler(long activityInstanceOID,
EventHandlerBinding eventHandler)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
BindingException,
org.eclipse.stardust.common.error.InvalidArgumentException
activityInstanceOID - the OID of the activity instance.eventHandler - the specialized form of the event handler to bind.
ActivityInstance.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
BindingException - in case of semantic binding errors.
org.eclipse.stardust.common.error.InvalidArgumentException - in case eventHandler is null.getActivityInstanceEventHandler(long, java.lang.String)
@ExecutionPermission(id=manageEventHandlers,
scope=processDefinition,
defaults=ALL)
ProcessInstance bindProcessEventHandler(long processInstanceOID,
EventHandlerBinding eventHandler)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
BindingException
processInstanceOID - the OID of the process instance.eventHandler - the specialized form of the event handler to bind.
ProcessInstance.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no process instance with the specified OID.
BindingException - in case of semantic binding errors.getProcessInstanceEventHandler(long, java.lang.String)
@ExecutionPermission(id=manageEventHandlers,
scope=activity,
defaults=ALL)
ActivityInstance bindActivityEventHandler(long activityInstanceOID,
String handler)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
BindingException
activityInstanceOID - the OID of the activity instance.handler - the ID of the event handler to bind.
ActivityInstance.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
BindingException - in case of semantic binding errors.
@ExecutionPermission(id=manageEventHandlers,
scope=processDefinition,
defaults=ALL)
ProcessInstance bindProcessEventHandler(long processInstanceOID,
String handler)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
BindingException
processInstanceOID - the OID of the process instance.handler - the ID of the event handler to bind.
ProcessInstance.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no process instance with the specified OID.
BindingException - in case of semantic binding errors.
@ExecutionPermission(id=manageEventHandlers,
scope=activity,
defaults=ALL)
ActivityInstance unbindActivityEventHandler(long activityInstanceOID,
String handler)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
BindingException
activityInstanceOID - the OID of the activity instance.handler - the ID of the event handler to unbind.
ActivityInstance.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
BindingException - in case of semantic binding errors.
@ExecutionPermission(id=manageEventHandlers,
scope=processDefinition,
defaults=ALL)
ProcessInstance unbindProcessEventHandler(long processInstanceOID,
String handler)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
BindingException
processInstanceOID - the OID of the process instance.handler - the ID of the event handler to unbind.
ProcessInstance.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no process instance with the specified OID.
BindingException - in case of semantic binding errors.
@ExecutionPermission(id=manageEventHandlers,
scope=activity,
defaults=ALL)
EventHandlerBinding getActivityInstanceEventHandler(long activityInstanceOID,
String handler)
throws org.eclipse.stardust.common.error.ObjectNotFoundException
activityInstanceOID - the OID of the activity instance.handler - the ID of the event handler.
EventHandlerBinding.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified OID.
@ExecutionPermission(id=manageEventHandlers,
scope=processDefinition,
defaults=ALL)
EventHandlerBinding getProcessInstanceEventHandler(long processInstanceOID,
String handler)
throws org.eclipse.stardust.common.error.ObjectNotFoundException
processInstanceOID - the OID of the process instance.handler - the ID of the event handler.
EventHandlerBinding.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no process instance with the specified OID.
@ExecutionPermission(id=readModelData,
scope=activity,
defer=true,
defaults=ALL)
List<TransitionTarget> getAdHocTransitionTargets(long activityInstanceOid,
TransitionOptions options,
ScanDirection direction)
throws org.eclipse.stardust.common.error.ObjectNotFoundException
activityInstanceOid - the oid of the activity instance from where the transition will be
performed.options - search options, if null then TransitionOptions.DEFAULT will be used.direction - TODO
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified oid.
@ExecutionPermission(id=performActivity,
scope=activity,
defaults=OWNER)
ActivityInstance performAdHocTransition(long activityInstanceOid,
TransitionTarget target,
boolean complete)
throws IllegalOperationException,
org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.AccessForbiddenException
performAdHocTransition(TransitionTarget, boolean)
activityInstanceOid - the oid of the activity instance from where the transition will be
performed.target - the transition target.complete - true if the activity instance specified should be completed, false if the
activity should be aborted.
IllegalOperationException - if the transition could not be performed because the specified
TransitionTarget did not originate from the specified activity instance,
or the process instance containing the activity instance has more than
one active activity instance.
org.eclipse.stardust.common.error.AccessForbiddenException - if the current user is not allowed to perform the ad-hoc transition, or
the activity instance was already terminated.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified oid.
@ExecutionPermission(id=performActivity,
scope=activity,
defaults=OWNER)
TransitionReport performAdHocTransition(TransitionTarget target,
boolean complete)
throws IllegalOperationException,
org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.AccessForbiddenException
target - the transition target.complete - true if the activity instance specified should be completed, false if the
activity should be aborted.
IllegalOperationException - if the transition could not be performed because the specified
TransitionTarget did not originate from the specified activity instance,
or the process instance containing the activity instance has more than
one active activity instance.
org.eclipse.stardust.common.error.AccessForbiddenException - if the current user is not allowed to perform the ad-hoc transition, or
the activity instance was already terminated.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no activity instance with the specified oid.
@ExecutionPermission(id=readModelData,
defaults=ALL)
List<ProcessDefinition> getStartableProcessDefinitions()
ProcessDefinition objects.@ExecutionPermission User getUser()
@ExecutionPermission List<Permission> getPermissions()
@ExecutionPermission(id=modifyAttributes,
scope=processDefinition,
defaults=ALL)
void setProcessInstanceAttributes(ProcessInstanceAttributes attributes)
throws org.eclipse.stardust.common.error.ObjectNotFoundException
ProcessInstanceAttributes instance is applied to this method it is discouraged to
use this same instance again. Any new note which has been added by the first use
will be added again. In order to add new notes to a certain process instance a fresh
ProcessInstance has to be retrieved
(e.g. by getProcessInstance(long)). Get a current copy of
ProcessInstanceAttributes by
ProcessInstance.getAttributes().
attributes - the container of attributes.
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no process instance with the specified OID.
org.eclipse.stardust.common.error.PublicException - if the process instance is no scope process instance.
org.eclipse.stardust.common.error.InvalidArgumentException - if attributes is null.
@ExecutionPermission(id=modifyAttributes,
scope=activity,
defaults=ALL)
void setActivityInstanceAttributes(ActivityInstanceAttributes attributes)
throws org.eclipse.stardust.common.error.ObjectNotFoundException,
org.eclipse.stardust.common.error.InvalidArgumentException
attributes - - the attributes to set
org.eclipse.stardust.common.error.ObjectNotFoundException - - if the activity instance specified by ActivityInstanceAttributes.getActivityInstanceOid() could no be found.
org.eclipse.stardust.common.error.InvalidArgumentException - - when a result is set (ActivityInstanceAttributes.getQualityAssuranceResult() and the codes
list(QualityAssuranceResult.getQualityAssuranceCodes() contains a
null element
org.eclipse.stardust.common.error.InvalidArgumentException - - when the specified quality assurance ActivityInstanceAttributes.getActivityInstanceOid() instance is marked
as ResultState.PASS_WITH_CORRECTION or ResultState.FAILED, the corresponding activity for this activity
instance supplies error codes IActivity.getQualityAssuranceCodes() and no error code was supplied
@ExecutionPermission(id=modifyAuditTrailStatistics)
void writeLogEntry(LogType logType,
ContextKind contextType,
long contextOid,
String message,
Throwable throwable)
throws org.eclipse.stardust.common.error.ObjectNotFoundException
LogCode.EXTERNAL.
logType - Set the type of log (info, warn, error etc.). Whereas the
Unknown type is mapped to a warning.contextType - Set the context scope of the eventcontextOid - Oid of the runtime object (only used if context type is set to
ProcessInstance or ActivityInstance)message - any message that should be loggedthrowable - any exception (or null) that should be appended to the message
org.eclipse.stardust.common.error.ObjectNotFoundException - if there is no runtime object with the specified OID
@ExecutionPermission
Serializable execute(ServiceCommand serviceCmd)
throws org.eclipse.stardust.common.error.ServiceCommandException
ServiceCommand in a single engine transaction.
If the service command implements
Configurable
, the following option may be provided:
Boolean
object. The default value is
Boolean.FALSE.
serviceCmd - the ServiceCommand to be executed.
null if the command has no
result.
org.eclipse.stardust.common.error.ServiceCommandException - that encapsulates any exception thrown during the execution of the
command.
@ExecutionPermission(id=modifyDataValues,
scope=data,
defer=true,
defaults=ALL)
org.eclipse.stardust.engine.api.runtime.BusinessObject createBusinessObjectInstance(String qualifiedBusinessObjectId,
Object initialValue)
qualifiedBusinessObjectId - the qualified id of the business object.initialValue - the initial value of the business instance (can be null).
org.eclipse.stardust.common.error.ObjectExistsException - if BO already exists.
@ExecutionPermission(id=modifyDataValues,
scope=data,
defer=true,
defaults=ALL)
org.eclipse.stardust.engine.api.runtime.BusinessObject updateBusinessObjectInstance(String qualifiedBusinessObjectId,
Object newValue)
qualifiedBusinessObjectId - the qualified id of the business object.newValue - the new value of the business instance (can be null).
@ExecutionPermission(id=modifyDataValues,
scope=data,
defer=true,
defaults=ALL)
void deleteBusinessObjectInstance(String qualifiedBusinessObjectId,
Object primaryKey)
qualifiedBusinessObjectId - the qualified id of the business object.primaryKey - the primary key identifying the instance to be deleted.
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||