class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True, nullable=False, default='')
email = db.Column(db.String(120), unique=True, nullable=False)
company = db.Column(db.String(120),
unique=False,
nullable=False,
default='')
tel = db.Column(db.String(120), unique=False, nullable=False, default='')
address1 = db.Column(db.String(255),
unique=False,
nullable=True,
default='')
address2 = db.Column(db.String(255),
unique=False,
nullable=True,
default='')
city = db.Column(db.String(50), unique=False, nullable=True, default='')
state = db.Column(db.String(50), unique=False, nullable=True, default='')
zip = db.Column(db.String(50), unique=False, nullable=True, default='')
country = db.Column(db.String(50), unique=False, nullable=True, default='')
password = db.Column(db.String(60), nullable=False)
verified = db.Column(db.Boolean, default=False, nullable=True)
role = db.Column(db.Integer, nullable=False,
default=0) # 0: client, 1: admin
date_registered = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
user_services = db.relationship('UserService', backref='user', lazy=True)
def __repr__(self):
return f"User('{self.email}')"
class Answer(db.Model):
__tablename__ = 'answer'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
content = db.Column(db.Text, nullable=False)
create_time = db.Column(db.DateTime, default=datetime.now)
question_id = db.Column(db.Integer, db.ForeignKey('question.id'))
author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
question = db.relationship('Question',
backref=db.backref('answers',
order_by=id.desc()))
author = db.relationship('User', backref=db.backref('answers'))
# if __name__ == '__main__':
# # db.create_all()
# pass
class Label(db.Model):
'''标签表'''
__tablename__ = 'label'
label_id = db.Column(db.Integer, primary_key=True,
autoincrement=True) #标签id
label_name = db.Column(db.String(30)) # 标签名称
article_infos = db.relationship('Article', backref='label', lazy='dynamic')
class Phone(db.Model):
__tablename__ = "phone"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
model = db.Column(db.String(32))
price = db.Column(db.String(32))
company_name = db.Column(
db.String(20), db.ForeignKey('company.name')) # 创建与company.name关联的外键
company = db.relationship("Company", backref="phone_of_company")
class Role(db.Model):
__tablename__ = 'role'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
users = db.relationship('User', backref='role', lazy=True)
def serialize(self):
return {"id": self.id, "name": self.name, "users": self.users}
class Tournament(db.Model):
__tablename__ = 'tournament'
id = db.Column(db.Integer, primary_key=True)
city_id = db.Column(db.Integer, db.ForeignKey('city.id'))
date = db.Column(db.Date, nullable=False)
name = db.Column(db.String(32), nullable=False)
info = db.Column(db.Text)
matches = db.relationship("Match")
participants = db.relationship("TournamentPlayer")
def __repr__(self):
return f"Tournament: {self.name}"
def __str__(self):
return f"{self.name} {self.date}"
class Role(db.Model):
__tablename__ = 'tb_roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True, nullable=False, index=True)
users = db.relationship('User', backref='role', lazy='dynamic')
def __str__(self):
return 'Role is: {}'.format(self.name)
class ClassyText(db.Model):
__tablename__ = 'classy_texts'
id = db.Column(db.Integer, primary_key=True)
file_name = db.Column(db.String(1000))
file_created = db.Column(db.DateTime())
classification_text = db.Column(db.Text())
last_updated = db.Column(db.DateTime())
classy_job_id = db.Column(db.Integer, db.ForeignKey('classy_jobs.id'))
training_items = db.relationship("ClassyTrainingItem")
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(80), nullable=False)
events = db.relationship('Events', backref='author', lazy=True)
def __repr__(self):
return 'User {} and Id {}'.format(self.username, self.id)
class Question(db.Model):
__tablename__ = 'question'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(100), nullable=False)
content = db.Column(db.Text, nullable=False)
# now()获取的是服务器第一次运行的时间
# now就是每次创建一个模型的时候，都获取当前的时间
create_time = db.Column(db.DateTime, default=datetime.now)
author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
author = db.relationship('User', backref=db.backref('questions'))
class Issue(db.Model):
"""This class is used for issues table in database."""
__tablename__ = 'issues'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text)
user_id = db.Column(db.ForeignKey(u'users.id'), index=True)
category_id = db.Column(db.ForeignKey(u'category.id'),
nullable=False,
index=True)
location = db.Column(db.Text)
description = db.Column(db.Text)
open_date = db.Column(db.Date)
close_date = db.Column(db.Date)
delete_date = db.Column(db.Date)
category = db.relationship(u'Category')
user = db.relationship(u'User')
class Attachment(db.Model):
"""This class is used for attachment table in database."""
__tablename__ = 'attachments'
id = db.Column(db.Integer, primary_key=True)
issue_id = db.Column(db.ForeignKey(u'issues.id'), index=True)
image_url = db.Column(db.Text)
delete_date = db.Column(db.Date)
issue = db.relationship(u'Issue')
class Sport(db.Model): # hasta aca estan ok las relaciones
__tablename__ = 'sport'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
# clasificados = db.relationship('Clasificado', backref='sport', lazy=True)
user_sport = db.relationship('UserSport', backref='sport', lazy=True)
def serialize(self):
return {
"id": self.id,
"name": self.name,
}
class User(db.Model):
"""This class is used for user table in database."""
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text)
alias = db.Column(db.Text)
email = db.Column(db.Text)
password = db.Column(db.Text)
role_id = db.Column(db.ForeignKey(u'roles.id'), index=True)
avatar = db.Column(db.Text)
delete_date = db.Column(db.Date)
role = db.relationship(u'Role')
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(100))
last_name = db.Column(db.String(100))
email = db.Column(db.String(100), unique=True)
password = db.Column(db.String(100))
phone_number = db.Column(db.Integer)
opportunities = db.relationship('Opportunity', backref='client')
def __init__(self, first_name, last_name, email, password, phone_number):
self.first_name = first_name
self.last_name = last_name
self.email = email
self.password = password
self.phone_number = phone_number
class Player(db.Model):
__tablename__ = 'player'
id = db.Column(db.Integer, primary_key=True)
city_id = db.Column(db.Integer, db.ForeignKey('city.id'))
pin = db.Column(db.String, unique=True)
full_name = db.Column(db.String(64))
japanese_rank = db.Column(db.String(3))
national_rank = db.Column(db.String(5))
is_active = db.Column(db.Boolean, default=True)
ratings = db.relationship("TournamentPlayer")
def __repr__(self):
return f'Player: {self.first_name} {self.last_name}'
def __str__(self):
return f'{self.first_name} {self.last_name}'
class Show(db.Model):
__tablename__ = 'shows'
show_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
show_date = db.Column(db.Date, nullable=False)
show_venue = db.Column(db.String, nullable=False)
sales = db.relationship('Sales', backref='shows', cascade='all, delete-orphan', lazy='dynamic')
# sales = db.relationship('sales', backref='shows', passive_deletes=True)
# sales = db.relationship("Sales", cascade="save-update, merge, delete")
def __init__(self, date, venue):
self.show_date = date
self.show_venue = venue
def __repr__(self):
template = 'id: {} date: {} venue: {}'
return template.format(self.show_id, self.show_date, self.show_venue)
class Merch(db.Model):
__tablename__ = 'merch'
merch_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
merch_name = db.Column(db.String, nullable=False, unique=True)
merch_cost = db.Column(db.Float, nullable=False)
merch_descr = db.Column(db.VARCHAR, nullable=False)
sales = db.relationship('Sales', backref='merch', cascade='all, delete-orphan', lazy='dynamic')
#
# sales = db.relationship('Sales', cascade="save-update, merge, delete")
# sales = db.relationship('sales', backref='merch', passive_deletes=True)
def __init__(self, name, cost, descr):
self.merch_name = name
self.merch_cost = cost
self.merch_descr = descr
def __repr__(self):
template = 'id: {} name: {} cost: {} description: {}'
return template.format(self.merch_id, self.merch_name, self.merch_cost, self.merch_descr)
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
userslalala = db.relationship('User', backref='rolelalala')
class User(db.Model):
""" User Model for storing user related details """
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(255), unique=True, nullable=False)
registered_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow())
first_name = db.Column(db.String(100), nullable=False)
last_name = db.Column(db.String(100), nullable=False)
password_hash = db.Column(db.String(100), nullable=False)
birthdate = db.Column(db.DateTime)
#dia_hora = db.Column(db.DateTime)
bio = db.Column(db.String(100))
phones = db.Column(db.String(100))
gender = db.Column(db.String(100))
status = db.Column(db.Boolean, default=True)
role_id = db.Column(db.Integer, db.ForeignKey('role.id'), nullable=False)
photo = db.Column(db.String(100), default='without-photo.png')
user_sports = db.relationship('UserSport', backref='user', lazy=True)
#friends = db.relationship('Friend', backref='user', lazy=True)
def serialize(self):
return {
"id": self.id,
"firstname": self.first_name,
"lastname": self.last_name,
"email": self.email,
"bio": self.bio,
"phones": self.phones,
"status": self.status,
"birthdate": self.birthdate,
"gender": self.gender,
"role": self.role_id,
#"dia_hora": self.dia_hora,
"photo": self.photo,
"sports": self.get_all_sports()
}
def get_all_sports(self):
sports = list(map(lambda sport: sport.serialize(), self.user_sports))
return sports
@property
def password(self):
raise AttributeError('password: write-only field')
@password.setter
def password(self, password):
self.password_hash = flask_bcrypt.generate_password_hash(
password).decode('utf-8')
def check_password(self, password):
return flask_bcrypt.check_password_hash(self.password_hash, password)
def encode_auth_token(self):
"""
Generates the Auth Token
:return: string
"""
try:
payload = {
'exp': datetime.utcnow() + timedelta(days=1, seconds=5),
'iat': datetime.utcnow(),
'sub': self.id,
'role': self.role_id,
'firstName': self.first_name,
'email': self.email
}
return jwt.encode(payload, key, algorithm='HS256')
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
"""
Decodes the auth token
:param auth_token:
:return: integer|string
"""
try:
payload = jwt.decode(auth_token, key)
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
def __repr__(self):
return "<User '{}'>".format(self.username)
def save_changes(self):
db.session.add(self)
db.session.commit()