Skip to content

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

Sauvegarde du 23/08 avant mise en ligne

parent 36a25ef6
Hide whitespace changes
Inline Side-by-side
Showing with 415 additions and 39 deletions
app.py
View file @ f7f17472
......@@ -9,7 +9,7 @@ import random
import flask
import pytest
from bson import json_util, ObjectId
from flask import Flask, request, jsonify, Blueprint, make_response
from flask import Flask, request, jsonify, Blueprint, make_response, send_file
from pymongo import MongoClient
from werkzeug.datastructures import FileStorage
from werkzeug.utils import secure_filename
......@@ -56,7 +56,6 @@ api = Api(blueprint, doc='/doc/')
app.register_blueprint(blueprint)
users = api.namespace('utilisateurs', description='Entrées liées à la gestion utilisateur')
@app.route('/test')
......@@ -104,6 +103,17 @@ def refresh_expiring_jwts(response):
return response
## *********************************************************************************************************************
## Test de manipulation des images
image = api.namespace('images', description="pour les champs qui le nécessitent, permet de récupérer des images")
@app.route("/getImage/<nom_image>", methods=['GET'])
def monPetitProutney(image):
#return "Mais oui, les enfantches", 200
return send_file("/home/passerat/Stage/volet_navigation/src/assets/img/croix.png")
users = api.namespace('utilisateurs', description='Entrées liées à la gestion utilisateur')
## *********************************************************************************************************************
## Entrées liées à la gestion utilisateur
@users.route('/newUser')
......@@ -209,7 +219,8 @@ class AjouterContenu(Resource):
auteur = request.json["auteur"]
contenu_a_ecrire = request.json["contenu_a_ecrire"]
titre = request.json["titre"]
contenu_dao.ajouter_contenu(auteur, contenu_a_ecrire, titre)
tags = request.json["tags"]
contenu_dao.ajouter_contenu(auteur, contenu_a_ecrire, titre, tags)
return json.loads(json.dumps((contenu_dao.get_contenu_par_id(contenu_dao.id_dernier_contenu_ajoute())),
default=json_util.default)), 201
......@@ -228,6 +239,31 @@ class UploaderContenu(Resource):
default=json_util.default)), 201
@contenus.route("/incrementerPopularite")
@contenus.doc(params={'id_contenu': "l'id du contenu concerné"})
@contenus.doc(params={'version': "la version dont il faut augmenter la popularité"})
@contenus.doc(description="incrémenter la popularité d'une version d'un contenu")
class IncrementerPopularite(Resource):
@contenus.response(200, "Popularité Modifiée")
@jwt_required()
def patch(self):
id_contenu = json.loads(request.json["id_contenu"])
contenu_dao.incrementer_popularite(id_contenu["$oid"])
return "popularité modifiée", 200
# @contenus.route("/incrementerNote")
# @contenus.doc(params={'id_contenu': "l'id du contenu concerné"})
# @contenus.doc(description="incrémenter la note d'un contenu")
# class IncrementerNote(Resource):
# @contenus.response(200, "Note Modifiée")
# @jwt_required()
# def patch(self):
# id_contenu = json.loads(request.json["id_contenu"])
# contenu_dao.incrementer_note_contenu(id_contenu["$oid"])
# return "popularité modifiée", 200
@contenus.route('/ajouterTiers')
@contenus.doc(params={'auteur': "l'auteur qui ajoute le contenu"})
@contenus.doc(params={'contenu_a_ecrire': " le contenu à écrire"})
......@@ -312,7 +348,7 @@ class SupprimerTiers(Resource):
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)
contenu_dao.supprimer_tiers(id_tiers["$oid"], request.args.get('auteur'), version, request.args.get('note'))
if request.args.get('auteur') == "Aucun":
return str(contenu_dao.existe_en_tiers(id_tiers["$oid"])), 200
else:
......@@ -391,6 +427,103 @@ class get_tags_contenu(Resource):
default=json_util.default)), 200
@contenus.route("/modifierTags")
@contenus.doc(params={'id_publication': "l'id du contenu pour lequel on veut récupérer des tags"})
@contenus.doc(params={'tags': "les nouveaux tags du contenu"})
@contenus.doc(description="modifier les tags d'un contenu")
class modifier_tags_contenus(Resource):
@contenus.response(200, "Tags modifiés")
## récupérer les tags d'un contenu
@jwt_required()
def patch(self):
id_contenu = json.loads(request.json["id_contenu"])
ContenuDao().changer_tags_contenus(id_contenu["$oid"], request.json["tags"])
return "tags modifiés", 200
@contenus.route("/newTagLibre")
@contenus.doc(params={'auteur': "le créateur du tag"})
@contenus.doc(params={'id_contenu': "le contenu auquel le tag est associé. Possiblement vide"})
@contenus.doc(params={'tag': "Le tag créé"})
@contenus.doc(description="ajouter un tag libre")
class ajouter_tag_libre(Resource):
@contenus.response(201, "Tag libre créé")
## ajouter un tag libre (lié à un contenu ou non)
@jwt_required()
def patch(self):
if request.json['id_contenu'] != "":
id_contenu = json.loads(request.json["id_contenu"])
id_contenu = id_contenu["$oid"]
else:
id_contenu = ""
ContenuDao().creer_tag_libre(request.json["auteur"], request.json["tag"], id_contenu)
return "tag créé", 201
@contenus.route("/getTagLibre/<auteur>")
@contenus.doc(params={'auteur': "l'auteur des tags à récupérer"})
@contenus.doc(description="récupérer tous les tags libres d'un auteur")
class recuperer_tags_libres(Resource):
@contenus.response(200, "Tags libres récupérés")
## récupérer tous les tags libres d'un auteur
@jwt_required()
def get(self, auteur):
return ContenuDao().recuperer_all_tags_libres(auteur), 200
@contenus.route("/getTagLibreContenu/<id_contenu>/<auteur>")
@contenus.doc(params={'id_contenu': "le contenu auquel les tags ont été associés"})
@contenus.doc(params={'auteur': "l'auteur des tags à récupérer"})
@contenus.doc(description="récupérer tous les tags libres d'un auteur associés à un contenu particulier")
class recuperer_tags_libres_pour_un_contenu(Resource):
@contenus.response(200, "Tags libres contenu récupérés")
## récupérer tous les tags libres d'un auteur associés à un contenu particulier
@jwt_required()
def get(self, id_contenu, auteur):
id_contenu = json.loads(id_contenu)
return ContenuDao().recuperer_tags_libres_contenu(id_contenu["$oid"], auteur), 200
@contenus.route("/associerTagLibre")
@contenus.doc(params={'auteur': "le créateur du tag"})
@contenus.doc(params={'id_contenu': "le contenu à associer du tag"})
@contenus.doc(params={'tag': "Le tag concerné"})
class associer_tag_libre(Resource):
@contenus.response(201, "Tag libre créé")
## associer un tag libre à un contenu
@jwt_required()
def patch(self):
id_contenu = json.loads(request.json["id_contenu"])
ContenuDao().associer_tag_libre(request.json["auteur"], request.json["tag"], id_contenu["$oid"])
return "tag associe", 200
@contenus.route("/dissocierTagLibre")
@contenus.doc(params={'auteur': "le créateur du tag"})
@contenus.doc(params={'id_contenu': "le contenu à dissocier du tag"})
@contenus.doc(params={'tag': "Le tag concerné"})
class dissocier_tag_libre(Resource):
@contenus.response(201, "Tag libre créé")
## dissocier un tag libre d'un contenu
@jwt_required()
def patch(self):
id_contenu = json.loads(request.json["id_contenu"])
ContenuDao().dissocier_tag_libre(request.json["auteur"], request.json["tag"], id_contenu["$oid"])
return "tag dissocié", 200
@contenus.route("/supprimerTagLibre")
@contenus.doc(params={'auteur': "le créateur du tag"})
@contenus.doc(params={'tag': "Le tag à supprimer"})
class supprimer_tag_libre(Resource):
@contenus.response(201, "Tag libre créé")
## supprimer un tag libre
@jwt_required()
def delete(self):
ContenuDao().supprimer_tag_libre(request.args.get("auteur"), request.args.get("tag"))
return "tag supprimé", 200
@contenus.route("/isContenuAnonyme/<id_contenu>")
@contenus.doc(description="le contenu est-il anonyme ?")
class is_contenu_anonyme(Resource):
......@@ -446,6 +579,38 @@ class gerer_maj_tiers(Resource):
return "Tiers géré", 200
## fonction qui permet de renseigner la note d'un contenu
@contenus.route("/noterContenu")
@contenus.doc(params={'auteur': "l'auteur qui met la note"})
@contenus.doc(params={'id_contenu': "l'id du contenu à noter"})
@contenus.doc(params={'version': "la version du contenu concernée par la note "})
@contenus.doc(params={'note': "la note mise (entre 0 et 5)"})
@contenus.doc(description="permet de noter un contenu")
class noter_contenu(Resource):
@contenus.response(200, "contenu noté")
@jwt_required()
def patch(self):
note = request.json["note"]
auteur = request.json["auteur"]
version = request.json["version"]
id_contenu = json.loads(request.json["id_contenu"])
moyenne = ContenuDao().noterContenuTiers(id_contenu["$oid"], version, auteur, note)
return str(moyenne), 200
@contenus.route("/recupererNote")
@contenus.doc(params={'id_contenu': "l'id du contenu déja noté"})
@contenus.doc(params={'version': "la version du contenu concernée par la note "})
@contenus.doc(params={'auteur': "l'auteur de la note"})
class RecupererNoteDonneAUnContenu(Resource):
@contenus.response(200, "note du contenu")
@jwt_required()
def get(self):
id_contenu = json.loads(request.args.get("id_contenu"))
return str(ContenuDao().recupererNoteContenu(id_contenu["$oid"], request.args.get("version"),
request.args.get("auteur"))), 200
## récupérer le texte de la version en cours du contenu
@contenus.route("/getTexteContenu/<id_json>")
@contenus.doc(description="récupérer le texte de la version en cours du contenu")
......
config/utils.py
View file @ f7f17472
......@@ -68,12 +68,12 @@ class Utils:
if maj_contenu:
from modele.contenu_dao import ContenuDao
chemin_fichier = ContenuDao().get_chemin_du_contenu(id_contenu)
ContenuDao().changer_titre(id_contenu, titre)
else:
from modele.encours_dao import EncoursDao
chemin_fichier = EncoursDao().get_chemin_contenu_en_cours(id_contenu)
print("titre : " + titre)
#print("titre : " + titre)
EncoursDao().changer_titre(id_contenu, titre)
myFile = open(chemin_fichier, "w")
# y ajouter le texte du contenu
......
modele/contenu_dao.py
View file @ f7f17472
import json
from bson import ObjectId
from pymongo import MongoClient
......@@ -27,20 +29,21 @@ class ContenuDao:
# @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, contenu_a_ecrire, titre):
def ajouter_contenu(self, auteur, contenu_a_ecrire, titre, tags):
# créer la métadonnée dans la base mongo
self.base_donnees.contenu.insert_one(
{"auteur": auteur, "note": randrange(0, 10, 1),
{"auteur": auteur, "popularite": 0,
"fichier": "", "titre": titre,
"versionEnCours": {"numero": 1, "date": datetime.now().strftime("%d/%m/%y"),
"popularite": 0, "commit": ""},
"tags_banque_fixes": ["tag1", "tag2", "tag3", "tag4", "tag5"],
"tags_banque_libres": ["tagl1", "tagl2", "tagl3", "tagl4", "tagl5"], "type": " ", "source": "markdown"})
"note": 0, "nbreNotes": 0, "commit": ""},
"tags_fixes": tags,
"type": " ", "source": "markdown"})
nom_contenu = self.id_dernier_contenu_ajoute()
chemin_fichier = self.chemin + nom_contenu + "/"
chemin_tags = '/'.join(tags) + "/"
chemin_fichier = self.chemin + chemin_tags + nom_contenu + "/"
Path(chemin_fichier).mkdir(0o777, parents=True, exist_ok=True)
myFile = open(chemin_fichier + nom_contenu, "w")
......@@ -50,7 +53,7 @@ class ContenuDao:
# mettre a jour le chemin du contenu
self.base_donnees.contenu.update_one({"_id": ObjectId(nom_contenu)},
{"$set": {"fichier": nom_contenu + "/" + nom_contenu}})
{"$set": {"fichier": chemin_tags + nom_contenu + "/" + nom_contenu}})
# initialiser le git et récupérer le commit
commit = self.gitUtils.commit(chemin_fichier, nom_contenu, "version" + str(1))
......@@ -66,7 +69,6 @@ class ContenuDao:
global chemin_fichier, filename
if file:
filename = secure_filename(file.filename)
print(filename)
......@@ -75,7 +77,7 @@ class ContenuDao:
Path(chemin_fichier).mkdir(0o777, parents=True, exist_ok=True)
file.save(os.path.join(chemin_fichier, filename))
print (chemin_fichier + filename)
print(chemin_fichier + filename)
xmldoc = minidom.parse(chemin_fichier + filename)
mite = xmldoc.getElementsByTagName('name')
......@@ -83,14 +85,12 @@ class ContenuDao:
# créer la métadonnée dans la base mongo
self.base_donnees.contenu.insert_one(
{"auteur": auteur, "note": randrange(0, 10, 1),
{"auteur": auteur, "popularite": 0,
"fichier": filename + "/" + filename, "titre": titre,
"versionEnCours": {"numero": 1, "date": datetime.now().strftime("%d/%m/%y"),
"popularite": 0, "commit": ""},
"tags_banque_fixes": ["tag1", "tag2", "tag3", "tag4", "tag5"],
"tags_banque_libres": ["tagl1", "tagl2", "tagl3", "tagl4", "tagl5"], "type": "quiz", "source": "moodle"})
print("je suis ici")
"note": 0, "nbreNotes": 0, "commit": ""},
"tags_fixes": ["tag1", "tag2", "tag3", "tag4", "tag5"],
"type": "quiz", "source": "moodle"})
nom_contenu = self.id_dernier_contenu_ajoute()
......@@ -101,6 +101,22 @@ class ContenuDao:
self.base_donnees.contenu.update_one({"_id": ObjectId(nom_contenu)},
{"$set": {"versionEnCours.commit": commit}})
## récupérer la popularité d'une version
# @param id_contenu l'id du contenu
# @param version le numéro de version
def get_popularite(self, id_contenu):
return self.base_donnees.contenu.find_one({"_id": ObjectId(id_contenu)})["popularite"]
## incrémenter la popularité d'un contenu ou d'une de ses versions
# @param id_contenu l'id du contenu
# @param version le numéro de version incrémenté
def incrementer_popularite(self, id_contenu):
popularite = self.get_popularite(id_contenu)
self.base_donnees.contenu.update_one({"_id": ObjectId(id_contenu)},
{"$set": {"popularite": popularite + 1}})
## 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):
......@@ -128,22 +144,32 @@ class ContenuDao:
if tiers:
id_tiers = self.get_contenus_tiers(auteur)
for (id, version) in id_tiers:
contenu_tiers = self.get_contenu_par_id(id["contenu"])
for i in range(len(id_tiers)):
contenu_tiers = self.get_contenu_par_id(id_tiers[i][0]["contenu"])
contenu_tiers["tags_libres"] = self.recuperer_tags_libres_contenu(id_tiers[i][0]["contenu"], auteur)
contenu_tiers["provenance"] = "tiers"
contenu_tiers["version"] = version["version"]
contenu_tiers["version"] = id_tiers[i][1]["version"]
note = self.recupererNoteContenu(id_tiers[i][0]["contenu"], id_tiers[i][1]["version"], auteur)
if note == -1:
contenu_tiers["note_perso"] = "-"
# print("prout caca : " + contenu_tiers["note_perso"])
else:
contenu_tiers["note_perso"] = note
contenus.append(contenu_tiers)
if perso:
curseur_perso = self.get_contenus_persos(auteur)
for contenu in curseur_perso:
contenu["provenance"] = "perso"
contenu["tags_libres"] = self.recuperer_tags_libres_contenu(contenu["_id"], auteur)
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"
contenu["tags_libres"] = self.recuperer_tags_libres_contenu(contenu["_id"], auteur)
# print("tags libres en_cours", contenu["tags_libres"])
contenus.append(contenu)
# on garde le développement de l'évaliation pour plus tard
# return contenus_persos + contenus_en_cours + contenus_tiers
......@@ -174,6 +200,7 @@ class ContenuDao:
self.base_donnees.utilisateur.update({"nom": auteur}, {
"$push": {
"tiers": [{"contenu": ObjectId(id_contenu)}, {"version": version}]}})
self.incrementer_popularite(id_contenu)
## FOnction permettant de récupérer les contenus persos d'un auteur
# @param auteur l'auteur en question
......@@ -203,11 +230,22 @@ class ContenuDao:
# @param id_tiers l'id du tiers à supprimer
# @param auteur l'auteur concerné
# @param version la version du tiers à supprimer
def supprimer_tiers(self, id_tiers, auteur, version):
# @param la note associee au contenu
def supprimer_tiers(self, id_tiers, auteur, version, note):
self.base_donnees.utilisateur.update({"nom": auteur},
{"$pull": {
"tiers": [{"contenu": ObjectId(id_tiers)}, {"version": version}]}})
# on distingue le cas ou une note a été donnée ou non
if note == "-":
self.base_donnees.utilisateur.update({"nom": auteur},
{"$pull": {
"tiers": [{"contenu": ObjectId(id_tiers)}, {"version": version}]}})
else:
self.base_donnees.utilisateur.update({"nom": auteur},
{"$pull": {
"tiers": [{"contenu": ObjectId(id_tiers)}, {"version": version},
{"note": int(note)}]
}})
# si le contenu n'est plus possédé par personne, on le supprime définitivement
if self.is_anonyme(id_tiers) and self.existe_en_tiers(id_tiers) == 0:
self.supprimer_contenu(id_tiers)
......@@ -233,7 +271,7 @@ class ContenuDao:
contenu_a_ecrire = Utils().recuperer_contenu_fichier(id_contenu_en_cours, True)
# on utilise la fonction déja existante pour créer le contenu
self.ajouter_contenu(auteur_en_cours, contenu_a_ecrire)
self.ajouter_contenu(auteur_en_cours, contenu_a_ecrire, "", [])
# et on détruit la demande de publication et le contenu en cours associé, pour finir
DemandePubDao().supprimer_publication(id_demande_publication)
......@@ -302,7 +340,8 @@ class ContenuDao:
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,
"$set": {"versionEnCours": {"numero": version, "date": datetime.now().strftime("%d/%m/%y"), "note": 0,
"nbreNotes": 0,
"commit": ""}}})
# Si un auteur est passé en paramètres de la fonction maj = on l'ajoute dans les métadonnées
......@@ -315,6 +354,9 @@ class ContenuDao:
nouveau_texte = Utils().recuperer_contenu_fichier(id_contenu_en_cours, True)
titre_en_cours = EncoursDao().get_titre_en_cours(id_contenu_en_cours)
# print ("Titre en cours " + titre_en_cours)
Utils().changer_texte_fichier(id_contenu, nouveau_texte, titre_en_cours, True)
## on supprime le contenu en cours
......@@ -411,9 +453,9 @@ class ContenuDao:
# 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:
for i in range(len(tiers)):
versionCourante = self.get_version_courante(tiers[i][0]["contenu"])
if tiers[i][1]["version"] < versionCourante:
return True
return False
......@@ -425,10 +467,10 @@ class ContenuDao:
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.append(self.get_contenu_par_id(id["contenu"]))
for i in range(len(tiers)):
versionCourante = self.get_version_courante(tiers[i][0]["contenu"])
if tiers[i][1]["version"] < versionCourante:
liste.append(self.get_contenu_par_id(tiers[i][0]["contenu"]))
return liste
......@@ -451,4 +493,173 @@ class ContenuDao:
# @param id_contenu l'id du contenu concerné
# @return les tags associés au contenu
def get_tags_contenu(self, id_contenu):
return self.base_donnees.contenu.find({"_id": ObjectId(id_contenu)})["tags_banque_fixes"]
return self.base_donnees.contenu.find({"_id": ObjectId(id_contenu)})["tags_fixes"]
## Mise à jour des tags associés au contenu
# @param id_contenu l'id du contenu concerné
# @param tags les nouveaux tags
def changer_tags_contenus(self, id_contenu, tags):
# on modifie les tags
self.base_donnees.contenu.update({"_id": ObjectId(id_contenu)}, {"$set": {"tags_fixes": tags}})
# et le chemin du fichier
chemin_tags = '/'.join(tags) + "/"
# mettre a jour le chemin du contenu
self.base_donnees.contenu.update_one({"_id": ObjectId(id_contenu)},
{"$set": {"fichier": chemin_tags + id_contenu + "/" + id_contenu}})
## Modification d'un titre d'un contenu personnel
# @param id_en_cours l'id du contenu
# @param nouveau_titre le titre à changer
def changer_titre(self, id_en_cours, nouveau_titre):
self.base_donnees.contenu.update_one({"_id": ObjectId(id_en_cours)}, {"$set": {"titre": nouveau_titre}})
## Fonction permettant de créer un tag libre et de l'associer ou non à un contenu
# @param auteur l'auteur du nouveau tag
# @param tag le tag créé
# @param id_contenu l'id du contenu associé (potentiellement vide)
def creer_tag_libre(self, auteur, tag, id_contenu):
contenus = list()
if id_contenu != "":
contenus.append(ObjectId(id_contenu))
self.base_donnees.utilisateur.update({"nom": auteur}, {
"$push": {
"tags": [{"tag": tag}, {"contenu": contenus}]}})
## Fonction permettant de supprimer un tag libre
# @param auteur l'auteur du nouveau tag
# @param tag le tag a supprimer
# @param id_contenu l'id du contenu associé (potentiellement vide)
def supprimer_tag_libre(self, auteur, mon_tag):
# on récupère les tags
tags = self.base_donnees.utilisateur.find_one({"nom": auteur})["tags"]
# on "vide" les tags (qu'on réinjectera)
self.base_donnees.utilisateur.update({"nom": auteur}, {"$set": {"tags": []}})
for tag in tags:
if tag[0]['tag'] == mon_tag:
tags.remove(tag)
self.base_donnees.utilisateur.update({"nom": auteur}, {"$set": {"tags": tags}})
## Fonction permettant de dissocier un contenu d'un tag libre
# @param auteur l'auteur du nouveau tag
# @param tag le tag concerné
# @param id_contenu l'id du contenu à dissocier
def dissocier_tag_libre(self, auteur, mon_tag, id_contenu):
# on récupère les tags
tags = self.base_donnees.utilisateur.find_one({"nom": auteur})["tags"]
# on "vide" les tags (qu'on réinjectera)
self.base_donnees.utilisateur.update({"nom": auteur}, {"$set": {"tags": []}})
# on parcourt chaque tag et on vire les mentions à id_contenu
for tag in tags:
if tag[0]['tag'] == mon_tag:
tag[1]['contenu'].remove(ObjectId(id_contenu))
self.base_donnees.utilisateur.update({"nom": auteur}, {"$set": {"tags": tags}})
## Fonction permettant d'associer un contenu à un tag libre
# @param auteur l'auteur du nouveau tag
# @param tag le tag concerné
# @param id_contenu l'id du contenu à associer au tag
def associer_tag_libre(self, auteur, tag, id_contenu):
# on récupère les tags
tags = self.base_donnees.utilisateur.find_one({"nom": auteur})["tags"]
# on "vide" les tags (qu'on réinjectera)
self.base_donnees.utilisateur.update({"nom": auteur}, {"$set": {"tags": []}})
# on parcourt chaque tag et on vire les mentions à id_contenu
for letag in tags:
if letag[0]['tag'] == tag:
letag[1]['contenu'].append(ObjectId(id_contenu))
# print(letag[1]['contenu'], type(letag[1]['contenu']))
# for contenu_associe in letag[1]:
# print(contenu_associe)
self.base_donnees.utilisateur.update({"nom": auteur}, {"$set": {"tags": tags}})
# self.base_donnees.utilisateur.update({"nom": auteur}, {
# "$pull": {
# "tags": [{"tag": tag}, {"contenu": ObjectId(id_contenu)}]}})
## Fonction permettant de récupérer tous les tags libres d'un auteur
# @param auteur l'auteur du nouveau tag
# @return les tags libres de l'auteur
def recuperer_all_tags_libres(self, auteur):
tags = self.base_donnees.utilisateur.find_one({"nom": auteur})["tags"]
tags_auteur = list()
for f in tags:
tags_auteur.append(f[0]['tag'])
return tags_auteur
# recuperer_tags_libres_contenu
## Fonction permettant de récupérer les tags libres d'un auteur associés à un contenu en particulier
# @param auteur l'auteur du nouveau tag
# @param id_contenu le contenu associé
# @return les tags libres de l'auteur
def recuperer_tags_libres_contenu(self, id_contenu, auteur):
tags = self.base_donnees.utilisateur.find_one({"nom": auteur})["tags"]
tags_auteur = list()
for f in tags:
for cont in f[1]['contenu']:
if cont == ObjectId(id_contenu):
tags_auteur.append(f[0]['tag'])
return tags_auteur
## Fonction permettant de noter un contenu (pour une version donnée)
# @param id_contenu l'id du contenu concerné
# @param version la version du contenu notée
# @param auteur l'auteur qui met la note
# @param note la note affectée au contenu
def noterContenuTiers(self, id_contenu, version, auteur, note):
# on vire le précédent
self.base_donnees.utilisateur.update({"nom": auteur},
{"$pull": {
"tiers": [{"contenu": ObjectId(id_contenu)},
{"version": version}]}})
# et on ajoute la version maj
self.base_donnees.utilisateur.update({"nom": auteur},
{"$push": {
"tiers": [{"contenu": ObjectId(id_contenu)},
{"version": version},
{"note": note}]}})
# et on modifie le contenu de base (sa moyenne)
return self.modifierMoyenneContenu(id_contenu, version, note)
## Fonction permettant de récupérer une note donnée
# @param id_contenu l'id du contenu concerné
# @param version la version du contenu notée
# @param auteur l'auteur qui met la note
def recupererNoteContenu(self, id_contenu, version, auteur):
contenus_tiers = self.base_donnees.utilisateur.find_one({"nom": auteur})["tiers"]
for contenu in contenus_tiers:
if len(contenu) == 3 and contenu[0]["contenu"] == id_contenu and contenu[1]["version"] == version:
return json.dumps(contenu[2]["note"])
return -1
## Fonction permettant de changer la moyenne d'une version d'un contenu à l'insertion d'une nouvelle note
# @param id_contenu l'id du contenu concerné
# @param version la version du contenu notée
# @param note la note affectée au contenu
def modifierMoyenneContenu(self, id_contenu, version, note):
if version == self.get_version_courante(id_contenu):
versionEnCours = self.base_donnees.contenu.find_one({"_id": ObjectId(id_contenu)})["versionEnCours"]
self.base_donnees.contenu.update({"_id": ObjectId(id_contenu)}, {"$set": {"versionEnCours": []}})
versionEnCours['note'] = versionEnCours['note'] + note
versionEnCours['nbreNotes'] = versionEnCours['nbreNotes'] + 1
self.base_donnees.contenu.update({"_id": ObjectId(id_contenu)},
{"$set": {"versionEnCours": versionEnCours}})
return json.dumps([versionEnCours['note'], versionEnCours['nbreNotes']])
else:
print("Non, là")
contenus = self.base_donnees.contenu.find_one({"_id": ObjectId(id_contenu)})["historique"]
self.base_donnees.contenu.update({"_id": ObjectId(id_contenu)}, {"$set": {"historique": []}})
for cont in contenus:
if cont['numero'] == version:
cont['note'] = cont['note'] + note
cont['nbreNotes'] = cont['nbreNotes'] + 1
self.base_donnees.contenu.update({"_id": ObjectId(id_contenu)}, {"$set": {"historique": contenus}})
return json.dumps([cont['note'], cont['nbreNotes']])
modele/encours_dao.py
View file @ f7f17472
......@@ -104,7 +104,7 @@ class EncoursDao:
# @param id_en_cours l'id du contenu en cours
# @param nouveau_titre le titre à changer
def changer_titre(self, id_en_cours, nouveau_titre):
print("Je suis ici : " + nouveau_titre)
# print("Je suis ici : " + nouveau_titre)
self.base_donnees.encours.update_one({"_id": ObjectId(id_en_cours)}, {"$set": {"titre": nouveau_titre}})
## Récupération d'un titre d'un contenu en cours
......
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