Utilisateur

Information sur l'utilisateur

Champ	Signification	Exemple de Valeur
elementId	Identifiant unique global dans Neo4j pour le nœud.	4:d6babb03-ca8b-420a-adaa-b2560e937bd2:113982
id	Identifiant interne du nœud ou de l'entité (généralement une clé primaire).	113982
UNIQUE IMPORT ID	Identifiant unique utilisé lors de l'importation des données dans la base.	10255
accommodation	Type d'hébergement associé à l'utilisateur (par exemple, interne/externe).	INTERNE 6 JOURS
activationCode	Code d'activation généré pour permettre à l'utilisateur de valider son compte.	gnp9zf6y
address	Adresse postale de l'utilisateur.	769 boulevard dominique jamet
attachmentId	Identifiant lié à un fichier ou document attaché (par exemple, photo de profil).	1984341
birthDate	Date de naissance de l'utilisateur au format ISO 8601.	2002-08-14
checksum	Somme de contrôle générée pour vérifier l'intégrité des données associées à l'utilisateur.	6017a638def692cc930f82815873a5dbe47c5701
city	Ville de résidence de l'utilisateur.	SEYSSINS
classes	Identifiant(s) de classe(s) associée(s) à l'utilisateur, souvent structuré avec un préfixe.	950436$PSI
country	Pays de résidence de l'utilisateur.	FRANCE
created	Date et heure de création de l'entité dans la base au format ISO 8601.	2022-12-13T12:38:17.311Z
displayName	Nom complet affiché de l'utilisateur (prénom + nom).	CARTHY001 Wilton
displayNameSearchField	Version normalisée du nom complet utilisée pour les recherches (tout en minuscules, sans espaces).	carthy001wilton
externalId	Identifiant externe provenant d'un système tiers (par exemple, un SSO ou autre annuaire).	938535
fieldOfStudy	Codes des matières ou domaines d'études suivis par l'utilisateur.	003300,022700,030102,030201,061300,063300,065700,067000,100100,240500
fieldOfStudyLabels	Noms des matières ou domaines d'études correspondants aux codes.	TRAVAUX INITIAT.PERSONNEL ENCADRES,FRANCAIS-PHILOSOPHIE,...
firstName	Prénom de l'utilisateur.	Wilton
firstNameSearchField	Version normalisée du prénom utilisée pour les recherches (tout en minuscules).	wilton
groups	Identifiants des groupes ou classes auxquels l'utilisateur appartient.	950436$CPGEAL12,950436$PSI GR2,950436$CPGE GREPS
ine	Numéro INE (Identifiant National Élève), utilisé pour identifier les étudiants en France.	977231106YZ
joinKey	Clé utilisée pour joindre des données entre différents systèmes ou entités.	938535
lastName	Nom de famille de l'utilisateur.	CARTHY001
lastNameSearchField	Version normalisée du nom de famille utilisée pour les recherches (tout en minuscules).	carthy001
level	Niveau scolaire ou académique actuel de l'utilisateur.	CLASSE PREPA.GRANDES ECOLES : 2EME ANNEE
login	Identifiant de connexion utilisé par l'utilisateur (souvent basé sur le prénom et le nom).	wilton.carthy001
modified	Date et heure de la dernière modification de l'entité dans la base au format ISO 8601.	2022-12-13T12:38:17.311Z
module	Code ou identifiant du module pédagogique suivi par l'utilisateur.	30111029220
moduleName	Nom du module pédagogique correspondant au code.	CPGE2 PSI (PHYSIQUE ET SC. INGENIEUR)
otherNames	Autres prénoms possibles ou alias de l'utilisateur.	Wilton
profiles	Profil(s) attribué(s) à l'utilisateur (par exemple, rôle ou fonction).	Student
relative	Informations relatives aux contacts familiaux ou liens associés (structuré avec plusieurs valeurs).	1841154$20$1$1$1$1,1932609$10$0$1$0$0
relativeAddress	Identifiant de l'adresse associée à un contact familial ou proche.	1841154
scholarshipHolder	Indique si l'utilisateur est boursier (valeur booléenne).	true
sector	Secteur ou domaine académique général de l'utilisateur.	CLASSE PREPA.GRDES ECOLES : 2EME ANNEE
source	Source des données (par exemple, système tiers ou processus d'importation).	AAF
status	Statut actuel de l'utilisateur (par exemple, scolaire, inactif, etc.).	SCOLAIRE
structures	Identifiant(s) des structures auxquelles l'utilisateur appartient (par exemple, établissements).	950436
surname	Nom de famille alternatif ou complémentaire (souvent identique au champ lastName).	CARTHY001
transport	Indique si l'utilisateur bénéficie d'un service de transport (valeur booléenne).	false
zipCode	Code postal de la ville de résidence de l'utilisateur.	17781
emailVerified	Indique si l'adresse e-mail de l'utilisateur a été vérifiée (valeur booléenne).	true
enabled	Indique si le compte de l'utilisateur est activé (valeur booléenne).	true

Le champ level permet de savoir si l'utilisateur est :

• du 1er degré/école primaire (1d),
• du 2ème degré/ (2d)
• ou du 3ème degré.

Rechercher un utilisateur par son nom

MATCH (u:User) 
WHERE toLower(u.lastName) = toLower('Benzemou') 
RETURN u

Récupération d'un utilisateur

MATCH (u:User { id: $id }) RETURN u
MATCH (u:User { login: 'tom.mate' }) RETURN u

// Récupération des structures liées à l'utilisateur
OPTIONAL MATCH (u)-[:IN]->(:ProfileGroup)-[:DEPENDS]->(s:Structure)
WITH COLLECT(DISTINCT s) AS structureNodes, u

// Récupération des fonctions et des scopes
OPTIONAL MATCH (u)-[rf:HAS_FUNCTION]->(f:Function)
WITH COLLECT(DISTINCT [f.externalId, rf.scope]) AS functions, u, structureNodes

// Récupération des enfants liés à l'utilisateur
OPTIONAL MATCH (u)<-[:RELATED]-(child:User)
WITH COLLECT(DISTINCT {id: child.id, displayName: child.displayName, externalId: child.externalId}) AS children, functions, u, structureNodes

// Récupération des parents liés à l'utilisateur
OPTIONAL MATCH (u)-[:RELATED]->(parent:User)
WITH COLLECT(DISTINCT {id: parent.id, displayName: parent.displayName, externalId: parent.externalId}) AS parents, children, functions, u, structureNodes

// Récupération des groupes fonctionnels administratifs
OPTIONAL MATCH (u)-[:IN]->(fgroup:FunctionalGroup)
WITH COLLECT(DISTINCT {id: fgroup.id, name: fgroup.name}) AS admGroups, parents, children, functions, u, structureNodes

// Récupération des structures administratives
OPTIONAL MATCH (u)-[:ADMINISTRATIVE_ATTACHMENT]->(admStruct:Structure)
WITH COLLECT(DISTINCT {id: admStruct.id}) AS admStruct, admGroups, parents, children, functions, u, structureNodes

// Récupération des matières enseignées par l'utilisateur
OPTIONAL MATCH (u)-[r:TEACHES]->(s:Subject)
WITH COLLECT(DISTINCT s.code) AS subjectCodes, admStruct, admGroups, parents, children, functions, u, structureNodes

// Récupération des groupes manuels
OPTIONAL MATCH (u)-[:IN]->(mgroup:ManualGroup)
WITH COLLECT(DISTINCT {id: mgroup.id, name: mgroup.name}) AS manualGroups, subjectCodes, admStruct, admGroups, parents, children, functions, u, structureNodes

// Retour des résultats
RETURN DISTINCT 
    u.profiles AS type, 
    structureNodes, 
    [x IN functions WHERE size(FILTER(y IN x WHERE NOT isEmpty(y))) > 0] AS functions, 
    u.functions AS aafFunctions,
    [x IN COALESCE(children, []) WHERE NOT isEmpty(x.id)] AS children, 
    [x IN COALESCE(parents, []) WHERE x.id IS NOT NULL] AS parents, 
    [x IN COALESCE(admGroups, []) WHERE x.id IS NOT NULL] AS functionalGroups, 
    [x IN COALESCE(admStruct, []) WHERE x.id IS NOT NULL] AS administrativeStructures, 
    [x IN COALESCE(subjectCodes, []) WHERE x IS NOT NULL] AS subjectCodes, 
    CASE WHEN manualGroups IS NULL THEN [] ELSE manualGroups END AS manualGroups, 
    u

Liste de tous les utilisateurs pour une structure

MATCH (u:User)-[:IN]->(pg:ProfileGroup)-[:DEPENDS]->(s:Structure {id:$structureId}) 
OPTIONAL MATCH (u)-[:IN]->(:ProfileGroup)-[:DEPENDS]->(class:Class)   
WITH DISTINCT u, class, 
     CASE 
         WHEN class IS NULL THEN [] 
         ELSE COLLECT(DISTINCT {id: class.id, name: class.name, externalId: class.externalId}) 
     END AS classes 
OPTIONAL MATCH (u)-[d:DUPLICATE]-(duplicate:User)-[:IN]->(:ProfileGroup)-[:DEPENDS]->(sd:Structure)   
WITH DISTINCT u, classes, 
     COLLECT(DISTINCT {id: sd.id, name: sd.name}) AS structuresDup, 
     duplicate, d
OPTIONAL MATCH (u)-[:IN]->(:ProfileGroup)-[:DEPENDS]->(struct:Structure)   
WITH DISTINCT u, classes, structuresDup, duplicate, d, 
     CASE 
         WHEN duplicate IS NULL THEN [] 
         ELSE COLLECT(DISTINCT {id: duplicate.id, firstName: duplicate.firstName, lastName: duplicate.lastName, score: d.score, code: duplicate.activationCode, structures: structuresDup}) 
     END AS duplicates, 
     COLLECT(DISTINCT {id: struct.id, name: struct.name, externalId: struct.externalId}) AS structures 
OPTIONAL MATCH (u)-[:IN]->(fgroup:FunctionalGroup)   
WITH DISTINCT u, classes, structuresDup, duplicates, structures, fgroup,
     CASE 
         WHEN fgroup IS NULL THEN [] 
         ELSE COLLECT(DISTINCT fgroup.name) 
     END AS functionalGroups 
OPTIONAL MATCH (u)-[:IN]->(mgroup:ManualGroup)   
WITH DISTINCT u, classes, structuresDup, duplicates, structures, functionalGroups, mgroup,
     CASE 
         WHEN mgroup IS NULL THEN [] 
         ELSE COLLECT(DISTINCT mgroup.name) 
     END AS manualGroups 
OPTIONAL MATCH (u)-[rf:HAS_FUNCTION]->(f:Function)   
WITH DISTINCT u, classes, structuresDup, duplicates, structures, functionalGroups, manualGroups, f,
     CASE 
         WHEN f IS NULL THEN [] 
         ELSE COLLECT(DISTINCT [f.externalId, rf.scope]) 
     END AS functions 
RETURN DISTINCT 
    u.id AS id, 
    u.profiles[0] AS type, 
    u.activationCode AS code, 
    u.login

Explication détaillée de la requête

Cette requête vise à extraire des informations complexes et relationnelles sur des utilisateurs (u) dans une base de données Neo4j. Elle explore plusieurs niveaux de relations pour collecter des informations sur les utilisateurs, leurs classes, leurs groupes, leurs duplicatas, et d'autres données connexes.

1. Premier MATCH : Filtrage initial sur les utilisateurs

   MATCH (u:User)-[:IN]->(pg:ProfileGroup)-[:DEPENDS]->(s:Structure {id:$structureId})
   • Objectif : Trouver les utilisateurs (u) associés à un ProfileGroup (pg) dépendant d'une structure spécifique (s) identifiée par $structureId.
   • Relation :
     • (u)-[:IN]->(pg) : L'utilisateur appartient à un groupe de profils.
     • (pg)-[:DEPENDS]->(s) : Ce groupe dépend de la structure spécifiée.

2. Classes associées à l'utilisateur

   OPTIONAL MATCH (u)-[:IN]->(:ProfileGroup)-[:DEPENDS]->(class:Class)
   WITH DISTINCT u, class,
        CASE 
            WHEN class IS NULL THEN [] 
            ELSE COLLECT(DISTINCT {id: class.id, name: class.name, externalId: class.externalId}) 
        END AS classes
   • Objectif : Trouver les classes (class) liées indirectement à l'utilisateur.
   • Utilisation de CASE :
     • Si aucune classe n'est trouvée, la valeur retournée est une liste vide.
     • Sinon, les propriétés clés des classes sont collectées dans une liste.

3. Duplicatas des utilisateurs

   OPTIONAL MATCH (u)-[d:DUPLICATE]-(duplicate:User)-[:IN]->(:ProfileGroup)-[:DEPENDS]->(sd:Structure)
   WITH DISTINCT u, classes, 
        COLLECT(DISTINCT {id: sd.id, name: sd.name}) AS structuresDup, 
        duplicate, d
   • Objectif : Identifier les utilisateurs duplicatas (duplicate) et leurs structures (sd).
   • Relation :
     • (u)-[d:DUPLICATE]-(duplicate) : u est en relation de duplicata avec un autre utilisateur.
     • (duplicate)-[:IN]->(:ProfileGroup)-[:DEPENDS]->(sd) : Le duplicata appartient à un groupe lié à une structure.

4. Structures liées à l'utilisateur principal

   OPTIONAL MATCH (u)-[:IN]->(:ProfileGroup)-[:DEPENDS]->(struct:Structure)
   WITH DISTINCT u, classes, structuresDup, duplicate, d,
        CASE 
            WHEN duplicate IS NULL THEN [] 
            ELSE COLLECT(DISTINCT {id: duplicate.id, firstName: duplicate.firstName, lastName: duplicate.lastName, score: d.score, code: duplicate.activationCode, structures: structuresDup}) 
        END AS duplicates, 
        COLLECT(DISTINCT {id: struct.id, name: struct.name, externalId: struct.externalId}) AS structures
   • Objectif : Trouver toutes les structures directement liées à l'utilisateur (struct).
   • Logique sur les duplicatas :
     • Si aucun duplicata n'existe, la liste est vide.
     • Sinon, collecter des informations détaillées sur chaque duplicata (propriétés et structures associées).

5. Groupes fonctionnels

   OPTIONAL MATCH (u)-[:IN]->(fgroup:FunctionalGroup)
   WITH DISTINCT u, classes, structuresDup, duplicates, structures, fgroup,
        CASE 
            WHEN fgroup IS NULL THEN [] 
            ELSE COLLECT(DISTINCT fgroup.name) 
        END AS functionalGroups
   • Objectif : Récupérer les noms des groupes fonctionnels associés à l'utilisateur.

6. Groupes manuels

   OPTIONAL MATCH (u)-[:IN]->(mgroup:ManualGroup)
   WITH DISTINCT u, classes, structuresDup, duplicates, structures, functionalGroups, mgroup,
        CASE 
            WHEN mgroup IS NULL THEN [] 
            ELSE COLLECT(DISTINCT mgroup.name) 
        END AS manualGroups
   • Objectif : Identifier les groupes manuels liés à l'utilisateur.

7. Fonctions de l'utilisateur

   OPTIONAL MATCH (u)-[rf:HAS_FUNCTION]->(f:Function)
   WITH DISTINCT u, classes, structuresDup, duplicates, structures, functionalGroups, manualGroups, f,
        CASE 
            WHEN f IS NULL THEN [] 
            ELSE COLLECT(DISTINCT [f.externalId, rf.scope]) 
        END AS functions
   • Objectif : Collecter les fonctions (f) associées à l'utilisateur, ainsi que leur étendue (rf.scope).

8. Finalisation et retour des données

   RETURN DISTINCT 
       u.id AS id, 
       u.profiles[0] AS type, 
       u.activationCode AS code, 
       u.login AS login
   • Objectif : Retourner un ensemble d'informations consolidées sur l'utilisateur :
     • Identifiant (id), profil principal (type), code d'activation, et login.

Relations explorées

1. Liens directs : Utilisateur → Groupe de profils → Structure.
2. Associations optionnelles :
   • Classes liées, duplicatas, groupes fonctionnels et manuels, fonctions.
3. Organisation des données :
   • Les informations sont regroupées dans des collections (listes) pour des champs comme classes, duplicates, et functions.

Créer un utilisateur et son UserBook (Profil utilisateur)

// Création de l'utilisateur
CREATE (:User {
  id: 'user_123',
  login: 'jean.dupont',
  displayName: 'Jean Dupont'
});

// Création du UserBook associé
MATCH (u:User {id: 'user_123'})
MERGE (u)-[:HAS_USER_BOOK]->(:UserBook {
  userid: 'user_123',
  ine: '123456789AB',
  quota: 1073741824,
  storage: 536870912
});

Créer un lien parent/enfant

Un utilisateur de type élève est lié à ses parents.

MATCH (parent:User {id: 'parent_1'}), (child:User {id: 'user_123'})
MERGE (parent)-[:RELATED]->(child);

Créer un administrateur local (ADML)

// Création du groupe de fonction
CREATE (:FunctionGroup {
  id: 'adml_group_1',
  name: 'Admin Local Group',
  filter: 'ADMIN_LOCAL'
});

// Liaison à la structure
MATCH (fg:FunctionGroup {id: 'adml_group_1'}), (s:Structure {id: 'structure_1'})
MERGE (fg)-[:SCOPE]->(s);

// Attribution à un utilisateur
MATCH (u:User {id: 'admin_1'}), (fg:FunctionGroup {id: 'adml_group_1'})
MERGE (u)-[:IN]->(fg);