This overview describes the integration of the FileNet P8 Image Manager's services and functions with the Open Client application. The integration of the Process Engine with Open Client is implemented within the context of FileNet Web Services based on the ASP.NET platform. The purpose of this integrated approach is to provide business process functionality for Open Clients in a manner that is essentially comparable to the functionality provided for FileNet P8 Image Manager ActiveX clients (for FileNet Web Services 3.x).
This integrated framework allows customers and developers to use the out-of-the-box ASP.NET Open Client PWM (Personal Workflow Manager), Launcher (launches a workflow definition), Step Processor, and Launch Step Processor that come with the installation, or you may customize these as required (source code for is provided with the Open Client installation). The ASPX top-level pages host the Process Engine modules so that they can be launched either from the Open Client web application or via email notification messages.
The FileNet Open Client framework provides for a nearly seamless integration, except that the Process Designer, Linker, Tracker, Step Processor, Launch Step Processor, Admin, and Config must run in browser popup windows (by invoking JavaScript APIs on the client to open the popup windows). A .js file contains the JavaScript methods used to open the popup window (see figure below).
This topic provides a summary overview of the architecture, basic components, and the communication protocols and interfaces of the integrated FileNet Open Client model, as follows:
The following figure illustrates the integrated FileNet Open Client architecture within the context of the .NET platform environment. The architecture is based upon the "MVC" model, where:
For information on the components, communication access protocols, and interfaces shown in the figure, see FileNet Open Client Components and FileNet Open Client Communications Protocols and Interfaces below.
The FileNet Open Client architecture consists of the following basic server and client components (for details, click on the bulleted component):
Note: Not shown in the figure above (to avoid needlessly complicating the figure) is the Sun JRE 1.3.1, which provides the runtime environment on both the web server and the client. For details, see Java Runtime Environment (JRE) below.
FileNet Open Client components that reside on the FileNet P8 Image Manager Web Server include (for details, click on the bulleted link):
A key difference between standard ASP pages and the more object-oriented ASPX pages is that whereas a standard .asp page does not yield modularized code (both HTML and Script are included in a single page), an ASPX page allows you to divorce presentation code from the business logic code, where presentation is typically provided in the .aspx page and business logic is provided in its associated "code-behind" file.
Note: For those familar with ASP, but who are new to creating ASPX pages, each ASPX page (for example, created using Visual Studio) has an associated equivalent class written in a .NET compliant language, such as VB.NET, C#, C++, Managed C++, JavaScript, and so on (Open Client uses VB.NET). This class consists of event handlers, initialization code, and other supporting code for the user interface in the ASPX file. The .aspx.vb file that holds this class is called the "code-behind" file and provides the ASPX file's programmatic implementation.
In the FileNet Open Client model, the ASPX page provides the "Controller" layer component of the model. The ASPX page encompasses both the View layer (the various User, Factory, and other Controls that provide the user interface) and the Model layer (XML data supplied by the Data Providers to the ASPX page via XSLT transformation), which have been separately provided. As with all standard ASPX pages, the FileNet Open Client ASPX page incorporates server controls (for example, the start of the page <BODY> section typically includes the Runat="server" control).
The ASPX page is compiled and instantiated when first requested by the client via an HTTP request. The .NET Web Form (see below), which is the resulting .aspx form, is returned to the client and is also cached on the Web server for reuse.
The Process Java API classes provide access to the Process Server (WorkFlo) workflows and workflow items. The Process Java API enables you to access the runtime, administration, configuration, and workflow functionality supported in the FileNet Web Services server, as follows:
In addition to the Java API (used to provide access to Process services for Open Client applets), the Process Java UI Toolkit (not shown in figure above) is also provided with the Open Client installation. This toolkit provides Process Swing-based Java beans and interfaces which can be used to customize the user interface of an Open Client Java applet, such as a Java Step Processor, or Java Launch Step Processor.
For additional information on the Process Java APIs, see the Help for Process Development guide, the Process API JavaDoc documentation (for detailed Java API class descriptions), and the Process UI Toolkit JavaDoc documentation (for detailed descriptions of the Process Java UI Toolkit interfaces and beans).
The Process Data Providers are a set of VB.NET classes (.vb files) that are used to provide the Controller layer interface to Process services, such as VWSession, Step elements, etc. In addition, Open Client Data Providers retrieve FileNet P8 Image Manager COM objects (IDMObjects) instantiated from the Images Services client library via the IS server and from the Content Services client library via the CS server. The Data Providers invoke FileNet P8 Image Manager Web and Process COM objects to produce either .NET objects or XML data, so that they can be used by the Open Client UI user controls. Data Providers basically encapsulate and mask the UI user control interface to the Process services, as well as to the FileNet P8 Image Manager COM Foundation objects.
Process-specific Data Providers are used to provide Process-related functionality as follows:
Process DP Class |
Description |
---|---|
FneProcessBaseDP | The base Process Data Provider abstract class (inherits FnBase). This class also includes Open Client wrapper classes for corresponding Process Data Provider classes to provide Process-related functionality, such as setting an FneProcessSession object to a VWSession object, converting an Process VWQueueElement to an FnQueueElement, and so on. |
FneProcessLauncherDP |
Process public class Data Provider to provide Process Launcher functionality (inherits FneProcessBaseDP). |
FneProcessPWMDP |
Process public class Data Provider to provide Process Personal Work Manager functionality (inherits FneProcessBaseDP). |
FneProcessSessionDP |
Process public class Data Provider to handle Process authentication, unified logon (so the user does not have to logon more than once) and logoff (inherits FneProcessBaseDP). |
FneProcessStepProcDP |
Process public class Data Provider to provide Process Step Processor and Launch Step Processor functionality (inherits FneProcessBaseDP). |
FneProcessUserPrefsDP |
Process public class Data Provider to provide base Process user preferences support and integration (inherits FnBase). |
The Process Integration Services Module (ISM) provides services to interface between the client (via RMI) and the FileNet Open Client Foundation COM API objects (via JNI) for Open Client-related services. For example, the ISM interface enables the FileNet P8 Image Manager Designer on the client to retrieve top-level folders from the CS library for initial UI display.
The Process ISM provides the following integration/interface services:
Note: The FileNet P8 Image Manager VWServices.exe is an executable file that runs as an NT service.
Note: The Process router process also uses this vwidmcom.dll for encryption/decryption of the tokens.
The Sun JRE (not shown in the figure) provides the runtime environment on both the web server and the client (JRE 1.3.1 must reside on the client as well as the server in order for FileNet Open Client to run). JRE 1.3.1 is automatically configured on the client machine when the J2re_1_3_1_win_i.exe file is downloaded (when the application is run for the first time) and executed.
When setting up for Open Client, be sure to install JRE in its default directory in order to ensure that JiGlue (provides the COM Bridge between the Open Client Data Providers and Process services) works correctly; for details, see JiGlue below.
Note This assumes a Windows OS. If you are running Open Client on an AIX, HP-UX, or Solaris server, use JRE 1.3.0 instead of JRE 1.3.1. However, be aware that JRE 1.3.0 cannot be used with Process VWServices because the processes invoked by this service are killed when the user logs off the server.
On the web server, JRE provides the runtime environment for the following components:
On the client, JRE provides the runtime environment support for the Java Plug-in.
Caution: The Sun JRE 1.3.1 (not shown in the figure) must be installed in its default directory in order for JiGlue to work properly.
JiGlue (pronounced "JIG-LOO") is a COM object that serves as a COM Bridge to Process services. As indicated in the figure above, the Process Data Providers use JiGlue to interface to the Process API. JiGlue provides a translation layer between the Process Java APIs and COM. Using the JiGlue COM Bridge provides the ability to make calls (for example, in Visual Basic within the ASP.NET context) with the effect of native Java statements for most Win32 programming tasks.
In the FileNet Open Client model, use of JiGlue is specified in the appropriate Data Provider (for example, in the FneProcessStepProcDP Data Provider for the out-of-the-box HTML Step Processor). This is done in order to insulate the ASPX page and the User Controls from JiGlue and the FileNet Web Services server. Normally, you should not reference JiGlue outside the Data Provider.
For example, a typical Process use of JiGlue might be to use it to enable the Open Client's PWM (Personal Work Manager) FneProcessPWMDP Data Provider to retrieve items from the "Inbox" queue and provide them to the presentation layer. Or as another example, to use JiGlue to create and instantiate an Process VWSession object and logon, you might use VB.NET example code similar to:
Imports Jiglue Public Class FnJiglueSample Protected m_aJiglue As New JiglueUtil() Public Function Logon() As Boolean ... 'Use JiGlue to create a VWSession object and logon Dim aVWSession As Object aVWSession = m_aJiglue.newinstance("filenet.vw.api.VWSession") SetVWSession(aVWSession) aVWSession.logon(strUserName,strPassWord,strRouterURL) ... End Function ... End Class
where strRouterURL is the URL of the router for the FileNet Web Services server.
There are some issues related to using JiGlue with FileNet Open Client. For information on using JiGlue (including related issues) with Open Client, see Developing a Custom HTML Step Processor and Developing ASPX Pages for Open Client elsewhere in this Open Client Developer's Guide. For additional information on JiGlue (including guidelines and the JiGlue COM Bridge conversions between COM data types and Java data types), see the Help for Process Development guide.
The Open Client User Controls are a set of VB.NET .ascx files provided by FileNet that, in conjunction with Open Client Control Factory controls and the .NET server controls (and associated .NET classes), provide the building blocks of the Open Client user interface (the "View" part of the MVC model).
Note In some cases, a User Control is similar to a subpage that encapsulates both user interface and logic; i.e., in these cases, the User Control is more like a Controller component than a View component.
A key advantage of User Controls are that they are reusable; that is, Open Client User Controls are reusable, object-oriented, event-driven controls that can be loaded either into ASPX pages or into other User Controls. Open Client User Controls either display the data, or they represent available operations for the displayed data, or some combination of these. Each User Control defines its data format (for example, XML for Process controls).
For information on using Process User Controls when developing an ASP.NET Processor, see Developing a Custom HTML Step Processor. For additional information, see the description of Open Client User Controls and Control Factory Controls elsewhere in the Open Client Developer's Guide.
In addition to the Open Client User controls (both Process-specific and non-Process-specific), you can also use the standard .NET controls and .NET class libraries to help customize the user interface defined in the ASPX page. The .NET Framework comprises over 3,400 standard classes that you can apply (in addition to the Open Client user controls) to the ASPX page in order to help customize the user interface (by comparison for those new to the .NET platform, there are seven standard objects built-in in an ordinary ASP Framework the Application, ASPError, ObjectContext, Request, Response, Server, and Session objects). Normally, you would use the .NET controls and classes in those instances where the presentation element was not already provided by an available User control.
For additional information, see http://www.microsoft.com/net.
The .NET Web Form is the ASPX form that is provided to the client in response to a client HTTP form request. When an ASPX page is first requested, it is compiled and cached on the server. The .NET Web Form is the container of the Model and View layers provided to the client. The .NET Web Form comprises both the ASPX page and its related "code-behind file", written in a .NET-compliant language (for Process, in VB.NET), that provides event handlers, initialization code, and other supporting code for the user interface in the ASPX file.
A set of FileNet P8 Image Manager Web (Foundation) COM objects (IDMObjects) are provided from the Images Services client library via the IS server and the Content Services client library via the CS server. These objects are provided for the purpose of retrieving or updating folder content, document properties, and attachments from those libraries.
The FileNet P8 Image Manager Web COM objects are retrieved via RPCs (Remote Procedure Calls) and are provided to Open Client Data Providers, which invoke the COM objects to produce either .NET objects or XML data so that they can be used by the Open Client UI User Controls.
When the client is started for the first time, a package containing JRE 1.3.1 and the FileNet P8 Image Manager pw.jar file is downloaded to the client. The FileNet Open Client components that reside on the client include:
Note: JRE 1.3.1 (not shown in the figure above) must be on the client in order to run FileNet Open Client (on the client, JRE provides the runtime environment support for the Java Plug-in). For details, see Java Runtime Environment (JRE) above.
As previously indicated, the Process Designer, Linker, Tracker, Step Processor, Launch Step Processor, Admin, and Config must run in browser popup windows (these invoke JavaScript APIs on the client to open the popup windows). A JavaScript file, FnWindowHelper.js, contains the JavaScript methods used to open the popup window. The JavaScript API methods allow the Processor to invoke the following Open Client popups:
The Process Java API classes provide access to the Process Server (WorkFlo) workflows and workflow items (RMI is used to access Java methods distributed between the Process Java APIs on the client and on the web server). The Process Java API enables you to access the runtime, administration, configuration, and workflow functionality supported in the FileNet Web Services server, as follows:
In addition to customizing the Open Client user interface for ASP.NET Step Processors, for those who wish to use Java to customize the user interface, the Process Java UI Toolkit provides Java Swing-based interfaces and beans (not shown in figure above).
For additional information on the Process Java APIs, see the Help for Process Development guide and the Process API JavaDoc documentation (for detailed API class descriptions). For information on the Process UI Toolkit, see the Process UI Toolkit JavaDoc documentation.
As indicated in the above figure (see Process Open Client Architecture), communications and interfaces between Process Open Client components are accomplished via one or more of the following communications protocols or interfaces: