CONTENTREICH

Mixing Grails and Alfresco Share

Andreas Steffan — Tue, 08 May 2012 08:35:06 +0000

Alfresco Share and Spring Surf offer a nice extensible foundation for various kinds of content based applications. For some applications, it requires just a few tweaks to Share and you are done. In other situations, you might encounter bigger challenges remaining. Or maybe it is just that you do not feel comfortable with the way things are “usually” done in Share – like Freemarker templating or its typical Javascript.

Lets be honest: The Share application and the framework also do have weaknesses and our mileage varies.

Personally, I don’t really like the server side Javascript (Link to other post below). Besides, I have seen other requirements, like database access or security which provided food for thought.

Make Sense … and Fun !

I like Grails and the Groovy way – because it can be really productive (and fun !) once you passed the first hurdles and left the initial pain behind.

For quite some time, I was thinking about how to make sense of Groovy/Grails and the Alfresco stack at the same time (… and I don’t care if I’m the only one on the planet ;). In the past, there have been efforts getting these together at small scale – e.g. the introduction of Groovy (Web)Scripting.

This is about a large scale approach. As both, Spring Surf and Grails are based on Spring MVC, I was wondering whether they can be mixed in a single webapp and how nice they play together. With Alfresco Share the only Spring Surf application at hand, I started merging the whole beast with Grails – as a plugin. The dependency (hell) problem to overcome was expected. The only other one was due to a problem with absolute paths used by Alfresco Share to resolve Javascript imports (patch coming). In the end, I think these technologies play together at better than expected.

Here is a short demo video of the Alfresco Share Grails Plugin:

http://www.youtube.com/watch?v=T3a0_dUPRoU

If you would like to try it, out follow the steps below:

#
# Make sure you have grails 2.0.x installed and
# an alfresco repository ready to serve at
# http://localhost:8080/alfresco
#
grails create-app gshare
cd gshare
#
# add mavenRepo "http://vcs.contentreich.de/m2"
# to grails-app/conf/BuildConfig.groovy
#
grails install-plugin alfresco-share 0.1
grails -Dserver.port=9080 run-app
#
# You are in the business now ;)
#
# Share is at http://localhost:9080/page
#

Where to go next

As the plugin code is standing there now, it almost required no tweaking to Alfresco code at all. The library-dependency situation should stay stable for a little while, so I hope overall maintainance effort is minimal. That is fairly important to me.

So Grails and Alfresco Share can be squeezed into one webapplication. I would be interested to know whether that can be done with the repo as well. ;)

Seriously, I have to say I’m not quite sure yet where to go from here – suggestions welcome.

Update: Jira issue with fix created

References:

Why Groovy Scripting rocks : Use Case Alfresco

Andreas Steffan — Tue, 17 Apr 2012 07:10:21 +0000

Quick turnaround is a major benefit of embedding a dynamically typed language within a Java based application. Developers no longer need to restart the whole application or the entire server for certain types of changes.

On the JVM, we have various dynamically typed languages to choose from. Ruby, Groovy, Javascript, Python and Clojure are among the candidates. They all have pros and cons so the best choice depends on the use case. This post is about Groovys pros.

Javascript in Alfresco

The Alfresco repository (and Spring Surf as well) provides an embedded Javascript interpreter (Rhino). Quite a lot can be done with a few lines of Javascript. Turnaround is far better than what you have with Java language based coding.

Still, there are things which could be improved, including:

Debugging Support
Code Reuse
Java Integration

Java integration cannot really be fixed due to the very nature (i.e. concepts/keywords) of Javascript. Technically, you can access the Java world:


var ctx = Packages.org.springframework.web.context.ContextLoader.getCurrentWebApplicationContext();

var nr1 = Packages.org.alfresco.service.cmr.repository.NodeRef.newInstance();

var nr2 = Packages.org.alfresco.service.cmr.repository.NodeRef.getConstructor(...).newInstance(...);

This works and gets the job done, but feels just plain wrong.

There are Javascript improvement efforts underway (links below) regarding debugging support and code reuse. I cannot really tell where they are headed now, but I hope at least the reuse changes make it into the core code soon.

The Groovy Alternative

Groovy is really outshining the competition addressing these issues. Super smooth Java integration is baked into the language. Debugging is based on JPDA/JDI – a very mature and perfectly supported technology. Even the code providing the embedded scripting was almost where I wanted it. Spring Surf sources include an extension (spring-webscripts-addon-groovy) which has a working GroovyScriptProcessor.

The only little ~~hack~~ tweak to get breakpoints working was to break Webscript naming convensions replacing the dot with an underscore. Hence groovy.get.groovy becomes groovy_get.groovy. Today, it is just a proof of concept but it works right as I would expect. Deploy the module, attach your IDE to the process, set a breakpoint and drive the application there:

Groovy breakpoint in Alfresco Webscript

Below is a link to the sources and a ready made module just in case you’d like to try it out. Honestly, I think Groovy deserves a little more attention in the Alfresco ecosystem. I am volunteering to push a little further.

Other Languages

In the Alfresco Repository/Spring Surf use case, I personally think you cannot beat Groovy. The only other ScriptProcessor I’m aware of is the Clojure based implementation. No doubt – the OOP <-> FP language border is rough, but Clojure is a beautiful language well worth it compared to … ;) Clojures REPL based development model makes it very appealing to me. I only had a quick glimpse at lambda-alf so far, but I will definitely have another closer look soon. I would pick Clojure next because I enjoy the language – your mileage may vary.

PS: Just in case you look at my code and wonder what is going on in DebuggableGroovyScriptProcessorFactory:
I wanted to reuse all the repository baseJavaScriptExtensions without compile time dependencies so the same Groovy ScriptProcessor works in Surf Apps just as well. The reflection mess is just the struggle with the type system.

Update April 19, 2012:

Forked spring-webscripts-addon-groovy at github
Added Peters post to the references

References:

Alfresco module source code @ github
Fork of spring-webscripts-addon-groovy @ github
Alfresco and Groovy, Baby!
Script imports with a cleaner API (Alfresco/Rhino)
Debugging Alfresco #1 – Eclipse JavaScript Debugger and Alfresco Repository (Rhino/JSDT)
Getting Alfresco Content Types via JavaScript
lambdalf (Clojure flavour for Alfresco)
Image Credits
Definition of “outshine”

Download Contentreich Alfresco Repo Sandbox Module

Wir realisieren Alfresco Community Projekte – aber nicht kostenlos!

Sandra Martin — Mon, 02 Apr 2012 08:00:37 +0000

Als Dienstleister und Berater für ECM Lösungen erhalten wir immer öfter Projektanfragen für eine Umsetzung mit der Alfresco Community Software.

Alfresco bietet den Rahmen für Dokumentenverwaltung, Collaboration, Web-Content-Management uvm. und lässt sich sehr gut um kunden- und branchenspezifische Anforderungen erweitern.

Es ist nicht unüblich, dass Interessenten mit umfangreichen Projektanforderungen ein Festpreisangebot ohne Beauftragung einer Konzeptionsphase einfordern.

Häufig führen viele Wege zum Ziel, es ist uns wichtig den für den Kunden besten Weg auszuarbeiten. Als Dienstleister muss ich das Geschäft und die Business Prozesse meines Kunden verstehen, um ihn optimal zu beraten. Für ein komplexes Anforderungspaket muss aus unserer Sicht ein technisches Konzept erstellt werden. Für dies Konzeptionsphase werden Ressourcen mit fachlichen/technischen Know-how benötigt. Auch ein Dienstleister im Bereich der Alfresco Community Software kann diese Tätigkeit üblicherweise nicht kostenlos anbieten. Oft macht im Vorfeld zusätzlich eine kostenpflichtige 2 bis 5-tägige Proof of Concept Phase gemeinsam mit dem Kunden Sinn.

Nachfolgend möchten wir aufzeigen, bei welchen Anforderungen eine zusätzliche Konzeptionsphase eingeplant werden sollte und welche Implementierungskosten durch die kundenspezifische Erweiterung eines vermeintlich “kostenlosen” Open Source ECM Produktes verursacht werden können.

Wir unterteilen Projektanfragen in die Kategorien klein, mittel, groß.

„klein“
Der Kunde hat sich die Alfresco Community Lösung bereits angeschaut. Die „out of the box“ Funktionalitäten bilden seine Anforderungen an das System ab. Er benötigt noch 1 – 2 Tage Beratung, Schulung oder Anpassung um effektiver mit dem System arbeiten zu können.

–> Kosten ca. 600 bis 1500 Euro netto je nach Umfang

„mittel“
Der Kunde hat sich die Alfresco Community Lösung bereits angeschaut. Die „out of the box“ Funktionalität bildet 80% seiner Anforderungen an das System ab. Er benötigt noch 5 bis 15 Tage Beratung, Schulung und Anpassungen an das System. Auch hier macht die Beauftragung einer eintägigen Konzeptionsphase gemeinsam mit dem Kunden oft Sinn.

Anpassungen könnten sein:

kundenspezifischer einfacher Business Prozess
kundenspezifische Metadaten
Oberflächendesign anpassen
Site Template
einfache Anpassung am Rollen / Rechte Modell

–> Kosten ca. 3200 bis 9600 Euro netto je nach Umfang

„groß“
Umfangreiche Ausschreibungsunterlagen oder Excel Sheets mit nachfolgendem Anforderungspaketen:

Übernahme von bestehenden Daten
Abbildung von kundenspezifischen Business Prozessen
Modellierung eines kundenspezifischen Datenmodel
kundenspezifische Metadaten
erweiterte Suchmöglichkeiten
projektbezogene E-mail Archivierung
Anbindung Fax- und Scannsoftware
Integration von unterschiedlichen Microsoft Office Produkten
CIFS Anbindung
CMIS Integration an andere Systeme
revisionssichere Datenspeicherung
Replikation der Daten über mehrere verteilte Systeme (z.B. Filialen im Ausland, Rechenzentren)
Datensicherung und Restore Möglichkeiten usw.
komplexe Sicherheitsanforderungen

–> Kosten liegen abhängig von Umfang und Projektlaufzeit im fünf- oder sechsstelligen Bereich (siehe Aufstellung unten)

Bei “großen” Projekten werden sehr häufig die Kosten für die Konzeptions- und Implementierungsphase unterschätzt.

Anbei ein Rechenbeispiel für ein Projekt mit 6 Monaten Laufzeit in Anlehnung an die Forrester Studie „The Total Economic Impact Of Alfresco Enterprise Content Management Solution“ um unsere Erfahrungswerte aus Deutschland ergänzt:

Projektlaufzeit	6 Monate
1 interner Projektmitarbeiter	37.500 Euro
2 externe Alfresco Spezialisten (70 Euro/Stunde, 8-Stunden Tag, 110 Tage)	123.200 Euro
Hardwarekosten (Entwicklungs-, Integrations- und Produktivumgebung); Schulungskosten; kleinere Unterstützungen oder Upgrades für zwei Folgejahre	ca. 15.000 bis 20.000 Euro
GESAMTKOSTEN	ca. 180.000 Euro

Zusätzlich zu diesen Kosten wird in der Forrester Analyse ein Enterprise Abonnement mit 24×7 Service in Höhe einer jährlichen Gebühr von ca. 75.000 Euro ($ 100.000) für zwei Folgejahre beziffert.

Welche Vor- / Nachteile und Risiken müssen beim Einsatz der “kostenlosen” Community Software betrachtet werden?

Vorteile:
Einsparungen von ca. 75.000 Euro für Service/Support Gebühren jährlich (in Anlehnung an die Forrester Studie).

Nachteile:

keine Nutzung der Alfresco Enterprise Edition
kein Alfresco Technical Support Services 24/7 für businesskritische Anwendungen
kein Wartungs-Releases, Patches und Hotfixes
keine zugesicherte Qualitätssicherung (QS)-Verfahren
keine Plattform-Unterstützung

weitere Risiken:

der Kunde trägt das Risiko bei Softwarefehlern am Kern der Community Lösung (Hot-Fixes müssen zusätzlich beauftragt werden),
keine vorgefertigten Alfresco Schulungsunterlagen,
keine supported Plattformmatrix
und auch neue Funktionalität die manchmal noch nicht im Enterprise-Stadium getestet ist :) .

Achtung(!): Die o.g. Einsparungen ändern nichts an der Höhe der anfallenden Konzeptions- und Implementierungskosten, diese Aufwände entstehen bei der Enterprise und der Community Lösung gleichermaßen.

Fazit aus unserer Sicht ist:

Bei “kleineren” und “mittleren” Projekten können die Folgekosten beim Einsatz der Alfresco Community Lösung erheblich gesenkt werden. Die Risiken für nicht-business-kritische Projekte sind überschaubar.

Bei “großen” Projekten werden die Folgekosten (Service/Support Gebühren) ebenfalls gesenkt, aber auf die Kosten für die Konzeption und Implementierung hat die Wahl Community oder Enterprise Version keine Auswirkungen. Generell ist bei “großen” ECM Projekten die Aufteilung in kleinere Teilprojekte (auch hinsichtlich der Risiko-Minimierung) sinnvoll.

Bei hochverfügbaren business-kritischen Systemen würden wir unseren Kunden eher zum Einsatz der Enterprise Edition und dem damit verbundenen Enterprise Support raten.

Generic Brute Force SQL-Search – Groovy Style

Andreas Steffan — Mon, 26 Mar 2012 08:36:03 +0000

Assume you are given a rdbms schema you are not familiar with and you are wondering where a piece of information is stored. To me, this happens every now and then. A few days ago, a customer asked me to create a report based on data in his ERP database. Unfortunately it turned out that the schema was hosted in MS SQL Server, fairly big (roughly 100 tables with 30-40 columns on average), and looked meaningless to me (table- and column names). I remembered that ages ago, a colleague mentioned that he had written a tool addressing this kind of developer/admin problem. I never got to see it. Nevertheless, my current requirement made me revisit the idea. I really tried hard finding something ready to download and run – and failed – did not even find something close.

Quick, but not dirty !

To come up with something quickly, I picked Groovy. All of a sudden, an ugly reverse engineering task showed some beautiful aspects. I don’t want to praise the details of Groovy again. It just proved to be AWESOME in this case. Special thanks go to @mrhaki for his inspiring and practical posts. There is a link to the source at the bottom if you are interested. A few final remarks before you blow up your system:


$ ./DBBFSearch.groovy
error: Missing required options: v, U
usage: DBBFSearch -h -u userid -p password -v value -U url -d driver -j
                  jar -f function -m -q -s
 -d,--driver        Driver class
 -f,--function    Column function
 -h,--help                  help
 -j,--jar              Jar file containing driver
 -m,--matches               Show row matches, default is count only
 -p,--password    Password
 -q,--query                 Show SQL query
 -s,--substring             Substring search
 -U,--url              Database URL
 -u,--userid        Userid
 -v,--value          Value to search for

Example:
DBBFSearch -v findme \
-U 'jdbc:mysql://localhost/db?user=user&password=pass' \
-j mysql:mysql-connector-java:5.1.6 -s -f lower
$

What I personally like most is the fact that you can execute it right away.

Here is a quick demo using ~~the customers ERP~~ my Alfresco schema searching for admin.


$ groovy https://raw.github.com/gist/2170917/a4e2af6cee3022b34fe5ec536d2c2b9ed9891c2a/DBBFSearch.groovy \
-v admin -U 'jdbc:mysql://localhost/alfresco?user=alfresco&password=alfresco' \
-j mysql:mysql-connector-java:5.1.6 \
-f lower | grep '\] \['
alf_authority [1] [authority:1]
alf_child_assoc [2] [qname_localname:5]
alf_node [6] [audit_creator:16, audit_modifier:16]
alf_node_properties [1] [string_value:3]
$

The first line of output says the script looked at one column in the table alf_authority and found one row authority matching admin. The other lines have analogous meanings.

Just copying and pasting this commandline should work if you happen to have Groovy (>= 1.8.3 mostly because of the remote script execution) and the “usual developer alfresco database” – Trust me ! ;)

PS: With mysql I was sometimes executing things like


$ mysqldump --skip-extended-insert --user=alfresco \
--password=alfresco alfresco | \
grep www.alfresco.org >/dev/null && echo "strike"
strike
$

Sure, this approach has limitations. But sometimes it helps you getting at least basic information.

PPS: The Alfresco entity relationship diagram from the older post may be helpful if you really try digging in the Alfresco schema.

References:

Doppelte Alfresco Share Benutzer vermeiden

Sandra Martin — Mon, 19 Mar 2012 10:45:02 +0000

Wie oft ist es euch passiert, dass ihr auf einer Share Site über die Funktion “Externe Benutzer hinzufügen” Mitglieder als “neue System Benutzer” eingeladen habt, die bereits im System existieren?
Für ein Kundenprojekt haben wir überlegt, wie wir das Problem doppelte Alfresco Share Benutzer anlegen (innerhalb der Seite “Mitglieder einladen”) mit geringem Aufwand minimieren können.

Folgender Lösungsansatz wurde implementiert:

Bereich 1 “Suche nach Mitarbeitern” (oben links)

die E-Mail Adresse des Benutzers definieren wir für diesen Lösungsansatz als eindeutigen, bekannten Schlüssel
das Feld “Suche” unter Schritte 1 “Suche nach Mitarbeitern” wurde um die Suche nach der E-Mail Adresse erweitert
die Suchergebnisse wurden um die Ausgabe der E-Mail Adresse ergänzt

Bereich “Externe Benutzer hinzufügen” (unten links)

das Feld “E-Mail” wurde als erstes Formularfeld nach oben verschoben
nach Eingabe der E-Mail Adresse und Verlassen des Feldes wird eine Suche nach der E-Mail Adresse angestoßen
bei positivem Suchergebnis geben wir eine Meldung aus, dass der Benutzer bereits im System existiert, der ermittelte Benutzer wird im oberen Bereich “Suche nach Mitarbeitern” als Suchergebnis eingeblendet und kann zum Bereich “Benutzer einladen” hinzugefügt werden
eine doppelte Anlage von Benutzern mit derselben E-Mail wird bei positivem Suchergebnis durch Ausblenden des “Hinzufügen” Buttons im unteren Bereich “Externe Benutzer hinzufügen” unterbunden
bei negativem Suchergebnis kann die Einladung des externen Benutzers wie gewohnt fortgesetzt werden

Anmerkung: Ein 100% Lösungsansatz hätte direkt am Contentmodel erfolgen müssen, wäre aber aufwendiger gewesen und wurde daher verworfen.

Hier eine kurzes Video zur Demonstration unserer Erweiterung:

http://www.youtube.com/watch?v=A7iUpd5vc8A

Wir freuen uns auch diesmal über Fragen, Anregungen, Kritik oder Lob von euch ;)

Extending Alfresco FormService with Optimistic Locking

Andreas Steffan — Tue, 21 Feb 2012 08:05:04 +0000

Optimistic locking is a commonly used concurrency control method for web applications. It is so frequently needed that frameworks such as Grails use it by default. Alfresco FormService does not support it out of the box – and that may cause unexpected results. This post outlines an approach to change the system in order to get something “close to” optimistic locking behavior.

The Default Concurrent Write Situation

Today, I am working on an Alfresco Web Quickstart derived project. A part of the editorial interface is based on Alfresco Share and the editorial process as a whole makes heavy use of the FormService (which is used by the Web Editor as well). I have not used this service extensively in the past, but I was suprised to see that concurrent editing can end up “last writer wins”. A typical sequence of events goes:

You open the editing form for one item two times – using one browser with two tabs will do. You can just as well use two diffrent users or browser sessions.
You subsequently save the forms you just opened.
The second write operation overwrites the changes of the first.

The risk of a conflict depends on the content change frequency, editing process duration and amount of editors working on the content. You may be tempted to address this using versioning, but doing so may open a new can of worms you don’t want. The first thing I thought was that other people should have been faced with this situation before, so I started googling for a solution. I was even more suprised not finding anything really useful and ended up DIY.

I found, that in fact it is quite easy to get a behavior which is not optimistic locking in the very strict sense, but close. Even more important, the system can behave much more expected in the situation of a conflict.

An “Almost” Optimistic Locking Implementation

The following is a rough outline of the solution I came up with (There is a link to the sources below). I have been using it with Alfresco Community 4.0.d.

In the repository, you deploy a filter

which hooks into the form processing. This filter is aware of a special field name prefix _olock_, telling it that a field is meant to be used for version checking. I used cm:modified just because it was here and there and ready to go. In beforePersist the filter checks whether fields matching this prefix have been submitted. If that is the case, it compares the values with current persisted ones. It throws an exception if they don’t match.

To make use of it, you use a special form control template in your form configuration:

The control template is derived from hidden.ftl and the important part is

<#if form.mode == "edit" || form.mode == "create">

With all this in place, the second save operation will (usually) fail showing the following dialog:

Alfresco Share "Optimistic Locking" Failure Dialog

Actually quite funny that Share behaves nice here (with no further customization), presenting us with the failure dialog. :)

Again, this solution may not be beautiful for academic eyes as it is not 100% bullet-proof. Nevertheless, it should handle the real world situation fairly well and it should be almost impossible to create the “accidentally overwritten” situation. In fact, aiming for perfection, I tried making it 100% bullet-proof. At first glance, it seemed LockService provides the functionality needed, but that is not quite the case. What I wanted was “select ... for update” style row level read locking. The code using LockService is still in place and in fact used when the service gets injected.

I still feel like I must have missed something and wonder how other people deal with this situation. To be honest, I think Alfresco should be shipping optimistic locking functionality out of the box. I wonder whether they have something in the making.

Resources:

Download Optimistic Locking Alfresco Forms Service Extension

Individuelle Alfresco Share Gruppen

Sandra Martin — Thu, 02 Feb 2012 08:35:20 +0000

Das Berechtigungsmodell in Alfresco Share lässt bestimmte Szenarien “out of the box” nicht abbilden. Der Manager einer Share Site darf z.B. keine individuellen Gruppen anlegen und deren Mitglieder verwalten.

Sobald eine neue Share Site erstellt wird, legt Alfresco eine sitespezifische Gruppe für die jeweilige Site mit vier Untergruppen an.

Die vier Untergruppen dienen hierbei der Zusammenfassung der Mitglieder entsprechend ihrer Rolle als Contributor, Collaborator, Consumer und Manager. Per Defaultverhalten werden diesen Gruppen die gleichnamigen Berechtigungen Contributor, Collaborator, Consumer und Manager zugewiesen.

DEFAULT:
Gruppe: GROUP_SITE_XYZ_Collaborator
–> Berechtigung: SiteCollaborator

Die Benutzung des Administrationstools zur Gruppenverwaltung (Anlegen/Bearbeiten/Löschen von Gruppen sowie Zuweisen von Mitgliedern) obliegt einem Administrator. Der Manager einer Site kann diese vom Administrator vordefinierten Gruppen auf seine Site einladen. Zum Zeitpunkt der Einladung kann der Manager entscheiden, ob dieser Mitglieder der Gruppe zukünftig als Contributor, Collaborator, Consumer oder Manager Zugriff auf die Inhalte haben.

Das Basiswissen zum “out of the box” Berechtigungsmodell vermittelt nachfolgendes Video (kann von Alfresco “Profis” gerne übersprungen werden):

http://www.youtube.com/watch?v=17CUxw3pR3Q

Alfresco Share Basiswissen: sitespezifische Gruppen / Rollen / Berechtigungen und deren Zusammenspiel

Verwaltung individuellen Share Site Gruppen

Der SiteManager einer Share Site soll die Möglichkeit erhalten, individuelle sitespezifische Gruppen anzulegen und zu verwalten.

Im nachfolgendem Diagramm haben wir versucht diese Erweiterung grafisch darzustellen (Vergrößerung per Mausklick):

Das Berechtigungsmodell wurde wie folgt vorgegeben (wobei die Firmen “abc” und “xyz” für beliebig viele Firmen stehen):

interne Mitarbeiter haben entsprechend ihrer Rolle Zugriff auf alle Projektordner
externe Mitarbeiter der “Firma xyz” haben ausschließlich Zugriff als Collaborator auf Ordner / Dateien der „Firma xyz”
externe Mitarbeiter der “Firma abc” haben ausschließlich Zugriff als Collaborator auf Ordner / Dateien „Firma abc”
externe Mitarbeiter der Firmen “xyz” und “abc” können Ordner / Dokumente der internen Mitarbeiter und der jeweils anderen externen Firmen nicht sehen

In einem früheren Beitrag haben wir bereits einen Prototypen zur Verwaltung von Berechtigungen für einzelne Benutzer vorgestellt. Diese Erweiterung wurde nun entsprechend der oben genannten Anforderungen auf Gruppen ausgeweitet. Zusätzlich wurde der Menüpunkt “Gruppen” unterhalb der Mitgliederverwaltung (Funktionalität für Manager einer Site) durch die neue Funktionalität Gruppen- / Mitgliederverwaltung ersetzt. Natürlich kann man die neue Funktionalität auch ergänzend implementieren.

Unser nachfolgendes Video beschreibt diese Erweiterung an einem Prototypen:

http://www.youtube.com/watch?v=lK6nfN9fWR8

An Alfresco Developer’s Challenge and Journey

Andreas Steffan — Tue, 17 Jan 2012 09:05:16 +0000

Alfresco is a very flexible content-platform in general. It provides mechanisms to customize almost every component (Spring-Bean, Webscript, Templates) shipped with the core product.

Still, sometimes the technical solution does not prove to be even close to what the developer had in mind. This post is about a recent personal challenge and the journey to the solution in an Alfresco Share customization project targeting version 3.4.

Business Requirements

The project consisted of various stories. One was about customization of the Share invitation email with the following requirements:

As a Site-Manager, we want an optional personal message to be included in the invitation-email.
As a Site-Manager, we want to receive invitee read-receipts for invitation-emails
As a Site-Manager, we want the company logo to appear in the invitation email.

The customer was fairly pragmatic – requirements implemented quickly and decently priced being far more important than educational value of the code. Hence, it was ok to apply these customizations on a global level - to all share sites with no further scoping. That all sounded reasonably to me and I was confident to get it implemented “properly”.

The project was of type fixed-scope and fixed-price. A No-Go due to Heisenberg’s uncertainty principle – sure, but there was no way around.

Now, if you are an Alfresco developer reading this, please take a minute virtually outlining your solution and make a rough effort estimation before proceeding with solution journey on the next page. But even if you have no clue what Alfresco is, it might be worth reading further.

Merry Christmas and a Happy New Year!

Sandra Martin — Wed, 21 Dec 2011 11:41:55 +0000

Wir wünsche allen Partnern, Auftraggebern, Followern, Freunden und ihren Familien besinnliche Festtage und ein gutes Ankommen im neuen Jahr!

Andreas & Sandra

Online Reputation – Wie wollen wir wahrgenommen werden?

Sandra Martin — Fri, 09 Dec 2011 09:28:31 +0000

Online Reputation (ORM) ist für uns keine Einzelmaßnahme, sondern eine kontinuierliche Arbeit an unseren Profilen in sozialen Netzwerken, Beiträgen/Kommentaren in Blogs bis hin zum eigenen Webauftritt.

ORM = Unter Online-Reputationsmanagement wird die Überwachung und Beeinflussung des Rufs einer Person, einer Organisation oder eines Produkts in digitalen Medien verstanden. (Wikipedia)

In den letzten Wochen haben wir uns intensiv mit unserem eigenen Webauftritt auseinander gesetzt. Wir wollten unser Tätigkeitsfeld für „Nicht IT‘ler“ verständlicher kommunizieren, denn nicht selten haben wir uns anhören müssen, dass Freunde und Bekannte an Hand unserer Website nicht verstanden, was wir beruflich machen. Das sollte sich ändern.

Wir möchten bei unseren Kunden kostengünstige, leicht verständliche, einfach bedienbare und schnell erweiterbare webbasierte Dokumentenverwaltungs- / Kollaborationssysteme einsetzen. Bei unseren Webprojekten steht ein flexibler und schlanker (agil) Softwareentwicklungsprozess im Vordergrund. Gemeinsam mit unseren Kunden fokussieren wir uns auf die zu erreichenden Ziele und möchten mit geringem bürokratischen Aufwand Projekt erfolgreich abschließen.

Mit unser bisheriger Webauftritt konnten wir dieses offensichtlich nicht vermitteln.

Maßnahmen an unserer Website

Umstrukturierung der Inhalte, aktuelle Beiträge auf der Startseite.
„Technologie“ und „Wir über uns“ wurde unter dem Punkt „Sie benötigen Unterstützung?“ zusammengefasst und durch die Verwendung von Mindmaps (hoffentlich) „leicht verdaulicher“ gemacht.
Unter „Projekte“ haben wir eine chronologische Übersicht (auf Basis des WordPress Plugins Timeline) umgesetzt.
Unser „altes“ WordPress Theme „Oracle“ von ThemeTrust durch ein Freies WordPress Child Theme für Twenty Eleven: Paper (HTML5 / CSS3) ersetzt und durch CSS Anpassungen an unser CD angeglichen.

Das verwendete Theme spiegelt für uns den handwerklichen Teil unserer Arbeit wieder. Wir beginnen bei vielen unserer Projekt mit einem Papier und Bleistift Konzept. Es werden Diagramme gezeichnet, Abläufe skizziert usw. .

Das Child Theme (verantwortlich für das Grundlayout der Website) wird von WP Charity kostenlos zur Verfügung gestellt und kann durch eine Spende an weltweite Hilfsprojekte freiwillig unterstützt werden. Also eine gute Sache!

Durch den Einsatz eines Child Themes auf der Basis von Twenty Eleven sind wir von Weiterentwicklungen durch WordPress am „Eltern“ Theme nicht ausgeschlossen und somit zukunftssicher (soweit man das in unserer Branche sagen kann).

Im letzten Jahr haben wir einige Kundenprojekte unter Verwendung von WordPress kostengünstig umgesetzt und sind von den unzähligen Möglichkeiten der individuellen kundenspezifischen Anpassungen begeistert. Zwei Website Beispiele (neben unserem Auftritt) sind die Sites Saselmädchen und Ingenieurkonzepte.

Ob wir mit den beschriebenen Maßnahmen das Ziel erreicht haben …. wir hoffen es ;)

Quellen: