Cédric Bosdonnat - ECM

libcmis 0.4.0 released

2013-08-07T09:54:00+02:00

After quite a long time alternating intensive hacking and inactivity, libcmis 0.4.0 is finally out and brings quite a number of great new features. The hightlight of this release is of course the introduction of the Google Drive protocol as a CMIS binding by Cao Cuong Ngo for his Google Summer of Code project with LibreOffice. This allows to connect to your Google Drive documents in the same way than with any CMIS server.

However there are quite some other important improvements:

Support for OAuth2 authentication for the CMIS servers. This allows libcmis to connect to Alfresco cloud. Most of this feature comes from Cao Cuong Ngo's work.
Allow to provide custom HTTP proxy configuration.
Handle invalid SSL certificates instead of simply failing them. This feature depends if libcurl was built with OpenSSL or not.
Provide repository capabilities
Implement renditions support

And it's not a feature, but a great improvements from libcmis hackers: I removed the Atom binding unit tests depending on Apache Chemistry InMemory server and switched them to a unit test framework using a libcurl mockup. It heavily reduced the unit test execution time, but the WebService binding unit test still have to be migrated to completely get rid of the InMemory server.

You can download libcmis 0.4.0 on SourceForge.net as usual. The package for openSUSE will shortly available on software.opensuse.org

Screenshots of CMIS in Nautilus

2013-08-01T11:24:00+02:00

Michael asked me this week to provide some screenshots of my hackweek work on a GVFS backend for CMIS. Sadly I had none and switched to openSUSE Factory in the mean time so I had to update my code for gvfs master branch. I also had an annoying bug when browsing a CMIS repository in Nautilus... so I had to fix that.

After quite some hours searching, debugging, adding g_print in nautilus, gtk+ and glib, I finally found the culprit: g_vfs_encode_uri was leaving the ':' unencoded in the hostname.

Now I have screenshots to show here:

One from an Alfresco server:

One showing the SharePoint 2013 repositories:

CMIS for GNOME

2013-04-22T13:23:00+02:00

At SUSE, we recently had a Hackweek. It’s one week for all developers employed by SUSE to hack on any innovative open source project they want. Last years, I worked on libcmis and libcmis-c. And this year, I started implementing a GVFS backend for CMIS using libcmis-c. GVFS is the one of the low-level layers of GNOME to access files. A backend is a set of features like mount, unmount, read a document, writ a document, navigate in folders, etc. Currently GVFS has backends for FTP, SSH, WebDAV, Trash, Audio CDs, and quite a lot of other useful things. Having a CMIS backend would allow any Gnome application to access documents stored on a CMIS-enabled server.

What I achieved in one week:

mount and unmount a CMIS repository
read a document
provide the content of the folders and repositories
provide some of the CMIS properties

To have a complete backend to upstream, I will need to implement:

creating / writing files
deleting / moving items
creating folders
setting properties

The code can be found on a gvfs git clone in my freedesktop home. I want to thank the Gnome hackers who kindly answered my beginner questions during this week.

Testing libcurl-based HTTP clients

2013-02-14T14:48:00+01:00

Since the last blog post, quite some nice things happened: I moved to a new house, we released LibreOffice 4.0.0 fantastic release and Markus helped me write better unit tests for libcmis.In this post, I’ld like to give some details on these new unit tests. To understand the need of changing unit tests, you need to know that libcmis test script was downloading, setting up and starting an Apache Chemistry InMemory server to interact with. This system had several drawbacks like slow unit tests and dependency on the test server features and bugs for inventing new test cases. To work this around, Markus helped me to setup a libcurl mockup library.

The principle is pretty simple: replace the normal libcurl used to send the HTTP requests to the server by a mockup library. The mockup can then store the sent requests and provide the responses we want (either valid ones or invalid ones). The code of the mockup is still evolving and can be found in the qa/mockup folder of libcmis source tree. One of the key functions to get it working is curl_mockup_addResponse: it tells the mockup what response to provide under which circumstances. This function may still need some more parameters to cover all cases, but it will associate a response (body, headers, status) with a request (URL, HTTP method). The other important function for testing is curl_mockup_getRequest: it gives back the request content for a URL and HTTP method. It helps making sure that our code sent the proper request.

As always, a small code snippet helps a lot to understand. Let’s take one derived from libcmis unit tests.

void AtomTest::createDocumentTest( )
{
    // Reset the mockup configuration to avoid keeping other tests config
    curl_mockup_reset( );

    // Add a response to match. In this case, a POST request with a URL like
    // http://mockup/mock/children?id=root-folder&amp;somethingelse will fit
    // The response will have:
    //    - the body: "Response body up to server"
    //    - the HTTP status: 201
    //    - the HTTP Headers with Location defined
    curl_mockup_addResponse( "http://mockup/mock/children", "id=root-folder", "POST",
                             "Response body up to server", 201, false,
                             "Location: http://mockup/mock/id?id=create-document\r\n" );

    // Set the authentication credentials needed to fake the server
    curl_mockup_setCredentials( SERVER_USERNAME, SERVER_PASSWORD );

    // Create the CURL handle (in the session for libcmis)
    AtomPubSession session = getTestSession( SERVER_USERNAME, SERVER_PASSWORD );

    // Do something with the CURL handle (the session for libcmis)
    ...

    // You can check that your code worked fine (thanks to the response you provided)
    ...

    // You can also check that the request was the expected one
    // or matched some important criteria (beware of timestamps
    // and variable bits in the requests)
    string request( curl_mockup_getRequest( "http://mockup/mock/children",
                                                                "id=root-folder", "POST" ) );
    CPPUNIT_ASSERT_EQUAL_MESSAGE( "Wrong request  sent", expectedRequest, request );
}

I hope this testing experience can help others testing their HTTP client application based on libcurl. Of course, something similar can be done with other HTTP client libraries.

libcmis 0.3.0 is out

2012-09-13T15:16:00+02:00

Libcmis 0.3.0 just hatched and will bring a whole lot of change to the way you connect to your ECM. Here is are the cool new features that were added in this version:

WebService binding is implemented at the same level than the Atom binding
The session factory has been improved to auto-guess the binding to use based on the provided URL
libcmis-c provides a C wrapper API - Thanks to SUSE hackweek
Object move method has been implemented - Thanks to Grau Data
Versions handling has been implemented with the checkOut, checkIn, cancelCheckout and getAllVersions methods

This new version of libcmis also comes with quite some fixes to support XCMIS and Cloudoku (thanks to GrauData) and SharePoint.

You can download libcmis 0.3.0 on SourceForge.net as usual, or get it for your beloved openSUSE on http://software.opensuse.org.

Alfresco and groups of admins

2008-06-26T11:42:00+02:00

I had to add groups of users as administrators to the Alfresco configuration. As this is a common requested feature, I will explain how I did it. This will also be a good example of how to tweak Alfresco internal classes by overriding its Spring beans. Before reading further, you should have read the howto on Alfresco modules creation.

In an org.alfresco.sample package in the source/java folder of the module, add the following class. This class will subclass the default Alfresco AuthorityService implementation to change only the setAdminUsers() method defining the administrators from the Spring configuration.

public class MyAuthorityService extends AuthorityServiceImpl {
    private TransactionService transactionService;

    @Override
    public void setAdminUsers(Set pConfig) {
        UserTransaction txn = transactionService.getUserTransaction();
        try {
            txn.begin();

            HashSet users = new HashSet();

            Iterator iter = pConfig.iterator();

            while (iter.hasNext()) {
                String authority = iter.next();
                AuthorityType type = AuthorityType.getAuthorityType(authority);

                if (type.equals(AuthorityType.GROUP) && authorityExists(authority)) {
                    // Get all the group's users
                    Set groupLogins = getContainedAuthorities(AuthorityType.USER, authority, false);
                    users.addAll(groupLogins);
                } else {
                    users.add(authority);
                }
            }

            super.setAdminUsers(users);
            txn.commit();
        } catch (Exception e) {
            try { txn.rollback(); } catch (Exception e1) { }
        }
    }

    public void setTransactionService(TransactionService pTransactionService) {
        this.transactionService = pTransactionService;
    }
}

Now that the implementation is changed, we need to tell Alfresco to use it instead of the default one. For this, add the following bean definition to the module-context.xml file. This Spring configuration is a copy of the one in the authority-service-context.xml file with some changes to use our own implementation. As our implementation needs the transaction service, it has been added as a property to the bean configuration.

<bean id="authorityService" class="org.alfresco.sample.MyAuthorityService">
    <property name="authenticationComponent">
        <ref bean="authenticationComponent" />
    </property>
    <property name="personService">
        <ref bean="personService" />
    </property>
    <property name="nodeService">
        <ref bean="nodeService" />
    </property>
    <property name="authorityDAO">
        <ref bean="authorityDAO" />
    </property>
    <property name="permissionServiceSPI">
        <ref bean="permissionServiceImpl" />
    </property>
    <property name="transactionService">
        <ref bean="transactionService" />
    </property>
    <property name="adminUsers">
        <set>
            <value>admin</value>
            <value>GROUP_Administrators</value>
        </set>
    </property>
</bean>

It is now possible to set the full name of a groupe in the administrators' list. In the example case, all the users of the GROUP_Administrators group will be administrators of Alfresco.

Howto create a new Alfresco module

2008-06-17T08:41:00+02:00

This post aims at explaining how to set up Eclipse to build a new Alfresco module easily. Before continuing to read, be sure to have downloaded Alfresco and its Software Development Kit (SDK). Of course the following will assume that you have an installed Eclipse with the J2EE plugins. This article will not explain all the technical details on AMP files, for more informations on this topic, please refer to the corresponding Alfresco Wiki page.

This post will be composed of the following parts:

Creating the project
Useful settings for Alfresco development

Creating the project

First we need to create a common Java project in Eclipse. What will be interesting here is only how to structure the project and build it easily. The only tricky thing during the project creation is to remove the default source folder and replace it by two source/java and config folders. Don't forget to add the Alfresco embedded SDK project as a dependency of the new project.

In the newly created project, create the following folders:

source/web/jsp: this folder is mapped to the jsp folder in the Alfresco WAR
source/web/scripts: this folder is mapped to the scripts folder in the Alfresco WAR
source/web/images: this folder is mapped to the images folder in the Alfresco WAR
source/web/css: this folder is mapped to the css folder in the Alfresco WAR
lib: this folder will contain all the third party dependencies to include in the AMP file
WEB-INF: this folder will be mapped to the WEB-INF folder of the Alfresco WAR.

Now that the useful folders are created, we need to create the mandatory files of an Alfresco module package. Before continuing, please choose an identifier for the module: this will be needed in the next steps. For this tutorial I will named the module sample. The AMP file will need to have a descriptor file. This one will be a module.properties file created at the project's root. This file will need to contain the following properties:

module.id: the chosen identifier for the module. In my case: sample
module.version: the module version. Let's put 1.0 for a first version, but don't forget to change it afterwards
module.title: a displayable title for the module
module.description: a longer description for the module
module.repo.version.min: the minimum required version of Alfresco
module.repo.version.max: the maximum possible version of Alfresco

The module is almost ready, but there is still to add the module-context.xml file. This one will have to be placed in a alfresco.module.<your_id> package. In the example case, the file will need to be created in a alfresco.module.sample package in the config folder. This file only needs to contain the following content:

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE beans PUBLIC '-//SPRING//DTD BEAN//EN' 'http://www.springframework.org/dtd/spring-beans.dtd'>
<beans>
</beans>

All the spring configuration can go in the beans tag of this file. However you can also place it in files ending with -context.xml in a alfresco.extension package in the source/java folder. All the Java classes to package in a JAR and deploy with the AMP have to be placed somewhere inside the source/java folder.

To make Alfresco use the WEB-INF folder in the AMP file, you need to add a new file-mapping.properties file at the project's root containing the following line. Do not use the WEB-INF folder unless you really know what you are doing!

/WEB-INF = /WEB-INF

Now that all the important parts of the project are created we need to write an ANT build file to transform this into a valid AMP file. The ANT build file will need to know the path where to find the Alfresco SDK: this will need to be configured in a build.properties file. I won't explain the details of the ANT build file as this is not an ANT tutorial. However you will see that it is composed of the following targets:

clean: cleans the build results
compile: compile the Java code in the source/java folder and copy the resources in the build output tree
package-jar: package the results of the compile target into a JAR file
package-amp: package the JAR file, libraries, WEB-INF, config folders and configuration files into an AMP file

The ANT build file is a build.xml file at the project's root. This file will contain the code shown by the following snippet. Of course it can be changed to fit your needs, but don't forget to update the project's structure if necessary.

<?xml version="1.0"?>

<project name="Sample Module" default="package-amp" basedir=".">

    <property name="project.dir" value="."/>
    <property file="${project.dir}/build.properties"/>
    <property file="${project.dir}/module.properties"/>

    <property name="build.dir" value="${project.dir}/build"/>
    <property name="config.dir" value="${project.dir}/config"/>
    <property name="jar.file" value="${build.dir}/lib/${module.id}.jar"/>
    <property name="amp.file" value="${build.dir}/dist/${module.id}.amp"/>

    <target name="mkdirs">
        <mkdir dir="${build.dir}/dist" />
        <mkdir dir="${build.dir}/lib" />
        <mkdir dir="${build.dir}/classes" />
    </target>

    <path id="class.path">
        <dirset dir="${build.dir}" />
        <fileset dir="${project.dir}/lib" includes="**/*.jar" />
        <fileset dir="${alfresco.sdk.dir}/lib/server" includes="**/*.jar" />
    </path>

    <target name="clean">
        <delete dir="${build.dir}" />
    </target>

    <target name="compile" depends="mkdirs">      
        <javac classpathref="class.path" debug="${debug}" srcdir="${project.dir}/source/java" 
            destdir="${build.dir}/classes" target="1.5" encoding="UTF-8"/>
        <copy todir="${build.dir}/classes">
            <fileset dir="${project.dir}/source/java" defaultexcludes="false">
                <exclude name="**/*.java"/>
                <exclude name="**/.svn/**"/>
                <exclude name="**/CVS/**"/>
            </fileset>
        </copy>
    </target>

    <target name="package-jar" depends="compile">
        <jar destfile="${jar.file}" encoding="UTF-8">
            <fileset dir="${build.dir}/classes" excludes="**/custom*,**/*Test*" defaultexcludes="false" />
        </jar>
    </target>

    <target name="package-amp" depends="package-jar" description="Package the Module" >
        <zip destfile="${amp.file}" encoding="UTF-8">
            <fileset dir="${project.dir}/build" includes="lib/*.jar" />
            <fileset dir="${project.dir}" includes="config/**/*.*" excludes="**/module.properties" />
            <fileset dir="${project.dir}">
                <include name="module.properties"/>
                <include name="file-mapping.properties" />
                <include name="WEB-INF/**/*" />
                <include name="lib/**/*" />
                <exclude name="WEB-INF/alfresco.tld"/>
                <exclude name="WEB-INF/repo.tld"/>
            </fileset>
            <zipfileset dir="source/web" prefix="web"/>
        </zip>
    </target>
</project>

The ANT build file will try to find some configuration in a build.properties file. This file will have to be created under the project's root and have to contain the following properties:

alfresco.sdk.dir: the absolute path to the Alfresco SDK to build the module for.
debug: true if the module should be build with the debugging symbols. This property is not mandatory.

Useful settings for Alfresco development

Now that the module is ready for development, here are some Eclipse tricks to ease the Alfresco developement.

Copy the tomcat/webapps/alfresco/WEB-INF/classes/alfresco/model/modelSchema.xsd into the SDK folder and add it to the Eclipse XML Catalog in Window > Preferences. This schema doesn't cover the constraints in Alfresco model definitions, but it saves a lot of time fixing dummy syntax errors or typos.
You can do the same with the tomcat/webapps/alfresco/WEB-INF/classes/alfresco/auditSchema.xsd file.
Copy the alfresco.tld and repo.tld files into the WEB-INF folder of your project. This will provide auto-completion for the Alfresco tags when writing your JSP pages.
Install the Eclipse plugin for FreeMarker support: it helps a lot to write template and webscripts.

With the created module project and some Eclipse configuration, you are now ready for Alfresco extensions development. You can still improve the ANT build file by adding some target to auto-deploy your changes... Don't forget to have a look at the post explaining how to debug an Alfresco extension: this can save a lot of time too during your module development.

Debugging an Alfresco extension

2008-06-10T08:45:00+02:00

You may remember that I have written a post on how to debug an OpenOffice.org extension. This post is about to explain how to do the same for an Alfresco extension. In fact the principle is the same. To set Alfresco in a debug mode, edit the tomcat/bin/startup.sh file and change the last line into:

exec "$PRGDIR"/"$EXECUTABLE" jpda start "$@"

The next time Alfresco is started it will be listening on the 8000 port. Then you will be able to set up the Eclipse debugging session in the same way than the one I described in the post on OOo extension debugging.

To avoid lengthy Alfresco restarts when you change some code, you can unset the automatic build, and use the Project > Build All menu for a hot replace of code. This doesn't work when you have changed the signature of a method or of a class. There are some cases where it doesn't work... but I still haven't identified why it sometimes fails. I only have noticed that you shouldn't change code when the debug session isn't running or when you are stepping in the code.

Removing My Alfresco

2008-06-09T16:24:00+02:00

I needed to remove the My Alfresco part in Alfresco Navigator. This is a piece of JSF hack that I'll share here. The way it is done here isn't the way it should be done in order to properly package it... but it's a hack.

Copy the source code of the org.alfresco.web.ui.repo.component.UINavigator class and remove the following blocks:

else
{
    treePanel = false;
    areaTitle = Application.getMessage(context, NavigationBean.MSG_MYALFRESCO);
}

and

if (NavigationBean.LOCATION_MYALFRESCO.equals(area) == false)
{
    encodeSidebarButton(context, out, sideBarStyle,
                        NavigationBean.LOCATION_MYALFRESCO,
                        NavigationBean.MSG_MYALFRESCO);
}

Compile the Java class and put the result into a JAR file. Then place the jar file into the WEB-INF/lib folder and restart Alfresco.

Of course you should also remove the tag corresponding to My Alfresco in the jsp/parts/titlebar.jsp page to remove the link from the page.

Alfresco Database schema

2008-06-05T08:32:00+02:00

I'm often looking for some precise informations in Alfresco database. This is quite hard when you don't have a graph showing the database schema.

I have recently discovered that SQuirreL SQL could help me in this task. Select each table to show in the graph, right-clic and select Add to graph. There is now only to reorganize the graph manually to make it readable. The graph can be renamed and saved with the contextual menu of the graph.

Here is a picture showing Alfresco database schema created using this method.

Toggle Alfresco in a read-only mode

2008-06-04T18:35:00+02:00

Have you ever wondered how to keep Alfresco running while backing it up? As you may have found it, Alfresco database and data filesystem have to be saved in a coherent state. For this, Alfresco should be turned off, or in a read-only mode. A read-only mode is also useful for some maintainance operations.

On Alfresco 1.4, I could put it in a read-only mode by changing the transactions.properties file and restarting Alfresco. This doesn't work on Alfresco 2.1 as Alfresco tries to write some informations in the system repositories during the bootstrap. Thus the only way to set it in a read-only mode is to do it without stopping it, by interacting with the TransactionService. This post is about to explain how to create a webscript to toggle Alfresco in read-only or read-write mode.

Who's using my Alfresco?

2008-05-31T19:25:00+02:00

Every shared file server administrator has this problem: "who is taking most of the space?". This question is also a valid one for Alfresco administrators, but they do not have any easy tool to answer it. Adding this feature to Alfresco isn't very hard but for those who prefer reusing the others work, I will present a piece of Freemarker template doing it. This template will be also a good way to introduce interesting Alfresco Freemarker use.

First, here is a preview of the final result.

I will present the template file in two steps:

Showing a table with the current space children and their total size
Showing the same information as a pie chart

STEP 1: Showing the table

First of all, having a function returning the total size of a space is necessary. This function will have to recurse over the whole hierarchy to compute the real size of the space. The following piece of Freemarker code defines this function and can be called either on a container or on a leaf of the tree.

<#function getSize node>
    <#assign sum = 0/>
    <#if node.children?size = 0>
        <#assign sum = node.size/>
    <#else&gt;
        <#list node.children as child>
            <#assign sum = sum + getSize(child)/>
        <!--#list-->
    <!--#if-->
    <#return sum />
<!--#function-->

Now that the function computing a node's real size is written, the template showing the table is easy to do. Here is a way to do it like the screenshot. The only noticeable point in this code could be the way to alternate the CSS class for the data rows.

<table class="recordSet" border="0" cellspacing="0" cellpadding="0" width="100%">
    <tbody>
        <tr>
            <th class="recordSetHeader" style="padding: 2px; text-align: left;">Node</th>
            <th class="recordSetHeader" style="padding: 2px; text-align: left;">Size (in Byte)</th>
        </tr>
        <#if document?exists>
        <tr class="recordSetRow">
            <td>${document.name}</td>
            <td>${getSize(document)}</td>
        </tr>
        <#else>
        <#assign i = 0/>
        <#list space.children as child>
        <tr class="${(i % 2 = 0)?string(">
            <td style="padding: 2px; text-align: left;">${child.name}</td>
            <td style="padding: 2px; text-align: left;">${getSize(child)}</td>
        </tr>
        <#assign i = i + 1 />
        <!--#list-->
        <!--#if-->
    </tbody>
</table>

STEP 2: Showing the pie chart

To show a chart, an existing library for charts creation will be necessary. I have chosen to use PlotKit Javascript library. This library depends on the MochiKit Javascript library. There is an example of chart with labels among the PlotKit examples to know how to create the pie chart with the children names as labels. The problem is that the JavaScript function used to create the chart will need the data and these ones can't be computed another time for obvious performance reasons.

The previously written function will have to be reused to produce the JavaScript function. In order to reuse the data for both the chart and the table, the data have to be put in a Freemarker sequence. But as creating an empty Freemarker sequence and fill it in a loop doesn't seem to be possible, the only solution is to create the Freemarker definition of the sequence and evaluate it. Here is how to do it:

<#assign ftlArray = "["/>
<#if document?exists>
    <#assign ftlArray = "[["" + document.name + ""," + getSize(document)?c + "]]"/>
<#else>
    <#assign first = true />
    <#list space.children as child>
        <#if first = false>
            <#assign ftlArray = ftlArray + ","/>
        <!--#if-->
        <#assign ftlArray = ftlArray + "["" + child.name + ""," + getSize(child)?c + "]" />
        <#assign first = false/>
    <!--#list-->
    <#assign ftlArray = ftlArray + "]"/>
<!--#if-->

<#assign values = ftlArray?eval/>

After this Freemarker code, the values variable will contain the data as a sequence of sequences. The JavaScript function to add in the template and the HTML tag for the chart rendering are done in the following way. For it to work, the files provided in the lib/MochiKit directory of the MochiKit distribution and the files found in the PlotKit directory of the MochiKit distribution have to be placed in /scripts/mochikit and /scripts/plotkit in the alfresco WAR.

<script src="/alfresco/scripts/mochikit/MochiKit.js" type="text/javascript"><!--mce:0--></script>
<script src="/alfresco/scripts/plotkit/excanvas.js" type="text/javascript"><!--mce:1--></script>
<script src="/alfresco/scripts/plotkit/Base.js" type="text/javascript"><!--mce:2--></script>
<script src="/alfresco/scripts/plotkit/Layout.js" type="text/javascript"><!--mce:3--></script>
<script src="/alfresco/scripts/plotkit/Canvas.js" type="text/javascript"><!--mce:4--></script>
<script src="/alfresco/scripts/plotkit/SweetCanvas.js" type="text/javascript"><!--mce:5--></script>

<script type="text/javascript"><!--mce:6--></script>

The chart will be rendered in the canvas element. The code shown in the first step for the table printing has to be adapted to use the values variable instead of using directly the getSize() function.

In order to use the template, place it in the Data Dictionary/Presentation Templates space in Alfresco. Then simply apply the template on the space for which to get the table and chart.

Here are some useful links to create more templates like this one for Alfresco:

Freemarker reference
Alfresco Freemarker guide
Alfresco Freemarker cookbook

Alfresco and categories

2008-05-23T20:15:00+02:00

Have you ever counted the number of clics needed to select a Category on a document in Alfresco? The user interface for the category selection was really hard to understand for a normal user up to in the 2.x series and will be improved in the 3.0 version. This can already be tested in the 2.9 Beta version.

I have worked on a little test with RichFaces to make it better. When I hear that the 2.9 had changed the categories selection I needed to see how it was done... It's better than the previous interface but not yet perfect for me: my test is still useful.

My test presents the categories as a tree in a modal dialog. Here is a screenshot to better understand what I am talking about.

As you can guess this is a test on a blank page... it still needs to be integrated but it looks promising. To make it work I am using a combination of the JSF RichFaces taglib and WebScripts.

The next steps are

to support list of categories
to embed all the JSF part into a tag lib to make it easier to embed everywhere
test it as a replacement for Alfresco standard categories selection UI

That said Alfresco 2.9 has a nice feature around the categories. In the left panel you can show the list of your document sorted in the categories tree...

Useful link: the RichFaces live demo.

Changing Alfresco Breadcrumb

2008-05-23T08:05:00+02:00

Since I am configuring and installing Alfresco for customers I have a remark about the breadcrumb. Many of the customers want it to be a path showing the current node location instead of the default breadcrumb. In fact it behaves like a path if you are using only the browsing interface, but not if you are using the navigator on the left. This is often seen as a bug by the users.

The good news is that Alfresco breadcrumb will be configurable in version 3.0. This feature is already present in Alfresco 2.9. The Web client customisation FAQ page from the Alfresco Wiki explains how to configure it. However, if you want this feature on a previous version of Alfresco this can also be done... even if it is a bit more tricky.

To do this, you will have to override the org.alfresco.web.ui.common.renderer.BreadcrumbRenderer class and implement the encodeBegin() method yourself by using the NavigatorBean.getCurrentNode() method and the NodeService. To make Alfresco use your renderer instead of the defaults, don't forget to add something like the following section in the faces-config-custom.xml file:

<render-kit>
    <renderer>
     <component-family>org.alfresco.faces.Controls</component-family>
    <renderer-type>org.alfresco.faces.BreadcrumbRenderer</renderer-type>
    <renderer-class>some.company.alfresco.MyBreadcrumbRenderer</renderer-class>
    </renderer>
</render-kit>

And do not forget to change the class name in this small XML code...

Using webscripts to extend Alfresco Web client

2008-05-18T23:39:00+02:00

Alfresco Webscripts are really easy to code and can help to do many things (but not the coffee yet). They can even be used to create new dialogs in Alfresco, for example to show some custom informations. This post will explain how to setup a simple mechanism to help creating Alfresco dialogs based on webscript with only an action configuration.

The steps are the following:

Create a generic dialog configured in web-client-config-custom.xml
Create the Webscript to display in the dialog
Create the action configuration to display the dialog with the webscript

In this post, I will assume that you already have a webscript to show and that you are already quite used to Alfresco extensions developement: these could be topics for some other posts and are well explained on Alfresco Wiki.

Alfresco Webscripts contest

2008-03-24T18:46:00+01:00

Only 7 days before the end of the first period of the Alfresco Webscript contest. Alfresco has launched a context to stimulate the creation of nice and useful webscripts from the community. You can read the Alfresco contest page to get more informations on this context.

During my previous missions an Alfresco, customers often complains that there is no tool to easily view the permissions of a given user. In the Alfresco web client, the administrator has to navigate to the space or document, look for the permissions and possibily needs to look at the permissions set on the parent spaces. I submitted a webscript for this problem to the contest. This Alfresco WebScript shows all the permissions of the selected user on the content. If you click on the permissions summary you even have all the roles set for the user.

Here is a screenshot of the webscript:

The WebScript module can be downloaded from here:

alfresco-admin.amp

My first post on Alfresco

2008-03-10T10:03:00+01:00

Even if I'm working on Alfresco projects for a little bit more than one year, I haven't posted any message on this development adventure. Today will be the first post on that topic but maybe not the only one.

To get introduced to Alfresco development it takes quite a long time because of the numerous extension points and concepts to learn. A good starting point is to read the Developers guide on the wiki. However, unlike many other internet resources you will need to read it quite sequentially if you want to understand everything... otherwise you will be told about Data Dictionary and Model and you won't know what it is (this is an example).

There are several ways to extend Alfresco. The following ones are some examples:

Extend or customize the Web Client using JSF development or Alfresco actions creation
Create jBPM workflows, Javascript automated rules, Java behaviour policies
Extend the existing Data Model to match your needs
Extend the Alfresco Core using Spring beans
Extend the remote API using WebScripts and defining your own REST API

I will certainly detail some interesting development points or existing Alfresco extensions in next posts: stay tuned...