Modifications pour ajout des fonctionnalités git (en cours)

.gitignore

@@ -2,3 +2,5 @@ __pycache__/
 venv/
 .idea/
 dossierContenu*/
+en_cours/
+60*/

60cb7408a78a6274d18e1c13 @ e5e72d0f

+Subproject commit e5e72d0f4b1846df027dd811646f143270b04f56

app.py

 import distutils
 from distutils import util
 
-from bson import json_util
+from bson import json_util, ObjectId
 from flask import Flask, request
 from pymongo import MongoClient
 
-from modele.contenuDao import ContenuDao
+from config.utils import Utils
+from modele.contenu_dao import ContenuDao
 from modele.demande_pubDao import DemandePubDao
-from modele.encoursDao import EncoursDao
-from modele.evaluationDao import EvaluationDao
-from modele.utilisateurDao import UtilisateurDao
+from modele.encours_dao import EncoursDao
+from modele.evaluation_dao import EvaluationDao
+from modele.utilisateur_dao import UtilisateurDao
 
 import json
 
@@ -66,9 +67,8 @@ def ajouter_tiers():
 @cross_origin()
 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)
+    contenu_a_ecrire = request.json["contenu_a_ecrire"]
+    contenu_dao.ajouter_contenu(auteur, contenu_a_ecrire)
     return "Contenu ajouré"
 
 
@@ -130,6 +130,7 @@ def maj_contenu():
     else:
         auteur = request.json["auteur"]
     contenu_dao.maj_contenu(id_contenu["$oid"], auteur)
+    return "Le contenu a été mis à jour"
 
 
 @app.route("/gererDemandePub", methods=['PATCH'])
@@ -137,7 +138,7 @@ def maj_contenu():
 def gerer_demande_pub():
     id_publication = json.loads(request.json["id_publication"])
     demande_pub_Dao.gerer_demande_pub(id_publication["$oid"], request.json["reponse"], request.json["auteur"])
-    return "Réponse à la publication gérer"
+    return "Réponse à la publication gérée"
 
 
 @app.route("/allContenus", methods=['GET'])
@@ -164,9 +165,58 @@ def liste_maj_tiers(auteur):
     return json.dumps(contenu_dao.liste_tiers_maj(auteur), default=json_util.default)
 
 
+@app.route("/gererMajTiers", methods=['PATCH'])
+@cross_origin()
+def gerer_maj_tiers():
+    id_tiers = json.loads(request.json["id_tiers"])
+
+    if request.json["reponse"] == 'o':
+        refuse = False
+    else:
+        refuse = True
+
+    version = contenu_dao.get_version_tiers_avec_id(id_tiers["$oid"], request.json["auteur"])
+
+    contenu_dao.maj_tiers(id_tiers["$oid"], int(version) + 1, request.json["auteur"], refuse)
+    return "Tiers géré"
+
+
+@app.route("/getTexteContenu/<id_json>", methods=['GET'])
+@cross_origin()
+def get_texte_contenu(id_json):
+    id_contenu = json.loads(id_json)
+    return Utils().recuperer_contenu_fichier(id_contenu["$oid"])
+
+
+@app.route("/changerTexte/<id_contenu>", methods=['PATCH'])
+@cross_origin()
+def changer_texte_contenu(id_contenu):
+
+    if len(id_contenu) % 12 == 0:
+        id_contenu = ObjectId(id_contenu)
+    else:
+        tmp = json.loads(id_contenu)
+        id_contenu = tmp["$oid"]
+
+    Utils().changer_texte_fichier(id_contenu, request.json["nouveau_texte"])
+    return "Texte Maj"
+
+
 ## *********************************************************************************************************************
 ## Gestion des Contenus en Cours
 
+@app.route("/getTexteContenuEnCours/<id_json>", methods=['GET'])
+@cross_origin()
+def get_texte_contenu_en_cours(id_json):
+    if len(id_json) % 12 == 0:
+
+        id_du_contenu = ObjectId(id_json)
+    else:
+        tmp = json.loads(id_json)
+        id_du_contenu = tmp["$oid"]
+
+    return Utils().recuperer_contenu_fichier(id_du_contenu, True)
+
 
 @app.route("/getEnCours/<id_en_cours>", methods=['GET'])
 @cross_origin()
@@ -207,7 +257,7 @@ def supprimer_en_cours_par_id(id_en_cours):
 def creer_en_cours():
     id_contenu = json.loads(request.json["id_contenu"])
     en_cours_dao.creer_en_cours(request.json['auteur'], id_contenu["$oid"], request.json['version'])
-    return "En Cours créé"
+    return en_cours_dao.recuperer_dernier_id()
 
 
 @app.route("/newEnCoursRefuse", methods=['POST'])

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)
-
-
-## Fonction permettant de changer la version
-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

config/gitUtils.py

+from git import Repo
+
+
+class GitUtils:
+
+    ## commit d'un fichier (branche principale)
+    # @param cheminFichier le chemin du fichier
+    # @param texteCommit le texte associé au commit
+    # @return le hash du commit
+    def commit(self, cheminFichier, nomFichier, texteCommit):
+        repo = Repo.init(cheminFichier)
+
+        # # Il faudra faire une extraction du nom du fichier a partir du chemin
+        repo.index.add([nomFichier])
+        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
+    def embranchement(self, cheminFichier, nomBranche):
+        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
+    def changerVersionCommit(self, chemin, commit):
+        repo = Repo.init(chemin)
+        repo.head.reference = repo.commit(commit)
+        repo.head.reset(index=True, working_tree=True)
+        # repo.git.checkout("c785462dfd454045798baedb11d1674837733962")
+
+    ## 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é
+    def changerVersionBranche(self, chemin, branche):
+        repo = Repo.init(chemin)
+        repo.git.checkout(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
+    def mergeVersion(self, chemin, nombranche):
+        # "objectif : fusionner main et en_cours"
+        repo = Repo.init(chemin)
+        master = repo.branches['master']
+        enCours = repo.branches[nombranche]
+        # merge des deux branches
+        base = repo.merge_base(enCours, master)
+        repo.index.merge_tree(master, base=base)
+
+        # on commit le merge
+        repo.index.commit('Mise à jour de la branche principale',
+                          parent_commits=(enCours.commit, master.commit))
+
+        return repo.head.object.hexsha

config/utils.py

+from flask import Flask
+from flask_pymongo import PyMongo
+
+from config.gitUtils import GitUtils
+
+app = Flask(__name__)
+app.config["MONGO_URI"] = "mongodb://localhost:27017/squelette"
+mongo = PyMongo(app)
+
+
+class Utils:
+    ## Fonction permettant de changer la version
+    def changer_version(self, idContenu, version, nomBranche=""):
+        from modele.contenu_dao import ContenuDao
+        # on recupere le chemin du fichier associé au contenu (dans les 2 cas)
+        chemin = ContenuDao().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 = ContenuDao().get_commit_pour_une_version(idContenu, version)
+            GitUtils().changerVersionCommit(repertoire, idCommit)
+        else:
+            GitUtils().changerVersionBranche(repertoire, nomBranche)
+
+    def recuperer_contenu_fichier(self, id_contenu, en_cours=False):
+        from modele.contenu_dao import ContenuDao
+        from modele.encours_dao import EncoursDao
+
+        if(en_cours):
+            chemin = EncoursDao().get_chemin_contenu_en_cours(id_contenu)
+        else:
+
+            chemin = ContenuDao().get_chemin_du_contenu(id_contenu)
+        with open(chemin, "r") as fichier:
+            texte = fichier.read()
+
+        return texte.strip()
+
+    ## Fonction qui permet de mettre à jour l'intérieur du texte d'un contenu
+    def changer_texte_fichier(self, id_contenu, nouveau_texte):
+        from modele.contenu_dao import ContenuDao
+        from modele.encours_dao import EncoursDao
+        chemin_fichier = EncoursDao().get_chemin_contenu_en_cours(id_contenu)
+        print("chemin_fichier " + chemin_fichier)
+        myFile = open(chemin_fichier, "w")
+        # y ajouter le texte du contenu
+        myFile.write(nouveau_texte)
+        myFile.close()

en_cours/60cb7414a78a6274d18e1c14

+gkvihgiv
\ No newline at end of file

en_cours/60cb746ec667d5c52f6ff4c8

+gkvihgiv
\ No newline at end of file

en_cours/60cb74be866d7d37682125e0

+gkvihgiv
\ No newline at end of file

en_cours/60cb7544ef8c780ec43e9b3d

+gkvihgiv
\ No newline at end of file

en_cours/60cb75bfcc902554cd2dedee

+gkvihgiv
\ No newline at end of file

en_cours/60cb75f284e8571c90510cea

+gkvihgiv
\ No newline at end of file

en_cours/60cb761a3409ff2514ebdb3b

+gkvihgiv
\ No newline at end of file

en_cours/60cb764e3409ff2514ebdb3c

+gkvihgiv
\ No newline at end of file

en_cours/60cb76a631a517fd7a1d8dc3

+gkvihgiv
\ No newline at end of file

en_cours/60cb78439088e862b6790f21

+gkvihgiv
\ No newline at end of file

en_cours/60cb79179088e862b6790f22

+gkvihgiv
\ No newline at end of file

en_cours/60cb7a22e58ae943f2671e78

+gkvihgiv
\ No newline at end of file

en_cours/60cb7aa7cd73a823119f4dba

+gkvihgiv
\ No newline at end of file

en_cours/60cb7aa7cd73a823119f4dba60cb7aa7cd73a823119f4dba

+gkvihgiv22
\ No newline at end of file

en_cours/60cb7b196383b05c80696812

+gkvihgivle caca le pipi
\ No newline at end of file

modele/contenuDao.py → modele/contenu_dao.py

@@ -9,13 +9,14 @@ import os
 from pathlib import Path
 import string
 
-from modele.demande_pubDao import *
-from modele.encoursDao import *
+from config.gitUtils import GitUtils
+from modele.encours_dao import EncoursDao
 
 
 class ContenuDao:
     client = MongoClient('localhost', 27017)
-    chemin = "/home/passerat/Stage/Squelette/"
+    chemin = "/home/passerat/Stage/flaskProject/"
+    gitUtils = GitUtils()
 
     ## extraction d'une base de données. Si elle n'existe pas, elle esst créée
     base_donnees = client.squelette
@@ -24,15 +25,42 @@ class ContenuDao:
     # @param l'auteur en cours
     # @param nom_fichier le nom du fichier associé au contenu
     # @param commit le 'hash' du commit associé (récupéré via git)
-    def ajouter_contenu(self, auteur, nom_fichier, commit):
+    def ajouter_contenu(self, auteur, contenu_a_ecrire):
+
+        # créer la métadonnée dans la base mongo
         self.base_donnees.contenu.insert_one(
             {"auteur": auteur, "note": randrange(0, 10, 1),
-             "fichier": "dossier" + nom_fichier + "/" + nom_fichier,
+             "fichier": "",
              "versionEnCours": {"numero": 1, "date": datetime.now().strftime("%d/%m/%y"),
-                                "popularite": 0, "commit": commit},
+                                "popularite": 0, "commit": ""},
              "tags_banque_fixes": ["tag1", "tag2", "tag3", "tag4", "tag5"],
              "tags_banque_libres": ["tagl1", "tagl2", "tagl3", "tagl4", "tagl5"], "type": " ", "source": " "})
 
+        # créer un fichier (au bon endroit)
+        # récupérer l'id mongo (pour nommer le répertoire)
+        never_shall_we_die = self.base_donnees.contenu.find().sort("_id", -1).limit(1)
+
+        record = next(never_shall_we_die, None)
+        nom_contenu = str(record.get("_id"))
+
+        chemin_fichier = self.chemin + "/" + nom_contenu + "/"
+        Path(chemin_fichier).mkdir(parents=True, exist_ok=True)
+
+        myFile = open(chemin_fichier + nom_contenu, "w")
+        # y ajouter le texte du contenu
+        myFile.write(contenu_a_ecrire)
+        myFile.close()
+
+        # mettre a jour le chemin du contenu
+        self.base_donnees.contenu.update_one({"_id": record.get("_id")},
+                                             {"$set": {"fichier": nom_contenu + "/" + nom_contenu}})
+
+        # initialiser le git et récupérer le commit
+        commit = self.gitUtils.commit(chemin_fichier, nom_contenu, "version" + str(1))
+
+        #  puis le mettre a jour dans le contenu
+        self.base_donnees.contenu.update_one({"_id": record.get("_id")}, {"$set": {"commit": commit}})
+
     ## recherche d'un contenu par id (pour affichage de son contenu. charge la version courante
     # @param id_contenu l'id du contenu recherché
     def get_contenu_par_id(self, id_contenu):
@@ -152,8 +180,8 @@ class ContenuDao:
         # hard codé pour l'exemple, sera adaptatif dans le futur
         max_id = 3
 
-        id_contenu = DemandePubDao().get_id_contenu_associe_a_une_publication(id_demande_publication)
-        id_contenu_en_cours = DemandePubDao().get_id_contenu_en_cours_associe_a_une_publication(id_demande_publication)
+        id_contenu = modele.DemandePubDao().get_id_contenu_associe_a_une_publication(id_demande_publication)
+        id_contenu_en_cours = modele.DemandePubDao().get_id_contenu_en_cours_associe_a_une_publication(id_demande_publication)
 
         chemin = self.get_chemin_du_contenu(id_contenu)
 
@@ -172,19 +200,20 @@ class ContenuDao:
                             "5": "tag1"},
              "tags": {"1": "tag1", "2": "tag1", "3": "tag1", "4": "tag1", "5": "tag1"}})
 
-        DemandePubDao().supprimer_publication(id_demande_publication)
+        modele.DemandePubDao().supprimer_publication(id_demande_publication)
 
     ## récupère le chemin d'un contenu
     # @param id_contenu l'id du contenu recherché
     # @return le chemin désiré
     def get_chemin_du_contenu(self, id_contenu):
-        if type('id_contenu') == "String":
+
+        if type('id_contenu') == str:
             id_contenu = ObjectId(id_contenu)
         return self.chemin + self.base_donnees.contenu.find_one({"_id": id_contenu})["fichier"]
 
     ## récupère la version en cours du contenu
     def get_version_courante(self, id_contenu):
-        if type('id_contenu') == "String":
+        if type('id_contenu') == str:
             id_contenu = ObjectId(id_contenu)
         return self.base_donnees.contenu.find_one({"_id": id_contenu})["versionEnCours"]["numero"]
 
@@ -214,7 +243,7 @@ class ContenuDao:
         # Mise à jour du répertoire git
         # idCommit = UtilsGit.mergeVersion(repertoire, nomBranche)
 
-        if type('id_contenu') == "String":
+        if type('id_contenu') == str:
             id_contenu = ObjectId(id_contenu)
 
         # Mise à jour des métadonnées - ok
@@ -236,21 +265,12 @@ class ContenuDao:
         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)
+        chemin = self.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
 
-    ## modification d'un contenu (version test)
-    # @param idCOntenu l'id du contenu à modifier
-    # @param auteur l'auteur soihaitant modifier le contenu
-    # @param enCours si true, le contenu modifié est déja un en cours. SI false, il ne l'était pas
-    def modifier_contenu(self, idContenu, auteur, enCours=False):
-        # le chemin du fichier restera tjrs le même
-        contenu = self.base_donnees.contenu.find_one({"id": int(idContenu)})
-        self.base_donnees.modification_fichier(self.chemin + contenu["fichier"], idContenu, auteur, not enCours)
 
     ## après fin de consultation, destruction du fichier temporaire généré
     # @param id l'id du contenu consulté
@@ -277,7 +297,7 @@ class ContenuDao:
     # @param idContenu le contenu à 'tester'
     # @return booléen true.false si le contenu est chez l'auteur ou pas
     def is_tiers_auteur(self, auteur, idContenu):
-        return self.get_version_tiers_avec_id(idContenu, auteur) != 0
+        return self.get_version_tiers_avec_id(ObjectId(idContenu), auteur) != 0
 
     ## mettre à jour un contenu 'tiers'
     # @param auteur l'auteur concerné
@@ -334,3 +354,13 @@ class ContenuDao:
                 liste += self.get_contenu_avec_id_et_version(id, version)
 
         return liste
+
+    def get_commit_pour_une_version(self, idContenu, version):
+        if version == self.get_version_courante(idContenu):
+            courante = self.base_donnees.contenu.find_one({"id": idContenu})["versionEnCours"]
+            return courante["commit"]
+        else:
+            historique = self.base_donnees.contenu.find_one({"id": idContenu})["historique"]
+            for elt in historique:
+                if elt["numero"] == version:
+                    return elt["commit"]

modele/demande_pubDao.py

@@ -2,8 +2,7 @@ from pymongo import MongoClient
 from datetime import datetime
 from bson import ObjectId
 
-from modele.contenuDao import *
-from modele.encoursDao import *
+
 
 
 class DemandePubDao:
@@ -23,7 +22,8 @@ class DemandePubDao:
         self.base_donnees.demandesPub.insert_one(
             {"date": datetime.now().strftime("%d/%m/%y"), "auteurDemande": auteur_en_cours,
              "auteurContenu": auteur, "idContenu": ObjectId(id_contenu),
-             "idContenuEnCours": ObjectId(id_contenu_en_cours), "version_en_cours": version_en_cours, "etat": "enCours"})
+             "idContenuEnCours": ObjectId(id_contenu_en_cours), "version_en_cours": version_en_cours,
+             "etat": "enCours"})
 
     ## Fonction permettant de gérer une demande de publication
     # @param idPublication l'id de la demande de publication
@@ -31,7 +31,7 @@ class DemandePubDao:
     # @param auteur l'auteur d'origine
     def gerer_demande_pub(self, idPublication, reponse, auteurEnCours):
         if reponse == 'o':
-            #branche = self.get_branche_contenu_en_cours(id_en_cours)
+            # branche = self.get_branche_contenu_en_cours(id_en_cours)
 
             # on récupère l'id du contenu d'origine et l'id en cours
             id_contenu = self.get_id_contenu_associe_a_une_publication(idPublication)
@@ -43,12 +43,11 @@ class DemandePubDao:
             # on notifie au 'demandeur' que sa demande de publication est acceptée
             self.base_donnees.demandesPub.update_one({"_id": ObjectId(idPublication)}, {"$set": {"etat": "accepté"}})
 
-            version = ContenuDao().get_version_courante(id_contenu)
-
+            version = modele.ContenuDao().get_version_courante(id_contenu)
 
             # On met à jour le tiers (chez le 'demandeur' de la publication)
-            ContenuDao().maj_tiers(id_contenu, version, auteurEnCours)
-            EncoursDao().supprimer_contenu_en_cours(id_contenu_en_cours)
+            modele.ContenuDao().maj_tiers(id_contenu, version, auteurEnCours)
+            modele.EncoursDao().supprimer_contenu_en_cours(id_contenu_en_cours)
         else:
             # on change l'état de la demande de publication
             self.base_donnees.demandesPub.update_one({"_id": ObjectId(idPublication)}, {"$set": {"etat": "refus"}})

modele/encoursDao.py → modele/encours_dao.py

+from pathlib import Path
+
 from bson import ObjectId
 from pymongo import MongoClient
 from datetime import datetime
 
+from config.gitUtils import GitUtils
+from config.utils import Utils
+
 
 class EncoursDao:
     client = MongoClient('localhost', 27017)
+    chemin = "/home/passerat/Stage/flaskProject/"
+    gitUtils = GitUtils()
+    utils = Utils()
 
     ## extraction d'une base de données. Si elle n'existe pas, elle esst créée
     base_donnees = client.squelette
@@ -44,23 +52,49 @@ class EncoursDao:
     ## supprimer un contenu en cours
     # @param idContenu id du contenu  de la reference a supprimer
     def supprimer_contenu_en_cours(self, idContenuEnCours):
-
         self.base_donnees.encours.delete_one({"reference": ObjectId(idContenuEnCours)})
 
     ## supprimer un contenu en cours avec l'id
     # @param idContenuEnCours id du contenu a supprimer
     def supprimer_contenu_en_cours_via_id(self, idContenuEnCours):
-
         self.base_donnees.encours.delete_one({"_id": ObjectId(idContenuEnCours)})
 
-
     ## création d'un contenu en cours
     # @param version la version du contenu d'origine
     # @param nomBranche -> plus utile.
-    def creer_en_cours(self, auteur, idContenu, version):
+    def creer_en_cours(self, auteur, id_contenu, version):
         self.base_donnees.encours.insert_one(
-            {"date": datetime.now().strftime("%d/%m/%y"), "auteur": auteur,
-             "reference": ObjectId(idContenu), "version": version})
+            {"date": datetime.now().strftime("%d/%m/%y"), "fichier": "", "auteur": auteur,
+             "reference": ObjectId(id_contenu), "version": version})
+
+        id = self.recuperer_dernier_id()
+
+        # Deux choix -> création d'une branche dans le répertoire idContenu / idContenu
+
+        # chemin = ContenuDao().get_chemin_du_contenu(id_contenu)
+        #
+        # self.base_donnees.encours.update_one({"_id": id},
+        #                                      {"$set": {"branche": id}})
+        #
+        # GitUtils().changerVersionBranche(chemin, id)
+
+        # Ou création d'un autre répertoire id_en_cours / id_en_cours
+
+        chemin_fichier = self.chemin + "en_cours/"
+
+        Path(chemin_fichier).mkdir(parents=True, exist_ok=True)
+
+        myFile = open(chemin_fichier + id, "w")
+        # y ajouter le texte du contenu
+        myFile.write(self.utils.recuperer_contenu_fichier(id_contenu))
+        myFile.close()
+
+        # mettre a jour le chemin du contenu
+        self.base_donnees.encours.update_one({"_id": ObjectId(id)},
+                                             {"$set": {"fichier": "en_cours/" + id}})
+
+        # initialiser le git et récupérer le commit
+        # self.gitUtils.commit(chemin_fichier, id, "version" + str(version))
 
     ## création d'un contenu en cours, dans l'état refuse
     # @param version la version du contenu d'origine
@@ -69,3 +103,15 @@ class EncoursDao:
         self.base_donnees.encours.insert_one(
             {"date": datetime.now().strftime("%d/%m/%y"), "auteur": auteur,
              "reference": ObjectId(idContenu), "version": version, "etat": "refuse"})
+
+    def recuperer_dernier_id(self):
+        dernier_id_insere = self.base_donnees.encours.find().sort("_id", -1).limit(1)
+
+        record = next(dernier_id_insere, None)
+        return str(record.get("_id"))
+
+    def get_chemin_contenu_en_cours(self, id_contenu):
+        if type('id_contenu') == str:
+            id_contenu = ObjectId(id_contenu)
+
+        return self.chemin + self.base_donnees.encours.find_one({"_id": id_contenu})["fichier"]