Merge branch 'master' into dev_accueil

README.md

@@ -1 +1,5 @@
-# TNAHBox
+# TNAHBox
+
+
+
+La présente application, nommé TNAH BOX, a été créé par Caroline Méot, Ségolène Albouy, Lemosquet Lauryne, Marie Morillon, Victoria Le Fourner

Tables_BDD.sql

@@ -10,7 +10,9 @@ person_password TEXT NULL,
 person_linkedIn TEXT NULL,
 person_cv TEXT NULL,
 person_git TEXT NULL,
-person_is_admin INTEGER NULL
+person_is_admin INTEGER NULL,
+person_last_seen TEXT NULL,
+person_description TEXT NULL
 );
 
 CREATE TABLE IF NOT EXISTS Document (
@@ -47,4 +49,14 @@ FOREIGN KEY (hasTag_tag_id) REFERENCES Tag(tag_id)
 ON DELETE CASCADE ON UPDATE CASCADE,
 FOREIGN KEY (hasTag_doc_id) REFERENCES Document(document_id)
 ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS IsFav (
+faved_docu_id,
+loving_user_id,
+PRIMARY KEY (faved_docu_id, loving_user_id),
+FOREIGN KEY (faved_docu_id) REFERENCES Document(document_id)
+ON DELETE CASCADE ON UPDATE CASCADE,
+FOREIGN KEY (loving_user_id) REFERENCES Person(person_id)
+ON DELETE CASCADE ON UPDATE CASCADE
 );

Values_BDD.sql

@@ -4,23 +4,23 @@ person_name, person_firstname, person_is_teacher, person_promotion)
 -- person_login, person_password, person_linkedIn,
 -- person_cv, person_git, person_is_admin
 VALUES
-("Pinche","Ariane", 1, "2013-2014"),
+("Pinche","Ariane", 1, "2014"),
 ("Jolivet","Vincent", 1, ""),
-("Clérice","Thibault", 1, "2013-2014"),
-("Andrieux","Clément", 0, "2018-2019"),
-("Schmied","Marie-Caroline", 0, "2018-2019"),
+("Clérice","Thibault", 1, "2014"),
+("Andrieux","Clément", 0, "2019"),
+("Schmied","Marie-Caroline", 0, "2019"),
 ("","Tony", 0, "");
 
 INSERT INTO Document(
 document_title, document_format, document_teaching, document_date, document_description)
 -- document_downloadLink
 VALUES
-("doc1","pdf","XML TEI","2018-11-23","Présentation des TEI Guidelines"),
-("doc2","jpg","SQL","2018-12-12","Tuto MySQL Workbench"),
-("doc3","odt","Python","2019-03-01","Correction du devoir sur table"),
-("doc4","txt","XML EAD","2019-01","Retroconvertion de l'instrument de recherche du fonds Emile Portzer"),
-("doc5","img","CMS","2018","Schéma d'un CMS comme Omeka"),
-("doc6","code","LaTeX","2018-11-13","Template de présentation du mémoire de M2");
+("doc1","Autre","XML TEI","2018-11-23","Présentation des TEI Guidelines"),
+("doc2","Texte","SQL","2018-12-12","Tuto MySQL Workbench"),
+("doc3","Code","Python","2019-03-01","Correction du devoir sur table"),
+("doc4","Texte","XML EAD","2019-01","Retroconvertion de l'instrument de recherche du fonds Emile Portzer"),
+("doc5","Image","CMS","2018","Schéma d'un CMS comme Omeka"),
+("doc6","Code","LaTeX","2018-11-13","Template de présentation du mémoire de M2");
 
 INSERT INTO Authorship(
 authorship_person_id, authorship_document_id)

app/app.py

@@ -11,6 +11,8 @@
 # on stocke le chemin vers les templates
 statics = os.path.join(chemin_actuel, "static")
 # on stocke le chemin vers les statics
+uploads = os.path.join(chemin_actuel, "uploads")
+# on stocke le chemin vers le dossier où stocker les fichiers uploadés
 
 db = SQLAlchemy()
 # on initie l'objet SQLAlchemy
@@ -22,7 +24,7 @@
     __name__,
     template_folder=templates,
     static_folder=statics
-)
+    )
 # on initie l'app où le nom __name__ sera précisé dans la configuration (config_app())
 # et on définit les dossiers contenants les templates et les statics
 

app/constantes.py

@@ -3,7 +3,8 @@
 # Déclaration de toutes les constantes à utiliser dans le projet
 # Convention : les constantes portent des noms en majuscule
 
-RESULTS_PER_PAGE = 10
+RESULTS_PER_PAGE = 9
+DOSSIER_UPLOAD = "./app/static/uploads/"
 
 SECRET_KEY = "JE SUIS UN SECRET !"
 # variable nécessaire à la création d'applications Flask

app/modeles/donnees.py

@@ -3,13 +3,18 @@
 from flask_login import UserMixin
 import datetime
 from werkzeug.security import generate_password_hash, check_password_hash
+from datetime import date
 
 from .. app import db
 
 HasTag = db.Table('HasTag',
     db.Column('hasTag_doc_id', db.Integer, db.ForeignKey('Document.document_id'), primary_key=True),
     db.Column('hasTag_tag_id', db.Integer, db.ForeignKey('Tag.tag_id'), primary_key=True))
 
+IsFav = db.Table('IsFav',
+    db.Column('faved_docu_id', db.Integer, db.ForeignKey('Document.document_id'), primary_key=True),
+    db.Column('loving_user_id', db.Integer, db.ForeignKey('Person.person_id'), primary_key=True))
+
 Authorship = db.Table('Authorship',
     db.Column('authorship_person_id', db.Integer, db.ForeignKey('Person.person_id'), primary_key=True),
     db.Column('authorship_document_id', db.Integer, db.ForeignKey('Document.document_id'), primary_key=True),
@@ -26,13 +31,163 @@ class Document(db.Model):
     document_downloadLink = db.Column(db.Text)
     document_tag = db.relationship("Tag",
                     secondary=HasTag,
+                    backref=db.backref("Document", lazy='dynamic'))
+    loving_users = db.relationship("Person",
+                    secondary=IsFav,
                     backref=db.backref("Document"))
 
+    def get_id(self):
+        return(self.document_id)
+
+
+    @staticmethod
+    def add_doc(title, description, format, date, matiere, downloadlink):
+        """
+        Fonction qui permet d'ajouter un nouveau document dans la BDD
+        :param title: titre donné au document (str)
+        :param description: courte présentation sur le doc (str)
+        :param format: "image", "texte", "code" ou "autre" (str)
+        :param date: date du cours rentrée par utilisateur (str)
+        :param matiere: matière de l'enseignement (str)
+        :param downloadLink: lien de téléchargement du document (str)
+        :return:
+        """
+        erreurs = []
+        if not title:
+            erreurs.append("Veuillez renseigner un titre pour ce document.")
+        if not description:
+            erreurs.append("Veuillez renseigner une description pour ce document.")
+        if not format:
+            erreurs.append("Veuillez renseigner un format pour ce document.")
+        if not date:
+            erreurs.append("Veuillez renseigner une date pour ce document.")
+        if not matiere:
+            erreurs.append("Veuillez renseigner une matière pour ce document.")
+        if not downloadlink:
+             erreurs.append("Aucun lien de téléchargement pour ce document.")
+
+        docu = Document(document_title=title,
+                        document_description=description,
+                        document_format=format,
+                        document_date=date,
+                        document_teaching=matiere,
+                        document_downloadLink=downloadlink)
+        # on ajoute une nouvelle entrée dans la table document avec les champs correspondant aux paramètres du modèle
+
+        try:
+            # On essaie d'ajouter le document à la BDD
+            db.session.add(docu)
+            db.session.commit()
+
+            return docu
+        except Exception as erreur:
+            return False, [str(erreur)]
+
+
+    @staticmethod
+    def associate_docu_and_user(user, docu):
+        '''
+        Fonction qui permet d'asssocier un user à un document et
+        de créer un nouvel enregistrement dans Authorship
+        :param user: auteur du document (entrée de la BDD)
+        :param docu: document importé par l'utilisateur (entrée de la BDD)
+        :return: renvoie une liste d'erreurs s'il y en a
+        '''
+        erreurs = []
+        if not user:
+            erreurs.append("Il n'y a pas d'utilisateur à associer")
+        if not docu:
+            erreurs.append("Il n'y a pas de document à associer")
+
+        if user is None or docu is None:
+            return
+
+        if docu not in user.created_document:
+            # si le document n'est pas dans la liste de document créés par cet utilisateur
+            user.created_document.append(docu)
+
+        db.session.add(user)
+        db.session.commit()
+
+
 class Tag(db.Model):
     __tablename__ = "Tag"
     tag_id = db.Column(db.Integer, unique=True, nullable=False, primary_key=True, autoincrement=True)
     tag_label = db.Column(db.String, nullable=False)
 
+    def __repr__(self):
+        return '{}'.format(self.tag_label)
+
+    def get_id(self):
+        return(self.tag_id)
+
+    @staticmethod
+    def add_tag(label):
+        '''
+        Fonction qui permet d'ajouter un tag dans la BDD
+        :param label: label du tag à ajoute (str)
+        :return: renvoie le tag nouvellement créé dans la BDD
+        '''
+        erreurs = []
+        if not label:
+            erreurs.append("Le tag fourni est vide")
+
+        all_tag_labels = Tag.query.with_entities(Tag.tag_label)
+        all_tag_labels = [tlbl[0] for tlbl in all_tag_labels.all()]
+        # je récupère tous les enregistrements de tag_label dans la table Tag
+
+        if label:
+            if label not in all_tag_labels:
+                tag = Tag(tag_label=label)
+                # si mon tag n'est pas déjà dans la table tag
+                # je crée un nouvel enregistrement
+                # On essaie d'ajouter et de commit ce nouvel enregistrement
+                db.session.add(tag)
+                db.session.commit()
+            else: # si j'ai déjà un tag déjà ainsi nommé
+                tag = Tag.query.filter(Tag.tag_label == label).first()
+                # j'assigne à tag, la valeur de l'enregistrement dont le label
+                # correspond bien à celui renseigné en paramètre
+
+        try:
+            return tag
+        except Exception as erreur:
+            return False, [str(erreur)]
+
+    @staticmethod
+    def associate_tag_and_docu(tag_id, docu_id):
+        '''
+        Fonction qui permet d'associer un tag à un document
+        :param tag_id: identifiant du tag à ajouter au document (int)
+        :param docu_id: identifiant du document auquel ajouter le tag (int)
+        :return: renvoie une liste d'erreurs s'il y en a
+        '''
+        erreurs = []
+        if not tag_id:
+            erreurs.append("Il n'y a pas de tag à associer")
+        if not docu_id:
+            erreurs.append("Il n'y a pas de document à associer")
+
+        tag = Tag.query.filter(Tag.tag_id == tag_id).first()
+        # je récupère le tag correspondant à l'id
+        doc = Document.query.filter(Document.document_id == docu_id).first()
+        # idem pour le document
+
+        if tag is None or doc is None:
+            # si les identifiants ne correspondent à rien, je ne fais rien
+            return
+
+        if tag not in doc.document_tag:
+            # si le tag n'est pas déjà dans la liste de tag contenu dans document_tag
+            doc.document_tag.append(tag)
+            # je l'ajoute à cette liste
+
+        db.session.add(doc)
+        db.session.commit()
+
+        return erreurs
+
+
 class Person(UserMixin, db.Model):
     __tablename__ = "Person"
     person_id = db.Column(db.Integer, unique=True, nullable=False, primary_key=True, autoincrement=True)
@@ -42,14 +197,73 @@ class Person(UserMixin, db.Model):
     person_email = db.Column(db.Text, nullable=False)
     person_login = db.Column(db.Text,unique=True, nullable=False)
     person_password = db.Column(db.Text, unique=True, nullable=False)
-    person_linkedIn = db.Column(db.Text,unique=True)
+    person_linkedIn = db.Column(db.Text, unique=True)
     person_cv = db.Column(db.Text)
     person_git = db.Column(db.Text, unique=True)
     person_promotion = db.Column(db.Text)
     person_is_admin = db.Column(db.Boolean)
+    person_last_seen = db.Column(db.Text, default=date)
+    person_description = db.Column(db.Text)
     created_document = db.relationship("Document",
                     secondary=Authorship,
-                    backref=db.backref("Person"))
+                    backref=db.backref("Person")) #, lazy='dynamic'))
+
+    @staticmethod
+    def add_docu_to_favorites(user, docu):
+        '''
+        Fonction qui permet d'ajouter aux favoris de l'utilisateur
+        le document courant
+        :param user: auteur du document (entrée de la BDD)
+        :param docu: document importé par l'utilisateur (entrée de la BDD)
+        :return: liste d'erreurs d'il y en a
+        '''
+        erreurs = []
+        if not user:
+            erreurs.append("Il n'y a pas d'utilisateur à associer")
+        if not docu:
+            erreurs.append("Il n'y a pas de document à associer")
+
+        if user is None or docu is None:
+            # si les paramètres renseignés ne correspondent à rien, je ne fais rien
+            return
+
+        if user not in docu.loving_users:
+            # si le document n'est pas déjà dans la liste des documents favoris de l'utilisateur
+            docu.loving_users.append(user)
+            # je l'ajoute à cette liste
+
+        db.session.add(docu)
+        db.session.commit()
+
+        return erreurs
+
+    def remove_docu_to_favorites(user, docu):
+        '''
+        Fonction qui permet d'enlever aux favoris de l'utilisateur
+        le document courant
+        :param user: auteur du document (entrée de la BDD)
+        :param docu: document importé par l'utilisateur (entrée de la BDD)
+        :return: liste d'erreurs d'il y en a
+        '''
+        erreurs = []
+        if not user:
+            erreurs.append("Il n'y a pas d'utilisateur à dissocier")
+        if not docu:
+            erreurs.append("Il n'y a pas de document à dissocier")
+
+        if user is None or docu is None:
+            # si les paramètres renseignés ne correspondent à rien, je ne fais rien
+            return
+
+        if user in docu.loving_users:
+            # si le document est déjà dans la liste des documents favoris de l'utilisateur
+            docu.loving_users.remove(user)
+            # je le supprime de cette liste
+
+        db.session.add(docu)
+        db.session.commit()
+
+        return erreurs
 
     def __repr__(self):
         return '<User {}>'.format(self.person_login)