class OrderModel(db.Model):
__tablename__ = 'order'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
create_date = db.Column(db.DATETIME, default=datetime.datetime.utcnow())
customized_message = db.Column(db.String(255))
serial_number_list = db.relationship('SerialNumberModel', back_populates='order', lazy=True)
owner = db.relationship('UserModel', back_populates='order_list')
menus = db.relationship('AssociationModel', back_populates='order')
is_obsolete = db.Column(db.Boolean, default=False)
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def get_by_id(cls, order_id: int):
return cls.query.get(order_id)
@classmethod
def find_valid_by_user(cls, user: UserModel):
return cls.query.filter_by(user_id=user.id, is_obsolete=False)
@classmethod
def find_history_by_user(cls, user: UserModel):
return cls.query.filter_by(user_id=user.id, is_obsolete=True)
class SerialNumberModel(db.Model):
__tablename__ = 'serial_number'
id = db.Column(db.Integer, primary_key=True)
order_id = db.Column(db.Integer, db.ForeignKey('order.id'), nullable=False)
menu_id = db.Column(db.Integer, db.ForeignKey('menu.id'), nullable=False)
serial_number = db.Column(db.String(255), nullable=False)
create_date = db.Column(db.DATETIME, default=datetime.datetime.utcnow())
order = db.relationship('OrderModel', back_populates='serial_number_list')
menu = db.relationship('MenuModel', back_populates='serials')
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_duplicate_link(cls, order_id: int, serial_number: str, menu_id: int):
return cls.query.filter_by(order_id=order_id, serial_number=serial_number, menu_id=menu_id).first()
@classmethod
def find_by_order(cls, order: OrderModel):
return cls.query.filter_by(order_id=order.id)
@classmethod
def get_by_id(cls, serial_id: int):
return cls.query.get(serial_id)
@classmethod
def get_by_serial_number(cls, serial_number: str):
db_result = cls.query.filter_by(serial_number=serial_number).first()
result = None
if db_result:
result = db_result
return result
class AssociationModel(db.Model):
__tablename_ = 'association_menu_order'
menu_id = db.Column(db.Integer, db.ForeignKey('menu.id'), primary_key=True)
order_id = db.Column(db.Integer, db.ForeignKey('order.id'), primary_key=True)
counts = db.Column(db.Integer, default=0)
menu = db.relationship('MenuModel', back_populates='orders')
order = db.relationship('OrderModel', back_populates='menus')
class MenuModel(db.Model):
__tablename__ = 'menu'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
menu_type = db.Column(db.Enum(*MenuTypes.get_enum_labels()), default=MenuTypes.CUSTOMIZED.value) # menu type
coffee_option = db.Column(db.Enum(*CoffeeOption.get_enum_labels()), default=CoffeeOption.CoffeeA.value) # coffee option
owner_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=True)
taste_level = db.Column(db.Enum(*TasteLevels.get_enum_labels()), default=TasteLevels.STANDARD.value) # taste level
water_level = db.Column(db.Enum(*WaterLevels.get_enum_labels()), default=WaterLevels.STANDARD.value) # water level
foam_level = db.Column(db.Enum(*FoamLevels.get_enum_labels()), default=FoamLevels.STANDARD.value) # foam level
grind_size = db.Column(db.Enum(*SizeLevels.get_enum_labels()), default=SizeLevels.MEDIUM.value) # particle size
create_date = db.Column(db.DATETIME, default=datetime.datetime.utcnow())
owner = db.relationship('UserModel', back_populates='menu_list')
orders = db.relationship('AssociationModel', back_populates='menu')
serials = db.relationship('SerialNumberModel', back_populates='menu')
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_by_user(cls, owner: UserModel):
return cls.query.filter_by(owner_id=owner.id)
@classmethod
def get_by_owner_and_id(cls, menu_id: int, owner: UserModel):
return cls.query.filter_by(id=menu_id, owner_id=owner.id).one_or_none()
@classmethod
def get_by_id(cls, menu_id: int):
return cls.query.get(menu_id)
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
author = db.Column(db.String(30))
email = db.Column(db.String(254))
site = db.Column(db.String(255))
body = db.Column(db.Text)
from_admin = db.Column(db.Boolean, default=False)
reviewed = db.Column(db.Boolean, default=False)
timestamp = db.Column(db.DateTime, default=datetime.utcnow, index=True)
replied_id = db.Column(db.Integer, db.ForeignKey('comment.id'))
post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
post = db.relationship('Post', back_populates='comments')
replies = db.relationship('Comment',
back_populates='replied',
cascade='all, delete-orphan')
replied = db.relationship('Comment',
back_populates='replies',
remote_side=[id])
# Same with:
# replies = db.relationship('Comment', backref=db.backref('replied', remote_side=[id]),
# cascade='all,delete-orphan')
# class Link(db.Model):
# id = db.Column(db.Integer, primary_key=True)
# name = db.Column(db.String(30))
# url = db.Column(db.String(255))
class Usuario(UserMixin, db.Model):
def __init__(self, nombre, apellido, email, psw):
self.nombre = nombre
self.apellido = apellido
self.email = email
self.password_hash = generate_password_hash(psw)
usuarioId = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(40), nullable=False)
apellido = db.Column(db.String(30), nullable=False)
email = db.Column(db.String(60), nullable=False)
password_hash = db.Column(db.String(128), nullable=False)
admin = db.Column(db.Boolean, nullable=False, default=False)
eventos = db.relationship("Evento",
back_populates="usuario",
cascade="all, delete-orphan")
comentarios = db.relationship("Comentario",
back_populates="usuario",
cascade="all, delete-orphan")
@property
def password(self):
raise AttributeError('La password no puede leerse')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def get_id(self):
return self.usuarioId
def verificar_pass(self, password):
return check_password_hash(self.password_hash, password)
def __repr__(self):
return str(self.nombre) + ' ' + str(self.apellido)
def is_admin(self): # Comprueba si el usuario es administrador
aux = False
if self.admin == 1:
aux = True
return aux
def is_owner(
self, event_or_coment
): # Comprueba si el usuario es dueño, puede usarse con comentarios o eventos.
aux = False
if self.usuarioId == event_or_coment.usuarioId:
aux = True
return aux
class LabeledDatasetModel(db.Model):
__tablename__ = "labeled_dataset"
__table_args__ = (db.UniqueConstraint("unlabeled_dataset_id",
"user_id",
name="uix_1"), )
id = db.Column(db.Integer, primary_key=True)
unlabeled_dataset_id = db.Column(db.Integer,
db.ForeignKey("unlabeled_dataset.id"))
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
label = db.Column(db.Integer)
user = db.relationship("UserModel", back_populates="evaluations")
evaluation = db.relationship("UnlabeledDatasetModel",
back_populates="users")
@classmethod
def get_unlabeled(cls, user_id):
subquery = (cls.query.filter(cls.user_id == user_id).with_entities(
cls.unlabeled_dataset_id).distinct(cls.unlabeled_dataset_id))
dataset = UnlabeledDatasetModel.query.filter(
~UnlabeledDatasetModel.id.in_(subquery)).all()
return {
"dataset":
list(
map(
lambda row: {
"id": row.id,
"item_1": row.item_1,
"item_2": row.item_2,
},
dataset,
))
}
@classmethod
def get_all(cls):
dataset = UnlabeledDatasetModel.query.all()
return {
"dataset":
list(
map(
lambda row: {
"id": row.id,
"item_1": row.item_1,
"item_2": row.item_2,
},
dataset,
))
}
def save(self):
db.session.add(self)
db.session.commit()
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(60))
body = db.Column(db.Text)
timestamp = db.Column(db.DateTime, default=datetime.utcnow, index=True)
can_comment = db.Column(db.Boolean, default=True)
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category', back_populates='posts')
comments = db.relationship('Comment',
back_populates='post',
cascade='all, delete-orphan')
class Article(db.Model):
__tablename__ = 'article'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255))
content = db.Column(db.Text)
status = db.Column(db.Integer, default=0)
pushtime = db.Column(db.DateTime)
users = db.relationship('User',
secondary=article_user,
backref=db.backref('article'))
types = db.relationship('Type',
secondary=article_type,
backref=db.backref('article'))
class UserModel(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
phone = db.Column(db.String(20), nullable=True)
gender = db.Column(db.Enum(*Gender.get_enum_labels()), default=Gender.NONE.value) # gender
birthday = db.Column(db.Date, nullable=True)
email = db.Column(db.String(255), nullable=False, default="")
menu_list = db.relationship('MenuModel', back_populates='owner', lazy=True)
order_list = db.relationship('OrderModel', back_populates='owner', lazy=True)
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 get_by_id(cls, user_id: int):
return cls.query.get(user_id)
@classmethod
def return_all(cls):
def to_json(x):
return {
'username': x.username,
'email': x.email
}
return {'users': list(map(lambda x: to_json(x), UserModel.query.all()))}
@classmethod
def delete_all(cls):
try:
num_rows_deleted = db.session.query(cls).delete()
db.session.commit()
return {'message': '{} row(s) deleted'.format(num_rows_deleted)}
except:
return {'message': 'Something went wrong'}
@staticmethod
def generate_hash(password):
return sha256.hash(password)
@staticmethod
def verify_hash(password, hash_value):
return sha256.verify(password, hash_value)
class User(db.Model, UserMixin):
id = db.Column(db.String(256))
username = db.Column(db.String(128), primary_key=True)
password = db.Column(db.String(256))
forms = db.relationship('Form', backref='user', lazy=True)
filled_forms = db.relationship('FilledForm', backref='user', lazy=True)
def __init__(self, data):
db_data = data.copy()
db_data['id'] = str(uuid.uuid4())
db_data['password'] = generate_password_hash(data['password'])
super().__init__(**db_data)
def create(self):
for key, value in self.__dict__.items():
if key.startswith('_'):
pass
self.__dict__[key] = value[0] if isinstance(
value, list) else value # workaround for pythonanywhere
db.session.add(self)
try:
db.session.commit()
return True
except IntegrityError:
return False
@staticmethod
def get(username):
return User.query.filter_by(username=username).first()
def detail(self):
return {
'id': self.id,
'name': self.username,
}
@staticmethod
def is_active(**kwargs):
return True
def authenticate(self, password):
return check_password_hash(self.password, password)
def change_pwd(self, password):
self.password = generate_password_hash(password)
db.session.commit()
def get_id(self):
return self.username
class Networks(db.Model):
""" User Model for storing network related details """
__tablename__ = "networks"
id = db.Column(db.Integer, primary_key=True)
key = db.Column(db.String(75))
networkname = db.Column(db.String(50))
vlanid = db.Column(db.String(25))
datacenter = db.Column(db.String(50))
cluster = db.Column(db.String(50))
subnets = db.relationship('NetworkPools', backref='owner', lazy='joined')
network_tag = db.relationship('Tags',
secondary=tags_junction_table,
backref=db.backref('network_tag'),
lazy='dynamic')
class Session(db.Model):
username = db.Column(db.String(256),
db.ForeignKey('user.username'),
nullable=False)
id = db.Column(db.String(256), primary_key=True)
start_time = db.Column(db.DateTime)
end_time = db.Column(db.DateTime)
domains = db.relationship('Domain', backref='session', lazy=True)
def __init__(self, data):
data['start_time'] = cvt_date(data['start_time'])
data['end_time'] = cvt_date(data['end_time'])
super().__init__(**data)
try:
db.session.add(self)
db.session.commit()
except Exception as e:
print(e)
def detail(self):
data = self.__dict__.copy()
del data['_sa_instance_state']
data['domains'] = [domain.detail() for domain in self.domains]
return data
def delete(self):
db.session.delete(self)
db.session.commit()
class PayRecord(db.Model):
__tablename__ = 'pay_record'
id = db.Column(db.Integer, primary_key=True)
pay_time = db.Column(db.DateTime)
amount = db.Column(db.Float)
user = db.relationship('Users', backref='users')
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120), nullable=False, unique=True)
likes = db.relationship('Like', backref='user', lazy=True)
def __repr__(self):
return 'User - {}'.format(self.username)
class User(UserMixin, db.Model):
"""
The users of the system.
"""
__tablename__ = 'User'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(30), nullable=False)
user_name = db.Column(db.String(64), nullable=False, unique=True)
password = db.Column(db.String(128), nullable=False)
db.relationship("Tasks")
def __init__(self, name, user_name, password):
self.name = name
self.user_name = user_name
self.password = password
@staticmethod
def set_password(password):
return generate_password_hash(password)
@staticmethod
def check_password(restored_password, login_given_password):
return check_password_hash(restored_password, login_given_password)
class Employee(db.Model):
__tablename__ = 'employee'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
gender = db.Column(db.String)
mobile = db.Column(db.String)
address = db.Column(db.String)
text = db.Column(db.Text)
c_time = db.Column(db.DateTime)
departmentid = db.Column(db.Integer, db.ForeignKey('department.id'))
department = db.relationship('Department',
backref=db.backref('employees',
lazy='dynamic'))
def __init__(self,
name=None,
gender=None,
mobile=None,
address=None,
text=None,
c_time=None):
self.name = name
self.gender = gender
self.mobile = mobile
self.address = address
self.text = text
self.c_time = datetime.now()
class JingFenClass(BaseModel, db.Model):
"""
京粉类别
"""
__tablename__ = "jingfen_class"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
jd_uid = db.Column(db.String(512), unique=True, nullable=True)
name = db.Column(db.String(512), unique=True, nullable=False)
sub_name = db.Column(db.String(512), nullable=False, default='')
url = db.Column(db.String(512), nullable=False, default='')
pic_url = db.Column(db.String(512), nullable=False, default='')
type = db.Column(db.Integer, unique=False, nullable=False, default=0)
content_skus = db.Column(db.Text, nullable=True, default='')
products = db.relationship('Product', backref='jingfenclass') # 分类下的所有产品
def __init__(self, name=None, jd_uid=None):
self.create_time = self.now
self.update_time = self.now
self.name = name
self.jd_uid = jd_uid
def to_dict(self):
"""将对象转换为字典数据"""
class_dict = {
"class_id": self.id,
"name": self.name,
"sub_name": self.sub_name,
"jd_uid": self.jd_uid,
"url": self.url,
"pic_url": self.pic_url,
"type": self.type,
"create_time": arrow.get(self.create_time).format(),
"content_skus": json.loads(self.create_time)
}
return class_dict
class RecipeModel(db.Model):
__tablename__ = 'recipes'
id = db.Column(db.Integer, primary_key = True)
name = db.Column(db.String(120), unique = True, nullable = False)
ingredients = db.relationship('IngredientModel', backref='associated_ingredient', lazy='dynamic')
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def return_all(cls):
def to_json(x):
return {
'id': x.id,
'name': x.name
}
return {'recipes': list(map(lambda x: to_json(x), RecipeModel.query.all()))}
@property
def serialize(self):
return {
self.name,
}
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def get_reset_token(self, expires_sec=120):
s = Serializer(current_app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
user = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.password}')"
class Product(db.Model):
"""Products for our website"""
pk = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60), nullable=False)
price = db.Column(db.Float, nullable=False)
description = db.Column(db.String(120))
messages = db.relationship("Message", back_populates="product")
def __init__(self, name, price, description):
self.name = name
self.price = price
self.description = description
def __repr__(self):
return "Product {} @ {}".format(self.name, self.price)
def to_dict(self):
return {
"pk": self.pk,
"name": self.name,
"price": self.price,
"description": self.description,
}
class Message(db.Model):
"""Messages for our website"""
__table_args__ = (db.UniqueConstraint("message_type", "product_id",
"version"), )
pk = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(120), nullable=False)
message_type = db.Column(db.String, nullable=False)
version = db.Column(db.String(5), nullable=False)
product_id = db.Column(db.Integer,
db.ForeignKey("product.pk"),
nullable=False)
product = db.relationship("Product", back_populates="messages")
@validates("message_type")
def validate_type(self, key, value):
assert value in MESSAGE_TYPES
return value
def __init__(self, body, message_type):
self.body = body
self.message_type = message_type
@property
def sms_body(self):
return "{}: {!r}".format(self.body, self.product)
def to_dict(self):
return {
"pk": self.pk,
"body": self.body,
"message_type": self.message_type,
"product_id": self.product_id,
}
class Snippets(db.Model):
__tablename__ = 'snippets'
id = db.Column(db.Integer,
nullable=False,
primary_key=True,
autoincrement=True)
name = db.Column(db.String(200), nullable=False, unique=True)
public_flag = db.Column(db.Boolean, nullable=False)
reference = db.Column(db.String(), nullable=False)
description = db.Column(db.Text, nullable=False)
preview = db.Column(db.Text, nullable=False)
born_date = db.Column(db.DateTime())
children_files = db.relationship('Files',
cascade='all, delete',
backref='snippets')
@classmethod
def find_by_name(cls, snippet_name):
return cls.query.filter_by(name=snippet_name).first()
@classmethod
def find_by_id(cls, snippet_id):
return cls.query.filter_by(id=snippet_id).first()
class Hostviews(db.Model):
__tablename__ = 'hostviews'
id = db.Column(db.INTEGER, primary_key=True)
Hostname = db.Column(db.String(50))
Netip = db.Column(db.String(50), unique=True)
Wnetip = db.Column(db.String(50), unique=True)
Cpus = db.Column(db.INTEGER)
Memtotal = db.Column(db.INTEGER)
Service = db.Column(db.String)
env_id = db.Column(db.INTEGER, db.ForeignKey('envviews.id'))
envviews = db.relationship('EnvViews',
backref=db.backref('hostviews', lazy='dynamic'))
def __init__(self, Hostname, Netip, Wnetip, Cpus, Memtotal, Service,
env_id):
self.Hostname = Hostname
self.Netip = Netip
self.Wnetip = Wnetip
self.Cpus = Cpus
self.Memtotal = Memtotal
self.Service = Service
self.env_id = env_id
def __repr__(self):
return '<主机信息：{} {}>'.format(self.Hostname, self.Netip)
class Poet(db.Model):
"""Define the poets table."""
__tablename__ = 'poets'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True, nullable=False)
poems = db.relationship('Poem', backref='author', lazy='dynamic')
def __repr__(self):
"""Represent the class."""
return f"<Poet '{self.name}'>"
@staticmethod
def insert_samples():
"""
Insert some sample poets into the database.
Idempotent.
"""
POETS = ['John Keats', 'Edward Lear', 'John Donne', 'Wilfred Owen']
needs_commit = False
for poet in POETS:
if Poet.query.filter_by(name=poet).first() is None:
db.session.add(Poet(name=poet))
print(f"Adding poet '{poet}' to database.")
needs_commit = True
if needs_commit:
db.session.commit()
print("Changes committed.")
class Comentario(db.Model):
comentarioId = db.Column(db.Integer, primary_key=True)
contenido = db.Column(db.String(350), nullable=False)
fechahora = db.Column(db.DateTime,
nullable=False,
default=db.func.current_timestamp())
usuario = db.relationship("Usuario", back_populates="comentarios")
usuarioId = db.Column(db.Integer,
db.ForeignKey('usuario.usuarioId'),
nullable=False)
evento = db.relationship("Evento", back_populates="comentarios")
eventoId = db.Column(db.Integer,
db.ForeignKey('evento.eventoId'),
nullable=False)
def to_json(self):
comentario_json = {
'comentarioId':
url_for('apiGetComentarioById',
id=self.comentarioId,
_external=True),
'usuario':
self.usuario.nombre + ' ' + self.usuario.apellido,
'contenido':
self.contenido,
'evento':
url_for('apiGetEventoById', id=self.eventoId, _external=True)
}
return comentario_json
@staticmethod
def from_json(comentario_json):
usuario = comentario_json.get('usuario')
contenido = comentario_json.get('contenido')
evento = comentario_json.get('evento')
return Comentario(usuario=usuario, contenido=contenido, evento=evento)
class Role(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20), nullable=False)
authorisation = db.Column(db.String(60), default='user', unique=True)
users = db.relationship('User', backref='role')
def __repr__(self):
return '<Role %r>' % self.name
class Emergency(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(100))
last_name = db.Column(db.String(100))
phone = db.Column(db.String(100))
alt_phone = db.Column(db.String(100))
token = db.Column(db.String(255))
kids = db.relationship('Kids', backref='emergency')
class Users(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(50), nullable=False)
todos = db.relationship('Todo', backref='owner', lazy=True)
def __repr__(self):
return "<Users %r %r %r>" % self.username
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
first_name = db.Column(db.String(80), nullable=False)
middle_name = db.Column(db.String(80))
surname = db.Column(db.String(80), nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
photoname = db.Column(db.String(120), nullable=True)
role_id = db.Column(db.Integer, db.ForeignKey('role.id'), nullable=False)
role = db.relationship('Role', backref=db.backref('users', lazy=True))
general_info = db.relationship('GeneralInfo',
backref=db.backref('users', lazy=True))
highschool_info = db.relationship('HighschoolInfo',
backref=db.backref('users', lazy=True))
population_info = db.relationship('PopulationInfo',
backref=db.backref('users', lazy=True))
university_info = db.relationship('UniversityInfo',
backref=db.backref('users', lazy=True))
family = db.relationship('Family', backref=db.backref('users', lazy=True))
interests = db.relationship('Interests',
backref=db.backref('users', lazy=True))
def __repr__(self):
return "<User {0!r}>".format(self.username)
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
