Premier commit

.gitignore

+__pycache__/
+venv/
+.idea/

Contenu1

+Bonjour, je suis un contenu 1 dans sa version 52
\ No newline at end of file

Contenu2

+Bonjour, je suis un contenu 2 dans sa version 12
\ No newline at end of file

Main.py

+from Menu import Menu
+from Utils import Utils
+
+##
+# @mainpage Projet Open Quiz
+# Cette application à pour objectif de définir une version minimaliste du projet OpenQuiz
+#
+# @section intro_sec Fonctionnalités
+# 1. Choisir un auteur parmi trois choix
+# 2. Un menu proposant diverses options est affiché
+#   - 0 : Importer un contenu
+#   - 1 : Consulter le panier
+#   - 2 : Aller à la banque de contenu
+#   - 3 : Revenir au menu
+#   - 4 : Supprimer un contenu
+#   - 5 : Créer une évaluation
+#   - 6 : Consulter les évaluations
+#   - 7 : Modifier un contenu
+#   - 8 : Valider une demande de modification sur un contenu (a venir)
+#   - 9 : Rechercher un contenu dans la banque (a venir)\n
+#   - 10 : Consulter les contenus en cours de modification\n
+
+#   <b> (Il manquera les fonctionnalités à propos des tags libres "privés", la notation contenu / auteur, la gestion de la "popularité" des versions) </b>\n
+#   \n
+#   0 -> Ouvre un menu permettant l'import d'un fichier (deux choix sont disponibles) \n
+#   1 -> Permet de consulter les contenus importées & celles mises en favori \n
+#   2 -> Permet de consulter les contenus d'auteurs tiers & de les mettre en favori \n
+#   3 -> Retourne sur le choix de l'auteur \n
+#   4 -> "Renier la paternité" d'une question \n
+#   5 -> Créer un regroupement de contenus \n
+#   6 -> Consulter les évaluations crééees \n
+#   7 -> Permet de modifier un des fichiers importé OU un des favoris \n
+#   8 -> Consulter les demandes de modifications "tierces" \n
+#   9 -> Recherche par auteur, date, tag (imposés / libres), contenu / titre, note \n
+#   10 -> Par la suite, les contenus "en cours" seront disponibles dans le panier\n
+
+
+
+
+#
+
+Menu()
+
+
+#Utils.initialiseMongo()
+#Utils.ajouterUtilisateur("Auteur 1")
+#Utils.ajouterUtilisateur("Auteur 2")
+#Utils.ajouterUtilisateur("Auteur 3")
+#Utils.sumContenuEnFavori(1)
+#Utils.sumContenuEnFavori(2)
+#print(Utils.getMaxIdContenus())
+#print(Utils.getMaxIdEvaluations())
+#print(Utils.getMaxIdContenusEnCours())
+#print (Utils.getIdContenuAssocieAUnEnCours(1))

Menu.py

+from Utils import Utils
+import os
+
+
+## Classe Menu
+# Affichage principal de l'application du squelette
+# Toutes les interactions utilisateur sont effectuées ici
+
+
+class Menu:
+    auteurEnCours = 0
+
+    ## Constructeur, permet de lancer le 1er menu
+
+    def __init__(self):
+        # obligatoire à faire au début
+        Utils.initialiseMongo()
+        self.menuDeBase()
+
+    ##  1er menu affiché et proposé à l'utilisateur
+    #    Permet de choisir un "compte"
+    #    (Version spéciale pour le squelette)
+    def menuDeBase(self):
+        os.system('clear')
+        # temporaire, juste pour la création du squelette
+        print("Choisir votre numéro d'auteur")
+        print("1 : Auteur 1")
+        print("2 : Auteur 2")
+        print("3 : Auteur 3")
+        print("Votre choix : ")
+        choix = (input())
+        if choix == 'p':
+            Utils.toutPeter()
+            self.menuDeBase()
+        choix = Utils.switchAuteur(int(choix))
+
+        if choix != "Auteur inconnu":
+
+            if Utils.presenceUtilisateur(choix):
+                self.auteurEnCours = choix
+                self.menuDesActions()
+
+    ##    Menu affiché une fois un compte valide sélectionné
+
+    def menuDesActions(self):
+        os.system('clear')
+        print("Bonjour ", self.auteurEnCours)
+        print("Choisir l'action : ")
+        print("0 : Importer un contenu")
+        print("1 : Consulter le panier")
+        print("2 : Aller à la banque de contenu")
+        print("3 : Revenir au menu")
+        print("4 : Supprimer un contenu")
+        print("5 : Créer une évaluation")
+        print("6 : Consulter les évaluations")
+        print("7 : Modifier un contenu")
+        print("8 : Valider une modification")
+        print("9 : Rechercher un contenu")
+        print("10 : Consulter les contenus en cours de modification")
+        print("Votre choix : ")
+        choix = (input())
+        if choix.isdigit():
+            self.switchActions(int(choix))
+
+
+    ##  Permet de récupérer l'action désirée par l'utilisateur
+
+    def switchActions(self, argument):
+        if argument == 0:
+            self.importFichier()
+        elif argument == 1:
+            self.consulterPanier()
+        elif argument == 2:
+            self.consulterBanque()
+        elif argument == 3:
+            self.menuDeBase()
+        elif argument == 4:
+            self.supprimerContenu()
+        elif argument == 5:
+            self.creerEvaluation()
+        elif argument == 6:
+            self.consulterEvaluations()
+        elif argument == 7:
+            self.modifierContenu()
+        elif argument == 8:
+            os.system('clear')
+            print("Bonjour ", self.auteurEnCours)
+            print("Fonctionnalité à venir")
+        elif argument == 9:
+            os.system('clear')
+            print("Bonjour ", self.auteurEnCours)
+            print("Fonctionnalité à venir")
+        elif argument == 10:
+            self.consulterEnCours()
+        else:
+            print("Action inconnue")
+
+    ##   Importer un fichier (action 0)
+
+    def importFichier(self):
+        os.system('clear')
+        print("Bonjour ", self.auteurEnCours)
+        print("Selectionner le fichier à charger")
+        print("1 : Contenu1")
+        print("2 : Contenu2")
+        print("3 : Revenir en arrière")
+        print("Votre choix : ")
+        choix = (input())
+        if choix.isdigit():
+            self.switchFichiers(int(choix))
+
+    ##    En fonction du choix effectué dans importFichier, on charge le fichier choisi
+
+    def switchFichiers(self, argument):
+        if argument == 1 or argument == 2:
+            Utils.ajouterContenu("Contenu" + str(argument), self.auteurEnCours)
+            self.consulterPanier()
+        elif argument == 3:
+            self.menuDesActions()
+        else:
+            print("Fichier inexistant")
+
+    ##    Consulter le panier (action 1)
+    def consulterPanier(self):
+        os.system('clear')
+        print("Bonjour ", self.auteurEnCours)
+
+        # 1. On charge les contenus "propres" de la banque
+        questions = Utils.consulterContenu(self.auteurEnCours, True)
+        print(self.auteurEnCours + " possede " + str(questions.count()) + " contenu(s)")
+        if questions.count() > 0:
+            self.afficherContenus(questions)
+        # 1. On charge les contenus "mis en favori" de la banque
+
+        # print("Contenus mis en favori par l'auteur ", self.auteurEnCours, " : ",
+        #      len(Utils.getFavoris(self.auteurEnCours)))
+        print(f"Contenus mis en favori par l'auteur {self.auteurEnCours} : {len(Utils.getFavoris(self.auteurEnCours))}")
+
+        if len(Utils.getFavoris(self.auteurEnCours)):
+            for (id, version) in Utils.getFavoris(self.auteurEnCours):
+                print("La question : ", int(id['contenu']), " et sa version", int(version['version']))
+                self.afficherContenusFavoris(
+                    Utils.getContenuavecIdEtVersion(int(id['contenu']), int(version['version'])),
+                    int(version['version']))
+        print("Appuyer sur q pour revenir en arriere")
+        choix = (input())
+        if choix == 'q':
+            self.menuDesActions()
+
+    ##    Consulter la banque (action 2)
+    def consulterBanque(self):
+        os.system('clear')
+        print("Bonjour ", self.auteurEnCours)
+
+        # on charge tous les contenus n'appartenant pas à l'utilisateur (qu'il peut retrouver dans son panier)
+        questions = Utils.consulterContenu(self.auteurEnCours, False)
+        print("La banque possède actuellement", questions.count(), " contenu(s)")
+        if questions.count() > 0:
+            self.afficherContenusBanque(questions)
+
+            # on propose à l'utilisateur de mettre en favori les contenus de la banque
+            print("Entrer l'id de la question à mettre en favori ou appuyer sur q pour revenir en arriere")
+            choix = (input())
+            if choix == 'q':
+                self.menuDesActions()
+            elif choix.isdigit():
+                print("Je veux favoriser la question ", choix, " et je suis l'auteur ", self.auteurEnCours)
+                Utils.mettreContenuEnFavori(choix, self.auteurEnCours)
+                self.consulterPanier()
+            else:
+                print("On t'a dit q ou un un chiffre sérieux :<")
+        else:
+            print("Appuyer sur q pour revenir en arriere")
+            choix = (input())
+            if choix == 'q':
+                self.menuDesActions()
+
+    ##    Fonction d'affichage des contenus 'panier personnel'
+
+    def afficherContenus(self, contenu):
+
+        for elt in contenu:
+            print("nom :", elt["fichier"], " - v", elt["versionEnCours"]["numero"], " - du",
+                  elt["versionEnCours"]["date"])
+
+    """
+        La deuxième est pour les contenus de la banque. Certains champs supplémentaires apparaissent
+        (On verra + tard si une mutualisation de code est jouable)
+    """
+
+    ##    Fonction d'affichage des contenus 'banque'
+    def afficherContenusBanque(self, contenu):
+
+        favoris = Utils.getFavoris(self.auteurEnCours)
+        is_fav = False
+        print("favoris : ", favoris)
+
+        for elt in contenu:
+            print("id :", elt["id"], "auteur :", elt["auteur"], " - nom :", elt["fichier"], " - v",
+                  elt["versionEnCours"]["numero"], " - du",
+                  elt["versionEnCours"]["date"], end='')
+            is_fav = False
+
+            for fac in favoris:
+                if elt["id"] == fac[0]["contenu"]:
+                    print(f' (* v{fac[1]["version"]})')
+                    is_fav = True
+            if not is_fav:
+                print("\r")
+
+    ##    Fonction d'affichage des contenus 'favoris'
+    def afficherContenusFavoris(self, contenu, version):
+
+        # print (contenu)
+
+        print("id :", contenu["id"], "auteur :", contenu["auteur"], " - nom :", contenu["fichier"], " - v",
+              version, " - du",
+              contenu["versionEnCours"]["date"])
+
+    ##    Fonction d'affichage des contenus 'en cours de modification'
+    def afficherContenusEnCours(self, contenu):
+
+        en_cours = Utils.getContenusEnCours(self.auteurEnCours)
+
+        print("Je veux afficher", en_cours.count(), "contenus en cours")
+
+        for elt in en_cours:
+            print("id Modif :", elt["idContenuEC"], "auteur original :", elt["auteur"], " - id Original :",
+                  elt["reference"],
+                  "version original", elt["version"], " date modif ", elt["date"])
+
+    ##    Supprimer un contenu  (permet de dissocier son auteur) (action 4)
+
+    def supprimerContenu(self):
+        os.system('clear')
+        print("Bonjour ", self.auteurEnCours)
+
+        print("1. Supprimer un contenu personnel")
+        print("2. Supprimer un favori")
+        print("3. Revenir en arrière")
+
+        choix = int(input())
+        if choix == 1:
+            self.supprimerContenuPersonnel()
+        elif choix == 2:
+            self.supprimerContenuFavori()
+        else:
+            self.menuDesActions()
+
+    ##    Supprimer un contenu - Fonction spécifique contenu personnel (action 4)
+
+    def supprimerContenuPersonnel(self):
+        # On charge les contenus de l'auteur en cours (si existants)
+        questions = Utils.consulterContenu(self.auteurEnCours, True)
+        print(self.auteurEnCours + " possede " + str(questions.count()) + " contenu(s)")
+        if questions.count() > 0:
+            self.afficherContenusBanque(questions)
+
+        print("Entrer l'id du contenu à supprimer ou appuyer sur q pour revenir en arriere")
+        choix = (input())
+        if choix == 'q':
+            self.supprimerContenu()
+
+        # on charge la fonction de "suppression" d'un contenu en fonction de la saisie de l'utilisateur
+        if choix.isdigit():
+            print("Le contenu choisi a ", int(choix), "favoris liés")
+            if Utils.sumContenuEnFavori(int(choix)) > 0:
+                Utils.supprimerContenu(int(choix))
+                self.consulterPanier()
+            else:
+                Utils.aneantirContenu(int(choix))
+                self.consulterPanier()
+
+    ##    Supprimer un contenu - Fonction spécifique contenu favori (action 4)
+
+    def supprimerContenuFavori(self):
+
+        favoris = dict()
+        print(self.auteurEnCours, " possede ", len(Utils.getFavoris(self.auteurEnCours)), " favori(s)")
+
+        # On charge les contenus de l'auteur en cours (si existants)
+        if len(Utils.getFavoris(self.auteurEnCours)):
+            for (id, version) in Utils.getFavoris(self.auteurEnCours):
+                print("La question : ", id["contenu"], " et sa version", version["version"])
+                self.afficherContenusFavoris(Utils.getContenuavecIdEtVersion(id["contenu"], version["version"]),
+                                             version["version"])
+                favoris[id["contenu"]] = version["version"]
+
+        print("Entrer l'id du contenu à supprimer ou appuyer sur q pour revenir en arriere")
+        choix = (input())
+        if choix == 'q':
+            self.supprimerContenu()
+
+        # on charge la fonction de "suppression" d'un contenu en fonction de la saisie de l'utilisateur
+        if choix.isdigit():
+            print("Le contenu choisi a ", int(choix), "favoris liés. Sa version associée est : ", favoris[int(choix)])
+            Utils.supprimerFavori(int(choix), self.auteurEnCours, favoris[int(choix)])
+            print("Le favori ", int(choix), " a été supprimé")
+            print("nombre : ", Utils.sumContenuEnFavori(int(choix)))
+            print("anonyme : ", Utils.isAnonyme(int(choix)))
+
+            if Utils.sumContenuEnFavori(int(choix)) == 0 and Utils.isAnonyme(int(choix)):
+                Utils.aneantirContenu(int(choix))
+                print("Le contenu ", int(choix), " a été définitivement supprimé")
+
+    ##    Créer une evaluation (regroupement de contenu) (action 5)
+    def creerEvaluation(self):
+        os.system('clear')
+        print("Bonjour ", self.auteurEnCours)
+
+        # on charge tous les contenus présents
+        questions = Utils.consulterTousLesContenu()
+        if questions.count() > 0:
+            self.afficherContenusBanque(questions)
+        print("Nombre de contenus à ajouter : (entre 1 et ", Utils.getMaxIdContenus(),
+              "), q pour revenir en arrière")
+        choix = (input())
+
+        questions = list()
+        if choix == 'q':
+            self.menuDesActions()
+        if choix.isdigit():
+            print(int(choix), "questions dans l'éval")
+            # en fonction de la saisie précédente on invite l'utilisateur à entrer ses numéros de contenu
+            for i in range(int(choix)):
+                print("Contenu ", i + 1, ", donner l'id du contenu :")
+                questions.append(int(input()))
+            print("Contenus(s) choisi(s) : ", questions)
+            Utils.creerEvaluation(questions, self.auteurEnCours)
+            self.consulterEvaluations()
+
+    ##    Consulter les évaluations pour l'auteur en cours (action 6)
+    def consulterEvaluations(self):
+        os.system('clear')
+        print("Bonjour ", self.auteurEnCours)
+
+        print("L'auteur ", self.auteurEnCours, " a ", Utils.getEvaluations(self.auteurEnCours).count(), " evaluations")
+        self.afficherEvaluations(Utils.getEvaluations(self.auteurEnCours))
+        print("Entrer un id pour supprimer une évaluation ou Appuyer sur q pour revenir en arriere")
+        choix = (input())
+        if choix == 'q':
+            self.menuDesActions()
+        if choix.isdigit():
+            # print("Je veux modifier la question : ", choix)
+            Utils.supprimerEvaluation(choix)
+            print("Contenu supprimé")
+            self.consulterEvaluations()
+
+    ##    Afficher le détail des évaluations d'un auteur
+    def afficherEvaluations(self, evaluations):
+        for elt in evaluations:
+            print("n°", elt["idEval"], " - date", elt["date"], " - contenus : ", end='')
+            for i in range(len(elt["contenu(s)"])):
+                print(i + 1, " ", end='')
+            print("\r")
+
+    ##    Afficher le détail des évaluations d'un auteur (action 7)
+    def modifierContenu(self):
+
+        os.system('clear')
+        print("Bonjour ", self.auteurEnCours)
+
+        contenuPerso = Utils.consulterContenu(self.auteurEnCours, True)
+        favoris = Utils.getFavoris(self.auteurEnCours)
+
+        # 1. Les contenus personnels
+        print("Vous avez", contenuPerso.count(), "questions à vous en banque : ")
+        if contenuPerso.count() > 0:
+            self.afficherContenusBanque(contenuPerso)
+
+        # 2. Les contenus "favoris"
+        print("Et ", len(favoris), "favoris")
+        if len(favoris) > 0:
+            for (id, version) in favoris:
+                self.afficherContenusFavoris(Utils.getContenuavecIdEtVersion(id["contenu"], version["version"]),
+                                             version["version"])
+        # si aucune question dans le panier on n'offre pas la possibilité d'en choisir une
+        if contenuPerso.count() == 0 and len(favoris) == 0:
+            phrase = "Appuyer sur q pour revenir en arriere"
+        else:
+            phrase = "Entrez le numéro de la question à modifier ou Appuyer sur q pour revenir en arriere"
+        print(phrase)
+        choix = (input())
+
+        if choix == 'q':
+            self.menuDesActions()
+        # si un chiffre a été saisi on va charger la modif de question pour cet id (les filtres viendront + tard)
+        if choix.isdigit():
+            print("Je veux modifier la question : ", choix)
+            Utils.modifierContenu(choix, self.auteurEnCours)
+            self.consulterEnCours()
+
+    ## Contenus en cours de modification. Seront par la suite intégrés au panier
+    def consulterEnCours(self):
+        os.system('clear')
+        print("Bonjour ", self.auteurEnCours)
+        contenus = Utils.getContenusEnCours(self.auteurEnCours)
+        print("Vous avez ", contenus.count(), "contenu(s) en cours de modification")
+        if contenus.count() > 0:
+            self.afficherContenusEnCours(contenus)
+        print("Entrer l'id du contenu en cours, puis une lettre d'action (ou directement q pour quitter)")
+        print("c pour consulter le contenu")
+        print("m pour modifier le contenu")
+        print("s pour supprimer le contenu")
+        print("v pour valider la modification du contenu (sous réserve)")
+        print("n pour créer un nouveau contenu")
+
+        choix = input()
+
+        id = 0
+        action = ""
+
+        if choix == "q":
+            self.menuDesActions()
+        if len(choix) < 2 or choix[len(choix) - 1:].isdigit():
+            self.consulterEnCours()
+        else:
+            id = int(choix[:len(choix) - 1])
+            action = choix[len(choix) - 1:]
+
+            print("id :", id)
+            print("id type :", type(id))
+            print("action :", action)
+
+        # affiche le contenu courant du fichier
+        if action == 'c':
+            Utils.changerVersion(int(id), self.auteurEnCours, "version")
+            print(Utils.getIdContenuAssocieAUnEnCours(int(id)))
+            Utils.affichage(Utils.getFichierContenu(Utils.getIdContenuAssocieAUnEnCours(int(id))))
+        elif action == 'm':
+            Utils.changerVersion(int(id), self.auteurEnCours, "version")
+            Utils.modifierContenu(Utils.getIdContenuAssocieAUnEnCours(int(id)), self.auteurEnCours, True)
+            Utils.affichage(Utils.getFichierContenu(Utils.getIdContenuAssocieAUnEnCours(int(id))))
+        elif action == 's':
+            Utils.supprimerContenuEnCours(int(id))
+        elif action == 'v':
+            self.validerModification(int(id))
+        elif action == 'n':
+            Utils.ajouterContenu(Utils.getFichierContenu(Utils.getIdContenuAssocieAUnEnCours(int(id))),
+                                 self.auteurEnCours)
+        elif action == 'q':
+            self.menuDesActions()
+
+    ## changement de version d'un contenu OU demande de publication à l'auteur d'origine
+
+    def validerModification(self, idContenuEnCours):
+        auteur = Utils.getAuteurContenuEnCours(idContenuEnCours)
+        if auteur == self.auteurEnCours:
+            print("Modification directe d'un auteur")
+        else:
+            print("Modification indirecte -> demande de publication")
+        #self.consulterEnCours()

Utils.py

+from datetime import datetime
+
+from pymongo import MongoClient
+from random import randrange
+import os
+from UtilsGit import UtilsGit
+from pathlib import Path
+
+##  Classe utils.
+# Permet de stocker les fonctions utilitaires "transversales"
+#
+
+
+class Utils:
+    statdb = None
+    chemin = "/home/passerat/Stage/Squelette/"
+
+    # chemin = "/home/jeremie/Stage/Squelette/"
+
+    ##   Filtrage de la saisie utilisateur pour le choix d'un auteur
+    # @param Le numéro d'auteur choisi
+    @staticmethod
+    def switchAuteur(argument):
+        switcher = {
+            1: "Auteur 1",
+            2: "Auteur 2",
+            3: "Auteur 3",
+        }
+        return switcher.get(argument, "Auteur inconnu")
+
+    ##
+    #    Connexion avec la base de données
+    #    recherche -> find and find_one
+    #     insertion -> insert_one and insert_many
+    #     maj -> update_one, update_many and replace_one
+    #     suppression -> delete_one and delete_many
+    @staticmethod
+    def initialiseMongo():
+        client = MongoClient('localhost', 27017)
+
+        ## extraction d'une base de données. Si elle n'existe pas, elle esst créée
+        Utils.statdb = client.squelette
+
+    ## Création d'utilisateur
+    # @param nomUtilisateur Le nom de l'utilisateur
+    @staticmethod
+    def ajouterUtilisateur(nomUtilisateur):
+        Utils.statdb.utilisateur.insert_one(
+            {"nom": nomUtilisateur, "note": randrange(0, 10, 1), "favoris": []})
+
+    ## Vérification de la présence d'un utilisateur en base
+    # @param nomUtilisateurLe nom de l'utilisateur
+    # @return True si Utilisateur présent, False sinon
+    @staticmethod
+    def presenceUtilisateur(nomUtilisateur):
+        # print("Je suis dans présence utilisateur pour ", nomUtilisateur)
+        nmbre = Utils.statdb.utilisateur.find({"nom": nomUtilisateur})
+        # print("Et j'en ai trouvé : ", nmbre.count())
+
+        return nmbre.count() == 1
+
+    ##    Creation d'un contenu
+    #   @param nomFichier le nom du fichier importé
+    #   @param auteur l'auteur qui importe le fichier
+    @staticmethod
+    def ajouterContenu(nomFichier, auteur):
+
+        max_id = Utils.getMaxIdContenus()
+        if max_id is None:
+            max_id = 0
+
+        print("nomFichier : ", Utils.chemin + "dossier" + nomFichier + "/")
+
+        # Un contenu doit être dans un répertoire isolé pour pouvoir le manipuler en versionnage
+        Path(Utils.chemin + "dossier" + nomFichier + "/").mkdir(parents=True, exist_ok=True)
+        os.replace(Utils.chemin + nomFichier, Utils.chemin + nomFichier + "/" + nomFichier)
+
+        Utils.statdb.contenu.insert_one(
+            {"id": max_id + 1, "auteur": auteur, "note": randrange(0, 10, 1), "fichier": "dossier" + nomFichier + "/" + nomFichier,
+             "versionEnCours": {"numero": 1, "date": datetime.now().strftime("%d/%m/%y"),
+                                "popularite": 0, "branche": "master"},
+             "tags_fixes": {"1": "tag1", "2": "tag1", "3": "tag1", "4": "tag1",
+                            "5": "tag1"},
+             "tags": {"1": "tag1", "2": "tag1", "3": "tag1", "4": "tag1", "5": "tag1"}})
+        print("Le contenu a bien été ajouté pour l'utilisateur ", auteur)
+
+    ##  Consultation de tous les contenus publics :
+    #    Si panier est égal à True, on sort les contenus de l'auteur
+    #    Si panier est égal à False, on sort toutes les questions sauf celles de l'auteur
+    #    (Nb: La problématique des contenus "en cours de modification" sera traitée ultérieurement)
+    # @return les contenus de l'auteur ou tous les autres
+
+    @staticmethod
+    def consulterContenu(auteur, panier=False):
+        if panier:
+            return Utils.statdb.contenu.find({"auteur": auteur})
+        else:
+            return Utils.statdb.contenu.find({"auteur": {"$ne": auteur}})
+
+    ##    Consultation de tous les contenus, sans distinction
+    #      (utile temporairement pour la création d'évaluations)
+    # @return tous les contenus présents
+
+    @staticmethod
+    def consulterTousLesContenu():
+        return Utils.statdb.contenu.find()
+
+    ## Suppression d'un contenu (dissociation avec son auteur)
+    # @param numContenu l'id du contenu à dissocier
+
+    @staticmethod
+    def supprimerContenu(numContenu):
+        Utils.statdb.contenu.update({"id": numContenu}, {"$set": {"auteur": "Aucun"}})
+
+    ## Permet d'associer un contenu avec le panier d'un auteur tiers
+    # @param idContenu l'id associé au contenu
+    # @param auteur le nom de l'auteur qui désire un favori
+
+    @staticmethod
+    def mettreContenuEnFavori(idContenu, auteur):
+        # print("Le contenu est dans la version ", Utils.getVersionContenuavecId(idContenu))
+        Utils.statdb.utilisateur.update({"nom": auteur}, {
+            "$push": {"favoris": [{"contenu": int(idContenu)}, {"version": Utils.getVersionContenuavecId(idContenu)}]}})
+
+    ## Permet de dissocier un contenu du panier d'un auteur tiers
+    # Si cet auteur était le seul à posséder une question "anonyme", elle est supprimée
+    # @param idContenu l'identifiant du contenu favori
+    @staticmethod
+    def supprimerFavori(idContenu, auteur, version):
+        Utils.statdb.utilisateur.update({"nom": auteur},
+                                        {"$pull": {"favoris": [{"contenu": idContenu}, {"version": version}]}})
+
+    ## Permet de savoir si un contenu possède un auteur légitime
+    # @param idContenu l'identifiant du contenu
+    @staticmethod
+    def isAnonyme(idContenu):
+        print("Is anonyme : ", Utils.statdb.contenu.find_one({"id": idContenu})["auteur"])
+        return Utils.statdb.contenu.find_one({"id": idContenu})["auteur"] == "Aucun"
+
+    ## Récupérer un contenu à partir de son identifiant et sa version
+    # @param idContenu l'id associé au contenu
+    # @param version version désirée
+    # @return Le contenu lié à l'id
+
+    @staticmethod
+    def getContenuavecIdEtVersion(idContenu, version):
+
+        # a décommenter quand git sera actif
+        # Utils.changerVersion(idContenu, version, "")
+        return Utils.statdb.contenu.find_one({"id": idContenu})
+        # return Utils.statdb.contenu.find_one({"$and": [
+        #     {"id": idContenu},
+        #     {"$or": [{"versionEnCours.numero": version}, {"historique.numero": version}]}
+        # ]
+        # })
+
+    ## Récupérer un contenu à partir de son identifiant
+    # @param idContenu l'id associé au contenu
+    # @return Le contenu lié à l'id
+    @staticmethod
+    def getContenuavecId(idContenu):
+        # Id unique donc find_one utilisable
+        return Utils.statdb.contenu.find_one({"id": idContenu})
+
+    ## Récupérer la version en cours d'un contenu à partir de son identifiant
+    # @param idContenu l'id associé au contenu
+    # @return La version en cours du contenu lié à l'id
+    @staticmethod
+    def getVersionContenuavecId(idContenu):
+        # print("Je veux le contenu : ", int(idContenu))
+        return int(Utils.getContenuavecId(int(idContenu))["versionEnCours"]["numero"])
+
+    ##  Récupérer l'id maximal (pour les contenus)
+    # permet de s'assurer que les id de contenu soient uniques
+
+    @staticmethod
+    def getMaxIdContenus():
+        ## Fonction permettant de récupérer l'id max présent en base (pour pouvoir incrémenter un nouveau contenu).
+        element = Utils.statdb.contenu.find().sort("id", -1).limit(1)
+
+        for elt in element:
+            # print("id : ", elt["id"])
+            return int(elt["id"])
+
+    ##  Récupérer l'id maximal (pour les evaluations)
+    # permet de s'assurer que les id de contenu soient uniques
+
+    @staticmethod
+    def getMaxIdEvaluations():
+        ## Fonction permettant de récupérer l'id max présent en base (pour pouvoir incrémenter un nouveau contenu).
+        element = Utils.statdb.evaluation.find().sort("idEval", -1).limit(1)
+
+        for elt in element:
+            # print("id : ", elt["id"])
+            return int(elt["idEval"])
+
+    ##  Récupérer l'id maximal (pour les contenus en cours de modification)
+    # permet de s'assurer que les id de contenu soient uniques
+
+    @staticmethod
+    def getMaxIdContenusEnCours():
+        ## Fonction permettant de récupérer l'id max présent en base (pour pouvoir incrémenter un nouveau contenu).
+        element = Utils.statdb.encours.find().sort("idContenuEC", -1).limit(1)
+
+        for elt in element:
+            print("id : ", elt)
+            return int(elt["idContenuEC"])
+
+    ## Récupérer les favoris d'un utilisateur
+    # @param auteur le nom de l'utilisateur
+    # @return les favoris de l'utilisateur 'auteur'
+
+    @staticmethod
+    def getFavoris(auteur):
+        return Utils.statdb.utilisateur.find_one({"nom": auteur})["favoris"]
+
+    ##  Créer une évaluation
+    #   @param contenus les numeros des contenus associés à l'évaluation
+    #   @auteur l'auteur qui créée l'évaluation
+
+    @staticmethod
+    def creerEvaluation(contenus, auteur):
+
+        # création de l'évaluation
+        max_id_eval = Utils.getMaxIdEvaluations()
+        if max_id_eval is None:
+            max_id_eval = 0
+
+        Utils.statdb.evaluation.insert_one(
+            {"idEval": max_id_eval + 1, "date": datetime.now().strftime("%d/%m/%y"), "auteur": auteur,
+             "contenu(s)": contenus})
+        # on renseigne l'évaluation dans les contenus associés
+        for i in contenus:
+            Utils.statdb.contenu.update({"id": i}, {"$push": {"evals": maxIdEval + 1}})
+
+    ## Récupérer les évaluations d'un auteur
+    #   @param auteur le nom de l'auteur
+    #   @return les évaluations de l'auteur
+
+    @staticmethod
+    def getEvaluations(auteur):
+        return Utils.statdb.evaluation.find({"auteur": auteur})
+
+    ## Modifier un contenu
+    #   @param idContenu contenu à modifier
+    #   @param auteur l'utilisateur désirant modifier la question
+    #   @param isEnCours Vrai si modification d'un contenu en cours
+    @staticmethod
+    def modifierContenu(idContenu, auteur, isEnCours=False):
+
+        # le chemin du fichier restera tjrs le même
+        contenu = Utils.statdb.contenu.find_one({"id": int(idContenu)})
+
+        Utils.modification(Utils.chemin + contenu["fichier"], idContenu, auteur)
+
+    @staticmethod
+    ## affichage d'un contenu de fichier
+    def affichage(chemin):
+        with open(chemin, "r") as fichier:
+            texte = fichier.read()
+
+        texte = texte.strip()
+        print("Le fichier (v", int(texte[-1]), ") : " + texte)
+        return texte
+
+    ## modification (directe ici) d'un fichier
+    # @param chemin chemin d'acces au contenu
+    # @param id id du contenu
+    # @param auteur auteur qui fait la modification du contenu
+    # @param modifPremiere permet de déterminer si on est sur une premiere modification du contenu ou si on remodifie un contenu en cours
+
+    @staticmethod
+    def modification(chemin, idContenu, auteur, modifPremiere=True):
+
+        # on récupère la fin du fichier (la version)
+        fin = Utils.affichage(chemin)
+        version = int(fin[-1])
+
+        if modifPremiere:
+            # on créée une nouvelle branche et on va dedans
+            nomBranche = "version" + str(version + 1)
+            print("Je veux la branche", nomBranche)
+
+        # si on est pas en "modifPremiere" on est déja dans la bonne branche.
+
+        # 2. on remplace le dernier caractère du fichier en l'incrémentant de 1
+        with open(chemin, "a") as fichier:
+            pos = fichier.tell()
+            pos = pos - 1
+            fichier.seek(pos)
+            fichier.truncate()
+            fichier.write(str(version + 1))
+            fichier.close()
+        Utils.affichage(chemin)
+
+        # si on est dans le cas d'une modification 1ere d'un contenu, on l'entre en bd (sinon il y est déja)
+        if modifPremiere:
+            max_id_encours = Utils.getMaxIdContenusEnCours()
+            if max_id_encours is None:
+                max_id_encours = 0
+            Utils.statdb.encours.insert_one(
+                {"idContenuEC": max_id_encours + 1, "date": datetime.now().strftime("%d/%m/%y"), "auteur": auteur,
+                 "reference": int(idContenu), "version": version, "branche": "sansObjet"})
+
+            # et on créée une nouvelle branche pour accueillir ce contenu en cours
+
+    ## Mettre à jour un contenu (branche principale)
+    @staticmethod
+    def majContenu(chemin, idContenu, nomBranche):
+
+        fin = Utils.affichage(chemin)
+        version = int(fin[-1])
+        # Mise à jour des métadonnées
+        version_en_cours = Utils.statdb.contenu.find_one({"id": int(idContenu)})["versionEnCours"]
+        Utils.statdb.contenu.update_one({"id": int(idContenu)}, {"$push": {"historique": version_en_cours}})
+        Utils.statdb.contenu.update_one({"id": int(idContenu)}, {
+            "$set": {"versionEnCours": {"numero": version + 1, "date": datetime.now().strftime("%d/%m/%y"),
+                                        "popularite": 0, "branche": "master"}}})
+
+        # Mise à jour du répertoire git
+        UtilsGit.mergeVersion(chemin, nomBranche)
+
+    ## Supprimer une évaluation (définitif)
+    # @param idEval l'id de l'évaluation à supprimer
+    @staticmethod
+    def supprimerEvaluation(idEval):
+        Utils.statdb.evaluation.delete_one({"idEval": idEval})
+
+    ## Fonction pour savoir combien de favoris actifs d'un contenu existent
+    # @param idContenu
+    @staticmethod
+    def sumContenuEnFavori(idContenu):
+        return Utils.statdb.utilisateur.find(
+            {"favoris": {"$elemMatch": {"$elemMatch": {"contenu": idContenu}}}}).count()
+
+    ## Suppression définitive d'un contenu
+    @staticmethod
+    def aneantirContenu(idContenu):
+        Utils.statdb.contenu.delete_one({"id": idContenu})
+
+    ## permet de récupérer tous les contenus en cours pour un auteur
+    # @param auteur le nom de l'auteur
+
+    @staticmethod
+    def getContenusEnCours(auteur):
+        return Utils.statdb.encours.find({"auteur": auteur})
+
+    ## permet de récupérer le contenu originel associé à un contenu en cours
+    # @param idContenuEnCours l'id du contenu en cours de modification
+
+    @staticmethod
+    def getIdContenuAssocieAUnEnCours(idContenuEnCours):
+        print("L'id en cours que j'ai est", idContenuEnCours, " - ", type(idContenuEnCours))
+        return Utils.statdb.encours.find_one({"idContenuEC": idContenuEnCours})["reference"]
+
+    ## récupérer le chemin d'un fichier associé à un contenu
+    # @param idContenu l'id du contenu
+
+    @staticmethod
+    def getFichierContenu(idContenu):
+        return Utils.chemin + Utils.statdb.contenu.find_one({"id": idContenu})["fichier"]
+
+    ## permet de changer de version pour un contenu (modification de la branche / du commit en fonction de la situation)
+    # @param idContenu le contenu concerné
+    # @param version la version du contenu désirée
+    # @param nomBranche changement direct de branche -> utile pour naviguer parmi les versions "en cours"
+    @staticmethod
+    def changerVersion(idContenu, version, nomBranche):
+        # on recupere le chemin du fichier associé au contenu (dans les 2 cas)
+        chemin = Utils.getFichierContenu(idContenu)
+        if version != 0:
+            # on change le repertoire récupéré ci dessus dans la bonne version (si on travaille avec une version)
+            idCommit = Utils.getCommitPourUneVersion(idContenu, version)
+            UtilsGit.changerVersionCommit(chemin, idCommit)
+        else:
+            UtilsGit.changerVersionBranche(chemin, nomBranche)
+
+    ## permet de recuperer un commit particulier lié avec une version donnee
+    # @param idContenu l'id du contenu manipulé
+    # @param version le numéro de version désiré
+    @staticmethod
+    def getCommitPourUneVersion(idContenu, version):
+        return 42
+
+    ## supprimer un contenu en cours
+    # @param idContenuEnCours id du contenu a supprimer
+    @staticmethod
+    def supprimerContenuEnCours(idContenuEnCours):
+        Utils.statdb.encours.delete_one({"idContenuEC": idContenuEnCours})
+
+    ## récupérer l'auteur initial d'un contenu en cours (peut être l'auteur effectuant la modification ou non)
+    # @param idContenuEnCours l'id du contenu en cours de modification
+    @staticmethod
+    def getAuteurContenuEnCours(idContenuEnCours):
+        id_contenu = Utils.getIdContenuAssocieAUnEnCours(idContenuEnCours)
+        return Utils.statdb.contenu.find_one({"id": id_contenu})["auteur"]
+
+    ## A NE JAMAIS UTILISER SANS REFLECHIR
+    # Suppression integrale de la base de données & recreation des 3 auteurs
+    @staticmethod
+    def toutPeter():
+        Utils.statdb.contenu.delete_many({})
+        Utils.statdb.utilisateur.delete_many({})
+        Utils.statdb.evaluation.delete_many({})
+        Utils.statdb.encours.delete_many({})
+        Utils.ajouterUtilisateur("Auteur 1")
+        Utils.ajouterUtilisateur("Auteur 2")
+        Utils.ajouterUtilisateur("Auteur 3")
+

UtilsGit.py

+from git import Repo
+
+
+class UtilsGit:
+    ## affichage d'un index (permet une extraction à partir du contenu d'un fichier)
+    # utile uniquement pour la démonstration du squelette
+    @staticmethod
+    def getIndex():
+        with open("/home/jeremie/Stage/Test_Main/test", "r") as fichier:
+            texte = fichier.read()
+
+        texte = texte.strip()
+        return int(texte[-1]) + 1
+
+
+    ## commit d'un fichier (branche principale)
+    # @param cheminFichier le chemin du fichier
+    # @param texteCommit le texte associé au commit
+    # @return le hash du commit
+    @staticmethod
+    def commit(cheminFichier, texteCommit):
+        repo = Repo.init(cheminFichier)
+
+        # Il faudra faire une extraction du nom du fichier a partir du chemin
+        repo.index.add([cheminFichier])
+        repo.index.commit(texteCommit)
+
+        return repo.head.object.hexsha
+
+
+    ## commit d'un fichier (branche principale)
+    # @param cheminFichier le chemin du fichier
+    # @param texteCommit le texte associé au commit
+    # @return le hash du commit
+    @staticmethod
+    def embranchement(cheminFichier, nomBranche):
+
+        # a voir pour améliorer le Repo.init à chaque fois
+        repo = Repo.init(cheminFichier)
+        repo.create_head(nomBranche, 'HEAD')
+
+    ## changer la version actuelle (avec une base commit):
+    # @param chemin chemin du repertoire git
+    # @param commit branche contenant le commit de la version à charger
+    @staticmethod
+    def changerVersionCommit(chemin, commit):
+        repo = Repo.init(chemin)
+        repo.head.reference = repo.commit(commit)
+        repo.head.reset(index=True, working_tree=True)
+
+    ## changer la version actuelle (avec une base branche):
+    # @param chemin chemin du repertoire git
+    # @param nombranche branche contenant la branche avec le contenu désiré
+    @staticmethod
+    def changerVersionBranche(chemin, branche):
+        repo = Repo.init(chemin)
+        repo.head.reference = branche
+        repo.head.reset(index=True, working_tree=True)
+
+    ## valider une nouvelle version courante d'un contenu - Un peu plus compliqué à faire.
+    # @param chemin chemin du repertoire git
+    # @param nombranche branche contenant le contenu temporaire à repasser en principal
+    @staticmethod
+    def mergeVersion(chemin, nombranche):
+        pass