class customer(user):
__tablename__ = 'customer'
id = db.Column(db.String, db.ForeignKey('user.id'), primary_key=True)
project = db.Column('project', db.String)
__mapper_args__ = {
'polymorphic_identity': 'customer',
}
class Role(db.Model):
__tablename__ = "roles"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Enum(RoleEnum), unique=True)
def __repr__(self):
return "Role: {}".format(self.name)
class Like(db.Model):
__tablename__ = 'wish_list_likes'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
wish_item_id = db.Column(db.Integer,
db.ForeignKey('wish_list_items.id'),
nullable=False)
def __repr__(self):
return '<Like {}>'.format(self.id, )
@classmethod
def like_exists(cls, wish_id, user):
return db.session.query(Like.id)\
.filter_by(user_id=user.id, wish_item_id=wish_id)\
.scalar() is not None
@classmethod
def like(cls, wish_id, user):
new_like = Like(user_id=user.id, wish_item_id=wish_id)
db.session.add(new_like)
db.session.commit()
@classmethod
def unlike(cls, wish_id, user):
unlike = Like.query\
.filter_by(user_id=user.id, wish_item_id=wish_id).first()
db.session.delete(unlike)
db.session.commit()
class TaskList(db.Model):
__tablename__ = "task-list"
id = db.Column(db.Integer, primary_key=True)
list_title = db.Column(db.String(256), unique=True, nullable=False)
newly_created = db.Column(db.Boolean, default=True)
list_accomplished = db.Column(db.Boolean)
task_cards = db.relationship('TaskCard')
class user(UserMixin, db.Model):
__tablename__ = 'user'
id = db.Column('id', db.String, primary_key=True)
name = db.Column('name', db.String)
username = db.Column('username', db.String)
password = db.Column('password', db.String)
role = db.Column('role', db.String)
__mapper_args__ = {'polymorphic_identity': 'user', 'polymorphic_on': role}
class TaskDetails(db.Model):
__tablename__ = "details"
id = db.Column(db.Integer, primary_key=True)
task_description = db.Column(db.String(512))
task_card_id = db.Column(db.Integer,
db.ForeignKey('task-card.id'),
nullable=False)
task_card = db.relationship('TaskCard', back_populates='task_details')
class WishListItem(db.Model):
__tablename__ = 'wish_list_items'
id = db.Column(db.Integer, primary_key=True)
authors = db.Column(db.String(256))
title = db.Column(db.String(256), nullable=False)
likes = db.relationship('Like',
backref='wish_list_item',
cascade="all, delete-orphan",
lazy=True)
pub_year = db.Column(db.Date)
item_type = db.Column(db.String(256), nullable=False)
def __repr__(self):
return '<Wish List Item {}>'.format(self.title)
def __lt__(self, other):
return (self.likes_count < other.likes_count)
def __le__(self, other):
return (self.likes_count <= other.likes_count)
def __gt__(self, other):
return (self.likes_count > other.likes_count)
def __ge__(self, other):
return (self.likes_count >= other.likes_count)
def __eq__(self, other):
return (self.likes_count == other.likes_count)
def __ne__(self, other):
return not (self.__eq__)
@classmethod
def delete_wish(cls, wish_id):
delete_wish_admin = WishListItem.query.get(wish_id)
db.session.delete(delete_wish_admin)
db.session.commit()
@hybrid_property
def likes_count(self):
return self.likes.count()
@likes_count.expression
def likes_count(cls):
return (select([func.count(
Like.id)]).where(Like.wish_item_id == cls.id).label("likes_count"))
def serialize(self):
return {
'id': self.id,
'item_type': self.item_type,
'title': self.title,
'authors': self.authors,
'pub_year': self.pub_year,
'likes': self.likes,
}
class Tag(db.Model):
__tablename__ = 'tags'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
def __repr__(self):
return "<Tag: {}>".format(self.name)
def __str__(self):
return "Tag: {}".format(self.name)
class questions(db.Model):
__tablename__ = 'questions'
id = db.Column('id', db.Integer,
primary_key=True) ##id e.g. 0,1,2,3,4,5......
series_num = db.Column('series_num', db.Integer)
part_num = db.Column('part_num', db.Integer)
ques_num = db.Column('ques_num', db.Integer)
question = db.Column('question', db.String)
__mapper_args__ = {
'polymorphic_identity': 'questions',
}
class TaskCard(db.Model):
__tablename__ = "task-card"
id = db.Column(db.Integer, primary_key=True)
card_title = db.Column(db.String(256))
accomplished = db.Column(db.Boolean)
task_list_id = db.Column(db.Integer,
db.ForeignKey('task-list.id'),
nullable=False)
task_list = db.relationship('TaskList', back_populates='task_cards')
task_details = db.relationship('TaskDetails')
class Department(db.Model):
__tablename__ = 'department'
id_dep = db.Column(db.Integer, primary_key=True)
dep_name = db.Column(db.String(30))
description = db.Column(db.String(100))
employees = db.relationship('Employee',
backref='department',
lazy='dynamic')
def __init__(self, dep_name, description):
self.dep_name = dep_name
self.description = description
class Author(db.Model):
__tablename__ = "authors"
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(64))
last_name = db.Column(db.String(64))
@property
def full_name(self):
return "{} {}".format(self.first_name, self.last_name)
def __str__(self):
return "{}".format(self.full_name)
def __repr__(self):
return "<Author: {} {}>".format(self.first_name, self.last_name)
class Recipe(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.String(300))
title = db.Column(db.String(100), nullable=False)
total_time_minutes = db.Column(db.Integer)
yields = db.Column(db.String(50))
ingredients = db.Column(db.String(2000), nullable=False)
instructions = db.Column(db.String(6000), nullable=False)
img_url = db.Column(db.String(300))
desc = db.Column(db.String(300))
def __repr__(self):
return "<Recipe ID %r>" % self.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 audit(db.Model):
__tablename__ = 'audit'
id = db.Column('id', db.Integer, primary_key=True)
series_num = db.Column('series_num', db.Integer)
part_num = db.Column('part_num', db.Integer)
ques_num = db.Column('ques_num', db.Integer)
answer = db.Column('answer', db.Integer)
comment = db.Column('comment', db.String)
suggestion = db.Column('suggestion', db.String)
auditor = db.Column('auditor', db.String)
name = db.Column('name', db.String)
#datetime = db.Column('datetime',db.datetime.datetime)
__mapper_args__ = {
'polymorphic_identity': 'audit',
}
class WishListItem(db.Model):
__tablename__ = 'wish_list_items'
id = db.Column(db.Integer, primary_key=True)
authors = db.Column(db.String(256))
title = db.Column(db.String(256), nullable=False)
likes = db.relationship('Like',
backref='wish_list_item',
cascade="all, delete-orphan",
lazy=True)
pub_year = db.Column(db.Date)
item_type = db.Column(db.String(256), nullable=False)
def __repr__(self):
return '<Wish List Item {}>'.format(self.title)
@classmethod
def delete_wish(cls, wish_id):
delete_wish_admin = WishListItem.query.get(wish_id)
db.session.delete(delete_wish_admin)
db.session.commit()
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 "-"
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 Employee(db.Model):
__tablename__ = 'employee'
id_emp = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(30))
last_name = db.Column(db.String(30))
birth_date = db.Column(db.Date())
salary = db.Column(db.Integer())
department_id = db.Column(db.Integer, db.ForeignKey("department.id_dep"))
def __init__(self, first_name, last_name, birth_date, salary, department_id):
self.first_name = first_name
self.last_name = last_name
self.birth_date = birth_date
self.salary = salary
self.department_id = department_id
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 Tag(db.Model):
__tablename__ = 'tags'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
def __repr__(self):
return "<Tag: {}>".format(self.name)
def __str__(self):
return "Tag: {}".format(self.name)
item_tags = db.Table(
'item_tags',
db.Column('item_id', db.Integer, db.ForeignKey('library_item.id')),
db.Column('tag_id', db.Integer, db.ForeignKey('tags.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)
@property
def authors_string(self):
if self.authors:
return ", ".join(a.full_name for a in self.authors)
else:
return "-"
class Author(db.Model):
__tablename__ = "authors"
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(64))
last_name = db.Column(db.String(64))
@property
def full_name(self):
return "{} {}".format(self.first_name, self.last_name)
def __str__(self):
return "{}".format(self.full_name)
def __repr__(self):
return "<Author: {} {}>".format(self.first_name, self.last_name)
book_author = db.Table(
"books_authors",
db.Column("author_id", db.Integer, db.ForeignKey("authors.id")),
db.Column("book_id", db.Integer, db.ForeignKey("books.id")),
)
class admin(user):
__tablename__ = 'admin'
id = db.Column(db.String, db.ForeignKey('user.id'), primary_key=True)
__mapper_args__ = {
'polymorphic_identity': 'admin',
}
class RentalLog(db.Model):
id = db.Column(db.Integer, primary_key=True)
copy_id = db.Column(db.Integer, db.ForeignKey('copy.id'), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
_borrow_time = db.Column(db.DateTime)
_return_time = db.Column(db.DateTime)
book_status = db.Column(ChoiceType(BookStatus, impl=db.Integer()))
_reservation_begin = db.Column(db.DateTime)
_reservation_end = db.Column(db.DateTime)
@property
def borrow_time(self):
return self._borrow_time.replace(tzinfo=pytz.utc).\
astimezone(tz=pytz.timezone('Europe/Warsaw'))
@borrow_time.setter
def borrow_time(self, dt):
if dt.tzinfo is None:
raise ValueError("borrow_time has to be timezone aware")
self._borrow_time = dt.astimezone(tz=pytz.utc)
@property
def return_time(self):
return self._return_time.replace(tzinfo=pytz.utc). \
astimezone(tz=pytz.timezone('Europe/Warsaw'))
@return_time.setter
def return_time(self, dt):
if dt.tzinfo is None:
raise ValueError("return_time has to be timezone aware")
self._return_time = dt.astimezone(tz=pytz.utc)
@property
def reservation_begin(self):
return self._reservation_begin.replace(tzinfo=pytz.utc). \
astimezone(tz=pytz.timezone('Europe/Warsaw'))
@reservation_begin.setter
def reservation_begin(self, dt):
if dt.tzinfo is None:
raise ValueError("reservation_timestamp has to be timezone aware")
self._reservation_begin = dt.astimezone(tz=pytz.utc)
@property
def reservation_end(self):
return self._reservation_end.replace(tzinfo=pytz.utc). \
astimezone(tz=pytz.timezone('Europe/Warsaw'))
@reservation_end.setter
def reservation_end(self, dt):
if dt.tzinfo is None:
raise ValueError("reservation_timestamp has to be timezone aware")
self._reservation_end = dt.astimezone(tz=pytz.utc)
def __str__(self):
return "RENTAL LOG: user: {} copy: {}".format(self.user.full_name,
self.copy.asset_code)
def __repr__(self):
return "<RentalLog: ID: {} user_id={} copy_id={}>".format(
self.id, self.user_id, self.copy_id)
import enum
from sqlalchemy import event
from flask_user import UserMixin
from init_db import db
user_roles = db.Table(
"user_roles",
db.Column(
"user_id",
db.Integer,
db.ForeignKey("users.id", ondelete="CASCADE"),
primary_key=True,
),
db.Column(
"role_id",
db.Integer,
db.ForeignKey("roles.id", ondelete="CASCADE"),
primary_key=True,
),
)
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)
