class UserRoles(db.Model): __tablename__ = 'user_roles' id = db.Column(db.Integer(), primary_key=True) user_id = db.Column(db.Integer(), db.ForeignKey('users.id', ondelete='CASCADE')) role_id = db.Column(db.Integer(), db.ForeignKey('roles.id', ondelete='CASCADE'))
class ItemModel(db.Model): __tablename__ = 'items' id = db.Column(db.Integer(), primary_key=True) name = 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, name, price, store_id): self.name = name self.price = price self.store_id = store_id def json(self): return { "name": self.name, "price": self.price, "store_id": self.store_id } @classmethod def find_item_by_name(cls, name): return cls.query.filter_by(name=name).first() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class CasesAggregated(db.Model): """ Hospital data class """ __abstract__ = True name = db.Column(db.String()) ids = db.Column(db.Integer, primary_key=True) until = db.Column(db.String()) cases = db.Column(db.Integer()) deaths = db.Column(db.Integer()) bevoelkerung = db.Column(db.Integer()) outline = db.Column(db.String()) def __init__(self, **kwargs): self.__dict__.update(kwargs) def __repr__(self): return '<Hospital in %r>' % (self.name) def as_dict(self): result = { 'geometry': json.loads(self.outline), 'properties': { 'name': self.name, 'ids': self.ids, 'until': self.until, 'cases': int(self.cases), 'deaths': int(self.deaths), 'bevoelkerung': int(self.bevoelkerung) } } return result
class YeastModel(db.Model, BaseModel, SearchableMixin): __tablename__ = "yeast" __searchable__ = [ 'brand', 'name', 'style', 'yeast_format', 'avg_attenuation', 'min_temp', 'max_temp' ] id = db.Column(UUID(as_uuid=True), unique=True, nullable=False, primary_key=True, default=uuid4) brand = db.Column(db.String(80)) name = db.Column(db.String(80), nullable=False) style = db.Column(db.String(120)) yeast_format = db.Column(db.String(80)) avg_attenuation = db.Column(db.Integer()) min_temp = db.Column(db.Integer()) max_temp = db.Column(db.Integer()) custom = db.Column(db.Boolean(), default=True) user_id = db.Column(UUID(as_uuid=True), db.ForeignKey("user.id"), nullable=False) user = db.relationship("UserModel")
class Data_Access(db.Model): user_id = db.Column(db.Integer(), db.ForeignKey('user.id'), primary_key=True, default=-1) data_id = db.Column(db.Integer(), db.ForeignKey('data.id'), primary_key=True, default=-1) user = db.relationship("User", foreign_keys=[user_id]) data = db.relationship("Data", foreign_keys=[data_id]) def __init__(self, user_id, data_id): self.user_id = user_id self.data_id = data_id def save_to_db(self): db.session.add(self) db.session.commit() return self def delete_from_db(self): db.session.delete(self) db.session.commit() @classmethod def get(cls, user_id=None, data_id=None): if user_id and data_id: return cls.query.filter_by(user_id=user_id, data_id=data_id).all() if user_id: return cls.query.filter_by(user_id=user_id).all() if data_id: return cls.query.filter_by(data_id=data_id).all() return None
class ItemModel(db.Model): __tablename__ = "items" id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String(50)) price = db.Column(db.Float(precision=2)) store_id = db.Column(db.Integer(), db.ForeignKey("stores.id")) store = db.relationship("StoreModel") def __init__(self, name, price, store_id): self.name = name self.price = price self.store_id = store_id def json(self): return {"name": self.name, "price": self.price} @classmethod def get_item_by_name(cls, name): return ItemModel.query.filter_by(name=name).first() # select * from items where name=name limit 1; 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_items(cls): return ItemModel.query.all()
class FavouriteModel(db.Model): """ Se genera un objeto de esta clase cuando un usuario marca un producto como favorito. """ __tablename__ = 'Favourites' favourite_id = db.Column(db.Integer(), primary_key=True) user_id = db.Column(db.Integer(), db.ForeignKey('Users.id', ondelete='CASCADE')) product_id = db.Column( db.Integer(), db.ForeignKey('Products.product_id', ondelete='CASCADE')) def __init__(self, user_id: int, product_id: int): self.user_id = user_id self.product_id = product_id def json(self): """ Devuelve el favorito en formato JSON. """ return {"id": self.favourite_id, "product": self.product.json()} @classmethod def find_by_id(cls, favourite_id: int): """ Devuelve un favorito con base en su ID. """ return cls.query.filter_by(favourite_id=favourite_id).first() @classmethod def find_if_exists(cls, user_id: int, product_id: int): """ Devuelve el objeto si existe, de lo contrario, devuelve None. """ return cls.query.filter_by(user_id=user_id).filter_by( product_id=product_id).first() @classmethod def get_by_user(cls, user_id: int): """ Devuelve la lista de favoritos de un usuario. """ return cls.query.filter_by(user_id=user_id).all() def save_to_db(self): """ Guarda los datos del objeto en la base de datos. No se puede actualizar aunque el método lo permita. """ db.session.add(self) db.session.commit() def delete_from_db(self): """ Elimina el registro de la base de datos. Ocurre cuando un usuario quita un producto de sus favoritos. """ db.session.delete(self) db.session.commit()
class OpinionModel(db.Model): """ Opinión de un usuario sobre un producto comprado. """ __tablename__ = 'Opinions' opinion_id = db.Column(db.Integer(), primary_key=True) product_id = db.Column( db.Integer(), db.ForeignKey('Products.product_id', ondelete='CASCADE')) rating = db.Column(db.Integer(), nullable=False) comment = db.Column(db.String(50), nullable=False) def __init__(self, product_id: int, rating: int, comment: str): self.product_id = product_id self.rating = rating self.comment = comment def json(self): """ Devuelve la opinión en formato JSON. """ return { "id": self.opinion_id, "productId": self.product_id, "rating": self.rating, "comment": self.comment } @classmethod def find_by_id(cls, opinion_id: int): """ Devuelve los detalles de una opinión con base en su ID. """ return cls.query.filter_by(opinion_id=opinion_id).first() @classmethod def get_by_product(cls, product_id: int): """ Devuelve la lista de opiniones hechas sobre un producto. """ return cls.query.filter_by(product_id=product_id).all() def save_to_db(self): """ Guarda la opinión en la base de datos. No puede ser actualizada, aunque el método lo permita. """ db.session.add(self) db.session.commit() def delete_from_db(self): """ Elimina la opinión de la base de datos. """ db.session.delete(self) db.session.commit()
class RecipeYeasts(db.Model, BaseModel): __tablename__ = "recipes_yeasts" id = db.Column(UUID(as_uuid=True), nullable=False, primary_key=True, default=uuid4) recipe_id = db.Column(UUID(as_uuid=True), db.ForeignKey('recipe.id')) yeast_id = db.Column(UUID(as_uuid=True), db.ForeignKey('yeast.id')) pitch_temp = db.Column(db.Integer(), nullable=False) pitch_time = db.Column(db.String(128)) attenuation = db.Column(db.Integer(), nullable=False) yeast = db.relationship("YeastModel")
class RecipeMashSteps(db.Model, BaseModel): __tablename__ = "recipes_mash" id = db.Column(UUID(as_uuid=True), nullable=False, primary_key=True, default=uuid4) step = db.Column(db.Integer()) recipe_id = db.Column(UUID(as_uuid=True), db.ForeignKey('recipe.id')) amount = db.Column(db.Float()) notes = db.Column(db.String(240), nullable=False) mash_type = db.Column(db.String(80), nullable=False) temperature = db.Column(db.Integer(), nullable=False) time = db.Column(db.Integer(), nullable=False)
class UserModel(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(255)) email = db.Column(db.String(255)) gender = db.Column(db.Integer()) dateOfBirth = db.Column(db.String(255)) def __init__(self, name, email, gender, dateOfBirth): self.name = name self.email = email self.gender = gender self.dateOfBirth = dateOfBirth def json(self): return { 'id': self.id, 'name': self.name, 'email': self.email, 'gender': self.gender, 'dateOfBirth': self.dateOfBirth } @classmethod def find_by_id(cls, _id): return cls.query.filter_by(id=_id).first()
class StoreModel(db.Model): __tablename__ = 'stores' id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String(80)) items = db.relationship('ItemModel', lazy="dynamic") def __init__(self, name): self.name = name def json(self): return { "name": self.name, "items": [item.json() for item in self.items.all()] } @classmethod def find_by_name(cls, name): return cls.query.filter_by(name=name).first() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class Reminder(db.Model): __tablename__ = "reminders" reminder_id = db.Column(db.Integer(), primary_key=True) reminder_text = db.Column(db.Unicode) reminder_time = db.Column(db.DateTime) user_id = db.Column(db.Numeric) channel_id = db.Column(db.Numeric)
class StoreModel(db.Model): __tablename__ = "stores" id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String(80)) items = db.relationship('ItemModel', lazy='dynamic') def __init__(self, name): self.name = name def json(self): return { 'name': self.name, 'items': [item.json() for item in self.items.all()] } @classmethod def find_by_name(cls, name): return cls.query.filter_by( name=name).first() # SELECT * FROM items WHERE name=name LIMIT 1 def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class Permission(db.Model): id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String(80), unique=True) description = db.Column(db.String(255)) def __str__(self): return self.name @staticmethod def insert_permissions(): data = { 'Root': 'control everything', 'ModifyUser': '******', 'ModifyArticle': 'edit/delete article', 'ModifyComments': 'edit/delete comments', 'ModifyOwnComments': "delete/edit user's own comments. the author of article can also edit/delete " "comments of the article", 'ModifyOwnArticle': "delete/edit user's own article", 'PostArticle': 'post a new article', 'PostComments': 'post a new comment' } for name, description in data.items(): if Permission.query.filter_by(name=name).first() is None: permission = Permission(name=name, description=description) db.session.add(permission) db.session.commit()
class ItemModel(db.Model): __tablename__ = 'items' id = db.Column(db.Integer, primary_key = True) name = 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, name, price, store_id): self.name = name self.price = price self.store_id = store_id def json(self): return {'name': self.name, 'price': self.price} @classmethod def find_by_name(cls, name): return cls.query.filter_by(name=name).first() # select * from items where name={name} limit 1 """ does both insert and update """ def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class CategoryClosureModel(db.Model): __tablename__ = 'category_closure_v2' id = db.Column(db.Integer(), primary_key=True, autoincrement=True, nullable=False) id_ancestor = db.Column(db.String(255), primary_key=False, nullable=False) id_descendant = db.Column(db.String(255), primary_key=False, nullable=False) def __init__(self, id_ancestor, id_descendant): self.id_ancestor = id_ancestor self.id_descendant = id_descendant def json(self): return { 'id_ancestor': self.id_ancestor, 'id_descendant': self.id_descendant } def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_tb(self): db.session.delete(self) db.session.commit()
class User(db.Model): __tablename__ = 'user' id = db.Column(db.Integer(), primary_key=True) username = db.Column(db.String(255), nullable=False, default=None) password = db.Column(db.String(255), default=None, nullable=False, unique=False) fullname = db.Column(db.String(255), default=None, nullable=False, unique=False) @staticmethod def add_user(username, password, fullname): try: user = User(username=username, password=generate_password_hash(password), fullname=fullname) db.session.add(user) db.session.commit() except Exception as e: print(e) return False return True
class FermentablesModel(BaseModel, db.Model, SearchableMixin): """ holds grain database table """ __tablename__ = "fermentable" __searchable__ = ['id', 'brand', 'name', 'lovibond', 'category', 'ppg'] id = db.Column(UUID(as_uuid=True), unique=True, nullable=False, primary_key=True, default=uuid4) brand = db.Column(db.String(80)) name = db.Column(db.String(80), nullable=False) ppg = db.Column(db.Integer(), nullable=False) lovibond = db.Column(db.Float(), nullable=False) category = db.Column(db.String(80), nullable=False) country = db.Column(db.String(80)) user_id = db.Column(UUID(as_uuid=True), db.ForeignKey("user.id"), nullable=False) custom = db.Column(db.Boolean(), default=True) user = db.relationship("UserModel") @classmethod def find_by_ids(cls, ids): """ Takes in a list of ids and returns list of Model objects""" arr = [] for id in ids: try: obj = cls.find_by_id(id) except: continue arr.append(obj) return arr
class contactForm(db.Model): __tablename__ = 'contactmsgs' id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String(100)) email = db.Column(db.String(100)) subject = db.Column(db.String(1000)) message = db.Column(db.String(10000))
class Restaurant(db.Model): __tablename__ = 'restaurants' restaurant_id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String(256)) street_address = db.Column(db.String(256)) city = db.Column(db.String(256)) state = db.Column(db.String(256)) def __init__(self, name, street_address, city, state): self.name = name self.street_address = street_address self.city = city self.state = state def __repr__(self): return '<Restaurant {}>'.format(self.restaurant_id) def serialize(self): return { 'id': self.restaurant_id, 'name': self.name, 'street address': self.street_address, 'city':self.city, 'state':self.state }
class ItemModel(db.Model): __tablename__ = "items" id = db.Column(db.Integer(), primary_key=True) name = 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, name, price, store_id): self.name = name self.price = price self.store_id = store_id def json(self): return {'name': self.name, 'price': self.price} @classmethod def find_by_name(cls, name): return cls.query.filter_by( name=name).first() # SELECT * FROM items WHERE name=name LIMIT 1 def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class UserModel(db.Model): __tablename__ = 'users' id = db.Column(db.Integer(), primary_key=True) password = db.Column(db.String()) username = db.Column(db.String()) def __init__(self, username, password): self.username = username self.password = password @classmethod def find_by_username(cls, username): result = cls.query.filter_by(username=username).first() if result: user = result else: user = None return user @classmethod def find_by_id(cls, _id): result = cls.query.filter_by(id=_id).first() if result: user = result else: user = None return user def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class UserModel(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80)) password = db.Column(db.String(80)) fullName = db.Column(db.String(80)) eMail = db.Column(db.String(80)) phoneNumber = db.Column(db.Integer()) def __init__(self, username, password, fullName, eMail, phoneNumber): self.username = username self.password = password self.fullName = fullName self.eMail = eMail self.phoneNumber = phoneNumber def save_to_db(self): db.session.add(self) db.session.commit() @classmethod def find_by_username(cls, username): return cls.query.filter_by(username=username).first() @classmethod def find_by_id(cls, _id): return cls.query.filter_by(id=_id).first()
class ReviewModel(db.Model): __tablename__ = 'Review' review_id = db.Column(db.Integer(), primary_key=True) title = db.Column(db.String(45), nullable=False) comment = db.Column(db.String(2000), nullable=False) rating = db.Column(db.Float(), nullable=False) date = db.Column(db.DateTime()) cws_id = db.Column(db.Integer(), db.ForeignKey('CoworkingSpace.cws_id'), primary_key=True) coworker_id = db.Column(db.Integer(), db.ForeignKey('Coworker.coworker_id'), primary_key=True) def __init__(self, title, comment, rating, cws_id, coworker_id): self.title = title self.comment = comment self.rating = rating self.cws_id = cws_id self.coworker_id = coworker_id def save_to_db(self): db.engine.execute( "INSERT INTO `Review` (title, comment, rating, cws_id, coworker_id) VALUES (%s,%s,%s,%s,%s)", (self.title, self.comment, self.rating, self.cws_id, self.coworker_id)) @classmethod def get_all(cls): return db.engine.execute("SELECT * FROM Review").fetchall() @classmethod def find_by_id(cls, review_id): return db.engine.execute("SELECT * FROM Review WHERE review_id=%s", (review_id)).fetchone() @classmethod def find_by_cwsId_coworkerId(cls, cws_id, coworker_id): return db.engine.execute( "SELECT * FROM Review WHERE cws_id=%s AND coworker_id=%s", (cws_id, coworker_id)).fetchone() @classmethod def find_by_cwspace(cls, cws_id): return db.engine.execute("SELECT * FROM Review WHERE cws_id=%s", (cws_id)).fetchall()
class CreditModel(db.Model): __tablename__ = 'credit' id = db.Column(db.Integer, primary_key=True) age = db.Column(db.Integer) sex = db.Column(db.String(6)) job = db.Column(db.Integer) housing = db.Column(db.String(4)) saving_accounts = db.Column(db.String(20)) checking_account = db.Column(db.String(20)) credit_amount = db.Column(db.Integer) duration = db.Column(db.Integer()) purpose = db.Column(db.String(20)) risk = db.Column(db.String(20)) def __init__(self, age, sex, job, housing, saving_accounts, checking_account, credit_amount, duration, purpose, risk): self.age = age self.sex = sex self.job = job self.housing = housing self.saving_accounts = saving_accounts self.checking_account = checking_account self.credit_amount = credit_amount self.duration = duration self.purpose = purpose self.risk = risk def json(self): return { 'id': self.id, 'age': self.age, 'sex': self.sex, 'job': self.job, 'housing': self.housing, 'saving_accounts': self.saving_accounts, 'checking_account': self.checking_account, 'credit_amount': self.credit_amount, 'duration': self.duration, 'purpose': self.purpose, 'risk': self.risk } @classmethod def find_by_id(cls, id): return cls.query.filter_by( id=id).first() #posso colocar varios filter_by @classmethod def find_all(cls): return cls.query.all() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class NearbyRestaurant(db.Model): __tablename__ = 'nearbyrestaurants' uid = db.Column(db.Integer(), db.ForeignKey('users.uid'), primary_key=True) restaurant_id = db.Column(db.Integer(), db.ForeignKey('restaurants.restaurant_id'), \ primary_key=True) distance = db.Column(db.Float()) def __init__(self, distance): self.distance = distance def serialize(self): return { 'uid': self.uid, 'restaurant id': self.restaurant_id, 'distance': self.distance }
class Link(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) entered_link = db.Column(db.String(2048)) generated_hash = db.Column(db.String(50)) generated_day = db.Column(db.Date(), default=current_date(), nullable=False) hash_lifetime = db.Column(db.Integer(), default=90, nullable=False)
class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer(), primary_key=True) username = db.Column(db.String(150), unique=True, nullable=False) password = db.Column(db.String(250), unique=True, nullable=False) admin = db.Column(db.Integer(), default=0) def add_to_session(self): """Add self to the session""" return db.session.add(self) @classmethod def find_by_username(cls, username): """Find a record by username and return it""" return cls.query.filter_by(username=username).first()
class UserModel(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) # User email information email = db.Column(db.String(255), nullable=False, unique=True) confirmed_at = db.Column(db.DateTime()) # User information is_enabled = db.Column(db.Boolean(), nullable=False, default=False) first_name = db.Column(db.String(50), nullable=False, default='') last_name = db.Column(db.String(50), nullable=False, default='') birth_year = db.Column(db.Integer(), nullable=False) # User authentication information username = db.Column(db.String(50), nullable=False, unique=True) password = db.Column(db.String(255), nullable=False, default='') # meters = db.relationship('Meter', backref='owner', lazy='dynamic') def __init__(self, email, username, password, first_name, last_name, birth_year): self.email = email self.username = username self.set_password(password) self.first_name = first_name self.last_name = last_name self.birth_year = birth_year @classmethod def find_by_username(cls, username): return cls.query.filter_by(username=username).first() @classmethod def find_by_email(cls, email): return cls.query.filter_by(email=email).first() @classmethod def find_by_id(cls, _id): return cls.query.filter_by(id=_id).first() def save_to_db(self): db.session.add(self) db.session.commit() def is_active(self): return self.is_enabled def set_password(self, password): self.password = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password, password) def json(self): return {'username': self.username, 'email': self.email}