Manipulations sur les contenus en cours finies

Main.py

@@ -16,9 +16,11 @@ from Utils import Utils
 #   - 5 : Créer une évaluation
 #   - 6 : Consulter les évaluations
 #   - 7 : Modifier un contenu
-#   - 8 : Valider une demande de modification sur un contenu (a venir)
+#   - 8 : Naviguer dans un contenu (a venir)
 #   - 9 : Rechercher un contenu dans la banque (a venir)\n
 #   - 10 : Consulter les contenus en cours de modification\n
+#   - 11 : Gérer les demandes de publication\n
+#   - 12 : Mises à jour de favoris\n
 
 #   <b> (Il manquera les fonctionnalités à propos des tags libres "privés", la notation contenu / auteur, la gestion de la "popularité" des versions) </b>\n
 #   \n
@@ -30,30 +32,28 @@ from Utils import Utils
 #   5 -> Créer un regroupement de contenus \n
 #   6 -> Consulter les évaluations crééees \n
 #   7 -> Permet de modifier un des fichiers importé OU un des favoris \n
-#   8 -> Consulter les demandes de modifications "tierces" \n
+#   8 -> Permet de sélectionner un contenu et une version particulière. Sera intégré, à terme, dans le panier
 #   9 -> Recherche par auteur, date, tag (imposés / libres), contenu / titre, note \n
 #   10 -> Par la suite, les contenus "en cours" seront disponibles dans le panier\n
-
-
+#   11 -> Demandes de publication recues et émises
+#   12 -> Sera intégré, à terme, dans le panier
 
 
 #
 
 Menu()
 
+from datetime import datetime
+'''
+Utils.initialiseMongo()
+Utils.toutPeter()
+Utils.statdb.demandesPub.insert_one(
+    {"id": 1, "date": datetime.now().strftime("%d/%m/%y"), "auteurDemande": "Auteur 1",
+     "auteurContenu": "Auteur 2",
+     "idContenu": 1, "idContenuEnCours": 1, "etat": "enCours"})
+# Utils.statdb.demandesPub.update_one({"id": 1}, {"$set": {"etat": "refus"}})
+print(Utils.statdb.demandesPub.find_one({"id": 1}))
+#Utils.statdb.demandesPub.update_one({"id": 1}, {"$set": {"etat": "refus"}})
+Utils.statdb.demandesPub.delete_one({"id": 1})
+'''
 
-#Utils.initialiseMongo()
-#Utils.ajouterUtilisateur("Auteur 1")
-#Utils.ajouterUtilisateur("Auteur 2")
-#Utils.ajouterUtilisateur("Auteur 3")
-#Utils.sumContenuEnFavori(1)
-#Utils.sumContenuEnFavori(2)
-#print(Utils.getMaxIdContenus())
-#print(Utils.getMaxIdEvaluations())
-#print(Utils.getMaxIdContenusEnCours())
-#print (Utils.getIdContenuAssocieAUnEnCours(1))
-
-#from UtilsGit import UtilsGit
-#UtilsGit.changerVersionCommit("/home/passerat/Stage/Squelette/dossierContenu1", "master")
-
-#print (Utils.isFavoriDeAuteur("Auteur 2", 1))
\ No newline at end of file

Menu.py

@@ -57,9 +57,11 @@ class Menu:
         print("5 : Créer une évaluation")
         print("6 : Consulter les évaluations")
         print("7 : Modifier un contenu")
-        print("8 : Valider une modification")
+        print("8 : Naviguer dans un contenu")
         print("9 : Rechercher un contenu")
         print("10 : Consulter les contenus en cours de modification")
+        print("11 : Gérer les demandes de publication")
+        print("12 : Mises à jour de favoris")
         print("Votre choix : ")
         choix = (input())
         if choix.isdigit():
@@ -85,15 +87,17 @@ class Menu:
         elif argument == 7:
             self.modifierContenu()
         elif argument == 8:
-            os.system('clear')
-            print("Bonjour ", self.auteurEnCours)
-            print("Fonctionnalité à venir")
+            self.naviguerContenu()
         elif argument == 9:
             os.system('clear')
             print("Bonjour ", self.auteurEnCours)
             print("Fonctionnalité à venir")
         elif argument == 10:
             self.consulterEnCours()
+        elif argument == 11:
+            self.gererDemandesPublication()
+        elif argument == 12:
+            self.majFavoris()
         else:
             print("Action inconnue")
 
@@ -188,7 +192,7 @@ class Menu:
 
         favoris = Utils.getFavoris(self.auteurEnCours)
         is_fav = False
-        print("favoris : ", favoris)
+        #print("favoris : ", favoris)
 
         for elt in contenu:
             print("id :", elt["id"], "auteur :", elt["auteur"], " - nom :", elt["fichier"], " - v",
@@ -446,7 +450,6 @@ class Menu:
 
             Utils.creerNouveauContenu(chemin,
                                       self.auteurEnCours, id)
-            Utils.supprimerContenuEnCours(int(id))
             if Utils.isFavoriDeAuteur(self.auteurEnCours, contenu_associe):
                 versionFavori = Utils.getVersionFavoriById(contenu_associe, self.auteurEnCours)
                 Utils.supprimerFavori(contenu_associe, self.auteurEnCours, versionFavori)
@@ -463,6 +466,9 @@ class Menu:
         idContenu = Utils.getIdContenuAssocieAUnEnCours(idContenuEnCours)
         branche = Utils.getBrancheContenuEnCours(idContenuEnCours)
 
+        print("L'auteur en cours est : ", self.auteurEnCours)
+        print("L'auteur de base est : ", auteur)
+
         if auteur == self.auteurEnCours:
             print("Modification directe d'un auteur")
             chemin = Utils.getCheminDuContenu(idContenu)
@@ -470,4 +476,128 @@ class Menu:
         else:
             print("Modification indirecte -> demande de publication")
             print("Je demande à l'auteur ", auteur, "de valider ma demande de proposition")
-            # supprimer favori
+            Utils.demandePublication(idContenu, idContenuEnCours, self.auteurEnCours, auteur)
+            self.menuDesActions()
+
+    ## Naviguer entre différentes versions d'un contenu - Action 8
+    def naviguerContenu(self):
+        print("Cette fonction servira à consulter différentes versions d'un contenu")
+        os.system('clear')
+        print("Bonjour ", self.auteurEnCours)
+
+        # 1. On charge les contenus "propres" de la banque
+        questions = Utils.consulterContenu(self.auteurEnCours, True)
+        nbreQuestion = questions.count()
+        print(self.auteurEnCours + " possede " + str(nbreQuestion) + " contenu(s)")
+        if questions.count() > 0:
+            self.afficherContenusBanque(questions)
+        # 1. On charge les contenus "mis en favori" de la banque
+
+        print(f"Contenus mis en favori par l'auteur {self.auteurEnCours} : {len(Utils.getFavoris(self.auteurEnCours))}")
+        nbreFavoris = len(Utils.getFavoris(self.auteurEnCours))
+        if len(Utils.getFavoris(self.auteurEnCours)):
+            for (id, version) in Utils.getFavoris(self.auteurEnCours):
+                print("La question : ", int(id['contenu']), " et sa version", int(version['version']))
+                self.afficherContenusFavoris(
+                    Utils.getContenuavecIdEtVersion(int(id['contenu']), int(version['version'])),
+                    int(version['version']))
+        if nbreFavoris > 0 or nbreQuestion > 0:
+            print ("Entrer le numero de contenu désiré (ou q pour quitter)")
+            choix = input()
+            if choix == 'q':
+                self.menuDesActions()
+            if choix.isdigit():
+                print ("La question qui m'intéresse est la : ", int(choix))
+                print ("Cette question en est à la version : ", Utils.getVersionCourante(int(choix)))
+                if Utils.getVersionCourante(int(choix)) == 1:
+                    print ("Aucun choix, j'affiche juste la version en cours")
+                    Utils.affichage(Utils.getCheminDuContenu(int(choix)))
+                else:
+                    print ("Je choisis la version que je veux")
+
+
+    ## Gérer les demandes de publication emises et recues - Action 11
+    def gererDemandesPublication(self):
+        os.system('clear')
+        print("Bonjour ", self.auteurEnCours)
+        print("1. Demandes de publication emises")
+        print("2. Demandes de publication reçues")
+        print("3. Revenir en arrière")
+
+        choix = int(input())
+        if choix == 1:
+            contributions = Utils.getDemandesPub(self.auteurEnCours)
+            print("Je veux afficher les contributions emises, j'ai ", contributions.count(), "contributions")
+            if contributions.count() > 0:
+                self.afficherDdePublications(contributions, True)
+            else:
+                print("Vous n'avez aucune demande de contribution emise, appuyez sur q pour revenir en arriere")
+                input()
+                self.gererDemandesPublication()
+        elif choix == 2:
+            contributions = Utils.getDemandesPub(self.auteurEnCours, False)
+            print("Je veux afficher les contributions recues, j'ai ", contributions.count(), "contributions")
+            if contributions.count() > 0:
+                self.afficherDdePublications(contributions, False)
+            else:
+                print("Vous n'avez aucune demande de contribution emise, appuyez sur q pour revenir en arriere")
+                input()
+                self.gererDemandesPublication()
+        elif choix == 3:
+            self.menuDesActions()
+
+    ## Affichage des demandes de publication
+    # @param emetteur -> l'auteur est le demandeur de la publication si True, et le réceptionnaire si False
+    def afficherDdePublications(self, publications, emetteur):
+        if not emetteur:
+            texte = "auteur demandeur : "
+            for pub in publications:
+                etat = pub["etat"]
+                # pour raison de simplicité, les demandes de publication refusées sont invisibles (dans un futur proche elle seront visibles mais non interactives)
+                if etat != "refus":
+                    print(texte, pub["auteurDemande"], "idDemandePublication : ", pub["id"], "date : ", pub["date"])
+            print("Entrer l'id de la publication puis O ou N pour accepter ou refuser la demande")
+            choix = input()
+            num_contenu = choix[0:len(choix) - 1]
+            choix = choix[len(choix) - 1:]
+            Utils.gererDemandePub(num_contenu, choix)
+        else:
+            texte = "auteur source : "
+            for pub in publications:
+                id_pub = pub["id"]
+                print(texte, pub["auteurContenu"], "idDemandePublication : ", pub["id"], "date : ", pub["date"],
+                      "etat : ", pub["etat"])
+                if pub["etat"] == "refus":
+                    print("Actions possibles : ")
+                    print("n : creer un nouveau contenu a partir de celui ci")
+                    print("s : supprimer le contenu")
+                    print("q : remettre ce choix à plus tard")
+                    choix = input()
+                    if choix == 'n':
+                        id_en_cours = Utils.getIdContenuEnCoursAssocieAUnePublication(id_pub)
+                        contenu_associe = Utils.getIdContenuAssocieAUnEnCours(id_en_cours)
+                        chemin = Utils.getCheminDuContenu(contenu_associe)
+
+                        Utils.creerNouveauContenu(chemin,
+                                                  self.auteurEnCours, id_pub)
+                        if Utils.isFavoriDeAuteur(self.auteurEnCours, contenu_associe):
+                            versionFavori = Utils.getVersionFavoriById(contenu_associe, self.auteurEnCours)
+                            Utils.supprimerFavori(contenu_associe, self.auteurEnCours, versionFavori)
+                        self.consulterPanier()
+                    elif choix == 's':
+                        Utils.supprimerContenuEnCours(Utils.getIdContenuEnCoursAssocieAUnePublication(pub["id"]))
+                    elif choix == 'q':
+                        self.menuDesActions()
+
+    ## Observer les possibilités de mettre à jour les favoris - Action 12
+    def majFavoris(self):
+        os.system('clear')
+        print("Bonjour ", self.auteurEnCours)
+        nbreFavoris = len(Utils.getFavoris(self.auteurEnCours))
+        print("L'auteur possède ", nbreFavoris, " favoris")
+        if nbreFavoris > 0:
+            Utils.listeMajFavoris(self.auteurEnCours)
+        else:
+            print("Vous n'avez aucun favori, appuyez sur q pour revenir en arriere")
+            input()
+            self.menuDesActions()

Utils.py

@@ -161,6 +161,12 @@ class Utils:
         # ]
         # })
 
+    ## récupérer la version courante d'un contenu
+    # @param idContenu l'id du contenu concerné
+    @staticmethod
+    def getVersionCourante(idContenu):
+        return Utils.statdb.contenu.find_one({"id": idContenu})["versionEnCours"]["numero"]
+
     ## Récupérer un contenu à partir de son identifiant
     # @param idContenu l'id associé au contenu
     # @return Le contenu lié à l'id
@@ -213,6 +219,18 @@ class Utils:
             print("id : ", elt)
             return int(elt["idContenuEC"])
 
+    ##  Récupérer l'id maximal (pour les demandes de publication)
+    # permet de s'assurer que les id de demande de publication soient uniques
+
+    @staticmethod
+    def getMaxIdDemandesDePublication():
+        ## Fonction permettant de récupérer l'id max présent en base (pour pouvoir incrémenter un nouveau contenu).
+        element = Utils.statdb.demandesPub.find().sort("id", -1).limit(1)
+
+        for elt in element:
+            print("id : ", elt)
+            return int(elt["id"])
+
     ## Récupérer les favoris d'un utilisateur
     # @param auteur le nom de l'utilisateur
     # @return les favoris de l'utilisateur 'auteur'
@@ -390,7 +408,17 @@ class Utils:
     @staticmethod
     def getIdContenuAssocieAUnEnCours(idContenuEnCours):
         print("L'id en cours que j'ai est", idContenuEnCours, " - ", type(idContenuEnCours))
-        return Utils.statdb.encours.find_one({"idContenuEC": idContenuEnCours})["reference"]
+        return Utils.statdb.encours.find_one({"idContenuEC": int(idContenuEnCours)})["reference"]
+
+    @staticmethod
+    def getIdContenuAssocieAUnePublication(idDdePublication):
+        #print("L'id en cours que j'ai est", idContenuEnCours, " - ", type(idContenuEnCours))
+        return Utils.statdb.demandesPub.find_one({"id": int(idDdePublication)})["idContenu"]
+
+    @staticmethod
+    def getIdContenuEnCoursAssocieAUnePublication(idDdePublication):
+        print("L'id en cours que j'ai est", idDdePublication, " - ", type(idDdePublication))
+        return Utils.statdb.demandesPub.find_one({"id": int(idDdePublication)})["idContenuEnCours"]
 
     ## récupérer le chemin d'un fichier associé à un contenu
     # @param idContenu l'id du contenu
@@ -415,13 +443,6 @@ class Utils:
         else:
             UtilsGit.changerVersionBranche(repertoire, nomBranche)
 
-    ## permet de recuperer un commit particulier lié avec une version donnee
-    # @param idContenu l'id du contenu manipulé
-    # @param version le numéro de version désiré
-    @staticmethod
-    def getCommitPourUneVersion(idContenu, version):
-        return 42
-
     ## supprimer un contenu en cours
     # @param idContenuEnCours id du contenu a supprimer
     @staticmethod
@@ -451,6 +472,7 @@ class Utils:
         Utils.statdb.utilisateur.delete_many({})
         Utils.statdb.evaluation.delete_many({})
         Utils.statdb.encours.delete_many({})
+        Utils.statdb.demandesPub.delete_many({})
         os.system("rm -rf dossierContenu*/")
         Utils.ajouterUtilisateur("Auteur 1")
         Utils.ajouterUtilisateur("Auteur 2")
@@ -494,3 +516,119 @@ class Utils:
     @staticmethod
     def isFavoriDeAuteur(auteur, idContenu):
         return Utils.getVersionFavoriById(idContenu, auteur) != 0
+
+    ## créer une demande de Publication à l'auteur d'origine
+    # @param idContenuEnCours la modification à soumettre
+    # @param idContenu le contenu de base
+    # @param auteurEnCours l'auteur de la modification
+    # @param auteur l'auteur du contenu d'origine
+    # ATTENTION, IL FAUDRA SUREMENT INSERER UN ID POUR PLUS DE FACILITE A MANIPULER
+    @staticmethod
+    def demandePublication(idContenu, idContenuEnCours, auteurEnCours, auteur):
+        max_id = Utils.getMaxIdDemandesDePublication()
+        if max_id is None:
+            max_id = 0
+        Utils.statdb.demandesPub.insert_one(
+            {"id": max_id + 1, "date": datetime.now().strftime("%d/%m/%y"), "auteurDemande": auteurEnCours,
+             "auteurContenu": auteur,
+             "idContenu": idContenu, "idContenuEnCours": idContenuEnCours, "etat": "enCours"})
+
+    ## recuperer toutes les demandes de publication en cours pour un auteur
+    # @param auteur l'auteur concerné
+    @staticmethod
+    def getDemandesPub(auteur, emises=True):
+        if emises:
+            return Utils.statdb.demandesPub.find({"auteurDemande": auteur})
+        else:
+            return Utils.statdb.demandesPub.find({"auteurContenu": auteur})
+
+    ## permet de recuperer un commit particulier lié avec une version donnee
+    # @param idContenu l'id du contenu manipulé
+    # @param version le numéro de version désiré
+    @staticmethod
+    def getCommitPourUneVersion(idContenu, version):
+        return 42
+
+    ## permet de gerer la reponse à la publication
+    # @param idPublication la publication concernée
+    # @param reponse la reponse donnée (0 / N)
+    @staticmethod
+    def gererDemandePub(idPublication, reponse):
+        if reponse == 'O':
+            print("Publication acceptée")
+            id_en_cours = Utils.getIdContenuEnCoursAssocieAUnePublication(idPublication)
+            branche = Utils.getBrancheContenuEnCours(id_en_cours)
+            idContenu = Utils.getIdContenuAssocieAUnePublication(idPublication)
+            chemin = Utils.getCheminDuContenu(idContenu)
+            Utils.majContenu(chemin, idContenu, branche)
+            Utils.supprimerContenuEnCours(id_en_cours)
+            Utils.statdb.demandesPub.delete_one({"id": int(idPublication)})
+        else:
+            print("Publication refusée ", idPublication)
+
+            # 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"}})
+    ## récupérer l'état d'une demande de publication
+    #@param idDdePublication l'id de la demande de publication
+    @staticmethod
+    def etatDemandePublication(idDdePublication):
+        pass
+
+    ## listing de toutes les mises a jour possibles pour les favoris d'un auteur
+    # @param auteur l'auteur en cours
+    @staticmethod
+    def listeMajFavoris(auteur):
+        # on cherche toutes les versions en cours dans les favoris et on compare avec celles de la banque
+        # Trouver un moyen de sauvegarder le fait qu'une maj ait été refusée.
+        favoris = Utils.getFavoris(auteur)
+        for (id, version) in favoris:
+            versionCourante = Utils.getVersionCourante(id["contenu"])
+            print("contenu : ", id["contenu"], " - version : ", version["version"], " - versionCourante : ", versionCourante)
+            if version["version"] < versionCourante:
+                #Utils.isMajRefusee(auteur, id["contenu"], versionCourante)
+                if not Utils.isMajRefusee(auteur, id["contenu"], versionCourante):
+                    print("Mise à jour possible")
+                    print("Voulez vous la faire (O / N)")
+                    choix = input()
+                    if choix == 'O':
+                        Utils.majFavori(id["contenu"], versionCourante, auteur)
+                    else:
+                        Utils.majFavori(id["contenu"], versionCourante, auteur, True)
+            else:
+                pass
+
+    ## mettre à jour un favori
+    #   @param idContenu l'id du favori
+    #   @param versionContenu la version du favori
+    #   @param auteur l'auteur concerné
+    #   @param refuse True = maj acceptée, False = maj refusée
+    def majFavori(idFavori, idNouvelleVersion, auteur, refuse=False):
+        if not refuse:
+            # on vire le précédent
+            Utils.statdb.utilisateur.update({"nom": auteur},
+                                            {"$pull": {
+                                                "favoris": [{"contenu": idFavori},
+                                                            {"version": idNouvelleVersion - 1}]}})
+
+            # et on ajoute la version maj
+            Utils.statdb.utilisateur.update({"nom": auteur},
+                                            {"$push": {
+                                                "favoris": [{"contenu": idFavori}, {"version": idNouvelleVersion}]}})
+        else:
+            Utils.statdb.utilisateur.update({"nom": auteur},
+                                            {"$push": {
+                                                "majRejetees": [{"contenu": idFavori, "version": idNouvelleVersion}]}})
+
+    ## Fonction permettant de savoir si une maj de favori a été refusée ou pas
+    # @param auteur l'auteur concerné
+    #   @param idContenu l'id du favori
+    #   @param versionMaj la version de la mise à jour potentielle
+    @staticmethod
+    def isMajRefusee(auteur, idContenu, versionMaj):
+        print("print")
+        compteur =  Utils.statdb.utilisateur.find({"nom" : auteur} and
+            {"majRejetees": {"$elemMatch": {"$elemMatch": {"contenu": idContenu, "version": versionMaj}}}}).count() != 0
+        print ("Compteur : ", compteur)
+        exit(0)
+        return compteur