|
Building blocks are the core parts of a solution. They
are fully customizable, re-usable, and extensible modules that define
capabilities of a solution. Building blocks allow you to leverage
services hosted by CRX. They also expose reusable APIs and Flex
based UX components that developers can leverage to customize the
solution.
The Correspondence Management Solution contains three building
blocks:
Asset Composer building block
Data Dictionary building block
Expression Manager building block
Building blocks are solution-specific product capabilities with
technical documentation, specific to each building block, that explains
how they can be used for production applications.
Building Block structureThe Correspondence Management building blocks are delivered
as a CRX package which you can unzip to any installation directory.
All of CRX packages fit into one one the following categories:
Platform packages: Packages that contribute
to the complete Adobe LiveCycle Platform.
Building Block packages: Packages that contribute
to the full range of Building Blocks that Partners use to help build
custom solutions.
Solution Template packages: Packages for demonstration
components of a target solution. This package relies on building
blocks already deployed on the LiveCycle server
Solution Single Install packages: Includes a Solution
Template and a set of building blocks all merged into one CRX package.
Asset Composer building blockThe Asset Composer building block is part of the Correspondence
Management Solution, available with Adobe LiveCycle Enterprise Suite
4 (ES4). The Asset Composer building block provides core capabilities
to create and manage assets like text, images, list modules, and
conditional modules. It also supports defining and rendering a correspondence.
Asset Composer building block componentsThe Asset Composer building block is deployed as a LiveCycle
package with OSGI bundles. The building block’s services are registered
as OSGI services.
Persistence servicesThe Persistence Services component provides the Object
Model and APIs for the individual assets (Category, Data Module,
Layout, Fragment Layout, Letter, Document, and Portfolio) that interact
with the LiveCycle Content server-side APIs. The services facilitate
CRUD-like operations and other utility APIs, such as publish, to
retrieve the list of dependencies on an asset, and download the content
for an asset.
Render ServiceThe Render Service is a server-side component that renders
a Letter or Portfolio/Package, based on a given letter/portfolio
template and instance data. It also provides post processing capabilities
on these templates, through integration with external web services.
Web ModulesThis component consists of web layer-related artifacts
such as servlets and other related services.
This component includes the following services:
Submit: This servlet submits XML data and the
rendered PDF to the selected post-process service for a Letter or
Portfolio template. Before submitting, it calls the LetterRenderService
to render the letter with the given XML data submitted by the Create
Correspondence application. The servlet then calls the ServiceInvoker
APIs to finally submit the PDF and XML data to the post-process.
FlexConfigurationService: This utility service permits
client applications to access the properties configured specific
to the host web application such as web context and servlet mappings.
ExternalDataUtil: This service permits connection
to various data sources, by registering the appropriate URL handlers.
There is support for standard Java protocols and the crx:// protocol
for accessing content from the CRX repository.
Create CorrespondenceThe Create Correspondence application is made up of several
Flex components within the Asset Composer building block. This application
is componentized into Presentation Model, Domain Model, Resource
bundles, and Style SWCs, so you can extend them to create a customized
experience.
Asset Composer ScenariosYou can implement the following scenarios using the Asset
Composer building block:
For more information, see the Asset
Composer scenarios.
Data Dictionary building blockThe Data Dictionary building block is based on the Adobe
application modeling technology, which allows for an independent
representation of metadata and back-end integration. Metadata, in
the solution context, represents descriptions of the data structures
and their associated attributes. Therefore, a data dictionary is
a catalog of domain-specific objects and their associated definitions.
The Data Dictionary building block allows business users to use
models at a solution level. They can also create a domain-specific
data dictionaries or enhance the artifacts without requiring back-end
data integration. For example, an insurance domain data dictionary
can contain data dictionary elements (DDEs) such as person, age, eligibility,
loan amount, and so on. Data dictionary models can be developed
and seamlessly exported into an extended application model, for
import into production systems.
Data Dictionary building block componentsThe Data Dictionary building block consists of clients
and services that connect to the back-end system.
Data Dictionary building block clientsThe Data Dictionary clients include:
Data Dictionary Java clients (adobe-dct-client.jar).
The Java clients include server-side value objects, service APIs,
and exception classes required for any custom code for the building
block.
Data Dictionary Flex client (adobe-dct-flex-services.swc):
The Flex client includes various ActionScript Value Objects, Data
Dictionary service Flex APIs, events, and fault handling.
Data Dictionary building block user interface components.
The Data Dictionary building block user interface components (Data
Dictionary Editor, Data Elements Panel) use the Data Dictionary
Services for interacting with the back-end repository.
Data Dictionary Editor: The Administrator user interface
for creating and modifying a data dictionary, its properties, and
elements. In the Definition view and Properties view, you can associate
the value of various properties with the data dictionary elements.
You can associate metadata with a data dictionary and each of its
elements by adding extended properties.
Data Elements Panel. The user interface for creating DDE
and place holder variables which are displayed in table and tree
formats. You also perform live searches on the Display Name for
a DDE.
Data Dictionary building block servicesThe Data Dictionary building block services are exposed
as spring beans. Following is the list of beans that are provided
in Data Dictionary building block:
DataDictionaryRegistryService: This service provides
Create, Update, and Delete operations for the Data Dictionary building
block.
DataDictionaryUtilService: This service provides data dictionary
utility functions.
Expression Evaluation Service: This service is as a reusable
component that uses standard EL syntax and libraries for expression
evaluation. The component has server-side APIs for expression evaluation
on the server and a client-side counterpart for evaluation of expressions
on the client.
Back-end integration layerThe server-side component of the Platform Content exposes
operations/APIs to interact with the underlying repository that
stores the assets. The services component for the Asset Composer
building block encapsulates APIs for the individual assets that
interact with the Platform Content server-side APIs. The server-side
component of the Platform Content facilitates operations and other utility
APIs, such as list of dependencies on an asset and downloading the content
bytes for an asset.
Developing with the Data Dictionary building blockDeveloping a solution that uses a data dictionary typically
involves the use of the following tools:
Data Dictionary Editor. The user interface that allows
creation and maintenance of the data dictionary that is shipped
with this building block.
Java Development Tools:
LiveCycle Tools:
Expression Manager building blockThe Expression Manager building block provides the ability
to evaluate expressions on the server side and the client side.
Client-side expression evaluation is achieved using the Expression
Manager client library that interprets the expression at runtime
without a server roundtrip.
By default, Expression Manager uses standard Expression Language
(EL) syntax and libraries, but it also provides the ability to connect
to any other rule base.
Expression Manager building block componentsAn expression evaluation service requires an instance of
Variable Resolver to retrieve values of variables. Typically an
expression requires a Function Mapper to retrieve function definitions
from the library. When connecting to a Data Dictionary the DDE Variable
resolver is required.
Variable Resolver: used to retrieve the value
of variables used in expressions by expression evaluation library.
Function Mapper: used to provide definitions of custom
functions used in expressions.
DDE Variable Resolver: used to resolve Data Dictionary
Element values.
The Expression Manager building block can be divided into two
modules: server-side expression evaluation and client-side expression
evaluation.
Server-side expression evaluationThe server-side expression evaluation module provides the
capability to evaluate expressions on the server side. The Expression
Evaluator service is the core of the server-side expression evaluation
module. It provides APIs for expression evaluation and validation.
Expressions can be evaluated in single or batch mode. This component
acts as a wrapper to the expression evaluation library (JSP EL).
The actual expression evaluation task is delegated to the expression
library.
Client-side expression evaluation in using FlexThe client-side expression evaluation module provides the
capability to evaluate expressions in a Flex client application,
without a server roundtrip. The Flex Expression Manager can interpret
and evaluate JSP-EL compliant-expressions. The IExpressionManager
interface is the entry point into client-side expression evaluation.
Consuming applications are expected to pass a JSP-EL compliant expression.
The client-side expression manager requires a variable resolver
and a function mapper to resolve variable references and function
calls inside expressions.
Expression Manager Scenarios
|
|
|
