Web Content Library Management APIs | HCL Digital Experience

You can perform various web content library functions by using the Web content API.

  • Create a library
  • Delete a library
  • Copy a library
  • Import a library
  • Export a library
Note: Drafts are not copied or exported when using the API to copy or export libraries.

See the Javadoc documentation for further information. The Javadoc files for Web Content Manager are in the PortalServer_root/doc/Javadoc/spi_docs/com/ibm/workplace/wcm directory.

Invoking web content library API methods asynchronously

Although Web content library API functions can be invoked synchronously, if you run these against web content libraries containing large amounts of data, they may take extremely long to complete execution. For example, if these methods are invoked from a JSP page, this may result in the JSP page being invalidated due to a session timeout.

WebSphere® Application Server uses a mechanism known as asynchronous beans. An asynchronous bean is a Java object that can be run asynchronously. The "Work object" asynchronous bean is used to invoke web content library API methods asynchronously.

A Work object (which is represented by the interface com.ibm.websphere.asynchbeans.Work) extends java.lang.Runnable It is used to run a block of code as an independent thread. WebSphere® Application Server maintains a pool of independent threads that can be assigned to run code encapsulated in Work instances. This pool of threads is managed by the WorkManager. This is used to spawn threads to run Work objects and to monitor them. WebSphere® Application Server maintains default Work Managers for each of the application servers that are contained on a particular node. The sample in this topic makes use of the default Work Manager (wm/wpsWorkManager) for the HCL Portal application server. This maintains a pool of 300 threads. It is possible to create new Work manager instances with customized thread pools. This is done using the WebSphere® Integrated Solutions Console for the HCL Portal server.

The example uses the DeleteWork class to implement the Work interface:

package deletesample;

import com.ibm.workplace.wcm.api.*;
import javax.naming.*;

public class DeleteWork implements com.ibm.websphere.asynchbeans.Work
   private String m_username = null;
   private String m_password = null;
   private String m_libraryToDelete = null;

   public DeleteWork(String username, String password, String library)
      m_username = username;
      m_password = password;
      m_libraryToDelete = library;
   public void release()

   public void run()
		// Construct and inital Context
	    	InitialContext ctx = new InitialContext();

		// Retrieve WebContentService and WebContentLibraryService using JNDI name
		WebContentService webContentService = (WebContentService) 
		WebContentLibraryService webContentLibraryService = (WebContentLibraryService) 

		Workspace ws = webContentService.getRepository().getWorkspace(m_username, m_password);
		DocumentLibrary docLib = ws.getDocumentLibrary(m_libraryToDelete);
		LibraryTaskResult res = webContentLibraryService.deleteLibrary(ws, docLib);

		// Once you get the result object back, print status to StandardOut
		if (res.getResultType() == ResultTypes.OPERATION_SUCCESS)
			System.out.println("Successfully Deleted Library " + m_libraryToDelete);
			System.out.println("Failed To Delete Library " + m_libraryToDelete);
	      catch (Exception e)

The run method is what is required in order to implement this interface. This is where you wrap the library method that you want to run in a thread separate from the calling thread. In the previous example, DeleteWork is instantiated passing in credentials as well as the library to be deleted. In run(), the repository is logged into and a Workspace instance is obtained as is a DocumentLibrary corresponding to the library that is to be deleted. deleteLibrary() is then called to perform the actual deletion. Once this method is completed, the Result object can be queried to determine the status of the deletion. This can then be logged or processed as required.

The following JSP file is used to invoke the DeleteWork object:

<%@ page import="java.util.*" %>
<%@ page import="java.io.*" %>
<%@ page import="java.lang.*" %>
<%@ page import="com.ibm.workplace.wcm.api.*" %>
<%@ page import="com.aptrix.identity.*" %>
<%@ page import="com.ibm.workplace.wcm.services.library.*" %>
<%@ page import="com.ibm.workplace.wcm.services.*" %>
<%@ page import="com.ibm.workplace.wcm.services.repository.*" %>
<%@ page import="com.ibm.websphere.asynchbeans.*" %> 
<%@ page import="javax.naming.*" %> 
<%@ page import="deletesample.DeleteWork" %> 

 *  JSP Sample to demonstrate how to delete a WCM Library 
 *  making use of the WebSphere Application Server
 *  Work asynchronous bean. 

   //obtain a work manager instance - the work manager manages a pool of threads 
   //which can be used to invoke the functionality encapsulated
   // within a work instance
   InitialContext ctx  = new InitialContext();
   com.ibm.websphere.asynchbeans.WorkManager wm  =

   //create a new work instance
   DeleteWork workItem = new DeleteWork(request.getParameter("username"), request.getParameter("password"), 
   //spawn a thread to run the create work instance
catch (Exception e)  
%>  <%= e.toString() %><%

In order to run a Work object, it is necessary to do a JNDI lookup to obtain the default HCL Portal Server Work Manager instance. Once this is done, the DeleteWork class can be instantiated. To run DeleteWork on a separate thread, call startWork() on the WorkManager passing in the DeleteWork instance. For example, wm.startWork(workItem); The System.out log can be checked to see when DeleteWork finishes.