Skip to content

O
OpenQuizz
Commit b6bf0a50 authored by Jérémie Passerat's avatar Jérémie Passerat
Browse files
Options

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

parent f5414041
Show whitespace changes
Inline Side-by-side
Showing with 208 additions and 103 deletions
app.py
View file @ b6bf0a50
......@@ -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/contenuDao.py
View file @ b6bf0a50
......@@ -9,7 +9,8 @@ import os
from pathlib import Path
import string
from modele.encoursDao import EncoursDao
from modele.demande_pubDao import *
from modele.encoursDao import *
class ContenuDao:
......@@ -127,13 +128,11 @@ class ContenuDao:
if self.existe_en_tiers(id_contenu):
self.dissocier_contenu(id_contenu)
else:
print("Je suis id contenu dans contenuDao.py " + id_contenu)
self.base_donnees.contenu.delete_one({"_id": ObjectId(id_contenu)})
## l'auteur 'renie' un tiers (suppression définitive)
# @param auteur l'id du contenu à supprimer
def supprimer_tiers(self, id_tiers, auteur, version):
print(auteur, " - ", id_tiers, " - ", version)
self.base_donnees.utilisateur.update({"nom": auteur},
{"$pull": {
"tiers": [{"contenu": ObjectId(id_tiers)}, {"version": version}]}})
......@@ -142,48 +141,52 @@ class ContenuDao:
# @param auteur l'id du contenu à 'tester'
def existe_en_tiers(self, id_contenu):
return self.base_donnees.utilisateur.find(
{"tiers": {"$elemMatch": {"$elemMatch": {"contenu": id_contenu}}}}).count() != 0
{"tiers": {"$elemMatch": {"$elemMatch": {"contenu": ObjectId(id_contenu)}}}}).count() != 0
## fonction qui permet de créer un contenu à partir d'une contenu en cours
# @param chemin le chemin du contenu
# @param auteur_en_cours l'auteur du contenu en cours
# @param id_contenu_en_cours l'id du contenu en cours
def creer_nouveau_contenu(self, chemin, auteur_en_cours, id_contenu_en_cours):
# print("chemin : ", chemin)
def creer_nouveau_contenu(self, id_demande_publication, auteur_en_cours):
# hard codé pour l'exemple, sera adaptatif dans le futur
max_id = 3
id_contenu = DemandePubDao().get_id_contenu_associe_a_une_publication(id_demande_publication)
id_contenu_en_cours = DemandePubDao().get_id_contenu_en_cours_associe_a_une_publication(id_demande_publication)
chemin = self.get_chemin_du_contenu(id_contenu)
dossierFichier = "dossierContenu" + str(max_id) + "/"
cheminFichier = self.chemin + dossierFichier
nomFichier = chemin[chemin.rfind("/") + 1:]
# print("Chemin fichier : ", cheminFichier)
# print("Dossier Fichier : ", dossierFichier)
# print("NomFichier :", nomFichier)
Path(cheminFichier).mkdir(parents=True, exist_ok=True)
os.system("cp " + chemin + " " + cheminFichier)
os.system("mv " + cheminFichier + nomFichier + " " + cheminFichier + "Contenu" + str(max_id))
# exit(0)
# commit = UtilsGit.commit(cheminFichier, "Contenu" + str(max_id), "Version 1")
'''
# Path(cheminFichier).mkdir(parents=True, exist_ok=True)
self.base_donnees.contenu.insert_one(
{"id": max_id + 1, "auteur": auteur_en_cours, "note": randrange(0, 10, 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"),
"popularite": 0, "commit": commit},
"popularite": 0, "commit": ""},
"tags_fixes": {"1": "tag1", "2": "tag1", "3": "tag1", "4": "tag1",
"5": "tag1"},
"tags": {"1": "tag1", "2": "tag1", "3": "tag1", "4": "tag1", "5": "tag1"}})
self.base_donnees.supprimer_contenu_en_cours(idContenuEnCours)
'''
DemandePubDao().supprimer_publication(id_demande_publication)
## récupère le chemin d'un contenu
# @param id_contenu l'id du contenu recherché
# @return le chemin désiré
def get_chemin_du_contenu(self, id_contenu):
return self.chemin + self.base_donnees.contenu.find_one({"id": id_contenu})["fichier"]
if type('id_contenu') == "String":
id_contenu = ObjectId(id_contenu)
return self.chemin + self.base_donnees.contenu.find_one({"_id": id_contenu})["fichier"]
## récupère la version en cours du contenu
def get_version_courante(self, id_contenu):
if type('id_contenu') == "String":
id_contenu = ObjectId(id_contenu)
return self.base_donnees.contenu.find_one({"_id": id_contenu})["versionEnCours"]["numero"]
## récupère la version d'un contenu mis en tiers (ou 0 si ce contenu n'est pas sossédé en tiers)
# @param auteur l'auteur concerné
......@@ -198,27 +201,30 @@ class ContenuDao:
return 0
## mise à jour d'un contenu
# @param chemin le chemin du contenu
# @param idContenu l'id du contenu à mettre à jour
# @param nomBranche le nom de la branche
# @param auteur l'auteur du contenu à mettre à jour
def maj_contenu(self, chemin, idContenu, nomBranche, auteur=None):
def maj_contenu(self, id_contenu, auteur=None):
chemin = self.get_chemin_du_contenu(id_contenu)
repertoire = chemin[:chemin.rfind("/") + 1]
# fin = s.affichage(chemin)
version = int(fin[-1])
version = int(self.get_version_courante(id_contenu)) + 1
# Mise à jour du répertoire git
# idCommit = UtilsGit.mergeVersion(repertoire, nomBranche)
if type('id_contenu') == "String":
id_contenu = ObjectId(id_contenu)
# Mise à jour des métadonnées - ok
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}}})
version_en_cours = self.base_donnees.contenu.find_one({"_id": id_contenu})["versionEnCours"]
self.base_donnees.contenu.update_one({"_id": id_contenu}, {"$push": {"historique": version_en_cours}})
self.base_donnees.contenu.update_one({"_id": id_contenu}, {
"$set": {"versionEnCours": {"numero": version, "date": datetime.now().strftime("%d/%m/%y"), "popularite": 0,
"commit": ""}}})
if auteur is not None:
self.base_donnees.contenu.update_one({"id": int(idContenu)}, {
self.base_donnees.contenu.update_one({"_id": id_contenu}, {
"$set": {"auteur": auteur}})
## lecture d'un contenu (version basique pour les tests)
......@@ -255,16 +261,6 @@ class ContenuDao:
nom_fichier = chemin[chemin.rfind("/") + 1:]
os.system("rm '" + self.chemin + auteur + nom_fichier + "'")
## Fonction permettant de récupérer l'id max en cours (ceux ci étant uniques)
# Sera par la suite supprimé car les id seront récupérés de l'indexation mongo
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.contenu.find().sort("id", -1).limit(1)
for elt in element:
# print("id : ", elt["id"])
return int(elt["id"])
## Fonction permettant de déterminer si un contenu est "anonyme"
# @param idCOntenu le contenu à tester
# @return booléen true.false si le contenu est anonyme ou pas
......@@ -282,3 +278,59 @@ class ContenuDao:
# @return booléen true.false si le contenu est chez l'auteur ou pas
def is_tiers_auteur(self, auteur, idContenu):
return self.get_version_tiers_avec_id(idContenu, auteur) != 0
## mettre à jour un contenu 'tiers'
# @param auteur l'auteur concerné
# @param id_favori le favori à maj
# @param nouvelle_version le numero de la nouvelle version
# @param refuse indique si la mise a jour est acceptee ou refusee
def maj_tiers(self, id_tiers, nouvelle_version, auteur, refuse=False):
if not refuse:
# on vire le précédent
self.base_donnees.utilisateur.update({"nom": auteur},
{"$pull": {
"tiers": [{"contenu": ObjectId(id_tiers)},
{"version": nouvelle_version - 1}]}})
# et on ajoute la version maj
self.base_donnees.utilisateur.update({"nom": auteur},
{"$push": {
"tiers": [{"contenu": ObjectId(id_tiers)},
{"version": nouvelle_version}]}})
else:
self.base_donnees.utilisateur.update({"nom": auteur},
{"$push": {
"majRejetees": [{"contenu": ObjectId(id_tiers),
"version": nouvelle_version}]}})
## Permet de savoir si au moins un tiers est mettable à jour pour un auteur
# @param auteur l'auteur concerné
# @return un booléen indiquant si on a des mises à jour faisables
def is_tiers_maj(self, auteur):
# on cherche toutes les versions en cours dans les tiers et on compare avec celles de la banque
# On réfcupère tous les ties d'un auteur
tiers = self.get_contenus_tiers(auteur)
for (id, version) in tiers:
versionCourante = self.get_version_courante(id["contenu"])
if version["version"] < versionCourante:
return True
return False
## Permet de savoir si au moins un tiers est mettable à jour pour un auteur
# @param auteur l'auteur concerné
# @return la liste des tiers mettables à jour
def liste_tiers_maj(self, auteur):
liste = list()
# On réfcupère tous les ties d'un auteur
tiers = self.get_contenus_tiers(auteur)
for (id, version) in tiers:
versionCourante = self.get_version_courante(id["contenu"])
if version["version"] < versionCourante:
liste += self.get_contenu_avec_id_et_version(id, version)
return liste
modele/demande_pubDao.py
View file @ b6bf0a50
......@@ -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
# @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 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"}})
'''
# on notifie au 'demandeur' que sa demande de publication est acceptée
self.base_donnees.demandesPub.update_one({"_id": ObjectId(idPublication)}, {"$set": {"etat": "accepté"}})
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
......
modele/encoursDao.py
View file @ b6bf0a50
......@@ -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"})
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment