class Admin(db.Model):
__tablename__ = 'Admin'
id = db.Column(db.String(100), primary_key=True)
username = db.Column(db.String(80))
password = db.Column(db.String(100))
email = db.Column(db.String(100))
photoURL = db.Column(db.String())
def __init__(self, id_, username, password, email, photoURL=None):
self.id = id_
self.username = username
if password:
self.password = generate_password_hash(password)
self.email = email
if photoURL:
self.photoURL = photoURL
else:
self.photoURL = 'Some default asset'
def save_to_db(self):
db.session.add(self)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
db.session.flush()
print(e)
@classmethod
def getAdmin(cls, admin_id=None, username=None):
if username is None:
return cls.query.filter_by(id=admin_id).first()
if admin_id is None:
return cls.query.filter_by(username=username).first()
class User(UserMixin, db.Model):
"""Class to create a User class object"""
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
first_name = db.Column(db.String(50), nullable=False)
last_name = db.Column(db.String(50), nullable=False)
username = db.Column(db.String(50), nullable=False, unique=True)
password_hash = db.Column(db.String(256), nullable=False)
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
businesses = db.relationship('Business',
order_by='Business.id',
cascade='all, delete-orphan')
def __init__(self, first_name, last_name, username, password):
self.first_name = first_name
self.last_name = last_name
self.username = username
self.password_hash = generate_password_hash(password)
def __repr__(self):
return '<User: {}>'.format(self.username)
def user_as_dict(self):
"""Represent the user as a dict"""
return {u.name: getattr(self, u.name) for u in self.__table__.columns}
class Category(db.Model):
"""Class to create a Category class object"""
__tablename__ = 'categories'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50), unique=True, nullable=False)
description = db.Column(db.String(256), nullable=False)
created_by = db.Column(db.Integer, db.ForeignKey('users.id'))
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
author = db.relationship("User")
def __init__(self, name, description):
self.name = name
self.description = description
self.created_by = session["user_id"]
def __repr__(self):
return '<Category: {}>'.format(self.name)
def category_as_dict(self):
"""Represent the category as a dict"""
category = {
c.name: getattr(self, c.name)
for c in self.__table__.columns
}
category[
'author'] = self.author.first_name + ' ' + self.author.last_name
return category
class Log(db.Model):
"""Class for database changes logs"""
__tablename__ = 'logs'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
action = db.Column(db.String(50), nullable=False)
message = db.Column(db.String(256), nullable=False)
table = db.Column(db.String(50), nullable=False)
created_by = db.Column(db.Integer, db.ForeignKey('users.id'))
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
author = db.relationship("User")
def __init__(self, action, message, table, user_id):
self.action = action
self.message = message
self.table = table
self.created_by = user_id
def __repr__(self):
return '<Log: {}>'.format(self.message)
def log_as_dict(self):
"""Represent the log as a dict"""
log = {l.name: getattr(self, l.name) for l in self.__table__.columns}
log['author'] = self.author.first_name + ' ' + self.author.last_name
return log
class Permissions(db.Model):
__tablename__ = 'Permissions'
id = db.Column(db.String(100), primary_key=True)
isUser = db.Column(db.Boolean, default=False)
isAdmin = db.Column(db.Boolean, default=False)
isSales = db.Column(db.Boolean, default=False)
user_id = db.Column(db.String(100),
db.ForeignKey('User.id', ondelete='CASCADE'))
def save_to_db(self):
self.id = str(uuid.uuid4())
db.session.add(self)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
db.session.flush()
print(e)
@classmethod
def getPermissions(cls, permissions_id):
return cls.query.filter_by(id=permissions_id).first()
@classmethod
def get_by_uid(cls, uid=None):
return cls.query.filter_by(user_id=uid).first()
class Review(db.Model):
"""Class to create a Review class object"""
__tablename__ = 'reviews'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50), unique=True, nullable=False)
description = db.Column(db.String(256), nullable=False)
business = db.Column(db.Integer, db.ForeignKey('businesses.id'))
created_by = db.Column(db.Integer, db.ForeignKey('users.id'))
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime, default=db.func.current_timestamp(
), onupdate=db.func.current_timestamp())
author = db.relationship("User")
def __init__(self, name, description, business):
self.name = name
self.description = description
self.business = business
self.created_by = session["user_id"]
def __repr__(self):
return '<Review: {}>'.format(self.name)
def review_as_dict(self):
"""Represent the review as a dict"""
review = {r.name: getattr(self, r.name) for r in self.__table__.columns}
review['author'] = self.author.first_name + ' ' + self.author.last_name
return review
class User(db.Model):
"""Class to create a User class object"""
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
first_name = db.Column(db.String(50), nullable=False)
last_name = db.Column(db.String(50), nullable=False)
username = db.Column(db.String(50), nullable=False, unique=True)
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime, default=db.func.current_timestamp(
), onupdate=db.func.current_timestamp())
def __init__(self, first_name, last_name, username):
self.first_name = first_name
self.last_name = last_name
self.username = username
def __repr__(self):
return '<User: {}>'.format(self.username)
def user_as_dict(self):
"""Represent the user as a dict"""
return {u.name: getattr(self, u.name) for u in self.__table__.columns}
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship("Role",
secondary=roles_users,
backref=db.backref("users", lazy="dynamic"))
class MessageModel(db.Model):
__tablename__ = "messages"
id = db.Column(db.Integer, primary_key=True)
message = db.Column(db.String(140))
sender_id = db.Column(db.Integer,
db.ForeignKey("users.id"),
nullable=False)
recipient_id = db.Column(db.Integer,
db.ForeignKey("users.id"),
nullable=False)
recipient = db.relationship("UserModel", foreign_keys=[recipient_id])
sender = db.relationship("UserModel", foreign_keys=[sender_id])
def save_to_db(self):
db.session.add(self)
db.session.commit()
def json(self):
return {
"id": self.id,
"message": self.message,
"sender_id": self.sender_id,
"recipient_id": self.recipient_id,
}
@classmethod
def find_recent_from(cls, recipient_id, sender_id):
return (cls.query.filter_by(
sender_id=sender_id, recipient_id=recipient_id).limit(100).all())
@classmethod
def find_recent(cls, recipient_id):
return cls.query.filter_by(recipient_id=recipient_id).limit(100).all()
class Business(db.Model):
"""Class to create a Business class object"""
__tablename__ = 'businesses'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50), unique=True, nullable=False)
description = db.Column(db.String(256), nullable=False)
category = db.Column(db.Integer, db.ForeignKey('categories.id'))
location = db.Column(db.Integer, db.ForeignKey('locations.id'))
photo = db.Column(db.String(256))
created_by = db.Column(db.Integer, db.ForeignKey('users.id'))
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
reviews = db.relationship('Review',
order_by='Review.id',
cascade='all, delete-orphan')
author = db.relationship("User")
category_relationship = db.relationship("Category")
location_relationship = db.relationship("Location")
def __init__(self, name, description, category, location, photo):
self.name = name
self.description = description
self.category = category
self.location = location
self.photo = photo
self.created_by = session["user_id"]
def __repr__(self):
return '<Business: {}>'.format(self.name)
def business_as_dict(self):
"""Represent the business as a dict"""
business = {
b.name: getattr(self, b.name)
for b in self.__table__.columns
}
business[
'author'] = self.author.first_name + ' ' + self.author.last_name
business['category_name'] = self.category_relationship.name
business['location_name'] = self.location_relationship.name
return business
class CategoryModel(db.Model, CRUDMixin):
__tablename__ = "api_category"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
def __repr__(self):
return '<id {}>'.format(self.id)
class Badges(db.Model):
__tablename__ = 'Badges'
id = db.Column(db.String(100), primary_key=True)
image = db.Column(db.String(100), nullable=False)
csv = db.Column(db.String(100), nullable=False)
text_color = db.Column(db.String(100), nullable=False)
badge_size = db.Column(db.String(100), nullable=False)
download_link = db.Column(db.String)
image_link = db.Column(db.String)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
deleted_at = db.Column(db.DateTime, nullable=True)
badge_name = db.Column(db.String(100), default='My Badge')
user_id = db.Column(db.String(100),
db.ForeignKey('User.id', ondelete='CASCADE'))
def save_to_db(self):
self.id = str(uuid.uuid4())
db.session.add(self)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
db.session.flush()
print(e)
def delete_from_db(self):
self.deleted_at = datetime.utcnow()
self.save_to_db()
@classmethod
def getBadge(cls, badge_id):
return cls.query.filter_by(id=badge_id).first()
class File(db.Model):
__tablename__ = 'File'
id = db.Column(db.String(100))
filename = db.Column(db.String(100), nullable=False, primary_key=True)
filetype = db.Column(db.String(100), nullable=False)
user_id = db.Column(db.String(100),
db.ForeignKey('User.id', ondelete='CASCADE'))
def save_to_db(self):
self.id = str(uuid.uuid4())
db.session.add(self)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
db.session.flush()
print(e)
class ArticleModel(db.Model, CRUDMixin):
__tablename__ = 'api_article'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
description = db.Column(db.Text)
categories = db.relationship('CategoryModel', secondary=api_category_article, lazy='subquery',
backref=db.backref('articles', lazy=True))
def __repr__(self):
return '<id {}>'.format(self.id)
class Utilities(db.Model):
__tablename__ = 'Utilities'
id = db.Column(db.String(100), primary_key=True)
pricing = db.Column(db.Float)
def save_to_db(self):
self.id = str(uuid.uuid4())
db.session.add(self)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
db.session.flush()
print(e)
class UserModel(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
@classmethod
def find_all(cls):
return cls.query.all()
@classmethod
def find_by_id(cls, user_id):
return cls.query.get(user_id)
def save_to_db(self):
db.session.add(self)
db.session.commit()
def json(self):
return {"id": self.id, "name": self.name}
class Blacklist(db.Model):
"""Class for blacklisted tokens"""
__tablename__ = 'blacklists'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
token = db.Column(db.String(500), unique=True, nullable=False)
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
def __init__(self, token):
self.token = token
# Represent the object when it is queried
def __repr__(self):
return '<Token: {}>'.format(self.token)
def token_as_dict(self):
"""Represent the token as a dict"""
return {t.name: getattr(self, t.name) for t in self.__table__.columns}
class User(db.Model):
__tablename__ = 'User'
id = db.Column(db.String(100), primary_key=True)
username = db.Column(db.String(80))
password = db.Column(db.String(100))
email = db.Column(db.String(100))
photoURL = db.Column(db.String, default=_photoURL)
allowed_usage = db.Column(db.Integer)
ftl = db.Column(db.Boolean, default=True)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
deleted_at = db.Column(db.DateTime, nullable=True)
files = db.relationship('File', backref='uploader')
badges = db.relationship('Badges', backref='creator')
permissions = db.relationship('Permissions',
backref=db.backref('user_permissions'),
lazy='dynamic')
siteAdmin = db.Column(db.Boolean, default=False)
last_login_ip = db.Column(db.String, nullable=True)
last_login_date = db.Column(db.DateTime, nullable=True)
def __init__(self, id_, username, password, email, photoURL=None):
self.id = id_
self.username = username
self.allowed_usage = 200
if password:
self.password = generate_password_hash(password)
self.email = email
if photoURL:
self.photoURL = photoURL
def create_site_admin(self):
self.siteAdmin = True
self.save_to_db()
def save_to_db(self):
db.session.add(self)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
db.session.flush()
print(e)
def delete_user(self):
db.session.delete(self)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
db.session.flush()
print(e)
@classmethod
def getUser(cls, user_id=None, username=None, email=None):
if user_id:
return cls.query.filter_by(id=user_id).first()
if username:
return cls.query.filter_by(username=username).first()
if email:
return cls.query.filter_by(email=email).first()
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))