The Activity

Overview

An activity defines the core unit of execution in a process. A process consists of one or more activities. An activity contains one or more Object Groups housing one or more objects. These objects define the input, rules and resulting flow within the process. At runtime, an activity is instantiated, and the instance assigned to configured participants (whether a User or Role Group) where the instance is then transformed into a user interface or form to be rendered by clients, presenting the Object Groups and objects accordingly as client-specific controls.

The (inherently web-oriented) life-cycle of an activity instance:

Opening a new/pending instance (includes resetting an instance)

The client presents a list of new or pending task instance descriptions to a user; following the selection of one of these the engine performs the following actions:

1. Materialization

   The first step in opening a task instance is to materialize it from the back-end. The result is an empty structure based on the designed task.

2. Population

   Several actions are performed to populate the created task instance, and in the following order:

   a) Inherit Values

   If a pending task is designed to Inherit Values, the object values of the first instance in the current pending task's branch (as directed path from the current pending task all the way to the first task that started the process instance) that has the same designed task associated with it (both are instances of the same task) will be copied to the current pending instance. This includes the population of Object Group rows and all objects on the instance. No code, whether .NET or VBScript, has been executed yet.

   b) Task Parameters

   All task parameters provided (externally) are applied – this results in the (possibly additional) population of the objects on the current instance.

   c) Managed Code Engine

   The Managed Code Engine instantiates an appropriately designated FlowCentric.Engine.Managed.TaskForm implementation as executable for the task instance (if found), and executes the method with the following signature:

   protected virtual System.Threading.Tasks.Task LoadAsync(
       FormLoadContext context,
       System.Threading.CancellationToken cancellationToken);
   

   and for VB.NET:

   Protected Overridable Function LoadAsync(
       context As FormLoadContext,
       cancellationToken As System.Threading.CancellationToken)
     As System.Threading.Tasks.Task
   

   The TaskFormCodeGenerator Custom Tool automatically generates an implementation for this method similar to the following:

   /// <inheritdoc />
   protected override async Tasks.Task LoadAsync(
       FormLoadContext context,
       CancellationToken cancellationToken)
   {
       // Load Script equivalent goes here...
       // Load Groups
       await this.ColumnsGroup1.LoadAsync(context, cancellationToken);
       // More Groups here...
   
       // Calling base.RefreshAsync(context, cancellationToken) to forward to Refresh method.
       await RefreshAsync(context, cancellationToken);
   }
   

   and for VB.NET

       '''<inheritdoc/>
       Protected Overrides Async Function LoadAsync(
           context As FormLoadContext,
           cancellationToken As CancellationToken) As Tasks.Task
       ' Load Script equivalent goes here...
       ' Load Groups
           Await ColumnsGroup1.LoadAsync(context, cancellationToken)
       ' More Groups here...
   
       ' Calling base.RefreshAsync(context, cancellationToken) to forward to Refresh method.
           Await RefreshAsync(context, cancellationToken)
       End Function
   

   This implementation aims at a backward-compatible implementation with Load Script related functionality, followed by per column group specific Load Scripts (in the order that these would have been executed in the VBScript engine, i.e. ordered by object group id), and finally an initial refresh of the associated TaskForm implementation.

   c) VBScript (Classic) Engine

   i) Task Load Script

   The VBScript associated with the Task's Load Script is executed first.

   ii) Object Group Scripts

   The VBScript associated with all Object Groups are executed next, in the order of their Object Group IDs.

   iii) Object Scripts

   Finally, all the VBScripts of all objects (excluding Command Options) as associated with this instance are executed, in the order of objects' indexes.

3. Transformation

   In this final step, the instance is transformed into a client-agnostic format to be presented by an associated client to some user. At this point in time, all Browse Page definitions are evaluated to be available on said client.

Warning

The order of execution has changed slightly from previous versions with regards to the population of a task - this was mainly done for the sake of consistency between the Managed Code and VBScript (Classic) Engines. Previously Inherit Values were followed by Object Group Scripts, Task Parameters, Task Load Script, and finally Object Scripts. This would typically result in the Object Group Scripts not having access to Task Parameters.

Retrieving Browse Page Data

Once a user opens a (normal or advanced) Browse Page, the client requests the data page to be displayed based on the specific state of the task instance (as populated by the engine and the user). The following details the actions that the engine performs to provide the configured data page:

1. Materialization

   The engine materializes the specific task instance from the back-end, again resulting in an empty structure based on the designed task (the same result as in the preceding life-cycle section).

2. Population

   The task instance is populated with the values sent by the client, representing the current state of the task instance. No code, whether .NET or VBScript, has been executed yet.

3. Building the data page

   Managed Code Engine

   The Managed Code Engine instantiates an appropriately designated FlowCentric.Engine.Managed.TaskForm implementation as executable for the task instance (if found), and executes the method with the following signature:

   protected virtual System.Threading.Tasks.Task<DataPage> GetDataAsync(
       FormDataContext context,
       System.Threading.CancellationToken cancellationToken);
   

   and for VB.NET

   Protected Overridable Function GetDataAsync(
       context As FormDataContext,
       cancellationToken As System.Threading.CancellationToken)
       As System.Threading.Tasks.Task(Of DataPage)
   

   The TaskFormCodeGenerator Custom Tool automatically generates an implementation for this method similar to the following:

   /// <inheritdoc />
   protected override async Tasks.Task<DataPage> GetDataAsync(
       FormDataContext context,
       CancellationToken cancellationToken)
   {
       // Please update the OleDb connection string setting 'TO_UPDATE'.
       // Alternatively, remove this method to inherit the default implementation
       // that is backward-/designer-compatible.
       string oleDbConnectionString =
           context.Settings.Company.Connections.TO_UPDATE;
       DataPage dataPage = null;
       switch (context.ControlName)
       {
           case Fields.UngroupedPage1Name:
               dataPage = await context.GetDataPageAsync(
                   this.UngroupedPage1,
                   oleDbConnectionString,
                   cancellationToken);
           break;
           // ...
           case Groups.ColumnsGroup1.GroupedPage1Name:
               dataPage = await context.GetDataPageAsync(
                   this.ColumnsGroup1.GroupedPage1,
                   oleDbConnectionString,
                   cancellationToken);
           break;
           // ...
           default:
               dataPage = await base.GetDataAsync(context, cancellationToken);
           break;
       }
       return dataPage;
   }
   

   and for VB.NET

   '''<inheritdoc/>
   Protected Overrides Async Function GetDataAsync(
       context As FormDataContext,
       cancellationToken As CancellationToken) As Tasks.Task(Of DataPage)
       ' Please update the OleDb connection string setting 'TO_UPDATE'.
       ' Alternatively, remove this method to inherit the default
       ' implementation that is backward-/designer-compatible.
       Dim oleDbConnectionString As String =
           context.Settings.Company.Connections.TO_UPDATE
       Dim dataPage As DataPage = Nothing
       Select context.ControlName
           Case Fields.UngroupedPage1Name
               dataPage = Await context.GetDataPageAsync(
                   UngroupedPage1,
                   oleDbConnectionString,
                   cancellationToken)
               Exit Select
           ' ...
           Case Groups.ColumnsGroup1.GroupedPage1Name
               dataPage = Await context.GetDataPageAsync(
                   ColumnsGroup1.GroupedPage1Name,
                   oleDbConnectionString,
                   cancellationToken)
               Exit Select
           ' ...
           Case Else
               dataPage = Await GetDataAsync(context, cancellationToken)
               Exit Select
       End Select
   
       Return dataPage
   End Function
   

   This implementation lists all the (normal and/or advanced) Browse Pages allowing for a page-specific data-page override, a backward-compatible data page, or even complete backward/designer-compatibility by removing the implementation (as stated in the comments). See the appropriate section on Browse Page Controls for more details.

   VBScript (Classic) Engine

   The (normal or advanced) Browse Page representation is materialized and populated by executing the VBScripts on the specific Browse Page (based, again, on the current state of the task instance).

4. Transformation

   The resulting data page is returned in a client-agnostic format to be presented by the client to the user.

These steps are performed for every Browse Page (irrespective of the type of Browse Page), for every data page available (as per configuration).

Refreshing an instance (post-backs)

An activity instance needs to be refreshed when a row in some Object Group is added or removed, the Object Group is refreshed, or some object (whether included in an Object Group) was designed to post-back on having its value changed. The engine performs the following actions in these cases:

1. Materialization

   The specific instance is once again materialized from the back-end, resulting in an empty structure based on the signed activity (the same result as in the first life-cycle section).

2. Population

   The current state of the activity instance, as sent by the client, is used to populate the structure from the previous step. No code, whether .NET or VBScript, has been executed yet.

3. Refresh

   Managed Code Engine

   The Managed Code Engine instantiates an appropriately designated FlowCentric.Engine.Managed.TaskForm implementation as executable for the task instance (if found), and executes the method with the following signature:

   protected virtual System.Threading.Tasks.Task RefreshAsync(
       FormRefreshContext context,
       System.Threading.CancellationToken cancellationToken);
   

   and for VB.NET

   Protected Overridable Function RefreshAsync(
       context As FormRefreshContext,
       cancellationToken As System.Threading.CancellationToken)
       As System.Threading.Tasks.Task
   

   The TaskFormCodeGenerator Custom Tool automatically generates an implementation for this method similar to the following:

   /// <inheritdoc />
   protected override async Tasks.Task RefreshAsync(
       FormRefreshContext context,
       CancellationToken cancellationToken)
   {
       if(!String.IsNullOrWhiteSpace(context.GroupName))
       {
           ColumnsGroup columnsGroup = this.ColumnsGroup1;
           switch(context.GroupName)
           {
               case Groups.ColumnsGroup2.Name:
                   columnsGroup = this.ColumnsGroup2;
               break;
               // ...
               case Groups.ColumnsGroupX.Name:
                   columnsGroup = this.ColumnsGroupX;
               break;
           }
   
           var groupAction = GroupAction.Refresh;
           var rowNumber = context.RowNumber;
           if(context.RowAddition)
           {
               groupAction = GroupAction.RowAddition;
               switch(columnsGroup.Group.GetExecutionOnRowAddition())
               {
                   case ScriptExecution.PerPage:
                       columnsGroup = null;
                   break;
                   case ScriptExecution.PerGroup:
                       rowNumber = null;
                   break;
                   default:
                       // Handled!
                   return;
               }
           }
           else if(context.RowRemoval)
           {
               groupAction = (GroupAction.RowRemoval);
               switch(columnsGroup.Group.GetExecutionOnRowRemoval())
               {
                   case ScriptExecution.PerPage:
                       columnsGroup = null;
                   break;
                   case ScriptExecution.PerGroup:
                       rowNumber = null;
                   break;
                   default:
                       // Handled!
                   return;
               }
           }
           else // Row Refresh.
           {
               switch(columnsGroup.Group.GetExecutionOnRowRefresh())
               {
                   case ScriptExecution.PerPage:
                       columnsGroup = null;
                   break;
                   case ScriptExecution.PerGroup:
                       rowNumber = null;
                   break;
               }
           }
   
           if(columnsGroup != null)
           {
               await columnsGroup.RefreshAsync(
                   context,
                   groupAction,
                   context.ControlName,
                   rowNumber,
                   cancellationToken);
               // Group Refresh Handled!
               return;
           }
       }
   
       // Refresh Script equivalent goes here...
   
       // All controls ordered by index ( = order of execution).
       await this.ColumnsGroup1.RefreshAsync(
           context,
           GroupAction.Refresh,
           null,
           null,
           cancellationToken);
       // ...
       await this.ColumnsGroupX.RefreshAsync(
           context,
           GroupAction.Refresh,
           null,
           null,
           cancellationToken);
       // ...
   }
   

   and for VB.NET

   '''<inheritdoc/>
   Protected Overrides Async Function RefreshAsync(
       context As FormRefreshContext,
       cancellationToken As CancellationToken) As Tasks.Task
       If Not([String].IsNullOrWhiteSpace(context.GroupName)) Then
           Dim columnsGroup As ColumnsGroup = ColumnsGroup1
           Select context.GroupName
               Case Groups.ColumnsGroup2.Name:
                   columnsGroup = ColumnsGroup2
               Exit Select
               ' ...
               Case Groups.ColumnsGroupX.Name:
                   columnsGroup = ColumnsGroupX
               Exit Select
   
           Dim groupAction As GroupAction = GroupAction.Refresh
           Dim rowNumber = context.RowNumber
           If context.RowAddition Then
               groupAction = GroupAction.RowAddition
               Select columnsGroup.Group.GetExecutionOnRowAddition()
                   Case ScriptExecution.PerPage
                       columnsGroup = Nothing
                       Exit Select
                   Case ScriptExecution.PerGroup
                       rowNumber = Nothing
                       Exit Select
                   Case Else
                       ' Handled!
                       Return
               End Select
           ElseIf context.RowRemoval Then
               groupAction = GroupAction.RowRemoval
               Select columnsGroup.Group.GetExecutionOnRowRemoval()
                   Case ScriptExecution.PerPage
                       columnsGroup = Nothing
                       Exit Select
                   Case ScriptExecution.PerGroup
                       rowNumber = Nothing
                       Exit Select
                   Case Else
                       ' Handled!
                       Return
               End Select
           Else
               Select columnsGroup.Group.GetExecutionOnRowRefresh()
                   Case ScriptExecution.PerPage
                       columnsGroup = Nothing
                       Exit Select
                   Case ScriptExecution.PerGroup
                       rowNumber = Nothing
                       Exit Select
               End Select
           End If
   
           If columnsGroup IsNot Nothing Then
               Await columnsGroup.RefreshAsync(
                   context,
                   groupAction,
                   context.ControlName,
                   rowNumber,
                   cancellationToken)
               ' Group Refresh Handled!
               Return
           End If
       End If
   
       ' Refresh Script equivalent goes here...
   
       ' All controls ordered by index ( = order of execution).
       Await ColumnsGroup1.RefreshAsync(
           context,
           GroupAction.Refresh,
           Nothing,
           Nothing,
           cancellationToken)
       ' ...
       Await ColumnsGroupX.RefreshAsync(
           context,
           GroupAction.Refresh,
           Nothing,
           Nothing,
           cancellationToken);
       ' ...
   End Function
   

   This implementation starts off with a simple backward/designer-compatible algorithm for performing a columns group specific refresh, instead of refreshing all controls and groups, based on the group specific refresh type (refresh, add, or remove). If the refresh is not group-specific, then continue with the Refresh Script equivalent code, continuing with the refresh of all controls and groups according to control indices.

   VBScript (Classic) Engine

   The actual refresh of the task instance depends on the cause of the refresh and the associated configuration.

   a) Page Refresh

   A page refresh occurs in the following cases

   i. an un-grouped object configured to post-back on value changes has its value changed,

   ii. a grouped object configured to post-back on value changes has its value changed, and the containing Object Group has its Post Back Script Execution Mode property set to Page (value 0)

   iii. Line addition or removal on an Object Group configured with either its Add Lines or Delete Lines Script Execution Mode set to Page (value 0)

   iv. Object Group manually refreshed. The steps executed in this case include:

   • The execution of the task Refresh Script,

   • The execution of all the VBScripts of all objects (excluding Command Options) as associated with this instance, in the order of the objects' indexes.

     b) Group Refresh

     A group refresh occurs in the following cases

     i. a grouped object configured to post-back on value changes has its value changed, and the containing Object Group has its Post Back Script Execution Mode property set to Group (value 1)

     ii. Line addition or removal on an Object Group configured with either its Add Lines or Delete Lines Script Execution Mode set to Group (value 1)

     In this case all VBScripts for all objects in the Object Group are executed, on a row-by-row basis, as in the VBScripts for all objects in row i are executed based on the objects' indexes, before the execution on row i+1.

     c) Line Refresh

     A line refresh occurs when a grouped object is configured to post-back on value changes and has its value changed, while its containing Object Group's Post Back Script Execution Mode is set to Line (value 2). In this case all VBScripts of all objects for that line is executed ordered by the index of the objects on that line.

4. Transformation

   Once again, the instance is transformed in a client-agnostic format to the client, and all Browse Page definitions are re-evaluated for client-side availability.

Submitting the instance/Continuing the Process

When a user selects a Command Option, the client sends the task in its current state, and the engine performs the following actions:

1. Materialization

   An empty structure based on the designed task is once again materialized from the back-end.

2. Population

   The structure from the previous step is populated based on the values sent from the client. No code, whether .NET or VBScript, has been executed yet.

3. Continuation

   The following outlines the rules pertaining to the continuation of the process instance:

   a) For each Object Group in the instance, empty lines are removed, where an empty line entails any line on which the first grouped object (by index) that is either a Browse Page with a visible textbox, or any of the other objects, is empty.

   b) Managed Code Engine

   The Managed Code Engine instantiates an appropriately designated FlowCentric.Engine.Managed.TaskForm implementation as executable for the task instance (if found), and executes the method with the following signature:

   protected virtual System.Threading.Tasks.Task ValidateAsync(
       FormValidationContext context,
       System.Threading.CancellationToken cancellationToken);
   

   and for VB.NET

   Protected Overridable Function ValidateAsync(
       context As FormValidationContext,
       cancellationToken As System.Threading.CancellationToken)
           As System.Threading.Tasks.Task
   

   The implementation of this method allows for custom validation (prior to engine validation).

   b) VBScript (Classic) Engine

   Refresh the task instance in its current state by executing the task's Refresh Script followed by the execution of the VBScript of all objects (excluding Command Options) as associated with the instance, in the order of the objects` indexes.

   c) Perform (engine) validation, including required field validation (if so configured on the selected Command Option), Input Mask and Data Type validations (on Simple Text Boxes and Date Pickers).

   d) Upload the data associated with all File Attachments as configured.

   e) If this was a first (process instance starter) task, persist the instance - indicating the creation of the process instance. For a pending task, mark it as completed to prevent others from completing the same task.

   f) Managed Code Engine

   The Managed Code Engine executes the method with the following signature (on the appropriately designated FlowCentric.Engine.Managed.TaskForm implementation):

   protected virtual System.Threading.Tasks.Task CompleteAsync(
       FormCompletionContext context,
       System.Threading.CancellationToken cancellationToken);
   

   and for VB.NET

   Protected Overridable Function CompleteAsync(
       context As FormCompletionContext,
       cancellationToken As System.Threading.CancellationToken)
           As System.Threading.Tasks.Task
   

   The TaskFormCodeGenerator Custom Tool automatically generates an implementation for this method similar to the following:

   /// <inheritdoc />
   protected override Tasks.Task CompleteAsync(
       FormCompletionContext context,
       CancellationToken cancellationToken)
   {
       switch(context.CommandName)
       {
           case Fields.Command1Name:
               // Handle accordingly.
           break;
           // ...
           case Fields.CommandXName:
               // Handle accordingly.
           break;
       }
       return Tasks.Task.CompletedTask;
   }
   

   and for VB.NET

   '''<inheritdoc/>
   Protected Overrides Function CompleteAsync(
       context As FormCompletionContext,
       cancellationToken As CancellationToken) As Tasks.Task
       Select context.CommandName
           Case Fields.Command1Name:
               ' Handle accordingly.
           Exit Select
           ' ...
           Case Fields.CommandXName:
               ' Handle accordingly.
           Exit Select
       Return Tasks.Task.CompletedTask
   End Function
   

   This implementation determines which Command Option was selected, allowing the implementor to act accordingly.

   Important

   The Managed Code Engine does not currently support process flow logic directly, and the VBScript (Classic) Engine is spun up to evaluate the selected Command Option (refer to the next step).

   f) VBScript (Classic) Engine

   Execute the VBScript on the selected Command Option.

   g) If this was a first (process instance starter) task, execute and persist it’s Dynamic Description.

   Important

   Again it is important to note that the Managed Code Engine does not currently support the evaluation of dynamic descriptions, and the VBScript (Classic) Engine spun up in the previous step is used to evaluate the dynamic description.

   h) The task instance is now considered to be completed. Based on the outcome of the Command Option's execution, the Process Instance is either:

   • Completed

     i. Persist object values with the representation of their current state (Options).

     ii. Archive the current Process Instance.

   • Not completed

     i. Retrieve the tasks that are to follow the current (completed) instance.

     ii. Evaluate the Dynamic Descriptions of the new pending instances.

     iii. Persist the object values with the representation of their state (Options) for the completed instance.

     iv. Derive the participants that are to perform on the resulting instances.

     v. Persist the new pending instances, complete with their dynamic descriptions and allocated participants.

     On any error prior to the completion of the initial task instance, all uploaded File Attachments are removed and the back-end cleared to allow for the correction and continuation of the instance.

Properties

Tasks support the following properties:

Attributes

Standard Time

An integer value indicating the time, in number of minutes, in which this task is expected to be completed. This value is not currently used by the runtime.

Behavior

Allow Parameterization

A Boolean value indicating whether the task should allow being populated via parameters. The parameters are usually a collection of name-value pairs, identifying non-grouped objects and their initial values. The default value is True.

How do I get the Allow Parameterization value of an activity

Via VBScript:

allowParameterization = fcBusinessEvent.AllowParameterization

Note

This value cannot be changed via VBScript.

Auto Load Next

A Boolean value specifying whether a next activity should be loaded automatically when this one is completed. The next activity must be assigned to the current participant (either directly to the Role or indirectly via membership to a Role Group). The default value is False.

How do I get the Auto Load Next value of an activity

Via VBScript:

autoLoadNext = fcBusinessEvent.AutoLoadNext

Note

This value cannot be changed via VBScript.

Event Create

Specifies the Creation Type for the activity, that mostly indicates the type of participant associated with the activity. In some cases the Creation Type can also indicate where an instance of the activity will be located on clients (such as First Activity on new processes and Report for reporting activities/processes). This property defines the design-time value, that can be overwritten via VBScript (specifically Trigger scripts) on Command Options.

Creation Type

The Creation Type property indicates the rules for the creation of the activity, and specializes the associated Creation Value property accordingly. The possible Creation Types include:

Dynamic Group

This Creation Type value binds the participant of an activity to the result of an object on a preceding activity (in the branch defined by the path for an instance of the current activity to the first activity that started the process instance). The value specified in the Creation Value property references an object (usually a Reference Label or Team Select) that has as value the name of the Role Group-based participant that should complete the resulting activity instance.

First Activity

The Creation Type value that binds a Role Group Creation Value to the current activity, and indicates that the current activity initiates process instances of its containing process. The activity will be available to Users with Roles in the specified Role Group, and will be located under the New Processes section of supporting clients.

Group

This Creation Type value statically binds a specific Role Group Creation Value as participant for the instances of the current activity. Only a single Role in this Role Group will be able to take ownership of the activity instance (by assigning it to him-/herself), after which it will not be available anymore to other Roles in the Role Group.

Group Member Split

The Creation Type value that statically binds all members of a specific Role Group Creation Value as participants for an equal number of activity instances of the current activity, such that each member or Role in the Role Group will need to complete one such instance.

Object Value

This Creation Type value binds the participant of an activity to the result of an object on a preceding activity (in the branch defined by the path for an instance of the current activity to the first activity that started the process instance). The value specified in the Creation Value property references an object (usually a Reference Label or Employee-Lookup) that has as value the full name of a valid user (in the format FirstName LastName) that should complete the resulting activity instance.

Originator

The Creation Type value indicating that the Role that started the associated process instance (or that completed the single First Activity in the process) should complete the resulting instance of the current activity. No Creation Value is required.

Reply To

Another Creation Type referencing an existing participant in the current process instance, this time the participant is the Role that completed the activity instance preceding the current one. No Creation Value is required.

Report

The Creation Type value that binds a Role Group Creation Value to the current activity, and indicates that the current activity provides reporting capabilities. As such the activity will be available to Users with Roles in the specified Role Group, and located under the Reports section of supporting clients.

Report To

The Creation Type value indicating that instances of the current activity are to be completed by the Report To configured for the Role that completed the preceding activity instance. A typical use case for this Creation Type is applicable to an approval step in a typical approval process. No Creation Value is required.

Role Object Value

This Creation Type value binds the participant of an activity to the result of an object on a preceding activity (in the branch defined by the path for an instance of the current activity to the first activity that started the process instance). The value specified in the Creation Value property references an object that has as value the description of a valid Role that should complete the resulting activity instance.

Same As

The Creation Type value that binds the participant for instances of the current activity to the Role that completed a preceding activity instance (in the branch defined by the path for an instance of the current activity to the first activity that started the process instance), with the Creation Value specifying the name of the preceding activity.

User

This Creation Type value binds the participant of an activity to a specific User, as defined by that User’s Role (as specified in the Creation Value).

Hyperlink

Specifies the URI to a custom page that is to be loaded and displayed in the current activity’s stead.

Index

A unique (per process) integer value indicating the sequence of the activities in the parent process. This value is mostly used in the designer (and specifically the Script Editor) to order the activities, and to provide a default unique Name for the activity.

Inherit Values

A Boolean value indicating whether instances of the current activity may be initialized with values from other preceding (identical activity) instances (in the branch defined by the path for an instance of the current activity to the first activity that started the process instance). The default value is False.

How do I get the Inherit Values value of an activity

Via VBScript:

inheritsValues = fcBusinessEvent.InheritValues

Note

This value cannot be changed via VBScript.

JavaScript File Name

Specifies the (web-only) name of a JavaScript file to be associated with instances of the current activity, optionally grouping the functionality to be applied on child Simple Text Box’s client-side-events (see the ClientSideEvents property for more details). This file must be located in a client-specific directory (as specified by the client).

Layout

Specifies an optional layout that is to be applied to instances of this activity, overwriting the default layout of a client. A default client-specific layout typically renders an activity with all ungrouped objects (excluding Command Options) rendered first, ordered by index, followed by Object Groups ordered by ID (and grouped objects ordered by index), and finally the Command Options (again ordered by index). The [GroupByControlIndex] layout value instructs clients to render activities by ordering all objects (grouped and ungrouped, excluding Command Options) by index, rendering Object Groups where ever an appropriate first grouped object occurs, followed by the Command Options (ordered by index).

How do I get the Layout value of an activity

Using C#:

using FlowCentric.Engine.Entities.Classic;
//...
var layout = Extensions.GetLayout(base.Form);
// or
var layout = base.Form.GetLayout();

Via VBScript:

layout = fcBusinessEvent.StyleSheet

How do I set the Layout value of an activity

Using C#:

using FlowCentric.Engine.Entities.Classic;
//...
Extensions.SetLayout(base.Form, "[GroupByControlIndex]");
// or
base.Form.SetLayout("[GroupByControlIndex]");

Via VBScript:

fcBusinessEvent.StyleSheet = "[GroupByControlIndex]"

Object Groups

Allows the configuration of the Object Groups associated with the activity.

Identification

Description

The default title (or short text description) for instances of the current activity that will be displayed on clients. This value defines the title for the activity as associated with the default Processware Language, and can be made language-specific using the Language Editor in the designer. The default description can also be overwritten via the Dynamic Description of the activity.

ID

Displays the (read-only) numeric identifier of this activity.

How do I get the ID of an activity

Using C#:

var id = base.Form.DesignTimeId;

Via VBScript:

Id = fcBusinessEvent.EventID

Note

This value cannot be changed.

Parent

Displays the (read-only) numeric identifier of the process containing (or parenting) the activity.

How do I get the ID of an activity’s parent process

Using C#:

var id = context.Process.DesignTimeId;

Where context is one of the FormXXXContext parameters from an appropriately overridden TaskForm method.

Via VBScript:

id = fcBusinessEvent.ProcessID

Or by referencing its parent directly, as in:

id = Process.ID

Name

The unique (per process) name of the activity that can be used to reference the activity at runtime (via VBScript). It is usually of the form ProcessPrefix+ActivityIndex_ActivityDesignator, where ProcessPrefix usually denotes part of the containing process’ name. As an example, an activity used to apply for leave in a process named Leave Requisition could be named LR10_ApplyForLeave.

Notifications

The Notifications section instructs an associated Notification & Escalation Services on how to process the notifications associated with (some of) the state changes of activity instances.

Move on Escalation

A Boolean value instructing an associated Notification & Escalation Services on whether to only notify the Escalate To of a pending instance’s participant or to also move the instance to the Escalate To, when the number of notifications processed by the service has run out (in which case it will be reset). The default value is True.

Notification Interval

The frequency (in hours) between notifications to be send by an associated Notification & Escalation Services.

How do I get the Notification Interval value of an activity

Via VBScript:

interval = fcBusinessEvent.WarnTrigger

How do I set the Notification Interval value of an activity

See fcTrigger for overriding the Notification Interval for the next activity.

Notification Number

The number of notifications that an associated Notification & Escalation Services is to send per instance of the associated activity, before escalating such instance (after which this number is reset).

How do I get the Notification Number value of an activity

Via VBScript:

number = fcBusinessEvent.WarnAmount

How do I set the Notification Number value of an activity

See fcTrigger for overriding the Notification Number for the next activity.

Notification Type

The type of notification to be send by an associated Notification & Escalation Service; either Email or SMS (translating to emails to supporting service providers) notifications are supported.

Notify New

A Boolean value instructing an associated Notification & Escalation Service to send a notification on the creation of a new pending activity instance. The default value is False.

Notify Outstanding

A Boolean value instructing an associated Notification & Escalation Service to send a notification once a pending activity instance is due (past its due date). The default value is False.

Scripting (Properties)

Dynamic Description

The VBScript Script to be executed at runtime to populate the activity instance’s description. Either one of the VBScript string variables, fcDescription or fcLabel, can be used for output, but only fcDescription supports multi-lingual descriptions on the instance (the runtime will re-execute the dynamic description for each language defined in this case).

As described in the life-cycle section, the dynamic description of First Activity (and Report) based instances are executed as these instances are completed (and persisted), following the selection of a specific Command Option. The dynamic description of pending activity instances is executed on instance creation (before any client gets to render them to users).

Caveats

The VBScript construct, fcBusinessEvent, is not available on the dynamic description of activities as the state of the activity is undefined (or already persisted, depending on the Creation Type) when the dynamic description is executed.

Load Script

The VBScript Script to be executed at runtime on loading the activity instance. As this executes only once, the need for hidden Reference Labels used to populate activity instances are no longer needed.

Refresh Script

The VBScript Script to be executed at runtime on every refresh/post-back and on completion of the activity instance.

Tracking

At any point in time an entire process instance (whether pending or completed) can be tracked (as in viewed) by the participant that started the process, and any other participant for which tracking rights have been explicitly granted. The tracking section applies further limitations on process instances from the perspective of the process starting participant, and on the current participant of pending activity instances.

Allow Tracking

A Boolean value indicating whether instances of the activity can be tracked, that is, may be viewed by the participant that started the process instance. The default value is True.

Allow Value Tracking

A Boolean value indicating whether the values of the activity instances can be tracked, that is, may be viewed by the participant that started the process instance. The default value is True.

Display History

A Boolean value indicating whether the participant of pending instances of the current activity can view previous instances in the process branch (where a branch follows a path from the current pending activity instance directly to the first instance that started the process instance). The default value is True.

Managed Code (.NET)

The class hierarchy in .NET, as it pertains to Tasks, is shown here: