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/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