Nuxeo Blogs

Extend Nuxeo Drive Series #3 – How to synchronize a document without attached binaries

Laurent Doguin — Mon, 20 May 2013 12:47:13 +0000

As we’ve seen last week in the Extend Nuxeo Drive series, files and folders are represented server side using adapters. By default it’s the DocumentBackedFileItem adapter that is used for simple, non-folderish documents. When you get the file from a document, the document BlobHolder is used. It’s a document adapter used to get or set the main file of a document. It means that the file you see on the desktop while using Drive has been retrived with this code:

    BlobHolder bh = documentModel.getAdapter(BlobHolder.class);
    Blob b = bh.getBlob();

It also means that when you modify a file on the desktop, it’s updated to the document using the BlobHolder.setBlob method. Once you know that, you can do some interesting stuff without having to write Nuxeo Drive factories or adapters (sorry, not yet, maybe in the next post :-) ).

Here’s a fairly simple example. The book document type available in the BookTraining-Day3 studio template has no binary field, only metadata. So we have to think of a specific blob holder. We can easily represent it as a CSV file like this:


"Name","Value"
"Author","Soulcie"
"Borrowed By","Administrator"
"Category","comics/manga/managa1;comics/manga;"
"ISBN","1307483092"
"Publication date","5/23/13 12:00 AM"
"Rating","5"

Now imagine that when the user modifies some of the values, we update the document’s metadata. This will happen in the BlobHolder.setBlob method. Here’s a simple implementation of a BookBlobHolder:

package org.nuxeo.sample;

import java.io.IOException;
import java.io.Serializable;
import java.io.StringWriter;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.List;

import org.nuxeo.ecm.core.api.Blob;
import org.nuxeo.ecm.core.api.ClientException;
import org.nuxeo.ecm.core.api.DocumentModel;
import org.nuxeo.ecm.core.api.blobholder.DocumentBlobHolder;
import org.nuxeo.ecm.core.api.impl.blob.StringBlob;
import org.nuxeo.ecm.core.api.model.PropertyException;
import org.nuxeo.ecm.core.schema.DocumentType;
import org.nuxeo.ecm.core.schema.SchemaManager;
import org.nuxeo.ecm.core.schema.types.Field;
import org.nuxeo.ecm.core.schema.types.ListType;
import org.nuxeo.ecm.core.schema.types.Type;
import org.nuxeo.ecm.core.schema.types.primitives.BooleanType;
import org.nuxeo.ecm.core.schema.types.primitives.DateType;
import org.nuxeo.ecm.core.schema.types.primitives.DoubleType;
import org.nuxeo.ecm.core.schema.types.primitives.IntegerType;
import org.nuxeo.ecm.core.schema.types.primitives.LongType;
import org.nuxeo.ecm.core.schema.types.primitives.StringType;
import org.nuxeo.runtime.api.Framework;

import au.com.bytecode.opencsv.CSVReader;
import au.com.bytecode.opencsv.CSVWriter;

public class BookBlobHolder extends DocumentBlobHolder {

    public static final String[] HEADERS = { "Name", "Value" };

    public enum BookProperties {
        AUTHOR("Author", "bk:author"), BORROWED_BY("Borrowed By",
                "bk:borrowedBy"), CATEGORY("Category", "bk:category"), ISBN(
                "ISBN", "bk:isbn"), PUBLICATION_DATE("Publication date",
                "bk:publicationDate"), RATING("Rating", "bk:rating");

        private String propertyName;

        private String name;

        private BookProperties(String name, String propertyName) {
            this.name = name;
            this.propertyName = propertyName;
        }

        public void setProperty(DocumentModel doc, String stringValue)
                throws PropertyException, ClientException {
            DocumentType docType = Framework.getLocalService(
                    SchemaManager.class).getDocumentType(doc.getType());
            Serializable value = convertStringValue(docType, propertyName,
                    stringValue);
            doc.setPropertyValue(propertyName, value);
        }

        public String getPropertyValue(DocumentModel doc)
                throws PropertyException, ClientException {
            DocumentType docType = Framework.getLocalService(
                    SchemaManager.class).getDocumentType(doc.getType());
            Serializable value = doc.getProperty(propertyName).getValue();
            if (value == null) {
                return "";
            }
            return convertValueToString(docType, propertyName, value);
        }

        public String[] getLine(DocumentModel doc) throws PropertyException,
                ClientException {
            String[] line = new String[2];
            line[0] = name;
            line[1] = getPropertyValue(doc);
            return line;
        }

        public static BookProperties fromString(String name) {
            if (name != null) {
                for (BookProperties b : BookProperties.values()) {
                    if (name.equalsIgnoreCase(b.name)) {
                        return b;
                    }
                }
            }
            return null;
        }

        protected Serializable convertStringValue(DocumentType docType,
                String fieldName, String stringValue) {
            if (docType.hasField(fieldName)) {
                Field field = docType.getField(fieldName);
                if (field != null) {
                    try {
                        Serializable fieldValue = null;
                        Type fieldType = field.getType();
                        if (fieldType.isListType()) {
                            Type listFieldType = ((ListType) fieldType).getFieldType();
                            if (listFieldType.isSimpleType()) {
                                fieldValue = stringValue.split(";");
                            } else {
                                fieldValue = (Serializable) Arrays.asList(stringValue.split(";"));
                            }
                        } else {
                            if (field.getType().isSimpleType()) {
                                if (field.getType() instanceof StringType) {
                                    fieldValue = stringValue;
                                } else if (field.getType() instanceof IntegerType) {
                                    fieldValue = Integer.parseInt(stringValue);
                                } else if (field.getType() instanceof LongType) {
                                    fieldValue = Long.parseLong(stringValue);
                                } else if (field.getType() instanceof DoubleType) {
                                    fieldValue = Double.parseDouble(stringValue);
                                } else if (field.getType() instanceof BooleanType) {
                                    fieldValue = Boolean.valueOf(stringValue);
                                } else if (field.getType() instanceof DateType) {
                                    fieldValue = SimpleDateFormat.getInstance().parse(
                                            stringValue);
                                }
                            }
                        }
                        return fieldValue;
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                }
            }
            return null;
        }

        protected String convertValueToString(DocumentType docType,
                String fieldName, Serializable value) {
            if (docType.hasField(fieldName)) {
                Field field = docType.getField(fieldName);
                if (field != null) {
                    try {
                        String stringValue = null;
                        Type fieldType = field.getType();
                        if (fieldType.isListType()) {
                            Type listFieldType = ((ListType) fieldType).getFieldType();
                            if (listFieldType.isSimpleType()) {
                                String[] arrayValue = (String[]) value;
                                StringBuilder sb = new StringBuilder();
                                for (int i = 0; i < arrayValue.length; i++) {
                                    sb.append(arrayValue[i]);
                                    sb.append(";");
                                }
                                stringValue = sb.toString();
                            } else {
                                List listValue = (List) value;
                                StringBuilder sb = new StringBuilder();
                                for (String string : listValue) {

                                    sb.append(string);
                                    sb.append(";");
                                }
                                stringValue = sb.toString();
                            }
                        } else {
                            if (field.getType().isSimpleType()) {
                                if (field.getType() instanceof DateType) {
                                    Calendar date = (Calendar) value;
                                    stringValue = SimpleDateFormat.getInstance().format(
                                            date.getTime());
                                } else {
                                    stringValue = String.valueOf(value);
                                }
                            }
                        }
                        return stringValue;
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                }
            }
            return null;
        }
    }

    public BookBlobHolder(DocumentModel doc, String path) {
        super(doc, path);
    }

    @Override
    public Blob getBlob() throws ClientException {
        try {
            StringWriter sw = new StringWriter();
            CSVWriter csw = new CSVWriter(sw, ',', '"');
            List allLines = new ArrayList();
            allLines.add(HEADERS);
            for (BookProperties bookProperty : BookProperties.values()) {
                allLines.add(bookProperty.getLine(doc));
            }
            csw.writeAll(allLines);
            csw.flush();
            csw.close();
            sw.close();
            Blob b = new StringBlob(sw.toString(), "text/csv");
            String filename = doc.getTitle() + ".csv";
            b.setFilename(filename);
            return b;
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void setBlob(Blob blob) throws ClientException {
        if (blob == null) {
            return;
        }
        CSVReader csvReader = null;
        try {
            csvReader = new CSVReader(blob.getReader(), ',', '"');
            List lines = csvReader.readAll();
            for (String[] line : lines) {
                String name = line[0];
                BookProperties bookProperty = BookProperties.fromString(name);
                if (bookProperty != null && line.length == 2) {
                    String value = line[1];
                    bookProperty.setProperty(doc, value);
                }
            }
            csvReader.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public String getHash() throws ClientException {
        return doc.getId() + getModificationDate().toString();
    }

}

There’s a lot of boring code to get and set the values of the different properties used by the Book document type. All types are not supported, but it’s a start. It handles all scalar properties and simple lists of scalar item (using ‘;’ char as a separator). Now you will see all your Book documents as CSV files on the desktop. See, just with BlobHolder you can do some interesting things :)

The post Extend Nuxeo Drive Series #3 – How to synchronize a document without attached binaries appeared first on Nuxeo Blogs.

Extend Nuxeo Drive Series #2 – Override existing adapter parameters

Laurent Doguin — Mon, 13 May 2013 16:07:20 +0000

Last week I started a series of blog post on how to extend Nuxeo Drive. Today I’ll write about factories and adapters. Every file or folder on the client file system is represented on the server side using adapters. Those adapters are associated to a particular document through a factory.

  - FileSystemItem  // Represents any file on the fs
    | -- FileItem    // A File
         |-- DocumentBackedFileItem // Default adapter implementation for non-folderish document
    | -- FolderItem  // A Folder
         | -- AbstractVirtualFolderItem // Represents a folder on the client side, that is not backed by an actual document
             | -- DefaultTopLevelFolderItem // The default Nuxeo Drive folder, containing your synchronized documents.
         | -- DocumentBackedFolderItem // Default adapter for folderish document
              | -- DefaultSyncRootFolderItem // Adapter for the root synchronized doc. (put simply, the docs where you clicked on the sync button)
              | -- UserWorkspaceTopLevelFolderItem  // User workspace based implementation of the top level
              | -- UserWorkspaceSyncRootParentFolderItem // User workspace based implementation of the synchronization root parent

We can take the default configuration as an example to better understand this.

A look at the default configuration

Using Drive on the client side, the first entry point is the Nuxeo Drive folder. It contains all the documents you have synchronized. This folder is represented on the server side through the DefaultTopLevelFolderItem adapter, and returned by the DefaultTopLevelFolderItemFactory factory. This configuration is declared in the org.nuxeo.drive.service.FileSystemItemAdapterService#topLevelFolderItemFactory extension point:

  

    
      
        Nuxeo Drive

As you can see, you can change the folderName parameter to something else. Some might prefer ‘My Drive’ or ‘My Nuxeo Files’ as name for your sync documents. The default implementation simply lists all the synchronization roots, which is to say all the document where you clicked on the Sync Drive icon. You can imagine different implementations like one that would display the content of your personal workspace along your synchronization roots. You could also have a hard-coded implementation that shows the same documents for every Nuxeo users. That’s really up to you :) . It doesn’t even have to be documents. You could have a folder called My Directories that would have a CSV file per directories declared in Nuxeo. (lots of coding involved but why not?)

Anyway, inside the default Nuxeo Drive folder you will see your synchronized roots and their children. This is managed by the org.nuxeo.drive.service.FileSystemItemAdapterService#fileSystemItemFactory extension point. Every one of these factories has an order attribute. They are resolved from the lowest to the highest. The first factory that returns an adapter is used. As you can see the lowest order is set on the defaultSyncRootFolderItemFactory. It will be returned if the adapted document has the DriveSynchronized facet. And the thing is, each time you click on the sync button, this facet is added to the document. As the child documents won’t have this facet, defaultSyncRootFolderItemFactory won’t match and the defaultFileSystemItemFactory will be used.

As you can see the defaultFileSystemItemFactory factory takes some parameters. They describe the default versioning behaviour. The adapter returned by the factory is DocumentBackedFileItem, which has a versionIfNeeded method called when the associated file is changing. This method first looks if the document needs to be versioned. This will occur if the current contributor is different from the last contributor or if the last modification was done more than 3600 seconds ago. As you have already guessed, 3600 is not arbitrary and comes from the versioningDelay parameter of the factory. If the doc needs to be versioned, the following code is executed:

            doc.putContextData(VersioningService.VERSIONING_OPTION,
                    factory.getVersioningOption());

We put the versioningOption parameter in the document context map. This information will be retrieved and used next time the document is saved. So by default, we do minor increments. Possible values are MINOR, MAJOR and NONE.

Customize the default configuration

Here’s an example of custom configuration of the default factories (no, we’re not going to write a complete new adapter or factory just yet). Let’s say I don’t want my Drive folder to be called Nuxeo Drive. I want it to be called ‘My Favorite Nuxeo Files’. And I also want to upgrade the major increment version number each time a document is modified using drive. This can be done using the following contributions.




  
  org.nuxeo.drive.adapters

  
  
    
      
        My Favorite Nuxeo Files
      
    
  

  
  
    
      
        MAJOR

Next week we’ll dig deeper into these factories and adapters.

The post Extend Nuxeo Drive Series #2 – Override existing adapter parameters appeared first on Nuxeo Blogs.

Extend Nuxeo Drive Series #1 – Override Operations

Laurent Doguin — Tue, 07 May 2013 11:53:17 +0000

Extend Nuxeo Drive

Like most parts of the Nuxeo Platform, we designed Nuxeo Drive as something extensible. And there are indeed different ways you can customize it to fit your needs. I’ll be writing more posts about how to extend Nuxeo Drive in the coming weeks. Today we’ll take a look at what you can do by simply overriding the different operations used by Nuxeo Drive.

Let’s take a very simple example. When Drive detects a conflict, the file is renamed a certain way. This is done using the NuxeoDrive.GenerateConflictedItemName operation. So what we can do is override this operation to specify our own way of renaming a file. Right now what it does is split the name of the file and the extension. Then we generate the contextSection. It’s the user’s first and last name concatenated with the current date formatted as “yyyy-MM-dd hh-mm”. Then it puts them back together.

To override it, you need to declare your operation as usual, but don’t forget to use the exact same ID as the operation you want to override. Here I’m changing the date format to “dd-MM-yyyy hh-mm” and adding the user’s email address.

/*
 * (C) Copyright 2013 Nuxeo SA (http://nuxeo.com/) and contributors.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the GNU Lesser General Public License
 * (LGPL) version 2.1 which accompanies this distribution, and is available at
 * http://www.gnu.org/licenses/lgpl.html
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * Contributors:
 *     ldoguin
 */

package org.nuxeo.sample;

import java.text.SimpleDateFormat;

/**
 * @author ldoguin
 */
// Use the same ID as the operation to override
@Operation(id = NuxeoDriveGenerateConflictedItemName.ID, category = Constants.CAT_SERVICES, label = "Nuxeo Drive: Generate Conflicted Item Name")
public class NuxeoDriveCustomGenerateConflictedItemName {

    @Context
    protected OperationContext ctx;

    @Param(name = "name")
    protected String name;

    @Param(name = "timezone", required = false)
    protected String timezone;

    @OperationMethod
    public Blob run() throws Exception {

        String extension = "";
        if (name.contains(".")) {
            // Split on the last occurrence of . using a negative lookahead
            // regexp.
            String[] parts = name.split("\\.(?=[^\\.]+$)");
            name = parts[0];
            extension = "." + parts[1];
        }
        NuxeoPrincipal principal = (NuxeoPrincipal) ctx.getPrincipal();
        String userName = principal.getName(); // fallback
        if (!StringUtils.isBlank(principal.getLastName())
                && !StringUtils.isBlank(principal.getFirstName())) {
            // build more user friendly name from user info
            userName = principal.getFirstName() + " " + principal.getLastName();
        }
        Calendar userDate;
        if (timezone != null) {
            userDate = Calendar.getInstance(TimeZone.getTimeZone(timezone));
        } else {
            userDate = Calendar.getInstance();
        }
        // I'll use a French date format
        SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy hh-mm");
        dateFormat.setCalendar(userDate);
        String formatedDate = dateFormat.format(userDate.getTime());
        // and I'll add the user's email
        String contextSection = String.format(" (%s - %s - %s)", userName,
                principal.getEmail(), formatedDate);
        String conflictedName = name + contextSection + extension;
        return NuxeoDriveOperationHelper.asJSONBlob(conflictedName);
    }

}

Don’t forget the require tag and the replace)”true” attribute to make sure your operation override the default one:



  org.nuxeo.drive.operations.NuxeoDriveGetRootsOperation

That’s just a simple example, but you can do a lot more. Every call from Drive to the server are made through Content Automation. So that means you can override pretty much everything it does. All these operations are located in the nuxeo-drive-operations bundle. Most of them are using the FileSystemItemManager and NuxeoDriveManager services. I’ll write more about this in the next posts.

The post Extend Nuxeo Drive Series #1 – Override Operations appeared first on Nuxeo Blogs.

Make It Red and Uppercase with Nuxeo Studio

Thibaud Arguillere — Mon, 06 May 2013 02:31:45 +0000

Building a wonderful content-centric application with a perfect taxonomy, with damn smart workflows, with incredible automation chains, etc. is great, sure. Still. You still need to paint it, if you see what I mean.

Nuxeo Studio lets you easily define the main branding of your application: login screen, colors used for text, background, links, … It is documented here. That said, you also often need to be more context-specific. For example, you may want to display a text widget in red so the user knows it is an important part of the layout. Or you may also want to force data entry with upper case letters for example.

Let’s take the following example: A workflow…

… has a “name” workflow variable. The form of its “First task” node displays this variable in a text widget…

… and you want it to be displayed in red.

So, you set its “Style class” property to “doItRed”…

…you save, and in the branding you create the doItRed style:

Then, you test your work⁽¹⁾.

. . . [here, I'm waiting while you are testing] . . .

You probably noticed something very unfortunate happened: It does not work as expected. The value we entered in the “Name” field is displayed in black. We want it red, right? So, how can we do this? How can we change the style of a widget?

Before explaining how you can customize this widget, I’d like to say you could have used one of the predefined classes provided by Nuxeo (and explained in the Nuxeo UI Style Guide.) For example, by using “warning” or “error”, our text would have been displayed in red. But here, we want it red-red, so we have an example of customization that can’t use a predefined class.

If you need the thing to be red now, immediately, can’t wait, emergency-emergency, then you may have the idea to use !important:

.doItRed {
    color:red !important;
}

And well, yes, it works. But the thing is: You don’t want to use it. Really. I believe !important has been added to the specification when the CSS team was spending time in Vegas with The Hangover folks. If you start using it, you’ll soon find yourself using it everywhere and at some point in a short future, nothing will work at all, your user interface will be broken. Instead of using it, it is better to understand why your style is not used. So, we remove this !important thing, save, update our project in the server and run it.

A web inspector is the perfect tool for the purpose of understanding what happened to our style. So, at runtime, we display the inspector and select our widget. The right pane clearly shows that the class has been overridden (it is in strikethrough):

What happened here is that the default nuxeo theme, “galaxyDefaultCssNNN” (with NN being a number dynamically evaluated by the server) has been applied after our own class, hence the fact that our red color is not used.

What can we do to display our widget in red? We must (besides not using The Suffix That Must Not Be Named) use a CSS definition that will have a higher priority than the Galaxy one. Using the DOM ID of the widget would work, but it is complicated to get this ID, since it is generated at runtime (we don’t know this ID at the time we are adding the class in Studio). The best solution is to define our style by using the class hierarchy that is applied to our widget:

.classOfAncestor [...] .classOfParent .classOfElement {...}

So, we take look at the web inspector and find the classes:

It is good to be specific in the path and get the right ancestors. In our example, we want to apply the style only in the context of a task, so we walk the path up to “single_tasks_block”. The CSS we must define is:

.single_tasks_block .dataInput .fieldColumn .doItRed {
    color:red;
}

If you want to apply your red style in a wider area than a table, don’t hesitate to use the framework CSS classes: .nxHeader, .nxMainContainer, .nxFooter. These classes are called in all the pages of the platform.

There is one last thing to do actually: Our doItRed class becomes a place holder that we use for the “Style class” widget property. We can leave it empty. So, here is our CSS definition in the branding:

Save. Update⁽²⁾. Run. Enjoy.

We can now move a step further. Because at the beginning of the article, I was talking about displaying the field in red, but also as upper case. We want every character, every key hit by the user to be displayed as upper case.

How you implement this in Nuxeo Studio depends on what you need. Either you just want to display data entry in upper case, or you want the field itself, its content, to hold only upper case letters. Just displaying uppercase is quite easy — we add the appropriate text-transform style:

.single_tasks_block .dataInput .fieldColumn .doItRed {
    color:red;
    text-transform:uppercase;
}

That’s all. CSS handles the conversion at runtime. I’ll add that we should then rename our class, because giving useful names is useful⁽³⁾. If we do rename the class, we will not forget to change the “Style class” widget property in our task form.

Also notice that it is only about how the data is displayed: CSS does not change the actual content. In our example if the user enters “john” in the name workflow variable, it will be displayed as “JOHN”, but the variable itself still holds “john”.

If we want the transformation to be persistent, then we have to move to something different. Here is my suggestion: To stay with the CSS transformation for the display, and to add a “Transform to Uppercase” automation chain to the workflow. In our example, we added a basic “OK” button to the “First task” form. This button does nothing but move to “Second task”. We can now add an automation chain to the transition, which will be run when the user hits this “Ok” button. In the “Transitions” tab of the node properties dialog, click the “Create” button:

We name the chain “upperCaseName”. Our challenge is to set the name field to uppercase. It is a workflow variable. So we use the “Workflow context > Set context variable” operation chain. We can safely remove the first, default action (“Fetch > Context document”) that was created by Studio because we are not – in this example – using the document.

Here is what our chain looks like:

The “name” field is obvious: our workflow variable’s name is “name” (funny, isn’t it?).

Now what should we put in the “value” field of this chain to transform the characters to uppercase? You can use here a MVEL expression. Not everything is allowed in this context, but to make a long story short, basically, everything that is put between @{ and } is evaluated as a Java expression. Some expressions are very specific to Nuxeo, but you can also use a bit of Java here. And even more interesting for us, we can use its String class. And guess what? The String class has a toUpperCase() method whose function is quite clear in my opinion. This means that when you have a string, you just have to write…

myString.toUpperCase()

…to return a capitalized string. And a hard coded expression is also valid. I mean something like…

"nuxeo studio rocks".toUpperCase()

…returns “NUXEO STUDIO ROCKS”.

So basically, what we have to do now is to get the current value of the name workflow variable, and to transform it to upper case. Getting its value is done using the helper drop down menus of the expression dialog. We select “Workflow Variables” in first drop-down, then ["var"] in the second, and then we click “Insert”…

…this inserts the expression:

@{WorkflowVariables["var"]}

We replace “var” with “name”, since it is the name of our variable. The expression between the curly brackets is evaluated at runtime and returns a string: The characters the user entered. Because it is a string, we can call the toUpperCase() Java String method. We just need to be careful and to let the whole thing inside the curly brackets:

@{WorkflowVariables["name"].toUpperCase()}

We’re done with our automation chain, which contains actually one single operation:

We save, update and run. After starting a workflow on a document, here is my first task. I entered everything in lower case, “working well”. The CSS transformation displays it as we want:

Then, when I hit the “OK” button, the chain is run and “working well” is transformed using Java. So its value is now “WORKING WELL”:

Isn’t it wonderful that you can customize your application in such detail with Nuxeo Studio?

And don’t forget to add comments in your CSS to make it readable and easy to follow for you team^{(5)^.}

(1) Yes. Checking that what we do works as expected is part of our lives
(2) Update the project in the server. Something we sometimes forget. Then we wonder why our changes don’t work. Come on.
(3) Yes, that’s what I wrote: Useful is useful.
(4) If you are not very familiar with Java, it is not a problem at all. Finding the appropriate function requires a simple Internet search on keywords like “java upper case”. You’ll get an answer such as “use the toUpperCase method of the String class”
(5) Lise Kemen helped me a lot on this article. She is our CSS super specialist (see the Nuxeo UI Style Guide for example). She also she really insisted for this “comment your class” to be added. And when Lise really insists, well, you know, you just follow the orders.

The post Make It Red and Uppercase with Nuxeo Studio appeared first on Nuxeo Blogs.

Nuxeo World 2013 – Save the Date!

julie — Fri, 03 May 2013 16:59:13 +0000

First of all, we’re very excited to announce that Nuxeo World is coming back in October 2013. You can already save the date: October 9-10, 2013. We’re putting together 2 action-packed days for all things Nuxeo. Since last year’s format was well received, we’re going to do it again. The first day will feature the latest technology from Nuxeo R&D, case studies, vertical application demonstrations, community contributions, and much more. The second day will be a full day of hands-on workshops.

For a glimpse of last year, check this out!

Stay tuned also for other upcoming events. We’re preparing something special for our Connect clients in France and in North America.We’d like to share a cup of coffee at a special breakfast event in Paris. The Nuxeo team will show you the latest innovations from our R&D department. This will take place in our Paris office on Tuesday, June 11, so watch your email inbox for the invitation.

For our North American clients, who are spread out all over the U.S., Canada, and Latin America, it would be challenging to organize a meet-and-greet over coffee and croissants. But we’d still like to give you the opportunity to meet other clients and to connect with the Nuxeo team, so we’re organizing a Google Hangout for US customers. The first Hangout will be held on June 5th, so check your email for the invitation!

The post Nuxeo World 2013 – Save the Date! appeared first on Nuxeo Blogs.

[Q&A Friday] How to add tagging capability during drag’n'drop

Laurent Doguin — Fri, 03 May 2013 13:41:35 +0000

How to add tagging capability during drag’n'drop

Here’s a question that comes back often, asked by bruce: How to add tag capability during drag’n'drop?. Since Thierry added HTML5 drag’n'drop to the Nuxeo Platform, it’s possible to fill in metadata right after the import, and apply them to all the imported documents. But I understand it can be frustrating not being able to add tags. And fortunately the drag’n'drop service for content capture is extensible. The full code sample is available on GitHub.

So here’s how it works. When dragging files in a content view for at least 2 seconds, you’ll be prompted with a Select import operation choice. Those select operations are actually actions. It means you can add as any as you want through the action extension point. These actions have a specific behavior.

The ID of the action must, for instance, be the ID of the operation or the operation chain that will be executed when dropping the files. The link will display an iFrame itself displaying the layout passed as query parameter (layout=dndTagsEdit). The schema query parameter (schema=dc) is used to specify which schema you need to update with the chosen layout. Take a look at the documentation for the other specificities of those actions.




  org.nuxeo.ecm.platform.actions

  

    
      ContentView
      create

There are two things different from the classic import with metadata: the layout and the operation chain. The operation chain as an intermediate operation called Document.TagDocument. It’s responsible for the actual tagging of every document.

/*
 * (C) Copyright 2013 Nuxeo SA (http://nuxeo.com/) and contributors.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the GNU Lesser General Public License
 * (LGPL) version 2.1 which accompanies this distribution, and is available at
 * http://www.gnu.org/licenses/lgpl.html
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * Contributors:
 *     ldoguin
 */

package org.nuxeo.sample.dnd;

import java.io.Serializable;
import java.util.List;

import org.jboss.seam.contexts.Contexts;
import org.nuxeo.ecm.automation.OperationContext;
import org.nuxeo.ecm.automation.core.Constants;
import org.nuxeo.ecm.automation.core.annotations.Context;
import org.nuxeo.ecm.automation.core.annotations.Operation;
import org.nuxeo.ecm.automation.core.annotations.OperationMethod;
import org.nuxeo.ecm.automation.core.collectors.DocumentModelCollector;
import org.nuxeo.ecm.core.api.CoreSession;
import org.nuxeo.ecm.core.api.DocumentModel;
import org.nuxeo.ecm.platform.tag.TagService;

/**
 * @author ldoguin
 */
@Operation(id = TagDocument.ID, category = Constants.CAT_DOCUMENT, requires = Constants.SEAM_CONTEXT, label = "TagDocument", description = "")
public class TagDocument {

    public static final String ID = "Document.TagDocument";

    @Context
    protected CoreSession session;

    @Context
    protected OperationContext ctx;

    @Context
    TagService tagService;

    @OperationMethod(collector = DocumentModelCollector.class)
    public DocumentModel run(DocumentModel doc) throws Exception {
        if (!isSeamContextAvailable()) {
            return doc;
        }
        List tags = getDndTagsFormAction().getDndTags();
        for (Serializable tag : tags) {
            tagService.tag(session, doc.getId(), (String) tag,
                    ctx.getPrincipal().getName());
        }
        return doc;
    }

    public static boolean isSeamContextAvailable() {
        return Contexts.isSessionContextActive();
    }

    public static DndTagsFormActionBean getDndTagsFormAction() {
        return (DndTagsFormActionBean) Contexts.getConversationContext().get(
                "dndTagsFormActions");
    }

}

As you can see, it retrieves the list of tags from a SEAM bean. It’s the backing bean of a new widget I have defined in my custom layout dndTagsEdit. This layout is almost the same as the original one, except it displays the tag widget. Take a look at the code and the documentation – it’s pretty easy to understand.

The post [Q&A Friday] How to add tagging capability during drag’n'drop appeared first on Nuxeo Blogs.

[Monday Dev Heaven] Nuxeo and Atlassian HipChat Integration

Laurent Doguin — Mon, 29 Apr 2013 11:00:02 +0000

Atlassian HipChat

Being big Atlassian fans here at Nuxeo, we recently started using HipChat. It’s an enterprise chat room. One of the cool things about HipChat is its very simple web API. It makes it really easy to send notifications to a chat room.

To show you how dead easy it is, I did a project showing how to send Nuxeo events to a Hipchat room using their web API. I did it using Nuxeo IDE to generate my plugin structure, using the Nuxeo Plugin Project and Nuxeo Listener wizards. My listener only listens to documentCreated and documentModified events. Each time they occur, we send a small message to a HipChat room, containing the URL of the document, its title, date and creator. The code is really simple (especially because most of it is generated by Nuxeo IDE):

/*
 * (C) Copyright ${year} Nuxeo SA (http://nuxeo.com/) and contributors.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the GNU Lesser General Public License
 * (LGPL) version 2.1 which accompanies this distribution, and is available at
 * http://www.gnu.org/licenses/lgpl.html
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * Contributors:
 *     ldoguin
 */

package org.nuxeo.sample;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Date;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.nuxeo.ecm.core.api.ClientException;
import org.nuxeo.ecm.core.api.DocumentModel;
import org.nuxeo.ecm.core.event.Event;
import org.nuxeo.ecm.core.event.EventContext;
import org.nuxeo.ecm.core.event.EventListener;
import org.nuxeo.ecm.core.event.impl.DocumentEventContext;
import org.nuxeo.ecm.platform.url.DocumentViewImpl;
import org.nuxeo.ecm.platform.url.api.DocumentView;
import org.nuxeo.ecm.platform.url.api.DocumentViewCodecManager;
import org.nuxeo.runtime.api.Framework;

/**
 * @author ldoguin
 */
public class HipChatListener implements EventListener {

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

    public static final String MESSAGE_TEMPLATE = "Document %s has been modified by %s on the %s";

    public static final String BASE_URL = "https://api.hipchat.com/v1/rooms/message?format=json&auth_token=%s";

    public void handleEvent(Event event) throws ClientException {
        // First we make sure that the event is about a document
        EventContext ctx = event.getContext();
        if (!(ctx instanceof DocumentEventContext)) {
            return;
        }
        DocumentEventContext docCtx = (DocumentEventContext) ctx;
        DocumentModel doc = docCtx.getSourceDocument();
        // Once we have the document, we can start building the message we'll send to HipChat

        // First we build the document's URL
        DocumentView docView = new DocumentViewImpl(doc);
        DocumentViewCodecManager docLocator = Framework.getLocalService(DocumentViewCodecManager.class);
        String nuxeoUrl = Framework.getProperty("nuxeo.url");
        String docUrl = docLocator.getUrlFromDocumentView(docView, true,
                nuxeoUrl + "/");
        // Than the message body
        Date date = new Date(event.getTime());
        String chatMessage = String.format(MESSAGE_TEMPLATE, docUrl,
                doc.getTitle(), docCtx.getPrincipal().getName(),
                date.toString());
        log.debug(chatMessage);
        try {
            // now we can send it to HipChat
            sendMessage(chatMessage);
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public void sendMessage(String message) throws IOException {
        // We retrieve every needed property from nuxeo.conf
        String roomId = Framework.getProperty("hipchat.roomId");
        String authToken = Framework.getProperty("hipchat.authToken");
        String userName = Framework.getProperty("hipchat.userName");
        String notify = Framework.getProperty("hipchat.notify");
        String color = Framework.getProperty("hipchat.color");

        // then we do the actual rest call to HipChat web API
        String url = String.format(BASE_URL, authToken);
        HttpClient client = new HttpClient();
        PostMethod post = new PostMethod(url);
        try {
            post.addParameter("from", userName);
            post.addParameter("room_id", roomId);
            post.addParameter("message", message);
            post.addParameter("color", color);
            post.addParameter("notify", notify);
            post.getParams().setContentCharset("UTF-8");
            client.executeMethod(post);
        } finally {
            post.releaseConnection();
        }
    }
}

What it does is simply relay the modify or create events to a room. This is the simplest integration possible, but there are many other cool use cases you can implement. You could have a dedicated room per Nuxeo group, you could integrate this with the notification module and send personal notifications, etc. Let us know what you think about this — are you using the same kind of tools to collaborate? Would like to see integrations between other collaboration tools and Nuxeo?

The post [Monday Dev Heaven] Nuxeo and Atlassian HipChat Integration appeared first on Nuxeo Blogs.

[Q&A Friday] How to Access a Resource Bundle with MVEL in Content Automation

Laurent Doguin — Fri, 26 Apr 2013 16:08:15 +0000

Access resource bundle label with MVEL

There’s an interesting question today from milonette, asking how to access labels with MVEL. Sometimes the Content Automation API doesn’t provide everything you need out of the box, hence the question. But the good news is this API is extensible.

While some functions are already available in the automation context, there is currently nothing to access the resource bundles. We’ll need to add our own function into it. This is quite easy to do. First we need to write the new function we need, then we’ll write an operation that adds this function to the content automation context.

Our localized function needs different parameters. We want the locale, the name of the resource bundle, the key of our message and some optional parameters. Here’s a simple implementation:

package org.nuxeo.sample;

import java.util.Locale;

import org.nuxeo.common.utils.i18n.I18NUtils;

public class LocalizationFunctions {

    public static String localize(String bundleName, String localeStr, String key, String... params) {
        Locale locale = Locale.forLanguageTag(localeStr);
        return I18NUtils.getMessageString(bundleName, key, params, locale);
    }

}

Now that I have my function, I need to create an operation that will make this available within the automation context:

package org.nuxeo.sample;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.nuxeo.ecm.automation.OperationContext;
import org.nuxeo.ecm.automation.core.Constants;
import org.nuxeo.ecm.automation.core.annotations.Context;
import org.nuxeo.ecm.automation.core.annotations.Operation;
import org.nuxeo.ecm.automation.core.annotations.OperationMethod;

@Operation(id = AddLocalizationFunctions.ID, category = Constants.CAT_SCRIPTING, label = "AddLocalizationFunctions", description = "Add new function namespace to automation context.")
public class AddLocalizationFunctions {

    public static final String ID = "AddLocalizationFunctions";

    public static final String LOCALIZATION_FUNCTION_NAME = "LocFn";

    protected static final Log log = LogFactory.getLog(AddLocalizationFunctions.class);

    @Context
    protected OperationContext ctx;

    @OperationMethod
    public void run() {
        ctx.put(LOCALIZATION_FUNCTION_NAME, new LocalizationFunctions());
    }

}

This should do the trick. Now if I do an operation chain starting with this operation, I’ll be able to use this function:

    
      
      
        expr:LocFn.localize("messages", "en", "label.permalink.description",{"param1", "param2"})

Notice the use of an inline MVEL array to comply with String… params argument. Now you can go wild and add any functions you want. In the future we’ll try to make this extensible through an extension point.

The post [Q&A Friday] How to Access a Resource Bundle with MVEL in Content Automation appeared first on Nuxeo Blogs.

[meet the team] Benjamin Jalon

Jimena Ballina — Fri, 26 Apr 2013 10:20:26 +0000

Originally a Nuxeo customer at EADS, a European industrial flagship, Benjamin Jalon worked with the Nuxeo Platform and helped improve Nuxeo Document Management during their project. Benjamin, impressed with all of the Nuxeo Platform’s capabilities, joined the Nuxeo team as a developer at the end of 2008.

Where are you originally from?

I am from Paris. I was born in Paris, grew up in Paris, and I have lived in a suburb of Paris for four years now. I went to college in Paris and studied mathematics for my undergraduate degree. For my master’s degree, I also studied mathematics. After my master’s, I completed two years at ENSTA (École Nationale Supérieure de Techniques Avancées) to earn an engineering degree, with emphasis in Computer Science.

What made you want to be an engineer after studying mathematics for so long?

I wanted to be an engineer because after a master’s in mathematics, you usually work in research or in theoretical areas. I liked mathematics, but I like to build things too, so I was really interested in computer science and I chose to go to engineering school. I didn’t like school so much before college but once I went to university for math and computer science, it was easy for me since I like these subjects a lot. I found my calling.

What is your background?

I worked for a company named EADS, which owns Airbus, and I worked in the military domain. The company where I worked created the information systems for the French Army to use during conflict situations. I worked to make the system easy to install since, in this case, you had to install the networks and servers along with many other things, and have it integrate with the global systems all at the same time. It was a bit complex, but a very interesting experience.

You mentioned that you used the Nuxeo Platform for your projects at EADS. Can you tell me more about your use of the platform before joining Nuxeo?

At EADS, we used the Nuxeo Platform for military intelligence (Renseignements Militaire). We used the Nuxeo Platform for its digital asset management capabilities, so that military intelligence had a repository to store images and video footage of military equipment. The information came from all over the world – television, pictures taken during military operations, all types of sources. This system provided a place to store all of these digital resources, with custom metadata that enabled us to clearly define the subject. I was really interested in the Nuxeo Platform after this experience and I decided I wanted to work at Nuxeo.

How has your career at Nuxeo progressed since you joined?

I began at Nuxeo as a developer and was a developer for about four years. I was on the Starship team with Delphine. We named our team “Starship” because of the movie Starship Troopers, where the characters in the movie had to kill bugs from other planets. They’d say, ”A good bug is a dead bug,” so we chose this name for our development team. During this period, we started moving to scrum methodology for more regulated development activity. We planned tasks for weeks and we tried to not talk about tasks by days, but by complexity. We estimated the length of a project based on complexity. My role then was Developer and Scrum Master, and my main responsibility was to organize and coordinate with the team to find out how complex a project was, and then translate that into days for Delphine. Each day at the beginning of the day I would ask the team what their plans were and what they had completed already, and I would map which developer worked on specific tasks. If the developer was blocked on his or her activity, then at the daily scrum (our daily meeting), the entire team would try to help the developer figure out a solution. After two weeks of development, we would have a retrospective meeting and talk about all the tasks done and how they went. I did that for about five years. Then, last year, I became a PreSales Engineer.

What do you do now as a PreSales Engineer?

Now, my activities are to explain why our platform is great for customers. I present the platform, and I help potential customers figure out if the platform can do what they want, and if so, how much development it would take. I also do some consulting activities; I do an initial meeting with the customer when they do not know Nuxeo yet, and I stay with them until they are in the development process. I do training, consulting and give technology guidance to help them start a project. Basically, I help them with all of the stuff they need before beginning a project, and sometimes I even help them start the project.

What is your favorite Nuxeo project you’ve worked on so far?

I started the mobile application. I was the first to contribute to this project because I did it in my free time. The first implementation was for the first Nuxeo World. I had a presentation, and my goal was to show what we can do in two weeks with Nuxeo and the IUI Java Script Library. The goal was to have a mobile application that was usable on both iOS and Android smartphones.

In the time you’ve spent at Nuxeo, how have you seen the company and products grow? And what has been most exciting for you?

At the beginning, we were more in a start-up mode, where we all worked a lot. Now, we have more standard activities. It was hard at the beginning because we were both integrators and software developers — we wanted to integrate the solution for our customers. Now that we have many integrators around us, we are more focused on the software development part. Even if we do some integration activities, like we did for Netflix, Nuxeo is now more focused on just improving the platform. It’s interesting because we now really take the time to improve everything around the platform for our integrators and we try to do our best to deliver the best platform and the best tools for our platform. That’s why Nuxeo Studio and Nuxeo IDE were created. The idea of Nuxeo is to try to give our own tools to developers who use our platform. All the tools that we are using, we give them to our customers. It’s a really good example of open source, I think.

You’ve presented at Nuxeo World and other conferences before; what points do you make in these presentations and what do you want to make sure you get across to anyone interested in the platform?

The platform, basically, is made for developers. It’s open source, so developers can see the Java code, and it can inspire developers. With Nuxeo, I learned to create and write better quality code. Since the platform is open source, you can see beautiful lines of Java code, and this is why I say that this is a platform that inspires developers, because they see good code. Secondly, for integrators, there are different levels of understanding the Nuxeo Platform. The first step is just using Nuxeo – installing it and using it. You don’t need to know anything technical. The second step is configuring it with Nuxeo Studio, which takes just three days of training or reading the documentation that is freely available. The third step is that by reading the documentation you can go deeply in the platform and produce what Nuxeo Studio produces to suit your needs.

What is the coolest thing you have learned while at Nuxeo?

I think the coolest thing is writing code and working toward building something. That is not easy in all companies, especially in France. I like producing something that is trustworthy, writing code, and I also like that we share our knowledge.

What do you do in your spare time?

I spend time with my family. I have a 3 1/2 year old daughter and a 1 1/2 year old son. I’m learning to draw clowns and build Lego towers with my daughter. My son is very good at destroying the towers. So we have both forces at work in my house: construction and destruction. [laughs] We like to strike a nice balance.

The post [meet the team] Benjamin Jalon appeared first on Nuxeo Blogs.

[Nuxeo Tech Report] News from the Developer Front #6

Laurent Doguin — Thu, 25 Apr 2013 13:30:16 +0000

Hi everyone, and welcome to this new tech report. It’s a rather short one this week — we’re mostly consolidating what you’ve read about in the previous report. Oh, and we released Nuxeo Drive :D

Nuxeo Drive

Drive 1.0.1 released

Drive 1.0.1 was release last week.

Next steps

There is a known issue when several files are created on the server: because the server may be busy, there is a time shift between the audit log event date and the time where the audit entry is actually persisted. This time shift can lead the client to ‘loose some events’ and then not see some files.

To fix that, we should:

Review the polling system: based on the audit sequence ID rather than the time window
Prepare the upgrade of the client side database
Make the client able to detect when a database update is needed.

Oracle issue

There is a date formatting issue when doing Hibernate queries on Audit logs. => We should simply use Hibernate queryMaker to avoid that (AuditReader provides a method to allow parameters merge and will handle that!).

Technical tasks

Tomcat DS/Hibernate upgrade/Seam patch/H2 upgrade + MVCC branch

As already raised in previous tech reports, we still have several branches holding important infrastructure changes. We’re starting the merge of these branches.

NXP-10926: H2 upgrade + H2 MVCC mode + use H2 in memory so speed up tests
Tomcat Pool and ‘real’ XA mode + upgrade hibernate + patch Seam
Improvements on test framework and error management (need to create ticket)
Tomcat upgrade.

BIRT

A BIRT upgrade has been scheduled. The target is:

upgrade to BIRT 4.2
make an ODA connector for NXQL so that we can use NXQL from within BIRT designer.

PreSales sandbox

The PreSales team has started a sandbox where they code some extensions that can be useful for building demos and POCs. See nuxeo-presales-prototyping-toolkit.

Part of this work is also to fill the potential holes we can have in the API or in the Extension Point system. That’s why we did a quick review with Benjamin and a lot of the work should be directly merged inside the trunk:

missing Operations
Operation with missing parameters
new Publisher extensions
…

Automation

As already explained in previous reports, changes in Automation API are one of the cornerstone of the next release.

Automation improvements

do some non-regression validation tests
merge Olivier’s changes on JSON marshaling

Angular Layout/CRUD Automation/Automation

Damien has started working on:

adding a REST CRUD API
improving the JS client and make integration with AngularJS
wrapping the Layout system

Layouts/Widgets/Studio/DAM

Widgets

Tabs widgets

We are almost ready to have a Widget that renders tabs defined by actions and allows Ajax Switching. This will be useful for DAM, but more globally, this would good for CAP too. So, the next steps include:

finishing the implementation
use by default in Nuxeo CAP tab system
may be merging with changes on RESTDocumentLink for conversation management NXP-11331
updating Selenium tests

Action types // Widget types

We are now very close to being able to use WidgetTypes to define Action types. The idea is basically to make action types more than a simple string attribute, but associate it with a set of property that can be defined by the user. Doing so would be good:

for Studio, action configuration would be easier since we can have a form
for documentation and showcase
for Ajax behavior

Ajax Rerender and duplicated IDs

Depending on layout and widgets config there may some cases where RichFaces + Facelet infrastructure fails to correctly manage Ids. For now, this is a problem that:

can be avoided via small workarounds in most cases
can not be fixed in Nuxeo
can not be easily fixed in JSF/Facelets

The JSF duplicate ID issue on ajax rerender has been identified, and fixed by using the nxu:repeat tag (revisited) and making it create new sub-components when it detects that the iteration list has changed. Otherwise existing components are reused and their ID is not reset, leading to potential duplicate IDs. See https://jira.nuxeo.com/browse/NXP-11434.

Anahide will try to submit the problem to RichFaces/JSF2 community to see if we have some feedback.

DAM

Box listing

The Box listing is used to manage the DAM thumbs view inside a ContentView. This works in DAM, but there is still some work to be done:

integration inside CAP/DM to manage the ‘BigIcon view’
standardize the DAM selection use case (clicking on the Thumb in DAM changes the currentDocument)
Studio editor UI to be adapter to Box listing display
- this is not strictly needed for now, but this would be really better.

Selection system

For ContentView the current selection model is built on the use of the DocumentListsManager. This system that is also used for Worklist and Clipboard becomes an issue for selection:

when DAM and DM show the same ContentView but with different filters
when there are several ContentView in the same page

If we allow to have several selection lists, this should impact the Copy/Past/Move actions available on ContentView.

Next steps

The next steps on DAM include:

Tab Widget integration
Html5 DnD integration for mass Import
- start from existing code
- add Canavas based preview if we have time
- add support for async processing
‘Ajax Permlink’ (already discussed but not done)
functional testing

Connect/Studio

Advanced Studio

Part of the ongoing work is about unlocking advanced feature so that people using studio don’t end up with a lot of XML Override in the XML extensions. This typically includes:

Extended ContentView configuration
Widgets configuration
Selection configuration

Having all these new options:

will unlock feature for advanced users
may confuse basic users and lead them into problem
- problems we will have to fix via support

This may be worth adding a disclaimer saying something like ‘use advanced settings only if you now what you are doing, support won’t be able to easily help you if you mess up something’.

The post [Nuxeo Tech Report] News from the Developer Front #6 appeared first on Nuxeo Blogs.