Controleur version 0.1

.gitignore

+__pycache__/
+venv/
+.idea/
+dossierContenu*/

app.py

+from bson import json_util
+from flask import Flask, request
+from pymongo import MongoClient
+
+from modele.contenuDao import ContenuDao
+from modele.demande_pubDao import DemandePubDao
+from modele.encoursDao import EncoursDao
+from modele.evaluationDao import EvaluationDao
+from modele.utilisateurDao import UtilisateurDao
+import json
+
+app = Flask(__name__)
+
+contenu_dao = ContenuDao()
+utilisateur_dao = UtilisateurDao()
+demande_pub_Dao = DemandePubDao()
+evaluation_dao = EvaluationDao()
+en_cours_dao = EncoursDao()
+
+client = MongoClient('localhost', 27017)
+
+base_donnees = client.squelette
+
+
+## *********************************************************************************************************************
+## Routage utilisateur : 1 post, 1 get, 2 patch
+@app.route('/newUser', methods=['POST'])
+def creer_utilisateur():
+    utilisateur_dao.ajouter_utilisateur(request.json["login"])
+    return "Utilisateur créé"
+
+
+@app.route('/checkUser', methods=['POST'])
+def verifier_utilisateur():
+    return str(utilisateur_dao.presence_utilisateur(request.json["login"]))
+
+
+@app.route('/changePassword', methods=['PATCH'])
+def changer_mdp():
+    pass
+
+
+@app.route('/ajouterTiers', methods=['POST'])
+def ajouter_tiers():
+    contenu_dao.creer_tiers(request.json["auteur"], request.json["id_tiers"], 1)
+    return "tiers ajouté"
+
+
+## *********************************************************************************************************************
+## Routage contenus : beaucoup de fonctions
+@app.route("/newContenu", methods=['POST'])
+def ajouter_contenu():
+    auteur = request.json["auteur"]
+    nom_fichier = request.json["nom_fichier"]
+    commit = request.json["commit"]
+    contenu_dao.ajouter_contenu(auteur, nom_fichier, commit)
+    return "Contenu ajouré"
+
+
+@app.route("/getContenu/<id>", methods=['GET'])
+def get_contenu_par_id(id):
+    return json.dumps(list(contenu_dao.get_contenu_par_id(int(id))), default=json_util.default)
+
+
+@app.route("/getContenuPanier/<auteur>", methods=['GET'])
+def get_contenu_panier(auteur):
+    print(contenu_dao.get_contenus(auteur, True, True, True))
+    return json.dumps(contenu_dao.get_contenus(auteur, True, True, True), default=json_util.default)
+
+
+@app.route("/deletePerso/<id_perso>", methods=['DELETE'])
+def supprimer_perso(id_perso):
+    contenu_dao.supprimer_contenu(id_perso)
+
+
+@app.route("/deleteTiers/<id_tiers>", methods=['DELETE'])
+def supprimer_tiers(id_tiers):
+    contenu_dao.supprimer_tiers(id_tiers, request.args.get('auteur'), request.args.get('version'))
+
+
+@app.route("/newContenu", methods=['POST'])
+def creer_nouveau_contenu():
+    pass
+
+
+@app.route("/majContenu", methods=['PATCH'])
+def maj_contenu():
+    pass
+
+
+@app.route("/allContenus", method=['GET'])
+def get_tous_les_contenus():
+    return json.dumps(list(contenu_dao.get_tous_les_contenus()), default=json_util.default)
+
+
+@app.route("/isContenuAnonyme/<id_contenu>", methods=['GET'])
+def is_contenu_anonyme(id_contenu):
+    return str(contenu_dao.is_anonyme(id_contenu))
+
+
+## *********************************************************************************************************************
+## Gestion des Contenus en Cours
+
+
+@app.route("/getEnCours/<id_en_cours>", methods=['GET'])
+def get_contenu_en_cours(id_en_cours):
+    return json.dumps(list(en_cours_dao.get_contenu_en_cours(id_en_cours)), default=json_util.default)
+
+
+@app.route("/getAuteurOrigineEnCours/<id_en_cours>", methods=['GET'])
+def get_contenu_en_cours(id_en_cours):
+    return json.dumps(list(en_cours_dao.get_auteur_origine_contenu_en_cours(id_en_cours)), default=json_util.default)
+
+
+@app.route("/isContenuDemandePublication/<id_en_cours>/<auteur>", method=['GET'])
+def is_contenu_demande_publication(id_en_cours, auteur):
+    return str(en_cours_dao.is_en_cours_demande(id_en_cours, auteur))
+
+
+@app.route("/supprimerEnCours/<id_en_cours>", methods=['DELETE'])
+def supprimer_en_cours(id_en_cours):
+    en_cours_dao.supprimer_contenu_en_cours(id_en_cours)
+
+
+@app.route("/newEnCours", methods=['POST'])
+def creer_en_cours():
+    en_cours_dao.creer_en_cours(request.args.get('id_contenu'), request.args.get('version'),
+                                request.args.get('branche'))
+    return "En Cours créé"
+
+
+## *********************************************************************************************************************
+## Gestion des Publications
+
+@app.route("/demandePublication", methods=['POST'])
+def demande_de_publication():
+    demande_pub_Dao.creer_demande_publication(request.args.get('id_contenu'), request.args.get('id_contenu_en_cours'),
+                                              request.args.get('auteur_en_cours'), request.args.get('auteur'))
+
+
+@app.route("/demandePublication/<auteur>/<emise>", method=['GET'])
+def get_demandes_pub(auteur, emise):
+    return demande_pub_Dao.get_demandes_pub(auteur, emise)
+
+
+@app.route("/demandePublication/<id_publication>", method=['DELETE'])
+def get_demandes_pub(id_publication):
+    demande_pub_Dao.supprimer_publication(id_publication)
+
+
+## *********************************************************************************************************************
+## Gestion des Evaluations
+
+@app.route("/newEval", methods=['POST'])
+def creer_evaluation():
+    evaluation_dao.creer_evaluation(request.args.get('contenus'), request.args.get('auteur'))
+    return "evaluation créée"
+
+
+@app.route("/getEval/<auteur>/<id_evaluation>", methods=['GET'])
+def get_evaluation(auteur, id_evaluation):
+    return json.dumps(list(evaluation_dao.get_evaluations(auteur, id_evaluation)), default=json_util.default)
+
+
+@app.route("/getEval/<auteur>", methods=['GET'])
+def get_all_evaluations(auteur):
+    return json.dumps(list(evaluation_dao.get_evaluations(auteur, 0)), default=json_util.default)
+
+
+@app.route("/deleteEval", methods=['DELETE'])
+def supprimer_evaluation(id_evaluation):
+    evaluation_dao.supprimer_evaluation(id_evaluation)
+
+
+if __name__ == '__main__':
+    app.run()

config/connexion.py

+from flask import Flask
+from flask_pymongo import PyMongo
+
+app = Flask(__name__)
+app.config["MONGO_URI"] = "mongodb://localhost:27017/squelette"
+mongo = PyMongo(app)
+
+
+def changer_version(idContenu, version, nomBranche=""):
+    # on recupere le chemin du fichier associé au contenu (dans les 2 cas)
+    chemin = Utils.get_chemin_du_contenu(idContenu)
+    repertoire = chemin[:chemin.rfind("/") + 1]
+
+    if version != 0:
+        # on change le repertoire récupéré ci dessus dans la bonne version (si on travaille avec une version)
+        idCommit = Utils.get_commit_pour_une_version(idContenu, version)
+        UtilsGit.changerVersionCommit(repertoire, idCommit)
+    else:
+        UtilsGit.changerVersionBranche(repertoire, nomBranche)
\ No newline at end of file

modele/contenuDao.py

+from flask_pymongo import PyMongo
+
+from pymongo import MongoClient
+from random import randrange
+from datetime import datetime
+import os
+# from UtilsGit import UtilsGit
+from pathlib import Path
+import string
+
+from modele.encoursDao import EncoursDao
+
+
+class ContenuDao:
+    client = MongoClient('localhost', 27017)
+    chemin = "/home/passerat/Stage/Squelette/"
+
+    ## extraction d'une base de données. Si elle n'existe pas, elle esst créée
+    base_donnees = client.squelette
+
+    def ajouter_contenu(self, auteur, nom_fichier, commit):
+        self.base_donnees.contenu.insert_one(
+            {"id": 1, "auteur": auteur, "note": randrange(0, 10, 1),
+             "fichier": "dossier" + nom_fichier + "/" + nom_fichier,
+             "versionEnCours": {"numero": 1, "date": datetime.now().strftime("%d/%m/%y"),
+                                "popularite": 0, "commit": commit},
+             "tags_banque_fixes": ["tag1", "tag2", "tag3", "tag4", "tag5"],
+             "tags_banque_libres": ["tagl1", "tagl2", "tagl3", "tagl4", "tagl5"], "type": " ", "source": " "})
+
+    ## recherche d'un contenu par id (pour affichage de son contenu)
+    # @param id l'id du contenu recherché
+    def get_contenu_par_id(self, id):
+        return self.base_donnees.contenu.find({"id": id})
+
+    def get_contenu_avec_id_et_version(self, id_contenu, version):
+
+        # a décommenter quand git sera actif
+        # Utils.changer_version(idContenu, version, "")
+        return self.base_donnees.contenu.find_one({"id": id_contenu})
+        # return Utils.statdb.contenu.find_one({"$and": [
+        #     {"id": idContenu},
+        #     {"$or": [{"versionEnCours.numero": version}, {"historique.numero": version}]}
+        # ]
+        # })
+
+    ## recherche des contenus pour un auteur donné (son 'panier')
+    # param
+    def get_contenus(self, auteur, perso, tiers, en_cours):
+
+        contenus = list()
+
+        if tiers:
+            id_tiers = self.get_contenus_tiers(auteur)
+            for (id, version) in id_tiers:
+                contenus.append(
+                    self.get_contenu_avec_id_et_version(int(id['contenu']), int(version['version'])))
+
+        if perso:
+            curseur_perso = self.get_contenus_persos(auteur)
+            for contenu in curseur_perso:
+                contenus.append(contenu)
+
+        if en_cours:
+            curseur_en_cours = EncoursDao().get_en_cours(auteur)
+            for contenu in curseur_en_cours:
+                contenus.append(contenu)
+        # on garde le développement de l'évaliation pour plus tard
+        # return contenus_persos + contenus_en_cours + contenus_tiers
+        return contenus
+
+
+
+    def creer_tiers(self, auteur, id_contenu, version):
+        self.base_donnees.statdb.utilisateur.update({"nom": auteur}, {
+            "$push": {
+                "tiers": [{"contenu": int(id_contenu)}, {"version": version}]}})
+
+    def get_contenus_persos(self):
+        return self.base_donnees.contenu.find({"auteur": auteur})
+
+    def get_contenus_tiers(self, auteur):
+        return self.base_donnees.statdb.utilisateur.find_one({"nom": auteur})["tiers"]
+
+    ## l'auteur 'renie' son contenu, qui reste disponible dans le panier de ceux qui le possédent
+    def dissocier_contenu(self, id_contenu):
+        self.base_donnees.contenu.update({"id": id_contenu}, {"$set": {"auteur": "Aucun"}})
+
+    ## l'auteur 'renie' son contenu, mais vu que personne d'autre ne l'a il est définitivement supprimé
+    def supprimer_contenu(self, id_contenu):
+        self.base_donnees.db.contenu.delete_one({"id": id_contenu})
+
+    def supprimer_tiers(self, id_contenu, auteur, version):
+        self.base_donnees.statdb.utilisateur.update({"nom": auteur},
+                                                    {"$pull": {
+                                                        "tiers": [{"contenu": id_contenu}, {"version": version}]}})
+
+    def existe_en_tiers(self, id_contenu):
+        return self.base_donnees.statdb.utilisateur.find(
+            {"tiers": {"$elemMatch": {"$elemMatch": {"contenu": id_contenu}}}}).count() != 0
+
+    def creer_nouveau_contenu(self, chemin, auteur_en_cours, idContenuEnCours):
+        # print("chemin : ", chemin)
+
+        # hard codé pour l'exemple, sera adaptatif dans le futur
+        max_id = 3
+
+        dossierFichier = "dossierContenu" + str(max_id) + "/"
+        cheminFichier = self.chemin + dossierFichier
+        nomFichier = chemin[chemin.rfind("/") + 1:]
+
+        # print("Chemin fichier : ", cheminFichier)
+        # print("Dossier Fichier : ", dossierFichier)
+        # print("NomFichier :", nomFichier)
+        Path(cheminFichier).mkdir(parents=True, exist_ok=True)
+        os.system("cp " + chemin + " " + cheminFichier)
+        os.system("mv " + cheminFichier + nomFichier + " " + cheminFichier + "Contenu" + str(max_id))
+        # exit(0)
+        #commit = UtilsGit.commit(cheminFichier, "Contenu" + str(max_id), "Version 1")
+        '''
+        self.base_donnees.statdb.contenu.insert_one(
+            {"id": max_id + 1, "auteur": auteur_en_cours, "note": randrange(0, 10, 1),
+             "fichier": "dossierContenu" + str(max_id) + "/Contenu" + str(max_id),
+             "versionEnCours": {"numero": 1, "date": datetime.now().strftime("%d/%m/%y"),
+                                "popularite": 0, "commit": commit},
+             "tags_fixes": {"1": "tag1", "2": "tag1", "3": "tag1", "4": "tag1",
+                            "5": "tag1"},
+             "tags": {"1": "tag1", "2": "tag1", "3": "tag1", "4": "tag1", "5": "tag1"}})
+
+        self.base_donnees.supprimer_contenu_en_cours(idContenuEnCours)
+        '''
+
+    def get_chemin_du_contenu(self, idContenu):
+        return self.chemin + self.base_donnees.contenu.find_one({"id": idContenu})["fichier"]
+
+    def get_version_tiers_avec_id(self, idContenu, auteur):
+        tiers = (self.base_donnees.utilisateur.find_one({"nom": auteur})["tiers"])
+        for i in range(len(tiers)):
+            tmp = tiers[i]
+            if int(tmp[0]["contenu"]) == idContenu:
+                return int(tmp[1]["version"])
+        return 0
+
+    def maj_contenu(self, chemin, idContenu, nomBranche, auteur=None):
+
+        repertoire = chemin[:chemin.rfind("/") + 1]
+        #fin = s.affichage(chemin)
+        version = int(fin[-1])
+
+        # Mise à jour du répertoire git
+        #idCommit = UtilsGit.mergeVersion(repertoire, nomBranche)
+
+        # Mise à jour des métadonnées - ok
+        version_en_cours = self.base_donnees.statdb.contenu.find_one({"id": idContenu})["versionEnCours"]
+        self.base_donnees.statdb.contenu.update_one({"id": int(idContenu)}, {"$push": {"historique": version_en_cours}})
+        self.base_donnees.statdb.contenu.update_one({"id": int(idContenu)}, {
+            "$set": {"versionEnCours": {"numero": version, "date": datetime.now().strftime("%d/%m/%y"),
+                                        "popularite": 0, "commit": idCommit}}})
+        if auteur is not None:
+            self.base_donnees.statdb.contenu.update_one({"id": int(idContenu)}, {
+                "$set": {"auteur": auteur}})
+
+    def consulter_un_contenu(self, id, auteur):
+        # Créer un répertoire au nom de l'auteur (ou l'utiliser si il existe déja)
+        auteur = auteur.lower().replace(" ", "_")
+        repertoire_auteur = self.chemin + auteur + "/"
+        Path(repertoire_auteur).mkdir(parents=True, exist_ok=True)
+        # Copier le fichier lié au contenu dans ce répertoire
+        chemin = Utils.get_chemin_du_contenu(id)
+        nom_fichier = chemin[chemin.rfind("/") + 1:]
+        os.system("cp '" + chemin + "'  '" + repertoire_auteur + nom_fichier + "'")
+        #self.affichage(chemin)
+
+        ## détruire un fichier temporaire
+
+    def modifier_contenu(self, idContenu, auteur, enCours=False):
+        # le chemin du fichier restera tjrs le même
+        contenu = self.base_donnees.statdb.contenu.find_one({"id": int(idContenu)})
+        self.base_donnees.modification_fichier(self.chemin + contenu["fichier"], idContenu, auteur, not enCours)
+
+    def detruire_fichier_tmp(self, id, auteur):
+        auteur = auteur.lower().replace(" ", "_") + "/"
+        chemin = self.get_chemin_du_contenu(id)
+        nom_fichier = chemin[chemin.rfind("/") + 1:]
+        os.system("rm '" + self.chemin + auteur + nom_fichier + "'")
+
+    def get_max_id_contenus(self):
+        ## Fonction permettant de récupérer l'id max présent en base (pour pouvoir incrémenter un nouveau contenu).
+        element = self.base_donnees.statdb.contenu.find().sort("id", -1).limit(1)
+
+        for elt in element:
+            # print("id : ", elt["id"])
+            return int(elt["id"])
+
+    def is_anonyme(self, idContenu):
+        # print("Is anonyme : ", Utils.statdb.contenu.find_one({"id": idContenu})["auteur"])
+        return self.base_donnees.contenu.find_one({"id": idContenu})["auteur"] == "Aucun"
+
+    def get_tous_les_contenus(self):
+        return self.base_donnees.contenu.find()
+
+    def is_tiers_auteur(self, auteur, idContenu):
+        return self.get_version_tiers_avec_id(idContenu, auteur) != 0

modele/demande_pubDao.py

+from pymongo import MongoClient
+from datetime import datetime
+
+
+class DemandePubDao:
+    client = MongoClient('localhost', 27017)
+
+    ## extraction d'une base de données. Si elle n'existe pas, elle esst créée
+    base_donnees = client.squelette
+
+    def creer_demande_publication(self, idContenu, idContenuEnCours, auteurEnCours, auteur):
+        max_id = self.base_donnees.get_max_id_demandes_de_publication()
+        if max_id is None:
+            max_id = 0
+        self.base_donnees.demandesPub.insert_one(
+            {"id": max_id + 1, "date": datetime.now().strftime("%d/%m/%y"), "auteurDemande": auteurEnCours,
+             "auteurContenu": auteur,
+             "idContenu": idContenu, "idContenuEnCours": idContenuEnCours, "etat": "enCours"})
+
+    '''
+    def gerer_demande_pub(self, idPublication, reponse, auteur):
+        if reponse == 'o':
+            print("Publication acceptée")
+            id_en_cours = Utils.get_id_contenu_en_cours_associe_a_une_publication(idPublication)
+            branche = Utils.get_branche_contenu_en_cours(id_en_cours)
+            idContenu = Utils.get_id_contenu_associe_a_une_publication(idPublication)
+            chemin = Utils.get_chemin_du_contenu(idContenu)
+            Utils.maj_contenu(chemin, idContenu, branche)
+            Utils.statdb.demandesPub.update_one({"id": int(idPublication)}, {"$set": {"etat": "accepté"}})
+            Utils.maj_tiers(idContenu, Utils.get_version_courante(idContenu), auteur)
+            Utils.supprimer_contenu_en_cours(id_en_cours)
+        else:
+            print("Publication refusée ", idPublication)
+
+            # on change la valeur "acceptation" de la demande de publication
+            Utils.statdb.demandesPub.update_one({"id": int(idPublication)}, {"$set": {"etat": "refus"}})
+            # Utils.statdb.demandesPub.update_one({"id": 1}, {"$set": {"etat": "refus"}})
+    '''
+
+        ## Supprimer une demande de publication
+        # @param idPub l'id de la demande de publication
+
+    def supprimer_publication(self,idPub):
+        self.base_donnees.demandesPub.delete_one({"id": idPub})
+
+    ## Récupérer l'auteur d'une demande de publication
+    # @param idPub l'id de la demande de publication
+    def get_auteur_demande_publication(self,idPub):
+        return self.base_donnees.demandesPub.find_one({"id": idPub})["auteurDemande"]
+
+    def get_id_contenu_associe_a_une_publication(self,idDdePublication):
+        # print("L'id en cours que j'ai est", idContenuEnCours, " - ", type(idContenuEnCours))
+        return self.base_donnees.demandesPub.find_one({"id": int(idDdePublication)})["idContenu"]
+
+    def get_id_contenu_en_cours_associe_a_une_publication(self,idDdePublication):
+        # print("L'id en cours que j'ai est", idDdePublication, " - ", type(idDdePublication))
+        return self.base_donnees.demandesPub.find_one({"id": int(idDdePublication)})["idContenuEnCours"]
+
+    def get_max_id_demandes_de_publication(self):
+        ## Fonction permettant de récupérer l'id max présent en base (pour pouvoir incrémenter un nouveau contenu).
+        element = self.base_donnees.demandesPub.find().sort("id", -1).limit(1)
+
+        for elt in element:
+            # print("id : ", elt)
+            return int(elt["id"])
+
+    def get_demandes_pub(self, auteur, emises=True):
+        if emises:
+            return self.base_donnees.demandesPub.find({"auteurDemande": auteur})
+        else:
+            return self.base_donnees.demandesPub.find({"auteurContenu": auteur})
\ No newline at end of file

modele/encoursDao.py

+from pymongo import MongoClient
+from datetime import datetime
+
+
+class EncoursDao:
+    client = MongoClient('localhost', 27017)
+
+    ## extraction d'une base de données. Si elle n'existe pas, elle esst créée
+    base_donnees = client.squelette
+
+    ## Fonction qui permet de savoir si un contenu en cours à fait l'objet d'une demande de publication
+    # @param idEnCours l'id du contenu en cours
+    def is_en_cours_demande(self, idEnCours, auteur):
+        return self.base_donnees.demandesPub.find({"id": idEnCours} and {"auteurDemande": auteur}).count() != 0
+
+    ## 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 get_auteur_origine_contenu_en_cours(self, id_contenu_en_cours):
+        id_contenu = self.base_donnees.find_one({"idContenuEC": id_contenu_en_cours})["reference"]
+        return self.base_donnees.contenu.find_one({"id": id_contenu})["auteur"]
+
+    ## récupérer la branche d'un contenu en cours
+    # @param idContenuEnCours l'id du contenu en cours de modification
+    def get_contenu_en_cours(self, id_contenu_en_cours):
+        # id_contenu = Utils.getIdContenuAssocieAUnEnCours(idContenuEnCours)
+        return self.base_donnees.find_one({"idContenuEC": id_contenu_en_cours})
+
+    ## supprimer un contenu en cours
+    # @param idContenuEnCours id du contenu a supprimer
+    def supprimer_contenu_en_cours(self, idContenuEnCours):
+        self.base_donnees.delete_one({"idContenuEC": idContenuEnCours})
+
+
+    def get_max_id_contenus_en_cours(self):
+        ## Fonction permettant de récupérer l'id max présent en base (pour pouvoir incrémenter un nouveau contenu).
+        element = self.base_donnees.find().sort("idContenuEC", -1).limit(1)
+
+        for elt in element:
+            # print("id : ", elt)
+            return int(elt["idContenuEC"])
+
+    def creer_en_cours(self, idContenu, version, nomBranche):
+        max_id_encours = Utils.get_max_id_contenus_en_cours()
+        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": nomBranche})

modele/evaluationDao.py

+from pymongo import MongoClient
+from datetime import datetime
+
+
+class EvaluationDao:
+    client = MongoClient('localhost', 27017)
+
+    ## extraction d'une base de données. Si elle n'existe pas, elle esst créée
+    base_donnees = client.squelette
+
+    def creer_evaluation(self, contenus, auteur):
+
+        # création de l'évaluation
+        max_id_eval = self.base_donnees.get_max_id_evaluations()
+        if max_id_eval is None:
+            max_id_eval = 0
+
+        self.base_donnees.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:
+            self.base_donnees.contenu.update({"id": i}, {"$push": {"evals": max_id_eval + 1}})
+
+    @staticmethod
+    def get_evaluations(self, auteur, id=0):
+        if id == 0:
+            return self.base_donnees.evaluation.find({"auteur": auteur})
+        else:
+            return self.base_donnees.evaluation.find({"auteur": auteur} and {"idEval": id})
+
+    @staticmethod
+    def supprimer_evaluation(self, idEval):
+        self.base_donnees.evaluation.delete_one({"idEval": idEval})
+
+    @staticmethod
+    def get_max_id_evaluations(self):
+        ## Fonction permettant de récupérer l'id max présent en base (pour pouvoir incrémenter un nouveau contenu).
+        element = self.base_donnees.evaluation.find().sort("idEval", -1).limit(1)
+
+        for elt in element:
+            # print("id : ", elt["id"])
+            return int(elt["idEval"])

modele/utilisateurDao.py

+from pymongo import MongoClient
+from random import randrange
+
+
+class UtilisateurDao:
+    client = MongoClient('localhost', 27017)
+
+    ## extraction d'une base de données. Si elle n'existe pas, elle esst créée
+    base_donnees = client.squelette
+
+    def presence_utilisateur(self, nomUtilisateur):
+        # print("Je suis dans présence utilisateur pour ", nomUtilisateur)
+        nmbre = self.base_donnees.utilisateur.find({"nom": nomUtilisateur})
+        # print("Et j'en ai trouvé : ", nmbre.count())
+
+        return nmbre.count() == 1
+
+    def ajouter_utilisateur(self, nomUtilisateur):
+        self.base_donnees.utilisateur.insert_one(
+            {"nom": nomUtilisateur, "note": randrange(0, 10, 1), "tiers": []})