class Copy(db.Model):
id = db.Column(db.Integer, primary_key=True)
asset_code = db.Column(db.String(8), unique=True)
library_item_id = db.Column(db.Integer,
db.ForeignKey('library_item.id'),
nullable=False)
library_item = db.relationship('LibraryItem',
foreign_keys=library_item_id,
uselist=False,
backref=db.backref(
'copies',
lazy='select',
cascade='all, delete-orphan'))
shelf = db.Column(db.String(56))
has_cd_disk = db.Column(db.Boolean)
available_status = db.Column(ChoiceType(BookStatus, impl=db.Integer()),
server_default='3',
default=BookStatus.RETURNED)
rental_logs = db.relationship('RentalLog',
lazy='dynamic',
cascade='all, delete-orphan',
backref=db.backref('copy', uselist=False))
def __str__(self):
return "Copy asset_code: {}, type/title: {}/{}".format(
self.asset_code, self.library_item.type, self.library_item.title)
def __repr__(self):
return "<Copy: {} library_item_id={}>".format(self.asset_code,
self.library_item_id)
class LibraryItem(db.Model):
__tablename__ = 'library_item'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(256))
table_of_contents = db.Column(db.String(256))
language = db.Column(db.String(56))
category = db.Column(db.String(56))
tags = db.relationship('Tag',
secondary=item_tags,
lazy='subquery',
backref=db.backref('library_items'))
description = db.Column(db.Text)
type = db.Column(db.String(32))
__mapper_args__ = {
'polymorphic_identity': 'library_item',
'polymorphic_on': type
}
@property
def tags_string(self):
if self.tags:
return ', '.join(t.name for t in self.tags)
else:
return '-'
class User(db.Model, UserMixin):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(128), unique=True, nullable=False)
first_name = db.Column(db.String(64), nullable=False)
surname = db.Column(db.String(64), nullable=False)
employee_id = db.Column(db.String(64), nullable=False)
active = db.Column(db.Boolean)
roles = db.relationship(
"Role",
secondary=user_roles,
lazy="select",
backref=db.backref("users", lazy="select"),
)
rental_logs = db.relationship(
"RentalLog",
backref=db.backref("user",
uselist=False,
single_parent=True,
lazy="joined"),
lazy="dynamic",
cascade="all, delete-orphan",
)
@property
def full_name(self):
return "{} {}".format(self.first_name, self.surname)
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
role = Role.query.filter_by(name=RoleEnum.USER).first()
self.roles.append(role)
def __repr__(self):
return "<User: {} {} role={}>".format(self.first_name, self.surname,
self.roles)
def has_role(self, role):
if type(role) is str:
try:
role = RoleEnum[role.upper()]
except ValueError:
raise ValueError("No role with that name.")
if type(role) is not RoleEnum:
raise ValueError("No such role.")
return role in [r.name for r in self.roles]
class Book(LibraryItem):
__tablename__ = "books"
id = db.Column(db.ForeignKey("library_item.id"), primary_key=True)
isbn = db.Column(db.String(128), unique=True)
authors = db.relationship(
"Author",
secondary="books_authors",
lazy="joined",
backref=db.backref("books"),
)
original_title = db.Column(db.String(256))
publisher = db.Column(db.String(256))
pub_date = db.Column(db.Date)
__mapper_args__ = {"polymorphic_identity": "book"}
def columns(self):
"""Return the actual columns of a SQLAlchemy-mapped object"""
return [
prop.key
for prop in class_mapper(self.__class__).iterate_properties
if isinstance(prop, ColumnProperty)
]
def __init__(self, **kwargs):
super(Book, self).__init__(**kwargs)
def __str__(self):
return "'{}' by {}".format(self.title,
", ".join([str(a) for a in self.authors]))
def __repr__(self):
return "<Book: '{}' tags={} authors={} copies={}>".format(
self.title, self.tags, self.authors, self.copies)
@property
def authors_string(self):
if self.authors:
return ", ".join(a.full_name for a in self.authors)
else:
return "-"