Tib Ip Workspace Browser Config
Tib Ip Workspace Browser Config
Contents
Preface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . v
Configurations and Customizations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . vi
Related Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ix
TIBCO iProcess Workspace (Browser) Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ix
Other TIBCO Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . x
How to Contact TIBCO Support. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xi
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
Preface
This guide provides information about configuring and customizing your TIBCO
iProcess Workspace (Browser).
Topics
The following configuration and customization tasks are described in this guide:
• iProcess Workspace (Browser):
— User Access Profiles - These profiles specify the functions that are available
to each type of user of the iProcess Workspace (Browser).
— Server Nodes - Specifies which TIBCO iProcess Objects Servers the user
can log into.
— Action Processor URL - Specifies the URL to the Action Processor to which
you would like the iProcess Workspace (Browser) to connect.
— iProcess Workspace (Browser) Logs - This provides information about the
three types of logs available: Session Activity Log, Application Log, and the
Application Monitor.
— Remember Login Information - This specifies whether or not to display
the Remember User Id and Server next time I login check box on the
Login dialog.
— Customizing Browser Window Caption - This allows you to customize the
caption that is displayed in the browser window after a user has logged
into the iProcess Workspace (Browser).
— Releasing Resources On Logout - Specifies the level that resources are
released when a user logs out of the TIBCO iProcess Workspace (Browser).
— User Options - These settings allow you to specify default options (list
thresholds, form location and size, etc.) in the iProcess Workspace
(Browser).
— Font and Image Settings - These settings allow you to customize the
appearance of the application, such as changing the images that display for
icons/buttons, font types, sizes, colors, etc.
— Adding Custom Menu Items and Toolbar Buttons - This allows you to
add menu items and toolbar buttons to the existing menus and toolbars in
the TIBCO iProcess Workspace (Browser).
— Callout Interface - The callout interface provides methods that allow you
to set default filters, sorts, columns, etc.
• Action Processor:
— Log Settings - These allow you to configure the Action Processor log file
(type of information to write to the log, name of log file, etc.).
— XML Response Compression - This specifies whether or not to compress
the XML response. (Only applicable for the Java Action Processor.)
— Return Request Parameters - This specifies the default setting for
returning input parameters in the XML response.
— External Form URI - This specifies the URI that points to an external forms
package.
— Server Factories - This specifies information about the server factories used
when using RMI. (Only applicable for the Java Action Processor.)
— XML Validation - This specifies whether or not to validate the XML
request sent to the Action Processor.
— Action Processor Version - This specifies whether or not to display the
Action Processor version number in the Action Processor action response
• Using GI Forms - The GI Forms interface allows you to create forms using the
TIBCO General Interface™ Builder, then use those forms for work item steps
in the TIBCO iProcess Workspace (Browser). This allows you to take
advantage of the advanced form-building capabilities of the TIBCO General
Interface Builder.
• Application Server:
— Session Timeout - This specifies the number of minutes in which the
session will time out.
— Maximum POST Size - This specifies the maximum size of HTTP POST
requests.
— Character Encoding - Specifies encoding when using double-byte
characters.
• ASP Forms - A Microsoft Visual Studio .NET 2003 project that defines an
example ASP form is provided with the TIBCO iProcess Workspace (Browser).
• JSP Forms - An IntelliJ project that defines an example JSP form is provided
with the TIBCO iProcess Workspace (Browser).
• Direct Login - This chapter describes how to bypass the TIBCO iProcess
Workspace (Browser) Login screen by passing login credentials directly into
the application.
• Single Authentication - This chapter describes how to configure the TIBCO
iProcess Workspace (Browser) so that users can be authenticated using
credentials they have already entered in another web application.
Related Documentation
For comments or problems with this manual or the software it addresses, please
contact TIBCO Support as follows.
• For an overview of TIBCO Support, and information about getting started
with TIBCO Support, visit this site:
http://www.tibco.com/services/support
• If you already have a valid maintenance or support contract, visit this site:
http://support.tibco.com
Entry to this site requires a user name and password. If you do not have a user
name, you can request one.
The installation procedure for the TIBCO iProcess Workspace (Browser) steps you
through the configurations that are necessary to get the client application up and
running.
This chapter describes additional options that can be configured after the iProcess
Workspace (Browser) has been installed.
Topics
Introduction
There are two primary configuration files provided to configure the TIBCO
iProcess Workspace (Browser):
• userAccessProfiles.xml - This is used to specify which users have access to
the functions available in the TIBCO iProcess Workspace (Browser). For
information about configuring user access profiles, see User Access Profiles on
page 3.
• config.xml - This is used to configure many other aspects of the TIBCO
iProcess Workspace (Browser), such as which servers the user can connect to,
default settings in the application, etc. These are described throughout the rest
of this chapter.
The location of these configuration files depends on whether you are using the
example application provided with the iProcess Workspace (Browser), or a
custom application developed with the iProcess Workspace (Browser)
components.
• If you are using the client application, these configuration files are located as
follows:
ClientInstallDir\JSXAPPS\ipc\
where ClientInstallDir is the directory in which the iProcess Workspace
(Browser) is installed.
• If you are using a custom application developed with the iProcess Workspace
(Browser) components, these configuration files are located as follows:
WorkspaceDir\JSXAPPS\ProjectName
User access profiles provide the ability to specify which application functionality
is available to various types of users of the iProcess Workspace (Browser). They
do this by specifying which user interface components (i.e., icons, buttons, and
menu selections) are made available to the logged-in user.
User access profiles only define which user interface components are made
available to the logged-in user — the ability to actually execute the functionality is
determined by the level of security defined on the iProcess Objects Server. For
instance, the user's access profile may grant access to the tool/menu selection for
closing cases, however, if the user does not have system administrative privileges
on the iProcess Objects Server, any attempt to close a case will be rejected.
The user access profiles are defined using the UserAccessProfiles record in the
ClientInstallDir\JSXAPPS\ipc\userAccessProfiles.xml file.
Each profile represents a type of application user and defines the user interface
components available to users of that type. The following shows a collapsed view
of the default user access profiles included in the iProcess Workspace (Browser):
Each user's profile type is stored in the MENUNAME user attribute, the name of
which is specified by the serverUserAttr attribute (for information about the
MENUNAME user attribute, see the TIBCO iProcess Server Objects Programmer’s
Guide or on-line help system). By default, the MENUNAME attribute is used
because it is an inherent attribute of all iProcess users and requires no
customization when the iProcess Workspace (Browser) is installed.
The “Default” profile type is assigned to application users that do not have their
iProcess attribute set to one of the defined profile types. In this example, if a user
logs in to the iProcess Workspace (Browser), and the value of their MENUNAME
iProcess attribute is empty, or set to a value other than “Admin”, “User”,
“ProDef”, or “Manager”, the access defined for the “Default” profile type is
assigned. If the MENUNAME value is invalid, and the “Default” profile type has
not been defined in userAccessProfiles.xml, access is automatically limited to
viewing only the list of procedures.
There is also a special “PreLogin” user type specified in the
userAccessProfiles.xml file that represents all users before they login, i.e.,
before the application knows their user name/type. The access profile for the
“PreLogin” user type only contains the elements needed to specify how much
error information will be shown to the user prior to logging in.
If you need additional user profile types, you must create a new user attribute and
assign profile types to that user attribute (rather than assigning new types to the
MENUNAME attribute). For information on how to create custom profiles by
defining a new user attribute, see Creating Custom User Access Profiles on
page 13.
Each user access profile (i.e., each <Profile/> element) specified in the
userAccessProfiles.xml file contains the following attributes:
• The type attribute of each profile represents the user type and corresponds to
the value that is stored in the iProcess attribute of the user. For example:
<Profile type="Admin" description="Access Level: Admin">
Initially, profiles are defined for each of the possible MENUNAME values:
“Admin”, “User”, “ProDef” and “Manager” (as well as a “Default” and
“PreLogin” type, which are described above).
• The description attribute defines a text string that is displayed in the header
area of the iProcess Workspace (Browser) interface, and provides an indication
of the access level of the logged-in user. For example:
<Profile type="Admin" description="Access Level: Admin">
This example would cause the following to be displayed when a user with a
MENUNAME of “Admin” is logged in:
For a complete list of the allowable name attributes (functions), see the table
in the Access Profile ‘name’ Attributes section on page 6.
• The state attribute specifies whether or not the associated user type has access
to the functionality identified by the name attribute (see the bullet item
above), where “1” means allow access and “0” means deny access.
<property name="Procedure" state="1">
Hierarchy
The hierarchy of the <property/> elements is significant, i.e., if a child
<property/> element gives the user type access to a button/menu selection, the
child’s parent <property/> element must also be enabled (by setting its state
attribute to “1”). For example, see the following excerpt from the
userAccessProfiles.xml file. If the user type is given access to open work items
(name=”Open”), it must also be given access to view the work items
(name=”WorkItem”).
Likewise, if you give the user type access to “ForwardAnyQueue”, you must also
give access to “Forward”, since “ForwardAnyQueue” is a child of “Forward”.
AddHistoryEntry Procedure Case Add History Provides access to the Add Entry
Case Entry tool for adding entries to the
Open history of a case (audit trail).
History
ForwardAnyQueue WorkQueue Work Item Forward This is applicable only if the user
WorkItem Any Queue has access to the Forward Work
Forward Item(s) tool.
This causes the list of work
queues on the Forward Selected
Work Items dialog to contain all
work queues on the system.
If disabled, the list of work
queues on the Forward Selected
Work Items dialog will contain
only the work queues of which
the user is a member.
Sort WorkQueue Work Item List Sort Provides access to the Sort
WorkItem icon/dialog for the work item
list.
a. If a user that has neither procedure view access (name=”Procedure”) nor work queue view access
(name=”WorkQueue”) logs into the iProcess Workspace (Browser), a screen is displayed containing the
message: “Access to Procedure and Work Queue data is denied - please contact your system administra-
tor”. The only components available on this screen are the Logout and Help tools.
b. If you are using an older iProcess Objects Server that does not provide recalculate deadline function-
ality, you may want to set state=”0” for RecalculateDeadlines so that the Recalculate Deadline radio
buttons are not displayed on the Events dialog.
c. The case close (name=”Close”), case purge (name=”Purge”), and work queue supervisors (name=”Su-
pervisors”) functions all require system administrative authority. Without system administrative author-
ity, a user cannot perform these functions even if their access profile provides access to the tools/buttons
for these functions. If a user’s access profile causes the buttons/selections to appear, but they don’t have
administrative authority, the buttons/selections are grayed out.
6. For each iProcess user, set the value of their iProcess attribute to one of the
profile types defined in userAccessProfiles.xml. This must be done by a
user with administrative access using the TIBCO iProcess User Manager (for
information about the User Manager, see the TIBCO iProcess Workspace
(Windows) Manager’s Guide).
Server Nodes
When the iProcess Workspace (Browser) Login screen is displayed, the Server
field drop-down list will contain a list of TIBCO iProcess Objects Servers that the
user can log into:
This list of servers is controlled using the ServerNodes record in the iProcess
Workspace (Browser)’s configuration file.
During the iProcess Workspace (Browser) installation process, you enter the
information for one iProcess Objects Server. This section describes how to add
additional entries to the ServerNodes record if you would like more than one
server to appear in the Server field drop-down list.
To configure the server nodes for your installation:
1. Open the ClientInstallDir\JSXAPPS\ipc\config.xml file with an editor.
The first record should reflect the entries that were entered during the
installation. The elements in this record can be modified if the information is
no longer correct (for instance, the TCP port has changed for that server).
Placeholders have been provided for two additional iProcess Objects Servers.
3. To configure additional servers, remove or move the appropriate comment
delimiters from the “Server Two” or “Server Three” record, then enter the
appropriate information in the record’s displayNodeName attribute, and the
When the TIBCO iProcess Workspace (Browser) is installed, you must specify the
URL to the Action Processor to which you want the iProcess Workspace (Browser)
to connect when it is started. This URL is written to the iProcess Workspace
(Browser)’s configuration file by the installation program.
You can later modify the Action Processor URL in the configuration file so that the
client connects to a different Action Processor. You can also specify multiple
URLs, and assign each a weighting value, which is used to determine the
percentage of connections given to that URL (Action Processor). This allows load
balancing of the available Action Processors. When the TIBCO iProcess
Workspace (Browser) starts, it randomly selects (with weighting applied) one of
the Action Processor URLs specified in the configuration file.
To configure the Action Processor URL:
1. Open the ClientInstallDir\JSXAPPS\ipc\config.xml file with an editor.
where:
— Host is the name of the machine hosting the Action Processor. (Note that if
you are hosting both the iProcess Workspace (Browser) and the Action
Processor on the same machine, and they are both being hosted by Tomcat,
you can specify Host as “localhost”.)
— Port is the port number used by the Web Application Server (WAS) that is
hosting the Action Processor to communicate with web applications.
— APDir is the directory on Host in which the Action Processor is installed.
— ext is the file name extension. This is “servlet” (for Java servlet) if you are
connecting to a Java Action Processor, or “aspx” (for .NET ASP web
application) if you are connecting to a .NET Action Processor.
The example shown in step 2 specifies that the iProcess Workspace (Browser)
connect to a Java Action Processor (hence the “servlet” extension) on machine
“austin”. The WAS hosting the Action Processor is communicating with web
applications on port 90, and the Action Processor was installed in the
TIBCOActProc directory.
5. Specify a weighting value for each Action Processor by setting the weighting
attribute as follows:
— If you are only specifying a single URL, the weighting attribute can be set
to any value, or it can be left unspecified.
— For multiple URLs, the weighting value determines the percentage of
connections based on the total of all weighting values. For instance, if a
URL’s weighting value is 30% of the total of all weighting values (see the
example below), the client will connect to it 30% of the time:
Note that the weighting parameter is only for load balancing purposes — it is
not to provide failover. If the Action Processor fails, the application should
return to the Login screen.
The weighting values can total any number, although it’s easier to calculate
the percentage for each if they total 100 as in the example above.
If an Action Processor is not available when the client attempts to connect to
it, the weighting values are recalculated based on the remaining available
Action Processors, and another URL is randomly selected. This process
continues until a connection is made, or no active Action Processor can be
found (in which case, an error is returned — the TIBCO iProcess Workspace
(Browser) must be reloaded to continue).
There are three types of TIBCO iProcess Workspace (Browser) logs available:
• Session Activity Log - This log allows users of the iProcess Workspace
(Browser) to view information about activities they have performed in the
application since they logged in. For information about this log, see the TIBCO
iProcess Workspace (Browser) User’s Guide.
• Application Log - This log provides detailed debug information, as well as
communications between the client and the Action Processor. For more
information, see iProcess Workspace Application Log on page 21.
• Application Monitor - This log provides debug information on error
conditions and exceptions encountered. For more information, see iProcess
Workspace Application Monitor on page 22.
Note that this log is available only if the logged-in user has “ApplicationLog”
enabled in their user access profile. For more information, see page 12.
The Application Log can be closed by clicking in the X in the upper right corner of
the Application Log window.
The Application Monitor can be configured using the following configuration file:
ClientInstallDir\logger.xml
where ClientInstallDir is the path to the directory in which the iProcess Workspace
(Browser) is installed.
Default settings are specified by the handler element in the logger.xml file, as
shown below:
By default, both the Application Monitor and its hotkeys are enabled.
• To disable the Application Monitor, comment out the entire <handler/>
element, as well as the <handler-ref/> element under the global logger
element. (Note that if you comment out the Application Monitor, you must
comment out both the <handler/> element, as well as the <handler-ref/>
element. If the <handler/> element is commented out, but the <handler-ref/>
element is not commented out, it results in a fatal error — the application will
not load.)
• To disable the Application Monitor hotkeys, change the activateOnHotKey
property’s value attribute to “false”.
When the Application Monitor’s hotkeys are enabled, you can turn the monitor
on and off using the <Ctrl>+<Alt>+<m> key sequence.
You can configure whether or not to display the Remember User Id and Server
next time I login check box on the Login dialog:
You can customize the caption that is displayed in the browser window after a
user has logged into the TIBCO iProcess Workspace (Browser).
<record jsxid="postLoginCaption"
pattern="TIBCO iProcess Workspace (Browser) - %username% - %displayNodeName%"
/>
3. Modify the pattern attribute for the caption you would like displayed. The
following placeholders can be used in the pattern string to display various
information:
— %username% - This placeholder is replaced with the name of the logged-in
user.
— %usernameDesc% - This placeholder is replaced with the user's
"DESCRIPTION" attribute defined on the server.
— %serverNodeName% - This placeholder is replaced with the node name of
the server the user has logged into. Note that when single authentication is
used (see Single Authentication on page 161), this value is available only if
the logged-in user’s access profile (see User Access Profiles on page 3)
allows access to server information (name=”ServerInfo”).
— %displayNodeName% - This placeholder is replaced with the value of the
displayNodeName attribute of the server the user has logged into (see the
displayNodeName attribute for the ServerNodes element on page 17). If
displayNodeName is null, the server node name is displayed.
Any or all of the placeholders can be specified or omitted.
If a placeholder is specified that is not available, it will be replaced with a
zero-length string.
You can specify the level that resources are released when a user logs out of the
TIBCO iProcess Workspace (Browser).
To configure this option:
1. Open the ClientInstallDir\JSXAPPS\ipc\config.xml file with an editor.
User Options
The iProcess Workspace (Browser) contains an Options dialog from which each
user can specify their personal user options. User options establish default settings
for each user who logs into the iProcess Workspace (Browser). These include
things such as the list (procedure or work queue) to display first, the size and
location of forms, the language to display, etc. For information about setting user
options from the Options dialog, see the iProcess Workspace (Browser) User’s Guide.
There are default user options defined in the system that each new user inherits
until they specify their own user options on the Options dialog. These default
user options are defined in the iProcess Workspace (Browser)’s configuration file,
config.xml.
Note that the Options dialog in the iProcess Workspace (Browser) also contains a
Defaults button that sets all of the options for the user to the default user options
specified in the config.xml file.
To configure the default user options:
1. Open the ClientInstallDir\JSXAPPS\ipc\config.xml file with an editor.
2. Locate the Options record:
3. Using the information in the following table, change the values of the
appropriate element attributes to the desired default values:
swPrecedenceMUR — swPrecedenceUR:
Unreleased, then released.
— swPrecedenceMR: Model,
then released.
— swPrecedenceUMR:
Unreleased, model, then
released.
— swPrecedenceMUR:
Model, unreleased, then
released.
A cascading style sheet-like file is provided that allows you to customize the
appearance of the iProcess Workspace (Browser). This file can be modified to
change elements such as:
• icon/button images
• font type, size, color
• background colors
The appearance of these elements is defined in the following file:
ClientInstallDir\JSXAPPS\ipc\jss\ipcCSS.jss
An excerpt from this file is shown below:
This file is well-commented, making it easy to find the area you would like to
customize.
To make a change to a font, image, color, etc., modify the value in the jsxtext
attribute.
Custom menus and/or toolbar buttons can be added to the TIBCO iProcess
Workspace (Browser) using configuration settings in the TIBCO iProcess
Workspace (Browser)’s configuration file, config.xml.
The record element that specifies a custom menu or toolbar button has a jsxid
attribute value of customMenus:
<record jsxid="customMenus">
<!-- custom menu or toolbar elements added here -->
</record>
The following example shows a toolbar and a menu element taken from the
samples given in config.xml:
<record jsxid="customMenus">
<toolbar parent="MainAppToolbar" width="110"
prototype="JSXAPPS/ipc/custom/prototypes/toolbars/ToolbarSample.xml" />
Both the toolbar and menu elements may also have optional locale child elements
that define prototype XML files that are localized for specific languages. If a
locale child element exists, and it corresponds to the language and locale
currently selected by the user, the language-specific prototype is loaded,
otherwise the default prototype is loaded. For more information on customizing
the iProcess Workspace (Browser) for language localization, see Localization on
page 175.
Each locale child element has three attributes:
• localeKey - Locale identifier. This value must correspond to one of the
localeKey attributes defined in the Locales element of the
JSXAPPS/ipc/locale/locales.xml configuration file (see <record
jsxid=”Locales” type=”ipc”>). The localeKey attribute values are of the
format: ll or ll_CC, where ll is a lowercase, two- letter ISO 639 language code,
and CC is the optional, uppercase, two-letter ISO 3166 country code. For a list
of codes, visit these web sites:
— International Organization for Standardization (ISO):
http://www.iso.ch/iso/en/ISOOnline.frontpage
— Language codes:
http://www.loc.gov/standards/iso639-2/langhome.html
— Country codes:
http://www.iso.ch/iso/en/prods-services/iso3166ma/
02iso-3166-code-lists/index.html
• width - The display width in pixels.
• prototype - The path to the prototype XML file containing language-specific
data. This is the General Interface prototype that defines the GUI components
for the menu or toolbar.
The custom localized menu files should be added in a directory under the
application root:
ClientInstallDir\JSXAPPS\ipc
The following example shows a toolbar and a menu element, with localized
language-specific prototypes, taken from the samples in config.xml:
<record jsxid="customMenus">
<toolbar parent="MainAppToolbar" width="110"
prototype="JSXAPPS/ipc/custom/prototypes/toolbars/ToolbarSample.xml" />
<locale localeKey="de_DE" width="200"
prototype="JSXAPPS/ipc/custom/prototypes/toolbars/ToolbarSample_de_DE.xml"/>
</toolbar>
There is an example entry in config.xml for each of the valid parent attribute
values. These examples make reference to the sample files that can be found
under the installation home directory:
InstallationHomeDir\iprocessclientbrowser\samples\CustomMenus
where InstallationHomeDir is the directory in which the installer places
administrative files, such as the uninstaller, documentation, and sample code.
This defaults to C:\tibco on Windows systems, and /opt/tibco on UNIX
systems, but can be specified as a different directory when the TIBCO iProcess
Workspace (Browser) is installed.
The files in the ...\CustomMenus directory show examples of how to use both
menu and toolbar prototype XML files and handle the events using a
CustomEventHandler class.
The sample custom menus and toolbars can be installed using the steps listed
below. These same steps can be used to install actual custom menus and toolbars,
substituting the actual custom prototype, JavaScript, and image files and
config.xml entries. See the TIBCO General Interface Builder documentation for
details on creating custom menu or toolbar prototype files.
1. Create a custom directory under the application root:
ClientInstallDir\JSXAPPS\ipc\custom
Any valid directory name can be used. The “custom” directory name is used
in the sample entries shown in config.xml.
2. Copy all of the files from the following directory:
InstallationHomeDir\iprocessclientbrowser\samples\CustomMenus
... to your custom directory:
ClientInstallDir\JSXAPPS\ipc\custom
Note that the custom directory structure, and the examples in config.xml,
include samples for localizing the iProcess Workspace (Browser) in German
(locale de_DE). These files provide an example of the structure necessary to
provide language-specific support, however, to utilize these localized files, the
iProcess Workspace (Browser) must be configured for German language
support (see Localization on page 175).
3. In config.xml, add menu or toolbar elements under the <record
jsxid=”customMenus”> element. (Uncomment the samples shown in the
description for <record jsxid=”customMenus”>.)
4. Add a new mapping record in the config.xml file as a child element under
<record jsxid=”includes” type=”array”> for CustomEventHandler.js as
shown below:
The application should now load with the sample custom menus and toolbars
displayed.
Callout Interface
calloutWorkItemFilter Specifies the filter to apply to the work item list. This may be
used to either modify the user-defined filter, to append
additional criteria, or to override it. This is applied
automatically when the user applies a filter by either clicking
the Apply button on the work item list Filter dialog, or by
applying a server-side find. Any user-defined filter will
appear on the Filter dialog, but any modification applied to
the filter with this method will not be visible to the user.
calloutInitialCaseFilter Specifies the filter to be used when the case list is opened. The
filter that was saved when the list was last closed can be
reused with or without modifications, or it can be replaced
with a default filter. This filter appears on the Filter dialog
after it is applied, and can be changed by the user if they have
access to the Filter dialog.
calloutCaseFilter Specifies the filter to apply to the case list. This may be used
to either modify the user-defined filter, to append additional
criteria, or to override it. This is applied automatically when
the user applies a filter by clicking the Apply button on the
case list Filter dialog. Any user-defined filter will appear on
the Filter dialog, but any modification applied to the filter
with this method will not be visible to the user.
calloutWorkItemSort Specifies the sort to apply to the work item list. This may be
used to either modify the user-defined sort, to append
additional criteria, or to override it. This is applied
automatically when the user applies a sort by clicking the
Apply button on the work item list Sort dialog. Any
user-defined sort will appear on the Sort dialog, but any
modification applied to the sort with this method will not be
visible to the user.
calloutInitialCaseSort Specifies the sort to be used when the case list is opened. The
sort that was saved when the list was last closed can be
reused with or without modifications, or it can be replaced
with a default sort. This sort appears on the Sort dialog after
it is applied, and can be changed by the user if they have
access to the Sort dialog.
calloutCaseSort Specifies the sort to apply to the case list. This may be used to
either modify the user-defined sort, to append additional
criteria, or to override it. This is applied automatically when
the user applies a sort by clicking the Apply button on the
case list Sort dialog. Any user-defined sort will appear on the
Sort dialog, but any modification applied to the sort with
this method will not be visible to the user.
Column Methods (Procedure, Case, Work Queue, Work Item, Outstanding, Outstanding-Jump
Lists)
Method Description
calloutColumns Specifies the default columns to display on the procedure
list, case list, work queue list, work item list, outstanding
work items list on the case Outstanding tab, and the
outstanding work items lists on the Process Jump dialog.
A custom class can implement one or more of the methods in the tables above.
One or more custom classes may be used to handle these method calls.
If there is no implementation of these methods, there are no restrictions other than
what might be applied through user access profiles.
Additional details about each callout method can be found in Callout Method
Signatures on page 46.
Configuration
The TIBCO iProcess Workspace (Browser) comes with a sample callout handler
that contains sample implementations of all of the callout methods. This sample
callout handler is named ‘SampleCalloutHandler.js’ and is located in the
InstallationHomeDir\iprocessclientbrowser\samples\Callouts directory,
where InstallationHomeDir is the directory in which the installer places
administrative files, such as the uninstaller, documentation, and sample code.
This defaults to C:\tibco on Windows systems, and /opt/tibco on UNIX
systems, but can be specified as a different directory when the TIBCO iProcess
Workspace (Browser) is installed.
Perform the following steps to create a custom handler and configure your TIBCO
iProcess Workspace (Browser) to use the callout methods.
1. Copy the SampleCalloutHandler.js file into a directory you’ve created
under the ClientInstallDir\JSXAPPS\ipc\ directory, where ClientInstallDir is the
path to the directory in which the TIBCO iProcess Workspace (Browser) is
installed. For example, ClientInstallDir\JSXAPPS\ipc\Callouts.
app.getCalloutController().registerHandler(target,arrayOfMethodNames)
where:
— target - (Object) The instance or object the method is called on.
— arrayOfMethodNames - (Array<strings>) Array of strings that are the names of
the methods to register.
The following is an example of the init method in which the
calloutColumns method is registered:
ipcClass.prototype.init = function(app) {
this.app = app;
this.controller = this.app.getCalloutController();
this.controller.registerHandler(this,['calloutColumns']);
};
Note that the application getServer() method can be used to get a reference
to the jsx3.app.Server instance:
app.getServer()
3. Specify the callout handler custom class in the iProcess Workspace (Browser)’s
configuration file, ClientInstallDir\JSXAPPS\ipc\config.xml.
The <record jsxid=”customCallout” element specifies which classes will be
loaded to handle custom callout methods. The <Classes> element can contain
any number of <Class> elements whose class attribute is set to the fully
qualified name of the custom class to load. The class is loaded after the user is
authenticated at login. This gives the custom class access to the logged-in
user's session to query the Action Processor for initialization data, if required.
The following is an example of the customCallout element identifying the
ColumnsCalloutHandler custom class:
4. Add a mapping record to the config.xml file that points to the custom
handler. This is added as a child element of the <record jsxid=”includes”
element. The following is an example class mapping element for the custom
callout handler, ColumnsCalloutHandler.js.
5. Optionally, modify the user access profiles that would be used in conjunction
with the custom handling. For example, if your custom handler is setting the
default columns on the work item list, you may want to deny access to the
Column Selector on the work item list (see SelectColumns on page 11).
calloutInitialWorkItemFilter
/**
* @param filterExpression (string) The filter string value.
* @param username (string) The logged in user name.
* @param queueNode (jsx3.xml.Entity) The queue node XML for the
* workitem list.
* @param availableFields (jsx3.xml.Entity) XML defining the available
* fields that can be filtered.
*
* @return (string) Modified filter string.
*/
ipcClass.prototype.calloutInitialWorkItemFilter = function(
filterExpression,
username, queueNode,
availableFields) {
calloutWorkItemFilter
/**
* @param filterExpression (string) The filter string value.
* @param username (string) The logged in user name.
* @param queueNode (jsx3.xml.Entity) The queue node XML for the
* workitem list.
* @param availableFields (jsx3.xml.Entity) XML defining the available
* fields that can be filtered.
*
* @return (string) Modified filter string.
*/
ipcClass.prototype.calloutWorkItemFilter = function(filterExpression,
username, queueNode,
availableFields) {
The sample above would show only work items whose procedure name starts
with “a”. (For information about filter expression syntax, see the TIBCO iProcess
Server Objects (Java or .NET) Programmer’s Guide.)
calloutWorkItemFilterColumns
/**
* @param availableFields (jsx3.xml.Entity) XML defining the available
* fields that can be filtered.
* @param username (string) The logged in user name.
* @param queueNode (jsx3.xml.Entity) The queue node XML for the
* workitem list.
* @return (jsx3.xml.Entity) Modified XML defining the
* available fields that can be
* filtered.
*/
ipcClass.prototype.calloutWorkItemFilterColumns = function(
availableFields,
username,
queueNode) {
availableFields (jsx3.xml.Entity)
<data jsxid="jsxroot">
<record jsxid="OCCUPATION" jsxtext="Occupation" fieldType="swText"
fieldLength="20" />
<record jsxid="SW_ARRIVAL" jsxtext="Date and Time Arrived" fieldType="swTimeStamp"
fieldLength="16" />
<record jsxid="SW_ARRIVALDATE" jsxtext="Date Arrived" fieldType="swDate"
fieldLength="10" />
<record jsxid="SW_ARRIVALTIME" jsxtext="Time Arrived" fieldType="swTime"
fieldLength="5" />
...
</data>
queueNode (jsx3.xml.Entity)
<record jsxid="IDA3CHEB"
Name="swadmin"
Description="System Administrator"
HostingNode="i2tagtest"
Tag="i2tagtest|swadmin|R"
IsGroup="false"
IsReleased="true"
FirstDeadline="2006-07-28 10:44:00"
DeadlineCnt="17"
UnopenedCnt="138"
UrgentCnt="2"
WorkItemCnt="267"
WorkQParam1Name="WQ Parameter1"
WorkQParam2Name="WQ Parameter2"
WorkQParam3Name="WQ Parameter3"
WorkQParam4Name="WQ Parameter4" >
</record>
calloutInitialCaseFilter
/**
* @param filterExpression (string) The filter string value.
* @param username (string) The logged in user name.
* @param procNode (jsx3.xml.Entity) The procedure node XML for
* the case list.
* @param availableFields (jsx3.xml.Entity) XML defining the available
* fields that can be sorted.
*
* @return (string) Modified filter string.
*/
ipcClass.prototype.calloutInitialCaseFilter = function(
filterExpression,
username, procNode,
availableFields) {
calloutCaseFilter
/**
* @param filterExpression (string) The filter string value.
* @param username (string) The logged in user name.
* @param procNode (jsx3.xml.Entity) The procedure node XML for
* the case list.
* @param availableFields (jsx3.xml.Entity) XML defining the available
* fields that can be filtered.
*
* @return (string) Modified filter string.
*/
ipcClass.prototype.calloutCaseFilter = function(filterExpression,
username, procNode,
availableFields) {
calloutCaseFilterColumns
/**
* @param availableFields (jsx3.xml.Entity) XML defining the available
* fields that can be filtered.
* @param username (string) The logged in user name.
* @param procNode (jsx3.xml.Entity) The proc node XML for the
* case list.
* @return (jsx3.xml.Entity) Modified XML defining the
* available fields that can be
* filtered.
*/
ipcClass.prototype.calloutCaseFilterColumns = function(availableFields,
username,
procNode) {
calloutInitialWorkItemSort
/**
* @param sortFields (Array) An array of
* com.tibco.bpm.ipc.vSortField
* instances.
* @param username (string) The logged in user name.
* @param queueNode (jsx3.xml.Entity) The queue node XML for the
* workitem list.
* @param availableFields (jsx3.xml.Entity) XML defining the available
* fields that can be sorted.
*
* @return (Array) Modified array of
* com.tibco.bpm.ipc.vSortField
* instances.
*/
ipcClass.prototype.calloutInitialWorkItemSort = function(sortFields,
username, queueNode,
availableFields) {
calloutWorkItemSort
/**
* @param sortFields (Array) An array of
* com.tibco.bpm.ipc.vSortField
* instances.
* @param username (string) The logged in user name.
* @param queueNode (jsx3.xml.Entity) The queue node XML for the
* workitem list.
* @param availableFields (jsx3.xml.Entity) XML defining the available
* fields that can be sorted.
*
* @return (Array) Modified array of
* com.tibco.bpm.ipc.vSortField
* instances.
*/
ipcClass.prototype.calloutWorkItemSort = function(sortFields,
username, queueNode,
availableFields) {
Work items will be sorted in the order in which elements are passed in the
vSortField array.
New vSortField values are created by passing the three properties in the
constructor:
var newSortFields = new Array();
newSortFields.push(new com.tibco.bpm.ipc.vSortField('SW_CASEDESC',
true,
'swTextSort'));
newSortFields.push(new com.tibco.bpm.ipc.vSortField('SW_CASENUM',
true,
'swTextSort'));
calloutWorkItemSortColumns
/**
* @param availableFields (jsx3.xml.Entity) XML defining the available
* fields that can be sorted.
* @param username (string) The logged in user name.
* @param queueNode (jsx3.xml.Entity) The queue node XML for the
* workitem list.
* @return (jsx3.xml.Entity) Modified XML defining the
* available fields that can be
* filtered.
*/
ipcClass.prototype.calloutWorkItemSortColumns = function(
availableFields,
username,
queueNode) {
<data jsxid="jsxroot">
<record jsxid="SW_ARRIVAL" jsxtext="Date and Time Arrived"
sorttype="swDateTimeSort" />
<record jsxid="SW_CASEDESC" jsxtext="Case Description"
sorttype="swTextSort" />
<record jsxid="SW_CASENUM" jsxtext="Case Number"
sorttype="swNumericSort" />
...
</data>
calloutInitialCaseSort
/**
* @param sortFields (Array) An array of
* com.tibco.bpm.ipc.vSortField
* instances.
* @param username (string) The logged in user name.
* @param procNode (jsx3.xml.Entity) The procedure node XML for
* the case list.
* @param availableFields (jsx3.xml.Entity) XML defining the available
* fields that can be sorted.
*
* @return (Array) Modified array of
* com.tibco.bpm.ipc.vSortField
* instances.
*/
ipcClass.prototype.calloutInitialCaseSort = function(sortFields,
username, procNode,
availableFields) {
calloutCaseSort
/**
* @param sortFields (Array) An array of
* com.tibco.bpm.ipc.vSortField
* instances.
* @param username (string) The logged in user name.
* @param procNode (jsx3.xml.Entity) The procedure node XML for
* the case list.
* @param availableFields (jsx3.xml.Entity) XML defining the available
* fields that can be sorted.
*
* @return (Array) Modified array of
* com.tibco.bpm.ipc.vSortField
*
*/
ipcClass.prototype.calloutCaseSort = function(sortFields,
username, procNode,
availableFields) {
calloutCaseSortColumns
/**
* @param availableFields (jsx3.xml.Entity) XML defining the available
* fields that can be sorted.
* @param username (string) The logged in user name.
* @param procNode (jsx3.xml.Entity) The proc node XML for the
* case list.
* @return (jsx3.xml.Entity) Modified XML defining the
* available fields that can be
* filtered.
*/
ipcClass.prototype.calloutCaseSortColumns = function(availableFields,
username,
procNode) {
calloutColumns
/**
* @param columns (jsx3.xml.Entity) The serialized columns for
* the list.
* @param username (string) The logged in user name.
* @param eventNode (jsx3.xml.Entity) The procedure (Cases list),
* workQ (WorkItems list), or
* caseTag data (Outstanding)
* node XML. Null for Proc and
* WorkQ list types:
* @param availableFields (jsx3.xml.Entity) XML defining the available
* fields for column selection.
* @param listType (string) The list type, one of:
* com.tibco.bpm.ipc.ListContainer.PROC
* com.tibco.bpm.ipc.ListContainer.CASE
* com.tibco.bpm.ipc.ListContainer.WORKQ
* com.tibco.bpm.ipc.ListContainer.WORKITEM
* com.tibco.bpm.ipc.ListContainer.OUTSTANDING
* com.tibco.bpm.ipc.ListContainer.OUTSTANDING +
'Jump'
*
* @return (jsx3.xml.Entity) Modified serialized columns
* for the list.
*
*/
ipcClass.prototype.calloutColumns = function(columns,
username, eventNode,
availableFields,
listType) {
<record
Name="ALLOCATE"
Description="Allcate Resources"
HostingNode="i2tagtest"
Version="0.2"
Tag="i2tagtest|ALLOCATE|0|2"
ProcNumber="36"
StartStepName="STEP1"
Status="swReleased"
CaseDescOpt="swRequiredDesc"
IsAutoPurge="false"
IsIgnoreBlank="false"
IsNetworked="false"
IsSubProc="false"
IsOrphaned="false"
IsWorkDays="true"
IsPrediction="false"
Owner="swadmin"
Duration="swDurationNone"
Permission="Start / History"
CaseCount="40"
ActiveCount="39"
ClosedCount="1">
</record>
— WorkItem list:
<record
Name="rbTestGroup"
Description="rbTestGroup"
HostingNode="i2tagtest"
Tag="i2tagtest|rbTestGroup|R"
IsGroup="true"
IsReleased="true"
DeadlineCnt="0"
UnopenedCnt="1"
UrgentCnt="0"
WorkItemCnt="1"
WorkQParam1Name="WQ Parameter1"
WorkQParam2Name="WQ Parameter2"
WorkQParam3Name="WQ Parameter3"
WorkQParam4Name="WQ Parameter4" >
</record>
<record
CaseTag="i2tagtest|ALLOCATE|0|2|2453"
NodeName="i2tagtest"
ProcName="ALLOCATE"
MajorVerion="0"
MinorVerion="2"
CaseNumber="2453"/>
</record>
calloutSelectColumns
/**
* @param availableFields (jsx3.xml.Entity) XML defining the fields
* available for column
* selection.
* @param username (string) The logged in user name.
* @param eventNode (jsx3.xml.Entity) The procedure (Cases list),
* workQ (WorkItems list), or
* caseTag data (Outstanding)
* node XML. Null for Proc and
* WorkQ list types:
* @param columns (jsx3.xml.Entity) The serialized columns for
* the list.
* @param listType (string) The list type, one of:
* com.tibco.bpm.ipc.ListContainer.PROC
The following are example availableFields and columns parameter values used
with calloutSelectColumns:
availableFields (jsx3.xml.Entity)
<data jsxid="jsxroot">
<record jsxid="IsStatusImage" />
<record jsxid="CaseNumber" fieldname="SW_CASENUM" fieldtype="swNumeric"/>
<record jsxid="CaseReference" fieldname="SW_CASEREF" fieldtype="swText"/>
...
</data>
columns (jsx3.xml.Entity)
The columns value contains the serialized columns for the list. The following
sample shows how this can be obtained from a jsx3.gui.List:
var objProperties = new Object();
objProperties['children'] = true;
<serialization xmlns="urn:tibco.com/v3.0">
<unicode></unicode>
<name><![CDATA[]]></name>
<icon><![CDATA[]]></icon>
<description><![CDATA[]]></description>
<onBeforeDeserialize><![CDATA[]]></onBeforeDeserialize>
<onAfterDeserialize><![CDATA[]]></onAfterDeserialize>
<objects>
<object type="jsx3.gui.Column">
<dynamics jsxfontname="ipcList FN" jsxfontsize="ipcList FS" .../>
<variants jsxwidth="23" jsxresize="1"/>
<strings jsxname="colStatusImage" jsxpath="@IsStatusImage" ... />
<children>
</children>
</object>
<object type="jsx3.gui.Column">
<dynamics jsxfontname="ipcColHeader FN" jsxfontsize="ipcColHeader FS" .../>
<variants jsxwidth="45"/>
<strings jsxname="colWorkItemCaseNumber" jsxpath="@CaseNumber" .../>
<children>
</children>
</object>
<object type="jsx3.gui.Column">
<dynamics jsxtext="txtCaseDesc" jsxfontname="ipcColHeader FN" .../>
<variants jsxwidth="120"/>
<strings jsxname="colWorkItemDesc" jsxpath="@Description" ..."/>
<children>
</children>
</object>
...
</objects>
</serialization>
The installation procedure for the TIBCO iProcess Workspace (Browser) steps you
through the configurations that are necessary to get the Action Processor up and
running.
This chapter describes additional options that can be configured after the Action
Processor has been installed.
Topics
• Overview, page 60
• Log Settings, page 61
• XML Response Compression, page 62
• Return Request Parameters, page 63
• External Form URI, page 64
• Server Factories, page 65
• XML Validation, page 66
• Action Processor Version, page 67
Overview
All of the Action Processor configuration settings are specified in the Action
Processor’s configuration file, which is located as follows:
APDir\apConfig.xml
where APDir is the directory in which the Action Processor is installed (which
defaults to “TIBCOActProc”). The location of this directory on your system will
depend on which Web Application Server is hosting your Action Processor.
If changes are made to any of the Action Processor configuration settings, you
must restart the Action Processor so it picks up the changes to apConfig.xml. To
restart the Action Processor, stop and restart the Web Application Server.
The Action Processor configuration settings are described in the following
subsections.
Note that Secure Sockets Layer (SSL) can be used to secure communications
between the Action Processor and the client. However, the way in which it is
implemented is specific to the Web Application Server (WAS) you are using. See
the documentation for your WAS.
Also note that if you access the TIBCO iProcess Workspace (Browser) through
HTTPS, you must also access the Action Processor through HTTPS, and vice
versa. In other words, you cannot access one through HTTP and the other one
through HTTPS.
Log Settings
There are a number of configuration parameters that allow you to specify the type
and amount of information to write to the Action Processor log file. Locate the
following elements in the apConfig.xml file and change the default value to fit
your needs for Action Processor logging:
• <LogLevel> - This specifies the level of information to write to the log. The
valid levels are:
— ERROR - This provides the least amount of information.
— WARN - This provides more information than ERROR, but less than INFO.
— INFO - (The default) This provides more information than WARN, but less
than DEBUG.
— DEBUG - This provides the most amount of information. This setting
should be used only if there is a problem that is being diagnosed.
• <MaxLogFileSize> - This specifies the maximum size of the log file before it is
rolled over. The default is 10 MB. Setting this to 0 (zero) causes the log to
never roll over.
• <LogArchiveCount> - This specifies the number of archived log files. These
are created if the log exceeds the maximum size limit specified with the
<MaxLogFileSize> tag. The default is 5. Note that the naming convention for
these differs between Java and .NET, as follows (assuming you are using the
default log file name specified in the <LogFile> tag):
— Java Action Processor: APLog.log.X, where X starts at 1 and increases as
archive log files are created (e.g., APLog.log.1).
— .NET Action Processor: APLogXXX.log, where XXX starts at 001 and
increases as archive log files are created (e.g., APLog001.log).
• <LogFile> - This specifies the fully qualified path to the log file. If only the
name is specified, the log file is written to the directory specified in the system
property user.home. This defaults to APLog.log.
This parameter specifies whether or not to compress the XML response from the
Action Processor. (This is only applicable for the Java Action Processor.) This may
be desired if the connection link between the client and Action Processor is slow.
The default is to not compress the response.
To specify the XML response compression setting:
1. Locate the <IsCompressResponse> element in the apConfig.xml file:
<IsCompressResponse>false</IsCompressResponse>
2. Specify a value in this element of “true” to compress the XML response from
the Action Processor, or “false” to not compress.
This configuration setting specifies whether or not the Action Processor should,
by default, return parameter information to the client (parameter information is
returned to the client in the form of <InParam> elements).
When the Action Processor calls the GetXMLResult method, it passes the value
in this configuration setting in the “WithInput” parameter to specify whether or
not to return input information. This setting defaults to “false”.
To specify the return request parameter setting:
1. Locate the <IsReturnSSOParams> element in the apConfig.xml file:
<IsReturnSSOParams>false</IsReturnSSOParams>
This parameter is used to specify a URI that points to an external forms package
that is used to display forms in the iProcess Workspace. This parameter is used
with the following external forms packages:
• TIBCO BusinessWorks iProcess™ Forms Plug-in - This plug-in allows you
to create a form using TIBCO BusinessWorks™ FormBuilder, then associate
that form with a step in a TIBCO iProcess Engine procedure. For information
about this plug-in, see the TIBCO BusinessWorks iProcess Forms Plug-in User’s
Guide.
• ASP Forms - These forms can be created in a .NET project, then used in a
TIBCO iProcess Engine procedure. For information about using these types of
forms, see ASP Forms on page 137.
• JSP Forms - These forms can be created in a Java development environment,
then used in a TIBCO iProcess Engine procedure. For information about using
these types of forms, see JSP Forms on page 147.
To specify the external form URI setting:
1. Locate the <ExternalFormURI> element in the apConfig.xml file:
<ExternalFormURI>http://localhost:8080/</ExternalFormURI>
2. Replace “localhost” with the name of the computer on which the Formflow
process, ASP form, or JSP form is deployed, and replace “8080” with the port
number used by the Web Application Server that is hosting your external
form. For example:
<ExternalFormURI>http://whisler:90/</ExternalFormURI>
Note that the final slash following the port number is required.
Server Factories
This parameter specifies the server factories to use when using the Remote
Method Invocation (RMI). (This parameter is only applicable for the Java Action
Processor.)
To specify the server factories to use:
1. Locate the <ServerFactories> element in the apConfig.xml file:
<ServerFactories>
<ServerFactory>
<UniqueId></UniqueId>
<Name></Name>
<IsJRMP></IsJRMP>
<LoadFactor></LoadFactor>
<JNDIEnvs>
<JNDIEnv>
<Name></Name>
<Value></Value>
</JNDIEnv>
</JNDIEnvs>
</ServerFactory>
</ServerFactories>
2. Enter values in these elements to specify information about the server factory:
— <UniqueId>: Used to uniquely identify the server factory.
— <Name>: The name of the server factory.
— <IsJRMP>: This specifies the protocol used to marshall objects. Setting this
to “true” causes the Java Remote Method Protocol (JRMP) to be used;
setting this to “false” causes Internet Inter-ORB Protocol (IIOP) to be used.
(Note that the protocol specified here must be the same protocol used when
constructing xSession objects.)
— <LoadFactor>: This specifies how the load should be dispersed among the
server factories when using multiple server factories. The number specified
here is viewed as a percentage of the total of the load factors specified for
all server factories. For ease of use, the total of all load factors should total
100 (although it’s not required). For example, if three server factories are
used, their load factors might be set to 50, 30, and 20 — the first one will get
50% of the load, the second 30%, and the third 20%.
— <JNDIEnv>: Multiple JNDI environment settings can be specified to use
when creating the context used to locate the server factory. Each of these
will contain a <Name> and <Value> element to provide specifics about the
environment setting.
Multiple <ServerFactory> elements can be configured, one for each server factory
used.
XML Validation
This parameter specifies whether or not to validate the XML requests to the
Action Processor using an XSD (apAction.xsd). This is configurable because there
is some overhead incurred when validating requests.
The default is to not validate the requests.
To specify the XML validation setting:
1. Locate the <IsValidateActionXML> element in the apConfig.xml file:
<IsValidateActionXML>false</IsValidateActionXML>
This parameter is used to specify whether or not to display the Action Processor
version number in the Action Processor action response. The version number is
displayed under the <ap:Status> element in the response: For example:
<ap:Status>
<ap:Version>10.6.0</ap:Version>
...
Topics
• Overview, page 70
• Implementation, page 73
• Interface Properties and Methods, page 78
• FieldData Class, page 112
• Date Conversions, page 116
• Accessing User Options When Using GI Forms, page 127
Overview
The GI Forms interface allows you to create forms using the TIBCO General
Interface Builder, then use those forms for work item steps in the iProcess
Workspace (Browser). This allows you to take advantage of the advanced
form-building capabilities of the TIBCO General Interface Builder.
The GI Forms interface allows your custom forms to utilize the existing iProcess
Workspace (Browser) communication methods to perform the following
functions:
• start a case
• lock a work item
• get field data to display in the form
• keep or release the work item
Custom Form
Name
Address
City
State
. . .
N ame
User Action
A ddress
Form Prototype
C ity
S tate
. . .
When a user either starts a case of a procedure or opens an existing work item, the
TIBCO iProcess Workspace (Browser) will check to see if there is a GI form
specified for that step in the <Forms> element of the client’s config.xml file:
• If there is a GI form specified for the step:
— The iProcess Workspace (Browser) instantiates the custom GI form class
that is specified in the <Forms> element in the iProcess Workspace
For information about the version of TIBCO General Interface Builder that must
be used if you are developing your own GI forms to use with the iProcess
Workspace (Browser), see the Release Notes for the iProcess Workspace
(Browser).
Base Class
The GI Forms interface provides the following base class that is extended for each
custom GI form created:
• com.tibco.bpm.ipc.Form
Sample Implementation
A sample subclass implementation of the GI Forms interface base class is provided
in the FormTemplate subdirectory.
Implementation
Perform the following steps to implement the GI Forms interface in the TIBCO
iProcess Workspace (Browser):
1. Copy the entire FormTemplate directory, and paste it into the
.../components/Forms directory.
2. Rename the copied directory to match the class name for your custom form.
For example, assume a custom form with a class name of “CustomForm1”:
3. In the new custom form directory, replace the “FormTemplate” name with the
name of your custom form class. For example:
— Forms/CustomForm1/js/FormTemplate.js
— Forms/CustomForm1/prototype/FormTemplateDefault.xml
<object type="jsx3.gui.Button">
<variants jsxindex="0" jsxheight="18"/>
<strings jsxname="btnKeep" jsxtext="Keep" jsxmargin="top:6px"/>
<events jsxexecute="this.getAncestorOfName('layoutFormData').getParent().doKeep();"/>
</object>
Note that the name referenced above, layoutFormData, is the name assigned
to the top-level object (using: jsxname=”layoutFormData”) in the form
prototype:
<object type="jsx3.gui.LayoutGrid">
<variants jsxrepeat="2" jsxsizearray="['*','30']" jsxrelativeposition="0" ... />
<strings jsxname="layoutFormData" jsxwidth="100%" jsxheight="100%"/>
<children>
...
See JSXAPPS\ipc\components\Forms\FormTemplate\prototypes
\FormTemplateDefault.xml to see these examples in their complete context.
The following defines the available <Form> element attributes that need to be
specified for each custom form (note that the optional attributes can be either
omitted or set to a zero-length string):
— procName (required) - The name of the procedure in which the custom
form is used.
— stepName (required) - The name of the step to which the custom form is
associated. When this step is reached in the case (procedure instance), the
custom form is displayed.
— class (required) - The name of the class that defines the custom form. This
is the class that is instantiated by the iProcess Workspace (Browser) when
the user starts a case or opens an existing work item. For the example
described earlier, this would be specified as:
class=”com.tibco.bpm.ipc.CustomForm1”
If the prototype path is not specified here or explicitly in the class, the
default path is used:
For example, the default prototype path for the sample FormTemplate is:
“FormTemplate/prototypes/FormTemplateDefault.xml”
(Browser). If omitted or set to any other value, the value selected in the
When opening a floating work item form, open it in option on the
application’s Options dialog is used.
8. Update the TIBCO iProcess Workspace (Browser) configuration file to include
mappings to each custom form class. The configuration file is located at:
...\JSXAPPS\ipc\config.xml
The following is an example map record for the sample form template:
Locate the existing mapping records (type = “map”) in the config.xml file and
enter a record for each of your custom form classes.
Note that the jsxid value for the map-type record (127 in this example) is
arbitrary, i.e., you can specify any value desired (the jsxid is not used in this
context).
This section provides information about the properties and methods available in
the com.tibco.bpm.ipc.Form base class. Since the custom form class extends this
base class, these properties and methods can be accessed directly in your custom
form class.
a. The case number, work item tag, and work queue tag are null for start case.
Note that any of the values in the node returned by getNode() can be read using
getAttribute('attributeName') as shown below:
var version = this.getNode().getAttribute('Version');
Arrived="2006-08-29 16:22"
IsDeadline="false"
IsDeadlineImage="JSXAPPS/ipc/application/images/IsFalse.gif"
IsDeadlineExp="false"
IsDeadlineExpImage="JSXAPPS/ipc/application/images/IsFalse.gif"
IsKeepOnWithdrawalImage="JSXAPPS/ipc/application/images/IsFalse.gif"
IsKeepOnWithdrawal="false"
IsForwardableImage="JSXAPPS/ipc/application/images/IsFalse.gif"
IsForwardable="false"
IsLocked="false"
IsLockedImage="JSXAPPS/ipc/application/images/IsFalse.gif"
IsLongLocked="true"
IsLongLockedImage="JSXAPPS/ipc/application/images/IsTrue.gif"
IsOrphanedImage="JSXAPPS/ipc/application/images/IsFalse.gif"
IsOrphaned="false"
IsReleasable="false"
IsReleasableImage="JSXAPPS/ipc/application/images/IsFalse.gif"
IsUnopened="false"
IsUnopenedImage="JSXAPPS/ipc/application/images/IsFalse.gif"
IsUrgent="false"
IsUrgentImage="JSXAPPS/ipc/application/images/IsFalse.gif"
IsSuspended="false"
IsSuspendedImage="JSXAPPS/ipc/application/images/IsFalse.gif"
LockedBy="username"
Priority="50"
StepName="STEP1"
StepDescription="First step"
OCCUPATION=""
WorkQParam1=""
WorkQParam2=""
WorkQParam3=""
WorkQParam4=""
DeltaStatus="swNotDeltaItem"
jsxselected="1"
ListId="_jsx_ipcNS_254"
IsCustomFormStartCase="false">
</record>
closeForm
Syntax closeForm()
Parameters None
Returns Void
Remarks This method also clears the XML cache data. The XML cache data includes any
XML data stored in cache as a result of a socketRequest or transformData call.
Caches are cleared that have IDs containing the form instance object ID. If names
other than the default cache names have been used, the overriding class should
ensure that all caches have been removed.
confirmUserMessage
Purpose Displays a confirm dialog with the given message. If this is a child browser
window, the confirm is sent to the child window context to prevent focus being
moved to the parent browser window.
Note - Custom GI forms should call this.confirmUserMessage (vs. confirm) to
prevent window focus from shifting back to the parent window.
Syntax confirmUserMessage(message)
Parameters
Parameter Type Required? Description
message string Yes The message to be displayed in the
confirm dialog.
Returns Boolean — True if the user selects OK from the confirm dialog; False if the user
selects Cancel.
createFieldDefsRequest
Purpose This method creates and returns the Action Processor GetFieldDefs request,
which is used to get the field definitions for a procedure for which you are
starting a case or opening a work item.
This method is used if you don’t have knowledge of the fields on the form. The
GetFieldDefs request returns all fields defined for the procedure.
This method only returns the GetFieldDefs request; it does not submit it to the
Action Processor. To submit the request, you must call the socketRequest method
(see page 110).
Syntax createFieldDefsRequest(requestId)
Example XML The following provides example XML for this method.
<ap:ActionResult xmlns:ap="http://tibco.com/bpm/actionprocessor">
<ap:Status>
<ap:Version>10.6.0</ap:Version>
<ap:ReturnCode>0</ap:ReturnCode>
<ap:ReturnComment>The Action was processed successfully. Check the individual
Request Results for their status.</ap:ReturnComment>
<ap:ReturnDateTime>2006-02-06T10:43:42.432-0800</ap:ReturnDateTime>
</ap:Status>
<ap:SSO>
<sso:vSSOData xmlns:sso="http://tibco.com/bpm/sso/types">
<sso:Results>
<sso:vResult Id="_jsx_ipcNS_301_XML_apfd">
<sso:FieldDefs>
<sso:vFieldDef>
<sso:Name>LOCATION</sso:Name>
<sso:FieldType>swText</sso:FieldType>
<sso:Value></sso:Value>
<sso:Length>20</sso:Length>
<sso:DecimalPlaceCnt>0</sso:DecimalPlaceCnt>
<sso:IsArrayField>false</sso:IsArrayField>
</sso:vFieldDef>
<sso:vFieldDef>
<sso:Name>MEMO</sso:Name>
<sso:FieldType>swMemo</sso:FieldType>
<sso:Value></sso:Value>
<sso:Length>0</sso:Length>
<sso:DecimalPlaceCnt>0</sso:DecimalPlaceCnt>
<sso:IsArrayField>false</sso:IsArrayField>
</sso:vFieldDef>
<sso:vFieldDef>
<sso:Name>NAME</sso:Name>
<sso:FieldType>swText</sso:FieldType>
<sso:Value></sso:Value>
<sso:Length>20</sso:Length>
<sso:DecimalPlaceCnt>0</sso:DecimalPlaceCnt>
<sso:IsArrayField>false</sso:IsArrayField>
</sso:vFieldDef>
<sso:vFieldDef>
<sso:Name>NUMERIC</sso:Name>
<sso:FieldType>swNumeric</sso:FieldType>
<sso:Length>10</sso:Length>
<sso:DecimalPlaceCnt>2</sso:DecimalPlaceCnt>
<sso:IsArrayField>false</sso:IsArrayField>
</sso:vFieldDef>
<sso:vFieldDef>
<sso:Name>REASON</sso:Name>
<sso:FieldType>swText</sso:FieldType>
<sso:Value></sso:Value>
<sso:Length>20</sso:Length>
<sso:DecimalPlaceCnt>0</sso:DecimalPlaceCnt>
<sso:IsArrayField>false</sso:IsArrayField>
</sso:vFieldDef>
<!-- SW fields removed -->
</sso:FieldDefs>
</sso:vResult>
</sso:Results>
</sso:vSSOData>
</ap:SSO>
</ap:ActionResult>
<data>
<record jsxid="IDARQ4YC" ssoName="LOCATION" ssoFieldType="swText" ssoValue=""/>
<record jsxid="IDAYQ4YC" ssoName="MEMO" ssoFieldType="swMemo" ssoValue=""/>
<record jsxid="IDA5Q4YC" ssoName="NAME" ssoFieldType="swText" ssoValue=""/>
<record jsxid="IDAGR4YC" ssoName="NUMERIC" ssoFieldType="swNumeric" ssoValue=""/>
<record jsxid="IDAMR4YC" ssoName="REASON" ssoFieldType="swText" ssoValue=""/>
<record jsxid="IDA1T4YC" ssoName="TEXT" ssoFieldType="swText" ssoValue=""/>
<record jsxid="IDACU4YC" ssoName="TITLE" ssoFieldType="swText" ssoValue=""/>
</data>
createKeepRequest
Purpose If a case is being started, this method creates and returns the Action Processor
StartCase request, with the isRelease flag set to False.
If an existing work item is being kept in the work queue, this method creates and
returns the Action Processor KeepItems request.
This method only returns the StartCase or KeepItems request; it does not submit
it to the Action Processor. To submit the request, you must call the socketRequest
method (see page 110).
Syntax createKeepRequest(fields,
requestId,
validate,
subProcPrecedence)
Remarks This method is called by the custom form class doKeep method. The Keep button
on the form triggers the call to the doKeep method. Data is collected from the
form and the XML request is obtained using this method. This request is then
submitted to the Action Processor using the socketRequest method.
ipcClass.prototype.doKeep = function() {
var keepRequest = this.createKeepRequest(this.getFormData());
var socket = this.socketRequest(keepRequest);
if (socket.isSuccess() && socket.getSsoErrorMsg() == null) {
this.jsxsuper();
}
};
Example XML The following provides example XML for this method.
Keep Request:
createLockRequest
Purpose This method creates and returns the Action Processor LockItems request.
This method only returns the LockItems request; it does not submit it to the
Action Processor. To submit the request, you must call the socketRequest method
(see page 110).
Note that it is not required that you call this method — it is called by the custom
form class lockWorkItem method. It is available, however, if you want the Action
Processor LockItems request to lock a work item and get field data.
Syntax createLockRequest(fieldNames,
requestId)
ipcClass.prototype.lockWorkItem = function(
fieldNames, xslPath, apCacheId, cdfCacheId) {
var fieldData = null;
var useApCacheId = apCacheId != null ? apCacheId :
this.getXmlCacheIdAp();
var useXslPath = xslPath != null ? xslPath :
com.tibco.bpm.ipc.Form.DIR + 'xsl/lockItemsToCdf.xsl';
var useCdfCacheId = cdfCacheId != null ? cdfCacheId :
this.getXmlCacheId();
var lockRequest = this.createLockRequest(fieldNames, useApCacheId);
var socket = this.socketRequest(lockRequest, useApCacheId);
if (socket.isSuccess() && socket.getSsoErrorMsg() == null) {
this.transformData(useXslPath, useApCacheId, useCdfCacheId);
var doc = this.getApp().getCache().getDocument(useCdfCacheId);
fieldData = new com.tibco.bpm.ipc.FieldData();
fieldData.loadFromCdfDoc(doc);
}
return fieldData;
};
Example XML The following provides example XML for this method.
<ap:ActionResult xmlns:ap="http://tibco.com/bpm/actionprocessor">
<ap:Status>
<ap:Version>10.6.0</ap:Version>
<ap:ReturnCode>0</ap:ReturnCode>
<ap:ReturnComment>The Action was processed successfully. Check the individual
Request Results for their status.</ap:ReturnComment>
<ap:ReturnDateTime>2006-02-06T10:43:42.698-0800</ap:ReturnDateTime>
</ap:Status>
<ap:SSO>
<sso:vSSOData xmlns:sso="http://tibco.com/bpm/sso/types">
<sso:Results>
<sso:vResult Id="_jsx_ipcNS_301_XML_ap">
<sso:WIFieldGroups>
<sso:vWIFieldGroup>
<sso:WorkItemTag>i2tagtest|ALLOCATE|swadmin|R|2050|408966|
i2tagtest|SUMMARY|0|2</sso:WorkItemTag>
<sso:WorkItemFields>
<sso:vField>
<data>
<xsl:apply-templates select="/ap:ActionResult/ap:SSO/sso:vSSOData/
sso:Results/sso:vResult[@Id = $uniqueId]"/>
</data>
</xsl:template>
<xsl:template match="sso:vResult">
<xsl:apply-templates select="sso:WIFieldGroups/sso:vWIFieldGroup/
sso:WorkItemFields/sso:vField"/>
</xsl:template>
<xsl:template match="sso:vField">
<xsl:element name="record">
<xsl:attribute name="jsxid">
<xsl:value-of select="generate-id()"/>
</xsl:attribute>
<xsl:attribute name="ssoName">
<xsl:value-of select="sso:Name"/>
</xsl:attribute>
<xsl:attribute name="ssoFieldType">
<xsl:value-of select="sso:FieldType"/>
</xsl:attribute>
<xsl:attribute name="ssoValue">
<xsl:value-of select="sso:Value"/>
</xsl:attribute>
</xsl:element>
</xsl:template>
</xsl:stylesheet>
<data>
<record jsxid="IDAF1CZC" ssoName="TITLE" ssoFieldType="swText" ssoValue="test
title 3"/>
<record jsxid="IDAJ1CZC" ssoName="TEXT" ssoFieldType="swText" ssoValue="test"/>
<record jsxid="IDAN1CZC" ssoName="REASON" ssoFieldType="swText"
ssoValue="test"/>
<record jsxid="IDAR1CZC" ssoName="NUMERIC" ssoFieldType="swNumeric"
ssoValue="123.0"/>
<record jsxid="IDAV1CZC" ssoName="NAME" ssoFieldType="swText"
ssoValue="test name 3"/>
<record jsxid="IDAZ1CZC" ssoName="MEMO" ssoFieldType="swMemo"
ssoValue="test memo 4"/>
<record jsxid="IDA31CZC" ssoName="LOCATION" ssoFieldType="swText"
ssoValue="test 6"/>
</data>
createReleaseRequest
Purpose If a case is being started, this method creates and returns the Action Processor
StartCase request, with the isRelease flag set to True.
If an existing work item is being released from the work queue, this method creates
and returns the Action Processor ReleaseItems request.
This method only returns the StartCase or ReleaseItems request; it does not
submit it to the Action Processor. To submit the request, you must call the
socketRequest method (see page 110).
Syntax createReleaseRequest(fields,
requestId,
validate,
subProcPrecedence)
Remarks This method is called by the custom form class doRelease method. The Release
button on the form triggers the call to the doRelease method. Data is collected
from the form and the XML request is obtained using this method. This request is
then submitted to the Action Processor using the socketRequest method.
ipcClass.prototype.doRelease = function() {
var releaseRequest = this.createReleaseRequest(this.getFormData());
var socket = this.socketRequest(releaseRequest);
if (socket.isSuccess() && socket.getSsoErrorMsg() == null) {
this.jsxsuper();
}
};
Release Request:
doCancel
Purpose This method closes the form dialog and unlocks the work item. No field data is
saved. This method also updates the work item list.
Unlock work item and list update are not applicable for case start.
Syntax doCancel()
Parameters None
Returns Void
doClose
Purpose This method closes the form dialog and unlocks the work item. No field data is
saved. This method also updates the work item list.
Unlock work item and list update are not applicable for case start.
Syntax doClose()
Parameters None
Returns Void
doKeep
Purpose This method closes the form dialog and updates the work item list. (List update is
not applicable for case start.)
A custom form class that extends the base class must override this method. The
overridden method provides the keep functionality and calls this super class
method (using this.jsxsuper();) upon successful completion, as follows:
• The Keep button on the form triggers the call to the doKeep method.
• Data is collected from the form.
• The XML request is obtained using createKeepRequest. This request is then
submitted to the Action Processor using socketRequest.
• The socket results are checked for success, and if successful, calls this super
class method (using this.jsxsuper();).
Note that the com.tibco.bpm.ipc.Socket class presents the user with a message
dialog if any errors are encountered. The Socket class can be checked for any error
conditions using the methods shown in the example below.
Syntax doKeep()
Parameters None
Returns Void
ipcClass.prototype.doKeep = function() {
var keepRequest = this.createKeepRequest(this.getFormData());
var socket = this.socketRequest(keepRequest);
if (socket.isSuccess() && socket.getSsoErrorMsg() == null) {
this.jsxsuper();
}
};
doRelease
Purpose This method closes the form dialog and updates the work item list. (List update is
not applicable for case start.)
A custom form class that extends the base class must override this method. The
overridden method provides the release functionality and calls this super class
method (using this.jsxsuper();) upon successful completion, as follows:
• The Release button on the form triggers the call to the doRelease method.
• Data is collected from the form.
• The XML request is obtained using createReleaseRequest. This request is
then submitted to the Action Processor using socketRequest.
• The socket results are checked for success, and if successful, calls this super
class method (using this.jsxsuper();).
Note that the com.tibco.bpm.ipc.Socket class presents the user with a message
dialog if any errors are encountered. The Socket class can be checked for any error
conditions using the methods shown in the example below.
Syntax doRelease()
Parameters None
Returns Void
ipcClass.prototype.doRelease = function() {
var releaseRequest = this.createReleaseRequest(this.getFormData());
var socket = this.socketRequest(releaseRequest);
if (socket.isSuccess() && socket.getSsoErrorMsg() == null) {
this.jsxsuper();
}
};
init
Purpose This method is called when a new instance of the class is created. A custom form
class that extends this base class can override this method if required, but must
call the super class init method (using this.jsxsuper();). The init method might be
overridden to set the dialog caption bar (if something other than the default value
is desired) or to explicitly set the prototypePath.
Syntax init(node,
strName,
intWidth,
intHeight,
strCaption)
Returns Void
lockWorkItem
Purpose This method creates an Action Processor LockItems request XML, submits the
request, then applies the specified XSL transform to the result returned.
The lockWorkItem method combines several common actions into a convenient
single method call. This can be used by a custom form class when initializing the
form data, typically called from the custom class postLoadInit method override.
For a code example, see postLoadInit (on page 106).
This method returns an instance of com.tibco.bpm.ipc.FieldData. Each record
element in the transformed CDF is added as a data field in
com.tibco.bpm.ipc.FieldData. The field data is read from the corresponding
attributes in each record: ssoName, ssoFieldType, and ssoValue.
The com.tibco.bpm.ipc.FieldData class provides convenient access to field data,
which can be updated and then passed into the fields parameter of the
createKeepRequest or the createReleaseRequest function.
If an error is encountered processing the request, a null is returned.
Note that if a custom transform is applied, the returned
com.tibco.bpm.ipc.FieldData will contain valid data only if the resulting CDF
conforms to the expected default format shown below:
<data>
<record ssoName="FieldName"
ssoFieldType="swFieldType"
ssoValue="FieldValue"/>
...
</data>
If an expected record attribute is not found, its matching property in the data
object is set to null.
If record elements are not found, no data objects are created.
Syntax lockWorkItem(fieldNames,
xslPath,
apCacheId,
cdfCacheId)
onBeforeUnload
Purpose This method can be extended by a sub-class to handle any actions to be taken
before the browser window is closed directly using the window close icon. This
only applies if the form is opened in a new external browser window.
Note that this method is not called if the window is closed as a result of a call to
doCancel().
Syntax onBeforeUnload()
Parameters None
Returns Void
postLoadInit
Purpose A custom form class that extends the base class must override this method. The
postLoadInit method is called after the form prototype is loaded. The overridden
method first calls this super class method (using this.jsxsuper();), then
implements data loading and GUI initialization code.
Note that this method does not update (refresh) the work item list by sending a
message to the server, although statuses in the list are updated (not applicable for
case start).
Syntax postLoadInit()
Parameters None
Returns Void
ipcClass.prototype.postLoadInit = function() {
this.jsxsuper();
this.readFieldNames();
if (! this.startCase) {
this.fieldData = this.lockWorkItem(this.fieldNames);
if (this.fieldData == null) {
this.showUserMessage(
'Error encountered locking the work item.');
}
}
this.initializeFormData();
};
readFieldDefs
Purpose This method creates an Action Processor GetFieldDefs request XML, submits the
request, then applies the specified XSL transform to the result returned.
The readFieldDefs method combines several common actions into a convenient
single method call. This is called by
com.tibco.bpm.ipc.FormTemplate.readFieldNames. This might be most useful in
development if the values of fields on a procedure are not known or if there is a
need to obtain these dynamically instead of having statically defined fields on a
form.
This method returns an instance of com.tibco.bpm.ipc.FieldData. Each record
element in the transformed CDF is added as a data field in
com.tibco.bpm.ipc.FieldData. The field data is read from the corresponding
attributes in each record: ssoName, ssoFieldType, and ssoValue.
The com.tibco.bpm.ipc.FieldData class provides convenient access to field data,
which can be updated and then passed into the fields parameter of the
createKeepRequest or the createReleaseRequest function.
If an error is encountered processing the request, a null is returned.
Note that if a custom transform is applied, the returned
com.tibco.bpm.ipc.FieldData will contain valid data only if the resulting CDF
conforms to the expected default format shown below:
<data>
<record ssoName="FieldName"
ssoFieldType="swFieldType"
ssoValue="FieldValue"/>
...
</data>
If an expected record attribute is not found, its matching property in the data
object is set to null.
If record elements are not found, no data objects are created.
Syntax readFieldDefs(xslPath,
apCacheId,
cdfCacheId)
showUserMessage
Purpose Displays an alert dialog with the given message. If this is a child browser window,
the alert is sent to the child window context to prevent focus being moved to the
parent browser window.
Note - Custom GI forms should call this.showUserMessage (vs. alert) to prevent
window focus from shifting back to the parent window.
Syntax showUserMessage(message)
Parameters
Parameter Type Required? Description
message string Yes The message to be displayed in the
alert.
Returns Void
this.showUserMessage(
'Invalid format:' +
'\n\n Field name: ' + fieldName +
'\n\n Current value: ' + fieldValue +
'\n\n Expected format: ' + pattern + '.');
socketRequest
Purpose This method creates an Action Processor socket for the given request and submits
the request to the Action Processor. This must be called to submit the request after
calling any of the “create...Request” methods (createKeepRequest,
createLockRequest, etc.).
The instance of the Socket class returned can be checked for any error conditions
using the following functions:
• socket.isSuccess - A false value indicates an error occurred communicating
with the Action Processor.
• socket.getSsoErrorMsg - If not null, this will contain a string message
indicating what iProcess Server Object error was returned in the Action
Processor result.
Syntax socketRequest(requestXml,
cacheId)
ipcClass.prototype.doKeep = function() {
var keepRequest = this.createKeepRequest(this.getFormData());
var socket = this.socketRequest(keepRequest);
if (socket.isSuccess() && socket.getSsoErrorMsg() == null) {
this.jsxsuper();
}
};
transformData
Purpose This method applies the given XSL transform to the source CacheId XML and
stores the result in the target CacheId XML.
Syntax transformData(xslPath,
sourceCacheId,
targetCacheId)
FieldData Class
• removeField(name)
This function removes the field data Object specified by setting it to null.
where:
— name is the field name (string) to remove.
• getFieldDataObject()
This function returns the fieldDataObject, which serves as a map, where each
association is:
— property = field name
— value = a field data Object, with properties name, fieldType, and value.
• getFieldDataArray()
This function returns an array of Objects whose properties contain field data.
These properties are: name, fieldType, and value.
• enableLogging(app, forceLog)
This function enables logging.
where:
— app is the application instance (com.tibco.bpm.ipc.Application) to log to.
— forceLog (boolean) allows you to force logging. If true, the log is written
even if appLogActive = false. This is optional. Default = false.
• log(message)
This function logs the specified message if logging is enabled — see the
enableLogging function.
where:
— message is the message to write to the log.
For example, given an array field named 'IDX_ITEM', the lockWorkItem method
of the GI form class is called:
this.lockWorkItem(this.fieldNames);
Date Conversions
• The only alphanumeric characters that can appear in the pattern are those
shown in the list above.
• Quoted, literal text is not supported in the pattern.
• One or more non-alphanumeric characters MUST appear between tokens as
delimiters (spaces, colons, slashes, dashes, etc). There is one exception to this
rule; the am/pm designator can immediately follow another token without a
delimiter between.
The routines are very flexible when interpreting dates and times entered by a
user, so information will not have to be entered exactly like the pattern, character
by character.
• Any number of delimiting characters can be entered between parts of the
date/time. These delimiting characters do not have to match the characters in
the formatting pattern (keeping in mind that alpha characters cannot be used
as delimiters). For instance, all of these values will be interpreted the same:
'12/31/2005', '12-31-2005', '12 31 * 2005', '(12) (31?%$#@2005)'.
• Numeric values can be entered either with or without leading zeros.
• No matter what token is used in the pattern for the month, it can be entered as
either a number or as the abbreviated or full month name.
• When the name or abbreviation for a month is entered, there does not have to
be delimiters around it, and it can be placed out of the expected order.
However, all the remaining elements must appear in the expected order. For
instance, if the pattern is 'dd-MM-yyyy', then 'Sep-10-2005', 'September 10,
2005', '10Sep2005', and even '10 2005Sep' will all be interpreted as the 10th of
September, 2005.
• Time can be entered in either 24-hour or 12-hour format. If seconds or minutes
are left off, they will be set to zero. The AM/PM designator does not have to
appear in the exact position specified in the pattern. For instance, using any of
these formatting patterns: 'h:mm:ssa', 'h:mm:ss', 'h.mm.ss a', cause all of the
following values to be interpreted as 2PM: '2:00pm', '2pm', '2:00:00pm', '14',
'14:00', '14:00:00', and even 'pm2'.
• The sets of characters 'st', 'nd', 'rd', and 'th' when used with day numbers, such
as '1st', '2nd', '3rd', '4th', etc., will be ignored. The fact that these follow a
number will not automatically cause the number to be used as the day,
however. The number must still fall in the proper relative order according to
the pattern. Aside from these pairs of characters, the am/pm designator, and
the full and abbreviated month names, no other alpha characters (a-z and
A-Z) are allowed in the input string, and will cause a conversion to fail. Month
names will, of course, have to be spelled properly, and only the one expected
abbreviation will be valid.
• When 0 through 99 is entered for a year, it will be interpreted as 2000 - 2099.
• The user must enter the elements of the date/time in the order specified in the
formatting pattern, but if some elements are left off the end, a suitable value
will be used. For instance, when using the pattern MM-dd-yyyy, if only the
month and day are entered, the current year is used. If only the month is
entered, the first day of the month for the current year is used.
• Relative dates or times can be specified by entering a plus or minus sign
followed by a number:
— If the pattern includes date information, this is interpreted in days. So '+1'
is tomorrow, '-1' is yesterday, '+7' is a week from today, etc. Time is set to
00:00:00.
— For time-only fields, this is interpreted as minutes. So '-30' is thirty minutes
ago, '+90' is an hour and a half from now, etc. Seconds are set to 00.
• All XML dateTime strings will have the fractional seconds values shown with
a decimal followed by six zeros:
2006-06-30T17:14:39.0000000
Note that the JavaScript Date object milliseconds value is truncated.
• No XML dateTime strings will include a timezone value.
• The following range of dates is allowed:
— Any valid JavaScript Date with a year of 100 or greater:
0100-01-01T00:00:00.0000000 to 275760-09-13T01:00:00.0000000
— For a JavaScript date, this range is: 59011430400000 milliseconds (-683002
days) to 8640000000000000 milliseconds (100000000 days) elapsed since
1/1/1970 GMT.
The following are examples of valid patterns:
— MM/dd/yyyy
— dd-MMM-yyyy
— MMMM dd, yyyy
— yyyy-mm-dd
— h:mma
The following are examples of invalid patterns (although they are valid in Java
patterns):
— yyyyMMddhhmmss (no delimiters)
— yyyy-mm-dd'T'hh:mm:ss.000z (quoted text and unsupported commands)
— E MMMM dd, yyyy G (unsupported commands)
— 'week:' w 'day:' F 'of' yyyy (quoted text and unsupported commands)
— h 'o''clock' a (quoted text)
Code Example
jsDateToLocal
Purpose This method converts a JavaScript Date object into a string containing a formatted
local date value.
Parameters
Parameter Type Required? Description
jsDate Date Yes JavaScript Date object to be
object converted.
Returns A string containing a formatted date. Returns null if parameters are omitted or
the format pattern is invalid.
Remarks If the date portion of the format pattern is omitted, the resulting date is
12/30/1899. If the time portion of the format pattern is omitted, the resulting time
is 00:00.
jsDateToXml
Purpose This method converts a JavaScript Date object into a standard serialized XML date
string.
Syntax jsDateToXml(jsDate)
localToJSDate
Purpose This method converts a string containing a formatted local date value into a
JavaScript Date object.
Parameters
Parameter Type Required? Description
strDate string Yes Formatted date string.
Returns A JavaScript Date object. Returns null if parameters are omitted or the format
pattern is invalid.
Remarks If the date portion of the format pattern is omitted, the resulting date is
12/30/1899. If the time portion of the format pattern is omitted, the resulting time
is 00:00.
localToXml
Purpose This method converts a string containing a formatted local date value into a
standard serialized XML date string.
Parameters
Parameter Type Required? Description
strDate string Yes Formatted date string.
Remarks If the date portion of the format pattern is omitted, the resulting date is
12/30/1899. If the time portion of the format pattern is omitted, the resulting time
is 00:00.
xmlToJSDate
Purpose This method converts a standard serialized XML date string into a JavaScript Date
object.
Syntax xmlToJSDate(xmlDate)
Parameters
Parameter Type Required? Description
xmlDate string Yes Standard serialized XML date string
in the format:
yyyy-MM-ddThh:mm:ss.0000000
Returns A JavaScript Date object. Returns null if the xmlDate parameter is omitted or the
format pattern is invalid.
xmlToLocal
Purpose This method converts a standard serialized XML date string into a string
containing a formatted local date value.
Returns A string containing a formatted date. Returns null if parameters are omitted or
the format pattern is invalid.
Remarks If the date portion of the format pattern is omitted, the resulting date is
12/30/1899. If the time portion of the format pattern is omitted, the resulting time
is 00:00.
getAbbrMonthNames
Purpose This method returns the abbreviations of the months that are returned when the
abbreviated month name format (MMM) is specified in a pattern parameter to a
date conversion method.
Syntax getAbbrMonthNames()
Parameters None
Returns JavaScript array of strings representing the abbreviations for months of the year,
in order from the first month to the twelfth month.
Remarks The default abbreviated month names returned by the date conversion methods
are: 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'.
setAbbrMonthNames
Purpose This method allows you to specify the abbreviations that are returned when the
abbreviated month name format (MMM) is specified in a pattern parameter to a
date conversion method.
Syntax setAbbrMonthNames(monthNames)
Parameters
Parameter Type Required? Description
monthNames JavaScript Yes Array of strings representing the
array abbreviations for the months of
the year, in order from the first
month to the twelfth month.
Returns None
Remarks The default abbreviated month names returned by the date conversion methods
are: 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'.
getAmPm
Purpose This method returns the am/pm designation that is returned when the am/pm
designator (‘a’) is specified in a pattern parameter to a date conversion method.
Syntax getAmPm()
Parameters None
Returns JavaScript array of two strings, the first representing the am, and the second
representing the pm designation.
Remarks The default designations returned by the date conversion methods are: 'am', 'pm'.
setAmPm
Purpose This method allows you to specify the am/pm designation that is returned when
the am/pm designator (‘a’) is specified in a pattern parameter to a date
conversion method.
Syntax setAmPm(designators)
Parameters
Parameter Type Required? Description
designators JavaScript Yes Array of strings representing the
array am/pm designators, the first
element represents am, and the
second represents pm.
Returns None
Remarks The default designations returned by the date conversion methods are: 'am', 'pm'.
getFullMonthNames
Purpose This method returns the names of the months that are returned when the full
month name format (MMMM) is specified in a pattern parameter to a date
conversion method.
Syntax getFullMonthNames()
Parameters None
Returns JavaScript array of strings representing the months of the year, in order from the
first month to the twelfth month.
Remarks The default full month names returned by the date conversion methods are:
'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September',
'October', 'November', 'December'.
setFullMonthNames
Purpose This method allows you to specify the names of the months that are returned
when the full month name format (MMMM) is specified in a pattern parameter to
a date conversion method.
Syntax setFullMonthNames(monthNames)
Parameters
Parameter Type Required? Description
monthNames JavaScript Yes Array of strings representing the
array months of the year, in order from
the first month to the twelfth
month.
Returns None.
Remarks The default full month names returned by the date conversion methods are:
'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September',
'October', 'November', 'December'.
User options establish default settings for each user who logs into the iProcess
Workspace (Browser). These include things such as the language to display, form
position on the screen, etc. (More information about the options available and
how they can be set from the application can be found in the iProcess Workspace
(Browser) User’s Guide.)
The custom GI form class that extends the com.tibco.bpm.ipc.Form base class can
access the user options for the currently logged in user using:
this.getAppPrefValue(prefName)
where prefName identifies the user option for which you would like the value.
This method returns a string, identifying the current setting of the given user
option. The following table lists the valid prefName values and the possible return
values for each option (note that options were formerly called preferences, hence the
prefName parameter):
formLeft “integer value” The work item form window is positioned this
number of pixels from the left. (Only applicable if
both formFullscreen and formCenter are false.)
formTop “integer value” The work item form window is positioned this
number of pixels from the top. (Only applicable if
both formFullscreen and formCenter are false.)
formWidth “integer value” The width (in pixels) of the work item form window.
(Only applicable if formFullscreen is false.)
formHeight “integer value” The height (in pixels) of the work item form window.
(Only applicable if formFullscreen is false.)
Topics
Session Timeout
The session timeout specifies the number of minutes in which the communication
session between the WAS and the client will timeout if there is no user activity,
which results in the Action Processor timing out. If the session times out, a
message similar to the following is displayed:
The following subsections describe how to change the session timeout in Tomcat
and IIS. If you are using a different application server, see the documentation for
that server.
2. Set the value of the <session-timeout> element to the number of minutes for
the timeout. A value of -1 causes the session to never timeout.
You must restart the Action Processor for the change to take effect.
2. Set the value of the <session-timeout> element to the number of minutes for
the timeout. A value of -1 causes the session to never timeout.
You must restart the Action Processor for the change to take effect.
where APDir is the directory in which the Action Processor is installed (which
defaults to TIBCOActProc).
For example:
<sessionState
mode="InProc"
stateConnectionString="tcpip=127.0.0.1:42424"
sqlConne�tionString="data
source=127.0.0.1;Trusted_Connection=yes"
cookieless="false"
timeout="20"
/>
2. Set the value of the timeout attribute for the desired number of minutes for
the session timeout.
You must restart the Action Processor for the change to take effect.
Character Encoding
For more information about configuring your system for character encoding, see
the TIBCO iProcess Server Objects (Java) Programmer’s Guide.
This sets the total memory and the maximum memory to 1 GB.
This sets the total memory and the maximum memory to 1 GB.
This chapter describes how to set up the ASP form example that is provided with
the iProcess Workspace.
Topics
A Microsoft Visual Studio .NET 2003 project that defines an example ASP form is
provided with the iProcess Workspace. This example can be used as a starting
point to create your own custom ASP form project.
The example .NET project is located in the following directory:
InstallationHomeDir\iprocessclientbrowser\samples\ASPFormExample
where InstallationHomeDir is the directory in which the installer places
administrative files, such as the uninstaller, documentation, and sample code.
This defaults to C:\tibco on Windows systems, and /opt/tibco on UNIX
systems, but can be specified as a different directory when the TIBCO iProcess
Workspace is installed.
The following sections describe how to implement this example.
where:
— Host is the name of the machine on which you’ve installed the ASP form
project.
— Port is the port used by IIS to communicate with web applications.
The Open Project dialog is displayed.
6. Select and open the ASPFormExample.csproj file.
7. In Visual Studio, select Build > Rebuild Solution.
You will be prompted to save the solution file (.sln).
8. Save the solution file in the ASPFormExample directory.
9. In Visual Studio, right click on ASPForm.aspx in the Solution Explorer
window and select Set As Start Page.
10. In Visual Studio, select Debug in the Solution Configuration drop-down list,
then click the start arrow to the left of the field.
Visual Studio will connect to IIS, allowing you to develop and debug the
ASPFormExample project. (A browser window may appear with the
ASPForm.aspx page displayed containing an error message — you can ignore
this message and close the browser window.)
4. Click the Edit button on the Step Definition dialog. The FormFlow Form
dialog is displayed.
5. Enter the location of the ASPForm.aspx file. Don't enter the full URL, as the
base URL location is defined in the ExternalFormURI parameter (see step 1).
Only enter the portion of the URL that is unique to the step.
6. Start a case of the procedure. The ASP form example should look as follows.
7. Edit the ASPFormExample example project for the desired form layout and
fields to be displayed.
Define the field names in the fieldNames array, the types in the fieldTypes
array, and the date format in the dateFormat string.
The field names should correspond to the iProcess Engine procedure field
names. The arrays are defined in ASPForm.aspx, as follows:
The dateFormat variable can be set to “MDY”, “DMY”, or “YMD”, to indicate the
order of the day, month, and year in date fields. (Time fields will be displayed in
the hh:mm format.)
The position and look of these fields can be defined in the ASPForm.css cascading
style sheet. For example:
#TEXTFLD1marking {
position:relative;
left:75px;
top:0px;
width:240px;
}
ASPFormLib Constructor
The constructor initiates the ASPFormLib with the request and field information.
getRequestType
This method returns the type of the request.
The getRequestType method returns one of the following constant int values:
• public const int REQUEST_TYPE_UNKNOWN = 0x0;
• public const int REQUEST_TYPE_RENDER_WORK_ITEM_FORM = 0x1;
• public const int REQUEST_TYPE_RENDER_START_CASE_FORM = 0x2;
• public const int REQUEST_TYPE_START_CASE = 0x3;
• public const int REQUEST_TYPE_UNDO = 0x4;
• public const int REQUEST_TYPE_KEEP = 0x5;
getInitXML
This method returns the details of the XML generated by an Undo, Keep or
Release button click on the form.
startCase
This method creates and submits an Action Processor StartCase request.
undoItem
This method creates and submits an Action Processor UndoItems request.
lockItem
This method creates and submits an Action Processor LockItems request.
keepItem
This method creates and submits an Action Processor KeepItems request.
releaseItem
This method creates and submits an Action Processor ReleaseItems request.
This chapter describes how to set up the JSP form example that is provided with
the iProcess Workspace.
Topics
An IntelliJ project that defines an example JSP form is provided with the iProcess
Workspace. This example can be used as a starting point to create your own
custom JSP form project.
Note that this example was developed using IntelliJ IDEA 5.1 and assumes
Tomcat as the Web Application Server.
The example IntelliJ project is located in the following directory:
InstallationHomeDir\iprocessclientbrowser\Samples\JSPFormExample
where InstallationHomeDir is the directory in which the installer places
administrative files, such as the uninstaller, documentation, and sample code.
This defaults to C:\tibco on Windows systems, and /opt/tibco on UNIX
systems, but can be specified as a different directory when the TIBCO iProcess
Workspace is installed.
The following sections describe how to implement this example.
4. Click the Edit button on the Step Definition dialog. The FormFlow Form
dialog is displayed.
5. Enter the location of the JSPForm.jsp file. Don't enter the full URL as the
base URL location is defined in the ExternalFormURI parameter (see step 1).
Only specify the portion of the URL that is unique to the step.
6. Start a case of the procedure. The JSP form example should look as follows.
7. Edit the JSPFormExample example project for the desired form layout and
fields to be displayed.
Define the field names in the fieldNames array, the types in the fieldTypes
array, and the date format in the dateFormat string.
The field names should correspond to the iProcess Engine procedure field
names. The arrays are defined in JSPForm.jsp, as follows:
The dateFormat variable can be set to “MDY”, “DMY”, or “YMD”, to indicate the
order of the day, month, and year in date fields. (Time fields will be displayed in
the hh:mm format.)
The position and look of these fields can be defined in the JSPForm.css cascading
style sheet. For example:
#TEXTFLD1marking {
position:relative;
left:75px;
top:0px;
width:240px;
}
JSPFormLib Constructor
The constructor initiates the JSPFormLib with the request and field information.
getRequestType
This method returns the type of the request.
The getRequestType method returns one of the following static int values:
• public static final int REQUEST_TYPE_UNKNOWN = 0x0;
• public static final int REQUEST_TYPE_RENDER_WORK_ITEM_FORM =
0x1;
• public static final int REQUEST_TYPE_RENDER_START_CASE_FORM =
0x2;
• public static final int REQUEST_TYPE_START_CASE = 0x3;
getInitXML
This method returns the details of the XML generated by an Undo, Keep or
Release button click on the form.
startCase
This method creates and submits an Action Processor StartCase request.
undoItem
This method creates and submits an Action Processor UndoItems request.
lockItem
This method creates and submits an Action Processor LockItems request.
keepItem
This method creates and submits an Action Processor KeepItems request.
releaseItem
This method creates and submits an Action Processor ReleaseItems request.
Topics
Direct Login
You can bypass the iProcess Workspace (Browser) Login screen by passing login
credentials directly into the application.
Users can also be authenticated using credentials they have already entered in
another web application by using the single authentication feature. For
information, see Single Authentication on page 161.
Login credentials can be directly passed into the iProcess Workspace (Browser) in
one of the following ways:
• On the URL
• In an HTML form element named ‘DirectLogin’
• In an HTML script element that defines ‘getDirectLoginArgs’
When loading, the application will look for direct login credentials in the order
shown above.
The direct login feature is supported on IIS 5.1 (Windows XP) and IIS 6.0
(Windows Server 2003).
To use any of the methods of direct login listed above, direct login must be
enabled in the iProcess Workspace (Browser) configuration file. This is described
in Enabling Direct Login on page 157.
In all of the methods of direct login, the following case-insensitive parameters can
be specified:
— BaseUrl - The Action Processor base URL.
— Username - The user name of the user logging in.
— Password - The password of the user logging in.
— ServerName - If specified, this will override the other server node values
below. These will be looked up from the config.xml file as specified under
the <record jsxid=”ServerNodes” type=”ipc”> node by a record <record
displayNodeName=”nodename”>, where ServerName matches the
nodename value.
— ComputerName - The computer name for the iProcess Objects Server.
— IPAddress - The IP address of the machine on which the TIBCO iProcess
Objects Server is installed. You can specify the name of the host machine,
as long as that name resolves to the IP address of the machine where the
iProcess Objects Server is running. Note, however, that this name must be
able to be resolved by the machine on which the Action Processor is
running.
— TCPPort - The TCP Port for the iProcess Objects Server.
— Name - The iProcess Engine node name.
— Director - “true” or “false”, indicating if an iProcess Objects Director is
being used.
The following sections provide examples of each of the three direct login
methods.
On the URL
The following are examples of passing login credentials on the URL:
Example 1
http://clientServer/ipc/iProcessClient.html?Username=swadmin&Password=&ServerName=
MyServerConfigName
Example 2
http://clientServer/ipc/iProcessClient.html?Username=swadmin&Password=&ComputerName
=ServerComputerName&IPAddress=10.20.30.40&TCPPort=54321&Name=ServerNodeName&
Director=false
Example 3
http://clientServer/ipc/iProcessClient.html?Username=swadmin&Password=&ComputerName
=ServerComputerName&IPAddress=10.20.30.40&TCPPort=54321&Name=ServerNodeName&
Director=false&BaseUrl=https%3A%2F%2Fsummer-heart-0930.chufeiyun1688.workers.dev%3A443%2Fhttp%2FServerComputerName%3A90%2Fipc%2F
ActionProcessor.aspx
Note that if the BaseUrl is passed on the URL, it must be URI encoded as shown
in the last example above.
<form name="DirectLogin">
<input type="hidden" name="BaseUrl"
value="http://ServerComputerName:90/ipc/ActionProcessor.aspx">
<input type="hidden" name="Username" value="swadmin">
<input type="hidden" name="Password" value="">
<!--If ServerName is specified, this will override other
values and will be looked up from the config.xml file. -->
<!-- <input type="hidden" name="ServerName"
value="MyServerConfigName"> -->
<input type="hidden" name="ComputerName"
value="ServerComputerName">
<input type="hidden" name="IPAddress" value="10.20.30.40">
<input type="hidden" name="TCPPort" value="54321">
Add this form to the HTML file used to launch the iProcess Workspace (Browser),
which by default is ClientInstallDir/iProcessClient.html, where ClientInstallDir is
the path to the directory in which the iProcess Workspace (Browser) is installed.
<script language="JavaScript">
function getDirectLoginArgs(nameSpace) {
var args = new Object();
if (nameSpace == 'wccApp') {
args.BaseUrl = "http://ServerComputerName:90/" +
"ipc/ActionProcessor.aspx";
args.Username = "swadmin";
args.Password = "";
//If ServerName is specified, this will override other
//values and will be looked up from the config.xml file.
//args.ServerName = "MyServerConfigName";
args.ComputerName = "ServerComputerName";
args.IPAddress = "10.20.30.40";
args.TCPPort = "54321";
args.Name = "ServerNodeName";
args.Director = "false";
}
return args;
}
</script>
Add this script to the HTML file used to launch the iProcess Workspace
(Browser), which by default is ClientInstallDir/iProcessClient.html, where
ClientInstallDir is the path to the directory in which the iProcess Workspace
(Browser) is installed.
This chapter describes how to configure the TIBCO iProcess Workspace (Browser)
so that users can be authenticated using credentials they have already entered in
another web application.
Topics
Introduction
The Java single authentication feature is used if you are using the Java Action
Processor. It allows users to go directly to the iProcess Workspace (Browser) from
another web application in which they have already been authenticated.
The Java single authentication feature implements a filter to act as a mediator
between the customer’s web application authentication methods and the iProcess
Workspace (Browser) and Java Action Processor.
<filter>
<filter-name>LoginAuthenticator</filter-name>
<filter-class>com.tibco.bpm.ap.filter.AuthenticateFilter</filter-class>
<init-param>
<param-name>AuthenticatorClass</param-name>
<param-value>
com.tibco.bpm.ap.filter.sample.SampleAuthenticator
</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>LoginAuthenticator</filter-name>
<servlet-name>ActionProcessor</servlet-name>
</filter-mapping>
Authenticator Plug-in
The customer must create a plug-in that implements the Authenticator interface,
as follows:
The authenticate method receives the request object so it can sync its
authentication parameters with the request ID. The authenticate method’s return
value is boolean, indicating either success or failure of the authenticate call.
The Authenticator interface also provides getter methods for the information
required for a successful login to the iProcess Workspace (Browser). The filter uses
these values to construct a Login action request to the Java Action Processor.
This informs the iProcess Workspace (Browser) that an external application will
be providing the login authentication credentials.
The failureUrl attribute is used to specify a URL to which the user is redirected if
the login fails.
— If there is a value specified in the failureUrl attribute, and the login fails,
an alert dialog is displayed containing the message "User authentication
could not be confirmed. You will be redirected to an appropriate login
page." The browser is then redirected to the specified URL.
— If the value of failureUrl is empty, and the login fails, an alert dialog is
displayed containing the message “User authentication could not be
confirmed. You must successfully log in before using this site."
• SingleAuthentication.jar - This JAR file contains the class files used by the
authenticator plug-in. It includes:
— com/tibco/bpm/ap/filter/Authenticator.class
— com/tibco/bpm/ap/filter/AuthenticateFilter.class
— com/tibco/bpm/ap/filter/AuthenticateRequestWrapper.class
— com/tibco/bpm/ap/filter/xml/Attribute.class
— com/tibco/bpm/ap/filter/xml/Element.class
— com/tibco/bpm/ap/filter/xml/action/Action.class
— com/tibco/bpm/ap/filter/xml/request/Login.class
— com/tibco/bpm/ap/filter/xml/request/Request.class
— com/tibco/bpm/ap/filter/xml/request/UserId.class
— com/tibco/bpm/ap/filter/xml/vobject.NodeId.class
These JAR files are located in the following directory:
InstallationHomeDir\iprocessclientbrowser\samples\
SingleAuthentication\Java
where:
— Host is the name of the machine hosting the Action Processor.
— Port is the port number used by the WAS that is hosting the Action
Processor to communicate with web applications.
— APDir is the directory on Host in which the Action Processor is installed.
This defaults to TIBCOActProc.
This presents a dialog on which you can enter login credentials. This
represents the outside source from which login credentials are provided.
2. Enter a user name and password, as well as information about the iProcess
Objects Server to log into, then click the Submit button.
This causes the login credentials to be sent to the login.do servlet, which
stores the information in the session using a Java hash map. It then launches
the customerApplication.html file, which represents the customer
application. This page contains the following fields: New window URL,
Window width, and Window height.
3. Enter the URL to the TIBCO iProcess Workspace in the New window URL
field. You can also specify new width and height values, if desired.
The URL must be in the form:
http://Host:Port/iProcessClientDir/iProcessClient.html
where:
— Host is the name of the machine hosting the iProcess Workspace (Browser).
— Port is the port number used by the WAS that is hosting the iProcess
Workspace (Browser) to communicate with web applications.
— iProcessClientDir is the directory on Host in which the iProcess Workspace
(Browser) is installed. This defaults to TIBCOiPClnt.
4. Click the Open new window button.
Since the iProcess Workspace (Browser) has been configured to use the single
authentication feature (see step 8 on page 167), it will bypass the normal
iProcess Workspace (Browser) Login screen and send a login request to the
Action Processor.
The filter (AuthenticateFilter), which sits between the iProcess Workspace
(Browser) and the Action Processor (see the illustration on page 163), wraps
each requests in an AuthenticateRequestWrapper object. The wrapper
examines each request for a single-authenticate login request. When it finds
one, it uses the SampleAuthenticator, which implements the Authenticator
interface, calling the authenticate method, and passing the request object. The
authenticate method obtains the login data hash map from the session, and
queries the hash map to populate its login properties. The
AuthenticateRequestWrapper then uses the SampleAuthenticator properties
to construct a login request that is passed to the Action Processor.
If the previously entered credentials are valid, the iProcess Workspace
(Browser) is displayed.
The .NET single authentication feature is used if you are using the .NET Action
Processor. It allows users to go directly to the iProcess Workspace (Browser) from
another web application in which they have already been authenticated.
The .NET single authentication feature implements an HTTP module that is
inserted into the HTTP request pipeline to act as a mediator between the
customer’s web application authentication methods and the iProcess Workspace
(Browser) and .NET Action Processor.
where APInstallDir in the installation directory of the .NET Action Processor, which
defaults to TIBCOActProc.
The following shows the elements that must be added to web.config:
<configuration>
<appSettings>
<add key=”AuthenticatorAssemblyPath”
value=”D:\\SingleAuthenticationSample.dll” />
<add key=”AuthenticatorAssemblyName”
value=”SingleAuthenticationSample” />
<add key=”AuthenticatorAssemblyImpl”
value=”SingleAuthenticationSample.SampleAuthenticator” />
<add key=”AuthenticatorLogFile”
value=”C:\\temp\\SingleAuthentication.log” />
</appSettings>
<system.web
<httpModules>
<add name=”LoginAuthenticator>
type=”SingleAuthentication.AuthenticateFilter, SingleAuthentication” /
</httpModules>
</system.web
</configuration>
where:
• AuthenticatorAssemblyPath is the absolute path to the customer assembly.
• AuthenticatorAssemblyName is the name of the assembly.
• AuthenticatorAssemblyImpl is the name of the IAuthenticator
implementation.
• AuthenticatorLogFile is the absolute path to the log file.
Authenticator Plug-in
The customer must create a plug-in that implements the
SingleAuthentication.IAuthenticator interface, as follows:
using Sysyem;
using System.Web;
namespace SingleAuthentication {
The IAuthenticator interface also provides getter methods for the information
required for a successful login to the iProcess Workspace (Browser). The HTTP
module uses these values to construct a Login action request to the .NET Action
Processor.
This informs the iProcess Workspace (Browser) that an external application will
be providing the login authentication credentials.
The useSingle parameter can also be passed in the URL, if desired. The following
example URL is telling the client that an outside source is supplying the login
credentials:
http://somedirectory/iProcessClient.html?useSingle=true
The failureUrl attribute is used to specify a URL to which the user is redirected if
the login fails.
— If there is a value specified in the failureUrl attribute, and the login fails, an
alert dialog is displayed containing the message “User authentication
could not be confirmed. You will be redirected to an appropriate login
page.” The browser is then redirected to the specified URL.
— If the value of failureUrl is empty, and the login fails, an alert dialog is
displayed showing the message “User authentication could not be
confirmed. You must successfully log in before using this site."
• customerApplication.htm
• iProcessClient.htm
The SingleAuthenticationLoginSample.aspx page provides the user the
ability to define login particulars. Once the data has been filled in, the user will
select the Login button. This action sends login data to the event method, which
stores it in the session using a C# hash table. The event method then launches
customerApplication.htm.
The customerApplication.htm page provides the user the ability to specify the
URL from which to launch the iProcess Workspace (Browser) application, as well
as the window width and window height. The customerApplication.htm page
also contains an Open new window button, which launches the application
specified in the URL field in a new browser window using the specified width
and height settings.
Since the iProcess Workspace (Browser) application has been configured for
single authentication, it bypasses the client’s login window, and sends a single
authentication request to the Action Processor. The AuthenticateFilter is inserted
into the Action Processor request pipeline, and it examines each request looking
for the single authentication request. When it finds a single authentication
request, it uses the sample object, SampleAuthenticator, which implements the
IAuthenticator interface, calling the Authenticate method and passing the
HttpContext object. The Authenticate method obtains the login data hash table
from the session and queries the hash table to populate it with the login
properties. The AuthenticateFilter then uses the SampleAuthenticator to
construct a login request that is passed to the Action Processor.
where:
— Host is the name of the machine hosting the Action Processor.
— Port is the port number used by IIS to communicate with web applications.
— APDir is the directory on Host in which the Action Processor is installed.
This defaults to TIBCOActProc.
This presents a dialog on which you can enter login credentials. This
represents the outside source from which login credentials are provided.
2. Enter a user name and password, as well as the information about the iProcess
Objects Server to log into, then click the Submit button.
The customerApplication.htm page is opened. This page contains the
following fields: New window URL, Window width, and Window height.
The New window URL field will be prefilled with “iProcessClient.htm”. You
can specify different width and height values, if desired.
3. Click the Open new window button.
If the login particulars you entered in step 2 are correct, the iProcess
Workspace (Browser) will start without displaying its Login screen.
Chapter 9 Localization
This chapter describes how to add a language resource file to the iProcess
Workspace (Browser) to display the application in the desired language.
Topics
Localizing the TIBCO iProcess Workspace (Browser) involves the following steps:
• Create a new localized language resource file. The resource file contains a
collection of application text strings that have been translated to a specific
language and may be localized for language variations used by individual
countries.
• Configure the new localized language in the iProcess Workspace (Browser).
• Modify an existing, or create a new, General Interface system locale file. These
files contain localized resources utilized by the General Interface framework.
• Translate user access profile descriptions.
• Set the new default language for the iProcess Workspace (Browser).
• Create a new folder to hold localized help files.
These steps are described in detail in the following subsections, using Spanish as
an example of the new language being added to the iProcess Workspace
(Browser).
Note that each localized language is represented by a two-letter code, in the
format:
— ll
where ll is a lowercase, two-letter ISO 639 language code. For a list of
language codes, visit the following web site:
http://www.loc.gov/standards/iso639-2/langhome.html
Each country is represented by a two-letter code, in the format:
— CC
where CC is an uppercase, two-letter ISO 3166 country code. For a list of
country codes, visit the following web site:
http://www.iso.ch/iso/en/prods-services/iso3166ma/02iso-3166-code-lists
/index.html
A locale key is a string representation of a locale that includes a language and a
country code in the following format:
— ll_CC
4. Copy all record elements that are direct children of the <locale> element in
locale.xml.
Note - Only copy children of the <locale> elements that do not have a key
attribute (e.g., <locale key = en_AU>).
5. Paste all copied record elements into the newly created file as direct children
of the <locale key=”es”> element.
6. Translate the value of every jsxtext attribute in the newly created file to
language-specific values.
Note - Any record elements that are deleted from the new language resource
file will cause the iProcess Workspace (Browser) to “fallback” to the record
that is defined in the default (English) locale file.
7. Optionally, localize the new language resource for specific countries. The
purpose of localizing for specific countries is to provide a mechanism for
overriding default language text values (translated in Step 6) with text values
that are specific for a country and that differ from the default (type b above).
For each country-specific locale, create a <locale> element (within the root
<data> element) and specify the locale key as the value of the key attribute.
Insert record elements into each new <locale> element, that are to “override”
default language records, with matching jsxid attribute values.
In the example above, the default Spanish language text of “Abierto” will be
replaced with country-specific values when either the Spanish (Spain) or
Spanish (Mexico) locales have been selected by the user as the language for
the iProcess Workspace (Browser).
Any records not explicitly overridden in country-specific locales will
“fallback” to the default language definition (e.g., “Cierre” in the example
above).
8. Save the newly created locale resource file as follows:
ClientInstallDir\JSXAPPS\ipc\locale\locale.ll.xml
where ll in the filename is the language code , and CC is the country code (e.g.,
locale.es.xml - for Spanish; locale.es_MX.xml - for a Mexico-only
translation) and ClientInstallDir is the path to the directory in which the
iProcess Workspace (Browser) is installed.
The language resource files for these locales are stored at the following path:
ClientInstallDir\JSX\locale\
where ClientInstallDir is the path to the directory in which the iProcess Workspace
(Browser) is installed. For example:
As with the iProcess Workspace (Browser), the default GI language resource file is
locale.xml (English). If the locale resource files already defined by General
Interface do not support the desired localization being created for the iProcess
Workspace (Browser), a new GI system locale file must be created using the
following steps:
1. Create a new localized GI system language file using the same instructions as
in Create a New Localized Language Resource File on page 177 of this
document, substituting ClientInstallDir\JSX\locale\ as the file path.
2. Perform Step 1 of the section, Configure the New Localized Language in the
iProcess Workspace (Browser) on page 179 of this document, substituting
ClientInstallDir\JSX\locale\ as the file path.
If General Interface already provides a locale resource file for the desired
localization, perform the following steps to add text resources, utilized by the
iProcess Workspace, into the locale file:
1. Open the XML file corresponding to the language of the new localization (e.g.,
ClientInstallDir\JSX\locale\locale.es.xml) and open the default GI
system locale file: ClientInstallDir\JSX\locale\locale.xml.
2. Copy the following record elements from locale.xml into the locale file of
the new localization (under the <locale> element whose key attribute value
matches the locale key of the new localization):
In the example above, “Access Level: Admin” is defined as the user access profile
description for Admin-level users.
To localize user access profile descriptions, locate the <Profile> elements in the
ClientInstallDir\JSXAPPS\ipc\userAccessProfiles.xml file (where
ClientInstallDir is the path to the directory in which the iProcess Workspace
(Browser) is installed), and change the description attributes to the desired
language.
Set the New Default Language for the iProcess Workspace (Browser)
Set the new default language using one of the following methods:
• Modify the config.xml file to specify the default localeKey, as follows:
• Or, specify the language on the Options dialog in the application. For
information about setting options in the application, see the TIBCO iProcess
Workspace (Browser) User's Guide.
Topics
Overview
The TIBCO iProcess Workspace (Browser) renders the standard iProcess Modeler
forms as HTML with scripting. This can be customized with additional HTML
and scripting code to alter the appearance and augment the functionality
provided by the standard form.
Customizations can be done using two methods:
• Embedding - Additional HTML can be embedded directly into the iProcess
Modeler Form definition so that it is included when the browser form is
dynamically generated.
— The customizations are stored in the form definitions. Exporting and
importing the procedure maintains the customizations.
— A smaller, simpler set of scripting functions are used to access work item
data.
— The iProcess Modeler Form definition will not be suitable for display in the
rich client versions of the iProcess Workspace (Browser), where the HTML
tags and scripting code will be visible as part of the form.
— Each type of marking (required marking, optional marking, display field,
and embedded field) has a consistent, standard appearance. You can
customize the appearance of each type of control, but not individual
markings. You can, however, create your HTML controls, then set and get
work item / case values.
— Standard Undo, Keep, and Release buttons always appear at the bottom of
the form.
• File Caching - The HTML that is generated for the iProcess Modeler Form can
be altered and saved to a disk cache where it will be used instead of
dynamically generated HTML.
— The customizations are stored in files on the web server and will not
automatically follow the iProcess Modeler Form definition through export
/ import, so backups will need to be maintained separately.
— Customizations can be saved for use with a specific minor version of the
procedure, a specific major version, or for all versions. So when the
procedure is changed, new cache files may need to be created, copied, or
modified so that the appropriate customizations are available for use with
a modified procedure definition, or for work items not migrated to the new
version of the procedure.
— The iProcess Modeler Form definition can be designed to work well in the
other rich client versions of the iProcess Workspace (Browser), while the
customizations are used only for the iProcess Workspace (Browser).
— The appearance and functionality of the individual marking control can be
customized.
— The Undo, Keep, and Release buttons can be modified or moved. They can
also be removed and replaced with other controls that would trigger the
actions through scripting.
If you will only be displaying forms in the iProcess Workspace (Browser), and
your customization needs are not overly complex, you might choose to embed the
HTML into the form definition. If you need to be able to use both the rich client
and browser versions of the iProcess Workspace (Browser), or apply more
extensive customizations, you might choose file-cached customizations.
Also, you do not have to handle all procedures, steps, and versions of steps using
the same method. You can use a mixture of standard dynamically generated
HTML, embedded HTML, and file-cached HTML.
These methods of customization are described in more detail in the following
sections.
Embedding HTML
When embedding HTML directly into the iProcess Modeler Form definition, any
valid HTML can be included, with a few limitations and considerations, as
described in the following subsections.
Disabling Pre-Formatting
Pre-formatting could interfere with the appearance of some types of HTML you
embed. If it does, the pre-formatting can be disabled by including the HTML
comment “<!-- DISABLE PRE -->” anywhere in the form definition. When that
comment is detected, the HTML <pre> tag will not be placed around the HTML
for the form. If there are some isolated sections of your form that still need to be
pre-formatted, <pre> tags can be added where needed in the form definition.
Including Scripts
Scripting can also be included in the form. As an example, to disable the context
menu for the page, you could include the following block of text anywhere on the
form.
<script language="javascript">
document.oncontextmenu = function (){return false;}
</script>
You’ll see the “SPD” acronym used in places. This is a carryover from the
previously used “Staffware Process Definer” name, which is now called the
“iProcess Modeler”.
CHECKBOX
The CHECKBOX example uses check boxes to modify field data.
• The form includes a hidden marking for each of the fields that will be edited
with a check box.
• An input control of the type “checkbox” is included for each field. The onclick
event of the check box calls the function spdSetFieldValue() with the
appropriate value for the current checked state of the control.
• A notification function is defined and is registered with the spdform.js code
using the function spdSetFieldNotificationFunction().
• Any time the field value is changed by other controls or through scripting
code, the notification function is called, which will set the state of the check
boxes to match the data. This includes a call to the function when the form is
initialized so the check boxes will display the correct information when the
form is first loaded.
RADIOBTN
The RADIOBTN example uses radio buttons to modify field data. The setup of a
set of radio buttons is very similar to the check box example, except that each field
requires multiple input controls, one for each radio button.
SCRIPT
The SCRIPT example lets the user enter a URL on the initial step. The form for the
second step shows the URL as an embedded field. The web page for the URL is
displayed on the form inside an IFRAME. A button will let the user alter the URL,
which will both change the IFRAME to the new page and set the new value for
the URL field.
TABFIELD
The TABFIELD example creates a set of tabs using HTML <span> elements.
Clicking on the tabs will change the value of a hidden field, which in turn causes
different conditional sections of the form to be displayed.
TABNOFLD
The TABNOFLD example also creates a set of tabs, but it does not use an actual
field value or rely on conditional sections of the form.
CSSCHGS
The CSSCHGS example shows changing the appearance of the iProcess Modeler
Form through a <style> tag embedded in the form definition.
File Caching
You can now load the saved page directly into your browser from the work
directory. Everything should work as if you had just loaded the page from the
iProcess Workspace (Browser), except that the Undo, Keep, and Release buttons
will not actually communicate with the server. You can use any text or HTML
editor to make modifications and test your changes.
Once you are satisfied with your changes, you can deploy by copying the file to
the appropriate file name in the “htmlcache” subdirectory under the Action
Processor installation directory (the htmlcache directory does not exist by
default; you must create it).
Data XML
This block is XML containing data for the work item / case that is displayed. The
XML itself will not be visible on the page, but is embedded in the page as a source
of information for the standard scripting inside of spdform.js. You should not
write scripting code to directly query this XML because the format is subject to
change in future versions. Only use the spdform.js functions to access the work
item / case data.
After you have made some customizations to a form, you might want to try the
form with data for a different work item. To do this, display a different work item
in the iProcess Workspace (Browser), view the source, copy the Data XML section
from that source, and use it to replace the same section in the copy of the page you
are customizing.
• spdPostInitForm()
Near the end of the HTML that is dynamically generated for the iProcess Modeler
Form is a block of script code that initializes the form. This should be left at the
end since many of the function calls may reference text boxes, select lists, or other
controls defined earlier in the form. The code begins with the spdInitForm()
function and ends with the spdPostInitForm() function. The code in between
performs actions such as populating selection lists, initializing markings, and
defining a function that updates the information on the form after a field is
changed.
The spdInitForm() function sets up some hidden form elements that will be later
used when submitting the form to undo, keep or release the work item.
When a marking has validation items, it will be rendered as an HTML <select>
element. Individual selection items that are part of the form definition will appear
as <option> elements under that. Items retrieved from lists maintained on the
server, however, must be added through code. The spdAppendList() function
retrieves the list values from the data XML block and adds them as <option>
elements under the <select> element.
All markings are converted into HTML elements. In addition to <select> lists,
these might be text boxes, hidden input areas, spans, or buttons. Calls to the
spdInitMarking() function links up these controls to the appropriate fields and
specifies how the data is formatted and whether it is required. When this function
gets called during form initialization, the initial field value is retrieved from the
data XML and placed into the HTML element that is defined.
Next, the spdFormUpdate() function must be defined. This function will be called
whenever a field value changes. If any of the <option> elements for a <select> list
are iProcess expressions (either a field name or a simple supported expression),
there will be a call to the spdCalculateOptionValue() function to update the
value for that <option> element.
If the form contains any conditional sections, there will be calls to the
spdConditionalBlock() function to display or hide the section on the form.
Finally, the spdPostInitForm() function will be called. This makes an initial call to
the spdFormUpdate() function and then performs an initial validation of the data
in the form.
These are similar to the functions for accessing field values, but rather than
accessing the fields by name, it accesses them through the markings that have
been set up on the form. When accessed this way, formatting information does
not have to be specified, as that is defined for the marking when it is initialized.
For some dynamically generated controls, the onchange event will contain a call
to the spdSetMarkingValue() function. This will validate the data in the field and
notify any other markings for the same field of the change.
If the marking control is a text box, selection list or button, and it uses one of the
standard class names to indicate it is an optional or required field, the colors of
the text and background indicates the status of the data., as follows:
• Valid data - black on white
• Invalid data - white on bright red
• Required fields that are empty - dark red background
• Optional fields that are empty - dark blue background
If a custom notification is set up for the field, it is called. Also, the
spdFormUpdate() function is called so that calculated validation items and
conditional sections of the form can be properly updated.
Also, the onkeypress event for text boxes calls the spdSetMarkingValue()
function, but will pass the optional parameter indicating that actions should only
be performed if the last key pressed was the Enter key.
During form validation, the Keep and Release buttons will be enabled or
disabled as appropriate, and their appearance will be altered to indicate their
enabled state: the Keep button is disabled if any fields contain invalid data, and
the Release button is disabled if there is invalid data or an empty required field.
To override this default behavior, you can change the id attribute for the buttons
and set up a validation notification function to trigger your own code.
Other Functions
• spdEditMemo(markingControlId, isReadOnly)
• spdShowCalendar(markingControlId, calendarLinkControl)
• spdShowMarkingHelp(markingControlId)
The spdEditMemo() function opens a separate dialog to edit or display a memo
field. The memo will be editable unless you specify true for the optional second
parameter.
The spdShowCalendar() function displays a calendar in the page. The
calendarLinkControl parameter is required, and it should be set to an object that
appears on the form. The calendar selection interface will be displayed next to the
control specified. In the dynamically generated HTML, markings for date fields
are followed by an <a> tag containing a small calendar selection graphic. This <a>
tag is passed in as the calendar line control so the calendar appears to the right of
that.
The spdShowMarkingHelp() function displays the help message defined for the
marking in an alert box. The dynamically generated form only includes a link to
display help if help text exists for that marking.
A name attribute is assigned to each control, but is not actively used. The default
name that is dynamically generated is the text “MARKING$”, plus the field
name.
Selection Lists
Selection lists are implemented as an HTML <select> element. These are used for
required and optional markings that have validations items.
The class attribute is typically set to SPD_MARKING_REQ for required fields and
SPD_MARKING_OPT for optional. As with text boxes, the appearance of the
control is automatically changed to indicate the validity of the data if one of these
standard class names is used.
The onchange event will call the spdSetMarkingValue() function so that changes
made to the selection will be applied to the work item data.
Embedded Markings
Embedded markings are implemented as an HTML <span> element.
Memo Markings
Memo markings are displayed as buttons, i.e., HTML <input> elements with a
type attribute of “button”.
The class attribute sets the general appearance. Required memo markings will
typically have a class of SPD_MEMO_BUTTON_REQ, optional memo markings
will be SPD_ MEMO_BUTTON_OPT, and display memo markings will be SPD_
MEMO_BUTTON_READONLY.
The appearance of the buttons will change based on the data for the memo field
when the standard class names are used, similar to text boxes and selection lists.
The value attribute for a button is, of course, used for the button text rather than
data.
The onclick event for the Memo button calls the spdEditMemo() function, which
displays a separate dialog window with the memo text. For read-only Memo
buttons, an extra parameter is passed to this function to disable editing.
Calculated Markings
Calculated markings are rendered identically to display markings. They are
shown as read-only text boxes.
Note that calculations are only performed when the work item is locked at the
server and when the work item is kept or released at the server. If calculations
need to occur in the browser, they will need to be implemented in custom
scripting code.
Hidden Markings
Hidden markings are rendered as an HTML <input> element with the type
“hidden” and simply store a copy of the current data for the marking field.
Calendar Link
Text boxes for date fields will typically be followed by a link used to display a
calendar for selecting a date.
In the dynamically generated HTML, this will be an HTML <a> tag with an href
attribute set to “#” and an onclick event that calls the spdShowCalendar()
function. Inside the link is a <span> element with a class attribute of
“SPD_CALENDAR” that sets a background image for the span, which is a
calendar selection icon.
This link could be replaced with any HTML for calling the spdShowCalendar()
function.
Help Link
Text boxes that have associated help text will typically be followed by a link for
displaying the help text.
In the dynamically generated HTML, this will be an HTML <a> tag with an href
attribute set to “#” and an onclick event that calls the spdShowMarkingHelp()
function. Inside the link is a <span> element with a class attribute of “SPD_
HELP” that sets a background image for the span, which is a help icon.
This link could be replaced with any HTML for calling the
spdShowMarkingHelp() function.
You may wish to reference images, JS files, CSS files, or other external files in your
custom HTML code. If you will be using a relative path to access these files, keep
in mind that all paths are relative to the Action Processor installation directory.
Although the file cache for your modified HTML is the subdirectory
“htmlcache”, underneath the Action Processor directory, this is not the base
directory for pages generated using those files as a source for the iProcess
Modeler Form or form header and footer sections for the page.
Therefore, if you store images in the directory “htmlcache\images”, you will
need to use “htmlcache\images” as the relative path to those files in either
embedded or file-cached HTML.
When using a working directory to create and test your file-cached HTML, you
will need to create a copy of any files referenced by relative path to an appropriate
directory under your working directory.
Topics
where:
— workitemtag identifies the work item. This is required.
— nodename, computername, ipaddress, tcpport, and isdirector identify the
TIBCO iProcess Objects Server. Either these parameters can be provided to
identify the server, or you can provide the nodealias (see below).
— nodealias identifies the TIBCO iProcess Objects Server. Either this
parameter can be provided to identify the server, or you can provide the
five parameters listed above (nodename, computername, etc.). If a node
alias name is specified, code inside of the LinkForm.html must set the
other five values to identify the iProcess Objects Server.
— username and password provide login credentials. These are optional. If
both are provided, the work item will immediately be displayed. If either
of these is omitted, a login section of the page will be displayed allowing
the user to enter the information. If there is a problem logging in with the
information provided, a message is displayed and it will return to the login
interface. (Note that all parameters are passed to the LinkForm.html file
as part of the URL, so specifying the password in the password parameter
is not advised.)
The URL should be launched using the javascript window.open(...) command, so
the work item will appear in a separate window without browser menus or
toolbars. The following is an example of this command:
window.open('http://myserver/actionprocessor/linkform.html?workite
mtag=myserver|TESTPROC|swadmin|R|4475|19048|myserver|FORM1|0|7@nod
ealias=myserver@username=swadmin', '_blank',
'resizable=1,scrollbars=1');
The following is an example of HTML for a hyperlink displaying the work item:
Index
A baseUrl attribute 18
Button
Access settings 35
profiles 3
Action Processor
configuration settings 60
URL 18 C
version number 67
Activate Case(s) tool 7 Callout interface 40
Activate, in access profile 7 calloutCaseFilter method 49
Add Entry tool 9 calloutCaseFilterColumns method 50
AddHistoryEntry, in access profile 9 calloutCaseSort method 53
Adding custom menu items / toolbar buttons 36 calloutCaseSortColumns method 53
Admin profile 4 calloutColumns method 54
allowDirectLogin attribute 157 calloutInitialCaseFilter method 49
apAction.xsd 66 calloutInitialCaseSort method 52
apConfig.xml file 60, 130, 131 calloutInitialWorkItemFilter method 46
APLog.logX log file 61 calloutInitialWorkItemSort method 50
APLogXXX.log log file 61 calloutSelectColumns method 56
Application calloutWorkItemFilter method 47
log 12, 21 calloutWorkItemFilterColumns method 47
Monitor 22 calloutWorkItemSort method 51
ApplicationLog, in access profile 12 calloutWorkItemSortColumns method 52
Array fields, requesting values from 114 Caption, customizing 25
ASP Forms 64 captionCases attribute 29
aspx extension 19 captionWorkItems attribute 29
Authenticate/authenticate method 164, 170 Case, in access profile 7
Authentication, single 161 CaseStart, in access profile 6
Authenticator interface 164 ChangePwdExpired, in access profile 12
Auto-Repeat Open Work Item tool 11 ChangePwdOption, in access profile 12
Character encoding 134
CHECKBOX example 192
class attribute 76
B Clearing XML cache data 82
Close
Background colors 35 Case(s) tool 7
Base class 71 Close, in access profile 7
properties 78 closeForm method 82
BaseUrl 156 Color settings 35
L
language N
option 127
Language, setting 175 Name element 17, 65
layout element 32 nodeName attribute 76
LinkForm example 214 Nodes, server 15
LoadFactor element 65
LoadingChart, in access profile 6, 10
localeKey attribute 29
localhost 64 O
Localization 175
localToJSDate method 121 onBeforeUnload method 105
localToXml method 121 Open
LockItems request 91, 103 Case(s) tool 9
lockWorkItem method 103 First Available Work Item tool 11
Log settings 61 Next Available Work Item tool 11
LogArchiveCount parameter 61 Selected Work Item(s) tool 11
LogFile parameter 61 Open, in access profile 9, 11
Login Options, user 28, 127
direct 156 outstanding element 34
screen 15, 156, 162 Outstanding tab 9
single authentication 161 Outstanding, in access profile 9
Login record 24, 157
LogLevel parameter 61
Logs, iProcess Client 20
P
Participation
tool 10
Participation, in access profile 10
W
WARN log level 61
WAS 19, 167, 168
Web Application Server 19, 167, 168
Web.config file 132
web.config file 169
web.xml file 130, 131, 163
WebLogic
session timeout 131
Window layout 127
Work Queue Loading Chart tool 10
WorkItem, in access profile 11
WorkQueue, in access profile 10
X
XML
cache data, clearing 82
date conversions 116
response compression 62
validation 66
xmlToJSDate method 122
xmlToLocal method 122
XSD 66
XSL transform 111