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 tels 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. Deux 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 les versions 1 et 3.3.

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

Le tableau ci-dessous indique les versions de beCPG associées :

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

Batches des canaux de publication

De nouveaux points de terminaison API sont disponibles pour gérer les lots (batches) des canaux de publication :

• GET /becpg/remote/channel/batch/start/{channelId} : démarrer un nouveau lot pour un canal spécifique.
• GET /becpg/remote/channel/batch/ack/{batchId} : accuser réception d'un lot.
• GET /becpg/remote/channel/batch/end/{batchId} : terminer un lot.

API beCPG

La remote API de beCPG propose les URL REST suivantes.

À 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>

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

À 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, décrite dans la documentation Alfresco Search Services. Consultez aussi la partie Construction de requêtes Lucène.

Attention : en fonction de la syntaxe utilisée, la recherche peut avoir un décalage de quelques minutes avec les modifications faites 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œuds en choisissant db-afts : votre recherche doit renvoyer des résultats.

La recherche transactionnelle (db-afts) supporte les critères suivants :

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

Plus d'informations sur les recherches transactionnelles :

https://docs.hyland.com/r/Alfresco/Alfresco-Search-Services/2.0/Alfresco-Search-Services

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érieures)

L'URL correspondante :

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

Pour obtenir l'URL encodée (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ésultats (-1 pour avoir tous les résultats).

Le paramètre format permet de modifier le format 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.

Par 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, avec les requêtes de type GET suivantes :

<url>/becpg/remote/entity?nodeRef={nodeRef}&format={format}</url>
 <url>/becpg/remote/entity?query={query}&format={format}</url>
 <url>/becpg/remote/entity?nodeRef={nodeRef}&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 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étail 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)

Vous pouvez également utiliser des paramètres supplémentaires de filtrage pour alléger la réponse. Il existe trois types de filtrage [>=2.0] :

• Filtrage des propriétés : inclut uniquement les propriétés listées (fields=bcpg:legalName)
• Filtrage des associations : inclut uniquement les associations listées (fields=bcpg:clients)
• Filtrage des listes : inclut 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ée [>=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 multilingues
• appendNodeRef (true) : désactive l'ajout de l'ID
• appendMlText (true) : désactive l'ajout des valeurs multilingues [>=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
        }

Il 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 préfixe [>=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 traitement des données 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 produit.

Attention : cette API est moins performante.

Cette API accepte 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.

Voici un exemple de reportParams. Reportez-vous à la documentation des rapports 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?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ée.

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 des listes non présentes dans le fichier JSON [>=3.0]
• dataListsToReplace ("") : permet de supprimer les lignes dans certaines listes uniquement [>=3.0]
• failOnAssociationNotFound (true) : lève une erreur si une entité associée est introuvable. Passez ce paramètre à false pour ignorer les associations introuvables [>=3.1]
• ignorePathOnSearch (false) : si le code beCPG ou le code ERP est fourni, 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 les requêtes de type DELETE suivantes :

<url>/becpg/remote/entity?nodeRef={nodeRef}&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 premiè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 DELETE "$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, consultez 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éée 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":"Branch description"
}

API Alfresco

Alfresco propose également une API REST documentée ici :

https://docs.alfresco.com/content-services/latest/

Vous pouvez la parcourir à cette URL :

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

Récupération des utilisateurs et groupes

Alfresco fournit des API pour récupérer les utilisateurs et leurs groupes associés.

Lister les utilisateurs

Utilisez l'endpoint suivant pour récupérer la liste des utilisateurs :

GET /alfresco/api/-default-/public/alfresco/versions/1/people

Récupérer les groupes d'un utilisateur

Utilisez l'endpoint suivant pour récupérer la liste des groupes associés à un utilisateur spécifique :

GET /alfresco/api/-default-/public/alfresco/versions/1/people/{Id}/groups

Remplacez {Id} par l'identifiant de l'utilisateur concerné.

Annexe 1 : exemples 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

Paramètre	Valeur
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

Paramètre	Valeur
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

Paramètre	Valeur
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

Paramètre	Valeur
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

Paramètre	Valeur
query	@bcpg\:erpCode:"TEST1"
format	json

Annexe 2 : utilitaire Java

beCPG fournit également une bibliothèque utilitaire Java permettant de faciliter les appels aux services REST. Cette bibliothèque 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 ses origines géographiques :

@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;
    }
}