The XPages Blog

In my previous article I demonstrated how to take an XML stream (in that case an RSS feed) and transform it on the fly using XSLT. This same technique can be used to display Domino data as well.

So the first question is why would we use an Domino XML Data Source instead of a standard view design? I'm glad you asked. A couple of reasons.

Views can be limited to the amount of data that they display in the alloted columns. Using Java and LotusScript developers can write agents that returned well formed XML that can be consumed by both Domino and non-Domino systems.

There is currently an issue with XPages consuming web services when the XPage and the Web Service is hosted on the same Domino Server. If hosting the Web Service and the XPage on separate servers is not an option, then the Web Service logic could be coded as an agent that returns well formed XML that could then be consumed by any system, Domino and non-Domino alike.

Back to the issue at hand. In this article I will demonstrate two ways to display XML data as a data source on an XPage.

• Via XSLT
• Via an XPage Data Table

 

Transforming XML on an XPage via XSLT

This first technique is identical to this previous article on the XPages blog, except that is uses a Domino Agent to supply the XML instead of an RSS feed. So that it is easy for you to duplicate the examples I will be providing I'm going to use names.nsf (local or server) as the data source. This way you can test the example code with "real" data at your house

The following image demonstrates the output of reading an XML data stream, transforming it on the fly with XSLT and displaying the results (there is nothing wrong with your eyes, I just blurred the details as my mom didn't want her email published). The name of the XPage is XPageWithTransfomedDominoXML.xsp in the XML Playground application you can download from here.

The output is produced by running an agent called javanames.xml and applying an XSLT called names.xsl

The Pros of this solution are

• Works well with small data sets
• Results are dynamic
• All document data is available, not just the view data

The Cons to this solution are

• Not easy to apply paging
• All formatting has to be done via CSS added to the transformed output (not a huge con, if you use css classes)
• Must know how to write an XSLT transformation stylesheet.

If that last bullet point applys to you then your question is "Paul, can't I produce these same results via standard XPage controls?" and the answer to the question is yes you can !

Displaying XML data on an XPage using a Data Table control

The following image demonstrates the output of reading an XML data stream, parsing it with the Java 6 XML parser and displaying the results in a standard XPage Data Table control. The name of the XPage is XPageWithXMLDataSource.xsp in the XML Playground application you can download from here.

This technique is accomplished using the following procedure

• Parse the XML and store it to a session scoped variable in the XPages afterPageLoad event
• Add a Data Table control to the XPage
• Add columns to the Data Table for each element of the XML to be displayed
• Add computed field controls to the Data Table columns to display the parsed XML
• Add a pager control to the Data Table for paging purposes

The XPage in design mode looks like the following;

In the XPages afterPageLoad event add the following server side JavaScript to read the XML stream and parse it into an XML document to be stored in the session variable.

//Create the XML Document
var parsedxml:org.w3c.dom.Document = null;

//Create the Parser Factory and document builder
var domfactory:javax.xml.parsers.DocumentBuilderFactory = javax.xml.parsers.DocumentBuilderFactory.newInstance();
var xmldocument:javax.xml.parsers.DocumentBuilder = domfactory.newDocumentBuilder();

//Read the XML from the Domino Agent
var parsedxml = xmldocument.parse("http://localhost/dotoxp.nsf/javanames.xml");

//Store the parsed XML to a session scope variable.
sessionScope.put("names",parsedxml);

Add a Data Table control to the XPage with the following properties.  Notice the "Index name:" variable as it will play an important part in the column formulas.

The Iteration formula (determines how many elements the data table displays) the following Server Side Java Script is used to read the parsed XML variable, read the fullname node list and return the elements of that node list.

 

// Read the parsed XML from the Session scope variable

var domdoc:DOMDocument = sessionScope.get("names");

//Create a node list of all of the fullName elements from the XML Stream

var dtnames:DOMNodeList = domdoc.getElementsByTagName("fullname");

// Return the entire node list

return dtnames;

 

The Data Table control includes a repeat control that repeats the rows for every element of the data source.  Add columns to the Data Table control for each element of the XML stream to be displayed

 In each column add a Computed Field control using the following Server Side JavaScript.  This script will read the parsed XML session scope variable read the specific XML element by tag name, get the current node based upon the row index and then display the value in the column.  This will be repeated for every element in the XML data source.

 

Pros of this technique

• Any XML data source that can be read by URL (even non-Domino data sources) can now be used as data sources on an XPage
• Any of the XML "nodes" can be displayed (all or one)
• Pager control can be added to the Data Table Control to "page" through the data
• CSS formatting can be applied to XPage controls via the designer UI

Cons of this technique

• Currently the data table does not display column headers

 

So now you can start using any accessible XML data stream in you XPage development. 

Don't forget you can download the complete XML Playground application with the included XPage solutions here.

 

As I mentioned in my first article I have been a huge fan of XML and related technologies since XML first came on the scene. So any time I have an opportunity to incorporate XML into my development and it meets a particular need, then I get pretty excited.

So in searching all of the excellent resources on XPages I hadn't yet come across a technique for transforming XML on the fly with an XSLT stylesheet and displaying the results in an XPage. This technique will allow you to use any XML data source (via URL) and transform it with a stylesheet stored in the Domino application and display the results anywhere on your XPage. So a picture being worth a thousand words the result would resemble the following.

 

 

In this particular case I am reading the XPages Blog RSS feed and transforming it into HTML links via XSLT and then rendering the results in the XPage inside of a Panel control.

So here is the walk through.

Design Elements

• URL of XML (In this case it can be any web sites RSS feed URL)
• URL of XSLT (Stylesheet included in the sample application)
• XPage with Computed Field using Server Side JavaScript

Create a new XPage or edit an existing page. Add a computed field to the page. My design looks like the following

 

On the Value tab of the Computed Field controls Properties tab, change the Bind data using to JavaScript. Click on the Open Script Dialog icon to open the Script editor to add the Server Side JavaScript code.

 The following is the Server Side JavaScript code that reads the XML RSS Feed, reads the XSLT stylesheet, creates the result object, performs the transformation and renders the results onto the XPage. 

var xmlSource:javax.xml.transform.Source = javax.xml.transform.stream.StreamSource("http://xpagesblog.com/xpages-blog/rss.xml" );

var xsltSource:javax.xml.transform.Source = javax.xml.transform.stream.StreamSource("http://localhost/XPagePlay.nsf/newsstyle.xsl" );

var result:javax.xml.transform.Result = javax.xml.transform.stream.StreamResult(facesContext

.getResponseWriter());

// create an instance of TransformerFactory

var 

transFact:javax.xml.transform.TransformerFactory = javax.xml.transform.TransformerFactory.newInstance( );

var 

trans:javax.xml.transform.Transformer = transFact.newTransformer(xsltSource);

//return result;

trans.transform(xmlSource, result);

 

 Thats all there is to it.

This technique takes advantage of the fact the during XPage development we have complete access to the entire Java 6 JDK, which includes the XML parsers and transformation engine.

The first line of code reads the RSS XML.  Note that this could be ANY xml.  This example is using RSS because it is readily available for demonstration purposes, but this could be any XML from an accessible web site including a Java or Lotus Script agent on a Domino Server.

The second line of code gets the XSLT stylesheet. Now the Style sheet is specific to the XML source that is being transformed.  In this case the referenced stylesheet will ONLY transform RSS feeds.  But you could write XSLT stylesheets to transform whatever XML you are consuming.

The third line of code creates the transformed results and sets the output to the XPages responseWriter.

Next we create an instance of the transformation factory.

Finally the transformation is performed with the results being written to the XPage.

Using this technique developers can include Domino and non-Domino data sources represented as XML and transformed on the fly to be rendered in the XPage.

I have included an application (XPages Playground) with the complete solution on my web site. 

In my next post I will show how to use raw XML as a data source and output the results to the XPage.