Alfresco Consultant Maurizio Pillitu wrote a blog post about the Maven Alfresco SDK. In his post he shows you how to create projects using the Alfresco Maven archetypes.
The Maven Alfresco SDK allows you to manage the life cycle of your Alfresco projects in a standardized way without the need to download anything other than Maven. Run a single maven command on your console and start doing great work!
Today Alfresco released the Maven Alfresco SDK 1.0. The current version focuses on the Community release, but support for the Alfresco Enterprise is to be expected next month. The release provides complete and documented Maven life cycle support for Alfresco projects including dependency management, packaging and testing.
In Alfresco 4.0 you can transfer files from the repository to a remote file system. You can use it for example to publish static content to a web server. In older Alfresco versions this was only possible for Web Projects that used Alfresco’s AVM (Advanced Versioning Manager) repository.
I had some difficulties setting up the target. This feature does not seem to be documented very well. Luckily Michael McCarthey of Tribloom documented the basic steps on his blog.
Alfresco supports replication jobs that allow you to schedule transfers of content and structure between a source and a target system. In order to use it you first configure a Transfer Target, being a remote Alfresco instance or a File System Transfer Receiver, and then you use these targets in your replication jobs.
In order to succesfully transfer files to a remote file system you need to change the type of the transfer folder to File Transfer Target and you have to make sure to set the end point to /alfresco-ftr/service/api/transfer.
This Alfresco forum post might also be helpful. It explains the difference between the payload property in the replication job and the root folder property in the transfer target.
Last week I received an e-mail from an Alfresco developer with a question about integrating dojox.gantt with Alfresco. The dojox.gantt widget is part of the popular Dojo Toolkit and provides an integrated widget for project and resource management.
I never used the Dojo Toolkit before, but I decided to give it a try and I must say that it is a poweful framework for web application development. In this tutorial I will show you how you can integrate dojox.gantt with Alfresco without much coding thanks to Alfresco’s Web Scripts and CMIS. In the end you will be able to load and save project data from Alfresco into the dojox.gantt widget. I used Alfresco Community 4.0b to test the integration, but it should also work with other versions.
Data Model
The dojox.gantt widget uses a simple JSON format to represent project management data. Here is an example:
The structure consists of one or more project items and each project has zero or more tasks. The first step is to upload a dojox.gantt project file into Alfresco. We will use this file as a source for the project data. The dojox.gantt widget requires at least one project item, otherwise you will not be able to open the context menu to add and update projects and tasks. Create a file called gantt_default.json in Alfresco in the Company Home space and add the following lines:
{"identifier":"id","items":[{"id":1,"name":"Development Project","startdate":"2012-2-11","tasks":[]}]}Web Script
The next step is to create the Web Script. If you are not familiar with the concept of Web Scripts, I suggest that you read this first. On the file system go to the Alfresco Web Scripts folder to create a new Web Script. I used the following location:
tomcat/shared/classes/alfresco/extension/templates/webscriptsFirst create a file called dojox-gantt.get.desc.xml and add the following lines:
<webscript>
<shortname>dojox.gantt</shortname>
<description>dojox.gantt example</description>
<url>/samples/gantt</url>
<authentication>user</authentication>
</webscript>This file declares the Web Script and the URL to access the service. Next create a file dojox-gantt.get.html.ftl and add the following lines:
<html>
<head>
<title>Dojo Gantt test</title>
<link type="text/css" rel="stylesheet" href="http://yandex.st/dojo/1.7.1/dijit/themes/claro/claro.css">
<link type="text/css" rel="stylesheet" href="http://yandex.st/dojo/1.7.1/dojox/gantt/resources/gantt.css">
<script src="http://yandex.st/dojo/1.7.1/dojo/dojo.js" type="text/javascript"></script>
<script type="text/javascript">
dojo.require("dojo.parser");
dojo.require("dojox.gantt.GanttChart");
dojo.addOnLoad(function(){
// put the save code here later
var ganttChart = new dojox.gantt.GanttChart({
readOnly: false,
dataFilePath: "${url.context}/s/cmis/p/gantt_default.json/content",
withResource: false
}, "gantt");
ganttChart.init();
ganttChart.loadJSONData();
});
</script>
</head>
<body class="claro">
<div class="ganttContent">
<div id="gantt">
</div>
</div>
</body>
</html>This file is the view. It loads the required libraries, initializes the Gantt Chart and then loads the data from the server. This line of code is a CMIS get content request to load a file by providing the path:
${url.context}/s/cmis/p/gantt_default.json/contentSince the file is located in Company Home, Alfresco’s root space, providing the name of the file is enough. The /content part of the URL tells Alfresco to return the contents of the file in stead of the object metadata:
In order to test the Web Script first go to the Web Scripts Home page in Alfresco by visiting http://localhost:8080/alfresco/s/. Click the refresh button to add the new Web Script. When you now visit the page http://localhost:8080/alfresco/s/samples/gantt you should see a page similar to this:
When you move the mouse over the project name Requirements you will see a menu to add new tasks.
Saving Data
The dojox.gantt widget is now able to load data from Alfresco using the dataFilePath parameter, but not able to save it back into the system. To save data back into the system you can set a parameter called saveProgramPath in order to provide the server-side script that is able to persist the data. The widget will POST a request to the provided script.
In Alfresco you can create another Web Script to process the POST data, but this requires additional server-side coding. CMIS is able to directly write content back to the server using the same URL as used to read the content, but this requires a PUT method. The dojox.gantt widget by default uses the POST method. I will first show how to use the standard POST method and then we will extend dojox.gantt to use the PUT method.
Server-side Solution
First create another description document called gantt.post.desc.xml in the same directory as where you put the Web Script to read the Gantt chart and add the following lines:
<webscript>
<shortname>dojox.gantt</shortname>
<description>dojox.gantt save example</description>
<url>/samples/gantt/{filename}</url>
<authentication>user</authentication>
</webscript>Next create a JavaScript controller that reads the data submitted by the dojox.gantt widget and saves it back to Alfresco. Create a file gantt.post.js with the following contents:
var filename = url.extension;
if (filename == undefined || filename.length == 0)
{
status.code = 400;
status.message = "Filename not provided.";
status.redirect = true;
}
else
{
var data = args["data"];
var document = companyhome.childByNamePath(filename);
if (document == null)
{
document = companyhome.createFile(filename) ;
}
document.content = data;
document.save();
model.content = data;
}The last part of the Web Script is the view. This file simply returns the JSON data received from gthe dojox.gantt widget. Create a file gantt.post.json.ftl with the following line:
${content}The final part is updating the gantt.get.html.ftl. Add the following parameter to the constructor of dojox.gantt.GanttChart just before the dataFilePath parameter:
saveProgramPath: "${url.context}/s/samples/gantt/gantt_default.json",The result should look like this:
var ganttChart = new dojox.gantt.GanttChart({
readOnly: false,
saveProgramPath: "${url.context}/s/samples/gantt/gantt_default.json",
dataFilePath: "${url.context}/s/cmis/p/gantt_default.json/content",
withResource: false
}, "gantt");Now refresh the Web Scripts and reload the page. Add some tasks to the Gantt chart and click save to save the contents back to Alfresco. You can now save project data back to Alfresco using the default dojox.gantt save method.
Client-side Solution
To avoid server-side coding we can rewrite the dojox.gantt save function to use a PUT in stead of a POST. I prefer this approach as it does not require any custom coding on the server. When using CMIS you can use the same URL as defined in the dataFilePath parameter to save data back to the server.
The Dojo Toolkit provides the ability to extend an object. To support the PUT method, we can rewrite the saveJSONData function in order to use PUT in stead of POST. Add the following lines of code to the body of the dojo.addOnLoad function in the file gantt.get.html.ftl:
dojo.extend(dojox.gantt.GanttChart, {
saveJSONData: function(fileName){
var _this = this;
_this.dataFilePath = (fileName && dojo.trim(fileName).length > 0) ? fileName : this.dataFilePath;
try {
var td = dojo.xhrPut({
url: _this.saveProgramPath,
putData: dojo.toJson(_this.getJSONData()),
handle: function(res, ioArgs) {
if ((dojo._isDocumentOk(ioArgs.xhr))||
(ioArgs.xhr.status == 405)){
alert("Successfully! Saved data to " + _this.dataFilePath);
}else{
alert("Failed! Saved error");
}
}
});
} catch (e){
alert("exception: " + e.message);
}
}
});The function can be found in the file GanttChart.js in the Dojo Toolkit SVN that you can access on the Dojo Toolkit Download page. The only changes required are the replacement of xhrPost with xhrPut and the replacement of the content parameter with a parameter putData with the JSON data as value. The reference documentation for xhrPut is here.
In addition to this change the saveProgramPath needs to be added and since the value is the same as the value of the dataFilePath I added a separate variable saveAndLoadPath for the value:
var saveAndLoadPath = "${url.context}/s/cmis/p/gantt_default.json/content"
var ganttChart = new dojox.gantt.GanttChart({
readOnly: false,
saveProgramPath: saveAndLoadPath,
dataFilePath: saveAndLoadPath,
withResource: false
}, "gantt");There is no need to refresh the Web Script as the only changes were made in the template. When you run this Web Script again you should be able to save any changes back to the system.
Conclusion
As you can see there is not that much work involved to load and save data from dojox.gantt to Alfresco. Thanks to CMIS a single call can both read and write data. The only challenge was to rewrite the save function to use PUT rather than POST. You can use dojox.gantt to create project plans using Alfresco, for example by creating a custom action or through a Share dashlet. The Alfresco developer who e-mailed me about the integration will use dojox.gantt to provide reports on top of Alfresco Share Data Lists. You can for example do this by creating a custom rendition that renders a Share Task List into the JSON structure that can be loaded into dojox.gantt.
Updates
February 19, 2012: added the server-side save method as an example.
Today Jeff Potts, Alfresco’s Chief Community Officer, writes on Social Content that the Alfresco AVM (Alternative Versioning Model) will no longer be supported from Alfresco 5. The AVM was an alternative repository implementation in Alfresco to support Web Content Management use cases. It was designed as some sort of version control system with support for repository virtualization. It was originally designed by Kevin Cochrane who left Alfresco in 2008 to work for Day Software.
I am must say that I am very happy with Alfresco’s decision to get rid of the AVM store. The whole idea behind the virtualization was interesting, but having to work with two repositories always caused a lot of problems. The solution was also too complex for most end users. At Incentro we support a couple of publishers who use Alfresco and publishing to the internet is only one of their channels. For these customers we always had to write custom actions to copy content from one repository to the other using the CrossRepositoryCopyService. End users, including non-technical authors, had to execute a copy action and then they where forced to navigate to the Web Project in order to deploy the content to a web server.
Starting from Alfresco 4.0 you can deploy directly from the DM (Document Management) repository to a web server. I haven’t tried it yet, but you might even be able to add a publishing channel to do the job.
Through an email Jeff Potts commented on my recent post Processing CMIS with Freemarker. In his email Jeff suggested to have a look at the ‘cmis’ root object that is available in Alfresco Community 4.0. I assume it will also be available in the upcoming Alfresco Enterprise 4.0.
Note: Jeff warned that the cmis root object appears to be broken in the current Community release 4c, but it might be fixed in the upcoming release 4d.
Basic Example
To test it in my Alfresco Community 4b release I created a new Web Script in Alfresco Share similar to the one I used to test the approach described in the Freemarker related tutorial. It retrieves a file by path and displays the properties.
The first step is to create the Web Script descriptor. Create a file called ‘sample-opencmis.get.desc.xml’ with the following contents:
<webscript>
<shortname>Open CMIS example</shortname>
<description>Open CMIS Example</description>
<url>/sample/opencmis</url>
</webscript>The next step is to create the controller. We start with a simple example to test the root object. It simply retrieves the root folder and adds it to the model. Create a file called ‘sample-opencmis.get.js’ with the following contents:
var cmisConnection = cmis.getConnection();
var cmisSession = cmisConnection.getSession();
folder = cmisSession.getRootFolder();
model.folder = folder;Finally create the view by adding a file called ‘sample-opencmis.get.ftl’ with the following contents:
<h2>${folder.name}</h2>Now when you refresh your Web Scripts at http://localhost:8080/share/service/index.html you should see a new Web Script called ‘sample/opencmis’. When you run this script using the URL http://localhost:8080/share/page/sample/opencmis, you should see a page similar to this:
Retrieving a Document
You can also use the cmis root object to retrieve content by path or to execute queries. For example to get a file ‘sample.txt’ located in the Company Home folder, you can add the following lines to the JavaScript controller:
doc = cmisSession.getObjectByPath("/sample.txt");
model.doc = doc;You can then use the document in your view, for example to print the name and list the properties:
<h2>${doc.name}</h2>
<ul>
<#list doc.properties as p>
<li>${p.definition.displayName}: ${p.valuesAsString}</li>
</#list>
</ul>This will output the following information:
You can for example also access a number of properties directly like the creationDate, createdBy or versionLabel. To access a property by queryName or id, you can use the following method:
${doc.getPropertyValue("cmis:objectTypeId")}Next Steps
Within the next couple of days I hope to find some time to further explore the features and limitations of the cmis root object, for example how to execute queries, how to set up a remote connection, or even how to create or update content, folders, properties and aspects.
References
The cmis root object does not seem to be extensively documented in the alfresco documentation. Exploring the documentation of the Alfresco OpenCMIS Extension can be very helpful to lookup the available objects and methods. You can adjust them to meet the conventions of either the JavaScript controller or the Freemarker view.
Updates
References
Since its release in version 2.1 Alfresco Web Scripts proved to be extremely useful as a framework to build data oriented services and UI Components. They are even used to develop complete application integrations. Thanks to Web Scripts Alfresco was for example able to deliver one of the first CMIS implementations.
Officially Web Scrips are now part of the Spring Surf Framework, but the Spring community never embraced Surf and it will not surprise me if the maintenance and development of the framework returns to Alfresco in the near future. I think the limited tool support also contributed to the lack of success.
I have always been a great fan of Web Scripts. It is a simple yet powerful MVC framework that allows you to build services with just a couple of simple files. You implement the controller using Server Side JavaScript and the view using Freemarker, a very powerful templating language that can output any text oriented data wheter it is HTML, JSON or some XML based format.
Remote Client
In Alfresco Explorer you have direct access to model objects, but with Alfresco Share this is not the case. Alfresco Share is a remote client that requires you to collect data from the Alfresco backend using a service layer. You can write your own backend services with Web Scripts, but you can also use CMIS or one of the other backend services provided out of the box.
The problem with CMIS is that each request returns an XML response and XML and JavaScript are not a great marriage. With the upcoming CMIS 1.1 you can use JSON as an alternative binding. To some extend you can use the Abdera JavaScript client, but Abdera focuses on Atom entries and as far as I know there is no extension that allows easy access to all the CMIS specific properties.
After writing a lot of lines of code in JavaScript (click here for an example from Alfresco’s 3.4 documentation), I got tired of coding and decided to use a more simple approach by consuming the CMIS data using Freemarker. I am aware that it is the responsibility of the controller to deliver an easy to use model to the view, but Freemarker provides proper support for XML including XPath support.
Example Web Script
The following example Web Script shows how you can pass the CMIS response to the view in the controller layer and use the data within the Freemarker template.
The first step is to define a new Web Script in Alfresco Share. Navigate to the ‘tomcat/shared/classes/alfresco/web-extension/site-webscripts’ folder and create the Web Script. A Web Script consists of a Web Script descriptor, an optional JavaScript controller and a Freemarker template for the view. First create a folder ‘samples’ for the example Web Scripts. In this folder create a file called ‘sample-cmis.get.desc.xml’ with the following contents:
<webscript>
<shortname>XML example</shortname>
<description>XML Example</description>
<url>/sample/cmis</url>
</webscript>The next step is the controller. In the same folder create a file ‘sample-cmis.get.js’ with the following contents:
var connector = remote.connect("alfresco");
var result = connector.get("/cmis/p/sample.txt");
model.doc = stringUtils.parseXMLNodeModel(result.getText());This script first creates a connection with the Alfresco backend. The connection is then used to execute a CMIS request. The request ‘/cmis/p/sample.txt’ retrieves the object data by path for a file called ‘sample.txt’ located in the Company Home root space. I simply created a plain text file in Alfresco with some dummy content and name, title, author and description properties. The CMIS response is then passed to the Freemarker template as an XML document using the parseXMLNodeModel method available in the root scoped object stringUtils (see here).
In order to retrieve values from the model in Freemarker you can now use the XML document. Create a file called ‘sample-cmis.get.ftl’ and add the following lines:
<#ftl ns_prefixes={ "D":"http://www.w3.org/2005/Atom" }>
<p>${doc.entry.title}</p>Since CMIS uses namespaces to combine several schema’s, you need to register the prefixes of the namespaces. In the example above only the default ‘atom’ namespace is registered. Freemarker uses a D as a prefix for the default namespace. If you do not register the namespaces, including the default namespace, Freemarker will not retrieve any values and throw an exception.
In order to register the Web Script in Share you can visit http://localhost:8080/share/service/index.html and click the refresh button. If you then visit the page http://localhost:8080/share/page/sample/cmis you should see a page with the name of the document.
Tip: if you set the mode of Share to ‘development’ in ‘surf.xml’ you do not need to refresh the Web Scripts every time you make changes. You can find the file in ‘tomcat/webapps/share/WEB-INF’.
Adding namespaces
In order to, for example, print the icon of the document, we need to add the Alfresco namespace. Freemarker requires the use of square brackets when selecting elements with prefixes because otherwise the colon would confuse the Freemarker engine. The following template outputs the icon and name of the document:
<#ftl ns_prefixes={ "D":"http://www.w3.org/2005/Atom",
"alf":"http://www.alfresco.org" }>
<p><img src="${doc.entry["alf:icon"]}" />${doc.entry.title}</p>When you revisit the page you should see a page similar to this:
Using XPath
You can also use XPath to select values from the CMIS document. The following template retrieves the Alfresco author property using an XPath expression:
<#ftl ns_prefixes={ "D":"http://www.w3.org/2005/Atom",
"alf":"http://www.alfresco.org",
"cmis":"http://docs.oasis-open.org/ns/cmis/core/200908/" }>
<p><img src="${doc.entry["alf:icon"]}" />${doc.entry.title}</p>
<p>Author: ${doc["//cmis:propertyString[@propertyDefinitionId = 'cm:author']/cmis:value"] </p>You can parse a date value in order to reformat the date like this:
<p>Updated: ${doc.entry.updated?date("yyyy-MM-dd'T'HH:mm:ss")?string("yyyy-MM-dd HH:mm:ss")}</p>In order to retrieve the value, a third namespace prefix was registered to select elements from the ‘cmis’ namespace.
Using The List Directive
You can also retrieve multiple propeties using XPath. The following template lists all the CMIS property display labels and values:
<#ftl ns_prefixes={ "D":"http://www.w3.org/2005/Atom",
"alf":"http://www.alfresco.org",
"cmis":"http://docs.oasis-open.org/ns/cmis/core/200908/" }>
<p><img src="${doc.entry["alf:icon"]}" />${doc.entry.title}</p> <ol>
<#list doc["//cmis:properties/*/cmis:value"] as p>
<li>${p?parent.@displayName}: ${p}</li>
</#list>
</ol>In order to include the properties of aspects, you can for example use the XPath local-name() function:
<#list doc["//*[local-name() = 'properties']/*/cmis:value"] as p>
<li>${p?parent.@displayName}: ${p}</li>
</#list>When you revisit the page, the result should look simliar to this:
Building a model
To make things easier to process in your template you can write a function that returns a map of name and propety values. You can then use the map as you are used to in backend Web Scripts. The following function retrieves the properties and adds them to a map using the property name as a key:
<#function properties doc>
<#assign s = "{"> <#list doc["//*[local-name() = 'properties']/*/cmis:value"] as p>
<#assign s = s + "\"${p?parent.@propertyDefinitionId}\":\"${p}\"">
<#if p_has_next> <#assign s = s + ","> </#if> </#list>
<#assign s = s + "}">
<#return s?eval>
</#function>This is just a basic function that works fine for non-repeatable fields. You can execute the function and use the properties for example in a list directive:
<#assign props = properties(doc)>
<ol>
<#list props?keys as key>
<li>${key}: ${props[key]}</li>
</#list>
</ol>You can of course also get individual properties by property name. The following line outputs the description of the document:
<p>Description: ${props["cm:description"]}</p>The following listing shows the complete Freemarker template using the function:
<#ftl ns_prefixes={ "D":"http://www.w3.org/2005/Atom",
"alf":"http://www.alfresco.org",
"cmis":"http://docs.oasis-open.org/ns/cmis/core/200908/" }>
<#function properties doc>
<#assign s = "{">
<#list doc["//*[local-name() = 'properties']/*/cmis:value"] as p>
<#assign s = s + "\"${p?parent.@propertyDefinitionId}\":\"${p}\"">
<#if p_has_next>
<#assign s = s + ",">
</#if>
</#list>
<#assign s = s + "}">
<#return s?eval>
</#function>
<p><img src="${doc.entry["alf:icon"]}" /> ${doc.entry.title}</p>
<#assign props = properties(doc)>
<ol>
<#list props?keys as key>
<li>${key}: ${props[key]}</li>
</#list>
</ol>When you visit the example page again you will see a listing of all the property names and values:
Conclusion
Although from a design point of view this approach might not be perfect, it provides a means to consume CMIS responses in just a couple of lines of code. If you have other suggestions to consume CMIS documents in Web Scripts, please let me know.
The Learning by Example page from the Freemarker Manual can be a useful resource when processing XML documents with Freemarker.
Updates
References
Friday I will talk about the open standard CMIS (Content Management Interoperability Standard) at the Open Source Conference in Amsterdam. Although CMIS is not exclusively open source, most efforts in promoting this emerging standard seem to come from the open source world.
This is the first year Incentro sponsors this event as a platinum sponsor together with Alfresco. John Powell President and CEO of Alfresco will deliver a keynote about the “insatiable demand for engaging content”. Registration is free of charge. You can register here.
I recently posted three tutorials about transforming XML to PDF using XSL-FO and Alfresco’s Rendition Service. The tutorials do not cover every detail, but they might be helpful to those who are interested in using renditions in Alfresco. Alfresco’s Rendition Service allows you to automatically render content in alternative forms when the content or properties are updated.
This post is a follow-up to the post Using Alfresco Composite Rendition to Render PDF. In this tutorial we will update the Java code in order to persist the composite rendition that creates a PDF rendition using Apache FOP and XSL-FO as an intermediate format.
Follow Alfresco
When you persist a rendition in Alfresco, the system will update a rendition every time the document properties are updated. You can follow Alfresco’s rendition behaviour by adding the following line to the log4j.properties file:
log4j.logger.org.alfresco.repo.rendition=debugPersist a rendition
To make a rendition persistent you need to store the rendition definition using the folowing method:
renditionService.saveRenditionDefinition(compositeDefinition);In addition to adding this line, I also decided to check if the rendition definition already exists, since you call this code every time you add a new rendition to a document.
Updated code
In the following class the updates are highlighted:
package com.someco.action;
import java.util.List;
import org.alfresco.repo.action.ParameterDefinitionImpl;
import org.alfresco.repo.action.executer.ActionExecuterAbstractBase;
import org.alfresco.repo.content.MimetypeMap;
import org.alfresco.repo.rendition.executer.ReformatRenderingEngine;
import org.alfresco.repo.rendition.executer.XSLTRenderingEngine;
import org.alfresco.service.cmr.action.Action;
import org.alfresco.service.cmr.action.ParameterDefinition;
import org.alfresco.service.cmr.dictionary.DataTypeDefinition;
import org.alfresco.service.cmr.rendition.CompositeRenditionDefinition;
import org.alfresco.service.cmr.rendition.RenditionDefinition;
import org.alfresco.service.cmr.rendition.RenditionService;
import org.alfresco.service.cmr.repository.NodeRef;
import org.alfresco.service.namespace.NamespaceService;
import org.alfresco.service.namespace.QName;
public class FoRenditionActionExecuter extends ActionExecuterAbstractBase {
public static final String NAME = "fo";
public static final String PARAM_TEMPLATE_REF = "template";
RenditionService renditionService;
public RenditionService getRenditionService() {
return renditionService;
}
public void setRenditionService(RenditionService renditionService) {
this.renditionService = renditionService;
}
@Override
protected void executeImpl(Action action, NodeRef actionedUponNodeRef) {
QName compRenderingName = QName.createQName(
NamespaceService.CONTENT_MODEL_1_0_URI,
"compRenderingDefinition");
CompositeRenditionDefinition compositeDefinition = (CompositeRenditionDefinition) renditionService
.loadRenditionDefinition(compRenderingName);
if (compositeDefinition == null) {
RenditionDefinition xslDefinition = renditionService
.createRenditionDefinition(QName.createQName(
NamespaceService.CONTENT_MODEL_1_0_URI,
"xslRenderingDefinition"), XSLTRenderingEngine.NAME);
NodeRef template = (NodeRef) action
.getParameterValue(PARAM_TEMPLATE_REF);
xslDefinition.setParameterValue(
XSLTRenderingEngine.PARAM_TEMPLATE_NODE, template);
xslDefinition.setParameterValue(
ReformatRenderingEngine.PARAM_MIME_TYPE, "text/xsl");
RenditionDefinition pdfDefinition = renditionService
.createRenditionDefinition(QName.createQName(
NamespaceService.CONTENT_MODEL_1_0_URI,
"pdfRenderingDefinition"),
ReformatRenderingEngine.NAME);
pdfDefinition.setParameterValue(
ReformatRenderingEngine.PARAM_MIME_TYPE,
MimetypeMap.MIMETYPE_PDF);
compositeDefinition = renditionService
.createCompositeRenditionDefinition(compRenderingName);
compositeDefinition.addAction(xslDefinition);
compositeDefinition.addAction(pdfDefinition);
renditionService.saveRenditionDefinition(compositeDefinition);
}
renditionService.render(actionedUponNodeRef, compositeDefinition);
}
@Override
protected void addParameterDefinitions(List paramList) {
paramList.add(new ParameterDefinitionImpl(PARAM_TEMPLATE_REF,
DataTypeDefinition.NODE_REF, true,
getParamDisplayLabel(PARAM_TEMPLATE_REF)));
}
}Test the rendition
Now if you create a rendition using this custom action, the system will first check if there is already a rendition definition with the same name. If this is not the case, the system persists the rendition definition and creates the rendition.
On any properties update, the system will update the rendition. If you added the log statement to the log properties file, you can trace the rendition engine’s behaviour.
You can check the rendition by locating the document in the node browser. By default the rendition is stored as a hidden child node of the source document.
This blog contains posts about several topics that have my interest including art, photobooks, photography, content management (mainly Alfresco), open source software and open standards, music and food.
Bas Peters
Only interested in a specific topic? Click one of the links below to filter by topic.
View Bas Peters's Linkedin profile
