Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.fujitsu.iflow.model.workflow
Interface WFAdminSession

All Superinterfaces:
  WFSession

public interface WFAdminSession
extends WFSession

The `WFAdminSession` interface is an extension of `WFSession`. The functions inherited from `WFSession` allow for initial access to the server.

This interface represents a login session of an Interstage BPM administrator. It offers an additional set of functionality that can be performed by administrators only. The functions can be categorized as follows:

- User and System Management: includes the reloading of LDAP user data and updating Interstage BPM system properties.
- Process Definition Management: includes the deleting and archiving of process definitions, which requires administration rights. In addition, process definitions can only be published for all Interstage BPM users by an administrator.
- Process Instance Management: includes the deleting and archiving of process instances.

The standard way of constructing a new `WFAdminSession` object is to call the method `WFObjectFactory.getWFAdminSession`. It is necessary that a user logs into this session by calling the method `login` of the `WFSession` interface before any operation of this interface is executed.

The `String` parameters of all methods in this class have a length limit. This limit is documented in the Javadoc descriptions for every parameter. If the length of a value supplied for such a parameter exceeds this limit or the value is `null`, an exception is thrown. This exception is a subclass of the `ModelException` class. For future compatibility, only a `ModelException` should be caught explicitly.

If the signature of a method does not allow the throwing of exceptions, any value supplied to this method that exceeds the length limit is truncated to the maximum length supported. `null` values are ignored in this case. Any method’s behaviour that differs from the behaviour described above is explained in the respective method’s Javadoc description.

See Also:
  `WFObjectFactory`, `Plan`, `ProcessInstance`, `UserInfo`

Method Summary
`void` | `archiveClosedProcess(long processID)` Archives the process instance (`ProcessInstance` object) specified by the ID.
`long[]` | `archiveClosedProcesses(java.util.Date start, java.util.Date end)` Archives the process instances which have been closed between the specified start and end date, inclusively.
`long[]` | `archiveClosedProcesses(long[] processIDs)` Archives the list of processes instances specified by the array of IDs.
`void` | `archivePlan(long planID)` Archives the process definition (`Plan` object) specified by the ID.
`long[]` | `archivePlans(long[] planIDs)` Archives the list of process definitions specified by the array of IDs.
`Plan` | `createPlanFromXML(java.lang.String archivedPlanXML)` Creates a process definition from an XML string.
`long` | `createPlanVersion(java.lang.String planName, java.lang.String versionComment)` Creates a copy (new version) of the latest version of an existing process definition specified by `planName`.
`long` | `createPlanVersion(java.lang.String planName, java.lang.String versionComment, Plan parentPlan)` Creates a copy of the provided process definition (`parentPlan`) by the given `planName`.
`long` | `createPlanVersion(java.lang.String planName, java.lang.String versionComment, java.lang.String parentVersion)` Creates a copy (new version) of an existing process definition specified by the `planName` and the `parentVersion`.
`void` | `deletePlan(long planID)` Deletes the specified process definition (`Plan` object) from the database.
`void` | `deleteProcessInstance(long processInstanceID)` Deletes the specified process instance (`ProcessInstance` object) from the database.
`UserInfo[]` | `getAllUserAgentInfo()` Returns an array of `UserInfo` objects representing the user agent information for all users.
`Plan` | `getArchivedPlan(long planID)` Returns the archived process definition identified by its unique ID.
`java.lang.String` | `getArchivedPlanXML(long planID)` Returns the archived process definition specified by its ID in XML format.
`ProcessInstance` | `getArchivedProcess(long processID)` Returns the archived process instance specified by the ID.
`java.lang.String` | `getArchivedProcessXML(long processID)` Returns the archived process instance specified by its ID in XML format.
`DataItem[]` | `getOptimizedWorkListUDAs()` Returns the List of all optimized WorkList User Defined Attribute (UDA).
`Plan` | `getPlanFromXML(java.lang.String archivedPlanXML)` Returns the process definition recovered from the XML string.
`ProcessInstance` | `getProcessFromXML(java.lang.String archivedProcessXML)` Returns the process instance recovered from the XML string (for process viewing only).
`void` | `logoutAllUsers()` Logs out all users registered as connected.
`void` | `logoutUser(long clientID)` Disconnects the session of a user, given a specific `clientID`.
`ProcessMigrationResult` | `migrateProcess(long[] instanceIds, long newDefinitionId, boolean markAsError)` Migrates a batch of existing running process instances to a new process defined in a new process definition.
`void` | `obsoletePlan(long planID)` Changes the state of a process definition to state `Plan.STATE_OBSOLETE`.
`void` | `publishPlan(long planId)` Publishes the specified process definition.
`boolean` | `reassign(java.lang.String currentAssignee, java.lang.String newAssignee, long procInstId, long workItemId, boolean changeOwner)` Reassigns a work item to the specified user and updates the ownership, if defined.
`void` | `recoverEvents(java.lang.String serverName)` Recovers the unhandled timer events and enactment events that were created by the failed server.
`java.lang.String` | `refreshWIforGroup(java.lang.String role, boolean ignoreActivityWithRoleScript)` Updates the work items of a specified group and returns the result of this refreshing.
`java.lang.String` | `refreshWIforPlan(long planId, boolean ignoreActivityWithRoleScript)` Updates the work items of a specified process definition and returns the result of this refreshing.
`java.lang.String` | `refreshWIforProcess(long procInstId, boolean ignoreActivityWithRoleScript)` Updates the work items of a specified process instance and returns the result of this refreshing.
`java.lang.String` | `refreshWorkItems(boolean ignoreActivityWithRoleScript)` Updates all active work items and returns the result of this refreshing.
`void` | `replaceOptimizedWorkListUDA(java.lang.String newUdaName, java.lang.String oldUdaName, java.lang.String oldUdatype)` This will allow user to replace an existing optimized Worklist UDA with a new Worklist uda of similar type.
`void` | `resetLDAPGroupsList()` Resets the cached memory objects of Interstage BMP groups.
`void` | `resetLDAPUsersList()` Resets the cached memory objects of Interstage BPM users.
`java.lang.String` | `savePlanToXML(long planID)` Converts the process definition specified by the ID to an XML string and returns it.
`java.lang.String` | `saveProcessToXML(long processID)` Converts the process specified by the ID to an XML string and returns it.
`void` | `syncUpWithRepository()` Synchronizes the the Interstage BPM environment with the UDDI and WebDAV-compliant Repository.
`void` | `updateIflowProperties(java.util.Properties iflowProperties)` Updates the Interstage BPM parameters with the new values, specified by pairs of parameter name and parameter value.

Methods inherited from interface com.fujitsu.iflow.model.workflow.WFSession
`checkWFAppManifest, dumpServerStatistics, getDashboard, getPlanVersionHistory, getServerList, getServerOption, getUserName, getWFAppManifest, initForApplet, initForApplet, initForApplication, initForApplication, installWFApp, logIn, logOut, packageWFApp, reconnect, setNamingContext, setNamingContext2, setServerIOR, shutdown, validateSession`

Method Detail

### logoutAllUsers

    public void logoutAllUsers()
                        throws ModelException

  Logs out all users registered as connected. This method provides a basic garbage collection method, since there are many instances where a user might not log off before closing or crashing a browser. Schedule this method for a time when no users will be logged in.

  Throws:
    `ModelException`

### logoutUser

    public void logoutUser(long clientID)
                    throws ModelException

  Disconnects the session of a user, given a specific `clientID`.

  After disconnecting a session, the Server automatically tries to generate a new session for the user (=reconnect). This means, calling this method normally does not logout a user but disconnects the actual session and generates a new one.

  There are two scenarios how you can use this function:

  1. Hung session: If for some reason a user disconnects but the server does not know about it, the session could be hanging around.
  2. Immediate revocation of service: If you want to lock someone out of the system immediately. You need to do two things: disable the user account (either change the password, or make the user a non-BPM user) and THEN forcibly log out the user. This will force the client to attempt to re-login, but since the user is disabled, log in will be prevented.

  Parameters:
    `clientID` - The unique identifier associated with the user's session to be disconnected out.
  Throws:
    `ModelException`
  See Also:
    `UserInfo.getClientID()`

### getAllUserAgentInfo

    public UserInfo[] getAllUserAgentInfo()
                                   throws ModelException

  Returns an array of `UserInfo` objects representing the user agent information for all users. If there are no users, an empty array is returned.

  Returns:
    The `UserInfo` objects of all users.
  Throws:
    `ModelException`

### deletePlan

    public void deletePlan(long planID)
                    throws ModelException

  Deletes the specified process definition (`Plan` object) from the database.

  To be totally removed from the database, the process definition must be in state `Plan.STATE_DRAFT` or `Plan.STATE_PRIVATE`. If the process definition is in any other state, calling this method will set it to state `Plan.STATE_DELETED`; the process definition will not be physically deleted from the database.

  Specified by:
    `deletePlan` in interface `WFSession`
  Parameters:
    `planID` - The unique identifier of the process definition to be deleted
  Throws:
    `ModelException`

### deleteProcessInstance

    public void deleteProcessInstance(long processInstanceID)
                               throws ModelException

  Deletes the specified process instance (`ProcessInstance` object) from the database.

  Parameters:
    `processInstanceID` - The unique identifier of the process instance to be deleted
  Throws:
    `ModelException`

### archivePlan

    public void archivePlan(long planID)
                     throws ModelException

  Archives the process definition (`Plan` object) specified by the ID.

  The archiving of a process definition is not possible if its state is `Plan.STATE_PUBLISHED`. To archive a process definition in this state, it must be deleted first (changes its state to `Plan.STATE_DELETED`).

  Parameters:
    `planID` - The unique identifier of the process definition to be archived.
  Throws:
    `ModelException`

### archiveClosedProcess

    public void archiveClosedProcess(long processID)
                              throws ModelException

  Archives the process instance (`ProcessInstance` object) specified by the ID.

  The process instance should have been closed before archiving, i.e., completed, aborted or terminated.

  Parameters:
    `processID` - The unique identifier of the process instance to be archived
  Throws:
    `ModelException`

### archiveClosedProcesses

    public long[] archiveClosedProcesses(long[] processIDs)
                                  throws ModelException

  Archives the list of processes instances specified by the array of IDs. The processes should have been closed, i.e., completed, aborted or terminated.

  The process instances are archived one after the other in the order of supplied IDs. If any process instance within the array cannot be archived, this method fails and throws an exception. The process instances prior to the one that causes the error will nevertheless be archived.

  Parameters:
    `processIDs` - An array of IDs identifying the `ProcessInstance` objects to be archived.
  Returns:
    An array of IDs that specifies the process instances that have been archived successfully.
  Throws:
    `ModelException`
  See Also:
    `archiveClosedProcess(long)`

### archivePlans

    public long[] archivePlans(long[] planIDs)
                        throws ModelException

  Archives the list of process definitions specified by the array of IDs. This call archives all the process definitions whose IDs are passed in the array.

  The process definitions are archived one after the other in the order of supplied IDs. If any process definition within the array cannot be archived, this method fails and throws an exception. The process definitions prior to the one that caused the error will nevertheless be archived.

  Parameters:
    `planIDs` - An array of IDs identifying the process definitions to be archived
  Returns:
    An array of IDs that specifies the process definitions that have been archived successfully.
  Throws:
    `ModelException`
  See Also:
    `archivePlan(long)`

### archiveClosedProcesses

    public long[] archiveClosedProcesses(java.util.Date start,
                                         java.util.Date end)
                                  throws ModelException

  Archives the process instances which have been closed between the specified start and end date, inclusively.

  The process instances are archived one after the other. If any process instance within the array cannot be archived, this method fails and throws an exception. The process instances prior to the one that caused the error, will nevertheless be archived.

  Parameters:
    `start` - Date of closing processes from where to start archiving
    `end` - Date of closing processes until archiving is executed
  Returns:
    An array of IDs that specifies the process instances that have been archived successfully.
  Throws:
    `ModelException`

### getArchivedPlan

    public Plan getArchivedPlan(long planID)
                         throws ModelException

  Returns the archived process definition identified by its unique ID.

  Irrespective of the process definition's state when it was archived, the `Plan` object returned by this call supports read and copy operations only.

  Parameters:
    `planID` - The ID that identifies the process definition to be retrieved
  Returns:
    The archived process definition
  Throws:
    `ModelException` - Thrown when no process definition exists for the supplied id.
  See Also:
    `archivePlan(long)`

### getArchivedProcess

    public ProcessInstance getArchivedProcess(long processID)
                                       throws ModelException

  Returns the archived process instance specified by the ID.

  The `ProcessInstance` object returned by this call is different only supports read operations.

  Parameters:
    `processID` - The ID that identifies the process instance to be retrieved.
  Returns:
    The archived process instance
  Throws:
    `ModelException` - Thrown when no process instance exists for the supplied id.
  See Also:
    `archiveClosedProcess(long)`

### getArchivedProcessXML

    public java.lang.String getArchivedProcessXML(long processID)
                                           throws ModelException

  Returns the archived process instance specified by its ID in XML format.

  Parameters:
    `processID` - The ID that identifies the process instance to be retrieved.
  Returns:
    The process instance in XML format.
  Throws:
    `ModelException`

### getArchivedPlanXML

    public java.lang.String getArchivedPlanXML(long planID)
                                        throws ModelException

  Returns the archived process definition specified by its ID in XML format.

  Parameters:
    `planID` - The ID that identifies the archived process definition.
  Returns:
    The archived process definition in XML format.
  Throws:
    `ModelException`

### getProcessFromXML

    public ProcessInstance getProcessFromXML(java.lang.String archivedProcessXML)
                                      throws ModelException

  Returns the process instance recovered from the XML string (for process viewing only).

  This API rebuilds the process in the Client Model for overview display. It does not instantiate the process on the Server side, and it does not allow continued execution or re-execution of the process.

  Parameters:
    `archivedProcessXML` - The XML string to be recovered.
  Returns:
    The process instance generated from the XML data.
  Throws:
    `ModelException`

### getPlanFromXML

    public Plan getPlanFromXML(java.lang.String archivedPlanXML)
                        throws ModelException

  Returns the process definition recovered from the XML string.

  Parameters:
    `archivedPlanXML` - The XML string to be recovered.
  Returns:
    The process definition generated from the XML data.
  Throws:
    `ModelException`

### saveProcessToXML

    public java.lang.String saveProcessToXML(long processID)
                                      throws ModelException

  Converts the process specified by the ID to an XML string and returns it.

  Parameters:
    `processID` - The ID that specifies the process to be retrieved.
  Returns:
    The process in XML format.
  Throws:
    `ModelException`

### savePlanToXML

    public java.lang.String savePlanToXML(long planID)
                                   throws ModelException

  Converts the process definition specified by the ID to an XML string and returns it.

  Parameters:
    `planID` - The ID that specifies the process definition to be retrieved.
  Returns:
    The process definition in XML format.
  Throws:
    `ModelException`

### createPlanFromXML

    public Plan createPlanFromXML(java.lang.String archivedPlanXML)
                           throws ModelException

  Creates a process definition from an XML string.

  Parameters:
    `archivedPlanXML` - The XML string to be used to create the process definition.
  Returns:
    The process definition generated from the XML data.
  Throws:
    `ModelException`

### obsoletePlan

    public void obsoletePlan(long planID)
                      throws ModelException

  Changes the state of a process definition to state `Plan.STATE_OBSOLETE`. To make a process definition obsolete can be used for marking it to be no longer in use.

  Parameters:
    `planID` - The unique identifier of the process definition to be marked as obsolete
  Throws:
    `ModelException`

### createPlanVersion

    public long createPlanVersion(java.lang.String planName,
                                  java.lang.String versionComment)
                           throws ModelException

  Creates a copy (new version) of the latest version of an existing process definition specified by `planName`.

  The name of the plan must not be longer than specified in `Plan.MAX_PLAN_NAME_LENGTH` and the version comment is limited to the number of characters specified by the constant `PlanVersionHistoryElement.MAX_PLAN_VERSION_COMMENT_LENGTH`.

  Parameters:
    `planName` - The name of the process definition for which the new version is to be created.
    `versionComment` - An optional comment to describe the reason for creating the new version of the process definition.
  Returns:
    The unique ID of the newly created process definition version.
  Throws:
    `ModelException` - Thrown when the supplied `planName` is invalid or `null`, or the versionComment exceeds the length limitation.

### createPlanVersion

    public long createPlanVersion(java.lang.String planName,
                                  java.lang.String versionComment,
                                  java.lang.String parentVersion)
                           throws ModelException

  Creates a copy (new version) of an existing process definition specified by the `planName` and the `parentVersion`.

  The `parentVersion` parameter defines the version number of the parent process definition to generate a copy from. The format of this value must be, for example, '1.0' to specify that version 1 is to be used.

  The `planName` must not be longer than specified in `Plan.MAX_PLAN_NAME_LENGTH` and the version comment is limited to the number of characters specified by the constant `PlanVersionHistoryElement.MAX_PLAN_VERSION_COMMENT_LENGTH`.

  Parameters:
    `planName` - The name of the new process definition.
    `versionComment` - An optional comment to describe the reason for creating a new version of the process definition.
    `parentVersion` - The version number of the parent process definition formatted as `String` such as '1.0' or '2.0'.
  Returns:
    The unique ID of the newly created process definition version.
  Throws:
    `ModelException` - Thrown when the supplied `planName` or parentVersion is invalid or `null`, or the versionComment exceeds the length limitation.

### createPlanVersion

    public long createPlanVersion(java.lang.String planName,
                                  java.lang.String versionComment,
                                  Plan parentPlan)
                           throws ModelException

  Creates a copy of the provided process definition (`parentPlan`) by the given `planName`.

  There is no relationship between the new created process definition and the provided one. Also the `planName` can be different from the supplied `parentPlan`. To create a new version of a process definition use the method `createPlanVersion(String, String)` or `createPlanVersion(String, String, String)`

  The `planName` must not be longer than specified in `Plan.MAX_PLAN_NAME_LENGTH` and the version comment is limited to the number of characters specified by the constant `PlanVersionHistoryElement.MAX_PLAN_VERSION_COMMENT_LENGTH`.

  Parameters:
    `planName` - The name of the new process definition.
    `versionComment` - An optional comment to describe the reason for creating a new version of the process definition.
    `parentPlan` - The process definition from which the copy is generated.
  Returns:
    The unique ID of the newly created process definition.
  Throws:
    `ModelException` - Thrown when the supplied `planName` is invalid or `null`, or the versionComment exceeds the length limitation.

### publishPlan

    public void publishPlan(long planId)
                     throws ModelException

  Publishes the specified process definition. The state of the process definition is changed to `Plan.STATE_PUBLISHED`.

  Parameters:
    `planId` - The ID of the process definition to be published
  Throws:
    `ModelException`

### reassign

    public boolean reassign(java.lang.String currentAssignee,
                            java.lang.String newAssignee,
                            long procInstId,
                            long workItemId,
                            boolean changeOwner)
                     throws ModelException

  Reassigns a work item to the specified user and updates the ownership, if defined.

  The `newAssignee` parameter is limited to the number of characters specified by `DirectoryServices.MAX_DIR_NAME_LENGTH` and must not contain a comma ('`,`') character.

  Parameters:
    `currentAssignee` - User's name who is currently assigned to the work item.
    `newAssignee` - User's name who is the new assignee of the specified work item.
    `procInstId` - The unique identifier of the process instance the work item belongs to.
    `workItemId` - The ID that identifies the work item to be reassigned.
    `changeOwner` - `true` to change the owner of the process instance from the current assignee to the new assignee; `false` otherwise.
  Throws:
    `ModelException` - When the specified assignees are invalid, e.g. the length exceeds the limiation or the length of value is 0, or `null` or if the current.

### resetLDAPUsersList

    public void resetLDAPUsersList()
                            throws ModelException

  Resets the cached memory objects of Interstage BPM users. Any modification to Interstage BPM users in LDAP will be retrieved to the memory object.

  Throws:
    `ModelException`

### resetLDAPGroupsList

    public void resetLDAPGroupsList()
                             throws ModelException

  Resets the cached memory objects of Interstage BMP groups. Any modification to Interstage BPM groups in LDAP will be retrieved to the memory object.

  Throws:
    `ModelException`

### recoverEvents

    public void recoverEvents(java.lang.String serverName)
                       throws ModelException

  Recovers the unhandled timer events and enactment events that were created by the failed server.

  Parameters:
    `serverName` - The name of the failed server in a clustered environment.
  Throws:
    `ModelException` - Thrown if the supplied serverName is invalid, e.g. if the length of name is 0 or if it contains only blanks. Furthermore the exception is thrown if the serverName is `null`.

### updateIflowProperties

    public void updateIflowProperties(java.util.Properties iflowProperties)
                               throws ModelException

  Updates the Interstage BPM parameters with the new values, specified by pairs of parameter name and parameter value.

  You can find a list of supported parameters in the Interstage Business Process Manager Administration Guide, Appendix A: "Manually Editing the ibpm.properties File".

  To get the current values of parameters use method `WFSession.getServerOption(String)`

  Note: This method is only available in Enterprise Edition of Interstage BPM.

  Parameters:
    `iflowProperties` - A list of key-value combinations defining the new values of parameters.
  Throws:
    `ModelException`

### migrateProcess

    public ProcessMigrationResult migrateProcess(long[] instanceIds,
                                                 long newDefinitionId,
                                                 boolean markAsError)
                                          throws ModelException

  Migrates a batch of existing running process instances to a new process defined in a new process definition.

  If one or more of the supplied processes are invalid, the migration will proceed nevertheless. The returned Migration result will contain information about the success or failure for each supplied process instance.

  Parameters:
    `instanceIds` - The IDs of process instances that are to be migrated.
    `newDefinitionId` - The ID of the new process definition.
    `markAsError` - `true` if the running process instances is to be marked as error state if migration failed, `false` otherwise.
  Returns:
    ProcessMigrationResult The result of the migration.
  Throws:
    `ModelException` - Thrown when the supplied list of instance ids is `null` or if one or more elements of the supplied list is `null`.

### syncUpWithRepository

    public void syncUpWithRepository()
                              throws ModelException

  Synchronizes the the Interstage BPM environment with the UDDI and WebDAV-compliant Repository.

  Synchronization works only if a UDDI and WebDAV-compliant Repository is configured for use by Interstage BPM in the ibpm.properties.

  When a process definition is published in Interstage BPM, it is automatically published to the Repository. If the connection between Interstage BPM and the Repository should be broken for any reason, the definitions published in Interstage BPM, and those published in the Repository could get out of sync and calling this API will synchronize them.

  Following are two samples when this synchronisation could be useful:

  1. Definition One and Definition Two are published in both Interstage BPM and the Repository. As Definition Three is being published in Interstage BPM, the connection is lost between Interstage BPM and the Repository. The process definition will be published in Interstage BPM, but not in the Repository. With the synchronization, Interstage BPM will compare the definitions published in Interstage BPM with the definitions published in the Repository. The comparison will reveal that Definition Three is not in the Repository, so Definition Three will be published to the Repository.
  2. Interstage BPM and the Repository are installed, but not connected. Definitions one through three are published in Interstage BPM. Because there is no connection between Interstage BPM and the Repository, there are no process definitions published in the Repository. If you were to subsequently connect Interstage BPM, and the Repository, calling this API would publish definitions one through three to the Repository.

  Further actions performed by the synchronization:

  - Command Line Web Service or also called Interstage BPM Web Service
  - publication of the WF-XML Registry Web Service
  These actions are not actually synchronization actions, but one-time only publications of Web Services related to Interstage BPM.

  Throws:
    `ModelException`

### refreshWIforProcess

    public java.lang.String refreshWIforProcess(long procInstId,
                                                boolean ignoreActivityWithRoleScript)
                                         throws ModelException

  Updates the work items of a specified process instance and returns the result of this refreshing.

  This operation is only allowed for Interstage BPM users who have administrator privileges.

  All active activities of the specified process instance are checked, ignoring those activities containing a Role Script (if specified) or a JavaAction. Within the check, new work items are generated for those users who became members of the role after the activity first became active. Work items of users who are no longer part of the role are deleted. All the other work items are not changed.

  The returned data represent the results of the refreshing. The format is:

       <?xml version="1.0 encoding="UTF-8" ?>
       <Processes>
           <success>
              <Process Name="..." id="..."></Process>
           </success>

           <failed>
               <Process Name="..." id="..." Status="ignored" message="..."></Process>
               <Process Name="..." id="...">
                  <Activities>
                     <Activity Id="..." Name="..." Status="ignored" message="..."></Activity>
                  </Activities>
               </Process>
           </failed>
       </Processes>

  In the section success all successful refreshed process instances are listed with their name and id. The section failed contains the list of process instances that failed to be updated and/or the failed activities related to a process instance.

  Parameters:
    `procInstId` - The unique identifier of the process instance whose active work items are to be refreshed.
    `ignoreActivityWithRoleScript` - `true` when activities with Role JavaActions shall not be refreshed; `false` otherwise.
  Returns:
    The result of the refreshing, formatted as XML String.
  Throws:
    `ModelException`

### refreshWorkItems

    public java.lang.String refreshWorkItems(boolean ignoreActivityWithRoleScript)
                                      throws ModelException

  Updates all active work items and returns the result of this refreshing.

  This operation is only allowed for Interstage BPM users who have administrator privileges.

  All active activities are checked, ignoring those activities containing a Role Script (if specified) or a JavaAction. Within the check, new work items are generated for those users who became members of the Role after the activity first became active. Work items of users who are no longer part of the Role are deleted. All the other work items are not changed.

  The returned data represent the results of the refreshing. The format is:

       <?xml version="1.0 encoding="UTF-8" ?>
       <Processes>
           <success>
              <Process Name="..." id="..."></Process>
           </success>

           <failed>
               <Process Name="..." id="..." Status="ignored" message="..."></Process>
               <Process Name="..." id="...">
                  <Activities>
                     <Activity Id="..." Name="..." Status="ignored" message="..."></Activity>
                  </Activities>
               </Process>
           </failed>
       </Processes>

  In the section success all successful refreshed process instances are listed with their name and id. The section failed contains the list of process instances that failed to be updated and/or the failed activities related to a process instance.

  Parameters:
    `ignoreActivityWithRoleScript` - `true` when activities with Role JavaActions shall not be refreshed; `false` otherwise.
  Returns:
    The result of the refreshing, formatted as XML String.
  Throws:
    `ModelException`

### refreshWIforGroup

    public java.lang.String refreshWIforGroup(java.lang.String role,
                                              boolean ignoreActivityWithRoleScript)
                                       throws ModelException

  Updates the work items of a specified group and returns the result of this refreshing.

  This operation is only allowed for Interstage BPM users who have administrator privileges.

  All active activities assigned to the specified Role are checked, ignoring those activities containing a Role Script (if specified) or a JavaAction. Within the check, new work items are generated for those users who became members of the Role after the activity first became active. Work items of users who are no longer part of the Role are deleted. All the other work items are not changed.

  The returned data represent the results of the refreshing. The format is:

       <?xml version="1.0 encoding="UTF-8" ?>
       <Processes>
           <success>
              <Process Name="..." id="..."></Process>
           </success>

           <failed>
               <Process Name="..." id="..." Status="ignored" message="..."></Process>
               <Process Name="..." id="...">
                  <Activities>
                     <Activity Id="..." Name="..." Status="ignored" message="..."></Activity>
                  </Activities>
               </Process>
           </failed>
       </Processes>

  In the section success all successful refreshed process instances are listed with their name and id. The section failed contains the list of process instances that failed to be updated and/or the failed activities related to a process instance.

  Parameters:
    `role` - The name of Role whose work item are to be refreshed.
    `ignoreActivityWithRoleScript` - `true` when activities with Role Java Actions shall not be refreshed; `false` otherwise.
  Returns:
    The results of the refreshing, formatted as XML String.
  Throws:
    `ModelException` - Thrown when the supplied role is invalid (e.g. the length is 0) or `null`.

### refreshWIforPlan

    public java.lang.String refreshWIforPlan(long planId,
                                             boolean ignoreActivityWithRoleScript)
                                      throws ModelException

  Updates the work items of a specified process definition and returns the result of this refreshing.

  This operation is only allowed for Interstage BPM users who have administrator privileges.

  All active activities of process instances that have been started from the specified process definition are checked, ignoring those activities containing a Role Script (if specified) or a JavaAction. Within the check, new work items are generated for those users who became members of the Role after the activity first became active. Work items of users who are no longer part of the Role are deleted. All the other work items are not changed.

  The returned data represent the results of the refreshing. The format is:

       <?xml version="1.0 encoding="UTF-8" ?>
       <Processes>
           <success>
              <Process Name="..." id="..."></Process>
           </success>

           <failed>
               <Process Name="..." id="..." Status="ignored" message="..."></Process>
               <Process Name="..." id="...">
                  <Activities>
                     <Activity Id="..." Name="..." Status="ignored" message="..."></Activity>
                  </Activities>
               </Process>
           </failed>
       </Processes>

  In the section success all successful refreshed process instances are listed with their name and id. The section failed contains the list of process instances that failed to be updated and/or the failed activities related to a process instance.

  Parameters:
    `planId` - The unique identifier of the process definition whose process instances are to be controlled.
    `ignoreActivityWithRoleScript` - `true` when activities with Role JavaActions shall not be refreshed; `false` otherwise.
  Returns:
    The result of the refreshing, formatted as XML String.
  Throws:
    `ModelException`

### getOptimizedWorkListUDAs

    public DataItem[] getOptimizedWorkListUDAs()
                                        throws ModelException

  Returns the List of all optimized WorkList User Defined Attribute (UDA).

  Maximum 250 WorkList UDAs can be optimized for fast retrieval as part of WorkList(specially useful for using advance UDA filtering). System automatically select the first 250 WorkList UDAs as optimized. Subsequent WorkList UDAs will not be optimized. Based on UDA type 250 WorkList UDAs are distributed in following categories 100 - Shared by all DataItemRef.TYPE_STRING and DataItemRef.TYPE_BIGDECIMAL UDAs 100 - Shared by all DataItemRef.TYPE_INTEGER, DataItemRef.TYPE_LONG, DataItemRef.TYPE_BOOLEAN, and DataItemRef.TYPE_DATE UDAs 50 - Shared by all DataItemRef.TYPE_FLOAT UDAs

  Returns:
    List of all optimized WorkList UDA.
  Throws:
    `ModelException`

### replaceOptimizedWorkListUDA

    public void replaceOptimizedWorkListUDA(java.lang.String newUdaName,
                                            java.lang.String oldUdaName,
                                            java.lang.String oldUdatype)
                                     throws ModelException

  This will allow user to replace an existing optimized Worklist UDA with a new Worklist uda of similar type. Specially useful when all 250 optimized WorkList UDA is assigned and any more new worklist UDAs can not be optimized, the only option is to replace an existing one. getOptimizedWorkListUDAs() can be called to get the list of available optimized WorkList UDA. After replacing, the new WorkList UDA will be optimized for fast retrieval as part of workList, the old WorkList UDA will not be optimized any more.

  Maximum 250 WorkList UDAs can be optimized for fast retrieval as part of WorkList(specially useful for using advance UDA filtering). System automatically select the first 250 WorkList UDAs as optimized. Subsequent WorkList UDAs will not be optimized. Based on UDA type 250 WorkList UDAs are distributed in following categories 100 - Shared by all DataItemRef.TYPE_STRING and DataItemRef.TYPE_BIGDECIMAL UDAs 100 - Shared by all DataItemRef.TYPE_INTEGER, DataItemRef.TYPE_LONG, DataItemRef.TYPE_BOOLEAN, and DataItemRef.TYPE_DATE UDAs 50 - Shared by all DataItemRef.TYPE_FLOAT UDAs

  Parameters:
    `newUdaName` - The name of the new WorkList UDA.
    `oldUdaName` - The name of the existing WorkList UDA.
    `oldUdatype` - The type of this old WorkList UDA. The parameter must be one of the constants defined in the `DataItemRef` interface such as `TYPE_BOOLEAN`.
  Throws:
    `ModelException`

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD