WebPublisherTM
Version 4.4
March, 2002
Copyright 1999-2002 by Documentum, Inc. 6801 Koll Center Parkway Pleasanton, CA 94566
Documentum® Documentum RightSite®, Documentum Server®, Docbasic®, Documentum DocPage Server®, Now You Know®, Documentum WorkSpace®,
Documentum SmartSpace®, Documentum ViewSpace®, AutoRender Pro™, Docbase™, DocInput™, Docobject™, DocPage Builder™, Documentum 4i™,
Documentum Administrator™, Documentum CADLink™, Documentum Commerce Server Integrators™, Documentum Application Server Integrators™,
Documentum Content Authentication Services™, Documentum Content Personalization Services™, Documentum ContentCaster™, Documentum Corrective
Action Manager™, Documentum Desktop Client™, Documentum Developer Studio™, Documentum DocControl Manager™, Documentum DocLoader™,
Documentum DocViewer™, Documentum Dynamic Content Assembler™, Documentum eConnector for CAD™, Documentum eConnector™ for IBM
WebSphere® (IBM and WebSphere are trademarks of IBM) Documentum eConnector for SAP™ (SAP is a trademark of SAP AG), Documentum eConnector™,
Documentum eConnector™ for BEA Weblogic® (BEA is a registered trademark of BEA Systems Inc) Documentum eConnector™ for JDBC, Documentum
eConnector™ for ATG Dynamo® (ATG and Dynamo are registered trademarks of Art Technology Group), Documentum eConnector™ for Lotus Notes® (Lotus
Notes is a registered trademark of Lotus Development Corporation) Documentum eContent Server™, Documentum Engagement Services™, Document
Engagement Server™, Documentum ftpIntegrator™, Documentum Intranet Client™, Documentum iTeam™, Documentum Reporting Gateway™, Documentum
Site Delivery Services™, Documentum Web Development Kit™, Documentum Web Gear™, Documentum WebCache™, Documentum WebPublisher™,
GMPharma™, GXPharma™, GDPharma™, GSPharma™, Momentum™, Virtual Document Manager™ (VDM), and Documentum Selfrepair™ are trademarks
or registered trademarks of Documentum, Inc. in the United States and throughout the world. All other company and product names are used for identification
purposes only and may be trademarks of their respective owners.
Contents
Preface .............................................................................................................................. ix
Purpose of the Manual .......................................................................................................... ix
Intended Audience ............................................................................................................... ix
Organization ........................................................................................................................ x
Conventions ....................................................................................................................... xi
Related Documentation ......................................................................................................... xi
HTML and JavaScript References ............................................................................................. xii
TM
Customizing Documentum WebPublisher i
Contents
TM
ii Customizing Documentum WebPublisher
Contents
TM
Customizing Documentum WebPublisher iii
Contents
TM
iv Customizing Documentum WebPublisher
List of Figures
TM
Customizing Documentum WebPublisher v
Contents
TM
vi Customizing Documentum WebPublisher
List of Tables
TM
Customizing Documentum WebPublisher vii
Contents
TM
viii Customizing Documentum WebPublisher
Preface
Intended Audience
This manual is primarily intended for system integrators who customize and deploy
WebPublisher. This manual assumes you are familiar with JavaScript and HTML and
that you have experience working with the following Documentum systems:
• Documentum WebPublisher
• Documentum Developer Studio
• Documentum Administrator
• DocApp Installer
• Documentum WebCache
To help you gain the knowledge you need to effectively customize WebPublisher,
Documentum recommends that you take the following training courses through
Documentum’s Education Services.
• Technical Fundamentals for Documentum 4i Admin/Developer Version
Designed for Web developers, system administrators, and project managers who
want to become familiar with the various Documentum 4i products and their
capabilities.
• Developing Web Applications Using RightSite
Designed for application developers who are creating Web applications using
Documentum 4i technology.
TM
Customizing Documentum WebPublisher ix
Preface
• WebPublisher
Designed for WebPublisher administrators and Web developers who need to install
and configure the WebPublisher application.
• System Administration for Documentum 4i
Designed for the Documentum system administrator and project architect.
• Managing Site Delivery Services — WebCache
Designed for deployment managers, Web site administrators and system
administrators who need to deploy content and or applications from Documentum
eContent servers to multiple Web sites using Documentum.
For more information and Documentum’s suggested curriculum path for WebPublisher
refer to Documentum’s Web site and search for Web Content Management (WCM)
Edition classes.
Organization
This manual contains six chapters and one appendix. The table below lists the
information that you can expect to find in each.
Chapter Contents
Chapter 4, Customizing the Properties Page Discusses creating new attributes and
modifying existing attributes.
Chapter 5, Modifying a List Item Discusses creating new list items and
actions.
Chapter 7, Customizing Content Pages Discusses creating a new import page, and
add new content page.
TM
x Customizing Documentum WebPublisher
Preface
Chapter Contents
Chapter 9, Creating Process Workflows and Lifecycles Provides step-by-step instructions to create
WebPublisher specific workflows and
lifecycles.
Chapter 10, Creating a Web Site Provides in depth analysis of a sample Web
site creation using a custom DocApp, the
Rules Editor and WebPublisher Editor.
Conventions
This manual uses the following conventions:
Convention Description
<>angle brackets Represents a variable name for which you must provide a value,
or a defined term.
Note: Attributes and Properties are used interchangeably throughout this guide.
Attributes when discussing the attributes.xml file, and Properties when referring to the
Web page. Both terms represent the same elements.
Related Documentation
The following lists other Documentum documentation you should be familiar with
before attempting to customize WebPublisher.
• Using WebPublisher Pro explains how to configure WebPublisher and to design and
administer Web sites.
• Using WebPublisher explains how to use and manage the WebPublisher
content-authoring interface, used for creating and publishing Web pages.
• Docbasic Reference Manual helps application developers create Docbasic procedures.
TM
Customizing Documentum WebPublisher xi
Preface
TM
xii Customizing Documentum WebPublisher
Chapter 1
Functional Overview and Architecture
This section contains an overview of WebPublisher, lists the pre-requisite knowledge of Documentum
products that all WebPublisher customizers should have, and describes how different software and
hardware components interact to support WebPublisher.
What is WebPublisher?
WebPublisher is a Web browser-based software application used to create, manage
and construct Web pages according to company-designed templates. WebPublisher
uses numerous Documentum software products to integrate with both the eContent
Server and the Web. Following is a description of how WebPublisher uses Documentum
products.
WebPublisher uses:
• eContent Server to provide content management services, content file stores,
database tables, indexes, and metadata in a secure repository called a Docbase.
In addition to its storage and retrieval services, eContent Server provides object
management services (including version control, rendition management, and
security and access control), workflow management services, lifecycle services, and
viewing and printing services.
• RightSite to provide the HTTP server integration between WebPublisher and the
eContent Server.
• WebCache to export Web pages and associated metadata from a Docbase to a
WebCache repository. The WebCache repository can contain a staging Web site or a
production Web site and can be integrated with your production Web (HTTP) server.
• AutoRender Pro to generate HTML renditions of content files for display in a Web
browser.
• Content Personalization Services (CPS) to automatically provide suggested property
data for WebPublisher-created content objects.
• Media Services to enable processing and management of rich media content.
TM
Customizing Documentum WebPublisher 1–1
Functional Overview and Architecture
Customizing WebPublisher is a complex task that should only be attempted if you have
the knowledge of Documentum products as recommended below.
To customize files in your WebPublisher Docbase, you use Documentum Developer
Studio to create a custom DocApp (Docbase Application). You can copy objects from
TM
1–2 Customizing Documentum WebPublisher
Functional Overview and Architecture
your WebPublisher Docbase into your custom DocApp and modify the object in your
custom DocApp or create new custom objects in your custom DocApp. Details for
customizing WebPublisher files as well as sample customizations for files on your Web
server and WebPublisher Docbase are provided in subsequent chapters. Following is a
list of topics that will be explored.
• XML files
WebPublisher consists of XML files stored on your Web (HTTP) server and in your
WebPublisher Docbase. You customize WebPublisher by customizing the files
in these two areas.
To customize files on your Web server, you copy the file (to be customized) to a
custom folder in the WebPublisher hierarchy on your Web server and modify the
copied file so that it contains your desired customization.
• workflows and lifecycles
Process workflows and how they can be customized for your business processes.
Document lifecycles and how they affect the state of documents as they move
through a process workflow
• templates and files
WebPublisher Editor templates and files can be customized to create a layout and
other non-content related elements used in your company’s Web page.
• existing Web site
WebPublisher enables you to bring your existing Web sites into WebPublisher and
manage them in a central location. The guidelines discussed in this document
should be followed for best results.
You should be familiar with the concepts of a Docbase, DQL (Document Query
Language), Docbasic, JavaScript, RightSite, DFC (Documentum Foundation Classes),
APIs, and the WebQL language, as well as HTML and XML. Many of these elements are
used to create needed customizations. All of them are used within WebPublisher itself.
WebPublisher Architecture
WebPublisher architecture is a structural arrangement of components installed on your
system. This section describes the installed components including Web (HTTP) server
components and Docbase components, and folders and delivery cabinets. You will
learn the importance of the directory structure and how to use this structure to affect
customizations.
TM
Customizing Documentum WebPublisher 1–3
Functional Overview and Architecture
Installed Components
WebPublisher consists of components installed on the Web server and components
installed in the WebPublisher Docbase. The Web components are created during
WebPublisher installation by a standard Windows (InstallShield) installer. The Docbase
components are created during WebPublisher installation by the Documentum DocApp
Installer. The DocApp installer installs the default WebPublisher DocApp. There is
an optional WebPublisher sample Web site DocApp (Accelera DocApp) that you are
encouraged to install if you want guidance on modifying an existing Web site. The
sample Web site is described in further detail in Chapter 10, Creating a Web Site. For more
information about installing WebPublisher, refer to Installing WebPublisher.
Folder Description
Online Help files for the administrator and Web developer user,
help
and for the content author and content manager users.
TM
1–4 Customizing Documentum WebPublisher
Functional Overview and Architecture
Folder Description
Docbase Components
WebPublisher contains two sets of Docbase components:
• Those created from installation of the WebPublisher default DocApp
• Those created from installation of the Accelera DocApp
Both of these DocApp installations create one or more sets of cabinets and folders in the
Docbase as well as creating a DocApp that can be viewed and edited in Documentum
Developer Studio. For more information about Documentum Developer Studio, please
refer to the Documentum Developer Studio Help.
The WebPublisher installation creates the following default cabinet and folders in the
WebPublisher Docbase.
Note: In the WebPublisher interface, the Favorites and User Preferences folders are not
displayed in the Docbase view.
WebPublisher-specific folders that can be accessed by an administrator or Web developer
are stored in the WebPublisher Configuration cabinet. The following table lists the folders
contained in WebPublisher Configuration and summarize the contents of each folder.
TM
Customizing Documentum WebPublisher 1–5
Functional Overview and Architecture
Folder Description
Editor Presentations Contains presentation files used for files created with
the WebPublisher Editor.
External Application Presentations Contains presentation files used for files created in an
authoring tool other than the WebPublisher Editor.
Object Model
In WebPublisher, all the items you manipulate are objects. Every document is an object,
as are the cabinets and folders in which you store the documents. Even users are objects.
TM
1–6 Customizing Documentum WebPublisher
Functional Overview and Architecture
All objects have associated characteristics, called properties and associated operations,
called methods. Properties are fields that are part of the object. The values in these
fields describe the object. Methods are operations that you can perform on an object.
Properties and methods are part of the object’s type description. All objects belong to a
type. Please refer to Documentum eContent Server Fundamentals for a full description of
objects and types.
This section contains a listing of all WebPublisher object types and properties and a
diagram showing the relationship between the object types. A short description is
provided for each object type followed by a tabular listing of the custom properties for
the designated type with a description of the property and the value of the property.
Following is a list of all WebPublisher dm_sysobject types.
• wcm_auto_naming
• wcm_channel
• wcm_channel_fld
• wcm_change_set
• wcm_config
• wcm_edition
• wcm_edition_fld
• wcm_favorites
• wcm_locale
• wcm_supporting_doc_folder
• wcm_user_pref
TM
Customizing Documentum WebPublisher 1–7
Functional Overview and Architecture
TM
1–8 Customizing Documentum WebPublisher
Functional Overview and Architecture
dm_sysobject
The dm_sysobject type is the parent type of all objects in the WebPublisher system. The
dm_sysobject type has three important properties, represented by properties, that it
passes on to all its subtypes. These properties are:
• A sysobject accepts security permissions. Attributes defined for the sysobject allow
you to set permissions on the object.
• A sysobject, unless it is a cabinet, can belong to a folder.
• A sysobject can own one or more content objects.
Please refer to Documentum eContent Server Object Reference Manual for more detailed
information on objects and object types.
TM
Customizing Documentum WebPublisher 1–9
Functional Overview and Architecture
wcm_auto_naming
wcm_channel
A channel is defined in WebPublisher as a delivery cabinet and the top level of a structure
that mirrors a web site. This object is a subtype of dm_cabinet.
TM
1–10 Customizing Documentum WebPublisher
Functional Overview and Architecture
wcm_channel_fld
The channel folder object is the folder created by default underneath a delivery cabinet.
This object is a subtype of dm_folder. It has no custom properties.
wcm_change_set
TM
Customizing Documentum WebPublisher 1–11
Functional Overview and Architecture
wcm_config
The wcm_config object tracks the configuration data that is applicable for the application
as a whole. This object is a subtype of dm_sysobject.
TM
1–12 Customizing Documentum WebPublisher
Functional Overview and Architecture
TM
Customizing Documentum WebPublisher 1–13
Functional Overview and Architecture
TM
1–14 Customizing Documentum WebPublisher
Functional Overview and Architecture
TM
Customizing Documentum WebPublisher 1–15
Functional Overview and Architecture
• 1, prompted
• 1, comments required
TM
1–16 Customizing Documentum WebPublisher
Functional Overview and Architecture
• 1, optional
• 2, required
wcm_edition
TM
Customizing Documentum WebPublisher 1–17
Functional Overview and Architecture
at a WebPublisher Docbase since there may be hundreds of edition cabinets created over
a period of time. wcm_edition is a subtype of dm_cabinet.
wcm_edition_fld
The wcm_edition_fld (edition folder) object represents a delivery folder object within
an edition. It contains links to specific versions of content objects. wcm_edition_fld is
a subtype of dm_folder.
wcm_favorites
Every WebPublisher user will be assigned a favorites folder. It will be the default location
of objects created by the user that are not assigned to a location within a delivery cabinet
through the folder map. Users will also be able to add a link to any document to their
favorites folder. When the user interface displays location information for objects, user’s
favorites folders should not show up.
TM
1–18 Customizing Documentum WebPublisher
Functional Overview and Architecture
wcm_locale
wcm_locale is a new object type for WebPublisher 4.3 and is used to define allowable
locales for the WebPublisher system. wcm_locale is a subtype of dm_sysobject.
wcm_supporting_doc_folder
This is the folder contains all supporting objects for a change set. Every change set folder
contains a wcm_supporting_doc_folder folder. Supporting objects (and these may be
new objects imported just for the change set or existing Docbase objects) are linked to
this folder. No properties are required for this object type.
wcm_user_pref
The user preference object stores information about the user that should be persistent
from session to session. This is used for user interface preferences such as layout and
colors and for system-required items like default checkout. This object is a subtype of
dm_sysobject.
TM
Customizing Documentum WebPublisher 1–19
Functional Overview and Architecture
TM
1–20 Customizing Documentum WebPublisher
Functional Overview and Architecture
Relations
Relations are dm_relation type objects. A relation type object describes a relationship that
can exist between two objects in the Docbase, and can act as an indicator. WebPublisher
uses relations to relate documents and for global content purposes like turning fallback
rules off, and using dynamic content. Please refer to Documentum eContent Server Object
Reference Manual for more information on dm_relation type objects.
WebPublisher creates several dm_relation_type objects. They are:
• DM_TRANSLATION_OF
• wcm_category
• wcm_default_workflow
• wcm_doc_template
• wcm_dynamic_content
• wcm_layout_template
• wcm_my_template
• wcm_process_workflow
• wcm_publishing_template
• wcm_rules_template
• wcm_template_thumbnail
TM
Customizing Documentum WebPublisher 1–21
Functional Overview and Architecture
DM_TRANSLATION_OF
wcm_category
wcm_default_workflow
This relation type tracks the relationship between a template and its default process
workflow.
When an object is created from the template and routed on a process workflow, the
system will check if the template has a wcm_default_workflow relation that points to a
valid process workflow. If so, it will use that process workflow and not prompt the user
for it. The type should be defined as follows:
TM
1–22 Customizing Documentum WebPublisher
Functional Overview and Architecture
• 1, restrict delete
• 2, cascade delete
• 2, bidirectional
wcm_doc_template
This relation keeps track of the template from which the document was created. This
relation is new to WebPublisher 4.3.
TM
Customizing Documentum WebPublisher 1–23
Functional Overview and Architecture
wcm_dynamic_content
This relation is used to indicate a file that has xDQL queries that need to be transformed.
Documentum marks the Child Label of this relation to CURRENT and uses chronicle
ID as its child ID.
wcm_layout_template
The wcm_layout_template relation type tracks the relationship between a data template
and a layout template.
TM
1–24 Customizing Documentum WebPublisher
Functional Overview and Architecture
wcm_my_template
The wcm_my_template relation type keeps track of a business user’s frequently used
templates and the category each of these templates belongs to. It will allow us to not
only know a favorite template, but also which category the template belonged to. This is
important because a template can be in multiple wcm_category folders.
wcm_process_workflow
TM
Customizing Documentum WebPublisher 1–25
Functional Overview and Architecture
wcm_publishing_template
wcm_rules_template
The wcm_rules_template relation type tracks the relationship between a data template
and an authoring rules template. It is used to indicate if the Editor rules file is checked
out by the Rules Editor.
TM
1–26 Customizing Documentum WebPublisher
Functional Overview and Architecture
wcm_template_thumbnail
TM
Customizing Documentum WebPublisher 1–27
Functional Overview and Architecture
TM
1–28 Customizing Documentum WebPublisher
Chapter 2
Customization Overview
Components to Customize
Components can be anything from DocApp attributes to WebPublisher templates and
files. Components are parts of the WebPublisher system that control WebPublisher
functionality and provide WebPublisher’s look and feel. You can modify the components
to reflect your company’s business processes and appearance.
DocApps
DocApp components include object types, attributes, alias sets, content templates,
lifecycles and workflows. The default WebPublisher DocApp should already be installed
to your Docbase before you begin your customizations.
A DocApp encapsulates Docbase-related objects and processes that are specific to a
business or department. You can build DocApps from scratch, or build DocApps from
WebPublisher’s default DocApp.
TM
Customizing Documentum WebPublisher 2–1
Customization Overview
To copy custom Docbase-related objects and processes easily from one Docbase to another
you must create a custom DocApp that encapsulates your customizations. Your custom
DocApp could include an object type, attributes, an alias set and permission set template,
a lifecycle, a workflow, and configuration templates all specific to your company’s needs.
You use Documentum Developer Studio (DDS) to create a custom DocApp, and you use
Documentum DocApp Installer to deploy the DocApp to various Docbases.
When you want to customize your WebPublisher installation, you should create a new
custom DocApp containing any customizations. Custom DocApps ensure that your
customizations will not be overwritten by future upgrades to the default WebPublisher
DocApp. You must install the WebPublisher default DocApp before you install your
custom DocApp for WebPublisher to work correctly.
Developing DocApps contains all the information you need to create and deploy a custom
DocApp. Refer to Chapter 9, Creating Process Workflows and Lifecycles for specific
workflow and lifecycle examples.
An object type is a template for objects (usually documents) that play a special role in a
DocApp. An object type inherits properties from its supertype (usually dm_document or
one of its subtypes). The additions or modifications you make to these properties define
the object type. You create new types to identify characteristics of specific documents as
well as to allow specific lifecycles and workflows to manage them.
Attributes are data items that accompany an object of a given type. Use the type and
attribute editors to define or modify object types.
You might want to create object types that are specific to your company. You can associate
any number of attributes with your object type. In DDS you must associate an object type
with a lifecycle in order to use your custom object type in WebPublisher. Refer to the
Documentum Developer Studio Help for more information about object types and attributes.
A Docbase user or group with membership in at least one WebPublisher user group.
Each user group provides a different level of functionality. Administrators assign users
to their groups using Documentum Administrator. All users assigned to a group use the
WebPublisher User Default ACL.
WebPublisher provides four user groups:
• Content Authors create, edit and review Web pages using the authoring interface.
• Content Managers can do all of the above, and also manage workflows, using the
authoring interface.
TM
2–2 Customizing Documentum WebPublisher
Customization Overview
• Web Developers can do all of the above, and also design templates and Web sites,
and generate reports, using the WebPublisher Pro interface.
• Administrators can do all of the above, and also configure WebPublisher and archive
Web sites, using the WebPublisher Pro interface.
When you add users you must following the instructions provided in Using WebPublisher
Pro.
For more information about how to use Documentum Administrator, refer to
Documentum Administrator Online Help.
Aliases are the parameters of a document lifecycle. They enable you to assign symbolic
names to aspects of the document lifecycle that you expect to differ from one context to
the next. When WebPublisher attaches a document to a lifecycle, it must provide specific
values for all aliases. Alias sets facilitate this process. You create alias sets to encapsulate
aliases for groups and folders. You use these aliases to make your DocApp portable to
other Docbases. For example, you might design a lifecycle using symbolic user names
Reviewer1, Reviewer2, Reviewer3. In one context you can specify:
• Reviewer1 = Linda
• Reviewer2 = Ed
• Reviewer3 = Denise
In another context, you can assign different user names to these symbolic names. The
assignment of an actual user, group, permission set, or Docbase cabinet or folder to a
symbolic name is called an alias. The actual value is called the alias value. A collection
of aliases is called an alias set.
You create permission set templates (also called ACLs) that assign permissions to the
users and folders. By default, a user’s default permission set template is assigned to
any new documents that the user creates. A permission set template that is specified
for a folder regulates operations on objects within the folder, such as creating, moving,
deleting, and copying objects. If you are reusing a DocApp and deploying it to another
Docbase that services a different set of users in your company, permission set templates
are of great utility.
TM
Customizing Documentum WebPublisher 2–3
Customization Overview
the process workflow, it is restricted from being sent to another workflow until it is
complete. The Cleanup task releases the restriction.
Administrators create process workflows in advance and make these workflows
available to users. Refer to Using WebPublisher Pro for more information about workflows
and Chapter 9, Creating Process Workflows and Lifecycles for an example custom workflow.
A document lifecycle encodes business rules for changes in the properties of an object as
it moves through the stages of its life (for example, review, publishing, and end-of-life).
All WebPublisher lifecycles have a minimum of four lifecycle states. Those states are
Start, WIP, Staging, and Approved. An administrator can create new lifecycles with
additional states between the WIP and Approved states, and can change the names of
these default states.
The Expired state is not part of the configured lifecycle object, but is based on property
values of the content object. Refer to Using WebPublisher Pro for more information about
lifecycles.
After you have created a custom DocApp and DocApp archive in DDS, install the
DocApp archive to your WebPublisher Docbase, create a template, and test your lifecycle
and workflow.
Once you install the DocApp archive to your WebPublisher Docbase, you must connect
to WebPublisher as an Administrator or Web developer and add the workflow. Refer to
Using WebPublisher Pro for step-by-step instructions to add a workflow.
To test your lifecycle, connect to your Docbase from WebPublisher, create a new template
using a custom object type and lifecycle, add content to your custom template, and
promote the content through the lifecycle.
To test your workflow connect to your Docbase from WebPublisher, import a custom
content template, promote the content to the WIP state, and insert your content into
your custom workflow.
If you receive errors then you need to return to DDS to examine your lifecycle and
workflow.
You can package a DocApp into an archive that you can deploy to other Docbases. If you
are reusing the DocApp and deploying it to another Docbase that services a different set
of users in your company, permission set templates are of great value. When you install
TM
2–4 Customizing Documentum WebPublisher
Customization Overview
the DocApp archive to a Docbase, you are prompted to provide values (user names,
groups, cabinets, or directories) for the aliases in your DocApp.
If an error message appears stating that an alias already exists, it means that you have
aliases defined in your Docbase with the same name as one that you are trying to install.
Use Documentum Administrator to delete the duplicate aliases and reinstall the DocApp.
TM
Customizing Documentum WebPublisher 2–5
Customization Overview
TM
2–6 Customizing Documentum WebPublisher
Customization Overview
Browser Settings
To correctly display your WebPublisher customizations in Web browsers you must
configure your Web browser with specific settings.
WebPublisher supports multiple browsers through either multiple presentation files
or templates, and generates multiple renditions from single content objects. These
renditions can be HTML-based renditions viewed through a standard HTML browser, or
they can be HTML files viewed on WebTV or for WML (Wireless Markup Language)
renditions viewed through a WAP browser (for eventual viewing on a wireless device
such as a cell phone or PDA). Web developers define the applications used to view
alternate Web renditions by selecting the correct format in their Web browser and typing
the path to the viewing application.
Components to Customize
Components can be anything from DocApp attributes to WebPublisher templates and
files. Components are parts of the WebPublisher system that control WebPublisher
functionality and provide WebPublisher’s look and feel. You can modify the components
to reflect your company’s business processes and appearance.
DocApps
DocApp components include object types, attributes, alias sets, content templates,
lifecycles and workflows. The default WebPublisher DocApp should already be installed
to your Docbase before you begin your customizations.
A DocApp encapsulates Docbase-related objects and processes that are specific to a
business or department. You can build DocApps from scratch, or build DocApps from
WebPublisher’s default DocApp.
To copy custom Docbase-related objects and processes easily from one Docbase to another
you must create a custom DocApp that encapsulates your customizations. Your custom
DocApp could include an object type, attributes, an alias set and permission set template,
a lifecycle, a workflow, and configuration templates all specific to your company’s needs.
TM
Customizing Documentum WebPublisher 2–7
Customization Overview
You use Documentum Developer Studio (DDS) to create a custom DocApp, and you use
Documentum DocApp Installer to deploy the DocApp to various Docbases.
When you want to customize your WebPublisher installation, you should create a new
custom DocApp containing any customizations. Custom DocApps ensure that your
customizations will not be overwritten by future upgrades to the default WebPublisher
DocApp. You must install the WebPublisher default DocApp before you install your
custom DocApp for WebPublisher to work correctly.
Developing DocApps contains all the information you need to create and deploy a custom
DocApp. Refer to Chapter 9, Creating Process Workflows and Lifecycles for specific
workflow and lifecycle examples.
An object type is a template for objects (usually documents) that play a special role in a
DocApp. An object type inherits properties from its supertype (usually dm_document or
one of its subtypes). The additions or modifications you make to these properties define
the object type. You create new types to identify characteristics of specific documents as
well as to allow specific lifecycles and workflows to manage them.
Attributes are data items that accompany an object of a given type. Use the type and
attribute editors to define or modify object types.
You might want to create object types that are specific to your company. You can associate
any number of attributes with your object type. In DDS you must associate an object type
with a lifecycle in order to use your custom object type in WebPublisher. Refer to the
Documentum Developer Studio Help for more information about object types and attributes.
A Docbase user or group with membership in at least one WebPublisher user group.
Each user group provides a different level of functionality. Administrators assign users
to their groups using Documentum Administrator. All users assigned to a group use the
WebPublisher User Default ACL.
WebPublisher provides four user groups:
• Content Authors create, edit and review Web pages using the authoring interface.
• Content Managers can do all of the above, and also manage workflows, using the
authoring interface.
• Web Developers can do all of the above, and also design templates and Web sites,
and generate reports, using the WebPublisher Pro interface.
• Administrators can do all of the above, and also configure WebPublisher and archive
Web sites, using the WebPublisher Pro interface.
TM
2–8 Customizing Documentum WebPublisher
Customization Overview
When you add users you must following the instructions provided in Using WebPublisher
Pro.
For more information about how to use Documentum Administrator, refer to
Documentum Administrator Online Help.
Aliases are the parameters of a document lifecycle. They enable you to assign symbolic
names to aspects of the document lifecycle that you expect to differ from one context to
the next. When WebPublisher attaches a document to a lifecycle, it must provide specific
values for all aliases. Alias sets facilitate this process. You create alias sets to encapsulate
aliases for groups and folders. You use these aliases to make your DocApp portable to
other Docbases. For example, you might design a lifecycle using symbolic user names
Reviewer1, Reviewer2, Reviewer3. In one context you can specify:
• Reviewer1 = Linda
• Reviewer2 = Ed
• Reviewer3 = Denise
In another context, you can assign different user names to these symbolic names. The
assignment of an actual user, group, permission set, or Docbase cabinet or folder to a
symbolic name is called an alias. The actual value is called the alias value. A collection
of aliases is called an alias set.
You create permission set templates (also called ACLs) that assign permissions to the
users and folders. By default, a user’s default permission set template is assigned to
any new documents that the user creates. A permission set template that is specified
for a folder regulates operations on objects within the folder, such as creating, moving,
deleting, and copying objects. If you are reusing a DocApp and deploying it to another
Docbase that services a different set of users in your company, permission set templates
are of great utility.
TM
Customizing Documentum WebPublisher 2–9
Customization Overview
A document lifecycle encodes business rules for changes in the properties of an object as
it moves through the stages of its life (for example, review, publishing, and end-of-life).
All WebPublisher lifecycles have a minimum of four lifecycle states. Those states are
Start, WIP, Staging, and Approved. An administrator can create new lifecycles with
additional states between the WIP and Approved states, and can change the names of
these default states.
The Expired state is not part of the configured lifecycle object, but is based on property
values of the content object. Refer to Using WebPublisher Pro for more information about
lifecycles.
After you have created a custom DocApp and DocApp archive in DDS, install the
DocApp archive to your WebPublisher Docbase, create a template, and test your lifecycle
and workflow.
Once you install the DocApp archive to your WebPublisher Docbase, you must connect
to WebPublisher as an Administrator or Web developer and add the workflow. Refer to
Using WebPublisher Pro for step-by-step instructions to add a workflow.
To test your lifecycle, connect to your Docbase from WebPublisher, create a new template
using a custom object type and lifecycle, add content to your custom template, and
promote the content through the lifecycle.
To test your workflow connect to your Docbase from WebPublisher, import a custom
content template, promote the content to the WIP state, and insert your content into
your custom workflow.
If you receive errors then you need to return to DDS to examine your lifecycle and
workflow.
You can package a DocApp into an archive that you can deploy to other Docbases. If you
are reusing the DocApp and deploying it to another Docbase that services a different set
of users in your company, permission set templates are of great value. When you install
the DocApp archive to a Docbase, you are prompted to provide values (user names,
groups, cabinets, or directories) for the aliases in your DocApp.
TM
2–10 Customizing Documentum WebPublisher
Customization Overview
If an error message appears stating that an alias already exists, it means that you have
aliases defined in your Docbase with the same name as one that you are trying to install.
Use Documentum Administrator to delete the duplicate aliases and reinstall the DocApp.
TM
Customizing Documentum WebPublisher 2–11
Customization Overview
This is the cabinet that contains the WebPublisher Editor templates and files.
7. Click Insert, and then Next.
8. Select the permission set alias to apply to this cabinet, and click Finish.
The WebPublisher Configuration cabinet is inserted into the custom DocApp under
the Data Objects folder. Refer to the Documentum Developer Studio Help for more
information on alias sets.
You should now insert two default WebPublisher object types. You need these object
types because Developer Studio will not archive objects that are based on a custom
type unless the type definition is included in the DocApp. If you do not have the
type in the DocApp, then the delivery cabinet, folders within the delivery cabinet,
system configuration, and category folders will not get archived. This is true for any
custom object types you create.
9. Choose Insert>Object From Docbase>Object Type.
10. Select the object type to insert, and click Insert.
The four default WebPublisher object types are:
• wcm_category
• wcm_channel
• wcm_channel_fld
• wcm_config
11. Create a DocApp archive, or update your existing DocApp with the new cabinet
and object types.
Refer to Packaging and Deploying DocApps to Other Docbases to create a DocApp
archive and deploy it to a Docbase.
TM
2–12 Customizing Documentum WebPublisher
Customization Overview
Browser Settings
To correctly display your WebPublisher customizations in Web browsers you must
configure your Web browser with specific settings.
WebPublisher supports multiple browsers through either multiple presentation files
or templates, and generates multiple renditions from single content objects. These
renditions can be HTML-based renditions viewed through a standard HTML browser, or
they can be HTML files viewed on WebTV or for WML (Wireless Markup Language)
renditions viewed through a WAP browser (for eventual viewing on a wireless device
such as a cell phone or PDA). Web developers define the applications used to view
alternate Web renditions by selecting the correct format in their Web browser and typing
the path to the viewing application.
Customization Process
Customization Guidelines
This section discusses some guidelines for a customization strategy and methodology.
Before you begin a customization project, you should understand how the WebPublisher
directory structure is arranged and the basic functionality of the WebPublisher Web
server components.
You customize WebPublisher functionality on the Web server. You create a folder
structure under the custom directory on your file system and modify files in the custom
directory. The custom folder structure and file location must parallel the folder structure
and file location from the product folder or the customizations will not be picked up
by the dispatcher.
Note: Do not customize files in the product directory, but instead copy the hierarchy of
folders you want to work on into the custom directory, and customize them there.
If you are adding or modifying any images you must copy the entire images directory to
the custom directory structure.
TM
Customizing Documentum WebPublisher 2–13
Customization Overview
Warning If you make customizations in the product directory, they will be overwritten
when you upgrade.
The customizations you create can apply to all Docbases or specific Docbases. If you
want your customization to apply to all Docbases, copy the appropriate subfolders
into the \custom\default folder that parallels the product directory structure for that
feature. If you want a customization to apply only to a specific Docbase, you must create
a folder at the same level as the default folder, name it with the name of the Docbase to
which you want the customization to apply, and copy the appropriate subfolders into the
\custom\<Docbase> folder that parallels the product directory structure for that feature.
For example, if you have a Docbase called Corporate_Development and you want to
customize the cabinet view for all users who connect to that Docbase, you would create
the following directories to make sure your customization only applies to that particular
Docbase.
You may want to create a subtype to customize for your specific application of
WebPublisher. If you have created a subtype to use with WebPublisher you must store
the subtype in the proper location on the Web server.
A subtype is a child of an object type and can inherit the feature of its supertype. For
example, if SOP is a subtype of dm_document and the ACTIONS page for both types has
the same features then you do not need to create an SOP ACTIONS page directory. The
dispatcher automatically picks up all the needed components from the dm_document
directory.
On the other hand, if an SOP’s ACTIONS page needs to vary from its supertype’s
then you must create an actions\sop folder under your custom\default folder and
copy or create those components that are different from the supertype. For example, if
export is not available for this type, then only the actions.xml file needs to be copied to
the actions\sop folder and modified by taking out the export_object feature; all other
components of this feature are automatically picked up from the supertype directories.
TM
2–14 Customizing Documentum WebPublisher
Customization Overview
Any component file that needs to be shared among all the subtypes resides in the
feature’s base directory. For example, because all title blocks share the same start.htm
file this file is placed in the wcm\product\titles folder.
Customizing Features
Following are some examples on customizing WebPublisher features. The examples tell
you which files you need to copy and modify.
Using WebPublisher, you can view or change the attributes of objects. The forms that
make up these features are located in wcm\product\views\attributes. There is a
subfolder for each object type: dm_cabinet, dm_folder, dm_document, dm_sysobject.
For example, when you view the attributes of a document, you see the form
wcm\product\views\attributes\start.htm in the main frame.
The start.htm page displays a title block from wcm\product\titles\start.htm
at the top, the PROPERTIES page for the object, and a standard footer from
wcm\product\footers\default.htm at the bottom.
If you change any attributes and then click Save Changes a standard success page is
displayed briefly to indicate that your changes have successfully been applied to the
object . You are then returned to the originating screen, for example, the contents view of
the folder, which contains the document.
In order to separate literal strings displayed in a page from the HTML layout and
logic of a feature, WebPublisher provides a facility for feature pages to access strings
from a dictionary.htm file. If the strings are specific to a feature they are placed in
the feature’s base directory for example, cancel checkout. If they need to be accessed
from multiple features in the system, they are placed in the global dictionary in
wcm\product\dictionary.htm. The dictionary items are RightSite variables that are
declared and accessed using DMW_DECLARE in a dictionary.htm file.
The dictionary.htm file is also useful for software localization. Because the dictionary.htm
file contains numerous strings that need to be translated, the translator only needs to
access this one file instead of several files.
WebPublisher provides many centralized services that are accessed throughout the
product. Success, failure, and confirmation pages constitute one such service. This
TM
Customizing Documentum WebPublisher 2–15
Customization Overview
service only requires the feature to set specific RightSite variables and then include the
confirmation, success, or failure page using DMW_INCLUDE or DMW_DECLARE
methods. Alternatively, you can specify DMW_APP_SUCCESS for DMW_INPUTFORM
and DMW_APP_FAILURE for DMW_ON_ERROR in a form hidden input field when
calling a RightSite method. You can also call a script that sets the variables using
dwSetVar().
TM
2–16 Customizing Documentum WebPublisher
Customization Overview
</attribute>
<attribute>
<name>a_expiration_date</name>
<label>MSG_ATTR_LABEL_EXPIRATION_DATE</label>
</attribute>
<attribute>
<name>a_category</name>
</attribute>
<attribute show_all_values="true">
<name>a_publish_formats</name>
<label>MSG_ATTR_LABEL_PUBLISH_FORMATS</label>
<info_string>MSG_ATTR_INFO_LABEL_PUBLISH_FORMATS</info_string>
</attribute>
<attribute display_control="textarea" default_textarea_rows=
"3"textarea_wrap="true">
<name>log_entry</name>
<label>MSG_ATTRIBUTES_COMMENTS</label>
</attribute>
</attributelist>
</group>
</editablegroups>
As you can see, each element must have a start and an end tag. Each element may
contain element attributes, not to be confused with Docbase object type attributes as well
as other elements, in the form of:
<element element_attribute="some_value"
<element >
:
</element >
</element >
For example:
<attributelist>
<attribute show_all_values="true">
<name>keywords</name>
</attribute>
</attributelist>
TM
Customizing Documentum WebPublisher 2–17
Customization Overview
If you are developing a custom view or operation you should have some familiarity with
the history mechanism. This mechanism is used to identify the view you can return to
after an operation completes. The display data is retrieved from the Docbase every
time the data is requested.
The success page interacts with the history mechanism to automatically return you to the
appropriate view. Here is an example of a success page’s interaction with the history
mechanism. An operation may require you to perform several steps. Each of those steps
display in a different frame set. If the operation completes successfully you want to be
returned to a logical view such as the beginning of the procedure. The success operation
enables this return to happen by destroying the middle steps of an operation so the
history mechanism cannot read the pages in between the success page and the start
procedure page. The failure page works in a similar way destroying middle pages to
return you to the start procedure page to redo the procedure.
An operation can change the state of an object by:
• modifying a property value
• saving a new version of a document
• creating a new object by importing a file
• deleting an object by deleting a version of a document.
In these cases we need to set specific RightSite session variables before DMW_INCLUDE
calls the success page.
If you use the success page without setting these RightSite session variables, the
view of the last cabinet or folder is automatically refreshed from Docbase data.
RightSite session variables are set in the dictionary.htm file for each specific operation.
For example, a success session variable for a check in operation would be set in
wcm\product\operations\checkin\dictionary.htm and look as follows:
<DMW_DECLARE NAME="SUCCESS_SHOW_OBJECT_ICON" SCOPE=
"SESSION" VALUE="true">
TM
2–18 Customizing Documentum WebPublisher
Customization Overview
In the save operation a new object is created, which should be displayed in place of the
old object. In this case three RightSite session variables should be set:
• SUCCESS_OPER_PERFORM should be set to replace.
• SUCCESS_OPER_OLD_ID should be set to the ID of the old object.
• DMW_NEW_OBJECTID is set to the ID of the newly saved object. This variable is
actually set by RightSite when you invoke the checkin method.
For a view to use the information set up by the operation, history_utils.ebs defines three
public functions:
• writeContainerRequestToBrowser:
called from start.htm located in wcm\product\titles. This function adds a URL
for the current view to the history list so you can return to it when an operation
successfully completes.
<DMW_EXEC
EXECTYPE="Docbasic"
FILE="<DMW_SUBST NAME ="DMW_APP_SCRIPTS_DIR">history_utils.ebs"
ARGUMENT="-ewriteContainerRequestToBrowser"
ARGUMENT="-p"
>
• writeFolderAncestorIDsToBrowser:
called from start.htm of every view located in wcm\product\views\contents, such
as dm_folder. This function stores information about the two most recent content
views you have visited, so if a folder is deleted as part of an operation we can return
to that folder’s parent folder.
<DMW_EXEC
EXECTYPE="Docbasic"
FILE="<DMW_SUBST NAME ="DMW_APP_SCRIPTS_DIR">history_utils.ebs"
ARGUMENT="-ewriteFolderAncestorIDsToBrowser"
>
• writeContentsCheckToBrowser:
called from start.htm of every content view located in wcm\product\views\contents,
such as dm_folder. This function refreshes the content view if the content of the
container has changed in any way. It makes this determination based on information
passed to it by the last operation performed.
<DMW_EXEC
EXECTYPE="Docbasic"
FILE="<DMW_SUBST NAME ="DMW_APP_SCRIPTS_DIR">history_utils.ebs"
ARGUMENT="-ewriteContentsCheckToBrowser"
Most of the time you do not need to modify the start.htm file for a content view. If you
want to modify start.htm, copy an existing start.htm file and make changes to it. This
TM
Customizing Documentum WebPublisher 2–19
Customization Overview
way you do not need to decide where to enter calls for the functions mentioned above
since the calls are already in the file you have copied.
When customizing WebPublisher you should never hard-code a URL for a feature or the
dispatcher. Use one of the central Docbasic routines, documented in scripts\readme.txt,
that constructs the desired URL based on parameters you pass to it. This ensures that if
the syntax of the product’s URL changes your code will continue to function correctly.
The dispatcher acquires information it needs from a URL which, like a RightSite method
URL with an implied formexec, calls for a preliminary file. For information about
RightSite method URLs, refer to RightSite Reference Manual.
This URL can also include arguments in name=value pairs for the dispatcher to use
when further processing the request, for example:
/RightSite.dll/
wcm?view=contents&type=dm_cabinet&id=0c00000abcd23456
These name=value pairs not only include information that the dispatcher needs, but can
include any other name=value pairs that the customized feature needs. The dispatcher
uses a DMW_INCLUDE statement to provide the form that starts the customized feature,
it can pass all the information in the URL to the first form. However, the dispatcher is
responsible only for getting you to the first HTML form template in the customization.
After that, any further information needed in the feature must be provided by the user,
set as a session variable, or passed from page to page. For information about variables,
refer to the RightSite Reference Manual.
The dispatcher looks for the arguments and their values as shown in the following table.
Several other RightSite and WebPublisher preliminary file environment variables that
the dispatcher may need are also supported.
Argument Values
view The name of the feature and subfolder under the views directory.
TM
2–20 Customizing Documentum WebPublisher
Customization Overview
Argument Values
type The name of the subfolder under the feature subfolder defined by
either operation or view. If there is no value for operation or view
then this is ignored. If view\operation has a value, but type is
missing, id\DMW_OJBECTID is examined for its Documentum
object typename. The typename is then used as the value of type. If
the value of type does not match any subfolder, the type’s parent
typename is tried, and so on until a match is found. Then, if no
match is found, the dispatcher looks for a subfolder named default
under the feature and uses that. If this is missing as well, an error
message is issued indicating why the request could not be resolved.
entry (defaults to start.htm) The template form name that the dispatcher
calls with DMW_INCLUDE when the appropriate subfolder is
found.
error The template form name that the dispatcher calls with
DMW_INCLUDE when the eflag has been set to YES by the
vsi_error and ssi_error preamble. If this form is missing, the generic
error form is called using DMW_INCLUDE.
eflag This is set to YES when RightSite calls the error preamble (which
is the value of the optional DMW_ON_ERROR RightSite method
argument). If it is set to "YES", the dispatcher processes the request
as a feature error handler instead of the feature entry point.
Several other RightSite and WebPublisher preliminary file environment variables that
the dispatcher may need are also supported.
Almost all environment variables that the dispatcher sets begin with DMW_APP.
The directory environment variables all end in "_DIR" and specify an operating system
file’s system directory path. These paths always end with a trailing path separator (a
slash). The direction that the slash goes (forward slash or backslash) depends on the
TM
Customizing Documentum WebPublisher 2–21
Customization Overview
operating system of the server that RightSite is installed on. The standard is usually "/"
for UNIX systems and "\" for Windows systems.
The path environment variables all end in "_PATH" and specify the URL namespace
path recognized by the Web server.
By definition, URL paths do not necessarily match the string of the corresponding file
system directory.
The following table lists the environment variables that you may encounter when
implementing your customizations:
TM
2–22 Customizing Documentum WebPublisher
Customization Overview
TM
Customizing Documentum WebPublisher 2–23
Customization Overview
TM
2–24 Customizing Documentum WebPublisher
Customization Overview
TM
Customizing Documentum WebPublisher 2–25
Customization Overview
The following are examples of how to use some of the dispatcher-set variables:
Public gDMW_APP_SCRIPTS_DIR As String
:
:
ret = external(gDMW_APP_SCRIPTS_DIR & "utils.ebs")
Call getVersionLabels(id, theLabels)
<DMW_EXEC
EXECTYPE="Docbasic"
FILE="<DMW_SUBST NAME="DMW_APP_SCRIPTS_DIR">process_page.ebs"
ARGUMENT="-eexecuteFeatureScript"
ARGUMENT="-pexecute_query" >
<DMW_INCLUDE FILE="<DMW_SUBST
NAME="DMW_APP_DIALOG_HEADER_DIR">start.htm">
<DMW_INCLUDE FILE="<DMW_SUBST
NAME="DMW_APP_SUCCESS_DIALOG_DIR">start.htm">
<FONT FACE="<DMW_SUBST NAME="DMW_APP_FONT_FACE">" SIZE="-1">
<IMG SRC="<DMW_SUBST NAME="DMW_APP_ICONS_PATH">misc/
m_clear_1.gif" WIDTH=10 HEIGHT=1>
You should always use one of the central Docbasic routines documented in the
scripts\readme.txt file that constructs the desired URL based on parameters you pass
to it.
/RightSite/
wcm_logged_in?view=attributes&id=090000028002dd3d&type=
dm_document&DMW_DOCBASE=engineering&DMW_ON_ERROR=
wcm_silent_login _failure&pid=0c00000280000143&gpid=
filing_cabinets">Properties
This example shows a URL for the Properties link in a dm_document list item.
<DMW_DECLARE NAME="DMW_APP_ARGS" SCOPE="SESSION"
VALUE="id=<DMW_SUBST NAME="id">&entry=checkin&type=
<DMW_SUBST NAME="type">&operation=<DMW_SUBST NAME=
"operation"> & DMW_ECHO=id,operation,type,entry">
The previous example uses a URL variable called entry which tells the dispatcher which
form within the feature directory to use for this request. It defaults to start, but can be
TM
2–26 Customizing Documentum WebPublisher
Customization Overview
set to any template name that is valid within this feature’s subfolder. The entry variable
allows multi-sequence features to set the links from one page to the next within the
feature’s set of templates. The uploadfile method is a RightSite (and plug-in) method, so
the previous example does not call the dispatcher.
TM
Customizing Documentum WebPublisher 2–27
Customization Overview
Users invoke the dispatcher when they click a link or a button in the WebPublisher user
interface. This action causes the dispatcher to find and include the appropriate start.htm
form for the feature invoked by the link.
The dispatcher looks at the parameters of the URL associated with the selected link or
button to determine what feature to invoke. The dispatcher matches URL parameters to
files in the Web server directory structure to determine the appropriate start.htm form to
use. The URL could look something like this:
http://eng064/rs-bin/RightSite.dll/wcm_logged_in?
view=get_content&id=09011c748000545&DMW_FORMAT=crtext&ShowCuVer=
TRUE&DMW_DOCBASE=EngineeringOne&DMW_ON_ERROR=wcm_s1_failure
or like this:
javascript:submitOperation(’/rs-bin/RightSite.dll/wcm_logged_in?view=
oper_frame&next_operation=export_object&DMW_DOCBASE_EngineeringOne&
DMW_ON_ERROR=wcm_s1_failure&rndn=345536’,’09’,’false’)
TM
2–28 Customizing Documentum WebPublisher
Customization Overview
The dispatcher looks in two places on the file system to find the appropriate start.htm
form, wcm\product\views and wcm\product\operations. All list start.htm forms are
stored in the views folder, and all action start.htm forms are stored in the operations
folder. The first URL directs the dispatcher to the wcm\product\views\get_content
folder and open the start.htm form. The second URL directs the dispatcher to the
wcm\product\operations\export_object folder and open the start.htm form of the object
which you are exporting. For example, if you select a file of object type dm_document,
the dispatcher navigates to the dm_document folder in the export_object folder and
opens the start.htm form for dm_document.
The dispatcher also looks at some hard-coded information to find the
URLs for such features as the success, failure, and confirmation pages. The
dispatcher looks in two places on the file system to find the proper success
and failure forms. To display the success or failure warning to the user
the dispatcher looks at wcm\product\failure\one_button_dialog.htm or
wcm\product\success\one_button_dialog.htm. The one_button_dialog.htm directs the
dispatcher to bu_one_button_dialog.htm or wd_one_button_dialog.htm, depending on
the logged-in user’s level. When you click Close on the success or failure warnings,
the dispatcher looks at wcm\product\views\oper_frame\remove.htm to remove the
warning page and return you to a logical place.
If the parameter entry= is present in the URL, the dispatcher picks up the .htm form
to which the parameter points. For example, if you want to cancel an export operation,
the dispatcher navigates to wcm\product\views\oper_frame and opens remove.htm
to display the cancel export operation page. The URL for the cancel export operation
looks like this:
http://eng064/rs-bin/RightSite.dll/wcm_logged_in?view=oper_frame&entry=
remove&url_id=remove&url_id=09011c7480004545&dialog_type=Failure&layout=
one_button_dialog.htm&DMW_DOCBASE= EngineeringOne&DMW_ON_ERROR=
wcm_s1_failure
If no
entry=
parameter exists then the dispatcher picks up the operation start.htm form.
The start.htm form can contain an entire feature, include other subforms, or set up
variables and other information.
Most of the dispatcher is contained in two files called wcm_dispatch.htm and
wcm_dispatch_script.ebs, which are called by a DMW_INCLUDE method in one of
several preliminary files that are used in every WebPublisher request. These preliminary
files set environment variables, and separate out pre- and post-log in requests and error
processing requests. The preliminary files and their purposes are:
• wcm.htm: WebPublisher non-error pre-log in requests.
• wcm_logged_in.htm: WebPublisher non-error post-log in requests
• wcm_failure.htm: WebPublisher error processing requests
TM
Customizing Documentum WebPublisher 2–29
Customization Overview
The dispatcher determines which files to use based on a recursive search through the
custom and product folder hierarchies on the Web server. When a form is invoked, the
dispatcher looks for a series of directories and paths and adds them to a list of "base
directories", if they exist. If DW_APPS_ROOTDIR is the root directory into which
WebPublisher has been installed, the dispatcher looks, in the order described below, for
application-specific customizations in the \wcm\custom\application_name subfolder.
If it does not locate that directory, it looks for Docbase-specific customizations in the
\wcm\custom\current_Docbase subfolder. If it does not find any of these directories, an
error message is issued; if it does find one, the process continues.
Next, the dispatcher tries to find out which base directory is used for each of the
page fragments (footers, titles, list_items, etc.) and where the application-common
directories are found. This search is conducted in the same order as the steps above. The
custom\application_name subfolder is checked first, then the \custom\current_Docbase
directory, then the \custom\default subfolder, and finally the product directory.
Because the dispatcher does this searching for each component of a feature, you need
to place only the added or modified files in the custom directory. The dispatcher finds
the remainder of the feature’s components from the other locations. The one exception
to this behavior is the script directory. If you want to modify a file that resides in the
scripts directory then you must copy all files under wcm\default\product\scripts to
wcm\custom\default\scripts.
The final step is for the dispatcher to find the entry point of the requested feature. The
starting location for every feature is a file named start.htm. The only exception to this
rule is the starting location for list_items, which is start.ebs. To find the entry point
the dispatcher looks through the base directories. If the URL passed to the dispatcher
contains a type argument, the dispatcher looks for a subfolder below the feature
subfolder (using the same search order as the previous two searches) that has the same
name as the type.
• If a subfolder for that type is not found, the dispatcher searches the object hierarchy
until it finds the correct subfolder.
• If it does not find a matching subfolder, it looks in the feature’s subfolder.
• If the component it is looking for is still not found, then an error page is displayed.
• If the URL contains only a value for an id argument or DMW_OBJECTID, but
without a type specification, the dispatcher goes to the Docbase to get the type of the
object specified and then performs the search for a subfolder named for that type.
TM
2–30 Customizing Documentum WebPublisher
Customization Overview
WebPublisher forms are HTML files with code that, through the RightSite integration,
access information stored on the eContent Server. RightSite converts the returned data
from the eContent Server to pure HTML so that the WebPublisher form can be displayed
in the browser-based WebPublisher user interface.
WebPublisher forms are constructed using a combination of standard HTML, WebQL,
and Docbasic scripts. When a form is called using the formexec method, it is sent to
RightSite. RightSite checks it for WebQL tags and executes any it finds. The executed
WebQL tags are then replaced with the results of the processing. This process is
recursive. After the replacements are made, the process is repeated until no more WebQL
is present. The finished form, now containing only HTML, is returned to the browser.
For information about WebQL, refer to the Documentum RightSite Reference Manual.
TM
Customizing Documentum WebPublisher 2–31
Customization Overview
WebPublisher uses the history mechanism to ensure that when users complete an
operation (such as saving a file), they are returned to a logical place in WebPublisher.
For example, if a user is viewing the properties of an object and decides to delete
that object, it is important that the dispatcher knows which page to take the user to
after that object is successfully deleted. The history mechanism tells the dispatcher
which page to display, and is accessed using three Docbasic scripts located in
wcm\product\scripts\history_utils.ebs. The history mechanism determines a logical
return by tracking URLs that users have selected from the WebPublisher user interface.
When you click the Back button in your browser you are returned to a logical place
based on the URL selection.
The wcm\product folder contains the HTML forms, graphic images, configuration files,
and Docbasic scripts that make up default WebPublisher functionality. Following is a
description of each subfolder in the product folder.
Folder Description
app Contains global application-level files such as the About page and
global dictionary.
app_scripts Contains scripts that you can modify for your specific environment.
For example, the script wcm_calc_preview_url.ebs is a script that
constructs the URL to Web view content. You can modify this script
based on the structure of your Web site and the application server
that serves the Web site.
category_titles Contains forms that are displayed as part of a view for a given
category object.
failure Contains forms that display the failure window. All the features in
WebPublisher use the same failure window.
TM
2–32 Customizing Documentum WebPublisher
Customization Overview
Folder Description
footers Contains a form that is included on the bottom of every view page.
It indicates that there is no more data to be displayed and lets you
jump to the top of the page.
images Contains the images that are used throughout WebPublisher user
interface. For example, \images\formats contains the .gif images
for the icons that represent the format of documents in the Docbase.
list_items Contains forms that display the object when you display a
folder’s contents view. For example, when you are looking at a
folder’s contents, a document or a sysobject is displayed using the
corresponding list item definition.
obj_titles Contains forms that are displayed as part of a view for a given object
within the content author and content manager user interface.
operation Contains the forms that compose product features. For example,
the forms which compose the feature of creating a document are
located in \operations\create_document\dm_folder.
scripts Contains files that have utility type Docbasic functions that are
invoked from various forms. The readme.txt file in the scripts
directory describes all the other Docbasic methods or central public
that can invoke these utility type Docbasic functions.
status Contains forms that display the status window. All features in
WebPublisher use the same status window. Features that accept
multi-selection will display to the status window.
stylesheet Contains the cascading stylesheet (CSS) for WebPublisher. You can
modify the CSS to meet your company’s needs.
success Contains forms that display the success window. All the features in
WebPublisher use the same success window.
TM
Customizing Documentum WebPublisher 2–33
Customization Overview
Folder Description
titles Contains forms that are displayed as part of a view for a given
object. For example, when you are viewing the attributes of a
document type such as dm_document, the title form specific to
dm_document appears at the top of the PROPERTIES page. A title
for an object shows the object name, object type and other types of
views or actions that are available for this object.
views Contains the forms which compose different views of objects. For
example, the forms which compose the view of what is contained
in a cabinet are located in \views\contents\ dm_cabinet. Views are
pages that have a title area to allow you to switch among pages that
display different information about the current object, for example
properties of that object and actions you can perform on that object.
Any function not explicitly documented in this file should not be
called directly.
TM
2–34 Customizing Documentum WebPublisher
Chapter 3
Customizing WebPublisher’s Default
Settings
You can customizing WebPublisher’s default settings by copying and modifying the configuration.xml
file. In this chapter we discuss role selection, and filename lengths.
TM
Customizing Documentum WebPublisher 3–1
Customizing WebPublisher’s Default Settings
TM
3–2 Customizing Documentum WebPublisher
Customizing WebPublisher’s Default Settings
TM
Customizing Documentum WebPublisher 3–3
Customizing WebPublisher’s Default Settings
TM
3–4 Customizing Documentum WebPublisher
Chapter 4
Customizing the Properties Page
This chapter begins with the modification to the PROPERTIES page. The customization will show the
properties for a custom object type labeled standard operating procedure (SOP).
Note: Attributes and Properties are used interchangeably throughout this chapter. Attributes when
discussing the attributes.xml file, and Properties when referring to the Web page. Both terms
represent the same elements.
Before you can proceed with any customization you must have created your custom DocApp. The
DocApp should include:
• custom object type
• custom_number attribute
• affected_departments attribute
• approval_department
• alias set
• lifecycle
• workflow
• WebPublisher Configuration cabinet
You need also to package and deploy the custom DocApp to a Docbase, and create new content based
on a custom object type and lifecycle.
Refer to Developing DocApps for more information about creating a DocApp.
Note: To view your customizations you should always log out and log back in to WebPublisher
because of browser caching issues. Refer to Working Around Memory Caching Issues for more
information about caching.
Use the following three methodology questions to see how to proceed.
• Where will the user see the result?
The SOP PROPERTIES page, which is displayed to the user.
• What needs to be modified to achieve the result in the feature?
A custom DocApp, or object type in DDS, and the WebPublisher dm_document attributes.xml file.
TM
Customizing Documentum WebPublisher 4–1
Customizing the Properties Page
• What action, if any, will the user take to initiate this feature?
The user selects the Properties link for an SOP-type document from a Folder FILE LIST page in
which it is listed.
Caution Never make changes to the original files in the product directory. Doing this will change the
WebPublisher defaults and you will not be able to return to restore the defaults unless you re-install
WebPublisher. It is always best to make changes in your custom directory.
The next things to decide are where on the page you want the SOP attributes to show up and who
should be able to view or edit them.
TM
4–2 Customizing Documentum WebPublisher
Customizing the Properties Page
TM
Customizing Documentum WebPublisher 4–3
Customizing the Properties Page
The PROPERTIES page is made up of an editable portion and a Read-Only portion. In the editable
portion, there are a number of attributes that you will change in the following procedures.
To modify the PROPERTIES page.
• Copy the attributes.xml File
• Delete attributes
• Add attributes
• Add value assistance
• Add value selection
• Create scripts
• Display and hide attributes
• Adding or removing content
• Test customizations
1. On the server where WebPublisher is installed, open Windows Explorer and navigate
to RightSite\applications\wcm\custom\default.
2. In the default folder, create a views\attributes\sop folder structure.
3. Navigate to RightSite\applications\wcm\product\views\attributes\dm_
document\attributes.xml.
4. Copy the attributes.xml from the product folder to the SOP folder that you created
in step two.
You should now see the following in your custom directory:
TM
4–4 Customizing Documentum WebPublisher
Customizing the Properties Page
Since you are changing the list of attributes displayed, the only file you need to modify
is the attributes.xml file.
There are other files in the \product\views\attributes folder that are used by all the
object types. If you needed to override their implementation, you would have to copy
those to the custom directory and modify them as well. For this exercise you do not
need any other files.
If you open the attributes.xml file you copied to custom\views\attributes\sop, you
can see that it is divided into two sections, editablegroups and viewonlygroups.
Furthermore, all the attributes in each section are displayed on the PROPERTIES page in
the exact order you see in the XML file.
The first portion of the file, editablegroup, looks as follows:
<editablegroups>
<group>
<attributelist>
<attribute>
<name>object_name</name>
<label>MSG_ATTR_LABEL_OBJECT_NAME</label>
</attribute>
<attribute>
<name>title</name>
<label>MSG_ATTR_LABEL_TITLE</label>
</attribute>
<attribute>
<name>subject</name>
</attribute>
<attribute show_all_values="true" display_control="select">
<name>keywords</name>
</attribute>
<attribute show_all_values="true">
<name>authors</name>
</attribute>
<attribute>
<name>a_effective_date</name>
<label>MSG_ATTR_LABEL_EFFECTIVE_DATE</label>
<validate_attr_script>donot_show_in_change_set</validate_attr_script>
</attribute>
<attribute>
<name>a_expiration_date</name>
<label>MSG_ATTR_LABEL_EXPIRATION_DATE</label>
TM
Customizing Documentum WebPublisher 4–5
Customizing the Properties Page
</attribute>
<attribute>
<name>a_category</name>
</attribute>
<attribute show_all_values="true">
<name>a_publish_formats</name>
<label>MSG_ATTR_LABEL_PUBLISH_FORMATS</label>
<info_string>MSG_ATTR_INFO_LABEL_PUBLISH_FORMATS</info_string>
</attribute>
<attribute display_control="textarea" default_textarea_rows=
"3"textarea_wrap="true">
<name>log_entry</name>
<label>MSG_ATTRIBUTES_COMMENTS</label>
</attribute>
</attributelist>
</group>
</editablegroups>
Deleting Attributes
Since the title, subject, keywords, and authors attributes are not used for SOP documents
in your company, remove the lines for those attributes and save the attributes.xml file.
To delete attributes:
TM
4–6 Customizing Documentum WebPublisher
Customizing the Properties Page
<name>subject</name>
</attribute>
<attribute show_all_values="true" display_control="select">
<name>keywords</name>
</attribute>
<attribute show_all_values="true">
<name>authors</name>
</attribute>
4. Choose File>Save.
5. Navigate to your browser page and refresh the contents of the right-hand frame that
displays the PROPERTIES page.
You should see that the title, subject, keywords, and authors attributes are no longer
displayed.
Adding Attributes
You now add sop_number, affected_departments, effective_date, and
approval_department attributes to the XML page where title, subject, keywords, and
authors attributes used to be.
To add attributes:
TM
Customizing Documentum WebPublisher 4–7
Customizing the Properties Page
3. Choose File>Save.
4. Connect to WebPublisher as Web developer or administrator.
5. Select an SOP document and click the Properties link.
You should see the following Properties page.
TM
4–8 Customizing Documentum WebPublisher
Customizing the Properties Page
3. Choose File>Save.
4. Connect to WebPublisher as Web developer or administrator.
5. Select an SOP document and click the Properties link.
You should see the following.
TM
Customizing Documentum WebPublisher 4–9
Customizing the Properties Page
TM
4–10 Customizing Documentum WebPublisher
Customizing the Properties Page
1. On the server where WebPublisher is installed, open Windows Explorer and navigate
to RightSite\applications\wcm\product\views\attributes\wcm_category
2. Copy the get_rendition_choices.ebs script from the product folder to the SOP folder
in \custom\default\views\attributes.
TM
Customizing Documentum WebPublisher 4–11
Customizing the Properties Page
End Sub
1. On the server where WebPublisher is installed, open Windows Explorer and navigate
to RightSite\applications\wcm\product\views\attributes\dm_document
2. Copy the get_status.ebs script and the attributes .xml from the product folder to the
SOP folder in RightSite\applications\wcm\custom\default\views\attributes.
TM
4–12 Customizing Documentum WebPublisher
Customizing the Properties Page
<attr_value_script>get_status</attr_value_script>
The script get_status.ebs returns a single value for the attribute. There are actually
two values returning back: the first is the value for the display, the second is the
value to store in the attribute.
3. Choose File>Save.
4. Using a text editor, navigate to
RightSite\applications\wcm\custom\default\views\attributes\sop and
open the get_status.ebs script.
Public gClientX As IDfClientX
Public gLocalClient As IDfClient
Public gSession As IDfSession
isWebDoc = theObject.isWebDoc
if (isWebDoc) then
attr_sysvalue$ = theObject.getCurrentStateName
else
attr_sysvalue$ = theObject.getVersionStatus
end if
attr_value$ = attr_sysvalue$
End Sub
TM
Customizing Documentum WebPublisher 4–13
Customizing the Properties Page
Creating Scripts
You can enforce an additional requirement that only the owner or the administrator
or Web developer can edit the affected_departments, effective_date, and
approval_department attributes. Content authors and content managers are restricted to
viewing this information.
To do this, put the list of attributes in both the editablegroups and viewonlygroups
sections of the attributes.xml file.
To assign all other users View Only status you must write two very small scripts and
let WebPublisher invoke them to determine if a particular SOP attribute should be
displayed or not. You must also then edit the attributes.xml file.
Since these scripts are specific to the SOP PROPERTIES page handling, we place them in
the \custom\views\attributes\sop folder. If the scripts are common to all subtypes of
dm_document, put them in an attributes\dm_document folder. If they are common to
all object types, put them in the attributes directory.
option cStrings on
Sub validateAttr(byref isvalid as boolean)
Dim wcmUtil As Object
Dim wcmConstant As Object
If (UserGroup = wcmConstant.getCONTENT_AUTHOR_GROUP())
Or (UserGroup = wcmConstant.getCONTENT_MANAGER_GROUP()) Then
TM
4–14 Customizing Documentum WebPublisher
Customizing the Properties Page
isValid=false
Else
isValid=true
End If
End Sub
The Sub validateUser entry point checks to see if the current user is the owner of the
current SOP object; if the previous condition is true, true is returned, indicating that
the attribute element should be accessible by this user.
3. Choose File>Save.
4. Navigate to
C:\RightSite\applications\wcm\custom\default\views\attributes\sop.
5. Name your script file validate_edit_sop_info.ebs.
option cStrings on
Sub validateAttr(byref isvalid as boolean)
Dim wcmUtil As Object
Dim wcmConstant As Object
If (UserGroup = wcmConstant.getCONTENT_AUTHOR_GROUP())
Or (UserGroup = wcmConstant.getCONTENT_MANAGER_GROUP()) Then
isValid=true
Else
isValid=false
End If
End Sub
3. Choose File>Save.
4. Navigate to c:\RightSite\applications\wcm\custom\default\views\attributes\sop.
5. Name your script file validate_view_sop_info.ebs.
Note: The object ID is retrieved by doing a dwGetVar(“id?) and the current user
is retrieved by accessing the RightSite variable DMW_DOCBASE_USER using a
dwGetVar().
Next, modify the attributes.xml file to complete the view and hide customization.
TM
Customizing Documentum WebPublisher 4–15
Customizing the Properties Page
TM
4–16 Customizing Documentum WebPublisher
Customizing the Properties Page
<attribute>
<name>_permit</name>
</attribute>
</attributelist>
</group>
You must add this code to each of the four elements.
4. Choose File>Save.
5. In the viewonlygroups section, add the edit script to the following elements:
• r_version_label
• r_lock_date
6. Type the following code. The bolded section below contains the attributes to add.
<attribute show_all_values="true">
<name>r_version_label</name>
<validate_attr_script>validate_edit_sop_info</validate_attr_script>
</attribute>
<attribute>
<name>r_lock_date</name>
<validate_attr_script>validate_edit_sop_info</validate_attr_script>
</attribute>
7. Choose File>Save.
You can now add multiple application elements to this application list. Each application
must specify whether it is to include or exclude the user-level specified in the name
element.
TM
Customizing Documentum WebPublisher 4–17
Customizing the Properties Page
<validate_attr_script>validate_edit_sop_info</validate_attr_script>
</attribute>
<attribute>
<name>sop_number</name>
<label>SOP number:</label>
<validate_attr_script>validate_edit_sop_info</validate_attr_script>
</attribute>
<attribute show_all_values="true">
<name>affected_departments</name>
<validate_attr_script>validate_edit_sop_info</validate_attr_script>
<label>Affected departments:</label>
</attribute>
<attribute>
<name>approval_department</name>
<validate_attr_script>validate_edit_sop_info</validate_attr_script>
<label>Approval department:</label>
</attribute>
<attribute>
<name>a_effective_date</name>
<validate_attr_script>validate_edit_sop_info</validate_attr_script>
<label>MSG_ATTR_LABEL_EFFECTIVE_DATE</label>
</attribute>
</attributelist>
4. Choose File>Save.
The file name is entered without the .ebs extension.
1. Using a text editor, navigate to your custom folder and open the attributes.xml file.
2. Copy the object_name, sop_number, affected_departments, approval_department,
and a_effective_date attributes from the editablegroups section to the
viewonlygroups section.
3. Change the following line:
validate_edit_sop_info code line
to
validate_view_sop_info
4. Type the following code. The bolded section below contains the attributes to add.
<attributelist>
<attribute>
<name>object_name</name>
<label>MSG_ATTR_LABEL_OBJECT_NAME</label>
<validate_attr_script>validate_view_sop_info</validate_attr_script>
</attribute>
<attribute>
TM
4–18 Customizing Documentum WebPublisher
Customizing the Properties Page
<name>sop_number</name>
<label>SOP number:</label>
<validate_attr_script>validate_view_sop_info</validate_attr_script>
</attribute>
<attribute show_all_values="true">
<name>affected_departments</name>
<validate_attr_script>validate_view_sop_info</validate_attr_script>
<label>Affected departments:</label>
</attribute>
<attribute>
<name>approval_department</name>
<validate_attr_script>validate_view_sop_info</validate_attr_script>
<label>Approval department:</label>
</attribute>
<attribute>
<name>a_effective_date</name>
<validate_attr_script>validate_view_sop_info</validate_attr_script>
<label>MSG_ATTR_LABEL_EFFECTIVE_DATE</label>
</attribute>
</attributelist>
5. Choose File>Save.
TM
Customizing Documentum WebPublisher 4–19
Customizing the Properties Page
<name>SOP_Subject</name>
<label>Subject of SOP</label>
</attribute>
5. To remove the effective date select the following element and press the Delete key.
<attribute>
<name>a_effective_date</name>
</attribute>
Each document must have an effective date. If you remove the effective date from the
PROPERTIES page WebPublisher will derive the document’s effective date from the
template the document was based on. If the template does not have an effective date,
then WebPublisher will derive the effective date from the document creation date.
6. To remove the expiration date select the following element and press the Delete key.
<attribute>
<name>a_expiration_date</name>
</attribute>
Each document must have an expiration date. If you remove the expiration date
from the PROPERTIES page WebPublisher will use the default expiration date of 15
days. The default expiration date can be changed in the system configuration file
by the system administrator. The system configuration file is located on the System
Configuration page in WebPublisher/Properties
Testing Customizations
Test your customizations to ensure that you have correctly modified the attributes.xml
file, and correctly created the edit and view scripts.
TM
4–20 Customizing Documentum WebPublisher
Customizing the Properties Page
TM
Customizing Documentum WebPublisher 4–21
Customizing the Properties Page
TM
4–22 Customizing Documentum WebPublisher
Chapter 5
Modifying a List Item
In this chapter you will create a new list item for the SOP document type, and you will modify a
list item for thumbnails.
A list item is an attribute such as a subject, author, or SOP number displayed under your specified
document type or thumbnail in the FILE LIST page. WebPublisher uses the list_item.xml file to
specify the attribute or data to be displayed and the content.xml file to specify the DQL.
Before you can proceed with any customization you must have created your custom DocApp. The
DocApp should include
You need also to package and deploy the custom DocApp to a Docbase, and create new content based
on an custom object type and lifecycle.
Refer to Developing DocApps for more information about creating a DocApp.
Note: To view your customizations you should always log out and log back in to WebPublisher
because of browser caching issues. Refer to Working Around Memory Caching Issues for more
information about caching.
WebPublisher uses the contents.xml file to specify the DQL and list_item.xml to specify the attribute
or other data to display. If you add new dm_sysobject/dm_document attributes to the list_item.xml
file we recommend that you add these same attributes to the contents.xml file. If you add custom
attributes that are subtypes of dm_document WebPublisher performs a query for these attribute IDs.
TM
Customizing Documentum WebPublisher 5–1
Modifying a List Item
TM
5–2 Customizing Documentum WebPublisher
Modifying a List Item
3. Navigate to RightSite\applications\wcm\product\list_items\dm_document\list_
items.xml
4. Copy the list_items.xml file from the product folder to the sop folder that you
created in step two.
You should now see the following in your custom directory:
To change the list item for sop document types, the only file you need to edit is the
dm_document\list_items.xml file.
Note: There are other XML files for different views, including cabinets, folders, content
authors, content managers, and Web developers. The bu_dm_document folder enables
you to change the list item for content authors and Managers, and the dm_document
folder enables you to change the list item for Web developers. For this exercise you do
not need to edit any other files.
If you open the list_item.xml file you copied to custom\default\list_items\sop, you can
see that it has one section: attributelist.
Some of the XML files are divided into two sections: attributelist and featurelist. The
attributelist section specifies which attributes should be displayed for an object of this
type and the featurelist specifies which FILE LIST and ACTIONS should be available.
In this example we display object_name and title attributes. The following is the content
of the dm_document list_items.xml file:
<listitem>
<attributelist>
<attribute show_default_label="false">
<name>object_name</name>
</attribute>
<attribute show_default_label="false">
<name>title</name>
</attribute>
</attributelist>
</listitem>
TM
Customizing Documentum WebPublisher 5–3
Modifying a List Item
1. Using a text editor, navigate to your custom folder and open the list_items.xml file.
2. Type the following code:
<attribute show_default_label="false">
<name>sop_number</name>
</attribute>
3. Choose File>Save.
4. Connect to WebPublisher as Web developer or administrator.
You should see the following SOP number under the sop object in the FILE LIST page:
1. Using a text editor, navigate to your custom folder and open the list_items.xml file.
2. Select the false label, and modify it to say true.
This change displays the SOP Number label. The bolded section below is the
attribute to change.
<attribute show_default_label="true">
<name>sop_number</name>
</attribute>
3. Choose File>Save.
4. Connect to WebPublisher as Web developer or administrator.
You should see the following SOP number label under the sop object in the FILE
LIST page.
TM
5–4 Customizing Documentum WebPublisher
Modifying a List Item
Note: To display all the values for a repeating attribute in the attributes.xml file, set the
element attribute show_all_values to true. For example:
<attribute show_all_values="true">
<name>a_publish_formats</name>
<label>MSG_ATTR_LABEL_PUBLISH_FORMATS</label>
<info_string>MSG_ATTR_INFO_PUBLISH_FORMATS</info_string>
</attribute>
By default, WebPublisher does not retrieve any custom attributes as part of a Cabinet or
Folder query. To display a custom attribute, WebPublisher performs a fetch of the object.
TM
Customizing Documentum WebPublisher 5–5
Modifying a List Item
1. Using a text editor, navigate to your custom folder and open the list_items.xml file.
2. Remove the following file size code by selecting the entire attribute and clicking
Delete.
<attribute>
<name>r_content_size</name>
</attribute>
4. Choose File>Save.
5. Connect to WebPublisher as Web developer or administrator.
6. Navigate to the thumbnails on the FILE LIST page.
TM
5–6 Customizing Documentum WebPublisher
Modifying a List Item
You should now see the name of the file owner on the right-hand side of the
thumbnail.
You can modify the list_items.xml file to hide or display any thumbnail information.
Any words that overlap the character limit for thumbnail information will be wrapped.
You cannot modify the character length.
TM
Customizing Documentum WebPublisher 5–7
Modifying a List Item
TM
5–8 Customizing Documentum WebPublisher
Chapter 6
Customizing Search Pages
This chapter explains how to customize the existing default ADVANCED SEARCH page, the existing
default SIMPLE SEARCH page, and how to create a new simple search option. Each of these tasks are
completed by modifying the search_facility.xml file, or the wd_header.htm file and bu_header.htm file.
TM
Customizing Documentum WebPublisher 6–1
Customizing Search Pages
To modify the default ADVANCED SEARCH page, copy the search_facility.xml from
product\views\search_facility\untyped.
TM
6–2 Customizing Documentum WebPublisher
Customizing Search Pages
After copying the file you should see the following in your custom directory:
Since you are changing the default advanced search, the only file you need is the
untyped\search_facility.xml file.
TM
Customizing Documentum WebPublisher 6–3
Customizing Search Pages
— default: enables you to choose an object type that is first displayed in the Search
For field on the SEARCH page. You want to change the default object type.
• Changes the default logical operator to AND and hides the control from the user.
• Simplifies the user interface by allowing searches only on the object_name property,
set the default relational operator to CONTAINS, and hide the control from the user.
• Displays the match case control enabling users to specify whether the search should
be case-sensitive or case-insensitive.
1. Using a text editor, navigate to your custom folder and open the search_facility.xml
file.
2. In the defaultObjectType section, select the dm_document type.
3. Change the dm_document name to SOP.
The bolded text below is the name to change.
<burootObjectType>
<name>dm_document</name>
</burootObjectType>
<wdrootObjectType>
<name>dm_sysobject</name>
</wdrootObjectType>
<defaultObjectType>
<name>sop</name>
</defaultObjectType>
4. Choose File>Save.
1. In a text editor, navigate to your custom folder, and open the search_facility.xml file.
2. Remove the following bolded clause that specifies the OR operator in the
logicOperatorList section.
<logicOperatorlist>
<operator>
<name>all</name>
</operator>
<operator default_selection="true">
<name>any</name>
</operator>
</logicOperatorlist>
TM
6–4 Customizing Documentum WebPublisher
Customizing Search Pages
4. Choose File>Save.
1. Using a text editor, navigate to your custom folder and open the search_facility.xml
file.
2. From the whereAttributelist section, delete everything except the object_name block.
The object name block looks as follows:
<attribute display_control="text">
<name>object_name</name>
<label>MSG_SF_LABEL_OBJECT_NAME</label>
<relationalOperatorlist>
<operator>
<name>is</name>
</operator>
<operator default_selection="true">
<name>contains</name>
</operator>
<operator>
<name>starts_with</name>
</operator>
</relationalOperatorlist>
</attribute>
TM
Customizing Documentum WebPublisher 6–5
Customizing Search Pages
</operator>
<operator>
<name>starts_with</name>
</operator>
</relationalOperatorlist>
</attribute>
TM
6–6 Customizing Documentum WebPublisher
Customizing Search Pages
The customization affects the custom search content view page, as well as the
sop_search criteria page.
• What needs to be modified to achieve the result in the feature?
— You must create a new search criteria page for the sop_search page so that the
search is centered around the SOP object type and its custom attributes.
— You must add the sop_search link to the custom search content view page, where
the sop_search can be accessed.
• What action, if any, will the user take to initiate this feature?
The user clicks Search on the upper frame to get to the search criteria page for
the default type. Clicking the custom search link on the upper right-hand corner
displays the modified custom search content view with a SOP search link in it. Click
the SOP search to view the search criteria.
Before you begin these customizations copy the search_facility.xml file from the product
folder to your custom folder. Refer to Copying the search_facility.xml File for more
information.
The original whereAttributelist in the search_facility.xml file looks like this:
<whereAttributelist>
<attribute>
<name>affected_departments</name>
<relationalOperatorlist>
<operator>
<name>is_any_of</name>
</operator>
<operator>
<name>is_all_of</name>
</operator>
</relationalOperatorlist>
</attribute>
</whereAttributelist>
TM
Customizing Documentum WebPublisher 6–7
Customizing Search Pages
<operator>
<name>is</name>
</operator>
<operator default_selection="true">
<name>contains</name>
</operator>
<operator>
<name>starts_with</name>
</operator>
</relationalOperatorlist>
</attribute>
TM
6–8 Customizing Documentum WebPublisher
Customizing Search Pages
</attribute>
TM
Customizing Documentum WebPublisher 6–9
Customizing Search Pages
To modify the default SIMPLE SEARCH page, copy the search_facility.xml from
product\views\search_facility\simple.
TM
6–10 Customizing Documentum WebPublisher
Customizing Search Pages
1. Using a text editor, navigate to your custom folder and open the simple
search_facility.xml file.
2. In the selectAttributelist section, select the title type.
3. Change the title to mytitle.
The text below is the code to change.
<attribute>
<name>mytitle</name>
</attribute>
4. Choose File>Save.
1. In a text editor, navigate to your custom folder, and open the simple
search_facility.xml file.
2. In the selectAttributelist section, add the following attribute:
<attribute>
<name>keywords</name>
</attribute>
3. Choose File>Save.
TM
Customizing Documentum WebPublisher 6–11
Customizing Search Pages
To modify the default search link, copy the wd_header.htm file and the bu_header.htm
file from product\app to custom\default\app.
Note: If you want to modify the simple search queries, other than attributes and
types, you must know Documentum Docbasic, and you must make changes to the
display_results.ebs file. We do not go into detail about this customization in this guide.
Copying Files
If you look in the product directory hierarchy, you see that under \app there is the
wd_header file and bu_header file. The wd_header.htm file controls the WebPublisher
Pro search facility for Web developers and administrators, and the bu_header.htm file
controls the WebPublisher search facility for content managers and content authors.
TM
6–12 Customizing Documentum WebPublisher
Customizing Search Pages
4. Copy all the files from the product folder to the app folder that you created in step
two.
After copying the files you should have 48 files in your custom\default\app
folder two of which should be the search header files bu_header.htm file, and
wd_header.htm file.
Your custom Web macro must include the WebPublisher method to generate a link to
your custom search type folder, you must change the search argument from simple to
custom, and you must set the variable name which determines where WebPublisher will
look for the custom search link when users click GO in the user interface.
Following is an example of a custom Web macro.
<!-- new search type -->
<DMW_EXEC
FILE="<DMW_SUBST NAME=""DMW_APP_SCRIPTS_DIR">templates.ebs"
EXECTYPE="Docbasic"
ARGUMENT="-egetFeatureLinkWOEntryAsVar"
ARGUMENT="-p"
ARGUMENT="-pmytype" <!-- custom search argument -->
ARGUMENT="-psearch_facility"
ARGUMENT="-p"
ARGUMENT="-pmytypeLink" <!-- Go Link folder where the custom search is located
on file system-->
>
FORM NAME="SEARCH" TARGET="display" ACTION=="<DMW_SUBST NAME="=mytypeLink">"
METHOD="POST" <TD VALIGN="TOP" BGCOLOR="#FFFFFF">
TM
Customizing Documentum WebPublisher 6–13
Customizing Search Pages
TM
6–14 Customizing Documentum WebPublisher
Chapter 7
Customizing Content Pages
This chapter explains how to customize content pages. Content pages enable WebPublisher users to
create content for Web pages. Content is the text, graphics, scripts and other output that you create
for Web pages. When you create content in WebPublisher, you are creating the information that is
combined with a WebPublisher page type to produce a Web page.
For WebPublisher Pro you will customize the IMPORT page. For WebPublisher you will customize
the CREATE PAGE tab.
This chapter discusses the following topics:
• Customizing the Import Page
• Customizing the Create Page Tab
TM
Customizing Documentum WebPublisher 7–1
Customizing Content Pages
The IMPORT page is made up of an editable section and a Read-Only section. The
editable section can be modified through the import_object.xml file to display changes
for administrators and Web developers.
TM
7–2 Customizing Documentum WebPublisher
Customizing Content Pages
1. On the server where WebPublisher is installed, open Windows Explorer and navigate
to RightSite\applications\wcm\custom\default.
2. In the default folder, create an operations folder\import_object structure.
3. Navigate to RightSite\applications\wcm\product\operations\import_object.
4. Copy the import_object.xml file from the product folder to the custom folder that
you created in step two.
5. You should now see the following in your custom directory:
<attributelist>
<attribute>
<name>a_effective_date</name>
</attribute>
<attribute>
<name>a_expiration_date</name>
</attribute>
</attributelist>
</import_object>
You can add or delete attributes, and change the full-text index flag.
TM
Customizing Documentum WebPublisher 7–3
Customizing Content Pages
You may want to add new attributes if you have created a custom object type that requires
a special attribute, and remove attributes that are not applicable to your custom type.
5. To remove the effective date select the following element and press the Delete key.
<attribute>
<name>a_effective_date</name>
</attribute>
Each document must have an effective date. If you remove the effective date from
the IMPORT page WebPublisher will derive the document’s effective date from the
template the document was based on. If the template does not have an effective date,
then WebPublisher will derive the effective date from the document creation date.
6. To remove the expiration date select the following element and press the Delete key.
<attribute>
<name>a_expiration_date</name>
</attribute>
Each document must have an expiration date. If you remove the expiration date
from the IMPORT page WebPublisher will use the default expiration date of 15
days. The default expiration date can be changed in the system configuration file
by the system administrator. The system configuration file is located on the System
Configuration page in WebPublisher/Properties.
TM
7–4 Customizing Documentum WebPublisher
Customizing Content Pages
You can set the full-text index flag to true or false in the add_content.xml file. If this flag
is set to true then the full-text index option is set on the document. The eContent server
will periodically run a process that full-text indexes the flagged document. If this flag is
set to false then the full-text index option is not set on the document.
Testing Customizations
Test your customizations to ensure that you have correctly modified the XML files.
TM
Customizing Documentum WebPublisher 7–5
Customizing Content Pages
The user clicks the CREATE PAGE tab and navigates to a template from which
to create new content.
You now need to decide which content fields on the tab you want to modify.
1. On the server where WebPublisher is installed, open Windows Explorer and navigate
to RightSite\applications\wcm\custom\default.
2. In the default folder, create an operations\add_content structure.
3. Navigate to RightSite\applications\wcm\product\operations\add_content.
4. Copy the add_content.xml file from the product folder to the custom folder that
you created in step two.
5. You should now see the following in your custom directory:
TM
7–6 Customizing Documentum WebPublisher
Customizing Content Pages
displayed on the CREATE PAGE tab as content fields in the exact order you see in the
XML file and each attribute can be customized.
The attribute list looks as follows:
<add_content>
<base_type>dm_document</base_type>
<attributelist>
<attribute>
<name>a_effective_date</name>
</attribute>
<attribute>
<name>a_expiration_date</name>
</attribute>
</attributelist>
<add_content>
You can add or delete attributes, and add a full-text index flag.
You may want to add new attributes if you have created a custom object type that requires
a special attribute, and remove attributes that are not applicable to your custom type.
5. To remove the effective date select the following element and press the Delete key.
TM
Customizing Documentum WebPublisher 7–7
Customizing Content Pages
<attribute>
<name>a_effective_date</name>
</attribute>
Each document must have an effective date. If you remove the effective date from the
CREATE PAGE tab WebPublisher will derive the document’s effective date from the
template the document was based on. If the template does not have an effective date,
then WebPublisher will derive the effective date from the document creation date.
6. To remove the expiration date select the following element and press the Delete key.
<attribute>
<name>a_expiration_date</name>
</attribute>
Each document must have an expiration date. If you remove the expiration date
from the CREATE PAGE tab WebPublisher will use the default expiration date of 15
days. The default expiration date can be changed in the system configuration file
by the system administrator. The system configuration file is located on the System
Configuration page in WebPublisher/Properties.
You can set the full-text index flag to true or false in the add_content.xml file. If this flag
is set to true then the full-text index option is set on the document. The eContent server
will periodically run a process that full-text indexes the flagged document. If this flag is
set to false then the full-text index option is not set on the document.
Testing Customizations
Test your customizations to ensure that you have correctly modified the XML files.
TM
7–8 Customizing Documentum WebPublisher
Customizing Content Pages
TM
Customizing Documentum WebPublisher 7–9
Customizing Content Pages
TM
7–10 Customizing Documentum WebPublisher
Chapter 8
Creating a Custom Feature
This chapter explains how you can create new features either by using an existing feature as a starting
template, or by writing your own using the information in other sections of this guide.
Note: To view your customizations you should always log out and log back in to WebPublisher
because of browser caching issues. Refer to Working Around Memory Caching Issues for more
information about caching.
1. Create a new subdirectory under the class of feature (views or operations) directory.
• If you want the feature to apply to a particular Docbase only, create this
subdirectory in the \custom\Docbase_name folder.
• If you want this feature to apply across all Docbases, create it in the
\custom\default folder.
2. Within your new feature’s subdirectory, create all the templates, configuration files,
scripts, and icons that are unique to the new feature and simply allow the rest of the
components be inherited from the parent object types’ directories.
3. You must also add the jumping-in point for your feature to either the ACTIONS
page, the title page fragment for the object type, or a list item to which it applies.
TM
Customizing Documentum WebPublisher 8–1
Creating a Custom Feature
the checkboxes of the items on which you want to perform an action, and then you
click the action. To select all items, check all. If an action has two arrows, you can
select multiple items before clicking the action. If an action has one arrow, you can
select only one item before clicking the action
The default channel action list on the FILE LIST page within a cabinet should look
similar to the following figure.
TM
8–2 Customizing Documentum WebPublisher
Creating a Custom Feature
The user must navigate to the page whose action list was modified. In the following
examples, the channel action list is modified.
To modify the channel action list, customize the actionlist.xml file for
your Send Attachment action. You must copy the actionlist.xml file from
product\actionlist\wcm_channel_fld to custom\default\actionlist\wcm_channel_fld,
and you must create a folder for your custom action under custom\default\operations.
TM
Customizing Documentum WebPublisher 8–3
Creating a Custom Feature
Each feature list contains features or operations that can be performed on selected
documents. Following is an explanation of the feature elements.
• process type: an object type that is a subtype of dm_sysobject for example, a
dm_document object type or a custom object type. Only documents of this process
type can access this feature. If you have created a custom object type for a custom
feature you would enter the custom object type here.
• currentVerOnly: This element can be set to true or false. True enables users to perform
operations on only the current version of a selected document. False, or deleting this
attribute, enables users to perform operations on any version of a selected document.
• name: The name of the operations\<new action> folder. For example,
operations\SendAttachment.
• Label: The name displayed in the user interface. This name is usually taken from the
data dictionary. If no name is available in the data dictionary then WebPublisher
will use whatever name is in the <label> </label>attribute. For example, Send
Attachment.
• arguments: Some features contain arguments that provide WebPublisher with
directions for an operation. For example, the multi checkout feature contains the
argument no_editor=true. This argument tells WebPublisher not to launch an editor
when multiple documents are selected and checked out. If you want to create a
custom argument you must first code the argument for the feature to which you are
attaching the argument. By default WebPublisher looks in the start.htm file for
arguments. You can change this starting file to any file you wish by adding the
following code to the actionlist.xml file for your custom action.
entry="<new_filename>"
• include_pid: Some features contain an include parent Id (pid) element. This element
tells WebPublisher to include the parent ID of the current folder. The URL provides
WebPublisher with information on the operation as well as the location of the
document to which the operation is being performed.
TM
8–4 Customizing Documentum WebPublisher
Creating a Custom Feature
import com.documentum.wcm.xml.*;
import com.documentum.webclient.*;
import com.documentum.wcm.*;
if (isGlobalizationOn)
return IActionListFilter.ENABLED;
else
return IActionListFilter.DISABLED;
TM
Customizing Documentum WebPublisher 8–5
Creating a Custom Feature
}
catch(Exception e)
{
return -1;
}
} // filter()
} // TranslationFilter Class
To further modify the action list you can delete any feature, or rearrange features so they
are presented to the user in a different order on the WebPublisher user interface.
<filter_classpath>com.documentum.webclient.views.TranslationFilter
</filter_classpath>
<feature multiselect="true" process_type="sop" include_pid="true"
currentVerOnly="true">
<name>send_attachment</name>
<label>SEND ATTACHMENT</label>
</feature>
</actionlist>
4. Choose File>Save.
5. Connect to WebPublisher.
You should see the following action Send Attachment in the action list under the
Edit group.
TM
8–6 Customizing Documentum WebPublisher
Creating a Custom Feature
TM
Customizing Documentum WebPublisher 8–7
Creating a Custom Feature
TM
8–8 Customizing Documentum WebPublisher
Chapter 9
Creating Process Workflows and
Lifecycles
Many companies have policies that govern how specific types of documents work their way through
their useful lives, and beyond. Such policies typically specify the stages that a document passes
through and the activities that occur at each stage. Documentum separates these aspects of document
policy into two concepts: lifecycles, which define the stages of a document’s life, and workflows,
which define sequences of actions that users must perform on the document. Document lifecycles
(DLC) and workflows complement one another. A DLC specifies the states a document occupies
during its life. The DLC does not define what activities happen to a document while it resides in a
state, who is responsible for those activities, or when the document should move to another state. A
workflow defines a connected set of activities, including who performs the activities and when.
WebPublisher uses process workflows to ensure that Web pages adhere to your organization’s
review and management requirements before they are published on a production Web site. Process
workflows manage Web page content from its creation in a Docbase to its publication on an external
Web site. A process workflow consists of a standard Documentum 4i workflow integrated with
a Documentum 4i lifecycle. You can use the same workflow for all content or create many different
workflows for different kinds of content or different authoring groups.
Administrators can use default process workflows as a basis for creating new process workflows
with different reviewers, steps, and actions, depending on your organization’s requirements.
Administrators can modify task performers using groups or alias sets, modify approval and rejection
paths, and customize workflow source files to provide their own alias suggestion values for every
alias.
Using a process workflow, you can set WebPublisher to promote content objects automatically to
the next state in their lifecycle when a particular task owner submits the change set. The lifecycle
controls the publishing and end-of-life processing for the objects in the change set. The creator of a
workflow or lifecycle needs to have the WebPublisher Default ACL assigned to them. This ACL
enables users to participate in the workflow or lifecycle. Please refer to Using WebPublisher Pro for
more information on change sets.
A document lifecycle (DLC) encodes business rules for changes in the properties of an object
as it moves through the stages of its life (for example, review, publishing, and end-of-life). All
WebPublisher lifecycles have a minimum of four lifecycle states: Start, WIP, Staging, and Approved.
An administrator can create new lifecycles with additional states between the WIP and Approved
states, and can change the names of these default states.
TM
Customizing Documentum WebPublisher 9–1
Creating Process Workflows and Lifecycles
WebPublisher assigns the Work In Progress (WIP) state to all newly created or newly versioned
content. WebPublisher automatically launches a process workflow when a user submits a WIP file
and the file has a default workflow. WebPublisher then automatically creates a change set for the file.
Once the process workflow begins, the change set appears as a task for the next performer. Performers
can view or edit the files and supporting files in the change set and they can add files or delete files
from the change set. When a performer forwards the task, WebPublisher automatically promotes the
change set (if configured to do so) to the next state in the lifecycle. The change set then appears as
a task for the next performer in the workflow.
Administrators can configure WebPublisher so that any reviewer can reject a workflow task, which
means they do not approve of the content. A rejection of a task could return WebPublisher to the
previous task and demote the change set from its current state back to the previous state. The actions
of a reject task are determined by the workflow template designed by the workflow designer.
If a workflow task is rejected, and the workflow template rejection path points back to a group, all
users of that group will receive the rejection notice, not just the user that originally acquired the
task in the group.
TM
9–2 Customizing Documentum WebPublisher
Creating Process Workflows and Lifecycles
TM
Customizing Documentum WebPublisher 9–3
Creating Process Workflows and Lifecycles
Following is a description of the tasks and their correct settings that appear in the
Figure 71.
Initialize: This is the workflow starting task. You must set the performer to be a Docbase
owner, and the automatic WebPublisher method to be wcmInitializeProcessWorkflow. At
this time WebPublisher creates a change set to include all the documents to be translated.
The documents display in WebPublisher with a change set and workflow icon.
TM
9–4 Customizing Documentum WebPublisher
Creating Process Workflows and Lifecycles
Translate: This is the document translation task. The Description must be set to one
of the three descriptions.
• trans_internal: <comment to next performer><(locale)>
• trans_external: <comment to next performer><(locale)>
• trans_launch_wf: <comment to next performer><(locale)>
The three translation tasks will have different information in this dialog box. Please
refer to the following examples for more information. The locale is especially important
because internally WebPublisher does not allow the original language files in the change
set to be translated. WebPublisher makes a copy of the original files and enables only the
copies to be translated. For example, if two English documents need to be translated
the trans_internal change set will contain four documents after translation, two English
original documents and two translated documents. All users will see four documents
except the translator who will only see two documents. With this information,
WebPublisher determines which translation activity to run, and which documents to
display to the performer for translation.
Promote To Staging: This is an automatic promote task. Once the translation task is
complete the documents are automatically promoted for review. You must set the
performer to be a Docbase owner, and you must set the automatic WebPublisher method
to be wcmPromoteToStaging. This method automatically promotes all the files in the
change set from WIP to Staging in the lifecycle unless this is a trans_launch_wf. If this is
a launch task only the files in the trans_launch_wf change set are promoted.
TM
Customizing Documentum WebPublisher 9–5
Creating Process Workflows and Lifecycles
Reviewer: This is the reviewer of the translated document task. The reviewer can only
view the documents, they cannot add or edit documents. If the reviewer is not satisfied
with the translation they can reject the documents, sending them back to the translation
task. If the reviewer is satisfied with the translation they can finish their task.
Promote To Approved: This is an automatic promote task. Once the review task is
complete the documents are automatically promoted to approved. You must set the
performer to be a Docbase owner, and you must set the automatic WebPublisher method
to be wcmPromoteToApproved. This method promotes the translated documents
from Staging to Approved in the lifecycle, and enables users to see the document as an
approved file.
TM
9–6 Customizing Documentum WebPublisher
Creating Process Workflows and Lifecycles
Clean Up: This is an automatic clean up task. Once the approved task is complete
WebPublisher does cleanup of the workflow. You must set the performer to be
a Docbase owner, and you must set the automatic WebPublisher method to be
wcmTerminateProcessWorkflow. This method removes the translated files from the
change set, deletes the change set, and displays the documents to users as an approved
document removing the change set and workflow icon.
TM
Customizing Documentum WebPublisher 9–7
Creating Process Workflows and Lifecycles
trans_internal task
A trans_internal task integrates with a process workflow created for the specific use of
moving documents through a translation process. This task assumes that for a given
locale defined in the task description, documents will be translated by an in-house
translator.
In the following example, a content author creates English documents that need to
be translated into one other language and published to a Web site. Following is a
description of all the task and its correct settings.
Translate: This is the document translation task. The Description must be set to
trans_internal: <comment to next performer><(locale)>. For example, trans_internal:
Translate to French (fr_FR). trans_internal tells WebPublisher that the documents will be
translated by an in-house translator. (fr_FR) tells WebPublisher that the documents in
the change set are going to be translated into French. The locale is especially important
because internally WebPublisher does not allow the original language files in the change
set to be translated. WebPublisher makes a copy of the original files and enables only the
copies to be translated. For example, if two English documents need to be translated
the trans_internal change set will contain four documents after translation, two English
original documents and two translated documents. WebPublisher will only display
two documents to the French translator not four documents. With this information,
WebPublisher determines which translation activity to run, and which documents to
display to the performer for translation.
TM
9–8 Customizing Documentum WebPublisher
Creating Process Workflows and Lifecycles
trans_external task
A trans_external task integrates with a process workflow created for the specific use of
moving documents through a translation process. This type of workflow assumes all
translations will be completed by an outside translator.
The trans_external task indicates that documents will be sent outside the company
to be translated. The process workflow calls Documentum Engagement Services
to start an email process through which documents can be emailed to the outside
translator. To begin this process you need to change the workflow performer method
in the Translate task and associate the task with the automatic performer method
wcmSendTranslationViaSmtp.
TM
Customizing Documentum WebPublisher 9–9
Creating Process Workflows and Lifecycles
Translate: This is the document translation task. The Description must be set to
trans_external: <comment to next performer><(locale)>. For example, trans_external:
Translate to German (de_De). trans_external tells WebPublisher that the documents will
be translated by an outside translator so an email process needs to be launched. (de_De)
tells WebPublisher which documents in the change set are going to be translated into
German. The locale is especially important because internally WebPublisher does not
allow the original language files in the change set to be translated. WebPublisher makes
a copy of the original files and enables only the copies to be translated. For example, if
two English documents need to be translated the trans_external change set will contain
four documents after translation, two English original documents and two German
documents. With this information, WebPublisher determines which translation activity
to run, and which documents to display to the performer for translation.
TM
9–10 Customizing Documentum WebPublisher
Creating Process Workflows and Lifecycles
The workflow template properties can link to a default alias set. If there is no alias
set linked, WebPublisher takes a global alias set defined for the application named
TranslatorEmailAddress. The TranslatorEmailAddress alias set provides translator email
addresses for each language code. The email addresses tell WebPublisher where to send
the documents for translation given the different language codes Following is a table of
some language code and email address examples.
Fr_CA cafrench@translationsource.com
Fr_FR translations@francais.com
de_DE translations@greatgerman.com
Receive Translation: This task follows an external translation task and is a manual task
with a defined trigger. You can give the trigger any applicable name. This task appears
in a performer’s inbox when the translations are received from an external source
through email, and after the engagement server and a server method finish processing
the received files.
trans_launch_wf task
TM
Customizing Documentum WebPublisher 9–11
Creating Process Workflows and Lifecycles
Translate: This is the document translation task. The Description must be set
to trans_launch_wf: <comment to next performer><(locale)>. For example,
trans_launch_wf: Launch Translation Workflow (fr_FR). trans_launch_wf tells
WebPublisher that a translation task needs to be launched to translate the documents
by another workflow. (fr_FR) tells WebPublisher which translation task to launch. With
this information, WebPublisher determines which translation activity to run, and which
documents to display to the translator.
TM
9–12 Customizing Documentum WebPublisher
Creating Process Workflows and Lifecycles
Engagement Services
If you have properly installed Engagement Services the machine on which Engagement
Services is installed and running should have the file esclient.jar in the classpath where
eContent server is running.
If you have properly configured Engagement Services you can send and recieive email.
Test the following three scenarios to pinpoint the issue as eContent server related or
WebPublisher related.
• test esupload.htm to make sure it works
• send email to Engagement Services and make sure it works
TM
Customizing Documentum WebPublisher 9–13
Creating Process Workflows and Lifecycles
WebPublisher Configuration
The WebPublisher default DocApp automatically configures WebPublisher to work with
Engagement Services. If you have created a custom DocApp you might not have created
the correct components to interact with Engagement Services. If you run into translation
workflow problems you can check WebPublsiher’s configuration to ensure that the
DocApp was created and installed correctly.
• check if the Engagement Services host address is entered in the WebPublisher System
configuration
The host address should not contain port numbers. For example,
eng999.documentum.com NOT eng999.documentum.com:9999
• check to ensure the TranslatorEmailAddress alias set was installed with the DocApp
You must have valid email entries defined in the translator email alias sets for your
translation locales. You can define these email entries in Documentum Administrator
or Documentum Developer Studio.
TM
9–14 Customizing Documentum WebPublisher
Creating Process Workflows and Lifecycles
For further troubleshooting information you can view the Server Logs which
records Engagement Services integration activities. You can view the server
logs under Menu>Logs in Documentum Administrator, or you can navigate to
c:\documentation\dba\log.
TM
Customizing Documentum WebPublisher 9–15
Creating Process Workflows and Lifecycles
/**
* @param String wfTemplateId - user selected workflow template id
* @param String aliasName - alias name
* @param int aliasType - alias type (use static variable
defined in interface class
* public static final int UNKNOW_ALIAS = 0;
* public static final int USER_ONLY = 1;
* public static final int GROUP_ONLY = 2;
* public static final int USER_OR_GROUP = 3;
* public static final int CABINET_PATH = 4;
* public static final int FOLDER_PATH = 5;
* public static final int ACL_NAME = 6;
* @return string[] performerList performers’ name
- please look at sample below.
* If the performer is the default selection,
then the value is [default]name.
* public static final String DEFAULT_ALIAS = "[default]";
*/
TM
9–16 Customizing Documentum WebPublisher
Creating Process Workflows and Lifecycles
/**
* Give a list of groups based on workflow template and activity name
* @param wfTemplateId workflow template ID
* @param activityName activity name which performer need to be assigned
* @return String[] group list
*/
public String[] getDynamicGroups(String wfTemplateId, String activityName)
{
String str[]= {"content author", "content manager",
"web developer", "administrator"};
return str;
}
} // class FilterWFPerformers
TM
Customizing Documentum WebPublisher 9–17
Creating Process Workflows and Lifecycles
d. Choose File>Save.
TM
9–18 Customizing Documentum WebPublisher
Chapter 10
Creating a Web Site
This chapter examines the creation of a WebPublisher managed Web site and the installation of the
Accelera DocApp to numerous Docbases. The Accelera DocApp should already be installed to
your test WebPublisher Docbase. Please refer to Installing WebPublisher for instructions to install
the Accelera DocApp.
Creating a Web site brings all your WebPublisher customization knowledge together so you can
create and manage a Web site that is specific to your company’s business processes and look and feel.
You will learn how to design a Web page using customized WebPublisher Editor templates, and a
customized DocApp of components such as object types, lifecycles and permission sets. You will learn
how to install the DocApp, and create new content for the Web page using your customized XML
components such as the IMPORT page, and PROPERTIES page.
To help you understand how the Web page components work together Documentum has created a
sample Web site for Accelera Communications a fictional company. This sample Web site presents
information for different cellular phones and cellular phone services, and company press releases.
The Web site includes:
• product name
• product number
• product price
• product image selector
• product description
• product benefits
The sample Web site contains an XML and HTML example of the Editor rules file and content
template, and an XSL example of the Editor presentation file.
Note: You should have a base knowledge of XML, XSL, HTML, and Web page creation methodology.
TM
Customizing Documentum WebPublisher 10–1
Creating a Web Site
customize through WebPublisher Editor templates and files. The default WebPublisher
Editor consists of four different types of templates and files that work together.
• Editor rules file
• Editor presentation file
• thumbnail file (optional)
• content template
The files provide the layout and other non-content related elements (such as JavaScript
code) used in a Web page. Web developers create WebPublisher files in any appropriate
authoring application (Dreamweaver, FrontPage, Notepad). Web developers can also
manually import files that were not created in Dreamweaver into the Docbase (or
DocApp if you want to deploy the files to multiple Docbases). When the DocApp is
installed to the Docbase, the files are also installed.
Templates are the files upon which content files are based. When an author chooses a
template, WebPublisher makes a copy of the template and saves it as a new content file.
The content file inherits the template’s content and properties.
Supporting files include Editor rules files and thumbnail files, both of which define
behaviors within WebPublisher. In order to be used with a template, a supporting file
must be associated with the template.
You create templates and supporting files in external applications, and then import them
into WebPublisher’s Configuration cabinet.
The content template and Editor rules file work together to enable authors to enter
content in WebPublisher Editor. The content file, in to which authors enter information,
and Editor presentation file work together to display content on a Web page. The
thumbnail file enables a graphical representation of a template. Refer to Using
WebPublisher Pro for more information about using WebPublisher the templates and files,
and Chapter 10, Creating a Web Site for an example Web page.
Web developers create templates in any appropriate authoring application (FrontPage,
Notepad) and import them in to a Docbase (or DocApp if you want to deploy the
templates to multiple Docbases).
When the DocApp is installed to the Docbase, templates are also installed.
Once the files are installed, Web developers can check out files, work on files in the
editing application, and check in and version the files.
TM
10–2 Customizing Documentum WebPublisher
Creating a Web Site
TM
Customizing Documentum WebPublisher 10–3
Creating a Web Site
When creating tagcontent widgets for non-XML WebPublisher Editor templates (e.g.
HTML-based templates), place the following tag in the file where you want the data to
be stored:
<dctmEditor teComponentType="myelement">default data
</dctmEditor>
The rules file would read:
<tagcontent tag_name="myelement"></tagcontent>
While we recommend using the <dctmEditor> tag for all non-attribute WebPublisher
Editor tags within HTML-based templates, we strongly recommend using the
<dctmEditor> tag whenever the widget referred to in the rules file is a content widget.
Specifically, because of the possibility of improper nesting, do not add the
teComponentType attribute to any other type of tag the content widget itself produces
(especially tags like <b>, <font>, <p> etc.).
Note: If you use a tagattribute widget, put teComponentType in the tag where you
want the attribute to be stored, as before:
<img border="0" teComponentType="myelement">
The rules file would read:
<tagattribute tag_name="myelement" selected_attr="src">
</tagattribute>
<textline>
The <textline> element creates a single-line text field. The <textline> element is nested in
the <tagcontent> or <tagattribute> element.
TM
10–4 Customizing Documentum WebPublisher
Creating a Web Site
TM
Customizing Documentum WebPublisher 10–5
Creating a Web Site
<content>
The <content> element creates a multi-line text box with an editing toolbar. The
<content> element is nested. If you are creating a rules file for a non-XML template, see
When Creating Non-XML Templates, page 10–14.
TM
10–6 Customizing Documentum WebPublisher
Creating a Web Site
If omitted, WebPublisher
Editor defaults to ’N’.
If omitted, WebPublisher
Editor defaults to ’N’.
<FONT color=
’#FFFFFF’>what the user
typed</FONT>
TM
Customizing Documentum WebPublisher 10–7
Creating a Web Site
TM
10–8 Customizing Documentum WebPublisher
Creating a Web Site
<BLOCKQUOTE><P>what
the user typed</P></
BLOCKQUOTE>
If omitted, WebPublisher
Editor defaults to ’N’.
If omitted, WebPublisher
Editor defaults to ’N’.
TM
Customizing Documentum WebPublisher 10–9
Creating a Web Site
If omitted, WebPublisher
Editor defaults to ’N’.
TM
10–10 Customizing Documentum WebPublisher
Creating a Web Site
TM
Customizing Documentum WebPublisher 10–11
Creating a Web Site
TM
10–12 Customizing Documentum WebPublisher
Creating a Web Site
If omitted, WebPublisher
Editor defaults to ’N’.
TM
Customizing Documentum WebPublisher 10–13
Creating a Web Site
The WebPublisher Editor contains a spell checker function which is currently using an
English dictionary. To incorporate dictionaries for your supported languages you must
purchase a dictionary license from Wintertree Software, Inc. for each supported language.
The dictionary license enables you to include the dictionaries with WebPublisher.
The Microsoft Interent Explorer editor contains five language dictionaries—English
(US), German, French, Italian and Spanish. The Netscape editor contains one language
dictionary—English (US). The default language dictionary in both cases is English
(US). If the language part of the locale of the file being edited in WebPublisher Editor
matches any of the bundled dictionaries, then that dictionary displays when spellcheck
is invoked. For example, if the file has a locale of fr_CA (French - Canadian). The fr
stands for language French, so the French dictionary file is used. If the file has a locale of
ja_JP (Japanese - Japan). There is no Japanese dictionary file, so the default dictionary file
of English (US) is used.
If you are using Microsoft Internet Explorer you can purchase a Wintertree Software
dictionary and add it to the app\wintertree\ssce folder. If you are using Netscape
you can purchase a Wintertree Software dictionary and modify your te.jar file to
contain the additional dictionaries. You can also modify your dictionary.htm file to
include additional dictionaries. Please refer to Localizing Documentum WebPublisher for
more information on language values and modifying the te.jar file, and Documentum
Technical Support for more information on modifying the dictionary.htm file.
When creating content fields for non-XML templates (for example, for HTML templates),
place the following tag in the content file at the point where you want the content to
be stored:
<dctmEditor teComponentType="my_element">content to
be stored</dctmEditor>
The value you enter for my_element is read by the rules file as a tag name. The rules file
refers to my_element as follows:
<tagcontent tag_name="my_element">
While we recommends using the dctmEditor tag for all non-attribute WebPublisher
Editor tags within HTML-based templates, we strongly recommend using the dctmEditor
tag whenever the field referred to in the rules file is a content field. Specifically, because
of the possibility of improper nesting, do not add the teComponentType attribute to
any other type of tag the content field itself produces (especially tags like <b>, <font>,
and <p>.
If you use tagattribute, put teComponentType in the tag where you want the attribute to
be stored, as before:
<img border="0" teComponentType="my_attribute">
TM
10–14 Customizing Documentum WebPublisher
Creating a Web Site
Any data from the content field that is stored in the XML will contain HTML paragraph
tags, like this:
<P>what the user typed</P>
Any additional formatting, such as bold or ordered lists, is stored as HTML tags within
the <P> the tags. You must process these elements via your XSL file in order for the text
to display. If you do not, your authors might think WebPublisher is "broken".
<choice>
The <choice> element creates a selection list. You can use a query to populate the list.
The <choice> element is nested in the <tagcontent> or <tagattribute> element.
If omitted, WebPublisher
Editor collapses the space
normally reserved for the
label.
TM
Customizing Documentum WebPublisher 10–15
Creating a Web Site
TM
10–16 Customizing Documentum WebPublisher
Creating a Web Site
If omitted, WebPublisher
Editor defaults to ’N’.
<graphic>
The <graphic> element displays either a list or a navigation tree that allows authors to
select graphics. You can specify a query to populate the list. WebPublisher displays a
scaled-down version of the graphic in the preview box, unless a thumbnail is available.
The <graphic> element is nested in the <tagcontent> or <tagattribute> element.
TM
Customizing Documentum WebPublisher 10–17
Creating a Web Site
TM
10–18 Customizing Documentum WebPublisher
Creating a Web Site
TM
Customizing Documentum WebPublisher 10–19
Creating a Web Site
TM
10–20 Customizing Documentum WebPublisher
Creating a Web Site
TM
Customizing Documentum WebPublisher 10–21
Creating a Web Site
This attribute is
only applicable if
query_type=’query’ and
import=’Y’; it is ignored if
query_type=’tree’. If omitted,
WebPublisher Editor silently
fails the import, since it has to
place to put the imported file.
TM
10–22 Customizing Documentum WebPublisher
Creating a Web Site
TM
Customizing Documentum WebPublisher 10–23
Creating a Web Site
If output_format is specified,
then the Editor will look up
the publishing convention
for the specified format and
store that name in the XML.
For example, if the graphic
’graphic.gif’ is stored in a
folder called ’images’ in
the ’Website’ cabinet, and
output_property=’jpeg_lres’,
the following will be
stored in the XML:
/images/graphic_lres.jpg.
If omitted, the Editor stores
the name of the primary
rendition.
TM
10–24 Customizing Documentum WebPublisher
Creating a Web Site
TM
Customizing Documentum WebPublisher 10–25
Creating a Web Site
TM
10–26 Customizing Documentum WebPublisher
Creating a Web Site
/Cabinet/Press/2000/
release.xml
/Cabinet/Images/
Corporate/image.gif
/Images/Corporate/
image.gif.
../../Images/Corporate/
image.gif
This attribute is
only applicable if
output_property=’folderPath’.
If omitted, WebPublisher
Editor defaults to ’N’.
TM
Customizing Documentum WebPublisher 10–27
Creating a Web Site
TM
10–28 Customizing Documentum WebPublisher
Creating a Web Site
<textselector>
The <textselector> element displays either a list or a navigation tree that allows authors
to select boilerplate text. You can specify a query to populate the list. The <textselector>
element is nested.
TM
Customizing Documentum WebPublisher 10–29
Creating a Web Site
This attribute is
only applicable if
query_type=’query’ and
import=’Y’; it will be ignored if
query_type=’tree’. If omitted,
no navigational path will be
assigned, and the imported
file will not be visible when
the author browses through
the EDIT PAGE navigational
structure.
TM
10–30 Customizing Documentum WebPublisher
Creating a Web Site
TM
Customizing Documentum WebPublisher 10–31
Creating a Web Site
TM
10–32 Customizing Documentum WebPublisher
Creating a Web Site
If omitted, WebPublisher
Editor collapses the space
normally reserved for
instructions.
TM
Customizing Documentum WebPublisher 10–33
Creating a Web Site
TM
10–34 Customizing Documentum WebPublisher
Creating a Web Site
TM
Customizing Documentum WebPublisher 10–35
Creating a Web Site
If output_property=’contents’,
the actual contents of the file
itself will be stored in the
XML. Note that this may cause
problems if the contents of
the file contain data that is
not well-formed XML, so be
sure to point to text fragments
that are safe. Please also note
ouput_property=’contents’
will only be honored if the
textselector element is within
a <tagcontent>, because it is
too problematic to put the
contents of a file within an
attribute.
If output_property=’ID’,
the Documentum ID of the
selected object will be stored in
the XML. ID is only supported
when query_type=query.
If omitted, WebPublisher
Editor defaults to ’folderPath’
in a <tagattribute> rule, and
defaults to ’contents’ in a
<tagcontent> rule.
TM
10–36 Customizing Documentum WebPublisher
Creating a Web Site
If omitted, WebPublisher
Editor defaults to ’5’.
TM
Customizing Documentum WebPublisher 10–37
Creating a Web Site
If omitted, WebPublisher
Editor defaults to ’query’.
TM
10–38 Customizing Documentum WebPublisher
Creating a Web Site
If omitted, WebPublisher
Editor defaults to ’N’.
/Cabinet/Press/2000/
release.xml
/Cabinet/Includes/
Corporate/copyright.txt
/Includes/Corporate/
copyright.txt
../../Includes/Corporate/
copyright.txt
This attribute is
only applicable if
output_property=’folderPath’.
If omitted, WebPublisher
Editor defaults to ’N’.
TM
Customizing Documentum WebPublisher 10–39
Creating a Web Site
required If set to Yes, the author will not ’Y’ or ’N’ required=’Y’
be able to save until a text file
has been selected. The field is
marked with a red star.
TM
10–40 Customizing Documentum WebPublisher
Creating a Web Site
<checkbox>
The <checkbox> element gives an author a choice. Clicking the checkbox chooses the
option it offers. The <checkbox> element is nested in the <tagcontent> or <tagattribute>
element.
TM
Customizing Documentum WebPublisher 10–41
Creating a Web Site
If omitted, WebPublisher
Editor collapses the space
normally reserved for
instructions.
If omitted, WebPublisher
Editor collapses the space
normally reserved for the
label.
TM
10–42 Customizing Documentum WebPublisher
Creating a Web Site
The <tabledef> element defines a table with a fixed number of columns. The <tabledef>
element requires you to replicate the structure of an HTML table within your XML. Each
cells contains a WebPublisher Editor field, which means that after the table rule you enter
rules to associate each field with an element in the content file. The number of columns
is fixed, but authors can create, delete and move rows.
TM
Customizing Documentum WebPublisher 10–43
Creating a Web Site
TM
10–44 Customizing Documentum WebPublisher
Creating a Web Site
You can make a set of fields repeatable using the <repeatdef> element. After the
<repeatdef> rule, you define additional rules for each repeatable field. Authors
determine how many times the set of fields appears on the Web page. Repeatable fields
are used when it is up to the author to determine how often a certain type of information
appears. For example, on a page that lists Frequently Asked Questions, the number of
questions can vary.
When creating an Editor rules file for an HTML-based WebPublisher Editor template, do
not include the <repeatdef> element. WebPublisher will not recognize the <repeatdef>
element for an HTML-based content file.
TM
Customizing Documentum WebPublisher 10–45
Creating a Web Site
TM
10–46 Customizing Documentum WebPublisher
Creating a Web Site
<reported_by/>
<related_issue/>
correct: tag_list=
’FAQ,reported_by’
incorrect: tag_list=
’FAQ,answer’ (not on the
same level)
incorrect: tag_list=
’FAQ,related_issue’ (not
contiguous)
TM
Customizing Documentum WebPublisher 10–47
Creating a Web Site
<xselector>
Currently, the <graphic> and <textselector> elements enable a user either to select from
the results of one pre-defined query or to navigate down a folder hierarchy from one
or more “root” folders. These elements also show the displayed graphic/text item plus
the list of available items. If the query returns many values, this can have performance
implications. The <xselector> element provides more extended functionality that is
useful when your users need the ability to sift through a large quantity of images or
other filetypes. To increase performance, when a content file is initially opened in
WebPublisher Editor, the xselector will only display the selected graphic/text item. The
user must click a button to open a file selection dialog box. In addition, the xselector
allows for the WebPublisher template developer to specify multiple queries from which
the user can select. The queries can either be full queries, which do not depend upon
values selected by the user, or the queries can include values from users. For example,
in the same xselector element, you could set up one query that would display all
images of a particular format, and another query that would display all images with a
particular language code. In the first query, the user could select different formats from
a criteria pulldown, so that the user could see all the jpeg images first, and then all of
the gif images. In the second query, the user could select different languages and then
run the query.
The <xselector> element also provides pagination. That is, it can display a maximum
number of query results at a time. This is useful when a query returns a large number
of items.
Note: Currently, the xselector does not support the selection of a file that is not within
the same delivery cabinet as the content file itself. If a file is selected that is not in the
same delivery cabinet, problems may occur such as: the next time the content file is
opened, the selected file may not appear to be selected, or the next time the content
file is opened, even if the file appears to be selected, the wrong data is stored in the
content file. Therefore, please be very careful to create filter queries that return files in
the same delivery cabinet.
TM
10–48 Customizing Documentum WebPublisher
Creating a Web Site
If auto_exec_NAME_
OF_FILTER=’Y’, the
query is executed
as soon as the user
selects the filter. If
’N’, the user must
press the Go button to
initiate the query.
If the corresponding
query_NAME_OF_
FILTER contains the
keyword {user.entry},
then this option will
be ignored, since the
query depends on
input from the user.
TM
Customizing Documentum WebPublisher 10–49
Creating a Web Site
If the corresponding
query_NAME_OF_
FILTER does not
contain the keyword
{user.entry}, then the
specified criteria
values will not
display.
TM
Customizing Documentum WebPublisher 10–51
Creating a Web Site
TM
10–52 Customizing Documentum WebPublisher
Creating a Web Site
If enable_locale_
fallback=’N’, all
matching files will be
displayed, regardless
of language. If ’Y’, the
Editor will determine
the language of
the content file
being edited, and
when displaying the
query results will
only display the
translation that is
being published to the
same language web
site as the content
file (according to
fallback rules). For
example, suppose you
have two graphics:
graphic1 has only an
English translation,
and graphic2 has
both an English and
German translation.
Suppose the user
is editing a English
content file. If enable_
locale_fallback=’N’,
then three files
will be displayed:
graphic1, graphic2
[English], graphic2
[German]--and the
user may be unable to
tell them apart.
TM
Customizing Documentum WebPublisher 10–53
Creating a Web Site
If omitted, the
WebPublisher Editor
displays nothing.
TM
10–54 Customizing Documentum WebPublisher
Creating a Web Site
TM
Customizing Documentum WebPublisher 10–55
Creating a Web Site
TM
10–56 Customizing Documentum WebPublisher
Creating a Web Site
If output_format
is specified, then
the Editor will look
up the publishing
convention for the
specified format
and store that name
in the XML. For
example, if the
graphic ’graphic.gif’
is stored in a folder
called ’images’ in the
’Website’ cabinet, and
output_property=
’jpeg_lres’, the
following will be
stored in the XML:
/images/graphic_
lres.jpg.
This option is
only available if
select_type=’graphic’.
It will be ignored if
select_type=’text’.
TM
Customizing Documentum WebPublisher 10–57
Creating a Web Site
If omitted, the
Editor defaults to
’folderPath’.
TM
10–58 Customizing Documentum WebPublisher
Creating a Web Site
If omitted, the
Editor will return
the Documentum
attribute ’object_
name’ by default.
TM
Customizing Documentum WebPublisher 10–59
Creating a Web Site
If omitted, the
attribute specified
in the ’property’
attribute will be
used (by default,
object_name).
TM
10–60 Customizing Documentum WebPublisher
Creating a Web Site
If omitted,
WebPublisher Editor
defaults to ’N’.
TM
Customizing Documentum WebPublisher 10–61
Creating a Web Site
/Cabinet/Press/
2000/release.xml
/Cabinet/Includes/
Corporate/
copyright.txt
If relative=’No’, then
this will be stored in
the XML:
/Includes/
Corporate/
copyright.txt
If relative=’Yes’, then
this will be stored in
the XML:
../../Includes/
Corporate/
copyright.txt
This attribute is
only applicable if
output_property=
’folderPath’.
If omitted,
WebPublisher Editor
defaults to ’N’.
TM
10–62 Customizing Documentum WebPublisher
Creating a Web Site
If select_type=’text’,
the attribute
’output_format’ will
not be applicable.
<texttrigger>
TM
Customizing Documentum WebPublisher 10–63
Creating a Web Site
XML Examples
The Editor rules file is an XML file or an HTML file with an XSL wrapper that defines
how the elements in the content template display in WebPublisher Editor. You can code
each piece of your WebPublisher Editor by modifying the Editor rules file using an
external editor or Documentum’s Rules Editor.
The following procedures explain the creation of an Editor rules file
(prod_detail_xml_rules.xml) using an external editor. Refer to Using WebPublisher Pro for
information about the Rules Editor. This Editor rules file is provided with the sample
Web site. Tags that are used in the prod_detail_xml_rules.xml file are tags that are most
common. A comprehensive list of the tags you can use in the Editor rules file appears in
the sections above.
TM
10–64 Customizing Documentum WebPublisher
Creating a Web Site
readonly=’N’
/>
</tagcontent>
Do not use the < or > symbols in your values attribute. The use of these symbols will
cause an error in your XML file.
3. Choose File>Save.
This code should translate into the following widget in WebPublisher Editor.
3. Choose File>Save.
This code should translate into the following widget in WebPublisher Editor.
TM
Customizing Documentum WebPublisher 10–65
Creating a Web Site
required=’N’
readonly=’N’
/>
</tagcontent>
3. Choose File>Save.
This code should translate into the following widget in WebPublisher Editor.
4. Choose File>Save.
This code should translate into the following widget in WebPublisher Editor.
TM
10–66 Customizing Documentum WebPublisher
Creating a Web Site
3. Choose File>Save.
This code should translate into the following widget in WebPublisher Editor.
TM
Customizing Documentum WebPublisher 10–67
Creating a Web Site
<repeatdef
<tag_name="repeat"
label=’Benefits of the phone’
instruction=’Add each benefit individually. The recommended maximum
number is 10.’
tag_list=’BENEFIT’
</repeatdef>
<!--
<tagcontent tag_name=’BENEFIT’>
<textline
label=’Benefit’
required=’N’
readonly=’N’
/>
</tagcontent>
<repeatdef
<tag_name="repeat"
label=’Benefits of the phone’
instruction=’Add each benefit individually. The recommended maximum
TM
10–68 Customizing Documentum WebPublisher
Creating a Web Site
number is 10.’
tag_list=’BENEFIT’
</repeatdef>
-->
3. Choose File>Save.
This code should translate into the following widget in WebPublisher Editor.
Your final XML Editor rules file should look like the following.
<rules>
<tagcontent tag_name=’TITLE’>
<textline
label=’Product Title’
instruction=’This must be typed exactly as it appears in the Product Title
attribute of this file.’
required=’N’
readonly=’N’
/>
</tagcontent>
<tagcontent tag_name="PRODUCTNUMBER">
<textline
label=’Product Number’
instruction=’This must be typed exactly as it appears in the Product Number
attribute of this file.’
required=’N’
readonly=’N’
/>
</tagcontent>
<tagcontent tag_name=’PRICE’>
<textline
label=’Price’
instruction=’Enter the price in US dollars, like this: $###.##’
required=’N’
readonly=’N’
/>
</tagcontent>
<tagcontent tag_name=’GRAPHIC’>
TM
Customizing Documentum WebPublisher 10–69
Creating a Web Site
<graphic
label=’Product image’
instruction="Select one of the available product images, or import your own.’
required=’N’
readonly=’N’
rows=’5’
query_type=’query’
query="dm_document where folder(’/accelera.com/prod_detail/ph_images’)"
property=’object_name’
output_property=’folderPath’
relative=’N’
import=’Y’
location=’/accelera.com/prod_detail/ph_images’
type=’dm_document’
/>
</tagcontent>
<tagcontent tag_name=’DESCRIPTION’>
<content
label=’Description of the product’
instruction="Try not to duplicate information here and in the benefits.
Be sure to spell check!’
required=’N’
readonly=’N’
lines=’10
bold=’Y’
italic=’N’
color=’N’
spellcheck=’Y’
fontSize=’N’
indent=’Y’
orderedLists=’Y’
unorderedLists=’Y’
align=’N’
links=’N’
symbols=’Y’
/>
</tagcontent>
<tagcontent tag_name=’BENEFIT’>
<textline
label=’Benefit’
required=’N’
readonly=’N’
/>
</tagcontent>
TM
10–70 Customizing Documentum WebPublisher
Creating a Web Site
<repeatdef
<tag_name="repeat"
label=’Benefits of the phone’
instruction=’Add each benefit individually. The recommended maximum number is 10.’
tag_list=’BENEFIT’
</repeatdef>
<!--
<tagcontent tag_name=’BENEFIT’>
<textline
label=’Benefit’
required=’N’
readonly=’N’
/>
</tagcontent>
<repeatdef
<tag_name="repeat"
label=’Benefits of the phone’
instruction=’Add each benefit individually. The recommended maximum number is 10.’
tag_list=’BENEFIT’
</repeatdef>
-->
</rules>
Once you have created the Editor rules file you must import it into WebPublisher.
<PAGE>
<PRODUCT>
</PRODUCT>
TM
Customizing Documentum WebPublisher 10–71
Creating a Web Site
</PAGE>
3. Choose File>Save.
3. Choose File>Save.
3. Choose File>Save.
TM
10–72 Customizing Documentum WebPublisher
Creating a Web Site
$199.00
</PRICE>
3. Choose File>Save.
3. Choose File>Save.
3. Choose File>Save.
TM
Customizing Documentum WebPublisher 10–73
Creating a Web Site
3. Choose File>Save.
The completed XML content template should look like the following
<?xml version="1.0" ?>
<PAGE>
<PRODUCT>
<TITLE>
Name of the Phone
</TITLE>
<PRODUCTNUMBER>
Product Number for the phone
</PRODUCTNUMBER>
<GRAPHIC>
</GRAPHIC>
<PRICE>
$199.00
</PRICE>
<DESCRIPTION>
Summary of the phone
</DESCRIPTION>
<DETAIL>
<BENEFIT>
A benefit of the phone
</BENEFIT>
<BENEFIT>
Another benefit
</BENEFIT>
<BENEFIT>
etc.
</BENEFIT>
</DETAIL>
<PROD_TYPE>
phone
</PROD_TYPE>
</PRODUCT>
</PAGE>
HTML Procedure
The HTML content template is more difficult than the XML content template. Below are
the guidelines to produce an HTML content template of the same information used in
the XML content template.
TM
10–74 Customizing Documentum WebPublisher
Creating a Web Site
3. Choose File>Save.
To create a product number, price, image, description, benefits and type element:
This section of the code enables you to create a number, price, image, description,
benefits list and type for the product.
1. Open the content template, prod_detail_external_app_###.xml in a text editor such
as Notepad.
2. Type the following code after the start tag.
<TR>
<td width="88" valign="TOP"><img teComponentType="GRAPHIC"
src="" border="0" />
<p><br/> <br/> </p>
<p>
<b><WPEDITOR teComponentType="PRODUCTNUMBER">Product Number
for the phone</WPEDITOR></b>
<br/>
<span class="title"><WPEDITOR teComponentType="PRICE">$199.00
</WPEDITOR></span>
<br/>
<a href="#"><img src="../images/buy_btn.gif" border="0" height="13"
width="45"/></a>
</p>
TM
Customizing Documentum WebPublisher 10–75
Creating a Web Site
</td>
<td valign="TOP" width="558">
<b class="largetitle"><WPEDITOR teComponentType="TITLE">Name of the Phone
</WPEDITOR></b><br/>
<img src="../images/dots_300.gif" border="0" height="8" width=
"300"/><br/>
<WPEDITOR teComponentType="DESCRIPTION">
<P>Summary of the phone</P>
</WPEDITOR>
<p> <br/> </p>
<WPEDITOR teComponentType="DETAIL">
<P>
<UL>
<LI>A benefit</LI>
<LI>Another benefit</LI>
<LI>etc.</LI>
</UL>
</P>
</WPEDITOR>
</td>
</TR>
3. Choose File>Save.
The completed HTML content template should look like the following
<html>
<head>
<title>Accelera Communications Product List</title>
<link HREF="../style.css" TYPE="text/css" REL="stylesheet"/>
</head>
TM
10–76 Customizing Documentum WebPublisher
Creating a Web Site
</TD>
</TR>
<TR>
<TD VALIGN="BOTTOM" >
<!--#INCLUDE FILE="/fragments/footer.incl"-->
</TD>
</TR>
</TABLE>
</BODY>
</html>
TM
Customizing Documentum WebPublisher 10–77
Creating a Web Site
<xsl:template match="*|@*|comment()|processing-instruction()|text()">
<xsl:copy>
<xsl:apply-templates select="*|@*|comment()|processing-instruction()|text()"/>
</xsl:copy>
</xsl:template>
<xsl:template match="PAGE">
<xsl:text disable-output-escaping="yes">
<![CDATA[
<head>
<title>Accelera Communications Product List</title>
TM
10–78 Customizing Documentum WebPublisher
Creating a Web Site
]]>
</xsl:text>
<xsl:text disable-output-escaping="yes">
<![CDATA[
</TD>
</TR>
<TR>
<TD VALIGN="BOTTOM" >
<!--#INCLUDE FILE="/fragments/footer.incl"-->
</TD>
</TR>
</TABLE>
</BODY>
</html>
3. Choose File>Save.
TM
Customizing Documentum WebPublisher 10–79
Creating a Web Site
<TR>
<td valign="TOP" width="88">
<xsl:apply-templates select="GRAPHIC"/>
<p><br/> <br/> </p>
<p>
<b><xsl:value-of select="PRODUCTNUMBER"/></b> <br/>
<span class="title"><xsl:value-of select="PRICE"/></span> <br/>
<a href="#"><img width="45" height="13" border="0"
src="../images/buy_btn.gif"/></a>
</p>
</td>
<td width="558" valign="TOP">
<b class="largetitle"><xsl:value-of select="TITLE"/></b> <br/>
<img width="300" height="8" border="0" src="../images/dots_300.gif"/><br/>
<xsl:apply-templates select="DESCRIPTION"/>
<p> <br/> </p>
<xsl:apply-templates select="DETAIL"/>
</td>
</TR>
</TABLE>
</xsl:template>
3. Type the following code to build the image area of your Web page.
The image is variable enabling it to change to match the content file.
<xsl:template match="GRAPHIC">
<xsl:if test=’string()’>
<img border="0" src="{.}"/>
</xsl:if>
</xsl:template>
4. Type the following code to build the description area of your Web page.
The product description is a variable because it is a link to changing information to
match the content file.
<xsl:template match="DESCRIPTION">
<xsl:apply-templates/>
</xsl:template>
5. Type the following code to build the detail area of your Web page.
The product detail is variable because it is repeating information to match the
content file.
<xsl:template match="DETAIL">
<ul>
<xsl:apply-templates />
</ul>
</xsl:template>
TM
10–80 Customizing Documentum WebPublisher
Creating a Web Site
6. Type the following code to build the benefiit areas of your Web page.
The product benefits are variable because they change to match the content file.
<xsl:template match="BENEFIT">
<li>
<xsl:apply-templates />
</li>
</xsl:template>
7. Choose File>Save.
3. Choose File>Save.
The final Editor presentation should look something like the following. The HTML
section will match your HTML code.
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output method="html" />
<xsl:strip-space elements="*"/>
<xsl:template match="*|@*|comment()|processing-instruction()|text()">
<xsl:copy>
<xsl:apply-templates select="*|@*|comment()|processing-instruction()|text()"/>
</xsl:copy>
</xsl:template>
<xsl:template match="PAGE">
<xsl:text disable-output-escaping="yes">
<![CDATA[
<html>
<head>
<title>Accelera Communications Product List</title>
<link HREF="../style.css" TYPE="text/css" REL="stylesheet">
</head>
TM
Customizing Documentum WebPublisher 10–81
Creating a Web Site
]]>
</xsl:text>
<xsl:text disable-output-escaping="yes">
<![CDATA[
</TD>
</TR>
<TR>
<TD VALIGN="BOTTOM" >
<!--#INCLUDE FILE="/fragments/footer.incl"-->
</TD>
</TR>
</TABLE>
</BODY>
</html>
]]>
</xsl:text>
</xsl:template>
<xsl:template match="PRODUCT">
<TABLE WIDTH="99%" CELLSPACING="20" CELLPADDING="0" BORDER="0">
<TR>
<td valign="TOP" width="88">
<xsl:apply-templates select="GRAPHIC"/>
<p><br/> <br/> </p>
<p>
<b><xsl:value-of select="PRODUCTNUMBER"/></b> <br/>
<span class="title"><xsl:value-of select="PRICE"/></span> <br/>
<a href="#"><img width="45" height="13" border="0"
TM
10–82 Customizing Documentum WebPublisher
Creating a Web Site
src="../images/buy_btn.gif"/></a>
</p>
</td>
<td width="558" valign="TOP">
<b class="largetitle"><xsl:value-of select="TITLE"/></b> <br/>
<img width="300" height="8" border="0" src="../images/dots_300.gif"/><br/>
<xsl:apply-templates select="DESCRIPTION"/>
<p> <br/> </p>
<xsl:apply-templates select="DETAIL"/>
</td>
</TR>
</TABLE>
</xsl:template>
<xsl:template match="GRAPHIC">
<xsl:if test=’string()’>
<img border="0" src="{.}"/>
</xsl:if>
</xsl:template>
<xsl:template match="DESCRIPTION">
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="DETAIL">
<ul>
<xsl:apply-templates />
</ul>
</xsl:template>
<xsl:template match="BENEFIT">
<li>
<xsl:apply-templates />
</li>
</xsl:template>
</xsl:stylesheet>
Once you have created the Editor presentation file you must import it into WebPublisher.
Refer to Using WebPublisherPro for more information on the Editor presentation file.
TM
Customizing Documentum WebPublisher 10–83
Creating a Web Site
template or another type of identifying icon. Thumbnails should be no more than 100 x
100 pixels.
TM
10–84 Customizing Documentum WebPublisher
Creating a Web Site
The Rules Editor performs some checking on the XML file to determine if the file is
created with well-formed XML If the file is well-formed then it opens in the Rules Editor.
If the file is not well-formed then a message opens telling you where the first error occurs.
The Rules Editor checks for errors and displays them one-by-one until all the errors are
fixed. Once the file is well-formed it the Rules Editor opens it for modification. Refer to
Using WebPublisherPro for more information on the importing the Editor rules file.
You can import the templates and files individually or you can import them into your
custom DocApp. If you import them into a custom DocApp you must then create a
DocApp archive to deploy the DocApp to each Docbase. Refer to Example DocApp
Customization, Chapter 2, Customization Overview, and Using WebPublisher Pro for more
information on importing templates and files, and packaging and deploying a DocApp
Validating Templates
Once you have imported the templates and files into a Docbase you must validate them
to ensure they are created correctly. Refer to Using WebPublisher Pro for more information
on validating templates.
Associating Templates
Once you have imported the templates and files into a Docbase you must associate the
content template with the supporting Editor rules, Editor presentation, and optional
thumbnail file so they will work together when you add new content. Refer to the Using
WebPublisher Pro for more information on associating templates.
Promoting Content
Once authors have added new content they can promote the content from WIP to Staging
so you can publish to a standard WIP Web site. Refer to the Using WebPublisher Pro for
more information on promoting content.
TM
Customizing Documentum WebPublisher 10–85
Creating a Web Site
TM
10–86 Customizing Documentum WebPublisher
Creating a Web Site
• procedure
— PreConfigureSampleWebSite
— PostConfigureSampleWebSite
• DataObject
— Accelera.com
— English (US) active
• Templates
Each template has different formats to illustrate the variety of options users have
when developing templates.
— press release template
Formats include XML/HTML, Word/HTML
— product template
Formats include XML/XSL, XML/HTML, HTML/HTML, Word/HTML
Note: Developing DocApps contains all the information you need to create a custom
DocApp. Follow the DocApp tutorial to begin your DocApp creation.
WebPublisher lifecycles and workflows contain states and tasks that are specific to
WebPublisher so you need to use the information in Chapter 9, Creating Process Workflows
and Lifecycles to create WebPublisher specific-lifecycles and workflows. Then package
and deploy the DocApp.
Below is a quick outline of where to find information.
Note: If you are creating a custom object type and attributes in the same Docbase in
which you intend to use them you do not need to create a DocApp. You only need to
create a DocApp if you want to copy the DocApp attributes from one Docbase to another.
• Creating a DocApp: Developing DocApps
• Describing the Documentum Developer Studio (DDS) interface: Developing DocApps
• Describing a custom DocApp: Developing DocApps
• Creating object types: Developing DocApps
• Creating alias sets and permission set templates: Developing DocApps
• Creating WebPublisher process workflows and lifecycles: Customizing Documentum
WebPublisher
• Testing your DocApp: Customizing Documentum WebPublisher
TM
Customizing Documentum WebPublisher 10–87
Creating a Web Site
You package a DocApp into an archive that you can deploy to other Docbases.
If you are reusing the DocApp and deploying it to another Docbase that services a
different set of users in your company, permission sets are of great value.
When you install the DocApp archive into a Docbase, you are prompted to provide
values (user names, groups, cabinets, or directories) for the aliases in your DocApp.
Use DDS to package your DocApp into an archive. Use DocApp Installer to install the
DocApp archive into the Docbase.
Note: When the instructions do not ask you to specify a value for a field or to select an
option, accept the default.
TM
10–88 Customizing Documentum WebPublisher
Creating a Web Site
7. If a message appears stating that there are connected users, click Yes to continue.
The Resolve Alias dialog box opens.
8. If you have not created the corresponding users, groups, and folders in the Docbase,
create them.
a. Use DDS to create the folders shown in the Group and Folder Alias table.
b. Use Documentum Administrator to create the users and groups shown in the
Docbase.
9. In the Resolve Alias dialog box, select the alias or folder in the Docbase as shown in
Group and Folder Alias table.
a. To find the appropriate folder, click the browse button, select the folder. Do not
double-click it to open it. Click Select.
b. Select the corresponding user or group from the drop-down list
10. Click OK.
After you have resolved all the aliases, the DocApp Installer installs the Accelera
DocApp archive. Any errors that occur are displayed in the Installation Status
window. Refer to the following section, Troubleshooting Your DocApp Installation
for information on DocApp installation errors.
The following table lists and describes the folders and users for the aliases in your
DocApp.
Name Description
Note: docbase_cabinet is the cabinet that has the same name as your Docbase.
If an error message appears stating that an alias already exists, it means that you have
aliases defined in your Docbase with the same name as one that you are trying to install.
TM
Customizing Documentum WebPublisher 10–89
Creating a Web Site
Use Documentum Administrator to delete the duplicate aliases and reinstall the DocApp.
Summary
TM
10–90 Customizing Documentum WebPublisher
Appendix A
Troubleshooting
This troubleshooting chapter provides you with information about common RightSite
and WebPublisher problems. Please read this section before you contact Documentum’s
Technical Support team. You may find the answers you need.
This chapter discusses the following topics:
• Working Around Memory Caching Issues
• Locating Docbasic Errors by Line Number
TM
Customizing Documentum WebPublisher A–1
Troubleshooting
For optimal performance you should not have these variable settings for your production
site.
TM
A–2 Customizing Documentum WebPublisher
Glossary
action list
A list of operations that users can perform on selected documents. The action list displays on the
right hand side of the WebPublisher window.
Active
In a default configuration the lifecycle status (state) of a file that is in use on one or more live
Web site(s).
administrator
The WebPublisher user or user group responsible for installing, customizing, and configuring
WebPublisher to meet specific organizational requirements. An administrator will use other
Documentum products to customize and configure WebPublisher.
alias set
An alias set contains one or more alias names that can be used as placeholders for certain objects
in a Documentum Docbase. Web developers and administrators can create alias sets.
Approved
In a default configuration, the lifecycle status (state) of a file that is ready for publication but is
awaiting its effective date.
The file becomes active when the effective date occurs or when an approved page is manually
promoted.
attribute
Information, or metadata, that is associated with an object. Attributes are also called properties. A
Docbase object can have many different properties associated with it. Each property can take on
multiple values. For example the property of format could take on the value of .htm, .doc, .xsl.
TM
Customizing Documentum WebPublisher GL–1
Glossary
authoring interface
WebPublisher provides two interfaces: the authoring interface and the WebPublisher Pro interface.
The authoring interface allows non-technical users (content authors and content managers) to
create content for Web sites without having to understand the mechanics of Web page creation.
automatic task
A task that promotes a file without a user intervention. For example, a workflow might contain an
automatic task that promotes files to the Staging lifecycle status (state).
change set
A group of content files that travel together through workflows and share the same lifecycle. If a
change set effective date is set, all files in the change set publish to the active Web site at the same
time. Web developers and administrators can create change sets.
choice
An element describing the selection list editor component.
content
Any information, such as text, graphics, or charts, published to a Web page.
content author
A WebPublisher user or user group who creates content for Web sites without getting involved in
the technical details of the Web site creation or maintenance.
content manager
A WebPublisher user or user group who assigns content to be written by a content author, and
makes sure content adheres to organizational practices.
delivery cabinet
A cabinet in the WebPublisher Docbase that contains the files belonging to a particular Web site.
Delivery cabinets are visible only to Web developers and administrators.
descriptive name
A name used to identify a file in WebPublisher. It is not limited to the naming conventions used on
the Web and gives you more latitude to describe a file. The descriptive name is optional. If a file
has no descriptive name, WebPublisher identifies the file by the file name. When WebPublisher
lists files, the file name is the primary identifier, and the descriptive name appears underneath.
dispatcher
A WebPublisher component that controls the overall operation of WebPublisher on the Web
server. It calls various features and forms to display a list or page, or perform an action.
DocApp
A DocApp is a Documentum application that encapsulates customized Docbase objects. DocApps
usually contain, object types, properties, lifecycles, workflows, alias sets, and WebPublisher
Editor templates.
TM
GL–2 Customizing Documentum WebPublisher
Glossary
DocApp archive
A portable representation of a DocApp in a file on the file system.
Docbase
An object repository. Docbases store Web pages and other objects that you use to create Web sites.
Docbasic
An easy-to-use programming language provided by Documentum. You can write Docbasic
procedures to interact directly with a Documentum server. You write Docbasic procedures using
the Docbasic Editor, which comes with Documentum Developer Studio.
edition
A snapshot of a Web site at a specific point in time. Administrators can create editions.
effective date
The date a file is to be published to a Web site.
expiration date
The date a file is to be removed from a Web site.
Expired
In a default configuration, the lifecycle status (state) of a file that has been removed from a
Web site.
feature
An action or link in WebPublisher.
file format
The type of file, often indicated in the file name.
file name
The name that identifies a file on the Web. The file name must follow naming conventions used
for Web documents. For example, Web documents cannot have spaces or symbols.
FTP
File Transfer Protocol. The protocol used on the Internet for sending files.
ftpIntegrator
A Documentum application that provides direct integration between the WebPublisher Docbase
and any Web-authoring tool that supports FTP (File Transfer Protocol) over a TCP/IP network.
ftpIntegrator allows you to use client applications, such as Macromedia Dreamweaver, HomeSite
and GoLive, to securely transfer files of any format to and from the Docbase through FTP.
TM
Customizing Documentum WebPublisher GL–3
Glossary
group
A set of users. The users in a group can be individual users, groups of users or a combination
of both. WebPublisher has four default user groups: administrators, Web developers, content
authors, content managers.
history mechanism
A WebPublisher component that returns users to a logical place in the WebPublisher user interface
upon completion of an operation such as saving a file.
HTML
HyperText Markup Language. HTML is a collection of platform-independent styles (indicated by
markup tags) that define the various components of a Web document.
HTTP
HyperText Transfer Protocol. HTTP is a generic stateless object-oriented protocol, that can be
used for similar tasks such as name servers, and distributed object-oriented systems, by extending
the commands, or "methods", used.
keyword
A property of a content object that can be used to locate the content object in a search.
lifecycle
The different states a file goes through on its way to publication to a Web site. A file’s current
lifecycle state determines how the file is used and who has access to it.
list item
A property, such as a subject, author, or date, displayed under your specified document type in
the FILE LIST page
lock
A lock ensures that only one person at a time is able to edit a file. When you edit a file, the file is
locked in the WebPublisher Docbase so that no one else can edit it. When a file is locked, other
users can view the last version saved to the Docbase.
navigation path
The hierarchy of categories through which a file or page type is accessed in the WebPublisher
authoring interface.
object
An entity in a Documentum Docbase. In Documentum, all items such as documents, folders,
cabinets, and even users are objects. All objects have associated descriptive characteristics, called
properties, and associated operations, called methods
TM
GL–4 Customizing Documentum WebPublisher
Glossary
object type
A template for objects (usually documents) that play a special role in a DocApp. An object
type inherits properties from its supertype (usually dm_document or one of its subtypes). The
additions or modifications you make to these properties define the object type. You create object
types using Documentum Developer Studio.
page type
A template for creating new content files. In the WebPublisher authoring interface, templates
are called page types.
permission set
A permission set controls the ways in which specified users can interact with an object in a
Docbase. You can attach a permission set to an object to specify permissions for the object owner,
generic users (the world), and any other users or groups
process workflow
The standard way of routing Web page content to other users. The process workflow is integrated
with the lifecycle so that Web page content can be automatically when approved by a reviewer.
property
Information, or metadata, that is associated with a object. A Docbase object can have many
different properties associated with it. Each property can take on multiple values. For example the
property of format could take on the value of .htm, .doc, .xsl.
publish
Moving content to the active Web site; refers to the automatic jobs that WebCache runs to push
files out to the Web server.
rendition
A copy of a file that differs from the original only in the format of the content.
repeatdef
A repeating editor element.
Rules Editor
A GUI application enabling users to create or modify an Editor rules file and template file through
a user-friendly interface. The Editor rules file creates or modifies the WebPublisher Editor
interface.You access the Rules Editor from WebPublisher Pro.
Staging
In a default configuration, the lifecycle status (state) of a completed file waiting to receive final
approval for publishing.
synchronize
A WebPublisher feature that enables you to manually update the files on the Web server.
tabledef
A table editor element.
TM
Customizing Documentum WebPublisher GL–5
Glossary
template
The files upon which new content files are based. When an author chooses a template,
WebPublisher makes a copy of the template and saves it as a new content file. The content file
inherits the template’s content and properties. WebPublisher chooses where to store the file in
the Docbase by applying a set of mapping rules to the content file’s properties. The rules are
contained in the FolderMap.xml file.
In the authoring interface, templates are called page types.
textline
A single-line text element.
textselector
An element describing the boilerplate text selector editor template.
texttrigger
A Read-Only element such as label.
thumbnail
A file that is a visual representation of a file or template, to make it easier for users to recognize
the file.
URL
Uniform Resource Locator, the global address of documents and other resources on the World
Wide Web. The first part of the address indicates what protocol to use, and the second part
specifies the IP address or the domain name where the resource is located.
validate
A WebPublisher feature that checks to see that template files are well-formed XML files.
version
An instance of a file as it was saved to the Docbase. When you save a file to the WebPublisher
Docbase, WebPublisher saves it as a new version with an incremental number. WebPublisher
keeps the previous versions of the file, as well.
Web developer
The WebPublisher user responsible for creating and managing Web page templates and Web sites.
Web page
A document formatted in HTML and viewable on the World Wide Web portion of the Internet.
Web ready
A content file that Web browsers can read.
Web server
An HTTP server that gives access to a Web site.
TM
GL–6 Customizing Documentum WebPublisher
Glossary
Web view
A WebPublisher feature that allows you to preview what content will look like when it people
view it on the Web site.
WebPublisher Docbase
See Docbase.
WebPublisher Editor
A browser-based application for creating and modifying Web page content.
widget
An item in a WebPublisher Editor file—such as a textbox, checkbox, or table—that authors
use to create content.
WIP
Work In Progress. In a default configuration, the lifecycle status (state) of a file that is not yet
complete and not yet ready for publishing. Anytime a file is versioned or demoted, its lifecycle
starts over at the WIP state.
workflow
A predefined sequence of tasks users perform to process files. WebPublisher administrators
create and define workflows. When users are to perform a task, they are notified in their email
inbox and their WebPublisher task list.
workflow supervisor
The user who is responsible for a workflow in progress and who has permission to modify or
stop it.
XML
Extensible Markup Language. XML is the universal format for structured documents and data on
the Web, and is a method for putting structured data in a text file.
Xselector
An element that extends the functionality of the graphic selector and text selector.
XSL
Extensible Stylesheet Language. An XSL stylesheet specifies the presentation of a class of XML
documents by describing how an instance of the class is transformed into an XML document
that uses the formatting vocabulary.
XSLT
Extensible Style Language Transformation, the language used in XSL stylesheets to transform
XML documents into other XML documents.
XSLT is used when creating WebPublisher Editor files.
TM
Customizing Documentum WebPublisher GL–7
Glossary
TM
GL–8 Customizing Documentum WebPublisher
Index
A example
action list HTML product title, 10–75
new action, 8–6 HTML start and end tags, 10–75
actionlist product benefits, 10–73
adding features, 8–4 product description, 10–73
alias set product image, 10–72
definition, 2–3, 2–9 product number, 10–72, 10–75
attribute, 4–1 product price, 10–72
See also property product title, 10–72
adding, 4–7 product type, 10–73
adding or removing, 4–19 start and end tags, 10–71
attributes.xml file, 4–4 create page
copying, 4–4 customizing, 7–5
definition, 2–2, 2–8 page, 7–1
deleting, 4–6 tab, 7–5
displaying, 4–17 customization, 2–13
displaying and hiding, 4–16 dispatcher, 2–20
hiding, 4–16 features, 2–14
list item, 5–3, 5–6 history mechanism, 2–18
Read-Only, 4–18 methodology, 2–13
script, 4–14 object types, 2–14
value assistance, 4–9 testing, 4–20, 7–5, 7–8
value selection, 4–9
D
C dctmEditor, 10–14
checkbox, 10–41 directory
choice element, 10–15 custom, 2–31
content product, 2–31
adding new, 10–85 dispatcher
promoting, 10–85 customization, 2–20
publishing, 10–86 definition, 2–28
content element, 10–6 environment variables, 2–20 to 2–21
content template examples
definition, 10–71 URL and DMW_INCLUDE, 2–26
global variables, 2–20, 2–23
RightSite methods, 2–20
understanding, 2–30
TM
Customizing Documentum WebPublisher Index–1
Index
F L
feature lifecycle
actionlist, 8–4
definition, 2–3, 2–9
attributes, 2–15, 2–31
TM
Index–2 Customizing Documentum WebPublisher
Index
TM
Customizing Documentum WebPublisher Index–3
Index
V WebPublisher Editor
value assistance associating, 10–85
attribute, 4–9 customizing, 10–1
value selection importing templates and files, 10–84
attribute, 4–9 templates, 10–1
variables templates and files
dispatcher, 2–26 definition, 2–5, 2–11
verifying, 10–84
adding new content, 10–85
W promoting content, 10–85
Web page publishing, 10–86
creating, 10–1 validating templates, 10–85
custom, 10–1 Web page, 10–86
example, 10–86 workflow
publishing, 10–86 definition, 2–3, 2–9
Web server testing, 10–88
components, 2–27 workflows
files, 1–4 process, 9–1
folder structure, 2–27
Web site
creating, 10–1
X
custom, 10–1 XML
WebPublisher configuration, 2–16
4i products fundamentals, 2–16
AutoRender Pro, 1–1 xselector, 10–48
Content Personalization XSL
Services, 1–1 building, 10–79
Developer Studio, 1–1 XSL file
Documentum Administrator, 1–1 HTML renditions, 10–90
eContent Server, 1–1
Engagement Services, 1–1
ftpIntegrator, 1–1
Media Services, 1–1
RightSite, 1–1
WebCache, 1–1
TM
Index–4 Customizing Documentum WebPublisher