OPAL (OpenOffice Plug-in for ALfresco) pour Alfresco 3.4 maintenant disponible

OPAL, le plugin permettant d’ouvrir et de modifier des fichiers OpenOffice/LibreOffice placés sur un serveur Alfresco, bénéficie d’une nouvelle version, compatible avec Alfresco 3.4, OpenOffice 3.3 et LibreOffice.

OPAL 3.3.1 apporte également des corrections, notamment concernant la modification des méta-données des documents depuis la suite bureautique. Cette nouvelle version corrige aussi la modification des type-mime des fichiers qui posaient des problèmes pour la prévisualisation des fichiers dans Share.

La fonction d’enregistrement des fichiers a été simplifiée afin de proposer un fonctionnement intuitif pour l’utilisateur, en reprenant la logique des fonctions d’enregistrement et de fermeture de document du menu Fichier standard d’OpenOffice.org/LibreOffice.

Ainsi lorsque l’utilisateur utilise la fonction « Enregistrer » du menu OPAL, la copie de travail est mise à jour sur le serveur sans poser de question (pas de création de nouvelle version à cette étape). La copie de travail n’est réintégrée dans le document sur le serveur que lors de la fermeture du document. Une nouvelle version du document sera créée à la fermeture du document seulement.

En savoir plus :

Télécharger OPAL pour :

Alfresco Share : architecture pour créer un nouveau module

Nous avons récemment annoncé la création d’ASUR, le nouveau module d’audit pour Alfresco Share. Aujourd’hui, nous allons examiner la première étape de la création d’un nouveau module Share, à savoir le squelette pour projet Ant Eclipse.

Pour créer un module pour Share il faut mettre en place l’arborescence suivante :

Nous allons maintenant détailler le contenu des fichiers décrits ci-dessus.

build.xml

<?xml version="1.0"?>

<project name="Module Share" default="package-amp" basedir=".">
	<property name="project.dir" value="."/>
	<property file="${project.dir}/build.properties"/>
	<property file="${project.dir}/module.properties"/>
	<property name="build.dir" value="${project.dir}/build"/>
	<property name="config.dir" value="${project.dir}/config"/>
	<property name="jar.file" value="${build.dir}/lib/${module.id}.jar"/>
	<property name="amp.file" value="${build.dir}/dist/${module.id}.amp"/>
	<path id="class.path">
		<dirset dir="${build.dir}" />
		<fileset dir="${project.dir}/lib" includes="**/*.jar" />
		<fileset dir="${alfresco.sdk.dir}/lib/server" includes="**/*.jar" />
	</path>
	<target name="mkdirs">
		<mkdir dir="${build.dir}/dist" />
		<mkdir dir="${build.dir}/lib" />
		<mkdir dir="${build.dir}/classes" />
	</target>
	<target name="clean" description="Clean the build results">
		<delete dir="${build.dir}" />
	</target>

	<target name="compile" depends="mkdirs">
		<javac classpathref="class.path" debug="${debug}"
			srcdir="${project.dir}/source/java"
			destdir="${build.dir}/classes" encoding="UTF-8" >
			<compilerarg value="-Xlint:unchecked"/>
		</javac>
		<copy todir="${build.dir}/classes">
			<fileset dir="${project.dir}/source/java" defaultexcludes="false">
				<exclude name="**/*.java"/>
				<exclude name="**/.svn/**"/>
			</fileset>
		</copy>
	</target>

	<target name="package-jar" depends="compile">
		<jar destfile="${jar.file}" encoding="UTF-8" >
			<fileset dir="${build.dir}/classes"
				excludes="**/custom*,**/*Test*"
				defaultexcludes="false" />
		</jar>
	</target>

	<target name="package-amp" depends="package-jar" description="Package the Module">
		<zip destfile="${amp.file}" encoding="UTF-8" >
			<fileset dir="${project.dir}/build" includes="lib/*.jar" />
			<fileset dir="${project.dir}" includes="config/**/*.*" excludes="**/module.properties" />
			<fileset dir="${project.dir}">
				<include name="module.properties"/>
				<include name="file-mapping.properties" />
				<include name="WEB-INF/**/*" />
				<include name="lib/**/*" />
				<exclude name="WEB-INF/alfresco.tld"/>
				<exclude name="WEB-INF/repo.tld"/>
			</fileset>
			<zipfileset dir="source/web" prefix="web"/>
		</zip>
	</target>
</project>

build.properties

alfresco.sdk.dir = /path/to/sdk

file-mapping.properties

# Mappings des dossiers entre le module AMP et fichier WAR
#
# La propriété suivante peut être utilisée pour inclure l'ensemble des mappings standards.
# La valeur par défaut est «vrai », c'est à dire les mapping par défaut seront augmentés ou modifiés
# par les valeurs de ce fichier.
#
include.default=true
#
# Mappings personnalisés. Si 'include.default' est false, alors then ceci est l'ensemble complet.
#
/web/components=/components

module.properties

# Module Share

module.id=Module_Share
module.title=Module Share
module.description=Module for the application Share
module.version=1.0

Comment effectuer un audit avec Alfresco 3.4 ?

Il y a bien des cas où il est utile de savoir quelles personnes ont pris connaissent d’un document. C’est pourquoi Alfresco comporte une fonction d’audit. Avec la version 3.4 d’Alfresco apparaît une nouvelle façon d’effectuer un audit. Si cette nouvelle méthode présente des avantages par rapport à l’ancienne, elle n’est pas sans impact sur l’historique des données héritées des anciennes versions d’Alfresco. Cet article se propose d’expliquer en quoi il est intéressant d’effectuer un audit, les différences notoires entre l’audit sous Alfresco 3.4 et les versions précédentes et enfin la manière d’exécuter un audit Alfresco.

Qu’est-ce que l’audit Alfresco ?

Mettre en place un audit sur une application permet d’en tirer des statistiques. Les données qui peuvent être auditées sont par exemple :

  • le nombre de connections à la journée, au mois, à l’année sur une période donnée.
  • le nombre de documents lus / modifiés / supprimés / ajoutés en une journée, un mois, une année, sur une période donnée.

Pour chacune des données auditées il peut être intéressant de croiser ces informations avec d’autres données afin d’obtenir des statistiques plus précises comme par exemple :

  • le nombre de connections à la journée, au mois, à l’année sur une période donnée pour un utilisateur particulier.
  • le nombre de documents lus / modifiés / supprimés / ajoutés en une journée, un mois, une année sur une période donnée par un utilisateur particulier.
  • le nombre de fois qu’un document spécifique a été lu / modifié par tel utilisateur.

Pour mettre en place un audit il faut obligatoirement définir une période d’audit, c’est à dire les dates qui vont définir les bornes de l’audit. Toutes les autres informations facultatives qui peuvent être définies pour l’audit permettent d’effectuer des statistiques suivant un contexte particulier (pour un utilisateur donné, pour un document donné, …).

Principe de l’audit avec Alfresco 3.4

Avec la version 3.4 d’Alfresco le système d’audit a changé. Il faut maintenant définir dans un fichier xml les actions que l’on souhaite auditer (connexions, lecture, …). De plus, un webscript permet maintenant de récupérer les résultats de l’audit au format JSON (un fichier JSON est un fichier texte qui permet de représenter de l’information structurée). Ce fichier doit ensuite être exploité par un autre langage (page php, html, …) pour extraire des résultats sous la forme d’un graphique, par exemple, car il n’existe pour l’instant pas d’interface permettant de lire les résultats de l’audit.

Dans le fichier xml il faut définir :

  • la méthode à auditer
  • les éléments à enregistrer au moment de l’exécution de l’action
  • les éléments à retourner lors de l’audit

Le webscript créé par Alfresco doit être appelé par l’url : http://<serveur-alfresco>:<port>/alfresco/service/api/audit/query/<applicationName>

  • <serveur-alfresco> : nom du serveur sur lequel est installé alfresco
  • <port> : port utilisé pour accéder à l’application
  • <applicationName> : nom de l’action auditée défini dans le fichier xml

Différences avec l’ancienne méthode d’audit

Pour mettre en place un audit en version 3.4, il n’est plus nécessaire de requêter la base de données directement. Cela présente l’avantage d’être indépendant par rapport aux couches basses du code, aussi l’audit continuera à fonctionner même si ces couches sont modifiées. Pour ajouter de nouvelles données dans les tables d’audit il suffit de configurer les fichiers xml, ce qui est plus simple et plus rapide qu’avec l’ancienne méthode, et ne nécessite plus d’avoir des connaissances en Hibernate.

Les tables utilisées pour l’audit ont changé et les anciennes tables d’audit ont été supprimées. Cela implique que les données auditées en version inférieure ne pourront pas être récupérées. Toutes les requêtes SQL utilisées dans l’ancien audit devront être remplacées par des appels à l’API fournis à travers les fichiers de configuration XML.

Exemple : Audit des connections

Pour mieux comprendre le fonctionnement de l’audit voici un petit exemple qui nous permettra d’auditer les connections à l’application.

Fichier xml : audit-authenticate.xml

<Audit xmlns="http://www.alfresco.org/repo/audit/model/3.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.alfresco.org/repo/audit/model/3.2 alfresco-audit-3.2.xsd" >
    <DataExtractors>
        <DataExtractor name="simpleValue" registeredName="auditModel.extractor.simpleValue"/>
    </DataExtractors>
    <DataGenerators>
        <DataGenerator name="personFullName" registeredName="auditModel.generator.personFullName"/>
    </DataGenerators>
    <PathMappings>
        <PathMap source="/alfresco-api/post/AuthenticationService/authenticate" target="/auditExempleLogin/login"/>
    </PathMappings>
    <Application name="AuditExempleLogin" key="auditExempleLogin">
        <AuditPath key="login">
            <AuditPath key="args">
                <AuditPath key="userName">
                    <RecordValue key="userName" dataExtractor="simpleValue" />
                </AuditPath>
            </AuditPath>
            <AuditPath key="no-error">
                <GenerateValue key="fullName" dataGenerator="personFullName"/>
            </AuditPath>
        </AuditPath>
    </Application>
</Audit>

On choisit ici d’auditer la méthode d’authentification qui est définit dans la partie <PathMappings>. La partie <Application> permet de définir quels éléments seront audités. Dans cet exemple on veut connaître le login de la personne qui se connecte ainsi que les propriétés Nom et Prénom.

Un dataExtractor est un composant qui utilise les données d’entrée pour produire une sortie. L’extracteur le plus simple est le SimpleValueDataExtractor, qui retourne toutes les données transmises. Pour connaître le login on récupère l’argument username par la méthode authenticate grâce au dataExtractor simpleValue. Il est possible de créer ses propres extracteurs en développant une nouvelle classe qui étendra la classe AbstractDataExtractor.

Un dataGenerator est un composant qui produit des données sans entrée. Les exemples de générateurs sont les classes :

  • AuthenticatedUserDataGenerator qui produit le nom de l’utilisateur couramment authentifié
  • AuthenticatedPersonDataGenerator qui produit le nom complet de l’utilisateur actuellement authentifié

Pour retourner les propriétés Nom et Prénom on utilise le dataGenerator personFullName qui correspond à la classe AuthenticatedPersonDataGenerator. Tout comme les extracteurs il est possible de créer de nouveaux générateurs en développant une nouvelle classe qui étendra la classe AbstractDataGenerator.

Appel de l’audit

En exécutant le webscript correspondant à l’url http://<serveur-alfresco>:<port>/alfresco/service/api/audit/query/AuditExempleLogin?verbose=true on obtient un fichier JSON qui nous retourne les éléments suivants :

{
   "count":2,
   "entries":
   [
      {
         "id":1,
         "application":AuditExempleLogin,
         "user":admin,
         "time":"2011-02-24T14:30:36.698+01:00",
         "values":
         {
                     "/auditExempleLogin/login/no-error/fullName":"Administrator"
                     ,"/auditExempleLogin/login/args/userName/userName":"admin"
         }
      },
      {
         "id":2,
         "application":AuditExempleLogin,
         "user":cpiassale,
         "time":"2011-02-24T14:31:33.455+01:00",
         "values":
         {
                     "/auditExempleLogin/login/no-error/fullName":"Cindy PIASSALE"
                     ,"/auditExempleLogin/login/args/userName/userName":"cpiassale"
         }
      }
   ]
}

Dans cet exemple on peut voir qu’il y a eu deux personnes qui se sont connectées : admin et cpiassale. Dans la liste « values » on retrouve les éléments que l’on souhaitait connaître par le biais de l’audit :

  • « /auditExempleLogin/login/no-error/fullName » : nom et prénom de l’utilisateur connecté
  • « /auditExempleLogin/login/args/userName/userName » : login de la personne qui a déclenché la méthode d’authentification

Il existe un certain nombre de dataExtractor et de dataGenerator par défaut. Dans le cas où l’on souhaite auditer ses propres services et méthodes il est possible de développer de nouveaux dataExtractor ou dataGenerator pour récupérer les données recherchées.

Opal 3.1.4 est disponible

Opal (OpenOffice Plugin pour ALfresco), l’extension développée par StarXpert pour permettre d’accéder à Alfresco depuis l’interface OpenOffice ou vice versa, est maintenant disponible en version 3.1.4. La dernière version d’Opal organise les espaces et documents par ordre alphabétique depuis la boîte de dialogue d’ouverture, ne crée plus de nouvelle version d’un document si aucun changement n’a été effectué et corrige un bug d’ouverture des fichiers contenant « :// »

Opal est disponible sur la forge Alfresco.

Alfresco Share, l’outil collaboratif indispensable pour mener à bien un projet

Un des principaux intérêts d’un outil collaboratif est de faciliter et d’enregistrer les échanges entre les utilisateurs. Pour cela il doit s’inscrire dans les usages et permettre au flot de communication de s’effectuer de façon naturelle. En créant un site Alfresco Share par projet, les utilisateurs abonnés à ce projet peuvent échanger par le biais des discussions, organiser des réunions grâce au calendrier, publier des informations sur le blog ou le wiki, déposer des documents, effectuer des recherches. Une fois le projet achevé, le site Share est supprimé puisque n’ayant plus lieu d’être, tandis que les documents importants (livrables, etc) sont archivés dans l’espace Alfresco pour référence ultérieure.

Cette utilisation d’Alfresco est possible depuis la version 3.2r, laquelle permet d’accéder à Alfresco et Alfresco Share à partir d’une seule et même interface.

Editer les documents Alfresco avec Google Docs

Afresco 3.3 permettra d’éditer les documents contenus dans Alfresco grâce à Google Docs, évitant aux utilisateurs d’avoir à télécharger le document sur leur bureau. Cette option sera disponible dans Share.

Une démonstration est disponible à l’adresse suivante