Note: we are using some trickery here, and doing things that aren’t typically recommended, so please be very careful and test things out in your environment. This worked for me on Alfresco 3.0SP1.

The auditing properties are being set pretty deep inside the infrastructure code (class HibernateNodeDaoServiceImpl). The code checks whether Auditable aspect is applied, and if so, it sets these properties explicitly. One way to disable this is by modifying the code. The way to do it more cleanly is by temporarily changing contentModel.xml. Auditable aspect applied is a mandatory aspect on cm:object, which is parent of cm:content.

Step 1 - Disabling Automatic Setting of Auditable Properties

So my solution is to remove Auditable as a mandatory aspect and to add those properties to cm:object directly. This is the new definition of cm:object.

<type name=”cm:cmobject”>

<title>Object</title>

<parent>sys:base</parent>

<properties>

<property name=”cm:name”>

<title>Name</title>

<type>d:text</type>

<mandatory enforced=”true”>true</mandatory>

<constraints>

<constraint ref=”cm:filename” />

</constraints>

</property>

<!–temporary added properties to go around auditable –>

<property name=”cm:created”>

<title>Created</title>

<type>d:datetime</type>

</property>

<property name=”cm:creator”>

<title>Creator</title>

<type>d:text</type>

</property>

<property name=”cm:modified”>

<title>Modified</title>

<type>d:datetime</type>

</property>

<property name=”cm:modifier”>

<title>Modifier</title>

<type>d:text</type>

</property>

<property name=”cm:accessed”>

<title>Accessed</title>

<type>d:datetime</type>

</property>

</properties>

<!—- Disable Auditable Aspect

<mandatory-aspects>

<aspect>cm:auditable</aspect>

</mandatory-aspects>

–>

</type>

Additionally, for convenience, it’s a good idea to not make these protected, or enforce them as being mandatory, as they are on the original Auditable aspect. As you can see, we commented out cm:auditable as mandatory aspect on this type, which means the code that sets these properties automatically will not get triggered.

Step 2 – Show Properties in the User Interface

The next step is cosmetic – we need to make these properties visible in our UI so it’s easier to test. For that, you will need to edit CONFIGROOT\ web-client-config-properties.xml. Add the auditable properties to “content” evaluator:

<config evaluator=”node-type” condition=”content”>

<property-sheet>

<show-property name=”creator” />

<show-property name=”created” />

<show-property name=”modifier” />

<show-property name=”modified” />

This will allow you to see these in the UI.

Step 3 – Set Properties, Migrate Content, Perform Bulk Load, etc.

After a server restart, you have now disabled the automatic setting of properties. You can either set them programmatically (and your changes will no longer get intercepted), or manually through the UI.

Edit Auditable properties

Note: This is an all or nothing operation – you can’t have it automatically set some properties but not others (to do it you’d have to do metadata extraction or some kind of event handler). This is why this is usually a temporary step as you are loading or migrating content.

After you are done with the content load, the next step is re-enable original model to ensure consistency. You also have a bunch of nodes that don’t have Auditable Aspect applied, so we need to reapply it.

Step 4 – Apply Auditable Aspect to Migrated Content

First, you need to revert to the original content model. To apply auditable aspect to many nodes, you typically write a JavaScript script that walks through the nodes and adds Auditable Aspect.

For applying Auditable aspect manually, you’ll have to add some code to CONFIGROOT\web-client-config.xml so it shows u in Add Aspect action.

<config evaluator=”string-compare” condition=”Action Wizards”>

…

<!– and the has-aspect condition –>

<aspects>
<aspect name=”generalclassifiable”/>

<aspect name=”complianceable”/>

<aspect name=”dublincore”/>

<aspect name=”auditable”/>

<aspect name=”effectivity”/>

<aspect name=”summarizable”/>

<aspect name=”versionable”/>

<aspect name=”templatable”/>

<aspect name=”emailed”/>

<aspect name=”emailserver:aliasable”/>

<aspect name=”taggable”/>

</aspects>

Another possible solution that might preclude this is to have a rule that automatically adds the Auditable aspect as you create nodes, but I haven’t tested that yet.

Step 5 – Restore original state of contentModel.xml and web-client-config-properties.xml

To get everything back to a consistent state, you now have to restore your original contentModel and UI properties. Because all nodes now have auditable aspect applied, as well as the properties that need to exist do in fact exist, Alfresco will now be able to pick it up from there and manage these properties the way it always does.

For a more introductory stuff on Surf, see the Surf Platform Category on the Wiki

There is also a webinar I did a few weeks ago - that one runs through a basic technical overview of Surf and some basic extensions.

java.net.BindException: Address already in use: JVM_Bind
    at java.net.PlainSocketImpl.socketBind(Native Method)
    at java.net.PlainSocketImpl.bind(PlainSocketImpl.java:359)
    at java.net.ServerSocket.bind(ServerSocket.java:319)

I double check that all of my java processes are killed, but no cigar.  I even tried redirecting tomcat to another port until next reboot, but then I’d d also have to redirect RMI ports as well.


I finally figured out the problem.  The port references were kept by OpenOffice process soffice.bin.  Killing it resolved the issue. 

In this example, I have a WCM content type defined through XSD press_release.xsd.  I want to extract some metadata from it, for example, expiration date of the press release. The extraction process works similarly to the way things function on the DM side, with some gotchas. When extracting metadata, you need somewhere (properties) to store it.

For WCM (where all the XML nodes are stored as wcm:avmplaincontent type), is by creating an aspect with the properties that you want to extract.   This is important – it has to be an aspect. This aspect will automatically get applied appropriately, as we’ll see later. In the included example, I have a XSD that creates a press release.  I want to extract and index three properties – abstract (string), expiration date (date), and numtimes (int). Here is the code (I removed all the indexing properties for simplicity)

<aspects>

<aspect name="my:press_release_metadata">

<title>Sample Aspect for WCM - Press Release</title>

<properties>

<property name="my:abstract">

<type>d:text</type>

</property>

<property name="my:expiration_date">

<type>d:datetime</type>

</property>

<property name="my:numtimes">

<type>d:int</type>

</property>

</properties>

</aspect>

</aspects>

You’ll also need to expose your aspect properties in the UI through web-client-config-custom.xml

<config evaluator="aspect-name" condition=" my:press_release_metadata">

<property-sheet>

<show-property name="my:abstract" />

<show-property name="my:expiration_date" />

<show-property name="my:numtimes" />

</property-sheet>

</config>

Once I have the aspect in my content model (customModel.xml, which I introduce to the Data Dictionary through custom-model-context.xml), I can start configuring extraction process as outlined in wcm-xml-metadata-extracter-context.xml.  There are two key sections:

1. Selector section (extracter.xml.sample.selector.XPathSelector bean), which looks inside the XML and maps it to the correct Extractor Bean.  Since all the XForms of any type get saved as XML, we need to select the appropriate one (in this case pr:press_release). This configuration associates the specific XForm with a specific extraction definition.

   <bean id="extracter.xml.sample.selector.XPathSelector" class="org.alfresco.repo.content.selector.XPathContentWorkerSelector" init-method="init"> <property name="workers"> <map> <entry key="/pr:press_release"> <ref bean="extracter.xml.sample.AlfrescoCustomModelMetadataExtracter" /> </entry> </map> </property> </bean>

2. Extractor bean for each of the Web Content Types you defined.  These have two parts:

   A. xpathMappingProperties – take an xpath expression that can extract value out of XML file and store it into internal Map.  So, for example, the abstract property can be found through xpath expression "/press_release/abstract".  It then gets stored into "abstract" internal map property.

   <prop key="abstract">/press_release/abstract</prop>

   Note that we have to also specify namespace so Alfresco can resolve them appropriately:   
   

   <prop key="namespace.prefix.pr">http://www.alfresco.org/alfresco/pr</prop>

B. mappingProperties – takes the properties out of internal map, and puts it into the specified data dictionary property.  Here is the key – the extractor finds the corresponding aspect and automatically ("automagically") adds it to the Alfresco node. Before setting it, it checks for the target data type, and attempts to convert it to that type.  In the example we are using, it takes out the internal map property "abstract" and sets it to property my:abstract. In this case the property is a string, so no conversion is really required.

       <prop key="abstract">my:abstract</prop>

Note on Converting Dates: When I did this initially, I got an exception for converting dates.  This is because the XForms store dates in the format of 2008-04-28, and the automatic cast did not work.  To remedy that, I added a configuration setting where I specified the correct date format for the extractor to use: <property name="supportedDateFormats"> <list> <value>yyyy-MM-dd</value> </list> </property> Note, that metadata extraction runs when you create content (in the user sandbox).   They key here is that the aspect gets applied automatically by the extraction process – you don’t need to make sure it’s added. You don’t even see mention of the aspect anywhere in the configuration files. This is what is should look like in the example:

The Lucene indexing will happen when you promote the content to the staging sandbox.

The indexing is governed by the settings on the properties you define on properties of the aspects (namely <index> element):

<property name="my:expiration_date">

<type>d:datetime</type>

<index enabled="true">

<atomic>true</atomic>

<stored>false</stored>

<tokenised>false</tokenised>

</index>

</property>

You cannot search based on these properties from the Search UI, since this relates to the WCM content, but you can query this using the Node Browser for testing, or, of course, the ultimate goal is likely to expose this through some web scripts.

In this post, I’ll talk about what I’ve been working on, ask for feedback, and also ask for contributions in improving the SDK. I’ve been working in a separate branch, so the changes are not available yet publically if you try to look for them.

Phase I as outlined below is what I already completed. Next is Phase II, which mostly involves integrating some existing samples. I also outline some other samples I feel will be useful to have, and ask for ideas on other samples to add things that might be useful. The goal is to have a number of samples that are representative of development tasks that you need to perform when working on customer projects.

Most of all, I ask for your feedback, and for any samples you may have that you think will be useful. I know they are out there. We are looking especially for samples that represent common development tasks. Please contact me at jbarmash at alfresco dot com if you have something to contribute.

I recently found a great service for gathering feedback, please add further suggestions there and vote for various improvement proposals.

http://alfresco.uservoice.com/pages/sdk_improvement

Phase I - Already Completed:

Bring SDK Up To Date

• Added source code for packages introduces in 3.0
• Added a few missing jars that were preventing running some samples in Eclipse

Improve Eclipse Experience

• Renamed Sample Projects to organize them better
• Reordered SDK Embedded jars to be more alphabetical
• Added project for source files – importing projects into Eclipse will now have source code automatically attached. Before this, every time I’d download a new SDK and import it into Eclipse, I would have to manually attach the corresponding source files to the SDK (i.e. alfresco-repository.jar and alfresco-repository-src.zip). The goal is to make this step automatic.
• Added a project for shared properties for Java Embedded Projects – can now set just one property file that will affect multiple projects.

Improve SDK Build Infrastructure

• Integrated identical Build file for all projects
• Automatically create AMP files based on directory structure convention. Can easily re-point the location of the SDK, to retarget against other SDKs. Creating AMP files is viewed as being hard, but it’s really not the build file I introduced will automatically create it for you as long as you follow a few conventions. I hope to go through it in a separate post, but here is a link to the project so you can start using it right now.
• Created master build file that allows to build all the SDK projects, including integrate a set of them into alfresco.war for easier testing. This one will not only be helpful for developers, but, once integrated into the alfresco build file, will allow us to identify any future regressions of SDK samples not building.

Improving Existing Samples

• Reorganized projects to create AMP Files. This one is a big one in my mind – AMP is the standard extension mechanism that we encourage customers to use. Now everybody will have good samples on how they are supposed to be laid out.

Phase II – Adding Existing Samples

This is my next step – re-testing and adding samples we already have. Here they are, along with priorities:

• MUST - Exposing new Custom root object to FreeMarker
• Test it for working with both Alfresco repo and Surf / Share.
• MUST - Exposing new Custom root object to JavaScript
• Test it for working with both Alfresco repo and Surf / Share.
• MUST - Standalone Custom Content Model Project, with validation check
• MUST – WCM SampleFileSystemDeployment
• MUST - WCM Metadata Extraction Sample from XML
• MUST - Surf / Share Dashlet Samples
• SHOULD - JSF Dialog backed by a Web Script
• SHOULD – Custom Condition backed by a JavaScript (with UI).  Possibly simplify first.
• COULD - Cascading Component Generator & Lucene-backed Drop Down Component Generator (described here: - http://blogs.alfresco.com/wp/jbarmash/2008/08/18/implementing-cascading-dropdowns-for-editing-properties/ ). There are some dependencies in the product for this that makes this a bit harder than a simple extension.

Phase III – Create New Samples

These we don’t have developed yet, and thus view them as secondary, though some of these are very important. Here I am looking for more feedback, as well as prioritization on what to do when we have time. You will notice that these are more repository-focused at this point – Surf / Share-oriented SDK samples is something we will revisit as well, but after this initial project.

• SHOULD - WCM - XForm Samples (move them from extras directory)
• SHOULD - WCM - Custom Widget for XForms (supposedly we have something on this)
• SHOULD - More standalone Web Script examples, including java-backed web scripts. There are many of these in existence, just need to find something representative.
• SHOULD - Repository - Custom Transformer Sample
• SHOULD - Repository - Custom Metadata Extraction Sample
• COULD - Repository - Custom Authentication Component
• COULD - Custom Behavior for Content Model
• COULD - Custom Scheduled Job
• COULD - AMP That Bootstraps some Data into the repository
• COULD - Dynamic Content Models and AMP that automatically loads them

Call for Contributions

This is where you can help. Any sample on the Phase III list, or whatever other samples you may already have, would be appreciated. Please contact me and tell me what you have that might be able to include (jbarmash at alfresco dot com). Normal code contributions will be followed, and we are happy to give you the credit you deserve of course. Improving the SDK and having a good set of samples to point customers to is something that should benefit the whole community, and let potential new developers to get up to speed more quickly.

And once again, if you have anything you’d like to contribute that may not be good as a sample, you can do that as well – email me or our community manager Nancy Garrity and we’ll post it up to the Developer Toolbox. You never know, she may even give you a t-shirt or a chumby.

Let’s use this link for ongoing discussion and prioritization of effort.

http://alfresco.uservoice.com/pages/sdk_improvement

Thanks!

To learn more about Dynamic Models, check out the wiki page, and for a quick overview - see this great Screencast that J.M. Pascal created showing the Dynamic Models functionality.  Check it out, as well as his blog in general - he has a bunch of fun presentation about some other Alfresco concepts as well!

Some of the notable things from the event, (apart from my riveting demonstration of Alfresco Share of course), were the case studies:

Harvard Business Publishing talked about their use of Alfresco. Of particular interest was the fact that they are using Alfresco as an integrated content management application, both the Document Management as well as Web Content Management. It sounds like they also integrated Alfresco with some interesting technologies, such as Synaptica for Taxonomy and Oracle ERP Suite. They built up a custom interface with JBoss SEAM. Their Web Content Management involves three web properties, and numerous micro-sites. Other interesting integrations on the project were Endeca for Search, MarcLogic for XML storage, integration with Ad networks. Because the presentation was more business focused, I’d like to learn more about some of the internals of these integrations.

Partner Red Hat (JBoss) spoke about how Open Source delivers true value to the consumers, and how portals help deliver that value.

Our partner RivetLogic spoke about another interesting case study - ConnectedWeddings.com.  ConnectedWeddings received a grant from FaceBook fund to build their application on top of a true enterprise platform. They chose Alfresco, and now they using Alfresco in conjunction with JBoss to power their Facebook application. They can author content in Alfresco WCM and publish it to a delivery environment that surfaces content to Facebook, a website, and iPhone client.

I enjoyed the event, especially since it kept at a brisk pace with a lot of content to cover. I did get a sense that more of a deep dive into some of the 3.0 technologies might have been nice though.

One nice thing that came out of it is that I reconnected with my old college suitemate, who came to the event.

Alfresco Tech Talk Live is a series of regularly scheduled sessions where attendees get to guide the discussion. Alfresco will host the sessions along with a panel of subject matter experts who will be prepared to answer your questions.

Today’s topics will include:

• CMIS Rollout
• Alfresco Labs 3B Release
• Much more!

Learn more at: http://wiki.alfresco.com/wiki/live

Join us at: http://alfresco.acrobat.com/live