Services WEB/REST

En standard, beCPG propose un service HTTP REST appelé Remote API qui permet :

• d'importer les données d'une entité au format Xml,
• d'exporter les données d'une entité au format Xml selon des critères (Ex : je souhaite tous les produits qui sont validés et effectifs à la date DD/MM/YYYY).

Ce service REST permet de réaliser des interfaces avec des logiciels tiers tel que l'ERP. Par entité, on entend le produit, le client, le fournisseur, le projet, etc... avec l'ensemble de ses informations et cela de manière dynamique sans développement.

L'interface d'échange peut donc être réalisée par un outil tiers dont le rôle est de :

• piloter les échanges,
• transformer les flux (règles de transformation sur des listes de valeurs par exemple),
• gérer les erreurs. Cet outil tiers dialogue avec la Remote API pour importer et exporter les données de beCPG. 2 approches sont possibles :
• le client possède un outil tiers permettant de réaliser l'interface,
• le client souhaite que beCPG mette en place un outil tiers permettant de réaliser l'interface. Par ailleurs, toutes les API de l'application sont accessibles par services REST :
• opérations CRUD, Create/Read/Update/Delete
• formulation
• génération documentaire
• récupération des versions, des fiches techniques
• etc...

Versions

Différentes versions des API existent en fonction de votre version de beCPG. La compatibilité descendante est maintenue. Le format XML par exemple est identique entre la version 1 et 3.3.

Le tableau ci-dessous énumère les différentes versions de l'API et les principaux changements

Ci-dessous les versions de beCPG associés

Les options spécifiques à chaque version de l'API sont notés [>= 3.3] dans la documentation

API beCPG

La remote API de beCPG propose les URL REST suivantes:

A partir de la version 1

<url>/becpg/remote/entity/list?path={path}</url>
<url>/becpg/remote/entity/list?query={query}&maxResults={maxResults}</url>
<url>/becpg/remote/entity?nodeRef={nodeRef}</url>
<url>/becpg/remote/entity?path={path}</url>
<url>/becpg/remote/entity?query={query}</url>

A partir de la version 2.1

<url>/becpg/remote/formulate?nodeRef={nodeRef}</url> 
<url>/becpg/remote/formulate?path={path}</url>
<url>/becpg/remote/formulate?query={query}</url>
<url>/becpg/remote/merge?nodeRef={nodeRef}</url>
<url>/becpg/remote/check?nodeRef={nodeRef}</url>
<url>/becpg/remote/content?nodeRef={nodeRef}</url>
<url>/becpg/remote/branch?nodeRef={nodeRef}</url>
<url>/becpg/remote/report?nodeRef={nodeRef}&tplNodeRef={tplNodeRef}</url>
<url>/becpg/remote/report?nodeRef={nodeRef}&tplNodeRef={tplNodeRef}&locale={locale}</url>
<url>/becpg/remote/report?nodeRef={nodeRef}&tplNodeRef={tplNodeRef}&locale={locale}&format={format}</url>

Les méthodes PUT/GET/POST/DELETE permettent respectivement d'ajouter, retrouver, mettre à jour et supprimer des entités dans le PLM (produit, client, fournisseur, etc ..).

A partir de la version 3.4

<url>/becpg/remote/dictionary?type={type}</url>

Lister les entités

La liste des entités est obtenue avec la requête LIST et peut être filtrée suivant des critères de recherche avancés (dernier produit modifié depuis une date spécifiée par exemple).

<url>/becpg/remote/entity/list?path={path}</url>
<url>/becpg/remote/entity/list?query={query}&maxResults={maxResults}&fields={fields}</url>
<url>/becpg/remote/entity/list?path={path}&maxResults={maxResults}&fields={fields}</url>

La syntaxe de recherche est la syntaxe Alfresco FTS ¹ : https://docs.alfresco.com/search-services/latest/using/

¹. Vous pouvez aussi vous référer à la partie Construction de requêtes Lucène de la documentation ↩

Attention en fonction de la syntaxe utilisé la recherche peut avoir un décalage de quelques minutes avec les modifications faite sur le système. Ce temps est lié à l'indexation. Pour éviter cela il est conseillé d'utiliser uniquement des recherches utilisant la syntaxe db-afts. Si ce n'est pas le cas, il faut décaler les critères de recherche de 10 min. Pour tester que votre requête est compatible db-afts, utilisez le navigateur de nœud en choisissant db-afts, votre recherche doit renvoyer des résultats.

La recherche transactionnel (db-afts) supporte les critères suivant:

• PARENT
• TYPE
• ASPECT
• EXACTTYPE
• EXACTASPECT
• = (Property equality)
• Date Range
• AND NOT OR

Plus d'informations sur les recherches transactionnelles:

https://docs.alfresco.com/search-services/latest/config/transactional/

Un exemple de requête permettant d'avoir un produit fini suivant son code erp :

+TYPE:"bcpg:finishedProduct" AND =@bcpg\\:erpCode:"codeErp" AND -ASPECT:"bcpg:compositeVersion"
(-ASPECT:"bcpg:compositeVersion" permet d'exclure les versions antérieur)

L'Url correspondante :

http://localhost:8080/alfresco/service/becpg/remote/entity?query=%2BTYPE%3A%22bcpg%3AfinishedProduct%22%20AND%20%2B%40bcpg%5C%3AerpCode%3A%22codeErp%22%20AND%20-ASPECT%3A%22bcpg%3AcompositeVersion%22

Pour obtenir l'URL encodé (dans la console de firefox):

encodeURIComponent('+TYPE:"bcpg:finishedProduct" AND =@bcpg\\:erpCode:"codeErp" AND -ASPECT:"bcpg:compositeVersion"')

Le paramètre maxResults permet de spécifier un nombre de résultat (-1 pour avoir tous les résultats)

Le paramètre format permet de modifier le format XML de la réponse

• format=xml (Par défaut)
• format=json (Format json)

Le paramètre fields permet de spécifier des champs ou des associations à extraire dans les résultats [>2.0] :

http://localhost/alfresco/service/becpg/remote/entity/list?query=%2BTYPE%3A%22bcpg%3AfinishedProduct%22&fields=bcpg:legalName,bcpg:clients

Paramètres de pagination [>=4.0] :

• maxResults : Définit le nombre maximum de résultats à retourner par requête. Si ce paramètre est omis, la valeur par défaut est toujours de 256. En utilisant maxResults=-1, vous pouvez demander à récupérer tous les résultats disponibles.

N.B : Lorsque le paramètre fields est utilisé, la pagination s'active automatiquement et le paramètre maxResults n'est plus pris en compte.

• skipCount : Indique le nombre de résultats à ignorer avant de commencer à retourner les résultats. Cela est utile pour la pagination.

Exemple, si skipCount est défini sur 10 et maxResults sur 5, la réponse contiendra les résultats de 11 à 15.

http://localhost/alfresco/service/becpg/remote/entity/list?query=%2BTYPE%3A%22bcpg%3AfinishedProduct%22&maxResults=5&skipCount=10

• page : Permet de naviguer d'une page à l'autre en incrémentant la valeur. Utilisez ce paramètre pour passer d'une page à la suivante.

N.B : Lorsque vous arrivez à la dernière page, la réponse indiquera hasMoreItems avec la valeur false, ce qui signifie qu'il n'y a plus d'entités supplémentaires à récupérer.

Champ pagination dans la réponse API :

• hasMoreItems : Un booléen indiquant si tous les résultats n'ont pas été envoyés. Si true, cela signifie qu'il reste encore des résultats à récupérer.

• count : Le nombre total de résultats retournés dans la réponse actuelle.

Cela permet une gestion efficace des grandes quantités de données en facilitant la pagination des résultats.

Exemples :

Exemple de script bash permettant de récupérer directement sous forme de fichier xml une liste d'entités :

#!/bin/sh

export REMOTE_SERVER=http://localhost:8080/alfresco/service/becpg/remote/entity
export REMOTE_USER=admin
echo "Entrez le mots de passe"
read REMOTE_PASSWORD=

#Récupération de la liste des noeuds :

wget --quiet --http-user=$REMOTE_USER --http-password=$REMOTE_PASSWORD  --header=Accept-Charset:iso-8859-1,utf-8 --header=Accept-Language:en-us -O list.xml $REMOTE_SERVER/list 
count=1

#On parcourt la liste
while [ -n "$nodeRef" -o $count = 1 ]
   do
      nodeRef=`cat list.xml | xpath -q -e //*[$count]/@nodeRef | sed s/nodeRef=//g |sed s/\"//g`
      echo "\Obtention du noeud $nodeRef"; 
      #On enregistre chaque noeud
      wget --quiet --http-user=$REMOTE_USER --http-password=$REMOTE_PASSWORD  --header=Accept-Charset:iso-8859-1,utf-8 --header=Accept-Language:en-us -O entity_$count.xml $REMOTE_SERVER?nodeRef=$nodeRef
      count=$((count+1))
done

Obtenir une entité

Pour l'obtention d'entités, deux services REST sont disponibles :

La remote API en utilisant des requêtes de TYPE GET suivantes

<url>/becpg/remote/entity?nodeRef={nodeRef}&format={format}</url>
 <url>/becpg/remote/entity?path={path}&format={format}</url>
 <url>/becpg/remote/entity?query={query}&format={format}</url>
 <url>/becpg/remote/entity?nodRef={nodeRef}&lists={lists}&fields={fields}</url>
 <url>/becpg/remote/entity?path={path}&lists={lists}&fields={fields}</url>
 <url>/becpg/remote/entity?query={query}&lists={lists}&fields={fields}</url>

Une erreur 404 sera renvoyée si aucune entité n'est trouvée avec les paramètres fournis.

Le paramètre format permet de modifier le format XML de la réponse :

• format=xml (Par défaut)
• format=json (Format json)) [>= 3.0]
• format=json_schema (Schéma de validation JSON) [>=3.2]
• format=xml_all (Contient le détails de toutes les associations)
• format=xml_excel (Format adapté pour l'utilisation comme datasource dans excel)
• format=xml_light (Ce format ne contient pas les associations de type enfants)
• format=xsd (Ce format permet d'extraire la XSD)
• format=xsd_excel (Ce format permet d'extraire la XSD pour excel)

des paramètres supplémentaires de filtrage pour alléger la réponse. Il y a 3 types de filtrage [>=2.0]:

• Filtrage des Propriétés : inclus uniquement les propriétés listées (fields=bcpg:legalName)
• Filtrage des Associations : inclus uniquement les associations listées (fields=bcpg:clients)
• Filtrage des Listes : inclus uniquement les listes listées (lists=bcpg:compoList)

Par ailleurs, vous pouvez extraire les propriétés d'une association en passant dans le paramètre fields le nom des associations et leurs propriétés, en respectant le format suivant : ASSOC_Name1|PROP_Name1,ASSOC_Name1|PROP_Name2.

La forme négative est également supporté [>=3.1]:

• lists=!bcpg:activityList
• fields=!cm:created,!bcpg:nutListRoundedValue,!cm:modifier,!cm:creator,!cm:modifier,!cm:modified,!bcpg:entityScore,!bcpg:formulatedDate,!bcpg:illLogValue

Enfin pour le format JSON le paramètre params permet de passer certains paramètres à l'API [>=3.1]:

• appendCode (true) : Désactive l'ajout du code beCPG
• appendErpCode (true) : Désactive l'ajout du code ERP
• appendMlTextConstraint (true) : Désactive l'ajout des contraintes en multilangue
• appendNodeRef (true) : Désactive l'ajout de l'ID
• appendMlText (true) : Désactive l'ajout des valeurs en multilangue [>=3.2]
• appendContent (false) : Permet d'inclure le contenu des fichiers dans le JSON

Ce paramètre est au format JSON

params =  {
            "appendCode" : true,
            "appendErpCode": false
        }

Et doit être encodé dans la requête

params=%7B%22appendCode%22%3Afalse%2C%22appendMlTextConstraint%22%3Afalse%2C%22appendContent%22%3Atrue%7D

Il est également possible de spécifier les paramètres dans l'URL en utilisant jsonParam comme prefix [>=3.3]

?jsonParamAppendCode=true&jsonParamAppendErpCode=false...

Exemple:

http://localhost/alfresco/service/becpg/remote/entity?nodeRef=workspace://SpacesStore/9b4dd09a-afaa-41ec-84eb-db062146975c&fields=bcpg:legalName,bcpg:clients,bcpg:compoListProduct|bcpg:productState&lists=bcpg:compoList

Obtenir des informations via l'API rapport

<url>/becpg/report/datasource?nodeRef={nodeRef}</url>

L'API rapport effectue un travail de la donnée et permet d'obtenir un XML plus facile à exploiter. Les données de formulation, tare, coût, ainsi que les listes multi-niveaux sont directement exploitables. Cette API est conseillée si vous souhaitez extraire des données produits.

Attention cette API est moins performante.

Cette API accèpte le paramètre locale permettant de spécifier la langue de la donnée, ainsi que l'objet reportParams passé dans le contenu POST de la requête.

Ci-dessous un exemple de reportParams, se référer à la documentation rapport pour plus de détails sur les différents paramètres Extracteur - Partie 1:

 {
  iterationKey : "bcpg:compoList",
  params : [{
    id: "param1",
    prop : "bcpg:compoListProduct|cm:name",
    // Values
    nodeRef : dataListNodeRef
    value : productName
  }],
  prefs : {
   extractInMultiLevel : "true",
   componentDatalistsToExtract : "",
   extractPriceBreaks : "true",
   mlTextFields: "cm:title",
   assocsToExtract : "bcpg:plants,bcpg:suppliers,bcpg:storageConditionsRef,bcpg:precautionOfUseRef,bcpg:nutListNut",
   assocsToExtractWithDataList : "",
   assocsToExtractWithImage : "bcpg:clients",
   multilineProperties:"bcpg:organoListValue"
  }
  nameFormat : "{entity_cm:name} - {report_cm:name} - {locale} - {param1}",
  titleFormat : "{report_cm:name} - {locale} - {param1}"

 }

Vérifier qu'une entité existe

Il est possible de vérifier l'existence d'une entité en utilisant l'URL suivante :

<url>/becpg/remote/check?nodeRef={nodeRef}&format={format}</url>

Si l'entité existe, la réponse sera "OK". Si elle n'existe pas, la réponse sera "KO".

Obtenir ou partager un document

Pour obtenir ou partager un document, il est nécessaire d'utiliser la requête GET suivante :

<url>/becpg/remote/entity/content?nodeRef={nodeRef}&share={?true/false}</url>

Si le paramètre "share" est défini comme étant "true", la requête permettra de partager le document, et l'URL de partage sera renvoyée. Dans le cas où le paramètre est à "false" ou n'est pas présent, le contenu du document sera simplement renvoyé.

Obtenir des informations sur le modèle

Pour obtenir la description des champs d'un type d'entité, vous pouvez utiliser l'URL suivante :

<url>/becpg/remote/entity/dictionary?type={type}&format={json_schema}&fields={fields}</url>

Le paramètre type permet de spécifier le type d'objet à décrire, par exemple : type=bcpg:finishedProduct.Notez que ce paramètre est utilisé uniquement pour le format JSON et n'a aucun effet pour les formats XSD.

Le paramètre format vous permet de spécifier le format de la réponse. Les options disponibles sont :

• format=json_schema : Schéma de validation JSON.
• format=xsd : Format XSD (XML Schema Definition).
• format=xsd_excel : Format XSD pour Excel.

Vous pouvez également utiliser des paramètres supplémentaires de filtrage pour alléger la réponse.

• Filtrage des Propriétés : Ce paramètre inclut uniquement les propriétés listées. Par exemple, pour filtrer uniquement la propriété bcpg:legalName, vous pouvez utiliser : fields=bcpg:legalName.

  Mettre à jour une entité

La mise à jour et la création d'une entité sont réalisées en utilisant les méthodes PUT (Création) et POST (Mise à jour) et les requêtes suivantes :

<url>/becpg/remote/entity?nodeRef={nodeRef}</url>
<url>/becpg/remote/entity?path={path}</url>
<url>/becpg/remote/entity?query={query}</url>
<url>/becpg/remote/entity?nodeRef={nodeRef}&createVersion=true&majorVersion={majorVersion}&versionDescription={description}</url>

Le contenu de la requête doit contenir un XML ou JSON au format par défaut de la remote API. Il n'est pas nécessaire d'avoir tous les champs. Seuls les champs présents sont créés/mis à jour.

Lorsque createVersion=true alors majorVersion (true/false) et versionDescription permettent de créer une nouvelle version de l'entité à mettre à jour. [>=2.1]

Le symbole ~ peut être utilisé pour indiquer un chemin relatif à l'entité importé.

Exemple:

Exemple de requête CURL pour créer une entité

curl --user username:password -H "Content-Type: application/xml"  -X PUT --data @sample-entity.xml  http://localhost/alfresco/service/becpg/remote/entity

Exemple de XML permettant de créer un projet sample-entity.xml

<?xml version='1.0' encoding='UTF-8'?>
<pjt:project xmlns:pjt="http://www.bcpg.fr/model/project/1.0" path="/app:company_home/st:sites/cm:simulation/cm:documentLibrary"
    type="node" name="Sample project">
    <pjt:projectPriority type="d:int"><![CDATA[2]]></pjt:projectPriority>
    <cm:description xmlns:cm="http://www.alfresco.org/model/content/1.0" type="d:mltext" fr="Texte - texte -texte"><![CDATA[Texte - texte -texte]]></cm:description>
    <cm:name xmlns:cm="http://www.alfresco.org/model/content/1.0" type="d:text"><![CDATA[Sample project]]></cm:name>
    <cm:title xmlns:cm="http://www.alfresco.org/model/content/1.0" type="d:mltext" fr="Sample project"><![CDATA[Sample project]]></cm:title>
    <pjt:projectState type="d:text"><![CDATA[Planned]]></pjt:projectState>
</pjt:project>

Vous pouvez également utiliser le format JSON qui est le format conseillé pour la création et la mise à jour à partir de la version 3.0 de l'API. Ce format a l'avantage de permettre la mise à jour de certains champs impossible auparavant.

curl --user username:password -H "Content-Type: application/json"  -X PUT --data @sample-json.json  http://localhost/alfresco/service/becpg/remote/entity?format=json

Pour chaque élément, la racine définit les clés sur lesquelles rechercher un élément et attributes permet de spécifier les valeurs à mettre à jour.

Exemple :

{
    "entity": {
        "bcpg:erpCode": "TEST-REMOTE001",
        "cm:name":"Test remote",
        "type": "bcpg:finishedProduct",
        "params" : {
            "replaceExistingLists" : true,
            "dataListsToReplace": "bcpg:allergenList,bcpg:compoList"
        },
        "attributes": {
                 "bcpg:legalName_en": "Legal Produit fini EN",
                 "bcpg:legalName": "Legal Produit fini FR",
                 "bcpg:clients": [
                        {
                            "bcpg:code": "C1"
                        },
                        {
                            "bcpg:code": "C2"
                        }
                    ],

                  "bcpg:productHierarchy2": {
                    "path": "/app:company_home/cm:System/cm:ProductHierarchy/bcpg:entityLists/cm:finishedProduct_Hierarchy",
                    "bcpg:lkvValue": "Pizza",
                    "type": "bcpg:linkedValue"
                }  
            },
        "datalists": {
          "bcpg:allergenList": [
                {
                    "bcpg:allergenListAllergen": {
                         "bcpg:charactName": "Allergen 4"
                    },
                    "attributes": {
                        "bcpg:allergenListVoluntary": false,
                        "bcpg:allergenListInVoluntary": true
                    },
                    "type": "bcpg:allergenList"
                }
            ],
          "bcpg:compoList": [
                {
                     "bcpg:compoListProduct": {
                            "bcpg:code": "LSF411"
                     },
                    "attributes": {
                        "bcpg:compoListQtySubFormula": 15,
                        "bcpg:compoListUnit": "kg"
                    }
                },
                 {
                     "bcpg:compoListProduct": {
                            "bcpg:erpCode": "TEST1"
                     },
                    "attributes": {
                        "bcpg:compoListQtySubFormula": 10,
                        "bcpg:compoListUnit": "kg"
                    }
                }
        ]
        }
    }
}

L'attribut params permet de passer certains paramètres à l'API:

• replaceExistingLists (false) : Permet de supprimer les lignes dans les listes non présentes dans le fichier JSON [>=3.0]
• dataListsToReplace ("") : Permet de supprimer les lignes dans certains listes uniquement [>=3.0]
• failOnAssociationNotFound (true) : Ne lève pas d'erreur si une association est manquante (sauf si l'association est obligatoire) [>=3.1]
• ignorePathOnSearch (false) : Si le code beCPG ou le code ERP est fourni alors ignore le chemin pour la recherche [>=3.1]

Mettre à jour une propriété multi-langue

Vous pouvez importer les champs de type mltext en spécifiant pour chaque langue la valeur :

<cm:title xmlns:cm="http://www.alfresco.org/model/content/1.0" type="d:mltext" de="Beispielprojekt" fr="Exemple de projet" en="Sample project"><![CDATA[Sample project]]></cm:title>

En json la propriété est suivie d'un underscore et du code de la langue

"bcpg:legalName_en_US": "Valeur US"

Mettre à jour une association

Une association peut être identifiée par son nodeRef, son nom, son code (beCPG ou ERP) et son chemin

N.B : Dans les précédentes versions < 2.0, il faut fournir un nodeRef factice.

Exemple : l'association entité d'un projet

<pjt:projectEntity type="assoc"><bcpg:finishedProduct type="node" name="ENTITY_NAME" code="BCPG_CODE" nodeRef="FAKE_NODEREF"></bcpg:finishedProduct></pjt:projectEntity>

Supprimer une entité

La remote API permet de supprimer des entités en utilisant des requêtes de TYPE DELETE suivantes:

<url>/becpg/remote/entity?nodeRef={nodeRef}&format={format}</url>
<url>/becpg/remote/entity?path={path}&format={format}</url>
<url>/becpg/remote/entity?query={query}&format={format}</url>

Exemple de script permettant de supprimer en masse des entités (Toutes les matières):

#!/bin/sh
export REMOTE_SERVER=http://localhost/alfresco/service/becpg/remote/entity
export REMOTE_USER=admin
echo "Entrez le mots de passe"
read REMOTE_PASSWORD=

if [ $# -ne 1 ]
   then
                #LIST
                wget --quiet --http-user=$REMOTE_USER --http-password=$REMOTE_PASSWORD  --header=Accept-Charset:iso-8859-1,utf-8 --header=Accept-Language:en-us -O list.xml $REMOTE_SERVER/list?query=%2BTYPE%3A%22bcpg%3ArawMaterial%22%20-ASPECT%3A%22sys%3Atemporary%22%20-ASPECT%3A%22bcpg%3AentityTplAspect%22
                count=1

                while [ -n "$nodeRef" -o $count = 1 ]
                do
                   nodeRef=`cat list.xml | xpath -q -e //*[$count]/@nodeRef |sed s/nodeRef=//g|sed s/\"//g|sed s/\:\\\///g| xargs`

                 echo "DELETE ${nodeRef}";
                 curl --user $REMOTE_USER:$REMOTE_PASSWORD -X $REMOTE_SERVER?nodeRef=$nodeRef
                 count=$((count+1))
                done

      exit 0
fi

Obtenir une fiche technique

La remote API [>=2.0] permet aussi de télécharger des rapports en utilisant les méthodes GET suivantes:

<url>/becpg/remote/report?nodeRef={nodeRef}&tplNodeRef={tplNodeRef}</url>
<url>/becpg/remote/report?nodeRef={nodeRef}&tplNodeRef={tplNodeRef}&locale={locale}</url>
<url>/becpg/remote/report?nodeRef={nodeRef}&tplNodeRef={tplNodeRef}&locale={locale}&format={format}</url>

• nodeRef étant l'identifiant système du produit
• tplNodeRef étant l'identifiant du modèle de rapport
• locale étant le code de la langue
• format étant le format du rapport (PDF, XLSX, DOCX, ODT, ZIP)

De plus, il est possible de télécharger des rapports en spécifiant les paramètres au format JSON dans une requête POST

Exemple en utilisant l'outil CURL:

    #!/bin/sh

    export LOCAL_SERVER=http://localhost/alfresco/service/becpg/remote/report
    export LOCAL_USER=admin
    export LOCAL_PASSWORD=becpg

    curl --user $LOCAL_USER:$LOCAL_PASSWORD -H "Content-Type: application/json"  -X POST --data @params.json  "$LOCAL_SERVER?nodeRef=$1&tplNodeRef=$2" > report.pdf

Les variables $1 et $2 sont respectivement l'identifiant du produit et l'identifiant du modèle de rapport. Le fichier params.json contient les paramètres :

    {
    iterationKey : "bcpg:plant",
    params : [{
    id: "param1",
    prop : "cm:name" 
    }],
    prefs : {
    assocsToExtract : "bcpg:plants,bcpg:suppliers,bcpg:storageConditionsRef,bcpg:precautionOfUseRef,bcpg:nutListNut",
    assocsToExtractWithDataList : "bcpg:compoListProduct" 
    },
    nameFormat : "{entity_cm:name}- {report_cm:name}  - {locale} - {param1} ",
    titleFormat : " {report_cm:name} -  {locale} - {param1}" 
    }

Pour plus de détails sur le paramétrage des rapports voir Extracteur - Partie 1

Créer et fusionner une branche

Les requêtes POST suivantes permettent respectivement de créer et fusionner une branche [>=V2.1]:

<url>/becpg/remote/branch?nodeRef={nodeRef}&destNodeRef={destNodeRef?}</url>

destNodeRef est optionnel, par défaut la branche est créé dans le même dossier que l'entité.

<url>/becpg/remote/merge?nodeRef={nodeRef}&branchToNodeRef={branchToNodeRef?}&majorVersion={majorVersion?}&impactWused={impactWused?}</url>

Contenu de la requête:

{
 "description":"Branche description"
}

API Alfresco

Alfresco propose également une API REST documenté ici :

https://docs.alfresco.com/5.2/pra/1/topics/pra-welcome.html

Que vous pouvez parcourir à cette URL:

https://api-explorer.alfresco.com/api-explorer/

Annexe 1: Exemple de requêtes

GET List Finished Product Sample

 curl --location --request GET 'https://$server/alfresco/service/becpg/remote/entity/list?query=+TYPE:"bcpg:finishedProduct"&format=json&fields=bcpg:legalName,bcpg:clients'

PARAMS

| query | +TYPE:"bcpg:finishedProduct" | | format | json | | fields | bcpg:legalName,bcpg:clients |

GET List of products by last modified Sample

curl --location --request GET 'https://$server/alfresco/service/becpg/remote/entity?format=json&query=(@cm\:created:[2020-02-10 TO MAX] OR @cm\:modified:[2020-02-10 TO MAX]) AND ( TYPE:"bcpg:finishedProduct" OR TYPE:"bcpg:semiFinishedProduct")

PARAMS

| query | (@cm\:created:[2020-02-10 TO MAX] OR @cm\:modified:[2020-02-10 TO MAX]) AND ( TYPE:"bcpg:finishedProduct" OR TYPE:"bcpg:semiFinishedProduct") | | format | json |

Get Entity allergen list Sample

  curl --location --request GET 'https://$server/alfresco/service/becpg/remote/entity?format=json&query=+@bcpg\:erpCode:"TEST1"&lists=bcpg:allergenList&fields=bcpg:allergenListAllergen|bcpg:allergenCode,bcpg:allergenListVoluntary,bcpg:allergenListInVoluntary'

PARAMS

| query | @bcpg\:erpCode:"TEST1"| | format | json | | lists | bcpg:allergenList | | fields | bcpg:allergenListAllergen|bcpg:allergenCode,bcpg:allergenListVoluntary,bcpg:allergenListInVoluntary |

Get Compo List Sample

  curl --location --request GET 'https://$server/alfresco/service/becpg/remote/entity?format=json&query=+@bcpg\:erpCode:"TEST1"&lists=bcpg:compoList&fields=bcpg:compoListProduct,bcpg:compoListQtySubFormula,bcpg:compoListUnit'

PARAMS

| query | @bcpg\:erpCode:"TEST1"| | format | json | | lists | bcpg:compoList | | fields | bcpg:compoListProduct,bcpg:compoListQtySubFormula,bcpg:compoListUnit |

GET Get Entity

 curl --location --request GET 'https://$server/alfresco/service/becpg/remote/entity?format=json&query=+@bcpg\:erpCode:"TEST1"'

PARAMS

| query | @bcpg\:erpCode:"TEST1"| | format | json |

Annexe 2: Utilitaire JAVA

beCPG fournit également une librairie utilitaire JAVA permettant de faciliter les appels aux services REST. Cette librairie peut être compilée depuis le code source :

https://github.com/becpg/becpg-java-rest-api

Ci-dessous un exemple permettant de récupérer une entité et ces origines geographique

@Autowired
private EntityApi entityApi;

@Test
void testEntityApi() {        
    List<RemoteEntityRef> entities =  entityApi.list("+TYPE:\"bcpg:finishedProduct\" AND +bcpg\\:erpCode:\"PERF-PF1\"");
    for(RemoteEntityRef entityRef : entities) {
       RemoteEntity entity = entityApi.get(entityRef.getEntity().getId());

       Assert.assertNotNull(entity.getName());
       Assert.assertNotNull(entity.getAttributes());
       Assert.assertNotNull(entity.getDatalists());

       logger.info(entity.getAttributes().get("bcpg:entityTplRef").toString());

        List<RemoteNodeInfo> geoOrigins = entity.getAssociations("bcpg:productGeoOrigin");
        RemoteNodeInfo entityTpl =  entity.getAssociation("bcpg:entityTplRef");

        break;
    }
}