Password Reset

This question is sometimes asked on answers or in the forum. It’s a method to handle password reset for users. So I’m going to show you how I would do it. This is going to be a two part blog. Today I’ll write mostly about the WebEngine module handling the password reset functionality. Next week I’ll show you how to package it for Nuxeo’s Marketplace.

How does it work?

Starting with something simple, we’ll add a ‘forgotten password’ link on Nuxeo’s home page. It will redirect the user to an open (i.e. no authentication needed) page asking for an email address. Once the user submits the form, we’ll look in the user directory to see if the email has a corresponding user. If there’s no user, we’ll simply render the page again with an error message saying there’s no user associated with that email address. If we do find a user, we generate a temporary link and send it to the user by email. This link has to exist for only a short period of time, for security reasons. When the user clicks on the link, he ends up on a form asking for his new password.

That’s it for the simple, short user story. We’ll see the details along the way. Now let’s get to it :)

Ask for the reset

The first thing I did was to run the Nuxeo WebEngine project wizard with Nuxeo IDE. This gives me an empty project. I’m already able to code :) My next step is to create the form to retrieve the user email and make it available to an open URL.

This is my form:

<@extends src="./base.ftl">
<@block name="title">
 ${Context.getMessage('label.askResetPassForm.title')}
</@block>
<@block name="content">

<div class="registrationForm">
<form action="${This.path}/sendPasswordMail" method="post" enctype="application/x-www-form-urlencoded" name="submitNewPassword">
 <table>
    <tr>
      <td class="login_label">
        <span class="required">${Context.getMessage('label.registerForm.email')}</span>
      </td>
      <td>
        <input type="text" id="EmailAddress" value="${data['EmailAddress']}" name="EmailAddress" class="login_input" isRequired="true"/>
      </td>
    </tr>
    <tr>
      <td></td>
      <td>
        <input class="login_button" type="submit" name="submit"
          value="${Context.getMessage('label.registerForm.submit')}" />
      </td>
    </tr>
  <#if err??>
    <tr>
      <td colspan="2">
        <div class="errorMessage">
          ${Context.getMessage("label.connect.trial.form.errvalidation")}
          ${err}
        </div>
      </td>
    </tr>
  </#if>
  <#if info??>
    <tr>
      <td colspan="2">
        <div class="infoMessage">
          ${info}
        </div>
      </td>
    </tr>
  </#if>
  </table>
</form>
</div>
</@block>
</@extends>

One of the cool features that comes with WebEngine is its templating model. It gives us the ability to extend an existing Freemarker template. This way you can override only the part of the template you need. For instance, here we’re extending the base.ftl template (that’s because of the extends markup). This template defines at least two blocks named ‘title’ and ‘content’. So we can redefine the content of these two using the block markup.

And this is the contribution to the openUrl extension point. It’s needed to make my form available without user authentication.

  <extension
    target="org.nuxeo.ecm.platform.ui.web.auth.service.PluggableAuthenticationService"
    point="openUrl">
    <openUrl name="Forgotten_password">
      <grantPattern>${org.nuxeo.ecm.contextPath}/site/resetPassword/</grantPattern>
    </openUrl>
    <openUrl name="SendPasswordMail">
      <grantPattern>${org.nuxeo.ecm.contextPath}/site/resetPassword/sendPasswordMail</grantPattern>
    </openUrl>
    <openUrl name="EnterNewPassword">
      <grantPattern>${org.nuxeo.ecm.contextPath}/site/resetPassword/enterNewPassword/.*</grantPattern>
    </openUrl>
    <openUrl name="SubmitNewPassword">
      <grantPattern>${org.nuxeo.ecm.contextPath}/site/resetPassword/submitNewPassword</grantPattern>
    </openUrl>
    <openUrl name="Graphical_Resources">
      <grantPattern>${org.nuxeo.ecm.contextPath}/site/skin/resetPassword/.*</grantPattern>
    </openUrl>
  </extension>

Now let’s get to the Java part. The doGet method will render the page I’ve just defined, while the sendPasswordMail method will handle the form submit. In the latter, we will do the email validation, look if we have an existing user with the given address, and if this is the case, we’ll send him an email.

The validation is really simple here — we just check if the given parameter is not null nor empty. Then if we have an email address, we go through the CreatePasswordResetLinkUnrestricted. This is the class where we look for the user, build a reset password link if the user exists, or render our page with an error message. I’ve tried to internationalize the email a little, but you still have to fork the code to modify the templates and subjects… I’ll try to enhance that later.

    @GET
    public Object doGet() {
        Map<String, String> data = new HashMap<String, String>();
        return getView("newPasswordRequest").arg("data", data);
    }

    @POST
    @Path("sendPasswordMail")
    @Produces("text/html")
    public Object sendPasswordMail() throws ClientException {
        FormData formData = getContext().getForm();
        String email = formData.getString("EmailAddress");
        if (email == null || "".equals(email.trim())) {
            return redisplayFormWithErrorMessage("newPasswordRequest",
                    ctx.getMessage("label.registerForm.validation.email"),
                    formData);
        }
        email = email.trim();
        CreatePasswordResetLinkUnrestricted runner = new CreatePasswordResetLinkUnrestricted(
                getDefaultRepositoryName(), email);
        runner.runUnrestricted();

        String errorMessage = runner.getErrorMessage();
        if (errorMessage != null) {
            return redisplayFormWithErrorMessage("newPasswordRequest",
                    ctx.getMessage(errorMessage), formData);
        } else {
            String passwordResetLink = runner.getPasswordResetLink();
            String subject;
            Template template;
            if (ctx.getLocale().equals(Locale.FRENCH)) {
                template = getView("mail/passwordForgotten_fr");
                subject = "Nuxeo - Votre nouveau mot de passe";
            } else {
                template = getView("mail/passwordForgotten");
                subject = "Nuxeo - Your new password";
            }
            String message = template.arg("passwordResetLink",
                    passwordResetLink).render();
            try {
                sendEmail(email, subject, message);
            } catch (MessagingException e) {
                // issue while sending the mail
                log.error("Sending Registration E-Mail Error", e);
                return Response.status(500).build();
            }
            return redisplayFormWithInfoMessage("newPasswordRequest",
                    ctx.getMessage("label.sendPasswordMail.emailSent"),
                    formData);
        }
    }

    protected Template redisplayFormWithMessage(String messageType,
            String formName, String message, FormData data) {
        Map<String, String> savedData = new HashMap<String, String>();
        for (String key : data.getKeys()) {
            savedData.put(key, data.getString(key));
        }
        return getView(formName).arg("data", savedData).arg(messageType,
                message);
    }

    protected Template redisplayFormWithInfoMessage(String formName,
            String message, FormData data) {
        return redisplayFormWithMessage("info", formName, message, data);
    }

    protected Template redisplayFormWithErrorMessage(String formName,
            String message, FormData data) {
        return redisplayFormWithMessage("err", formName, message, data);
    }

    public void sendEmail(String email, String subject, String message)
            throws MessagingException {
        Composer cp = new Composer();
        Mailer mailer = cp.getMailer();
        Mailer.Message msg = mailer.newMessage();
        msg.setFrom(MAIL_FROM);
        msg.setSubject(subject);
        msg.setRecipient(RecipientType.TO, new InternetAddress(email));
        msg.setContent(message, "text/html");
        msg.send();
    }

Manage the keys

Now we’re able to retrieve and email address, find the corresponding user and send the email. Under the hood, the CreatePasswordResetLinkUnrestricted generates a unique key, stored in a directory along with the user email address and the current date. A directory is a good fit to store our temporary keys. I will delete every one-day-old key using Nuxeo’s event system.

Let’s add a contribution to the scheduler service. It will raise the cleanResetPassKeys event every day at 1am.

  <extension
    target="org.nuxeo.ecm.platform.scheduler.core.service.SchedulerRegistryService"
    point="schedule">
    <schedule id="cleanResetPassKeys">
      <username>Administrator</username>
      <eventId>cleanResetPassKeys</eventId>
      <eventCategory>default</eventCategory>
      <cronExpression>0 0 1 * * ?</cronExpression>
    </schedule>
  </extension>

So what we need to do now is add a listener for the cleanResetPassKeys event.

Here’s the code of my listener. It’s straightforward. The simpleDate String is the previous day’s date, formatted the same way we stored it in the directory. We use it as a directory filter. This way we can retrieve all keys created the day before and delete them. What I’d like to do in the future is make this configurable in the Admin Center. That way, the administrator could choose the time to live for the key.

public class CleanForgottenPasswordKeysListener implements EventListener {

	public static final Log log = LogFactory
			.getLog(CleanForgottenPasswordKeysListener.class);

    @Override
    public void handleEvent(Event event) throws ClientException {
		SimpleDateFormat sdf = new SimpleDateFormat("yyMMdd");
		Calendar yesterday = Calendar.getInstance();
		yesterday.add(Calendar.DATE, -1);
		String simpleDate = sdf.format(yesterday.getTime());
		DirectoryService ds;
		try {
			ds = Framework.getService(DirectoryService.class);
		} catch (Exception e) {
			throw new RuntimeException("Could not find DirectoryService", e);
		}
		Session session = ds.open("resetPasswordKeys");
		Map<String, Serializable> filter = new HashMap<String, Serializable>();
		filter.put("creationDate", simpleDate);
		DocumentModelList keysToRemove = session.query(filter);
		for (DocumentModel key : keysToRemove) {
			session.deleteEntry(key);
		}
		session.close();
    }
}

That’s it for today. In the second part I’ll tell you how to actually reset the password. Or if you are curious you can already checkout the source code on Github. I will also show you how to make a Marketplace package of this. See ya’ on Friday :)

Clear selected documents list operation

This part is simple. You need Nuxeo IDE with a SDK setup. Create a new project or use an existing one, and run the operation wizard.

Here’s what my wizard looks like:

And here’s the code of my operation:

@Operation(id = ClearSelectedDocuments.ID, category = Constants.CAT_UI, requires = Constants.SEAM_CONTEXT, label = "Clear Selected Documents", description = "Clear the default list of selected documents")
public class ClearSelectedDocuments {

	public static final String ID = "Seam.ClearSelectedDocuments";

	@OperationMethod
	public void run() {
            OperationHelper.getDocumentListManager().resetWorkingList(
                DocumentsListsManager.CURRENT_DOCUMENT_SELECTION);
	}

}

The operationHelper can give you access to some useful Seam components. Here, it gives us the DocumentListManager, which handles the different selection lists like the clipboard, the working list or the selected documents.

Now we need to make Studio aware of that operation. If you use Nuxeo IDE and have configured your Studio account, it’s dead easy. When you’re on the Nuxeo Studio tab, there’s an ‘Export operations’ button. It will first ask you to select which projects you want to scan. On the same screen, you can select the Studio project where you want to export the operations, if you have many. Click on next and you get the list of operations, it found. Select the one one you need and simply click on finish. That’s it, your operation is available in your Studio project.

What it does under the hood is simply generate a Json signature of the operation and paste it on the Studio operation registry:

So if you have other questions about Studio and operations, ask them on answers.nuxeo.com.

When the file is imported, Nuxeo goes through each plugin following their processes. If the mime type matches, then it tries to create the document. If it returns null instead of a DocumentModel, the next plugin with a matching mime type is used, and so on. Here is a simple plugin contribution as an example:

  <extension
    target="org.nuxeo.ecm.platform.filemanager.service.FileManagerService"
    point="plugins">

    <plugin name="ExportedArchivePlugin"
      class="org.nuxeo.ecm.platform.filemanager.service.extension.ExportedZipImporter"
      order="10">
      <filter>application/zip</filter>
    </plugin>

    <plugin name="CSVArchivePlugin"
      class="org.nuxeo.ecm.platform.filemanager.service.extension.CSVZipImporter"
      order="11">
      <filter>application/zip</filter>
    </plugin>

    <plugin name="DefaultFileImporter"
      class="org.nuxeo.ecm.platform.filemanager.service.extension.DefaultFileImporter"
      order="100">
      <filter>.*</filter>
    </plugin>
  </extension>

Take a simple zip file as an example. The first plugin used will be the ExportedArchivePlugin. It will return null because the zip file is not a Nuxeo export; it doesn’t contain a .nuxeo-archive file. The next plugin will be the CSVArchivePlugin. Since the zip doesn’t contain a meta-data.csv file, the plugin returns null. The next one to be used will be the DefaultFileImporter, which will create a simple File document with the zip file as main attachment.

When should you use plugins?

Plugins are a good fit for two things. The first one is creating several documents from a single file. With the ExportedArchivePlugin, you can create as many documents as you want using the content of this archive. You could also have a big XML file or maybe a GEDCOM file.

The other good fit is choosing the right DocType for a specific file. Maybe you have defined an OfficeFile document type that would be better then the usual File for all your office files.

Sure, you could use it to add business code like metadata extraction, specific property updates, file transformation, etc., but this would be better in a listener. This way, your code is called when you create a document from a creation form or from the import. And you can choose to do this synchronously or asynchronously, which is always good for big imports or file conversions.

Creating a new plugin

So now I’m going to write a plugin that creates people and links them together from a GEDCOM file. A GEDCOM file represents a genealogical tree. You can get information about individuals, and meta data linking them together. That’s a perfect example for a FileImporter plugin. Let’s get to it!

Here is my XML contribution. It’s really simple — you need to indicate the Java class implementing your import logic, give it an order, a name and a list of mime types. GEDCOM files are text, so you just need the ‘text/plain’ mime type. I’ve chosen 9 as the order to be sure this plugin is the first to be used. If my GEDCOM parser does not recognize the file as a GEDCOM, my plugin will simply return null and the FileManagerService will give the file to the next plugin.

  <extension
      target="org.nuxeo.ecm.platform.filemanager.service.FileManagerService"
      point="plugins">
      <plugin name="GEDCOMImporter"
        class="org.nuxeo.genealogy.core.plugin.GEDCOMFileManagerPlugin"
        order="9">
      <filter>text/plain</filter>
    </plugin>

  </extension>

This is my Java Class which extends the AbstractFileImporter (which itself implements the FileImporter Interface). I’ve found a nice library to do the GEDCOM parsing. It’s called gedcom4j and is available on Google code. It’s open source and the project is still active.

This is a really simple and basic example. It creates a folder named as the original file, then creates documents of type Individual, adding some metadata and then linking those documents together with relations.

public class GEDCOMFileManagerPlugin extends AbstractFileImporter {

	public static final String SPOUSE_OF_PREDICATE = "http://purl.org/vocab/relationship/spouseOf";

	public static final String CHILD_OF_PREDICATE = "http://purl.org/vocab/relationship/childOf";

	private static final long serialVersionUID = 1876876876L;

	private static final Log log = LogFactory
			.getLog(GEDCOMFileManagerPlugin.class);

	protected RelationManager relationManager;

	protected DocumentModel treeContainerDoc;

	public DocumentModel create(CoreSession session, Blob content, String path,
			boolean overwrite, String filename, TypeManager typeService)
			throws ClientException, IOException {

		GedcomParser parser = new GedcomParser();
		try {
			parser.load(content.getStream());
		} catch (GedcomParserException e) {
			log.warn("Not a gedcom file", e);
			return null;
		}
		Gedcom gedcom = parser.gedcom;

		// create tree container
		treeContainerDoc = session
				.createDocumentModel(path, filename, "Folder");
		treeContainerDoc.setPropertyValue("dc:title", filename);
		session.createDocument(treeContainerDoc);

		// create every individual in the tree
		Collection<Individual> everybody = gedcom.individuals.values();
		for (Individual individual : everybody) {
			DocumentModel docInd = session.createDocumentModel(
					treeContainerDoc.getPathAsString(), individual.xref,
					"Individual");
			docInd.setPropertyValue("dc:title", individual.formattedName());
			docInd.setPropertyValue("idv:xref", individual.xref);
			docInd.setPropertyValue("idv:name", individual.formattedName());
			docInd.setPropertyValue("idv:gender", individual.sex);
			session.createDocument(docInd);
		}
		// add spouseOf relations
		for (Individual individual : everybody) {
			for (FamilySpouse spouse : individual.familiesWhereSpouse) {
				if (spouse.family.husband == individual) {
					if (spouse.family.wife != null) {
						addIndividualsRelation(individual.xref,
								SPOUSE_OF_PREDICATE, spouse.family.wife.xref,
								session);
					}
				} else {
					if (spouse.family.husband != null) {
						addIndividualsRelation(individual.xref,
								SPOUSE_OF_PREDICATE,
								spouse.family.husband.xref, session);
					}
				}

			}
			// add childOf relations
			for (FamilyChild f : individual.familiesWhereChild) {

				if (f.family.wife != null) {
					addIndividualsRelation(individual.xref, CHILD_OF_PREDICATE,
							f.family.wife.xref, session);
				}
				if (f.family.husband != null) {
					addIndividualsRelation(individual.xref, CHILD_OF_PREDICATE,
							f.family.husband.xref, session);
				}
			}
		}

		return treeContainerDoc;
	}

	private RelationManager getRelationManager() {
		if (relationManager == null) {
			try {
				relationManager = Framework.getService(RelationManager.class);
			} catch (Exception e) {
				throw new RuntimeException(e);
			}
		}
		return relationManager;
	}

	private void addIndividualsRelation(String subjectXRef, String predicat,
			String objectXRef, CoreSession session) throws ClientException {
		Resource documentResource = getDocumentResource(getIndDoc(subjectXRef,
				treeContainerDoc.getRef(), session));
		Resource predicate = new ResourceImpl(predicat);

		Resource objectResource = getDocumentResource(getIndDoc(objectXRef,
				treeContainerDoc.getRef(), session));

		Statement stmt = new StatementImpl(documentResource, predicate,
				objectResource);
		Graph graph = getRelationManager().getGraphByName(
				RelationConstants.GRAPH_NAME);
		graph.add(stmt);
	}

	public DocumentModel getIndDoc(String xref, DocumentRef parentRef,
			CoreSession session) throws ClientException {
		return session.getChild(parentRef, xref);
	}

	public QNameResource getDocumentResource(DocumentModel document)
			throws ClientException {
		QNameResource documentResource = null;
		if (document != null) {
			documentResource = (QNameResource) getRelationManager()
					.getResource(RelationConstants.DOCUMENT_NAMESPACE,
							document, null);
		}
		return documentResource;
	}

}

That’s it for today — see you on Friday!

How does Seam.PushDocument work?

A new question by Michael Bell: How does Seam.PushDocument work? Well, it does not navigate to a document, as Clément said:

If you just want to navigate to your newly created Document, you should use the Seam.NavigateTo operation.
The Seam.PushDocument operation pushes just your Document in the Seam Context.

For those of you who don’t know Seam, it’s the framework we use to write Nuxeo’s Web interface. It can be easily extended with Nuxeo Studio, hence the presence of Seam in Studio.

Seam.PushDocument adds a document to a Seam context: session, conversation, page or event. This can be useful if you think the user will click on different buttons, which is to say launch different operation chains, during his conversation or session. This way you can share documents between independent chains. So once you have stored your document, to retrieve it, you need the Seam.FetchDocument operation. It will restore the document as input for the next operation.

This can be useful if you manage your navigation with buttons. Let’s say I am currently viewing a Quality Report document. I’ve added a button called “Navigate to Incident Library.” What it does is push the current document into the Seam context and then navigates to the “Incident Library” document. When I’m inside such a document, I have a button called “Back to Report.” The only thing that button does is retrieve the document from the Seam context and then navigate to the document, using the Seam.NavigateTo operation.

CDI? Tomcat7?

Nelson Silva asked us two questions: If we plan to replace Seam in the future and is Tomcat 7 support planned?

About Seam, we will use CDI instead, mostly because it’s close to Seam concepts and because it’s a JSR (JSR-299). We try to use standards as much as we can in Nuxeo.

We already have a code sample available on Github. It builds a nuxeo-cdi-distribution, which is a coreserver distribution customized to run CDI/JSF2 components in nuxeo-cdi-sample.

About Tomcat 7, the answer here is not as straightforward as the previous one. We’d be happy to do it, but it’s not part of our priorities. So as Florent said, we’ll start the work when it is a higher priority, and there is more demand for it. This might be accelerated if we have customer requests, but this is not yet the case.

I’ve chosen these two questions today because it’s the perfect opportunity to tell you about the upcoming webinar I’ll be doing with our CTO, Thierry Delprat. Simply entitled ‘An Hour with the CTO and the Community Liaison of Nuxeo’, we’ll talk about some of the features that will be in the Nuxeo Platform version 5.6, and tell you a bit more about the roadmap and where we’re heading technically. We want to make this as interactive as possible, so don’t hesitate to come and ask your questions. If you cannot attend the webinar, feel free to ask questions in the comment section of this blog or on answers.nuxeo.com.

Hi guys, I wanted to let you know that we have planned the next Nuxeo code sprint. It’s scheduled for June 21-22, 2012, and will be held at Nuxeo’s office in Paris. All the details are on our wiki.

You are all more than welcome to participate. The goal of this sprint, which will occur shortly after the Nuxeo Platform 5.6 code freeze, is to produce addons for the platform. There is no particular theme, as long as it’s related to Nuxeo, of course. I strongly encourage participants to discuss their subject on the wiki prior to the sprint. It’s always good to exchange information, especially on how you plan to implement it, so that we can give you suggestions.

And even if you don’t plan on coming, don’t hesitate to add your thoughts to the wiki page, and discuss features you’d like to see. You might inspire a team that will take on this project :)

Part of the Nuxeo team attended Devoxx France last week. If you don’t know about Devoxx, It’s an independent Java developer conference. This was the first French edition and I must say it went amazingly well for a first try, so kudos to the 20-person organizing team for pulling this off so smoothly.

We attended many, many different and interesting sessions. There’s a lot to say so I’ll try to be short. And all the sessions will be available on Parleys anyway :)

I’ll start with a very inspiring talk given by Alexandre Bertails: Linked Data – Big Data at Web scale. The web of data is here, and vendors have to step up. Nuxeo is already engaged in it through the Apache Stanbol project. This talk made me want to look more into RDFa, WebID and WebACLs.

There was a lot of interests in new languages. This is not new and reflects what’s been going on for a while on the Internet. So I went to the Ceylon and the Kotlin talks. It’s funny how those two, as well as many new languages, want to address the same issues, like Java verbosity and null pointer safety. Most Java developers write defensive code, with the sole purpose of handling null objects, making the code less clear than it should be. New languages also have to be compatible with Java. Kotlin does a great job at this. Seamless debugging with Java and Kotlin in intellij was quite impressive.

If I would have to choose, I think I’d go for Celyon. I like their approach, summed up by a simple tagline ‘say more, more clearly’. This is a very important factor for an enterprise language, and  a requirement for an open source software vendor, like Nuxeo. Our code has to be easy to read/understand.

You could really see an interest in Java7. There were talks about JVM bytecode and invokedynamic, which are in a sense linked to the new language trend, and also some talks about the new stuff in Java7, like project coin or NIO2. I really liked the one by Jean-Michel Doudoux, who did a small demo every time he introduced a new feature of NIO2. It was very instructive.

There were also some talks about client/server architecture. I saw the one from James Ward. He basically said that the client is now Javascript + HTML + CSS. It’s more than a trend, it’s already here. I’ll try to show you how it can be done with WebEngine in a future blog post. This will be the time to test Webjars, a tool that he presented during his talk. It’s a Maven repo of web libraries wrapped into JAR files.

The last talk I saw was really unique — it was a live episode of Les Cast Codeurs, the French Java Posse. We had a lot of fun. You can listen to the episode here to learn more about Devoxx France 2012. Thanks to Atlassian for providing the beer :-D

So this was a really interesting week for me, because I attended both the Jenkins User Conference and Devoxx France. I now have a list of things I need to try or look into. Here are some of them:

• JaCoCo
• Ceylon
• JBoss Byteman
• Java7 features (mostly NIO2)
• Webjars
• WebID, WebACLs

Now I will go back to my usual blog posting pace ;-) See you on Friday!

Update:

Julien’s video and slides are online on techtoc.tv

Yesterday I was at the Paris Jenkins User Conference 2012 with Julien Carsique. Julien was talking about how we use Jenkins at Nuxeo. For those of you who don’t know Jenkins, it’s a wonderful piece of software used to run and automate continuous integration jobs. We previously wrote a blog about this.

So about Julien’s presentation, you can check out the slides on nuxeo.com or right here:

He explained how Nuxeo has been using Jenkins for continuous integration for the past five years. We started small and added more and more jobs. At first it was for default platform tests only, and it evolved to include tests on different OS, JDK or Databases, automatic release process, code coverage tools etc.. Then he went on the different issues we had because of the ever increasing number of jobs and how we tried to solve them using for instance Jenkviz. It’s a tool that crawls a jenkins build and reports stats and graphs about the build flow. It was pretty cool to get attention the attention of the creator of the Jenkins CI server on this subject , thanks Kohsuke!

@kohsukekawa: I’m quite impressed at the degree of sophistication that Nuxeo setup is at. We need a super #JenkinsCI admin award for him!

Looks like attendees were interested in what we had to say. Some also looked scared seeing our Jenkins dashboard :-) . It’s true that it can look impressive but keep in mind that we started using Jenkins five years ago.

We also attended to some pretty cool talks, starting with a nice keynote from Kohsuke. Then we listened to Nicolas De Loof and Mathieu Ancelin who presented their Build-Flow Plugin. It was really interesting. They showed us how to manage jobs pipeline using a groovy DSL. The syntax is simple and straightforward. It looks easy and efficient. Only drawback when using this system is that it replaces the existing triggers. So we won’t be able to use it with our current build setup.

Another talk got my attention. Xavier Seignard from Pod Programming and Mickael Istria from JBoss presented Tycho, Jenkins & Sonar: The Eclipse Build Dream Team. It was nice to learn more about Tycho and to see that Eclipse (RCP/OSGI) apps works well with Jenkins and Sonar. And this was another good point about their presentation: they motivated us to test Sonar with JaCoCo, a Java Code Coverage Library. It looked so simple to setup and use, we definitely must try it at Nuxeo! Then I had a small chat with them, it was nice meeting you guys :)

Overall we had a great time, it was cool to see that much people into Jenkins. Hope there will be even more attendees next year. Congrats to Cloudbees for the organization! Next conference is Devoxx France tomorrow and Friday, maybe we’ll see you there !

What’s your file’s mime-type?

A first and mandatory step to deal with files in Nuxeo is to be sure you’ll get the right mime-type. I’ve first tried to upload a Pages file into our intranet but it was detected as a zip file. A quick look at the mime-type using the so called mime-type command confirmed I was dealing with a zip file:

[~]$ mimetype hello.pages
hello.pages: application/zip

So I have to add a small contribution to the MimetypeRegistryService. Details are as usual on explorer.nuxeo.org .

  <extension
    target="org.nuxeo.ecm.platform.mimetype.service.MimetypeRegistryService"
    point="extension">
   <fileExtension name="pages" mimetype="application/vnd.apple.pages" ambiguous="false" />
  </extension>

This code will make sure that each time a Pages file is uploaded in Nuxeo, its mime-type will be set to ‘application/vnd.apple.pages’. Now that I know what kind of file I’m dealing with, I can start using converters.

An introduction to converters

A Pages file is basically a zip file containing all of its different assets, such as images and some XML files for the content. But the good thing is that sometimes, the zip also contains a preview folder, itself containing a pdf preview of the document. This is just perfect for our needs. I will create a “pages2PDF” converter.

A converter can be added as usual through an extension point.

  <extension target="org.nuxeo.ecm.core.convert.service.ConversionServiceImpl"
    point="converter">

    <converter name="pages2pdf" class="org.nuxeo.ecm.platform.convert.plugins.Pages2PDFConverter">
      <destinationMimeType>application/pdf</destinationMimeType>
      <sourceMimeType>application/vnd.apple.pages</sourceMimeType>
    </converter>

  </extension>

It basically comes down to three things. We need a sourceMimeType, a destinationMimeType and a Java Class to handle the conversion. We can have as many sourceMimeTypes as we want. A classic example would be the any2pdf converter that can take XML, HTML, plain text, RTF or any other LibreOffice supported format. We will choose the Pages mimeType ‘application/vnd.apple.pages’. Then we want only one destinationMimeType: ‘application/pdf’. The goal of our Java Class will be to take a Pages file as input and return a pdf file. This class must implement the Converter interface. That makes two methods to implement: init and convert.

As stated in the documentation, init can be used to retrieve some configuration information from the XMap descriptor. I can already tell you that we don’t need any options so my init implementation will be empty.

The convert method gives us a BlobHolder and a parameter Map and must return another BlobHolder. So all we have to do is look for the pdf preview in the Pages file, extract it and return it as a BlobHolder. Here’s what I did:

public class Pages2PDFConverter implements Converter {

    private static final String PAGES_PREVIEW_FILE = "QuickLook/Preview.pdf";

    @Override
    public BlobHolder convert(BlobHolder blobHolder,
            Map<String, Serializable> parameters) throws ConversionException {
        try {
            // retrieve the blob and verify its mimeType
            Blob blob = blobHolder.getBlob();
            String mimeType = blob.getMimeType();
            if (mimeType == null || !mimeType.equals("application/vnd.apple.pages")) {
                throw new ConversionException("not a pages file");
            }
            // look for the pdf file
            if (ZipUtils.hasEntry(blob.getStream(), PAGES_PREVIEW_FILE)) {
                // pdf file exist, let's extract it and return it as a
                // BlobHolder.
                InputStream previewPDFFile = ZipUtils.getEntryContentAsStream(
                        blob.getStream(), PAGES_PREVIEW_FILE);
                Blob previewBlob = new FileBlob(previewPDFFile);
                return new SimpleCachableBlobHolder(previewBlob);
            } else {
                // Pdf file does not exist, conversion cannot be done.
                throw new ConversionException(
                        "Pages file does not contain a pdf preview.");
            }
        } catch (Exception e) {
            throw new ConversionException(
                    "Could not find the pdf preview in the pages file", e);
        }
    }

    @Override
    public void init(ConverterDescriptor descriptor) {
    }
}

Now we can convert a Pages file to a pdf. But to be able to preview it, it must be in HTML. So the next logical step is to make a ‘pages2html’ converter.

PagesToHMTL converter for the preview service

A very cool feature about the converters is that they can be chained. If I want a ‘pages2html’ converter, I can have it by first converting the Pages file to a pdf, and then converting the pdf to HTML. This contribution would look like this:

  <extension target="org.nuxeo.ecm.core.convert.service.ConversionServiceImpl"
    point="converter">

    <converter name="pages2html">
      <conversionSteps>
        <subconverter>pages2pdf</subconverter>
        <subconverter>pdf2html</subconverter>
      </conversionSteps>
    </converter>

  </extension>

We now have our ‘pages2html’ converter, which means Pages files will be previewable in Nuxeo. That’s it for today. If you have any questions, use the comments section or go to answers.nuxeo.com. See you on Friday!

Nuxeo WCM, blogs, wikis

Cool question asked by Nelson Silva: what about Blogs, Wikis, and WCM features? We get this question a lot actually. Publishing the content you manage in your ECM on the web seems perfectly legit. And there are as of now many different ways to do this in the Nuxeo Platform. You can use the publishing features with WebEngine, and you can create small Blogs and Wiki documents. These can be seen as light features compared to full-fledged WCM solutions and they are indeed! Nuxeo as a vendor won’t take the path to becoming a WCM solution with complex features like multilingual web publishing, portal management, online marketing capabilities, and personalization. You’d be much better off with a best-of-breed WCM solution connected to Nuxeo through CMIS or Content Automation APIs, if your project requires advanced WCM capabilities.

However, some WCM features or Web Publishing features in Nuxeo could totally make sense and might happen!

So as Alain said, if you need to build a WCM-like feature:

There is no “ready-to-use” bundle. Each Nuxeo project that has a “Content Management” flavor faces many options :
- for front-end templating engine (JSF based? WebEngine based? other language based ? Leveraging NX Themes? )
- Content/Structure model (Generic articles? more personalized objects?)
- publishing pattern (ACL based? Source/Proxy based? Using lifecycle?).

And it would certainly be good for Nuxeo to have a more advanced technical solution for each of these options. Here we would love input and potentially contributions from the community! Please bring your ideas and code, this is an official call to the community :) If you guys want to see WCM-like features in Nuxeo or on the Nuxeo Marketplace, we really want to talk more about this. We  need your input to organize the different light WCM-like features each of us would like to see integrated in Nuxeo.

There is another real reason why people could expect WCM based on Nuxeo. Now that I explained why we don’t focus at Nuxeo on this, I should reiterate that Nuxeo’s main mission is to provide a platform for developers to build content-centric applications, and certainly a WCM solution is a content-centric application. So YES a WCM solution made out of Nuxeo would make sense and be awesome. However, it is simply not Nuxeo’s mission to focus on this one. But if a new Application Builder partner wants to focus on that — I think it would be a very good idea to compete in the WCM arena. In that respect, I can only invite you to check out what people like Stepnet did with their solution SmartMedia. Although this is not WCM — it’s an editorial and publishing platform — it’s still very impressive!