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}
