Modèle de données et Formulaires

Le paramétrage et la modification de modèle de données et formulaires dans beCPG est destinée aux administrateurs. Cela nécessite une connaissance du langage XML et de la modélisation du contenu. Une vidéo présente la création de modèles et de formulaires en utilisant le designer.(voir Tutoriel)

Le modèle de données et les formulaires de beCPG permettent de personnaliser et d'adapter le système aux besoins spécifiques de votre entreprise en ajoutant des champs supplémentaires pour stocker des données supplémentaires et en les affichant dans les objets concernés.

Cette modification s'effectue en 3 étapes:

Modification du modèle de données afin de créer les champs supplémentaires
Modification des formulaires pour ajouter et afficher le champs dans le/les objet(s) concerné(s)
Publication des fichiers pour la prise en compte des modifications

Il est donc nécessaire de créer ou modifier 2 fichiers:

{$client}Model.xml pour la modification du modèle de données
{$client}-form-config.xml pour la mise en forme des formulaires

où {$client} correspond au nom du client.

1. Modification du modèle de données

Les modèles de données standard sont défini dans les fichiers suivant :

Fichiers	Description
becpgModel.xml	Modèle beCPG
gs1Model.xml	Modèle GS1
ecmModel.xml	Modèle process
projectModel.xml	Modèle projet
packagingModel.xml	Modèle emballage
qualityModel.xml	Modèle qualité
nonConformityModel.xml	Modèle non conformité

Le modèle de données client est défini dans le fichier : {$client}Model.xml disponible dans l'Entrepôt > Dictionnaire de données > Modèles. Si celui-ci n'est pas disponible, vous pouvez le créer en vous aidant du fichier extCustomModel.xml Dans le fichier {$client}Model.xml, il est possible d'ajouter :

Des propriétés: valeur de type texte, nombre, listes de valeurs etc...
Des associations: association vers un type d'objet (ex: origine géographique, matière première..)
Des types d'objets: composé de plusieurs propriétés et/ou associations (ex: une nouvelle liste...)
Des aspects: groupe de propriétés et/ou associations pouvant être ajoutées à un type d'objet. Cela permet de réutiliser un groupe de propriétés commun à plusieurs types d'objet, par exemple un groupe de propriétés « Produit vendable ».

Prefix

Lors de la création d'un modèle client, un prefix doit être defini dans <namespace>. Tous les champs créés dans le modèle commenceront par ce prefix (ex : $client:name).

<model xmlns="http://www.alfresco.org/model/dictionary/1.0" name="$client:extensionModel">
    <description>Extension model</description>
    <author>beCPG</author>
    <version>1.0</version>
    <imports>
        <import uri="http://www.alfresco.org/model/dictionary/1.0" prefix="d"/>
        <import uri="http://www.alfresco.org/model/content/1.0" prefix="cm"/>
        <import uri="http://www.bcpg.fr/model/becpg/1.0" prefix="bcpg"/>
        <import uri="http://www.bcpg.fr/model/quality/1.0" prefix="qa" />
        <import uri="http://www.bcpg.fr/model/project/1.0" prefix="pjt" />
    </imports>
    <namespaces>
        <namespace uri="http://www.bcpg.fr/model/$client/1.0" prefix="$client"/>
    </namespaces>

Paramétrage d'une propriété

Les types de propriété sont :

Types	Description
d:date	Date
d:text	Texte simple
d:mltext	Multilingue
d:content	Document
d:int	Nombre entier
d:float	Nombre avec 6-7 décimales
d:datetime	Date avec heure et minute
d:double	Nombre
d:boolean	Case à cocher
d:noderef	Hierarchie
d:path	Chemin d'un noeud

Les propriétés d'un type d'objet sont définies dans la section <properties>. Modèle de définition d'une propriété :

  <property name="...">
    <type>Type de données</type>
    <mandatory>obligatoire ou non</mandatory>
    <multiple>Valeur multiple ou non</multiple>
    <default>Valeur par défaut</default>
    <constraints>
       <constraint ref="ID" />
    </constraints>
  </property>

Exemple :

  <property name="bcpg:productType">
      <type>d:text</type>
      <mandatory>true</mandatory>
      <multiple>true</multiple>
      <constraints>
         <constraint ref="bcpg:systemProductType" />
      </constraints>
  </property>

Paramétrage d'une contrainte

Les contraintes sont définies dans la section <constraints>. Voici des exemples de contraintes :

Expression classique

    <constraint name="test:regex1" type="REGEX">
           <parameter name="expression"><value>[A-Z]*</value></parameter>
           <parameter name="requiresMatch"><value>false</value></parameter>
    </constraint>

Ajouter des caractères interdits à un champs

Exemple

    <constraint name="test:regex1constraint" type="REGEX">
           <parameter name="expression">
         <value>(')|(TM)|(®)|(œ)|(Œ)|(Æ)|(ç)|(ù)|(é)|(è)|(ê)|(ë)|(â)|(ô)|(à)|(ï)|(î)|(")|(&amp;)</value>
           </parameter>
           <parameter name="requiresMatch">
               <value>false</value>
           </parameter>
    </constraint>

Longeur Min/Max

    <constraint name="test:stringLength1" type="LENGTH">
            <parameter name="minLength"><value>0</value></parameter>
            <parameter name="maxLength"><value>256</value></parameter>
    </constraint>

Nombre Min/Max

    <constraint name="test:minMax1" type="MINMAX">
            <parameter name="minValue"><value>0</value></parameter>
            <parameter name="maxValue"><value>256</value></parameter>
    </constraint>

Liste de valeur fixe

    <constraint name="test:list1" type="LIST">
            <parameter name="allowedValues">
                <list>
                    <value>ABC</value>
                    <value>DEF</value>
                </list>
            </parameter>
            <parameter name="caseSensitive"><value>true</value></parameter>
    </constraint>

Liste de valeur dynamique (Administration)

<constraint name="test:dynListConstraint1" type="fr.becpg.repo.dictionary.constraint.DynListConstraint">
   <parameter name="path">
      <list>
         <value>/System/Lists/bcpg:entityLists/NutGroups</value>
      </list>
   </parameter>
   <parameter name="constraintType">
      <value>bcpg:listValue</value>
   </parameter>
   <parameter name="constraintProp">
      <value>bcpg:lvValue</value>
   </parameter>
</constraint>

Paramétrage d'un aspect

Les aspects sont définies dans la section <aspects>. Un aspect est un groupe de propriétés ou d'association qui peut être appliqué à un type. Un aspect peut être obligatoire ou pas.

        <aspect name="cm:auditable">
             <title>Auditable</title>
             <properties>
                <property name="cm:created">
                   <type>d:datetime</type>
                </property>
                <property name="cm:creator">
                   <type>d:text</type>
                </property>
                <property name="cm:modified">
                   <type>d:datetime</type>
                </property>
                <property name="cm:modifier">
                   <type>d:text</type>
                </property>
                <property name="cm:accessed">
                   <type>d:datetime</type>
                </property>
             </properties>
    </aspect>

L'ajout d'un aspect obligatoire à un type se fait dans la section <mandatory-aspects>. Exemple :

    <type name="XXX">
        <parent>YYY</parent>
        <mandatory-aspects>
            <aspect>ZZZ</aspect>
        </mandatory-aspects>
    </type>

Où ZZZ est l'aspect obligatoire défini sur le type XXX.

Bonne pratique:
Il est important de créer plusieurs aspects pour stocker les champs et non de mettre tous dans un même aspect. Nous vous recommandons de créer un aspect distinct pour chaque "lieu de stockage" des champs (ex: produit finis, semi-finis, liste ingrédient... ). Si certains champs sont utilisés sur plusieurs objets, il est possible de les regrouper dans un aspect commun nommé produit ou liste par exemple.

2.Modification des formulaires

Les formulaires clients sont définis dans les fichiers : {$client}-form-config.xml disponible dans l'Entrepôt > Dictionnaire de données > Configurations. Si ceux-ci ne sont pas disponible, vous pouvez les créer en utilisant les formulaires standards en suivant les instructions suivantes Les formulaires standards de beCPG sont présent ici :

Fichiers	Descriptions
becpg-plm-fp-form-config.xml	Formulaires produits finis
becpg-plm-sfp-form-config.xml	Formulaires semis finis
becpg-plm-rm-form-config.xml	Formulaires matières premières
becpg-plm-pm-form-config.xml	Formulaires emballages
becpg-plm-form-rp-config.xml	Formulaires ressources
becpg-plm-form-config.xml	Autres formulaires et formulaires des listes
becpg-project-form-config.xml	Formulaires projets
becpg-quality-form-config.xml	Formulaires qualités

Afin d'ajouter des champs à un formulaire et de définir la mise en forme, il faut surcharger les formulaires standards.

Configurations

Pour chaque formulaire xml, 2 configurations (<config>) sont disponibles un pour la création (model type) et un pour l'édition (node type) (voir la partie Types de formulaire) comprenant eux même plusieurs formulaires (<forms>).

Pour surcharger un formulaire, copier les deux blocs <config> ayant pour condition le nom du type d'objet et rajouter "replace=true" dans les balises config.

Par exemple : on souhaite modifier le formulaire de création d'une matière première

Copier les deux blocs <config> ayant pour condition "bcpg:rawMaterial" en ajoutant "replace="true" sur la ligne <config>
Modifier le <forms> create

<config evaluator="model-type" condition="bcpg:packagingMaterial" replace="true">
   <forms>
      <form id="create">
      ...
      </form>
   </forms>
</config>

Types de formulaire

Il existe différents types de formulaire. Un formulaire est identifié par son ID (create,formulation...).

Formulaire de création

Il s'agit du formulaire affiché lors de la création d'un produit en appuyant sur "+ Créer...".
Exemple: Formulaire de création d'une matière première Pour le modifier, il faut surcharger la section <config> ayant pour condition le nom du type en question et l'évaluator model-type puis modifier le <forms> ayant l'id="create".

    <config evaluator="model-type" condition="bcpg:rawMaterial">
      <forms>
        <form id="create">

Formulaire de formulation

Il s'agit du formulaire de création affiché lors de l'ajout d'un produit dans la datalist de composition d'une recette.
Exemple: Formulaire de formulation d'une matière première Pour le modifier, il faut surcharger la section <config> ayant pour condition le nom du type en question puis modifier le <forms> ayant l'id id="formulation".

    <config evaluator="model-type" condition="bcpg:rawMaterial">
      <forms>
        <form id="formulation">

Formulaire d'édition

Il s'agit du formulaire affiché lorsqu'on édite les propriétés d'un produit en appuyant sur "Editer les propriétés".
Exemple: Formulaire d'édition des propriétés d'une matière première

Pour le modifier, il faut surcharger la section <config> du produit en question ayant pour evaluator node-type puis modifier le <forms> par défaut c'est-à-dire sans id.

    <config evaluator="node-type" condition="bcpg:rawMaterial">
      <forms>
        <form>

Formulaire d'édition à partir de l'entrepôt

Lorsqu'on édite les propriétés d'un produit à partir de l'entrepôt, une pop-up s'affiche. Il s'agit d'un formulaire d'édition moins détaillé que le précédent.
Exemple: Formulaire d'édition des propriétés d'une matière première à partir de l'entrepôt

Pour le modifier, il faut surcharger la section <config> du produit en question ayant pour evaluator node-type puis modifier le <forms> ayant l'id id="doclib-simple-metadata".

    <config evaluator="node-type" condition="bcpg:rawMaterial">
      <forms>
        <form id="doclib-simple-metadata">

Formulaire de consultation

Il s'agit du formulaire affiché lorsqu'on consulte les propriétés d'un produit en appuyant sur "Propriétés". Il a les mêmes champs que le formulaire d'édition.
Exemple: Formulaire de consultation des propriétés d'une matière première

Formulaire des paramètres des rapports

Il s'agit du formulaire affiché lorsqu'on modifie les paramètres des rapports en appuyant sur l'engrenage à partir d'une fiche technique.
Exemple: Formulaire des paramètres des rapports d'un produit fini

Pour le modifier, il faut surcharger la section <config> du produit en question ayant pour evaluator node-type puis modifier le <forms> ayant l' id"reports-parameters".

    <config evaluator="node-type" condition="bcpg:finishedProduct">
      <forms>
        <form id="reports-parameters">

Formulaire par site

Il est possible de définir un formulaire spécifique à un site précis. Pour cela, il suffit d'ajouter l'ID du site à celui du formulaire.

Exemple: Définition d'un formulaire de création de matière première dans le site des produits validés d'ID valid

<config evaluator="model-type" condition="bcpg:rawMaterial">
   <forms>
      <form id="create-valid">
         </form>

Formulaire datalists

Dans les différentes datalists (onglets sur le panneau gauche: propriétés,composition...) d'un produit, on peut configurer les colonnes à afficher sur le panneau central.

Exemple: Colonnes de la datalist Nutriments d'un produit fini

Pour ajouter ou supprimer les colonnes à afficher, il faut surcharger la section <config> du produit, d'evaluator model-type et modifier le <forms> ayant l'id=""datagrid" .

    <config evaluator="model-type" condition="bcpg:nutList">
       <forms>
          <form id="datagrid">

Sur le formulaire des listes il est également possible via le paramètre help de spécifier les tailles de colonnes (voir la partie Aide).

Formulaire d'export

Il est possible de faire un formulaire d'export sur une liste afin de pouvoir exporter celle-ci sous Excel avec le bouton exporter sous Excel :

<config evaluator="model-type" condition="bcpg:ingList">
       <forms>
          <form id="export">

En l'absence de formulaire "export", l'export Excel prend en compte le formulaire "datagrid".

Formulaire de liste

Dans certaines datalists (comme nutriments) d'un type précis, un panneau à droite affiche un formulaire présentant des informations supplémentaires.

Exemple: Formulaire de liste des nutriments d'un produit fini

Pour le modifier, il faut surcharger le <config> ayant pour condition le type en question, d'evaluator node-type et modifier le <forms> ayant l'id="datalist.

Exemple: pour la datalist Nutriments d'un produit fini, l'ID du formulaire est "nutList".

    <config evaluator="node-type" condition="bcpg:finishedProduct">
       <forms>
          <form id="nutList">

Formulaire de filtres et recherche

Filtres
Dans les datalists d’un produit, on peut filtrer les éléments à afficher en appuyant sur la loupe. Un formulaire présentant les différentes caractéristiques du filtre s'affiche alors.
Exemple: Formulaire du filtre des nutriments d'un produit fini

Pour le modifier, il faut se rendre au <config> du produit, d'evaluator model-type et modifier le <forms> ayant l' id="filter".

    <config evaluator="model-type" condition="bcpg:nutList">
       <forms>
          <form id="filter">

Recherche
Il s'agit du formulaire affiché lorsqu'on fait une recherche avancée sur un type de produit précis.

Pour le modifier, il faut se rendre au <config> du produit en question avec l'évaluator model-type puis modifier le <forms> ayant l'id="search" dans le fichier {$client}-form-config.xml.

    <config evaluator="model-type" condition="bcpg:rawMaterial">
       <forms>
          <form id="search">

Formulaire d'édition multiple et cas d'emplois

Edition multiple
Il s'agit du formulaire affiché lorsqu'on exécute une édition multiple afin de choisir quels champs nous voulons afficher pour un contenu précis. On l'affiche en appuyant sur "Edition multiple" à partir de l'entrepôt.

Pour le modifier, il faut se rendre au <config> du produit, d'evaluator model-type et modifier le <forms> ayant l'id="bulk-edit".

    <config evaluator="model-type" condition="bcpg:rawMaterial">
       <forms>
         <form id="bulk-edit"/>

Cas d'emplois
Pour chaque type de produit, il existe une datalist "Cas d'emplois". Cette liste a pour ID WUsed
Exemple: Cas d'emplois d'un produit fini
- Filtre de cas d'emplois
  Dans certaines datalists, comme la liste des coûts par exemple, on peut visualiser le cas d'emploi d'un coût sélectionné. Il suffit de sélectionner un coût et de cliquer sur "Cas d'emploi". Une fenêtre pop-up, présentant un formulaire, s'affiche alors.
  Exemple: Filtre de cas d'emploi d'un coût Pour le modifier, il faut surcharger le <config> de la datalist, d'evaluator model-type et modifier le <forms> ayant l'id="filter-wused".
```
<config evaluator="model-type" condition="bcpg:compoList">
 <forms>
   <form id="filter-wused">
```
Liste de cas d'emplois

Une fois que vous avez sélectionné le filtre de cas d'emploi sur la pop-up, vous êtes redirigé vers une autre page appelée "Cas d'emploi". Choisissez les paramètres de recherche dans les menus déroulants. Les résultats de la recherche s'affichent alors.
Exemple: Liste de cas d'emploi d'un coût

Vous pouvez modifier les colonnes des résultats de la recherche en surchargeant le <config> de la datalist, d'evaluator model-type et modifier le <forms> ayant l'id="datagridWUsed".

    <config evaluator="model-type" condition="bcpg:compoList">
       <forms>
         <form id="datagridWUsed">

Export de cas d'emplois

Il s'agit du même mode de fonctionnement que pour le formulaire "export". Il est possible de faire une formulaire d'export sur un cas d'emploi:

<config evaluator="model-type" condition="bcpg:ingList">
       <forms>
          <form id="exportWUsed">

En l'absence de formulaire "exportWUsed", l'export Excel prend en compte le formulaire "datagridWUsed".

Visibilité

Pour afficher un champ, il doit être présent dans la section <field-visibility>.
Chaque champ est précédé d'une balise <show> avec pour id le nom de la propriété. Pour forcer l'affichage d'un champ, ajouter "force=true".

    <show id="bcpg:legalName" force="true" />

Mise en forme

La modification de la mise en forme d'un champ, est disponible dans la section <appearance>
Chaque champ est précédé d'une balise <field> avec pour id le nom de la propriété.

    <field id="bcpg:meatCharacts" set="charact">
        <control template="/fr/becpg/components/form/controls/textarea.ftl" >
            <control-param name="rows">4</control-param>
        </control>
    </field>

Set

Les set permettent de définir des regroupement de champs et de les afficher dans des sections (ex: Désignation)

<set id="mainInfo" appearance="bordered-panel" label-id="becpg.forms.set.designation.label" template="/org/alfresco/components/form/2-column-set.ftl" />
<field id="bcpg:entityTplEnabled" set="template" />

Template défini le template Freemarker utilisé pour afficher le champ, si rien n'est définit, le système prend le template par défaut. Il defini aussi le nombre de colonnes pour présenter les champs.

Contrôles

Les control-param permettent de réaliser des filtres et conditions dans les formulaires pour limiter les résultats sur un champ.

Contrôle multilingue
Ce contrôle apparaît automatiquement à côté du champ MLText . Il permet la traduction d'un champ.

Cliquez que le drapeau pour ouvrir la pop-up d'édition du champ multi-langues:

Sélectionner la langue à ajouter:

Pour ajouter ce contrôle à un champ, on utilise le template défini dans "mtlangue.ftl"

<field id="rep:reportLocales" >
    <control template="/org/alfresco/components/form/controls/mtlangue.ftl">
         <control-param name="insertBlank">true</control-param>
    </control>
</field>

Pour configurer le contrôle multilingue: cliquez ici

Note : Il est possible d'utiliser le traducteur deepl pour générer les traductions plutot que google traduction

Contrôle d'autocomplétion
Ce contrôle permet de compléter automatiquement un champ. L'utilisateur sélectionne la valeur voulue dans le menu déroulant

Pour l'instant le module fournit deux contrôles utilisables en l'état:

Suggérer des propositions pour un champs texte

Pour ajouter ce contrôle à un champ, on utilise le template défini dans "autocomplete.ftl"

<field id="bcpg:productHierarchy1" help-id="becpg.forms.help.productHierarchy1" set="2-col-product-criteria">
    <control template="/org/alfresco/components/form/controls/autocomplete.ftl">
        <control-param name="ds">becpg/autocomplete/allLinkedvalue/values/System/ProductHierarchy/bcpg:entityLists/semiFinishedProduct_Hierarchy
        </control-param>
        <control-param name="multiple">true</control-param>
    </control>
</field>

Suggérer des éléments à associer à un noeud. Pour ajouter ce contrôle à un champ, on utilise le template défini dans "autocomplete-association.ftl"

<field id="bcpg:packagingListProduct" set="3-col-product-criteria">
    <control template="/org/alfresco/components/form/controls/autocomplete-association.ftl">
        <control-param name="ds">becpg/autocomplete/product classNames=bcpg:packagingMaterial,bcpg:packagingKit
        </control-param>
    </control>
</field>

Il est aussi possible d'avoir plus d'une condition. Pour cela il faut utiliser un filtre (filter). L'url nécessite un encodage spécifique. & (équivalent de &) et ajouter la seconde condition suivi de %7C qui servira à isoler la condition ( équivalent de "|").

ex : pour limiter les résultats aux produits finis à l'état validé.

<control-param name="ds">becpg/autocomplete/product?classNames="Typed'entité"&amp;filter="secondecondition"%7C"Condition"</control-param>

soit

<control-param name="ds">becpg/autocomplete/product?classNames=bcpg:finishedProduct&amp;filter=bcpg:productState%7CValid</control-param>

Nous utilisons d'abord classNames pour limiter le choix aux produits finis, puis filter et un "|" pour filtrer ces produits finis sur l'état validé.

Pour configurer les contrôles d'autocompletion: cliquez ici

Contrôle d'unité
Lorsque l'utilisateur sélectionne une unité (L,cL,mL, pièce...) lors de l'édition de propriétés d'un produit par exemple, un champ "poids net (kg)" peut s'afficher à droite du champ selon l'unité choisie.

Pour ajouter ce contrôle à un champ, on utilise le template défini dans "product-unit.ftl"

<field id="bcpg:productUnit" set="formulation">
    <control template="/org/alfresco/components/form/controls/product-unit.ftl">
        <control-param name="options">kg,g,lb,oz,L,cL,mL,gal,cp,fl_oz,P becpg.forms.field.productUnit
        </control-param>
    </control>
</field>

Contrôle de checkbox
En cas de réponse possible multiple, par exemple les Paramètres Rapports, il est possible d'utiliser ce contrôle pour ne pas avoir à utiliser CTRL enfoncé pour choisir plusieurs options.
```
<field id="rep:reportParameters" >
<control template="/org/alfresco/components/form/controls/checkboxmany.ftl"/>
</field>
```

Contrôle d'arbre de décision
Dans certains cas, plusieurs questions sont posées à l'utilisateur. Les questions s'affichent en fonction des réponses fournies. Pour cela, on utilise un contrôle d'arbre de décision.
Exemple: Arbre de décision dans le formulaire d'ajout d'un allergène

Pour ajouter ce contrôle à un champ, on utilise le template défini dans "decision-tree.ftl"

<field id="bcpg:allergenListDecisionTree">
    <control template="/org/alfresco/components/form/controls/decision-tree.ftl">
        <control-param name="prefix">allergenList</control-param>
        <control-param name="data">
            [{id:"q1",choices :[{id : "yes" , cid : "q3" }, {id: "no" , cid : "q2"}, {id:"-", cid :"q2"}]},{id:"q2",choices :[{id : "yes" , cid : "q3", comment : true}, {id:"no", cid : "r1"},{id:"-", cid : "q3"}]},{id:"q3",choices :[{id : "yes" , cid : "q4"}, {id:"no", cid :"r1"}, {id:"-", cid :"q4"}]},{id:"q4",choices :[{id : "yes", cid :"r1"}, {id:"no", cid:"r2"}, {id:"-"}]},{id:"r1"}, {id:"r2"}]
        </control-param>
    </control>
</field>

Pour configurer le contrôle d'arbre de décision: cliquez ici

Contrôle de picker de couleurs
Certains champs consistent à choisir une couleur. Ils ont donc un contrôle picker de couleurs.

Pour ajouter ce contrôle à un champ, on utilise le template défini dans "selectcolorpicker.ftl"

<field id="bcpg:dynamicCharactGroupColor">
    <control template="/org/alfresco/components/form/controls/selectcolorpicker.ftl" />
</field>

Contrôle pour renseigner une valeur par défaut
Certains champs peuvent être complétés par defaut avec une valeur spécifique.

ex: Le champ sera systématiquement complété par 125

<control template="/org/alfresco/components/form/controls/textfield.ftl">
    <control-param name="defaultValue">125</control-param>
</control>

Contrôle pour restreindre le nombre de caractères

ex: Le champ ne pourra contenir plus de 25 caractères

<control>
      <control-param name="maxLength">25</control-param>
</control>

Contrôle pour ajouter un lien

Les champs de type association peuvent avoir un lien qui renvoie en un clic vers l'entité liée. C'est le cas par exemple du modèle d'entité. Il est possible de désactiver (false) ou d'activer (true) ce lien.

    <control-param name="showLink">false</control-param>

Label

Les paramètres label= et lable-id permettent de modifier le nom d'un champ. label-id inclut la notion de traduction en indiquant le code de traductions saisies dans un fichier properties chargé sur le système.

    <field id="cm:title" set="mainInfo" label-id="becpg.forms.field.tradeName">

Help id

Le paramètre help-id permet d'afficher des descriptions d'aide pour compléter le champ.

    <field id="bcpg:legalName" help-id="becpg.forms.help.legalName" set="mainInfo" />

Il est possible de traduire ce champ en plusieurs langues comme le label.

Help

Le paramètre help de permet de spécifier les tailles de colonnes dans un format json, pour les formulaire de type liste

Exemple :


<field help="{&quot;maxAutoWidth&quot;:265,&quot;pattern&quot;:&q
uot;{cm:name}&quot;}" id="cm:name" mandatory="false" read-only="true"/>

Les paramètres possibles sont:

{
 "with":100, // Largeur 
 "minWidth":200, // Largeur mini
 "maxAutoWidth":500, // Largeur maxi
 "tooltip":150, // Affiche un tooltip si le texte dépasse 150 caractères (retour à la ligne = 25 caractère)
 "pattern":"{cm:name} - {bcpg:code"},  // Pattern pouvant être utilisé dans un columnRenderer
 "className": "align-right|align-center|align-justify|indent|hide-ifopen|bold-ifopen|italic-ifchild|bold-ifclose|hide-ifchild|hide-iflevel1|hide-iflevel2...", //Aligne le texte
 "numberFormat":  { "maximumSignificantDigits": 3, "minimumFractionDigits": 3 }
 "forceUnit" : "ppm ou perc" // Permet de forcer la quantité ingrédient ou allergène à s'afficher en % ou ppm
}

Pour le format nombre, se référer aux options ci-dessous : https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl/NumberFormat

Mandatory

Le paramètre mandatory="true" rend la saisie du champ obligatoire.

    <field id="bcpg:erpCode" mandatory="true" set="mainInfo" />

Read only

Le paramètre read-only="true" empêche l'édition du champ.

    <field id="bcpg:code" read-only="true" set="mainInfo" />

Description

Le paramètre description et description-id permet de surcharger la description pop up du navigateur.

    <field id="cm:title" label-id="becpg.forms.field.tradeName" mandatory="false" read-only="false" set="mainInfo" description-id="becpg.forms.field.tradeName">
        <control template="/org/alfresco/components/form/controls/textfield.ftl" />
    </field>

3. Publication des fichiers

Mise à jour des fichiers

Pour que l'application prenne en compte les modifications apportées, il faut importer les fichiers dans beCPG.

Importer le fichier {$client}Model.xml dans le dossier Entrepôt>Dictionnaire de données>Modèles.
Importer les fichiers {$client}-form-config.xml dans le dossier Entrepôt>Dictionnaire de données>Configurations.

Rafraîchissement et publication des modèles

Lors de la publication d'un nouveau modèle :

activer le modèle en cliquant sur "Éditer les propriétés" puis en cochant la case "Model active".
avec le designer sélectionner le bon modèle dans les menus déroulants sur la barre d'outils en haut à gauche. L'arbre du modèle et du formulaire s'affiche sur le panneau de gauche. Placez vous à la racine de chaque arbre puis cliquer sur Publier pour exécuter la publication des fichiers. (voir partie Designer pour plus de détails).

Pour rafraîchir le modèle, recharger les modèles depuis l'Administration beCPG.

Rafraîchissement et publication des formulaires

La méthode de raffraichissement des formulaires dépend de la version beCPG :

Avant la version 4.0 : depuis l'outil Admin, exécuter le rechargement des formulaires.
Depuis la version 4.0 : faire Plus -> Publier, ou publier depuis le Designer (idem point 3)

Wizards

beCPG permet de créer un assistant avancé avec Alfresco share config. L’assistant peut alors être utilisé seul ou pendant une tâche de projet ou une action plm.

En effet, lors d'un projet de référencement d'une matière première par exemple, l'utilisateur va créer un projet en définissant le contexte (raisons du projet, dates échéance...) et en sélectionnant un fournisseur. Le fournisseur reçoit alors une demande de référencement sur son portail avec un ou plusieurs wizards joints. Ces wizards correspondent à une suite de formulaires spécifiques avec un ID propre. Le fournisseur devra donc remplir les champs en renseignant les informations sur la matière première. Ce wizard destiné à la création de matières premières a pour id "supplier-mp".

Exemple: Wizard "supplier-mp"

Ajouter un wizard

Depuis la version 3.2.0, Les wizards sont définis dans le fichier : becpg-plm-share-config.xml.

Pour ajouter un wizard, il faut le définir dans le fichier share-config-custom.xml en listant les différentes étapes

<config evaluator="string-compare" condition="wizard">
        <wizards>
            <wizard id="sample-npd">
                <step id="step1" label="Création demande" type="form" formId="create-article"
                    itemId="pjt:project" nextStepWebScript="becpg/project/entity?nodeRef={nodeRef}"></step>
                <step id="step2" label="Information produits" type="form"
                    formId="create-article" itemId="bcpg:finishedProduct"></step>
                <step id="step3" label="Composition produit" type="entityDataList"
                    listId="compoList" itemId="bcpg:compoList"></step>
                <step id="step4" label="Emballages" type="entityDataList" listId="packagingList" itemId="bcpg:packagingList"></step>
            </wizard>
        <wizards>   
</config>

Ainsi:

Vous pouvez utiliser plusieurs formId avec ou sans noeuds existants.
Vous pouvez appeler webscript intermédiaire avec nextStepWebScript (le webscript doit renvoyer un nodeRef pour pouvoir être utilisé à l'étape suivante).
Vous pouvez afficher les datalists d'entités

Pour appeler le wizard afin de créer un nouveau nœud: /share/page/wizard?id=sample-npd&destination=

Pour appeler le wizard afin d'ouvrir un nœud déjà existant: /share/page/wizard?id=sample-npd&nodeRef={nodeRef}

Voir partie Étendre beCPG pour plus de détails sur la surcharge du fichier share.

Pour ajouter le formulaire à une entité, il faut surcharger le <config> de l'entité, d'evaluator node-type et modifier le <form> ayant l'ID du wizard dans le fichier {$client}-form-config.xml en ajoutant les champs à afficher.

Exemple: Ajout du wizard "supplier-mp" à l'entité Matière Première

<config evaluator="node-type" condition="bcpg:rawMaterial" replace=true>
    <forms>
        <form id="supplier-mp">

Rafraîchissement et publication des wizard

Depuis la version 3.2.0, il est possible de déployer le fichier becpg-config-custom.xml directement comme un formulaire, avec le même fonctionnement. Il faut toutefois que le nom becpg-config-custom.xml soit parfaitement orthographié.

Questionnaires

Depuis la version 3.2.3, il est possible dans beCPG de créer des questionnaires intégrables dans les wizards. Les questions et leurs réponses sont à saisir dans l'administration, dans une liste de caractéristiques de type "Questionnaire". Il est possible de créer des questions avec des réponses de type:

Texte simple, en sélectionnant "textarea" dans "Type de commentaire"
Liste de choix, en créant et associant les choix possibles à la question avec le champ "Parent".
Liste de choix multiples, en sélectionnant "checkboxes" dans "Type de commentaire" il faut choisir comme type de réponse "checkboxes", puis créer et associer les choix possibles à la question avec le champ "Parent".

Une fois les questions créées dans l'administration, ajouter sur le modèle d'entité une nouvelle liste de type questionnaire et peupler avec les questions désirées.

Pour ajouter les questions au wizard, il faut rajouter une étape dans le fichier becpg-config-custom.xml:

<step id="stepxxx" label="Your survey label" title="Your survey title" type="survey" listId="surveyList" itemId="survey:surveyList"></step>

Gestionnaire de validation

Un gestionnaire de validation est une fonction JavaScript appelée par l'exécution des formulaires lorsqu'une valeur de champ doit être validée. beCPG utilise 3 gestionnaires de validation définis dans le fichier becpg-validation-handler.js:

mandatoryIf: affiche un champ en fonction de la sélection d'un autre champ
hideIf: masque le champ en fonction de la sélection d'un autre champ
filterBy: filtre le champ en fonction de la sélection du champ parent
GTIN: valide le champ s'il est au format GTIN
Aussi on peut utiliser les règles d'expression dans les conditions de hideIf

Pour utiliser ces gestionnaires, il faut ajouter des contraintes dans le <field> ayant l'id du champ à valider dans le formulaire en question. N'oublie pas de remplacer field par assoc ou prop dans le nom du champ.

Exemple: Afficher le champ "acme:fieldId" si le champ "field_bcpg_code" n'est pas vide:

<field id="acme:fieldId">
     <constraint-handlers>
         <constraint type="MANDATORY" validation-handler="beCPG.forms.validation.mandatoryIf" event='keyup,change@[{"prop":"field_bcpg_code", "condition": "NOTEMPTY"}]' />
     </constraint-handlers>
</field>

Exemple: Masquer le champ "acme:fieldId" si le champ "field_bcpg_code" il n'a pas la valeur Autre:

<field id="acme:fieldId">
     <constraint-handlers>
         <constraint type="MANDATORY" validation-handler="beCPG.forms.validation.hideIf" event='keyup,change@[{"prop":"field_bcpg_code","condition":"RegExp_^(?!Autre$).*"}]' />
     </constraint-handlers>
</field>

Exemple: Masquer le champ "acme:fieldId" si le champ "field_bcpg_code" est vide:

<field id="acme:fieldId">
     <constraint-handlers>
         <constraint type="MANDATORY" validation-handler="beCPG.forms.validation.hideIf" event='keyup,change@[{"prop":"field_bcpg_code","condition":""}]' />
     </constraint-handlers>
</field>

Exemple: Valider le champ "acme:fieldId" s'il est au format GTIN

<field id="acme:fieldId">
     <constraint-handlers>
         <constraint type="MANDATORY" validation-handler="beCPG.forms.validation.GTIN" event="keyup" />
     </constraint-handlers>
 </field>

Exemple: Filtrer le champ "acme:fieldId" pour qu'il ne contienne que les valeurs préfixées par la valeur du champ "field_bcpg_code"

<field id="acme:fieldId">
    <constraint-handlers>
        <constraint type="MANDATORY" validation-handler="beCPG.forms.validation.filterBy" event='keyup,change@[{"prop":"field_bcpg_code","condition":"STARTWITH"}]' />
    </constraint-handlers>
</field>

Plus de détails : http://docs.alfresco.com/5.1/concepts/dev-extensions-share-form-field-validation-handlers.html

Designer

Le designer de modèle de beCPG permet de créer des modèles de données et des formulaires. On y accède depuis le bandeau supérieur avec le rôle administrateur.

Le designer se compose de trois panneaux :

le panneau de gauche comprend un arbre représentant le modèle et un arbre représentant les formulaires
le panneau central présente les formulaires d'édition des modèles et formulaires
le panneau de droite présente une palette de regroupement et de contrôle

Ajout des fichiers dans le dictionnaire de données

Pour ajouter un modèle au designer, chargez un fichier de modèle dans Dictionnaire de données/Modèles. Pour ajouter un fichier de formulaires, chargez un fichier de formulaires dans Dictionnaire de données/Configurations.

Pour que l'ajout des fichiers soient prises en compte par le designer, il faut exécuter le rechargement des modèles et des formulaires depuis l'outil admin.

Le choix du fichier de modèle et de formulaire à afficher se fait grâce au menu déroulant dans la barre d'outil du panneau de gauche.

Modification du modèle de données

L'arbre des modèles permet de créer des types, aspects, propriétés et contraintes en se positionnant dans l'arbre et en pressant le bouton Nouvel enfant. Il faudra ensuite sélectionner le regroupement, le type d'élément à créer ainsi qu’éventuellement le modèle à utiliser.

Une fois le modèle créé ou modifié,pressez le bouton publier à la racine du modèle afin de publier le modèle.

Notes :

Tous les champs obligatoires doivent être renseignés
Un type peut être supprimé si aucun élément dans l'entrepôt et dans la corbeille ne possède ce type
Une propriété peut être supprimée si aucun élément dans l'entrepôt et dans la corbeille ne possède cette propriété
Une propriété ne peut être modifiée que par surcharge du type ou de l'aspect

Création d'un formulaire

La création d'un formulaire s'effectue par un glisser-déposer d'un type dans l'arbre des formulaires ou grâce au bouton Nouvel enfant. L'association de contrôle à des champs ou de regroupement de champs se fait par un glisser-déposer depuis la palette vers la zone correspondante dans le panneau central.

Pour publier le formulaire placez vous à la racine de l'arbre formulaires et cliquez sur Publier.

L’aperçu s'effectue en sélectionnant un type dans l'arbre de modèle et en cliquant sur le bouton « Aperçu ». Le type doit être publié pour être visualiser. de même, le formulaire ayant l'identifiant « create » associé à ce type doit être publié.

Tutoriel

Méthode avancée de publication des fichiers

Il existe également une autre méthode de publication des fichiers modifiés.

Placez vous dans le dossier de votre instance: cd /opt/becpg-srv-instances/inst1\
Créez un dossier config si celui-ci n'a pas encore été créé: mkdir config
Placez vos fichiers modifiés dans ce dossier.
Créez le fichier docker-compose.override.yml s'il n'existe pas dans le dossier de votre instance: touch /opt/becpg-srv-instances/inst1/docker-compose.override.yml
Éditez le en ajoutant les volumes dans la section becpg afin de surcharger les configurations:

Exemple Si votre fichier s'appelle becpg-config-custom.xml:

version: '2'
networks:
    internal:
services:
    becpg:
        volumes:
              -./config/becpg-config-custom.xml:/usr/local/tomcat/shared/classes/alfresco/web-extension/becpg-config-custom.xml:ro

Voir partie Étendre beCPG pour plus de détails.

Enfin redémarrez le service beCPG pour permettre la prise en compte des nouvelles configurations: docker-compose up -d
Pour plus de détails sur l'arrêt et le démarrage du service: cliquez ici