New In this Release
Concepts
BPM Concepts
Important Information
TIBCO Documentation and Support Services
Introduction to TIBCO ActiveMatrix BPM
TIBCO ActiveMatrix BPM Applications
TIBCO Business Studio
TIBCO ActiveMatrix BPM
TIBCO ActiveMatrix Administrator
TIBCO ActiveMatrix BPM Architecture
TIBCO ActiveMatrix Enterprise
TIBCO ActiveMatrix Environments
TIBCO ActiveMatrix Hosts
TIBCO ActiveMatrix Nodes
TIBCO ActiveMatrix BPM Logical Nodes and Services
High Availability and Fault Tolerance - Clustered Operation
Specialization and Scalability - Logical Node Distribution
Developer Server
Shared Objects
Monitoring and Managing Distributed Applications and Operating Systems
Multiple TIBCO ActiveMatrix BPM Systems in an Enterprise
TIBCO ActiveMatrix BPM Web Service APIs
Client Application Development
TIBCO Mobilespace
Processes as Services
Workflow Patterns Support
Model Driven Architecture and Development
Role-Based User Interfaces
A Single Design Time Environment
Flexible Runtime Clients
System Calendars
Base and Overlay Calendars
Time Zones
Deadlines and Localization
Exclusions in Overlay Calendars
Calendar References
Work Views
Work View Permissions
Creating a Work View for an Organizational Entity
Process Management
Standards-Based Process Notations
Process Design - Business Process Model and Notation (BPMN)
Process Interchange - XML Process Definition Language (XPDL)
Process Deployment and Execution - Business Process Execution Language (BPEL)
Data Type Support
Using Processes as Services
Correlation Data
Workflow Process and Data Pattern Support
Pageflow Processes
Business Services
Example 1 - Starting a Business Process
Example 2 - Updating a Database
Process Instance Migration
Example of Process Instance Migration
Organization Management
Modeling the Workforce
Organization Model
Organizations Organization Units and Positions
Groups
Resources (Users)
Privileges
Capabilities
Creating the Organization Model
Use of LDAP and Dynamic Organization Models
Organization Model Partitioning
Organization Model Versioning
Example - Phase 1 Deploying an Initial Organization Model
Example - Phase 2 Making an Additive Update to the Model
Example - Phase 3 Making a Destructive Update to the Model
Example - Phase 4 Extending the Organization Model
Example - Phase 4 An Alternative Implementation
Work Management
Distributing Work to Users
Offering and Allocating Work
Distribution Strategies and Offer Sets
Resource Query Language
Participants
Dynamic Organization Participants
Push and Pull Distribution Models
Presenting Work to Users
TIBCO ActiveMatrix BPM Client Applications
Work Lists
Work Items
Forms and Presentation Channels - Separating Presentation from Content
Pageflows
Case Management
Creating Case Management Applications in TIBCO Business Studio
Case Data Model
Interacting with Cases in Business Processes
Case Actions
Case Management in Application Development
Components and Component Services
Case Management APIs
Case Data Store
Case Management in Openspace
Custom Applications
Modeling and Implementing Applications
Deployment of Project Artifacts
Administration of TIBCO ActiveMatrix BPM
Platform Administration
Application Management
Organization Model and Resource Management
The tibco-admin User
System Calendar Management
Logging and Auditing
Managed Objects and Events
Measures
Logging
Logging Levels
Workspace Logging
Auditing
Correlation and Sequencing of Audit Data
Workspace and Openspace Audit Trail
Publishing Audit Data to a Java Message Service (JMS) Topic
Security Features Provided by TIBCO ActiveMatrix BPM
Authentication
Privilege-Based Authorization
System Actions
Scope of System Actions
Example of using System Actions to Control Users’ Access to System Functions
System Actions and Organization Model Versions
Workflow Patterns Reference
Workflow Resource Patterns Support
Workflow Process Patterns Support
Workflow Data Patterns Support
TIBCO Business Studio™ Concepts
Important Information
TIBCO Documentation and Support Services
TIBCO Business Studio Usage
TIBCO Business Studio Welcome Page
Process Design - Business Process Model and Notation (BPMN)
Process Modeling Methodology
Capabilities and Perspectives
Live Development Perspective
Source Control
Process Modeling Concepts
Projects Packages and Processes
Projects
Work List Facade
Work Item Attributes
Project Lifecycle
Packages
Processes
Pageflow Process Modeling
Service Process Modeling
Process and Service Process Interfaces
Start Events
Intermediate Events
Process Errors
Process Components
Process Migration
Project References
Assets
Special Folders
Special Folders and Asset Types
Process Fragments
Exports from TIBCO Business Studio
Activities
Types of Tasks
Activity Markers
Presentation Channels
Sub-Processes
Refactoring Sub-Processes
Dynamic Sub-Processes
Synchronous and Asynchronous Sub-Process Invocations
Transactions
Participants
Participants from the Organization Model
Dynamic Organization Participants
Resource Patterns and Work Distribution
Resources
Distribution Strategy
Re-offer Work Item Strategy
Piling
Separation of Duties
Retain Familiar
Chained Execution
Multiple Parallel Paths in a Chaining Group
Process Navigation
Gadgets
Swimlanes
Associations
Data Objects
Text Annotations
Groups
Flows
Loops
Gateways
Order of Flow Evaluation
Exclusive (XOR)
Inclusive (OR)
Complex
Parallel (AND)
Events
Start Events
Intermediate Events
End Events
Throw and Catch Events
Triggers and Results
Palette Summary
Event Handlers
Signals
Data Fields and Parameters
Declared Types
Correlation Data
Destinations and Validation
Organization Model Concepts
The Organization Model as an Analysis Tool
Organization Model Deployment
The Organization Model at Runtime
Elements of Organization Models
Benefits of Organization Models
Organization Modeler Diagram Editors
Organizations
Dynamic Organizations
Large Organizations with Branch Networks
Organization Units
Dynamic Organization Units
Hierarchies and Associations
Position
Groups
Capabilities and Privileges
Locations
Resources
Resources and BPM
Queries
System Actions
System Actions Reference
Data Types
Schemas
Organization Modeler Default Schema
Attributes
Members
Multiplicity
Business Object Modeler Concepts
Business Object Models
Unified Modeling Language (UML)
UML Profiles and Stereotypes
Concept Models
Diagram Nodes
BOM Packages
BOM Classes
Primitive Types
Attributes
Multiplicity of Attributes
To Set Restrictions on Primitive Types and Attributes
Operations
Enumerations
Enumeration Literals
Relationships
Generalizations
Associations
Composition
Aggregation
Association Class
Modeling and Simulation
Modeling User's Guide
Important Information
TIBCO Documentation and Support Services
Introduction to TIBCO Business Studio
Creating a Project Package and Process
Process Creation
Gadgets for an Object
Adding Objects Using the Palette
Using an Object’s Gadget to Connect Objects
Using Connection Tools on the Palette to Connect Objects
Selecting Objects
Tools for Finding Objects in a Diagram
Customizing Palette Favorites
Projects Packages and Processes
Migration of Projects Created in Previous Versions
Creating a Package
Pre-Compiling Projects
Setting Your BPM Project to Pre-Compilation
Disabling Pre-Compilation Your BPM Project
Copying a Package
Creating a Business Process
Creating a Pageflow Process
Creating a Case Action Process
Generating Case Actions From Case Classes
Creating a Service Process
Refactoring Service Processes and Service Process Interfaces
Creating a Work List Facade
Setting the Display Label for Work Item Attributes
Mapping Process Data to Work Item Attributes
Creating a Global Signal Definition Project
Creating Payload Data for Global Signals
Deleting a Process
Using the Dependency Viewer
Finding Cyclic Dependencies
Creating Extended Attributes
Project Reference Creation
Creating References in the Project Properties
Creating Project References in a Selection Dialog
Assets
Quality Process Business Assets
Using Quality Processes in Your Project
Adding Ad-hoc Assets
Enabling and Disabling Special Folders
Changing and Refactoring Project Lifecycle Settings
Changing Project Lifecycle Settings
Refactoring Lifecycle Settings
Process Fragments
Migrating Fragments from Previous Versions
Using the Predefined Fragments
Creating Custom Fragments
Importing Custom Fragments
Source Control
Using Subversion with TIBCO Business Studio
Creating a Project from an Existing Project in Source Control
Browsing SVN Repositories
Deletion of Projects from SVN Repositories
Design Considerations for Process Migration
Migration Point Viewing
Migration Point Restrictions
Comparison of Different Versions of a Process Package
Performing a Two-way Compare
Use of Process Package Comparison Editor with Two-way Compare
Performing a Three-way Compare
Use of Process Package Comparison Editor with Three-way Compare
Documentation
Creating Documentation From Within TIBCO Business Studio
Creating Documentation from the Command Line
Generating Documentation On Demand
Viewing Documentation
Emailing Processes
Creating your Email template files
Applying the Email template to a Project
Creating an Alternative Email Template
Import and Export of Projects
Importing Existing Studio Projects into Workspace
Importing Existing Modelled Application Archive (MAA) Files into Workspace
Importing Archive Files into Workspace
Importing Nimbus Process Diagrams
Equivalences between Nimbus Process Diagrams and TIBCO Business Studio BPMN Processes
Exporting TIBCO Business Studio Projects to Archive File
Exporting Projects to a File System
Exporting Projects to Modelled Application Archive (MAA)
Exporting Projects to a Work Data Model
Activities
Creating References
Creating a Reference with the Reference Task Gadget
Creating a Reference in the Properties View
Using Request Response Operation with Send and Receive Tasks
Creating Scripts
User Tasks and Pageflow Processes
Selecting a Pageflow Process
Creating a Pageflow Process From a User Task
Synchronizing Parameters With a Pageflow Process
Mandatory Parameters and Pageflow Processes
Resource Patterns and Work Distribution
Specifying Separation of Duties
Specifying tasks that should be considered separate using the Resources tab
Specifying tasks that should be considered separate using the Task Groups Tab
Specifying Tasks That Should be Part of a Retain Familiar Group
Specifing that tasks should be part of a Retain Familiar group using the Resources tab
Specifing that tasks should be part of a Retain Familiar group using the Task Groups Tab
Chained Execution- Multiple Parallel Paths in a Chaining Group
Controlling Flow in a Process
Creating a Standard Loop
Creating a Multi-Instance Loop
Adding Additional Instances to a Multi-instance Loop While the Task is Still in Progress
Configuring a Task as Automatic Ad-Hoc
Configuring a Task as Manual Ad-Hoc
Refactoring Ad-Hoc Activities
Exclusive Event Based Gateway Example
Events
Creating References Between Throw and Catch Events
Timer Event Rescheduling
Configuring Timer Event Scripts
Catch Signal Events
Throw and Catch Signal Events
Throw and Catch Error Events
Configuring Error Events
Fixing Invalid Error Events
Error Data Mapping
Compensation Events Configuration
Message Event Implementation
To Receive a One-Way Request Operation
To Send a One-Way Request Operation
To Receive a Request-Response Operation
Event Handlers
Signal Event Handlers
Using the Cancellation Event Handler
Event Handlers in Pageflows
Message/Global Signal Event Handlers in Business Processes
Migration and Upgrade when using Event Handlers
Process Data
Adding Data Fields or Parameters to a Package or Process
Using the Properties View to Create a New Data Field or Parameter
Using the Wizards to Create a New Data Field or Parameter
Constraints on Field or Parameter Values
Adding Data Fields to an Activity
Creating Correlation Data
Creating Correlation Data Using the Properties View
Creating Correlation Data Using the Wizard
Associating Process Data with Events and Tasks
Using Drag and Drop to Associate a Data Field or Parameter with an Activity
Using the Interface Tab to Associate a Data Field or Parameter with an Activity
Associating Correlation Data with an Event or Task
Specifying Correlate Immediately
Setting Event and Task Visibility (Private and Public)
Using Process Data to Create Tasks
Creating a Participant
Associating Participants with Activities
Using Drag and Drop to associate a participant with an activity
Using Properties View to associate a participant with an activity
Highlighting Participants
Exporting Participants to an Organization Model
Participants to Organization Model Mapping
Using Participants to Create Tasks
Deletion of Data Fields Parameters Participants and Type Declarations
Creating a Dynamic Organization Participant
Auditing Process Data
Enable Auditing of Process Data
Mapping Process Data to be Audited
Sub-Processes
Creating Call Sub-Processes
Creating a Call Sub-Process Activity Call Using Drag and Drop
Creating a call sub-process call using the palette
Call Sub-Process Example
Expanding a Sub-Process
Configuring a Sub-Process
Prioritizing a Scheduled Call Sub-Process
Invoking a Sub-Process Asynchronously
Embedded Sub-Processes
Adding Local Data Fields
Local Data Fields in Loops
Creating a New Embedded Sub-Process
Refactoring Activities into a Sub-Process
Inline Sub-Process Content
Refactoring a Call Sub-Process into an Embedded Sub-Process
Inline Sub-Process in Detail
Data Fields and Mapped Parameters
Sub-Process Data Fields and Unmapped Formal Parameters
Sub-Process Participants And Type Declarations
Event Sub-Processes
Creating Dynamic Sub-Processes
Automatically Passing Different Data To and From Sub-Process Instances
Inputting Different Data To Each Sub-Process Instance
Returning Different Data From Each Sub-Process Instance
Control of the Flow in Dynamic Sub-Processes
Correcting Validation Errors
Setting the Validation Preferences
Configuring the Problems View
Making a Sub-Process Call to a Process Interface
Creating a Call Sub-Process Call using Drag and Drop
Creating a Call Sub-Process Call Process Interface using the Palette
Process Interfaces
Creating a Process Interface
Creating Error Events
Modification of a Process Interface
Creating a Service Process Interface
Error Codes and Process Interfaces
Integration with ARIS Software
Creating Custom Symbols in ARIS Business Designer (Optional)
Using Custom Symbols in TIBCO Business Studio
Preparing to Export from ARIS to XML
Exporting from ARIS to XML
Importing ARIS XML Files into TIBCO Business Studio
Object Mappings — ARIS Software
Extended Attributes
Business Object Modeler Tasks
Creating an Analysis Project with a Business Object Model
Creating a Business Object Model in an Existing Project
Creation of a Model by Import
Importing a Business Object Model from a Database
Importing Existing UML Models into the Business Object Modeler
Importing XML Schema Files
Importing WSDL Files
Business Object Model Editor
Adding Diagram Nodes to a Business Object Model
Adding Packages
Opening a Diagram Editor for a Package
Adding Classes Attributes and Operations
Adding Primitive Types
Connections
Creating a Generalization between Two Classes
Creating an Association between Two Classes
Aggregation and Composition
Adding Text to a Model
Adding a Child Diagram to a Business Object Model
Adding Elements to the Child Diagram
Deleting Elements from the Child Diagram
Concept Models
Migrating Concept Models
Creating an Analysis Project with a Concept Model
Creating a Concept Model in an Existing Project
Adding Diagram Nodes to a Concept Model
Models
Copying Diagram Nodes Between Models
Model Organization Tools
UML Profiles
Applying a UML Profile to a Business Object Model
Applying Stereotypes to Business Objects
Exporting Business Object Model Documentation
Viewing Business Object Model Documentation
Export of Business Object Models to XML Schema or WSDL Files
Exporting Business Object Models to XML Schema Files
Exporting Business Object Models to WSDL Files
Exporting a Class to XML Schema File
Exporting a Class to WSDL Format
Setting Diagram Preferences
Setting the Validation Preferences
Setting Generation Preferences
Business Object Model Mappings to XML Schema
Import Mappings - XSD to Business Object Model
XSD SimpleType
Basic SimpleType
SimpleType that Extends Another SimpleType
Annotation within SimpleType
XSD Complex Type
ComplexType with Attributes and Sequence of Elements
ComplexType with Element of Type ComplexType
ComplexType with SimpleContent
ComplexType with ComplexContent Extension
ComplexType with ComplexContent Restriction
Anonymous ComplexType
Annotation within ComplexType
ComplexType with Mixed Construct
ComplexContent with Mixed Construct
XSD Global Elements
Simple Element and Attribute Type
Element of Complex Type
Top Level Enumeration Elements
Export Mappings
Primitive Type
Class
Complex Type
Complex Type - Class with Attributes
Enumeration
Package
Relationships
Data Type Mappings
XML Schema to Business Object Model Import Mappings
Business Object Model to XML Schema Export Mappings
Round-trip Export
XSD Export Validation Rules
XSD Import Restrictions
Business Object Model Mappings to WSDL
Worked Example
WSDL Import Restrictions
Export Mappings – Business Object Model to WSDL
Troubleshooting
Application Upgrade Issue
Default Channels are Unavailable
Submenus Selection not Available when you Switch Workspace
Manual Deletion of Presentation Resources Special Folder Problem
Refactoring When Importing from Studio for Analysts into Studio for Designers
Failures in Linux Version 7 when TIBCO Business Studio uses the SWT Internal Browser
Importing Projects
Importing Projects into your Workspace which were Created in a Previous Version of TIBCO Business Studio
Importing Projects from Subversion
Disabling Flow Validation to prevent lockups in the User Interface
Business Data Project Deployment
Command line DAA Generation on HP-UX
What to do if a URL does not open in the default internal browser
HTTP Request/Reply on Correlation
Third-Party Source Control System (MKS) Adding project.pj Files
Locally Imported WSDLs Java Linkage Error
Using -prepare-report Task in Java 1.7/Java 1.8
Organization Model
Organization Model Creation
Creating a Project Containing an Organization Model
Adding an Organization Model in an Existing Project
Creating a Schema
Using Your Own Schema Types
Creation Types in the Schema
Creating a Location Type
Creating an Organization Type
Creating an Organization Unit Type
Creating a Position Type
Creating an Organization Unit Relationship Type
Creating a Resource Type
Organization Modeler Diagram Editors
Adding Objects in Organization Modeler Diagrams
To add Objects in Organization Modeler Diagrams using the Palette
To add Objects in Organization Modeler Diagrams using the Pop-up Icons
To add Objects in Organization Modeler Diagrams using the Context Menu
Adding Objects in Organization Modeler Diagrams using the Project Explorer
Adding Notes and Labels
Tailoring the Appearance of Organization Modeler Diagrams
Creating an Organization Model
Creating an Organization
Creating a Dynamic Organization
Creating an Organization Unit
Creating a Dynamic Organization Unit
Dynamic Organization Identifier Mapping
Creating a Position
Creating a Group
Creating Capabilities
Creating Capability Categories
Creating Privileges
Creating Privilege Categories
Creating a Location
Creating a Resource
Creating Queries
Using a Schema in an Organization Model
Exporting Organization Model Documentation
Viewing Organization Model Documentation
Reference
Project Explorer View
Problems View
Outline View
Fragments View
Process Modeler Properties View
Process Properties
Case Action Properties
Activity Properties
Gateway Properties
Sequence Flow Properties
Event Properties
Lane Properties
Cheat Sheets View
Process Editor
Palette
Alignment Tools
Business Object Modeler Properties View
Package Properties
Class Properties
Attribute Properties
Operation Properties
Primitive Type Properties
Enumeration Properties
Enumeration Literal Properties
Generalization Properties
Association Aggregation Composition Properties
Association Class Properties
Organization Modeler Properties View
Organization Model Properties
Organization Properties
Dynamic Organization Properties
Organization Unit Properties
Dynamic Organization Unit Properties
Hierarchy and Association Properties
Position Properties
Group Properties
Capability Category and Privilege Category Properties
Capability Properties
Privilege Properties
Location Properties
Resource Properties
Organization Query Properties
Properties View for the Organization Schema
Organization Type Properties
Organization Unit Type
Position Type Properties
Location Type Properties
Organization Unit Relationship Type Properties
Resource Type Properties
Human Durable and Consumable Resource Types
Tips and Tricks
Process Editor
Business Object Model Editor
Workbench
Problems View
Simulation User's Guide
Important Information
TIBCO Documentation and Support Services
Getting Started with Simulation
Overview of Simulation
Tutorial 1 Setting Up a Simple Simulation
Creating the Claims Management Process
Adding the Participants
Specifying the Unit Cost of the Participants
Specifying the Duration of the Activities
Associating the Participants with the Activities
Adding the Data Fields
Tutorial 2 - Running a Simulation
Tutorial 3 - Interpreting the Results of Simulation
Tutorial 4 - Changing Simulation Properties
Tutorial 5 - Viewing and Comparing the Results of Simulation
Tutorial 6 - Using Loops in Simulation
Tutorial 7 - Controlling Flow From a Gateway
Tutorial 8 - Using Historical Data for Activity Duration
Reviewing the Import File
Creating the Parameter
Importing the Data
Tutorial 9 - Monitoring SLAs
Concepts and Definitions
Activity-Based Costing
Destination Environment
Scenario
Service Level Agreement (SLA)
Simulation
Simulation Time
Tasks
Simulating Business Processes
Define the As Is Process
Prepare the Simulation
Assign Activity Duration
Add the Participants and Associate them with Activities
Assign Unit Costs to Participants
Add the Data Fields and Associate them with Activities (optional)
Set the Number of Simulation Cases
Set Up Looping Strategies
Run the Simulation of the As Is Process
View the Simulation Progress
Interpret the Results of Simulation
Optimize or Re-Engineer the Process
Using Historical Data for Activity Duration
Controlling Sequence Flow from a Gateway
Monitoring SLAs
Comparing Simulations
Creating and Viewing a Simulation Report
Designing Custom Reports
Obtaining a Data Source
Creating a New Report
Creating the Data Source
Create the Data Set
Creating the Report Parameters
Creating a Table to Display the Data
Importing the Report
Editing the Report
Customizing Simulation Preferences
Reference
Simulation Control View
Simulation Results View
Simulation Report View
Simulation Properties View
Compare Simulation Results View
Case Cost-Time Analysis
Participant Utilization
Simulation Data
BPM Application Development
BPM Implementation
Important Information
TIBCO Documentation and Support Services
Using Projects and Processes
Projects Assets and Project Organization
Distribution of Assets across Multiple Projects
TIBCO Business Studio Workspace Folder
Setting BPM as the Destination Environment
Creating or Obtaining a Project for BPM
Creating a Project Using the BPM Developer Project Wizard
Adding New Assets to an Existing Project
Referencing Other Projects
Deployment of a Project
Using Live Development
Pageflow Processes and Business Services
Create a Pageflow Process
Generate a Business Service
Trigger an Incoming Message Activity from a Business Service
Managing Work Using Organization Models
Using Organization Models in a Process
Creating or Obtaining an Organization Model
Organization Model Entities as Process Participants
Using Capabilities and Privileges in Allocating Work to Process Participants
Using System Actions for Processing Work
Deploying an Organization Model
Mapping Resources to the Organization Model
About Participants
Assigning Participants to a User Task
Using a Performer Data Field or Parameter to Dynamically Define a Participant
Dynamic Organization Identifier Mapping
Using a Participant Expression to Define a Participant
Using Organization Entities in Performer Data Field or Parameter
Defining How Work Will be Assigned to Users
Offering and Allocating Work
Distributing Work Within the Target Pool
Allocating a Work Item to a Member of an Offer Set
Using Resource Patterns to Control How Work is Assigned
Chained Execution
Separation of Duties
Retain Familiar
Piling
Using Forms with User Tasks
Creating a New Form
Creating a New Form for an Existing User Task
Creating a New Form Manually from the Project Explorer
Creating a Free-standing Form
Switching Back to the Default Form
Updating Forms with the Synchronization Wizard
Using Data Fields and Parameters with Process User Tasks
The Mode Property of User Task Parameters
Using Data Fields and Parameters
Data Types for Data Fields and Process Parameters
Using Presentation Channels to Display Tasks to Users
Identifying an Appropriate Presentation Channel
Viewing the Available Presentation Channels
Adding a Channel Type to the Default Channel
Adding a Presentation Channel
Editing Email Attributes
Editing Email Attributes at Workspace Level
Editing Email Attributes at Project Level
Sending an Email Message from a Process
Configuring Service Tasks to Send Email Messages from a Process
Defining an E-Mail Service Type from a Service Task
Setting up Dynamic Data Inputs to an Email Message
Example of Setting up Dynamic Data Inputs to an Email Message
Calling a Database From a Process
Defining and Using a Database Connection Profile
Creating a Database Connection Profile
Creating and Using a Local Copy of the Database Connection Profile
Working Online or Offline To Connect to the Database or to the Local Copy
Using a System Participant to Identify the Target Database
Creating a System Participant and Mapping it to a Target Database
Assigning the System Participant to the Database Service Task
Configuring a Service Task to Call a Database
Creating a SQL Query
Using SQL Query Builder
Changing the SQL Statement
Building a Query - A Simple Example
Testing the SQL Statement
Selecting a Stored Procedure
Manually Entering a Stored Procedure Name
Selecting a Stored Procedure From the Database
Updating a Stored Procedure Used in a Database Task Activity
Mapping Data Between the Process and the Database
Mapping Data Parameters
Mapping an Externally Referenced Class Attribute to a Database Parameter
Automatically Creating a Business Object Model to Store Returned Data
Mapping the Result Set
JDBC Driver Connection Details
Using Web Services
Web Service Definition Language (WSDL) Documents
WSDL Document Requirements
XSD Constructs
Using Service Registries
Importing a WSDL Document Into a Project
Calling a Web Service
How to Call a Web Service
Calling a Service on a Virtualization Binding (Contract First)
Calling a Service on a SOAP Binding (Contract First)
Calling a Service on a Virtualization Binding (Contract Last)
Calling a Service on a SOAP Binding (Contract Last)
Configuring a Task or Event to Call a Web Service
Invoking a One-Way Operation on a web service
Invoking a Request-Response Operation on a web service
Selecting the Web Service Operation to Invoke
Selecting an Operation From a WSDL That Exists in the Workspace
Importing a WSDL and Selecting an Operation from the WSDL
Generating a WSDL and Creating an Operation from your Process Data
Updating a Generated WSDL File
Using a System Participant to Identify the Web Service Endpoint
Configuring Security on an Outgoing Service Call
Defining Input and Output Data
Defining Input and Output Mappings
Creating a Mapping
Points to Note About Mappings
Using A Script to Define a Mapping
Automapping
Catching WSDL Fault Messages on a Request-Response Operation
Using a Catch Intermediate Error Event to Catch a Fault Message
Handling SOAP/JMS Message Timeouts on a Request-Response Operation
Deploying a Process That Calls a Web Service
Exposing a Web Service
Exposing a Service
Exposing a Service (Contract First)
Exposing a Service (Contract Last)
Configuring a Task or Event to Expose a Web Service
Exposing a One-Way Operation
Exposing a Request-Response Operation
Using the Default Generated Web Service Operation
Updating the Default Web Service Operation
Exposing Multiple Default Web Service Operations
Selecting an Alternative Web Service Operation to Expose
Selecting an Operation From a WSDL That Exists in the Workspace
Importing a WSDL and Selecting an Operation
Using a System Participant to Define the Endpoint Provided by the Web Service
Setting a Common Context Root for Web Service Endpoint URIs
Exposing the Web Service Operation as a REST Service
Defining Input and Output Data
Defining Input and Output Mappings
Creating a Mapping
Points to Note About Mappings
Using A Script to Define a Mapping
Throwing WSDL Fault Messages on a Request-Response Operation
Using an End Error Event to Throw a Fault Message
Deploying a Process That Exposes a Web Service
Arbitrary Length Tasks and Request-Response Operations
Handling a Process that Includes Arbitrary Length Tasks
Using a Process as a Service Provider and as a Service Consumer
Authenticating Access to an Exposed Service
Calling the Service from a SOA Application
Example 1 - Single Sign-on Using a Virtualization Binding
Example 2 - Single Sign-on Using a SOAP Binding
Example 3 - Impersonation Using a SOAP Binding
Calling a REST Service
Defining the Interface to an External REST Service
Creating JSON Schemas
Creating JSON Schemas From a JSON Sample
Configuring the Process Project from Which you Want to Call the REST Service
Defining Input and Output Mappings
Creating a Mapping
Configuring Security
Custom Policy Set
Fault Handling and Propagation
Installing TIBCO ActiveMatrix® Binding Type for REST 3.3.0
REST and Authentication
WSDL Change Considerations for Application Upgrade
Application Upgrade
Reverting to the Original Version of an Upgraded Application
Making Changes to the Service Interface
Changes that Do Not Change the Service Interface
What Changes the Interface Using the Contract Last Approach
Changes That Apply to Both Contract First and Contract Last Approaches
Development vs. Production
Using Scripts
Implementing Script Tasks
Unsupported Script Types
Scripts on Other Tasks
Supported Script Types
Sample Scripts
Adding an Action Script to a Task
Associating a Script with a Conditional Flow
Associating a Script with a Loop
Timer Event Scripts
Task Scripts on Events
Editing Scripts
Assistance for Action Scripts
Using Process Data as Script Variables
Using Structured Data Types
Dynamically Created Factory Methods
JavaScript Exclusions
Customizing JavaScript Presentation Preferences
Customizing XPath Presentation Preferences
Scripts at Runtime
Data Mapping
Array Mapping Strategies
Like Mapping
Mapping Contents in Data Mapper
Mapping Process and Work Manager JavaScript Class Attributes
Executing Java Classes from a Process
Complete the Parameter Mapping
Web Service Definition Language (WSDL) Documents
Abstract and Concrete WSDL Documents
WSDL Document Structure
Abstract WSDL Documents
Concrete WSDL Documents
Web Service Configuration Properties
Web Service Implementation Properties
System Participant Shared Resource Properties
SOAP over HTTP Binding Details (Provider)
Endpoint Address Construction
SOAP over JMS Binding Details (Provider)
SOAP Over HTTP Binding Details (Consumer)
SOAP Over JMS Binding Details (Consumer)
Generating a DAA from the Command Line using an Ant Task
Using External Tools to run an Ant task within TIBCO Business Studio
Resource Query Language
Best Practices When Using Resource Query Language (RQL)
RQL Structure
Keywords
Operators
Organization Entities
Navigating the Organization Model with RQL Queries
Using the . Operator
Using only children and all
Combining Expressions
TIBCO Business Studio™ Forms User's Guide
Important Information
TIBCO Documentation and Support Services
Getting Started
Overview of Tutorials
Installing the Forms Tutorial Solutions Project
Tutorial 1 Creating Forms Panes and Controls
Examining the Claims Process Business Process
Opening the Forms
Examining User Tasks
Viewing Capture Claim User Task
Viewing Interview Witness User Task
Understanding Gateways
Adding New Panes
Modifying Names and Labels of Panes
Dragging Controls into Appropriate Panes
Dragging the Controls
Modifying Control Properties: Labels, Required, and Hint Values
Modifying Control Properties: Type and Enabled
Visibility of a Pane
Setting Visibility of Panes from the General Properties Tab
Setting Visibility of Panes from the Mappings Tab
Configuring the Interview Witness Form
Adding a Button
Tutorial 2 Customizing the Appearance of a Form
Changing the Background Colors of Panes
Changing the Label Width Property of the Panes
Previewing Finished Forms
Tutorial 3 Adding and Defining Validations
Adding Validation for Phone Field
Adding Syntax Validation for Email Field
Adding a Second Validation for Email Field
Adding Validation for Date of Birth Field
Examining Auto-Generated Validation for Age Field
Editing Validation for Claim Amount Field
Adding Validation for Time of Accident Field
Adding Validation for Witness Phone Field
Tutorial 4 Creating and Defining Rules Events and Actions
Creating a Rule to Compute Age (Capture Claim Form)
Creating a Rule to Update Required Option for Guardian
Creating Rule to Round Amount to Nearest Integer
Creating Rules that Display Hint on Specifying Claim Amount Controls
Creating Rules that Hide Hints on Exiting Amount Controls
Creating Rules to Display Context-Specific Hints on Specifying Customer Description Control
Creating Rules to Hide Hints on Exiting Customer Description Control
Defining Custom Actions for Buttons
Configuring the Failed - Try Again Button
Configuring the Failed - Do Not Try Again Button
Configuring the Completed Button
Concepts
The Modeling Environment for Forms
The Form and Form Elements
Form Builders and Form Validation
Viewing the Build Configuration of a Project
Data Mappings File
Structure of the Data Mappings File
Data Binding
Enabling the Generation of the Data Mappings File
Bindings
Direction of Bindings
Assigning Binding Both Ways
Actions
Actions Summary Table
Rules
Rules Summary Table
The Design Tab and Preview Tabs
Configuring Presentation Channels
Port Settings for Preview
Copy Form Preview URL
Logging
Locale
Logging Level
Reload
Performance Metrics
Instrumentation Level
View Datastore Data
Visibility in the Preview Tab
Outline View
Forms Compact Mode
Thumbnail Mode
Tree Mode
Usage of the Outline View with Forms
Data
Parameters
Data Fields
Shared Actions
Rules
Managing Form Elements From the Outline View
Use Business Labels in Outline View
Business Object Model
The Objects in a Business Object Model
Multiplicity of Relationships
Live Development of Forms
Viewing Forms in BPM Live Development
Setting Preferences for BPM Live Dev
Setting Preferences from the Properties View
Setting Preferences from the Preferences Dialog
Cross-Resource References
Breakage Mechanisms
Quick Fixes
Mobile Forms
Modified Functionality
Enabling Mobile Forms
Mobile Forms Preview
Mobile Specific Configuration of Controls and Panes
Rendering of Mobile Forms
Problem Markers
Tasks
Creation of a New Form
Drag and Drop Gesture to Customize a Form
Setting Bindings
Adding a Binding from the General Properties Tab for a Control
Adding a Binding from the Parameter Dialog
Adding a Binding from the Mappings Tab
Removing a Binding
Setting Actions
Adding a Script Action Using the Outline View
Adding a Computation Action Using the Outline View
Editing an Action
Setting Rules
Adding a Rule Using the Outline View
Picking an Existing Action
Creating a New Action
Adding a Rule Using the Rule Wizard
Enhanced User Interface
Enhanced User Interface on Custom Clients
CSS Best Practice
Cascading Style Sheets
Data Validation in a Form
Validation Messages and Usability
Validation Script
Implementing Validations
Adding a Validation
Editing a Validation
Examples of Validation Messages
Example 1 Setting a Custom Validation Message
Example 2 Custom Validation Message with Substitution Variables
Example 3 Validation Message Referenced from External Resource
Calling External JavaScript Functions
Specialized Layouts
Nesting Panes
Creating Columns with Nested Panes
Positioning Controls into a Multi-Column Layout
Resequencing Tabbed Panes
Resizing a Tabbed Pane
Positioning a Modal Dialog Pane
Setting Visibility of Pane and Control Borders
Embedded Forms
Working with Embedded Forms
Creating an Embeddable Form
Embedding a Form by Using the Embedded Form Icon
Embedding a Form from the Project Explorer
Adding a BOM Class or Form Parameter to a Form
Embedded Form Parameters
Setting Bindings from the Mappings Tab
Rendering of Embedded Forms
Editing Embedded Forms
Mappings Tab
Coloration Feedback
Setting Bindings
Adding Computation Actions
Editing Computation Action Using the Script Editor Section
Editing Mappings
Property Resource Bundles
The Merging Process
Customizing Property Resource Bundles
Validations Related to Custom Common Resources
Customizing the Form’s Preview Data
Editing the File form-name .data.json
Configuring the Setting in the Properties View
Form Data Fields
Configuring a Form Data Field
Numeric Controls
Inserting a Numeric Control
Inserting External Reference Format
Creating a Custom Format
Adding the Properties File in the Resource List
Inserting a Custom Format
Editing a Numeric Control
Localization of Forms
Creating a Locale-specific Properties File
Language-specific and Country-specific Properties Files
Locale-specific Version of a Form at Runtime
Defining Localization Properties Outside the Form
Example Using a Localization Properties File Defined Outside the Form
Business Analysis and Solution Design Modes
Migration from Previous Versions of TIBCO Business Studio Forms
Advanced Tasks
Importing the Forms Advanced Samples
Using CSS to Customize the Rendering of a Form Control
Creating Custom Add and Delete Buttons for a Grid Pane
Using Editable List Controls
Changing a Control’s Background Color Based on its Value
Controlling the Visibility of a Pane Based on the Value of a Control
Using a Check Box to Set Properties for Another Control
Setting Up the Visibility Flag of a Text Control
Setting Up the Enabled Flag of a Text Control
Setting Up the Required Flag of a Text Control
Using a Business Object Model with Multiple Sub-types
Illustrating the Use of Subclasses with the CapturePerson Form
Illustrating the Use of Subclasses with the DisplayAddressBook Form
Using Enumerations as Choices in an Optionlist or Radiogroup
Validating Commonly Used Primitive Types
Performance Improvements
Static Rendering
Constraints on Model Validations
Restrictions on Runtime Functionality
Deferred Rendering and Deferred Initialization
Constraints on Model Validations
Restrictions on Runtime Functionality
Custom Controls
Working with the Component Library File
Working with the ControlWrapper
Usage of Custom Controls
Runtime Life Cycle of Custom Controls
Runtime Life Cycle of Custom Control Used within Grid Pane
Component Library Model
Library
Palette Drawer
Event Type
External Resource
Control Type
Capabilities
Property
Control Wrapper Implementation
initialize()
refresh()
destroy()
getValue()
getFormattedValue()
isReady()
setFocus()
compare()
renderStatic()
Component Interface
generateId()
getControl()
getFactory()
getForm()
getHintId()
getLabelId()
getLocale()
getParentNode()
getPresentationURL()
getResources()
getValidationMessageIds()
raiseEvent()
BOM JavaScript API for Custom Controls
Factory Methods
BOM Class Methods
BOM Class Instance Methods
Utility Methods
Reference
The Workbench
The Palette for the Form Designer
Panes
Types of Panes
Setting Pane Properties with Bindings and Rules
Controls
Edit as List with a Control
Control or Component Labels
Properties View Tabs
Properties View for Forms
General Tab
Mappings Tab
Font Tab
Child Layout Tab
Child Labels Tab
Rules Tab
Resources Tab
Preview Data Tab
Properties View for Panes
General Tab
Properties Tab
Mappings Tab
Layout Tab
Font Tab
Child Layout Tab
Child Labels
Validations Tab
Rules Tab
Mobile Tab
Properties View for Controls
General Tab
Mappings Tab
Properties Tab
Layout Tab
Font Tab
Validations Tab
Rules Tab
Mobile Tab
Configuration of Parameters
Context Menus
Keyboard Shortcuts
Grid Panes
Grid Panes in Display Mode
Grid Panes in Edit Mode
Grid Pane Column Headers
Grid Pane Navigation Bar
List Controls
List Controls in Display Mode
List Controls in Edit Mode
List Control Command Bar
Record Panes
Record Pane Body
Record Pane Navigation Bar
Tabbed Panes
CSS Classes
Built-in Static CSS Classes
Built-in Dynamic CSS Classes
Common Resource Keys
Keys for Number Patterns
Keys for Basic Number and Currency Symbols
Keys for Duration Control Labels
Keys for Date-Time Patterns
Keys for Optionlist Controls
Keys for Built-in Buttons
Keys for Grid and Record Panes
Keys for Modal Dialog Panes
Keys for Built-in Validation Messages
Keys for List Controls
Keys for Implicit Validation Messages
Keys for Enhanced User Interface
Miscellaneous Keys
Design-time Constraints
Client-side Validations
Scripting
Forms Scripting Scope of Variables
Forms Scripting Order of Script Execution
API for Scripting
Methods for Form Class
Methods for Control Class
Methods for Pane Class
Methods for List Class
Methods for Iterator Class
Methods for Logger Class
Complex Data
Factories
Packages
DateTimeUtil Factory
Duration Class
Utility Methods
Tips and Tricks
Recommendations for Forms Modeling
Grouping Related Controls Together in Vertical Panes
The Visibility Property to Simplify User Experience
Configuration of the Pane Type Property (optional)
Modifying Excessively Long Forms
Expansion of Narrow Panes to Avoid Wrong Placement at Run Time
Creation of Tabbed Panes
Addition of a Tab to an Existing Tabbed Pane
FAQs on TIBCO Business Studio Forms
Tips for Using TIBCO Business Studio Forms
Business Data Services Guide
Important Information
TIBCO Documentation and Support Services
Business Data
Business Data Services (BDS)
BOM Class
Business Objects
Business Object Scope
Business Object Creation by Factory
Retrieving and Setting Business Object Attributes
Invoking Operations on Business Object Attributes
BOM Relationships and Process Local Data
Composition
Specialization and Generalization
UML Relationships Supported by Process Local Data
Assignment by Value and by Reference
BOM Native Type or Primitive Type Object to Business Object Attribute
Assigning a Business Object
Assigning a Basic Type Object to a Process Data Field
Significance of the Script Boundary
Business Data Definition
Business Data Projects
Business Data Project Versioning
Support for Local BOMs in Local Business Object Projects
Support for Local BOMs in Analysis Projects or BPM Developer Projects
Creating a Business Object Model (BOM)
Creating User-defined BOMs in the Business Objects Folder
Importing XSDs and WSDLs into Business Objects
Importing WSDLs into the Service Descriptors Folder
Importing a WSDL when Defining a Web Service Task
Generating a WSDL for a Web Service You Are Creating
BOM Native Types
Value Spaces for BOM Native Types
BOM Design-time Model
Primitive Types
Regular Expression Patterns for Text Fields
Multiplicity
Size Restrictions
Default Values
BOM Labels and Names
Label to Name Algorithm
BOM Class Label and Name
BOM Attribute Label and Name
BOM Package Label and Name
Reserved Words
Name Clashes
BDS Generation and Business Data Usage in TIBCO BPM
BDS Design-time Validations
Process Validations
BDS Runtime Validations
Process Migration
Using BDS in Tasks
Defining Web Services
Business Data Scripting
Supplying xsi:type Information in XML Sent to ActiveMatrix BPM
Business Data Scripting by Example
Factories
Creating a New Business Object
Create an Instance of a Class
Create a Copy of a Business Object
Using the Special Value Null
Checking for Null Attributes
Assigning a Null Value
Using Content Assist
Working with Single Instance Attributes of Business Objects
Multiple Instances of a BOM Class
Multiple Instances of a BOM Class in a Process Data Field
Multiple Instances of a BOM Class in a BOM Class Attribute
Multiple Instances in Sequences and Groups
Passing Multiplicity to a Form
Working with Temporary Variables and Types
Loops Within Scripts
Scripting Containment Relationships
Using the List set() Method
Working with Numeric Types
Working with Basic Integer Numbers
Signed Integers
Working with Basic Decimal Numbers
Implicit Conversions Between Numeric Types
Working with Dates and Times
Dates and Times
Durations
Using Date and Time Types with Durations
Comparing Dates and Times
Working with Enumerated Types (ENUMs)
Working with Primitive Types
Using Enumerated Types as Extensions of Primitive Types
Return Values from Scripts
Scripting with Web Services
Passing Arrays to Web Services
Parse Functions
Advanced Scripting Examples
Working with Fixed Length Integers (BigInteger)
Unsupported Conversions
Working with Fixed Decimals (BigDecimal)
Creating and Initializing Fixed Decimal Values
Simple Operations
Rounding
Unsupported Conversions
Comparing Fixed Decimals and BigDecimals
Object BOM Native Type
Using the Object BOM Native Type
Restrictions
Object BOM Native Type and ScriptUtil.setObject()
Additional JavaScript Global Functions
Business Data Modeling Best Practice
Store Local BOMs in Business Data Projects
Keep Local BOMs and Global BOMs in Separate Business Data Projects
Upgrade Business Data Projects and Dependent Process Projects Together
Use Pre-Compilation for Projects That Contain Large or Generated BOMs
Choose Appropriate Data Types
Use Sub-Packages to Aggregate Related Concepts
Process Data Field Granularity
BOM Class Attribute and Variable Names
Do Not Split a Namespace Across Projects
Do Not Modify Generated BOMs
Business Data Scripting Best Practice
Troubleshooting
Viewing BDS-generated BDS Plug-in Hidden Projects
Troubleshooting BDS Scripting
Reasons to Avoid Deleting Case Objects
Reserved keywords to avoid using for attribute names
BDS Classes Do Not Appear or Changes Do Not Appear
Break Script into Smaller Scripts
Examine the Server Logs
Write Variable Values and Progress Updates from the Script to the BPM Log File
eval()
Use the Process Debugger
Catch Exceptions
BDS Plug-in Generation Problems
Supplemental Information
Data Type Mappings
BOM Native Type to BDS Type Mapping
XSD Type to BDS Type Mapping
JDBC Database Type to BOM Data Type Mapping
Process Primitive Data Type Mapping
Unsupported XSD Constructs
BDS Limitations
Fixed Attribute Overwrite
Multiplicity Ordering in a Sequence or Choice
Nested xsd any in Sequences
xsd any ##local
Recurring Elements in Sequence
The block Function
Data Mapping
Converting Values Between Different BOM Attribute Types
Mapping to or from Process Basic Types
JavaScript Features not Supported in TIBCO BPM Scripting
Using If For and While Expressions
Reserved Words in Scripts
Business Data Scripting
Static Factory Methods
DateTimeUtil
DataUtil
ScriptUtil
IpeScriptUtil (and ScriptUtil) Conversion Date and Time and String Functions
BOM Native Type Methods
Fixed Length Integer (BigInteger) Methods
Fixed Point Decimal (BigDecimal) Methods
Date Time Datetime and Datetimetz (XMLGregorianCalendar) Methods
Duration Methods
Text (String) Methods
Other Supported Methods
List Methods
ListIterator Methods
Other JavaScript Functions
Math Methods
Process Manager and Work Manager Scripting
Process Instance Attributes and Methods
Organization Model Attributes and Methods
WorkManagerFactory
WorkItem
OrgModel
Business Data Services Glossary
Case Data User's Guide
Important Information
TIBCO Documentation and Support Services
Case Data Overview
Case Data Terminology
Case Data Model Deployment Lifecycle
Creating and Deploying a Case Data Model
BOM Type to Database Type Mappings
Modeling Case Data in a Global BOM
Case Classes, Global Classes and Local Classes
Case Identifiers
Adding a Case Identifier to a Case Class
Changing a Case Identifier's Type
Case States and Case Actions
Adding a Case State to a Case Class
Converting an Existing Case Class Attribute to a Case State
Creating a Case Action
Generating a Case Action From a Case Class
Case Summaries
Adding Attributes to a Case Summary
Deleting Attributes From a Case Summary
Defining the Order in Which Case Summary Attributes are Displayed at Runtime
Searchable Attributes
BOM Relationships and Global BOMs
Converting a Local BOM to a Global BOM
Upgrading a Case Data Model
Case Data Model Versioning
Process Dependencies and Case Data Model Versions
Upgrading a Case Data Model to a New Minor Version
Upgrade Error: Incompatible changes made during upgrade of version number of model
Upgrading a Case Data Model to a New Major Version
Deleting a Case Data Model
Using a Case Data Model in a Business Process
Creating a New Case Object
Displaying a Case Object in a User Task - Using a Form
Displaying a Case Object in a User Task - Using a Pageflow
Updating a Case Object
Notifying a Process That a Case Object It Uses Has Been Modified
CaseSignalAttributes Class and Methods
Deleting Case Objects
Reasons to Avoid Deleting Case Objects
Deleting Case Objects by Case Reference
Deleting Case Objects by Case Identifier
Deleting a Case Object by Composite Case Identifier
Searching For and Reading Case Objects
Case Access Classes
Finding a Case Object by its Case Identifier
Finding Case Objects by Example
Finding All Case Objects of a Particular Type
Finding Case Objects by Criteria
Case Data Query Language (DQL)
Attribute Paths
Operators
Functions
Values
Creating a Criteria Object
Criteria Object Methods and Attributes
Case Reference Methods and Attributes
Navigating Association Links to find Related Case Objects
Association Links and Association Relationships
Creating an Association Relationship Between Two Case Classes
Creating an Association Link
Deleting an Association Link
Reading Case Objects
Handling Case Objects That Use Inheritance in Scripts
Processing a Paginated List of Case References
Generating a Business Service to Create/Update/Delete Case Data
Using Case Data to Display Work Item Lists From Business Services Using TIBCO Openspace
Using Case Data to Open Work Lists From Business Services Using Custom Clients
Business Data Services Properties (bds.properties)
Configuring Whether Case Data Tables Are Managed Automatically or Manually
Case Folders
Terminology for Case Folders
Content Management System
TIBCO DocumentStore
Case Folder Configuration
Document Operations Service Type
Delete Document
Find Documents Linked to Case Object
Link Document to Case Object
Link System Document
Move Document Between Case Objects
Unlink Document From Case Object
Viewing Case Folders in Openspace
Case Folder System Actions
BPM Developer's Guide
Important Information
TIBCO Documentation and Support Services
Introduction to TIBCO ActiveMatrix BPM Components and Services
TIBCO ActiveMatrix BPM APIs
Obtaining BPM Web Service API
Obtaining Information From TIBCO Business Studio
Work Data Models
Business Object Models
Exporting the Business Object Model into an XML Schema
Formal Parameters
Valid Format for DataModel
Developing a .NET Client Application Using the Web Service API
The BPMTestApplication Example Client
Getting the BPMTestApplication Solution
Generating Service Model Code for BPM Services
Creating the services.cs file
Handling Choice Elements in the BPM API Schemas
Configuring Service Endpoints
Authenticating the Calling User - Web Service API
Obtaining the Calling User’s GUID
Writing Adapter Methods
Writing the Application Layer
Rendering a Form for a Work Item
FormRedirect
The onTIBCOFormRunnerLoad Function
Setting the useJSONP Variable
Setting the Form URL
Obtaining the Initial Data to Populate the Form
Setting the BOM JavaScript path
Creating Action Handlers for User Actions
Rendering the Form
Developing a Client Application Using the Java Service Connector API
Overview of the Java Service Connector
Enabling the Java Service Connector for Your Development Environment
Overview of The Sample Client Application
System Requirements of the Sample Client Application
Getting the SampleApp Solution
Architecture of the Sample Client Application
Instantiating and Configuring the Service Connector
Setting up the Security Handler
Authenticating the Calling User - Java Service Connector
Executing the Service Connector API Calls
Implementing the Client User Interface
Rendering a Form for a Work Item
Displaying the Work Item Data as a TIBCO form
Loading the Forms Runtime Adapter
Creating the onTIBCOFormRunnerLoad Function
The onTIBCOFormRunnerLoad Function
Setting the Form URL
Obtain the Initial Data to Load the Form
Set the BOM JavaScript Path
Create Action Handlers for User Actions
Render the Form
Developing a Client Application Using the REST API
Constructing REST Requests
ActiveMatrix BPM REST API Endpoint (baseurl)
Authenticating the Calling User - REST API
URL Encoding Path and Query Parameters
Data Payloads and Supported Media Types
Required Format for JSON Payloads
Response Status Codes
Setting Log Level for REST Services
Support for CORS
Authenticating Access to a TIBCO ActiveMatrix BPM Service
Direct Authentication
Single Sign-On (SSO) Authentication
Working with Case Data Models
Introduction to Case Data Models
Retrieving Case Model Database Scripts
Working with Data Views
Data Views
Dataview Categories
Performing an Ad-hoc Search
Using Wildcards to Search for Dataviews
Using Dataviews
Defining Dataview Conditions
Defining Value
Search Operators
Defining Named Parameter Assignments
Example Dataview Specifications
Determining a Data View's Named Parameters
Working With Organization Models and LDAP
Creating an LDAP Container
Creating an LDAP Container Using an LDAP Query Source
Creating an LDAP Container Using an LDAP Query Source— Service Connector API Example (Java)
Creating an LDAP Container Using an LDAP Group Source
Mapping Users
Mapping a Resource — Service Connector API Example (Java)
Adding Values to Organization Model Attributes
Adding Values to Organization Model Attributes — Service Connector API Example (Java)
Navigating the Organization Model
Navigating the Organization Model — Service Connector API Example (Java)
Navigating Large Organization Models
Organization Model Entity Properties
Mapping Resource Attributes to LDAP Attributes
Mapping Resource Attributes to LDAP Attributes — Service Connector API Example (Java)
Using LDAP Filters
Defining Secondary LDAP Sources in an LDAP Container
Organization Relationships
Overriding Organization Relationships
Moving a Resource to Different LDAP Container
Moving a Resource to a Different LDAP Container — Service Connector API Example (Java)
Updating Push Destinations
Updating Push Destinations for Organizational Entities
Updating Push Destinations for Organizational Entities — Service Connector API Example (Java)
Updating Push Destinations for Resources
Updating Push Destinations for Resources — Service Connector API Example (Java)
Configuring a Dynamic Organization Model Extension Point
Configuring a Dynamic Organization Model Extension Point — Service Connector API Example (Java)
Candidate Queries
Configuring a Candidate Query
Setting Candidate Queries — Service Connector API Example (Java)
Removing a Candidate Query Configuration
Removing Candidate Queries — Service Connector API Example (Java)
Working With Processes
Listing Available Process Templates
listProcessTemplates
queryProcessTemplates
queryProcessTemplatesAlt
Starting a Process Instance
Starting a Process Instance—Service Connector API Example (Java)
Listing Available Process Instances
listProcessInstances
queryProcessInstances
queryProcessInstancesAlt
Sorting and Filtering Lists of Process Templates and Instances
Query Parameter Syntax
Query Parameter Attributes
Using User-Defined Attributes
Query Parameter Operators
Using Wildcards
Date Time Data Type Specification
Query Parameter Examples
Process Instance State Transitions
Handling Process Instance Failures
Migrating a Process Instance to a Different Version
Migration Points
Migration Rules
How Process Instances Are Migrated
Process Migration Operations
Working with Work Lists
Introduction to Work Lists
Retrieving a Work List
getWorkListItems
getAllocatedWorkListItems
Sorting and Filtering Work Lists
getWorkItemOrderFilter
setResourceOrderFilterCriteria
getResourceOrderFilterCriteria
Sort and Filter Expression Syntax
Wildcard Characters
Sort Expressions
Sort Filter Criteria
Using Date Time Fields
Using Date Time Ranges
Using Work Item Attribute Fields
Working with Work List Views
Introduction to Work List Views
Creating Work List Views
Work List View Details
Creating a Work List View
Sorting Filtering Work List Views
Work List View Access
Custom Data
Creating and Managing Supervised Work List Views
Creating and Managing Supervised Work List Views - Example 1
Creating and Managing Supervised Work List Views - Example 2
Creating a Supervised Work List— Service Connector API Example (Java)
Editing Work Views
Public Work Views
Retrieve a List of Public Work List Views
Add a Resource as a User of a Public Work View
Delete a Resource as a User of a Public Work View
Using Work Views
Retrieving a List of Work Items
Retrieving a List of Work Views for a Resource
Deleting Work Views
Working with Work Items
Introduction to Work Items
Work Item Errors
Work Item Versions
Work Item States
Work Item State Transitions
Retrieving Information on Work Items
previewWorkItemFromList
getWorkItemHeader
getOfferSet
Offering and Allocating Work Items
Allocating Work Item to a Target Resource
Allocating a Work Item — Service Connector API Example (Java)
Required System Actions
Reallocating a Work Item
Reallocating to Offer Set or to World
Reoffering a Work Item
Opening a Work Item
Progressing a Work Item
openWorkItem
closeWorkItem
completeWorkItem
cancelWorkItem
skipWorkItem
saveOpenWorkItem
pendWorkItem
rescheduleWorkItem
setWorkItemPriority
Handling a Work Item That Contains Business Data
Accessing Hidden Work Items
Example of Processing a Work Item
Processing a Work Item with a Form
Processing Chained Work Items
Processing Chained Work Items — Web Service API Example
Processing Chained Work Items— Service Connector API Example (Java)
Working With Forms
Overview
Using TIBCO Forms
Binding the Client Application to a Channel
Identifying the Client Channel in a Service Call
Rendering a TIBCO Business Studio Form
Displaying a Work Item Form
Displaying a Form in a Pageflow
Displaying a Form in a Business Service
Using Custom Forms
Presentation Details
Data Format and Structures
Working With Business Services
Starting a Business Service
Starting a Business Service — Service Connector API Example (Java)
Displaying a Form in a Business Service
Injecting a Business Service Event
Injecting a Business Service Event — Service Connector API Example (Java)
Working With Pageflows
Starting and Processing a Pageflow
Injecting a Pageflow Event
Working with Events
Executing a Query
Dynamic Queries
Registered Queries
Correlated Events
Defining Query Filter Strings
Filter Expression Format
Functions
Operands
Using String Literals
Using DateTime Literals
Using Late-Bound Parameter Literals
Operators
Using Attributes in Query Filters
AUDIT Option Attributes
Message Categories and Attribute Contents
CASE_STATS Option Attributes
PROCESS_STATS Option Attributes
PROCESS_TEMPLATES Attributes
REGISTERED_ATTRIBUTES Option Attributes
REGISTERED_COMPONENTS Option Attributes
REGISTERED_QUERIES Option Attributes
USER_ACTIVITY Option Attributes
WORKITEM_STATS Option Attributes
Example Queries
Event Measures
Event Measure Parameters
Process Template IDs
Start and End Date
Granularity
Consolidation
requestProcessDurationMeasure
requestProcessTemplateMeasure
requestWorkItemPerformanceForTemplate
Purging Audit Data
Working with Calendars
Introduction to Calendars
Calendar API Services
Base and Overlay Calendars
Exclusions
Timezones
Calendar References
Calendars and User Tasks
Creating Calendars
Identifying Calendars
Adding Recurring Exclusions
Recurrence Rule
Assigning a Calendar Reference to a Calendar
Scheduling
Scheduling Example
TIBCO ActiveMatrix BPM Services
Business Data Services
Business Services
Business Resource Management Services
Calendar Services
Directory Services
Event Collection Services
Pageflow Services
Process Services
Work Presentation Services
BusinessDataServices
createCase
SOAP API - createCase
Java API - createCase
REST API - createCase
createDataView
SOAP API - createDataView
Java API - createDataView
REST API - create
deleteCaseByCID
SOAP API - deleteCaseByCID
Java API - deleteCaseByCID
REST API - deleteByID
deleteCaseByRef
SOAP API - deleteCaseByRef
Java API - deleteCaseByRef
REST API - deleteByRef - Single Case Data Object
REST API - deleteByRef - Multiple Case Data Objects
REST API - deleteByRefx
deleteDataView
SOAP API - deleteDataView
Java API - deleteDataView
REST API - delete - by ID
REST API - delete - by name
editDataView
SOAP API - editDataView
Java API - editDataView
REST API - edit
findCaseByCID
SOAP API - findCaseByCID
Java API - findCaseByCID
REST API - findByID
findCaseByCriteria
SOAP API - findCaseByCriteria
Java API - findCaseByCriteria
REST API - findCaseByCriteria
findAllCases
SOAP API - findAllCases
Java API - findAllCases
REST API - findAllCases
findCaseByExample
SOAP API - findCaseByExample
Java API - findCaseByExample
REST API - findByExample
getCaseReferencesForDataView
SOAP API - getCaseReferencesForDataView
Java API - getCaseReferencesForDataView
REST API - getCaseReferences
REST API - getCaseReferencesx
getCaseState
SOAP API - getCaseState
Java API - getCaseState
REST API - getCaseState - GET - single reference
REST API - getCaseState - GET - multiple references
REST API - getCaseState - POST
getCaseSummary
SOAP API - getCaseSummary
Java API - getCaseSummary
REST API - getCaseSummary - GET
REST API - getCaseSummary - POST
getDataViewDetails
SOAP API - getDataViewDetails
Java API - getDataViewDetails
REST API - getdetails - viewID
REST API - getdetails - viewName
REST API - getDataViewDetails - application details
REST API - getDataViewDetails - caseType
REST API - getDataViewDetails - category
REST API - getDataViewDetails - uncategorized
getDataViewCategories
SOAP API - getDataViewCategories
Java API - getDataViewCategories
REST API - getDataViewCategories
linkCase
SOAP API - linkCase
Java API - linkCase
REST API - link
REST API - linkx
navigateCase
SOAP API - navigateCase
Java API - navigateCase
REST API - navigateCase
navigateCaseByCriteria
SOAP API - navigateCaseByCriteria
Java API - navigateCaseByCriteria
REST API - navigateCaseByCriteria
navigateCaseDetailed
SOAP API - navigateCaseDetailed
Java API - navigateCaseDetailed
REST API - navigateCaseDetailed
readCase
SOAP API - readCase
Java API - readCase
REST API - read
REST API - read
REST API - readx
unlinkCase
SOAP API - unlinkCase
Java API - unlinkCase
REST API - unlink
REST API - unlinkx
updateCase
SOAP API - updateCase
Java API - updateCase
REST API - update
REST API - update - Array Operation
BusinessDataServicesAdminService
getAuditInfo
SOAP API - getAuditInfo
Java API - getAuditInfo
REST API - getAuditInfo
getCaseClassInfo
SOAP API - getCaseClassInfo
Java API - getCaseClassInfo
REST API - getCaseClassInfo
getCaseModel
SOAP API - getCaseModel
Java API - getCaseModel
REST API - getCaseModel
getCaseModelBasicInfo
SOAP API - getCaseModelBasicInfo
Java API - getCaseModelBasicInfo
REST API - getCaseModelBasicInfo
notifyDDLExecution
SOAP API - notifyDDLExecution
Java API - notifyDDLExecution
REST API - notifyFreeze
REST API - notifyUnfreeze
REST API - notifyCreated
REST API - notifyUpdated
REST API - notifyDropped
REST API - notifyCleaned
updateDBScripts
SOAP API - updateDBScripts
Java API - updateDBScripts
REST API - updateDBScripts
BusinessDeadlineService
calcDeadline
SOAP API - calcDeadline
Java API - calcDeadline
REST API - calcDeadline
BusinessService
cancelBusinessService
SOAP API - cancelBusinessService
Java API - cancelBusinessService
REST API - cancelBusinessService
injectBusinessServiceEvent
SOAP API - injectBusinessServiceEvent
Java API - injectBusinessServiceEvent
REST API - injectBusinessServiceEvent
listBusinessServices
SOAP API - listBusinessServices
Java API - listBusinessServices
REST API - listBusinessServices
listCaseAction
SOAP API - listCaseAction
Java API - listCaseAction
REST API - listCaseAction
listCategories
SOAP API - listCategories
Java API - listCategories
REST API - listCategories
queryBusinessServices
SOAP API - queryBusinessServices
Java API - queryBusinessServices
REST API - queryBusinessServices
queryCategories
SOAP API - queryCategories
Java API - queryCategories
REST API - queryCategories
startBusinessService
SOAP API - startBusinessService
Java API - startBusinessService
REST API - startBusinessService
updateBusinessService
SOAP API - updateBusinessService
Java API - updateBusinessService
REST API - updateBusinessService
ClientService
completeWorkItem
REST API - completeWorkItem
openNextWorkItem
REST API - openNextWorkItem
openWorkItem
REST API - openWorkItem
DirectoryService
deleteContainer
SOAP API - deleteContainer
Java API - deleteContainer
REST API - deleteContainer
executeLdapQuery
SOAP API - executeLdapQuery
Java API - executeLdapQuery
REST API - executeLdapQuery
REST API - executeLargeLdapQuery
REST API - pagedquery
getCandidateDetail
SOAP API - getCandidateDetail
Java API - getCandidateDetail
REST API - getCandidateDetail
getLdapEntry
SOAP API - getLdapEntry
Java API - getLdapEntry
REST API - getLdapEntry
listAttributeNames
SOAP API - listAttributeNames
Java API - listAttributeNames
REST API - listAttributeNames
REST API - listAttributeNamesLargeQuery
listCandidateResources
SOAP API - listCandidateResources
Java API - listCandidateResources
REST API - listCandidateResources
REST API - pagedcandidates
listContainers
SOAP API - listContainers
Java API - listContainers
REST API - listContainers
listLdapConnections
SOAP API - listLdapConnections
Java API - listLdapConnections
REST API - listLdapConnections
saveContainer
SOAP API - saveContainer
Java API - saveContainer
REST API - saveContainer
Document Service
createDocument
SOAP API - createDocument
Java API - createDocument
REST API - createDocument - POST
REST API - createDocument - Multi-part POST
deleteDocument
SOAP API - deleteDocument
Java API - deleteDocument
REST API - deleteDocument - with a Path Parameter
REST API - deleteDocument - with a Request Body
deleteOrphanedFolders
SOAP API - deleteOrphanedFolders
Java API - deleteOrphanedFolders
REST API - deleteOrphanedFolders
findDocuments
SOAP API - findDocuments
Java API - findDocuments
REST API - findDocuments - GET with Path Parameters
REST API - findDocuments - with Name Parameter in Request Body
REST API - findDocuments - POST with Query String in Request Body
Queries for findDocuments
getDocumentContent
SOAP API - getDocumentContent
Java API - getDocumentContent
REST API - getDocumentContent - GET
REST API - getDocumentContent - POST
getDocumentMetadata
SOAP API - getDocumentMetadata
Java API - getDocumentMetadata
REST API - getDocumentMetadata - GET
REST API - getDocumentMetadata - POST
getFolderContent
SOAP API - getFolderContent
Java API - getFolderContent
REST API - getFolderContent - GET
REST API - getFolderContent - POST
getRepositoryInfo
SOAP API - getRepositoryInfo
Java API - getRepositoryInfo
REST API - getRepositoryInfo
linkDocument
SOAP API - linkDocument
Java API - linkDocument
REST API - linkDocument - with Path Parameters
REST API - linkDocument - with a Request Body
moveDocument
SOAP API - moveDocument
Java API - moveDocument
REST API - moveDocument - with Path Parameters
REST API - moveDocument - with a Request Body
unlinkDocument
SOAP API - unlinkDocument
Java API - unlinkDocument
REST API - unlinkDocument - with Path Parameters
REST API - unlinkDocument - with a Request Body
EntityResolverService
listAssociatedResources
SOAP API - listAssociatedResources
Java API - listAssociatedResources
lookupUser
SOAP API - lookupUser
Java API - lookupUser
REST API - lookupUser
EventCollectorAuditService
batchEvent
SOAP API - batchEvent
Java API - batchEvent
REST API - batchEvent
event
SOAP API - event
Java API - event
REST API - event
EventCollectorQueryService
executeGenericQuery
SOAP API - executeGenericQuery
Java API - executeGenericQuery
REST API - executeGenericQuery
executeRegisteredGenericQuery
SOAP API - executeRegisteredGenericQuery
Java API - executeRegisteredGenericQuery
REST API - executeRegisteredGenericQuery
getAllAttributes
SOAP API - getAllAttributes
Java API - getAllAttributes
REST API - getAllAttributes
getAttributes
SOAP API - getAttributes
Java API - getAttributes
REST API - getAttributes
getComponents
SOAP API - getComponents
Java API - getComponents
REST API - getComponents
isQueryRegistered
SOAP API - isQueryRegistered
Java API - isQueryRegistered
REST API - isQueryRegistered
lookupQueryByTag
SOAP API - lookupQueryByTag
Java API - lookupQueryByTag
REST API - lookupQueryByTag
registerQuery
SOAP API - registerQuery
Java API - registerQuery
REST API - registerQuery
unRegisterQuery
SOAP API - unregisterQuery
Java API - unregister Query
REST API - unregister Query
EventCollectorManagementService
checkPurgeAudit
SOAP API - checkPurgeAudit
Java API - checkPurgeAudit
REST API - checkPurgeAudit
doPurgeAudit
SOAP API - doPurgeAudit
Java API - do Purge Audit
REST API - doPurgeAudit
Purge Audit Status
stopPurgeAudit
SOAP API - stopPurgeAudit
Java API - stopPurgeAudit
REST API - stopPurgeAudit
checkAutoArchive
SOAP API - checkAutoArchive
Java API - checkAutoArchive
REST API - checkAutoArchive
stopAutoArchive
SOAP API - stopAutoArchive
Java API - stopAutoArchive
REST API - stopAutoArchive
triggerAutoArchive
SOAP API - triggerAutoArchive
Java API - triggerAutoArchive
REST API - triggerAutoArchive
EventCollectorMeasuresService
requestProcessDurationMeasure
SOAP API - requestProcessDurationMeasure
Java API - requestProcessDurationMeasure
REST API - requestProcessDurationMeasure
requestProcessTemplateMeasure
SOAP API - requestProcessTemplate Measure
Java API - requestProcessTemplateMeasure
REST API - requestProcessTemplateMeasure
requestWorkItemPerformanceForTemplate
SOAP API - requestWorkItemPerformanceForTemplate
Java API - requestWorkItemPerformanceForTemplate
REST API - requestWorkItemPerformanceForTemplate
requestWorkItemPerformanceForResource
EventCollectorReportService
getCaseAudit
SOAP API - getCaseAudit
Java API - getCaseAudit
REST API - getCaseReport - Using Case Reference
REST API - getCaseReport - Using Case Details
getProcessInstanceAudit
SOAP API - getProcessInstanceAudit
Java API - getProcessInstanceAudit
REST API - getProcessInstanceReport
getWorkItemAudit
SOAP API - getWorkItemAudit
Java API - getWorkItemAudit
REST API - getWorkItemReport
getCommentAudit
SOAP API - getCommentAudit
Java API - getCommentAudit
REST API - Comment - Case Reference - GET
REST API - Comment - Case Class - GET
REST API - Comment - Process Instance Id - GET
REST API - Comment - Work Item Id - GET
getChart
SOAP API - getChart
Java API - getChart
REST API - getChart
getChartData
SOAP API - getChartData
Java API - getChartData
REST API - getChartData
EventCollectorUpdateService
Comment
SOAP API - comment
Java API - comment
REST API - comment - Work Item Id
REST API - comment - Process Instance Id
REST API - Comment - Case Reference
REST API - Comment - Case Details
errorEvent
SOAP API - errorEvent
Java API - errorEvent
REST API - errorEvent
registerAttributes
SOAP API - registerAttributes
Java API - registerAttributes
REST API - registerAttributes
registerComponent
SOAP API - registerComponent
Java API - registerComponent
REST API - registerComponent
ExporterService
exportResources
SOAP API - exportResources
Java API - exportResources
REST API - exportResources
importResources
SOAP API - importResources
Java API - importResources
REST API - importResources
OrganisationalEntityConfigService
deleteOrgEntityConfigAttributes
SOAP API - deleteOrgEntityConfigAttributes
Java API - deleteOrgEntityConfigAttributes
REST API - deleteOrgEntityConfigAttributes
getOrgEntityConfigAttributes
SOAP API - getOrgEntityConfigAttributes
Java API - getOrgEntityConfigAttributes
REST API - getOrgEntityConfigAttributes
getOrgEntityConfigAttributesAvailable
SOAP API - getOrgEntityConfigAttributesAvailable
Java API - getOrgEntityConfigAttributesAvailable
REST API - getOrgEntityConfigAttributesAvailable
setOrgEntityConfigAttributes
SOAP API - setOrgEntityConfigAttributes
Java API - setOrgEntityConfigAttributes
REST API - setOrgEntityConfigAttributes
OrgModelService
getCalendarReferences
SOAP API - getCalendarReferences
Java API - getCalendarReferences
REST API - getCalendarReferences
getOrgModel
SOAP API - getOrgModel
Java API - getOrgModel
REST API - getOrgModel
getOrgModelEntity
SOAP API - getOrgModelEntity
Java API - getOrgModelEntity
REST API - getOrgModelEntity
getOrgModelRoots
SOAP API - getOrgModelRoots
Java API - getOrgModelRoots
REST API - getOrgModelRoots
getPushDestinations
SOAP API - getPushDestinations
Java API - getPushDestinations
REST API - getPushDestinations - passing parameters
REST API - getPushDestinations - passing body
listOrgModelVersions
SOAP API - listOrgModelVersions
Java API - listOrgModelVersions
REST API - listOrgModelVersions
setCalendarReferences
SOAP API - setCalendarReferences
Java API - setCalendarReferences
REST API - setCalendarReferences - Assign Calendar Reference
REST API - setCalendarReferences - Delete Calendar Reference
setCandidateQueries
SOAP API - setCandidateQueries
Java API - setCandidateQueries
REST API - setCandidateQueries
REST API - Set Candidate Query - Position
REST API - Set Candidate Query - Group
REST API - Delete Candidate Query - Position
REST API - Delete Candidate Query - Group
setExtensionPoints
SOAP API - setExtensionPoints
SOAP API - setExtensionPoints - Remove Extension Point
Java API - setExtensionPoints
REST API - setExtensionPoints - Set or Update Extension Point Reference
REST API - setExtensionPoints - Remove Extension Point Reference
updatePushDestinations
SOAP API - updatePushDestinations
Java API - updatePushDestinations
REST API - updatePushDestination - using updatePushDestination element
REST API - updatePushDestination - passing parameters
REST API - deletePushDestinations
OrgResourceService
createResource
SOAP API - createResource
Java API - createResource
REST API - createResource
deleteResource
SOAP API - deleteResource
Java API - deleteResource
REST API - deleteResource - Using Query Parameters
REST API - deleteResource - Using Body Parameter
findResources
SOAP API - findResources
Java API - findResources
REST API - findResources - by name
REST API - findResources - by entity
getResource
SOAP API - getResource
Java API - getResource
REST API - getResource - Using Query Parameters
REST API - getResource - Using Body Parameter
getDeletedResources
SOAP API - getDeletedResources
Java API - getDeletedResources
REST API - getDeletedResources
purgeDeletedResources
SOAP API - purgeDeletedResources
Java API - purgeDeletedResources
REST API - purgeDeletedResources
updateResource
SOAP API - updateResource
Java API - updateResource
REST API - updateResource
PageFlowService
cancelPageFlow
SOAP API - cancelPageFlow
Java API - cancelPageFlow
REST API - cancelPageFlow
injectPageFlowEvent
SOAP API - injectPageFlowEvent
Java API - injectPageFlowEvent
REST API - injectPageFlowEvent
listPageFlows
SOAP API - listPageFlows
Java API - listPageFlows
REST API - listPageFlows
startPageFlow
SOAP API - startPageFlow
Java API - startPageFlow
REST API - startPageFlow
updatePageFlow
SOAP API - updatePageFlow
Java API - updatePageFlow
REST API - updatePageFlow
ProcessManagerService
bulkCancelProcessInstances
SOAP API - bulkCancelProcessInstances
cancelAdhocActivity
SOAP API - cancelAdhocActivity
Java API - cancelAdhocActivity
REST API - cancelAdhocActivity
cancelProcessInstance
SOAP API - cancelProcessInstance
Java API - cancelProcessInstance
REST API - cancelProcessInstance
cancelProcessInstances
SOAP API - cancelProcessInstances
Java API - cancelProcessInstances
REST API - cancelProcessInstances
checkPurgeTerminatedProcessInstances
SOAP API - checkPurgeTerminatedProcessInstances
Java API - checkPurgeTerminatedProcessInstances
REST API - checkPurgeTerminatedProcessInstances
clearMigrationRules
SOAP API - clearMigrationRules
Java API - clearMigrationRules
REST API - clearMigrationRules
createProcessInstance
SOAP API - createProcessInstance
Java API - createProcessInstance
REST API - createProcessInstance
decodeProcessId
SOAP API - decodeProcessId
Java API - decodeProcessId
REST API - decodeProcessId
getActivityInstanceStatus
SOAP API - getActivityInstanceStatus
Java API - getActivityInstanceStatus
REST API - getActivityInstanceStatus
getAvailableProcessInstanceVariables
SOAP API - getAvailableProcessInstanceVariables
Java API - getAvailableProcessInstanceVariables
REST API - getAvailableProcessInstanceVariables
getMigrationPoints
SOAP API - getMigrationPoints
Java API - getMigrationPoints
REST API - getMigrationPoints
getParameterValue
SOAP API - getParameterValue
Java API - getParameterValue
REST API - getParameterValue
getProcessInstanceStatus
SOAP API - getProcessInstanceStatus
Java API - getProcessInstanceStatus
REST API - getProcessInstanceStatus
getProcessInstanceSummary
SOAP API - getProcessInstanceSummary
Java API - getProcessInstanceSummary
REST API - getProcessInstanceSummary
getStarterOperationInfo
SOAP API - getStarterOperationInfo
Java API - getStarterOperationInfo
REST API - getStarterOperationInfo
ignoreProcessInstance
SOAP API - ignoreProcessInstance
Java API - ignoreProcessInstance
REST API - ignoreProcessInstance
ignoreProcessInstances
SOAP API - ignoreProcessInstances
Java API - ignoreProcessInstances
REST API - ignoreProcessInstances
isSetMigrationRule
SOAP API - isSetMigrationRule
Java API - isSetMigrationRule
REST API - isSetMigrationRule
listAdhocActivities
SOAP API - listAdhocActivities
Java API - listAdhocActivities
REST API - listAdhocActivities (using process ID)
REST API - listAdhocActivities (using global data reference)
listMigrationRules
SOAP API - listMigrationRules
Java API - listMigrationRules
REST API - listMigrationRules
listProcessInstanceAttributes
SOAP API - listProcessInstanceAttributes
Java API - listProcessInstanceAttributes
REST API - listProcessInstanceAttributes
listProcessInstances
SOAP API - listProcessInstances
Java API - listProcessInstances
REST API - listProcessInstances
SOAP API - queryProcessInstanceCountAlt
listProcessTemplateAttributes
SOAP API - listProcessTemplateAttributes
Java API - listProcessTemplateAttributes
REST API - listProcessTemplateAttributes
listProcessTemplates
SOAP API - listProcessTemplates
Java API - listProcessTemplates
REST API - listProcessTemplates
listServices
REST API - listServices
listSetofProcessInstanceAttributes
SOAP API - listSetofProcessInstanceAttributes
Java API - listSetofProcessInstanceAttributes
REST API - listSetofProcessInstanceAttributes
listStarterOperations
SOAP API - listStarterOperations
Java API - listStarterOperations
REST API - listStarterOperations
purgeTerminatedProcessInstances
SOAP API - purgeTerminatedProcessInstances
Java API - purgeTerminatedProcessInstances
REST API - purgeTerminatedProcessInstances
queryApplications
SOAP API - queryApplications
Java API - queryApplications
REST API - queryApplications
queryDone
SOAP API - queryDone
Java API - queryDone
REST API - queryDone
queryFirstPage
SOAP API - queryFirstPage
Java API - queryFirstPage
REST API - queryFirstPage
queryHaltedProcessInstances
SOAP API - queryHaltedProcessInstances
Java API - queryHaltedProcessInstances
REST API - queryHaltedProcessInstances
queryLastPage
SOAP API - queryLastPage
Java API - queryLastPage
REST API - queryLastPage
queryNextPage
SOAP API - queryNextPage
Java API - queryNextPage
REST API - queryNextPage
queryPreviousPage
SOAP API - queryPreviousPage
Java API - queryPreviousPage
REST API - queryPreviousPage
queryProcessInstanceCount
SOAP API - queryProcessInstanceCount
Java API - queryProcessInstanceCount
REST API - queryProcessInstanceCount
queryProcessInstanceCountAlt
SOAP API - queryProcessInstanceCountAlt
Java API - queryProcessInstanceCountAlt
REST API - queryProcessInstanceCountAlt - Using Query Request
REST API - queryProcessInstanceCountAlt - Using Statusmode and query Request
queryProcessInstances
SOAP API - queryProcessInstances
Java API - queryProcessInstances
REST API - queryProcessInstances
queryProcessInstancesAlt
SOAP API - queryProcessInstancesAlt
Java API - queryProcessInstancesAlt
REST API - queryProcessInstancesAlt
queryProcessTemplateCount
SOAP API - queryProcessTemplateCount
Java API - queryProcessTemplateCount
REST API - queryProcessTemplateCount
queryProcessTemplates
SOAP API - queryProcessTemplates
Java API - queryProcessTemplates
REST API - queryProcessTemplates
queryProcessTemplatesAlt
SOAP API - queryProcessTemplatesAlt
Java API - queryProcessTemplatesAlt
REST API - queryProcessTemplatesAlt
resumeHaltedProcessInstance
SOAP API - resumeHaltedProcessInstance
Java API - resumeHaltedProcessInstance
REST API - resumeHaltedProcessInstance
replaceUser
SOAP API - replaceUser
Java API - replaceUser
REST API - replaceUser
resumeHaltedProcessInstances
SOAP API - resumeHaltedProcessInstances
Java API - resumeHaltedProcessInstances
REST API - resumeHaltedProcessInstances
resumeProcessInstance
SOAP API - resumeProcessInstance
Java API - resumeProcessInstance
REST API - resumeProcessInstance
resumeProcessInstances
SOAP API - resumeProcessInstances
Java API - resumeProcessInstances
REST API - resumeProcessInstances
retryProcessInstance
SOAP API - retryProcessInstance
Java API - retryProcessInstance
REST API - retryProcessInstance
retryProcessInstances
SOAP API - retryProcessInstances
Java API - retryProcessInstances
REST API - retryProcessInstances
runAdhocActivity
SOAP API - runAdhocActivity
Java API - runAdhocActivity
REST API - runAdhocActivity
saveTerminatedProcessInstances
SOAP API - saveTerminatedProcessInstances
Java API - saveTerminatedProcessInstances
REST API - saveTerminatedProcessInstances - For all process templates
REST API - saveTerminatedProcessInstances - Passing appname
REST API - saveTerminatedProcessInstances - Passing process and module name
setAvailableProcessInstanceVariables
SOAP API - setAvailableProcessInstanceVariables
Java API - setAvailableProcessInstanceVariables
REST API - setAvailableProcessInstanceVariables
setDeadlineExpiration
SOAP API - setDeadlineExpiration
Java API - setDeadlineExpiration
REST API - setDeadlineExpiration
setMigrationRules
SOAP API - setMigrationRules
Java API - setMigrationRules
REST API - setMigrationRules
setPriority
SOAP API - setPriority
Java API - setPriority
REST API - setPriority
startProcessIncomingReceiveTask
REST API - startProcessIncomingReceiveTask
stopPurgeTerminatedProcessInstances
SOAP API - stopPurgeTerminatedProcessInstances
Java API - stopPurgeTerminatedProcessInstances
REST API - stopPurgeTerminatedProcessInstances
suspendProcessInstance
SOAP API - suspendProcessInstance
Java API - suspendProcessInstance
REST API - suspendProcessInstance
suspendProcessInstances
SOAP API - suspendProcessInstances
Java API - suspendProcessInstances
REST API - suspendProcessInstances
unsetMigrationRules
SOAP API - unsetMigrationRules
Java API - unsetMigrationRules
REST API - unsetMigrationRules
ResourceQueryService
executeQuery
SOAP API - executeQuery
Java API - executeQuery
REST API - executeQuery
REST API - executeComplexQuery
resetQueries
SOAP API - resetQueries
Java API - resetQueries
REST API - resetQueries
REST API - resetQuery
SecurityService
getUserPrivileges
SOAP API - getUserPrivileges
Java API - getUserPrivileges
REST API - getUserPrivileges
isActionAuthorised
SOAP API - isActionAuthorised
Java API - isActionAuthorised
REST API - isActionAuthorised
listActionAuthorisedEntities
SOAP API - listActionAuthorisedEntities
Java API - listActionAuthorisedEntities
REST API - listActionAuthorisedEntities
listAuthorisedOrgs
SOAP API - listAuthorisedOrgs
Java API - listAuthorisedOrgs
REST API - listAuthorisedOrgs
UserSettingsService
deleteUserSettings
SOAP API - deleteUserSettings
Java API - deleteUserSettings
REST API - deleteUserSettings
getUserSettings
SOAP API - getUserSettings
Java API - getUserSettings
REST API - getUserSettings
listUserSettingIds
SOAP API - listUserSettingIds
Java API - listUserSettingIds
REST API - listUserSettingIds
saveUserSettings
SOAP API - saveUserSettings
Java API - saveUserSettings
REST API - saveUserSettings
WorkCalService
copyCalendar
SOAP API - copyCalendar
Java API - copyCalendar
REST API - copyCalendar
deleteCalendar
SOAP API - deleteCalendar
Java API - deleteCalendar
REST API - deleteCalendar
deleteCalendarEntries
SOAP API - deleteCalendarEntries
Java API - deleteCalendarEntries
REST API - deleteCalendarEntries
listCalendars
SOAP API - listCalendars
Java API - listCalendars
REST API - listCalendars
listTimeZones
SOAP API - listTimeZones
Java API - listTimeZones
REST API - listTimeZones
getCalendar
SOAP API - getCalendar
Java API - getCalendar
REST API - getCalendar
getCalEntries
SOAP API - getCalEntries
Java API - getCalEntries
REST API - getCalEntries
purgeCalendarEntries
SOAP API - purgeCalendarEntries
Java API - purgeCalendarEntries
REST API - purgeCalendarEntries
renameCalendar
SOAP API - renameCalendar
Java API - renameCalendar
REST API - renameCalendar
resolveReferences
SOAP API - resolveReferences
Java API - resolveReferences
REST API - resolveReferences
saveCalendar
SOAP API - saveCalendar
Java API - saveCalendar
REST API - saveCalendar Create a Base Calendar
REST API - saveCalendar Create an Overlay Calendar
saveCalendarEntry
SOAP API - saveCalendarEntry
Java API - saveCalendarEntry
REST API - saveCalendarEntry Create a Working Day Exclusion
REST API - saveCalendarEntry Update a Working Day Exclusion
REST API - saveCalendarEntry Create a Recurring Exclusion
REST API - saveCalendarEntry Update a Recurring Exclusion
saveCalendarReferences
SOAP API - saveCalendarReferences
Java API - saveCalendarReferences
REST API - saveCalendarReferences Add References
REST API - saveCalendarReferences Remove References
WorkItemManagementService
allocateAndOpenWorkItem
SOAP API - allocateAndOpenWorkItem
Java API - allocateAndOpenWorkItem
REST API - allocateAndOpenWorkItem
allocateAndOpenNextWorkItem
SOAP API - allocateAndOpenNextWorkItem
Java API - allocateAndOpenNextWorkItem
REST API - allocateAndOpenNextWorkItem
allocateWorkItem
SOAP API - allocateWorkItem
Java API - allocateWorkItem
REST API - allocateWorkItem
closeWorkItem
SOAP API - closeWorkItem
Java API - closeWorkItem
REST API - closeWorkItem
completeWorkItem
SOAP API - completeWorkItem
Java API - completeWorkItem
REST API - completeWorkItem
getOfferSet
SOAP API - getOfferSet
Java API - getOfferSet
REST API - getOfferSet
getWorkItemHeader
SOAP API - getWorkItemHeader
Java API - getWorkItemHeader
REST API - getWorkItemHeader
openWorkItem
SOAP API - openWorkItem
Java API - openWorkItem
REST API - openWorkItem
pendWorkItem
SOAP API - pendWorkItem
Java API - pendWorkItem
REST API - pendWorkItem
reallocateWorkItem
SOAP API - reallocateWorkItem
Java API - reallocateWorkItem
REST API - reallocateWorkItem
reallocateWorkItemData
SOAP API - reallocateWorkItemData
Java API - reallocateWorkItemData
REST API - reallocateWorkItemData
saveOpenWorkItem
SOAP API - saveOpenWorkItem
Java API - saveOpenWorkItem
REST API - saveOpenWorkItem
setWorkItemPriority
SOAP API - setWorkItemPriority
Java API - setWorkItemPriority
REST API - setWorkItemPriority
skipWorkItem
SOAP API - skipWorkItem
Java API - skipWorkItem
REST API - skipWorkItem
unallocateWorkItem
SOAP API - unallocateWorkItem
Java API - unallocateWorkItem
REST API - unallocateWorkItem
WorkItemSchedulerService
rescheduleWorkitem
SOAP API - rescheduleWorkitem
Java API - rescheduleWorkitem
REST API - rescheduleWorkitem
WorkListService
addCurrentResourceToView
SOAP API - addCurrentResourceToView
Java API - addCurrentResourceToView
REST API - addCurrentResourceToView
createWorkListView
SOAP API - createWorkListView
Java API - createWorkListView
REST API - createWorkListView
deleteCurrentResourceFromView
SOAP API - deleteCurrentResourceFromView
Java API - deleteCurrentResourceFromView
REST API - deleteCurrentResourceFromView
deleteWorkListView
SOAP API - deleteWorkListView
Java API - deleteWorkListView
REST API - deleteWorkListView
editWorkListView
SOAP API - editWorkListView
Java API - editWorkListView
REST API - editWorkListView
getAllocatedWorkListItems
SOAP API - getAllocatedWorkListItems
Java API - getAllocatedWorkListItems
REST API - getAllocatedWorkListItems
getEditableWorkListViews
SOAP API - getEditableWorkListViews
Java API - getEditableWorkListViews
REST API - getEditableWorkListViews
getPublicWorkListViews
SOAP API - getPublicWorkListViews
Java API - getPublicWorkListViews
REST API - getPublicWorkListViews
getResourceOrderFilterCriteria
SOAP API - getResourceOrderFilterCriteria
Java API - getResourceOrderFilterCriteria
REST API - getResourceOrderFilterCriteria
getViewsForResource
SOAP API - getViewsForResource
Java API - getViewsForResource
REST API - getViewsForResource
getWorkListItems
SOAP API - getWorkListItems
Java API - getWorkListItems
REST API - getWorkListItems
REST API - getWorkListItemsAllResources
getWorkListItemsForGlobalData
SOAP API - getWorkListItemsForGlobalData
Java API - getWorkListItemsForGlobalData
REST API - getWorkListItemsForGlobalData
getWorkListItemsForView
SOAP API - getWorkListItemsForView
Java API - getWorkListItemsForView
REST API - getWorkListItemsForView
getWorkItemOrderFilter
SOAP API - getWorkItemOrderFilter
Java API - getWorkItemOrderFilter
REST API - getWorkItemOrderFilter
getWorkListViewDetails
SOAP API - getWorkListViewDetails
Java API - getWorkListViewDetails
REST API - getWorkListViewDetails
previewWorkItemFromList
SOAP API - previewWorkItemFromList
Java API - previewWorkItemFromList
REST API - previewWorkItemFromList
setResourceOrderFilterCriteria
SOAP API - setResourceOrderFilterCriteria
Java API - setResourceOrderFilterCriteria
REST API - setResourceOrderFilterCriteria
unlockWorkListView
SOAP API - unlockWorkListView
Java API - unlockWorkListView
REST API - unlockWorkListView
WorkPresentationService
cancelWorkItem
SOAP API - cancelWorkItem
Java API - cancelWorkItem
REST API - cancelWorkItem
closeWorkItem
SOAP API - closeWorkItem
Java API - closeWorkItem
REST API - closeWorkitem
completeWorkItem
SOAP API - completeWorkItem
Java API - completeWorkItem
REST API - completeWorkItem
getBusinessServiceDetailsByModule
SOAP API - getBusinessServiceDetailsByModule
Java API - getBusinessServiceDetailsByModule
REST API - getBusinessServiceDetailsByModule
openNextWorkItem
SOAP API - openNextWorkItem
Java API - openNextWorkItem
REST API - openNextWorkItem
openWorkItem
SOAP API - openWorkItem
Java API - openWorkItem
REST API - openWorkItem
System Actions
Scope of System Actions
System Actions at the Organization Model Level
System Actions at the Group Organization Unit and Position Level
System Actions and Organization Model Versions
TIBCO Forms Reference
Integrating TIBCO Forms with Custom Client Applications
Injecting the Forms Runtime Adapter in the Browser
Typical Flow of Events
iframe Integration
Forms Runtime Adapter
com.tibco.forms.client.FormRunner
com.tibco.forms.client.Form
com.tibco.forms.client.LoadStat
Auditing Customized Messages
Event Collector APIs and Customized Messages
Before you Start
Event Collector WSDLs and Services
Locating the EventCollectorAuditService WSDL
Service Virtualization
Examine the BPM Process
Get Audit Data User Task (Custom Audit 1 Details)
Custom Audit Service Task (Custom Audit 1)
Initialize Input Data
Input Mappings
Deploy and Test the ECCustomAudit Application
Deploy and Test
Create Custom Attributes
Creating a Custom Component
Creating Custom Attributes
Testing the Attributes
Event Viewer
Add the New Component
Modify the Attribute List
Add the Attribute Details
Test Event Viewer
Attributes
Get Attribute Information
Database
Event Collector Query API
API Error Messages
BusinessDeadlineService - Deprecated Operations
calcBusinessDeadline
SOAP API - calcBusinessDeadline
Java API - calcBusinessDeadline
CalendarService - Deprecated Service
updateWorkingDays
SOAP API - updateWorkingDays
Java API - updateWorkingDays
addWorkingDayExceptions
SOAP API - addWorkingDayExceptions
Java API - addWorkingDayExceptions
updateWorkingDayExceptions
SOAP API - updateWorkingDayExceptions
Java API - updateWorkingDayExceptions
deleteWorkingDayExceptions
SOAP API - deleteWorkingDayExceptions
Java API - deleteWorkingDayExceptions
getCalendarEntries
SOAP API - getCalendarEntries
Java API - getCalendarEntries
BPM Deployment
Important Information
TIBCO Documentation and Support Services
Introduction to Application Deployment
About Project Versions
Project Version Numbers
Version Usage Best Practices
How BPM Handles Organization Model Versions at Deployment
Amending Version Numbers
Changing the Major Version Number of an Organization Model
Deploying BPM Applications
Deployment from TIBCO Business Studio Direct Or DAA Export
Deploying a Process That Exposes a Web Service
Deploying a Global Signal Definition Project
Business Process Execution Language (BPEL) and Deployment
Preparation for Deployment
Creating a New Deployment Server
Local Development Server
Enabling Deployment Over Secured (https) Communications for a Deployment Server
Connecting to a Deployment Server
Refreshing a Deployment Server
Disconnecting From a Deployment Server
Viewing and Changing Deployment Server Properties
Accessing Runtime Clients and Administrator Server from TIBCO Business Studio
Deploying an Application from TIBCO Business Studio
Deploying an Application Using the Deployment Wizard
Deployment of Global Signal Definition Project and Process with Global Signal Events
Deploying an Application by Dragging and Dropping
Verifying the Deployment
Exporting to DAA
DAA Validation
Deploying an Application from Administrator
Deployed Applications
Deploying the Organization Model
Deploying a BPM Application Fails If the Referenced Organization Model Has Been Upgraded
Deployment to Multiple BPM Systems
Re-Deploying for Live Development a Project that Has Changed
Re-Deploy/Upgrade of a Global Signal Definition Run-time Application
Scripted Deployment
Custom version of command line ant runner on AIX platform
Creating a Deployment Project
Adding Resources to the Deployment Project
Specifying the Server
Configuring the Resources in the Deployment Project
Generating the Deployment Scripts
Modifying a Deployment Project
Adding a Resource
Removing a Resource
Reconfiguring a Resource
Changing the Deployment Order of Resources
Executing the Deployment Script
Checking in and out of a Repository
Deploying the Project
Sample Projects - Shared Resource Create Install and Subversion (SVN)
Creating Installing Shared Resources
Using Subversion
Undeployment
Undeploying an Application Directly from TIBCO Business Studio
Undeploying an Application Using Administrator
Undeploying an Application Using a Deployment Script
Tips for Successful Undeployment
Cleaning Up Undeployed Applications
Application Upgrade
Upgrading a Deployed Application
Reverting to the Original Version of an Upgraded Application
Upgrading an Application Using a Deployment Server
Upgrading an Application Using a Deployment Script
Deploying Language Packs
Web Client API Developer's Guide
Important Information
TIBCO Documentation and Support Services
TIBCO ActiveMatrix BPM Web Client API
TIBCO ActiveMatrix BPM Web Client API Components and Services
Web Client API jar Files
Authenticating Access to a TIBCO ActiveMatrix BPM Web Client Service
Accessing Ad-hoc Activities in a Custom Client
Web Application Development
Creating a New Web Application Project
Enabling Openspace Gadget Contribution
Creating an Openspace Gadget
About Gadget Development
Enabling Managed Events
Compiling Your Web Application Project
Exporting and Deploying Your Openspace Gadget
Viewing the Gadget Specification in a Browser
Contributing Your Openspace Gadget
Configure the Gadget Hub Policy
Web Client API Service
Authentication
GetAuthenticatedGuid
GetAuthenticatedUserName
IsActionAuthorised
Business Services
GetBusinessServices
ListBusinessServiceCategories
StartBusinessService
UpdateBusinessService
Calendar Services
CopyCalendar
DeleteCalendar
DeleteCalendarEntries
GetCalendarEntries
GetCalendarReferences
GetWorkCalendar
ListCalendars
ListTimeZones
PurgeCalendarEntries
RemoveCalendarReference
RenameCalendar
ResolveReferences
SaveCalendar
SaveCalendarEntry
SaveCalendarReference
SetCalendarReferences
Dataview Client Service
CreateDataView
EditDataView
Login Services
LoginAction
Logout Services
LogOutAction
Organization Model Services
GetEntityName
GetResourceDetails
OpenOrgModel
RunResourceQuery
Process Template Services
CancelProcessInstance
GetEventDurationsFromEC
GetMigrationPoints
GetProcessInstanceData
GetProcessInstancesFromEC
GetProcessInstanceStatus
GetProcessTemplateList
IgnoreHaltedProcessInstance
ListMigrationRules
QueryEventCollector
QueryHaltedProcessInstances
QueryProcessInstances
QueryProcessTemplates
ResumeHaltedProcessInstance
ResumeProcessInstance
RetryHaltedProcessInstance
SetMigrationRules
StartProcess
SuspendProcessInstance
Session
InvalidateSession
SetSessionMaxInactiveInterval
Work Item Services
AllocateWorkItem
CancelWorkItem
CloseWorkItem
CloseWorkItems
CompleteWorkItem
GetOrderandFilterForResource
GetOrgEntityConfigAttribute
GetOfferSet
GetToDoList
OpenNextWorkItem
OpenWorkItem
PendWorkItemByDate
PendWorkItemByPeriod
PrioritiseWorkItem
ReAllocateWorkItem
SetOrderAndFilterForResource
SetOrgEntityConfigAttribute
ReofferWorkItem
SkipWorkItem
Work Views Services
CreateWorkListView
DeleteResourceFromView
DeleteWorkListView
EditWorkListView
GetEditableWorkViews
GetPublicWorkViews
GetWorkItemsForView
GetWorkViewDetails
GetWorkViewsForResource
UnlockWorkListView
Using Wild Card Characters
Constraints for Contributing Gadgets in Openspace
Event Collector Schema Reference
Important Information
TIBCO Documentation and Support Services
Event Collector Overview
Private Database Tables
ec_array table
ec_attribute table
ec_component table
ec_case_status table
ec_environment table
ec_deployed_component table
ec_event view
ec_event_attr table
ec_message table
ec_pe_status table
ec_proc_template table
ec_user_activity table
ec_wi_status table
ec_pe_activity table
Integration with Content Management Systems
Important Information
TIBCO Documentation and Support Services
Content Management Interoperability Services
BPM Sample CMIS Application
Prerequisites
Installing the BPM Sample CMIS Application
Components of the BPM Sample CMIS Project
BPM CMIS Sample BOM Objects
BPM CMIS Sample Organization Model
BPM CMIS Sample Forms
BPM CMIS Sample Business Process
Configuring the BPM CMIS Sample Application
Running the BPM CMIS Sample in Preview
Deploying and Running the BPM CMIS Sample
The cmisproxyconfig.properties File
Repositories and User Identification
Whitelist Addresses
Custom Client Application Development
TIBCO ActiveMatrix® BPM Client Application Management Guide
Important Information
TIBCO Documentation and Support Services
Client Application Development
TIBCO Mobilespace
Applications
Application Lifecycle
Application Version Control
Revert to a Previous Application Version
Revert or Delete an Application Version
Editing and Publishing
Setting Logging on Applications
Manage Client Applications
How to Access Application Development
How to Set the Session Timeout
Edit an Application
Clone an Application
Launch and Test an Application
Upload an Application
Delete an Application
Publish an Application
Mobile Application Settings
Control Application Permissions
Export an Application
Work Offline With Application Development
Application Roles
Creating Application Roles
The roles.map.json File
Mapping Roles to Applications and Components
Application Roles Configuration Files
Viewing and Editing Application Roles Configuration Files
Uploading Roles
Deleting Roles
Mapping Organization Model Positions to Application Roles
Using the Roles Example
Localizing Applications
Application Localization
Creating Language Packs
Importing Language Packs
Exporting Language Packs
Editing Phrases in a Locale
Configuring a Fallback Chain for a Locale
Deleting Locales
Customizing the Workapp Application
Cloning the Workapp Application
Localizing Your Customized Application
Customizing the Workapp Application Custom Templates
Application Development System Actions
TIBCO ActiveMatrix® BPM Client Application Developer's Guide
Important Information
TIBCO Documentation and Support Services
Overview of the Client Application Framework
Custom Client Application
Example Applications
Bundled Applications
Using the openworkitem Application in Your Application
Using the startbizaction Application in Your Application
Hosting Applications on External Web Servers
Configure a Theme for a Custom Client Application
Theme Color Definitions
Internationalizing Applications
Internationalizing a Cloned Workapp Application
Internationalizing a Custom Application
BPMTranslationService
LocaleInfoModel
BPMTranslationServiceConfig
getLocaleInfo
registerApp
unregisterApp
App CDN
Business Components
Component Showcase Application
BUSINESS ACTIONS
START BIZ ACTION
WORK ITEM DETAILS
Case Management Application
Configure the Case Management Application
Mobile Case Manager Application
Configure the Mobile Case Manager Application
Adding a Business Component to Your Application
Customizing a Business Component
Business Components Reference
bpm-attributes-view
bpm-business-actions-drop-down
bpm-case-actions
bpm-case-data
bpm-case-details-page
bpm-case-event-view
bpm-case-instance-summary
bpm-case-states
bpm-case-types
bpm-comments
bpm-document-upload
bpm-event-view
bpm-highcharts
Define a Data Model in the Controller
Define a Chart Configuration Object in the Controller
Call the getChart Operation from the Controller
Include the Highcharts Library in your HTML File
bpm-linked-case-instances
bpm-login
bpm-process-view
bpm-summary-view
bpm-work-item-history
bpm-work-list
bpm-work-views
documents-view
mbpm-case-actions
mbpm-case-creator
mbpm-case-data
mbpm-case-event-view
mbpm-case-instance-summary
mbpm-case-states
mbpm-case-types
mbpm-comments
mbpm-documents
mbpm-document-upload
mbpm-work-list
work-item-data
work-item-detail-nav
workListData Object
workViewData Object
Business Component Services
Invoking a Business Component Service Operation From Your Application
Suppressing Errors Displayed by Business Component Services
Using the Lightweight TIBCO Component Framework
Business Component Services Reference
BPMBusinessActionsService
BizActionHandler
BusinessActionsServiceModel
StartBusinessActionServiceModel
fetchChildCategories
fetchTopCategories
startBizAction
BPMCaseEventViewService
CaseEventViewModel
getSearchCaseReport
BPMChartService
ChartModel
getChart
getChartData
BPMCommentService
CommentModel
addCaseComment
addProcessInstanceComment
addWorkItemComment
getCaseComments
getProcInstComments
getWorkItemComments
BPMEventViewService
EventViewModel
getEventView
BPMLoginService
LoginServiceModel
getExtendedUserInfo
getUserInfo
login
logout
BPMWorkItemDetailsService
WorkItemDetailsModel
fetchWorkItem
populateWorkItemAttributes
populateWorkItemData
populateWorkItemDetails
populateWorkItemProcessDetails
BPMWorkItemHistoryService
WorkItemHistoryModel
getWorkItemHistory
BPMWorklistService
OpenWorkitemServiceModel
WorklistServiceModel
allocateWorkItem
getViewsForResource
getWorklistItems
getWorkListItemsForGlobalData
getWorkListItemsForView
openNextWorkItem
openWorkItem
unallocateWorkItem
CaseDocumentService
CaseDocumentServiceModel
deleteDocument
deleteOrphanedFolders
downloadDocument
fetchDocuments
openDocument
CaseInformationService
CaseInformationServiceModel
getCaseData
getCaseInformation
listCaseActions
CaseManagementService
CaseManagementModel
findAllCases
getCaseData
getCaseInformation
getCaseStates
getRelatedCases
listCaseActions
listCaseTypes
objectAPI
objectAPI Configuration
objectAPI Reference
RestApiService
AuditService
Purge Audit Status
BusinessDeadlineService
Duration Definitions
Minimum Hours in Working Day Calculations
BusinessServiceService
CaseActionService
DirectoryService
DocumentService
Queries for findDocuments
DynamicResourceQueryService
EntityResolverService
ExporterService
GlobaldataAdminService
GlobaldataService
OrgEntityConfigService
OrgModelService
OrgResourceService
PageFlowService
ProcessManagementService
ResourceQueryService
RoleService
SecurityService
StatisticsService
UserSettingsService
WorkCalService
WorkItemManagementService
WorkListService
WorkPresentationService
Using the objectAPI in BPM Applications
Organization Models and LDAP
Navigating the Organization Model
Navigating Large Organization Models
Organization Model Entity Properties
Creating an LDAP Container
Creating an LDAP Container Using an LDAP Query Source
Creating an LDAP Container Using an LDAP Group Source
Defining Secondary LDAP Sources in an LDAP Container
LDAP Queries
Mapping Users
Resource Attributes
Setting Resource Attribute Values
Mapping Resource Attributes to LDAP Attributes
Organization Relationships
Overriding Organization Relationships
Moving a Resource to Different LDAP Container
Updating Push Destinations
Updating Push Destinations for Organizational Entities
Updating Push Destinations for Resources
Configuring a Dynamic Organization Model Extension Point
Candidate Queries
Configuring a Candidate Query
Removing a Candidate Query Configuration
Processes
Listing Available Process Templates
Starting a Process Instance
Listing Available Process Instances
Sorting and Filtering Lists of Process Templates and Instances
Query Parameter Syntax
Query Parameter Attributes
Using User-Defined Attributes
Query Parameter Operators
Using Wildcards
Date Time Data Type Specification
Query Parameter Examples
Process Instance State Transitions
Handling Process Instance Failures
Migrating a Process Instance to a Different Version
Migration Points
Migration Rules
How Process Instances Are Migrated
Process Migration Functions
Business Services
Starting a Business Service
Injecting Data into a Business Service
Pageflows
Starting and Processing a Pageflow
Injecting Data into a Pageflow
Work Lists and Work List Views
Work Lists
Retrieving a Work List
Sorting and Filtering Work Lists
Sort and Filter Expression Syntax
Wildcard Characters
Sort Expressions
Sort Filter Criteria
Using DateTime Fields
Using DateTime Ranges
Using Work Item Attribute Fields
Work List Views
Creating a Work List View
Custom Data
Sorting and Filtering Work List Views
Work List View Access
Editing Work List Views
Using Work List Views
Retrieving Work Items from a Work List View
Retrieving a List of Work Views for a Resource
Public Work List Views
Creating and Managing Supervised Work List Views
Creating and Managing Supervised Work List Views - Example 1
Creating and Managing Supervised Work List Views - Example 2
Deleting Work List Views
Work Items
Work Item Versions
Work Item States
Work Item State Transitions
Retrieving Information on Work Items
Offering and Allocating Work Items
Allocating a Work Item to a Target Resource
Reallocating a Work Item
Reallocating to Offer Set or to World
Reoffering a Work Item
Required System Actions
Opening a Work Item
Processing a Work Item
openWorkItem
closeWorkItem
completeWorkItem
cancelWorkItem
skipWorkItem
saveOpenWorkItem
pendWorkItem
rescheduleWorkItem
setWorkItemPriority
Example of Processing a Work Item
Example of Processing a Work Item with a Form
Processing Chained Work Items
Handling a Work Item That Contains Business Data
Accessing Hidden Work Items
Case Data Models
Retrieving Case Model Database Scripts
Forms
TIBCO Forms
Binding the Client Application to a Channel
Identifying the Client Channel in a Service Call
Rendering a TIBCO Business Studio Form
Custom Forms
Presentation Details
Data Format and Structures
Displaying a Work Item Form
Displaying a Form in a Pageflow
Displaying a Form in a Business Service
Integrating TIBCO Forms with Custom Client Applications
Injecting the Forms Runtime Adapter in the Browser
Typical Flow of Events
iframe Integration
Forms Runtime Adapter
com.tibco.forms.client.FormRunner
com.tibco.forms.client.Form
com.tibco.forms.client.LoadStat
Events
Executing a Query
Dynamic Queries
Registered Queries
Correlated Events
Defining Query Filter Strings
Filter Expression Format
Functions
Operands
Using String Literals
Using DateTime Literals
Using Late-Bound Parameter Literals
Operators
Using Attributes in Query Filters
AUDIT Option Attributes
CASE_STATS Option Attributes
PROCESS_STATS Option Attributes
PROCESS_TEMPLATES Attributes
REGISTERED_ATTRIBUTES Option Attributes
REGISTERED_COMPONENTS Option Attributes
REGISTERED_QUERIES Option Attributes
USER_ACTIVITY Option Attributes
WORKITEM_STATS Option Attributes
Message Categories and Attribute Contents
Example Queries
Event Measures
Purging Audit Data
Calendars
Base and Overlay Calendars
Exclusions
Time Zones
Calendar References
Assigning a Calendar Reference to a Calendar
Calendars and User Tasks
Creating Calendars
Identifying Calendars
Adding Recurring Exclusions
Recurrence Rule
Scheduling
Scheduling Example
Comments
System Actions
Administration and Reports
BPM Administration
Important Information
TIBCO Documentation and Support Services
Configuring TIBCO ActiveMatrix BPM to Use a New LDAP Directory Server
Configuring a New LDAP Shared Resource for TIBCO ActiveMatrix BPM
Creating an LDAP Connection Resource Template
Configuring the LDAP Connection to use LDAP Over SSL (LDAPS)
Creating an LDAP Authentication Resource Template
Redeploying BPM
Changing the tibco-admin User’s Password
BPM Properties Files
Properties Files Reference
Business Data Services Properties (bds.properties)
Content Management Properties (cm.properties)
Configuring TIBCO ActiveMatrix BPM Resource Management
Sort Criteria
Tuning Properties
Configuring TIBCO ActiveMatrix Calendar Properties
Configuration of the TIBCO ActiveMatrix BPM Directory Engine
Configuring the Admin User
Case-Sensitivity at Login
Specification of the Page Size to be Used to Return Search Results
Use of the n2-auth Login Application
Use of Binary Attributes
Configuration of the Email Presentation Channel
Changing the Location for Email Notifications
Configuration of the Push Channel in TIBCO ActiveMatrix BPM
Configuring Which Work Item Version is Linked from Push Emails
Deployment of Applications that Use Unsupported GI Presentation Channels
Configuring TIBCO ActiveMatrix BPM to Work with Openspace
Work Management
User Sessions
Gadgets
Logger Gadget
Configuration of the Pageflow Engine
Configuration of Chained Work Patterns in TIBCO ActiveMatrix BPM
Configuration of TIBCO ActiveMatrix BPM Form Locations
Using BPM Clients
Using BPM APIs
Using a Proxy Server
Publication of BPM Audit Data to a Java Message Service (JMS) Topic
Create or Edit a JMS Topic Configuration File
Supported JMS Message Format
Publishing BPM Audit Data Using an Administrator Shared Resource
Creating Shared Resources to Publish BPM Audit (SSL Enabled)
Creating a Shared Resource to Publish BPM Audit Data (Non-SSL)
Configuration of Error Handling Behavior for Process Instances
suspendOnError
Handling Process Instances That Are Suspended Because of an Activity Error
Configuring suspendOnError
Upgrading Process Applications to Use haltOnError
haltOnError
Handling Process Instances That Are Halted Because of an Activity Error
Configuring haltOnError
Activity Retry Settings
Configuring System-Wide Activity Retry Settings
Configuration of Per-Activity Retry Settings in TIBCO Business Studio
Defining Logging Information
Defining Where your Logging Output is Stored
Configuring TIBCO ActiveMatrix BPM Auditing
File Format
Auditing Level
Audit Rules File
Default Audit Level
Editing the Audit Rules File
Including All Audit-Level Messages
Tailoring the AuditMessages List
Auditing WARN or FATAL Messages
Audit of Custom Work Item Attributes
Auditing and Publishing Messages
Event Rules File
Full Auditing
Default Publication
Archiving Messages
Configuring How BPM Audit Messages are Auto-archived
Configuring Which System Event Messages are Archived
Configuring Apache Cassandra as an External Audit Message Store
Monitoring ActiveMatrix BPM Using TIBCO Hawk Rulebases
Configuration of the TIBCO Hawk Rulebases
Rulebase Files
Editing the Rulebase Files
Use of the TIBCO Hawk Rulebases
Importing the Rulebases into TIBCO Hawk
Generation of Hawk Rulebases from the Command Line
Tuning ActiveMatrix BPM
Enabling SSL for TIBCO ActiveMatrix BPM
Enabling SSL Communication with TIBCO ActiveMatrix BPM Runtime Clients
Replacing the Default Self-Signed Certificate with a CA-Authorized Certificate
Enabling SSL on an LDAP Connection
Configuring ActiveMatrix BPM to Use Single Sign-On
Support for CORS
Configure the CORS implementation
Default Properties and Substitution Variables for the CORS implementation
Housekeeping Tasks
Clearing Audit and Statistical Data for Process Instances
Stored Procedure for DB2
Installing the Stored Procedure for DB2
Running the Stored Procedure for DB2
Reorganizing the Event Collector database tables
Examples
Stored Procedure for Microsoft SQL Server
Installing the Stored Procedure for Microsoft SQL Server
Running the Stored Procedure for Microsoft SQL Server
Examples
Stored Procedure for Oracle
Installing the Stored Procedure for Oracle
Running the Stored Procedure for Oracle
Examples
Clearing Audit and Statistical Data for Process Instances Across Multiple Sessions
Running Stored Procedure for Microsoft SQL Server
Stored Procedure for Oracle
Clearing Audit and Statistical Data Not Related to a Process Instance
Stored Procedure for DB2
Installing the Stored Procedure for DB2
Running the Stored Procedure for DB2
Stored Procedure for Microsoft SQL Server
Installing the Stored Procedure for Microsoft SQL Server
Running the Stored Procedure for Microsoft SQL Server
Stored Procedure for Oracle
Installing the Stored Procedure for Oracle
Running the Stored Procedure for Oracle
Purging Processes through the Command Line Interface
Undelivered Work Items
Determining Why a Work Item was Undelivered
Changing the ActiveMatrix BPM Database Password
Using TIBCO Configuration Tool
Using ActiveMatrix Administrator
Changing the CMS Server Password
Moving the ActiveMatrix BPM Database
JDBC Connection String Formats
Configuring Business Data Services to Use a Separate Database
JDBC Connection String Formats
Configuring Business Data Services to Use a CMS
Changing the Version of SOAP Used by ActiveMatrix BPM
Moving an ActiveMatrix Host
Setting How Many Templates Can Be Listed in the Workspace "Start Process Instance" Dialog
List of Messages
Auditable Messages
Message Categories and Attribute Contents
CALENDAR
CALENDAR_API_SECURITY
CANDIDATE_QUERY
CHANNEL
DAC_API_SECURITY
COMPONENT
EVENT
GLOBAL_DATA
GLOBAL_DATA_ADMIN
LDAP_CONTAINER
LDAP_REQUEST
ORG_MODEL
ORGANIZATIONAL_ENTITY
PAGE_FLOW
PROCESS_INSTANCE
PROCESS_TEMPLATE
RESOURCE
RQL_REQUEST
SCRIPT_TYPE
SECURITY
UNSET
WORK_GROUP
WORK_ITEM
WORK_MODEL
WORK_TYPE
List of Process Engine Error Codes
SOA Administration
Important Information
TIBCO Documentation and Support Services
Introduction to Administrator
Components and Servers
Using the Web Interface
Logging in to the Web Interface
Understanding Administrator Object States
Runtime State
Runtime States
Action History
Action History Reference
Outstanding Actions
Synchronization
Using Command-Line Interface
Location of Sample Files
Invoking the Command-Line Interface
Understanding Build Files
Understanding AMXAdminTask
Understanding Data Files
Actions Performed Using CLI
Undertstanding Objects
Supported Objects
Object Formats
Object Navigation
Inter-Object Relationships
Property File Reference
Managing the Administrator Server
Administration Support for Older Hosts and Nodes
Creating an Administrator Server
Editing Server Configurations
DDL Script Generator
Starting and Stopping an Administrator Server
Administrator Configuration Reference
Default Ports Used by Servers
Plug-Ins
Plug-Ins Reference
Notification Server
Editing the Notification Server Configuration
Forcing a Reconnection
Authentication Realms
Administrator Replication
Creating an Environment
Configuring an Environments Messaging Bus
Environment General Reference
Environment Configuration Reference
Messaging Bus Reference
Using Diagnostics
Accessing and Using Diagnostics Commands
Retrieving Log Files for Hosts and Nodes from Administrator
Managing Hosts
Host Processes
Creating a TIBCO Host Instance
Assigning a Host to An Environment
Registering a TIBCO Host Instance as a Windows Service
Starting a TIBCO Host Instance
Stopping a TIBCO Host Instance
Enabling Secure Communication between a Host and an Administrator Server
Unregistering Hosts
Binding Hosts to an Administrator Server
Discover Hosts Reference
Register Host Reference
References
Hosts Reference
Host General Reference
Host Configuration Reference
Host Substitution Variables Reference
Host Resource Instances Reference
Managing Nodes
Node Processes
Developer Node
Navigating to a Nodes List
Creating a Node
Editing a Node
Updating the Port Number for a Node
Updating the JVM Configuration for a Node
Enabling and Disabling the Java Security Manager
Enabling and Disabling Debuggers
Installing or Syncing Nodes
Uninstalling Nodes
Starting Nodes
Manually Restarting Nodes
Stopping Nodes
Deleting Nodes
References
Nodes Reference
Node General Reference
Node Configuration Reference
Node Substitution Variables Reference
Node Resource Instances Reference
Transaction Recovery Configuration
Configuration Properties for HOWL Log Files
Deleting HOWL Logs
Managing Applications
Creating an Application
Distribution Modes
Distributing an Application
Application Dependencies
Deploying Applications
Undeploying Applications
Starting Applications
Stopping Applications
Deleting Applications
Editing an Application
Upgrading an Application
Upgrading an Application across Nodes
Applications Reference
Displaying an Applications Dependencies
Displaying an Applications Components
Displaying an Applications Bindings
Application General Reference
Application Configuration Reference
Application Substitution Variables Reference
Application Distribution Reference
Application Folders
Creating a Folder
Renaming a Folder
Deleting a Folder
Moving an Application to a Folder
Properties
Setting a Property Value
Editable Properties Reference
Non-Editable and Policy Set Properties Reference
Services and References
Displaying the Bindings for a Service or a Reference
Adding a Binding to a Service
Configuring a Binding for a Reference
Promoting a Service to the Environment
Promoting a Reference to the Environment
Reference Details Reference
Manual Binding Reference
Bindings
SOAP Bindings
Starting and Stopping Bindings
Generating a WSDL File for a SOAP Service Binding Instance
SOAP Binding Reference
WS-Addressing
Endpoint References
Message Addressing Properties
Validation and Fault Handling
Configuring the Action Property
WS-Reliable Messaging
JMS Bindings
JMS Binding Reference
Wire to Binding Reference
Managing Resource Templates
Resource Templates With Scope
Creating a Resource Template
Editing a Resource Template
Incremental Editing of a Resource Template
Renaming a Resource Template
Changing the Scope of a Resource Template
Deleting Resource Templates
Creating an Obfuscated Password
Configuring Mutual Authentication
Configuring Third-Party JDBC Drivers
Adding an Updated JDBC Driver
Configuring Third-Party JMS Drivers
Configuring the Read Response Timeout for an LDAP Connection
Keystores
Creating a Keystore Containing a User Name and Password
References
Hibernate
HTTP Client
HTTP Connector
JDBC
JMS Resource Templates
JMS Connection Factory
JMS Connection Factory Configuration
JMS Destination
JMS Destination Configuration
JNDI Connection Configuration
LDAP Connection
SMTP
Teneo
Thread Pool
Security Resource Templates
Identity Provider
Kerberos Authentication
Kerberos Identity Provider
Keystore Provider
Keystores
Creating a Keystore Containing a User Name and Password
LDAP Authentication
Mutual Identity Provider
SiteMinder Authentication
SSL Client Provider
SSL Server Provider
Trust Provider
WSS Authentication
Managing Resource Instances
Creating Resource Instances on Nodes
Installing Resource Instances on Nodes
Uninstalling Resource Instances from Nodes
Deleting Resource Instances from Nodes
Resource Instances Reference
Substitution Variables
Creating a Substitution Variable
How Substitution Variables Are Resolved
Software Management
Adding Features to the Enterprise
Adding a Feature to a Node
Adding Third-Party Libraries to Nodes
Setting Node Features
Removing Features from a Node
Deleting Features from the Enterprise
Adding Application Templates to the Enterprise
Deleting Application Templates
Feature Reference
Features Reference
Application Template Reference
Versions
Distributed Application Archives
Uploading a Distributed Application Archive
Distributed Application Archive Reference
Monitoring
Monitoring Service
Disabling the Monitoring Service
Enabling and Disabling Extended Monitoring
Configuring a Fault Tolerant Monitoring Service
Updating the Messaging Configuration
Metrics Reference
Log Viewer
Running Searches
Search Builder
Filter Area
Adding and Removing Filters
Event Models
Base Event Format Attribute Reference
Engine Event Format Attribute Reference
BW Engine Event Format Attribute Reference
Log Table
Deleting Log Entries
Dashboards
Displaying the Dashboards
Filter Criteria Gadget
Setting Dashboard Preferences
Drilling Down into Objects
Dashboard Controls
Users, Groups, and Permissions
Creating a User
Changing a User Password
Resetting a User Password
Assigning Superuser Privileges
Removing Superuser Privileges
Adding Users to Groups
Removing Users from Groups
Creating a Root Group
Creating a Subgroup
Deleting a Group
Setting Object-Specific Permissions
Setting Enterprise Permissions
Permission Reference
Groups
Superusers
Users
Permissions
System Logging
Log Services
Editing Log Service Properties
Log Service Property Reference
Logging Appenders
Creating a Logging Appender
Logging Appender Reference
Log Entry Enrichment
Logging Configurations
Navigating to a Logging Configurations List
Creating a Logging Configuration for a Host or a Node
Applying a Logging Configuration
Logging Configuration Reference
Payload Services
Payload Service Properties Reference
Creating Additional Log and Payload Services
Secure Communication Channels
Trust Stores
Creating a Trust Store Keystore
Configuring a Trust Store
Enabling Secure Communication Channels Using Command-Line Scripts
Installing Unlimited Jurisdiction Files
TIBCO Credential Service
Network Configuration
IPv6 Support
Port Usage
UDDI Servers
Registering an SSL-Enabled UDDI Server
Registering a UDDI Server
Setting the Default UDDI Server
Configuring SSL Communication
Publishing Services in a UDDI Server
References
UDDI Server Reference
Application UDDI Publication Reference
NodeUtil
Invoking the NodeUtil Utility
NodeUtil Commands
Troubleshooting
Single Sign-On
Important Information
TIBCO Documentation and Support Services
Introduction to Single Sign-On Authentication
Installation and Configuration for Authentication
Using X.509 Certificates or SAML Tokens for SSO Authentication
Configuring ActiveMatrix BPM to Access a Client’s Public Certificate
SSO Authentication Using an X.509 Certificate
SSO Authentication Using a SAML Token
Implementing SSO Authentication Using a SAML Token
Using a SAML Token to Authenticate a .NET Client Application
Using a SAML Token to Authenticate a .NET Client Application - An Example
System Requirements
Getting the SAMLAuthDemo Solution
How to Use the SAMLAuthDemo Example
Create and Set Up the Required Security Credentials
Configure John Eustace as a BPM User
Build and Run SAMLAuthDemo
How the SAMLAuthDemo Application Works
Example SOAP Envelope
Example Log File Entry
Handling Time Differences when using Validity Periods in a SAML Assertion
Using the Service Connector SamlSenderVouchesSecurityHandler Method
Establishing a Trust Relationship Between TIBCO ActiveMatrix BPM and the Client Application
Performing Runtime Authentication
Using TIBCO ActiveMatrix BPM as the Authority for SSO Authentication
Creating the Public Root Certificate and BPM Truststore
Generating a Client Certificate and Keystore
Creating a SAML Assertion
Using SiteMinder with ActiveMatrix BPM
Supported SiteMinder Use Cases
SiteMinder Use Case: Single Sign-On to Openspace and Workspace
SiteMinder Use Case: Single Sign-On to Openspace (or Workspace) and ActiveMatrix BPM REST Services
SiteMinder Use Case: Single Sign-On to Custom Web Application and Openspace (or Workspace)
Configuring ActiveMatrix BPM to Use SiteMinder
Using the Edit TIBCO ActiveMatrix BPM Instance Wizard
Using ActiveMatrix Administrator
Editing Substitution Variables for SiteMinder
Configuring Openspace to Use SiteMinder
Configuring Workspace to Use SiteMinder
Using Kerberos with ActiveMatrix BPM
Supported Kerberos Use Cases
Kerberos Use Case: Single Sign-On to Windows, Workspace, and Openspace
Kerberos Use Case: Single Sign-On to Custom .NET Application and ActiveMatrix BPM REST Services
Configuring ActiveMatrix BPM to Use Kerberos
Using the Edit TIBCO ActiveMatrix BPM Instance Wizard
Using ActiveMatrix Administrator
Increasing the HTTP Header Buffer Size for Kerberos
Editing Substitution Variables for Kerberos
Configuring Openspace to Use Kerberos
Configuring Workspace to Use Kerberos
Configuring Web Browsers for Kerberos
Kerberos Security
Kerberos & Active Directory Security
How to Configure an SPN Account for an Active Directory Domain Controller
Performance Tuning Guide
Important Information
TIBCO Documentation and Support Services
Tuning Overview
System Monitoring
Monitoring and Alerting
CPU Usage
Memory
Disk
Network
Operating System Configuration
Maximum Open File Descriptors
Non-Uniform Memory Access (NUMA) Systems
Database Tuning
Oracle Tuning
Database Disk Configuration
Redo Logs
Memory Configuration
Configuring Locking Operation on Retry When Receiving/Retrieving a Message
Parameter Configuration
Monitoring
SQL Execution Plans
Tune SQL Execution Plans
DB2 Tuning
Microsoft SQL Server Tuning
Virtual Machines
Virtual Machine Stuns
Time Drift
Java Virtual Machines (JVMs)
JVM Monitoring
JConsole
JVisualVM
jstat
JVMInfo
Hawk
Oracle JVM Options
Default JVM Settings
Changing the Value of -Xmx
Changing the Value of MaxPermSize
Other JVM Settings
Java Heap Memory
Permanent Heap
Thread Stack Size
Garbage Collection
Miscellaneous JVM Options
Information Resources
IBM JVM Options
AIX Settings
JVM Threads
ActiveMatrix BPM Configuration
Setting the ActiveMatrix BPM Tuning Options
TIBCO Configuration Tool (TCT)
Transaction Log File
BPM Threads
Sequence Caching
Auditing Levels
JDBC Resources
Maximum Connections
Prepared Statement Cache Size
Turning off JDBC Connection Validation
Deallocating Unused JDBC Connections
HTTP Connectors
Memory Usage
HTTP Client
Background Processing
Process Manager (PM)
Business Resource Management (BRM)
Event Collector (EC)
Statistics Collector (SC)
Thread Pools
Process Engine (PVM)
User Application (UserApp)
BPM Filtering and Sorting of Work Lists and Audit Entries
BPM Nodes
Configuring How Often the Process Engine Looks for Work Requests
Locking of Signal Definitions
Expired Signals Job
Maximum Listener Count
Configuring the Maximum Number of Tasks per Process Instance
Configuring Cleanup of the PVM_WORK_ITEM or PVM_REQUEST_QUEUE Database Tables
JVM Properties Reference
Load Balancer
Process Design
LDAP
Windows Tools
BPM Log Viewer
Important Information
TIBCO Documentation and Support Services
Log Viewer
Running Log Viewer
Loading Log Files
Loading Event Collector Audit Data From a Database
Using Log File Views
Highlighting Log Entries
Configuring Log Viewer Columns
Filtering Log Files
Using Custom Attributes
Viewing Log Entries
Searching Log Files
Browsing Log Files
Analyzing Log Files
Using Log Viewer Configuration Files
Hawk Plug-in User's Guide
Important Information
TIBCO Documentation and Support Services
TIBCO Hawk ActiveMatrix Plug-in Overview
ActiveMatrix Host Microagent and Service Microagent
Monitoring Architecture
ActiveMatrix 3.2 Monitoring Service Application
ActiveMatrix Host Microagent
isHostRunning
getHostInfo
getNodeInfo
onHostEvent
onNodeEvent
startNode
stopNode
Common Logging Event Publisher Microagent
startPublisher
stopPublisher
startAllPublishers
stopAllPublishers
getEventPublisherInfo
getEventDataSourceDetails
reloadEventDefinitions
Sample Event Definitions Configuration to CLEvents from Hawk
ActiveMatrix Service Microagent
getConfig
changeMonitoringConfig
getComponentInfo
getBindingInfo
onComponentEvent
onBindingEvent
getBindingOperationStats
getComponentOperationStats
onBindingOperationStats
onComponentOperationStats
Service Execution Stats
Spotfire Visualizations
Important Information
TIBCO Documentation and Support Services
BPM Spotfire Visualizations
BPM Spotfire Visualizations and Event Collector
BPM Spotfire Analysis File
Pre-requisites for Using BPM Spotfire Template Visualizations
Opening the BPM Spotfire Analysis File
Replacing Data in the BPM Spotfire Analysis File
Displaying Work Item Facade Display Labels in BPM Spotfire Visualizations
BPM Spotfire Operational Visualizations
BPM Spotfire Performance Visualizations
Using JasperReports with TIBCO ActiveMatrix® BPM
Important Information
TIBCO Documentation and Support Services
IMPORTANT: Restricted Use Case Licensing for Bundled TIBCO JasperReports for ActiveMatrix BPM
Using TIBCO JasperReports for ActiveMatrix BPM to Visualize TIBCO ActiveMatrix BPM Data
Example Files Reference
Setting up the Example Dashboards
Software Requirements to Use the Example Dashboards
Deploying and Setting up the Example BPM Claims Application
Deploying the Claims Application DAAs to the BPM Runtime
Mapping Users from the EasyAs LDAP Source to the Claims Organization Model
Generating Sample Data for the BPM Claims Application
Importing Jaspersoft Resources Used by the Example Dashboards to JasperReports Server
Configuring the Example JDBC Datasources
Adding the Example Dashboard Gadgets to Openspace
Changing the Default URL Used by the Openspace Gadget Dashboards
The Process Monitor Dashboard
Drilling Down and Raising the Priority of a Work Item
The Claim Breakdown Dashboard
Drilling Down to Find the Current Status of a Particular Claim
Process Monitor and Claim Breakdown Dashboard Design
Openspace Gadget Dashboard Architecture
Standalone Dashboard Architecture
Calling ActiveMatrix BPM Web Services From the Example HTML Dashboards
Authenticating Calls to BPM Web Services
Filtering the Data Shown in a Report Based on the Logged in User's Team Membership
Raising the Priority of a Work Item
Displaying Process Status (Statistical Data) for a Particular Claim (Case Data)
Viewing and Modifying Reports Used by Process Monitor and Claim Breakdown Dashboards
Process Monitor Dashboard Reports
Claim Breakdown Dashboard Reports
The AMX-BPM Statistics AdHoc Dashboard
Viewing the AMX-BPM Statistics AdHoc Dashboard
AMX-BPM Statistics AdHoc Dashboard Architecture
Creating Jaspersoft Domains from BPM Case Data Models
How ActiveMatrix BPM Maps a Case Data Model to Case Data Tables
Openspace
Openspace User's Guide
Important Information
TIBCO Documentation and Support Services
Openspace Overview
Openspace and TIBCO ActiveMatrix BPM
User Access in Openspace
Personas
Configuring the Standard Persona
Resetting Persona Settings
The Openspace Login URL
Adding a Locale Code
Adding a Login and Username
Logging into Openspace
Login Session Timeout
Logging out of Openspace
Welcome Page Overview
Localization Overview
Localizing Openspace
Localizing Gadgets
Localizing Work Item Attribute Display Names
Tabs Overview
Creating Tabs
Renaming Tabs
Deleting Tabs
Selecting Themes
Layouts Overview
Selecting Layouts
Gadgets
Common Openspace Gadget Functions
Openspace Gadget Store
Adding Gadgets to a Tab
Adding New Gadgets to Openspace
Deleting a Gadget From a Tab Using User Preferences Area
Deleting Gadgets from Openspace
Work Views
Public Work Views
Work Views for an Organizational Entity
Temporary Work Views
Work View Permissions
Accessing Your Editable Work Views
Creating Work Views
Enter Work View Details
Configure the Organizational Recipient
Configure the Work View Filter
Configure Sorting Order for the Work View
Specify the Work Item Columns
Specify the Recipients
Specify the Authors
Editing Work Views
Deleting Work Views from Openspace
Removing Work Views from Your Work View List
Work Items
Work Item Columns
Work Item State
Changing Work Item Priority
Refreshing Work Items
Configuring Work Item Columns
Setting the Number of Work Items Displayed
Searching for Work Items
Displaying Visible Hidden Work Items
Displaying Work Item Attribute Names
Filter Criteria
Value Data Types
DateTime Data Types
Filtering on Special Characters
Grouping
Sort Criteria
Specifying the Sort Direction
Specifying a Sort Order
Allocating Work Items Overview
Allocating Work Items To Yourself
Re-Offering Work Items
Allocating Work Items to Another User
Allocate Work Items to Offer Set
Allocating Work Items to the World
Find a Resource
Processing Work Items Overview
Opening Work Items
Opening a Work Item Using the Openspace URL
Auto-Repeat
Piling
Filling in a Work Item Form
Work Item Data Modified By Other Users or System Actions
Progressing Stale Case References
Saving Work Items
Submitting Work Items
Pending Work Items
Unpending Work Items
Skipping Work Items
Canceling Changes
Executing Manual Ad-Hoc Activities
Process Views
Process Template List Columns
Process Instance State
Refreshing the Process Template List
Configuring Process View Columns
Increasing Page Size
Searching for Process Templates
Starting a Process Instance
Suspending a Process Instance
Resuming a Suspended Process Instance
Canceling a Process Instance
Purging Process Instances
Process Instance Migration Overview
Migration Points
Migration Rules
Determining if Migration is Valid
Process Migration Example
How to Migrate a Process Instance
Administering Halted Process Instances Overview
Viewing Halted Process Instances
Progressing Halted Processes
Auditing Instances of Process Templates Overview
Displaying an Audit Trail
Audit Trail Columns
Event Attributes in an Audit Trail
Event Attribute Columns
Customizing Columns
Replaying the Graphical Audit Trail
Process Templates and Process Instances Filters
Process Template Filter Criteria
Process Instance Filter Criteria
Value Data Types
Wild Card Characters
Specifying a Filter Expression
Sorting Process Templates
Sort Criteria
Specifying the Sort Direction
Specifying a Sort Order
Applying the Sort Criteria
Business Services
Business Services Gadget
Business Service List Columns
Configuring Business Service Columns
Customizing Split
Refreshing the Business Service List
Searching for Business Services
Categories
Viewing Categories
Adding Categories as Favorites
Removing Categories as Favorites
Starting a Business Service
Event Views
Event Views Gadget
Saving Views
Creating Event Views Overview
Creating a Temporary Event List
Creating a List of Events Using the Wizard
Editing an Existing Event List
Deleting Event Lists
Event Lists
Selecting Items and Event Lists
Event Descriptions
Filtering and Event Lists
Pre-defined Filters
Sorting and Event Lists
Event List Columns Attributes
Specifying the Columns to Display in Event Lists
Specifying the Attributes to Display in Event Attribute Lists
Using Event Links
Using Bread Crumb Trails
Using Correlated Events
Saving an Event View Created Through Event Links
Sub-Process Events
Filtering Event Lists Overview
Base Filters and Refined Filters
Defining a Base Filter
Defining a Refined Filter
Accessing the Filter Function
Filter Expression Example
Specifying a Filter Expression
Choosing a Filter Grouping
Default Filter Grouping
Modifying the Filter Grouping
Combining “All Of” and “Any Of”
Selecting Filter Attributes
Value Data Types
DateTime Attributes
Dynamic Time-Period Point-in-Time Entries
DataTime Ranges
Using Wild Card Characters
Applying the Filter Expression
Modifying an Existing Filter Expression
Viewing the Filter Syntax
Sorting Lists in Event Views
Accessing the Sort Function
Selecting Sort Attributes
Specifying Sort Order
Specifying a Sort Direction
Applying the Sort Criteria
Sorting a List Using Column Headers
Auditing Process Data
Calendars
Base Calendars
Overlay Calendars
Calendar Aliases (References)
Calendar Time Zones
Exclusions in Calendars
How Calendars are Resolved
Required System Actions
Calendar Example
Displaying the Calendar
Specifying Working Days Times
Editing/Deleting Working Hours
Creating System Calendar Exclusions
Editing/Deleting Exclusions
Viewing Your Working Hours
Creating Base Calendars
Creating Overlay Calendars
Assigning Calendars to Organizational Entities
Opening Calendars
Copying Calendars
Editing Base Calendars
Calendar Aliases
Adding a Calendar Alias
Mapping a Calendar Alias to a new Calendar
Deleting a Calendar Alias
Deleting Calendars
Openspace and TIBCO Spotfire
The Spotfire Gadget
Accessing the TIBCO Spotfire BPM Visualizations
Setting Preferences
Logger Gadget
Displaying Messages in the Logger Gadget
Setting the Message Level
Turning Off Logging
Clearing the Logs
Copying the Logs
Saving the Logs to the Openspace Log File
Setting Preferences
Webviews
Rendering a Specific URL
Dynamically Rendering a URL
Data Admin
Guidelines When Editing Case Model Database Scripts
Retrieving CREATE Case Data Database Scripts
Retrieving UPDATE Case Data Database Scripts
Retrieving DROP Case Data Database Scripts
Comparing Case Data Database Scripts
Freezing Case Data Models
Case Management
Using Case Search
Performing an Advanced Case Data Search
Enter Advanced Search Details
Configuring the Advanced Search Filter Criteria
Filtering Array Attributes in Searches
Configuring Sort Order for Advanced Searches
Performing an Ad-hoc Search
Searching Cases
Editing Searches
Deleting Searches
Performing Case Actions
Managing Work Lists Associated With Cases
Configuring Columns in Case Navigation
Managing Processes Associated With Case Data
Viewing Event Information Associated with Case Data
Managing Case Documents
Managed Events
Contributing a Gadget to the Hub Policy Administrator
Using the Hub Policy Administrator
Developing Managed Events
Sample HubPolicy File
Openspace Managed Events
Managed Events Topic Names
Demo Applications
Accessing Crossframe Gadget Demo Applications
GWT Application - Summary Steps
JavaScript Application - Summary Steps
JSON Message Format
Openspace - Mobile
Accessing Openspace - Mobile
Logging into Openspace - Mobile
Using Gadgets in Openspace - Mobile
Using To Do List
Work Item Status
Processing Work Items
Allocating Work Items
Using Performance
Viewing the Status of Selected Process Templates
Using Settings
User Access in Openspace
System Actions Mapping to Openspace Features
Accessibility
About User Access
Navigating Openspace
Login Keyboard Shortcuts
Keyboard Shortcuts
Work Views Keyboard Shortcuts
Process Views Keyboard Shortcuts
Datagrid Keyboard Shortcuts
Datagrid Toolbar Keyboard Shortcuts
Configuring Text Size
The Openspace Login URL
Adding a Locale Code to the Openspace URL
Logging into Openspace
Login Session Timeout
Logging out of Openspace
Business Services Overview
Business Service Columns
Customizing Business Service Columns
Configuring Sort Criteria
Viewing Business Services
Adding Categories as Favorites
Removing Categories as Favorites
Searching for Business Service Categories
Searching for Business Services
Refreshing the Business Service List
Starting a Business Service
Work Views
Work Item Columns
Customizing Work Item Columns
Searching for Work Items
Refreshing Work Items
Displaying Work Item Summary
Displaying Visible Hidden Work Items
Changing Work Item Priority
Allocating Work Items To Yourself
Allocate Work Items to Offer Set
Re-Offering Work Items
Opening Work Items
Auto-Repeat
Piling
Filling in a Work Item Form
Submitting Work Items
Saving Work Items
Pending Work Items
Skipping Work Items
Canceling Changes
Work Item Filter Criteria
Specifying a Work Item Filter Expression
Wild Card Characters
Work Item Filter Attributes
Value Data Types
DateTime Data Types
Process Views
Process Views Columns
Process Instance State
Refreshing the Process Template List
Searching for Process Templates
Customizing Process Instance Columns
Auditing Instances of Process Templates Overview
Displaying an Audit Trail
Audit Trail Columns
Process Templates Filters
Process Template Filter Criteria
Specifying a Filter Expression
Configuring Sort Criteria
Specifying a Sort Direction
Openspace Customization Guide
Important Information
TIBCO Documentation and Support Services
Openspace Configuration Overview
Configuring Authentication
Openspace Rebranding
Login Rebranding
Masthead Rebranding
Gadgets Rebranding
Background Rebranding
Borders Rebranding
Tab States Rebranding
Masthead Images Rebranding
Replacing Images
Customizing the Openspace Window Title
Configuring the Welcome Page
Configuring Time Allowed for Gadgets to Load
Configuring the TIBCO Openspace Date Time Format
Adding New Themes
Layout Customization
Layout Properties
Enabling Sample/New Layouts
Openspace Features Lockdown
Lockdown Properties
Configuring Lockdown System Actions
Openspace Feature Lockdown Properties
Configuring the Lockdown Properties
Checking Lockdown Properties
Displaying Work Item Attributes
Configuring the Location of the Help Files
Configuring Custom Functionality
Configuring Sort Order
Business Service App (BizApp)
Localizing Openspace Overview
Manually Localizing Openspace Overview
Locales Overview
Configuring Locales
Configuring the TIBCO Openspace Date Time Format
Overview of the Steps Required to Manually Localize Openspace
Manually Translating Openspace Application Resource Bundles
Adding the New Language as a Property to the locale.properties File
Create an SOA Project
Configure the Composite
Create the Distributed Application Archive (DAA)
Deploying the DAA
Configuring What Happens on Openspace Logout
Organization Browser User's Guide (Openspace)
Important Information
TIBCO Documentation and Support Services
Introduction
Access to the Organization Browser
Organization Model Versions
Organization Model Version 0
Authentication
Export and Import of Organizational Information
Exporting Organizational Information
Importing Organizational Information
Browsing the Organization Model
Browsing Organization Units and Positions
Browsing Groups
The Action Path
LDAP Containers
Primary and Secondary Sources
LDAP Query Sources
LDAP Group Sources
Creating LDAP Containers
Defining the Primary Source Using an LDAP Query
Defining a Secondary Source Using an LDAP Query
LDAP Query String Characters and Examples
Defining the Primary Source Using an LDAP Group
Defining a Secondary Source Using an LDAP Group
Container Organization Relationships
Organization Relationship Examples
Invalid Mappings Because of Organization Relationships
Viewing the Resources in a Container
Searching the Resource List
Mapping Resource Attributes
Moving a Resource to a Different LDAP Container
Deleting LDAP Containers
Resources
Resource Lists
Creating BPM Resources
Creating Resources Using the Create BPM Resource Function
Mapping Resources
Groups and Positions Display
Removing Resources from Groups or Positions
Removing Resources Using the Mapping Remove Function
Removing Resources Using the Resource List Remove Function
Viewing Resources Mapped to a Group or Position
Searching the Resource List
Viewing Resource Details
Renaming a Resource
Missing Resource
Deleting Resources
Managing Deleted Users
Viewing Deleted Users
Viewing Details of Deleted Users
Reassigning Process Instances that are Assigned to Deleted Users
Purging Deleted Users
Privileges
Viewing a Resource's Privileges
Capabilities
Viewing and Editing Resource Capabilities
Viewing and Editing Resource Capabilities for a Single Resource
Viewing and Editing Resource Capabilities for Multiple Resources
Resource Attributes
Viewing and Editing Resource Attributes
Viewing and Editing Resource Attributes for a Single Resource
Viewing and Editing Resource Attributes for Multiple Resources
Push Destinations
Editing Organizational Entity Push Destinations
Editing Resource Push Destinations
Dynamic Organization Model Extension Points
Configuring Dynamic Organization Model Extension Points
Viewing a Dynamic Organization Model Template
Populating Dynamic Organization Models
Candidate Queries
Configuring Candidate Queries for Static Organizations
Configuring Candidate Queries for Dynamic Organizations
Modifying Existing Candidate Queries for Dynamic Organizations
Workspace
Workspace User's Guide
Important Information
TIBCO Documentation and Support Services
Introduction
Understanding a Business Process
The Workspace Screen Layout
The Preview Pane
Floating Windows
Lists
Selecting Items in a List
Selecting a Single Item
Selecting Multiple Items
Refreshing Information in a List
Customizing Columns in a List
The Column Default
Using the Column Selector
Number of Items in a List
List Page Size
Help
Access Privileges
Determining User Access
Accessing the Organization Browser
Setting the Language
Accessing Workspace
Logging Into Workspace
Login Session Timeout
Logging Out of Workspace
Views
Permanent and Temporary Views
Saving Views
Work Views
Personal Work Views vs. Supervised Work Views
Creating Work Views
Creating a Personal Work View Using the Wizard
Creating a Supervised Work View Using the Wizard
Editing an Existing Work View
Editing a System Work View
Deleting a Work View
Deleting a System Work View
Process Views
The Default Process View
Creating Process Views
Editing an Existing Process View
Editing a System Process View
Deleting a Process View
Deleting a System Process View
Event Views
Creating Event Views
Creating a Contextual List of Events
Creating a List of Events Using the Wizard
Editing an Existing Event View
Editing a System Event View
Deleting an Event View
Deleting a System Event View
System Views
Owners Authors and Recipients
User Access
Creating a System View
Editing a System View
Deleting a System View
Case Views
Creating Case Views
Case View Filter Attribute Types
Logical Operators for Filtering Case Views
Wildcard Characters
Filtering Array Attributes in Case Views
Editing an Existing Case View
Deleting a Case View
Business Services
Displaying the Available Business Services
Finding a Business Service
Starting a Business Service
Business Service Forms
Work Items
Work Item Lists
Why Are Work Items Sent to Your Work Item List
Selecting Items in a Work Item List
Refreshing the Work Item List
Auto-Refresh of Work Item Lists
Filtering a Work Item List
Sorting a Work Item List
Displaying Visible Hidden Work Items
Work Item List Columns
Finding a Work Item
Work Item State
Allocating Work Items
Allocate Work Item(s) To Yourself
Re-Offering Work Item(s)
Allocate Work Item(s) to Another User
Allocate Work Item(s) To Offer Set
Allocate Work Item(s) To World
Finding a Resource
Work Item Deadlines
Outstanding Work Items
Show Outstanding Work Items
Show Supervised List of Outstanding Work Items
Viewing Events Related to a Work Item
Processing Work Items
Opening Work Items
Re-Opening a Work Item
Work Item Form Location
Automatically Opening Work Items
Filling in a Work Item Form
Saving Work Items
Submitting Work Items
Work Items Modified by the System of Another Application
Pending Work Items
Setting Work Item Priority
Skipping Work Items
Canceling Changes
Process Instances
Starting an Instance of a Process
Process Instance List
Selecting Process Instances
Process Instance Details
Refreshing a Process Instance List
Process Instance List Timeout
Process Instance List Columns
Filtering a Process Instance List
Sorting a Process Instance List
Finding a Process Instance
Process Instance Status
Completing a Process Instance
Displaying Outstanding Work Items
Suspending a Process Instance
Suspension Status
Resuming a Suspended Process Instance
Halted Process Instances
Creating a Halted Process View
Sub-Processes
Viewing Events Related to a Process Instance
Cancelling a Process Instance
Events
Event Lists
Selecting Items in an Event List
Event Descriptions
Filtering an Event List
Pre-defined Filters
Sorting an Event List
Event List Column Attributes
Specifying the Columns to Display in Event Lists
Specifying the Attributes to Display in Event Attribute Lists
Viewing Work Item Participants
Finding an Event
Viewing an Additional Event List Using Event Links
Bread Crumb Trail
Viewing Correlated Events
Saving an Event View Created Through Event Links
Sub-Process Events
Auditing Process Data
Filtering Lists
Base Filter and Refined Filter
Accessing the Filter Function
Filter Expression Examples
Specifying a Filter Expression
Choosing a Filter Grouping
Default Filter Grouping
Modifying the Filter Grouping
Combining “AND (All Of)” and “OR (Any Of)”
Selecting Filter Attributes
Value Data Types
Custom Attributes in Process Instance Lists
DateTime Attributes
Using Wild Card Characters
Filtering on Special Characters
Applying the Filter Expression
Modifying an Existing Filter Expression
Viewing the Filter Syntax
Exporting Filter XML
Sorting Lists
Accessing the Sort Function
Specifying Sort Criteria
Selecting Sort Attributes
Custom Attributes in Process Instance Lists
Specifying Sort Order
Specifying a Sort Direction
Applying the Sort Criteria
Sorting a List Using Column Headers
User Options
Display Options
Language
Initial Display
Default View
Captions
Times
Work Item Options
Auto-Refresh
Work Item Preview
Work Item Forms
Business Service Options
Recently Started Services
Business Service Forms
Event Options
Event Paging Model
Appearance Options
Layout
Font
Starting a Process
Starting an Instance of a Process
Workspace Configuration and Customization Guide
Important Information
TIBCO Documentation and Support Services
Introduction
Methods of Configuration and Customization
Configuring and Customizing a Deployed Application
Using the Configuration Administrator
Configuration Administrator Writes Files to the Database
Setting Configuration Information to Default Values
Directly Modifying Files on the BPM Runtime Machine
Location of Files on a BPM Runtime Machine
Configuring and Customizing a Non-Deployed Application
Opening the Workspace Application In General Interface Builder
Configuring a Non-Deployed Application
WCC Configuration File
WCC Application Launch Fragment
Deploying an Application After Customizing
Disabling a Currently Deployed Application
Disabling an Application Using the Configuration Administrator
Disabling an Application by Modifying the config.xml File
Launching a WCC Application
Launching a Deployed Application
Launching a WCC Application Using an External Login
Launching a WCC Application Using Default Configuration Files
Launching the Application in an HTML Frame
Launching a Non-Deployed Application
Starting Multiple Applications from the Launch Fragment
Multiple Applications Referencing a Single Configuration File
Opening Forms when Testing an Application Locally
Cross-Domain Scripting
Single Sign-On Authentication
Configuring the Application
Configuration Parameter Summary
Pre-Login Configuration Parameters
Using the Graphical Editor to Configure the Application
Application
Session Monitor
Options
User Preference Persistence
Channel Identifier
Forms Configuration
Browser Features
Post-Login Caption
Logging
First Quarter Month
Column Sort
Modifying XML to Configure the Application
Application
Action Processor
Session Monitor
Help File Locations
Options
User Preference Persistence
Channel Identifier
Pre-login User Access
Login
Login Link
Forms Configuration
Browser Features
Post-Login Caption
Logging
First Quarter Month
Column Sort
Custom Callouts
Getting Binary LDAP Attributes
Facade Display Names
Event Paging Model
Authentication Mode
Show Logout Button
Logout Path
Configuring User Access
Overview of User Access Authority
Determining a User’s System Actions and User Access Controls
Configuring User Access
User Access Sets
Configuring User Access Sets Using the Graphical Editor
Creating a User Access Set Using the Graphical Editor
Editing an Existing User Access Set Using the Graphical Editor
Deleting a User Access Set Using the Graphical Editor
Configuring Access Sets by Editing XML
Turning Access Control On and Off
Turning Access Control On Off Using the Graphical Editor
Turning Access Control On Off by Editing XML
Provided User Access Sets
Version 0 of the Organization Model
Pre-Login Access
Available Functions
User Access Control to System Action Mapping
Scope of System Actions
System Actions at the Organization Model Level
System Actions at the Group Organization Unit and Position Level
Configuring Events
Location of the Event Configuration Files to Configure
Event-Related Text
Mapping Privileges to Event Roles
Adding Event Roles
Adding Event Roles to a Deployed Application
Adding Event Roles to a Non-Deployed Application
Customizing Event Descriptions
Customizing Links
Defining the Link Type
Defining the Individual Links
Defining Link Sets
Sub-Process Links
Customizing View Templates
Customizing Event Attributes
Customizing Event Components
Specifying Pre-defined Filters
Event Filter String
Substitution Tokens
Types of Substitution Tokens
Event Filter Masks
Customizations
Font Color and Image Settings
Adding Custom Menus and Toolbar Buttons
Provided Custom Menus Sample
Procedure to Run the Custom Menus Sample
Controlling User Access to Custom Menus and Toolbar Buttons
Controlling Access to Subordinate Items
Using the Graphical Editor
Using Access Elements in the XML
loadCustomMenu Override Method
Customizing Columns in Lists
Specifying Default Columns
Specifying Columns Available in the Column Selector
Restricting Reordering and Resizing of Columns
Turn reordering of columns on or off
Fix some columns and allow reordering of others
Turn resizing of columns on or off
Customizing the Work Item and Process Instance Summaries
Modifying the Work Item Summary
Modifying the Process Instance Summary
Custom Interfaces
Custom Interface Use Cases
Workspace Application vs a Custom WCC Application
Launching Custom Interfaces
Supported Custom Interfaces
Custom Interface Configuration
Menu and Toolbar Button Location
Custom Interface Location
Valid Custom Interface Locations
Configuration Elements
Menus and Toolbar Elements
Configuration Administrator Interface
Configuring a Custom Interface Launched from a Menu
Configuring a Custom Interface Launched from a Toolbar Button
Subscribing to or Publishing Events for a Managed Hub iFrame Interface
User Access Elements for Custom Interfaces
Localization for Custom Interfaces
Custom Interface Helper Methods
getInterfaceName
getInterfaceDisplayText
setInterfaceDisplayText
getInterfaceToolTip
setInterfaceToolTip
getInterfaceImage
setInterfaceImage
getInterfaceFeatures
setInterfaceFeatures
getInterfaceVisible
setInterfaceVisible
getInterfaceEnabled
setInterfaceEnabled
getInterfaceParent
getInterfaceLaunchType
getInterfaceMenuItems
getInterfaceLocation
getInterfaceSource
getInterfaceSelectedRecords
getInterfaceCaption
setInterfaceCaption
showInterfaceCaption
loadSimpleIframe
loadSimpleHubIframe
loadSimplePrototype
loadCustomInterface
closeInterfaceArea
showMasterSelection
getMasterSelectionSource
setMasterSelectionSource
getMasterSelectionDisplayText
setMasterSelectionDisplayText
getMasterSelectionImage
setMasterSelectionImage
getMasterSelectionToolTip
setMasterSelectionToolTip
Sample Custom Interfaces
simpleIframe Sample
simpleHubIframe Sample
simplePrototype
scriptedInterface
tibbrSearch
Custom Views
Customizing Location of Help Files
openworkitem Application
Configuring the openworkitem Application
Opening a Work Item with the openworkitem Application
Starting a Business Service with the openworkitem Application
External Login
Localization
Default Language
Language Resource Files
Language Resource File Deployment
Country-Specific Translations
Process of Displaying Text Strings
Creating New Resource Files
Creating New General Resource Files
Creating a New Event Resource File
Modify or Create a General Interface System Locale File
Deploying Language Resource Files
Sample Applications
View Distributor Sample Application
User Access Controls
Setting Up the View Distributor Application
Configuring the baseUrl
Namespace Configuration
Modifying the View Distributor Application’s Launch Fragment
Modifying the View Distributor Application’s wccConfig.xml
Starting the View Distributor Application
Using the View Distributor Application
Distributing a View
Browser Script Warnings
User Access Sample Application
Setting Up the User Access Sample Application
Deploying the wccAccessSample Application
The Sample Application’s User Access File
Custom Menus and Toolbar Buttons
Starting Business Services
Controlling Access to Individual Custom Menu Items and Toolbar Buttons
Granting the Required Privileges Through an Organization Model
Login Session Sample Application
amxbpm_item.js
amxbpm_item.html
amxbpm_login.html
amxbpm_item.create.war.cmd
Workspace Logs
Application Log
Configuring the Application Log
Application Monitor
Performance
Removing Unneeded Locale Keys
Workspace Components Developer Guide
Important Information
TIBCO Documentation and Support Services
Introduction
TIBCO General Interface
Browsers
Custom Application
Workspace
Workspace Action Processor
TIBCO ActiveMatrix BPM Node
Building Custom Applications
Location of Custom Applications
WCC Add-in
Application Template
Application Configuration
Running a Custom Application
Cross-Domain Scripting
Launching a Custom WCC Application in an HTML Frame
Using a Load Balancer
Deploying a Custom Application
Component Events
Loading PageBus
Publishing and Subscribing to Events
Non-WCC Components Publishing Events
Non-WCC Components Subscribing to Events
RenderComplete Event
Events Editor
Subscribing to Events
Events From External Applications
Creating the External Application Event Definition
Importing the Event Definition File
Properties Editor
Component Names
Changing Component Model Names
Disabling Default Handler
Component Reference
Viewing Triggered Events using the PageBus Event Monitor Component
Specifying the Events to Which the PageBus Event Monitor Component Subscribes
Composite Components
Organization Resource Browser
Process Instances Preview
Work Items Preview
Data View Results
Data Mask Component
List Container Components
Business Services
Event Views
Event Viewer
Process Templates
Process Templates Ex
Process Views
Process Instances
Work Views
Work Items
Data Views
Data View List
Login Component
LocaleSelector Component
Toolbar Button Component
Configuration Administrator Button
Logout Button
Open Next Work Item Button
Options Button
Organization Browser Window Button
Organization Browser Components
Organization Browser
Organization Resource List
Start Instance Component
WCC Public Methods
Override Methods
init
postLoadInit
postLogin
preLogout
postLogout
onBeforeUnload
onUnload
loadCustomMenu
onSessionInvalid
Application Class Methods
General Application-Class Methods
getApp
getAppVersion
getProductBrand
logoutOnUnload
getNamespace
getModelName
getPageBus
isWorkItemPreviewFormOpen
getApp
getAppBlock
getServer
isAuth
clearCacheData
publishPauseWorkItemsAutoRefresh
loadPrototype
adjustSpanForDialog
loadDialogPrototype
getCustomMenuNode
registerLongLivedProcess
cancelLongLivedProcess
isExternalLogin
getLocaleKey
getBaseUrl
getUsername
getUserGuid
getChannelId
setChannelId
getBrowserFeatures
getSystemActionsAuthorized
getUserAccessAuthorized
getPrivilegeNames
loadUrlArgs
Data Mask Methods
isMaskActive
showMask
showMaskFunction
hideMask
Options Methods
getOptionValue
getOptionNames
Application Log Methods
appLogZeroTimer
log
logDebug
logTrace
logFatal
logError
logWarn
logInfo
getAppLogLevel
getAppLogLevelName
setAppLogLevel
setAppLogLevelName
isEchoToJsxLog
setEchoToJsxLog
getJsxLogger
logException
logAlways
logStackTrace
logHierarchy
logTree
logStart
logStop
getAppLogText
clearAppLog
User Data Methods
getUserDataAttributes
setUserDataAttributes
User Message Methods
showUserMessage
showErrorMessage
confirmUserMessage
Display Caption Methods
setCaptionBar
setCaptionBarText
Exception Handling Methods
setToolsErrorHandlingEnabled
isToolsErrorHandlingEnabled
Tools Interface Methods
Exception Handling
Running the Sample Application
Access Methods
login
logout
initializeExternalLogin
Work Item Methods
allocateWorkItemToOfferSet
allocateWorkItemToWorld
allocateWorkItemToSelf
cancelWorkItem
openNextWorkItem
openNextWorkItemEx
openWorkItem
reofferWorkItem
skipWorkItem
pendWorkItem
prioritizeWorkItem
Process Instance Methods
startProcessInstance
cancelProcessInstance
resumeProcessInstance
suspendProcessInstance
resumeHaltedProcessInstance
retryProcessInstance
ignoreProcessInstance
Business Service Methods
startBusinessService
startBusinessServiceWithData
Event View Methods
showEvents
User Options Methods
workspaceOptions
Organization Browser Methods
workspaceOrganizationBrowserWindow
Configuration Methods
configAdmin
Locale Methods
getAppLocales
setAppLocale
Mixin Interface Methods
customPostLoginExample
customPostLogoutExample
sampleToolbarHandler
sampleMenuHandler
Component Public Methods
DataMask Component Public Methods
addCursorBlockId
setShowMaskCursorValue
setHideMaskCursorValue
WorkItemsPreview Component Public Methods
getCaption
showCaption
ProcessInstancesPreview Component Public Methods
getCaption
showCaption
EventViewer Component Public Methods
getCaption
showCaption
OrganizationResourceList Component Public Methods
getCaption
showCaption
BusinessServices Component Public Methods
setFormContainerBlock
getFormContainerBlock
Prototype Public Methods
getVersion
Server Requests
Submitting Server Requests
Submitting Request Examples
Responses to Server Requests
Response Status
wccApiSample Application
Setting Up the wccApiSample Application
Running the wccApiSample Application
Deploying the wccApiSample Application
Application Class for wccApiSample
Server Request Reference
Organization Browsing Resource Requests
listModelVersions
listOrgModelOverview
listMappedEntities
getResourceDetail
lookupUser
listQueryResources
Miscellaneous Requests
Ping
workItemFilterSortFields
getResourceOrderFilterCriteria
setResourceOrderFilterCriteria
getUserPrivileges
listSystemActionAuthorizedEntities
isActionAuthorized
Work Item Requests
listWorkItems
listSupervisedWorkItems
cancelWorkItems
skipWorkItems
reofferWorkItems
getOfferSet
allocateWorkItems
reallocateWorkItems
pendWorkItems
Process Template and Instance Requests
listStartTemplates
startProcessInstance
queryProcessTemplateCount
listProcessTemplateAttributes
queryProcessTemplates
listProcessInstanceAttributes
queryProcessInstanceCount
queryProcessInstances
queryProcessInstancesNextPage
queryProcessInstancesPreviousPage
queryProcessInstancesFirstPage
queryProcessInstancesLastPage
queryDone
suspendProcessInstance
resumeProcessInstance
cancelProcessInstance
resumeHaltedProcessInstance
retryProcessInstance
ignoreProcessInstance
Business Service Requests
listBusinessServiceCategories
queryBusinessServices
queryBusinessServiceCategories
Event Collector Requests
eventCollectorGetComponents
eventCollectorGetAllAttributes
eventCollectorGetAttributes
eventCollectorQuery
Callout Interface Methods
Sample CalloutHandler
Callout Handler Configuration
Using Configuration Administrator to Configure Callout Handlers
Callout Methods
overrideBaseFilter
overrideFilterOnLoad
overrideFilterOnRefresh
overrideFilterAttributes
overrideSortOnLoad
overrideSortOnRefresh
overrideSortAttributes
overrideColumnsOnLoad
overrideColumnsOnRefresh
overrideColumnAttributes
overrideProcesses
overrideBusinessServices
overrideBusinessServiceCategories
modifyMatrix
modifyViewListData
Callout Utilities
Generating a Filter Expression
Generating the Graphical Filter XML
appendFilterExpression
appendFilterXML
getLoggedInUserDetail
getUserDetail
getDisplayedListItems
getSelectedListItems
doRefresh
Workspace Attributes
Work Item Attributes
Process Instance Attributes
Event Attributes
Using WCC Components in Mash-Ups
TIBCO PageBus Managed Hub
Non-WCC Subscribing to WCC Events
Component PageBus Event Payloads
Composite Components
Data Mask Component
List Container Components
Login Component
LocaleSelector Component
Toolbar Button Component
Organization Browser Components
Start Instance Component
Event Schemas
com.tibco.wcc.schema.attributeSelected
com.tibco.wcc.schema.businessServices
com.tibco.wcc.schema.eventSelected
com.tibco.wcc.schema.eventViews
com.tibco.wcc.schema.eventViewsRemoved
com.tibco.wcc.schema.loginComplete
com.tibco.wcc.schema.organizationbrowser
com.tibco.wcc.schema.organizationresourcelist
com.tibco.wcc.schema.processInstances
com.tibco.wcc.schema.processInstancesShowOutstanding
com.tibco.wcc.schema.processtemplates
com.tibco.wcc.schema.processtemplatesex
com.tibco.wcc.schema.processtemplatesexrefresh
com.tibco.wcc.schema.processViews
com.tibco.wcc.schema.processViewsRemoved
com.tibco.wcc.schema.saveEventView
com.tibco.wcc.schema.saveEventViewAs
com.tibco.wcc.schema.saveProcessView
com.tibco.wcc.schema.saveProcessViewAs
com.tibco.wcc.schema.saveWorkView
com.tibco.wcc.schema.saveWorkViewAs
com.tibco.wcc.schema.showEvents
com.tibco.wcc.schema.startinstance
com.tibco.wcc.schema.workItems
com.tibco.wcc.schema.openNextWorkItem
com.tibco.wcc.schema.workviews
com.tibco.wcc.schema.workviewsRemoved
Non-WCC Code Publishing Events
pageBusPayloadHelperApp
Setting Up the pageBusPayloadHelperApp Application
Running the pageBusPayloadHelperApp Application
Creating a Work Item List Event Payload
Creating a Process Instance List Event Payload
pageBusPayloadPublishApp
Setting Up the pageBusPayloadPublishApp Application
Running the pageBusPayloadPublishApp Application
Event Payloads for the Work Item and Process Instance Lists
Work Item List Event Payload
Process Instance List Event Payload
Subscribing to an Event Published by Non-WCC Code
Create an Event Definition File
Importing the Event Definition File and Subscribing to the Event
Using the TIBCO PageBus Managed Hub with WCC Components
Managed Hub Sample Applications
wccLoginManagedHub Sample Application
Setting Up the wccLoginManagedHub Application
Executing the wccLoginManagedHub Application
wccPassThruManagedHub Sample Application
Setting Up the wccPassThruManagedHub Application
Executing the wccPassThruManagedHub Application
How to Create a BPM Desktop Using Components Tutorial
Tutorial Procedure
Creating the Tutorial Screen Layout
Reloading the appMain Prototype Upon Logout
Organization Browser User's Guide (Workspace)
Important Information
TIBCO Documentation and Support Services
Introduction
Accessing the Organization Browser
Organization Model Versions
Organization Model Version 0
Authentication
Exporting and Importing Organizational Information
Exporting Organizational Information
Importing Organizational Information
Browsing the Organization Model
Viewing Display Names vs. Unique Names for Organizational Entities
Viewing the Resources in a Container
Finding a Resource
Viewing Resources Mapped to a Position or Group
Viewing Details about an Organization Unit, Position, or Group
Viewing Details about an Individual Resource
Group and Position Names
The Resource List
Viewing System Resources
Viewing Events Related to Organizational Entities and Resources
Viewing Deployed Versions of Organization Model
LDAP Containers
Creating an LDAP Container
Defining the Primary LDAP Source
Defining One or More Secondary LDAP Sources
Determining Which Resources to Include
Container Organization Relationships
Organization Relationships in the Resource Editor
Invalid Memberships
Viewing Organization Relationships on the Main Organization Browser Window
Mapping Resource Attributes
Moving a Resource to a Different LDAP Container
Deleting LDAP Containers
Resources
Creating Resources
Using the Create Resource Function
Deleting Resources
Renaming a Resource
Mapping Resources
Mapping Resources From the Resource List
Using the Drag and Drop Method
Using the Add / Remove Membership for Resource(s) Functions
Evaluating Required Capabilities from the Resource List
Mapping Resources Using the Resource Editor
Organizational Entity Information
Editing Organizational Entity Push Destinations
Resource Information
Accessing the Resource Editor
Resource Editor Display Options
View Options for the Tree View
Limiting View by Status
Searching in the Resource Editor
Using the Resource Editor
Resource Editor Status Icons
Capabilities
Viewing Capabilities from the Resource List
Viewing Capabilities from the Resource Editor
Viewing a Resource’s Capabilities from the Resource Editor
Viewing a Group or Position’s Capabilities from the Resource Editor
Viewing the Defined Capabilities in the Resource Editor
Editing Capabilities for One or More Resources
Privileges
Viewing Privilege Information In the Resource Editor
Viewing Privileges from the Resource Editor
Viewing a Group or Position’s Privileges from the Resource Editor
Viewing the Defined Privileges in the Resource Editor
Assigning Privileges in the Resource Editor
Resource Attributes
Viewing Resource Attributes from the Resource List
Editing Resource Attributes
Resource Push Destinations
Editing Resource Push Destinations
Mobilespace
Mobilespace Guide
Important Information
TIBCO Documentation and Support Services
TIBCO Mobilespace
Pageflow Processes and Business Services
Generate a Business Service
Client Application Development
How to Access Application Development
Edit an Application
Mobile Application Settings
Mobile Case Manager Application
Configure the Mobile Case Manager Application
Installation and Troubleshooting
TIBCO ActiveMatrix® BPM Installation and Configuration
Important Information
TIBCO Documentation and Support Services
USING THIS GUIDE
Introduction
Installation Environment
Configuration Directory
ActiveMatrix BPM System Architecture
Distributed BPM System
Basic BPM System
Primary, Second Primary, and Remote Machines
Multiple BPM Systems in the Same ActiveMatrix Enterprise
Upgrading From an Earlier Version of ActiveMatrix BPM
Upgrade Impact
Disaster Recovery
Network Support
System Requirements
Hardware Requirements
Platform and Database Requirements
TIBCO Software Requirements
Third-Party Software Requirements
User Account Requirements
Additional System Requirements for a Distributed BPM System
I - INSTALLATION AND UPGRADE SCENARIOS
Creating a Basic ActiveMatrix BPM System
A Basic ActiveMatrix BPM System
Performing Required Pre-Installation Tasks
Installing ActiveMatrix BPM Software
Configuring JDBC Drivers
Creating a BPM Node and Administrator Server
Performing Required Post-Installation Tasks
Creating an ActiveMatrix Administrator Server (Single or Replicated)
An ActiveMatrix Administrator Server (Single or Replicated)
Performing Required Pre-Installation Tasks
Primary Machine: Installing ActiveMatrix BPM Software
Primary Machine: Configuring JDBC Drivers
Primary Machine: Creating the Administrator Server
Primary Machine: Sharing the ActiveMatrix Administrator Server Staging Area
Second Primary Machine: Installing ActiveMatrix BPM Software
Second Primary Machine: Configuring JDBC Drivers
Second Primary Machine: Replicating the ActiveMatrix Administrator Server
Creating a Distributed ActiveMatrix BPM System
A Distributed ActiveMatrix BPM System
Performing Required Pre-Installation Tasks
Remote Machine 1: Installing ActiveMatrix BPM Software
Remote Machine 1: Creating a Host Instance
Primary Machine: Creating a BPM Node on Remote Machine 1
Remote Machine 2: Installing ActiveMatrix BPM Software
Remote Machine 2: Creating a Host Instance
Remote Machine 2: Creating a BPM Node
Performing Required Post-Installation Tasks
Adding an Additional ActiveMatrix BPM System to an Existing ActiveMatrix Enterprise
Multiple BPM Systems in the Same ActiveMatrix Enterprise
Performing Required Pre-Installation Tasks
Production Machine: Installing ActiveMatrix BPM Software
Production Machine: Configuring JDBC Drivers
Production Machine: Creating a Host Instance
Production Machine: Creating a BPM Node
Performing Required Post-Installation Tasks
Upgrading an ActiveMatrix BPM System
Upgrade Overview
Performing Required Pre-Upgrade Tasks
Second Primary Machine: Installing ActiveMatrix BPM Software
Second Primary Machine: Upgrading the ActiveMatrix Host Instance and ActiveMatrix Administrator
Primary Machine: Installing ActiveMatrix BPM Software
Primary Machine: Upgrading the ActiveMatrix Host Instance and ActiveMatrix Administrator
Remote Machine: Installing ActiveMatrix BPM Software
Remote Machine: Upgrading the ActiveMatrix Host Instance
Primary Machine: Upgrading ActiveMatrix BPM
Performing Post-Upgrade Tasks
II - INSTALLATION AND UPGRADE PROCEDURES
Preparing for Installation or Upgrade
Checking For Any Late-Breaking Information
Checking the System Requirements
Configuring TIBCO Enterprise Message Service
Creating the External ActiveMatrix Administrator Database
Creating the ActiveMatrix Administrator Database Using SQL Server
Creating the ActiveMatrix Administrator Database Using Oracle
Creating the ActiveMatrix Administrator Database Using DB2
Configuring the BPM Database Server
Configuring the BPM Database Server Using SQL Server
Configuring the BPM Database Server Using Oracle 11g
Configuring the BPM Database Server Using Oracle 12c
Configuring the BPM Database Server Using DB2
Creating a Database to Hold the BDS Case Data Store (DB2 Only)
Setting up a Content Management System
Configuring the External LDAP Directory Server
Configuring System Parameters on UNIX or Linux Platforms
Configuring Apache Ant
Downloading Required Third-Party Software Assemblies
Downloading ActiveMatrix BPM Software
Backing Up the Existing ActiveMatrix BPM System
Removing any Indexes Added to the BPM Database
Backing Up Openspace Customizations
Backing Up Workspace
Creating a Filter for Environment Level Substitution Variables That Should Not be Moved When Upgrading From a Pre-Version 2.2 ActiveMatrix BPM System
Installing ActiveMatrix BPM (TIBCO Universal Installer)
TIBCO Universal Installer: Installation Modes
Deciding Whether to Use a New or Existing Installation Environment
JRE Used by TIBCO Universal Installer
Running TIBCO Universal Installer in GUI Mode
Running TIBCO Universal Installer in Console mode
Running TIBCO Universal Installer in Silent Mode
Configuring ActiveMatrix BPM Runtime Objects (TIBCO Configuration Tool)
TIBCO Configuration Tool: Configuration Modes
TIBCO Configuration Tool Log Files
Running TIBCO Configuration Tool in GUI Mode
Required External Libraries on an HP-UX (64-bit)/Itanium Platform
TIBCO Configuration Tool Wizards Available on a Primary Machine
TIBCO Configuration Tool Wizards Available on a Remote Machine
Running TIBCO Configuration Tool in Console Mode
Running TIBCO Configuration Tool in Silent Mode
The build.properties File
A Simple Example: Adding a New Server Node to a Distributed System
Manually Creating the BPM and BDS Databases
Manually Running BPM Database Creation Scripts
Manually Upgrading the BPM Database
Method 1: Stopping the BPM Application Before Upgrading It
Method 2: Performing the Upgrade in Two Stages
Manually Running BPM Database Upgrade Scripts
Performing Post-Installation Tasks
Configuring the DataSourceBDS Shared Resource
Configuring the Business Data Services (BDS) Database
Creating Any Other Required LDAP Connections to LDAP Directories
Configuring Client Communications Through the Load Balancer
Configuring the Work Presentation Component
Configuring Launch Pages to Handle Context-Switching
Configuring Transaction Recovery (Oracle only)
Setting Transaction Verification Property (SQL Server Only)
Reorganizing Event Collector Tables (DB2 Only)
Reconfiguring JDBC Connection Resource Templates After Upgrade From a Pre-4.0 ActiveMatrix BPM System
Upgrading the JDBC Driver on Oracle 11g R2
Upgrading the JDBC Driver on Oracle 12c
Upgrading the Openspace GlobalHubPolicy Data
Verifying the Event Collector Rules Files
Editing TIBCO Hawk® Rulebase Files
Minimizing Openspace Load Time
Restoring any Openspace Customizations
Adding New Openspace Gadgets
Restoring Workspace Configurations
Migrating Data Stored in Event Collector
Migrating Event Collector Data for DB2
Migrating Event Collector Data for Microsoft SQL Server
Migrating Event Collector Data for Oracle
Upgrade to Java Runtime Environment (JRE) 1.8
Replacing the Existing ActiveMatrix BPM SSO Certificates
IV - TIBCO CONFIGURATION TOOL WIZARD REFERENCE
Configure Third-Party Driver Wizard
Third-Party Driver: Details
Third-Party Driver: JAR Folder
Third-Party Driver: Summary
Create TIBCO ActiveMatrix BPM Server Wizard
Welcome
ActiveMatrix BPM: Database Administrator
JDBC Connection String Formats
ActiveMatrix BPM: Runtime Database Configuration
ActiveMatrix BPM: BDS Database Configuration
ActiveMatrix BPM: Configuration
ActiveMatrix BPM: Sizing Configuration
ActiveMatrix BPM: LDAP Configuration
ActiveMatrix BPM: CMIS Configuration
ActiveMatrix BPM: Authentication Configuration
ActiveMatrix BPM: SiteMinder Configuration
ActiveMatrix BPM: Kerberos Configuration
ActiveMatrix BPM: Administrator Server Configuration
ActiveMatrix BPM: JMS Configuration
ActiveMatrix BPM: Host and Node Configuration
Administrator Server Configuration: Summary
Create TIBCO ActiveMatrix Administrator Server Wizard
Welcome
Administrator Server Configuration: Details
Administrator Server Configuration: TIBCO Host Configuration
Administrator Server Configuration: Connection Settings
Administrator Server Configuration: Internal HTTP Settings
Administrator Server Configuration: Notification and Messaging Bus Server
Administrator Server Configuration: Enterprise Message Service Connection Factory
Administrator Server Configuration: Database Details
Administrator Server Configuration: Authentication Realm
Administrator Server Configuration: Database Authentication Realm Details
Administrator Server Configuration: LDAP Authentication Realm Details
Administrator Server Configuration: LDAP Authentication Realm Details (Screen 2)
Administrator Server Configuration: LDAP Authentication Realm Details (Screen 3)
Administrator Server Configuration: Credential Server Details
Administrator Server Configuration: Credential Server Keystore
Administrator Server Configuration: Monitoring Notification Server
Administrator Server Configuration: Monitoring Database Configuration
Administrator Server Configuration: Log Service Database Configuration
Administrator Server Configuration: Payload Service Database Configuration
Administrator Server Configuration: Summary
Create TIBCO Host Instance Wizard
Welcome
TIBCO Host Instance Configuration: Details
TIBCO Host Instance Configuration: Notification Server
TIBCO Host Instance Configuration: Administrator Server
TIBCO Host Instance Configuration: Summary
Configure TIBCO ActiveMatrix BPM Server Node Type Wizard
Welcome
ActiveMatrix BPM Node Type: Administrator Server Configuration
ActiveMatrix BPM Node Type: Host and Node Configuration
ActiveMatrix BPM Node Type: Custom Keystore Configuration
ActiveMatrix BPM Node Type: Sizing Configuration
ActiveMatrix BPM Node Type: Summary
Replicate TIBCO ActiveMatrix Administrator Server Wizard
Welcome
Remote Administrator Server Details
Create Replicated Instance Wizard
Administrator Server Configuration Details
Administrator Server TIBCO Host Configuration
Administrator Server Connection Settings
Administrator Server Notification and Messaging Bus Server
Administrator Server Database Details
Administrator Server Database Authentication Realm Details
Administrator Server Configuration LDAP Authentication Realm
Administrator Server Configuration Summary
Edit TIBCO ActiveMatrix BPM Instance Wizard
Welcome
ActiveMatrix BPM Edit: Administrator Server Configuration
ActiveMatrix BPM Edit: Select Edit Configurations
ActiveMatrix BPM: Runtime Database Configuration
JDBC Connection String Formats
ActiveMatrix BPM: BDS Database Configuration
ActiveMatrix BPM: SOAP Version Configuration
ActiveMatrix BPM: CMIS Configuration
ActiveMatrix BPM: Authentication Configuration
ActiveMatrix BPM: SiteMinder Configuration
ActiveMatrix BPM: Kerberos Configuration
ActiveMatrix BPM: Package / unpack AMX Host for moving
ActiveMatrix BPM Edit: Summary
Upgrade TIBCO ActiveMatrix BPM Instance Wizard
Welcome
ActiveMatrix BPM Upgrade: Administrator Server Configuration
ActiveMatrix BPM Upgrade: Upgrade Configuration
ActiveMatrix BPM Upgrade: Summary
Delete TIBCO ActiveMatrix BPM Instance Wizard
Using the Delete TIBCO ActiveMatrix BPM Instance Wizard
Welcome
ActiveMatrix BPM Deletion: Administrator Server Configuration
ActiveMatrix BPM Deletion: Instance Configuration
ActiveMatrix BPM Deletion: Summary
Edit TIBCO ActiveMatrix Administrator Server Configuration Wizard
Edit ActiveMatrix Administrator Server Configuration: Administrator Server Selection
Edit ActiveMatrix Administrator Server Configuration
Administrator Server Configuration: Edit HTTP Connection Settings
Administrator Server Configuration: Edit Database Settings
Administrator Server Configuration: Edit Authentication Realm Settings
Administrator Server Configuration: Edit Database Authentication Realm Details
Administrator Server Configuration: Edit LDAP Authentication Realm Details
Administrator Server Configuration: Edit LDAP Authentication Realm Details (Screen 2)
Administrator Server Configuration: Edit LDAP Authentication Realm Details (Screen 3)
Administrator Server Configuration: Summary
IV - ADDITIONAL INFORMATION
Troubleshooting Installation
Installer Log File
Sanitizing After a Failed Installation
Restoring a BPM System from a Backup
Uninstalling an ActiveMatrix BPM System
Disaster Recovery Using Data-Level Replication
Data-Level Replication
Configuring TIBCO ActiveMatrix BPM for Disaster Recovery
Creating Host Aliases for TIBCO ActiveMatrix BPM System Components
Creating Service Name Aliases for TIBCO ActiveMatrix BPM Databases
Storing EMS Queues in the Oracle Database
Configuring TIBCO ActiveMatrix BPM to Use Hostname and Aliases
Enabling Halt on Error Behavior
Replicating TIBCO ActiveMatrix BPM File-Based Data
Transaction Manager Log Files
Replicating TIBCO ActiveMatrix BPM Database-Based Data
Recovering TIBCO ActiveMatrix BPM if the Primary Site Fails
Before Starting TIBCO ActiveMatrix BPM on the Secondary Site
After Starting TIBCO ActiveMatrix BPM on the Secondary Site
Disaster Recovery Using Device-Level Replication
Deleting a Replica ActiveMatrix Administrator Server
Securing Communication Channels
Configuring TIBCO Enterprise Message Service Servers
Using Third-Party Solutions to Configure a High Availability, Fault Tolerant ActiveMatrix BPM System
TIBCO ActiveMatrix® BPM Installation: Developer Server
Important Information
TIBCO Documentation and Support Services
Introduction
Installation Environment (TIBCO_HOME)
Configuration Directory (CONFIG_HOME)
System Requirements
Hardware Requirements
Platform Requirements
Third-Party Software Requirements
User Account Requirements
Performing Required Pre-Installation Tasks
Setting Maximum Number of Open Files on Linux
Checking Port Used by Existing Installations of PostgreSQL
Downloading TIBCO Software
Downloading Required Third-Party Software Assemblies
Installing ActiveMatrix BPM
Creating an ActiveMatrix BPM Developer Server
Access to Developer Server Components
Restarting Developer Server After Restarting Computer
Troubleshooting
Installer Log File
TIBCO Configuration Tool Log File
Uninstalling ActiveMatrix BPM
BPM Troubleshooting
Important Information
TIBCO Documentation and Support Services
Indications of a Healthy ActiveMatrix BPM System
Installation and Upgrade Issues
Installation Error Caused by Special Characters in the Hostname
Installation Fails to Complete Due to Pending Tasks on BPMNode
Installation Failure Due to Missing Database Objects
Failure Due to Insufficient Memory or Disk Space
Failure Due to Missing .dll Files
Failure Due to Incorrect Database Details
SQL Recovery Error after Installation
Sanitizing After a Failed Installation
Error When Configuring the ActiveMatrix Administrator Server
Refreshing a Node when Passing an Array to a Stored Procedure
Out of Sync SystemNode after Upgrade
Additional EMS Requirements for Installation and Upgrade
Failures in Linux Version 7 when TIBCO Business Studio uses the SWT Internal Browser
Initializers and Migration
BPM Logging Issues
BPM Log Files Location
BPM Logging Levels
Turning Debug On and Changing the BPM Logging Level
Increasing the File Size of Your BPM Log Files
Using the BPM Logs for Troubleshooting
Log Viewer
Running Log Viewer
Loading Log Files
Loading Event Collector Audit Data From a Database
Using Log File Views
Configuring Log Viewer Columns
Highlighting Log Entries
Filtering Log Files
Using Custom Attributes
Viewing Log Entries
Searching Log Files
Browsing Log Files
Analyzing Log Files
Using Log Viewer Configuration Files
Workspace Application Log
Configuring the Workspace Application Log
Workspace Application Monitor
Configuring Workspace Application Monitor
Unique Constraint Errors in the Log Pertaining to RQL Due to Long Running Queries
Authentication and LDAP Issues
Cannot Log In as the User Mapped in the Organization Browser
Cannot See the LDAP Connection in the Organization Browser
Troubleshooting LDAP Server Paging Errors
Requested Page Size from the LDAP Server is Incorrect
LDAP Container is No Longer Available After Upgrading
Organization Browser Error When Browsing an Organization Model Entity That Contains Many Users
REST Service Participant Configured for Custom Policy Set
REST and Authentication
HTTP Client Shared Resource and Authentication Issue
Authentication Error When REST Service Participant Configured for Basic Authentication Type
BPM Application Deployment Undeployment Issues
Tips for Successful BPM Application Deployment and Undeployment
Deploying from TIBCO Business Studio
Deployment of Global Signal Definition Project and Process with Global Signal Events
Re-Deploy/Upgrade of a Global Signal Definition Run-time Application
Removing applications from a node
Derived Artifacts
Types of Derived Artifacts
Cleaning Up Undeployed BPM Applications
The bpm-db-cleanup Utility
Running the bpm-db-cleanup Utility
BDS Global Data Cleanup
Attribute Alias Cleanup
Running the BPM Clean-up QueryAMXBPMTablesForCleanup.sql Script
Deploying a BPM Application Fails If the Referenced Organization Model Has Been Upgraded
Opening Work Items Throws a Default Channel Not Found. No Channels Have Been Deployed Error
Failures When DAA is Deployed in Environment Configured with Dev Mode Settings
Troubleshooting Failed Deployments After Upgrade
Cleaning up Failed Deployments
Force Undeploy Behavior
Dependent Applications
Force undeploy Works on the Current Version
Dependent Applications in Out of Sync State
Recovering from a Major Version Upgrade for Org-model Applications
Manually Undeploying SOAP Endpoints
Cleaning up Partially Deployed State Applications
Performing a Force undeploy on a Running Version of an Application
Cleaning Up All Versions of Your Applications
Application Start and Stop Only Affects Current Versions
Administrator Database Schema Changes
Undeploying Dynamically Generated Organization Model Entities That Have Work Offered To Them
Undeployment of TIBCO ActiveMatrix BPM Business Data Services Applications
Cleaning Up the Software Repository
TIBCO Openspace and Workspace Issues
Unable to Login to Openspace or Workspace
Unable to Complete Login to Openspace
httpConnector Error Message is Displayed
The Intended Recipient is Not Receiving Work Items
Errors when Processing Work Items
Runtime Issues
Monitoring Your BPM Node
Creating a New BPM Node with TCT Causes Failures
Recovering From a BPM Node Crash
Removing applications from a node
Rescheduling Process Instances Stuck in Starting State after a Node Crash
Preventing Process Instances from Failing and being Purged if a System Error Occurs
Suspended Timer Event Behavior
Troubleshooting BPM Node has a Status of Out of Sync
Missing Application Dependencies
Reallocate Work Item is Failing
Maximum Number of Tasks Allowed Has Been Reached
"Could not commit with auto-commit set on" SQLException From Oracle 12c JDBC Driver
Issues When Starting the BPM Application
"OutOfMemory Native memory exhausted" Error on System Startup
The BPM Application Cannot Connect
Implementation.ec Fails to Start
Not Enough Disk Space
Event Collector Waiting for Hibernate Shared Resource
A Business Service Fails to Start
Application Development Issues
How To Recover From a Corrupt Cache
Explanations of Specific Errors and Warnings
Tips to Create a Service Request
TIBCO ActiveMatrix BPM Product Version
Determining the Version for ActiveMatrix Platform
Determining the Version for ActiveMatrix BPM