Pour que les entités du modèle de données du paragraphe soient prises en compte et gérées sous forme de contenus dans Alfresco, il faut décrire ces entités à l'aide du dictionnaire de donnéee Alfresco.

Le dictionnaire de données Alfresco est un ensemble de modèles de base (appelés modèles M1) qui permettent de décrire la structure des contenus à traiter.
Un modèle M1 contient la définition des types primitifs comme 'Double', 'Float', 'Integer' etc., ou des types complexes comme le type 'content' (type contenu pour contenir l'information sous forme binaire), 'folder' (pour les dossiers), 'person' (pour les personnes), etc.

Il existe plusieurs fichiers XML constituant le modèle M1. On peut citer:

-  dictionaryModel.xml (types primitifs)
-  contentModel.xml (types complexes)

Pour avoir une vue plus complète sur le Dictionnaire de données d'Alfresco, le Centre de Compétences Alfresco-jBPM de Koossery TechnologyKoossery Technology conseille la documentation ci-dessous:

Les entités de notre projet vont être décrites sous forme de contenus dans un nouveau modèle dit modèle M2. Ce modèle M2 est construit en utilisant les types de données des modèles M1 (voir paragraphe ).

Le modèle M2 de l'entité produit est défini dans le fichier productModel.xml dont le contenu est dans la figure ci-dessous :

1<?xml version="1.0" encoding="UTF-8"?>
2
3<!-- Definition of new Model -->
4<model name="product:model" xmlns="http://www.alfresco.org/model/dictionary/1.0">
5
6   <!-- Optional meta-data about the model -->   
7   <description>Custom Content Model</description>
8  <author>KOOSSERY TECHNOLOGY (Centre de Compétences Alfresco-jBPM)</author>
9   <version>1.0</version>
10
11   <!-- ici nos imports de modèles M1  -->     
12   <imports>
13   	  <!-- Import Alfresco Dictionary Definitions -->
14      <import uri="http://www.alfresco.org/model/dictionary/1.0" prefix="d"/>
15      <!-- Import Alfresco Content Domain Model Definitions -->
16      <import uri="http://www.alfresco.org/model/content/1.0" prefix="cm"/>
17   </imports>
18
19<!-- ci-dessous notre modèle M2 pour ce projet  -->
20
21   <!-- on définit le namespace de notre modèle M2 -->
22   <namespaces>
23      <namespace uri="http://www.koossery-tech.com/model/product/1.0" prefix="product"/>
24   </namespaces>
25  
26   <types>
27	   <!-- The product type -->
28      <type name="product:product">
29       	<title>Product</title>
30         <parent>cm:content</parent>
31         <properties>
32         	<property name="product:name">
33               <title>Name</title>
34               <type>d:text</type>
35               <mandatory>true</mandatory>
36            </property>
37            <property name="product:description">
38               <title>Description</title>
39               <type>d:text</type>
40            </property>
41            <property name="product:ref">
42               <title>REF</title>
43               <type>d:text</type>
44               <mandatory>true</mandatory>
45            </property>
46            <property name="product:prize">
47               <title>Prize</title>
48               <type>d:float</type>
49               <mandatory>true</mandatory>
50            </property>
51            <property name="product:stock">
52               <title>Stock</title>
53               <type>d:int</type>
54            </property>
55		 </properties>
56		 
57		 <associations>
58         	<!--  ci-dessous l'association qui lie le produit à ses images   -->
59         	<association name="product:image">
60         		<target>
61         			<class>product:picture</class>
62         			<mandatory>false</mandatory>
63         			<many>false</many>
64         		</target>
65         	</association>
66         </associations>
67		 
68		 <!--  on greffe les aspect/comportements versionable et auditable  -->
69		 <mandatory-aspects>
70		 	<aspect>cm:versionable</aspect>
71		 	<aspect>cm:auditable</aspect>
72		 </mandatory-aspects>
73      </type>
74
75	  <!-- The product image -->
76	  <type name="product:picture">
77	  	<title>Picture</title>
78         <parent>cm:content</parent>
79         <properties>
80         	<property name="product:pictureLegend">
81               <title>Legend</title>
82               <type>d:text</type>
83               <mandatory>false</mandatory>
84            </property>
85 		 </properties>
86      </type>
87      
88    </types>
89   
90</model>

Décrivons de bout en bout le contenu de ce fichier.

-  Ligne 4: le modèle est défini dans le corps de la balise "model". L'attribut "name" représente le nom du modèle : ce nom doit être unique au sein de la plateforme Alfresco. Le nom du modèle ici est "product:model". Remarquez qu'il est formé de deux mots séparés par deux points " : ". Le premier mot représente le préfixe du modèle. Le préfixe est un symbole de votre choix qui permet d'identifier le modèle une fois enregistré dans la plateforme. Ce préfixe doit être unique. Pour finir on distingue l'url du modèle de base du dictionnaire de données: http://www.alfresco.org/model/dictionary/1.0.

-  Ligne 7 à ligne 9: on distingue les sous éléments de description , d'auteur et de version du modèle.

-  Ligne 12 à ligne 17: la déclaration des imports des modèles de base M1. Tout modèle M2 est construit à partir d'éléments des modèles de base M1. Ici nous importons le modèle M1 (identifié par le préfix 'd') des types primitifs et le modèle M1 (identifié par le préfix 'cm') des types de contenu.

-  Ligne 23: on déclare le namespace de notre modèle que nous sommes entrain d'écrire. Nous avons donné comme prefix (qui doit être unique dans le système Alfresco) le mot 'product'. Nous avons donné comme uri l'url 'http://www.koossery-tech.com/model/product/1.0'

-  Ligne 28: définition du type de contenu 'product'.Ce type de contenu correspond à la modélisation de l'entity 'Product' du paragraphe . L'attribut 'name' du type de contenu doit être au format 'prefix : nom' où 'prefix' représente le prefix de notre modèle et 'nom' représente le nom qu'on veut donner au type de contenu.
Chaque propriété de notre type de contenu est définie dans un sous élément "property". On distingue pour une propriété les éléments suivants : son titre, son type, son caractère non obligatoire ou pas ("mandatory").

-  Ligne 57 à ligne 66: on représente l'association entre un produit et son image. Cette association ici est représentée par la composition "child-association": la destruction d'un produit entraîne la destruction de son image.

-  Ligne 69 à ligne 72: une autre partie très importante lors de la définition d'un type de contenu est la partie de la déclaration des aspects, représentée par le l'élément "mandatory-aspects". Celui-ci permet de greffer un aspect générique (ou comportement générique). Dans notre exemple, deux aspects sont greffés au modèle: l'aspect de versioning et l'aspect d'audit du contenu.

-  Ligne 76 à ligne 86: définition du type de contenu "image"

Les types de contenu ainsi définis vont représenter le contrat entre le client web et le Server Repository d'Alfresco pour ce qui concerne les manipulations sur le produit. Lorsque le client web va afficher le formulaire de saisie des informations d'un produit, les labels qui seront affichés seront les valeurs de l'élément "title" des propriétés de notre type de contenu 'product:product'. Comme dans toute application web les labels sont externalisés et définis dans des bundles d'internationalisation i18n. C'est l'objet du paragraphe .

Alfresco donne la possibilité d'externaliser les labels dans un fichier de bundle et de permettre ainsi leur internationalisation i18n. La saisie des informations concernant un produit se fera via le système de GED Alfresco. Pour cela il y aura différents écrans de saisie de fiche d'un produit. Ces écrans vont présenter des labels et des zones de saisies correspondant à toutes les propriétés d'un produit et de ses images.

Dans notre cas nous n'allons définir que les ressources pour les langues française (fr_FR) et anglaise (en_EN). La figure ci-dessous montre le contenu de la ressource fr_FR défini dans le fichier properties product-model_fr_FR.properties.

# Display labels for Content Domain Model
product_model.description=Modèle de contenu de l'entité produit

product_model.type.product_product.title=Produit
product_model.type.product_product.description=Produit
product_model.type.product_picture.title=Photo
product_model.type.product_picture.description=Photo du produit

product_model.property.product_name.title=Nom
product_model.property.product_name.description=Nom du produit
product_model.property.product_description.title=Description
product_model.property.product_description.description=Description du produit
product_model.property.product_ref.title=Reférence
product_model.property.product_ref.description=Reférence du produit
product_model.property.product_prize.title=Prix
product_model.property.product_prize.description=Prix du produit
product_model.property.product_stock.title=Nombre en stock
product_model.property.product_stock.description=Nombre en stock

product_model.property.product_pictureLegend.title=Légende
product_model.property.product_pictureLegend.description=Légende de la photo

product_model.child-association.product_image.title=Image
product_model.child-association.product_image.description=Images du produit

L'enregistrement du modèle productModel.xml et des bundles d'internationalisation se fait à l'aide de Spring dans le fichier product-context.xml. La figure ci-dessous montre un extrait du fichier product-context.xml:

 <!-- ici on enregistre notre modèle  avec les bundles des labels -->	
    <bean id="productContent.dictionaryBootstrap" parent="dictionaryModelBootstrap" 
    		depends-on="dictionaryBootstrap">
        <property name="models">
            <list>
                <value>com/koossery/alfresco/tuto/model/productModel.xml</value>
            </list>
        </property>
        <property name="labels">
			<list>
				<value>com/koossery/alfresco/tuto/model/product-model</value>
			</list>
		</property>
    </bean>

Le modèle productModel.xml et ses bundles sont enregistrés dans le Repository via le bean 'productContent.dictionaryBootstrap'.