Category: Alfresco

Alfresco open source content management

Custom Data Lists in Alfresco Share Community 3.3

One of the new features of Alfresco 3.3 Community is Data Lists. The ability to create an arbitrary list within a team collaboration site is a feature so loved by SharePoint users, it is often cited as one of the things holding back a migration to Alfresco. I agree that it’s a useful feature and I’m glad to see it making its way into Alfresco Share. Let’s take a look at the new feature, then we’ll lift up the hood to see how it works so you can implement your own custom data lists.

Quick Review of Data Lists in Alfresco Share

First, take a look at this screencast. It shows the new Data List feature in action as well as the high-level steps needed to create your own custom Data Lists.

As you can see, Data Lists let you keep track of team information that lends itself to being managed by classic web form interactions and displayed in sortable columns. You can probably think of a lot of examples of things your team needs to track that don’t make sense in a blog or a document library or maybe need a little more structure than the wiki. The screencast showed To Do’s and Issues but it could really be anything.

In the Community 3.3 releases, Alfresco Share includes To Do Lists. It sounds like more Data List examples are coming in the 3.3g release. But if you want to add your own custom data list type, it’s really easy, especially if you’re familiar with Alfresco content models (tutorial). However, right now, this still requires XML editing. SharePoint allows lists to be defined on-the-fly, so while Alfresco’s roadmap does have this as something to address in the future, right now this is still a gap between the two products.

If you are interested in just the end-user functionality of Data Lists in Alfresco Share, this is where you should bail. If you want details on what’s going on behind the scenes, keep reading…

How Data Lists are Implemented

Data Lists are persisted as nodes in the repository. One node represents the list itself–it contains child nodes for each item in the list. The data values for each list item are stored as metadata on the node–sometimes we call these “content-less objects” because there is no file content associated with them. The nodes live in the DM repository just like data from the other tools in your Share site.

If you want to see this for yourself, go into the Explorer Client. In the Sites folder, there is a folder for Share site and within that, a folder for each site tool. Data List nodes reside in the one called dataLists. In the back of your mind you should be thinking that this means items in a Data List can trigger rules and be routed through workflows just like any other node. In fact, any API call that can work with a node can work with an entry in a Data List, including CMIS. (Shameless plug: “Heck, you could even create Data Lists with Python using cmislib!”)

You know from working with data models that each Alfresco data model has an XML file that describes it. If you go look at the out-of-the-box model directory you’ll see a new content model XML file called datalistModel.xml. If you take a look at that file, you’ll see that the node that represents the container of list items is an instance of dl:dataList which inherits from cm:folder.

The nodes that represent each item on the data list are instances of specific data list types. So, for example, the out-of-the-box To Do List has items that are of type dl:todoList. In my Issues example, Issue items are instances of scidl:issuesList. All data list item types must inherit from dl:dataListItem. For one thing, that’s how the Share user interface knows what to offer as an available data list type.

The form that’s displayed when you create and edit new Data List items is configured through the Alfresco Form Service. In my example I didn’t do anything fancy with the form, but you’ve got the full power of the new Alfresco Form Service behind you so you’re not limited to simply listing one field after another.

So, creating your own custom Data List types involves two steps:

  1. Define and deploy a custom content model for your new Data List type, making sure it inherits from dl:dataListItem.
  2. Configure the Alfresco Form Service in the Alfresco Share application to display the metadata from the custom Data List in the create and edit forms as well as in the browse grid.

In my example, I used an AMP to deploy the content model to the repository tier (my Alfresco WAR) and a JAR to deploy the form service configuration to the presentation tier (the Share WAR).

If you want to try this example in your own environment, you can download the Eclipse project here. It includes an Ant build file, the content model, and the form configuration. Note that I deployed the Forms Development Kit to both the Alfresco and Share WARs prior to deploying my Data List form configuration. The example assumes you’ve done the same. If you don’t want to fool with the FDK, that’s cool, it’s not required for data lists. You may want to look at the Forms Development Guide for tips.

Big News: I’ve left Optaros to start my own firm

After nearly four years at Optaros I’ve decided to start a new chapter in my career. I’ve created a new firm called Metaversant that is focused on providing content-centric solutions and consulting to clients across all verticals and geographies. Based on my deep experience with the platform and my active participation in the community, I expect Metaversant to be heavily-focused on Alfresco. We may broaden into other technologies over time, but the over-arching theme will be to help companies get the most out of their digital assets–whether that’s documents, web content, rich media, or legal records–by leveraging Enterprise-ready, open, rich content repositories.

On one hand, I was sad to leave Optaros–it was a great place to work with lots of smart people and interesting clients/projects. And I had fun building the ECM practice into a significant portion of overall revenue. On the other hand, the timing felt right to make this change and I’m very excited about starting my own company. Optaros and I are on great terms and I’m sure we’ll find ways to do business together going forward.

There are a lot of to-do’s to get Metaversant fully functional as a corporation, but nothing’s more important than the success of your project. If you are looking for help in any of the following areas, we should talk:

  • Customized, on-site Alfresco developer training
  • Short-term tactical technical assistance
  • Architectural reviews/product fit assessments
  • Content Management customization & implementation leadership
  • Custom content-centric application development & integration
  • Domino.Doc, Vignette, Stellent, or other legacy ECM migrations

You can contact me at “jpotts” at either this domain or metaversant.com.

As usual, keep an eye out here for news on Metaversant (like a link to the yet-to-be-built web site) and other content management news and thanks for your continued support!

Using cmislib to migrate digital assets to CMIS repositories

The follow-on to my introduction to cmislib, published on developerWorks earlier in the week, is now live. In the article, Jay Brown, the development lead for IBM’s CMIS servers, walks you through a small utility that leverages Python and cmislib to xcopy image files (and their embedded EXIF metadata) into a CMIS repository.

When Jay wrote the article and the code that goes with it, he initially tested against his own IBM CMIS servers. As soon as the core functionality was complete, he changed the service URL in his config file to point to Alfresco’s CMIS server and it ran like a charm. That’s the beauty of CMIS and cmislib: Write once, manage digital assets anywhere.

Drupal Open Atrium and Alfresco CMIS files

A lot of people have been asking for the files we used to integrate Alfresco CMIS with Drupal Open Atrium (See ecmarchitect.com blog post). I’ve happily mailed those to whomever asked. I’ve had the intention of testing them with the latest version, cleaning them up, and putting somewhere more appropriate like the Open Atrium feature server, or at the very least, Google Code or GitHub. But it hasn’t happened yet so I figured I’d make them available here and appeal to the Community to give them a good home.

The zip includes a readme file with (very) rough install/config directions.

Good luck!

Updated Python CMIS library released

I’ve tagged and released a new version of cmislib, the Python CMIS client library. What’s cool about this release is that it is the first one known to work with more than one CMIS provider. Yea for interoperability! The beauty of CMIS, realized! Okay, it wasn’t that beautiful, it’s still “0.1”, and there are known issues. But I can now say the library works with both Alfresco and IBM FileNet and that’s a Good Thing.

IBM was a big help with this. Al Brown, one of the CMIS spec leads turned one of his colleagues, Jay Brown, onto cmislib. Jay called me up and asked, “If I give you access to a FileNet P8 server, can you test cmislib against it?” I was on it faster than you could say, “unittest.main()”.

I think the effort was valuable for all sides. Our little “mini plugfest” turned up issues in my client as well as both CMIS providers. Jay worked hard to chase down everything on the FileNet side. Dave Caruana chased a few down on the Alfresco side as well. Thanks to everyone for the team effort.

Anyway, give the new cmislib release a try and give me your feedback. If you want a feel for how easy it can be to work with CMIS repositories using the cmislib API, check out the documentation or dive right in. Installation is as easy as “easy_install cmislib” (easy_install instructions).

Next up is Nuxeo. Can the open source ECM vendor achieve cmislib Unit Test Greatness faster than Big Blue? We shall see!

Alfresco Share Status microblog component now supports 3.2 Enterprise

I’ve posted a new release of the Alfresco Share Status microblog component (original post). There are no new features–it’s just a few bug fixes. But one of the bugs was keeping it from working on 3.2 Enterprise. That’s now fixed, so if you’ve upgraded to Alfresco 3.2 Enterprise and you want to use this component in your Share sites, have at it.

Although I’ve tagged both the repository extensions and the surf extensions as “0.2”, only the surf extensions have changed since the last release. If you want to know specifically what’s changed, refer to the Release Notes.

Alfresco Developer Guide source code update for 3.2 Enterprise

I’ve updated the source code that accompanies the Alfresco Developer Guide to be compatible with the recent 3.2 Enterprise release of Alfresco. You can get the link from my original post on the source code re-org, or download it directly.

Most of it hasn’t changed terribly much. The BootstrapAuthorityCreator class, which you don’t need unless you are playing with the AMP example in Appendix C, isn’t working yet due to changes in the AuthorityService with 3.2 Enterprise.

The biggest change is in the LDAP configuration (Chapter 9). Overall, setting up LDAP authentication and chaining has gotten much easier in 3.2 Enterprise. But the configuration is much different than in previous releases (See the Alfresco wiki pages on Subsystems and the Authentication Subsystem for more info).

I don’t have CAS SSO working with 3.2 Enterprise quite yet, so the authentication filter included in the Chapter 9 source code is commented out for now.

cmislib: A CMIS client library for Python

I’ve started a new project on Google Code called cmislib. It is an interoperable client library for CMIS in Python that uses the Restful AtomPub Binding of a CMIS provider to perform CRUD and query functions on the repository.

I created it for a couple of reasons. First, it’s been bugging me that, unlike our Drupal Alfresco integration, our Django Alfresco integration does not use CMIS. After talking it over with one of our clients we decided it would make more sense to create a more general purpose CMIS API for Python that Django (and any other Python app) could leverage, rather than build CMIS support directly into the Django Alfresco integration.

Second, around the time I was putting together the Getting Started with CMIS tutorial, it struck me that there needed to be an API that didn’t have a lot of dependencies and was very easy to use. Otherwise, it’s too easy to get lost in the weeds and miss the whole point of CMIS: Easily working with rich content repositories, regardless of the underlying implementation.

Even if you’ve never worked with Python before, it is super easy to get started with cmislib. The install is less than 3 steps and the API should feel very natural to anyone that’s worked with a content repository before. Check it out.

Install

  1. If you don’t have Python installed already, do so. I’ve only tested on Python 2.6 so unless you’re looking to help test, stick with that.
  2. If you don’t have setuptools installed already, do so. It’s a nice tool to use for installing Python packages.
  3. Once setuptools is installed, type easy_install cmislib

That’s all there is to it. Now you’re ready to connect to your favorite CMIS-compliant repository.

Examples

There’s nothing in cmislib that is specific to any particular vendor. Once you give it your CMIS provider’s service URL and some credentials, it figures out where to go from there. But I haven’t tested with anything other than Alfresco yet, and this thing is still hot out of the oven. If you want to help test it against other CMIS 1.0cd04 repositories I’d love the help.

Anyway, let’s look at some examples using Alfresco’s public CMIS repository.

  1. From the command-line, start the Python shell by typing python then hit enter.
    2. Python 2.6.3 (r263:75183, Oct 22 2009, 20:01:16)
GCC 4.2.1 (Apple Inc. build 5646)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>
  2. Import the CmisClient and Repository classes:
    3. >>> from cmislib.model import CmisClient, Repository
  3. Point the CmisClient at the repository’s service URL
    4. >>> client = CmisClient('http://cmis.alfresco.com/s/cmis', 'admin', 'admin')
  4. Get the default repository for the service
    5. >>> repo = client.getDefaultRepository()
>>> repo.getRepositoryId()
u'83beb297-a6fa-4ac5-844b-98c871c0eea9'
  5. Get the repository’s properties. This for-loop spits out everything cmislib knows about the repo.
    6. >>> repo.getRepositoryName()
    u'Main Repository'
>>> info = repo.getRepositoryInfo()
>>> for k,v in info.items():
    ...     print "%s:%s" % (k,v)
    ...
    cmisSpecificationTitle:Version 1.0 Committee Draft 04
    cmisVersionSupported:1.0
    repositoryDescription:None
    productVersion:3.2.0 (r2 2440)
    rootFolderId:workspace://SpacesStore/aa1ecedf-9551-49c5-831a-0502bb43f348
    repositoryId:83beb297-a6fa-4ac5-844b-98c871c0eea9
    repositoryName:Main Repository
    vendorName:Alfresco
    productName:Alfresco Repository (Community)

Once you’ve got the Repository object you can start working with folders.

  1. Create a new folder in the root. You should name yours something unique.
    2. >>> root = repo.getRootFolder()
>>> someFolder = root.createFolder('someFolder')
>>> someFolder.getObjectId()
u'workspace://SpacesStore/91f344ef-84e7-43d8-b379-959c0be7e8fc'
  2. Then, you can create some content:
    3. >>> someFile = open('test.txt', 'r')
>>> someDoc = someFolder.createDocument('Test Document', contentFile=someFile)
  3. And, if you want, you can dump the properties of the newly-created document (this is a partial list):
    4. >>> props = someDoc.getProperties()
>>> for k,v in props.items():
...     print '%s:%s' % (k,v)
...
cmis:contentStreamMimeType:text/plain
cmis:creationDate:2009-12-18T10:59:26.667-06:00
cmis:baseTypeId:cmis:document
cmis:isLatestMajorVersion:false
cmis:isImmutable:false
cmis:isMajorVersion:false
cmis:objectId:workspace://SpacesStore/2cf36ad5-92b0-4731-94a4-9f3fef25b479
  4. You can also use cmislib to run CMIS queries. Let’s find the doc we just created with a full-text search. (Note that I’m currently seeing a problem with Alfresco in which the CMIS service returns one less result than what’s really there):
    5. >>> results = repo.query("select * from cmis:document where contains('test')")
>>> for result in results:
...     print result.getName()
...
Test Document2
example test script.js
  5. Alternatively, you can also get objects by their object ID or their path, like this:
    6. >>> someDoc = repo.getObjectByPath('/someFolder/Test Document')
>>> someDoc.getObjectId()
u'workspace://SpacesStore/2cf36ad5-92b0-4731-94a4-9f3fef25b479'

Set Python loose on your CMIS repository

These are just a few examples meant to give you a feel for the API. There are several other things you can do with cmislib. The package comes with documentation so look there for more info. If you find any problems and you want to pitch in, you can check out the source from Google Code and create issues there as well.

Give this a try and let me know what you think.

[UPDATE: I had the wrong URL for the Alfresco-hosted CMIS service. It’s fixed now.]

Spring, Roo, and Alfresco Too: What Alfresco Gave to Spring and Why

Surf Logo

You’ll recall from my community event takeaways post in November that Alfresco announced plans around Surf, the Apache license, and Spring but the details were foggy at the time. This week, Alfresco and SpringSource announced that Surf, Web Scripts, and Web Studio have been donated to the Spring open source community under the Apache 2.0 license.

What is Surf?

Surf is a lightweight web application development framework. At a very high-level, Surf is essentially Alfresco Web Scripts (an MVC framework for binding URLs to server-side JavaScript/Java and Freemarker-based views) plus some page layout constructs and some built-in objects for connecting to and authenticating with remote HTTP end points, including Alfresco (See also “Alfresco UI Options” and “Surf Code Camp“).

Why Spring Surf Makes Sense

Alfresco’s team collaboration application, Alfresco Share, is built on top of the Surf framework and clients and partners, including Optaros, have built solutions on top of Surf. But so far, our experience has been that we probably could have built solutions faster using a different framework. One of the reasons is because you often can’t do everything you need to with Surf alone–it lacks services that would normally be provided by a broader framework. Your choice is either to re-create what’s missing or bolt on something that exists. So that’s the first reason why Surf becoming part of Spring makes sense. Spring is already a mature and widely-adopted framework. It’s much better to make Surf and Web Scripts part of an established framework (and community) than to try to grow Surf into a full-featured framework.

The second reason is more strategic. Alfresco sees a future dominated by CMIS (See “Getting Started with CMIS“). They want to be the go-to CMIS platform. From a repository perspective, they’ve been very active on this front. But development tools are going to be important, and although part of the beauty of CMIS is that it is tool-agnostic, I think SpringSource and Alfresco would obviously be pleased if their framework became a very natural and productive way to build CMIS apps.

Third, Alfresco doesn’t necessarily want to spend a lot of time on tools and frameworks if it doesn’t have to. Look at how much time Web Studio has languished in Community limbo–it’s clearly not a priority. If Surf catches on in the broader Spring community maybe Web Studio has a chance to turn into something. My guess is that SpringSource would prefer all development to take place within STS, its Eclipse-based IDE. Maybe Web Studio will get sucked into that somehow.

So what is Roo?

One of the things mentioned as part of the Spring Surf announcement is that Spring Roo integration is included. Spring Roo is pretty new so you might be wondering what that is. It’s pretty cool, actually. Basically, it’s a productivity tool for people who are building Spring apps. If you’ve ever worked with frameworks like Ruby on Rails, Grails, or Django, one of the first things you learn is how to use the command-line project scaffolding tools. Those tools make it easy for you to spin up and configure your project. Spring Roo is similar–it gives you a shell and a bunch of commands for things like setting up persistence, adding unit tests, and configuring security.

Spring Roo is extensible which is where Surf comes in. Let’s say you’ve created a Spring project and you want to use Surf as part of that project. All you have to do is go into your Roo shell and type “surf addon install”. No monkeying with the web.xml. No hunting for JAR files. It just happens. Next, suppose you want to add some Surf pages. Type “surf page create –id ‘SomeOtherPage’ –templateInstance home” and the XML is created for you in the right place (yes, the shell provides keyboard assist and hints so you don’t have to remember those commands).

Roo is definitely better appreciated by seeing it or trying it yourself. Michael Uzquiano did a short screencast showing the Spring Roo Surf extension. If you want to try Roo out yourself, go through Ben Alex’s “Getting Started with Spring Roo” posts.

Learn More

The bottom-line is that Surf becoming part of the Spring community is a good thing. You should check it out. The official Spring Surf page is the place to start. That’s where you’ll find the SVN URL, binary downloads, and links to other resources. There’s also going to be a webinar in January if you want to learn more.