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
Content Management Interoperability Services
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
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
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
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
RQL Expression Evaluation
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
RQL Cleanup Configuration
TIBCO Business Studio™ Forms User's Guide
Important Information
TIBCO Documentation and Support Services
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
Using CSS to Customize the Rendering of a Form Control
Using Editable List Controls
Changing a Control’s Background Color Based on its Value
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
Overview of the Java Service Connector
Enabling the Java Service Connector for Your Development Environment
Obtaining Information From TIBCO Business Studio
Work Data Models
Business Object Models
Formal Parameters
Valid Format for DataModel
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
Single-Element Arrays
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
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
Deprecated Services and Operations
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
UserSettingsService - Deprecated Service
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
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
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
Resource Caching
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
Configuring TIBCO ActiveMatrix BPM to Use Integrated Windows Authentication With SQL Server
How to Determine the ActiveMatrix BPM Hotfix Version
BPM Properties Files
Properties Files Reference
Business Data Services Properties (bds.properties)
Content Management Properties (cm.properties)
Process Instance Properties (bx.properties)
Configuring the Maximum Number of Tasks per Process Instance
Process Engine Properties (pvm.properties)
Configuring Cleanup of the PVM_WORK_ITEM or PVM_REQUEST_QUEUE Database Tables
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
Configuration of Per-Activity Retry Settings in TIBCO Business Studio
Disabling Provisioning of Application Development Applications
Configuring how Application Development Starts with ActiveMatrix BPM
Configuring System Logging
Configuring Logging Levels
Controlling What Information is Logged
Excluding Specific Audit Messages From the BPM Log File
Excluding Attributes From Logged Messages
Defining Where your Logging Output is Stored
Configuring TIBCO ActiveMatrix BPM Auditing
File Format
Auditing Level
Event Probe Rules File (ec-probe-rules.xml)
Default Audit Level
Editing the Event Probe 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 (ec-event-rules.xml)
Full Auditing
Default Publication
Using the rulesinfo Utility to Validate the Event Probe Rules and Event Rules Files
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
Enhancing Security in ActiveMatrix BPM
Configuring ActiveMatrix BPM to Use Single Sign-On
Backing up and Restoring the ActiveMatrix BPM System
Taking an Online Backup of the ActiveMatrix BPM System
Taking an Offline Backup of the ActiveMatrix BPM System
Restoring the ActiveMatrix BPM System From a Backup
Support for CORS
Configure the CORS Implementation
Default Substitution Variables for the CORS Implementation
Clearing Audit and Statistical Data
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
Clearing Audit and Statistical Data Entries Associated with Case Data
Using the Purge Process CLI
Managing the SSH Host Key Used by the Purge Process CLI
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
Configuring the Jackrabbit Janitor Thread
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 (CLI)
Location of Sample Files
Invoking the Command-Line Interface
Understanding Build Files
Understanding AMXAdminTask
Understanding Data Files
Understanding Objects
Supported Objects
Object Formats
Object Navigation
Inter-Object Relationships
Configuring Timeout
Property File Reference
Actions Performed Using CLI
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 using the GUI
Editing the Notification Transport Server Configuration using the CLI
Notification Transport Server Configuration Locations
The TIBCO ActiveMatrix Administrator Status Cache
Characteristics of the Approach
Prerequisites for Invoking the Notification Transport Server Configuration Update Target
Sample Scripts
Features
TRA properties and TIBCO ActiveMatrix Administrator CLI Options
Executing the Notification Transport Server Configuration Update from the Administrator CLI
Available ANT Targets
End-to-End Execution with Sample Outputs
Managing Hosts in an Inconsistent State
Sample Outputs
Reconnecting to EMS
Reconnect to EMS for Selected Host Using the GUI
Reconnect to EMS for Selected Host Using the CLI
Reconnect to EMS for JMS Deployment Server Connections
Reconnect to EMS for an Enterprise Using the GUI
Updating Internal HTTP Connector Configuration
Prerequisites
Sample Scripts
Features
Eligibility of a Host or Node for Update
Track Logs Using OperationID
Executing the ANT Script to Update the Internal HTTP Connector
End-to-End Execution with Sample Outputs
Managing Hosts and Nodes in "Not Running" State
Retrieving "Out of Sync" Keystore Resource Instances
Authentication Realms
Administrator Replication
Messaging Bus Configuration of an Enterprise
Determining Whether an Enterprise Uses a Messaging Bus
Configuring an Enterprise to Stop Using a Messaging Bus
Managing Environments
Determining Whether a New Environment should use a Messaging Bus
Creating an Environment
Configuring the Messaging Bus of an Environment
Changing the Messaging Bus of an Environment
Determining Whether an Environment Uses a Messaging Bus
Environment General Reference
Environment Configuration Reference
Messaging Bus Reference
Managing Hosts
Host Processes
Creating a TIBCO Host Instance
Adding a TIBCO Host
Adding a Host While Creating a New Node
Editing a TIBCO Host
Installing a TIBCO Host
Assigning a Host to An Environment
Starting a TIBCO Host
Stopping a TIBCO Host
Restarting a TIBCO Host
Uninstalling a TIBCO Host
Deleting a TIBCO Host
Enabling Secure Communication between a Host and an Administrator Server
Registering a TIBCO Host Instance as a Windows Service
Unregistering Hosts
Binding Hosts to an Administrator Server
Discover Hosts Reference
Register Host Reference
Appending tibcohost Instance Name to the Executable Process for Adminstrator Created TIBCO Host
Updating the JVM Configuration of a Host
Adding all JVM Properties to java.extended.properties
Updating the JVM Properties of a Host Through the GUI
Updating the JVM Properties of a Host Through the CLI
Setting the JVM Properties of a Host Through the CLI
Modifying JVM Properties of a Host Through the CLI
Deleting JVM Properties of a Host Through the CLI
Properties of Resource Templates
Hosts Reference
Host General Reference
Host Configuration Reference
Host Substitution Variables Reference
Host Resource Instances Reference
Caveats for Host Life Cycle Management
Managing Nodes
Node Processes
Developer Node
Navigating to a Nodes List
Creating a Node
Determining Whether a Node Uses a Messaging Bus
Creating Multiple Nodes with the Same Name
Extending Target Platform in Design Time
Extending Target Platform through the GUI
Extending Target Platform through the .ini File
Limitation
Date Display for Features
Copying Preparing for Undeploy (PFU) Components across BPM Nodes
Overview
Understanding the CLI action copyPFUComponents
Running the CLI action copyPFUComponents
Example Scenario for copyPFUComponents
Editing a Node
Updating the Port Number for a Node
JVM Arguments of a Node
Updating the JVM Configuration for a Node using Administrator UI
Enabling and Disabling the Java Security Manager
Enabling and Disabling Debuggers
Installing or Syncing Nodes
Uninstalling Nodes
Uninstalling Features using Wildcards
Starting Nodes
Manually Restarting Nodes
Stopping Nodes
Restarting a Node
Graceful Node Shutdown
TRA Property
Log Information for the Graceful Node Shutdown Feature
Deleting Nodes
Deleting Node Features using Wildcards
Threading Policy
Setting the Threading Policy Properties Through the GUI
Setting the Threading Policy Properties in the Node's TRA File
Example of Threading Policy
Properties of Resource Templates
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
Viewing an Aggregated Status of a Node
Using the GUI
Using the CLI
Using the Web Service API
Checks Done for an Aggregated Status of a Node
Limitations
Managing Applications
Creating an Application
Distribution Modes
Distributing an Application
Application Dependencies
Deploying Applications
Deployment Preflight Check
Tracking Application Deployment Progress
Undeploying Applications
Undeployment Preflight Check
Determining Whether an Application Uses a Messaging Bus
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
Editing a Binding
Deleting a Binding
Configuring a Binding for a Reference
Promoting a Service to the Environment
Getting a List of Promoted Services
Generating a WSIL Servlet Page
Invoking the EndpointService API Directly
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
REST Bindings
Adding a REST Binding
Editing a REST Binding
Deleting a REST Binding
REST Binding Reference
Visualizing and Testing REST Service Bindings Using Swagger
Accessing Swagger UI through ActiveMatrix Administrator
Swagger UI
Invoking an Operation
Invoking a GET Operation
Invoking a POST Operation
Generating a Swagger JSON File
Overview of the Swagger JSON File
Sample Swagger JSON File
Troubleshooting
Wire to Binding Reference
Viewing Policies Applied to an Application
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 a Resource Template
Creating an Obfuscated Password
Configuring Mutual Authentication
Configuring and Preparing HTTP Connector for Jetty 9
HTTP Request Referrer Header Validation
Configuring Third-party Drivers
Configuring a Third-party JDBC Driver
Upgrading a Third-party JDBC Driver Using the GUI
Upgrading a Third-party JDBC Driver Using the CLI
Sample Output
Sample Logs: Upgrading Third-party JDBC Drivers
Testing a Connection to a JDBC Resource
Disabling Test Connection to a JDBC Resource
Configuring a Third-party JMS Driver
Configuring the Read Response Timeout for an LDAP Connection
Keystores
Creating a Keystore Containing a User Name and Password
Properties of Resource Templates
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
Using Diagnostics
Accessing and Using Diagnostics Commands
Retrieving Log Files for Hosts and Nodes from Administrator
Service Health Check
Overview
Invoking Service Health Check
Executing a Request from the ActiveMatrix Administrator UI
Response: Graphical Representation on UI
Executing a Request from API Testing Tools
Response: XML Representation
Elements and Attributes in a Response
Database Queries for Service Health Check of JDBC Shared Resource
Example of a Complex Service Health Check Scenario
Status of Failure Scenarios
Caching a Service Health Check Response
Enabling or Disabling the Caching of a Service Health Check Response
Specifying the Validity Duration for a Service Health Check
Ping a SOAP or REST Endpoint
Specifying a Timeout Value for a Service Health Check Invocation
Suppressing Stack Trace in a Service Health Check Response
Service Health Check Logging
Log Information Specific to Service Health Check
Tracing a Request Flow Using the CorrelationID
Types of Log Messages
Deployment Time Messages
Runtime Messages
Disabling the Service Health Check
Service Health Check Samples
Service Health Check Sample for SOAP/HTTP
Service Health Check Sample for SOAP/JMS
Service Health Check Sample for REST
Custom Health Check Using Annotations
Scenarios Explaining Custom Service Health Check
Using TIBCO ActiveMatrix Business Studio for Service Health Check Annotations
Generating a Custom Service Health Check Method
Sample of Custom Service Health Check Method
Combinations of Custom Service Health Check Operations
Removing the Custom Service Health Check Method
Restrictions and Limitations
Coding Guidelines
Using the Custom Service Health Check Feature (Runtime)
Enabling Custom Service Health Check at the Node Level
Request Parameters
Response Elements
Logging
Service Health Check Sample for Annotations
Enterprise Deployment Health Check
Objectives
Running Enterprise Deployment Health Check
Running Enterprise Deployment Health Check using ActiveMatrix Administrator UI
Ping TIBCO ActiveMatrix Entities in Real Time
Enterprise Test Deploy
Getting ActiveMatrix Administrator Information
Getting ActiveMatrix Administrator Configuration Information
Custom Enterprise Health Check
Enterprise Health Check
Viewing Reports for Current or Past Health Check Tests
Updating Timeout Value for Enterprise Deployment Health Check Tests
Disabling Enterprise Deployment Health Check from ActiveMatrix Administrator UI
Running Enterprise Deployment Health Check using ActiveMatrix Administrator CLI
Prerequisites for Invoking Health Check Targets
Invoking Health Check Targets
Available Ant Targets
Restrictions for Target Usage
Chaining Targets
Data File: enterprise_healthcheck_data.xml
Schematic Representation of Enterprise Deployment Health Check
Sample CLI Output Explanation
CLI Target Validation and Upload of Sample Application
Starting Enterprise Deployment Health Check
Metadata of TIBCO ActiveMatrix Administrator
Runtime Information of TIBCO ActiveMatrix Administrator (Collected in Real-time)
TIBCO ActiveMatrix Enterprise-wide Summary
Hosts and Nodes: Initialization Status and Ping Response
Starting Test Deployment
Test Deployment Cleanup and Reporting
Report File Explanation
Sample Enterprise Deployment Health Check Outputs
Get Only Metadata of TIBCO ActiveMatrix Administrator
Get Only Runtime Configuration Information of TIBCO ActiveMatrix Administrator
Get Metadata Along With Runtime Information of TIBCO ActiveMatrix Administrator
Ping the Entire TIBCO ActiveMatrix Enterprise
Ping TIBCO ActiveMatrix Nodes and Hosts for Select Environments
Ping TIBCO ActiveMatrix Nodes for Select Hosts
Perform Test Deployment on Select Nodes in a TIBCO ActiveMatrix Environment
OSGi Diagnostic Tool
Accessing the OSGi Diagnostic Tool
Introduction to the GUI of the OSGi Diagnostic Tool
Node Page
Bundle Page
Endpoint Page
Implementation Component Page
Packages Search Utility Page
Exporting Reports from the Tool
Searching in Current Report
Searching for Packages
Reloading Data in Current Report
Sample Scenario: Node does not start during installation or upgrade
Sample Scenario: Application is in Running State but Unable to Respond to Queries
Export and Import
Exported Objects
Export Options
Exporting Data from TIBCO ActiveMatrix Administrator
Exporting from GUI
Exporting from CLI
Selecting Data to be Exported from CLI
Selecting Objects for Exporting from CLI
Selecting Export Options from CLI
Selecting the Administrator from which Data is to be Exported
Downloading the Archive File
Deleting the Archive File Automatically
Export Archive Directory Structure
Folders and Files in Exported Data
Export Reporting and Error Handling
Importing Data to TIBCO ActiveMatrix Administrator
Prerequisites for Importing
Modifying Archive Structure Before Import
Import Options
Scope of Execution of Import CLI Script
Import Order for Applications with Dependencies
Logging for Import
Post Builds Reports for Import
Error Handling
Troubleshooting
Running Report on Data Files
Running Report on Data on the Target Administrator Server
Limitations
FAQ for Export
FAQ for Import
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
Enabling or Disabling the Node Features using the tibcohost.exe Command
Synchronizing Node Feature List
Features Sync Status
Adding Application Templates to the Enterprise
Deleting Application Templates
Features Reference
Application Template Reference
Versions
Distributed Application Archives
Managing DAA Files
Uploading a Distributed Application Archive
Distributed Application Archive Reference
Monitoring
Monitoring Entities in an Enterprise from a Single Page
Accessing the Enterprise Status Page
Introduction to the UI of the Enterprise Status Page
Home Tab
Host Tab
Node Tab
Resource Instance Tab
Application Tab
Enterprise Tab
Searching for Entities in an Enterprise
Supported Entities and their Runtime States
Values in the Parent Column
Values in the Synchronization Column
Actions that can be Performed on Searched Entities
Search in Current Table
Bookmark a Search URL
Reload Data in the Table
Export Data from the Table
Accessing Administrator Dashboards
TIBCO ActiveMatrix SPM Dashboard
Accessing the Dashboard
Enterprise Dashboards
Dimension Hierarchies
Asset Status
Web Interface
Server Configuration
User Preferences
System Alerts
Filtering Alerts
Time Range Selectors
Working with Tables
Health Monitoring Summary
Environments Dashboard
Environment Details
Nodes
Node Details
Applications
Application Details
Services
Service Details
Service Instance Details
Shared Resource Instances
HTTP Resource Details
JDBC Resource Details
JMS ConnectionFactory Resource Details
ThreadPool Resource Details
Rules
Structure of a Rule
Example Authoring a Rule with E-mail Action
Rules on Asset Status
Rule Evaluation and Batching
Creating a New Rule
Defining the Scope of a New Rule
Setting Condition
Setting Action
Clearing Condition
Clearing Action
Customization of an Email-Action
Rules with Auto-Populated Dimensions
Rules Dashboard
Using HTTP Header Information to Emit Statistics
Emitting 'Sender Identifier' Information
Configuring the Sender Identifier Expression
Configuring the Sender Identifier Expression from TIBCO ActiveMatrix Business Studio
Configuring the Sender Identifier Expression Using the CLI
Configuring the Sender Identifier Expression Using the TIBCO ActiveMatrix Administrator UI
Sample: Sender Identifier Expression
Log Messages: Sender Identifier
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
TIBCO ActiveMatrix Policy Director Governance Administration
Object Groups
Creating an Object Group
Publishing an Object Group
Copying a Object Group
Deleting an Object Group
Command-Line Interface for Object Groups
Build Files for Object Groups
Creating a Fixed Object Group
Creating a Dynamic Object Group
Defining the Search Criteria for Object Groups
Selecting Attributes for The Search Criteria
Governance Controls Overview
Authentication
Authorization
Confidentiality
Integrity
Credential Mapping
The mustUnderstand Attribute
Command-Line Interface for Governance Controls
Build Files for Governance Controls
Using the Command-Line Interface to Define Governance Controls
Use Case for User Name Token Authentication
Use Case for WSS Consumer Reference
Use Case for WSS Provider Reference
Governance Control Management
Creating a Governance Control
Deploying a Policy
Activating a Policy
Synchronizing a Policy
Displaying a Policy
Copying a Policy
Deactivating a Policy
Undeploying a Policy
Deleting a Policy
Enforcing Integrity and Confidentiality
Enforcing WSS Provider
Enforcing WSS Consumer
Managing Governed Objects by Using the Governed Object Synchronization Utility
Synchronizing Governed Objects
Deleting Governed Objects
Governance Control Reference
Creating an LDAP Connection Resource Template
Configuring Kerberos Authentication Service Provider
Configuring SiteMinder
Basic Authentication
Basic Credential Mapping
Username Token Authentication
Authentication by Kerberos
Authentication by SiteMinder
Authorization by Role
Logging
View Log Utility
SAML Authentication for SSO
SAML Credential Mapping for SSO
WS Reliable Messaging
WS-Addressing for Reference
WS-Addressing for Service
WSS Consumer
WSS Provider
Policy Status List
Proxy Service Management
Registering an External Service
Modifying an External Service
Deleting an External Service
Creating a Proxy Application
Configuring a Proxy Application
Using System Preferences
Updating a Proxy Application
Deploying a Proxy Application
Starting a Proxy Application
Stopping a Proxy Application
Undeploying a Proxy Application
Deleting a Proxy Application
Command-Line Interface for Proxy Service Management
Build File for Proxy Service Management
Creating a Proxy Application Using the Command-Line Interface
Security Error Message
System Logging
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
Log Services
Editing Log Service Properties
Log Service Property Reference
Logging Appenders
Creating a Logging Appender
Logging Appender Reference
Log Entry Enrichment
JMS Appender Configuration
Setting the JMS Appender Configuration Properties
Downloading Logs for an Application
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
Schema Validation for SOAP Messages
Overview
Configuration
Enabling Schema Validation at Node Level
Disabling Schema Validation at Node Level
Enabling Schema Validation at Binding Level
From TIBCO Business Studio
From TIBCO ActiveMatrix Administrator UI
From TIBCO ActiveMatrix Administrator CLI
Runtime Behavior
Sample
Incoming SOAP Messages
Outgoing SOAP Messages
Logging
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
Properties of Resource Templates
UDDI Server Reference
Application UDDI Publication Reference
Suspending or Unsuspending an Enterprise
States of an Enterprise
Suspended State
Unsuspended State
Read-only State
Write State
Enabling or Disabling the Suspend Activity
Build and Data Files
Targets and Attributes in Build File
enterprise_suspend_build.xml
enterprise_suspend_data.xml
Putting an Enterprise in a Suspended State
Putting an Enterprise in an Unsuspended State
Putting an Enterprise in a Read-only State
Putting an Enterprise in a Write State
Getting the Status of an Enterprise
Getting the Status of a Read-only Enterprise
Logging
Samples
Sample: Suspend
Sample: Unsuspend
Sample: Read-only State
Sample: Write State
Sample: Suspend When the Enterprise is in a Suspended State (failOnError Set to True)
Sample: Unsuspend When the Enterprise is in an Unsuspended State
Sample: Unsuspend When the Enterprise is in an Unsuspended State (failOnError Set to False)
Sample: Status of an Enterprise
Sample: Status of Read-only Enterprise
Single Sign-On to SOA Applications Using SAML SSO Web Profile
Using SAML Web Profile to Implement SSO
Configuring Identity Provider for SAML SSO
Creating and Installing a Resource Template and Resource Instance
SAML SSO Web Profile Authentication Resource Template
Applying the SAML SSO Web Profile Authentication Policy
Testing an Application That Uses SAML Authentication
Log Information Specific to SSO using SAML SSO Web Profile
Single Sign-On to SOA Applications using OpenID Connect
OpenID Connect in ActiveMatrix
Implementing OpenID Connect
Create a Web Application with an OpenID Policy
Registering an Application at an Identity Provider
Create a Resource Template of Type 'OpenIDAuthentication'
Deploy a Web Application with the OpenID Policy
Testing a Deployed Web Application that Uses OpenID
Troubleshooting OpenID Connect Issues
Troubleshooting
NodeUtil
Invoking the NodeUtil Utility
NodeUtil Commands
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
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
Using OpenID Connect with ActiveMatrix BPM
Registering an Application at an Identity Provider to use OpenID
Configuring OpenID Connect in ActiveMatrix BPM
Using TCT to create an OpenID Connect Shared Resource
Using ActiveMatrix Administrator to create an OpenID Connect Shared Resource
Specifying the authDefaultMethod Substitution Variable for OpenID
Configuring the Referer Header
Using OpenID Connect with Custom Applications
Troubleshooting OpenID Connect Issues
Using SAML Web Profile with ActiveMatrix BPM
Registering an Application at an Identity Provider to use SAML Web Profile
Configuring SAML Web Profile Authentication in ActiveMatrix BPM
Using TCT to Create an SAML Web Profile Shared Resource
Using ActiveMatrix Administrator to Create a SAML Web Profile Shared Resource
Specifying the authDefaultMethod Substitution Variable for SAML Web Profile
Configuring the Referer Header
Using SAML Web Profile Authentication with Custom Applications
Dual Authentication
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
Other JVM Settings
Java Heap Memory
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)
Statistics Collector (SC)
Thread Pools
Process Engine (PVM)
User Application (UserApp)
BPM Filtering and Sorting of Work Lists and Audit Entries
BPM Nodes
BPM Node Recovery Configuration
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
Configuring BLOB Data Compression
Configuring LRUCache Size for Process Definitions and Modules
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 Monitoring Service Application
Configurations
Configuration Prerequisites
Configuring Sample Rulebases
Configuring for Hawk 5.x
Configuring for Hawk 6.1
Configuring for TIBCO Enterprise Message Service
Configuring to Manage and Monitor Multiple TIBCO Host Instances in the Same Hawk Agent
Configuring Service Rulebase Samples
Rulebase Details
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
Configuration of TIBCO ActiveMatrix Hawk Rulebase Samples
Scenarios
Scenario A: When Tibco Host is Abnormally Shutdown
Scenario B: When Administrator Node is Abnormally Shutdown
Scenario C: Runtime Nodes Managed by connected AMX Host
Deploying and Testing Sample Application
Testing the Sample Application
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
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 Files
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
Re-offering Work Items on Session Timeout
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
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
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
Adding a New BPM Node to an Existing System Fails Because a Resource Instance is Missing or Cannot be Installed
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 and 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
A Global Signal Audit Includes Expired Persistent Signals
Undeploy Does Not Work On An Upgraded Global Signal Definition 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
Upgrading a Business Data Project That References Another Business Data Project Fails
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
A Business Service Fails to Start
Process Halts with "... cannot be cast to..." Error
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
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