Application Engine is the FileNet® P8 component that hosts the Workplace web application, Workplace Java-based applets, and application development tools. It is the presentation layer for both process and content.
Application Engine protects user credentials passed between Workplace and Content Platform Engine and, if configured, provides SSL security.
- Workplace
- A web application that provides access to the document management
capabilities and is tightly integrated with the business process management
capabilities of FileNet P8. Workplace also supports extended FileNet P8 capabilities such as forms
management, records management, and portals.
Workplace is built using the Web Application Toolkit and runs within a web container on a Java™ Platform, Enterprise Edition (Java EE) application server. Workplace uses the latest JSF, Web 2.0, and Ajax technology for rendering many of its user interface elements, such as query results and folder contents. Most of the features provided in Workplace are zero-download HTML that run under many browsers on any platform. Advanced capabilities that are graphic-intensive are provided as Java applets, including Process Designer, Process Configuration Console, Process Administrator, Scenario Designer, Scenario Console, Search Designer, and Publish Designer.
- Integration for Office
- Enables users to easily manage Office documents and Outlook email messages within a FileNet P8 object store. Users can store, search, and retrieve documents, email, and attachments directly from Office menus. In addition to securing and versioning Office documents, users can browse object stores and insert properties into Word and Excel documents. Users can also use entry templates to add documents to an object store and launch approval workflows. For more information, see Microsoft Office integration.
- WebDAV Servlet
- Allows users to create and edit documents and manage files from WebDAV-compliant applications such as Word or Dreamweaver.
- Component Integrator
- Important: This Component Integrator information applies only if you created components using legacy Component Manager, and have not migrated the components.
Component Integrator makes it possible to interact with an external entity—a component, such as a Java object or (Workplace only) JMS messaging system—from a workflow step. Component Integrator handles the import of Java classes and manages the communication between the workflow system and the interfaces. Component Integrator provides the Web Services invocation framework for Process Orchestration, which uses SOAP/HTTP as its transport protocol.
Component Integrator includes adapters, which are interfaces that communicate events from the workflow system to external entities such as Java objects. Adapters interact with different types of components from a workflow step. FileNet P8 provides Java adapters and Java Message Service (JMS) adapters for calling Java components and posting messages to message queues. The adapters are deprecated in this release.
As shown in the following figure, the first step in the flow of control is the configuration and deployment of components. An administrator registers the component using Process Configuration Console, which in turn creates a component queue. Next, the administrator deploys the necessary JAR files for the component on the Application Engine server and registers the component in Process Task Manager. Process Designer retrieves configuration information from Content Platform Engine and now a user can create workflow definitions. The user creates a step and selects the registered component and method to invoke, specifying the workflow fields that are passed as parameters to the method at run time. The workflow definitions (requests for work) are then transferred to workflow queues.
The following figure depicts the runtime interaction of the Component Integrator with Application Engine services (such as Component Manager), workflow queues, and a custom entity. When the workflow process is executed, the Component Manager retrieves the request from the component queues and invokes the components through the adapters. For each step in the workflow, the following general sequence of events takes place:- Information is sent to the component (through the adapter).
- The component performs its work and interacts with the custom entity.
- The result of the work is saved in the step.
- The step is completed.
- Content and Process Java-based APIs
- An extensive set of Java classes
for programming custom applications and for extending the applications.
These classes provide programmatic interfaces for interaction with
the Content Platform Engine software. Developers
can use these APIs to build various applications, including those
that rely on a Java EE web container
(JavaServer Pages and Java Servlets),
Enterprise JavaBeans (EJB)
container, or Java 2 Platform
Standard Edition (J2SE) stand-alone applications, as shown in the
following diagram.
- Content Engine .NET API
- An extensive set of C# classes for programming custom applications and for extending the applications. These classes provide programmatic interfaces for interaction with the Content Platform Engine software. Developers can use these APIs to build .NET framework-based applications.
- Web Application Toolkit
- Provides an extensible framework and reusable modules for building
web applications. The Toolkit provides application developers with
access to Content Platform Engine and
third-party back-end servers. It supplies the behaviors and data structures
for authentication, event routing, state information, preferences,
globalization, and other features of robust and scalable applications. In
addition, the Toolkit's reusable user interface component model
facilitates the development of a robust HTML-based application user
interface with little or no DHTML or JavaScript required. IBM® has developed a number of web applications
from the toolkit, including Workplace and IBM Enterprise
Records.
As shown in the following diagram, additional functionality provided by Workplace includes user interface components—including JavaServer Pages that specify the page layout, Enterprise JavaBeans that render user interfaces, XSL documents that are used to control how XML returned from the Java API is rendered in the user interface, and Cascading Style Sheets (CSS) that define fonts, colors, and other formatting options.
- Application Integration Toolkit
- A full-featured API that enables third parties to integrate their Windows-based
client applications with Workplace. FileNet P8 uses this toolkit to provide
integration with Excel, PowerPoint, Word, and Outlook. In addition, FileNet eForms
Designer uses this toolkit.
Customers and partners can use the toolkit, including the reusable
user interface, to integrate with other applications with little coding.
The toolkit contains a set of COM servers that are installed on the Windows-based client and Java servlets that run on the Java EE application server. The Application Engine UI Service, which supports calls from both thick client applications and web-based thin clients, provides the toolkit's reusable Workplace JSP pages and wizards. Together, these components provide developers with a complete set of content management functionality, including the interactive user interface.
- Application Integration ExpressAddIn
- A developer tool contained in the Application Integration Toolkit
that enables rapid integration of the IBM FileNet Application Integration
infrastructure into vendor applications such as Office.
The tool is a COM server that defines incoming and outgoing interfaces that enable two-way communication between client applications and the Application Integration framework. While similar to the IBM FileNet Application Integration Toolkit in some respects, the ExpressAddIn uses more infrastructure code and greatly reduces the burden on integration developers. The ExpressAddIn is delivered with the Add-in sample application, which demonstrates how to use the ExpressAddIn to integrate a vendor application with the Application Integration infrastructure. Developers can customize the sample code to rapidly integrate their application into the framework and easily customize an integration to meet specific needs.
- Application Engine UI Service
- An Application Engine service used
by applications to access eForms,
to capture content through Entry Templates, to check in content, to
gain access to work tasks and step processors, and to select objects
through browsing or searching. Application Engine UI
Service supports calls from both thick-client applications and web-based
thin clients. A web-based application must be built from the Web Application
Toolkit. A thick client must be built from the Application Integration
Toolkit.
The following diagram illustrates how an external thick-client or web-based application interacts with the Application Engine UI Service. In this example, an external application uses the Application Engine UI Service to call Workplace JSP pages (using Workplace user interface components).
- The external application sends a command to Application Engine UI Service. Thick clients use an XML-based protocol to communicate with Application Engine UI Service, whereas thin clients use request-based command response URLs.
- Application Engine UI Service handles authentication, maps the command to a JSP request, and forwards the request to Workplace.
- Workplace responds with the requested JSP page.
- The user submits the page to Workplace.
- Workplace returns a response to the external application.
The following diagram illustrates how an external web application interacts with the Application Engine UI Service. The web application must be built from the Web Application Toolkit. The initial page launched from the browser-based client shown in the diagram would be from the external web application.
- A browser-based client sends a request URL to the Application Engine UI Service. The request URL is an ID-based command, and includes a response URL parameter that specifies a page in the toolkit-based web application that handles the response information returned by Workplace.
- Application Engine UI Service handles authentication, maps the ID-based command to a JSP request, and forwards the request to Workplace.
- Workplace responds with the requested JSP page.
- The user submits the page to Workplace.
- Workplace redirects response parameters to the toolkit-based web application specified in the request URL.
- The response is processed and passed to the client.