Category Archives: Blog

Article de blog

19Oct/18

Pourquoi Alfresco abandonne Alfresco Share au profit d’ADF ?

ADF ou Alfresco/Application Development Framework est le nouvel outil d’interface mis à disposition par Alfresco. Il vise, à terme, à remplacer la solution d’interface “Alfresco Share”, actuellement distribuée avec Alfresco, qui est en cours d’abandon. Les cycles de vie des produits Alfresco et Alfresco Share ayant été dissociés, Alfresco Share sera quand même disponible sur les prochaines versions d’Alfresco mais n’évoluera plus.

Alfresco Share est un outil générique de gestion documentaire, avec de nombreuses fonctionnalités pas toujours utiles aux utilisateurs. Il peut être jugé, à raison, complexe et ne facilite pas la conduite du changement. En outre, basé sur des technologies “maison” telles que Surf ou abandonnées telles que Y!UI (Yahoo) et Dojo (un vieux projet IBM), il est difficile de trouver des compétences pour l’adapter.

A la lumière de tous ces éléments, Alfresco a choisi d’adapter sa stratégie et propose ainsi un nouveau framework basé sur Angular, technologie récente, supportée par un géant de l’internet, assurant une disponibilité importante de compétences. En outre, ce framework est constitué d’un ensemble de composants fonctionnels, qu’il est possible d’assembler en fonction des besoins des utilisateurs.

ADF permet de développer des outils qui s’adaptent aux besoins des utilisateurs et non l’inverse. La conduite du changement sera ainsi facilitée.

ADF se base sur le framework Angular 5, qui lui apporte beaucoup de flexibilité au niveau des fonctionnalités ainsi qu’une bonne adaptabilité par rapport au support de visualisation (PC, tablette ou téléphone).

ADF est un projet open-source et profite d’une communauté très active sur internet.

 

06Juil/18

Créons une application métier avec Flowable

1 -Préambule

Flowable est un outil de BPM, acronyme de Business Process Management, c’est à dire la Gestion des Processus Métiers, ce qui parle tout de suite plus 😉
De manière schématique, c’est une palette d’outils destinés à des utilisateurs métier (spécialistes fonctionnels) pour qu’ils décrivent leurs processus métier, qui peuvent être aussi simples et usuels qu’une demande de congés que complexes et uniques comme un diagnostic de panne pour un avion. A partir de la modélisation réalisée, selon les outils, on obtient automatiquement une application de gestion des tâches permettant de saisir des données dans des formulaires pour démarrer un processus, visualiser le processus et son état d’avancement, réaliser une tâche… Des outils complémentaires permettent généralement d’analyser les processus et de produire des statistiques fonctionnelles, techniques, d’exploitation afin de les suivre, les auditer, de mieux comprendre leur fonctionnement et de les optimiser dans une approche itérative d’amélioration progressive continue.

Flowable est un fork d’Activiti et présente le même périmètre fonctionnel que Bonita, Intalio, W4 qui sont ses principaux concurrentes… Les grands éditeurs comme IBM, Microsoft… ont également leur outil.
La quasi-totalité des logiciels qui appartiennent au domaine du BPM travaillent sur le standard de formalisation BPMNv2 (BPM Notation). Ces logiciels permettent de créer, éditer, importer, exporter des processus au format BPMNv2, c’est à dire respectant une notation standardisée permettant d’échanger les éléments entre les outils. Comme nous le verrons, un processus est également constitué de formulaires, tables de décision… qui ne font pas obligatoirement partie de la notation BPMNv2 et qui feront que, dans la pratique, on ne récupère qu’une partie des éléments constituant un projet.

2 -Introduction

Notre objectif est de créer un premier processus de gestion de demande de congés dans le cadre de l’informatisation du périmètre fonctionnel RH. Nous créerons par la suite d’autres processus RH qui viendront s’ajouter à notre bibliothèque.

Les outils de BPM permettent généralement de définir les éléments suivants :

  • Le(s) processus proprement dit permettant d’exprimer la circulation des informations, données et documents ;
  • Le(s) formulaire(s), permettant de saisir et afficher des données, joindre des documents ;
  • La(es) table(s) de décision permettant à partir de critères basées sur des valeurs issues du processus, de formulaires, de référentiels externes de calculer une conclusion….
  • L’application, donnant accès, en fonction de vos droits, aux processus accessibles dans le cadre d’un module ainsi qu’aux tâches à réaliser pour l’utilisateur connecté.

A l’issue de ce tutoriel, vous serez capable de créer un processus et l’utiliser avec d’autres acteurs, indépendamment de tout autre élément logiciel. Un BPM peut généralement fonctionner de manière totalement autonome. Il n’a pas besoin d’une GED par exemple.

Il est cependant clair qu’associé à une GED, un outil de BPM permet de construire une solution très puissante puisqu’on bénéficie alors des fonctionnalités d’indexation, de recherche, de transformation documentaire, de partage particulièrement bien développées dans les GED.

On a bien ainsi :

1 (GED) + 1 (BPM) = 3

Bien sûr, je pars du principe que Flowable est installé et initialisé. L’installation et l’initialisation ont fait l’objet d’un autre tutoriel.

3 -Demande de gestion de congés

3.1 -Analyse

L’analyse consiste à réaliser les étapes suivantes :

  • étude de l’existant
  • rédaction des spécifications
3.1.1 -Existant

J’ai la demande de congés suivante :

Elle est basée sur un fichier Excel et permet simplement de saisir les dates de début/fin et le type de congés souhaité.

Le processus de validation consiste à l’envoyer par mail à l’adresse rh@xxx.com qui s’occupe alors de la traiter et de renvoyer la réponse au demandeur initial.

3.1.2 -Spécifications

La demande de congés est initialisée par le demandeur. L’objectif est de réaliser la gestion de cette demande de manière complètement dématérialisée en la passant d’acteurs en acteurs, chacun réalisant les tâches qui lui incombent à travers une application spécialisée.

Cette approche pilotée par les processus pourrait dans un second temps être rematérialisée afin de faciliter la consultation, le partage, l’archivage…

De manière très succincte :

  • l’initiateur remplit un formulaire de demande ;
  • il saisit son service, les dates de début et de fin, le type de congés… ;
  • lorsqu’il valide sa demande, le responsable destinataire est automatiquement déduit en fonction de son service d’appartenance ;
  • ce responsable approuve ou rejette la demande ;
    • si elle est rejetée, un commentaire doit être ajouté et la demande est renvoyée à l’initiateur qui la corrige ;
    • si elle est approuvée, elle doit passer alors par le responsable RH ;
  • la demande suit alors le même circuit que précédemment :
    • si elle est rejetée, un commentaire doit être ajouté et la demande est renvoyée à l’initiateur qui la corrige ;
    • si elle est approuvée, un mail est envoyé à l’initiateur tandis que le service RH enregistre la demande.
3.1.3 -Roadmap

L’objectif est d’avoir une première version le plus rapidement possible en utilisant les fonctionnalités par défaut de Flowable. Ainsi, la roadmap est la suivante :

  • v1, le processus est piloté par Flowable ;
  • v2, les informations précédemment saisies sont déterminées automatiquement à partir de l’utilisateur et d’un référentiel externe ;
  • v3, le processus est rematérialisé sous la forme d’un document PDF stocké et classé automatiquement dans Alfresco afin de permettre la constitution d’un dossier agent ;
  • v4, le processus peut être piloté par la GED.

3.2 -Réalisation

La réalisation suit les étapes suivantes :

  • Modélisation du processus
  • Définition des formulaires
  • Définition des tables de décisions
  • Finalisation du processus
  • Configuration de l’application
3.2.1 -Modélisation du processus

Nous allons créer plusieurs versions de ce processus dans le cadre d’une suite de tutoriels afin de montrer la démarche de modélisation.

Connectez-vous sur http://localhost:8080/flowable-modeler/ avec un compte utilisateur qui a les privilèges de « modeleurs ».

Cliquez sur Créer un processus et reproduisez le processus suivant :

Rien ne vaut une bonne séance d’essais/erreurs, vous verrez que ça vient vite 😉

Ce travail correspond à une démarche de modélisation et s’appuie sur les étapes suivantes :

  • Circulation de l’information ;
  • Formulaire de saisie des informations ;
  • Tables explicitant les critères de décision et les déductions à faire.
3.2.1.1 -Circulation de l’information

Cette étape de modélisation consiste à dessiner le circuit que l’information doit suivre pour passer d’une étape à l’autre.

Le risque n°1 est de sur-modéliser : tout excité par la possession d’un nouvel outil qui semble vous permettre de tout faire, vous risquez de modéliser des cas qui n’arriveront que rarement. Jouez plutôt la carte de la simplicité en vous concentrant sur les 80 % de fonctions que vous pouvez atteindre avec 20 % de l’effort.

Pensez en outre que si vous êtes dans une démarche de dématérialisation, vous n’avez vraisemblablement rien pour le moment, donc toute réalisation est déjà un plus . Soyez donc raisonnable et ne visez pas trop haut au risque de vous retrouver dans un tunnel très rapidement…

Ceci étant dit, je vous invite à suivre les étapes suivantes :

  • Cliquez sur l’événement de démarrage (start event) et donnez-lui un nom correspondant à sa fonction : Demande initiale de congés
  • Cliquez et déplacez l’événement de fin (end event)
  • Cliquez, déplacez puis déposez les activités correspondantes à des actions faites par les utilisateurs :
    • Validation N+1
    • Correction demande de congés
    • Validation N+2
  • Cliquez, déplacez puis déposez les « exclusive gateways » (pour les conditions) permettant d’avoir une ou plusieurs transitions en sortie d’une activité :
    • Une gateway après Validation N+1
    • Une gateway après Validation N+2
3.2.2 -Formulaires

Cette étape de modélisation consiste à dessiner les formulaires de saisie que les utilisateurs vont devoir remplir en fonction de l’avancement du processus.

On retrouve un formulaire pour l’étape de démarrage ainsi qu’un formulaire pour chaque activité humaine ci-dessus :

  • Un formulaire pour la demande de congés initiale : FORM_CREATION ;
  • Un formulaire pour la validation N+1, permettant de valider la demande par le N+1 en fonction du service d’origine du demandeur. Le formulaire permet de consulter les données saisies précédemment mais pas de les modifier. En revanche, un champ de commentaires est disponible afin de pouvoir indiquer le problème éventuel : FORM_VALIDATION ;
  • Un formulaire pour la correction, permettant à l’initiateur du processus de modifier sa demande. Les champs sont donc à nouveau en écriture mais le champ commentaire saisi par l’approbateur est en lecture seule : FORM_CORRECTION ;
  • Un formulaire pour la validation, permettant de valider la demande par le N+2 en fonction du type de la demande. C’est exactement le même formulaire que pour l’étape de validation N+1.

Comme vous pouvez le constater, les formulaires suivent des conventions de nommage pour faciliter la communication, la maintenance… Il est prépondérant d’être cohérent !

3.2.2.1 -FORM_CREATION

Le champ Direction contient les valeurs suivantes :

  • Commercial
  • Communication
  • Informatique

Le champ Motif contient les valeurs suivantes :

  • Congés payés
  • RTT

Pour les listes déroulantes, le premier élément sera considéré comme neutre (c’est celui qui fera office de titre pour les choix possibles). Veillez donc à ne pas mettre une des valeur de la liste comme un choix possible sous peine de ne pas pourvoir le sélectionner lors du déroulement du processus.

A l’issue de sa demande, l’initiateur peut simplement envoyer sa demande. Seul le bouton « OK » est disponible :

  • Cliquez sur l’onglet Résultats ;
  • Cliquez sur « Utiliser des résultats personnalisés pour ce formulaire » ;
  • Saisissez « OK » ;
  • Ne cliquez pas sur « Ajouter un résultat » mais sur Enregistrer (icône de disquette en haut à gauche… qui ne doit pas beaucoup parler aux jeunes générations 😀 )
3.2.2.2 -FORM_VALIDATION

Pour le formulaire « form_validation », inutile de ré-inventer la roue. Faites simplement une copie de « form_creation ».

Ce formulaire permet de valider la demande. La philosophie est de pouvoir consulter toutes les informations préalablement saisies afin de vérifier la demande tout en empêchant leur modification. Ces informations sont donc en lecture seule.

Un champ Commentaires a été ajouté pour permettre à l’approbateur d’indiquer la raison du refus pour faciliter la correction de la demande par l’initiateur.

En outre, le valideur peut :

  • soit accepter et appuyer sur OK
  • soit refuser la demande et appuyer sur Corriger

Il faut donc créer ces 2 boutons :

  • Cliquez sur l’onglet Résultats ;
  • Cliquez sur « Utiliser des résultats personnalisés pour ce formulaire » ;
  • Saisissez « OK » puis cliquez sur « Ajouter un résultat » ;
  • Saisissez « Corriger » ;
  • Ne cliquez pas sur « Ajouter un résultat » cette fois mais sur Enregistrer.

3.2.2.3 -FORM_CORRECTION

De même pour « form_corection », une copie de « form_validation » vos donnera toutes les bases pour votre nouveau formulaire.
Le champ Commentaires a été saisi par le valideur N+1 pour indiquer la raison de la correction afin que le demandeur puisse modifier sa demande. Le champ Commentaires est en lecture seule.

A l’issue de la correction, seul le bouton « OK » est disponible pour l’initiateur de la demande, n’oubliez pas de l’ajouter !

3.2.3 -Tables de décision

Une table de décision est un outil permettant de formaliser, à partir d’un ou plusieurs critères d’entrée, le ou les résultats souhaités.

Dans notre application de gestion de demande de congés, les tables de décision permettent de :

  • sélectionner le groupe d’approbation N + 1 (par exemple les chefs de service) en fonction du service auquel l’utilisateur appartient pour vérifier que cela ne nuit pas au bon fonctionnement de celui-ci ;
  • sélectionner le groupe d’approbation N + 2 pour valider la demande au niveau RH.

Une bonne pratique consiste généralement à assigner une tâche à un groupe plutôt qu’à un utilisateur afin de faciliter la gestion de l’organisation et pallier aux absences, aux réorganisations, aux départs…

3.2.3.1 -Sélection N+1 en fonction du service du demandeur

Techniquement, cette table de décision sera traduite en une succession de si/alors/sinon successifs :

SI direction est vide

ALORS le groupe d’approbation est la direction RH

SINON SI direction = Commercial

ALORS le groupe d’approbation est la direction Commerciale

SINON SI direction = Communication

ALORS le groupe d’approbation est la direction Communication

SINON SI …

Vous pouvez ajouter de nouveaux critères en fonction des informations saisies au niveau du formulaire ou disponibles à partir de sources externes. Dans ce dernier cas, cela nécessite de pouvoir accéder à un référentiel externe, ce qui dépasse le cadre de ce tutorial et fera l’objet d’un tutorial dans le futur.

Vous pouvez également ajouter un nouveau résultat qui vous permettra de répondre à des situations plus complexes.

3.2.3.1.1 -Ajout d’un nouveau critère

En cliquant sur l’icône représentant un crayon ou sur le bouton Editeur de table de décision, vous accédez à l’écran suivant :

Les colonnes à gauche où apparaissent les conditions sont appelées les colonnes d’entrée. Dans la capture d’écran ci-dessus, la première colonne est une colonne d’entrée.
Les colonnes à droite où apparaissent les résultats (ou les conclusions) sont appelées les colonnes de sortie. Dans la capture d’écran ci-dessus, la colonne de droite est une colonne de sortie.
L’icône située à droite en haut d’une colonne d’entrée permet d’ajouter un critère de condition :

Les informations à saisir sont les suivantes :

  • Libellé de colonne : Nom d’affichage du critère ;
  • Nom de variable : Nom de la variable, généralement issu du formulaire ;
  • Type de variable : Indique si la variable est une chaine de caractères, un nombre, une date, un booléen (oui/non) ;
  • Valeurs autorisée : Liste les valeurs possibles.

L’icône située à droite en haut de la deuxième colonne permet d’ajouter un nouveau résultat (on dit aussi une nouvelle conclusion) :

Les informations à saisir sont les suivantes :

  • Libellé de colonne : Nom d’affichage du critère ;
  • Nom de variable : Nom de la variable, généralement issu du formulaire ;
  • Type de variable : Indique si la variable est une chaîne de caractères, un nombre, une date, un booléen (oui/non) ;
  • Valeurs autorisée : Liste les valeurs possibles.
3.2.3.2 -Sélection N+2, N+3…

On peut facilement imaginer d’autres tables de décision pour exprimer des situations de plus en plus complexes. Attention à ne pas construire d’usine à gaz. En outre, la modélisation peut devenir difficile à maintenir, voir à comprendre.
Restez simple !
Il serait également possible d’imaginer une table de décision unique rassemblant des critères de condition et des résultats multiples. Ces résultats pourraient par la suite être testés sur chaque transition.

3.2.4 -Finalisation de la configuration du processus

Revenez au processus. Il faut finaliser la configuration :

  • associer les formulaires aux activités
  • configurer les conditions sur les transitions
  • configurer les assignations pour indiquer qui doit réaliser chaque tâche. Généralement, l’acteur sera défini via une table de décision.
3.2.4.1 -Association des formulaires

Pour associer un formulaire déjà existant à une activité, effectuez les étapes suivantes :

  • Sélectionner par exemple l’étape de lancement du processus correspondant à l’étape de départ
  • La valeur du champ Form Reference est normalement vide

  • Cliquer sur cette valeur : une fenêtre contenant les formulaires disponibles s’ouvre

  • Sélectionner celui qui vous intéresse puis cliquer sur Sauver
  • Le nom du formulaire correspondant à cette étape apparaît

3.2.4.2 -Configuration des conditions

Dans notre exemple, les conditions servent à contrôler le nom des boutons cliqués sur les formulaires et à suivre les chemins (transitions) correspondants. Ainsi, sans surprise :

SI le bouton cliqué sur formulaire de Création est « Corriger »
ALORS on suit la transition Corriger
SINON on suit la transition par défaut

En fait, la configuration se fait sur chaque transition en exprimant une condition (aussi appelée garde) pour qu’elle se réalise. Pour mettre en place cette approche avec notre outil de BPM, il faut ainsi configurer une condition pour chaque transition. Effectuez les opérations suivantes :

  • Sélectionner par exemple la transition OK à l’issue de l’étape de validation N+1 qui amène sur « Sélection Valideur N+2 »

  • Cocher la boite Default flow : cette transition est la transition par défaut, il n’y a donc pas de condition à configurer dessus ;
  • Sélectionner la transition à l’issue de l’étape de « Validation N+1 » qui amène sur « Notification d’un problème »

  • Cliquer sur Flow condition et saisir la condition « ${form_FORM_VALIDATION_outcome == “Corriger”} »

  • Cliquer sur Sauvegarder
3.2.4.3 -Assignations

Les activités humaines (ou tâches utilisateurs – User task) sont généralement assignées à des groupes, afin de faciliter la réalisation de celles-ci lors de l’absence d’un ou plusieurs acteurs. Ce peut être vu comme une sorte de délégation de fait (dans la réalité, une délégation est plus complexe, basée sur une date de début et de fin…).

Dans notre exemple, les tables de décision permettent de calculer les groupes auxquels seront assignés les tâches de validation N+1 et N+2. Ainsi, comme décrit plus haut, la table de décision Sélection valideur N+1 calcule le groupe auquel sera assigné la tâche de validation N+1 en fonction du service d’appartenance du demandeur. Ce groupe une fois calculé est stocké dans la variable « validator ».

Pour configurer cette assignation, effectuez les assignations suivantes :

  • Sélectionner la tâche

  • Cliquer sur Assignments, en bas de la fenêtre de propriétés
  • Cliquer sur Valeur fixées
  • Cliquer dans Groupes candidats
  • Saisir ${validator}

  • A l’exécution, cette variable sera remplacée par sa valeur correspondant dans notre exemple à la conclusion de la table de décision précédente ;
  • Cliquer sur Sauvegarder.

Cette opération est à répéter également pour le formulaire N+2.

Pour le formulaire Correction demande de congés, il doit être assigné à l’initiateur de la demande :

  • Cliquer sur la tâche Correction demande de congés
  • Cliquer sur Assignments
  • Cliquer sur Identity Store
  • Sélectionner Assigné à l’initiateur de processus

3.2.4.4 -Déploiement de l’application

A chaque fois que vous effectuez quelques étapes de configuration, je vous suggère de les tester en effectuant un déploiement de test de votre processus. En cas d’erreur, vous saurez ainsi que vos dernières étapes de configuration posent problème.

3.2.4.4.1 -Création de l’application

3.2.4.4.2 -Configuration de l’application
  • Cliquer sur l’icône représentant un crayon

  • Saisir le nom, le titre et la description de votre application/module ;
  • Cliquer sur Sauvegarder.

Cliquer ensuite sur

  • Indiquer éventuellement les utilisateurs et les groupes ayant accès à cette application. Attention, il faut indiquer « id » des utilisateurs et des groupes. Si vous n’indiquez rien alors elle sera accessible à tout le monde ;
  • Cliquer sur Editeur les modèles ;
  • Sélectionner les modèles de processus auxquels vos utilisateurs devront pouvoir accéder.
3.2.5 -Applications

Les outils de BPM permettent de générer automatiquement les applications de gestion des processus. Ceux-ci sont généralement rassemblés en modules. Dans le cadre de notre exemple, nous aurons ainsi un module de gestion RH, dans lequel on trouvera la gestion de demande de congés. On peut bien sûr avoir d’autres processus pour ce même module et on peut avoir d’autres modules.

4 -Conclusions

Travailler avec des listes déroulantes dont on rentre les éléments à la main devient vite fastidieux. Dans la vraie vie, on a intérêt à s’interconnecter avec des référentiels externes où ces éléments existent déjà. L’intérêt de pouvoir les insérer à la main est de mettre le doigt là où la valeur ajoutée de votre service informatique ou de votre prestataire sera maximale. En lui demandant de s’interfacer simplement avec votre référentiel, vous décuplerez l’intérêt de votre BPM tout en limitant strictement les manipulations du service informatique à une couche technique : vous gardez totalement le contrôle sur les aspects fonctionnels.

5 -Ressources

https://en.wikipedia.org/wiki/Comparison_of_Business_Process_Modeling_Notation_tools

03Juil/18

Intégrer CMIS avec Ruby

Installation

Pour jouer cette même requête avec ruby, et l’intégrer par exemple dans un développement basé sur RoR, il faut installer une  librairie cmis, par exemple :

  • https://github.com/UP-nxt/cmis-ruby.git

Configuration

Après installation, il faut saisir les informations correspondantes à votre GED, en l’occurrence Alfresco, dans spec/config.yml :

server:
  service_url: http://localhost:8080/alfresco/api/-default-/public/cmis/versions/1.1/browser
  username: admin
  password: admin
repository: -default-

Lancez alors les tests avec la commande suivante :

rake

Récupération d’une liste de documents

Pour vous aider à faire vos premiers pas avec cette librairie, vous pouvez tester le script suivant adapté depuis le readme du projet :

[code language=”ruby”] $LOAD_PATH.unshift ‘lib’
require ‘cmis’

# get the repository object
server = CMIS::Server.new(service_url: ‘http://localhost:8080/alfresco/api/-default-/public/cmis/versions/1.1/browser’,
username: ‘admin’, password: ‘admin’)
repository = server.repository(‘-default-‘)

# query for first 50 documents where the property ‘cmis:name’ is ‘%DAT%’
# and stored in sites/test directory
cmisq = <<eos
select * from cmis:document
where cmis:name like ‘%DAT%’
and contains (‘PATH:\”//app:company_home/st:sites/cm:test//*\”‘)
eos

#query = repository.query(“select * from cmis:document where cmis:name like ‘GED%'”)
query = repository.query(cmisq)

query.each_result(limit: 50) { |document|
puts “-New item ——————————”
puts “Name: ” + document.name
puts “CMIS ObjectId: ” + document.cmis_object_id
puts “Mime-Type: ” + document.content_stream_mime_type
puts “Last Modification Date: ” + document.last_modification_date.to_s
}
[/code]

En exécutant ce code, on obtient la sortie suivante :

Conclusion

Pour étudier les autres possibilités de la librairie, je vous invite à consulter les fichiers de tests dans le répertoire spec/cmis-ruby, et plus particulièrement :

  • document_spec.rb : pour la création/lecture/mise à jour/suppression de document
  • folder_spec.rb : pour la création/lecture/mise à jour/suppression de dossier
01Juil/18

Introduction à CMIS

CMIS est le langage de choix pour requêter une gestion documentaire. En effet, ce langage, proche de SQL, utilise les concepts proches des bases de données. CMIS est un standard mais, bien sûr, chacun a développé un sous-ensemble de fonctions supplémentaires en dehors du standard. Cependant, c’est mieux que rien…

Ainsi, pour récupérer la liste des documents dont le nom contient la chaine DAT et qui sont stockés dans la sous arborescence “sites/test”, il faudra taper la requête suivante :

select * from cmis:document
where cmis:name like '%DAT%'
  and contains ('PATH:"//app:company_home/st:sites/cm:test//*"')

Navigateur de noeuds

Les habitués d’Alfresco auront remarqué que le chemin fait référence à un répertoire stocké dans un site…

Dans mon cas, en tapant la requête dans le navigateur de noeuds d’Alfresco j’obtiens le résultat suivant :

CMIS Workbench

Afin de découvrir Alfresco d’un point de vue CMIS (nom des propriétés notamment), je vous invite à télécharger CMIS Workbench. Il vous permettra de mieux comprendre le fonctionnement de CMIS :

  • Navigation dans le repository et découverte des propriétés CMIS
  • Exécution d’une requête CMIS depuis une fenêtre de console

CMIS Workbench est disponible à l’adresse suivante :

Navigation dans le repository et découverte des propriétés

Exécution d’une requête CMIS

Conclusion

Un standard riche, simple à utiliser de par sa proximité avec le SQL, une fois qu’on a, comme d’habitude, intégré quelques subtilités (notamment les D: et P: pour spécifier les types et aspects… 😉

Bon tests !

18Mai/18

Ouvrez simplement votre entrepôt Alfresco au grand public

Module de consultation externe simplifié par profil

Blue Search

Introduction

BlueSearch est une application de consultation simplifiée qui permet d’effectuer des recherches « à la google » sur un repository Alfresco. Les recherches effectuées sans authentification sont limitées à des documents « publics » et ne ramènent que des documents accessibles par l’utilisateur « public ».

Les recherches peuvent également être réalisées avec authentification ; elles sont alors réalisées sur l’ensemble des documents accessibles par l’utilisateur authentifié.

Suite à la recherche, les résultats peuvent être affinés grâce la sélection de facettes. Les documents peuvent être prévisualisés, téléchargés, étudiés dans le détail et partagés via un lien par mail ou sur les réseaux sociaux quels qu’ils soient (twitter, pinterest, facebook…).

Les principaux écrans de cette application peuvent être facilement personnalisés via des fichiers css directement accessibles par l’administrateur de l’application ou par un prestataire d’une agence de communication.

Application de consultation

Spécifications fonctionnelles

Cas d’utilisation

@TODO

Rôles

L’application est composée de 2 modules :

  1. l’application de consultation simplifiée ;
  2. l’application de configuration.

Elle peut être accédée par 3 rôles :

  • un rôle public : une authentification automatique et transparente est réalisée par l’application. Les utilisateurs n’ont généralement que des droits de lecture, de consultation et de téléchargement ;
  • un rôle authentifié : l’utilisateur s’authentifie à l’aide de son identifiant et de son mot de passe. Il a les droits correspondant à son degré d’habilitation quelle que soit l’application utilisée ; il accède généralement à l’application de consultation simplifiée mais il peut également accéder à l’application Alfresco Share native s’il a besoin de l’ensemble des fonctionnalités disponibles ;
  • un rôle d’administrateur fonctionnel : l’utilisateur s’authentifie à l’aide de son identifiant et de son mot de passe. Il a les droits correspondants à son degré d’habilitation. Il accède à l’application uniquement via Alfreco Share natif.

Plateformes de consultation

Les plateformes de consultation se divisent en :

  • Ordinateurs de bureau ;
  • Tablettes ;
  • Smartphones.

Cette application de consultation a été développée pour les ordinateurs de bureau. Elle peut être consultée sur une tablette et un smartphone mais son ergonomie n’a clairement pas été pensée pour ces derniers.

Il serait intéressant de développer un module pour tablette et smartphone.

Architecture

Diagramme d’architeture

L’architecture de la solution est la suivante :

@TODO

Fonctionnalités techniques

Les fonctionnalités suivantes sont implémentées :

  • Interface d’administration de l’application
  • Authentification automatique
  • Pages personnalisables
    • Pages html statiques
    • Fichiers css statiques
    • Personnalisation des informations à afficher

Interface d’administration de l’application

Une IHM spécifique est disponible. Elle correspond à l’application Alfresco Share native. Elle permet de :

  • créer le compte public
  • modifier les pages personnalisables

Authentification automatique

L’accès à quelque page que ce soit au niveau de l’application Alfresco nécessite obligatoirement une authentification. BlueSearch authentifie automatiquement l’utilisateur sans saisie d’aucun mot de passe. Les documents qui peuvent être recherchés ou accédés sont limités par les droits de l’utilisateur choisi pour l’authentification automatique.

Ce mécanisme pourrait être étendu très simplement afin de s’authentifer avec diffférents utilisateurs selon divers critères (son adresse IP – interne/externe, l’heure, le temps qu’il fait… :-).

Pages personnalisables

L’application peut être personnalisée au niveau des pages html statiques suivantes :

  • formulaire de recherche : construction totale de la page ;
  • mentions légales : construction totale de la page ;
  • contact : construction totale de la page.

L’application peut également être personnalisée au niveau des fichiers css statiques qui permettent d’adapter la présentation des pages dynamiques :

  • home.css : pour personnaliser la présentation globale des pages statiques ;
  • delib.css : pour personnaliser la présentation de la page détail.

Fonctionnalités

L’application est constituée des pages suivantes :

  • Page de recherche à la google
  • Page de liste de résultats
  • Page de recherche avancée
  • Page de détails

Page de recherche à la google

Cette page permet de rechercher le repository à partir d’un ensemble de mots-clés comme sur Google, Bing, Yahoo…

Page de liste de résultats

Cette page s’affiche suite à une recherche « à la google » ou suite à une recherche avancée.

Par défaut, seuls 20 documents sont affichés. Il est possible de « scroller » en bas de page pour afficher 20 nouveaux résultats… Dans la pratique, l’utilisateur sélectionne souvent une facette afin d’affiner sa recherche.

Téléchargement d’un ou plusieurs documents

L’utilisateur peut télécharger un document avec les actions suivantes :

  • Cliquer sur Actions ;
  • Cliquer sur Télécharger.

L’utilisateur peut aussi télécharger un ou plusieurs documents :

  • Sélectionner plusieurs documents ;
  • Cliquer sur Documents sélectionnés ;
  • Cliquer sur Télécharger un .zip.

Navigation par facettes

Sélection de facettes métier

En cliquant sur une facette métier, la liste des résultats s’affine et se met à jour. Il est possible de sélectionner une autre facette ou de désélectionner une facette.

Prévisualisation du document

En cliquant sur l’icône de « document », la page suivante s’affiche :

Page de recherche avancée

Une page de recherche avancée est disponible. Elle permet de sélectionner plusieurs critères en même temps sur un ou plusieurs champs. Elle renvoie sur la liste de résultats ci-dessus.

Page de détails du document

Partage d’un document

Des actions de partage par mail sont disponibles. Elles créent un message en mode édition dans votre outil de messagerie que l’utilisateur peut personnaliser :

Visualisation des métadonnées

Les métadonnées sont présentées à l’utilisateur sur la page de détails. Ces détails peuvent être cachés/affichés via le fichier css personnalisable delib.css.

Conclusion

BlueSearch permet de valoriser très simplement le contenu public d’un repository Alfresco et d’augmenter très simple votre retour sur investissement.

Pour voir le système en production, je vous invite à consulter le site public suivant :

11Mai/18

Découverte de l’interface ADF pour ECM Alfresco

Etude de faisabilité ADF pour outils Alfresco

Qu’est ce qu’ADF ?

ADF ou Application Development Framework est le nouvel outil d’interface mis à disposition par Alfresco. Il vise, à terme, à remplacer la solution d’interface “Share” qui est actuellement utilisée. Le projet est open-source et profite déjà d’une communauté assez active sur internet.

ADF se base sur le framework Angular 5, ce qui lui apporte beaucoup de flexibilité au niveau des fonctionnalités ainsi qu’une bonne adaptabilité par rapport au support de visualisation (PC, tablette ou téléphone).

La force d’ADF réside également dans son côté customisable : la plupart des fonctionnalités de “Share” peuvent être déployées dans ADF, c’est l’utilisateur qui décide ou non de les faire incorporer par le développeur. On se retrouve donc avec un outil unique, s’adaptant au mieux aux besoins spécifiques de chacun.

L’interface ADF s’adapte aussi bien à la gestion de fichiers avec l’ECM d’Alfresco, qu’à la gestion de processus avec l’outil de BPM Activiti.

ADF pour la gestion de contenu numérique

Comme pour l’interface “Share” classique, l’accès aux fonctionnalités de l’application n’est possible qu’après la connexion de l’utilisateur.

La page de connexion

Une fois connecté l’utilisateur est automatiquement redirigé vers l’explorateur de fichiers. La gestion des droits étant prise en compte, il n’aura accès qu’aux répertoires auxquels il est autorisé. Depuis cette interface il pourra également créer un nouveau répertoire ou ajouter un fichier (via un bouton ou en drag’n’drop). Une fonctionnalité de recherche est également présente pour retrouver plus rapidement un document particulier.

L’explorateur de fichiers

Quand l’utilisateur arrive sur le document qui l’intéresse, un volet d’options lui offre l’accès à plusieurs actions : copier le document, le télécharger, le déplacer, le supprimer ou encore voir les différentes versions de ce document. Cette liste n’est pas exhaustive, d’autres actions sont à disposition mais n’ont pas été mise en place dans notre monture de test (le partage du document vers l’extérieur notamment).

L’onglet détails permet d’afficher toutes les actions relatives au document : la visualisation, l’affichage et l’édition des métadonnées ainsi que les différentes versions de ce document.

Les options disponibles pour un fichier

 

La visionneuse de documents

 

Options d’édition des métadonnées

 

Encore une fois les fonctionnalités présentées ici ne représentent pas la totalité des possibilités offertes par ADF.

Le versioning est pris en charge par ADF

 

 

 

Ressentis

L’application ADF offre vraiment énormément de possibilités que ce soit pour Alfresco ou Activiti. Les modules node mis à disposition pour les équipes de développeur Alfresco sont très complets et des documentations détaillées sont accessibles sur le GitHub du projet. La création de sa propre application avec les modules qui nous sont utiles est assez simple, même si des connaissances de base en Angular sont les bienvenues.

 

Cela conclu le premier billet de blog dédié à ADF, traitant de l’aspect ECM. Un autre article arrive prochainement, qui exposera les possibilités qu’offre ADF pour l’outil de BPM Activiti.

24Avr/18

Hot Reloading en Alfresco avec HotswapAgent

Pour développer en Java sur Alfresco, il faut absolument mettre en place une solution de hot reloading, car le temps de redémarrage du serveur de la plateforme est bien trop long pour pouvoir tester facilement les changements au code. Cela concerne aussi le développement de scripts serveur en JavaScript qui sont exécutés par le moteur Rhino : il n’est pas normal pour un dev JavaScript de devoir attendre quelques minutes avant de tester une petite modification du code.

Alfresco propose deux solutions : JRebel (payante) et HotswapAgent (open source). Pour l’instant j’ai choisi de ne pas investir dans JRebel et de bien tester son concurrent gratuit pour voir s’il suffit. Alfresco nous donne un tutoriel officiel pour l’utiliser, mais il manque quelque passage (notamment l’utilisation dans Eclipse qu’on ne trouve que pour JRebel), donc je vais refaire le tour pour arriver a un petit projet basé sur l’archétype Maven et le code démo qu’il contient.

La liste de courses

Nous allons utiliser un correctif pour la machine virtuelle Java (ne paniquez pas, il s’installe à côté, sans modifier la VM originale). Téléchargez donc la version pour Java 8 de DCEVM (version 8u152 à l’heure).

Bien évidemment, il faut avoir exactement la même version de Java, donc si vous utilisez une version différente, allez fouiller dans l’archive Oracle pour trouver la bonne.

Enfin, le vrai HotswapAgent. Inutile de télécharger la version la plus récente : pour Alfresco il faut utiliser la 1.0.

Voici un résumé des fichiers que j’ai utilisés dans Linux :

L’installation

Après avoir installé le JDK (pas besoin de l’installer en tant que administrateur), appliquez le correctif en utilisant cette commande :

$ java -jar DCEVM-8u152-installer.jar

En Windows on peut aussi taper deux fois sur DCEVM-8u152-installer.

Il s’agit d’un installateur qui vous donne une interface utilisateur assez simple :

Ajoutez la VM que vous venez d’installer et après tapez sur Install DCEVM as altjvm :

Quant au JAR du HotswapAgent, il faut tout simplement le mettre quelque part et se souvenir de son parcours.

Creation d’un projet

Créez un projet Maven comme indiqué dans la documentation Alfresco :

mvn archetype:generate -Dfilter=org.alfresco:

Choisissez l’archétype « All-in-One » et configurez les paramètres comme vous voulez.

Configuration d’Eclipse

Après avoir rajouté le JDK installé à la liste des JREs disponibles dans Eclipse (Window > Preferences > Java > Installed JREs), importez le projet (la documentation officielle explique comment faire et vous l’avez déjà fait plusieurs fois, donc je vous évite les détails).

Exécution du projet en mode hot reloading

Enfin, vous êtes prêts à créer une configuration pour exécuter le code. Dans les configurations de debug, créez-en une nouvelle de type Maven. Les paramètres à définir sont :

  • Base directory ${project_loc}
  • Goals clean install alfresco:run
  • Dans l’onglet JRE, sélectionnez le JRE avec le correctif DCEVM
  • VM arguments -Xms256m -Xmx2G -javaagent:/<parcours du HotswapAgent>/hotswap-agent-1.0.jar -XXaltjvm=dcevm

(Je vous conseille aussi de sélectionner Skip Tests, parce que la VM Hotswap est plus lente, donc c’est mieux de vérifier les tests séparément.)

Cette configuration peut être exécuté en mode DEBUG. Il faudra attendre un peu plus que d’habitude avant de pouvoir se connecter à Alfresco, mais il vaut le coup.

Cela donne quoi ?

Nous allons faire le test proposé par Alfresco dans le tutoriel JRebel : en se connectant à http://localhost:8080/alfresco/s/sample/helloworld, ou ici ;  le résultat sera Message: ‘Hello from JS!’ ‘HelloFromJava’

Sans arrêter le processus de debug, nous allons modifier ce message qui est généré par trois fichiers du projet platform-jar (on peut les ouvrir en tapant Ctrl+R et helloworld) : helloworld.get.js, helloworld.get.html.ftl et HelloWorldWebScript.java. Habituellement, un changement à chacun de ces fichiers entraine un redémarrage du projet.

Allons donc changer les messages :

  • dans helloworld.get.js remplacez model["fromJS"] = "Hello from JS!"; avec model["fromJS"] = "Bonjour de JS !";
  • dans helloworld.get.html.ftl remplacez Message: '${fromJS}' '${fromJava}' avec Messages : '${fromJS}' et '${fromJava}'
  • dans HelloWorldWebScript.java remplacez model.put("fromJava", "HelloFromJava"); avec model.put("fromJava", "Bonjour de Java");

À noter que chaque fois que vous tapez Ctrl+S, les changements sont pris en charge à l’instant et le log vous en donne confirmation. Un coup de F5 dans Firefox vous donne le nouveau message qui arrive des trois fichiers modifiés : pour l’instant rien à envier à JRebel.

Conclusion

Je trouve encore plus intéressante de pouvoir exécuter mes tests d’intégration en mode debug hot reloading, ce qui donne la possibilité de redémarrer à la volée une méthode qu’on vient de changer. Cela sera peut-être le sujet d’une autre article si cela vous intéresse.

02Mar/18

Conteneur Docker Alfresco avec SSL

Ceci est une petite note concernant la génération de conteneur Docker Alfresco. Pour d’autres logiciels, possédant par exemple des ports particuliers il conviendra d’adapter ces informations.
Afin d’utiliser un conteneur Alfresco en HTTPS, voici la configuration à passer à la commande “docker run” :

#!/bin/sh
docker run -it -d -v /data/mvico:/opt/alfresco/alf_data \
-e VIRTUAL_PROTO=https \
-e VIRTUAL_PORT=8443 \
-e VIRTUAL_HOST=mvico.docker.bluexml.com \
-e INITIAL_PASS=mvicoforever \
-e ALF_1=smart.folders.enabled.EQ.true \
-e ALF_2=alfresco.host.EQ.mvico.docker.bluexml.com \
-e ALF_3=alfresco.port.EQ.443 \
-e ALF_4=alfresco.protocol.EQ.https \
-e ALF_5=share.host.EQ.mvico.docker.bluexml.com \
-e ALF_6=share.port.EQ.443 \
-e ALF_7=share.protocol.EQ.https \
–name mvico-522 mvico-522:$BUILD_NUMBER

Note 1 : Les variables VIRTUAL_XXX servent à la configuration du vhost générée automatiquement par le proxy NGINX lors de chaque nouveau “run” de conteneur.
Voir conteneur NGINX proxy utilisé ici
Note 2 : Les variables ALF_XXX servent à la configuration du fichier “alfresco-global.properties” en accord avec le travail de Philippe Dubois (d’où le travail sur le changement de numéro de port)
Note 3 :  “.EQ.” signifie “=“. La substitution est effectuée pas NGINX lors de la génération du vhost.

Attention, dans Jenkins, onglet build du projet en question, par défaut il est nécessaire de mettre toute la commande sur un ligne; je vous l’accorde ce n’est pas hyper pratique ni lisible. L’éditeur ne gérant pas les sauts de ligne dans la commande. Il y a possibilité de scinder la commande en ajoutant “#!/bin/sh” au début du script et en ajoutant ” \” à chaque fin de ligne où la commande se poursuit. Ceci force l’outil d’intégration continue à exécuter la commande comme dans un script shell.

J’ajouterais enfin que pour l’édition en ligne, ne pas oublier d’ajouter la propriété aos.baseUrlOverwrite (pour cet exemple) (et en remplaçant le “=” par “.EQ.” bien sûr 😉 ). Sans cela Alfresco insérera le port 8443 dans l’URL AOS et le document ne sera pas ouvert par Office.

Je terminerais en précisant s’il est nécessaire que dans cette installation, et vous l’aurez sans doute compris, nous avons plusieurs conteneurs Docker qui interagissent : celui d’Alfresco et ceux d’NGINX.

Hope this helps.

16Fév/18

Génération d’un paquet SIP conforme au format SEDA 2.0

Introduction

Le projet VITAM propose des outils pour générer des SIP conformes au format SEDA 2.0 à partir d’une arborescence de fichiers.

Si cette fonctionnalité est disponible sur Windows et Linux, il est nécessaire de faire quelques adaptations pour MacOSX.

Adaptations

Installation de siegfried

Le générateur SEDA de VITAM utilise l’application siegfried pour détecter les formats des fichiers à intégrer. Pour cela, il suffit d’installer cette application à l’aide de brew :

brew install siegfried

Modification de run_generate.sh

Vous tentez alors de générer le paquet SIP :

sh run_generate.sh monrepertoire

Il est possible que vous obteniez le message d’erreur suivant :

jck$ > sh run_generator.sh conf
 run_generator.sh: line 4: realpath: command not found
 The given path must be a directory (not a single file):

Pour résoudre ce problème, vous devez installer coreutils :

brew install coreutils

Les outils ainsi fournis sont stockés, pour mon installation, dans le répertoire /usr/local/opt/coreutils/libexec/gnubin. Du coup, il faut modifier run_generator.sh pour lui donner cette information (ligne 4) :

#!/bin/sh
SCRIPT_DIR=$(dirname $0)
if [ "x$1" != "x" ];then
 TARGET_DIR=$(/usr/local/opt/coreutils/libexec/gnubin/realpath "$1")
fi
java -classpath "$SCRIPT_DIR/conf:$SCRIPT_DIR/lib/*" -Dvitam.config.folder=/tmp -Dvitam.tmp.folder=/tmp -Dvitam.data.folder=/tmp -Dvitam.log.folder=/tmp fr.gouv.vitam.generator.scanner.main.SedaGenerator "$SCRIPT_DIR" "$TARGET_DIR"

Utilisation

Il suffit alors de relancer le script run_generator.sh sur le répertoire de votre choix. Et ça marche !

jck$ > sh run_generator.sh monrepertoire
2018-02-16 16:01:25,987 [main] INFO f.g.v.g.scanner.main.SedaGenerator : Generateur SEDA : Beginning of scan of directory /Users/bxml/Documents/opt/local/new-workspaces/vitam/seda/generateur-seda_0.16.0/monrepertoire 
2018-02-16 16:01:26,951 [main] INFO f.g.v.generator.scanner.core.ScanFS : Managing BinaryDataObjects : 455 ms for 3 BinaryDataObjects (time per BDO : 151 ms) 
2018-02-16 16:01:27,085 [main] INFO f.g.v.generator.scanner.core.ScanFS : Writing ArchiveUnits : 127 ms for 5 ArchiveUnits (time per AU : 25 ms) 
2018-02-16 16:01:27,366 [main] INFO f.g.v.g.scanner.main.SedaGenerator : Generateur SEDA : End of scan of directory /Users/bxml/Documents/opt/local/new-workspaces/vitam/seda/generateur-seda_0.16.0/monrepertoire in 1380 ms

Conclusion

Merci Vitam 🙂

18Jan/18
Blog

Présentation de l’outil Alfresco Bulk Export

Alfresco Bulk Export Tool.

Vijay Prince a présenté l’outil Alfresco Bulk Export Tool à la Devcon Alfresco et comment l’utiliser et gérer les exports de données pendant les migrations.
Plusieurs fonctionnalités ont été ajoutées à l’outil afin de rendre son usage plus simple :
[list style=”list12″ color:”#6699ff”]

  • Une interface utilisateur pour superviser l’export et utiliser l’outil
  • Vous pouvez à présent démarrer, stopper et redémarrer l’export via l’interface
  • Vous pouvez choisir une période d’export
  • Vous pouvez ajouter des aspects et des propriétés aux données exportées
  • Vous pouvez mettre à jour les types, les aspects et les propriétés
  • Vous pouvez mettre à jour le préfix du modèle
[/list] L’interface n’est pas très belle mais efficace :

Si vous souhaitez plus d’informations sur ce projet