WCM API Scenarios

Implementing common extension scenarios using IBM Lotus
Web Content Management 6.1 APIs
Bhargavkumar Thakker
Staff Software Engineer
IBM Software Group
Pune, India
Soumitra Limaye
Staff Software Engineer
IBM Software Group
Pune, India
October 2009
© Copyright International Business Machines Corporation 2009. All rights reserved.
Abstract: The IBM® Lotus® Web Content Management™ (hereafter called “Web Content
Management”) API provides an extension of standard features of Web Content Management. This
article provides usage and solutions with code samples of the most common implementations
carried out by customers using APIs. You can pick and choose the samples provided here, as is, to
incorporate into your system.
Contents
1 Introduction..................................................................................................................................... 2
2 Assumptions and considerations..................................................................................................... 4
3 Code samples to implement various scenarios using APIs per the requirement ............................ 4
Scenario 1: Find an item of a given type by name......................................................................... 4
Scenario 2: Find items based on the item type .............................................................................. 8
Scenario 3: Find content by various criteria ................................................................................ 12
Scenario 4: Search for content based on Authoring Template, Site Area, Category, and
Keywords criteria......................................................................................................................... 16
Scenario 5: Creating a new Site ................................................................................................... 18
Scenario 6: Creating a new Site Area .......................................................................................... 19
Scenario 7: Creating new Content ............................................................................................... 21
Scenario 8: Creating a new Content Link that is linked to existing Content............................... 23
Scenario 9: Creating various Library Components..................................................................... 24
-1-
Scenario 10: Creating a new Taxonomy and a new Category ..................................................... 25
Scenario 11: Creating and canceling drafts on published Content items..................................... 26
Scenario 12: Moving content to Next Stage of a Workflow, Restarting the Workflow, setting
another Workflow on specific content......................................................................................... 28
Scenario 13: Render Sites, Site Areas, Contents, Content components, or Library Components
...................................................................................................................................................... 29
Scenario 14: Moving or copying an entire Site Area within/between libraries........................... 31
Scenario 15: Moving or copying content within/between libraries ............................................. 33
Scenario 16: Moving or copying non-hierarchical or root items to another library .................... 35
Scenario 17: Moving or copying a Category within/between libraries ....................................... 39
Scenario 18: Deleting and purging Objects ................................................................................. 41
4 Standards for names specified in all examples ............................................................................. 43
5 Conclusion .................................................................................................................................... 43
6 Resources ...................................................................................................................................... 44
7 About the authors.......................................................................................................................... 44
1 Introduction
You can extend the standard features of Web Content Management using the product’s API and
JavaServer Pages™ (JSP) files. The Lotus Web Content Management API is focused on
processing the content programmatically and is an alternative way to access a Web Content
Management site. It allows content and other Web Content Management objects to be created,
edited, deleted, and rendered entirely by using Java™ code.
Additionally, you can always manipulate your site and integrate Web Content Management with
other applications in a way that was not previously possible using these APIs.
There are many functions that can be achieved using Web Content Management APIs; here are a
few examples:
• Web content libraries:

o Moving or copying items within a library.
o Moving or copying items between libraries.
• Search iterators of item IDs:

o Find item of given type by name.
o Find items of given type.
o Find library components by name.
o Find content by authoring template.
o Find content by category.
o Find content by path.
o Find content by workflow stage.
o Find content modified since date.
o Find content modified between dates.
-2-
• Content search (similar to the Menu Component search criteria but using item parameters
as ids).
• Retrieve via item IDs.
• The ability to create, delete and save the following items:

o Content
o Sites
o Site Areas
o File Resource components
o HTML components
o Image components
o Date and Time components
o Link components
o Number components
o Rich text components
o Style Sheet components
o Short text components
o Text components
o User Selection components
o taxonomies
o categories
• The ability to retrieve the following items:

o Content
o Sites
o Site areas
o Taxonomies and categories
o Workflows
o Components
• The ability to retrieve the following items from searches, (but NOT as an item):
o Authoring Template ID (Authoring Template)

o Presentation Template ID (Presentation Template)
o Workflow Stage ID
• The ability to approve or reject content items in a workflow stage. Other item-types do not
support this function.
The Javadocs should be reviewed for a complete set of the features available using the API. The
Javadoc HTML files are located under the
was_profile_root\installedApps\nodename\wcm.ear\ilwwcm.war\webinterface\ folder.
All the samples provided below can be picked directly and used or incorporated into your code, to
achieve the required result based on the various scenarios you must carry out in your
environment. We have added comments (in italic font) on most of the lines, to make it easier to
understand the code and flow.
NOTE: For further information, refer to the IBM Lotus Web Content Management API information
center topic, from which the material in this Introduction section is excerpted.
-3-
2 Assumptions and considerations
Before beginning, note the following:
• The user must have access to all the objects mentioned in the code samples below.
• We are not using the try-catch methods to pick up those exceptions.
• The Javadoc for moveToLibrary states "This method moves non-hierarchical or root items to
another library".
• Site and taxonomy are considered to be root items.
• Refer to Section 4, “Standards for names specified in all examples,” in this document for an
explanation of the standards used in the code samples.
3 Code samples to implement various scenarios using APIs

per the requirement
All the below scenarios have been tested on the 6.1 version of Web Content Management;
however, the same logic can be used for version 6.0 with a change in APIs wherever required.
Scenario 1: Find an item of a given type by name

To search for a specific type of an item by name, you can select and use the appropriate API
code in listing 1. With this you can search a Site, Site Area, Content, Content Link, Authoring
template, Presentation template, all library components, Workflow, Workflow stage, Taxonomy,
Category, etc., using the workspace.findbyName API.
This essentially returns an iterator of IDs of all objects of the given type with the specified name.
Listing 1. Example code to find item by name

<%@ page import="com.ibm.workplace.wcm.api.*"%>
<%@ page import="java.util.*"%>
<%
// retrieve repository
Repository repository = WCM_API.getRepository();
// get the workspace for current user

Workspace workspace = repository.getWorkspace(request.getUserPrincipal());
// set the library

workspace.setCurrentDocumentLibrary(workspace.getDocumentLibrary("WebContent"));
// **************************** Find Site example ***************************
// define site name
-4-
String siteName = new String("Site");
// find site by name

DocumentIdIterator siteIterator = workspace.findByName(DocumentTypes.Site,siteName);
if (siteIterator.hasNext()){
out.println("Site found : " + siteName + " ");
}else {
out.println("Could not find site : " + siteName + " ");
}
// ************************* Find Sitearea example **************************
// define sitearea name

String siteArea = new String("SiteArea");
// find sitearea by name

DocumentIdIterator siteAreaIterator =
workspace.findByName(DocumentTypes.SiteArea,siteArea);
if (siteAreaIterator.hasNext()){
out.println("Sitearea found : " + siteArea + " ");
}else {
out.println("Could not find Sitearea : " + siteArea + " ");
}
// ************************* Find Content example ***************************
// define content name

String contentName = new String("Content");
// find content by name

DocumentIdIterator contentIterator =
workspace.findByName(DocumentTypes.Content,contentName);
if (contentIterator.hasNext()){
out.println("Content found : " + contentName + " ");
}else {
out.println("Could not find Content : " + contentName + " ");
}
// *********************** Find Authoring Template example *******************
// define authoring template name

String authoringTemplateName = new String("AuthoringTemplate");
-5-
// find authoring template by name
DocumentIdIterator authoringTemplateIterator =
workspace.findByName(DocumentTypes.AuthoringTemplate,authoringTemplateName);
if (authoringTemplateIterator.hasNext()){
out.println("Authoring template found : " + authoringTemplateName + " ");
}else {
out.println("Could not find Authoring template: " + authoringTemplateName + " ");
}
// *********************** Find Presentation Template example *****************
// define presentation template name

String presentationTemplateName = new String("PresentationTemplate");
// find presentation template by name

DocumentIdIterator presentationTemplateIterator =
workspace.findByName(DocumentTypes.PresentationTemplate,presentationTemplateName);
if (presentationTemplateIterator.hasNext()){
out.println("Presentation template found : " + presentationTemplateName + " ");
}else {
out.println("Could not find Presentation template: " + presentationTemplateName + " ");
}
// *********************** Find Library Component example *******************
// define library component name

String libraryComponentName = new String("LibraryComponent");
// find library component by name

DocumentIdIterator libraryComponentIterator =
workspace.findByName(DocumentTypes.LibraryComponent,libraryComponentName);
if (libraryComponentIterator.hasNext()){
out.println("Library component found : " + libraryComponentName + " ");
}else {
out.println("Could not find Library component: " + libraryComponentName + " ");
}
// *************************** Find Workflow example ***********************
// define workflow name

String workflowName = new String("Workflow");
// find workflow by name
-6-
DocumentIdIterator workflowIterator =
workspace.findByName(DocumentTypes.Workflow,workflowName);
if (workflowIterator.hasNext()){
out.println("Workflow found : " + workflowName + " ");
}else {
out.println("Could not find Workflow: " + workflowName + " ");
}
// ************************* Find Workflow Stage example ********************
// define workflow stage name

String workflowStageName = new String("WorkflowStageName");
// find workflow stage by name

DocumentIdIterator workflowStageIterator =
workspace.findByName(DocumentTypes.WorkflowStage,workflowStageName);
if (workflowStageIterator.hasNext()){
out.println("Workflow Stage found : " + workflowStageName + " ");
}else {
out.println("Could not find Workflow Stage: " + workflowStageName + " ");
}
// ************************** Find Taxonomy example ************************
// define taxonomy name

String taxonomyName = new String("Taxonomy");
// find taxonomy by name

DocumentIdIterator taxonomyIterator =
workspace.findByName(DocumentTypes.Taxonomy,taxonomyName);
if (taxonomyIterator.hasNext()){
out.println("Taxonomy found : " + taxonomyName + " ");
}else {
out.println("Could not find Taxonomy: " + taxonomyName + " ");
}
// ************************** Find Category example *************************
// define category name

String categoryName = new String("Category");
// find category by name
-7-
DocumentIdIterator categoryIterator =
workspace.findByName(DocumentTypes.Category,categoryName);
if (categoryIterator.hasNext()){
out.println("Category Found : " + categoryName + " ");
}else {
out.println("Could not find Category : " + categoryName + " ");
}
%>
Scenario 2: Find items based on the item type

To find items based on the specific type, you can directly select and use the appropriate API code
in listing 2. With this you can search all Sites, Site Areas, Contents, Content Links, Authoring
templates, Presentation templates, all library components, Workflows, Workflow stages,
Taxonomies, Categories, etc., using the workspace.findbyType API.
This returns an iterator of IDs of all objects of the given type.
Listing 2. Example code to find items by type

<%
// get workspace for current user

// set library
// **************************** Find Site example ***************************
// find all sites

DocumentIdIterator siteIterator = workspace.findByType(DocumentTypes.Site);
DocumentId siteId = null;
if(siteIterator.hasNext()){
while(siteIterator.hasNext())
{
siteId = siteIterator.nextId();
out.println("Found Site : " + siteId.getName() + " ");
}
-8-
} else {
out.println("Could not find any Site");
}
// ************************** Find Sitearea example *************************
// find all siteareas

DocumentIdIterator siteAreaIterator = workspace.findByType(DocumentTypes.SiteArea);
DocumentId siteAreaId = null;
if(siteAreaIterator.hasNext()){
while(siteAreaIterator.hasNext())
{
siteAreaId = siteAreaIterator.nextId();
out.println("Found Sitearea : " + siteAreaId.getName() + " ");
}
} else {
out.println("Could not find any Sitearea");
}
// ************************** Find Content example **************************
// find all contents

DocumentIdIterator contentIterator = workspace.findByType(DocumentTypes.Content);
DocumentId contentId = null;
if(contentIterator.hasNext()){
while(contentIterator.hasNext())
{
contentId = contentIterator.nextId();
out.println("Found Content : " + contentId.getName() + " ");
}
} else {
out.println("Could not find any Content");
}
// ********************** Find Authoring Template example *********************
// find all authoring templates

workspace.findByType(DocumentTypes.AuthoringTemplate);
DocumentId authoringTemplateId = null;
if(authoringTemplateIterator.hasNext()){
while(authoringTemplateIterator.hasNext())
-9-
{
authoringTemplateId = authoringTemplateIterator.nextId();
out.println("Found Authoring Template : " + authoringTemplateId.getName() +
" ");
}
} else {
out.println("Could not find any Authoring Template");
}
// ********************* Find Presentation Template example ********************
// find all presentation templates

workspace.findByType(DocumentTypes.PresentationTemplate);
DocumentId presentationTemplateId = null;
if(presentationTemplateIterator.hasNext()){
while(presentationTemplateIterator.hasNext())
{
presentationTemplateId = presentationTemplateIterator.nextId();
out.println("Found Presentation Template : " + presentationTemplateId.getName()
+ " ");
}
} else {
out.println("Could not find any Presentation Template");
}
// ********************** Find Library Component example *********************
// find all library components

workspace.findByType(DocumentTypes.LibraryComponent);
DocumentId libraryComponentId = null;
if(libraryComponentIterator.hasNext()){
while(libraryComponentIterator.hasNext())
{
libraryComponentId = libraryComponentIterator.nextId();
out.println("Found Library component : " + libraryComponentId.getName() +
" ");
}
} else {
out.println("Could not find any Library component");
}
// ************************** Find Workflow example *************************
- 10 -
// find all workflows
DocumentIdIterator workflowIterator = workspace.findByType(DocumentTypes.Workflow);
DocumentId workflowId = null;
if(workflowIterator.hasNext()){
while(workflowIterator.hasNext())
{
workflowId = workflowIterator.nextId();
out.println("Found Workflow : " + workflowId.getName() + " ");
}
} else {
out.println("Could not find any Workflow");
}
// ************************ Find Workflow Stage example **********************
// find all workflow stages

workspace.findByType(DocumentTypes.WorkflowStage);
DocumentId workflowStageId = null;
if(workflowStageIterator.hasNext()){
while(workflowStageIterator.hasNext())
{
workflowStageId = workflowStageIterator.nextId();
out.println("Found Workflow Stage : " + workflowStageId.getName() + " ");
}
} else {
out.println("Could not find any Workflow Stage");
}
// ************************** Find Taxonomy example ************************
// find all taxonomies

DocumentIdIterator taxonomyIterator = workspace.findByType(DocumentTypes.Taxonomy);
DocumentId taxonomyId = null;
if(taxonomyIterator.hasNext()){
while(taxonomyIterator.hasNext())
{
taxonomyId = taxonomyIterator.nextId();
out.println("Found Taxonomy : " + taxonomyId.getName() + " ");
}
} else {
out.println("Could not find any Taxonomy");
- 11 -
}
// ************************** Find Category example *************************
// find all categories

DocumentIdIterator categoryIterator = workspace.findByType(DocumentTypes.Category);
DocumentId categoryId = null;
if(categoryIterator.hasNext()){
while(categoryIterator.hasNext())
{
categoryId = categoryIterator.nextId();
out.println("Found Category : " + categoryId.getName() + " ");
}
} else {
out.println("Could not find any Category");
}
%>
Scenario 3: Find content by various criteria

To find content by Authoring Template, Category, path, Workflow Stage, modified since date, and
modified between dates, you can select and use the appropriate API code in listing 3, which uses
the following APIs:
workspace.findContentByAuthoringTemplate
workspace.findContentByCategory
workspace.findContentByPath
workspace.findContentByWorkflowStage
workspace.findContentModifiedSince
workspace.findContentModifiedBetween
Listing 3. Example code to find content by criteria

<%

// Set library
- 12 -
DocumentIdIterator contentIterator = null;
// **************** Find Content by authoring template example ******************
// define authoring template


out.println("Authoring Template found : " + authoringTemplateName + " ");

// find all the contents having above authoring template

contentIterator = workspace.findContentByAuthoringTemplate(authoringTemplateId);
out.println("List of Content uses " + authoringTemplateName );
while(contentId!=null) {
out.println( " " + contentId.getName());
}
} else {
out.println("Could not find any Content that uses " + authoringTemplateName );
}
}else {
out.println("Could not find Authoring Template: " + authoringTemplateName + " ");
}
// ******************* Find Content by Category example ***********************
// define category

- 13 -
out.println("Category found : " + categoryName + " ");
// find all the content having above category

contentIterator = workspace.findContentByCategory(categoryId);
out.println("List of Content uses " + categoryName );
while(contentIterator.hasNext()) {
}
} else {
out.println("Could not find any Content that uses " + categoryName );
}
}else {
out.println("Could not find Category: " + categoryName + " ");
}
// ******************* Find Content by Path example **************************
// define content path

String contentPath = "/Web content/Site/SiteArea/Content";
// find content by path

contentIterator = workspace.findContentByPath(contentPath);
out.println("Content found on Path : " + contentPath + " : Content name : " +
contentId.getName() + " ");
}else {
out.println("Could not find Content on Path : " + contentPath + " ");
}
// ******************* Find Content by Workflow Stage example ******************
// define workflow stage

- 14 -
DocumentId workflowStageId = workflowStageIterator.nextId();

// find all the content having above workflow stage

contentIterator = workspace.findContentByWorkflowStage(workflowStageId);
out.println("List of contents under Workflow Stage " + workflowStageName );
}
} else {
out.println("Could not find any content under Workflow Stage " +
workflowStageName );
}
}else {
}
// ******************* Find Content since modified date example *****************
// define start date in dd/mm/yyyy format

Date startDate = new Date("01/01/2008");
// find content modified since start date

contentIterator = workspace.findContentModifiedSince(startDate);
out.println("List of contents modified since " + startDate );
}
} else {
- 15 -
out.println("Could not find any content modified since " + startDate );
}
%>
// **************** Find Content modified between two dates example *************
// define start date in dd/mm/yyyy format

startDate = new Date("01/01/2008");
// define end date in dd/mm/yyyy format

Date endDate = new Date("12/31/2009");
// find all the contents modified between start date and end date
contentIterator = workspace.findContentModifiedBetween(startDate,endDate);
out.println("List of contents modified between " + startDate + "and" + endDate );
}
} else {
out.println("Could not find any content modified between " + startDate + "and" +
endDate );
}
%>
Scenario 4: Search for content based on Authoring Template, Site Area,

Category, and Keywords criteria
To search for content based on criteria that are a combination of Authoring Template, Site Area,
Category, or Keywords, you can select and use the appropriate API code in listing 4. You can do
this by using the ContentSearch method, which returns an iterator of IDs of objects that match
the given search criteria.
The ContentSearch method behaves in a manner similar to the Menu Component. If Site Areas
have been specified, then all the ancestor and descendant Site Areas are also included in the
search.
This performs an "or" search, not an "and" search. This means that a search for two different
Categories and a Content Template will return content profiled with at least one of each profile
type (one Category and one Template), not just content that matches all the parameters. Content
that matches only one criteria type (Template only) will not be returned.
- 16 -
Note that the order of results is not guaranteed, and all parameters are optional except
matchAllKeys, the last parameter.
Listing 4. Example code to search for content by criteria

<%

// Set library


}else {
}
// define siteare
- 17 -
out.println("Sitearea Found : " + siteArea + " ");
}else {
}
// define category

}else {
}
// define keywords
String[] keywords = new String[]{"Keyword"};
// search all the contents based on authoring template , sitearea , category and keywords
DocumentIdIterator contentIterator = workspace.contentSearch(authoringTemplateId, new

DocumentId [] {siteAreaId}, new DocumentId [] {categoryId}, keywords,true);
while(contentId!=null)
{
out.println("Found Content : " + contentId.getName() + " ");
}
} else {
out.println("Could not find any Content using the contentSearch Method");
}
%>
Scenario 5: Creating a new Site

You can create a new site using Web Content Management API methods, after which you can
also use all the methods under Site Object once the site has been created. You can select and
- 18 -
use the appropriate code provided in listing 5, which demonstrates only the creation of a new site,
setting its name, title, description, and then saving it to the repository.
We use workspace.createSite to achieve this, which returns the new Site object.
Listing 5. Example code to create a new Site

<%

// Set library
// create new site

Site newSite = workspace.createSite();
newSite.setName("NewSite");
newSite.setTitle("NewSite");
newSite.setDescription("New Site Created using WCM API");
String[] saveMessage = workspace.save((Document)newSite);
if (saveMessage.length==0){
out.println("Could not create new Site.. ");
}else{
out.println("New Site created successfully.");
}
%>
Scenario 6: Creating a new Site Area

You can also create a new Site Area by using Web Content Management API methods, after
which you can use all the methods under the Site Area Object.
Listing 6 demonstrates only creating a new Site Area, setting its name, title, description, and
saving it to the repository. We use workspace.createSiteArea here, which creates a new Site
- 19 -
Area under the given parent. The parent can be a Site or a Site Area, and the method returns the
new Site Area object.
Listing 6. Example code to create new Site Area

<%

// Set library
DocumentId documentId = null;

Site parentSite = null;
String parentSiteName = "Site";
DocumentId siblingId = null;
// find parent site

DocumentIdIterator siteIterator = workspace.findByName(DocumentTypes.Site,parentSiteName);
documentId = siteIterator.nextId();
parentSite = (Site) workspace.getById(documentId);
// create new sitearea
SiteArea newSiteArea =
workspace.createSiteArea((DocumentId)parentSite.getId(),siblingId,ChildPosition.END);
newSiteArea.setName("NewSiteArea");
newSiteArea.setTitle("NewSiteArea");
newSiteArea.setDescription("New Sitearea Created using WCM API
String[] saveMessage = workspace.save((Document)newSiteArea);
if (saveMessage.length==0) {
out.println (" Created new Sitearea under " + parentSiteName );
}
} else {
out.println (" Could not find parent Site " + parentSiteName + ". Could not create a
new Sitearea." );
- 20 -
}
%>
Scenario 7: Creating new Content

You can create new Content under a specific Site Area at a specific position, using a Web
Content Management API. You can select and use the appropriate provided code in listing 7,
which demonstrates the creation of Content under a specific Site Area at the last position, with a
specific Authoring Template.
The code also configures the Workflow while saving the content. We use
workspace.createContent for this purpose, which returns a new content object based on the
specified Authoring Template. The API code can be changed based on your requirements.
Listing 7. Example code to create a new Content

<%

// Set library

// define parent sitearea

String parentSiteAreaName = new String("SiteArea");
// define workflow

DocumentId parentSiteAreaId = null;
DocumentId workflowId = null;

- 21 -
}else {
}

workspace.findByName(DocumentTypes.SiteArea,parentSiteAreaName );
parentSiteAreaId = siteAreaIterator.nextId();
out.println("Sitearea Found : " + parentSiteAreaName + " ");
}else {
out.println("Could not find Sitearea : " + parentSiteAreaName + " ");
}

workflowId = workflowIterator.nextId();
}else {
}
if((authoringTemplateId!=null) && (parentSiteAreaId!=null) && (workflowId!=null)){
// create new content

Content newContent =
workspace.createContent(authoringTemplateId,parentSiteAreaId,siblingId,ChildPosition.END);
newContent.setName("NewContent");
newContent.setTitle("NewContent");
newContent.setDescription("New Content created using WCM API");
newContent.setWorkflowId(workflowId);
String[] saveMessage = workspace.save((Document)newContent);
out.println (" Created new Content under " + parentSiteAreaName );
}
- 22 -
}else {
out.println ("Could not create new content");
}
%>
Scenario 8: Creating a new Content Link that is linked to existing

Content
You can create a new Content Link that is linked to existing Content under a specific Site Area.
The Content must be saved before creating a link to it, while the Content Link is created
immediately, and should not be saved.
We use workspace.createContentLink to achieve this, which returns a new Content Link object.
The code in listing 8 assumes that the Content Link is not present under the Site Area.
Listing 8. Example code to create a new Content Link

<%

// Set library
// define content
// define sitearea where the content link needs to be created

String parentSiteArea = new String("NewSiteArea");

DocumentId parentSiteAreaId =null;

if (contentIterator.hasNext())
- 23 -
DocumentIdIterator parentSiteAreaIterator =
workspace.findByName(DocumentTypes.SiteArea,parentSiteArea);
if (parentSiteAreaIterator.hasNext())
parentSiteAreaId = parentSiteAreaIterator.nextId();
if((contentId!=null) && (parentSiteAreaId!=null)) {
// create content link

ContentLink contentLink =
workspace.createContentLink(contentId,parentSiteAreaId,siblingId,ChildPosition.END);
out.println("New Content link of Content " + contentName + " is created under new
Sitearea " + parentSiteArea);
} else{
out.println("Could not create Content link of Content " + contentName + " under new
Sitearea " + parentSiteArea);
}
%>
Scenario 9: Creating various Library Components

You can create Library Components such as DateComponent, DocumentManagerComponent,
FileComponent, HTMLComponent, ImageComponent, JSPComponent, LinkComponent,
RichTextComponent, ShortTextComponent, TextComponent, UserSelectionComponent.
The code in listing 9 demonstrates only creation, setting the name, title, description, and then
saving them in the Web Content Management repository. The code can be directly used to create
a File Component, Image Component, and Rich Text Component:
workspace.createFileComponent
workspace.createImageComponent
workspace.createRichTextComponent
Other APIs can be used once the components are created.
Listing 9. Example code to create various library components

<%

- 24 -
// Set library
String[] saveMessage = new String[1];
// ***************** Create File Resource Component example ********************
LibraryFileComponent libraryFileComponent = workspace.createFileComponent();

libraryFileComponent.setName("NewFileComponent");
libraryFileComponent.setTitle("NewFileComponent");
libraryFileComponent.setDescription("New File resource component created using API");
saveMessage = workspace.save((Document)libraryFileComponent);
out.println (" New File resource component created :" + libraryFileComponent.getName());
// ******************* Create Image Component example ***********************
LibraryImageComponent libraryImageComponent = workspace.createImageComponent();

libraryImageComponent.setName("NewImageComponent");
libraryImageComponent.setTitle("NewImageComponent");
libraryImageComponent.setDescription("New Image component created using API");
saveMessage = workspace.save((Document)libraryImageComponent);
out.println (" New Image component created :" + libraryImageComponent.getName());
// ******************* Create Rich Text Component example **********************
LibraryRichTextComponent libraryRichTextComponent =
workspace.createRichTextComponent();
libraryRichTextComponent.setName("NewRichTextComponent");
libraryRichTextComponent.setTitle("NewRichTextComponent");
libraryRichTextComponent.setDescription("New Rich text component created using API");
saveMessage = workspace.save((Document)libraryRichTextComponent);
out.println (" New Rich text component created :" +
libraryRichTextComponent.getName());
%>
Scenario 10: Creating a new Taxonomy and a new Category

You can create a new Taxonomy as well as a new Category under a specific Category or
Taxonomy. The code in listing 10 demonstrates creating a new Taxonomy and new Category
under a specific parent Taxonomy, and you can use this code directly in your code. We use:
workspace.createTaxonomy, which returns the new Taxonomy object

workspace.createCategory, which returns the new Category object
- 25 -
Listing 10. Example code to create a new Taxonomy and new Category
<%

// Set library
String[] saveMessage = new String[1];
// *********************** Create Taxonomy example **************************
Taxonomy parentTaxonomy = workspace.createTaxonomy();

parentTaxonomy.setName("NewParentTaxonomy");
parentTaxonomy.setTitle("NewParentTaxonomy");
parentTaxonomy.setDescription("New Taxonomy created using WCM API");
saveMessage = workspace.save((Document)parentTaxonomy);
out.println (" Created new Taxonomy : " + parentTaxonomy.getName());
}
// *********************** Create Category example **************************
Category newCategory = workspace.createCategory((DocumentId)parentTaxonomy.getId());

newCategory.setName("NewCategory");
newCategory.setTitle("NewCategory");
newCategory.setDescription("New Category Created using WCM API");
saveMessage = workspace.save((Document)newCategory);
out.println (" Created new Category : " + newCategory.getName());
}
%>
Scenario 11: Creating and canceling drafts on published Content items

You can create as well as cancel drafts on published content, using a Web Content Management
API. The code in listing 11 can be used directly to create a draft of existing content and also to
cancel an existing draft on published content.
- 26 -
Listing 11. Example code to create and cancel drafts
<%

// Set library
// define the publish content

String contentName = new String("PublishedContent");

Content content = (Content) workspace.getById(contentId);
// create draft from publish content

Document draftContent = content.createDraftDocument();
out.println("Draft created for content " + contentName);
// cancel draft
if (content. hasDraft()) {
draftContent = content.cancelDraftDocument();
out.println("Draft cancled for " + contentName);
} else {
out.println("Draft does not exist for content : " + contentName);
}
}
%>
- 27 -
Scenario 12: Moving content to Next Stage of a Workflow, Restarting
the Workflow, setting another Workflow on specific content
You can move content to the next Workflow stage, restart the Workflow, and set another workflow
on specific content. You can use the code in listing 12 to move content from the draft stage to the
publish stage, restart the workflow, and to set another Workflow on a specific content item.
Listing 12. Example code to move Content

<%

// Set library
// define the draft content

Content content = null;
// define new workflow to be set on content

String newWorkflowName = new String("Workflow");
DocumentId newWorkflowId = null;

content = (Content) workspace.getById(contentId);
// below code may not be required if the next workflow stage does not exist
// moving content to next workflow stage

content.nextWorkflowStage();
out.println("Draft content" + contentName + "is moved to next workflow stage");
// restarting workflow
content.restartWorkflow();
- 28 -
out.println(" Workflow restarted for content " + contentName);
}
// find new workflow by name

workspace.findByName(DocumentTypes.Workflow,newWorkflowName);
if (workflowIterator.hasNext())
newWorkflowId = workflowIterator.nextId();
if((contentId!=null) && (newWorkflowId !=null)) {
// set new \ another workflow on content

content.setWorkflowId(newWorkflowId);
String[] saveMessage = workspace.save((Document)content);

out.println(" New Workflow set on content : " + contentName);
} else {
out.println(" Could not set new Workflow on content : " + contentName);
}
%>
Scenario 13: Render Sites, Site Areas, Contents, Content components,

or Library Components
You can render Sites, Site Areas, Contents, Content components, or Library components. The
given Web Content Management content component is rendered using the specified rendering
context.
Note that it’s not enough to specify only the ContentComponent to be rendered; the path to the
item containing the ContentComponent must also be specified in the RenderingContext.
The code in listing 13 demonstrates rendering Content, Content component, and the Library
component. You can always add or remove more components per your requirements.
Listing 13. Example code to render various artifacts

<%

- 29 -
// Set library
// ******************* Render Site\ Sitearea or Content example ******************
// define path of the site , sitearea or content to be rendered.
String contentPath = new String ("/WebContent/Site/SiteArea/Content");

Map parametermap = new HashMap();
parametermap.put("srv", "page");
// create rendering context

RenderingContext renderingContext = workspace.createRenderingContext(request, response,
parametermap);
if(renderingContext!=null) {
renderingContext.setRenderedContent(contentPath);
out.println("Rendering content " + contentPath );
out.println (" " + workspace.render(renderingContext));
} else {
out.println("Could not render content");
}
// ********************* Render Content Component example ********************
// define content name

// define siteArea name

String siteAreaName = new String("SiteArea");
Content content = null;

ContentComponent component=null;
SiteArea siteArea = null;

content = (Content) workspace.getById(contentIterator.nextId());
component = content.getComponent("MyComponent");
}
- 30 -
workspace.findByName(DocumentTypes.SiteArea,siteAreaName);
if (siteAreaIterator.hasNext())
siteArea = (SiteArea) workspace.getById(siteAreaIterator.nextId());
if((content!=null) && (siteArea!=null)){

renderingContext.setRenderedContent(content,siteArea);
out.println(" Rendering content component : " + component.getName());
out.println (" " + workspace.render(renderingContext,component));
} else {
out.println("Could not render Content component");
}
// ********************* Render Library Component example ********************
// define library component

LibraryComponent libraryComponent = (LibraryComponent)
workspace.getById(libraryComponentIterator.nextId());
renderingContext.setRenderedContent(contentPath);
out.println(" Rendering library component " + libraryComponentName );
out.println (" " + workspace.render(renderingContext,libraryComponent));
} else {
out.println(" Could not render Library component" + libraryComponentName);
}
%>
Scenario 14: Moving or copying an entire Site Area within/between

libraries
To move or copy an entire Site Area with all its children to another parent site within the same
library or to another library, you can use the API code in listing 14. To move the Site Area, we use
the workspace.moveSiteFrameworkDocument method.
To copy the Site Area, you can use the workspace.copySiteFrameworkDocument method to
replace the workspace.moveSiteFrameworkDocument method, using the same code below.
- 31 -
Listing 14. Example code to move or copy Site Area
<%

// define sitearea to be move

// define new parent site

String newParentSite = new String("Site");
// define sibling id
DocumentId siblingId = null;.
DocumentId newParentsiteId = null;
// set source library

workspace.setCurrentDocumentLibrary(workspace.getDocumentLibrary("Source Library"));
// find sitearea to be moved

out.println("Sitearea Found : " + siteArea + " ");
}else {
}
// target library. Not required while moving Sitearea to the same library
workspace.setCurrentDocumentLibrary(workspace.getDocumentLibrary("Target Library"));
// find new parent site

DocumentIdIterator siteIterator = workspace.findByName(DocumentTypes.Site,newParentSite);
newParentsiteId = siteIterator.nextId();
out.println("New parent site found : " + newParentSite + " ");
- 32 -
}else {
out.println("Could not find new parent site : " + newParentSite + " ");
}
if ((newParentsiteId!=null) && (siteAreaId!=null)) {
out.println(" Moving Sitearea " + siteArea + " to new parent site " +
newParentSite + " ");
// move sitearea to new parent site
workspace.moveSiteFrameworkDocument(siteAreaId,newParentsiteId,siblingId,ChildPosit
ion.START);
out.println(" Moved Sitearea " + siteArea + " to new parent site " +
newParentSite + " ");
}else{
out.println(" Moving Sitearea " + siteArea + " to new parent site " +
newParentSite + " failed ");
}
%>
Scenario 15: Moving or copying content within/between libraries

You can move or copy the content to another Site Area either within the same library or to a
different library, using the code in listing 15. To move the content, we use the
workspace.moveSiteFrameworkDocument method.
To copy the Site Area, you can use the workspace.copySiteFrameworkDocument method to
replace the workspace.moveSiteFrameworkDocument method, using the same code below.
Listing 15. Example code to move or copy content

<%

// define content to be move

// define new parent siteArea
- 33 -
String newParentSitearea = new String("SiteArea");
// sibling id
DocumentId newParentsiteareaId = null;

// find content to be moved

out.println("Content Found : " + contentName + " ");
}else {
out.println("Could not find Content : " + contentName + " ");
}
// set target library. Not required when moving content to the same library
workspace.setCurrentDocumentLibrary(workspace.getDocumentLibrary("Target Library"));
// find new parent sitearea

DocumentIdIterator newParentSiteareaIterator =
workspace.findByName(DocumentTypes.SiteArea,newParentSitearea);
if (newParentSiteareaIterator.hasNext()){
newParentsiteareaId = newParentSiteareaIterator.nextId();
out.println("New parent Sitearea found : " + newParentSitearea + " ");
}else {
out.println("Could not find new parent Sitearea : " + newParentSitearea + " ");
}
if ((contentId!=null) && (newParentsiteareaId!=null)) {
out.println(" Moving content " + contentName + " to new parent Sitearea " +
newParentSitearea + " ");
// move content to new sitearea

workspace.moveSiteFrameworkDocument(contentId,newParentsiteareaId,siblingId,ChildP
osition.START);
- 34 -
out.println(" Moved content " + contentName + " to new parent Sitearea " +
newParentSitearea + " ");
}else{
out.println(" Moving content " + contentName + " to new parent Sitearea " +
newParentSitearea + " failed. ");
}
%>
Scenario 16: Moving or copying non-hierarchical or root items to

another library
To move or copy any non-hierarchical items (Authoring Templates, Presentation Templates,
Library Components, Workflows, Workflow Stages), or root items (Sites and Taxonomies) to
another library, use the code in listing 16. To move the item to another library, we use the
workspace.moveToLibrary method, which moves non-hierarchical or root items to another
library.
To copy the item, we use the workspace.copyToLibrary method to replace the

workspace.moveToLibrary method, using the same code below.
The code in listing 16 shows how we can achieve this for Authoring Templates, Presentation
Templates, Library components, Workflows, Workflow Stages, Sites, and Taxonomies.
Listing 16. Example code to move or copy root items to another library
<%


// get target library

DocumentLibrary targetDocumentLibrary = workspace.getDocumentLibrary("Target Library");
// ********************** Move Authoring Template example ******************

- 35 -
DocumentId authoringTemplateId = authoringTemplateIterator.nextId();
out.println(" Moving Authoring Template " + authoringTemplateName + " to new
library Target Library ");
// move authoring template to another library

workspace.moveToLibrary(targetDocumentLibrary ,authoringTemplateId );
out.println(" Moved Authoring Template " + authoringTemplateName + " to another
}else {
}
// ********************** Move Presentation Template example ******************

// define presentation template
String presentationTemplateName = new String("PresentationTemplate");
// find presentation template by name

workspace.findByName(DocumentTypes.PresentationTemplate,presentationTemplateName);
if (presentationTemplateIterator.hasNext()){
DocumentId presentationTemplateId = presentationTemplateIterator.nextId();
out.println("Presentation Template found : " + presentationTemplateName + " ");
out.println(" Moving Presentation Template " + presentationTemplateName + " to
new library Target Library ");
// move presentation template to another library

workspace.moveToLibrary(targetDocumentLibrary ,presentationTemplateId ); // Moving
presentation tempate to another library
out.println(" Moved Presentation Template " + presentationTemplateName + " to
another library Target Library ");
}else {
out.println("Could not find Presentation Template: " + presentationTemplateName + " ");
}
// ********************** Move Library Component example *********************
- 36 -

DocumentId libraryComponentId = libraryComponentIterator.nextId();
out.println("Library Component found : " + libraryComponentName + " ");
out.println(" Moving Library Component " + libraryComponentName + " to new
// move library component to new library

workspace.moveToLibrary(targetDocumentLibrary ,libraryComponentId );
out.println(" Moved Library Component " + libraryComponentName + " to
another library Target Library ");
}else {
out.println("Could not find Library Component: " + libraryComponentName + " ");
}
// ************************* Move Workflow example *************************
// define workflow

DocumentId workflowId = workflowIterator.nextId();
out.println(" Moving Workflow " + workflowName + " to new library Target
Library ");
// move workflow to another library

workspace.moveToLibrary(targetDocumentLibrary ,workflowId );
out.println(" Moved workflow " + workflowName + " to another library 
Target Library ");
}else {
}
- 37 -
// ************************ Move Site example ******************************
// define site to be move

String siteName = new String("Site");
// find site by name

DocumentIdIterator siteIterator = workspace.findByName(DocumentTypes.Site,siteName);
DocumentId siteId = null;
out.println("Site found : " + siteName + " ");
out.println(" Moving Site " + siteName + " to new library Target Library
 ");
siteId = siteIterator.nextId();
// move site to another library

workspace.moveToLibrary(targetDocumentLibrary ,siteId );
out.println(" Moved Site " + siteName + " to another library Target Library
 ");
}else {
out.println("Could not find Site : " + siteName + " ");
}
// ********************** Move Workflow Stage example ***********************
// define workflow stage


DocumentId workflowStageId = workflowStageIterator.nextId();
out.println(" Moving Workflow Stage " + workflowStageName + " to new library
 Target Library ");
// move workflowstage to another library

workspace.moveToLibrary(targetDocumentLibrary ,workflowStageId );
out.println(" Moved Workflow Stage" + workflowStageName + " to another
}else {
- 38 -
}
// ************************ Move Taxonomy example *************************
// define taxonomy
String taxonomyName = new String("Taxonomy");

workspace.findByName(DocumentTypes.Taxonomy,taxonomyName);
DocumentId taxonomyId = taxonomyIterator.nextId();
out.println("Taxonomy found : " + taxonomyName + " ");
out.println(" Moving Taxonomy " + taxonomyName + " to new library 
// move taxonomy to another library

workspace.moveToLibrary(targetDocumentLibrary ,taxonomyId );
out.println(" Moved Taxonomy " + taxonomyName + " to another library 
}else {
out.println("Could not find Taxonomy: " + taxonomyName + " ");
}
%>
Scenario 17: Moving or copying a Category within/between libraries

To move or copy a Category in the same library or between libraries, use the code in lisitng 17
below. To move the item in the same or to another library, we use the workspace.moveCategory
method, which essentially moves a category and adds it under a new parent.
To copy the category, we use the workspace.copyCategory method to replace the

workspace.moveToLibrary method, using the same code below.
Note that the example below moves a category to another taxonomy; you can also move the
category to another parent category.
Listing 17. Example code to move or copy a Category

<%
- 39 -
// Set library
// define category to be move

// define parent taxonomy

String newTaxonomy = new String("Taxonomy");

DocumentId taxonomyId = null;
// find category to be moved
}else {
}

workspace.findByName(DocumentTypes.Taxonomy,newTaxonomy);
taxonomyId = taxonomyIterator.nextId();
out.println("Taxonomy found : " + newTaxonomy + " ");
}else {
out.println("Could not find Taxonomy: " + newTaxonomy + " ");
}
if ((categoryId!=null) && (taxonomyId!=null)) {
out.println(" Moving Category " + categoryName + " to new parent taxonomy
" + newTaxonomy + " ");
// move category
- 40 -
workspace.moveCategory(categoryId,taxonomyId);
out.println(" Moved Category " + categoryName + " to new parent taxonomy "
+ newTaxonomy + " ");
}else{
out.println(" Moving Category " + categoryName + " to new parent taxonomy
" + newTaxonomy + " failed ");
}
%>
Scenario 18: Deleting and purging Objects

We can delete and purge all types of objects, using Web Content Management APIs. It’s best to
clear all the references of the object being deleted before deleting the actual object; otherwise, the
deletion will fail.
We can also purge (permanently delete) the object from the repository. The code in listing 18
demonstrates deleting as well as purging a content item and as well as a Library Component.
To delete a Site / Site Area / Taxonomy, you must delete all the children prior to deleting the Sites
/ Site Areas / and Taxonomies.
Listing 18. Example code to delete and purge Objects

<%

// Set library
// ********************** Delete \ Purge Content example **********************
// define content
String[] deleteMessage = new String[1];

- 41 -
// clear all the references of the content

if(workspace.getReferences(contentId)!=null)
workspace.clearReferences(workspace.getReferences(contentId));
// delete content
deleteMessage = workspace.delete(contentId);
out.println("Content deleted :" + deleteMessage);
// purge content
deleteMessage = workspace.purge(contentId);
out.println(" Content purged:" + deleteMessage);
} else {
out.println("Could not delete content :" + contentName);
}
// ****************** Delete \ Purge Library Component example ******************


DocumentId libraryComponentId = null;
libraryComponentId = libraryComponentIterator.nextId();
// clear all the references of library component

if(workspace.getReferences(libraryComponentId)!=null)
workspace.clearReferences(workspace.getReferences(libraryComponentId));
// delete library component

deleteMessage = workspace.delete(libraryComponentId);
out.println("Library Component deleted :" + deleteMessage);
// purge library component

deleteMessage = workspace.purge(libraryComponentId);
out.println(" Library Component purged:" + deleteMessage);
} else {
out.println("Could not delete Library Component :" + libraryComponentName);
- 42 -
}
%>
4 Standards for names specified in all examples

As noted at the beginning of this paper, we have added italicized comments on most of the lines
of code to make it easier to understand both the code and flow.
A few standards have been set while writing the code for the API samples provided. These may
need to be modified and entered with values that are appropriate based on the specifics of the
Web Content Management artifacts on your system:
WebContent. This is taken as the standard library that we are setting in all scenarios
Site. Defined Site Name to be searched or the name already set for a site
NewSite. Name of new site created
SiteArea. Defined Site Area
NewSiteArea. Name of new site area created
Content. Defined Content Name
NewContent. Name of new content created
PublishedContent. Name of the published content
AuthoringTemplate. Defined Authoring Template
PresentationTemplate. Defined Presentation Template
LibraryComponent. Defined library component name
MyComponent. Defined component name
NewImageComponent. Name of new Image Component created
NewRichTextComponent. Name of new Rich Text Component created
Workflow. Defined Workflow name
WorkflowStageName. Defined Workflow Stage name
NewFileComponent. Name of new file resource created
Taxonomy. Defined Taxonomy name
NewParentTaxonomy. Name of new Taxonomy created
Category. Defined Category name to be searched
NewCategory. Name of new category created
Keyword. Defined Keyword
"/Web content/Site/SiteArea/Content. Content path
Source Library. Name of the Source Library defined
Target Library. Name of the Target Library defined
01/01/2008. Sample date selected for Start date
12/31/2009. Sample date selected for End date
5 Conclusion
This document has presented detailed code samples that you can use directly (copying/pasting)
to implement various scenarios using Web Content Management 6.1.0.x APIs, to extend usage of
Web Content Management. Hopefully we have targeted the most common issues faced by
customers in implementing and using APIs.
- 43 -
6 Resources
• IBM WebSphere Portal Version 6.1 Information Center: Web Content Management Edition:
http://publib.boulder.ibm.com/infocenter/wcmdoc/v6r0/index.jsp?topic=/com.ibm.lotus.wcm.do
c/wcm
• IBM WebSphere Portal Version 6.1.0 Information Center:

http://publib.boulder.ibm.com/infocenter/wpdoc/v6r1/index.jsp?topic=/com.ibm.wp.ent.doc_v61
01/reference/wpsdirstr.html
• WebSphere Portal and Lotus Web Content Management product documentation page:
http://www.ibm.com/developerworks/websphere/zones/portal/proddoc.html
• developerWorks WebSphere Portal Family wiki:

http://www-10.lotus.com/ldd/portalwiki.nsf
• Lotus Web Content Management forum:

http://www.ibm.com/developerworks/forums/forum.jspa?forumID=452&S_TACT=105AGX13&
S_CMP=LP
7 About the authors

Bhargav Thakker is a Staff Software Engineer on the WebSphere Web Content Management
team, working out of IBM’s Pune, India, facility. He worked extensively with Java/J2EE-based
Web applications prior to joining IBM in 2006. Bhargav is a Web Content Management certified
developer and holds a degree in Computer Engineering. He can be reached at
bthakker@in.ibm.com.
Soumitra Limaye is the Team Lead for the WebSphere Web Content Management team, working
out of IBM’s Pune, India, facility. He worked extensively with UNIX (admin-scripting) and other
Portal servers such as BEA WebLogic prior to joining IBM in 2006. Soumitra is a Web Content
Management certified developer and holds a degree in Computer Engineering. He can be
reached at soumitra.limaye@in.ibm.com
Trademarks
• IBM, Lotus, Web Content Management, and WebSphere are trademarks or registered
trademarks of IBM Corporation in the United States, other countries, or both.
• Java and all Java-based trademarks and logos are trademarks or registered trademarks of Sun
Microsystems, Inc. in the United States, other countries, or both.
• Other company, product, and service names may be trademarks or service marks of others.
- 44 -

WCM API Scenarios

Încărcat de

Informații document

Descriere originală:

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

WCM API Scenarios

Încărcat de

Drepturi de autor:

Formate disponibile

Implementing common extension scenarios using IBM Lotus

Web Content Management 6.1 APIs

© Copyright International Business Machines Corporation 2009. All rights reserved.

• Web content libraries:

• Search iterators of item IDs:

• Retrieve via item IDs.

• The ability to create, delete and save the following items:

• The ability to retrieve the following items:

o Authoring Template ID (Authoring Template)

• We are not using the try-catch methods to pick up those exceptions.

• Site and taxonomy are considered to be root items.

3 Code samples to implement various scenarios using APIs

Scenario 1: Find an item of a given type by name

Listing 1. Example code to find item by name

// get the workspace for current user

// set the library

// **************************** Find Site example ***************************

// define site name

// find site by name

// ************************* Find Sitearea example **************************

// define sitearea name

// find sitearea by name

// ************************* Find Content example ***************************

// define content name

// find content by name

// *********************** Find Authoring Template example *******************

// define authoring template name

// *********************** Find Presentation Template example *****************

// define presentation template name

// find presentation template by name

// *********************** Find Library Component example *******************

// define library component name

// find library component by name

// *************************** Find Workflow example ***********************

// define workflow name

// find workflow by name

// ************************* Find Workflow Stage example ********************

// define workflow stage name

// find workflow stage by name

// ************************** Find Taxonomy example ************************

// define taxonomy name

// find taxonomy by name

// ************************** Find Category example *************************

// define category name

// find category by name

Scenario 2: Find items based on the item type

This returns an iterator of IDs of all objects of the given type.

Listing 2. Example code to find items by type

// get workspace for current user

// **************************** Find Site example ***************************

// find all sites

// ************************** Find Sitearea example *************************

// find all siteareas

// ************************** Find Content example **************************

// find all contents

// ********************** Find Authoring Template example *********************

// find all authoring templates

DocumentId authoringTemplateId = null;

// ********************* Find Presentation Template example ********************

// find all presentation templates

// ********************** Find Library Component example *********************

// find all library components

// ************************** Find Workflow example *************************

// ** Find Site example *

// * Find Sitearea example **

// * Find Content example ***

// ***** Find Authoring Template example *

// ******* Find Presentation Template example *

// ***** Find Library Component example *

// ***** Find Workflow example *

// ***** Find Workflow Stage example

// ** Find Taxonomy example

// ** Find Category example *

// ** Find Site example *

// ** Find Sitearea example *

// Find Content example

// ** Find Authoring Template example *

// * Find Presentation Template example

// ** Find Library Component example *

// ** Find Workflow example *

// ** Find Workflow Stage example

// ** Find Taxonomy example

// ** Find Category example *

// Find Content by authoring template example **

// * Find Content by Category example *****

// * Find Content by Path example ********

// * Find Content by Workflow Stage example

// *** Find Content since modified date example *

// **** Find Content modified between two dates example *