Ajout de deux méthodes de maj tiers & correction petits bugs

app.py

@@ -62,7 +62,7 @@ def ajouter_tiers():
 
 ## *********************************************************************************************************************
 ## Routage contenus : beaucoup de fonctions
-@app.route("/newContenu", methods=['POST'])
+@app.route("/addContenu", methods=['POST'])
 @cross_origin()
 def ajouter_contenu():
     auteur = request.json["auteur"]
@@ -116,13 +116,28 @@ def supprimer_tiers():
 @app.route("/newContenu", methods=['POST'])
 @cross_origin()
 def creer_nouveau_contenu():
-    pass
+    id_demande_pub = json.loads(request.json["id_demande_pub"])
+    contenu_dao.creer_nouveau_contenu(id_demande_pub["$oid"], request.json["auteur"])
+    return "Nouveau contenu créé"
 
 
 @app.route("/majContenu", methods=['PATCH'])
 @cross_origin()
 def maj_contenu():
-    pass
+    id_contenu = json.loads(request.json["id_contenu"])
+    if request.json["auteur"] == "":
+        auteur = None
+    else:
+        auteur = request.json["auteur"]
+    contenu_dao.maj_contenu(id_contenu["$oid"], auteur)
+
+
+@app.route("/gererDemandePub", methods=['PATCH'])
+@cross_origin()
+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"
 
 
 @app.route("/allContenus", methods=['GET'])
@@ -137,6 +152,18 @@ def is_contenu_anonyme(id_contenu):
     return str(contenu_dao.is_anonyme(id_contenu))
 
 
+@app.route("/isMajTiersDisponible/<auteur>", methods=['GET'])
+@cross_origin()
+def is_maj_tiers_disponible(auteur):
+    return str(contenu_dao.is_tiers_maj(auteur))
+
+
+@app.route("/listeMajTiers/<auteur>", methods=['GET'])
+@cross_origin()
+def liste_maj_tiers(auteur):
+    return json.dumps(contenu_dao.liste_tiers_maj(auteur), default=json_util.default)
+
+
 ## *********************************************************************************************************************
 ## Gestion des Contenus en Cours
 
@@ -159,14 +186,22 @@ 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'])
+@app.route("/supprimerEnCours/<id_reference>", methods=['DELETE'])
 @cross_origin()
-def supprimer_en_cours(id_en_cours):
-    id_contenu = json.loads(id_en_cours)
+def supprimer_en_cours(id_reference):
+    id_contenu = json.loads(id_reference)
     en_cours_dao.supprimer_contenu_en_cours(id_contenu["$oid"])
     return "Contenu En Cours supprimé"
 
 
+@app.route("/supprimerEnCoursParId/<id_en_cours>", methods=['DELETE'])
+@cross_origin()
+def supprimer_en_cours_par_id(id_en_cours):
+    id_contenu = json.loads(id_en_cours)
+    en_cours_dao.supprimer_contenu_en_cours_via_id(id_contenu["$oid"])
+    return "Contenu En Cours supprimé"
+
+
 @app.route("/newEnCours", methods=['POST'])
 @cross_origin()
 def creer_en_cours():
@@ -175,6 +210,15 @@ def creer_en_cours():
     return "En Cours créé"
 
 
+@app.route("/newEnCoursRefuse", methods=['POST'])
+@cross_origin()
+def creer_en_cours_refuse():
+    id_contenu = json.loads(request.json["id_contenu"])
+
+    en_cours_dao.creer_en_cours_refuse(request.json['auteur'], id_contenu["$oid"], request.json['version'])
+    return "En Cours Refuse créé"
+
+
 ## *********************************************************************************************************************
 ## Gestion des Publications
 
@@ -186,23 +230,24 @@ def demande_de_publication():
 
     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['auteur_en_cours'], auteur, request.json["version"])
     return "Demande de publication créée"
 
 
 @app.route("/demandePublication/<auteur>/<emise>", methods=['GET'])
 @cross_origin()
 def 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)
+    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'])
 @cross_origin()
 def supprimer_demande_pub(id_publication):
-    demande_pub_Dao.supprimer_publication(id_publication)
+    id_publication = json.loads(id_publication)
+
+    demande_pub_Dao.supprimer_publication(id_publication["$oid"])
+    return "Demande de publication supprimée"
 
 
 ## *********************************************************************************************************************

modele/demande_pubDao.py

@@ -2,6 +2,9 @@ from pymongo import MongoClient
 from datetime import datetime
 from bson import ObjectId
 
+from modele.contenuDao import *
+from modele.encoursDao import *
+
 
 class DemandePubDao:
     client = MongoClient('localhost', 27017)
@@ -15,68 +18,61 @@ class DemandePubDao:
     # @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):
+    def creer_demande_publication(self, id_contenu, id_contenu_en_cours, auteur_en_cours, auteur, version_en_cours):
 
         self.base_donnees.demandesPub.insert_one(
-            {"date": datetime.now().strftime("%d/%m/%y"), "auteurDemande": auteurEnCours,
-             "auteurContenu": auteur,
-             "idContenu": ObjectId(idContenu), "idContenuEnCours": ObjectId(idContenuEnCours), "etat": "enCours"})
+            {"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"})
 
-    '''
-    ## Fonction permettant de gérer une demande de publication 
+    ## 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):
+    def gerer_demande_pub(self, idPublication, reponse, auteurEnCours):
         if reponse == 'o':
-            print("Publication acceptée")
-            id_en_cours = Utils.get_id_contenu_en_cours_associe_a_une_publication(idPublication)
-            branche = Utils.get_branche_contenu_en_cours(id_en_cours)
-            idContenu = Utils.get_id_contenu_associe_a_une_publication(idPublication)
-            chemin = Utils.get_chemin_du_contenu(idContenu)
-            Utils.maj_contenu(chemin, idContenu, branche)
-            Utils.statdb.demandesPub.update_one({"id": int(idPublication)}, {"$set": {"etat": "accepté"}})
-            Utils.maj_tiers(idContenu, Utils.get_version_courante(idContenu), auteur)
-            Utils.supprimer_contenu_en_cours(id_en_cours)
-        else:
-            print("Publication refusée ", idPublication)
+            #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)
+            id_contenu_en_cours = self.get_id_contenu_en_cours_associe_a_une_publication(idPublication)
+
+            # et on met à jour le contenu d'id 'id_contenu' (sans en modifier l'auteur)
+            ContenuDao().maj_contenu(id_contenu, None)
+
+            # on notifie au 'demandeur' que sa demande de publication est acceptée
+            self.base_donnees.demandesPub.update_one({"_id": ObjectId(idPublication)}, {"$set": {"etat": "accepté"}})
 
-            # on change la valeur "acceptation" de la demande de publication
-            Utils.statdb.demandesPub.update_one({"id": int(idPublication)}, {"$set": {"etat": "refus"}})
-            # Utils.statdb.demandesPub.update_one({"id": 1}, {"$set": {"etat": "refus"}})
-    '''
+            version = 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)
+        else:
+            # on change l'état de la demande de publication
+            self.base_donnees.demandesPub.update_one({"_id": ObjectId(idPublication)}, {"$set": {"etat": "refus"}})
 
     ## Supprimer une demande de publication
     # @param idPub l'id de la demande de publication
 
-    def supprimer_publication(self,idPub):
-        self.base_donnees.demandesPub.delete_one({"id": idPub})
+    def supprimer_publication(self, idPub):
+        self.base_donnees.demandesPub.delete_one({"_id": ObjectId(idPub)})
 
     ## Récupérer l'auteur d'une demande de publication
     # @param idPub l'id de la demande de publication
-    def get_auteur_demande_publication(self,idPub):
-        return self.base_donnees.demandesPub.find_one({"id": idPub})["auteurDemande"]
+    def get_auteur_demande_publication(self, idDdePublication):
+        return self.base_donnees.demandesPub.find_one({"_id": ObjectId(idDdePublication)})["auteurDemande"]
 
     ## 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"]
+        return self.base_donnees.demandesPub.find_one({"_id": ObjectId(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)
-
-        for elt in element:
-            # print("id : ", elt)
-            return int(elt["id"])
+    def get_id_contenu_en_cours_associe_a_une_publication(self, idDdePublication):
+        return self.base_donnees.demandesPub.find_one({"_id": ObjectId(idDdePublication)})["idContenuEnCours"]
 
     ## Récupérer les demandes de publication
     # @param auteur l'auteur des demandes
@@ -86,4 +82,4 @@ class DemandePubDao:
         if emises:
             return self.base_donnees.demandesPub.find({"auteurDemande": auteur})
         else:
-            return self.base_donnees.demandesPub.find({"auteurContenu": auteur})
\ No newline at end of file
+            return self.base_donnees.demandesPub.find({"auteurContenu": auteur})

modele/encoursDao.py

@@ -22,6 +22,12 @@ class EncoursDao:
         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"]
 
+    ## récupérer l'id 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
+    # @return l'id intial du contenu en cours
+    def get_id_origine_contenu_en_cours(self, id_contenu_en_cours):
+        return self.base_donnees.encours.find_one({"_id": ObjectId(id_contenu_en_cours)})["reference"]
+
     ## 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
@@ -36,19 +42,17 @@ class EncoursDao:
         return self.base_donnees.encours.find_one({"idContenuEC": id_contenu_en_cours})
 
     ## supprimer un contenu en cours
-    # @param idContenuEnCours id du contenu a supprimer
+    # @param idContenu id du contenu  de la reference a supprimer
     def supprimer_contenu_en_cours(self, 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.encours.find().sort("idContenuEC", -1).limit(1)
+    ## 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)})
 
-        for elt in element:
-            # print("id : ", elt)
-            return int(elt["idContenuEC"])
 
     ## création d'un contenu en cours
     # @param version la version du contenu d'origine
@@ -57,3 +61,11 @@ class EncoursDao:
         self.base_donnees.encours.insert_one(
             {"date": datetime.now().strftime("%d/%m/%y"), "auteur": auteur,
              "reference": ObjectId(idContenu), "version": version})
+
+    ## création d'un contenu en cours, dans l'état refuse
+    # @param version la version du contenu d'origine
+    # @param nomBranche -> plus utile.
+    def creer_en_cours_refuse(self, auteur, idContenu, version):
+        self.base_donnees.encours.insert_one(
+            {"date": datetime.now().strftime("%d/%m/%y"), "auteur": auteur,
+             "reference": ObjectId(idContenu), "version": version, "etat": "refuse"})