StandardWfDefinerService (WNC.X-05.0.0.00.73)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

wt.workflow.definer
Class StandardWfDefinerService

java.lang.Object
  wt.services.StandardManager
      wt.workflow.definer.StandardWfDefinerService

All Implemented Interfaces:: Manager, NetFactor, Serializable, WfDefinerService

public class StandardWfDefinerService
extends StandardManager
implements WfDefinerService, Serializable

Standard implementation of the definer service.

Use the newStandardWfDefinerService static factory method(s), not the StandardWfDefinerService constructor, to construct instances of this class. Instances must be constructed using the static factory(s), in order to ensure proper initialization of the instance.

Supported API: false

Extendable: false

See Also:: Serialized Form

Field Summary
`private static String`	`CLASSNAME`
`private static Object`	`IGNORE_DELETE_KEY`
`private KeyedEventListener`	`listener`
`private static int`	`MAX_REPORT_LENGTH`
`private static String`	`RESOURCE`
`private static String`	`SYSTEM_DOMAIN`
`private static boolean`	`VERBOSE`
`private WfProcessTemplateCache`	`wfProcessTemplateCache`

Fields inherited from class wt.services.StandardManager

Fields inherited from interface wt.services.Manager

MANAGER_SERVICE, STARTUP_AUTOMATIC, STARTUP_MANUAL, STATUS_EMERGENCY_SHUTDOWN, STATUS_EMERGENCY_SHUTTING_DOWN, STATUS_SHUTDOWN, STATUS_SHUTDOWN_ERRORS, STATUS_SHUTDOWN_FAILURE, STATUS_SHUTTING_DOWN, STATUS_STARTED, STATUS_STARTED_ERRORS, STATUS_STARTING_UP, STATUS_STARTUP_FAILURE

Constructor Summary
`StandardWfDefinerService()`

Method Summary
`WfConnectorTemplate`	`addConnectorTemplate(WfContainerTemplate def, WfConnectorFunction function, WfConnectorType type)` Adds a connector template to a process template.
`NodeTemplateLink`	`addLinkTemplate(WfNodeTemplate source, WfNodeTemplate destination)` Creates a link between two definition nodes.
`WfTemplateObject`	`addStepTemplate(WfContainerTemplate process_def, WfTemplateObject step)` Adds an activity step to an existing process template.
`boolean`	`canCreateWorkflowTemplate(WTUser user, WTContainerRef context_ref)` Determines if a given user is entitled to create Workflow Templates.
`private void`	`checkDisable(WfProcessTemplateMaster master)` Throws exception if any process template iteration or the template master or any of its iterations is being used by an enabled template.
`private void`	`checkFolder(WfProcessTemplate process_template)` Throws exception if process template is not in the personal cabinet or in the system cabinet
`private void`	`checkWfObject(Persistable target)` Throws exception if target belongs to a process that can't be changed.
`WfExpression`	`compileExpression(WfExpression expression)` Compiles and, if compilation is successful, loads expression.
`WfExpression`	`compileExpression(WfExpression expression, ProcessDataInfo signature)` Compiles the expression passed as argument with the given signature.
`private WfContainerTemplate`	`copyContainerTemplate(WfContainerTemplate template, WfContainerTemplate templateCopy)` Copies container template and all associated steps and connectors.
`private void`	`copyTemplateExpressions(WfNodeTemplate source, WfNodeTemplate destination)` Copies and persists all expressions associated with the given template.
`WfTemplateObject`	`copyTemplateObject(WfTemplateObject template, String copyName)` Produces a copy of the template object and persists it with the name passed as argument.
`WfTemplateObject`	`copyTemplateObject(WfTemplateObject template, String copyName, WTContainerRef context_ref)` Produces a copy of the template object and persists it with the name passed as argument.
`WfBlockTemplate`	`createBlockTemplate(String name, Vector node_set)` Takes a set of nodes and builds a block out of the nodes.
`WfExpression`	`createRouterExpression(WfNodeTemplate template)` Deprecated. Use instead PersistenceHelper.manager.save (WfExpression.newWfExpression (WfNodeTemplate, WfExpression.ROUTER_EXPRESSION))
`WfExpression`	`createTransitionExpression(WfTemplateObject template, Object transition)` Deprecated. Use instead PersistenceHelper.manager.save (WfExpression.newWfExpression (node, transition))
`private void`	`deleteContainedObjects(WfContainerTemplate process_def)` Deletes all contained objects in a given process template.
`void`	`deleteExpression(WfTemplateObject template, Object event)` Supported API: false
`private void`	`deleteExpressions(WfTemplateObject template)` Deletes all expressions associated with the given object template.
`private WfTemplateObject`	`deleteProcessStepTemplateLink(WfTemplateObject step)` Deletes the process step template link from the node if it exists.
`void`	`deleteProcessTemplate(WfProcessTemplate process_def)` Deletes process template passed as argument.
`void`	`demoteBlockTemplate(WfBlockTemplate block_template)` Removes a block and place its constituents directly into the host process.
`protected void`	`dispatchVetoableEvent(String event_type, Object target)` Creates and dispatches event that may be vetoed by another services.
`Object`	`executeExpression(WfExpression expression, Object[] values)` Evaluates the expression for the given array of values.
`void`	`exportTemplates(Vector wfProcessTemplateVector, String fileName, boolean appendFlag)` Populate a file with the csv equivalent of the Workflow Template objects Supported API: false
`Vector`	`findExportImportFileNames()` Retrieve a vector of file names from the Import/Export directory Supported API: false
`Vector`	`getAccessibleNodes(WfContainerTemplate template, WfNodeTemplate start_template)` Returns all nodes (activities and connectors) that can be reached from the node passed as argument.
`Enumeration`	`getActivityTemplates(WfTemplateCategory category)` Returns all activity templates of the category passed as argument.
`Enumeration`	`getAllExpressions(WfNodeTemplate template)` Returns all expressions associated with template (transition and router).
`protected void`	`getAllStepTemplates(WfContainerTemplate process_def, Vector steps)` Returns all step templates contained in a container template.
`Enumeration`	`getAllTemplates()` Returns an enumeration containing all process templates.
`QueryResult`	`getAllTemplates(WTContainerRef context_ref)` Returns an enumeration containing all process templates for the passes WTContainerRef.
`WfExpression`	`getBlockExpression(WfBlockTemplate block_template)` Returns the expression associated to the block template passed as parameter.
`String`	`getConceptualClassname()` Deprecated.
`Enumeration`	`getConnectorTemplates(WfContainerTemplate process_def)` Returns all connector templates associated with a given process template.
`protected QueryResult`	`getCurrentDirectlyUsedBy(WfProcessTemplate template)` Returns all process templates that directly uses the process template passed as argument as a current proxy.
`private static WTContainerRef`	`getDefaultContainer()`
`Enumeration`	`getDirectlyUsedByTemplates(WfProcessTemplate template)` Returns all process templates that directly uses the process template passed as argument.
`Enumeration`	`getDirectlyUsedTemplates(WfProcessTemplate template)` Returns all process templates that are directly used in the process template passed as argument.
`Enumeration`	`getEnabledTemplates()` Returns an enumeration containing all enabled process templates.
`QueryResult`	`getEnabledTemplates(WTContainerRef context_ref)` Returns an enumeration containing all enabled process templates in the passed WTContainer.
`Enumeration`	`getEndConnectorTemplates(WfContainerTemplate process_def)` Returns an enumeration containing the end connector templates associated with the process template.
`private ObjectIdentifier`	`getId(Object object)` Helper method that extracts object identifier.
`private Object`	`getIgnoreDelete()`
`protected QueryResult`	`getLatestDirectlyUsedBy(WfProcessTemplate template)` Returns all process templates that directly uses the process template passed as argument as a latest proxy.
`WfProcessTemplate`	`getLatestIteration(WfProcessTemplateMaster master)` Given a WfProcessTemplateMaster, return the latest iteration (WfProcessTemplate) Supported API: false
`WfProcessTemplateReference`	`getLatestIteration(WfProcessTemplateMasterReference master)` Given a WfProcessTemplateMasterReference, return the latest iteration (WfProcessTemplateReference) Supported API: false
`Enumeration`	`getLinkTemplates(WfContainerTemplate process_def)` Returns an enumeration (of type NodeTemplateLink) containing all link templates defined for the process.
`Enumeration`	`getLinkTemplates(WfNode source, WfNode destination)` Return an enumeration (of type NodeTemplateLink) containing all link templates between two node templates.
`protected WfContainerTemplateReference`	`getParentProcessTemplate(WfTemplateObject template)`
`WfProcessDefinition`	`getProcessDefinition(String process_identity)` Returns a process definition given its identity.
`WfProcessDefinition`	`getProcessDefinition(String process_identity, WTContainerRef context_ref)` Returns a process definition given its identity.
`WfProcessDefinition`	`getProcessDefinition(String process_identity, WTContainerRef context_ref, boolean hierarchical_lookup)` Returns a process definition given its identity, container reference and whether or not the process definition should be looked up hierarchically or not.
`Vector`	`getProcessRoles(WfContainerTemplate process_def)` Returns a Vector of Role objects used by the process/block template passed as argument.
`ProcessStepTemplateLink`	`getProcessStepTemplateLink(WfContainerTemplate process_def, WfTemplateObject step)` Deprecated. use getProcessTemplateLink (WfTemplateObject) instead
`ProcessStepTemplateLink`	`getProcessStepTemplateLink(WfTemplateObject step)` Returns the link between a node template and the containing process template.
`private QueryResult`	`getProcessTemplates(WTContainerRef context_ref, boolean only_enabled)`
`WfExpression`	`getRobotExpression(WfRobotActivityTemplate template)` Returns router expression associated with template if it exists.
`WfExpression`	`getRouterExpression(WfNodeTemplate template)` Returns router expression associated with template if it exists.
`WfConnectorTemplate`	`getStartConnectorTemplate(WfContainerTemplate process_def)` Returns the start connector template associated with the process template.
`Enumeration`	`getStepTemplates(WfContainerTemplate process_def, WfTemplateObjectType type)` Returns an enumeration with existing definition objects that are contained in the process template passed as argument.
`WfExpression`	`getSynchExpression(WfRobotActivityTemplate template)` Returns the fileter expression associated with template if it exists.
`Enumeration`	`getTemplateObjects(WfTemplateObjectType type, WfTemplateCategory category)` Returns an enumeration containing existing definition objects of the type and category passed as arguments.
`WfExpression`	`getTransitionExpression(WfNodeTemplate template, Object transition)` Returns the expression associated with a given process or activity template object and transiiton.
`Enumeration`	`getUsedByTemplates(WfProcessTemplate template)` Returns all process templates that uses the process template passed as argument.
`Enumeration`	`getUsedTemplates(WfProcessTemplate template)` Returns all process templates that are used in the process template passed as argument.
`private Enumeration`	`getValidSuccessors(WfNodeTemplate node)` Returns all valid successor nodes of a given node.
`protected WfProcessTemplateCache`	`getWfProcessTemplateCache()` Caching methods *
`void`	`importTemplates(String fileName)` Given a file that contains a csv version of any number of Wf Process Template objects, import these objects Supported API: false
`boolean`	`isSafeToDelete(WfProcessTemplate template)` Returns whether the process template is not used by another and can be safely deleted.
`boolean`	`isTemplateInUse(ObjectReference process_template_ref)` Returns true if template is in use; false otherwise.
`private String`	`linkToString(NodeTemplateLink link)` Returns condensed readable identity of the link.
`static StandardWfDefinerService`	`newStandardWfDefinerService()` Default factory for the class.
`private String`	`nodeToString(WfNodeTemplate node)` Returns condensed readable identity of the node.
`protected void`	`performStartupProcess()` Performs initialization of the definer service.
`private void`	`registerAsListener()` Register as listener to the following events: PersistenceManagerEvent.POST_CHANGE_DOMAIN PersistenceManagerEvent.PRE_STORE PersistenceManagerEvent.PRE_MODIFY PersistenceManagerEvent.PRE_DELETE WorkInProgressServiceEvent.PRE_CHECKIN WorkInProgressServiceEvent.POST_CHECKOUT VersionControlServiceEvent.POST_INSERT_ITERATION The objects of interest are workflow objects, more specifically, node templates (processes, activities and connectors) and expressions.
`void`	`registerEvents(ManagerService ms)` Register events with the passed ManagerService.
`int`	`removeLinkTemplate(WfNodeTemplate source, WfNodeTemplate destination)` Deletes all links between two step templates in a process process.
`WfTemplateObject`	`removeStepTemplate(WfTemplateObject step_def)` Removes step template from its containing process.
`TransactionResult`	`saveProcessTemplate(TransactionContainer aTran)` Store or update a WfProcessTemplate.
`TransactionResult`	`saveProcessTemplate(TransactionContainer aTran, WTContainerRef context_ref)` Store or update a WfProcessTemplate.
`WfProcessTemplate`	`saveProcessTemplate(WfProcessTemplate process_def)` Saves a process template in the database.
`WfProcessTemplate`	`saveProcessTemplate(WfProcessTemplate process_def, WTContainerRef context_ref)` Saves a process template in the database.
`void`	`setEnabled(WfProcessDefinition process, boolean enabled)` Enables or disables the process template master.
`void`	`setIgnoreDelete(Object obj)` Supported API: false
`private void`	`setLinkPair(NodeTemplateLink link, Object event, Object action)` Deletes all existing pairs from the link and sets the new pair passed as argumen.
`WfNodeTemplate`	`setParentTemplate(WfNodeTemplate node_template, WfContainerTemplate container_template)` Sets the parent template of a node template.
`private void`	`showTemplateVector(Vector template_vector)` Prints all templates contained in a vector.
`private void`	`updateNodeObjectsDomain(WfContainerTemplate template)` Changes the domain of all contained steps to the new domain of the container.
`Vector`	`verifyTemplate(WfProcessTemplate process_def, boolean recurse)` Returns a report of defects in the process template.
`Vector`	`whereUsed(ProjectReference project, boolean returnOnlyFirstOccurence)` Returns a vector of references to any engine objects that use a particular Project object.
`Vector`	`whereUsed(TeamReference teamRef, boolean returnOnlyFirstOccurence)` Returns a vector of references to any engine objects that use a particular Team object.
`Vector`	`whereUsed(TeamTemplateReference teamTemplateRef, boolean returnOnlyFirstOccurence)` Returns a vector of references to any engine objects that use a particular Team Template object.

Methods inherited from class wt.services.StandardManager

emergencyShutdown, emergencyShutdownComplete, emergencyShuttingDown, getClassInfo, getManagerService, getManagerStatus, getName, getStartupType, init, initialize, initialize, isStarted, newStandardManager, newStandardManager, performEmergencyShutdownProcess, performShutdownProcess, setManagerService, shutdown, shutdownFailure, shutdownSuccess, shuttingDown, started, startedErrors, startingUp, startup, startupFailure, toString

Methods inherited from class java.lang.Object

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

Field Detail

RESOURCE

private static final String RESOURCE

See Also:: Constant Field Values

CLASSNAME

private static final String CLASSNAME

listener

private KeyedEventListener listener

VERBOSE

private static boolean VERBOSE

SYSTEM_DOMAIN

private static String SYSTEM_DOMAIN

IGNORE_DELETE_KEY

private static final Object IGNORE_DELETE_KEY

MAX_REPORT_LENGTH

private static int MAX_REPORT_LENGTH

wfProcessTemplateCache

private WfProcessTemplateCache wfProcessTemplateCache

Constructor Detail

StandardWfDefinerService

public StandardWfDefinerService()

Method Detail

getConceptualClassname

public String getConceptualClassname()

Deprecated.

Returns the conceptual (modeled) name for the class.

Supported API: false

Specified by:: getConceptualClassname in interface NetFactor
Overrides:: getConceptualClassname in class StandardManager

Returns:: String

performStartupProcess

protected void performStartupProcess()
                              throws ManagerException

Performs initialization of the definer service. This conists mostly in subscribing to the desired keyed events.

Supported API: false

Overrides:: performStartupProcess in class StandardManager

Throws:: ManagerException

dispatchVetoableEvent

protected void dispatchVetoableEvent(String event_type,
                                     Object target)
                              throws WTException

Creates and dispatches event that may be vetoed by another services.

Supported API: false

Parameters:: event_type -; target -
Throws:: WTException

registerEvents

public void registerEvents(ManagerService ms)

Specified by:: registerEvents in interface Manager
Overrides:: registerEvents in class StandardManager

Parameters:: ms - the ManagerService with which to register events.

newStandardWfDefinerService

public static StandardWfDefinerService newStandardWfDefinerService()
                                                            throws WTException

Default factory for the class.

Supported API: false

Returns:: StandardWfDefinerService
Throws:: WTException

addConnectorTemplate

public WfConnectorTemplate addConnectorTemplate(WfContainerTemplate def,
                                                WfConnectorFunction function,
                                                WfConnectorType type)
                                         throws WTException

Adds a connector template to a process template.

Supported API: false

Specified by:: addConnectorTemplate in interface WfDefinerService

Parameters:: def -; function -; type -
Returns:: WfConnectorTemplate
Throws:: WTException

addLinkTemplate

public NodeTemplateLink addLinkTemplate(WfNodeTemplate source,
                                        WfNodeTemplate destination)
                                 throws WTException

Creates a link between two definition nodes. Additional link information can be set after the link is created. For example, the event-action map for activity-activity links or the conditional code for conditional router links. Throws an InvalidDestination exception when a WfRouterTemplate is passed as the destination node of a connector or router template.

Supported API: false

Specified by:: addLinkTemplate in interface WfDefinerService

Parameters:: source -; destination -
Returns:: NodeTemplateLink
Throws:: WTException

addStepTemplate

public WfTemplateObject addStepTemplate(WfContainerTemplate process_def,
                                        WfTemplateObject step)
                                 throws WTException

Adds an activity step to an existing process template. The activity step may be any definition object, that is, another process template, a robot activity template or an assigned activity template.

The method returns the step template (which is modified to hold a reference to the parent and another to the link). Use 'getProcessStepTemplateLink' to get the link.

Supported API: false

Specified by:: addStepTemplate in interface WfDefinerService

Parameters:: process_def -; step -
Returns:: WfTemplateObject
Throws:: WTException

canCreateWorkflowTemplate

public boolean canCreateWorkflowTemplate(WTUser user,
                                         WTContainerRef context_ref)
                                  throws WTException

Determines if a given user is entitled to create Workflow Templates. Returns 'true' if the user is an Org Administrator or an Exhange Administrator.

Supported API: false

Specified by:: canCreateWorkflowTemplate in interface WfDefinerService

Parameters:: user -; context_ref -
Returns:: boolean
Throws:: WTException

compileExpression

public WfExpression compileExpression(WfExpression expression)
                               throws WTException

Compiles and, if compilation is successful, loads expression. In case of failure, one may get the message quirying directly the expression.

Supported API: false

Specified by:: compileExpression in interface WfDefinerService

Parameters:: expression -
Returns:: WfExpression
Throws:: WTException
See Also:: WfExpression

compileExpression

public WfExpression compileExpression(WfExpression expression,
                                      ProcessDataInfo signature)
                               throws WTException

Compiles the expression passed as argument with the given signature. If compilation is successful, loads expression. In case of failure, one may get the message quirying directly the expression.

Supported API: false

Specified by:: compileExpression in interface WfDefinerService

Parameters:: expression -; signature -
Returns:: WfExpression
Throws:: WTException
See Also:: WfExpression, ProcessDataInfo

copyTemplateObject

public WfTemplateObject copyTemplateObject(WfTemplateObject template,
                                           String copyName)
                                    throws WTException

Produces a copy of the template object and persists it with the name passed as argument. If the template is a process template all contained obejcts (steps, connectors, links and expressions) are copied as well. If name is "null" the name of the copied template is taken to be the name of the copied template object for activity templates; for process templates a prefix 'copy of' is used.

Supported API: false

Specified by:: copyTemplateObject in interface WfDefinerService

Parameters:: template -; copyName -
Returns:: WfTemplateObject
Throws:: WTException

copyTemplateObject

public WfTemplateObject copyTemplateObject(WfTemplateObject template,
                                           String copyName,
                                           WTContainerRef context_ref)
                                    throws WTException

Specified by:: copyTemplateObject in interface WfDefinerService

Parameters:: template -; copyName -; context_ref -
Returns:: WfTemplateObject
Throws:: WTException

createBlockTemplate

public WfBlockTemplate createBlockTemplate(String name,
                                           Vector node_set)
                                    throws WTException

Takes a set of nodes and builds a block out of the nodes. The desired block name and the set of nodes are passed as argument. The method assumes that node_set elements are WfNode and that there is an 'initial' node and a 'final' node, such that:

These two nodes are the only ones linked to nodes outside node_set.
The initial node is the destination of a link such that the source is outside the set of nodes.
The final node is the source of a link such that the destination is outside the set of nodes.
The initial and final nodes have each one of them has exactly one link outside the set of nodes.

Failure to meet these requirements causes an exception to be thrown. All links joining node_set nodes are included in the block. The block has no associated expression.

Supported API: false

Specified by:: createBlockTemplate in interface WfDefinerService

Parameters:: name -; node_set -
Returns:: WfBlockTemplate
Throws:: WTException

createRouterExpression

public WfExpression createRouterExpression(WfNodeTemplate template)
                                    throws WTException

Deprecated. Use instead PersistenceHelper.manager.save (WfExpression.newWfExpression (WfNodeTemplate, WfExpression.ROUTER_EXPRESSION))

Creates an empty expression associated with a given conditional router template. Throws an ExpressionAlreadyExists exception if there is already an expression for the for the router template passed as argument.

Supported API: false

Specified by:: createRouterExpression in interface WfDefinerService

Parameters:: template -
Returns:: WfExpression
Throws:: WTException

createTransitionExpression

public WfExpression createTransitionExpression(WfTemplateObject template,
                                               Object transition)
                                        throws WTException

Deprecated. Use instead PersistenceHelper.manager.save (WfExpression.newWfExpression (node, transition))

Creates an empty expression associated with a given process or activity template object and transition. If there is already an expression for the template/transition passed as argument then this expression is returned.

Supported API: false

Specified by:: createTransitionExpression in interface WfDefinerService

Parameters:: template -; transition -
Returns:: WfExpression
Throws:: WTException

deleteExpression

public void deleteExpression(WfTemplateObject template,
                             Object event)
                      throws WTException

Supported API: false

Specified by:: deleteExpression in interface WfDefinerService

Parameters:: template -; event -
Throws:: WTException

deleteProcessTemplate

public void deleteProcessTemplate(WfProcessTemplate process_def)
                           throws WTException

Deletes process template passed as argument. This method allows process templates to be deleted without requiring the current user to have modify rights over folders.

Supported API: false

Specified by:: deleteProcessTemplate in interface WfDefinerService

Parameters:: process_def -
Throws:: WTException

demoteBlockTemplate

public void demoteBlockTemplate(WfBlockTemplate block_template)
                         throws WTException

Removes a block and place its constituents directly into the host process. This operation will delete the block's expression. In other words, the iteration is lost when this method is used.

This operation will only be possible if links to the block are mapped to the START action. Links to the block will be directed to the start connector in the following way: links of the form A -> B, where B is a block, is transformed into A -> S, where S is the start connector of B and the action is FIRE. In the case of links from the block: B -> C, it also wise to restrict the event to COMPLETE. The transformed link is: E -> C, in which the action is FIRE.

The start connector is transformed into a simple OR connector and the end connector into a simple AND connector.

Note: A block can be the target of a change of state other than START even if there is no incoming link with this action. This happens, for example, when the process completes/is suspended ... It issues commands to all contained activities to do the same. In this case a block instance behaves like a sub-process, issuing similar commands.

Supported API: false

Specified by:: demoteBlockTemplate in interface WfDefinerService

Parameters:: block_template -
Throws:: WTException

executeExpression

public Object executeExpression(WfExpression expression,
                                Object[] values)
                         throws WTException

Evaluates the expression for the given array of values. Returns an object that is the result of the evaluation. This method is mostly to be used to check if the expression is correct.

Supported API: false

Specified by:: executeExpression in interface WfDefinerService

Parameters:: expression -; values -
Returns:: Object
Throws:: WTException
See Also:: WfExpression

exportTemplates

public void exportTemplates(Vector wfProcessTemplateVector,
                            String fileName,
                            boolean appendFlag)
                     throws WTException

Populate a file with the csv equivalent of the Workflow Template objects

Supported API: false

Specified by:: exportTemplates in interface WfDefinerService

Parameters:: wfProcessTemplateVector - a vector of Wf Process Template objects that need to be exported; fileName - the name of the file that the csv version of the templates should be written to (not including the .csv suffix or the directory name); appendFlag - a flag that determines whether the exported data should overwrite any existing data or append it to the end
Throws:: WTException

findExportImportFileNames

public Vector findExportImportFileNames()
                                 throws WTException

Retrieve a vector of file names from the Import/Export directory

Supported API: false

Specified by:: findExportImportFileNames in interface WfDefinerService

Returns:: Vector
Throws:: WTException

getAccessibleNodes

public Vector getAccessibleNodes(WfContainerTemplate template,
                                 WfNodeTemplate start_template)
                          throws WTException

Returns all nodes (activities and connectors) that can be reached from the node passed as argument.

Supported API: false

Specified by:: getAccessibleNodes in interface WfDefinerService

Parameters:: template -; start_template -
Returns:: Vector
Throws:: WTException

getActivityTemplates

public Enumeration getActivityTemplates(WfTemplateCategory category)
                                 throws WTException

Returns all activity templates of the category passed as argument. If 'null' is passed as argument returns all activity templates, irrespective of the category.

Supported API: false

Specified by:: getActivityTemplates in interface WfDefinerService

Parameters:: category -
Returns:: Enumeration
Throws:: WTException

getAllExpressions

public Enumeration getAllExpressions(WfNodeTemplate template)
                              throws WTException

Returns all expressions associated with template (transition and router).

Supported API: false

Specified by:: getAllExpressions in interface WfDefinerService

Parameters:: template -
Returns:: Enumeration
Throws:: WTException
See Also:: WfExpression

getAllTemplates

public Enumeration getAllTemplates()
                            throws WTException

Returns an enumeration containing all process templates. The process templates returned are the working copies if they exist or the vault's latest iteration.

Supported API: false

Specified by:: getAllTemplates in interface WfDefinerService

Returns:: Enumeration
Throws:: WTException
See Also:: getEnabledTemplates

getAllTemplates

public QueryResult getAllTemplates(WTContainerRef context_ref)
                            throws WTException

Returns an enumeration containing all process templates for the passes WTContainerRef. The process templates returned are the working copies if they exist or the vault's latest iteration.

Supported API: false

Specified by:: getAllTemplates in interface WfDefinerService

Parameters:: context_ref -
Returns:: QueryResult
Throws:: WTException
See Also:: getEnabledTemplates

getBlockExpression

public WfExpression getBlockExpression(WfBlockTemplate block_template)
                                throws WTException

Returns the expression associated to the block template passed as parameter. Returns null if expression hasn't been created yet.

Supported API: false

Specified by:: getBlockExpression in interface WfDefinerService

Parameters:: block_template -
Returns:: WfExpression
Throws:: WTException

getConnectorTemplates

public Enumeration getConnectorTemplates(WfContainerTemplate process_def)
                                  throws WTException

Returns all connector templates associated with a given process template.

Supported API: false

Specified by:: getConnectorTemplates in interface WfDefinerService

Parameters:: process_def -
Returns:: Enumeration
Throws:: WTException

getDirectlyUsedByTemplates

public Enumeration getDirectlyUsedByTemplates(WfProcessTemplate template)
                                       throws WTException

Returns all process templates that directly uses the process template passed as argument. A process template "A" directly uses another process template "B" when B is a sub-process of A or there is a proxy in A that references B.

Supported API: false

Specified by:: getDirectlyUsedByTemplates in interface WfDefinerService

Parameters:: template -
Returns:: Enumeration
Throws:: WTException

getDirectlyUsedTemplates

public Enumeration getDirectlyUsedTemplates(WfProcessTemplate template)
                                     throws WTException

Returns all process templates that are directly used in the process template passed as argument. A process template "A" directly uses another process template "B" when B is a sub-process of A or there is a proxy in A that references B.

Supported API: false

Specified by:: getDirectlyUsedTemplates in interface WfDefinerService

Parameters:: template -
Returns:: Enumeration
Throws:: WTException

getEnabledTemplates

public Enumeration getEnabledTemplates()
                                throws WTException

Returns an enumeration containing all enabled process templates. The process templates returned are the working copies if they exist or the vault's latest iteration.

Supported API: false

Specified by:: getEnabledTemplates in interface WfDefinerService

Returns:: Enumeration
Throws:: WTException
See Also:: getAllTemplates

getEnabledTemplates

public QueryResult getEnabledTemplates(WTContainerRef context_ref)
                                throws WTException

Returns an enumeration containing all enabled process templates in the passed WTContainer. The process templates returned are the working copies if they exist or the vault's latest iteration.

Supported API: false

Specified by:: getEnabledTemplates in interface WfDefinerService

Parameters:: context_ref -
Returns:: QueryResult
Throws:: WTException
See Also:: getAllTemplates

getEndConnectorTemplates

public Enumeration getEndConnectorTemplates(WfContainerTemplate process_def)
                                     throws WTException

Returns an enumeration containing the end connector templates associated with the process template.

Supported API: false

Specified by:: getEndConnectorTemplates in interface WfDefinerService

Parameters:: process_def -
Returns:: Enumeration
Throws:: WTException

getLatestIteration

public WfProcessTemplate getLatestIteration(WfProcessTemplateMaster master)
                                     throws WTException

Given a WfProcessTemplateMaster, return the latest iteration (WfProcessTemplate)

Supported API: false

Specified by:: getLatestIteration in interface WfDefinerService

Parameters:: master -
Returns:: WfProcessTemplate
Throws:: WTException

getLatestIteration

public WfProcessTemplateReference getLatestIteration(WfProcessTemplateMasterReference master)
                                              throws WTException

Given a WfProcessTemplateMasterReference, return the latest iteration (WfProcessTemplateReference)

Supported API: false

Specified by:: getLatestIteration in interface WfDefinerService

Parameters:: master -
Returns:: WfProcessTemplateReference
Throws:: WTException

getLinkTemplates

public Enumeration getLinkTemplates(WfContainerTemplate process_def)
                             throws WTException

Returns an enumeration (of type NodeTemplateLink) containing all link templates defined for the process.

Supported API: false

Specified by:: getLinkTemplates in interface WfDefinerService

Parameters:: process_def -
Returns:: Enumeration
Throws:: WTException

getLinkTemplates

public Enumeration getLinkTemplates(WfNode source,
                                    WfNode destination)
                             throws WTException

Return an enumeration (of type NodeTemplateLink) containing all link templates between two node templates.

Supported API: false

Specified by:: getLinkTemplates in interface WfDefinerService

Parameters:: source -; destination -
Returns:: Enumeration
Throws:: WTException

getProcessDefinition

public WfProcessDefinition getProcessDefinition(String process_identity)
                                         throws WTException

Returns a process definition given its identity. May return either the master process template or a specific iteration. Returns 'null' if no process definition is found that has the identity passed as argument.

Tries first to find a master with the identity equal to the one passed as argument; if not found, searches for an iteration.

Supported API: false

Specified by:: getProcessDefinition in interface WfDefinerService

Parameters:: process_identity -
Returns:: WfProcessDefinition
Throws:: WTException

getProcessDefinition

public WfProcessDefinition getProcessDefinition(String process_identity,
                                                WTContainerRef context_ref)
                                         throws WTException

Tries first to find a master with the identity equal to the one passed as argument; if not found, searches for an iteration.

Supported API: false

Specified by:: getProcessDefinition in interface WfDefinerService

Parameters:: process_identity -; context_ref -
Returns:: WfProcessDefinition
Throws:: WTException

getProcessRoles

public Vector getProcessRoles(WfContainerTemplate process_def)
                       throws WTException

Returns a Vector of Role objects used by the process/block template passed as argument.

Supported API: false

Specified by:: getProcessRoles in interface WfDefinerService

Parameters:: process_def -
Returns:: Vector
Throws:: WTException

getProcessStepTemplateLink

public ProcessStepTemplateLink getProcessStepTemplateLink(WfContainerTemplate process_def,
                                                          WfTemplateObject step)
                                                   throws WTException

Deprecated. use getProcessTemplateLink (WfTemplateObject) instead

Returns the link between a node template and the containing process template. The link returned contains the mapping betweenlocal and process variables. Returns null if the step template is not contained in the process template.

Supported API: false

Specified by:: getProcessStepTemplateLink in interface WfDefinerService

Parameters:: process_def -; step -
Returns:: ProcessStepTemplateLink
Throws:: WTException

getProcessStepTemplateLink

public ProcessStepTemplateLink getProcessStepTemplateLink(WfTemplateObject step)
                                                   throws WTException

Returns the link between a node template and the containing process template. The link returned contains the mapping between local and process variables. Returns null if the step is not embedded in a container template.

Supported API: false

Specified by:: getProcessStepTemplateLink in interface WfDefinerService

Parameters:: step -
Returns:: ProcessStepTemplateLink
Throws:: WTException

getRobotExpression

public WfExpression getRobotExpression(WfRobotActivityTemplate template)
                                throws WTException

Returns router expression associated with template if it exists. Returns null otherwise.

Supported API: false

Specified by:: getRobotExpression in interface WfDefinerService

Parameters:: template -
Returns:: WfExpression
Throws:: WTException
See Also:: WfExpression

getRouterExpression

public WfExpression getRouterExpression(WfNodeTemplate template)
                                 throws WTException

Returns router expression associated with template if it exists. Returns null otherwise.

Supported API: false

Specified by:: getRouterExpression in interface WfDefinerService

Parameters:: template -
Returns:: WfExpression
Throws:: WTException
See Also:: WfExpression

getStartConnectorTemplate

public WfConnectorTemplate getStartConnectorTemplate(WfContainerTemplate process_def)
                                              throws WTException

Returns the start connector template associated with the process template.

Supported API: false

Specified by:: getStartConnectorTemplate in interface WfDefinerService

Parameters:: process_def -
Returns:: WfConnectorTemplate
Throws:: WTException

getStepTemplates

public Enumeration getStepTemplates(WfContainerTemplate process_def,
                                    WfTemplateObjectType type)
                             throws WTException

Returns an enumeration with existing definition objects that are contained in the process template passed as argument.

Supported API: false

Specified by:: getStepTemplates in interface WfDefinerService

Parameters:: process_def -; type -
Returns:: Enumeration
Throws:: WTException

getSynchExpression

public WfExpression getSynchExpression(WfRobotActivityTemplate template)
                                throws WTException

Returns the fileter expression associated with template if it exists. Returns null otherwise.

Supported API: false

Specified by:: getSynchExpression in interface WfDefinerService

Parameters:: template -
Returns:: WfExpression
Throws:: WTException
See Also:: WfExpression

getTemplateObjects

public Enumeration getTemplateObjects(WfTemplateObjectType type,
                                      WfTemplateCategory category)
                               throws WTException

Returns an enumeration containing existing definition objects of the type and category passed as arguments. If type is null then all types are returned; likewise, if category is null, template objects of all categories are returned.

Supported API: false

Specified by:: getTemplateObjects in interface WfDefinerService

Parameters:: type -; category -
Returns:: Enumeration
Throws:: WTException

getTransitionExpression

public WfExpression getTransitionExpression(WfNodeTemplate template,
                                            Object transition)
                                     throws WTException

Returns the expression associated with a given process or activity template object and transiiton. Returns null if such expression doesn't exists.

Supported API: false

Specified by:: getTransitionExpression in interface WfDefinerService

Parameters:: template -; transition -
Returns:: WfExpression
Throws:: WTException
See Also:: WfExpression

getUsedByTemplates

public Enumeration getUsedByTemplates(WfProcessTemplate template)
                               throws WTException

Returns all process templates that uses the process template passed as argument. A process template "A" uses another process template "B" when A directly uses B or A directly uses a template "C" that uses B.

Supported API: false

Specified by:: getUsedByTemplates in interface WfDefinerService

Parameters:: template -
Returns:: Enumeration
Throws:: WTException

getUsedTemplates

public Enumeration getUsedTemplates(WfProcessTemplate template)
                             throws WTException

Returns all process templates that are used in the process template passed as argument. A process template "A" uses another process template "B" when A directly uses B or A directly uses a template "C" that uses B.

Supported API: false

Specified by:: getUsedTemplates in interface WfDefinerService

Parameters:: template -
Returns:: Enumeration
Throws:: WTException

importTemplates

public void importTemplates(String fileName)
                     throws WTException

Given a file that contains a csv version of any number of Wf Process Template objects, import these objects

Supported API: false

Specified by:: importTemplates in interface WfDefinerService

Parameters:: fileName - the name of the file that the csv version of the templates should be imported from (not including the .csv extension or the directory name)
Throws:: WTException

isTemplateInUse

public boolean isTemplateInUse(ObjectReference process_template_ref)
                        throws WTException

Returns true if template is in use; false otherwise.

Supported API: false

Specified by:: isTemplateInUse in interface WfDefinerService

Parameters:: process_template_ref -
Returns:: boolean
Throws:: WTException

removeLinkTemplate

public int removeLinkTemplate(WfNodeTemplate source,
                              WfNodeTemplate destination)
                       throws WTException

Deletes all links between two step templates in a process process. Returns the number of links deleted.

Supported API: false

Specified by:: removeLinkTemplate in interface WfDefinerService

Parameters:: source -; destination -
Returns:: int
Throws:: WTException

removeStepTemplate

public WfTemplateObject removeStepTemplate(WfTemplateObject step_def)
                                    throws WTException

Removes step template from its containing process. Returns the step template removed.

Supported API: false

Specified by:: removeStepTemplate in interface WfDefinerService

Parameters:: step_def -
Returns:: WfTemplateObject
Throws:: WTException

saveProcessTemplate

public TransactionResult saveProcessTemplate(TransactionContainer aTran)
                                      throws WTException,
                                             WfException

Store or update a WfProcessTemplate. This method accepts and processes a batch container of persistence assertions.

Supported API: false

Specified by:: saveProcessTemplate in interface WfDefinerService

Parameters:: aTran - a TransactionContainer that contains a set of LifeCycleTemplate, PhaseTemplate, AdHocNotificationList, AdHocAclSpec, and Criterion assertions that need to be applied against one or more LifeCycleTemplate objects
Returns:: TransactionResult
Throws:: WTException; WfException

saveProcessTemplate

public TransactionResult saveProcessTemplate(TransactionContainer aTran,
                                             WTContainerRef context_ref)
                                      throws WTException,
                                             WfException

Store or update a WfProcessTemplate. This method accepts and processes a batch container of persistence assertions.

Supported API: false

Specified by:: saveProcessTemplate in interface WfDefinerService

Parameters:: aTran -; context_ref -
Returns:: TransactionResult
Throws:: WTException; WfException

saveProcessTemplate

public WfProcessTemplate saveProcessTemplate(WfProcessTemplate process_def)
                                      throws WTException

Saves a process template in the database. This method allows process templates to be created without requiring the current user to have modify rights over folders.

Supported API: false

Specified by:: saveProcessTemplate in interface WfDefinerService

Parameters:: process_def -
Returns:: WfProcessTemplate
Throws:: WTException

saveProcessTemplate

public WfProcessTemplate saveProcessTemplate(WfProcessTemplate process_def,
                                             WTContainerRef context_ref)
                                      throws WTException

Saves a process template in the database. This method allows process templates to be created without requiring the current user to have modify rights over folders.

Supported API: false

Specified by:: saveProcessTemplate in interface WfDefinerService

Parameters:: process_def -; context_ref -
Returns:: WfProcessTemplate
Throws:: WTException

setEnabled

public void setEnabled(WfProcessDefinition process,
                       boolean enabled)
                throws WTException

Enables or disables the process template master. In case of disabling, throws exception if it is used by an enabled template or it is vetoed by another service.

Supported API: false

Specified by:: setEnabled in interface WfDefinerService

Parameters:: process -; enabled -
Throws:: WTException

setIgnoreDelete

public void setIgnoreDelete(Object obj)
                     throws WTException

Supported API: false

Specified by:: setIgnoreDelete in interface WfDefinerService

Parameters:: obj -
Throws:: WTException

setParentTemplate

public WfNodeTemplate setParentTemplate(WfNodeTemplate node_template,
                                        WfContainerTemplate container_template)
                                 throws WTException

Sets the parent template of a node template. The object is not persisted.

Supported API: false

Specified by:: setParentTemplate in interface WfDefinerService

Parameters:: node_template -; container_template -
Returns:: WfNodeTemplate
Throws:: WTException

verifyTemplate

public Vector verifyTemplate(WfProcessTemplate process_def,
                             boolean recurse)
                      throws WTException

Returns a report of defects in the process template.

Supported API: false

Specified by:: verifyTemplate in interface WfDefinerService

Parameters:: process_def -; recurse -
Returns:: Vector
Throws:: WTException

whereUsed

public Vector whereUsed(ProjectReference project,
                        boolean returnOnlyFirstOccurence)
                 throws WTException

Returns a vector of references to any engine objects that use a particular Project object.

Supported API: false

Specified by:: whereUsed in interface WfDefinerService

Parameters:: project -; returnOnlyFirstOccurence - this boolean parameter determines whether to return all objects that use the Project object or only the first usage. This parameter was added for performance reasons and the occasional need to only know that the project is used.
Returns:: Vector
Throws:: WTException

whereUsed

public Vector whereUsed(TeamReference teamRef,
                        boolean returnOnlyFirstOccurence)
                 throws WTException

Returns a vector of references to any engine objects that use a particular Team object.

Supported API: false

Specified by:: whereUsed in interface WfDefinerService

Parameters:: teamRef -; returnOnlyFirstOccurence - this boolean parameter determines whether to return all objects that use the Project object or only the first usage. This parameter was added for performance reasons and the occasional need to only know that the project is used.
Returns:: Vector
Throws:: WTException

whereUsed

public Vector whereUsed(TeamTemplateReference teamTemplateRef,
                        boolean returnOnlyFirstOccurence)
                 throws WTException

Returns a vector of references to any engine objects that use a particular Team Template object.

Supported API: false

Specified by:: whereUsed in interface WfDefinerService

Parameters:: teamTemplateRef -; returnOnlyFirstOccurence - this boolean parameter determines whether to return all objects that use the Project object or only the first usage. This parameter was added for performance reasons and the occasional need to only know that the project is used.
Returns:: Vector
Throws:: WTException

getProcessDefinition

public WfProcessDefinition getProcessDefinition(String process_identity,
                                                WTContainerRef context_ref,
                                                boolean hierarchical_lookup)
                                         throws WTException

Returns a process definition given its identity, container reference and whether or not the process definition should be looked up hierarchically or not. May return either the master process template or a specific iteration. Returns 'null' if no process definition is found that has the identity passed as argument.

Tries first to find a master with the identity equal to the one passed as argument; if not found, searches for an iteration.

Supported API: false

Specified by:: getProcessDefinition in interface WfDefinerService

Parameters:: process_identity -; context_ref -; hierarchical_lookup -
Returns:: WfProcessDefinition
Throws:: WTException

getProcessTemplates

private QueryResult getProcessTemplates(WTContainerRef context_ref,
                                        boolean only_enabled)
                                 throws WTException

Throws:: WTException

getAllStepTemplates

protected void getAllStepTemplates(WfContainerTemplate process_def,
                                   Vector steps)
                            throws WTException

Returns all step templates contained in a container template. Recursively probes into block templates for contained steps.

Throws:: WTException

deleteProcessStepTemplateLink

private WfTemplateObject deleteProcessStepTemplateLink(WfTemplateObject step)
                                                throws WTException

Deletes the process step template link from the node if it exists.

Throws:: WTException

checkWfObject

private void checkWfObject(Persistable target)
                    throws WTException

Throws exception if target belongs to a process that can't be changed. This method is called after an attempt is made to store, modify or delete the object passed as argument.

A process template can't be changed if the user has insufficient privileges or it is being used by an open process.

Parameters:: target - - workflow node or expression
Throws:: wt.util.WTException, - thrown if host template can't be modified; WTException

checkFolder

private void checkFolder(WfProcessTemplate process_template)
                  throws WTException

Throws exception if process template is not in the personal cabinet or in the system cabinet

Parameters:: process_template - - process template to be stored
Throws:: wt.util.WTException, - thrown if template is in use.; WTException

checkDisable

private void checkDisable(WfProcessTemplateMaster master)
                   throws WTException

Throws exception if any process template iteration or the template master or any of its iterations is being used by an enabled template.

Parameters:: master - - process template master to be disabled
Throws:: wt.util.WTException, - thrown if template is in use.; WTException

copyTemplateExpressions

private void copyTemplateExpressions(WfNodeTemplate source,
                                     WfNodeTemplate destination)
                              throws WTException

Copies and persists all expressions associated with the given template.

Parameters:: source - - template that owns expressions to be copied; destination - - template to which the copied expressions will be associated
Returns:: WfTemplateObject - template to which the copied expressions will be associated
Throws:: WTException

deleteContainedObjects

private void deleteContainedObjects(WfContainerTemplate process_def)
                             throws WTException

Deletes all contained objects in a given process template. The contained objects are nodes and connectors. This method is called after a process template is deleted.

Parameters:: process_def -
Throws:: WTException

deleteExpressions

private void deleteExpressions(WfTemplateObject template)
                        throws WTException

Deletes all expressions associated with the given object template. This method is called after a template is deleted.

Parameters:: template -
Throws:: WTException

copyContainerTemplate

private WfContainerTemplate copyContainerTemplate(WfContainerTemplate template,
                                                  WfContainerTemplate templateCopy)
                                           throws WTException

Copies container template and all associated steps and connectors.

Parameters:: template - - template to be copied; templateCopy - - copy recipient
Returns:: WfContainerTemplate - copied template
Throws:: WTException

nodeToString

private String nodeToString(WfNodeTemplate node)

Returns condensed readable identity of the node. For debugging purposes.

Parameters:: node - - WfNode to be printed out

showTemplateVector

private void showTemplateVector(Vector template_vector)

Prints all templates contained in a vector.

Parameters:: template_vector - - vector containing process templates

linkToString

private String linkToString(NodeTemplateLink link)

Returns condensed readable identity of the link. For debugging purposes.

Parameters:: link - - WfLink to be printed out

setLinkPair

private void setLinkPair(NodeTemplateLink link,
                         Object event,
                         Object action)
                  throws WTException

Deletes all existing pairs from the link and sets the new pair passed as argumen.

Parameters:: link - - WfLink to be printed out; event - - Object event; action - - Object action
Throws:: WTException

getValidSuccessors

private Enumeration getValidSuccessors(WfNodeTemplate node)
                                throws WTException

Returns all valid successor nodes of a given node. A valid successor node is one that can be reached through a valid link.

Parameters:: node - - node to be expanded
Returns:: Enumeration - list of valid successor nodes
Throws:: WTException

registerAsListener

private void registerAsListener()
                         throws ManagerException

PersistenceManagerEvent.POST_CHANGE_DOMAIN
PersistenceManagerEvent.PRE_STORE
PersistenceManagerEvent.PRE_MODIFY
PersistenceManagerEvent.PRE_DELETE
WorkInProgressServiceEvent.PRE_CHECKIN
WorkInProgressServiceEvent.POST_CHECKOUT
VersionControlServiceEvent.POST_INSERT_ITERATION

The objects of interest are workflow objects, more specifically, node templates (processes, activities and connectors) and expressions.

Throws:: ManagerException

getCurrentDirectlyUsedBy

protected QueryResult getCurrentDirectlyUsedBy(WfProcessTemplate template)
                                        throws WTException

Returns all process templates that directly uses the process template passed as argument as a current proxy.

Supported API: false

Parameters:: template -
Returns:: QueryResult
Throws:: WTException

getLatestDirectlyUsedBy

protected QueryResult getLatestDirectlyUsedBy(WfProcessTemplate template)
                                       throws WTException

Returns all process templates that directly uses the process template passed as argument as a latest proxy.

Supported API: false

Parameters:: template -
Returns:: QueryResult
Throws:: WTException

isSafeToDelete

public boolean isSafeToDelete(WfProcessTemplate template)
                       throws WTException

Returns whether the process template is not used by another and can be safely deleted. This happens in the following cases:

template is not "currently" referenced by a proxy, that is, a "hard" reference;
template is not the last one (no predecessor) and referenced by a proxy in a "latest" kind of relationship.

These two conditions guarantees that no template in use can be deleted but and the same time allows for undoing of checkouts.

Supported API: false

Parameters:: template -
Returns:: boolean
Throws:: WTException

getParentProcessTemplate

protected WfContainerTemplateReference getParentProcessTemplate(WfTemplateObject template)
                                                         throws WTException

Throws:: WTException

getWfProcessTemplateCache

protected WfProcessTemplateCache getWfProcessTemplateCache()

Caching methods *

getIgnoreDelete

private Object getIgnoreDelete()

getId

private ObjectIdentifier getId(Object object)

Helper method that extracts object identifier.

updateNodeObjectsDomain

private void updateNodeObjectsDomain(WfContainerTemplate template)
                              throws WTException

Changes the domain of all contained steps to the new domain of the container. Method called when a change of domain takes place.

Throws:: WTException

getDefaultContainer

private static WTContainerRef getDefaultContainer()
                                           throws WTException

Throws:: WTException

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

wt.workflow.definer Class StandardWfDefinerService

RESOURCE

CLASSNAME

listener

VERBOSE

SYSTEM_DOMAIN

IGNORE_DELETE_KEY

MAX_REPORT_LENGTH

wfProcessTemplateCache

StandardWfDefinerService

getConceptualClassname

performStartupProcess

dispatchVetoableEvent

registerEvents

newStandardWfDefinerService

addConnectorTemplate

addLinkTemplate

addStepTemplate

canCreateWorkflowTemplate

compileExpression

compileExpression

copyTemplateObject

copyTemplateObject

createBlockTemplate

createRouterExpression

createTransitionExpression

deleteExpression

deleteProcessTemplate

demoteBlockTemplate

executeExpression

exportTemplates

findExportImportFileNames

getAccessibleNodes

getActivityTemplates

getAllExpressions

getAllTemplates

getAllTemplates

getBlockExpression

getConnectorTemplates

getDirectlyUsedByTemplates

getDirectlyUsedTemplates

getEnabledTemplates

getEnabledTemplates

getEndConnectorTemplates

getLatestIteration

getLatestIteration

getLinkTemplates

getLinkTemplates

getProcessDefinition

getProcessDefinition

getProcessRoles

getProcessStepTemplateLink

getProcessStepTemplateLink

getRobotExpression

getRouterExpression

getStartConnectorTemplate

getStepTemplates

getSynchExpression

getTemplateObjects

getTransitionExpression

getUsedByTemplates

getUsedTemplates

importTemplates

isTemplateInUse

removeLinkTemplate

removeStepTemplate

saveProcessTemplate

saveProcessTemplate

saveProcessTemplate

saveProcessTemplate

setEnabled

setIgnoreDelete

setParentTemplate

verifyTemplate

whereUsed

whereUsed

whereUsed

getProcessDefinition

getProcessTemplates

getAllStepTemplates

wt.workflow.definer
Class StandardWfDefinerService