Ajustements controleur avec les tests interface vueJs

app.py

+import distutils
+from distutils import util
+
 from bson import json_util
 from flask import Flask, request
 from pymongo import MongoClient
@@ -40,7 +43,6 @@ def creer_utilisateur():
 @app.route('/checkUser', methods=['GET'])
 @cross_origin()
 def verifier_utilisateur():
-    print(request.args.get("login"))
     return str(utilisateur_dao.presence_utilisateur(request.args.get("login")))
 
 
@@ -50,11 +52,12 @@ def changer_mdp():
     pass
 
 
-@app.route('/ajouterTiers', methods=['POST'])
+@app.route('/ajouterTiers', methods=['PATCH'])
 @cross_origin()
 def ajouter_tiers():
-    contenu_dao.creer_tiers(request.json["auteur"], request.json["id_tiers"], 1)
-    return "tiers ajouté"
+    id_tiers = json.loads(request.json["id_tiers"])
+    contenu_dao.creer_tiers(request.json["auteur"], id_tiers["$oid"], request.json["version"])
+    return "Tiers ajouté"
 
 
 ## *********************************************************************************************************************
@@ -79,20 +82,35 @@ def get_contenu_par_id(id):
 @cross_origin()
 def get_contenu_panier(auteur):
     auteur = auteur.replace("_", " ")
-    return json.dumps(contenu_dao.get_contenus(auteur, request.args.get("perso"), request.args.get("tiers"), request.args.get("enCours")),
+    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("/getContenuBanque/<auteur>", methods=['GET'])
+@cross_origin()
+def get_contenu_banque(auteur):
+    auteur = auteur.replace("_", " ")
+    return json.dumps(list(contenu_dao.get_contenus_non_auteur(auteur)),
                       default=json_util.default)
 
 
 @app.route("/deletePerso/<id_perso>", methods=['DELETE'])
 @cross_origin()
 def supprimer_perso(id_perso):
-    contenu_dao.supprimer_contenu(id_perso)
+    id_perso = json.loads(id_perso)
+    contenu_dao.supprimer_contenu(id_perso["$oid"])
+    return "Contenu supprimé"
 
 
-@app.route("/deleteTiers/<id_tiers>", methods=['DELETE'])
+@app.route("/deleteTiers", methods=['DELETE'])
 @cross_origin()
-def supprimer_tiers(id_tiers):
-    contenu_dao.supprimer_tiers(id_tiers, request.args.get('auteur'), request.args.get('version'))
+def supprimer_tiers():
+    id_tiers = json.loads(request.args.get("id_tiers"))
+
+    version = contenu_dao.get_version_tiers_avec_id(id_tiers["$oid"], request.args.get('auteur'))
+    contenu_dao.supprimer_tiers(id_tiers["$oid"], request.args.get('auteur'), version)
+    return "Contenu Tiers supprimé"
 
 
 @app.route("/newContenu", methods=['POST'])
@@ -144,14 +162,16 @@ def is_contenu_demande_publication(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)
+    id_contenu = json.loads(id_en_cours)
+    en_cours_dao.supprimer_contenu_en_cours(id_contenu["$oid"])
+    return "Contenu En Cours supprimé"
 
 
 @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'))
+    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éé"
 
 
@@ -161,14 +181,22 @@ def creer_en_cours():
 @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'))
+    id_contenu = json.loads(request.json["id_contenu"])
+    id_contenu_en_cours = json.loads(request.json["id_contenu_en_cours"])
+
+    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)
+    return "Demande de publication créée"
 
 
 @app.route("/demandePublication/<auteur>/<emise>", methods=['GET'])
 @cross_origin()
 def get_demandes_pub(auteur, emise):
-    return demande_pub_Dao.get_demandes_pub(auteur, emise)
+    print("monzkostakedeikala:", emise)
+    print("tsioka:", type(emise))
+
+    return json.dumps(list(demande_pub_Dao.get_demandes_pub(auteur, distutils.util.strtobool(emise))), default=json_util.default)
 
 
 @app.route("/demandePublication/<id_publication>", methods=['DELETE'])

config/connexion.py

@@ -6,6 +6,7 @@ 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)

modele/demande_pubDao.py

 from pymongo import MongoClient
 from datetime import datetime
+from bson import ObjectId
 
 
 class DemandePubDao:
@@ -8,16 +9,24 @@ class DemandePubDao:
     ## extraction d'une base de données. Si elle n'existe pas, elle esst créée
     base_donnees = client.squelette
 
+    ## Crétion d'une demande de publication
+    # @param idCOntenu l'id du contenu d'origine
+    # @param auteur l'auteur du contenu d'origine
+    # @param idContenuEnCours l'id du contenu en cours
+    # @param auteurEnCours l'auteur du contenu en cours
+
     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,
+            {"date": datetime.now().strftime("%d/%m/%y"), "auteurDemande": auteurEnCours,
              "auteurContenu": auteur,
-             "idContenu": idContenu, "idContenuEnCours": idContenuEnCours, "etat": "enCours"})
+             "idContenu": ObjectId(idContenu), "idContenuEnCours": ObjectId(idContenuEnCours), "etat": "enCours"})
 
     '''
+    ## Fonction permettant de gérer une demande de publication 
+    # @param idPublication l'id de la demande de publication
+    # @param reponse la réponse donnée par l'auteur d'origine
+    # @param auteur l'auteur d'origine
     def gerer_demande_pub(self, idPublication, reponse, auteur):
         if reponse == 'o':
             print("Publication acceptée")
@@ -48,14 +57,19 @@ class DemandePubDao:
     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):
+    ## Récupérer lid du contenu (perso ou tiers) associé à une demande de publication
+    # @param idDdePublication l'id de la demande de publication
+    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"]
 
+    ## Récupérer lid du contenu en cours associé à une demande de publication
+    # @param idDdePublication l'id de la demande de publication
     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"]
 
+    ## Récupérer l'id max des demandes de publication (sera supprimé par la suite et remplacé par les id mongo)
     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)
@@ -64,6 +78,10 @@ class DemandePubDao:
             # print("id : ", elt)
             return int(elt["id"])
 
+    ## Récupérer les demandes de publication
+    # @param auteur l'auteur des demandes
+    # @param emises si true, récupère les demandes emises; les demandes recues sinon
+    # @return les demandes de publications idoines
     def get_demandes_pub(self, auteur, emises=True):
         if emises:
             return self.base_donnees.demandesPub.find({"auteurDemande": auteur})

modele/encoursDao.py

+from bson import ObjectId
 from pymongo import MongoClient
 from datetime import datetime
 
@@ -10,46 +11,49 @@ class EncoursDao:
 
     ## 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
+    # @param l'auteur l'auteur potentiel de la demande de publication
     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
+    # @return l'auteur intial du contenu en cours
     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"]
+        id_contenu = self.base_donnees.encours.find_one({"_id": ObjectId(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
-
+    # @return les contenus en cours 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
+    ## récupérer un contenu en cours
     # @param idContenuEnCours l'id du contenu en cours de modification
+    # @return le contenu en cours
     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})
+        return self.base_donnees.encours.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})
-
+        print ("id contenu en cours : " + idContenuEnCours)
+        self.base_donnees.encours.delete_one({"reference": ObjectId(idContenuEnCours)})
 
+    ## récupérer l'id max des contenus en cours (sera supprimé et remplacé par les id mongo)
     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)
+        element = self.base_donnees.encours.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})
+    ## 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):
+        self.base_donnees.encours.insert_one(
+            {"date": datetime.now().strftime("%d/%m/%y"), "auteur": auteur,
+             "reference": ObjectId(idContenu), "version": version})

modele/evaluationDao.py

@@ -8,6 +8,10 @@ class EvaluationDao:
     ## extraction d'une base de données. Si elle n'existe pas, elle esst créée
     base_donnees = client.squelette
 
+
+    ## Création d'une nouvelle évaluation
+    # @param contenus tableau avec les id des contenus associés à cette évaluation
+    # @param auteur l'auteur qui créée l'évaluation
     def creer_evaluation(self, contenus, auteur):
 
         # création de l'évaluation
@@ -22,6 +26,9 @@ class EvaluationDao:
         for i in contenus:
             self.base_donnees.contenu.update({"id": i}, {"$push": {"evals": max_id_eval + 1}})
 
+    ## récupérer une ou plusieurs évaluations
+    # @param auteur l'utilisateur souhaitant effectuer la récupération
+    # @param id si non 0, l'id de l'évaluation à récupérer.
     @staticmethod
     def get_evaluations(self, auteur, id=0):
         if id == 0:
@@ -29,10 +36,13 @@ class EvaluationDao:
         else:
             return self.base_donnees.evaluation.find({"auteur": auteur} and {"idEval": id})
 
+    ## supprimer une évaluation
+    # @param idEval l'id de l'évaluation à supprimer
     @staticmethod
     def supprimer_evaluation(self, idEval):
         self.base_donnees.evaluation.delete_one({"idEval": idEval})
 
+    ## récupérer l'id max des évaluations (sera supprimé et remplacé par les id mongo)
     @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).

modele/utilisateurDao.py

@@ -8,6 +8,11 @@ class UtilisateurDao:
     ## extraction d'une base de données. Si elle n'existe pas, elle esst créée
     base_donnees = client.squelette
 
+    ## permet d'authentifier un utilisateur
+    # (actuellement en version 'basique', sera mis aux normes ultérieurement)
+    # @param nomUtilisateur le login tapé
+    # @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)
         nmbre = self.base_donnees.utilisateur.find({"nom": nomUtilisateur})