Modèle de données et Formulaires

Le paramétrage et l'administration de modèle de données et formulaires pour le progiciel beCPG est destinée aux administrateurs du progiciel beCPG. Une vidéo présente la création de modèles et de formulaires en utilisant le designer.

Introduction

Il est possible d'enrichir le modèle de données et les formulaires standards de beCPG. Cette modification s'effectue en 3 étapes:

  1. Modification du modèle de données afin d'ajouter des aspects, associations... au modèle standard de beCPG.
  2. Définir la mise en forme des formulaires pour l'ajout d'un champ dans un formulaire par exemple.
  3. 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

Le modèle de données client est défini dans le fichier : {$client}Model.xml
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é

Il est donc possible d'enrichir le modèle de données de beCPG en ajoutant :

  • Des propriétés: valeur de type texte, entier, listes de valeurs etc...
  • Des associations: association vers un type d'objet
  • Des types d'objets: composé de plusieurs propriétés et/ou associations
  • 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 ».

Cela nécessite des connaissances en XML et en modélisation de contenu.

Paramétrage d'une propriété

Les types de propriété sont :

  • d:date
  • d:text
  • d:content
  • d:int
  • d:long
  • d:any
  • d:float
  • d:datetime
  • d:double
  • d:boolean
  • d:category
  • d:noderef
  • d:path

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 régulière
    <constraint name="test:regex1" type="REGEX">
           <parameter name="expression"><value>[A-Z]*</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 valeurs
    <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>
  • Contrainte dynamique
    Il est également possible d'ajouter des contraintes dynamiques comme l'affichage d'une liste dynamique par exemple:
<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>

Plus de détails sur les contraintes d'Alfresco: http://wiki.alfresco.com/wiki/Constraints

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.

2. Mise en forme de formulaires

Les formulaires clients sont définis dans le fichier : {$client}-form-config.xml
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 est possible de surcharger les formulaires standards.
Pour chaque entité, on définit plusieurs formulaires (formulaire de création, d'édition...) (voir la partie Types de formulaire). Ainsi, dans le fichier becpg-plm-form-config.xml, il y a deux éléments <config> par entité comprenant la configuration de plusieurs formulaires (balises <forms>).
L'élément <config> ayant l'évaluator model-type configure les formulaires utilisés pour créer de nouveaux nœuds (ex: formulaire de création). Tandis que l'élément <config> avec un evaluator node-type configure les formulaires traitant des noeuds existants (ex: formulaire d'édition).

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

Par exemple, si on veut modifier le formulaire de création d'une matière première, on copie les deux blocs <config> ayant pour condition "bcpg:rawMaterial" en ajoutant "replace="true" dans les propriétés de <config> et on modifie le formulaire d'ID create :

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

* Les champs affichés dans un formulaire sont dans la section <field-visibility>.
L'ajout d'un champs revient donc à ajouter une balise <show> avec pour ID le nom de la propriété.

    <show id="bcpg:legalName" />

Pour forcer l'affichage d'un champ, il faudra ajouter "force=true". Ainsi, les champs seront affichés même si l'aspect n'est pas ajouté à l'entité.

* La mise en forme se fait dans la section <appearance>
L'ajout de la mise en forme d'un champ revient à ajouter 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 » défini le regroupement de champs
« template » défini le template Freemarker utilisé pour afficher le champ, si rien n'est défini, le système prend le template par défaut
« control-param » défini un paramètre du template Freemarker

Filtres et conditions dans les formulaires : Il est possible d'ajouter des filtres et des conditions pour limiter les résultats sur un champ. Prenons l'exemple d'une association où nous ne voulons que les produits finis. Pour cela utiliser classNames comme dans l'exemple ci-dessous.

becpg/autocomplete/product?classNames=bcpg:finishedProduct</control-param>

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é.

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

soit

becpg/autocomplete/product?classNames=bcpg:finishedProduct&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é.

3. Publication des fichiers

Mise à jour des fichiers

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

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

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

Rafraîchissement et publication des modèles

  1. Pour publier le modèle, il est possible de :
  2. activer le modèle en cliquant sur "Éditer les propriétés" puis en cochant la case "Model active".

  3. 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).

  4. Recharger les modèles depuis l'Administration beCPG.

Rafraîchissement et publication des formulaires

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

  2. Avant la version 4.0 : depuis l'outils Admin, exécuter le rechargement des formulaires.

  3. Depuis la version 4.0 : faire Plus -> Publier, ou publier depuis le Designer (idem point 3)

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 <form> 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 <form> ayant l'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 <form> de base 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 <form> ayant l'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 formulaires 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ètre 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 <form> 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>

Listes

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 <form> 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 sous un format json:

Exemple


<field help="{&quot;maxAutoWidth&quot;:265,&quot;pattern&quot;:&quot;{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 utiliser dans un columnRenderer
 "className": "align-right|align-center|align-justify|indent|hide-ifopen|bold-ifopen|italic-ifchild|bold-ifclose|hide-ifchild", //Aligne le texte
 "numberFormat":  { "maximumSignificantDigits": 3, "minimumFractionDigits": 3 }
}

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

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"/>

Note : 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 panneaux à 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 <form> ayant l'ID de la 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"/>

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 <form> ayant l'ID filter dans le fichier {$client}-form-config.xml.

    <config evaluator="model-type" condition="bcpg:nutList">
       <forms>
          <form id="filter">
  • Formulaire de 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 <form> ayant l'ID search dans le fichier {$client}-form-config.xml.

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

Edition multiple et cas d'emplois

  • Formulaire d'édition 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 <form> 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 <form> 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'affiche 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 <form> 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"/>

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

Contrôles

Les contrôles permettent de personnaliser des champs.

  • 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

  • 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 fourni deux contrôles utilisables en l'état:

  • le contrôle autocomplete permet de 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>
  • le contrôle autocomplete-association permet de 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>

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>

Pour configurer le contrôle d'unité: cliquez ici

  • Contrôle de checkbox
    En cas de réponse possible multiple, pas exemple les Paramètres Rapports, il est possible d'utiliser ce contrôle pour ne pas avir à 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 certain 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>

Pour configurer le contrôle picker de couleurs: cliquez ici

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 (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">

Déploiement direct (3.2.0)

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". Pour créer une question avec une réponse texte simple, il faut simplement que le champ "Type de commentaire" ait la valeur "textarea". Pour créer une question avec réponses préselectionnées, il faut aussi saisir dans la liste de caractéristiques les choix possibles, et les associer à la question avec le champ "Parent". Pour créer une question à choix multiple, il faut choisir comme type de réponse "checkboxes", et saisir ensuite les réponses possibles en les associant à la question.

Une fois les questions paramétrées dans l'administration, il faut les associer à l'entité voulue. Il faut alors rajouter sur son modèle une nouvelle liste de type Questionnaire (administration), puis la 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:

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'outils 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 centrale.

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

  • Editez 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

results matching ""

    No results matching ""