Skip to content

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

Ajustements controleur avec les tests interface vueJs

parent 52c5ce8d
Hide whitespace changes
Inline Side-by-side
Showing with 219 additions and 72 deletions
app.py
View file @ f5414041
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
View file @ f5414041
......@@ -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/contenuDao.py
View file @ f5414041
from bson import ObjectId
from flask_pymongo import PyMongo
from pymongo import MongoClient
......@@ -18,25 +19,32 @@ class ContenuDao:
## extraction d'une base de données. Si elle n'existe pas, elle esst créée
base_donnees = client.squelette
## Fonction permettant d'ajouter un contenu dans le panier de l'auteur
# @param l'auteur en cours
# @param nom_fichier le nom du fichier associé au contenu
# @param commit le 'hash' du commit associé (récupéré via git)
def ajouter_contenu(self, auteur, nom_fichier, commit):
self.base_donnees.contenu.insert_one(
{"id": 1, "auteur": auteur, "note": randrange(0, 10, 1),
{"auteur": auteur, "note": randrange(0, 10, 1),
"fichier": "dossier" + nom_fichier + "/" + nom_fichier,
"versionEnCours": {"numero": 1, "date": datetime.now().strftime("%d/%m/%y"),
"popularite": 0, "commit": commit},
"tags_banque_fixes": ["tag1", "tag2", "tag3", "tag4", "tag5"],
"tags_banque_libres": ["tagl1", "tagl2", "tagl3", "tagl4", "tagl5"], "type": " ", "source": " "})
## recherche d'un contenu par id (pour affichage de son contenu)
# @param id l'id du contenu recherché
def get_contenu_par_id(self, id):
return self.base_donnees.contenu.find({"id": id})
## recherche d'un contenu par id (pour affichage de son contenu. charge la version courante
# @param id_contenu l'id du contenu recherché
def get_contenu_par_id(self, id_contenu):
return self.base_donnees.contenu.find({"_id": ObjectId(id_contenu)})
## recherche d'un contenu par id et une version précise
# @param id l'id du contenu recherché
# @param version la version du contenu recherché
def get_contenu_avec_id_et_version(self, id_contenu, version):
# a décommenter quand git sera actif
# Utils.changer_version(idContenu, version, "")
return self.base_donnees.contenu.find_one({"id": id_contenu})
return self.base_donnees.contenu.find({"_id": ObjectId(id_contenu["contenu"])})
# return Utils.contenu.find_one({"$and": [
# {"id": idContenu},
# {"$or": [{"versionEnCours.numero": version}, {"historique.numero": version}]}
......@@ -44,7 +52,11 @@ class ContenuDao:
# })
## recherche des contenus pour un auteur donné (son 'panier')
# param
# @param auteur l'auteur des contenus
# @param perso true si contenus persos a charger, false sinon
# @param tiers true si contenus tiers a charger, false sinon
# @param en_vours true si contenus en cours a charger, false sinon
# @return tous les contenus présents dans le panier de l'auteur
def get_contenus(self, auteur, perso, tiers, en_cours):
contenus = list()
......@@ -52,54 +64,91 @@ class ContenuDao:
if tiers:
id_tiers = self.get_contenus_tiers(auteur)
for (id, version) in id_tiers:
contenus.append(
self.get_contenu_avec_id_et_version(int(id['contenu']), int(version['version'])))
curseur_tiers = self.get_contenu_avec_id_et_version(id, version)
for contenu in curseur_tiers:
contenu["provenance"] = "tiers"
contenu["version"] = version
contenus.append(contenu)
if perso:
curseur_perso = self.get_contenus_persos(auteur)
for contenu in curseur_perso:
contenu["provenance"] = "perso"
contenus.append(contenu)
if en_cours:
curseur_en_cours = EncoursDao().get_contenus_en_cours_auteur(auteur)
for contenu in curseur_en_cours:
contenu["provenance"] = "en-cours"
contenus.append(contenu)
# on garde le développement de l'évaliation pour plus tard
# return contenus_persos + contenus_en_cours + contenus_tiers
# on garde le développement de l'évaliation pour plus tard
# return contenus_persos + contenus_en_cours + contenus_tiers
return contenus
## FOnction permettant de récupérer les contenus tiers d'un auteur
# @param auteur l'auteur en question
def get_contenus_tiers(self, auteur):
return self.base_donnees.utilisateur.find_one({"nom": auteur})["tiers"]
## Fonction permettant de charger tous les contenus 'publiés' n'appartenant pas à auteur (pour afficher sa banque)
# @param auteur l'auteur en cours
# @return tous les contenus non présents dans le panier de l'auteur
def get_contenus_non_auteur(self, auteur):
contenus_tiers = self.get_contenus_tiers(auteur)
tiers_auteur = list()
for tier in contenus_tiers:
tiers_auteur.append(ObjectId(tier[0]["contenu"]))
return self.base_donnees.contenu.find({"$and": [{"auteur": {"$ne": auteur}}, {"_id": {"$nin": tiers_auteur}}]})
## FOnction de création d'un tiers
# @param auteur l'auteur en cours
# @param id_contenu le contenu à ajouter en tiers
# @param version la version dans laquelle le contenu a été pris
def creer_tiers(self, auteur, id_contenu, version):
self.base_donnees.utilisateur.update({"nom": auteur}, {
"$push": {
"tiers": [{"contenu": int(id_contenu)}, {"version": version}]}})
"tiers": [{"contenu": ObjectId(id_contenu)}, {"version": version}]}})
## FOnction permettant de récupérer les contenus persos d'un auteur
# auteur l'auteur en question
def get_contenus_persos(self, auteur):
return self.base_donnees.contenu.find({"auteur": auteur})
def get_contenus_tiers(self, auteur):
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
# @param auteur l'id du contenu à renier
def dissocier_contenu(self, id_contenu):
self.base_donnees.contenu.update({"id": id_contenu}, {"$set": {"auteur": "Aucun"}})
self.base_donnees.contenu.update({"_id": ObjectId(id_contenu)}, {"$set": {"auteur": "Aucun"}})
## l'auteur 'renie' son contenu, mais vu que personne d'autre ne l'a il est définitivement supprimé
# @param auteur l'id du contenu à supprimer
def supprimer_contenu(self, id_contenu):
self.base_donnees.db.contenu.delete_one({"id": id_contenu})
def supprimer_tiers(self, id_contenu, auteur, version):
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": id_contenu}, {"version": version}]}})
{"$pull": {
"tiers": [{"contenu": ObjectId(id_tiers)}, {"version": version}]}})
## fonction qui permet de savoir si au moins un auteur possède un certain contenu dans ses tiers
# @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
def creer_nouveau_contenu(self, chemin, auteur_en_cours, idContenuEnCours):
## 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)
# hard codé pour l'exemple, sera adaptatif dans le futur
......@@ -116,7 +165,7 @@ class ContenuDao:
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")
# commit = UtilsGit.commit(cheminFichier, "Contenu" + str(max_id), "Version 1")
'''
self.base_donnees.contenu.insert_one(
{"id": max_id + 1, "auteur": auteur_en_cours, "note": randrange(0, 10, 1),
......@@ -126,29 +175,41 @@ class ContenuDao:
"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)
'''
def get_chemin_du_contenu(self, idContenu):
return self.chemin + self.base_donnees.contenu.find_one({"id": idContenu})["fichier"]
def get_version_tiers_avec_id(self, idContenu, auteur):
## 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"]
## 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é
# @param id_contenu le contenu recherché
# @return la version du tiers id_contenu (ou 0)
def get_version_tiers_avec_id(self, id_contenu, auteur):
tiers = (self.base_donnees.utilisateur.find_one({"nom": auteur})["tiers"])
for i in range(len(tiers)):
tmp = tiers[i]
if int(tmp[0]["contenu"]) == idContenu:
if tmp[0]["contenu"] == ObjectId(id_contenu):
return int(tmp[1]["version"])
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):
repertoire = chemin[:chemin.rfind("/") + 1]
#fin = s.affichage(chemin)
# fin = s.affichage(chemin)
version = int(fin[-1])
# Mise à jour du répertoire git
#idCommit = UtilsGit.mergeVersion(repertoire, nomBranche)
# idCommit = UtilsGit.mergeVersion(repertoire, nomBranche)
# Mise à jour des métadonnées - ok
version_en_cours = self.base_donnees.contenu.find_one({"id": idContenu})["versionEnCours"]
......@@ -160,6 +221,9 @@ class ContenuDao:
self.base_donnees.contenu.update_one({"id": int(idContenu)}, {
"$set": {"auteur": auteur}})
## lecture d'un contenu (version basique pour les tests)
# @param id l'id du contenu à consulter
# @param auteur l'auteur souhaitant consulter le contenu
def consulter_un_contenu(self, id, auteur):
# Créer un répertoire au nom de l'auteur (ou l'utiliser si il existe déja)
auteur = auteur.lower().replace(" ", "_")
......@@ -169,21 +233,30 @@ class ContenuDao:
chemin = Utils.get_chemin_du_contenu(id)
nom_fichier = chemin[chemin.rfind("/") + 1:]
os.system("cp '" + chemin + "' '" + repertoire_auteur + nom_fichier + "'")
#self.affichage(chemin)
# self.affichage(chemin)
## détruire un fichier temporaire
## modification d'un contenu (version test)
# @param idCOntenu l'id du contenu à modifier
# @param auteur l'auteur soihaitant modifier le contenu
# @param enCours si true, le contenu modifié est déja un en cours. SI false, il ne l'était pas
def modifier_contenu(self, idContenu, auteur, enCours=False):
# le chemin du fichier restera tjrs le même
contenu = self.base_donnees.contenu.find_one({"id": int(idContenu)})
self.base_donnees.modification_fichier(self.chemin + contenu["fichier"], idContenu, auteur, not enCours)
## après fin de consultation, destruction du fichier temporaire généré
# @param id l'id du contenu consulté
# @param auteur l'auteur auant effectué la consultation
def detruire_fichier_tmp(self, id, auteur):
auteur = auteur.lower().replace(" ", "_") + "/"
chemin = self.get_chemin_du_contenu(id)
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)
......@@ -192,12 +265,20 @@ class ContenuDao:
# 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
def is_anonyme(self, idContenu):
# print("Is anonyme : ", Utils.contenu.find_one({"id": idContenu})["auteur"])
return self.base_donnees.contenu.find_one({"id": idContenu})["auteur"] == "Aucun"
## Récupérer tous les contenus
def get_tous_les_contenus(self):
return self.base_donnees.contenu.find()
# FOnction permettant de déterminer si un certain contenu fait partie des tiers d'un auteur
# @param auteur l'auteur concerné
# @param idContenu le contenu à 'tester'
# @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
modele/demande_pubDao.py
View file @ f5414041
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")
......@@ -37,8 +46,8 @@ class DemandePubDao:
# Utils.statdb.demandesPub.update_one({"id": 1}, {"$set": {"etat": "refus"}})
'''
## Supprimer une demande de publication
# @param idPub l'id de la demande de publication
## 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})
......@@ -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
View file @ f5414041
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
View file @ f5414041
......@@ -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
View file @ f5414041
......@@ -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})
......
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