Connecteur

Un connecteur CSV permet d’exporter les données via des fichiers CSV. Il permet de configurer les données à exporter et les règles de transformation sont paramétrables dans un « Mapping ». Il est également possible de développer un connecteur spécifique pour prendre en compte des règles métier spécifiques et pour envoyer les données dans un format spécifique.

beCPG met à disposition un connecteur standard permettant d'extraire des entités et leurs listes au format CSV, ou bien des documents (images, fiches techniques) au format natif.

Version

Différentes versions du connecteur existent en fonction de votre version de beCPG. Il est conseillé d'utiliser la dernière version stable du connecteur, l'option isV1Api active la compatibilité avec la version 1.

Certaines options du connecteur ne sont pas valable avec toutes les versions de l'API, cela est indiqué dans la documentation par [>=3.2.1]

Installation

Installer la JDK Java sur votre machine à la version correspondante à votre version du connecteur. Télécharger et dé-zipper l'archive becpg-connector-3.2.2-distribution.zip

Si votre application utilise HTTPS et que le certificat SSL n'est pas reconnu par JAVA celui-ci doit être installé. Pour windows ce référer à l'annexe 1.

Utilisation

Sous linux, exécutez la commande suivante dans un terminal :

./becpg-connector.sh

Sous windows, double-cliquer sur le fichier becpg-connector.bat

Dans un environnement docker il est nécessaire de créer son propre script de lancement et de monter le volume docker correspondant au chemin de destination des fichiers :

Exemple de script de lancement docker:

docker run --rm -v "$PWD":/usr/becpg-connector -v "$PWD"/data:/usr/becpg-connector/data -w /usr/becpg-connector/data \
   --net inst1_internal --link inst1_becpg-mail_1 openjdk:8 java -Dfile.encoding=UTF8 \
   -jar /usr/becpg-connector/lib/becpg-connector-3.2.0-jar-with-dependencies.jar -file=/usr/becpg-connector/becpg-connector.properties >> $TMPFILE 2>&1

Les fichiers csv sont créés dans connector.dest.path

Exemple de fichiers obtenus :

csv/:
bcpg_client.csv           bcpg_semiFinishedProduct.csv  compoList.csv  organoList.csv     physicoChemList.csv
bcpg_finishedProduct.csv  bcpg_supplier.csv             nutList.csv    packagingList.csv

Configuration

Pour configurer le connecteur, il est nécessaire d'éditer le fichier becpg-connector.properties.

Ces paramètres peuvent également être surchargés directement dans le script d'appel avec l'option JAVA -D [>=3.0.0].

Exemple:

java -Dremote.scheme=https -Dremote.host=server.becpg.local -Dremote.port=443 
      -Dconnector.query.template="+TYPE:\"bcpg:finishedProduct\""
      -Dconnector.dest.path=".\data\case-units" 
      -jar ./lib/becpg-connector-3.2.0-jar-with-dependencies.jar -file=becpg-connector-case-units.properties

Le fichier becpg-connector.properties est spécifié grâce à l'option -file=sample-config.properties

Serveur et destination

Tout d'abord, vous devez indiquer l'adresse du serveur beCPG :

remote.scheme=http
remote.host=localhost
remote.port=8080
remote.login=admin
remote.password=becpg

Il faut également indiquer l'emplacement de destination des fichiers CSV (par défaut dans le dossier courant)

connector.dest.path=.

Attention : les chemins doivent s'écrire sous windows c:\\Temp\\becpg-connector (ou c:/Temp/becpg-connector)

Notifications

Il est possible d'envoyer une notification par e-mail à la fin de l’exécution du connecteur :

notify.enabled=false
connector.notify.from=support@becpg.fr
connector.notify.to=support@becpg.fr

mail.smtp.host=localhost
mail.smtp.port=25

Il est également possible d'envoyer les fichiers par FTP à la fin de l’exécution du connecteur :

ftp.protocol=ftp or ftps or sftp (default is ftp) [ >= 3.0.0]
ftp.enabled=false
ftp.host= 
ftp.port=21
ftp.login= 
ftp.password=
ftp.destFolder=
ftp.deleteOnSuccess=false

Il est également possible d'écrire des propriétés dans le PLM sur chaque entité synchronisé en utilisant le format XML de l'API [>=3.0.0]:

plm.activity.enabled=false
plm.activity.syncRemoteXml=<gs1:isPublicated xmlns:gs1="http://www.bcpg.fr/model/gs1/1.0" type="d:boolean" >false</gs1:isPublicated> \
                           <gs1:publicationDate xmlns:gs1="http://www.bcpg.fr/model/gs1/1.0" type="d:date" >%s</gs1:publicationDate>

Compatibilité

Dans certains cas, si la liste des champs à extraire est trop longue il peut être nécessaire de compresser les entêtes [API >= 2.1]:

connector.compress.param=true

Ou d'utiliser l'API V1 [>=3.0.0]:

connector.isV1APi=true

Actions post-connecteur

Il est possible d'executer d'exécuter des actions après le passage du connecteur en utilisant les paramètres suivants :

connector.channel.onSuccess.remote=
connector.channel.onError.remote=

Voici un exemple de JSON à appliquer à l'entité après l'exécution du connecteur, au format remoteEntity :

connector.channel.onSuccess.remote={"attributes": {"bcpg:productState": "Simulation"}}

Création d'un répertoire backup

Dans le cadre d'un export CSV, vous pouvez choisir d'enrichir les fichiers CSV existants (connector.csv.appendToExistingFiles=true) ou bien de créer un répertoire backup (connector.csv.appendToExistingFiles=false) dans lequel les anciens CSV sont déplacés. Pour cela, il faut utiliser le paramètre connector.csv.appendToExistingFiles (par défault, absent donc false).

Pour enrichir les CSV existants et ne pas créer de répertoire backup :

connector.csv.appendToExistingFiles=true

Debugging

Vous pouvez augmenter les niveaux de débuggage en utilisant la propriété connector.debug.level dans les arguments de la ligne de commande

-Dconnector.debug.level=trace
-Dconnector.debug.level=debug
-Dconnector.debug.level=info 
-Dconnector.debug.level=warn
-Dconnector.debug.level=error

Par défaut, le niveau INFO est utilisé.

SSL

Il est possible de desactiver la vérification SSL avec l'option (Pour les tests seulement pour des raisons de sécurité) [>=3.2.2]:

ssl.trustAll=true

Configuration des plugins

Un ou plusieurs plugins peuvent être utilisés pour extraire les données du PLM [ >= 3.0.0]

Pour spécifier un ou plusieurs plugins, utilisez le paramètre suivant:

connector.plugin.class=fr.becpg.connector.plugin.StandardCSVVisitor,fr.becpg.connector.plugin.StandardDocumentVisitor,fr.becpg.connector.plugin.WorkflowCSVVisitor

Plugin standard

Format CSV

Le plugin standard 'fr.becpg.connector.plugin.StandardCSVVisitor' permet de spécifier le format CSV de sortie via l'option connector.csv.format

connector.csv.format=

Plus de détails sur les différents formats:

https://commons.apache.org/proper/commons-csv/apidocs/org/apache/commons/csv/CSVFormat.html

D'autres options permettent de spécifier le séparateur des associations ( , par défaut) [>=3.0.0]:

mapping.csv.assoc_separator=|

Le format des nombres (notation scientifique par defaut) [>=3.2.1]:

connector.csv.decimalFormat=#.####

Ainsi que le format des dates (par défaut, notation ISO):

connector.csv.dateFormat=dd/MM/yyyy

https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/text/DecimalFormat.html

Configuration des entités à extraire

La liste des entités à extraire est configurée par une requête de recherche où % est remplacé par la date de dernier import. Cette date est stockée dans le fichier lastImport qui peut être modifié ou supprimé manuellement.

connector.query.template=(@cm\\:created:[%s TO MAX] OR @cm\\:modified:[%s TO MAX]) AND ( ASPECT:\"bcpg:productAspect\" OR TYPE:\"bcpg:client\" OR TYPE:\"bcpg:supplier\" )

Dans l'exemple, toutes les entités de type produit ainsi que les clients et fournisseurs modifiés ou créés depuis le dernier import sont extraits.

Configuration des champs à extraire

Pour chaque type d'entités renvoyées, il faut définir les champs à exporter dans le fichier CSV.

Export des entités

Pour chaque fichier à extraire il faut utiliser comme clé le prefix mapping.csv et le type d'entité, mapping.csv.bcpg_finishedProduct par exemple pour le type produit fini. Par défaut le nom du csv généré sera le nom du type, dans l'exemple précedent bcpg_finishedProduct.csv.

Il est possible de redéfinir le nom du fichier créé [>=3.2.1]:

mapping.csv.bcpg_finishedProduct.fileName=Custom file name

Il est également possible de mapper jusqu'a 10 fichiers pour un même type [>=3.2.1]:

mapping.csv.bcpg_finishedProduct.1.fileName=Sample file name
mapping.csv.bcpg_finishedProduct.1=bcpg:code,bcpg:erpCode,cm:name

Il est également possible de spécifier des alias pour mapper plusieurs types avec le même mapping [>=3.2.2]:

mapping.csv.bcpg_rawMaterial.alias=article
mapping.csv.bcpg_semiFinishedProduct.alias=article
mapping.csv.article=bcpg:entityTplRef,cm:name,cm:title,bcpg:productHierarchy1|bcpg:erpCode

Exemple de mapping pour le type produit fini :

mapping.csv.bcpg_finishedProduct=bcpg:code,bcpg:erpCode,cm:name,cm:title,bcpg:eanCode,bcpg:code,bcpg:legalName,cm:description,bcpg:entityTplRef\
                    ,bcpg:productHierarchy1,bcpg:productHierarchy2,bcpg:bestBeforeDate,bcpg:certificateDate,bcpg:contractDate\
                    ,bcpg:foodContact,bcpg:netWeightUnit,bcpg:numberOfServings,bcpg:packagingDescription,bcpg:periodAfterOpening\
                    ,bcpg:precautionOfUseRef,bcpg:preparationTips,bcpg:priceCurrency,bcpg:productComments,bcpg:productDensity\
                    ,bcpg:productMicrobioCriteriaRef,bcpg:productQty,bcpg:productSpecifications,bcpg:productState,bcpg:productUnit\
                    ,bcpg:projectedQty,bcpg:servingSize,bcpg:startEffectivity,bcpg:storageConditionsRef\
                    ,bcpg:supplierPlants,bcpg:suppliers,bcpg:suppliers|bcpg:code,bcpg:suppliers|bcpg:erpCode\
                    ,bcpg:clients,bcpg:clients|bcpg:code,bcpg:clients|bcpg:erpCode,bcpg:unitPrice,bcpg:useByDate

Chaque champ est spécifié par son nom interne bcpg:code par exemple.

Il est possible de spécifier le chemin d'un document afin de pouvoir le partager et obtenir son URL publique de partage.

Exemple pour exporter l'URL publique de documents:

/Images/produit.jpg,/Documents/${cm:name} - Fiche Technique Client.pdf

Ici le système va partager les documents produit.jpg et la fiche technique client, s'ils existent, puis il va ajouter leurs URL publiques dans le CSV.

Il est possible de spécifier plusieurs chemins sur une même colonne, permettant de tester chaque chemin jusqu'à l'obtention d'une URL. Exemple :

/Images/produit.jpg|/Images/product.jpg

Pour les associations c'est le nom qui est exporté par défaut. Vous pouvez spécifier la propriétés de l'association à extraire avec la syntaxe assoc_name|prop_name. L'attribut bcpg:nodeRef est également disponible assoc_name|bcpg:nodeRef

Exemple pour exporter le code ISO d'une association:

bcpg:ingListGeoOrigin|bcpg:geoOriginISOCode

Le connecteur standard permet aussi l'exportation des valeurs multilangues d'un champ de type "d:mltext". Pour exporter les différentes valeurs de ce champ, il suffit d'ajouter à la fin du nom le code "locale" de la langue concernée.

Exemple :

cm:description_en, pour exporter la description en Anglais.

bcpg:legalName_ja_JP, pour exporter la valeur du libellé légal en Japonais.

Export des listes:

Comme les entités il faut définir pour chaque liste un mapping des champs à exporter.

Exemple pour la liste nutriment et emballages :

mapping.csv.nutList=entity|bcpg:code,entity|bcpg:erpCode,bcpg:nutListNut,bcpg:nutListValue,bcpg:nutListFormulatedValue,bcpg:nutListUnit
mapping.csv.packagingList=entity|bcpg:code,entity|bcpg:erpCode,bcpg:packagingListProduct,bcpg:packagingListProduct|bcpg:erpCode,bcpg:packagingListQty,bcpg:packagingListUnit,bcpg:packagingListLossPerc,bcpg:packagingListPkgLevel,bcpg:packagingListIsMaster

Les champ préfixé par entity| permettre d'exporter les champs de l'entité (article| est un synonyme).

Exemple:

 entity|bcpg:code, entity|bcpg:erpCode, entity|bcpg:nodeRef

Certaines listes spécifiques on leur propre champs [>=3.0.0]

Liste nutriment

Accés de la valeur du nutriment arrondi en colonne dans l'export d'entité

• nut["Code"] ("locale") Permet d'avoir une colonne avec la valeur arrondi du nutriment pour un pays

Exemple :

• nut["ENER-KJO"] ou nut["ENER-KJO"]("EU") ou nut[ENER-KJO](EU) : Valeur arrondie de l'énergie pour l'europe équivalent à équivalent à
• nut["FAT"]("US") Valeur arrondie des Lipides pour les Etats Unis

Il est également possible dans la liste bcpg:nutList d'afficher les colonnes correspondants aux valeurs arrondis suivantes:

• roundedValue_locale
• roundedSecondaryValue_locale
• roundedSecondaryValuePerServing_locale
• roundedMini_locale
• roundedMaxi_locale
• roundedValuePerServing_locale
• roundedGDAPerc_locale
• roundedValuePerContainer_locale
• roundedGDAPercPerContainer_locale

Exemple:

roundedValue_EU

Nb: Il est nécessaire d'avoir les champs suivant dans le mapping

mapping.csv.nutList=bcpg:nutListNut|gs1:nutrientTypeCode,bcpg:nutListRoundedValue

Liste allégation

claim[Code] - Renvoi true si l'allégation est respecté

Exemple :

claim[ORGANIC_GS1]

Renvoi vrai si le produit est bio

Nb: Il est nécessaire d'avoir les champs suivant dans le mapping

mapping.csv.labelClaimList=bcpg:lclLabelClaim|bcpg:labelClaimCode,bcpg:lclClaimValue,bcpg:lclComments

Liste ingrédient

ingLabelingList[label]|value - Renvoie l'étiquetage manuel s'il est renseigné, sinon l'étiquetage formulé correspondant au libellé "label".

ingLabelingList[label]|manualValue [>=4.1.1] - Renvoie l'étiquetage manuel correspondant au libellé "label".

ingLabelingList[label]|formulatedValue [>=4.1.1] - Renvoie l'étiquetage formulé correspondant au libellé "label".

Le "label" peut être soit l'index soit le libellé de l'étiquette.

Par défaut, le HTML est supprimé de l'étiquetage. En ajoutant "@" à la fin, vous pouvez obtenir la version avec le HTML.

Exemple :

ingLabelingList[Liste des ingrédients]|value

Remarque : Les champs suivants doivent être présents dans le mapping

mapping.csv.ingLabelingList=bcpg:illManualValue,bcpg:illValue,bcpg:illGrp|bcpg:lrLabel

Allergènes

voluntaryAllergen libellés légaux des allergènes volontaires séparés par des virgules voluntaryAllergen|code codes des allergènes volontaires séparés par des virgules inVoluntaryAllergen libellés légaux des allergènes involontaires séparés par des virgules inVoluntaryAllergen|code codes des allergènes involontaires séparés par des virgules

Il est possible de récupérer les libellés légaux des allergènes volontaires et involontaires dans la langue souhaitée en rajoutant un underscore suivi par le code de la langue.

exemple :

voluntaryAllergen_en renvoi les libellés légaux des allergènes volontaires séparés par des virgules en Anglais

Nb: Il est nécessaire d'avoir les champs suivant dans le mapping

mapping.csv.allergenList=bcpg:allergenListAllergen|bcpg:allergenCode,bcpg:allergenListAllergen|bcpg:legalName,bcpg:allergenListVoluntary,bcpg:allergenListInVoluntary

Autre listes

listName[0]|prop - Renvoi la propriété prop de l'item 0 de la liste listName

Exemple :

compoList[0]|bcpg:compoListQty

Configuration via un fichier excel

Le mapping est défini dans becpg-connector.properties par défaut mais peut être réalisé directement dans un fichier excel en spécfiant l'option:

connector.csv.xlsxMapping=./sample/mapping.xlsx

Les entêtes du fichier sont les suivantes:

• Chaque onglet du fichier excel correspondra à un fichier CSV.
• Un onglet sans mapping n'est pas exporté
• Des formules excel peuvent être utilisés dans les headers
• #MaValeur dans une colonne indique une valeur fixe

Exemple:

Il est possible de définir un même mapping pour plusieurs types, par exemple :

| TYPE | bcpg:finishedProduct,bcpg:semiFinishedProduct |

Il est également possible de définir un mapping pour une liste d'un type en particulier, par exemple :

| TYPE | bcpg:rawMaterial|nutList |

Formules

Il est possible dans le mapping des champs d'utiliser des formules au format SPEL

La création d’une formule dans une colonne nécessite trois parties :

• Partie 1 : le mot formula (mot statique), utilisé pour dire que cette colonne est une formule SPEL.
• Partie 2 : un trait vertical | ;

• Partie 3 : la formule elle-même.

  Grâce aux formules SPEL vous pouvez personnaliser les colonnes qui seront affichées.

La formule la plus simple est d’afficher la valeur d’une propriété (standard, dynamique, calculée).

Exemple :

 formula|props["bcpg:erpCode"] 

Permet d'obtenir le code ERP de l'entité

La liste props contient quant à elle toutes les propriétés d’une entité ou d’une liste de données. Par la suite, vous pouvez récupérer la valeur d’une propriété en passant le nom de cette dernière entre 2 crochets : props[ "NOM_PROPRIÉTÉ"]

Pour les propriétés liées à des associations le caractère | doit être échappé par \:

props["bcpg:clients\|cm:title"]

Pour faire des formules compliquées en utilisant des conditions :

formula|props["qty"] != null ? props["qty"] / prop["bcpg:compoListQty"] : props["qty"]

Ce qui signifie :

Si la propriété qty n’est pas vide (null), calculer le pourcentage (qty / compoListQty ). Sinon, afficher la qty

Dans les formules SPEL vous pouvez faire des opérations mathématiques, logiques ou personnaliser l’affichage de données.

Exemple pour formater une valeur:

formula|(new java.text.DecimalFormat("#.###")).format(props["qty"])

Pour plus d’info sur le langage SPEL :

http://docs.spring.io/spring/docs/3.2.x/spring-framework-reference/html/expressions.html

Champs obligatoires

Il est possible de définir une liste de champs obligatoires via l'option connector.csv.mandatoryFields

Lorsqu'un champ obligatoire est défini et qu'un mapping contient ce champ, le système n'extraira pas les entités pour lesquelles ce champ est vide.

Exemple :

connector.csv.mandatoryFields=bcpg:useByDate,bcpg:unitPrice

Configuration du connecteur de documents

Le connecteur de documents est un plugin du connecteur standard. Vous devez donc tout d'abord l'activer en saisissant la ligne suivante dans le fichier becpg-connector.properties

connector.plugin.class=fr.becpg.connector.plugin.StandardDocumentVisitor

A noter que cette ligne est présente par défaut dans le fichier mais commentée par un # en début de ligne, il suffit alors de supprimer ce caractère.

Une fois que le plugin est pris en compte dans la configuration, vous pouvez modifier quels fichiers seront extraits pour chaque type d'entité (produit fini, matière première, etc)

Chaque entité aura un mapping défini comme ceci :

mapping.document.bcpg_<type de l'entité> = <champs à extraire>

Des mappings par défaut sont fournis avec le connecteur, permettant d'extraire les fiches techniques clients et l'image du produit, et ce pour les produits finis, semi-finis et les matières premières.

mapping.document.bcpg_finishedProduct=/Images/produit.jpg|img_produit${bcpg:erpCode}.jpg;/Documents/${cm:name} - Fiche Technique Client.pdf|FT_client${bcpg:erpCode}.pdf
mapping.document.bcpg_rawMaterial=/Images/produit.jpg|img_produit${bcpg:erpCode}.jpg;/Documents/${cm:name} - Fiche Technique Client.pdf|FT_client${bcpg:erpCode}.pdf
mapping.document.bcpg_semiFinishedProduct=/Images/produit.jpg|img_produit${bcpg:erpCode}.jpg;/Documents/${cm:name} - Fiche Technique Client.pdf|FT_client${bcpg:erpCode}.pdf

On constate que chaque entité à extraire est formée de la même façon :

• On a d'un côté le chemin sur l'instance du fichier à extraire
• Ensuite, un trait vertical |
• Suivi du nom (et chemin) du fichier extrait. Ceci permet de choisir comment sera nommé votre fichier, et s'il doit être rangé dans un autre dossier.

Ensuite, il est important de constater que chaque entité à extraire est séparée de la suivante par des points virgules ;

Deux variables seront encodées et utilisables dans le nom du fichier source (sur le système beCPG) et cibles (extraites sur votre système), le code erp du produit en question, et son nom. On peut donc imaginer extraire les fiches techniques dans un dossier ayant pour nom "code ERP - nom de l'entité" :

/Documents/${cm:name} - Fiche Technique Client.pdf|${bcpg:erpCode} - ${cm:name}/FT_client${bcpg:erpCode}.pdf

Il est possible d'utiliser une expression régulière pour matcher le fichier (*.pdf par exemple), les variables doc_cm:name, doc_path, doc_id, et doc_bcpg:nodeRef sont également disponible [>=3.2.2], un même fichier peut être exporter deux fois avec des noms différents.

/Documents/*.xlsx|Documents/${doc_id}_${doc_cm:name}     

Configuration du connecteur de workflows

Le connecteur de workflow permet d'exporter les workflows et leurs tâches au format CSV. Vous pouvez l'activer en saisissant la ligne suivante dans le fichier becpg-connector.properties

connector.plugin.class=fr.becpg.connector.plugin.WorkflowCSVVisitor

Les mapping suivants sont disponibles pour configurer les champs à extraire:

mapping.csv.workflow_instances=id,name,title,description\
                                ,package|cm:name,formula|props["package\\|path"]!=null ?props["package\\|path"].split("/")[props["package\\|path"].split("/").length-1]:""\
                                ,isActive,startDate,priority,message,endDate,dueDate,initiator.userName,initiator.firstName,initiator.lastName

mapping.csv.workflow_tasks=workflowInstance|id,workflowInstance|name,id,state,name,title,description,bpm:completionDate,bpm:workflowDueDate

La propriété connector.query.template permet de filtrer les workflows:

connector.query.template=startedAfter=%sZ

Les valeurs possibles sont:

 state,initiator,priority
 ,dueBefore,dueAfter,
 ,definitionId,definitionName,
 ,startedBefore,startedAfter
 ,completedBefore,completedAfter,exclude

Configuration du connecteur multiniveaux

Le « Connecteur de Multi-niveau » est un plugin du connecteur standard. Il permet d’extraire en format CSV les entités (produits finis, produits semi-finis), leurs listes « Compositions », « Emballages en multi-niveau » ainsi que les autres listes (nutriments, ingrédients, ext.). Ce plugin permet également d’extraire le niveau de chaque composant (produit semi fini, matière première) et sa quantité au niveau du produit.

En d’autres termes, le plugin permet d’extraire la composition d'un semi-fini présent dans la composition d’un produit fini, celle d’un semi-fini présent dans la composition d’un autre semi-fini et ainsi de suite. De plus, il permet d’afficher le niveau de chaque composant.

Exemple :

Composition d’un produit fini :

Calcul de la quantité de semi-fini au niveau du produit

Le niveau du Semi-fini C est égal à 3. Ainsi, pour calculer sa quantité au niveau du produit, il faut commencer par calculer la quantité de Semi-fini B au niveau du produit en appliquant la règle de trois :

QTE de Semi-fini B = (Poids du Semi-fini B / Poids du Semi-fini A) * Pois de Semi-fini A au niveau du produit 

• Poids du Semi-fini A = Somme des ses composants et on peut la trouver aussi dans les caractéristiques formulées

• QTE de Semi-fini B = (0.31 / 0.66) * 5 = 2,348 Kg.

Ce résultat est la quantité que vous utiliserez pour calculer la quantité de Semi-fini C, et ainsi de suite à chaque fois que vous descendez dans le niveau de composition.

Dans l’exemple :

• La quantité de Semi-fini B au niveau du produit => après le calcul = 2,348 kg.

• Le poids de Semi-fini B = 0,17 kg ;

• La quantité de Semi-fini C utilisée dans la composition du Semi-fini B = 0,1 kg.

• La quantité de Semi-fini C utilisée au niveau du produit = (0,1 / 0,17) * 2,348 = 1,381 kg.

Le raisonnement est le même pour calculer la quantité de matière première MP 3 au niveau du produit en utilisant cette fois le résultat 1,381 kg.

Le plugin multi-niveau permet également de calculer les valeurs suivantes :

• Nombre de produits par emballage PCB.

• Nombre de colis par palette dans chaque niveau d’emballage (primaire, secondaire, tertiaire).

• La quantité d’emballage par produit c’est à dire la quantité d’emballage utilisée par unité de produit.

De plus, il met à disposition les valeurs des caractéristiques formulées (caractéristiques dynamiques). Documentation sur les caractéristiques formulées

Ces caractéristiques sont extraites et vous pouvez les afficher directement et/ou les utiliser pour faire des calculs comme expliqué dans la partie : les formules SPEL.

N.B : les noms de ces propriétés sont bien les noms renseignés dans l’application à l’exception près qu’il faut remplacer les espaces par un tiret du 8 ( ) et ajouter le préfixe **dyn** au début du nom.

Par exemple :

• Nom de propriété : « qty en multiniveau ».
• Nom extrait: « dyn_qty_en_multiniveau ».

Configuration

Comme dans le connecteur standard, pour activer le connecteur multi-niveau, il suffit de saisir la ligne suivante dans le fichier becpg-connector.properties :

connector.plugin.class=fr.becpg.connector.plugin.MultiLevelCSVVisitor

Cette ligne débute par un # dans le fichier de configuration qu’il faut supprimer.

Une fois que le plugin est pris en compte dans la configuration, vous pouvez modifier les fichiers qui seront extraits pour chaque type d'entité (Produit fini, matière première, etc). Chaque entité aura un mapping défini comme ceci :

mapping.document.bcpg_<type de l'entité> = <champs à extraire>

Configuration des entités à extraire

Sachant que le plugin est dédié aux deux types d’entités (produit fini et produit semi-fini), les fichiers csv sont indisponibles pour les autres types d’entités (clients, fournisseurs, ext.).

Ainsi, la requête de recherche est assez similaire à la requête du connecteur standard. En revanche, dans ce cas, il n’y a pas besoin d’importer les entités de type client et fournisseur (supplier).

connector.query.template=(@cm\\:created:[%s TO MAX] OR @cm\\:modified:[%s TO MAX]) AND ( TYPE:\"bcpg:finishedProduct\" OR TYPE:\"bcpg:semiFinishedProduct\")

Annexe 1: Installation de certificat (Windows)

Récupérer le certificat du serveur beCPG:

Sur Firefox, cliquer sur l'icône du cadenas.

Puis, cliquer sur la flèche à droite de Connexion sécurisée.

Puis, cliquer sur "Plus d'information".

Puis, cliquer sur "Afficher le certificat". Puis, aller dans la section "Divers" et télécharger le certificat PEM (cert).

Sauvegarder le certificat dans un dossier sur votre ordinateur.

Puis, ouvrir un terminal sur le dossier java. Vous pouvez l'ouvrir rapidement en écrivant cmd sur l'explorateur de dossier windows une fois dans le bon dossier.

Note: il est parfois nécessaire de démarrer le terminal avec les droits d'administrateurs pour procéder à la suite des étapes. Pour ouvrir un terminal en droit d'administateurs, vous pouvez chercher cmd sur votre barre windows, clique droit et "Ouvrir en tant qu'administrateur".

Vous pouvez ensuite vous positionner dans le bon dossier avec la commande cd.

Exemple avec un dossier java positionné dont l'itinéraire est C:\Program Files\Java\jre1.8.0_241.

Vérifier également que le bin\keytool et lib\security\cacerts sont présents dans votre dossier java.

Une fois le terminal ouvert, vous pouvez utiliser la commande suivante :

bin\keytool -import -alias {nom certificat} -file {DESTINATION FICHIER .pem} -keystore lib\security\cacerts

Exemple, avec un certificat becpg.pem positionné dans C:\tmp et un alias becpg :

bin\keytool -import -alias becpg -file C:\tmp\becpg.pem -keystore lib\security\cacerts

Le mot de passe par défaut est : "changeit".

Suivre les messages affichés par le terminal. Une fois installé, vous pouvez utiliser la commande suivante :

bin\keytool -list -v -alias {nom certificat} -keystore lib\security\cacerts

En reprenant notre exemple précédent:

bin\keytool -list -v -alias becpg -keystore lib\security\cacerts