maintenance.graphdb

  1# -*- coding: utf-8 -*-
  2"""
  3Interface avec la partie de la base de données en graphe reflétant le dépôt.
  4
  5Modifié le 30/03/23   @author: remy
  6
  7- Définit des outils utiles pour tous les dépôts
  8- Importe le sous-module `bdg_xxxx` spécifique au dépôt sous le nom `specific`.
  9- Définit la classe `Maquis`.
 10
 11La maintenance de la base est réalisée par des requêtes cypher définies
 12 dans `specific` et exécutés lors de l'instanciation de la classe `Maquis`
 13 par l'appel `specific.exec()`.
 14 
 15Les sous-modules spécifiques sont [`bdg_mathCours`](bdg_mathCours.html), [`bdg_mathExos`](bdg_mathExos.html) et [`bdg_mathPbs`](bdg_mathPbs.html)
 16
 17"""
 18import importlib
 19# import neo4j
 20
 21
 22class Maquis:
 23    """
 24    Classe Maquis. Interface la base de données neo4j.
 25    - exécute les requêtes de mise à jour de la partie de la base associée au dépôt.
 26    - présente dans la propriété `.log` le journal de l'exécution des requêtes.
 27
 28    """
 29
 30    def __init__(self, data, specific_results):
 31        """
 32        Instancie la classe
 33
 34        #### Paramètres
 35        - data : dictionnaire `manifeste['context']` du module d'Initialisation.
 36    
 37        - specific_results : dictionnaire de données de contextalisation extraites du dépôt par le module d'exécution locale spécifique.
 38    
 39        #### Propriétés
 40        - `.log` : journal
 41        - `.connect_data` : `manifeste['context']` données de connexion.
 42        - `.specific_results` : données extraites du dépot par l'exécution locale spécifique
 43    
 44        #### Renvoie
 45
 46        None.
 47
 48        """
 49        self.connect_data = data
 50        self.specific_results = specific_results
 51        self.log = "\t Initialisation de la classe Maquis \n"
 52
 53        print("coucou du module graphdb")
 54
 55        lineprefix = "\n \t \t"
 56
 57        # Importation du module spécifique
 58        module = data['modulespec']
 59        if module:
 60            try:
 61                specific = importlib.import_module(module)
 62                self.log += lineprefix
 63                self.log += "Importation du module spécifique " + module
 64                # exécution des scripts de contextualisation
 65                self.log += specific.exec(self)
 66            except ImportError as error:
 67                self.log += lineprefix + "Module " + error.name + " pas trouvé"
 68
 69
 70    def format_cypher_RETURN(self, param):
 71        """
 72        Renvoie une requête cypher de type `RETURN`.
 73
 74        Dans la chaîne modèle
 75
 76            "MATCH (n: {label} {propsF}) RETURN {propsR}"
 77
 78        remplace les variables entre accolades par les valeurs dans `param`.
 79        Utilise la méthode `.format()` d'une chaine.
 80
 81        #### Parametres
 82
 83        param : TYPE dictionnaire
 84            DESCRIPTION exemple:
 85
 86            {'label': "Document",
 87             'propsF':" {typeDoc:'problème'}",
 88             'propsR': "n.titre, n.description"}.
 89
 90        #### Renvoie
 91
 92        TYPE chaine de caractères
 93        DESCRIPTION requête cypher.
 94
 95        """
 96        req = "MATCH (n: {label} {propsF}) RETURN {propsR}"
 97        req = req.format(**param)
 98        return req
 99
100    def format_cypher_DELETE(self, param):
101        """
102        Renvoie une requête cypher de type `DETACH DELETE`.
103
104        ATTENTION ! Ce type de requte est à manier avec précaution.
105         Toujours vérifier ce qui sera détruit.
106
107        Dans la chaîne modèle
108
109            "MATCH (n: {label} {propsF}) DETACH DELETE n"
110
111        remplace les variables entre accolades par les valeurs dans `param`.
112        Utilise la méthode `.format()` d'une chaine.
113
114        #### Parametres
115
116        param : TYPE dictionnaire
117           DESCRIPTION exemple pour supprimer le problème de titre 'grpe2'
118           dans la base:
119
120            {'label' : "Document",
121             'propsF' :"{typeDoc:'problème' titre:'grpe2'}"}
122
123        #### Renvoie
124
125        TYPE chaine de caractères
126        DESCRIPTION requête cypher.
127
128        """
129        req = "MATCH (n: {label} {propsF}) DETACH DELETE n"
130        req = req.format(**param)
131        return req
132
133    def format_cypher_SET(self, param):
134        """
135        Renvoie une requête cypher de type `SET`.
136
137        Dans la chaîne modèle
138
139            "MATCH (n: {label} {propsF}) SET {propsV}"
140
141        remplace les variables entre accolades par les valeurs dans `param`.
142        Utilise la méthode `.format()` d'une chaine.
143
144        #### Parametres
145
146        param : TYPE dictionnaire
147            DESCRIPTION exemple:
148
149            {'label' : "Document",
150             'propsF' :"{typeDoc:'problème'}",
151             'propsV' : "n.description = tagada"}.
152
153        #### Renvoie
154
155        TYPE chaine de caractères
156        DESCRIPTION requête cypher.
157
158        """
159        req = "MATCH (n: {label} {propsF}) SET {propsV}"
160        req = req.format(**param)
161        return req
162
163    def format_cypher_CREATE(self, param):
164        """
165        Renvoie une requête cypher de type `CREATE`.
166
167        Dans la chaîne modèle
168
169            "CREATE (n: {label} {propsF})"
170
171        remplace les variables entre accolades par les valeurs dans `param`.
172        Utilise la méthode `.format()` d'une chaine.
173
174        #### Parametres
175
176        param : TYPE dictionnaire
177            DESCRIPTION exemple:
178
179            {'label' : "Document",
180             'propsF' :"{typeDoc:'exercice',
181                         titre:'co01'
182                         discipline: 'mathématique}"}.
183
184        #### Renvoie
185
186        TYPE chaine de caractères
187        DESCRIPTION requête cypher.
188
189        """
190        req = "CREATE (n: {label} {propsF})"
191        req = req.format(**param)
192        return req
193
194    def do_cypher_tx(self, tx, cypher):
195        """
196        Exécute une requête cypher et renvoie les valeurs retournées.
197
198        #### Parametres
199
200        tx: TYPE transaction neo4j DESCRIPTION lié à la session neo4j
201        *pas clair!*
202
203        cypher: TYPE chaine de caractères DESCRIPTION requête cypher
204
205        #### Renvoie
206
207        TYPE liste
208
209        DESCRIPTION valeurs retournées par la requête
210        """
211        result = tx.run(cypher)
212        values = [record.values() for record in result]
213        return values