class AuthorDB(db.Model): """ Un auteur est une personne physique qui a écrit un livre ou qui a participé à l'élaboration du contenu d'un ouvrage. On pourrait rajouter comme informations : - commentaire - lien vers une page Wikipédia, par exemple - """ __tablename__ = "Author" __table_args__ = {'sqlite_autoincrement': True} id = db.Column(db.Integer, primary_key=True, autoincrement=True) first_name = db.Column(db.String(50)) family_name = db.Column(db.String(50)) valide = db.Column(db.Boolean, default=False) reference_biblio_livres = db.relationship("ReferenceBibliographiqueLivreDB", secondary=HelperAuthorBook, back_populates="authors") def __str__(self): return f"{self.first_name} {self.family_name}" def afficher_tooltip(self): return "Prénom : {}\nNom : {}".format(self.first_name, self.family_name) def export_to_prettify_line(self): return "{} ({})".format(self.family_name, self.first_name) def export_to_csv_line(self): return self.export_to_prettify_line()
class ReferenceBibliographiqueLivreDB(db.Model): """ Un livre est caractérisé par - un ou plusieurs auteurs - un titre - un lieu d'édition - éditeur ou par défaut un imprimeur - nombre de pages On parle vraiment de ce qui est propre à un livre. """ __tablename__ = "ReferenceBibliographiqueLivre" __table_args__ = {'sqlite_autoincrement': True} id = db.Column(db.Integer, primary_key=True, autoincrement=True) authors = db.relationship(AuthorDB, secondary=HelperAuthorBook, back_populates="reference_biblio_livres") # id_author = db.Column(db.Integer, db.ForeignKey('author.id')) # author = db.relationship(AuthorDB) titre = db.Column(db.String(200), nullable=False) lieu_edition = db.Column(db.String(100), default="s.l.") editeur = db.Column(db.String(50), default="s.n.") annee = db.Column(db.String(10)) nb_page = db.Column(db.String(10)) valide = db.Column(db.Boolean, default=False) description = db.Column(db.String(500), default="") def __str__(self): return " ".join([auteur.__str__() for auteur in self.authors]) + \ " " + self.titre + " " + self.lieu_edition + " " + self.editeur + " " + str(self.annee) + " " + \ self.nb_page def afficher_tooltip(self): """ Quand on survole une référence bibliographique, on affiche ces informations. :return: """ return "{}\nTitre : {}\nLieu d'édition : {}\nEditeur : {}\nAnnée : {}\nNombre de pages : {}".format( " ".join([auteur.afficher_tooltip() for auteur in self.authors.all()]), self.titre, self.lieu_edition, self.editeur, str(self.annee), self.nb_page) def export_to_csv_line(self): """ Exportation du contenu de la base en une forme lisible sous la forme d'une ligne CSV. :return: str """ return "\t".join([", ".join([auteur.export_to_csv_line() for auteur in self.authors.all()]), self.titre, self.lieu_edition, self.editeur, str(self.annee), self.nb_page, self.description.__str__()]) @staticmethod def get_csv_fieldnames(): """ Les champs d'une ligne CSV. :return: """ return "\t".join(["Auteur", "Titre", "Lieu d'édition", "Editeur", "Année d'édition", "N° de pages", "Description"])
class EmpruntLivreDB(db.Model): """ L'emprunt d'un livre est fait par un emprunteur. Un gestionnaire supervise un emprunt. Le livre emprunté est soigneusement noté. Il y a une date de retour du livre prévu. Et on note quand il revient. """ __tablename__ = "EmpruntLivre" __table_args__ = {'sqlite_autoincrement': True} id = db.Column(db.Integer, primary_key=True, autoincrement=True) id_emprunteur = db.Column(db.Integer, db.ForeignKey('User.id')) emprunteur = db.relationship(UserDB, primaryjoin=id_emprunteur == UserDB.id) # , related_name="emprunteur", on_delete=models.SET_NULL, null=True) id_enregistrement = db.Column(db.Integer, db.ForeignKey('Enregistrement.id')) enregistrement = db.relationship(EnregistrementDB, primaryjoin=id_enregistrement == EnregistrementDB.id) # , on_delete=models.SET_NULL, null=True) id_gestionnaire = db.Column(db.Integer, db.ForeignKey('User.id')) gestionnaire = db.relationship(UserDB, primaryjoin=id_gestionnaire == UserDB.id) # , related_name="gestionnaire", on_delete=models.SET_NULL, null=True) commentaire = db.Column(db.String()) emprunte = db.Column(db.Boolean, default=True) date_emprunt = db.Column(db.Date, default=datetime.datetime.now()) date_retour_prevu = db.Column(db.Date) date_retour_reel = db.Column(db.Date) rendu = db.Column(db.Boolean)
class UserDB(db.Model): """ Un utilisateur est quelqu'un qui peut se connecter à l'interface web. Un gestionnaire est un resp Un bibliothécaire est une personne auqui est responsable des collections Un éditeur est une personne qui peut exporter les données dans un format utilisable. """ __tablename__ = "User" __table_args__ = {'sqlite_autoincrement': True} id = db.Column(db.Integer, primary_key=True, nullable=False, autoincrement=True) first_name = db.Column(db.String(50)) family_name = db.Column(db.String(50)) right = db.Column(db.Enum(UserRight)) date_inscription = db.Column(db.DateTime, nullable=False) email = db.Column(db.String(120), unique=True, nullable=False) # mdp = db.Column(db.String(80), unique=False, nullable=False) mdp_hash = db.Column(db.String(128), unique=False, nullable=False) confirmed = db.Column(db.Boolean, default=False) confirmed_on = db.Column(db.DateTime, nullable=True, default=None) is_admin = db.Column(db.Boolean, nullable=True, default=False) link_to_validate = db.Column(db.String(64), nullable=True, default="") def get_id(self): return self.id def set_password(self, password): self.mdp_hash = generate_password_hash(password) def set_confirmed(self, confirmed): self.confirmed = confirmed def set_confirmed_on(self, confirmed_on): self.confirmed_on = confirmed_on def verify_password(self, password): return check_password_hash(self.mdp_hash, password) def get_right(self): return self.right @staticmethod def register(email, password): user = UserDB(email=email) user.set_password(password) db.session.add(user) db.session.commit() return user @classmethod def authenticate(cls, **kwargs): email = kwargs.get("email") password = kwargs.get("password") if not email: print("identification a échoué") message = "L'adresse email ou le mot de passe est incorrect." return None, message user = cls.query.filter_by(email=email).first() if not password: message = "Aucun mot de passe." return None, message if not user: message = "L'adresse email est inconnue." return None, message if not user.verify_password(password): print("mauvais mot de passe") message = "L'adresse email ou le mot de passe est incorrect." return None, message if not user.confirmed: print("utilisateur non confirmé") message = "L'utilisateur n'est pas confirmé." return None, message return user, "" def is_active(self): return True def is_anonymous(self): return False def is_authenticated(self): return True def __repr__(self): return '<User {0}>'.format(self.email) def generate_confirmation_token(self, expiration=3600): s = TimedJSONWebSignatureSerializer(current_app.config["SECRET_KEY"], expiration) return s.dumps({"confirm": self.id}).decode("utf-8") def confirm(self, token): s = TimedJSONWebSignatureSerializer(current_app.config["SECRET_KEY"]) try: data = s.loads(token.encode('utf-8')) except: return False if data.get('confirm') != self.id: return False self.confirmed = True self.confirmed_on = datetime.datetime.utcnow() db.session.add(self) return True
class EnregistrementDB(db.Model): """ Enregistrement tel que décrit dans le fichier principal qui est l'inventaire. C'est pour repérer un livre dans la bibliothèque. Les renseignements nécessaires sont : - description, qui est la référence bibliographique du livre - la côte du livre dans la bibliothèque - l'année d'obtention du livre - le nombre d'exemplaires de livres possédés - la provenance du livre (par un don, un achat, etc) - un champ texte contenant des mots-clef - la date de modification de la fiche - est-ce une fiche validée par le gestionnaire de la bibliothèque ? Si oui, alors la fiche est consultable par un utilisateur, si non, cela ne pourra pas être lu. #TODO Doit-on conserver toutes les versions des fiches ? Je crois que non, on conservera régulièrement des copies de la base de données. """ __tablename__ = "Enregistrement" __table_args__ = {'sqlite_autoincrement': True} id = db.Column(db.Integer, primary_key=True, autoincrement=True) # description = models.CharField(max_length=1000, verbose_name="description", null=True, default="") id_reference = db.Column(db.Integer, db.ForeignKey('ReferenceBibliographiqueLivre.id')) reference = db.relationship(ReferenceBibliographiqueLivreDB) # , on_delete=models.CASCADE) commentaire = db.Column(db.String(500), default="") cote = db.Column(db.String(100), nullable=True, default="") # annee = models.IntegerField(verbose_name="année", null=True, default=2018) annee = db.Column(db.String(20), nullable=True, default="") # nb_exemplaire_supp = models.IntegerField(verbose_name="Nombre d'exemplaires supplémantaires", # null=True, default=0) nb_exemplaire_supp = db.Column(db.String(50), nullable=True, default=0) provenance = db.Column(db.String(100), nullable=True, default="") mots_clef = db.Column(db.String(100), nullable=True, default="") # models.ForeignKey(to=Theme, on_delete=models.SET_NULL, null=True) # dernier_modifieur = models.ForeignKey(to=Compte, null=True, on_delete=models.SET_NULL) date_modification = db.Column(db.DateTime, default=datetime.datetime.utcnow, nullable=True) # proprietaire = models.ForeignKey(to=Compte, on_delete=models.SET_NULL) valide = db.Column(db.Boolean, default=False) row = db.Column(db.String(500), default="") def __str__(self): return self.cote + " " + self.annee + self.nb_exemplaire_supp + \ self.provenance + " " + self.mots_clef def afficher_tooltip(self): return """Cote : {}\nAnnée : {}\nNombre d'exemplaires : {}\nProvenance : {}""".format( self.cote, self.annee, self.nb_exemplaire_supp, self.provenance) def export_to_csv_line(self): line = [self.cote, self.annee, self.nb_exemplaire_supp, self.provenance, self.mots_clef, self.row] return "\t".join(line) @staticmethod def get_csv_fieldnames(): return "\t".join( [ReferenceBibliographiqueLivreDB.get_csv_fieldnames(), "Cote", "Année", "N° d'exemplaires", "Provenance", "Mots-clef", "Ligne"])
""" """ import datetime from sat_biblio_server.database.db_manager import db from sat_biblio_server.database.users import UserDB __author__ = ["Clément Besnier <*****@*****.**>"] HelperAuthorBook = db.Table('helperauthorbook', db.Column("id_author", db.Integer, db.ForeignKey("Author.id")), db.Column("id_reference_biblio_livre", db.Integer, db.ForeignKey("ReferenceBibliographiqueLivre.id")) ) # HelperAuthorArticle = db.Table('helperauthorarticle', # db.Column("id_author", db.Integer, db.ForeignKey("author.id"), primary_key=True), # db.Column("id_reference_biblio_article", db.Integer, # db.ForeignKey("reference_biblio_article.id"), primary_key=True) # ) class AuthorDB(db.Model): """ Un auteur est une personne physique qui a écrit un livre ou qui a participé à l'élaboration du contenu d'un ouvrage. On pourrait rajouter comme informations : - commentaire - lien vers une page Wikipédia, par exemple -