Key to Content

Resetting a Forgotten Alfresco admin password

2011-09-09T09:57:00.000-07:00

It may never happen to you, but if you ever lose or forget the password for the administration user in Alfresco, it is possible to reset that password within the database.

While the reset process is easy to do, it involves fiddling directly with the database, something which you should be careful with, especially if that's not something you typically work with. If you're having problems with a production system, by all means, experiment first on a test system. You don't want to make a bad situation worse.

First run the following SQL to find out the identifying parameters for how the admin password is stored:

SELECT anp1.node_id,
       anp1.qname_id,
       anp1.string_value as hash_pass,
       anp2.string_value as user_string
FROM alf_node_properties anp1
        INNER JOIN alf_qname aq1
           ON aq1.id       = anp1.qname_id
        INNER JOIN alf_node_properties anp2 
           ON anp2.node_id = anp1.node_id
        INNER JOIN alf_qname aq2            
           ON aq2.id       = anp2.qname_id
WHERE aq1.local_name    = 'password'
AND aq2.local_name    = 'username';

After doing that, you'll see something like the following:

In this example, we can see that the password for admin is set to the default MD5 hash value for 'admin'. You can set it back to some other MD5 hash value, but then of course, you'd need to calculate the MD5 value for whatever your desired password is. It's easier to set it back to the default value corresponding to 'admin': '209c6174da490caeb422f3fa5a7ae634'. Then, once you can log back into Alfresco again you would be able to change the password to something else.

To update the password, the following SQL works:

UPDATE alf_node_properties 
 SET string_value='209c6174da490caeb422f3fa5a7ae634'
 WHERE 
 node_id=THEADMINNODEID
 and
 qname_id=THEADMINQNAME

Or, from the example shown in the screenshot above:

UPDATE alf_node_properties 
 SET string_value='209c6174da490caeb422f3fa5a7ae634'
 WHERE 
 node_id=4
 and
 qname_id=10

Alfresco 3 Cookbook: Quick Answers to Common Problems by Snig Bhaumik

2011-08-13T22:58:00.000-07:00

Alfresco 3 Cookbook: Quick Answers to Common Problems by Snig Bhaumik is the latest book from PACKT Publishing about the Alfresco Open Source Enterprise Content Management System.(CMS). The book is now complete and is available in both print and electronic format. Prior to the book being completed, parts of it had been made available earlier by PACKT in a pre-release RAW format.

When I heard about this book, I was immediately interested. The concept of having a cookbook-style reference book filled with easy-to-follow self-contained recipes for how to perform common tasks in Alfresco is very appealing.

The book is about 380 pages long and is organized into 14 chapters, each chapter covering one category of Alfresco usage, like the Administration Console, the Web Client, and the Content Model. Then within each chapter, there are a number of recipes that describe how to perform specific tasks. In total, the book covers more than 70 such recipes. For example, Chapter 6 covers how to customize the Alfresco Web Client and includes recipes like the following:

Changing languages in the Login page
Changing textbox length and text area size
Controlling the Date Picker
Controlling the sidebar display

Each of the sections or 'recipes' is then broken down into a brief description of the task followed by a sub-section titled "Getting Ready" and then another one titled "How to do it...". There's also an occasional "There's more..." section that contains a more in-depth explanation for why or how something works. The "How to do it..." section is the heart of the recipe and it breaks down each task into step-by-step instructions for how to complete it.

The text descriptions are very clear and there are many illustrations, mostly of UI screenshots.

I like the cookbook style the book uses -- this book is part of PACKT's cookbook series. But to stay true to the cookbook format, I would have preferred a larger number of recipes with shorter discussions about the background mechanics for how any one particular recipe works. Some of the recipes are a bit long and stretch to as many as twenty pages.

The book starts out by describing the Alfresco installation process and then discusses topics useful to end users and administrators. In this part of the book and even in some of the later chapters, while I liked the overall style of presentation and format, it felt like there was a lot of overlap with material already covered in other places like Munwar Shariff's book Alfresco 3 Enterprise Content Management Implementation or even with what can be found in the standard Alfresco documentation. I would have liked to have seen more 'tips, tricks and gotchas' that go beyond just that material.

Later chapters discuss topics for those who want to customize and develop in the Alfresco environment. Topics include the Content Model, the Alfresco Javascript API, FreeMarker and Workflow. The final chapter describes how to download Alfresco source and set up a build environment. I did like the discussion in Chapter 10 on Web Scripts.

Chapter 12 had me a bit puzzled. That chapter discusses integration of Alfresco with Microsoft applications and has a lengthy discussion of Alfresco's MS-Office 2003 plug-in instead of discussing SharePoint protocol integration. I may be wrong, but I had been under the impression that the Office plugin for Alfresco has been problematic and doesn't support Office 2010.

The main caveat that I have about the book though is its focus on the use of Alfresco's older Explorer client. Alfresco Share is only mentioned on a couple of pages early on in the chapter that describes installation. I would have liked to have seen much more about Share. I think that almost all new deployments of Alfresco today will want to use Share as the web client, not the older Explorer client.

So, in general, I thought this book was well written and I think that you'll find a lot of useful facts about Alfresco here. I also find the cookbook format used by the book very appealing. But you'll likely be disappointed if you're looking for a book that covers Alfresco Share. I expect that PACKT has some books in the works on Alfresco Share coming up. In the near term though, there is a good overview discussion on Share in the latter part of Munwar's book that I reference above.

** I'd like to thank PACKT Publishing for making available to me a complementary copy of this book for review.

Alfresco Share Permissions/Roles -- Part II

2011-04-04T16:17:00.000-07:00

Creating Custom Alfresco Permissions/Roles

In the previous blog we saw how we were able to fairly easily replace the Share Manage Permissions dialog with the Manage Permissions page used for the Repository button browser. This allowed us to be able to assign at a much more granular level permissions to the folders and items that are stored within a Share site Document Library.

Now consider the scenario where we would like to be able to invite users to our site, and these users should be able to see and modify only a selected set of documents within the Document Library. We want access to the site for the majority of users to be unrestricted. This scenario doesn't work well with the standard Share site roles of Manager, Collaborator, Contributor and Consumer.

To invite a restricted user to the site, we still need to give them a role. Even if we give this user the role of Site Consumer, they will be able to see much more content in the site than what we want them to see.

What I propose here to help solve this problem is to add new custom Share site roles. Alfresco has a wiki page here that provides a good start for what needs to be done in creating a custom Share role. After following the instructions there, which were targeted for version 3.2r, I ran into some issues, and I noted a number of other people in the Alfresco forums also had some issues with it.

What I describe here should work with a fresh Alfresco install. Trying to add new roles after Share sites have already been created will likely result in errors being thrown. The reason why this happens is that the appropriate group authorities will not exist and Share will report that as an error. Once these new roles are created, Share expects them to exist for all sites. The absence of these authorities for existing sites likely is something that can be corrected by manually creating the correct authority objects in Alfresco, but we don't attempt to do that here.

Here we will create three new permissions sets/roles called External Consumer, External Contributor, and External Collaborator. The permissions for each of these roles are identical to those of the corresponding Site Consumer, Site Contributor and Site Collaborator that come standard with Share. What will be different is how these permissions are applied to content in the Document Library.

To do that, we edit the file sitePermissionDefinitions.xml and replicate the lines for SiteContributor, SiteConsumer, and SiteCollaborator permissionGroups. This file is then placed into the following directory:
tomcat/shared/classes/alfresco/extension/model/
<?xml version='1.0' encoding='UTF-8'?>

<!DOCTYPE permissions >

<permissions>
    
    <!-- Namespaces used in type references -->
    
   <namespaces>
      <namespace uri="http://www.alfresco.org/model/system/1.0" prefix="sys"/>
      <namespace uri="http://www.alfresco.org/model/content/1.0" prefix="cm"/>
      <namespace uri="http://www.alfresco.org/model/site/1.0" prefix="st"/>
   </namespaces>
   
   <!-- ============================================ -->
   <!-- Permissions specific to the wiki integration -->
   <!-- ============================================ -->
   
   <permissionSet type="st:site" expose="selected">
   
      <permissionGroup name="SiteManager" allowFullControl="true" expose="true" />
      
      <permissionGroup name="SiteCollaborator" allowFullControl="false" expose="true">
         <includePermissionGroup permissionGroup="Collaborator" type="cm:cmobject" />
      </permissionGroup>
      
      <permissionGroup name="SiteContributor" allowFullControl="false" expose="true">
         <includePermissionGroup permissionGroup="Contributor" type="cm:cmobject" />
      </permissionGroup>
      
      <permissionGroup name="SiteConsumer" allowFullControl="false" expose="true">
         <includePermissionGroup permissionGroup="Consumer" type="cm:cmobject" />
      </permissionGroup>

      <permissionGroup name="ExternalCollaborator" allowFullControl="false" expose="true">
         <includePermissionGroup permissionGroup="Collaborator" type="cm:cmobject" />
      </permissionGroup>
      
      <permissionGroup name="ExternalContributor" allowFullControl="false" expose="true">
         <includePermissionGroup permissionGroup="Contributor" type="cm:cmobject" />
      </permissionGroup>
      
      <permissionGroup name="ExternalConsumer" allowFullControl="false" expose="true">
         <includePermissionGroup permissionGroup="Consumer" type="cm:cmobject" />
      </permissionGroup>
      
   </permissionSet>

</permissions>

We need to alert Alfresco that this override file should be loaded on startup. To do that, we create a new file with the path
tomcat/shared/classes/alfresco/extension/restricted-role-context.xml.
The contents of that file are as follows:
<?xml version='1.0' encoding='UTF-8'?>

<!DOCTYPE beans PUBLIC '-//SPRING//DTD BEAN//EN' 'http://www.springframework.org/dtd/spring-beans.dtd'>

<!-- This file enables Alfresco Custom Site Roles.  It should be placed in shared/classes/extension -->

<beans>

    <bean id="siteService_permissionBootstrap" parent="permissionModelBootstrap">
     <property name="model" value="alfresco/extension/model/sitePermissionDefinitions.xml"/>
    </bean>

</beans>

Finally, there are a number of files where we add string properties that can be picked up so that the new role names display correctly within the Share UI.
First we create the file
tomcat/shared/classes/alfresco/web-extension/invitation-service-context.xml:
<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC '-//SPRING//DTD BEAN//EN' 'http://www.springframework.org/dtd/spring-beans.dtd'>
<beans>
     
    <bean id="invitationResourceBundles" class="org.alfresco.i18n.ResourceBundleBootstrapComponent">
     <property name="resourceBundles">
      <list>
       <value>alfresco.web-extension.messages.invitation-service</value>
      </list>
     </property>
   </bean>

</beans>

And the associated property file:
tomcat/shared/classes/alfresco/web-extension/messages/invitation-service.properties:

invitation.invitesender.email.role.ExternalCollaborator=External Collaborator
invitation.invitesender.email.role.ExternalContributor=External Contributor
invitation.invitesender.email.role.ExternalConsumer=External Consumer

We add the following lines to the file:
tomcat/shared/classes/alfresco/web-extension/custom-slingshot-application-context.xml

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

<beans>
   <bean id="webscripts.resources" class="org.springframework.extensions.surf.util.ResourceBundleBootstrapComponent">
      <property name="resourceBundles">
         <list>
             <value>alfresco.messages.common</value>
             <value>alfresco.messages.slingshot</value>
            <value>alfresco.web-extension.messages.slingshot</value>
         </list>
      </property>
   </bean>
</beans>

And the referenced new properties are in the file:
tomcat/shared/classes/alfresco/web-extension/messages/slingshot.properties

## Custom Site External Reviewer Roles
role.ExternalCollaborator=External Collaborator
role.ExternalContributor=External Contributor
role.ExternalConsumer=External Consumer

Next we copy the file
tomcat/webapps/share/WEB-INF/classes/alfresco/web-extension/site-webscripts/org/alfresco/components/folder-details/folder-info.get.properties
to
tomcat/shared/classes/alfresco/web-extension/site-webscripts/org/alfresco/components/folder-details
and include these lines at the end of the file:

folder-info.role.ExternalCollaborator=External Collaborator
folder-info.role.ExternalConsumer=External Consumer
folder-info.role.ExternalContributor=External Contributor

Similarly copy the file
tomcat/webapps/share/WEB-INF/classes/alfresco/web-extension/site-webscripts/org/alfresco/components/document-details/document-info.get.properties

tomcat/shared/classes/alfresco/web-extension/site-webscripts/org/alfresco/components/document-details/document-info.get.properties

and include these lines at the end:

## Customer External Review Role
document-info.role.ExternalCollaborator=External Collaborator
document-info.role.ExternalConsumer=External Consumer
document-info.role.ExternalContributor=External Contributor

Copy the file

tomcat/webapps/share/WEB-INF/classes/alfresco/web-extension/site-webscripts/org/alfresco/components/invite/invitationlist.get.properties

tomcat/shared/classes/alfresco/web-extension/site-webscripts/org/alfresco/components/invite/invitationlist.get.properties

and include these lines at the end:

## External Groups and Roles for Site
group.ExternalCollaborator=External Collaborators
role.ExternalCollaborator=External Collaborators

group.ExternalConsumer=External Consumers
role.ExternalConsumer=External Consumers

group.ExternalCotributor=External Contributors
role.ExternalContributor=External Contributors

And finally, copy the file

tomcat/webapps/share/WEB-INF/classes/alfresco/web-extension/site-webscripts/org/alfresco/modules/documentlibrary/permissions.get.properties

tomcat/shared/classes/alfresco/web-extension/site-webscripts/org/alfresco/modules/documentlibrary/permissions.get.properties

and include these lines at the end:

## External Groups and Roles for Site
group.ExternalCollaborator=External Collaborators
role.ExternalCollaborator=External Collaborator privileges

group.ExternalConsumer=External Consumers
role.ExternalConsumer=External Consumer privileges

group.ExternalCotributor=External Contributors
role.ExternalContributor=External Contributor privileges

External Site Roles in Action
Whew...
After doing that, we stop and restart the Alfresco server. We can then log in and create a new Share site.

Immediately after creating the site, we can navigate to the root node for the site by using the Repository button in Share. When we click on the Manage Permissions button for the new site, we can see that our new permissions sets (ExternalConsumer, ExternalCollaborator, and External Consumer) are included automatically and applied to this node.

At the Document Library level, we can create a folder structure where two top level folders are to be accessible only by the standard SiteConsumer, SiteCollaborator and SiteContributor. And a third folder is available to standard users and is also open for viewing to External Reviewers.

The internal folder permissions look as follows:

With these settings, only internal reviewers will be able to see the content of this folder.

In the External Reviewer folder, we set the permissions as follows:

In this case, we can see that both external and standard internal reviewers are able to access this folder.
And if we navigate one Folder down in the hierarchy of the External Reviewer Folder, we can see that the inheritance of these permissions flow down. One folder down, we see the permissions are set in the same way:

One last note. In order for the user/group search capability to work correctly on this form, I found that the "Add User/Group" button on this page does not find Alfresco Share groups. By default, search is performed for groups within the ALF.DEFAULT zone which does not include the Share zone groups. In order to find our groups, the following Javascript file was changed (Note the changes in bold made to that file):
tomcat/shared/classes/alfresco/web-extension/site-webscripts/org/alfresco/components/people-finder/authority-query.get.js
var getMappings = function()

{
   var mappings = [],
      authorityType = args.authorityType === null ? "all" : String(args.authorityType).toLowerCase();
   
   if (authorityType === "all" || authorityType == "user")
   {
      mappings.push(
      {
         type: MAPPING_TYPE.API,
         url: "/api/people?filter=" + encodeURIComponent(args.filter),
         rootObject: "people",
         fn: mapUser
      });
   }

   if (authorityType === "all" || authorityType === "group")
   {
      var url = "/api/groups?shortNameFilter=" + encodeURIComponent(args.filter);
//    if (args.zone !== "all")
// All authorities are to be found
      if (args.zone !== "all" && args.zone !== null)
      {
         url += "&zone=" + encodeURIComponent(args.zone === null ? "APP.DEFAULT" : args.zone);
      }
...

Alfresco Share Permissions/Roles -- Part I

2011-04-01T16:51:00.000-07:00

Accessing Granular Permission Rights within Alfresco Share

People are sometimes surprised to find that although the Alfresco repository is architected to have very granular permissions, permissions assignments via the Share UI are based on Site roles.

Share Site Roles
The Share roles are as follows:

Site Consumer		Read
Site Contributor		Read, Upload
Site Collaborator		Read, Upload, Checkout, Edit
Site Manager		Full Control

Interestingly, Alfresco did not include a Site Editor role for the Share UI, despite the fact that the Editor is a standard role used within the repository and is accessible in the Alfresco Explorer client. [Note the editor can change existing document but doesn't have the Upload/Create capability.]

Within the Alfresco Share client, assignment of permissions at the object level is possible using the Manage Permissions action dialog: Here we can see that permissions are assigned to the standard Share site groups. There is no way using this dialog to specify permissions for an individual.

The mix of using the same name, like 'Site Consumer' when referring to groups, privilege sets and roles also makes for some confusion on this dialog.

Role Assignments via the Share Repository Button
If permissions on objects can be enforced only by role, how can one restrict the viewing of some of the documents in the repository to only one or a few individuals? It can be done from the Explorer client. And, interestingly, it can also be accessed in Alfresco Share when browsing the Alfresco Repository, a feature which has been made available in Share.

When browsing the repository, a different page is displayed for setting permissions than the dialog we saw above which is used when browsing within a site Document Library. I'm not sure why Alfresco developers decided on this particular discrepancy in the design.

So setting permissions at a much more granular level is available within Share out of the box, but its location is a bit problematic because it isn't obvious that it is available.

Changing the Manage Permissions Action
To change the behavior of the Manage Permissions action to be the same as that available from the Share Repository button is not hard. To do that we need to modify three files. First we make folders in the tomcat/shared folder to hold the Share files that we will change.

In the document-details folder, we copy over the file document-actions.get.config.xml.

In the documentlibrary folder, we copy over the file documentlist.get.config.xml.

In the folder-details folder, we copy over the file folder-actions.get.config.xml.

In these files, we then edit the following line:

<action id="onActionManagePermissions" label="actions.document.manage-permissions" permission="permissions" type="action-link"></action>>

This line is changed to the following:

<action type="simple-link" id="onActionManagePermissions" permission="permissions" href="{managePermissionsUrl}" label="actions.folder.manage-permissions" />

This same line needs to change once in each of
document-actions.get.config.xml and folder-actions.get.config.xml files,
and twice in the file documentlist.get.config.xml.

After adding these files, we stop and start the server.

Testing out the Manage Permissions Changes
Consider the case of a manager who has uploaded a new document, a document that he wants only Susan, a user with role Site Consumer, to be able to see it. (Although note that site managers will always be able to see all site document regardless of permission settings.)

After creating the document, click on the document action Manage Permissions. We'll see a screen that looks like the following:

Because, via inheritance of permissions in Share, all members of the Share site currently have access to see this document. Let's change the access permissions by doing the following:

click on Inherit Permissions to turn off that inheritance, and then
click on Add User/Group and selecting Susan as the only user with permissions to see this document
click on the save button to save the new permission settings

After doing that, the Manage Permissions screen shows the following.

Login as Mary
Now we can log out as the site manager and log in as as Mary, a Site Collaborator. Mary should have no permission to see this document.

Mary can navigate into the document library for the site and she does not see the document restricted to Susan.

One glitch does show up here. In the "Site Activities" Dashlet of the site, the document still shows up. See the top document in this list, BGESWFViewer.png below:

This seems to be a bug with this Alfresco dashlet to have allowed a restricted document's name to be seen by someone without permission. But, other than that, this seems to work pretty well.

And when Mary clicks on the link to the document that she sees in this dashlet, she finds that she is restricted from accessing it:

Login as Susan, Site Consumer
When logging in as Susan, in the Dashboard for the site, we see references to the document in both the "Recently Modified Document" dashlet and also the "Site Activities" dashlet. But this is as it should be since Susan has rights to see this document.

On navigation into the Document Library, Susan is able to successfully open the document. She can open the document details page. If you notice when we assigned permissions to Susan above, we gave her permission as "Site Collaborator". In that case, Susan is able to edit the metadata for it.

Updates to Alfresco Aspect Properties using CMIS (Part 2)

2011-03-02T13:23:00.000-08:00

This is a follow-up to my previous post about how to update aspect properties on documents using CMIS in Alfresco. In the earlier post I provided a bit of a hack that permits aspect-defined properties to be updated just like regular document properties -- with no changes to the atom entry sent by CMIS to the server. I should say that this hack is frowned on because Alfresco is purposely disabling support for aspects in their implementation of the CMIS API.

The reason why aspects are disabled is because Alfresco wants to comply totally with the CMIS 1.0 standard, and that first version of the standard does not provide support for aspects. Actually, the possibility of adding support for aspects in CMIS has been a topic of discussion on the Alfresco forums for some time.

The interim solution for getting at aspect properties using CMIS is to use custom Alfresco CMIS extensions. But any code you write using an Alfresco extension of course will not work with any other CMIS repository. Using an extension seems to defeat the purpose of the 'write once, deploy against any repository' selling point for CMIS, but the alternative is to introduce hacks that allows Alfresco CMIS to recognize aspect properties as regular properties, which isn't pretty either.

A page on the Alfresco website describes how CMIS extensions can enable the handling of aspects:

CMIS extensions are XML fragments placed in different parts of a CMIS object. The Alfresco aspect fragments are documented on the Alfresco Wiki. So, theoretically, they are available to all CMIS clients out there including OpenCMIS.

In reality, dealing with CMIS extensions isn't fun and can require quite a lot of code. OpenCMIS does all the XML parsing for you but, since it doesn't know anything about aspects, it can't provide pretty interfaces.

For example, when properties are updated using CMIS against an Alfresco repository, properties need to be partitioned between those properties that are related to aspects and those that aren't. This is done by using Alfresco-specific extension tags as shown in bold in the atom entry below. In this example, the first property cmis:name is not included within the Alfresco tags, while aspect properties edm:program_project and cm:author are. These extension tags enable the partitioning out of aspect properties.

<entry xmlns="http://www.w3.org/2005/Atom" 
       xmlns:cmisra="http://docs.oasis-open.org/ns/cmis/restatom/200908/" 
       xmlns:cmis="http://docs.oasis-open.org/ns/cmis/core/200908/" 
       xmlns:alf="http://www.alfresco.org">
<title>2d_house_plan.dwg</title>
<cmisra:object>
<cmis:properties>
<cmis:propertyString propertyDefinitionId="cmis:name" queryName="cmis:name"><cmis:value>My CAD Drawing</cmis:value></cmis:propertyString>
<alf:setAspects>
<alf:properties>
<cmis:propertyString propertyDefinitionId="edm:program_project" queryName="edm:program_project"><cmis:value>Big Project</cmis:value></cmis:propertyString>
<cmis:propertyString propertyDefinitionId="cm:author" queryName="cm:author"><cmis:value>admin</cmis:value></cmis:propertyString>
</alf:properties>
</alf:setAspects>
</cmis:properties>
</cmisra:object>
</entry>

Updating Aspect Properties in Alfresco with CMIS

2011-02-28T14:06:00.000-08:00

The current CMIS 1.0 specification does not address the dynamic metadata assignment like the concept of aspects used within Alfresco. In the Alfresco 3.4d Community release, an attempt to send a CMIS request to update metadata properties on fields which have been assigned via aspects fails.

For example, in developing the Formtek EDM module, we attempted to send a request to update the value for a property which was assigned to a document through the addition of an aspect.

An example of the CMIS request to update metadata and the associated ATOM document are as follows:

PUT /alfresco/s/cmis/s/workspace:SpacesStore/i/4073281a-5e9c-45cc-966a-4a2f32a933b8

<entry xmlns="http://www.w3.org/2005/Atom"
  xmlns:cmisra="http://docs.oasis-open.org/ns/cmis/restatom/200908/" 
  xmlns:cmis="http://docs.oasis-open.org/ns/cmis/core/200908/" 
  xmlns:alf="http://www.alfresco.org">
    <title>2d_house_plan.dwg</title>
    <cmisra:object>
      <cmis:properties>
        <cmis:propertyString propertyDefinitionId="edm:program_project"
 queryName="edm:program_project"><cmis:value>2d_house_plan.dwg</cmis:value>
        </cmis:propertyString>
          </cmis:properties>
    </cmisra:object>
</entry>

Here the property edm:program_project is a property of a custom document type associated with the document via a mandatory aspect.

The request fails with the following error:

The WebScript has responded with a status of 400 - Bad Request.
400 Description: Request sent by the client was syntactically incorrect.
Message: Property edm:program_project is not a known property for type D:edm:engineeringDrawing

I was able to fix this by replacing lines 227-228 of the file /tomcat/webapps/alfresco/WEB-INF/classes/alfresco/templates/webscripts/org/alfresco/cmis/lib/modify.lib.js

// is this a valid property?
var propDef = typeDef == null ? cmis.queryProperty(propName) : typeDef.propertyDefinitions[propName];

with this:

// is this a valid property?
var propDef;
if(typeDef != null)
{
    propDef = typeDef.propertyDefinitions[propName];
}
    if(propDef == null)
{
    propDef = cmis.queryProperty(propName);
}

Formtek to Deliver Engineering Data Management Webinar

2011-01-20T08:39:00.000-08:00

Formtek to Deliver Engineering Data Management Webinar

On February 3, 2011, Formtek's Chief Technology Officer, Dick Weisinger, will present a webinar, sponsored by Alfresco, entitled: Engineering Data Management Module for Alfresco.

The Formtek Engineering Data Management (EDM) Module is a pre-packaged extension to the Alfresco data repository and Share application that is designed to improve the management, accessibility and search capability of engineering data. The EDM Module provides pre-configured content models specific to the needs of engineering organizations for the management of drawings and documents within the Alfresco repository.

Within Alfresco Share, the EDM Module provides packaged view, edit and advanced search forms that enable engineering metadata to be displayed, edited and efficiently searched. The EDM Module also supports popular AutoCAD® file formats, including DWG, DXF and DWF. Thumbnails and Flash (SWF) previews of AutoCAD files are automatically generated for display and use within the Share Document Library.

To register for this event, visit Alfresco's registration page.

For additional information about Formtek's Engineering Data Management offerings, download the product data sheet or contact: sales@formtek.com.

About Formtek: For over two decades, Formtek has been providing mission-critical Enterprise Document and Content Management solutions and services to some of the most demanding industrial operations in the world. Our capabilities and experience, particularly in the areas of engineering drawing management, technical document management, and secure collaboration, have helped both small organizations as well as large global enterprises manage their most important information assets. Formtek solutions address real, day-to-day document management, content management, and records management requirements for worldwide customers in manufacturing, aerospace, defense, telecommunication, utility, and government.

JBPM Workflow in Alfresco Share 3.4a community release

2010-10-25T19:17:00.000-07:00

There's some interesting improvements available for Workflow in the Alfresco 3.4a Share community release. Alfresco community downloads are available here.

Gavin Cornwell from Alfresco has updated the Alfresco wiki with information about 3.4 Share workflow.

Starting a Workflow in Share
Workflows can be started by clicking on the "Start Workflow" action links from either the document details page, from the actions along the right on an item row in the list of Document Library items, or from the select items menu which applies to all items selected in the Document Library page.

After clicking on that, the start-workflow page comes up. It's a little bit sparse. The main element is a button that lets you choose which workflow to assign from a popup list of all available Workflows that can be initiated.

The available workflows are those that have been registered with the JBPM engine. The Alfresco wiki outlines the steps for adding a new custom workflow. Once added, the new workflow automatically becomes available in this dropdown. Prior to release 3.4 in Share, the workflow items that could be assigned in Share were hardcoded.

In the screenshot above we can see the new "Custom Lifecycle Review" workflow added using the code from the Alfresco wiki.

As an aside: The server-side Javascript file tomcat\webapps\share\WEB-INF\classes\site-webscripts\org\alfresco\components\workflow\workflow.lib.js that contains the code used on this page to query out the available workflows (getWorkflowDefinitions).

The list of scripts displayed are determined for the dropdown menu from the webscript:
http://localhost:8080/alfresco/service/api/workflow-definitions
Workflows can be filtered out from this list, for example, if you don't want to see WCM workflows. These workflows are identified by the

tag <

hidden-workflows>

in the tomcat\webapps\share\WEB-INF\classes\alfresco\share-config.xml file, and also in the wcmquickstart-share-config.xml file in that same directory.

Form for Starting and Assigning a Workflow

After you select one of the workflows in the list, the form to enter the parameters that define the workflow is displayed. I didn't expect to see too much when I selected the new Custom Lifecycle workflow since I had not defined a form for it, but it wasn't too bad. The layout wasn't great, but everything seemed to work OK, and assigning the workflow worked too.

We can customize the look of this form easily. For example, by adding the following code to the tomcat\shared\classes\alfresco\web-extensions\share-config-custom.xml file, the layout can be changed. (The file tomcat\shared\classes\alfresco\web-extension\share-config-custom.xml defined where form definitions and overrides can be placed.)

The important thing here is to match the name of the workflow correctly in the condition for identifying the form that will be matched to it, like condition="jbpm$wfl:lifecycleapproval" in the example below.

<config condition="jbpm$wfl:lifecycleapproval" evaluator="string-compare">
      <forms>
         <form>
<field-visibility>
               <show id="bpm:workflowDescription">
               <show id="bpm:workflowDueDate">
               <show id="bpm:workflowPriority">
               <show id="bpm:assignee">
               <show id="packageItems">
            </show></show></show></show></show></field-visibility>
            <appearance>
               <set appearance="title" id="" label-id="workflow.set.general">
               <set appearance="" id="info" template="/org/alfresco/components/form/2-column-set.ftl">
               <set appearance="title" id="assignee" label-id="workflow.set.assignee">
               <set appearance="title" id="items" label-id="workflow.set.items">
               
               <field id="bpm:workflowDescription" label-id="workflow.field.message">
                  <control template="/org/alfresco/components/form/controls/textarea.ftl">
                     <control-param name="style">width: 95%</control-param>
                  </control>
               </field>
               <field id="bpm:workflowDueDate" label-id="workflow.field.due" set="info">
               <field id="bpm:workflowPriority" label-id="workflow.field.priority" set="info">
                  <control template="/org/alfresco/components/form/controls/workflow/priority.ftl">
               </control></field>
               <field id="bpm:assignee" label-id="workflow.field.reviewer" set="assignee">
               <field id="packageItems" set="items">
            </field></field></field></set></set></set></set></appearance>
         </form>
</forms>
   </config>

User Task and Started Workflow Lists

The uppermost Share navigation toolbar has been redesigned. A "More" button is available which now includes links to user areas like "My Profile", "My Sites", and "My Content". Links to two pages that are new to the 3.4 release are also included in this dropdown list: "My Tasks" and "Workflows I've Started". We'll talk about these two new features in just a bit.

Also included in this dropdown list are links to administrative functions like "Application" settings, "Groups", "Users", and another new-for-3.4 capability, "Replication Jobs". These are grouped together in the menu in a category called "Tools". I think that I would prefer that these administrative tasks be broken out into their own menu, but this layout is still workable given the current set of features in Share.

The "My Tasks" page presents a nice summary of the outstanding tasks for the user. Filters along the left let you quickly zoom in on a specific set of tasks if there are many in your list.

A similar page exists for the user to see the workflows that they've started. Unfortunately though, once the 'Task Complete' task is done it is removed from the list. It would be nice to be able to review the workflows that have completed.

Inbound Emails with Windows localhost

2010-07-11T19:14:00.000-07:00

In May I wrote a brief post that showed how you can post emails to the Alfresco server for automatic capture and upload into a specified Folder. It's a great way to upload email content into Alfresco without having to bring up the Alfresco client interface. This is powerful feature that I really like.

A few useful scenarios come to mind with this functionality:

You can compose a new email with information and add attachments that you send to an Alfresco folder. You don't need to bring up the client and navigate to the correct folder/space.
You receive an email containing important information or attachments and you simply forward the email to the Alfresco folder.
You can just add the target Alfresco folder alias as a cc and capture into Alfresco important emails messages when you send them. This is a very simple way to capture emails and requires very little overhead time for interacting with the repository.

So I wanted to be able to easily demonstrate this functionality. My previous post showed how you can setup inbound email on a server exposed on the internet. In that case I had Alfresco installed on an Amazon EC2 server. But I wanted to also be able to show this functionality working just on an isolated installation of Alfresco on my laptop.

It's easy to setup and here are some steps in the variation of what I described previously. With these changes I set up Outlook Express on my Windows machine to be able to send inbound emails to the Alfresco server installed on the same machine.

Step 1 Enable the Alfresco email server to run on port 25. See step 1 of the previous post.

Step 2 Add localhost.com to the Windows hosts file.
c:\windows\system32\drivers\etc\hosts

127.0.0.1 localhost
127.0.0.1 localhost.com

Step 3 Configure Outlook Express (or other email client)

From the Tools menu, select Accounts...

Select the option to add a new Mail account.

Add the Display Name to use and click Next.

Add the email address. This address needs to match the email address assigned to an Alfresco user. In this case, I plan to use this while demonstrating as user admin, so I add the email address admin@localhost.com.

Then configure the Outgoing mail SMTP server to be 127.0.0.1.

Finally, enter the user name and the password for this account (admin and admin).

And then Finish the wizard.

Step 4 Setup user admin within Alfresco Share

The email address for user admin is set to admin@localhost.com -- which matches what was entered into the Outlook Express configuration.

And the user (admin) as added to the EMAIL_CONTRIBUTORS group.

Step 5 Set up an email alias folder name within Share.

Create and/or navigate to the target email folder within share. In this case I have a folder named MailFolder within a Share Site documentLibrary area. Add the Aliasable (Email) aspect to the folder. Doing that will add a new metadata field that holds the name of the folder alias.

Everything is cool up until this point. Unfortunately the email alias name field is not exposed from the Share interface. You'll need to bring up the Alfresco JSF explorer client and navigate to the same space that you just created (or do all of this step in the Explorer client). There you can enter the alias name for the folder. In this case we call it 'mailfolder'. Note that the alias name you choose is case sensitive.

Step 6 Send a Test Email

Next to test it, we send an email to mailfolder, the alias name in Alfresco that we just set up. If we now navigate into the target Share site folder, we can see the document that was just sent.

Formtek Hosts Alfresco Lunch and Learn in July

2010-07-07T16:21:00.000-07:00

Formtek is hosting an Alfresco Software Lunch & Learn session in our Concord, California (near Oakland) office at 11:30 AM on July 28 to demonstrate how businesses like yours are benefiting from the leading open source enterprise content management (ECM) software solution.

Join us for lunch and sit back and relax while you hear how Alfresco is reducing ECM costs by over 95% compared to proprietary systems like Documentum, Open Text and SharePoint. Alfresco will review in depth how companies are seeing a huge return on their investment with Alfresco's document management, web content management and records management solutions. You will also have the opportunity to view a product demonstration provided by Formtek's Chief Technologist, Dick Weisinger.

This free lunch and learn is an opportunity for you to talk to the Alfresco and Formtek experts and hear first hand about the low cost, simple to use ECM software that thousands of companies are relying on, and saving money with, everyday.

Click here to register for the July 28 event in Concord.

Adding new Configurations in the Alfresco Share Admin Console

2010-06-09T16:12:00.000-07:00

Alfresco Enterprise 3.3 is out now. A release called 3.3FCS (First Customer Ship) is available for download now, and another version, and rumor that a 3.3G (community version. G for Google docs) should become available next week. The Alfresco product feels more stable and complete with every release. The 3.3 version comes with a lot of new features. One of those new features is the ability to change the theme of Alfresco directly from the Administration Console. (You're not able to define the theme via the UI, but you can select from a set of pre-defined themes and then apply them to immediately see their effects.)

The default configuration area available in the Admin Console are Groups, Users, and now with the 3.3 release, the Application (which currently only includes the theme).

From the image above you can see the five out-of-the-box themes that come standard with Alfresco 3.3. And the image below shows you the rainbow of effects that you can get by applying these themes.

Maybe not too exciting, but one interesting thing about the addition of Themes to the Admin Console is that it serves as a fairly simple example of how the Administration Console was designed to be extensible, so that new components that require administration could be added to the Console.

Surprisingly not that much new code is needed for the addition of themes into the Admin Console. Let's look at some of the files involved in the rest of this posting.

The files that define the themes can be found at this location:

We're not creating a new theme in this blog, but if you plan to make a custom new one, note that you should start by cloning the files from a theme other than the default one. The default theme has access to assets that the other themes have local copies of.

webapps\share\WEB-INF\classes\alfresco\messages\slingshot.properties
This file contains the labels used in the left-side navigation area of the Administration Console. We can see the definition for the label and description of the 'Application' Console configuration (along with similar definitions for users and groups).

## Admin console tools
tool.users.label=Users
tool.users.description=User Management
tool.groups.label=Groups
tool.groups.description=Group Management
tool.application.label=Application
tool.application.description=Application Settings and Management

webapps\share\WEB-INF\classes\alfresco\site-data\themes\default.xml
webapps\share\WEB-INF\classes\alfresco\site-data\themes\greenTheme.xml
webapps\share\WEB-INF\classes\alfresco\site-data\themes\gdocs.xml
webapps\share\WEB-INF\classes\alfresco\site-data\themes\yellowTheme.xml
webapps\share\WEB-INF\classes\alfresco\site-data\themes\hcBlack.xml
These files contain title and description data for each of the themes like this (from default.xml):

<?xml version='1.0' encoding='UTF-8'?>
<theme>
 <title>Default Blue Theme</title>
 <title-id>theme.default</title-id>
</theme>

Files to Render the Admin Console Theme Selector

application.get.desc.xml

<webscript>
  <shortname>Admin Console Application Tool</shortname>
  <description>Administration Console - Application Settings Tool</description>
  <url>/components/console/application</url>
  <family>admin-console</family>
</webscript>

application.get.head.ftl

<#include "../component.head.inc">
<!-- Admin Console Application Tool -->
<@link rel="stylesheet" type="text/css" href="${page.url.context}/components/console/application.css" />
<@script type="text/javascript" src="${page.url.context}/components/console/consoletool.js"></@script>
<@script type="text/javascript" src="${page.url.context}/components/console/application.js"></@script>

These files are included in application.get.head.ftl:

webapps\share\components\console\application.css

webapps\share\components\console\application.js

application.get.html.ftl
This file provides the actual layout markup for the Application Configuration in the Admin Console.

<!--[if IE]>
<iframe id="yui-history-iframe" src="${url.context}/yui/assets/blank.html"></iframe> 
<![endif]-->
<input id="yui-history-field" type="hidden" />

<script type="text/javascript">//<![CDATA[
   new Alfresco.ConsoleApplication("${args.htmlid}").setMessages(${messages});
//]]></script>

<#assign el=args.htmlid>
<div id="${el}-body" class="application">
   
   <!-- Options panel -->
   <div id="${el}-options" class="hidden">
      
      <form id="${el}-options-form" action="${url.context}/service/components/console/application" method="post">
         
         <div class="title">${msg("label.options")}</div>
         
         <div class="row">
            <span class="label">${msg("label.theme")}:</span>
            <div class="flat-button">
               <select id="console-options-theme-menu">
                  <#list themes as t>
                  <option value="${t.id}"<#if t.selected> selected="selected"</#if>>${t.title?html}</option>
                  </#list>
               </select>
            </div>
         </div>
         
         <div class="buttons">
            <button id="${el}-apply-button" name="apply">${msg("button.apply")}</button>
         </div>
      
      </form>
   </div>

</div>

application.get.js
This small server side javascript file makes use of the Surf/Share sitedata root object that is described here to find the available themes. The code here finds the available themes and collects and stores them into the model for later display.

function main()
{
   model.themes = [];
   
   // retrieve the available theme objects
   var themes = sitedata.getObjects("theme");
   for (var i=0, t; i<themes.length; i++)
   {
      t = themes[i];
      model.themes.push(
      {
         id: t.id,
         title: t.title,
         // current theme ID is in the default model for a script
         selected: (t.id == theme)
      });
   }
}

main();

application.get.properties
This file defines labels that appear on the Application configuration page.

label.options=Options
label.theme=Theme
button.apply=Apply
message.failure=Failed to apply selected options.

Files to Set the New Theme

Once the "Apply button is selected, the new theme (and later potentially other Application data) data is posted back to the server.

application.post.desc.xml

<webscript>
  <shortname>Admin Console Application Tool POST</shortname>
  <description>Admin Console Application Tool POST form submission processing</description>
  <format default="json" />
  <url>/components/console/application</url>
</webscript>

application.post.json.ftl

{
   "success": ${success?string},
   "message": "<#if errormsg??>${errormsg}</#if>"
}

application.post.json.js
This function marks the newly selected theme and sets it.

function main()
{
   var themeId = json.get("console-options-theme-menu");
   context.setThemeId(new String(themeId));
   
   // persist across Share application if this is the admin user
   if (user.isAdmin)
   {
      var sc = context.getSiteConfiguration();
      sc.setProperty("theme", themeId);
      sc.save();
   }
   
   model.success = true;
}

main();

Mounting Alfresco as an IMAP Mount Point in Outlook 2007

2010-05-18T16:06:00.000-07:00

A new feature from Alfresco version 3.2 is the ability to mount the repository within email clients that support IMAP. I thought that I'd give it a try and I found that it is pretty easy to set up.

I'll show here what I did to get it to work within Outlook 2007 running on a Windows development machine.

Since I'm running on a development machine, I typically use localhost as the root location for my Alfresco URLs. When trying to set up the IMAP user account in Outlook it doesn't seem possible to be able to define the IMAP mount point source to be localhost. The Alfresco wiki pages for IMAP also recommend against using localhost. To get around that, I defined a dummy domain name in my local hosts file. On a production machine, just use the domain name for that machine.

In c:\Windows\system32\drivers\etc\hosts I added the following line at the top, leaving the entry for localhost in tact in the file (my apologies to the owner of this domain name).

127.0.0.1 xxxxxx.com
127.0.0.1 localhost

In the alfresco_globals.xml file, I uncommented two lines near the bottom of the file, one to enable IMAP and the other to set the server host name we just defined.:

#
# IMAP
#-------------
imap.server.enabled=true
#imap.server.port=143
imap.server.host=xxxxxx.com

After making that change, I recycled the Alfresco server.

Next I brought up my Outlook 2007 client and went through the following screens of the wizard for adding a new account. Start at Tools -> Account Settings...

1. Click on the Add button of the dialog to start the process for mounting the IMAP point in Alfresco.

2. Select the default top option radio=button for adding a POP3, IMAP,...

3. Select the option on the bottom of the dialog to "Manually configure..." and then click Next.

4. Select "Internet E-mail" which has the IMAP option, and click on Next.

5. Next fill out the credentials for being able to connect to Alfresco IMAP. Here I use the dummy domain name that we defined in the hosts file - xxxxxx.com. I use the login information for the Alfresco admin user.

6. Click Next and we are finished.

7. After a few seconds pause, on the left navigation panel, you should see the Alfresco IMAP Point successfully mounted.

8. Click through on the Alfresco IMAP folder and you'll see folders of the Alfresco repository.

Not all folders have yet been enabled for display in the IMAP Alfresco folder hierarchy. I'm currently working with my Records Management site within Alfresco, so I log into Alfresco share, and from the Share main dashboard, I'm able to mark the Records Management folder as an IMAP favorite. After doing that, the records management site folders also are available from within Outlook.

In Outlook I can see the following in the left folder navigation area:

From within Outlook I can now drag my emails from my Inbox into the Alfresco IMAP storage. For example, I drag an email into the US20040249606 Folder of the Patents Category. From Share Records Management, I see the following:

There is a new entry: Message_755.eml.

Upload Files to Alfresco via Email -- Inbound Emails

2010-05-05T20:45:00.000-07:00

"Data Ingestion" -- that's the process of getting files and data into your content management system, and Alfresco makes it easy. My favorite example is being able to drag-and-drop to a mounted Alfresco CIFS drive. Alfresco 3.2R also introduces drag-and-drop within IMAP-compatible email clients like Outlook, which is pretty slick.

But there's another option that you may not know about that has been part of standard Alfresco for a while and it's something that you may find to be very handy. That's the uploading of emails sent to an Alfresco email address. This feature lets users send emails with attachments to Alfresco for archival. Only emails coming from designated users whose originating email address matches the email address that Alfresco knows from the user profile are accepted. This is a great option for people out in the field to be able to simply email in data and files that they need to be stored in the Alfresco repository.

You still need to use the Alfresco explorer JSF client to set it up, but once you've got it setup, you can file data into the Records Management module, an Alfresco Share site document library, or anywhere in the repository.

Step 1 -- Setup and Start the Alfresco Email Server
Edit the file Alfresco/tomcat/shared/classes/alfresco-global.properties. Change the section in the file called "Alfresco Email Server" as show below. Basically, I've uncommented the email.server.* and email.inbound.* properties. For the variable email.server.domain, I entered the name of the server where Alfresco is running. In my case, I am testing on an Amazon EC2 instance, so I've entered the Amazon Public DNS for my instance.

In this case, I've set the email.server.port value to 25. You might want to verify that there is no email server already running on the Alfresco server machine and listening to port 25.

On Linux to check this, I run the following command:
netstat -nap --inet | grep 25

On Windows, you could just run netstat.

After making those changes, I stop and restart the Alfresco server.

# Alfresco Email Service and Email Server
#-------------

# Enable/Disable the inbound email service.  The service could be used by processes other than
# the Email Server (e.g. direct RMI access) so this flag is independent of the Email Service.
#-------------
email.inbound.enabled=true

# Email Server properties 
#-------------
email.server.enabled=true
email.server.port=25
email.server.domain=ec2-184-73-58-194.compute-1.amazonaws.com
email.inbound.unknownUser=anonymous

# A comma separated list of email REGEX patterns of allowed senders.
# If there are any values in the list then all sender email addresses
# must match.  For example:
#   .*\@alfresco\.com, .*\@alfresco\.org
# Allow anyone:
#-------------
email.server.allowed.senders=.*

Step 2 -- Set Alfresco User Emails
Enable Alfresco users to be able to submit email uploads by starting up the Alfresco explorer client and going into the Admin area. For each user that will be enabled for email submit verify that the email address entered in their Alfresco profiles match the address that they will be using when submitting emails.

Step 3 -- Add Users to the EMAIL_CONTRIBUTORS group
While still in the Alfresco administration area on the Alfresco explorer client, go into group administration. Make sure that all users that are to be enabled to submit email uploads to Alfresco are part of the Alfresco group EMAIL_CONTRIBUTORS.

Step 3 -- Setup email aliases for Alfresco folders (spaces)
Identify which folders in Alfresco that you'd like users to be able to submit to. To do that, navigate to each of the target folders in the repository.

For example, here is a new folder in my user home area that is called "Email Inbox"

On examination of the properties for this folder, you can see an entry called "Email ID". This is really all you need for being able to send emails. I can do an email upload submit by sending my email to this email address, like: 545@ec2-184-73-58-194.compute-1.amazonaws.com.

But it is somewhat nicer to be able to send to an email address that is easier to remember than just a number.

To create an alias for the Email ID numeric, you need to first add an aspect to the folder.

Run Action -> Add Aspect to Item. Select the "Email alias" aspect.

Once the aspect is added, you'll see something like this.

The property "Email Alias" is now available. By selecting edit for the properties, you can define an alias for the submit email name. For example, I can use 'inbox'. Note that the name you select is case sensitive. After doing that, I can submit emails to populate the folder associated with the alias name, like: inbox@ec2-184-73-58-194.compute-1.amazonaws.com.

Step 4 -- Start sending Emails

Send an email to the Alfresco email server: inbox@ec2-184-73-58-194.compute-1.amazonaws.com, using the name appropriate for your system.
In this case I sent an email and an attachment called 'AlfrescoRMintro.txt'.

Then check the folder. Both the email body (with name based on the email subject) and attachment have been uploaded to the folder.

Yes, that's really great. If you look at the property page for this email, you'll see something like this:

There's only one thing that makes it not totally perfect. On the property page for the email body, you can see the Attachments property with a link to the attachment document. That's great, but it isn't a live link. You need to manually go back to the folder level and find the attachment document. It would nice to just be able to click right there to see the attachment.

Overall though this can be a very useful feature, and one not to forget about.

Alfresco Records Management Free Trial

2010-05-01T14:44:00.000-07:00

With the 3.2r release of Alfresco Share, the Alfresco Records Management module is now available in the Enterprise edition.

Alfresco has recently started a free trial program to get started using Alfresco Share and Records Management. Click here to sign up for it.

Paul Hampton, Product Manager at Alfresco, has recorded a number of Share Records Management videos. More of them are available on this page. I've included one of the videos below for your viewing interest.

Introduction to Fileplan

This video reviews the Fileplan within the Alfresco Records Management solution. It shows how multiple users will be presented with different views of the Fileplan based on their security setting and role.

Preview: Alfresco Share Rules

2010-04-15T14:07:00.000-07:00

Here's a followup from my previous post that previewed Data Lists in Alfresco Share.

This time I give a demonstration of the rules capability in the Alfresco Share 3.3 Community release. Rules are not new to Alfresco. They've been in the Explorer client for some time. But being able to specify them from Share is new. And the UI for managing them is a nice improvement over the JSF-based screens of Explorer.

While there's a 3.3 release downloadable now, as of this writing, bug fixes for rules in Share seems to be quite active. What I show here was made with a build from the latest source code in the SVN Head area that I made this morning.

Transcript for the video can be downloaded here.
A high resolution version of this demonstration can be seen here.
The Alfresco 3.3 Community release can be downloaded here.

The Alfresco Share 3.3 version is certainly shaping up. And the new rules capability in it really add to the usability of the product.

Preview: Alfresco Share Data Lists

2010-04-13T21:29:00.000-07:00

If you don't have the time to download and setup the newly released Alfresco Share 3.3 Community version, here's a video that previews one of the new features in that release: Data Lists.

Transcript for the video can be downloaded here.
A high resolution version of this demonstration can be seen here.
The Alfresco 3.3 Community release can be downloaded here.

The video doesn't get into how the lists are defined using the Alfresco Content model. It's possible to create new Data List types or to modify the columns of the existing To Do List.

The To-Do List example that ships with Alfresco Share is shown in the video and the content model definition can be found in a file in the Alfresco war under models called datalistModel.xml.

<type name="dl:todoList">
         <title>To Do List</title>
         <parent>dl:dataListItem</parent>
         <properties>
            <property name="dl:todoTitle">
               <title>Title</title>
               <type>d:text</type>
               <mandatory>true</mandatory>
            </property>
            <property name="dl:todoDueDate">
               <title>Due Date</title>
               <type>d:datetime</type>
               <mandatory>false</mandatory>
            </property>
            <property name="dl:todoPriority">
               <title>Priority</title>
               <type>d:int</type>
               <mandatory>false</mandatory>
            </property>
            <property name="dl:todoNotes">
               <title>Notes</title>
               <type>d:text</type>
               <mandatory>false</mandatory>
            </property>
         </properties>
         <associations>
            <association name="dl:assignee">
               <title>Assignee</title>
               <source>
                  <mandatory>false</mandatory>
                  <many>true</many>
               </source>
               <target>
                  <class>cm:person</class>
                  <mandatory>false</mandatory>
                  <many>false</many>
               </target>
            </association>
            <association name="dl:attachments">
               <title>Attachments</title>
               <source>
                  <mandatory>false</mandatory>
                  <many>true</many>
               </source>
               <target>
                  <class>cm:cmobject</class>
                  <mandatory>false</mandatory>
                  <many>true</many>
               </target>
            </association>
         </associations>
      </type>

The to-do list form is defined in the file share-form-config.xml:

<!-- dl:todoList type -->
   <config evaluator="model-type" condition="dl:todoList">
      <forms>
         <!-- Create item form -->
         <form>
            <field-visibility>
               <show id="dl:todoTitle" />
               <show id="dl:todoDueDate" />
               <show id="dl:todoPriority" />
               <show id="dl:todoNotes" />
               <show id="dl:assignee" />
               <show id="dl:attachments" />
            </field-visibility>
            <create-form template="../data-lists/forms/row-new.ftl" />
            <appearance>
               <field id="dl:todoNotes">
                  <control template="/org/alfresco/components/form/controls/textarea.ftl" />
               </field>
            </appearance>
         </form>

         <!-- Data Grid view -->
         <form id="datagrid">
            <field-visibility>
               <show id="dl:todoTitle" />
               <show id="dl:todoDueDate" />
               <show id="dl:todoPriority" />
               <show id="dl:assignee" />
               <show id="dl:attachments" />
            </field-visibility>
         </form>
      </forms>
   </config>

   <!-- dl_todoList type (existing nodes) -->
   <config evaluator="node-type" condition="dl:todoList">
      <forms>
         <!-- Data List pop-up edit form -->
         <form>
            <field-visibility>
               <show id="dl:todoTitle" />
               <show id="dl:todoDueDate" />
               <show id="dl:todoPriority" />
               <show id="dl:todoNotes" />
               <show id="dl:assignee" />
               <show id="dl:attachments" />
            </field-visibility>
            <edit-form template="../data-lists/forms/row-edit.ftl" />
            <appearance>
               <field id="dl:todoNotes">
                  <control template="/org/alfresco/components/form/controls/textarea.ftl" />
               </field>
            </appearance>
         </form>
      </forms>
   </config>

Alfresco Records Management Demonstration

2010-04-06T14:02:00.000-07:00

April has traditionally been celebrated as Records and Information Management Month (RIMM). So no better time than to give a look at Alfresco's recently released Records Management module. Alfresco Records Management is certified for the DoD 5015.2 Standard. Below is a video with an overview of the RM module as used in Alfresco Share.

Note: A high-resolution (1504x738) version of this video can be viewed here.
A slightly bigger version of the video (640x379) can be seen here.
A complete transcript of this video can be downloaded here.

More Information

A 20-page White Paper describing Records Management Best Practices can be downloaded here.
The Alfresco Share Records Management Data Sheet can be downloaded here.
The Formtek Web Site.
The Alfresco Web Site.

Reviving Alfresco Share Thumbnail and Avatar Images

2010-03-25T09:11:00.000-07:00

One great thing about Alfresco Share is (was) the ability to automatically create thumbnails for documents on upload. Being able to visually browse your documents before opening them is a feature that many people like. It can help you locate the document more quickly and helps to distinguish document contents in the case where documents are similarly named.

The problem is that on Windows in Alfresco Enterprise 3.2r, this feature broke. On upload of a document, Alfresco tries to generate the thumbnail for the image content, but fails and instead creates a zero-byte thumbnail file.

You'll see something like this.

The default picture of a pair of gears displays whenever Share doesn't have a valid thumbnail file to display.

Searching in the forums for a possible solution, I came across one posted by Nicola Prando. The bug and solution are also posted as ALF-1978. Thanks Nicola!

The trick to fix this is to define a base directory for ImageMagick to use on Windows. You can find the following file:
C:\Alfresco\tomcat\webapps\alfresco\WEB-INF\classes\alfresco\subsystems\thirdparty\default\imagemagick-transform-context.xml

You need to add the following lines to the property processProperties for the bean transformer.ImageMagick.Command:

<entry key="SYSTEMROOT"> 
       <value>C:/WINDOWS</value> 
    </entry>

But it isn't good practice to modify a file in the core Alfresco directory. Instead define a new imagemagick-transform-context.xml file and place here:
C:\Alfresco\tomcat\webapps\alfresco\WEB-INF\classes\alfresco\extension\imagemagick-transform-context.xml

The contents of the file with this change looks like:

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

   <bean id="transformer.worker.ImageMagick" class="org.alfresco.repo.content.transform.magick.ImageMagickContentTransformerWorker">
      <property name="mimetypeService">
         <ref bean="mimetypeService" />
      </property>
      <property name="executer">
         <bean name="transformer.ImageMagick.Command" class="org.alfresco.util.exec.RuntimeExec">
            <property name="commandsAndArguments">
               <map>
                  <entry key=".*">
                     <list>
                        <value>${img.exe}</value>
                        <value>${source}</value>
                        <value>SPLIT:${options}</value>
                        <value>${target}</value>
                     </list>
                  </entry>
               </map>
            </property>
            <property name="processProperties"> 
               <map>
                  <entry key="MAGICK_HOME">
                     <value>${img.root}</value>
                  </entry>
                  <entry key="DYLD_LIBRARY_PATH">
                     <value>${img.dyn}</value>
                  </entry>
                  <entry key="LD_LIBRARY_PATH">
                     <value>${img.dyn}</value>
                  </entry>
    <entry key="SYSTEMROOT"> 
                     <value>C:/WINDOWS</value> 
                  </entry>
               </map>
            </property>
            <property name="defaultProperties">
               <props>
                  <prop key="options"></prop>
               </props>
            </property>
         </bean>
      </property>
      <property name="checkCommand">
         <bean name="transformer.ImageMagick.CheckCommand" class="org.alfresco.util.exec.RuntimeExec">
            <property name="commandsAndArguments">
               <map>
                  <entry key=".*">
                     <list>
                        <value>${img.exe}</value>
                        <value>-version</value>
                     </list>
                  </entry>
               </map>
            </property>
         </bean>
      </property>
   </bean>

</beans>

After doing that, thumbnails will get correctly created.

Another tip, if you should ever need to debug Alfresco thumbnail creation, add the following lines to your log4j file to get debug information:
C:\Alfresco\tomcat\webapps\alfresco\WEB-INF\classes\log4j.properties

log4j.logger.org.alfresco.repo.content.transform=debug
log4j.logger.org.alfresco.repo.thumbnail.ThumbnailServiceImpl=debug

Alfresco 3.3 in the Making

2010-03-19T16:23:00.000-07:00

About a month has passed since the Alfresco Enterprise 3.2r release. The Alfresco development team is now in heads-down development, working on release 3.3. The roadmap for the 3.3 release is posted on the Alfresco wiki and the next upcoming release, version 3.3, is scheduled for Q2 2010.

Out of curiosity, I thought that I'd check in with the latest Alfresco SVN HEAD source code to see some of the things that are brewing for the 3.3 release. There are at least three areas that are showing interesting development, and I'll mention them here.

I did run across some problems, but then this code is far from a release date of a few months from now.

Themes for Share

The Admin Console of Share has been enhanced to include a new Tool plugin called "Application". It looks like a place where overall Share configuration will be done via the UI. The only thing there right now is the ability to select the Alfresco Share Theme. Have a look at the "High Contrast Theme":

And here is what the Dashboard looks like after the "Yellow Theme" is applied:

Space Rules in Share

The Alfresco 3.3 Roadmap mentions enhancements in Share around Space Rules:

   Rule and Action Management
   - Linked Rules allowing rules to reused across multiple space
   - Compensating actions triggered on main action failure

Now when looking at the Actions available for a Folder/Space within Share, you see the following options. Here I compare how the Folder Actions options have changed.

Folder Actions in 3.2r

Folder Actions in 3.3 pre-release

After clicking on "Manage Rules", you'll see the following:

On click of "Create Rule" you get a single screen for defining the new rule. Unlike the wizard of Alfresco explorer, it's all in one place. The "Link to Rule Set" will let you define libraries of reusable rules.

I think I prefer this consolidated view to defining a rule compared to the explorer wizard interface. And it looks like a lot of the new rules functionality for Share is already working. As shown above, I tried creating a rule on a space that adds the Taggable Aspect to incoming items to the folder. Most of the UI is working pretty well. The rule itself though didn't seem to get run when I later added content to the folder, and subsequent clicks on "Manage Rules" for the folder threw some errors.

I also experimented by creating a rule that would assign a simple workflow to incoming items of the folder. I selected the Review and Approve Workflow with the option of moving the document to a different folder after approval. I liked the interface for specifying the workflow, but this threw an error too. It was interesting, although maybe not unexpected, that the error was one that shows the Surf logo. That's the first time I've seen that in Share.

Alfresco Web Editor (AWE)

Alfresco's Ben Hagan has written a Blog entry explaining how to build and test the new Alfresco Web Editor (AWE). This is the Web Editor that will be used in future releases of Alfresco WCM.

It all worked for me as described in Ben's blog, and it looks like it has good potential. It looks a bit early though to start building anything out with it just yet. But to already have something up and running is a good sign that there will probably be rapid progress on this front.

Smart Record Filing with Alfresco Share

2010-03-15T21:44:00.000-07:00

Suppose you are using Alfresco with Records Management and you'd like to simplify the task of filing documents within the Records Management File Plan. That way documents filed by any user could be easily and automatically moved to the right spot within the File Plan. (Or in a similar scenario where document filing is needed outside of the Records Management world.)

Consider a scenario that uses an Advanced workflow for document approval. As the final step of the process, the document is accepted or rejected. If accepted, we want to file the document correctly within the File Plan. And we'd like to be able to do it in a way that the user needn't have to know anything about the File Plan hierarchy. Just hit "accept" and they're done.

One way to do that is to identify something about the document attributes that can be used to trigger off of for where to file the document. To keep things simple, let's consider the case where we trigger off of some text appearing within the name of the document.

Suppose the following three File Plan paths exist:
   Legal/Contracts/City Sewer
   Legal/Shareholder/2009Q3-public
   Legal/Corporate/2009Q3-10Q

Depending on whether the following key words are contained in the document name string, the document will be moved to the appropriate folder: "Sewer", "Shareholder", "Corporate".

We can write some server-side Javascript that will then process the file correctly.

Consider this code snippet:

// Define mapping pairs
//   [ "String to search", "Alfresco space to map to" ]
var remap = [ ["Sewer", "Sites/rm/documentLibrary/Legal/Contracts/City Sewer"],
              ["Shareholder", "Sites/rm/documentLibrary/Legal/Shareholder/2009Q3-public"],
              ["Corporate", "Sites/rm/documentLibrary/Legal/Corporate/2009Q3-10Q"] ];
              
// Get the Name of the document
var docName = document.properties.name;

for( m in remap )
{
    var check = remap[m];
    if( docName.search( check[0] ) > -1 )
    {
       // Found a match.  String contained in document name
       var destSpace = companyhome.childByNamePath( check[1] );
       
       // Move the document to the right Alfresco space
       document.move(destSpace);
    }
}

This code could be embedded within the approval workflow process definition file. Or it could be extracted out into an external script. For example, the workflow might simply move the file to an "approve" folder and that folder could have an Alfresco rule assigned to it that executes the Javascript for filing. In that case, if the identification fails, the document stays in the "approve" folder and must be manually identified and filed.

The Javascript code defines an array of filing rules that specify which folder to move the document to depending on a match on part of the document name.

Tip: Repository Browsing in Alfresco Share 3.2r

2010-03-10T16:56:00.000-08:00

There's a cool but not-well-publicized feature of the Alfresco 3.2r release (February 16) in Alfresco Share -- general browsing of the entire Alfresco Repository from the Share interface. Paul Hampton, director of Product Marketing at Alfresco, briefly showed the feature in a webinar and later wrote a blog entry describing it.

Since Alfresco is in the process of migrating functionality from their 'classic' explorer client application to Share, it makes sense that general repository browsing be migrated. Until this release, Share was only able to browse files in the document libraries of Share sites.

The feature is turned off by default, but it can be enabled by changing a boolean flag in the configuration file:
...\tomcat\shared\classes\alfresco\web-extension\share-config-custom.xml

This section of the XML configuration needs to be changed:


      
      true

The 'visible' flag needs to be set to true to be enabled.

After making that change and restarting the server, you'll see a link to the repository on your Share home page along the top links to the right of the Share logo.

After clicking on the Repository link, you'll then be able to browse the standard Alfresco repository. (You may need to F5/refresh your browser cache to see it.) You can upload files, create folders and create new content.

Tip: Setting Alfresco Global Properties

2010-03-03T18:09:00.000-08:00

Configuration of Alfresco can be a bit challenging. It takes some time to get a feel for which file needs to be modified and what directory that file is in. Part of the reason for the number of files has to do with the fact that Alfresco is based on Spring, and Alfresco has adopted Spring configuration methodology.

In Alfresco 3.2 some of the complexity around finding where to make a configuration change has been simplified. Alfresco introduces the concept of the alfresco-globals.properties file. This new file tries to centralize as much as possible basic Alfresco configuration parameters and settings.

alfresco-globals is basically a global override file. The goals was to try to simplify common configuration settings into a single file. Rather than centralizing everything into one file, which would be quite large and unwieldy, parameters defined in this file override parameters defined elsewhere in the standard configuration files used up until now.

After a full Windows install of an Alfresco 3.2+ system, you'll find this file in your tomcat\shared\classes directory. It will contain some of the settings selected during the installation process, like database connection information. If the file isn't already there, you can find a template for it here:
..../tomcat/webapps/alfresco/WEB-INF/classes/alfresco-global.properties.sample

Some of the most common settings that are configured in Alfresco that can now be set/overridden by values in alfresco-global file include parameters from these files:
..../tomcat/webapps/alfresco/WEB-INF/classes/alfresco/repository.properties
..../tomcat/webapps/alfresco/WEB-INF/classes/alfresco/hibernate-cfg.properties

Override values for Alfresco subsystems are also set in the alfresco-global.properties file.

Improved Alfresco Administration

2010-02-24T14:57:00.000-08:00

Alfresco 3.2r, just released on February 15th, comes along with some great new tools for administration. Alfresco's Paul Hampton described and demo-ed two categories of new features in a Alfresco recorded webcast:

New Subsystems
Storage Policies

Subsystems are mini-servers that run embedded within the overall Alfresco system. They are independent processes that can be brought up and down. This design lets an administrator of the system change a single configuration without having to bring down the entire Alfresco system. The advantages are reliability and availability.

Subsystems can be configured via any JMX client [Enterprise Alfresco only]. In the demonstration, Paul used JConsole, a common JMX console used by the JDK. From the console, the subsystems can be stopped and started, and parameters of the individual subsystems can then be reconfigured.

Starting in Alfresco 3.2 the file alfresco-global.properties is a centralized place for system configurations -- unless you are using JMX. If you are using JMX, the alfresco-global.properties file values are used until you configure new subsystem values via JMX. JMX changes get stored in the database, and thereafter, any time you start your system, the database values will override those of the properties file. An advantage of this approach is that system changes are stored in the database and easily propagated to all servers in a cluster. But the properties file is not updated and may lead to confusion about what system values are currently being used.

Examples of Alfresco Subsystems include:

Authentication
Synchronization
File Servers
Third party
IMAP
WCM Development Receiver
SysAdmin
OpenOffice Transformations

Paul gives a good detailed example in the demonstration of how he could stop the OpenOffice Transformation subsystem, configure a second one, and then start up two OpenOffice Transformation subsystems.

Storage Policies were covered in the second portion of the webcast. (There is also an Alfresco brief description of Storage Policies here.) Storage policies can be part of an Information Lifecycle Management (ILM) strategy. They let the administrator determine which content should be stored where.

Paul shows in the webcast an example where he automatically stores content to a particular location based on content type -- or whatever other criteria you might have. He accomplishes this by setting up rules that get run when the content is checked in. Images, videos, and PDFs, for example, could all be stored in separate directories or volumes.

Alfresco named by KMWorld as one of the top 100 KM companies

2010-02-23T10:32:00.000-08:00

KMWorld Magazine announced today that Alfresco was named as one of the "100 Companies that Matter in Knowledge Management". KMWorld worked with analysts, vendors and customers to compile the list which will be posted to www.kmworld.com on March 1.

This will be the first year for Alfresco to be on that list, and it follows up quickly after an announcement that Alfresco was named to CIO's list of top 20 UK companies.

"In today’s knowledge economy, Alfresco Software does more than simply throw sophisticated technology at its customers, it provides real solutions through inspired planning and execution throughout the entire constituency chain," said Hugh McKellar, KMWorld editor in chief.

Alfresco WCM followup

2010-02-22T17:26:00.000-08:00

Last week in a followup webcast to an early February webcast, Alfresco hosted a question and answer session about their planned roadmap for WCM in 2010. Both are pretty informative.

Interestingly as well, there have been a couple of other recent announcements of Alfresco-based WCM offerings, some of which aren't using Alfresco's standard WCM.

Jeff Potts in a good blog post last year described the differences between the WCM and DM repositories. The fact that there are two and that they are not fully compatible has led to some headaches.

Vodori has a video out showing their product Pepper. The Pepper tag library integrates well with a standard JSP-based web site. WYSIWYG and templated page edits are possible. Pepper was implemented using Alfresco WCM to take advantage of the Alfresco WCM publishing capabilities, but they are migrating to the use of the standard DM repository as Alfresco plans to support DM publishing alongside the release of the CMIS 1.0 version.

Last week the Blue Fish Group hosted an Alfresco Webinar. They presented a very nice WCM solution, but one that doesn't use Alfresco's native WCM tools. Their comment was that Alfresco WCM is a bit of a challenge for non-techie people. Their goal was to create a system that would accommodate the needs of casual web content creators.

So while Alfresco has hit a home run with its standard DM capabilities, they still need to do some more work in the area of WCM. While that is a criticism, it's really hard to complain, considering how much Alfresco has done and gotten right over the last five years.

And based on the roadmap, Alfresco is strongly focused on Web Content Management this year. Starting with the recent 3.2r release and the planned 3.3, 3.4 and 4.0 releases, WCM seems to be a central component of their plan.

Creating a Share Form for an Alfresco Custom Type having Two Columns

2010-02-17T16:53:00.000-08:00

This is a followup to a previous blog post that described a form created for use with a custom type. In this blog we show that it is easy to further control the layout of the form by applying a template to the form. The template is uses Freemarker. And it's possible to specify a separate template for each of the possible modes of the form: view, edit, and create.

By adding the following three lines to the form definition of the file web-framework-config-custom, the template(s) can be specified:

<view-form template="/tab-edit-form.ftl" />
           <edit-form template="/tab-edit-form.ftl" />
    <create-form template="/tab-edit-form.ftl" />

And when viewed in whole context of the form definition, we now have:

<alfresco-config>

 <config evaluator="node-type" condition="mm:doc">
    <forms>
       <form>
    <view-form template="/newtemplate.ftl" />
       <edit-form template="/newtemplate.ftl" />
    <create-form template="/newtemplate.ftl" />
          <field-visibility>
             <!-- inherited from cm:content -->
             <show id="cm:name" />
             <show id="cm:title" force="true" />
             <show id="cm:description" force="true" />
             <show id="mimetype" />
             <show id="cm:author" force="true" />
             <show id="size" for-mode="view" />
             <show id="cm:creator" for-mode="view" />
             <show id="cm:created" for-mode="view" />
             <show id="cm:modifier" for-mode="view" />
             <show id="cm:modified" for-mode="view" />

             <!--  aspect mm:colorAble -->             
             <show id="mm:color" />
             
             <!--  specific for mm:doc -->
             <show id="mm:relatedDocuments" />
             <show id="mm:freeText" />

           
          </field-visibility>
          <appearance>
             <set id="builtin" appearance="fieldset" label="Built In" />
             <set id="custom" appearance="fieldset" label="Custom Data" />
             <set id="mandatory" parent="builtin" appearance="panel" label="Mandatory" />
             <set id="optional" parent="builtin" appearance="panel" label="Optional" />
             
             <field id="cm:name" set="mandatory" />
             <field id="cm:title" set="optional" />
             <field id="cm:description" set="optional" />
             <field id="mimetype" set="optional" />
             <field id="cm:author" set="optional" />
             <field id="size" set="optional" />
             <field id="cm:creator" set="optional" />
             <field id="cm:created" set="optional" />
             <field id="cm:modified" set="optional" />        
             <field id="cm:modifier" set="optional" />
               
             <field id="mm:relatedDocuments" label="Related Docs" set="custom"/>
             <field id="mm:freeText" label="More Information" set="custom"/>
             <field id="mm:color" label="Color" set="custom">
                <control template="controls/selectone.ftl">
                   <control-param name="options">Red,Orange,Yellow,Green,Blue,Indigo,Violet</control-param>
                </control>
             </field>
          </appearance>
       </form>
    </forms>
 </config>
</alfresco-config>

Next we define the Freemarker template file. The code for this example is found on the Alfresco Wiki Form Example page:

tomcat\webapps\share\WEB-INF\classes\alfresco\web-extension\site-webscripts\newtemplate.ftl

<#import "/org/alfresco/components/form/form.lib.ftl" as formLib />



<#if error?exists>

   <div class="error">${error}</div>

<#elseif form?exists>



   <#assign formId=args.htmlid + "-form">

   <#assign formUI><#if args.formUI??>${args.formUI}<#else>true</#if></#assign>



   <#if formUI == "true">

      <@formLib.renderFormsRuntime formId=formId />

   </#if>

   

   <div id="${formId}-container" class="form-container">

      

      <#if form.showCaption?exists && form.showCaption>

         <div id="${formId}-caption" class="caption"><span class="mandatory-indicator">*</span>${msg("form.required.fields")}</div>

      </#if>

         

      <#if form.mode != "view">

         <form id="${formId}" method="${form.method}" accept-charset="utf-8" enctype="${form.enctype}" action="${form.submissionUrl}">

      </#if>

      

      <div id="${formId}-fields" class="form-fields"> 

        <#list form.structure as item>

            <#if item.kind == "set">

               <@renderSetWithColumns set=item />

            <#else>

               <@formLib.renderField field=form.fields[item.id] />

            </#if>

         </#list>

      </div>

         

      <#if form.mode != "view">

         <@formLib.renderFormButtons formId=formId />

         </form>

      </#if>



   </div>

</#if>



<#macro renderSetWithColumns set>

   <#if set.appearance?exists>

      <#if set.appearance == "fieldset">

         <fieldset><legend>${set.label}</legend>

      <#elseif set.appearance == "panel">

         <div class="form-panel">

            <div class="form-panel-heading">${set.label}</div>

            <div class="form-panel-body">

      </#if>

   </#if>

   

   <#list set.children as item>

      <#if item.kind == "set">

         <@renderSetWithColumns set=item />

      <#else>

         <#if (item_index % 2) == 0>

         <div class="yui-g"><div class="yui-u first">

         <#else>

         <div class="yui-u">

         </#if>

         <@formLib.renderField field=form.fields[item.id] />

         </div>

         <#if ((item_index % 2) != 0) || !item_has_next></div></#if>

      </#if>

   </#list>

   

   <#if set.appearance?exists>

      <#if set.appearance == "fieldset">

         </fieldset>

      <#elseif set.appearance == "panel">

            </div>

         </div>

      </#if>

   </#if>

</#macro>

In the template there is a reference to the form object and its element members, things like form.mode, form.structure, form.showCaption, etc. The definition of these elements can be found on the Alfresco wiki here.

When the form is rendered for the a document of this custom type, this is what it looks like now. The form is now rendered with two columns.

Alfresco one of CIO UK's Twenty Companies to Watch in 2010

2010-02-17T07:38:00.000-08:00

Alfresco was named one of CIO magazine's top 20 UK companies to watch in 2010. The list is intended to highlight vendors that are expected to see rapid growth in 2010. The companies in the list were selected by three analysts from MWD Advisors and CIO UK editor, Martin Veitch.

The reasons for selecting Alfresco for the list included their large user base and current momentum in the marketplace.

Using the Alfresco Share Forms Test Page

2010-02-16T17:09:00.000-08:00

In the previous post we created a custom document type for the content model and defined a web form to display the content for the custom metadata within Alfresco Share.

Share 3.2 also has a cool little utility called the form test page. The Alfresco wiki indicates that this page may be plugged into the Share Administration page as a module at some point in the future. For now, you can see it here:

http://localhost:8080/share/page/test-form

After checking in a document as the new custom type, you can go to the node browser in the Administration pages of the Alfresco explorer client and grab it's node path reference.

Using that path on the test form page, we can preview the form.

Now, we can play a bit with the tag for the form. Consider the following changes to appearance (compared to the appearance tag definition of the form defined in yesterday's blog):

<appearance>
             <set id="builtin" appearance="fieldset" label="Built In" />
             <set id="custom" appearance="fieldset" label="Custom Data" />
             <set id="mandatory" parent="builtin" appearance="panel" label="Mandatory" />
             <set id="optional" parent="builtin" appearance="panel" label="Optional" />
             
             <field id="cm:name" set="mandatory" />
             <field id="cm:title" set="optional" />
             <field id="cm:description" set="optional" />
             <field id="mimetype" set="optional" />
             <field id="cm:author" set="optional" />
             <field id="size" set="optional" />
             <field id="cm:creator" set="optional" />
             <field id="cm:created" set="optional" />
             <field id="cm:modified" set="optional" />        
             <field id="cm:modifier" set="optional" />
               
             <field id="mm:relatedDocuments" label="Related Docs" set="custom"/>
             <field id="mm:freeText" label="More Information" set="custom"/>
             <field id="mm:color" label="Color" set="custom">
                <control template="controls/selectone.ftl">
                   <control-param name="options">Red,Orange,Yellow,Green,Blue,Indigo,Violet</control-param>
                </control>
             </field>
          </appearance>

Here we separate the metadata into groups or 'sets'. For this example, we divide the metadata into two types: builtin and custom. And of the builtin fields, we further divide the fields into 'mandatory' or 'optional'. After making those changes (and restarting the server -- 'boo'), we're able to see the changes:

Creating Edit Forms for Custom Types in Alfresco Share

2010-02-16T10:00:00.000-08:00

Most organizations that will use Alfresco will want to create custom types.
Associated with each custom type is a data model or set of metadata that is unique to that type of document.
To be able to edit document type metadata in Alfresco Share, you need to define an edit form.

Here's a brief example for how to set up and define the metadata for a custom document type and then how to define a Share edit form for that custom type.

Some good resources with getting started with Alfresco Share forms include:

Alfresco Wiki Form Developer Guide page.
Alfresco Wiki Form Examples page. [Good starting place]
Ed Loves Java on creating Alfresco Share 3.2 forms.
Loftux on Alfresco Forms

First we define a minimum custom Alfresco type. There are four files needed to add this new type to the content model.

tomcat\alfresco\WEB-INF\classes\extension\model\mmModel.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- Definition of new Model -->
<model name="mm:minmodel" xmlns="http://www.alfresco.org/model/dictionary/1.0">

 <!-- Optional meta-data about the model -->
 <description>MinProperty Model</description>
 <author>Formtek</author>
 <version>1.0</version>

 <!-- Imports are required to allow references to definitions in other models -->
 <imports>
  <!-- Import Alfresco Dictionary Definitions -->
  <import uri="http://www.alfresco.org/model/dictionary/1.0" prefix="d" />
  <!-- Import Alfresco Content Domain Model Definitions -->
  <import uri="http://www.alfresco.org/model/content/1.0" prefix="cm" />
 </imports>

 <!-- Introduction of new namespaces defined by this model -->
 <namespaces>
  <namespace uri="http://www.formtek.com/model/content/1.0" prefix="mm" />
 </namespaces>

 <constraints>
  <constraint name="mm:colorList" type="LIST">
            <parameter name="allowedValues">
                <list>
                    <value>Red</value>
                    <value>Orange</value>
                    <value>Yellow</value>
                    <value>Green</value>
                    <value>Blue</value>
                    <value>Indigo</value>
                    <value>Violet</value>
                </list>
            </parameter>
        </constraint>
 </constraints>

 <types>
  <!-- Enterprise-wide generic document type -->
  <type name="mm:doc">
   <title>Minimum Custom Document</title>
   <parent>cm:content</parent>
   <properties>
    <property name="mm:freeText">
     <type>d:text</type>
     <mandatory>false</mandatory>
    </property>
   </properties>
   <associations>
    <association name="mm:relatedDocuments">
     <title>Related Documents</title>
     <source>
      <mandatory>false</mandatory>
      <many>true</many>
     </source>
     <target>
      <class>mm:doc</class>
      <mandatory>false</mandatory>
      <many>true</many>
     </target>
    </association>
   </associations>
  </type>
 </types>

 <aspects>
  <aspect name="mm:colorAble">
   <title>Rainbow Color</title>
   <properties>
    <property name="mm:color">
     <type>d:text</type>
     <mandatory>true</mandatory>
     <default>Green</default>
     <constraints>
      <constraint ref="mm:colorList" />
     </constraints>
    </property>
   </properties>
  </aspect>
 </aspects>
</model>

tomcat\webapps\alfresco\WEB-INF\classes\alfresco\min-model-context.xml

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

<beans>
    <!-- Registration of new models -->
    <bean id="minModel.dictionaryBootstrap" parent="dictionaryModelBootstrap" depends-on="dictionaryBootstrap">
        <property name="models">
            <list>
                <value>alfresco/extension/model/mmModel.xml</value>
            </list>
        </property>
        
        <property name="labels">
            <list>
                <value>alfresco/extension/model/mmModelResourceBundle</value>
            </list>
        </property>
    </bean>

</beans>

tomcat\webapps\alfresco\WEB-INF\classes\alfresco\extension\web-client-config-custom.xml

<alfresco-config>

 <!-- show related documents association on doc property sheet -->
 <config evaluator="node-type" condition="mm:doc">
  <property-sheet>
   <show-association name="mm:relatedDocuments"/>
   <show-property name="mm:freeText"/>
  </property-sheet>
 </config>

 <config evaluator="aspect-name" condition="mm:colorAble">
        <property-sheet>
            <show-property name="mm:color" />
        </property-sheet>
    </config>

 <config evaluator="string-compare" condition="Content Wizards">
  <content-types>
   <type name="mm:doc" />
  </content-types>
 </config>

 <config evaluator="string-compare" condition="Action Wizards">
  <subtypes>
   <type name="mm:doc" />
  </subtypes>  

  <!-- The list of content and/or folder types shown in the specialise-type action -->
  <specialise-types>
   <type name="mm:doc" />
  </specialise-types>  
  
  <aspects>
   <aspect name="mm:colorAble" />
  </aspects>
 </config> 
 
 <config evaluator="string-compare" condition="Advanced Search">
  <advanced-search>
   <content-types>
    <type name="mm:doc" />  
   </content-types>
   <custom-properties>  
    <meta-data aspect="mm:colorAble" property="mm:color"/>
   </custom-properties>
  </advanced-search>
 </config>
</alfresco-config>

tomcat\webapps\alfresco\WEB-INF\classes\alfresco\extension\model\mmModelResourceBundle.properties

mm_minmodel.description=Alfresco Example Minimum Domain Model

mm_minmodel.type.mm_doc.title=Min Extended Content
mm_minmodel.type.mm_doc.description=Minimum Extended Content Document
mm_minmodel.property.mm_freeText.title=Additional Details
mm_minmodel.property.mm_freeText.description=Place to enter more details about this document
mm_minmodel.aspect.mm_colorAble.title=Rainbow Color
mm_minmodel.aspect.mm_colorAble.description=Color of the rainbow this document belongs to

The example files above define a simple "Minimum Content Model" for Alfresco. All of these files are kept within the Alfresco repository -- within the alfresco.war file set.

The next file is on the Share side and is used to define a form within Share for editing metadata specific to the custom class just defined.

tomcat\webapps\share\WEB-INF\classes\alfresco\web-extension\web-framework-config-custom.xml

<alfresco-config>

 <config evaluator="node-type" condition="mm:doc">
    <forms>
       <form>
          <field-visibility>
             <!-- inherited from cm:content -->
             <show id="cm:name" />
             <show id="cm:title" force="true" />
             <show id="cm:description" force="true" />
             <show id="mimetype" />
             <show id="cm:author" force="true" />
             <show id="size" for-mode="view" />
             <show id="cm:creator" for-mode="view" />
             <show id="cm:created" for-mode="view" />
             <show id="cm:modifier" for-mode="view" />
             <show id="cm:modified" for-mode="view" />
           
             <!--  specific for mm:doc -->
             <show id="mm:relatedDocuments" />
             <show id="mm:freeText" />

             <!--  aspect mm:colorAble -->             
             <show id="mm:color" />
           
          </field-visibility>
          <appearance>
             <field id="mm:relatedDocuments" label="Related Docs"/>
             <field id="mm:freeText" label="More Information"/>
             <field id="mm:color" label="Color">
                <control template="controls/selectone.ftl">
                   <control-param name="options">Red,Orange,Yellow,Green,Blue,Indigo,Violet</control-param>
                </control>
             </field>
          </appearance>
       </form>
    </forms>
 </config>
</alfresco-config>

With those files in place, you can checkin a document of type mm:doc from the Alfresco Explorer client and then make it available from Alfresco Share. Edit the metadata for the document, and select "Full Metadata Edit Page...".

You should see something like this:

The three new custom fields are now exposed on the Share edit form: Related Docs, More Information, and Color.

Advanced Workflow in Alfresco Share

2010-02-08T21:49:00.000-08:00

Alfresco Share 3.2 is shaping up to be a great development platform. Prior to 3.1, Share's access to standard Alfresco repository capabilities were disappointingly weak. But with the 3.2 release, many repository features have been migrated from the older Alfresco JSF client (aka the 'explorer' client) to the Share Document Library.

Unfortunately, Alfresco's Advanced Workflow, the ability to create complex workflows using jBPM and to use them within Alfresco, is still not quite prime time. There's talk that Advanced Workflow will be ready to ship as part of the 3.3 release of Share. On the Alfresco wiki, a series of goals for implementing Advanced Workflow in Share are listed.

But... the current state of Alfresco 3.2 Share makes it look like a full integration of Advanced Workflow with Share may not be that far off. One promising sign is that two built-in Advanced Workflows already ship with Share 3.2: "Adhoc Tasks" and "Review and Approve". The negative is that only these two workflows are available -- and they are hardcoded. Also assigning a document to one of those workflows throws some errors at the server.

We're anxious to see general Advanced Workflow working in Share, so I decided to investigate a bit to see what could be done to make a general workflow work in Share 3.2.

As a starting point, I adopted the workflow example code from the Alfresco wiki that describes an Approve/Reject Lifecycle workflow. The flow for the workflow looks as follows:

To install the new workflow for use within Share, copy the following files with contents as defined on the wiki into the exploded alfresco repository file area:
alfresco\tomcat\webapps\alfresco\WEB-INF\classes\alfresco\extension\lifecycle-workflow-context.xml

alfresco\tomcat\webapps\alfresco\WEB-INF\classes\alfresco\extension\workflows\lifecycle

lifecycle_processdefinition.xml

lifecycle-messages.properties

lifecycleModel.xml

In the lifecycle_processdefinition.xml file, you need to make sure that the use of the < ("less than") operator in the embedded Javascript is replaced with <. For example, on the line:

for (var i = 0; i < bpm_package.children.length; i++)

To make the workflow available within Share, add a line to define the lifecycleapproval workflow to the file
alfresco\tomcat\webaps\share\WEB-INF\classes\alfresco\site-webscripts\org\alfresco\modules\documentlibrary\workflow.get.html.ftl:

The name of the workflow "wfl:lifecycleapproval" corresponds to the name of the process definition defined in the file lifecycle_processdefinition.xml:

With these files in place, the web application server can be restarted.

Then by going to the workflow console in the Alfresco repository application, you can see that the workflow has been defined.

The workflow console is located at this URL: http://localhost:8080/alfresco/faces/jsp/admin/workflow-console.jsp. And the defined workflow definitions can be queried. In this example, the new workflowid is jbpm$8:

The new workflow is also now visible from the Share Document Library. When a workflow is selected to be assigned to a document from within Share, the following dialog can now be seen with a "Lifecyle Approval" option now available (with spelling typo):

That's all good. Now, by clicking on "Assign Workflow", the workflow will be assigned to the document. Now, after logging into Share as the workflow assignee, the following can be seen in the Task List:

From the workflow console screen, you can check the status of the newly created instance of the workflow. First, specify which workflow definition id you will be querying.

And then query the workflow id of the current instance of the workflow.

The workflow id of the workflow instance is jbpm$11.

And the path id for this workflow instance is jbpm$11-@.

The current task for the path is as follows:

Going back into the Share task window, after approving the review/lifecycle item and then again checking the properties for the task in the workflow console, the following can be seen:

So it looks like the workflow is working. But a glance at the tomcat console shows that there are errors being reported each time a workflow is assigned to a document. With a little bit of investigation, the problem can be traced to the file alfresco\tomcat\webapps\alfresco\WEB-INF\classes\alfresco\templates\webscripts\org\alfresco\slingshot\documentlibrary\action\assign-workflow.post.json.ftl.

The variable 'results' is entering the Freemarker macro as undefined. I'm not sure how serious a problem this is, but making the following change to this file avoids the error.

This test seems to indicate that while Workflow within Alfresco Share in the 3.2 release is not officially ready, it may be close enough for at least creating simple workflows like the one described here.

Alfresco WCM Roadmap

2010-02-02T21:58:00.000-08:00

The Alfresco tech team for Web Content Management (WCM) made a presentation on the Alfresco WCM 2010 Roadmap.

   Ben Hagan - WCM Product Manager
   Brian Remmington - WCM Architect

Here are some notes from the presentation.

Alfresco 3.2 included a number of improvements in the area of WCM:
   - Better page previews
   - Better page rendering
   - Better web page authoring in a clustered environment

Upcoming Alfresco WCM Release Schedule
February 15th - 3.2r release [Records Management plus some new WCM functionality]
March, 2010 - 3.3 Community Release
May, 2010 - 3.3 Enterprise Release

Overall Vision and goals for Alfresco WCM

Common Content Services is a long-term goal.
   - Access to WCM and standard Alfresco DM should be consistent
   ie., unification of the two repositories

Web Content Production
   - Be able to quickly edit and modify pages 'in-context'
   - Better tools for managing the web page presentation
   - Website production tools

Infrastructure/Platform improvements
   - Use high productivity developer tools like Spring Surf
   - Modular, pluggable, extensible,...
   - Standards like CMIS and REST
   - Built on fast, scalable repository

All Releases
   - Performance Optimization
   - Changes to improve scalability
   - Removal of use of Hibernate for more control

Alfresco 3.2r [February 15th]
   - Deployment of WCM AVM content to standard Alfresco DM repository
   This will enable Alfresco WCM to take advantage of standard Alfresco DM capabilities
   eg. Transformations, clustering, content rules

Alfresco 3.3 [May 2010]
   - WCM Content Rendering Service API. [Uses DM content, not AVM content]
   Render/generate a new content renditions [eg., different format, sizes, cropped, ...]
   Freemarker scripting can be used to specify the rendition operations
   New content is intended for use on the web page.
   Can chain renditions
   Maintains relation between the new rendition and the source content
   Renditions are searchable and can have access permissions

   - Alfresco Web Editor (AWE)
   Next-generation of Web Studio [Web Studio is now in springsurf. How is it related?...]
   Makes use of work done with Surf and Alfresco Forms Engine
   Compatible with Spring Surf
   Allow in-context editing
   Web Editor toolbar is extensible and pluggable using Javascript
   Includes a Template Editor
   Can design JSP / tag library pages. Eventually can design other languages, like Freemarker

   - Alfresco to Alfresco Transfer - DM Deployment

   - Enable DM Content modeling for WCM
   Associations
   Aspects
   Properties

   - 3.3 release will be concurrent with the SpringSurf 1.0.0 Final release [May 2010]

Alfresco 3.4 or 4.x [No Date has been set]
   - WCM integration with Alfresco Share -- "Web Producer"
   Create Share sites
   - Tools focused around WCM
   Content Library
   Template management
   Metadata management
   User roles and content permissions
   - Ability to deploy to other endpoints
   File System, Database, ...

Alfresco 4.x [No Date has been set]
   - Work Packages [sounds like AVM sandboxes will be deprecated]
   Currently still being designed -- soliciting feedback
   Collaborative/shared workspace [AVM sandbox is for a single user only]
   People can be invited to work on 'an activity'
   'Activities' are isolated, can happen in parallel, and get merged when ready
   The complete Work Package can be versioned

What's new in Alfresco Enterprise 3.2?

2010-01-29T17:56:00.000-08:00

Alfresco 3.2 is out. In general, I'm very pleased with this release.
In particular, Alfresco Share is really shaping up and is sure to have some very interesting implementations.
Here is a rundown on some of the highlights with a little bit of commentary on this new release.
There's really a lot there.

High Availablity, Scalability and Improved Administration
(Available in the Enterprise version only)
   Alfresco is being used for some very large systems. [As an aside. Alfresco has been benchmarked to have 100 million objects, and this year there is talk that they will try to do a benchmark with one billion objects. That's pretty big.] With this release Alfresco introduces tools to ease the administration of production systems, especially useful when considering large production systems. And much of the new magic is made possible with something called JMX (Java Management EXtensions). JMX is a Java technology that is helps you dynamically monitor and manage Web-based systems.

   Alfresco with JMX is pretty cool because, with it, you can probe the inner workings of Alfresco while it is running and view the status on a dashboard. You can reconfigure things without ever restarting the server. You can see things like server memory usage and active database connections. And you can also see the configuration and workings of Alfresco 'subsystems'.

   Alfresco is modular and consists of subsystem components. Subsystems include things like Authenticaion, the User Directory, the File Server, Image transformations, the IMAP server, and others. From a JMX console you can now browse through Alfresco subsystems and change any of the configuration parameters.

   What are the benefits? System administration with JMX becomes much easier. There are fewer downtimes -- lower maintenance costs. It lets you monitor your system and look for any bottlenecks --easier troubleshooting. It simplifies the management of error and log files. It is cluster-aware -- make a change while you are live and the change will propagate out throughout your cluster.

   Alfresco's implementation is 100% compliant with 'standard' JMX. That means that you can use any JMX client as your dashboard diagnostic tool. That includes JMX clients like JConsole, jManage, or any other.

   A partner of Alfresco, RightScale, was able to use Alfresco JMX and combine it with Amazon EC2 infrastructure to provide a smart-sizing version of Alfresco running in the cloud that lets you scale up or down your Alfresco server resources as the demand calls for it.

Storage Policies or Lifecycle Management
(Available in the Enterprise version only)
   Another great addition that is only in the Enterprise version is the ability to specify Storage Policies. This basically lets you control what media you will store/archive selected content to. This ties in with the concept of a 'lifetime' associated with content. Some content may be highly relevant today, but a year from now will be considered stale -- you don't want to get rid of it, but then you'd prefer to store it on a cheaper slower-access disk.

   The idea is that you might use SSD drives for your most important information, and based on business policies that you control, gradually move the data to cheaper drives like FC or SATA as it becomes less important. This way you can more cost effectively manage the storage of your data. This concept of Information Lifecycle Management (ILM) is something that EMC has talked about for some time.

New Deployment Options
   The 'original' Alfresco is deployed like traditional software, 'on premise'. You buy a server and install the software on it to run on your intranet.

In 3.1 Alfresco enabled their explorer client application to run as a multi-tenanted solution. With this approach, you can install Alfresco one time and partition the installation so that content belonging to one group of people can be kept separate from another group. Now, with the 3.2 release, Alfresco Share can be configured as a multi-tenanted application also.

With the 3.2 release Alfresco is also pointing out that Alfresco can be easily set up to run in the 'cloud'. I don't think that there is too much new here. People at Alfresco have talked about this as an option for some time, but perhaps with the rise of cloud computing they want to point it out again. As mentioned above, their partnership with companies like RightScale show that running in the cloud is now easy to do.

Improvement in Alfresco Share
   Alfresco has been fairly open with the fact that their 'Explorer' client which is based on JSF technology is no longer being actively developed. While JSF is still around and actively used at a lot of places, it is a 'heavier' technology compared to a lot of whiz-bang Web 2.0 stuff. Alfresco is now investing development cycles in Alfresco Share.

   Early versions of Alfresco Share lacked some basic repository capabilities that the JSF client had and which you would expect to find in a content management system. The focus was to start building out team collaboration capabilities, like multiple project site areas, wikis, blogs, and calendars.

   With the 3.2 release a lot of the document management capabilities are starting to show up in Share's 'Document Library' area. Things like changing the type of a piece of content, adding or removing an aspect, or assigning a workflow are now available. The document library capabilities in Share out-of-the box are now pretty slick. Alfresco can read property data from common file type headers and automatically populate content metadata.

   Share's built-in Flash viewer is also great. It only works with some common file types like PDF, MS Office and some common image types, but it can convert the file to Flash on the server and allow it to be viewed on the client. It lets you zoom and page through the document. It looks great and it seems pretty speedy. Since the file is converted on demand on the server, the whole file need not be transmitted to the client before you can open and view it. And you don't need the native authoring application. Hopefully there will be some more file types added to the list of the currently supported ones.

   Along the lines of viewing, Share 3.2 also includes a new smart dashlet that has an image 'lightbox' viewing technique that lets you visually navigate across your image content. You can see thumbnail images on a grid, scan through them and then select one to expand that opens with a lightbox effect on top of the thumbnail grid.

   Speaking of smarter dashlets, the new Share also allows user dashlet preferences and size settings to be remembered. Set them, log out, log back in and all your settings are still there. Maybe that behavior is something you would have expected all along, but it works now.

   Share now takes advantage of a new forms system in Alfresco. Change your metadata and content type and forms will automatically reconfigure to reflect those changes.

   Share sites can now be public or moderated. Users need to first apply to a moderated Share site and be accepted before they can become contributors.

   Share also now includes some Administrative capabilities. Early versions of Share were a bit awkward since they relied on having to administer users and groups from the JSF explorer client. The 3.2 release includes administration of both users and groups from within Share. And the design of the Share Administration module is pluggable. Have other custom administration configurations that you need to manage? -- Create a component that can plug into the Share administration console.

   Since Share is about Collaboration, you often would like to bring collaborators onto a project that are external to your organization, maybe partners or vendors. This new version of Share will let you do that. And Alfresco has done a lot of work in improving the scalability of Share, claiming that it will support scalability into the tens of thousands of users.

   And while not strictly part of Share, there has been a lot of changes going on with Surf, the web development framework that Share is built with. Alfresco Surf has been donated to an Apache incubation project and will jointly be overseen by the people from SpringSource, the developers of the popular Spring framework. The project is called SpringSurf.

Email Archive

The 3.2 release also adds some interesting generic support for connecting with email systems. Alfresco is calling it their 'Virtualized IMAP support'. (IMAP stands for Internet Message Access Protocol. Like POP, it lets you access your email on the email server.)

The IMAP support means that any email client can become a client of Alfresco. Basically Alfresco looks like an email server. You will be able to see the Alfresco folder hierarchy from within the email client you are using. This means that you can easily drag and drop emails from your inbox directly into folders within Alfresco.

When used with Share this means that you no longer have to forward emails to project members. Just save them directly to the Share document library for the project site. Since it is based on the IMAP standard, no plugin or extra client install is required for this to work.

5015.2 Records Management
   This is a big announcement, and actually it was removed from the 3.2 release, so including it here isn't quite right. It is now scheduled for release near the end of February as part of an Enterprise release being dubbed 3.2.1. But anyway, it is a big announcement, so I'l include some information here.

   In the fall of 2009, the Alfresco Share 3.2 Community version of the software was certified for 5015.2 Records Management compliance. This will allow Alfresco to be used by federal government agencies for management of their records. It is based on a specification created by the Department of Defense. There are only a small number of products and vendors that have been able to get certified, and Alfresco is the first Open Source solution. Clearly Alfresco worked a lot on this, and if you are looking for an RM solution, I think you'll like it. Here's a video demo.

   Records management is important for companies to achieve goals related to governance, retention and compliance. Alfresco's ultimate goal is for the Alfresco Records Management solution to be fully CMIS-enabled.

Web Content Management
   Web Content Management (WCM) also saw some changes with the 3.2 release, although there has been some talk that some major restructuring around WCM may be coming soon. Currently the Alfresco WCM and DM repository stores are structured differently, and there is talk about 'unification' of the two.

   The 3.2 release saw some improvements in how a web page can be previewed and also in how it is rendered. There were changes that now allow web content authoring to happen more easily in a clustered environment.

   And there were some improvements that let Alfresco WCM interact better with 'fast delivery channel' mechanisms and services like those of Akamai.

For more information about 3.2 features, check out the Alfresco 3.2 Enterprise page .

Alfresco Moves to LGPL Licensing for the Community Version

2010-01-28T15:54:00.000-08:00

"Big News!" says Nancy Garrity, Director of the Alfresco Community. And it is. Yesterday John Newton, CTO and Chairman of Alfresco, announced plans to switch the license used by the Alfresco Community version from GPL to LGPL. The change is to go into effect for the Alfresco 3.3 release.

(Note that there is some information about licensing presented here, but the caveat is that this is not legal advice. Always be sure to consult with a lawyer when doing anything related to licensing.)

Also remember that the Enterprise version of Alfresco comes with a standard commercial license. Open Source licensing is used only with the Community version.

Open Source licensing does tend to be confusing... Alfresco changed Open Source licenses once before, from Mozilla Public License to GPL in February 2007. At that time, an InternetNews.com article wrote "There are many companies that are afraid of the GPL, Alfresco isn't one of them." On the current legal FAQ page on the Alfresco site, Alfresco describes the reasons for why they originally moved to GPL.

When Alfresco did move to GPL, version 3 of GPL had not yet been finalized, so Alfresco explicitly called out GPL version 2 when referencing the license in Alfresco code, unsure of what conditions would be included in version 3. Alfresco source code files now say "version 2 of the License, or (at your option) any later version." (Alfresco has also considered some complications around trying to combine a GPL-licensed piece of software with other Open Source licenses, and Alfresco has some 'exception' language that describes that.)

First, just what are the differences between GPL and LGPL?
Well, both licenses give you complete access to the source code and the ability to build working software.

The GPL license allows you to use, redistribute and change software, but you're then required to make the source code available to users of the new software, and those users can in turn redistribute and modify the software subject to GPL. For some commercial software vendors and even at companies where software is being developed in-house, GPL is considered a bit toxic and people avoid it at all costs to make sure that their commercial or proprietary code will not come into contact with GPL and the possibility that their source code would need to be released.

LGPL is similar to GPL but differs in that it allows LGPL software to be treated as a blackbox or as a self-contained library. It allows you to cordon off a certain set of code as LGPL. If you change the inner workings of the LGPL piece, then you're pretty much bound to standard GPL and will need to contribute back any changes you make to the code. The difference comes when there are software pieces that integrate with LGPL and that are outside the scope and code boundaries of the LGPL. These other pieces are not bound to the same conditions as the LGPL piece. Because of that, LGPL is sometimes considered to be a bit more friendly, at least to commercial developers.

Second, what will the change enable Alfresco to do?
As John Newton wrote: "What the LGPL license provides over GPL is the ability to link in the Alfresco repository without affecting proprietary software that links it."

John is a strong promoter of the CMIS (soon-to-be) standard. CMIS will enable many different applications and repositories to interact, and an LGPL license will make people more willingly consider combining Alfresco in solutions composed of a variety of software components. John wrote:

"We do this in the spirit of making Alfresco available as a CMIS platform and a general ECM platform to build content applications without inhibiting your business opportunities. What we hope is that your applications will build demand for Alfresco services from Alfresco Software, particularly in larger enterprise environments."

I think that this move to looser licensing terms should further encourage activity around the Alfresco ECM platform, and that, of course, is good.

Resources for Getting Started with Alfresco Web Scripts

2010-01-25T13:13:00.000-08:00

If you're going to be doing any development with Alfresco, you'll find that at the heart of much of the development are Web Scripts. Alfresco calls their Web Script technology "agile script-driven MVC".

Web Scripts enable very quick web application development. Instead of a single monolithic system, Web Scripts use a very focused light-weight approach for building components that can be combined and reused.

Alfresco has two types of Web Scripts:
   Data Web Scripts
   - Based on RESTful URLs
   - Can return structured data as XML, JSON, or CSV
   Presentation Web Scripts
   - Renders the UI
   - Can call data web scripts

There are three components to a Web Script:
   - Descriptor file
   - Controller file (Javascript makes it easy. Java is more capable).
   - View file (Typically uses Freemarker, but can use things like XSLT and XSL-FO)

Alfresco has dashboards to see which Web Scripts are available:
  eg., http://localhost:8080/alfresco/service or
   http://localhost:8080/share/service

Debugging Web Scripts
   Set log4j.logger.org.alfresco.repo.jscript to DEBUG under WEB-INF/classes/log4j.properties
   logger.log will write to catalina.out

Other Resources:

Alfresco Webinar on Web Scripts. A high-level overview.
Alfresco Web Scripts -- PDF Document by Alfresco/LifeRay. A bit light on specifics, but great graphics.
Alfresco Web Scripts Wiki page. A good place to get started.
Web Script Examples Alfresco Wiki page. Large number and variety of cookbook examples.
Alfresco Developer Guide by Jeff Potts. Chapter 6, 'Exposing Content through RESTful APIs with Web Scripts'. Great resource. A similar version of this chapter is available here.
Best Practices and DRY. Break up Web Script files and use 'import' and configuration files.
Using 'Remote' in Web Scripts. Lets Alfresco Share Web Scripts call into Alfresco repository and external services.

Alfresco Turns Five

2010-01-23T13:28:00.000-08:00

Birthday greetings go out to Alfresco this month. The Open-Source ECM vendor is celebrating its five year anniversary. Over just five years Alfresco has managed to put together a next-generation ECM product that competes well against traditional vendors like EMC/Documentum, IBM/Filenet, and even Microsoft/Sharepoint.

This week CIO magazine recognized the momentum behind Alfresco by naming it one of the top 20 tech companies to keep an eye on in 2010. CIO magazine said that "Alfresco is already well known to open-source types and has the giants of the enterprise content management space coming over all defensive. It already has a large user base and converting that mindshare into real money is the challenge for 2010, assuming it doesn't get picked off by one of said giants."

Alfresco and IBM Join Forces

2010-01-18T11:34:00.000-08:00

Alfresco announced yesterday at IBM Lotusphere 2010 in Orlando integration of Alfresco with IBM's Lotus Quickr, Lotus Notes, Lotus Connections and Websphere Portal. Alfresco has named the integration Alfresco Content Services for Lotus, and it is scheduled to be available in Spring 2010. The announcement described it as "economical, scalable and open."

Although it isn't clear exactly how long it took to pull off the integration of the two products, press releases boast that they managed to do it within 'record time', attributing much of their speedy development to the use of REST Web Services and CMIS, the new Content Management Interoperability Services standard, something which both Alfresco and IBM have been pushing hard for.

The CMIS standard (or more correctly, soon-to-be standard) has the potential to be the enabler for a whole new category of Content Management (CM) applications -- integrated collaborative content management (ICCM), ones that can blend data and information from multiple data sources, which could enable collaboration between users regardless of the exact collaboration tools that are being used.

Highlights of the Alfresco-Lotus integretion include:
- Integration with Microsoft Office using Alfresco's implementation of Microsoft Sharepoint protocol
- Integration with Alfresco's 5015.2-certified implementation of Records Management
- Ability to provide 'cloud-computing' deployment

"Lotus Quickr users can manage, store and retrieve documents, and kick off transformations and workflows through Alfresco without having to change anything on the front end," says John Powell, president and CEO of Alfresco.

Here is a demo prepared by Alfresco that shows the integration with Lotus Quickr:

Clearly Alfresco is aiming at Microsoft with this announcement. John Newton, Alfresco's CTO called the combination of Alfresco with IBM Lotus a "real SharePoint killer".

And that brings up the question of 'why Alfresco' and not IBM's own FileNet. Actually IBM already has a FileNet integration with Lotus. Kathleen Reidy, 451 Group senior analyst said that Alfresco is being positioned as a leaner and lighter-weight option than FileNet. "IBM can't tell customers evaluating Lotus vs. [Microsoft] SharePoint that they need to use FileNet if they want ECM. That is what this Alfresco integration says to me," she says. But the decision to add Alfresco must be causing some concern within IBM's FileNet group.

Alfresco Spring Surf using Roo

2010-01-11T21:39:00.000-08:00

Well, I saw Alfresco's SpringSurf webinar last week and I was inspired by the presentation to give it a go. SpringSurf combines the SpringSource Spring framework with Alfresco's Surf to create a rapid webapp development environment that focuses on scripting.

After some false starts, SpringSurf Milestone 2 was released over the weekend. I downloaded it and gave it a try by going through a fairly nice SpringSurf tutorial. But near the end of the first chapter I hit a roadblock. The version of the SpringSource Tool Suite (STS) that I downloaded bundled roo version 1.0.0.RC4. The tutorial shows roo 1.0.0.RC4 -- so it seemed right. But -- it didn't work for me.

Using the RC4 version of roo, my maven deployment went into an endless loop trying and failing to download dependencies. I ultimately downloaded roo version 1.0.0.RELEASE and, after that, things went a lot more smoothly. I got past the deployment and I saw my first roo-generated surf app! It was pretty cool when things went smoothly.

Overall the tutorial is good. Andrew Miller points out a couple of typos in the sample code in Chapter 2 that can cause some problems, and his solution saved me some time. After the tutorial's second chapter, a lot of the material is stubbed out, still to be written.

Overall, my impression is that SpringSurf can be used for setting up new sites and the building out of new web pages fairly easily. But it is still a bit rough around the edges -- definitely in an 'early adopter' phase right now.

It will also be interesting to see how Alfresco WCM capabilities will also be woven into the picture. Hopefully this will be one item that Alfresco addresses in the upcoming presentation of the Alfresco 3.3 and 4.0 WCM roadmaps.

Changing the default Alfresco Share Theme

2010-01-04T18:34:00.000-08:00

Alfresco Share is an open-source enterprise-class collaborative content management application based on the Alfresco content repository.

Share was built using Alfresco's web development framework called Surf. Surf is a flexible platform that allows quick and easy development and customization of web applications, like Share. The framework evolved as Alfresco engineers needed a tool for quickly building content-rich applications. Surf is Alfresco's second generation architecture for building web applications. First generation Alfresco applications were based on a web client built using Java JSF, a technology significantly more difficult to develop with than Surf.

From the beginning, Alfresco technology has been built up around the Java Spring framework. Surf continues to use Spring. In fact the developers of Spriong at SpringSource were so impressed with Surf that they agreed to cooperate jointly with Alfresco on a project under the Apache banner called the Spring Surf Extension.

"Alfresco and SpringSource share a common vision for providing more modular and productive web application development frameworks. We welcome this contribution and are pleased to have Alfresco as an active member of the Spring community," said Rod Johnson, General Manager of the SpringSource Division of VMware and the creator of Spring.

Spring is all about the 'wiring' of interchangeable components. Alfresco Surf/Share has adopted Spring application configurability and also introduced additional XML configuration files. Most Surf customizations and changes start by making a change to an XML property file.

As a simple example of how this wiring plays out, I'll show here how the 'theme' or color scheme can be changed in Alfresco Share. By default, which theme to use is defined in the file: share/WEB-INF/classes/alfresco/web-framework-config-application.xml.

Not too surprisingly, the default theme is called default. If you look into that xml configuration file you will find code similar to the following:

There are three out-of-the-box themes that ship with Share and the definitions for those themes can be found in the directories under the themes directory:

By changing the theme for the application, you can change the color schema for the application. For example, shown on the top below is the standard default theme for Share, and below that you can see the greenTheme for Share.

The default Alfresco Share Blue Theme

The Alfresco Green Theme

A quick way to test out how well a new theme will look is to simply include the theme parameter at the end of the URL, as in: http://localhost:8080/share/page/user/admin/dashboard?theme=default. (Although this trick doesn't seem to be swapping out the new theme images; it only changes the theme css files.)

To change the theme globally so that it will be applied to every page, it is necessary to make changes to the file: share/WEB-INF/classes/alfresco/web-framework-config-custom.xml. If the file doesn't exist, you should create it in that directory. Otherwise the existing file should be modified to include the following content:

As shown above, each theme is grouped into its own directory and contains a folder of images along with two CSS files, one for the login page (login.css), and another for all other pages in the application (presentation.css). To create a new theme, just create a new directory under themes -- the easiest way to get started is to copy over the default theme and then start editing and replacing.

Often the first step in customizing the Share site is to change the logo. With themes, swapping in a new logo is easy. By looking into the images directory, we find that there are images called logo.png (the logo displayed on the login page) and app-logo.gif (the logo displayed in the upper left of all other application pages). Making new files with identical file names and placed within your new theme area will override the default logos.

Next you should have a look at how to change the css files for your new theme. The presentation.css file holds most of those definitions. But looking at the presentation.css file can be a bit daunting. It is about 800 lines of css, including a lot of hex color codes. A good way to get a handle for what's going on in this file is to compare the presentation.css files between two out-of-the-box Alfresco themes. For example, do a diff between the presentation.css file of the greenTheme with the default one.

For example, using a source diff tool (like the free SourceGear DiffMerge) you'll quickly see that there are a lot of differences between the theme files, but things begin to make some sense. You'll need to rename skin references in the file to use your new theme name -- something which occurs in more than 100 places in the file. For example yui-skin-default will need to be renamed yui-skin-NewTheme. Global replace will quickly help with that.

Because the browser can be forced to reload the image and css files, the theme files can be modified and reloaded without having to stop and start the web server.

From there on it is possible to experiment with some of the colors. It is also a good idea to investigate using a point and click tool like Firefox/Firebug to visually examine the css. You'll find that about the last hundred lines of presentation.css is marked as "Theme background colors". This is a good place to start making changes. After changing colors there and also changing the dashlet-title-bg.png file, which is the image file used to produce a gradient color effect on the dashlet titlebars, you'll be pretty far along in transforming the skin of the application.

Creating a new theme is obviously tedious, but Alfresco has done a great job in separating out css from the markup, which at least makes the job possible.

Here are some screenshots of the Alfresco optional Green Theme:
http://www.slideshare.net/AlfrescoUE/visual-design-alfresco-green-theme-presentation.