Sauvegarde du 04/06

app.py

@@ -7,9 +7,15 @@ from modele.demande_pubDao import DemandePubDao
 from modele.encoursDao import EncoursDao
 from modele.evaluationDao import EvaluationDao
 from modele.utilisateurDao import UtilisateurDao
+
 import json
 
+from flask import Flask
+from flask_cors import CORS, cross_origin
+
 app = Flask(__name__)
+cors = CORS(app)
+app.config['CORS_HEADERS'] = 'Content-Type'
 
 contenu_dao = ContenuDao()
 utilisateur_dao = UtilisateurDao()
@@ -25,22 +31,27 @@ base_donnees = client.squelette
 ## *********************************************************************************************************************
 ## Routage utilisateur : 1 post, 1 get, 2 patch
 @app.route('/newUser', methods=['POST'])
+@cross_origin()
 def creer_utilisateur():
     utilisateur_dao.ajouter_utilisateur(request.json["login"])
     return "Utilisateur créé"
 
 
-@app.route('/checkUser', methods=['POST'])
+@app.route('/checkUser', methods=['GET'])
+@cross_origin()
 def verifier_utilisateur():
-    return str(utilisateur_dao.presence_utilisateur(request.json["login"]))
+    print(request.args.get("login"))
+    return str(utilisateur_dao.presence_utilisateur(request.args.get("login")))
 
 
 @app.route('/changePassword', methods=['PATCH'])
+@cross_origin()
 def changer_mdp():
     pass
 
 
 @app.route('/ajouterTiers', methods=['POST'])
+@cross_origin()
 def ajouter_tiers():
     contenu_dao.creer_tiers(request.json["auteur"], request.json["id_tiers"], 1)
     return "tiers ajouté"
@@ -49,6 +60,7 @@ def ajouter_tiers():
 ## *********************************************************************************************************************
 ## Routage contenus : beaucoup de fonctions
 @app.route("/newContenu", methods=['POST'])
+@cross_origin()
 def ajouter_contenu():
     auteur = request.json["auteur"]
     nom_fichier = request.json["nom_fichier"]
@@ -58,42 +70,51 @@ def ajouter_contenu():
 
 
 @app.route("/getContenu/<id>", methods=['GET'])
+@cross_origin()
 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'])
+@cross_origin()
 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)
+    auteur = auteur.replace("_", " ")
+    return json.dumps(contenu_dao.get_contenus(auteur, request.args.get("perso"), request.args.get("tiers"), request.args.get("enCours")),
+                      default=json_util.default)
 
 
 @app.route("/deletePerso/<id_perso>", methods=['DELETE'])
+@cross_origin()
 def supprimer_perso(id_perso):
     contenu_dao.supprimer_contenu(id_perso)
 
 
 @app.route("/deleteTiers/<id_tiers>", methods=['DELETE'])
+@cross_origin()
 def supprimer_tiers(id_tiers):
     contenu_dao.supprimer_tiers(id_tiers, request.args.get('auteur'), request.args.get('version'))
 
 
 @app.route("/newContenu", methods=['POST'])
+@cross_origin()
 def creer_nouveau_contenu():
     pass
 
 
 @app.route("/majContenu", methods=['PATCH'])
+@cross_origin()
 def maj_contenu():
     pass
 
 
-@app.route("/allContenus", method=['GET'])
+@app.route("/allContenus", methods=['GET'])
+@cross_origin()
 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'])
+@cross_origin()
 def is_contenu_anonyme(id_contenu):
     return str(contenu_dao.is_anonyme(id_contenu))
 
@@ -103,26 +124,31 @@ def is_contenu_anonyme(id_contenu):
 
 
 @app.route("/getEnCours/<id_en_cours>", methods=['GET'])
+@cross_origin()
 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):
+@cross_origin()
+def get_auteur_otigine_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'])
+@app.route("/isContenuDemandePublication/<id_en_cours>/<auteur>", methods=['GET'])
+@cross_origin()
 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'])
+@cross_origin()
 def supprimer_en_cours(id_en_cours):
     en_cours_dao.supprimer_contenu_en_cours(id_en_cours)
 
 
 @app.route("/newEnCours", methods=['POST'])
+@cross_origin()
 def creer_en_cours():
     en_cours_dao.creer_en_cours(request.args.get('id_contenu'), request.args.get('version'),
                                 request.args.get('branche'))
@@ -133,18 +159,21 @@ def creer_en_cours():
 ## Gestion des Publications
 
 @app.route("/demandePublication", methods=['POST'])
+@cross_origin()
 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'])
+@app.route("/demandePublication/<auteur>/<emise>", methods=['GET'])
+@cross_origin()
 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):
+@app.route("/demandePublication/<id_publication>", methods=['DELETE'])
+@cross_origin()
+def supprimer_demande_pub(id_publication):
     demande_pub_Dao.supprimer_publication(id_publication)
 
 
@@ -152,22 +181,26 @@ def get_demandes_pub(id_publication):
 ## Gestion des Evaluations
 
 @app.route("/newEval", methods=['POST'])
+@cross_origin()
 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'])
+@cross_origin()
 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'])
+@cross_origin()
 def get_all_evaluations(auteur):
     return json.dumps(list(evaluation_dao.get_evaluations(auteur, 0)), default=json_util.default)
 
 
 @app.route("/deleteEval", methods=['DELETE'])
+@cross_origin()
 def supprimer_evaluation(id_evaluation):
     evaluation_dao.supprimer_evaluation(id_evaluation)
 

modele/contenuDao.py

@@ -37,7 +37,7 @@ class ContenuDao:
         # 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": [
+        # return Utils.contenu.find_one({"$and": [
         #     {"id": idContenu},
         #     {"$or": [{"versionEnCours.numero": version}, {"historique.numero": version}]}
         # ]
@@ -61,7 +61,7 @@ class ContenuDao:
                 contenus.append(contenu)
 
         if en_cours:
-            curseur_en_cours = EncoursDao().get_en_cours(auteur)
+            curseur_en_cours = EncoursDao().get_contenus_en_cours_auteur(auteur)
             for contenu in curseur_en_cours:
                 contenus.append(contenu)
         # on garde le développement de l'évaliation pour plus tard
@@ -71,15 +71,16 @@ class ContenuDao:
 
 
     def creer_tiers(self, auteur, id_contenu, version):
-        self.base_donnees.statdb.utilisateur.update({"nom": auteur}, {
+        self.base_donnees.utilisateur.update({"nom": auteur}, {
             "$push": {
                 "tiers": [{"contenu": int(id_contenu)}, {"version": version}]}})
 
-    def get_contenus_persos(self):
+    def get_contenus_persos(self, auteur):
         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"]
+        print ("auteur a trouver : " + auteur)
+        return self.base_donnees.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):
@@ -90,12 +91,12 @@ class ContenuDao:
         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},
+        self.base_donnees.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(
+        return self.base_donnees.utilisateur.find(
             {"tiers": {"$elemMatch": {"$elemMatch": {"contenu": id_contenu}}}}).count() != 0
 
     def creer_nouveau_contenu(self, chemin, auteur_en_cours, idContenuEnCours):
@@ -117,7 +118,7 @@ class ContenuDao:
         # exit(0)
         #commit = UtilsGit.commit(cheminFichier, "Contenu" + str(max_id), "Version 1")
         '''
-        self.base_donnees.statdb.contenu.insert_one(
+        self.base_donnees.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"),
@@ -150,13 +151,13 @@ class ContenuDao:
         #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}}})
+        version_en_cours = self.base_donnees.contenu.find_one({"id": idContenu})["versionEnCours"]
+        self.base_donnees.contenu.update_one({"id": int(idContenu)}, {"$push": {"historique": version_en_cours}})
+        # self.base_donnees.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)}, {
+            self.base_donnees.contenu.update_one({"id": int(idContenu)}, {
                 "$set": {"auteur": auteur}})
 
     def consulter_un_contenu(self, id, auteur):
@@ -174,7 +175,7 @@ class ContenuDao:
 
     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)})
+        contenu = self.base_donnees.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):
@@ -185,14 +186,14 @@ class ContenuDao:
 
     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)
+        element = self.base_donnees.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"])
+        # print("Is anonyme : ", Utils.contenu.find_one({"id": idContenu})["auteur"])
         return self.base_donnees.contenu.find_one({"id": idContenu})["auteur"] == "Aucun"
 
     def get_tous_les_contenus(self):

modele/encoursDao.py

@@ -20,6 +20,12 @@ class EncoursDao:
         id_contenu = self.base_donnees.find_one({"idContenuEC": id_contenu_en_cours})["reference"]
         return self.base_donnees.contenu.find_one({"id": id_contenu})["auteur"]
 
+    ## permet de récupérer tous les contenus en cours pour un auteur
+    # @param auteur le nom de l'auteur
+
+    def get_contenus_en_cours_auteur(self, auteur):
+        return self.base_donnees.encours.find({"auteur": 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):