EngageOne Server
Editor Integration Guide - Interactive
Application/ActiveX
Version 4.4 Service Pack 11 R2
1 - Overview
EngageOne Compose editor types.......................4
2 - Workflow integration
Integration with workflow.......................................6
3 - Editor integration
EngageOne Compose Interactive Editor.............15
EngageOne Compose ActiveX Editor.................24
Integrating the Interactive or ActiveX editor in a
custom application.........................................25
Integrating the ActiveX editor in a custom application
(URL method).................................................38
Document delivery...............................................40
Table of Contents
1 - Overview
This document provides detailed information on integrating the EngageOne
Compose Interactive and ActiveX editors into your core business systems
and provides in-depth information for developers and other technical staff.
In this section
EngageOne Compose editor types............................................................4
EngageOne Compose editor types
In previous versions of EngageOne Compose (prior to 4.4.8) Cross-browser and ActiveX editing was
only available to edit communications. The ActiveX editor was available for use with Windows Internet
Explorer only.
From EngageOne Compose 4.4.8 the following editing options are available:
• EngageOne Compose Interactive Editor — a WYSIWYG editor available in Windows in each of
the supported browsers
• EngageOne Compose ActiveX Editor – a WYSIWYG editor available only in Windows using only
Internet Explorer
• Cross-browser editor — a non-WYSIWYG editor available for every operating system and for every
web browser
Note that the EngageOne Compose Interactive Editor can be used with the following web browsers:
• Microsoft Internet Explorer
• Microsoft Edge
• Mozilla Firefox
• Google Chrome
EngageOne Interactive Editor - desktop application and ActiveX
The EngageOne Interactive Editor is supported on the following 64 Bit operating systems only:
• Windows 8.1 - With current Windows updates
• Windows 10 - With current Windows updates
Note: The Interactive Editor will not install on the out of support Windows 7 operating system.
4EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Overview
Integration with workflow
The diagram below identifies the steps you need to follow for successful integration.
User Authentication
All web services accept an authentication context that is used by the service to authenticate the user.
The authentication context takes either a user name token or a session token for authentication. For
the initial invocation of any of the web services, the user name token should be passed in the user-id,
password, and domain of the user requiring authentication. This service response provides a session
token in the authentication for the user; use the session token in any subsequent service invocations.
Retrieving available domains
EngageOne organizes system data access by a community. The EngageOne Administration
application allows you to set up Communities. All valid system users are assigned to a community
for authentication purposes.
You can retrieve all communities names available to the server via the DomainService ,
searchDomains method. Note that the DomainService is the only service that does not require
authentication.
First, you must create an instance of the client stub for the DomainService. All Web Service
invocations require instantiation of the client stub, this code structure also applies to subsequent
code samples shown in this section.
6EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Workflow integration
To create an instance of the stub, you need to know the Web Service endpoint. Typically, an
EngageOne Web Service endpoint is in the following format:
http://<engageone-server-host>:<server-port>/EngageOneWS/<web-service-name>
where
• <engageone-server-host> is the host name where EngageOne server is deployed
• <server-port> is the port where the EngageOne Server Web Services is accessible
• <web-service-name> is the EngageOne Web Service you need to invoke.
Java sample
Once the stub object is instantiated you can call searchDomains to obtain a list of available domains.
The service returns a list of Domain objects, which hold community name values. You may use these
values for invoking the subsequent services. Note that the domain is a required field for user
authentication.
DomainServiceStub domainService = new DomainServiceStub(URL_BASE +
"DomainService");
SearchDomains request = new SearchDomains();
SearchDomainsResponse response = domainService.searchDomains(request);
List<Domain> domains = response.getDomains().getDomain();
7EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Workflow integration
Invalidating a Session
It is important to disconnect your user session to the EngageOne Server using the token you received
from an earlier authentication. Otherwise, your session will be continually active (unless timed-out)
and you unnecessarily use a session seat from your product license user count.
Java sample
To invalidate your session in the server use the SecurityService. To do this, create an instance
of the client stub for the SecurityService, then invoke the invalidateSession method and
pass the token you wish to invalidate.
SecurityServiceStub secService = new SecurityServiceStub(URL_BASE +
"SecurityService");
InvalidateSession request = new InvalidateSession();
AuthContext authContext = new AuthContext(); SessionToken sessionToken
= new SessionToken(); sessionToken.setToken(token);
authContext.setSessionToken(sessionToken);
request.setAuthContext(authContext);
secService.invalidateSession(request);
8EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Workflow integration
Session timeout
The session timeout value determines how long an unused session can stay valid in the server and
is implemented in all EngageOne Server services. For details on how to set a timeout value, refer
to the EngageOne Administration Guide. You must be able to detect session timeout on the server
and handle this exception appropriately.
Java sample
Session timeout cases can be detected as a fault with error code -6. In the example below the
retrieveTemplateList service is used, it shows how to handle the fault and signifying that the
token used to invoke the service has already had its session timed out.
try {
TemplateServiceStub templateService = new TemplateServiceStub(URL_BASE
+ "TemplateService");
SearchTemplates request = new SearchTemplates();
request.setFilter(SearchFilter.LIST);
SearchTemplatesResponse response =
templateService.searchTemplates(request);
List<Template> templates = response.getTemplates().getTemplate();
} catch (TemplateFault fault) {
if (fault.getFaultMessage().getCode() == -6) {
// Handle session timeout here
}
9EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Workflow integration
Retrieving templates
To retrieve the templates in the document repository via EngageOne Web Services you use the
TemplateService.
Java sample
First, you need to create an instance of the client stub for TemplateService and then invoke the
searchTemplates method:
TemplateServiceStub templateService = new TemplateServiceStub(URL_BASE
+ "TemplateService");
SearchTemplates request = new SearchTemplates();
request.setFilter(SearchFilter.LIST);
SearchTemplatesResponse response =
templateService.searchTemplates(request);
List<Template> templates = response.getTemplates().getTemplate();
10EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Workflow integration
Creating a document
When a template has been selected you must retrieve the individual template files from EngageOne
Server.
Retrieving template files
To retrieve the files associated with a template, use the TemplateService searchTemplates
method again, passing the template identifier as input to the service. The template can be identified
either by name or by a unique integer identifier which is returned from the search for the template
listing, refer to Java sample on page 10. Keep in mind that template name is not unique, searching
by name could potentially return multiple templates at different levels of the folder hierarchy. In any
event, in the second invocation of searchTemplates, set the search filter to DETAIL and the files
associated with the template will be returned.
Each template file returned has a type associated with it, along with other information that indicating
the type of file, for eaxmple, HIP, Publication, XForm.
Editing a document
To retrieve/edit your document:
1. Load the document in one of the following:
• EngageOne Compose Interactive Editor
• EngageOne Compose ActiveX Editor
2. Embed the control.
3. Pass the parameters required to load the document, refer to the list below for files and other
parameters required to load a document into the Interactive Editor:
• Properties XML file – the manifest describing a document instance. This file contains a list of
further file dependencies of the document. (.XML)
Note: This file should not be confused with the template master file.
• Publication file – the binary rules file for editing this document. (.PUBX).
• Hip file – the compiled binary rules file for composing this document (.HIP) file.
• Instance XML file – data file for this document instance (.XML).
• Instance schema file – the schema for the Instance xml file. (.XSD).
11EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Workflow integration
• XForm file – this file is used by the editor to describe the interactive prompts to the user.
(.XFORM).
• Server URL string – this string describes the server location and file retrieval method to use
when downloading additional dependent files from the server, for example,
http://www.ocmserver_xyz/EngageOneWS/openfile_by_token?token=f00e8a2fa227a03585c70
aac1b0c5084&".
• Speller ID – this is the file ID used for editor downloads to obtain the list of available speller
dictionaries.
Retrieving editor dependencies
To retrieve editor dependencies you must access the EngageOne Server via EngageOne Web
Services. Each resource stored on EngageOne Server has its own unique resource ID.
Files
At this stage you have streams for all the files required by the Interactive Editor. Place your file
retrieval code in a HTTP request handler and pass the path to the request handler through to the
Interactive Editor. The editor makes a series of HTTP GET requests to your handler, you can then
pass the file stream through the output response stream.
Server URL string
The Server URL is the server location and file retrieval method use to download additional files. This
allows the Interactive Editor to combine the resource ID of any file it requires with the Server URL
to request the physical file.
This is constructed using the server location, file retrieval method and Web Service token, as follows:
http://<SERVER>:<PORT>/EngageOneWS/openfile_by_token?token=#{token}&
The openfile_by_token is the file retrieval method presented by the EngageOne Server.
It takes one parameter - token, this is your Web Service token, which is passed in as a parameter.
It would have been collected when connecting to the DomainService.
Speller Manifest
The Interactive Editor requires access to a speller manifest containing a list of the different languages
installed in the EngageOne system. The DictionaryService is used to retrieve the speller manifest
which includes both the identifier of the manifest in the system and the manifest file contents.
12EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Workflow integration
Java sample
The following example illustrates a request to the DictionaryService to retrieve the speller
manifest:
SecurityServiceStub secService = new SecurityServiceStub(URL_BASE +
"SecurityService");
InvalidateSession request = new InvalidateSession();
AuthContext authContext = new AuthContext(); SessionToken sessionToken
= new SessionToken(); sessionToken.setToken(token);
authContext.setSessionToken(sessionToken);
request.setAuthContext(authContext);
secService.invalidateSession(request);
13EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Workflow integration
3 - Editor integration
This chapter runs through the process of completing key server integration
tasks and contains sample code for implementation in Java, under the Axis2
framework realized via EngageOne Web Services.
In this section
EngageOne Compose Interactive Editor..................................................15
EngageOne Compose ActiveX Editor......................................................24
Integrating the Interactive or ActiveX editor in a custom application........25
Integrating the ActiveX editor in a custom application (URL method)......38
Document delivery....................................................................................40
EngageOne Compose Interactive Editor
Architecture
The components that make up the architecture are as follows:
• Interactive Editor Application - this is a WYSIWYG editor implemented as a standalone Windows
application. It must be installed on the end-user's machine. The Interactive Editor Application allows
you to fill in all available template fields. This editor option provides the same editing features as
the EngageOne Compose ActiveX Editor.
• Template data source - this REST service provides template files and other necessary resources.
Note that the Interactive Editor Application and its ActiveX counterpart use the same API to obtain
data from this data source.
• Integrated Application - your browser based business application which integrates with the
Interactive Editor Application.
• Relay-Service - the server-side service used to provide an encrypted communication between the
EngageOne Compose Interactive Editor and any system integrated with it. It is built into the
EngageOne Compose Core bundle to simplify deployment.
15EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
The pbiea protocol
Your business application must generate and pass a unique communication identifier to the Interactive
Editor Application. To achieve this, the Custom Protocol Handler mechanism, a built in Windows
framework, is used. This protocol allows a stand-alone Windows application, in this case, the
Interactive Editor Application, to be run on all modern web browsers. The "pbiea" protocol is
automatically registered to the end-user's computer when installing Interactive Editor Application.
Whenever a web browser is redirected to an URL starting with "pbiea://...", it starts the Interactive
Editor Application and passes all necessary parameters, including the communication identifier.
The Relay service
Both the editor and your business application must connect to the Relay Service using the WebSocket
protocol. The Service determines that these two specific instances must communicate with each
other by the value of the communication identifier.
The Relay Service:
• mediates communication between the website and the editor, avoiding possible SSL restrictions.
• informs each application that a given template must be opened, has been completed, or that the
editor must be closed.
• relies on stateful communication, this means that messages must be sent to the same relay service
server instance. This is particularly important if EngageOne Compose Server uses load balancing
mechanisms.
The WebSocket protocol
The WebSocket protocol was chosen over HTTP, because it provides information on the status of
the connection, if it is alive, or has been broken. This information allows for processing to react to
the connection status; for example, where the web browser has aborted, the relay service can detect
this and inform the editing application that it should be closed.
16EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
Prerequisites
Interactive Editor application
The editor is a standalone Windows application that must be installed on the end-user's computer.
The installation file is located in the distribution file:
EngageOne_Server_v4.4.x.zip/utilities/InteractiveEditor/
setup-engageone-interactive-editor-app.exe
Relay Service
The Relay Service is built into the EngageOne server. If you already have the server installed and
configured, you do not need to take any additional actions to start using Relay Service.
Client library
The Interactive Editor application and your system communicates via a Relay service using a
WebSocket. For this purpose, a communication protocol has been provided together with a
TypeScript/JavaScript Client Library that can be used for communication.
You can use a RequireJs compatible version from the sample application, or you can compile the
source code located in:
EngageOne_Server_v4.4.x.zip/utilities/IeaClientSourceCode
To compile the source code, you must:
• Install NodeJs on your machine
• Install the grunt library globally by executing the following commands:
npm install -g grunt-cli
npm install -g grunt
• Download all the required libraries by executing the following commands:
cd <PATH to the unpacked Client Library source code location>
npm install
• Modify the tsconfig.json and gruntfile.js files to the compiler "module" flag to one of the values:
• AMD: to make the output compatible with the RequireJs library
• System: to make the output compatible with the SystemJs library
• Compile the source code using the following command:
17EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
grunt build
Loading the editor
The steps you must perform are as follows:
• Load the JavaScript Client Library at an appropriate location on your website. The method used
to perform the load depends on the library you have chosen (RequireJs vs SystemJs).
• Create an instance, and configure the Client Library. The following is a RequireJs library example:
requirejs(['iea/iea-service', 'iea/utils/iea-cookies'],
function (ieaLib, ieaCookiesUtil) {
var cookieUtil = new ieaCookiesUtil.IeaCookies()
iea = new ieaLib.IeaService({
webSocketAddress: 'wss://yourdomain.com:8080/relay-service/iea',
sessionId: generateUniqueSessionId(),
cookies: cookieUtil.getEOAuthCookies
(['securityCookieName', 'loadBalanceCookie']),
keepAlive: 15,
minIeaVersion: '4.4.10',
windowTitle: 'IEA sample demo',
template: 'Some outstanding template',
community: 'Sample',
user: 'admin',
enable: 'save', //optional
pulse: 180 //optional
},
'en'); // the language of the IEA interface
...
});
18EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
Parameters
webSocketAddress (mandatory parameter)
This parameter defines the Relay Service address. For example, If your EngageOne Compose Server
is available at a URL:
https://yourdomain.com:8080
the relay service address would be:
wss://yourdomain.com:8080/relay-service/iea
Note that the WebSocket address prefix used depends on your SSL server protection, for https://
use wss://, for http:// use ws:// in the relay service address.
sessionId (mandatory parameter)
A string of characters used to identify individual instances of the Interactive Editor Application and
the Client Library during communication via the Relay service; this ensures consistent messaging
between different Client Library and Interactive Editor instances.
19EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
cookies (optional parameter)
This parameter contains all the cookies required by the Interactive Editor Application to connect to
the Data Sources Service and download the required resources.
In contrast with the ActiveX editor implementation, where certain cookies were passed automatically
to the editor, the Interactive Editor is a standalone application and has no access to website resources.
You must, therefore, provide all the information required to authenticate to the Data Source Service
or to maintain communication with the same Relay Service instance when using the load balancing
mechanism on the EngageOne Compose Server.
An additional library called "iea-cookies" is included in the distribution, which can be used as a guide
to construct a properly formatted string for the specified cookie names.
keepAlive (optional parameter)
When using a regular website and sending an HTTP request, the server is aware of the end user's
activity, so that it can maintain the current session. However, in an Interactive Editor setting, the
website is unaware of any editor activity, and as a result, the session may end. To avoid this scenario,
20EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
the Interactive Editor Application sends a message to the website to indicate that the editor is in use
so that the session is kept active. The keepAlive parameter is the time interval in minutes for which
a keep-alive message is to be sent.
minIeaVersion (optional parameter)
To prevent the use of an outdated version of the Interactive Editor application, you can set a minimum
supported version using this parameter. When the Interactive Editor is launched, it sends a handshake
message to the website, containing its version. If the Integration Library detects an outdated version
level, it closes the Interactive Editor application and reports an appropriate error.
connectionOpenTimeout (optional parameter)
This parameter indicates the time-out period, in seconds after which the Client Library issues a
notification that the connection with the Relay Service was unsuccessful. Note that the Client Library
continues to retry connection, if successful, the connection error is revoked.
ieaResponseTimeout (optional parameter)
This parameter indicates the non-reply timeout period, in seconds, from sending a message to the
Relay Service by the Client Library. The error message issued on the initial time-out is revoked if a
response is received after this time.
windowTitle (optional parameter)
The window title to be displayed in the Editor window header
template (optional parameter)
The template name to be displayed in the Editor window header
community (optional parameter)
The community name to be displayed in the Editor window header
username (optional parameter)
The user name to be displayed in the Editor window header
21EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
enable (optional parameter)
This parameter enables optional features in the Editor. Currently, only the save option is supported,
which enables a Save button in the Editor window header. Pressing the Save button will send a
message back to the web page. The web page must respond to this message as if a Save button
were pressed on the web page. Refer to Event handling when integrating with the Interactive
Editor on page 33
pulse (optional parameter)
This parameter sets the interval (in seconds) after which a connection sustain signal is sent to the
Relay-Service by the Interactive Editor Application. Use this parameter when the connection between
the Interactive Editor Application and Relay-Service is broken; the loss of connection can happen
after an extended period of inactivity in the Editor application. This scenario is observed where
communication is managed by load balancers.
Recommendation: set this parameter to half the interval of inactivity which triggered the break in
connection.
In the diagram above, during a period of inactivity, a 15 second sustain signal is sent to the Relay
-Service to ensure that the connection is not stopped.
22EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
Language definition
You can determine the browser language currently being used from the navigator.language value
and set the language used by the editor accordingly via a parameter in the function which initializes
the JavaScript/TypeScript component that is being used as a communication layer between the web
browser and the Interactive editor.
In the Loading the editor on page 18 editor example, the language is set to English as in the code:
'en'); // the language of the IEA interface
Valid languages settings are as follows:
Possible LCID Language values
Language
1033en_USen-USenEnglish
1036fr_FRfr-FRfrFrench-France
3084fr_CAfr-CAFrench-Canada
1031de_DEde-DEdeGerman
1034es_ESes-ESesSpanish
23EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
EngageOne Compose ActiveX Editor
The EngageOne Compose ActiveX Editor takes the form of an ActiveX COM control, which is
packaged in a CAB file.
Loading the editor
To initialize the ActiveX Editor on a custom web page you must:
• ensure that the eoeditor.cab file is accessible from the website.
• add the following HTML tag in the source of the website:
<object id="eoEditor"
classid="clsid:E62608CD-5C5E-4088-BFAE-B9D6D1D84CB3"
codebase="<PATH>/eoeditor.cab" height="250px" width="100%"></object>
24EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
Integrating the Interactive or ActiveX editor in
a custom application
Both Interactive and ActiveX editor are embedded in EngageOne Compose and are available on the
installation media to be hosted by a custom application. The web application that will host your
chosen editor is responsible for handling certain items that would normally be managed by the
EngageOne Interactive web application.
The ActiveX Editor provides two entry point methods to the editor for making resource requests to
your custom application:
• XML message
• URL
The XML message method should be used as the primary method due to performance advantages.
When upgrading from EngageOne 3.x, or earlier, the URL method is still supported, however the
URL method does not provide the performance advantages of the XML method. Refer to Integrating
the ActiveX editor in a custom application (URL method) on page 38 for further details on this
method.
The Interactive Editor provides entry points based on XML messages only.
Providing an XML message for the editor to request resources
Both the Interactive and ActiveX editors expose entry point functions that are an interfaces between
the editor and your custom application. An XML string is passed to that functions as a parameter,
providing data such as the message name (Load or Save), the URL to your custom application, and
various parameters that define the SRIDs of the files that the editor requires. Based on the parameters
in the XML, the editor determines which files need to be downloaded from your custom application.
Load and Save parameters are details in the tables that follow the examples. The following sections
provide examples of the XML structure and the schema.
25EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
XML structure (Load)
<?xml version="1.0" encoding="utf-8" ?>
<MessageInfo version = "1" name = "Load">
<LCID Language="en-US" />
<ParameterGroup>
<Parameter name="BaseURL" value="http://servername:8080/
EngageOneCorrespondent/EditorDownloadServlet;
jsessionid=A2305388D2EEAA177?" />
<Parameter name="PropertiesID" value ="101" />
<Parameter name="AnswerID" value ="102" />
<Parameter name="SchemaID" value ="103" />
<Parameter name="XFormID" value ="104" />
<Parameter name="PubxID" value ="105" />
<Parameter name="ReviewMode" value ="1" />
<Parameter name="SpellMode" value ="0" />
<Parameter name="SpellerID" value ="107" />
<Parameter name="SpellDisableClose" value ="0" />
<Parameter name ="Compress" value ="1" />
<Parameter name="ServerUrl" value = "http://servername:8080/
EngageOneCorrespondent/EditorDownloadServlet;
jsessionid=A2305388D2EEAA177?" />
</ParameterGroup>
</MessageInfo>
26EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
Load Parameters
Supported ValuesDescriptionParameters
StringURL from which base template files
(properties, answer etc.) will be
retrieved.
BaseURL
StringURL from which additional template files
(images, keymaps etc.) will be retrieved.
If omitted BaseURL is used.
ServerURL
IntegerResource ID for properties XML filePropertiesID
IntegerResource ID for Answer fileAnswerID
IntegerResource ID for data Schema fileSchemaID
IntegerResource ID for XForm fileXFormID
IntegerResource ID for pubx filePubxID
0, 1
1 – Review mode (only preview) the
editor doesn’t show any prompts
0 – Normal mode (for editing)
ReviewMode
0, 1
1 – Automatically spell check on save
0 – Allow save without spell check
SpellMode
IntegerSpeller resource IDSpellerID
0, 11 – prevents closing until all spelling
errors are corrected
SpellDisableCheck
1Must be set for 1 for ActiveX control
version earlier than 6.6.8, from 6.6.8
can be omitted.
Compress
Language definition
27EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
You can determine the browser language currently being used from the navigator.language value
and set the language used by the editor accordingly via the LCID Language setting in the function,
which initializes the JavaScript/TypeScript component being used as a communication layer between
the web browser and the ActiveX editor.
In the XML structure (Load) on page 26 editor example, the language is set to English as in the
code:
<LCID Language="en-US" />
Valid languages settings are as follows:
Possible LCID Language values
Language
1033en_USen-USenEnglish
1036fr_FRfr-FRfrFrench-France
3084fr_CAfr-CAFrench-Canada
1031de_DEde-DEdeGerman
1034es_ESes-ESesSpanish
28EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
XML structure (Save)
<?xml version="1.0" encoding="utf-8" ?>
<MessageInfo version="1" name="Save">
<ParameterGroup>
<Parameter name="BaseURL"
value="http://servername:8080/EngageOneCorrespondent/
EditorDownloadServlet;jsessionid=A2305388D2EEAA177?" />
<Parameter name="HipID" value="106" />
<Parameter name="AnswerID" value="102" />
<Parameter name="PubxID" value="105" />
<Parameter name="Compress" value="1" />
</ParameterGroup>
</MessageInfo>
29EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
Save Parameters
Supported ValuesDescriptionParameters
StringURL on which PUT command will be
invoked to put edited template files.
BaseURL
StringURL from which additional template files
(images, keymaps etc.) will be retrieved.
If omitted BaseURL is used.
ServerURL
IntegerResource ID for HIP fileHipID
IntegerResource ID for Answer fileAnswerID
IntegerResource ID for pubx filePubxID
1Must be set for 1 for ActiveX control
version earlier than 6.6.8, from 6.6.8
can be omitted. Server should be able
to handle compressed files.
Compress
30EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
XML Schema Definition - load and save
<?xml version=”1.0” encoding=”utf-8”?>
<xs:schema attributeFormDefault=”unqualified”
elementFormDefault=”qualified”
xmlns:xs=”http://www.w3.org/2001/XMLSchema”>
<xs:element name=”MessageInfo”>
<xs:complexType>
<xs:sequence>
<xs:element name=”ParameterGroup”>
<xs:complexType>
<xs:sequence>
<xs:element maxOccurs=”unbounded” name=”Parameter”>
<xs:complexType>
<xs:attribute name=”name” type=”xs:string” use=”required” />
<xs:attribute name=”value” type=”xs:string” use=”required” />
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
<xs:attribute name=”version” type=”xs:unsignedByte” use=”required” />
<xs:attribute name=”name” type=”xs:string” use=”required” />
</xs:complexType>
</xs:element>
</xs:schema>
Sending and receiving template resources
Depending on your chosen editor, you must use one of the following scripts to load the document:
• Interactive Editor
requirejs(["iea/iea-service", "iea/utils/iea-cookies"], function (ieaLib,
ieaCookiesUtil) {
var iea = new ieaLib.IeaService({ ... }, 'en');
var loadXmlData='...'; // described in the section:
// “Providing an XML message for the editor to
request resources”
iea.sendExecuteLoadTemplateMessage(loadXmlData)
.subscribe(function (subscription, ieaLibInstance, status) {
…
});
};
31EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
• ActiveX Editor
var loadXmlData='...'; // described in the section:
// “Providing an XML message for the editor to
request resources”
var nResult = eoEditor.ExecuteMessage(loadXmlData);
When sendExecuteLoadTemplateMessage or ExecuteMessage with load XML is invoked, the
editor send GET request to endpoint provided in the base URL with resource IDd as parameters e.g.:
http://myapp.domain.com/editor?
/pubx=2386&properties=2391&answer=2388&schema=2389&xform=2387&compressed=true
The result expects a zip file response, this file should be a flat zip file containing all requested template
resources and name of each is its ID. In the case of the example above, the zip file should contain
5 files with names: 2386 for PubX file, 2391 for Properties file, 2388 for the Answer file, 2389 for
Schema file and 2387 for XForm file.
Depending on the editor used, you need to run the script to save the document, as follows:
• Interactive Editor
requirejs(["iea/iea-service", "iea/utils/iea-cookies"], function (ieaLib,
ieaCookiesUtil) {
var iea = new ieaLib.IeaService({ ... }, 'en');
//Parameters above described on page 18 in
section “Loading Editor”
var saveXmlData = '...'; // described in section named:
// “Providing an XML message for the editor
to request resources”
iea.sendExecuteSaveTemplateMessage(saveXmlData)
.subscribe(function (subscription, ieaLibInstance, status) { … });
};
• ActiveX Editor
var saveXmlData ='...'; // described in the section:
// “Providing an XML message for the editor to
request resources”
var nResult = eoEditor.ExecuteMessage(saveXmlData);
When sendExecuteSaveTemplateMessage or ExecuteMessage with save XML is invoked, the
editor sends a PUT request with ZIP file to endpoint provided in base URL with resource ID's as
parameters e.g.:
http://myapp.domain.com/editor?hip=2406&pubx=2386&answer=2388&compressed=true
32EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
If the template does not contain any editable text then the URL and Zip file only contains the answer
file, e.g.:
http://myapp.domain.com/editor? answer=2388&compressed=true
The Zip file format is the same as that used for load command, a flat file with resource ID as filename.
Event handling when integrating with the Interactive Editor
The JavaScript/TypeScript client library shipped for the Interactive Editor integration can broadcast
several types of events. A stream of events are used, these can be subscribed or unsubscribed
multiple times, instead of a singular Event Handler.
You can subscribe to event streams related to a specific action, such as loading a template into the
Interactive Editor Application, or general event streams available at the Client Library level, such as
the currently edited template status change.
• On document loaded sample
requirejs(["iea/iea-service", "iea/utils/iea-cookies"], function (ieaLib,
ieaCookiesUtil) {
var iea = new ieaLib.IeaService({ ... }, 'en');
var loadXmlData='...'; // described in the section:
// “Providing an XML message for the editor to
request resources”
var subscription = iea
.sendExecuteLoadTemplateMessage(loadXmlData)
.subscribe(function (subscription, ieaLibInstance,
status) {
if (status.isSuccessful) {
logMessage("The template has been loaded by the Editor
application");
} else {
logError("The template has not been loaded");
}
});
...
//if for any reason you would like to stop waiting till the template
is being loaded
subscription.unsubscribe()
};
• On document saved
requirejs(["iea/iea-service", "iea/utils/iea-cookies"], function (ieaLib,
ieaCookiesUtil) {
var iea = new ieaLib.IeaService({ ... }, 'en');
...
33EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
var saveXmlData = '...'; // described in section named:
// “Providing an XML message for the editor
to request resources”
var subscription = iea
.sendExecuteSaveTemplateMessage(saveXmlData)
.subscribe(function (subscription, ieaLibInstance,
status) {
if (status.isSuccessful) {
logMessage("The template has been loaded by the Editor
application");
} else {
logError("The template has not been loaded");
}
});
...
//if for any reason you would like to stop waiting till the template
is being saved
subscription.unsubscribe()
};
• On document status changed
requirejs(["iea/iea-service", "iea/utils/iea-cookies"], function (ieaLib,
ieaCookiesUtil) {
var iea = new ieaLib.IeaService({ ... }, 'en');
...
var subscription = iea.onStatusChanged.subscribe(function
(subscription, iea, isComplete, isModified) {
logMessage("Status changed: isComplete == " + isComplete + ",
isModified == " + isModified);
var composeButton =
document.getElementById("composeDocmentButton");
if(isComplete) {
… /eg. Enable the “Document Compose” button
} else {
… /eg. Disable the “Document Compose” button }
}.bind(this));
...
//if for any reason you would like to stop this subscription
subscription.unsubscribe()
});
• On exception
requirejs(["iea/iea-service", "iea/utils/iea-cookies"], function (ieaLib,
ieaCookiesUtil) {
var iea = new ieaLib.IeaService({ ... }, 'en');
...
var subscription = iea.onError.subscribe(function(subscription, iea,
error) {
if(error.isRevokable) {
34EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
logError("Revokable error. Error code = " + error.code + ", message
= '" + error.message + "'");
} else if(error.revoke) {
logError("The revokable error has been revoked. Revoked error code
= " + error.code);
} else {
logError("Regular error. Error code = " + error.code + ", message
= '" + error.message + "'");
}
}.bind(this));
...
//if for any reason you would like to stop this subscription
subscription.unsubscribe()
});
• On clicking the Editor Save button
requirejs(["iea/iea-service", "iea/utils/iea-cookies"], function (ieaLib,
ieaCookiesUtil)
{ var iea = new ieaLib.IeaService(\{ ... }
, 'en');
...
var subscription = iea.onClickSaveButton.subscribe(function
(subscription, iea, status)
{ ... iea.sendExecuteSaveTemplateMessage(saveXmlData) }
.bind(this));
...
//if for any reason you would like to stop this subscription
subscription.unsubscribe()
});
There are two types of errors that can occur:
• Errors that can be reported, but after a few seconds they can be revoked and should no longer
be displayed. For example, where the Client Library has issues establishing a connection to the
relay service, it will report this as a revokable error. If the connection is established after some
time, it cancels the previous error as this error.
• Unhanded/unpredicted exceptions that can potentially originate from errors in the Client Library
itself and are classed as an irrevocable error.
35EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
Providing a URL for the editor to request resources
The editor needs to request additional resources to load a document such as images, active content,
and keyed images. One of the input parameters when loading the editor is a server URL, the editor
invokes this when it requires a resource located on the server. The URL should be provided by the
hosting web application. For example, a Java servlet can be used. When the editor requires a
resource, it invokes the URL using HTTP GET passing together with the request a number of
parameters. Assume the URL provided by the hosting application is http://myapp.domain.com/editor.
The parameters used by the editor will be of one of the following two forms:
http://myapp.domain.com/editor?srid=1234
http://myapp.domain.com/editor?keymap=Keymap1&key=23
The servlet is responsible for retrieving either an editor resource, or a key map depending on which
form of the URL is invoked. In the first example, the sevlet should invoke the
EditorService.retrieveResources() Web Service operation to retrieve the resource specified
by the srid parameter.
In the second example, the KeymapService.searchKeymaps() Web Service operation should
be invoked to retrieve the keyed image contained in the key map named Keymap1 with a key of 23.
In either case, additional parameters can be provided as part of the server URL. For example, the
server URL passed to load XML could be:
http://myapp.domain.com/editor?session_id=45378292&srid=>
In this way, the editor can pass session information or any other data required by the custom
application when requesting resources.
Saving document instances
Finally, the third function required by a hosting application is to respond to HTTP PUT requests on
the provided server URL once the save method on the editor is invoked. This allows the hosting
application to save the updated document instance files, this includes the publication HIP, the editor
PUBX, and the answer XML. These three files will be modified by the editor and need to be saved
as a document instance.
The WorkItemService.createWorkItem() Web Service operation can be used to create a new
work item for the document with the three files attached to the work item. Alternatively, the document
may be delivered to a delivery option immediately without having to first create a work item. The
DeliveryService.deliverDocument() Web Service operation can be used to accomplish
this.
36EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
It is recommended that after the save contents method is invoked, you check for the existence of
the HIP, PUBX, and XML files the ActiveX Editor produces before calling any custom application. If
these files do not exist, return an applicable error.
Retrieving delivery options
The DeliveryManagementService is used to retrieve all the delivery options that are assigned
to a template. This tool presents the logged-in user with a list of valid delivery options that are available
for document delivery.
JAVA SAMPLE
DeliveryManagementServiceStub dmService = new
DeliveryManagementServiceStub
(URL_BASE + "DeliveryManagementService");
SearchDeliveryOptions request = new SearchDeliveryOptions();
SearchDeliveryOptions.Templates templates = new
SearchDeliveryOptions.Templates();
SearchDeliveryOptions.Templates.Template template = new
SearchDeliveryOptions.Templates.Template();
IntegerIdOrName id = new
IntegerIdOrName(); id.setId(templateId);
template.setIdent(id);
templates.setTemplate(template);
request.setTemplates(templates);
SearchDeliveryOptionsResponse response =
dmService.searchDeliveryOptions(request);
List<DeliveryOption> options =
response.getDeliveryOptions().getDeliveryOption();
An array of DeliveryOption objects is returned that contain information about the retrieved delivery
options of the specified template.
To deliver the document you require the ID of the selected Delivery Option. For example:
int selectedDeliveryOptionID = options.get(0).getId()
37EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
Integrating the ActiveX editor in a custom
application (URL method)
This section describes the depreciated API and should not be used in new implementations. Refer
to Integrating the Interactive or ActiveX editor in a custom application on page 25 for details
on the recommended integration method.
Loading the document
A JavaScript function executes the loading, which is called on page load. This invokes the
LoadContents method in the EngageOne Interactive Editor, passing the paths to the required files.
Some of the paths are URLs, which the editor uses to load the document, these files are not saved.
Other files passed as local file paths and are used for PUBX, HIP and Answer files. The editor saves
to these files, which are then stored with your document.
You can pass in the location of request handlers (for instance, using JSP), which would handle the
HTTP GET and PUT request sent by the editor, allowing you to handle the file streams according to
your requirements.
To load the document
Specify the following script in the HEAD of your HTML page.
<script>
// invokes the ActiveX LoadContents() method function
editorLoadContent(){
ipe.LoadContents('http://<server>:
<port>/EngageOneAdmin/openfile_by_token?token=<token>&srid=123',
'file:///C:/Documents%20and%20Settings/user/Local%20Settings/Temp/tmp15F.tmp',
'file:///C:/Documents%20and%20Settings/user/Local%20Settings/Temp/tmp160.tmp',
'file:///C:/Documents%20and%20Settings/user/Local%20Settings/Temp/tmp161.tmp',
'http://<server>:<port>/EngageOneAdmin/openfile_by_token?token=<token>&srid=120',
'http://<server>:<port>/EngageOneAdmin/openfile_by_token?token=<token>&srid=118',
'0',
'0',
'http://<server>:<port>/EngageOneAdmin/openfile_by_token?token=<token>&', '');
}
// attach the js function to load the document content upon page load
window.attachEvent("onload", editorLoadContent); </script>
38EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
Be aware that your HTML/JavaScript will need to be dynamically generated to integrate the resource
IDs for the template files. This is because you will not know until run-time which resource IDs will
need to be passed into the Editor's LoadContents method. There are several server-side scripting
languages you can use to achieve this.
Note that the URLs passed into the LoadContents interface must be an absolute path regardless
of the protocol used to access the resource. When the Interactive Editor is deployed in a clustered
environment, the absolute path must always point to the load-balancer address.
To save the document
Once the document has been edited by the user it must be saved. From your application page,
invoke the SaveContents() method of the ActiveX object via JavaScript. Typically, you will set
this JavaScript function as an event handler of your UI component (e.g. HTML input button).
<script>
function editorSaveContent() { ipe.SaveContents();
}
</script>
When the Interactive Editor's SaveContents method is called it will make a series of HTTP
PUT requests to the URLs specified when calling LoadContents. The updated Instance file,
Publication file and Production HIP file can then be written back to their original location, so ensure
that there is write access to these locations.
Depending on how you loaded the Interactive Editor you will have either passed in the paths to HTTP
request handlers, or the physical UNC file paths.
Request Handlers – create a PUT request handler that will handle the HTTP PUT requests sent by
the editor. The request includes the file stream from the editor, which must be streamed to disk for
delivering the document later.
UNC file paths – the editor writes back the saved files to the location it received them from, replacing
the original files.
Once templates have been edited and the versions of the document file are saved you must select
a delivery option before you can send your document to the EngageOne server for delivery.
39EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
Document delivery
After you have completed your document and selected the delivery option, the document can be
delivered.
Delivering the document using resource files
The DeliveryService delivers documents using its resource files. First you must create the
DeliveryService stub instance and then invoke the deliverDocument method.
The DeliverDocument class requires several key pieces of information in order to successfully
deliver a document:
• Template ID — of the document's original template
• Delivery Option ID — of the delivery option you want to deliver to
• Property file — the Property file loaded into memory
• Answer File — the document's Answer file loaded into memory
• HIP file — the document's HIP file loaded into memory
In the sample below, it is assumed that you have your completed document resource files stored to
the local disk, so you can stream them into memory and pass through to delivery.
In the sample below, it is assumed that the completed document resource files are stored to the local
disk, in order to stream them into the memory and pass through to delivery.
// JAVA SAMPLE
DeliveryServiceStub deliveryService = new DeliveryServiceStub(URL_BASE
+ "DeliveryService");
DeliverDocument request = new DeliverDocument();
DeliverDocument.Template template = new DeliverDocument.Template();
DeliverDocument.DeliveryOption option = new
DeliverDocument.DeliveryOption();
// Set template ID and delivery option ID
IntegerIdOrName tid = new IntegerIdOrName();
tid.setId(templateId);
template.setIdent(tid);
IntegerIdOrName oid = new IntegerIdOrName();
oid.setId(optionId);
option.setIdent(oid);
// Add the files
template.setFiles(new DeliverDocument.Template.Files());
DeliverDocument.Template.Files.File answer = new
DeliverDocument.Template.Files.File();
40EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
answer.setType(TemplateFileType.ANSWER);
answer.setData(new DataHandler(new FileDataSource(LOCAL_ANSFILE_PATH)));
template.getFiles().getFile().add(answer);
DeliverDocument.Template.Files.File prop = new
DeliverDocument.Template.Files.File();
prop.setType(TemplateFileType.PROPERTY);
prop.setData(new DataHandler(new FileDataSource(LOCAL_PROPFILE_PATH)));
template.getFiles().getFile().add(prop);
DeliverDocument.Template.Files.File hip = new
DeliverDocument.Template.Files.File();
hip.setType(TemplateFileType.HIP);
hip.setData(new DataHandler(new FileDataSource(LOCAL_HIPFILE_PATH)));
template.getFiles().getFile().add(hip);
request.setTemplate(template);
request.setDeliveryOption(option);
DeliverDocumentResponse response =
deliveryService.deliverDocument(request);
DeliveryRequest deliveryRequest = response.getDeliveryRequest();
Retrieving local print documents
The DeliveryService retrieves the resulting document file when a delivery item has been
successfully composed. This service can only be applied in cases where the selected delivery option
comprises one or more delivery channels that have channel types set to Print and have channel
modes set to Immediate. Additionally, the device of the delivery channel must have the necessary
resources to compose the document.
After successfully invoking the deliverDocument method, you extract the local print document on
the response object. A successfully invoked service method does not throw an exception and returns
a non-null response object.
The code fragment below shows how to retrieve the composed document files from the response
object. This leaves you with the delivered document in memory, which can be streamed to disk and
viewed in the appropriate reader.
// JAVA SAMPLE
DeliverDocumentResponse response =
delivery.deliverDocument(deliverDocument);
// Output the composed file
List<DeliveryItem> deliveryItem =
response.getDeliveryRequest().getDeliveryItems().getDeliveryItem();
for (DeliveryItem item : deliveryItem) {
com.pb.engageone.ws.model.ComposedDocument document =
item.getDocument();
saveFile(TEMP_DIR + "localprint.pdf", item.getDocument().getData());
}
41EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Editor integration
Notices
Copyright
©
2008, 2021 Precisely. All rights reserved.
This publication and the software described in it is supplied under license and may only be used or
copied in accordance with the terms of such license. The information in this publication is provided
for information only, is subject to change without notice, and should not be construed as a commitment
by Precisely. To the fullest extent permitted by applicable laws Precisely excludes all warranties,
representations and undertakings (express or implied) in relation to this publication and assumes
no liability or responsibility for any errors or inaccuracies that may appear in this publication and shall
not be liable for loss or damage of any kind arising from its use.
Except as permitted by such license, reproduction of any part of this publication by mechanical,
electronic, recording means or otherwise, including fax transmission, without the express permission
of Precisely is prohibited to the fullest extent permitted by applicable laws.
Nothing in this notice shall limit or exclude Precisely liability in respect of fraud or for death or personal
injury arising from its negligence. Statutory rights of the user, if any, are unaffected.
*TALO Hyphenators and Spellers are used. Developed by TALO B.V., Bussum, Netherlands Copyright
©
1998 *TALO B.V., Bussum, NL *TALO is a registered trademark
®
Encryption algorithms licensed from Unisys Corp. under U.S. Patent No. 4,558,302 and foreign
counterparts.
Security algorithms Copyright
©
1991-1992 RSA Data Security Inc
Copyright
©
DL Technology Ltd 1992-2010
Barcode fonts Copyright
©
1997 Terrapin Solutions Ltd. with NRB Systems Ltd.
This product includes software developed by the Apache Software Foundation
(http://www.apache.org/).
Artifex and the Ghostscript logo are registered trademarks and the Artifex logo and Ghostscript are
trademarks of Artifex Software, Inc.
This product contains the Regex++ library Copyright
©
1998-2000 Dr. John Maddock
PostScript is a trademark of Adobe Systems Incorporated.
PCL is a trademark of Hewlett Packard Company.
Copyright (c) 2000 - 2015 The Legion of the Bouncy Castle Inc. (http://www.bouncycastle.org)
ICU License - ICU 1.8.1 and later Copyright (c) 1995-2006 International Business Machines
Corporation and others All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
associated documentation files (the "Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish, distribute, and/or sell copies of the
Software, and to permit persons to whom the Software is furnished to do so, provided that the above
copyright notice(s) and this permission notice appear in all copies of the Software and that both the
above copyright notice(s) and this permission notice appear in supporting documentation.
43EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Copyright
Matra 0.8.2b (http://matra.sourceforge.net/) The contents of this documentation are subject to the
Mozilla Public License Version 1.1 (the "License"); you may not use this documentation except in
compliance with the License. You may obtain a copy of the License at http://www.mozilla.org/MPL/.
Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY
OF ANY KIND, either express or implied. See the License for the specific language governing rights
and limitations under the License. Otherwise all product names are trademarks or registered
trademarks of their respective holders.
This product contains Sycamore, version number 0.5.0, which is licensed under the MIT license.
The license can be downloaded from
https://github.com/ryexley/sycamore/blob/master/dist/requester.js. The source code for this
software is available from https://github.com/ryexley/sycamore.
This product contains Underscore, version number 1.13.1, which is licensed under the MIT license.
The license can be downloaded from
https://github.com/jashkenas/underscore/blob/master/LICENSE. The source code for this software
is available from http://underscorejs.org/.
This product contains Flowable, version number 6.4.2, which is licensed under the Apache license.
The license can be downloaded from
https://github.com/flowable/flowable-engine/blob/master/LICENSE. The source code for this
software is available from https://github.com/flowable/flowable-engine.
This product contains Bootstrap, version number 3.4.1, which is licensed under the MIT license. The
license can be downloaded from http://getbootstrap.com/getting-started/#license-faqs. The
source code for this software is available from http://getbootstrap.com/getting-started/#download..
This product contains Commons-Configuration, version number 1.10, which is licensed under the
Apache license. The license can be downloaded from http://www.apache.org/licenses/. The source
code for this software is available from
http://commons.apache.org/proper/commons-configuration/.
This product contains jQuery, version number 3.5.1, which is licensed under the MIT license. The
license can be downloaded from https://jquery.org/license/. The source code for this software is
available from http://jquery.com/download/.
This product contains Knockout-AMD-Helpers, version number 0.7.4, which is licensed under the
MIT license. The license can be downloaded from
https://github.com/rniemeyer/knockout-amd-helpers/blob/master/LICENSE. The source code
for this software is available from https://github.com/rniemeyer/knockout-amd-helpers.
This product contains Knockout, version number 3.5.1, which is licensed under the MIT license. The
license can be downloaded from https://github.com/knockout/knockout/blob/master/LICENSE.
The source code for this software is available from http://knockoutjs.com/downloads/.
This product contains bootstrap-datetimepicker, version number 4.17.49, which is licensed under
the MIT license. The license can be downloaded from
https://github.com/myactionreplay/bootstrap-datetimepicker/blob/master/LICENSE. The source
code for this software is available from
https://github.com/myactionreplay/bootstrap-datetimepicker.
44EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Copyright
This product contains Knockout-DelegatedEvents, version number 0.6.1, which is licensed under
the MIT license. The license can be downloaded from
https://github.com/rniemeyer/knockout-delegatedEvents#license. The source code for this
software is available from https://github.com/rniemeyer/knockout-delegatedEvents.
This product contains Moment.js, version 2.29.1, which is licensed under the MIT license. The license
can be downloaded from https://github.com/moment/moment/blob/develop/LICENSE. The source
code for this software is available from http://momentjs.com/.
This product contains Quartz-Scheduler, version number 2.3.2, which is licensed under the Apache
license. The license can be downloaded from http://quartz-scheduler.org/. The source code for
this software is available from http://quartz-scheduler.org.
This product contains RequireJS Text, version number 2.0.15, which is licensed under the BSD and
MIT licenses. The license can be downloaded from
https://github.com/requirejs/text/blob/master/LICENSE. The source code for this software is
available from https://github.com/requirejs/text.
This product contains RequireJS, version number 2.3.6, which is licensed under the BSD and MIT
licenses. The license can be downloaded from
https://github.com/jrburke/requirejs/blob/master/LICENSE. The source code for this software is
available from http://requirejs.org/docs/download.html.
This product contains Apache ActiveMQ, version number 5.15.9 , which is licensed under the Apache
license, version number 2.0. The license can be downloaded from
http://www.apache.org/licenses/.The source code for this software is available from
http://activemq.apache.org
This product contains Apache NMS version 1.7.2, which is licensed under the Apache license, version
number 2.0. The license can be downloaded from http://www.apache.org/licenses/.The source
code for this software is available from: http://activemq.apache.org/nms
This product contains Apache Commons DBCP2, version number 2.6.0, which is licensed under the
Apache license, version number 2.0. The license can be downloaded from
http://www.apache.org/licenses/.The source code for this software is available from
https://commons.apache.org/proper/commons-dbcp/.
This product contains OWASP Encoder, version number 1.2.2, which is licensed under the BSD
license. The license can be downloaded from https://opensource.org/licenses/BSD-3-Clause.
The source code for this software is available from
https://www.owasp.org/index.php/OWASP_Java_Encoder_Project.
This product contains Narayan, version number 5.2.13.Final, which is licensed under the LGPL
license, version number 2.1. The license can be downloaded from
http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt. The source code for this software is available
from http://narayana.io/.
This product contains Logback, version number 1.2.3, which is licensed under the EPL and LGPL
licenses, version numbers 1.0 and 2.1. The license can be downloaded from
http://logback.qos.ch/license.html. The source code for this software is available from
http://logback.qos.ch/.
45EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Copyright
This product contains JBoss Weld, version number 3.1.0.Final, which is licensed under the Apache
license, version number 2.0. The license can be downloaded from
http://www.apache.org/licenses/LICENSE-2.0.The source code for this software is available from
http://weld.cdi-spec.org.
This product contains Hibernate, version number 5.4.25.Final, which is licensed under the Apache
and LGPL license, version numbers 2.0 and 2.1. The license can be downloaded from
http://hibernate.org/community/license/. The source code for this software is available from
http://hibernate.org/orm/.
This product contains Apache Tomcat, version number 9.0.43, which is licensed under the Apache
license, version number 2.0. The license can be downloaded from
http://www.apache.org/licenses/LICENSE-2.0. The source code for this software is available from
http://tomcat.apache.org/.
This product contains Apache Procrun, version number 1.1.0, which is licensed under the Apache
license, version number 2.0. The license can be downloaded from
http://www.apache.org/licenses/.The source code for this software is available from
http://commons.apache.org/proper/commons-daemon/procrun.html.
This product contains FasterXML Jackson, version number 2.9.8, which is licensed under the Apache
license, version number 2.0. The license can be downloaded from http://www.apache.org/licenses/.
The source code for this software is available from https://github.com/FasterXML/jackson.
This product contains Log4net. The license for log4net can be downloaded from
https://www.apache.org/licenses/LICENSE-2.0. The source code for this software is available
from https://logging.apache.org/log4net/download_log4net.cgi.
Support
Click here for full EngageOne Compose documentation and access to your peers and subject matter
experts on the Knowledge community.
46EngageOne Server 4.4 Service Pack 11 R2 Editor Integration Guide - Interactive Application/ActiveX
Copyright
1700 District Ave Ste 300
Burlington MA 01803-5231
USA
www.precisely.com
© 2008, 2021 Precisely. All rights reserved.
Documentation Feedback
You can help us to improve our product documentation
by sharing your comments and feedback with us.
Please use the Adobe Acrobat Comments functionality
to highlight any issues or to comment on a specific part
of this document. Note that you will need to download
this document to use the feedback option when viewed
in a web browser.
If you are reading this document in hard copy and want
to send us feedback, you may email us at
with the subject line “Documentation Feedback” and
including the document information below
Document Title:
Software Version:
Last updated date:
Additional comments
EngageOne Server Editor Integration Guide
4.4.11 R2
23rd November 2021
Submit Feedback
