com.smartgwt.client.util.workflow

## Class Process

- java.lang.Object
- - com.smartgwt.client.core.BaseClass
  - - com.smartgwt.client.util.workflow.ProcessElement
    - - com.smartgwt.client.util.workflow.Task
      - - com.smartgwt.client.util.workflow.Process

-     public class Process
      extends Task

  A instance of Process represents a stateful process executing a series of Tasks, which may be:
  - user interactions
  - calls to DataSources (hence: any database or web service)
  - arbitrary code
  - other Processes
  A Process is stateful in the sense that it maintains `state` across the different tasks that are executed. This allows you to maintain context as you walk a user through a multi-step business process in your application, which may involve multiple operations on multiple entities. Each Task that executes can use the Process state as inputs, and can output a result which is stored in the Process state - see `TaskIO`.

  A Process can have multiple branches, choosing the next Task to execute based on `Criteria` - see `XORGateway` and `DecisionGateway`.

  Because a Process may return to a previous Task in various situations, the data model of a Process is strictly speaking a graph (a set of nodes connected by arbitary interlinks). However, most processes have sequences of several tasks in a row, and the definition format allows these to be represented as simple Arrays called "sequences", specified via `sequences`. This reduces the need to manually specify IDs and interlinks for Tasks that simply proceed to the next task in a sequence.

  NOTE: you must load the Workflow module `Optional Modules` before you can use Process.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static interface` | `Process.ProcessCallback`

  - ### Field Summary

    - ### Fields inherited from class com.smartgwt.client.core.BaseClass

      `config, id, scClassName`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Process()`
    `Process(com.google.gwt.core.client.JavaScriptObject jsObj)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `com.google.gwt.core.client.JavaScriptObject` | `create()`
    `void` | `finished(Record state)` StringMethod called when a process completes, meaning the process executes a ProcessElement with no next element.
    `java.lang.String` | `getContainerId()` Identifier of canvas where should be added UI elements created by using `inline view` property.
    `ProcessElement` | `getElement(java.lang.String ID)` Retrieve a `ProcessElement` by it's ID
    `ProcessElement[]` | `getElements()` Elements involved in this Process.
    `static Process` | `getOrCreateRef(com.google.gwt.core.client.JavaScriptObject jsObj)`
    `static Process` | `getProcess(java.lang.String processId)` Get a Process instance by it's ID.
    `ProcessSequence[]` | `getSequences()` Sequences of ProcessElements.
    `Record` | `getSetState()` Set new process state.
    `java.lang.String` | `getStartElement()` The ID of either a `sequence` or an `element` which should be the starting point of the process.
    `Record` | `getState()` Current state of a process.
    `java.lang.Boolean` | `getWizard()` If wizard is set then current workflow will be handled as wizard.
    `static void` | `loadProcess(java.lang.String processId, Process.ProcessCallback callback)`
    `protected void` | `onInit_Process()`
    `protected void` | `onInit()`
    `void` | `reset(Record state)` Reset process to it's initial state, so process can be started again.
    `void` | `setConfig(com.google.gwt.core.client.JavaScriptObject jsObj)`
    `void` | `setContainerId(java.lang.String containerId)` Identifier of canvas where should be added UI elements created by using `inline view` property.
    `void` | `setElements(ProcessElement... elements)` Elements involved in this Process.
    `void` | `setJavaScriptObject(com.google.gwt.core.client.JavaScriptObject jsObj)`
    `void` | `setSequences(ProcessSequence... sequences)` Sequences of ProcessElements.
    `void` | `setSetState(Record setState)` Set new process state.
    `void` | `setStartElement(ProcessElement startElement)`
    `void` | `setStartElement(java.lang.String startElement)` The ID of either a `sequence` or an `element` which should be the starting point of the process.
    `void` | `setState(Record state)` Current state of a process.
    `void` | `setWizard(java.lang.Boolean wizard)` If wizard is set then current workflow will be handled as wizard.
    `void` | `start()` Starts this task by executing the `startElement`.

    - ### Methods inherited from class com.smartgwt.client.util.workflow.Task

      `getInputField, getInputFields, getOutputField, getOutputFields, setInputField, setInputFields, setOutputField, setOutputFields`

    - ### Methods inherited from class com.smartgwt.client.util.workflow.ProcessElement

      `convertToJavaScriptArray, getID, getJsObj, getNextElement, getOrCreateJsObj, getProcessElements, isCreated, setAttribute, setID, setNextElement`

    - ### Methods inherited from class com.smartgwt.client.core.BaseClass

      `asSGWTComponent, destroy, doAddHandler, doInit, error, error, errorIfNotCreated, fireEvent, getAttribute, getAttributeAsBoolean, getAttributeAsDate, getAttributeAsDouble, getAttributeAsElement, getAttributeAsFloat, getAttributeAsInt, getAttributeAsJavaScriptObject, getAttributeAsMap, getAttributeAsString, getAttributeAsStringArray, getClassName, getConfig, getHandlerCount, getRef, getScClassName, internalSetID, internalSetID, onBind, registerID, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setProperty, setProperty, setProperty, setProperty, setScClassName`

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

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

- - ### Constructor Detail

    - #### Process

          public Process()

    - #### Process

          public Process(com.google.gwt.core.client.JavaScriptObject jsObj)

  - ### Method Detail

    - #### getOrCreateRef

          public static Process getOrCreateRef(com.google.gwt.core.client.JavaScriptObject jsObj)

    - #### setJavaScriptObject

          public void setJavaScriptObject(com.google.gwt.core.client.JavaScriptObject jsObj)

      Overrides:
        `setJavaScriptObject` in class `Task`

    - #### create

          public com.google.gwt.core.client.JavaScriptObject create()

      Overrides:
        `create` in class `Task`

    - #### setContainerId

          public void setContainerId(java.lang.String containerId)

      Identifier of canvas where should be added UI elements created by using `inline view` property.
      Parameters:
        `containerId` - . See `String`. Default value is null

    - #### getContainerId

          public java.lang.String getContainerId()

      Identifier of canvas where should be added UI elements created by using `inline view` property.
      Returns:
        . See `String`

    - #### setSequences

          public void setSequences(ProcessSequence... sequences)
                            throws java.lang.IllegalStateException

      Sequences of ProcessElements. By defining a sequences of elements you can make the `nextElement` implicit.

      Example of using sequences:

            Process process = new Process();
            process.setStartElement("firstSequence");
            ProcessSequence innerSequence = new ProcessSequence(incTask, add2Task, incTask);
            process.setSequences(
                new ProcessSequence("firstSequence", serviceTask, decisionGateway),
                new ProcessSequence("errorFlow", failureTask, userNotifyTask)
            );
            // standalone process elements not part of sequences
            process.setElements(new ServiceTask(){...});
            Record state = new Record();
            state.setAttribute("someField", "someValue");
            process.setState(state);
            process.start();

      Parameters:
        `sequences` - sequences Default value is null
      Throws:
        `java.lang.IllegalStateException` - this property cannot be changed after the underlying component has been created

    - #### getSequences

          public ProcessSequence[] getSequences()

      Sequences of ProcessElements. By defining a sequences of elements you can make the `nextElement` implicit.

      Example of using sequences:

            Process process = new Process();
            process.setStartElement("firstSequence");
            ProcessSequence innerSequence = new ProcessSequence(incTask, add2Task, incTask);
            process.setSequences(
                new ProcessSequence("firstSequence", serviceTask, decisionGateway),
                new ProcessSequence("errorFlow", failureTask, userNotifyTask)
            );
            // standalone process elements not part of sequences
            process.setElements(new ServiceTask(){...});
            Record state = new Record();
            state.setAttribute("someField", "someValue");
            process.setState(state);
            process.start();

      Returns:
        ProcessSequence

    - #### setSetState

          public void setSetState(Record setState)

      Set new process state.
      Parameters:
        `setState` - setState Default value is null

    - #### getSetState

          public Record getSetState()

      Set new process state.
      Returns:
        Record

    - #### setStartElement

          public void setStartElement(java.lang.String startElement)
                               throws java.lang.IllegalStateException

      The ID of either a `sequence` or an `element` which should be the starting point of the process. If not specified, the first sequence is chosen, or if there are no sequences, the first element. - log a warning and do nothing if there are neither sequences or elements
      Parameters:
        `startElement` - . See `String`. Default value is null
      Throws:
        `java.lang.IllegalStateException` - this property cannot be changed after the underlying component has been created

    - #### getStartElement

          public java.lang.String getStartElement()

      The ID of either a `sequence` or an `element` which should be the starting point of the process. If not specified, the first sequence is chosen, or if there are no sequences, the first element. - log a warning and do nothing if there are neither sequences or elements
      Returns:
        . See `String`

    - #### setState

          public void setState(Record state)

      Current state of a process. As with Records in general, any field of a Record may contain a nested Record or Array of Records, so the process state is essentially a hierarchical data structure.
      If this method is called after the component has been drawn/initialized: Set process state for current process
      Parameters:
        `state` - the new process state. Default value is null

    - #### getState

          public Record getState()

      Current state of a process. As with Records in general, any field of a Record may contain a nested Record or Array of Records, so the process state is essentially a hierarchical data structure.
      Returns:
        Record

    - #### setWizard

          public void setWizard(java.lang.Boolean wizard)
                         throws java.lang.IllegalStateException

      If wizard is set then current workflow will be handled as wizard. Every userTask will hide associated form after user finished step.
      Parameters:
        `wizard` - wizard Default value is false
      Throws:
        `java.lang.IllegalStateException` - this property cannot be changed after the underlying component has been created

    - #### getWizard

          public java.lang.Boolean getWizard()

      If wizard is set then current workflow will be handled as wizard. Every userTask will hide associated form after user finished step.
      Returns:
        Boolean

    - #### finished

          public void finished(Record state)

      StringMethod called when a process completes, meaning the process executes a ProcessElement with no next element.
      Parameters:
        `state` - the final process state

    - #### getElement

          public ProcessElement getElement(java.lang.String ID)

      Retrieve a `ProcessElement` by it's ID
      Parameters:
        `ID` - id of the process element
      Returns:
        the indicated process element, or null if no such element exists

    - #### reset

          public void reset(Record state)

      Reset process to it's initial state, so process can be started again.
      Parameters:
        `state` - new state of the process

    - #### start

          public void start()

      Starts this task by executing the `startElement`.

    - #### getProcess

          public static Process getProcess(java.lang.String processId)

      Get a Process instance by it's ID. See `Process.loadProcess`.
      Parameters:
        `processId` - process IDs to retrieve
      Returns:
        the process, or null if not loaded

    - #### setConfig

          public void setConfig(com.google.gwt.core.client.JavaScriptObject jsObj)

    - #### loadProcess

          public static void loadProcess(java.lang.String processId,
                         Process.ProcessCallback callback)

    - #### getElements

          public ProcessElement[] getElements()

      Elements involved in this Process. You can also group elements into `sequences` to reduce the need to explicitly define IDs for elements and interlink them.
      Returns:
        ProcessElement

    - #### setElements

          public void setElements(ProcessElement... elements)
                           throws java.lang.IllegalStateException

      Elements involved in this Process. You can also group elements into `sequences` to reduce the need to explicitly define IDs for elements and interlink them.
      Parameters:
        `elements` - elements Default value is null
      Throws:
        `java.lang.IllegalStateException` - this property cannot be changed after the underlying component has been created

    - #### setStartElement

          public void setStartElement(ProcessElement startElement)
                               throws java.lang.IllegalStateException

      Throws:
        `java.lang.IllegalStateException`
      See Also:
        `setStartElement(String)`

    - #### onInit_Process

          protected void onInit_Process()

    - #### onInit

          protected void onInit()

      Overrides:
        `onInit` in class `BaseClass`