Data Importer/fr

From CollectiveAccess Documentation
Jump to: navigation, search

<languages/> [Disponible dans la v1.4]

Résumé

A partir de la version 1.4 de CollectiveAccess, les utilisateurs peuvent réaliser leurs propres correspondances et migrer leurs sources de données directement depuis la ligne de commande ou depuis l'interface utilisateur de Providence (dans le menu "Import > Données"). Lancer un import de données nécessite de suivre 7 étapes, détaillées ci-dessous.

1 - Un utilisateur doit créer un document de correspondance qui servira à rapprocher la source des données et leur destination dans CollectiveAccess.

2 - Avant de lancer un import, il faut absolument sauvegarder la base de données en exécutant un dump de la base.

3 - Lorsque vous avez réalisé une sauvegarde et que votre document de correspondance est prêt, il faut ensuite lancer l'import soit depuis la ligne de commande soit depuis l'interface graphique.

4 - Une fois l'import exécuté, vérifiez les données dans CollectiveAccess à la recherche d'erreurs ou d'incohérences.

5 - Corrigez votre document de correspondance en fonction des erreurs trouvées.

6 - Rechargez le dump de la base pour que le système revienne dans son état avant l'import (et ainsi écraser les données que vous allez à nouveau importer).

7 - Lancer l'import à nouveau.

Formats acceptés en entrée

Actuellement : XLSX, XLS, MYSQL, Filemaker XML, Inmagic XML et MARC

A venir prochainement : texte délimité par des tabulations, CSV, OAI-PMH/DC

Créer une correspondance

Pour créer une correspondance, commencez par télécharger le modèle de correspondance d'import pour Excel disponible ici : (File:Data Import Mapping template.xlsx). Une fois que toutes les correspondances ont été saisies dans le modèle, il peut être chargé directement dans CollectiveAccess (Voir traiter une correspondance plus bas) et la page Créer et traiter une correspondance.

Ce fichier de correspondance fonctionne selon deux principes acquis sur vos données. 1 - que chaque ligne dans la source de données correspond à un enregistrement unique, et 2 - que chaque colonne correspond à une seule métadonnée.

Ci-dessous nous allons parcourir chaque colonne du fichier de correspondance. Dans la première colonne, vous devez définir le type de règle (Rule type) pour chaque colonne de donnée dans votre source. Consultez le tableau ci-dessous pour la description de chaque règle.

Types de règle (Rule types)

Rule type (type de règle) Description
Mapping Fait correspondre une colonne de la source de données (ou table.champ) vers une métadonnée de CollectiveAccess. Les correspondance peuvent utiliser des traitements supplémentaires (Refineries), voir plus bas.
SKIP Utiliser SKIP pour ignorer une colonne de la source de données ou un table.champ.
Constant Défini une colonne de la source de données (ou table.champ) à une valeur constante et arbitraire. Définir la valeur dans la colonne Source du fichier de correspondance. Correspond au champ CollectiveAccess idno pour un élément de liste.
Rule Réalise des actions durant l'import (telles qu'ignorer ou reformater les données) à partir d'expressions conditionelles. Constitué de deux parties : "Rule triggers" (interrupteurs) et "Rule actions" (actions).
Setting Définit des préférences pour la correspondance (voir ci-dessous).

Paramètres

Paramètre Description Notes sur le paramètre Exemple Actuellement supporté ?
name Nom de la correspondance Texte arbitraire Ma correspondance Implémenté
code Code alphanumérique de la correspondance Arbitraire, pas de caractères spéciaux ni d'espaces ma_correspondance Implémenté
inputFormats Définit quels types de sources (format) de données sont gérés par cette correspondance. Les valeurs sont les codes de format géré par les différents plugin DataReader. Vous pouvez spécifier des formats multiples par leurs codes dans une liste séparée par des points-virgules. Les codes actuellement supportés sont : XLSX, MYSQL. A venir : CSV, TAB, MARC. Si vous ne remplissez pas ce paramètre, la correspondance est supposée valide pour toutes les sources de données, ce qui est très peu probable. type de fichier XLSX;CSV;TAB Implémenté
table Définit la table correspondant aux données importées Correspond aux tables de la base CollectiveAccess ca_objects Implémenté
type Type à définir pour les enregistrements importés. Si l'import inclut une correspondance vers le champ type_id, celle-ci sera privilégiée et le paramètre type sera ignoré. identifiant d'élément de liste CollectiveAccess posters Implémenté
numInitialRowsToSkip Le nombre de lignes à ignorer en début de fichier. Utilisez ce paramètre pour ignorer différentes lignes correspondant à des entêtes de colonne au début d'une feuille de calcul valeur numérique 2 Implémenté
existingRecordPolicy Détermine comment les enregistrements déjà présents dans CollectiveAccess sont vérifiés et traités par la correspondance. Définit aussi comment les enregistrements créés par la correspondance sont ensuite fusionnés avec d'autres instances (par idno et/ou par labels préférés) de la source de données. none; skip_on_idno; merge_on_idno; overwrite_on_idno; skip_on_preferred_labels; merge_on_preferred_labels; overwrite_on_preferred_labels; skip_on_idno_and_preferred_labels; merge_on_idno_and_preferred_labels; overwrite_on_idno_and_preferred_labels none Implémenté
errorPolicy Détermine comment les erreurs sont gérées pour cet import. "Stop" arrêtera l'import à la première erreur. ignore; stop ignore Implémenté
archiveMapping Définir à "yes" pour enregistrer la correspondance dans la base ; "no" pour la supprimer après l'import yes; no yes A venir
archiveDataSets Définir à "yes" pour enregistrer les données source ou à "no" pour les effacer du serveur après l'import yes; no yes A venir

Source

La colonne source est utilisée pour définir précisément quel élément de la source de données doit être traitée ou ignorée. Vous pouvez aussi définir une valeur constante plutôt qu'une correspondance, en définissant le type de règle sur "Constant" et la colonne Source à la valeur (ex : "bon état" pour une métadonnée texte) ou l'idno de l'élément de liste (ex : "code_bon_etat" pour une métadonnée liée à une liste) correspondant à votre configuration CollectiveAccess.

Tableur
Si vous voulez faire correspondre la colonne B d'une feuille de calcul Excel, vous devrez définir la Source sur le numéro 2 (A = 1, B = 2, C = 3, et ainsi de suite). Pour cette correspondance, le contenu de la colonne B sera rapatrié. Si vous voulez ignorer cette colonne, vous devrez définir la valeur Rule Type à "Skip" et la valeur de la colonne Source à 2.

XML
Définir la colonne source du nom du tag XML, précédé d'un slash (par exemple /Sponsoring_Department or /inm:ContactName)

MARC
La valeur Source pour les fichiers MARC supporte les champs et les indicateurs. Par exemple : 100/a (champ=100; pas d'indicateur) 100/a/x (indicateur 1=x) 100/a/xy (indicateur 1=x; indicateur 2=y). Pour les sous-champs, formater le texte à importer avec l'option formatWithTemplate, par exemple {"formatWithTemplate": "^245/a ^245/b ^245/f ^245/g ^245/h ^245/k ^245/n ^245/p ^245/s"}

CA table.element

Vous avez déclaré la source de données dans la colonne précédente. Il faut maintenant définir la destination. A l'aide de la colonne table.élément, définissez où vous souhaitez que soit établie la correspondance dans CollectiveAccess. Si vous définissez la Source sur Skip (ignorer), bien sûr, vous n'aurez pas besoin de définir ceci. Si vous faites une correspondance de données ou si vous appliquez une valeur constante, vous devez définir une destination. Ceci est accompli dans cette colonne en saisissant la référence souhaitée sous la forme ca_table.element_code.

La table CollectiveAccess correspond aux tables principales de CollectiveAccess, alors que le code (element_code) est simplement le code que vous avez défini lors de la création d'un élément de métadonnée spécifique dans votre configuration.

Par exemple, pour faire correspondre une colonne titre de votre source de données dans CollectiveAccess, vous devez définir table.element de la manière suivante :

ca_objects.preferred_labels

Ceci va faire correspondre les données du champ de votre source indiquée vers le champ Titre d'un enregistrement Objet dans CollectiveAccess.

Groupe

Dans de nombreux cas, des lignes distinctes correspondront à des métadonnées regroupées dans un seul et même conteneur. Par exemple, un conteneur fréquemment utilisé est Date, qui contient deux éléments de métadonnée - un pour la date elle-même, et un autre pour une liste déroulante, indiquant le type de date (Date de création, Date d'acquisition, etc.)

Imaginons que dans votre source de données, il y ait un colonne qui contienne des valeurs de date, alors que la colonne d'à côté contient les types de dates.

Si les éléments de métadonnées dans CollectiveAccess sont rassemblées dans un conteneur, vous devez l'indiquer dans le document de correspondance en plaçant ces éléments Source dans un groupe. Sans cela, la valeur date sera affectée à un conteneur, alors que le type de date sera affecté à un autre conteneur (et chacun d'entre eux n'aurait pas la valeur réciproque définie !)

Créer un Groupe est très simple. Il suffit d'affecter un même nom à chaque ligne pour laquelle une correspondance doit être faite dans un seul conteneur.

Si la source "2" correspond à ca_objects_date.date_value, et la source "3" correspond à ca_objects_date.date_type, alors donnez à chaque ligne le même nom de groupe "Date". Ceci fera converger les valeurs de ces deux lignes dans un seul conteneur - et ne créera pas un nouveau conteneur pour chaque.

Traitements (refineries)

A l'heure actuelle, il existe dans CA 4 types de traitements : Splitters (diviseurs), Makers (créateurs), Joiners (assembleurs) et Getters (rapatrieurs). Chaque traitement est créé pour prendre des données dans un format spécifique et les transformer suivant un comportement prédéfini pour les importer ensuite dans CollectiveAccess.

Splitters (Diviseurs)
Les traitements Splitters (Diviseurs) peuvent soit créer des enregistrement, soit faire correspondre des données à des enregistrements existants (selon la configuration existingRecordPolicy de la correspondance) ou séparer une simple chaîne de caractères en différents éléments dans CollectiveAccess. Les Splitters pour les relations sont utilisés lorsque différents paramètres sont nécessaires, tels que définir un type d'enregistrement et définir un type de relation. A l'aide du post-traitement entitySplitter, un nom dans un seul emplacement (une colonne) dans une source de données peut être interprété dans le nouvel enregistrement (pour un prénom, un surnom, un nom de famille, un préfixe, un suffixe, etc ). De manière similaire, le traitement measurementSplitter répartit, par exemple, une liste de dimensions dans un conteneur de sous-éléments. "Splitter" permet aussi de séparer de multiples éléments de données, délimités dans un emplacement unique de la source, vers différents enregistrements uniques liés à l'enregistrement importé.

Makers (Créateurs)
Ces traitements sont utilisés pour créer des paires parcours/points du cours, lot d'objets/objet et liste/élément de liste. Ces relations sont différentes des autres relations de CollectiveAccess pour deux raisons. Tout d'abord, elles ne peuvent recevoir de type de relation. Ensuite, ces relations sont toujours du type unique vers multiple : un parcours peut avoir de nombreux points du parcours, mais un point du parcours ne peut être utilisé que pour un seul parcours. De manière similaire, un objet ne peut faire partie de plus d'un lot. Les éléments de liste appartienne à une seule et unique liste. Le traitement Maker est utilisé pour ces cas spécifiques, lorsque les types de relations (relationshipType) ne sont pas nécessaires.

Joiners (Assembleurs)
Par différents aspects, les Joiners sont à l'opposé des Splitters. Un traitement entityJoiner est utilisé lorsque deux ou plusieurs parties d'un nom (situé dans différentes zones de la source de données) doivent être assemblées dans un seul enregistrement. Le traitement dateJoiner crée un seule plage de date à l'aide de 2 éléments ou plus de la source de données.

Getters
Les Getters sont désignés spécifiquement pour les correspondances de données MySQL. Ces traitements font la correspondance de données répétables en rapprochant la table de la base de données source aux éléments correspondants dans la base CollectiveAccess.


Le traitement entitySplitter crée un enregistrement d'entité ou trouve une correspondance exacte (sur son nom) et crée une relation. Il reconnaît les partie d'un nom, défini un type et d'autres paramètres. NOTE : parce que le traitement entitySplitter crée de nouveaux enregistrements le chemin complement vers l'élément de données doit être spécifié dans le paramètre correspondant (sous la forme ca_table.container_code.subElement_code)

Post-traitement Paramètre du post-traitement Notes sur le paramètre Exemple
entitySplitter delimiter Définit la valeur du délimiteur qui sépare les valeurs dans la source de données {"delimiter": ";"}
entitySplitter relationshipType Accepte un code de constante pour un type de relation ou une référence à l'emplacement dans la source de données où le type de relation peut être trouvé {"relationshipType": "^10"} or {"relationshipType": "author"}
entitySplitter entityType Accepte un identifant tiré de la liste entity_types ou une référence à l'emplacement dans la source de données où le type peut être trouvé {"entityType": "person"}
entitySplitter attributes Définit ou fait correspondre les métadonnées de l'enregistrement pour l'entité en référençant le code de métadonnées (metadataElement) et l'emplacement où ces informations peuvent être trouvées dans la source de données {
  "attributes": {
      "address": {
          "address1": "^24",
          "address2": "^25",
          "city": "^26",
          "stateprovince": "^27",
          "postalcode": "^28",
          "country": "^29"
      }
  }

}

entitySplitter attributes:idno Pour faire correspondre les identifiants dans un entitySplitter, voir le paramètre 'attributes' ci-dessus. Une exception existe lorsque les identifiants sont générés automatiquement. Pour créer des identifiants automatiques avec un entitySplitter, utilisez la syntaxe suivante. "attributes": {"idno":"%"}
entitySplitter relationshipTypeDefault Définit le type de relation qui sera utilisé si aucun n'est défini ou si les valeurs de la source de données ne correspondent pas aux valeurs présentes dans CollectiveAccess {"relationshipTypeDefault":"creator"}
entitySplitter entityTypeDefault Définit le type d'entité par défaut qui sera utilisé si aucun n'est défini ou si les valeurs de la source de données ne correspondent pas à la liste entity_types {"entityTypeDefault":"individual"}
entitySplitter interstitial Définit les métadonnées pour l'enregistrement de la relation (entre la cible de la correspondance et l'entité liée via le "splitter") {
  "interstitial": {
      "relationshipDate": "^4"
  }

}

entitySplitter relatedEntities Ceci vous permet de créer et/ou lier d'autres entités à l'entité cible de la correspondance. Par exemple, si vous lancez un import pour des objets et que vous utilisez un entitySplitter pour générer des individus liés, mais que vous voulez aussi créer des enregistrements d'entité pour l'affiliation de chaque individu, utilisez ce paramètre. "Name" est le nom de l'entité, qui sera automatiquement découpé (prénom, nom, etc.) et importé. Si vous voulez faire correspondre une partie de la dénomination (nom de famille, prénom) vous pouvez ignorer "name" et utiliser "forename", "middlename", "surname", etc. "type", "attributes" et "relationshipType" fonctionnent exactement comme ils le feraient pour un autre "splitter". {"relatedEntities": [{"type":"ind", "name": "^3", "attributes":{}, "relationshipType":"related"}]}
entitySplitter nonPreferredLabels Fait correspondre les données source vers la métadonnée ca_entities.nonpreferred_labels (labels secondaires ou autres titres) de l'entité créée ou repéré par le post-traitement entitySplitter "nonPreferredLabels": [{"forename": "^5", "surname":"^6"}]

Le traitement collectionSplitter crée un enregistrement de collection ou trouve une correspondance exacte (basée sur le nom) et crée une relation à plat. collectionSplitter ne peut être utilisé que pour les relations linéaires (normales), pas pour les relations hiérarchiques. Pour les relations hiérarchiques, utilisez le traitement collectionHierarchyBuilder. NOTE : parce que le collectionSplitter crée de nouveaux enregistrements le chemins complet du conteneur doit être spécifié dans les attributs du paramètre (par exemple ca_table.container_code.subElement_code)

Traitement Paramètres Notes sur les paramètres Exemple
collectionSplitter delimiter Définit la valeur du délimiteur qui sépare les valeurs dans la source de données {"delimiter": ";"}
collectionSplitter relationshipType Accepte un code de constante pour un type de relation ou une référence à l'emplacement dans la source de données où le type de relation peut être trouvé. Note (pour les données d'objet) : si le type de relation correspondait déjà à une valeur dans la hiérarchie contrôlée, cet objet sera retiré de sa hiérarchie précédente et affectée en tant qu'élément "fils" dans la hiérarchie de la nouvelle collection. {"relationshipType": "part_of"}
collectionSplitter collectionType Accepte un identifant tiré de la liste collection_types ou une référence à l'emplacement dans la source de données où le type peut être trouvé {"collectionType": "box"}
collectionSplitter attributes Définit ou fait correspondre les métadonnées de l'enregistrement pour l'entité en référençant le code de métadonnées (metadataElement) et l'emplacement où ces informations peuvent être trouvées dans la source de données {
  "attributes": {
      "collectionDateSet": {
          "collectionDate": "^12"
      }
  }

}

collectionSplitter relationshipTypeDefault Définit le type de relation qui sera utilisé si aucun n'est défini ou si les valeurs de la source de données ne correspondent pas aux valeurs présentes dans CollectiveAccess {"relationshipTypeDefault":"part_of"}
collectionSplitter collectionTypeDefault Définit le type de collection par défaut qui sera utilisé si aucun n'est défini ou si les valeurs de la source de données ne correspondent pas à la liste collection_types {"collectionTypeDefault":"series"}
collectionSplitter parents Fait correspondre ou construit les niveaux parents au dessus de l'enregistrement lié aux données importées. Le paramètre parent a différents sous-paramètres dont :

idno: fait correspondre le niveau spécifique idno

name: fait correspondre le preferred_label

type: fait correspondre le type d'enregistrement (doit correspondre à l'identifiant idno exactement)

attributes: fait correspondre les métadonnées (optionnel). Inclut le code metadataElement et la source de données.

rules: fait correspondre toute règle (rule) supplémentaire.
{
  "parents": [
      {
          "idno": "^/inm:SeriesNo",
          "name": "^/inm:SeriesTitle",
          "type": "series",
          "attributes": { "ca_collections.description": "^7"}
      },
      {
          "idno": "^/inm:CollectionNo",
          "name": "^/inm:CollectionTitle",
          "type": "collection",
          "rules": [
              {
                  "trigger": "^/inm:Status = 'in progress'",
                  "actions": [
                      {
                          "action": "SET",
                          "target": "ca_collections.status",
                          "value": "edit"
                      }
                  ]
              }
          ]
      }
  ]

}

collectionSplitter interstitial Définit les métadonnées pour l'enregistrement intermédiaire (relation) : Relationship record (entre la cible de la correspondance et l'entité liée par le splitter) {
  "interstitial": {
      "relationshipDate": "^4"
  }

}

Le traitement collectionHierarchyBuilder est identique au collectionSplitter à l'exception d'une différence : au lieu de créer des enregistrements plats, il crée une relation hiérarchique entre les données importées et l'enregistrement parent créé par le traitement. Comme collectionSplitter, collectionHierarchyBuilder cherche d'abord une correspondance exacte (sur le nom) et si aucune n'est trouvée, le traitement crée les enregistrements nécessaires. NOTE : comme le traitement collectionHierarchyBuilder crée de nouveaux enregistrements, le chemin complet vers le conteneur doit être spécifié dans les attributs (par exemple ca_table.container_code.subElement_code)

Traitement Paramètres du traitement Notes sur les paramètres Exemple
collectionHierarchyBuilder parents Définit le ou les niveaux parents qui doivent être créés ou qui ont retrouvés dans la hiérarchie au dessus des données importées. Le paramètre parent a différent sous-paramètres dont:

idno: correspondance avec l'identifiant

name: établit une correspondance avec preferred_label

type: établit une correspondance avec le type d'enregistrement (doit correspondre à l'idno exactement)

attributes: fait correspondre les métadonnées avec des attributs. Inclut le code de la métadonnée et la source de données.

rules: maps any (optional) level-specific rules .
{
  "parents": [
      {
          "idno": "^/inm:SeriesNo",
          "name": "^/inm:SeriesTitle",
          "type": "series",
          "attributes": { "ca_collections.description": "^7"}
      },
      {
          "idno": "^/inm:CollectionNo",
          "name": "^/inm:CollectionTitle",
          "type": "collection",
          "rules": [
              {
                  "trigger": "^/inm:Status = 'in progress'",
                  "actions": [
                      {
                          "action": "SET",
                          "target": "ca_collections.status",
                          "value": "edit"
                      }
                  ]
              }
          ]
      }
  ]

}

Le traitement placeSplitter crée un enregistrement de lieu ou trouve une correspondance exacte (sur le nom) et crée une relation. NOTE : comme placeSplitter crée de nouveaux enregistrements, le chemin complet vers le conteneur doit être spécifié dans les attributs du paramètre (par exemple ca_table.container_code.subElement_code)

Post-traitement Paramètre du post-traitement Notes sur le paramètre Exemple
placeSplitter delimiter Définit la valeur du délimiteur qui sépare les valeurs dans la source de données {"delimiter": ";"}
placeSplitter relationshipType Accepte un code de constante pour un type de relation ou une référence à l'emplacement dans la source de données où le type de relation peut être trouvé. {"relationshipType": "location"}
placeSplitter placeType Accepte un identifant tiré de la liste place_types ou une référence à l'emplacement dans la source de données où le type peut être trouvé. {"placeType": "country"}
placeSplitter attributes Définit ou fait correspondre les métadonnées du lieu en indiquant le code de la métadonnée (metadataElement) et l'emplacement où ces informations peuvent être trouvées dans la source de données. {
  "attributes": {
      "placeNote": "^12"
  }

}

placeSplitter relationshipTypeDefault Définit le type de relation qui sera utilisé si aucun n'est défini ou si les valeurs de la source de données ne correspondent pas aux valeurs présentes dans CollectiveAccess {"relationshipTypeDefault":"location"}
placeSplitter placeTypeDefault Définit le type de lieu par défaut qui sera utilisé si aucun n'est défini ou si les valeurs de la source de données ne correspondent pas à la liste place_types {"placeTypeDefault":"country"}
placeSplitter hierarchy Identifie le code de la liste au sein de la liste place_hierarchies pour la hiérarchie de lieu sélectionnée. {"hierarchy": "dc"}
placeSplitter interstitial Définit les métadonnées pour l'enregistrement de la relation (entre la cible de la correspondance et le lieu lié par splitter) {
  "interstitial": {
      "relationshipDate": "^4"
  }

}

Le traitement measurementsSplitter formatte des valeurs qui correspondent à un élément contenant des données du type Length (longueur) ou Weight (poids). NOTE : measurementsSplitter ne crée pas de nouveaux enregistrements (il réalise seulement une correspondance), en conséquence le chemin intégral de l'élément ne doit pas être indiqué dans la colonne paramètre/attribut (utilisez juste le code du sous-élément subElement_code ou measurementsWidth)

Traitement Paramètres Notes sur les paramètres Exemple
measurementsSplitter delimiter Définit la valeur du délimiteur qui sépare les valeurs dans la source de données {"delimiter": ";"}
measurementsSplitter units Définit l'unité de mesure {"units": "cm"}
measurementsSplitter elements Fait correspondre les dimensions composantes à des éléments spécifiques de métadonnées {
  "elements": [
      {
          "quantityElement": "measurementWidth",
          "typeElement": "measurementsType",
          "type": "width"
      },
      {
          "quantityElement": "measurementHeight",
          "typeElement": "measurementsType2",
          "type": "height"
      }
  ]

}
Note : le type d'élément (typeElement) et les types de sous-composants sont optionnels et devraient être uniquement inclus lorsque les conteneurs incluent une liste déroulante pour les types de dimensions (avec cadre, sans cadre...).

measurementsSplitter attributes Fait correspondre les autres éléments distincts des dimensions qui peuvent être inclus dans le même conteneur. Les valeurs ici rassemblées sont définies pour toutes les mesures qui ont été séparées. {
  "attributes": {
      "notes": "^1"
  }

}

Le listitemSplitter crée un nouvel élément de liste ou trouve une correspondance exacte (basée sur le nom) et crée ensuite une relation. NOTE : listitemSplitter crée de nouveaux enregistrements et à ce titre, les chemins vers les conteneur doivent être spécifiés dans la colonne attributs (sous la forme ca_table.container_code.subElement_code)

Post-traitement Paramètre du post-traitement Notes sur le paramètre Exemple
listItemSplitter delimiter Définit la valeur du délimiteur qui sépare les valeurs dans la source de données {"delimiter": ";"}
listItemSplitter relationshipType Accepte une constante indiquant un type de relation ou une référence à l'emplacement dans la source de données où le type de relation peut être trouvé. {"relationshipType": "describes"}
listItemSplitter listItemType Accepte un identifant tiré de la liste correspondante ou une référence à l'emplacement dans la source de données où le type peut être trouvé. {"listItemType": "concept"}
listItemSplitter attributes Définit ou fait correspondre les métadonnées de l'élément de liste en indiquant le code de la métadonnée (metadataElement) et l'emplacement où ces informations peuvent être trouvées dans la source de données. Habituellement on ne définit pas d'attribut pour un élément de liste, mais vous pouvez le faire ici si vous en avez besoin. {
  "attributes": {
      "listItemNote": "^12"
  }

}

listItemSplitter parents Fait correspondre ou construit les niveaux parents au dessus de l'enregistrement lié aux données importées. Le paramètre parent a différents sous-paramètres dont :

idno: fait correspondre le niveau spécifique idno

name: fait correspondre le preferred_label

type: fait correspondre le type d'enregistrement (doit correspondre à l'identifiant idno exactement)

attributes: fait correspondre les métadonnées (optionnel). Inclut le code metadataElement et la source de données.

rules: fait correspondre toute règle (rule) supplémentaire.
{
  "parents": [
      {
          "idno": "^12",
          "name": "^14",
          "type": "concept",
          "attributes": { "ca_list_items.description": "^7"}
      },
      {
          "idno": "^16",
          "name": "^17",
          "type": "guide",
          "rules": [
              {
                  "trigger": "^3= 'in progress'",
                  "actions": [
                      {
                          "action": "SET",
                          "target": "ca_list_items.status",
                          "value": "edit"
                      }
                  ]
              }
          ]
      }
  ]

}

listItemSplitter list Saisir l'identifiant de la liste (list_code) pour la liste dans laquelle l'élément doit être ajouté. Ceci est obligatoire - si vous oubliez de le définir ou que vous le définissez sur un list_code qui n'existe pas dans la base, la correspondance va échouer. {"list": "list_code"}
listItemSplitter relationshipTypeDefault Définit le type de relation qui sera utilisé si aucun n'est défini ou si les valeurs de la source de données ne correspondent pas aux valeurs présentes dans CollectiveAccess {"relationshipTypeDefault":"concept"}
listItemSplitter listItemTypeDefault Définit le type d'élément de liste qui sera utilisé si aucun n'est défini ou que les valeurs de la source de données ne correspondent à aucune valeur dans la liste list_item_types {"listItemTypeDefault":"concept"}

Le tourStopSplitter crée un nouvel élément de liste ou trouve une correspondance exacte (basée sur le nom) et crée ensuite une relation. NOTE : tourStopSplitter crée de nouveaux enregistrements et à ce titre, les chemins vers les conteneur doivent être spécifiés dans la colonne attributs (sous la forme ca_table.container_code.subElement_code)

Post-traitement Paramètre du post-traitement Notes sur le paramètre Exemple
tourStopSplitter delimiter Définit la valeur du délimiteur qui sépare les valeurs dans la source de données {"delimiter": ";"}
tourStopSplitter relationshipType Accepte une constante indiquant un type de relation ou une référence à l'emplacement dans la source de données où le type de relation peut être trouvé. {"relationshipType": "linked"}
tourStopSplitter tourStopType Accepte un identifant tiré de la liste correspondante ou une référence à l'emplacement dans la source de données où le type peut être trouvé. {"tourStopType": "main_stop"}
tourStopSplitter attributes Définit ou fait correspondre les métadonnées de l'élément de liste en indiquant le code de la métadonnée (metadataElement) et l'emplacement où ces informations peuvent être trouvées dans la source de données. {
  "attributes": {
      "stopDescription": "^11"
  }

}

tourStopSplitter tour Identifie le parcours auquel raccrocher le point du parcours. {"tour": "tour_code"}
tourStopSplitter relationshipTypeDefault Définit le type de relation qui sera utilisé si aucun n'est défini ou si les valeurs de la source de données ne correspondent pas aux valeurs présentes dans CollectiveAccess {"relationshipTypeDefault":"linked"}
tourStopSplitter tourStopTypeDefault Définit le type d'élément de liste qui sera utilisé si aucun n'est défini ou que les valeurs de la source de données ne correspondent à aucune valeur dans la liste tour_stop_types {"tourStopTypeDefault":"main_stop"}

Le traitement storageLocationSplitter crée une nouvelle entrée dans la liste hiérarchique des emplacements de stockage.

Post-traitement Paramètre du post-traitement Notes sur le paramètre Exemple
storageLocationSplitter hierarchicalStorageLocationTypes Définit le type d'emplacement de stockage utilisé pour indiquer chaque niveau dans une hiérarchie descendante. {
   "hierarchicalStorageLocationTypes": [
       "room",
       "rack",
       "cabinet"
   ]

}

storageLocationSplitter delimiter Définit la valeur du délimiteur qui sépare les valeurs dans la source de données {"delimiter": ";"}
storageLocationSplitter hierarchicalDelimiter Définit la valeur du délimiteur qui indique où séparer les valeurs pour indiquer les valeurs de hierarchicalStorageLocationTypes {"hierarchicalDelimiter":"."}
storageLocationSplitter parents Fait correspondre ou construit les niveaux parents au dessus de l'enregistrement lié aux données importées. Le paramètre parent a différents sous-paramètres dont :

idno: fait correspondre le niveau spécifique idno

name: fait correspondre le preferred_label

type: fait correspondre le type d'enregistrement (doit correspondre à l'identifiant idno exactement)

attributes: fait correspondre les métadonnées (optionnel). Inclut le code metadataElement et la source de données.

rules: fait correspondre toute règle (rule) supplémentaire.
{
   "parents": [
       {
           "idno": "^10",
           "name": "^12",
           "type": "cabinet",
           "attributes": { "ca_storage_location.description": "^7"}
       },
       {
           "idno": "^14",
           "name": "^16",
           "type": "room",
           "rules": [
               {
                   "trigger": "^18= 'in progress'",
                   "actions": [
                       {
                           "action": "SET",
                           "target": "ca_storage_locations.status",
                           "value": "edit"
                       }
                   ]
               }
           ]
       }
   ]

}

storageLocationSplitter interstitial Défini les métadonnées pour l'enregistrement de la relation (entre la cible de la correspondance et l'entité liée via le "splitter") {
   "interstitial": {
       "relationshipDate": "^4"
   }

}

Le traitement loanSplitter crée un nouveau prêt entrant ou prêt sortant.

Post-traitement Paramètre du post-traitement Notes sur le paramètre Exemple
loanSplitter loanType Accepte un identifant tiré de la liste correspondante ou une référence à l'emplacement dans la source de données où le type peut être trouvé. {"loanType":"out"}
loanSplitter relationshipType Accepte une constante indiquant un type de relation ou une référence à l'emplacement dans la source de données où le type de relation peut être trouvé. Note pour les données des objets : si le type de relation correspond à celui qui est défini pour le contrôle de hiérarchie, l'objet sera rappatrié en tant qu'élément "fils" de cette hiérarchie des prêts {"relationshipType":"part_of"}
loanSplitter delimiter Définit la valeur du délimiteur qui sépare les valeurs dans la source de données {"delimiter": ";"}
loanSplitter attributes Définit ou fait correspondre les métadonnées de l'élément de liste en indiquant le code de la métadonnée (metadataElement) et l'emplacement où ces informations peuvent être trouvées dans la source de données. {
   "attributes": {
       "loanDate": "^11"
   }

}

loanSplitter relationshipTypeDefault Définit le type de relation qui sera utilisé si aucun n'est défini ou si les valeurs de la source de données ne correspondent pas aux valeurs présentes dans CollectiveAccess. {"relationshipTypeDefault":"part_of"}
loanSplitter loanTypeDefault Définit le type de prêt qui sera utilisé si aucun n'est défini ou que les valeurs de la source de données ne correspondent à aucune valeur dans la liste loan_types. {"loanTypeDefault":"in"}
loanSplitter interstitial Définit les métadonnées pour l'enregistrement de la relation (entre la cible de la correspondance et l'entité liée via le "splitter") {
   "interstitial": {
       "relationshipDate": "^4"
   }

}

Le tourMaker crée un parcours parent dans une correspondance créant des points d'un parcours.

Post-traitement Paramètre du post-traitement Notes sur le paramètre Exemple
tourMaker tourType Accepte un identifant tiré de la liste correspondante ou une référence à l'emplacement dans la source de données où le type peut être trouvé. {"tourType": "full_tour"}
tourMaker attributes Définit ou fait correspondre les métadonnées de l'élément de liste en indiquant le code de la métadonnée (metadataElement) et l'emplacement où ces informations peuvent être trouvées dans la source de données. {
   "attributes": {
       "tour_code": "^1"
   }

}

tourMaker tourTypeDefault Définit le type d'élément de liste qui sera utilisé si aucun n'est défini ou que les valeurs de la source de données ne correspondent à aucune valeur dans la liste tour_types {"tourTypeDefault": "full_tour"}


Le traitement dateJoiner rassemble deux sources de données différentes dans une seule plage temporelle (début-fin) au sein d'un seul champ dans CollectiveAccess.

Post-traitement Paramètre du post-traitement Notes sur le paramètre Exemple
dateJoiner mode Détermine la façon avec laquelle joindre les dates. Une plage de dates sur deux colonnes ("range") est le mode par défaut si aucun n'est défini. Les options disponibles sont : multiColumnDate (date multi-colonnes), multiColumnRange (plage de dates multi-colonnes), range (plage de dates sur deux colonnes) {"mode": "multiColumnDate"}
dateJoiner month Fait correspondre la valeur du mois de la date avec la source de données (concerne multiColumnDate). {"month": "^4"}
dateJoiner day Fait correspondre la valeur du jour de la date avec la source de données (concerne multiColumnDate). {"day": "^5"}
dateJoiner year Fait correspondre la valeur de l'année de la date avec la source de données (concerne multiColumnDate). {"year": "^6"}
dateJoiner startDay Fait correspondre la valeur du jour de début de la plage de dates avec la source de données (concerne multiColumnRange). {"startDay": "^4"}
dateJoiner startMonth Fait correspondre la valeur du mois de début de la plage de dates avec la source de données (concerne multiColumnRange). {"startMonth": "^5"}
dateJoiner startYear Fait correspondre la valeur de l'année de début de la plage de dates avec la source de données (concerne multiColumnRange). {"startYear": "^6"}
dateJoiner endDay Fait correspondre la valeur du jour de fin de la plage de dates avec la source de données (concerne multiColumnRange). {"endDay": "^7"}
dateJoiner endMonth Fait correspondre la valeur du jour de fin de la plage de dates avec la source de données (concerne multiColumnRange). {"endMonth": "^8"}
dateJoiner endYear Fait correspondre la valeur de l'année de fin de la plage de dates avec la source de données (concerne multiColumnRange). {"endYear": "^9"}
dateJoiner expression Expression de date (concerne "range") {"expression" : "^dateExpression"}
dateJoiner start Fait correspondre la source de données à la date de début de la plage de dates cible (concerne "range") {"start" : "^dateBegin"}
dateJoiner end Fait correspondre la source de données à la date de fin de la plage de dates cible (concerne "range") {"end": "^dateEnd"}

Le traitement entityJoiner rassemble des données de deux sources ou davantage (par exemple deux colonnes d'une feuille de calcul) pour créer un seul enregistrement d'entité. Ce traitement doit être utilisé quand les prénoms et noms, par exemple, sont dans deux colonnes différentes. NOTE : comme le traitement entityJoiner crée de nouveaux enregistrement, le chemin complet vers le contenur doit être spécifié dans la colonne attributs (par exemple sous la forme ca_table.container_code.subElement_code)

Post-traitement Paramètre du post-traitement Notes sur le paramètre Exemple
tourStopSplitter delimiter Définit la valeur du délimiteur qui sépare les valeurs dans la source de données {"delimiter": ";"}
tourStopSplitter relationshipType Accepte une constante indiquant un type de relation ou une référence à l'emplacement dans la source de données où le type de relation peut être trouvé. {"relationshipType": "linked"}
tourStopSplitter tourStopType Accepte un identifant tiré de la liste correspondante ou une référence à l'emplacement dans la source de données où le type peut être trouvé. {"tourStopType": "main_stop"}
tourStopSplitter attributes Définit ou fait correspondre les métadonnées de l'élément de liste en indiquant le code de la métadonnée (metadataElement) et l'emplacement où ces informations peuvent être trouvées dans la source de données. {
  "attributes": {
      "stopDescription": "^11"
  }

}

tourStopSplitter tour Identifie le parcours auquel raccrocher le point du parcours. {"tour": "tour_code"}
tourStopSplitter relationshipTypeDefault Définit le type de relation qui sera utilisé si aucun n'est défini ou si les valeurs de la source de données ne correspondent pas aux valeurs présentes dans CollectiveAccess {"relationshipTypeDefault":"linked"}
tourStopSplitter tourStopTypeDefault Définit le type d'élément de liste qui sera utilisé si aucun n'est défini ou que les valeurs de la source de données ne correspondent à aucune valeur dans la liste tour_stop_types {"tourStopTypeDefault":"main_stop"}


Post-traitement Paramètre du post-traitement Notes sur le paramètre Exemple
entityJoiner entityType Accepte un identifant tiré de la liste entity_types ou une référence à l'emplacement dans la source de données où le type peut être trouvé. {"entityType": "person"}
entityJoiner entityTypeDefault Définit le type d'élément de liste qui sera utilisé si aucun n'est défini ou que les valeurs de la source de données ne correspondent à aucune valeur dans la liste entity_types. {"entityTypeDefault": "person"}
entityJoiner forename Définit une constante pour le prénom ou un emplacement ou celui-ci peut être trouvé dans les données source {"forename":"^3"}
entityJoiner surname Définit une constante pour le nom de famille ou un emplacement ou celui-ci peut être trouvé dans les données source {"surname": "^2"}
entityJoiner other_forenames Définit une constante pour les autres prénoms ou un emplacement ou ceux-ci peuvent être trouvés dans les données source {"other_forenames": "^10"}
entityJoiner middlename Définit une constante pour le middlename (nom intermédiaire chez les anglo-saxons) ou un emplacement ou celui-ci peut être trouvé dans les données source. {"surname": "^12"}
entityJoiner displayname Définit une constante pour le nom utilisé pour l'affichage ou un emplacement ou celui-ci peut être trouvé dans les données source {"displayname": "^14"}
entityJoiner prefix Définit une constante pour le préfixe ou un emplacement ou celui-ci peut être trouvé dans les données source. {"prefix": "^14"}
entityJoiner suffix Définit une constante pour le suffixe ou un emplacement ou celui-ci peut être trouvé dans les données source. {"suffix": "^14"}
entityJoiner attributes Définit ou fait correspondre les métadonnées de l'élément de liste en indiquant le code de la métadonnée (metadataElement) et l'emplacement où ces informations peuvent être trouvées dans la source de données. {
   "attributes": {
       "agentDateSet": {
           "agentDate": "^12"
       }
   }

}

entityJoiner nonpreferred_labels Liste de valeurs pour les autres dénominations (non-preferred labels) ou références aux emplacements dans la source de données où ils peuvent être trouvés. Utiliser la valeur split pour un label pour indiquer où celui-ci devrait être découpé avant l'import. {
   "nonpreferred_labels": [
       {
           "forename": "^5",
           "surname": "^6"
       }
   ]

}
OU
{

   "nonpreferred_labels": [
       {
           "split": "^4"
       }
   ]

}

entityJoiner relationshipType Accepte une constante pour définir le type de relation ou une référence à un emplacement dans les données source où le type est indiqué {"relationshipType": "^10"}
entityJoiner relationshipTypeDefault Définit le type de relation par défaut qui sera utilisé si aucun n'est indiqué ou que les valeurs de la source de données ne correspondent à aucune valeur dans la base CollectiveAccess. {"relationshipTypeDefault": "author"}
entityJoiner skipIfValue Ignorer si la valeur importée est dans la liste de valeurs indiquées. {"skipIfValue": "unknown"}
entityJoiner relatedEntities Ceci vous permet de créer et/ou de lier des entités supplémentaires à l'entité qui est créé/liée. Par exemple, si vous exécutez un import pour des objets et que vous utilisez entityJoiner pour générer des individus, vous pouvez également souhaiter créer des enregistrements pour l'affiliation de chaque individu à une collectivité, utilisez ce paramètre. "Name" est le nom de l'entité, qui sera automatiquement divisés en plusieurs parties et importé. Si vous voulez de manière explicite faire correspondre des parties d'un nom (nom de famille, prénom), vous pouvez ne pas indiquer "name" et utiliser directement "forename", "middlename", "surname", etc. "type", "attributes" et "relationshipType" fonctionne de la manière habituelle pour un splitter. {"relatedEntities": [{"type":"ind", "name": "^3", "attributes":{}, "relationshipType":"related"}]}
entityJoiner interstitial Définit les métadonnées pour l'enregistrement interstitiel (entre la cible de la correspondance et l'entité liée par le splitter) {
   "interstitial": {
       "relationshipDate": "^4"
   }

}


Le traitement ATRelatedGetter fonctionne avec la base de données MySQL utilisée par ArchivistToolkit. Il fait correspondre les données répétées dans la source en les liens avec la table de données de CollectiveAccess qui correspond aux bons éléments.

Post-traitement Paramètre du post-traitement Notes sur le paramètre Exemple
ATRelatedGetter table Table Archivists Toolkit. {"table":"ArchDescriptionRepeatingData"}
ATRelatedGetter discriminator Valeur discriminante. {"discriminator":"note"}
ATRelatedGetter key champ clé Archivists Toolkit. {"key":"DigitalObjects.digitalObjectId"}
ATRelatedGetter map Correspondance des valeurs dans les tables liées avec un élément de métadonnée dans la base CollectiveAccess. {
   "map": {
       "descriptionText": "^noteContent",
       "descriptionSource": "repository"
   }

}

Options

Les options vous permettent de définir un formatage complémentaire et conditionnel aux données durant l'import. Certaines options sont créées pour définir certains paramètres liés au comportement de la correspondance, comme l'option skip. skipGroupIfEmpty, par exemple, vous permet d'éviter d'importer certains champs, suivant la présence d'une donnée dans un autre champ. D'autres options vous permettent de formater des données comme formatWithTemplate, suffix et convertNewlinesToHTML.

Option Description Notes Exemple
skipGroupIfEmpty Si la valeur liée à cette ligne de correspondance est vide, ignore la correspondance pour toutes les autres valeurs du groupe définir à une valeur non nulle {"skipGroupIfEmpty": 1}
skipGroupIfValue Si la valeur liée à cette ligne de correspondance contient la valeur indiquée, ignore la correspondance pour cette valeur et toutes les autres valeurs du groupe valeur arbitraire {"skipGroupIfValue": ["n/a"]}
skipGroupIfNotValue Si la valeur liée à cette ligne de correspondance ne contient pas la valeur indiquée, ignore la correspondance pour cette valeur et toutes les autres valeurs du groupe arbitrary value {"skipGroupIfNotValue": ["n/a"]}
skipGroupIfExpression Si l' expression indiquée est vraie, ignore la correspondance pour cette donnée et toutes les autres données dans le groupe valeur arbitraire {"skipGroupIfExpression":"^/inm:FileNo <> \"\""}
skipRowIfEmpty Si la valeur indiquée dans cette ligne de correspondance est vide, ne pas importer la ligne défini à une valeur autre que 0 {"skipRowIfEmpty": 1}
skipRowIfValue Si la valeur indiquée dans cette ligne de correspondance contient la valeur indiquée, ne pas importer la ligne {"skipRowIfValue": ["n/a"]}
skipRowIfNotValue Si la valeur indiquée dans cette ligne de correspondance ne contient aucune des valeurs indiquées, ne pas importer la ligne valeur arbitraire {"skipRowIfNotValue": ["n/a"]}
refineries Définit le traitement qui réalise la fonction modifant les données source pour qu'elles correspondent à la mise en forme demandée dans CollectiveAccess réalise une sélection des différents traitements dateJoiner
original_values Liste de valeurs séparées par des sauts de ligne dans les données source à remplacer. Par exemple, "photo" est utilisé dans la source de données, mais "photographie" est utilisé dans CollectiveAccess. valeurs de la source de données sound recording
replacement_values Liste d'identifiants (idno) séparés par des sauts de ligne qui correspondent à des valeurs de la source de données. Par exemple, "sound recording" (saisi dans la colonne Original values (valeur d'origine)) correspond à audio_digital, qui saisi ici dans la colonne Replacement values (valeurs de remplacement). identifiants d'élément de liste CollectiveAccess audio_digital
default Valeur à utiliser si la source de données est vide Identifiant d'élément de liste CollectiveAccess {"default": "mixed"}
delimiter Définit la valeur du délimiteur qui sépare les valeurs dans la source de données delimiter value {"delimiter": ";"}
restrictToTypes Restreint la correspondance aux seuls enregistrements du type indiqué. Par exemple, le champ durée n'est applicable qu'aux objets du type moving_image (image animée) et pas pour ceux du type photograph (photo). CollectiveAccess list item idnos {
   "restrictToTypes": [
       "photograph",
       "other",
       "mixed",
       "text"
   ]

}

formatWithTemplate Formate un champ pour inclure des mots et des valeurs depuis un template (modèle). mélange de texte et de sources de données {"formatWithTemplate": "Peinture #^15 créée par ^2"}
suffix Ajoute une valeur texte à la fin d'une valeur de la source de données. texte arbitraire {"suffix": " tons"}
excludeToTypes Non implémenté. Cette option serait l'inverse de restrictToTypes. {
   "excludeToTypes": [
       "photograph",
       "text"
   ]

}

maxLength La longueur maximum, en nombre de caractères, à autoriser. Les valeurs au delà de cette longueur seront tronquées à la taille maximale autorisée. {"maxLength":100}
errorPolicy Détermine comment sont gérées les erreurs. "Stop" arrêtera l'import à la première erreur pour cette correspondance. ignore ; stop ignore
convertNewlinesToHTML Convertit les sauts de lignes vers des balises HTML <BR/> dans le texte importé. La valeur doit être à 0 ou à 1. 0 par défaut – ne pas convertir. {"convertNewlinesToHTML":"1"}

Valeurs d'origine et valeurs de remplacement

Dans certains cas, vous pouvez souhaiter trouver certaines valeurs dans votre source de données et les remplacer par de nouvelles valeurs. Dans la colonne Original Value (valeur d'origine), saisissez toutes les valeurs à remplacer. Ensuite, dans la colonne Replacement Value (valeur de remplacement), saisissez les nouvelles valeurs. Vous pouvez ajouter des valeurs multiples dans une seule cellule, pour peu que les valeurs de remplacement correspondent aux valeurs d'origine ligne par ligne.

Cette fonctionnalité peut être utilisée pour corriger les erreurs de saisie les plus courantes dans la source de données, ou pour simplement normaliser les noms et les termes, ou pour se conformer à certaines codes dont la valeur est fixée dans CollectiveAccess.

Transformer des valeurs à l'aide d'une feuille de calcul

Utiliser les colonnes valeurs d'origine et de remplacement est suffisant pour une petite quantité de valeurs. Pour de grandes listes de vocabulaire, préférez utiliser l'option "transformValuesUsingWorksheet".

Vous pouvez utiliser cette option pour référence une liste de valeurs différentes dans une feuille de calcul séparée, au sein du document de correspondance Excel. Le formatage de cette feuille doit contenir les valeurs d'origine dans la première colonne, et les valeurs de remplacement dans le deuxième colonne.

L'option de correspondance "transformValuesUsingWorksheet" prend un nom de feuille de calcul et chargera les première et deuxième colonnes de cette feuille respectivement en tant que valeur d'origine et de remplacement. Lorsque cette option est définie, toute valeur présente dans les colonnes valeurs d'origine et valeurs de remplacement sera ignorée, même si la feuille de calcul définie par "transformValuesUsingWorksheet" est vide ou n'existe pas.

Vous vous referrez à la feuille par son nom. Ainsi la syntaxe des options de votre document de correspondance Excel devrait ressembler à ceci :

{"transformValuesUsingWorksheet":"Titre de la feuille de calcul"}

Encore une fois, si vous devez transformer un petit nombre de valeurs, utilisez simplement les colonnes Original/Replacement (valeur d'origine/valeur de remplacement) dans la feuille de calcul. Si vous devez transformer une très grande liste, créez une feuille de calcul supplémentaire, donnez lui un nom, ajoutez vos valeurs d'origine et de remplacement dans les deux premières colonnes, et définissez l'option transformValuesUsingWorksheet.

Rules (Règles)

Les règles vous permettent de définir des conditions au sein de votre correspondance basée sur les enregistrements avec des actions cibles conditionnées par tests vrai/faux. Avec les règles, vous pouvez manipuler la migration de données spécifiques et/ou définir des métadonnées basées sur des expressions. Par exemple, imaginons que vous voulez ignorer un enregistrement de votre source de données si un de ses éléments correspond à une valeur spécifique. Les Rules (règles) vous permettent de définir une action cible, telle que "SKIP" (ignorer) lorsque la valeur cible est trouvée.

Les règles reposent sur une opération en deux parties définies dans la correspondance d'import. Le premier composant est appelé "Rule triggers", il s'agit d'un expression qui résulte dans une quantité évaluée par l'import de données. La seconde partie est appelée "Rule actions" qui désigne des actions en fonction de l'évaluation de l'expression.

Parcourons ensemble un exemple. Pour un regard plus poussé sur l'écriture des "Rule triggers" (interrupteurs) à l'aide d'Expressions, veuillez consulter la page Expressions.

Pour notre exemple, nous allons ignorer tous les enregistrements avec la phrase "do not use" dans la description. Pour réaliser cela, nous écrivons une expression pour correspondre à "do not use" dans le champ requis, et ensuite l'action, à exécuter lorsque l'expression est vraie, à "SKIP". Pour simplifier l'exemple, nous importons un fichier tableur Excel et la description est située dans la colonne 5 :

Voici la façon dont la règle doit être indiquée dans la correspondance d'import :

Rule.png

Définir "Rule" (règle) comme type de règle et ajoutez ce qui suit dans la colonne "Rule triggers" (interrupteurs pour la règle) :

(^5 =~ /ne pas utiliser/)

Où ^5 faire référence à la colonne 5 et =~ fait appel à l'opérateur d'expression régulière. Dans la colonne "actions", se place uniquement une référence à l'action :

SKIP

Remarquez que vous pouvez potentiellement ajouter différentes actions à une simple règle en séparant les actions par des sauts de ligne (au sein de la même cellule). Actuellement, la seule action possible est "SKIP" (ignorer), qui va ignorer tout l'enregistrement plutôt que l'importer. Une action "SET", qui définit un champ lors de l'import à une valeur spécifique, est prévue dans le développement de CollectiveAccess prochainement.

Lancer un import

Pour lancer un import depuis la ligne de commandes, suivez ces instructions

Avant de commencer, il faut mieux trouver un emplacement pour vos correspondances et vos données qui soit facilement accessibles sans utiliser un trop long chemin. Pour la facilité de notre exemple, nos fichiers d'import seront dans un répertoire de Providence :

/support/project/mappings et
/support/project/data

Vous voudrez aussi faire une sauvegarde avant de lancer l'import.

mysqldump -u#name -p#password project > ~/project_date.dump

L'import est lancé à l'aide de caUtils. Pour voir toutes les tâches possibles, appelez l'aide de la commande depuis le répertoire support.

cd /path_to_Providence/support
bin/caUtils help

Pour plus d'informations sur l'utilitaire load-import-mapping :

bin/caUtils help load-import-mapping

Vous verrez que la commande load-import-mapping est nécessaire pour indiquer le fichier de correspondance. Pour charger le fichier de correspondance :

bin/caUtils load-import-mapping --file=project/mappings/mapping1.xlsx

Ensuite vous utilisez l'utilitaire import-data. Comme vous pouvez le voir avec

bin/caUtils help import-data

il y a différentes options pour vous permettre de désigner le format, la source de données, les préférences de log, etc. Pour lancer l'import :

bin/caUtils import-data --format=XLSX --mapping=mapping1 --source=project/data/Data.xlsx --log=project/log

L'extension PHP ncurses affichera des indicateurs sur le statut d'import dont la progression d'import et les erreurs récentes.

Pour modifier votre import et relancer l'utilitaire, restaurez simplement la base

mysql -u#name -p#password project < ~/project_date.dump

et recommencez le processus !

Problèmes habituels

Cette section sert à rassembler les erreurs les plus courantes (et leurs solutions).

ca_object_lots - Lors d'une correspondance avec la table des Lots, il faut se souvenir qu'un lot nécessite plus qu'un simple type et un libellé. Celui-ci a un "lot_status_id" obligatoire tiré de la liste des statuts de lot (Gérer > Listes et vocabulaires). Il doit être défini et fixé à une valeur valide sinon l'import va échouer, et renvoyer un message d'erreur. Soyez donc sûr de définir une valeur constante pour ca_object_lots.lot_status_id. Vous pouvez relever cette valeur depuis la liste des "types de lot" via Gérer > Listes et vocabulaires. Notez aussi que les identifiants pour la table ca_object_lots ne se trouvent pas dans le champ habituel idno mais à la place dans ca_object_lots.idno_stub.

Groupes - Lorsque vous faites des correspondances à plus d'un élément de métadonnées au sein d'un même conteneur, n'oubliez d'utiliser la colonne Group pour les rattacher tous à un seul conteneur global. Vous pouvez faire ceci en définissant un "nom de groupe" identique pour chacun des éléments.

Tableur Open/LibreOffice - Si vous chargez des données depuis une feuille de calcul créée dans Open/LibreOffice, le détecteur de date pose problème pour ces fichiers enregistrés en XLS/XLSX, nous vous conseillons d'enregistrer le fichier au format tableur ODF (*.ods). Vous pouvez utiliser l'import XLS / XLSX avec ces feuilles de calculs, même au format ODS. Le fichier de correspondance d'import peut lui rester au format XLSX, même en traitant un fichier ODS.

ca_entities.preferred_labels - Lorsque vous lancez une correspondance avec pour table cible ca_entities, et que la source de données est formatée sous la forme "prénom nom" (par exemple Jane Doe), vous devez assumer que la cible doit simplement être définie vers ca_entities.preferred_labels. Toutefois une étape supplémentaire est requise. Telle que, la correspondance ne reconnaitrait pas le prénom et le nom. Le nom de famille serait vide, et la correspondance serait ignorée. Dans ce cas, un traitement entitySplitter est actuellement requis dans les cas suivants :

1. Définir l'élément cible ca_table.element sur "ca_entities.preferred_labels"
2. Définir le traitement (refinery) sur entitySplitter.
3. Définir les paramètres du traitement de la manière suivante :
{"entityType": "entity_type", "skipIfValue": ["unknown"]}

i_sphinx

Namespaces

Variants
Actions
Navigation
Tools
User
Personal tools