Connecteur

Un connecteur CSV permet d’exporter les données via des fichiers CSV. 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 connector.isV1APi active la compatibilité avec la version 1.

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

Installation

Installez le JDK Java sur votre machine, dans la version correspondant à votre version du connecteur. Téléchargez et décompressez 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, reportez-vous à l'annexe 1.

Utilisation

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

./becpg-connector.sh

Sous Windows, double-cliquez 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, le dossier courant) :

connector.dest.path=.

Attention : sous Windows, les chemins doivent s'écrire 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ée 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 en-tê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'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 (absent par défaut, 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ébogage 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 désactiver la vérification SSL avec l'option suivante (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 défaut) [>=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é renvoyé, 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 préfixe mapping.csv et le type d'entité, par exemple mapping.csv.bcpg_finishedProduct pour le type Produit fini. Par défaut, le nom du CSV généré est le nom du type, dans l'exemple précédent 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'à 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é 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 multilingues 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 pour les entités, il faut définir pour chaque liste un mapping des champs à exporter.

Exemple pour les listes nutriments 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 champs préfixés par entity| permettent 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 ont leurs propres champs [>=3.0.0].

Liste nutriment

Accès à la valeur arrondie du nutriment en colonne dans l'export d'entité :

• nut["Code"] ("locale") permet d'avoir une colonne avec la valeur arrondie 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
• nut["FAT"]("US") valeur arrondie des lipides pour les États-Unis

Il est également possible dans la liste bcpg:nutList d'afficher les colonnes correspondant aux valeurs arrondies 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 suivants dans le mapping :

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

Liste allégation

claim[Code] - renvoie true si l'allégation est respectée.

Exemple :

claim[ORGANIC_GS1]

Renvoie vrai si le produit est bio.

Nb : il est nécessaire d'avoir les champs suivants 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 ajoutant un underscore suivi par le code de la langue.

Exemple :

voluntaryAllergen_en renvoie 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 suivants dans le mapping :

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

Autres listes

listName[0]|prop - renvoie 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 par défaut dans becpg-connector.properties, mais peut être réalisé directement dans un fichier Excel en spécifiant l'option suivante :

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

Les en-têtes du fichier sont les suivants :

• Chaque onglet du fichier Excel correspond à un fichier CSV.
• Un onglet sans mapping n'est pas exporté.
• Des formules Excel peuvent être utilisées 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 d'utiliser des formules au format SPEL dans le mapping des champs.

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

Cette formule 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 deux 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 complexes 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’informations 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

À noter que cette ligne est présente par défaut dans le fichier, mais commentée par un # en début de ligne : supprimez ce caractère.

Une fois que le plugin est pris en compte dans la configuration, vous pouvez modifier les fichiers 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, les 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 :

• D'abord, 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 un point-virgule (;).

Deux variables sont encodées et utilisables dans le nom du fichier source (sur le système beCPG) et cible (extrait 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 disponibles [>=3.2.2]. Un même fichier peut être exporté deux fois avec des noms différents.

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

Configuration du connecteur de workflows

Le connecteur de workflows 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 mappings 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 multiniveau » est un plugin du connecteur standard. Il permet d’extraire au format CSV les entités (Produits finis, Semi-finis), leurs listes « Compositions », « Emballages en multiniveau » ainsi que les autres listes (nutriments, ingrédients, etc.). Ce plugin permet également d’extraire le niveau de chaque composant (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) * Poids de Semi-fini A au niveau du produit

• Poids du Semi-fini A = somme de ses composants ; on peut aussi la trouver 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 multiniveau 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). Voir la 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 « Formules ».

N.B : les noms de ces propriétés sont bien les noms renseignés dans l’application, à ceci près qu’il faut remplacer les espaces par un tiret bas ( ) 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 multiniveau, saisissez la ligne suivante dans le fichier becpg-connector.properties :

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

Dans le fichier de configuration, cette ligne débute par un # 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

Le plugin étant dédié à deux types d’entités (Produit fini et Semi-fini), les fichiers CSV sont indisponibles pour les autres types d’entités (clients, fournisseurs, etc.).

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érez le certificat du serveur beCPG :

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

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

Puis, cliquez sur "Plus d'informations".

Puis, cliquez sur "Afficher le certificat". Puis, allez dans la section "Divers" et téléchargez le certificat PEM (cert).

Sauvegardez le certificat dans un dossier sur votre ordinateur.

Puis, ouvrez un terminal dans le dossier Java. Vous pouvez l'ouvrir rapidement en écrivant cmd dans la barre d'adresse de l'explorateur de fichiers Windows, une fois dans le bon dossier.

Note : il est parfois nécessaire de démarrer le terminal avec les droits d'administrateur pour procéder à la suite des étapes. Pour ouvrir un terminal avec les droits d'administrateur, cherchez cmd dans la barre Windows, faites un clic droit et choisissez "Exécuter en tant qu'administrateur".

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

Exemple avec un dossier Java situé dans C:\Program Files\Java\jre1.8.0_241.

Vérifiez également que 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 situé 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".

Suivez 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