Application Engine is
a previous-generation 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.
The following services and applications are included in
Application Engine:
- 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 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.