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
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() { try { // Construct and inital Context InitialContext ctx = new InitialContext(); // Retrieve WebContentService and WebContentLibraryService using JNDI name WebContentService webContentService = (WebContentService) ctx.lookup("portal:service/wcm/WebContentService"); WebContentLibraryService webContentLibraryService = (WebContentLibraryService) ctx.lookup("portal:service/wcm/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); } else { System.out.println("Failed To Delete Library " + m_libraryToDelete); } } catch (Exception e) { e.printStackTrace(); } } }
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. */ try { //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 = (com.ibm.websphere.asynchbeans.WorkManager) ctx.lookup("wm/wpsWorkManager"); //create a new work instance DeleteWork workItem = new DeleteWork(request.getParameter("username"), request.getParameter("password"), request.getParameter("library")); //spawn a thread to run the create work instance wm.startWork(workItem); } 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.