Fin cycle complet xml reponse courte

app.py

@@ -4,6 +4,7 @@ import random
 import string
 from datetime import datetime, timezone, timedelta
 from distutils import util
+from io import BytesIO
 
 from bson import json_util, ObjectId
 from flask import Flask
@@ -80,11 +81,11 @@ def my_invalid_token_callback(expired_token):
 @app.after_request
 def refresh_expiring_jwts(response):
     try:
-        print(get_jwt())
         return response
     except (RuntimeError, KeyError):
         return response
 
+
 ## *********************************************************************************************************************
 ## Fonction pour recharger le token d'accès
 
@@ -92,7 +93,6 @@ def refresh_expiring_jwts(response):
 @jwt_required(refresh=True)
 def refresh():
     identity = get_jwt_identity()
-    print("identity : " + identity)
     access_token = create_access_token(identity=identity)
     return jsonify(access_token=access_token)
 
@@ -235,7 +235,8 @@ class UploaderContenu(Resource):
     @jwt_required()
     def post(self, auteur):
         file = request.files['file']
-        contenu_dao.importer_contenu(auteur, file)
+        tags = request.args.get('tags')
+        contenu_dao.importer_contenu(auteur, file, tags)
         return json.loads(json.dumps((contenu_dao.get_contenu_par_id(contenu_dao.id_dernier_contenu_ajoute())),
                                      default=json_util.default)), 201
 
@@ -304,11 +305,6 @@ class GetContenuPanier(Resource):
     ## récupérer le contenu du panier d'un auteur
     @jwt_required()
     def get(self, auteur):
-        exp_timestamp = get_jwt()["exp"]
-        now = datetime.now(timezone.utc)
-        target_timestamp = datetime.timestamp(now + timedelta(minutes=30))
-        print("tuttutututu : ", datetime.fromtimestamp(exp_timestamp - target_timestamp))
-
         auteur = auteur.replace("_", " ")
         return json.loads(
             json.dumps(contenu_dao.get_contenus(auteur, request.args.get("perso"), request.args.get("tiers"),
@@ -492,7 +488,6 @@ class associer_tag_libre(Resource):
     ## associer un tag libre à un contenu
     @jwt_required()
     def patch(self):
-        print("Couzin")
         id_contenu = json.loads(request.json["id_contenu"])
         ContenuDao().associer_tag_libre(request.json["auteur"], request.json["tag"], id_contenu["$oid"])
         return "tag associe", 201
@@ -689,10 +684,19 @@ class modifier_xml(Resource):
     def patch(self):
         id_contenu = json.loads(request.json['id_contenu'])
         elements_contenu = json.loads(request.json['elements_contenu'])
-        print("elements_contenu : ", elements_contenu)
 
-        ContenuDao().modifier_xml_moodle(id_contenu["$oid"], elements_contenu)
-        return "contenu modifié", 200
+        return ContenuDao().modifier_xml_moodle(id_contenu["$oid"], elements_contenu).decode("utf-8"), 200
+
+
+@contenus.route("/exporterContenuXml/<id_contenu>")
+@contenus.doc(params={'id_contenu': "L'id du contenu à modifier"})
+@contenus.doc(description='exporter un xml moodle (contenu tiers ou perso)')
+class modifier_xml(Resource):
+    @contenus.response(200, "contenu exporté")
+    def get(self, id_contenu):
+        id_contenu = json.loads(id_contenu)
+        chemin = ContenuDao().get_chemin_du_contenu(id_contenu["$oid"])
+        return send_file(chemin)
 
 
 en_cours = api.namespace('en_cours', description='Entrées liées à la gestion des contenus en cours')
@@ -701,6 +705,18 @@ en_cours = api.namespace('en_cours', description='Entrées liées à la gestion
 ## *********************************************************************************************************************
 ## Entrées liées à la gestion des contenus en cours
 
+
+@en_cours.route("/exporterContenuXmlEnCours/<id_contenu>")
+@en_cours.doc(params={'id_contenu': "L'id du contenu à modifier"})
+@en_cours.doc(description='exporter un xml moodle (contenu tiers ou perso)')
+class modifier_xml(Resource):
+    @en_cours.response(200, "contenu exporté")
+    def get(self, id_contenu):
+        id_contenu = json.loads(id_contenu)
+        chemin = EncoursDao().get_chemin_contenu_en_cours(id_contenu["$oid"])
+        return send_file(chemin)
+
+
 @en_cours.route("/getTexteContenuEnCours/<id_en_cours>")
 @en_cours.doc(description="récupérer le texte d'un contenu en cours")
 class GetTexteContenuEnCours(Resource):
@@ -729,6 +745,31 @@ class GetContenuEnCours(Resource):
             json.dumps(list(en_cours_dao.get_contenu_en_cours_via_id(id_en_cours)), default=json_util.default)), 200
 
 
+@en_cours.route("/modifierXMLEnCours")
+@en_cours.doc(params={'id_contenu': "L'id du contenu en cours à modifier"})
+@en_cours.doc(params={'elements_contenu': "Le détail du contenu"})
+@en_cours.doc(desciption="modifier un xml moodle")
+class modifier_xml(Resource):
+    @en_cours.response(200, "contenu en cours modifié")
+    def patch(self):
+        id_contenu = json.loads(request.json['id_contenu'])
+        elements_contenu = json.loads(request.json['elements_contenu'])
+
+        xml_modifie = ContenuDao().modifier_xml_moodle(id_contenu["$oid"], elements_contenu, True)
+        return xml_modifie.decode("utf-8"), 200
+
+
+@en_cours.route("/parserContenuEnCours/<id_contenu_ec>")
+@en_cours.doc(params={'id_contenu_ec': "L(id du contenu en cours à parser"})
+@en_cours.doc(desciption="lire le xml du document pour en récupérer les données")
+class parser_contenu_xml(Resource):
+    @en_cours.response(200, "contenu parsé")
+    @jwt_required()
+    def get(self, id_contenu_ec):
+        id_contenu_ec = json.loads(id_contenu_ec)
+        return ContenuDao().previsualiser_xml_moodle(id_contenu_ec["$oid"], True), 200
+
+
 @en_cours.route("/getAuteurOrigineEnCours/<id_en_cours>")
 @en_cours.doc(description="récupérer l'auteur d'origine d'un contenu en cours")
 class GetAuteurOtigineContenuEnCours(Resource):
@@ -765,7 +806,7 @@ class SupprimerEnCoursParId(Resource):
 
 
 @en_cours.route("/newEnCours")
-@en_cours.doc(params={'id_contenu': "l'id du contenu d'origine"})
+@en_cours.doc(params={'contenu': "le contenu d'origine"})
 @en_cours.doc(params={'auteur': "l'auteur du contenu en cours"})
 @en_cours.doc(params={'version': "la version du contenu modifié pour créé l'en cours "})
 @en_cours.doc(params={'provenance': "la provenance du contenu en cours (perso ou tiers)"})
@@ -775,9 +816,9 @@ class CreerEnCours(Resource):
     ## créer un contenu en cours
     @jwt_required()
     def post(self):
-        id_contenu = json.loads(request.json["id_contenu"])
-        en_cours_dao.creer_en_cours(request.json['auteur'], id_contenu["$oid"], request.json['version'],
-                                    request.json['provenance'])
+        contenu = json.loads(request.json["contenu"])
+
+        en_cours_dao.creer_en_cours(request.json['auteur'], request.json['provenance'], contenu, request.json['titre'])
 
         return json.loads(json.dumps(en_cours_dao.get_contenu_en_cours_via_id(en_cours_dao.recuperer_dernier_id()),
                                      default=json_util.default)), 201
@@ -820,6 +861,7 @@ demande_pub = api.namespace('demande_pub', description='Entrées liées à la ge
 @demande_pub.doc(params={'id_contenu_en_cours': "l'id du contenu en cours associé à la demande de publica"})
 @demande_pub.doc(params={'auteur_en_cours': "l''auteur de la demande de publica"})
 @demande_pub.doc(params={'version': "la version 'effective' du contenu publié"})
+@demande_pub.doc(params={'version': "la source du contenu publié"})
 @demande_pub.doc(description="créer une demande de publication")
 class demande_de_publication(Resource):
     @demande_pub.response(201, "Demande de publication créée")
@@ -831,7 +873,8 @@ class demande_de_publication(Resource):
 
         auteur = en_cours_dao.get_auteur_origine_contenu_en_cours(id_contenu_en_cours["$oid"])
         demande_pub_Dao.creer_demande_publication(id_contenu["$oid"], id_contenu_en_cours["$oid"],
-                                                  request.json['auteur_en_cours'], auteur, request.json["version"])
+                                                  request.json['auteur_en_cours'], auteur, request.json["version"],
+                                                  request.json["source"])
         # return "Demande de publication créée", 201
 
         return json.loads(json.dumps((demande_pub_Dao.get_demande_pub_via_id(demande_pub_Dao.recuperer_dernier_id())),

config/utils.py

@@ -31,10 +31,13 @@ class Utils:
         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()
 
@@ -73,7 +76,6 @@ class Utils:
             from modele.encours_dao import EncoursDao
             chemin_fichier = EncoursDao().get_chemin_contenu_en_cours(id_contenu)
 
-            #print("titre : " + titre)
             EncoursDao().changer_titre(id_contenu, titre)
         myFile = open(chemin_fichier, "w")
         # y ajouter le texte du contenu

modele/contenu_dao.py

@@ -66,20 +66,26 @@ class ContenuDao:
                                              {"$set": {"versionEnCours.commit": commit}})
 
     ## Fonction qui permet d'importer un nouveau contenu
-    def importer_contenu(self, auteur, file):
+    def importer_contenu(self, auteur, file, tags):
 
         from xml.dom import minidom
 
-        global chemin_fichier, filename
+        global chemin_fichier, filename, chemin_tags, titre
         if file:
             filename = secure_filename(file.filename)
 
-            print(filename)
+            chemin_tags = '/'.join(json.loads(tags)) + "/"
 
-            chemin_fichier = self.chemin + filename + "/"
+            print("chemin_tags : ", chemin_tags)
+            print("filename : ", filename)
+
+            chemin_fichier = self.chemin + chemin_tags + filename + "/"
             Path(chemin_fichier).mkdir(0o777, parents=True, exist_ok=True)
             file.save(os.path.join(chemin_fichier, filename))
 
+            print("chemin_fichier : ", chemin_fichier)
+
+            # on récupère le vrai titre du contenu
             xmldoc = minidom.parse(chemin_fichier + filename)
             mite = xmldoc.getElementsByTagName('name')
             titre = mite[0].childNodes[1].firstChild.nodeValue
@@ -87,10 +93,10 @@ class ContenuDao:
         # créer la métadonnée dans la base mongo
         self.base_donnees.contenu.insert_one(
             {"auteur": auteur, "popularite": 0,
-             "fichier": filename + "/" + filename, "titre": titre,
+             "fichier": chemin_tags + filename + "/" + filename, "titre": titre,
              "versionEnCours": {"numero": 1, "date": datetime.now().strftime("%d/%m/%y"),
                                 "note": 0, "nbreNotes": 0, "commit": ""},
-             "tags_fixes": ["tag1", "tag2", "tag3", "tag4", "tag5"],
+             "tags_fixes": tags,
              "type": "quiz", "source": "moodle"})
 
         nom_contenu = self.id_dernier_contenu_ajoute()
@@ -372,8 +378,11 @@ class ContenuDao:
         # initialiser le git et récupérer le commit
         version = self.get_version_courante(id_contenu)
         index = chemin.rindex("/")
+        nom = chemin[index + 1:]
+
         chemin = chemin[:index]
-        commit = self.gitUtils.commit(chemin, str(id_contenu), "version" + str(version + 1))
+
+        commit = self.gitUtils.commit(chemin, nom, "version" + str(version + 1))
 
         #  puis le mettre a jour dans le contenu
         self.base_donnees.contenu.update_one({"_id": id_contenu}, {"$set": {"versionEnCours.commit": commit}})
@@ -459,7 +468,7 @@ class ContenuDao:
 
         # On réfcupère tous les ties d'un auteur
         tiers = self.get_contenus_tiers(auteur)
-
+        print("Je le ai ", len(tiers), " tiers disponibles")
         for i in range(len(tiers)):
             versionCourante = self.get_version_courante(tiers[i][0]["contenu"])
             if tiers[i][1]["version"] < versionCourante:
@@ -714,19 +723,11 @@ class ContenuDao:
     # # Fonction qui permet de parser un contenu (de type XML - Moodle) -Fonction utile pour la prévisualisation &
     # l'édition @param id_contenu l'id du contenu à parser @return un dictionnaire comprenant toutes les informations
     # utiles
-    def previsualiser_xml_moodle(self, id_contenu):
-        texte = Utils().recuperer_contenu_fichier(id_contenu)
-
-        # nom_fichier = os.path.basename(self.lineedit_adresse.text())
-        # adresse_fichier = os.path.dirname(self.lineedit_adresse.text())
-
-        type_question = ""
-        nom_question = ""
-        intitule_question = ""
-        note_defaut = ""
-        penalite = ""
-        feedback_general = ""
+    def previsualiser_xml_moodle(self, id_contenu, en_cours=False):
 
+        texte = Utils().recuperer_contenu_fichier(id_contenu, en_cours)
+        # exit(0)
+        # on va stocker tous les éléments séparés dans cette structure
         elements_question = dict()
 
         root = ET.fromstring(texte)
@@ -876,7 +877,7 @@ class ContenuDao:
                     for feed in feedback.iter('text'):
                         liste_feedback.append(feed.text)
                 for tolerance in answer.iter('tolerance'):
-                    #print ("tolerance : ", tolerance.text)
+                    # print ("tolerance : ", tolerance.text)
                     if tolerance.text is not None:
                         liste_tolerance.append(tolerance.text)
 
@@ -914,24 +915,189 @@ class ContenuDao:
     ## Fonction permettant de modifier un xml Moodle
     # @param id_contenu
     # @param elements_contenu
-    def modifier_xml_moodle(self, id_contenu, elements_contenu):
-        texte = Utils().recuperer_contenu_fichier(id_contenu)
-
+    def modifier_xml_moodle(self, id_contenu, elements_contenu, en_cours=False):
+        # On charge le fichier actuel
+        texte = Utils().recuperer_contenu_fichier(id_contenu, en_cours)
         root = ET.fromstring(texte)
 
-        print("root")
-        print(root)
-        print(type(root))
-        print(ET.tostring(root))
+        print(elements_contenu)
+
+        # On parcourt tous les champs généralistes (type_question est inamovible)
+        for note in root.iter('defaultgrade'):
+            note.text = elements_contenu["note_defaut"]
+
+        for penalty in root.iter('penalty'):
+            penalty.text = elements_contenu["penalite"]
 
         for name in root.iter('name'):
             for nom in name.iter('text'):
-                nom.text = "Chabala"
+                nom.text = elements_contenu["nom_question"]
 
-        print(ET.tostring(root))
+        for question in root.iter('questiontext'):
+            for intitule in question.iter('text'):
+                # print("new game now loading : " + intitule.text)
+                # elements_question["intitule_question"] = intitule.text[3:len(intitule.text) - 4]
+                intitule.text = elements_contenu["intitule_question"]
 
+        for general in root.iter('generalfeedback'):
+            for feedback in general.iter('text'):
+                feedback.text = elements_contenu["feedback_general"]
 
+            # puis on fait la même chose que dans la fonction d'au dessus, on parcourt les éléments spécifiques en fonction du type_question
 
+        if elements_contenu["type_question"] == "truefalse":
+            note_faux = 0
+            # # on récupère la bonne réponse (mise par défault à Vrai mais changée si besoin).
+            # bonne_reponse = 'Vrai'
+            i = 0
+            for answer in root.iter('answer'):
+                if i == 0:
+                    answer.attrib["fraction"] = '100' if elements_contenu['bonne_reponse'] == 'Vrai' else '0'
+                elif i == 1:
+                    answer.attrib["fraction"] = '100' if elements_contenu['bonne_reponse'] == 'Faux' else '0'
+                i = i + 1
 
-        pass
+                # for feedback in answer.iter('text'):
+                #     feedback.text = elements_contenu["liste_feedback"][i]
 
+        elif elements_contenu["type_question"] == "shortanswer":
+            pass
+            # majuscule -> permet la casse (à 1) ou non (à 0)
+            # majuscule = ''
+            for usecase in root.iter('usecase'):
+                usecase.text = elements_contenu["majuscule"]
+
+            # on récupère les réponses valables, les notes associées et les feedback
+            liste_reponse = []
+            liste_note = []
+            liste_feedback = []
+
+            i = 0
+
+            for answer in root.iter('answer'):
+                answer.attrib["fraction"] = elements_contenu["liste_note"][i]
+                for question in answer.iter('text'):
+                    if question.text is not None:
+                        question.text = elements_contenu["liste_reponse"][i]
+                for feedback in answer.iter('feedback'):
+                    for feed in feedback.iter('text'):
+                        feed.text = elements_contenu["liste_feedback"][i]
+
+                i += 1
+
+            print ("A la sortie, i = ", i)
+            print ("J'ai ", len(elements_contenu["liste_reponse"]), " reponses")
+
+            if i < len(elements_contenu["liste_reponse"]):
+                print("Je le ai ", len(elements_contenu["liste_reponse"]) - i, " nouveaux contenus")
+                for question in root.iter('question'):
+                    # eltQuestion = root.iter("question")
+                    newAnswer = SubElement(question, "answer")
+                    newAnswer.attrib["fraction"] = elements_contenu["liste_note"][i]
+                    newAnswer.attrib["format"] = "moodle_auto_format"
+                    text = SubElement(newAnswer, "text")
+                    text.text = elements_contenu["liste_reponse"][i]
+                    feedback = SubElement(newAnswer, "feedback")
+                    textFeedback = SubElement(feedback, "text")
+                    textFeedback.text = elements_contenu["liste_feedback"][i]
+                    i += 1
+
+            # # for k in range(3):
+            # #     liste_reponse.append("")
+            # #     liste_note.append("")
+            # #     liste_feedback.append("")
+            #
+            # elements_question["liste_reponse"] = liste_reponse
+            # elements_question["liste_note"] = liste_note
+            # elements_question["liste_feedback"] = liste_feedback
+
+        elif elements_contenu["type_question"] == "multichoice":
+            pass
+
+        # # nb_reponse = ''
+        # for single in root.iter('single'):
+        #     elements_question["nb_reponse"] = single.text
+        # # print ("nb_reponse : ", nb_reponse)
+        #
+        # for shuffleanswers in root.iter('shuffleanswers'):
+        #     elements_question["melange_reponse"] = shuffleanswers.text
+        #
+        # for answernumbering in root.iter('answernumbering'):
+        #     elements_question["numerotation"] = answernumbering.text
+        #
+        # liste_reponse = []
+        # liste_note = []
+        # liste_feedback = []
+        # for answer in root.iter('answer'):
+        #     liste_note.append(answer.attrib["fraction"])
+        #     for question in answer.iter('text'):
+        #         if question.text is not None:
+        #             liste_reponse.append(question.text)
+        #     for feedback in answer.iter('feedback'):
+        #         for feed in feedback.iter('text'):
+        #             liste_feedback.append(feed.text)
+        #
+        # elements_question["liste_reponse"] = liste_reponse
+        # elements_question["liste_note"] = liste_note
+        # elements_question["liste_feedback"] = liste_feedback
+        #
+        # liste_feedback_principaux = []
+        # for feedback in root.iter('text'):
+        #     liste_feedback_principaux.append(feedback.text)
+        #
+        # elements_question["liste_feedback_principaux"] = liste_feedback_principaux
+
+        elif elements_contenu["type_question"] == "numerical" or \
+                elements_contenu["type_question"] == "calculatedsimple":
+            pass
+
+        # for unit in root.iter('unitgradingtype'):
+        #     elements_question["traitement_unite"] = unit.text
+        #
+        # for showunits in root.iter('showunits'):
+        #     elements_question["saisie_unite"] = showunits.text
+        #
+        # for unitsleft in root.iter('unitsleft'):
+        #     elements_question["position_unite"] = unitsleft.text
+        #
+        # liste_unite_nom = []
+        # for unit_name in root.iter('unit_name'):
+        #     liste_unite_nom.append(unit_name.text)
+        # for k in range(3):
+        #     liste_unite_nom.append('')
+        #
+        # liste_unite_coef = []
+        # for multiplier in root.iter('multiplier'):
+        #     liste_unite_coef.append(multiplier.text)
+        # for k in range(3):
+        #     liste_unite_coef.append('')
+        #
+        # elements_question["liste_unite_nom"] = liste_unite_nom
+        # elements_question["liste_unite_coef"] = liste_unite_coef
+        #
+        # liste_reponse = []
+        # liste_note = []
+        # liste_feedback = []
+        # liste_tolerance = []
+        # for answer in root.iter('answer'):
+        #     liste_note.append(answer.attrib["fraction"])
+        #     for question in answer.iter('text'):
+        #         if question.text is not None:
+        #             liste_reponse.append(question.text)
+        #     for feedback in answer.iter('feedback'):
+        #         for feed in feedback.iter('text'):
+        #             liste_feedback.append(feed.text)
+        #     for tolerance in answer.iter('tolerance'):
+        #         #print ("tolerance : ", tolerance.text)
+        #         if tolerance.text is not None:
+        #             liste_tolerance.append(tolerance.text)
+        #
+        # elements_question["liste_reponse"] = liste_reponse
+        # elements_question["liste_note"] = liste_note
+        # elements_question["liste_feedback"] = liste_feedback
+        # elements_question["liste_tolerance"] = liste_tolerance
+
+        # on maj le fichier du contenu
+        Utils().changer_texte_fichier(ObjectId(id_contenu), ET.tostring(root).decode("utf-8"),
+                                      elements_contenu["nom_question"])
+        return ET.tostring(root)

modele/demande_pubDao.py

@@ -18,14 +18,14 @@ class DemandePubDao:
     # @param idContenuEnCours l'id du contenu en cours
     # @param auteurEnCours l'auteur du contenu en cours
 
-    def creer_demande_publication(self, id_contenu, id_contenu_en_cours, auteur_en_cours, auteur, version_en_cours):
+    def creer_demande_publication(self, id_contenu, id_contenu_en_cours, auteur_en_cours, auteur, version_en_cours, source):
 
         self.base_donnees.demandesPub.insert_one(
             {"date": datetime.now().strftime("%d/%m/%y"), "auteurDemande": auteur_en_cours,
              "auteurContenu": auteur, "idContenu": ObjectId(id_contenu),
              "titre": EncoursDao().get_titre_en_cours(id_contenu_en_cours),
              "idContenuEnCours": ObjectId(id_contenu_en_cours), "version_en_cours": version_en_cours,
-             "etat": "enCours"})
+             "source": source, "etat": "enCours"})
 
         self.base_donnees.encours.update_one({"_id": ObjectId(id_contenu_en_cours)}, {"$set": {"isPublie": "oui"}})
 

modele/encours_dao.py

+import json
 import os
 from pathlib import Path
 
@@ -69,42 +70,62 @@ class EncoursDao:
 
     ## création d'un contenu en cours
     # @param auteur -> l'auteur du contenu en cours.
-    # @param id_contenu -> l'id du contenu d'origine
+    # @param contenu -> le contenu d'origine
     # @param version la version du contenu d'origine
     # @param provenance pour déterminer si le contenu d'origine est un tiers ou un perso
-    def creer_en_cours(self, auteur, id_contenu, version, provenance):
+    def creer_en_cours(self, auteur, provenance, contenu, titre):
         from modele.contenu_dao import ContenuDao
 
-        if ContenuDao().is_anonyme(id_contenu):
+        if contenu["versionEnCours"]["nbreNotes"] == 0:
+            moyenne = 0
+        else:
+            moyenne = contenu["versionEnCours"]["note"] / contenu["versionEnCours"]["nbreNotes"]
+
+        # print("auteur : ", auteur)
+        # print("provenance : ", provenance)
+        # print("titre : ", titre)
+        # print("id : ", contenu["_id"]["$oid"])
+        # print("type id : ", type(contenu["_id"]["$oid"]))
+        # print("version : ", contenu["versionEnCours"]["numero"])
+
+        if ContenuDao().is_anonyme(contenu["_id"]["$oid"]):
 
             self.base_donnees.encours.insert_one(
                 {"date": datetime.now().strftime("%d/%m/%y"), "fichier": "", "auteur": auteur,
-                 "reference": ObjectId(id_contenu), "version": version, "origine": provenance, "anonyme": "oui"})
+                 "reference": ObjectId(contenu["_id"]["$oid"]), "version": contenu["versionEnCours"]["numero"],
+                 "origine": provenance, "tags_fixes": json.loads(contenu["tags_fixes"]),
+                 "titre": titre, "type": contenu["type"], "source": contenu["source"], "moyenne": moyenne,
+                 "anonyme": "oui"})
 
         else:
 
             self.base_donnees.encours.insert_one(
                 {"date": datetime.now().strftime("%d/%m/%y"), "fichier": "", "auteur": auteur,
-                 "reference": ObjectId(id_contenu), "version": version, "origine": provenance})
-
+                 "reference": ObjectId(contenu["_id"]["$oid"]), "version": contenu["versionEnCours"]["numero"],
+                 "origine": provenance, "tags_fixes": json.loads(contenu["tags_fixes"]),
+                 "titre": titre, "type": contenu["type"], "source": contenu["source"], "moyenne": moyenne})
         id = self.recuperer_dernier_id()
+        chemin_tags = '/'.join(json.loads(contenu["tags_fixes"])) + "/"
+
+        nom_fichier = (contenu["fichier"][contenu["fichier"].rfind("/") + 1:])
 
-        Path(self.chemin).mkdir(parents=True, exist_ok=True)
+        chemin_fichier = self.chemin + chemin_tags + nom_fichier + "/"
+        Path(chemin_fichier).mkdir(0o777, parents=True, exist_ok=True)
 
-        myFile = open(self.chemin + id, "w")
+        myFile = open(chemin_fichier + nom_fichier, "w")
         # y ajouter le texte du contenu
-        myFile.write(self.utils.recuperer_contenu_fichier(id_contenu))
+        myFile.write(self.utils.recuperer_contenu_fichier(contenu["_id"]["$oid"]))
         myFile.close()
 
         # mettre a jour le chemin du contenu
         self.base_donnees.encours.update_one({"_id": ObjectId(id)},
-                                             {"$set": {"fichier": id}})
+                                             {"$set": {"fichier": chemin_tags + nom_fichier + "/" + nom_fichier}})
 
     ## Modification d'un titre d'un contenu en cours
     # @param id_en_cours l'id du contenu en cours
     # @param nouveau_titre le titre à changer
     def changer_titre(self, id_en_cours, nouveau_titre):
-       # print("Je suis ici : " + nouveau_titre)
+        # print("Je suis ici : " + nouveau_titre)
         self.base_donnees.encours.update_one({"_id": ObjectId(id_en_cours)}, {"$set": {"titre": nouveau_titre}})
 
     ## Récupération d'un titre d'un contenu en cours

modele/utilisateur_dao.py

@@ -14,9 +14,6 @@ class UtilisateurDao:
     # @param motDePasse le mot de passe tapé
     # @return un booléen pour dire si l'utilisateur existe ou pas
     def presence_utilisateur(self, nomUtilisateur):
-        # print("Je suis dans présence utilisateur pour ", nomUtilisateur)
-
-        # print("Et j'en ai trouvé : ", nmbre.count())
 
         return self.base_donnees.utilisateur.count_documents({"nom": nomUtilisateur}) == 1