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))