class RevokedUserTokens(db.Model):
"""contains revoked user tokens"""
__tablename__ = 'RevokedUserTokens'
id = db.Column(db.Integer, primary_key=True)
jti = db.Column(db.String(120), index=True, unique=True, nullable=False)
revoke_ts = db.Column(db.DateTime, default=datetime.datetime.utcnow, nullable=False)
def __repr__(self):
return (f'<id={self.id}, jti={self.jti}, revoke_ts={self.revoke_ts}>')
def to_dict(self):
"""
return dictionary representation
"""
return {
'id': self.id,
'jti': self.jti,
'revoke_ts': self.revoke_ts
}
@classmethod
def get_all(cls):
"""
get all revoked tokens
"""
result = cls.query.all()
return list(result)
@classmethod
def delete_all(cls):
"""
delete all revoked tokens
"""
try:
nr_deleted = db.session.query(cls).delete()
db.session.commit()
return nr_deleted
except sqlalchemy.exc.SQLAlchemyError:
db.session.rollback()
raise
@classmethod
def is_blacklisted(cls, jti):
'''
checks if token jti is revoked
'''
token_jti = cls.query.filter_by(jti=jti).one_or_none()
return token_jti is not None
class BookRequests(db.Model):
"""provides state information for plugins"""
__tablename__ = 'BookRequests'
id = db.Column(db.String, default=_get_unique_id, primary_key=True)
book_title_id = db.Column(db.String,
db.ForeignKey('BookTitles.id'),
nullable=False)
email = db.Column(db.String, nullable=False)
timestamp = db.Column(db.String, nullable=False)
def __repr__(self):
return (f'<id={self.id}, book_title_id={self.book_title_id}, '
f'email={self.email}, timstamp={self.timestamp}>')
def to_dict(self):
"""
return dictionary representation
"""
return {
'id': self.id,
'book_title_id': self.book_title_id,
'email': self.email,
'timestamp': self.timestamp
}
@classmethod
def get(cls, request_id):
"""
get a book request
"""
return cls.query.filter_by(id=request_id).one_or_none()
@classmethod
def get_all(cls):
"""
get all book titles
"""
result = cls.query.all()
return list(result)
@classmethod
def delete(cls, id_):
"""
delete book request matching id
"""
try:
title = cls.query.filter_by(id=id_).one()
db.session.delete(title)
db.session.commit()
except sqlalchemy.exc.SQLAlchemyError:
db.session.rollback()
raise
@classmethod
def delete_all(cls):
"""
delete all book titles
"""
try:
nr_deleted = db.session.query(cls).delete()
db.session.commit()
return nr_deleted
except sqlalchemy.exc.SQLAlchemyError:
db.session.rollback()
raise
class TimeZones(db.Model):
"""contains predefined timezones"""
__tablename__ = 'TimeZones'
id = db.Column(db.Integer, primary_key=True)
location = db.Column(db.String, nullable=False)
city = db.Column(db.String, nullable=False)
relative_to_gmt = db.Column(db.String, nullable=False)
def __repr__(self):
return (
f'<id={self.id}, location={self.location}, city={self.city}, relative_to_gmt={self.relative_to_gmt}>'
)
def to_dict(self):
"""
return dictionary representation
"""
return {
'id': self.id,
'location': self.location,
'city': self.city,
'relative_to_gmt': self.relative_to_gmt
}
@classmethod
def get(cls, id_):
"""
get a timezone
"""
return cls.query.filter_by(id=id_).one_or_none()
@classmethod
def get_all(cls):
"""
get all timesones
"""
result = cls.query.all()
return list(result)
@classmethod
def delete(cls, id_):
"""
delete user matching id
"""
try:
role = cls.query.filter_by(id=id_).one()
db.session.delete(role)
db.session.commit()
except sqlalchemy.exc.SQLAlchemyError:
db.session.rollback()
raise
@classmethod
def delete_all(cls):
"""
delete all timezones
"""
try:
nr_deleted = db.session.query(cls).delete()
db.session.commit()
return nr_deleted
except sqlalchemy.exc.SQLAlchemyError:
db.session.rollback()
raise
class UserDetails(db.Model):
"""contains user specific information"""
__tablename__ = 'UserDetails'
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String, nullable=False)
last_name = db.Column(db.String, nullable=False)
username = db.Column(db.String, nullable=False, unique=True)
email = db.Column(db.String, nullable=False, unique=True)
password = db.Column(db.String, nullable=False)
role_id = db.Column(db.String, db.ForeignKey('UserRoles.id'))
enabled = db.Column(db.Boolean, default=False)
def __repr__(self):
return (
f'<id={self.id}, first_name={self.first_name}, last_name={self.last_name}, username={self.username}, '
f'email={self.email}, passwd={self.password}, role_id={self.role_id}, enabled={self.enabled}>'
)
def to_dict(self):
"""
return dictionary representation
"""
return {
'id': self.id,
'first_name': self.first_name,
'last_name': self.last_name,
'username': self.username,
'email': self.email,
'password': self.password,
'role_id': self.role_id,
'enabled': self.enabled
}
@classmethod
def get(cls, username):
"""
get a user's details
"""
return cls.query.filter_by(username=username).one_or_none()
@classmethod
def get_all(cls):
"""
get all users
"""
result = cls.query.all()
return list(result)
@classmethod
def delete(cls, username):
"""
delete user matching username
"""
try:
user = cls.query.filter_by(username=username).one()
db.session.delete(user)
db.session.commit()
except sqlalchemy.exc.SQLAlchemyError:
db.session.rollback()
raise
@classmethod
def delete_all(cls):
"""
delete all users
"""
try:
nr_deleted = db.session.query(cls).delete()
db.session.commit()
return nr_deleted
except sqlalchemy.exc.SQLAlchemyError:
db.session.rollback()
raise
@staticmethod
def generate_hash(password):
if not password:
return None
return passlib.hash.bcrypt.hash(password)
@staticmethod
def verify_hash(supplied_password, stored_password):
if not supplied_password:
return False
if not stored_password:
return False
return passlib.hash.bcrypt.verify(supplied_password, stored_password)
class UserTimeZones(db.Model):
"""contains user timezones"""
__tablename__ = 'UserTimezones'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer(), db.ForeignKey('UserDetails.id'))
timezone_id = db.Column(db.Integer(), db.ForeignKey('TimeZones.id'))
name = db.Column(db.String, nullable=False)
def __repr__(self):
return (f'<id={self.id}, user_id={self.user_id}, name={self.name}, timezone_id={self.timezone_id}>')
def to_dict(self):
"""
return dictionary representation
"""
return {
'id': self.id,
'user_id': self.user_id,
'timezone_id': self.timezone_id,
'name': self.name
}
@classmethod
def get(cls, id_):
"""
get a user timezone
"""
return cls.query.filter_by(id=id_).one_or_none()
@classmethod
def get_all(cls):
"""
get all user timesones
"""
result = cls.query.all()
return list(result)
@classmethod
def delete(cls, id_):
"""
delete user timezone matching id
"""
try:
role = cls.query.filter_by(id=id_).one()
db.session.delete(role)
db.session.commit()
except sqlalchemy.exc.SQLAlchemyError:
db.session.rollback()
raise
@classmethod
def delete_all(cls):
"""
delete all timezones
"""
try:
nr_deleted = db.session.query(cls).delete()
db.session.commit()
return nr_deleted
except sqlalchemy.exc.SQLAlchemyError:
db.session.rollback()
raise
class UserRoles(db.Model):
"""contains user roles information"""
__tablename__ = 'UserRoles'
id = db.Column(db.Integer, primary_key=True)
role = db.Column(db.String, unique=True, nullable=False)
permissions = db.Column(db.String, nullable=False)
def __repr__(self):
return (f'<id={self.id}, role={self.role}, permissions={self.permissions}>')
def to_dict(self):
"""
return dictionary representation
"""
return {
'id': self.id,
'role': self.role,
'permissions':self.permissions.split(',')
}
@classmethod
def get(cls, role):
"""
get a user role
"""
record = cls.query.filter_by(role=role).one_or_none()
record = record.to_dict() if record else None
return record
@classmethod
def get_all(cls):
"""
get all user roles
"""
result = cls.query.all()
return [x.to_dict() for x in result]
@classmethod
def delete(cls, user_role):
"""
delete user role
"""
try:
role = cls.query.filter_by(role=user_role).one()
db.session.delete(role)
db.session.commit()
except sqlalchemy.exc.SQLAlchemyError:
db.session.rollback()
raise
@classmethod
def delete_all(cls):
"""
delete all users
"""
try:
nr_deleted = db.session.query(cls).delete()
db.session.commit()
return nr_deleted
except sqlalchemy.exc.SQLAlchemyError:
db.session.rollback()
raise
class BookTitles(db.Model):
"""provides state information for plugins"""
__tablename__ = 'BookTitles'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String, nullable=False)
book_request = db.relationship('BookRequests',
backref="book_title",
single_parent=True,
cascade="all, delete, delete-orphan")
def __repr__(self):
return f'<id={self.id}, title={self.title}>'
def to_dict(self):
"""
return dictionary representation
"""
return {'id': self.id, 'title': self.title}
@classmethod
def get(cls, book_title):
"""
get a book title
"""
return cls.query.filter_by(title=book_title).one_or_none()
@classmethod
def get_all(cls):
"""
get all book titles
"""
result = cls.query.all()
return list(result)
@classmethod
def delete(cls, id_):
"""
delete book title matching id
"""
try:
title = cls.query.filter_by(id=id_).one()
db.session.delete(title)
db.session.commit()
except sqlalchemy.exc.SQLAlchemyError:
db.session.rollback()
raise
@classmethod
def delete_all(cls):
"""
delete all book titles
"""
try:
nr_deleted = db.session.query(cls).delete()
db.session.commit()
return nr_deleted
except sqlalchemy.exc.SQLAlchemyError:
db.session.rollback()
raise