class FoodKind(BaseMixin, UserDefinedNameMixin, db.Model): user_id = db.Column(UUID(as_uuid=True), db.ForeignKey('app_user.id')) unit_of_measurement_id = db.Column(UUID(as_uuid=True), db.ForeignKey('unit_of_measurement.id'), default=UNIT_OF_MEASURE_IS_SELF_ID) serving_size = db.Column(db.Float, default=0.0) unit_of_measurement = db.relationship('UnitOfMeasurement', lazy='joined') nutrition_info = db.relationship('FoodKindNutritionInfo', lazy='joined', uselist=False) categories = db.relationship('FoodCategory', secondary='food_kind_category', lazy='subquery', backref=db.backref('food_kinds', lazy=True)) stock_items = db.relationship('StockItem', lazy=True) def full_dict(self): remove = ['unit_of_measurement_id'] return { **{ key: getattr(self, key) for key in self.cols_dict().keys() if key not in remove }, 'unit_of_measurement': self.unit_of_measurement, 'categories': self.categories, 'nutrition_info': self.nutrition_info or {} }
class Organizations(db.Model): __tablename__ = "organizations" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) description = db.Column(db.String(80)) def __init__(self, name, description): self.name = name self.description = description def json(self): return { "id": self.id, "name": self.name, "description": self.description }, 200 def save_to_db(self): db.session.add(self) db.session.commit() @classmethod def find_org_by_name(cls, name): return cls.query.filter_by(name=name).first() @classmethod def get_all_organizations(cls): return cls.query.all() @classmethod def test(cls): return True
class AppUser(TimestampMixin, db.Model): email = db.Column(db.String, nullable=False, unique=True) pw_hash = db.Column(db.String, nullable=False) @classmethod def get_by_email(cls, email): return cls.query.filter(cls.email == email).first()
class StockItem(UuidPrimaryKeyMixin, CreatedUpdatedTimestampMixin, db.Model): stock_id = db.Column(UUID(as_uuid=True), db.ForeignKey('stock.id'), nullable=False) item_id = db.Column(UUID(as_uuid=True), db.ForeignKey('item.id'), nullable=False) snapshots = db.relationship('StockItemSnapshot', lazy=True)
class Requirement(db.Model, BaseModelMixin): id = db.Column(db.Integer, primary_key=True) key = db.Column(db.String) value = db.Column(db.String) job_id = db.Column(db.Integer, db.ForeignKey('job.id'), nullable=False) def __init__(self, key, value): self.key = key self.value = value
class UserPermission(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String, nullable=False) def __repr__(self): return f"UserPermission {self.id} - {self.name}" def save_to_db(self): db.session.add(self) db.session.commit()
class Language(db.Model, BaseModelMixin): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(100)) curriculum_id = db.Column(db.Integer, db.ForeignKey('curriculum.id'), nullable=False) def __init__(self, name): self.name = name
class Search(db.Model, BaseModelMixin): id = db.Column(db.Integer, primary_key=True) text = db.Column(db.String) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=True) created_at = db.Column(db.DateTime, default=datetime.utcnow) def __init__(self, text, user_id): self.text = text self.user_id = user_id
class UserProfile(TimestampMixin, db.Model): user_id = db.Column(UUID(as_uuid=True), db.ForeignKey('registered_user.id'), primary_key=True) role_id = db.Column(db.Integer, db.ForeignKey('user_role.id')) username = db.Column(db.String, unique=True, nullable=False) role = db.relationship('UserRole', lazy='joined') def save_to_db(self): db.session.add(self) db.session.commit()
class UserDefinedNameMixin: name = db.Column(db.String, nullable=False) uniform_name = db.Column(db.String, nullable=False) def __init__(self, **kwargs): self.name = kwargs.get('name') self.uniform_name = uniform_name(kwargs.get('name')) def update_name(self, name): self.name = name self.uniform_name = uniform_name(name)
class RegisteredUser(TimestampMixin, db.Model): id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid4) username = db.Column(db.String, nullable=False, unique=True) pw_hash = db.Column(db.String, nullable=False) @classmethod def find_by_username(cls, username): return cls.query.filter_by(username=username).first() def save_to_db(self): db.session.add(self) db.session.commit()
class Item(UuidPrimaryKeyMixin, CreatedUpdatedTimestampMixin, db.Model): name = db.Column(db.String, nullable=False) description = db.Column(db.String) tags = db.relationship('Tag', lazy=False, secondary='item_tag', backref=db.backref('items', lazy=True)) instances = db.relationship('StockItem', lazy=True, backref=db.backref('item', lazy=False))
class UserRole(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String, nullable=False) permission = db.relationship('UserPermission', secondary='user_role_permission', lazy='joined') def __repr__(self): return f"UserRole {self.id} - {self.name} - {self.permission}" def save_to_db(self): db.session.add(self) db.session.commit()
class StockItemSnapshot(UuidPrimaryKeyMixin, CreatedUpdatedTimestampMixin, db.Model): '''Represents the state of an item at any given time''' stock_item_id = db.Column(UUID(as_uuid=True), db.ForeignKey('stock_item.id'), nullable=False) maintainer_id = db.Column(UUID(as_uuid=True), db.ForeignKey('maintainer.id'), nullable=False) unit_of_measure_id = db.Column(db.Integer, db.ForeignKey('unit_of_measure.id'), nullable=False) quantity = db.Column(db.Float, nullable=False, default=0.0)
class UserLogin(db.Model): id = db.Column(db.Integer, primary_key=True) date_created = db.Column(TIMESTAMP(timezone=True), default=datetime.utcnow) user_id = db.Column(UUID(as_uuid=True), db.ForeignKey('registered_user.id'), nullable=False) def __repr__(self): return f"UserLogin {self.user_id} - {self.date_created}" def save_to_db(self): db.session.add(self) db.session.commit()
class Curriculum_Category(db.Model, BaseModelMixin): category_id = db.Column(db.Integer, db.ForeignKey('category.id'), primary_key=True) curriculum_id = db.Column(db.Integer, db.ForeignKey('curriculum.id'), primary_key=True) category = db.relationship("Category") created_at = db.Column(db.DateTime, default=datetime.utcnow) def __init__(self): pass
class Subcategory(db.Model, BaseModelMixin): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String) jobs = db.relationship('Job', backref='subcategory', lazy=False, cascade='all, delete-orphan') category_id = db.Column(db.Integer, db.ForeignKey('category.id'), nullable=False) created_at = db.Column(db.DateTime, default=datetime.utcnow) def __init__(self, name): self.name = name @classmethod def getByName(cls, name): return cls.query.filter(cls.name == name).first()
class RegisteredUser(db.Model): id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4) oauth_openid = db.Column( db.String, unique=True) # if the user registered through OAuth2 username = db.Column(db.String) email = db.Column(db.String, unique=True, nullable=False) role_id = db.Column(db.Integer, db.ForeignKey('user_role.id')) role = db.relationship('UserRole', lazy='joined') logins = db.relationship('UserLogin', lazy='dynamic') posts = db.relationship('Post', lazy='dynamic') prompts = db.relationship('Prompt', lazy='dynamic') def __repr__(self): return f"RegisteredUser {self.id} - {self.email} - {self.username} - {self.role}" @classmethod def get_profile_user(cls, user_id): '''Use this method to fetch data to display when any given logged on user views their profile information''' user = cls.query.get(user_id) if user: return dict( id=user.id, username=user.username, email=user.email, role=user.role, posts=[p for p in user.posts.all()], prompts=[p for p in user.prompts.all()], ) @classmethod def get_profile_admin(cls, user_id): '''Use this method to fetch data about users for admins to review/use in their tasks''' user = cls.query.get(user_id) if user: return dict( id=user.id, username=user.username, email=user.email, role=user.role, posts=[p.with_reviews() for p in user.posts.all()], prompts=[p.with_reviews() for p in user.prompts.all()], logins=[l for l in user.logins.all()], ) def save_to_db(self): db.session.add(self) db.session.commit()
class Notification(db.Model, BaseModelMixin): id = db.Column(db.Integer, primary_key=True) status = db.Column(db.String, nullable=False, default='unread') title = db.Column(db.String) description = db.Column(db.String) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) interview_id = db.Column(db.Integer, db.ForeignKey('job.id'), nullable=False) created_at = db.Column(db.DateTime, default=datetime.utcnow) def __init__(self, user_id, title, description, interview_id): self.user_id = user_id self.title = title self.description = description self.interview_id = interview_id @classmethod def get_pag(cls, data, id): return cls.query.filter(cls.user_id == id).order_by( cls.created_at.desc()).paginate(data['page'], 10, False) @classmethod def unreadNotificationsCount(cls, id): return cls.query.filter(cls.user_id == id, cls.status == 'unread').count()
class RevokedToken(db.Model): jti = db.Column(db.String, primary_key=True) def save_to_db(self): db.session.add(self) db.session.commit() def is_revoked(cls, jti): return bool(cls.query.get(jti))
class StockItemState(TimestampMixin, db.Model): stock_item_id = db.Column(UUID(as_uuid=True), db.ForeignKey('stock_item.id')) packaging_kind_id = db.Column(UUID(as_uuid=True), db.ForeignKey('packaging_kind.id')) packaging_state_id = db.Column(UUID(as_uuid=True), db.ForeignKey('packaging_state.id')) quantity = db.Column(db.Integer, default=0) # has lazy loaded 'backref'ed relationship field 'food_item' packaging_kind = db.relationship('PackagingKind', lazy='joined') packaging_state = db.relationship('PackagingState', lazy='joined') def full_dict(self): remove = ['packaging_kind_id', 'packaging_state_id'] return { **{ key: getattr(self, key) for key in self.cols_dict().keys() if key not in remove }, 'packaging_kind': self.packaging_kind, 'packaging_state': self.packaging_state }
class PromptReview(db.Model): id = db.Column(UUID(as_uuid=True), primary_key=True) prompt_id = db.Column(UUID(as_uuid=True), db.ForeignKey('prompt.id'), nullable=False) date_created = db.Column(TIMESTAMP(timezone=True), default=datetime.utcnow) date_modified = db.Column(TIMESTAMP(timezone=True)) created_by = db.Column(UUID(as_uuid=True), db.ForeignKey('registered_user.id'), nullable=False) is_approved = db.Column(db.Boolean, nullable=False) comments = db.Column(db.String(400))
class StockItem(TimestampMixin, db.Model): stock_id = db.Column(UUID(as_uuid=True), db.ForeignKey('stock.id')) food_kind_id = db.Column(UUID(as_uuid=True), db.ForeignKey('food_kind.id')) date_item_was_new = db.Column(DATE(), default=datetime.utcnow) expiration_date = db.Column(DATE(), nullable=False) # 'states' field in StockItem instance is sqlalchemy query object which can # be used to specify whether or not to grab all previous 'StockItemState's (a lot) # or just the most recent one...or something else states = db.relationship('StockItemState', lazy='dynamic', backref=db.backref('food_item', lazy=True)) food_kind = db.relationship('FoodKind', lazy='joined') def full_dict(self): current_state = self.states.order_by(text('date_created desc')).first() return { **self.cols_dict(), 'food_kind': self.food_kind.full_dict(), 'current_state': current_state.full_dict() if current_state else None, }
class RevokedToken(db.Model): jti = db.Column(db.String(120), primary_key=True) def save_to_db(self): db.session.add(self) db.session.commit() @classmethod def is_revoked(cls, jti): return bool(cls.query.filter_by(jti=jti).first())
class BaseMixin: id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid4) def save(self): db.session.add(self) db.session.commit() def delete(self): db.session.delete(self) db.session.commit()
class Company(db.Model, BaseModelMixin): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String, nullable=False) info = db.Column(db.String) logo = db.Column(db.String) jobs = db.relationship('Job', backref='company', lazy=False, cascade='all, delete-orphan') ratings = db.relationship('Rating', backref='company', lazy=False) def __init__(self, name): self.name = name @classmethod def get_by_name(cls, name): return cls.query.filter(Company.name == name).first() @classmethod def get_by_id(cls, id): return cls.query.filter(Company.id == id).first() @classmethod def get_pag(cls, data): filtro = cls.query filtro = filtro.filter(db.or_(~Company.name.contains('Workana'))) if 'search' in data and data['search'] is not None: filtro = filtro.filter( db.or_(Company.name.contains(data['search'].strip()))) if 'page' in data and 'per_page' in data: return filtro.paginate(int(data['page']), int(data['per_page']), False, 40) else: return filtro.paginate(1, 10, False) @classmethod def get_id(cls): filtro = db.engine.execute( "select setval('company_id_seq', (select max(id) from company));") return [row for row in filtro]
class RevokedToken(db.Model): jti = db.Column(UUID(as_uuid=True), primary_key=True) def save(self): db.session.add(self) db.session.commit() def delete(self): db.session.delete(self) db.session.commit()
class Stock(UuidPrimaryKeyMixin, CreatedUpdatedTimestampMixin, db.Model): name = db.Column(db.String, nullable=False) items = db.relationship('StockItem', lazy=True, backref=db.backref('stock', lazy=False)) maintainers = db.relationship('Maintainer', lazy=True, secondary='stock_maintainer', backref=db.backref('stocks', lazy=False))
class ItemModel(db.Model): __tablename__ = "items" id = db.Column(db.Integer, primary_key=True) item = db.Column(db.String(80)) price = db.Column(db.Float(precision=2)) store_id = db.Column(db.Integer, db.ForeignKey("stores.id")) store = db.relationship('StoreModel') def __init__(self, item, price, store_id): self.item = item self.price = price self.store_id = store_id def json(self): return { "name": self.item, "price": self.price, "store_id": self.store_id } @classmethod def find_by_name(cls, name): return cls.query.filter_by(item=name).first() # @classmethod def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit() @classmethod def get_all(cls): return cls.query.all() @classmethod def delete_all(cls): return cls.query.delete()
class Role(db.Model): id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String(50), unique=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) def __init__(self, name): self.name = name def __repr__(self): return '<Role {}>'.format(self.name) def json(self): return {"id": self.id, "name": self.name}, 200 def save_to_db(self): db.session.add(self) db.session.commit() @classmethod def find_role_by_name(cls, name): return cls.query.filter_by(name=name).first()