class CanPartTime(db.Model):
ccontact = db.Column(db.Integer,
db.ForeignKey('users.contact', ondelete='CASCADE'),
primary_key=True)
isparttime = db.Column(db.Boolean, nullable=False)
class notificationruletemplate(db.Model):
rule_template_id = db.Column(db.Integer(), primary_key=True)
templates = db.Column(db.String(20))
notifrules = db.relationship("notificationrules",
backref="notificationruletemplate",
lazy="dynamic")
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), unique=True)
password = db.Column(db.String(100))
notes = db.relationship('Note')
class Purchase(db.Model):
__tablename__ = 'purchases'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String)
confirmed = db.Column(db.String)
public_key = db.Column(db.String)
class notification2searchstring(db.Model):
id = db.Column(db.Integer, primary_key=True)
notification_uuid = db.Column(
db.String(20), db.ForeignKey("notificationheaders.notification_uuid"))
searchstring_uuid = db.Column(db.String(20))
class Order(db.Model):
__tablename__ = 'orders'
id = db.Column(db.Integer, primary_key=True)
creationDate = db.Column(db.Date, default = datetime.date.today())
status = db.Column(db.Enum(OrderStatus))
userId = db.Column(db.Integer, ForeignKey('users.id'))
user = relationship("User", back_populates = "orders")
products = relationship('OrderHasProducts', back_populates="order", lazy = "joined", cascade="all, delete-orphan")
snapshots = relationship("ProductSnapshot", back_populates="order")
def get_products(self):
if self.status == OrderStatus.Ongoing:
return self.products
else:
return self.snapshots
def finalize(self):
if self.status != OrderStatus.Ongoing:
return False
if len(self.products) == 0:
return False
for orderHasProduct in self.products:
if orderHasProduct.product.quantity < orderHasProduct.quantity:
return False
orderHasProduct.product.quantity -= orderHasProduct.quantity
self.snapshots = [ProductSnapshot(code = x.code, quantity = x.quantity, price = x.price, orderId = self.id, name = x.name) for x in self.products]
self.products = []
self.status = OrderStatus.Finalized
return True
def calculate_total_price(self):
if len(self.products) == 0:
sum = 0
for p in self.snapshots:
sum += p.price * p.quantity
return sum
else:
sum = 0
for p in self.products:
sum += p.product.price * p.quantity
return sum
def decide(self, isAccepted, service: OrderRequestService):
if self.status != OrderStatus.Finalized:
return
self.status = OrderStatus.Accepted if isAccepted else OrderStatus.Declined
if isAccepted:
service.request_products(self.snapshots)
else:
products = {p.code : p for p in Product.query.all()}
for snapshot in self.snapshots:
product = products[snapshot.code]
product.quantity += snapshot.quantity
class User(UserMixin,db.Model):
__tablename__='users'
id=db.Column(db.Integer,primary_key=True)
email=db.Column(db.String(64),unique=True,index=True)
username=db.Column(db.String(64),unique=True,index=True)
password_hash=db.Column(db.String(128))
#建立关系表
role_id=db.Column(db.Integer,db.ForeignKey('roles.id'))
confirmed=db.Column(db.Boolean,default=False)
#跟goal建立关联
goals=db.relationship('Goal',backref='user',lazy='dynamic')
#用户信息字段
name=db.Column(db.String(64))
location=db.Column(db.String(64))
about_me=db.Column(db.Text())
member_since=db.Column(db.Datetime(),default=datetime.utcnow)
last_seen=db.Column(db.DateTime(),default=datetime.utcnow())
#增加用户头像数据
avatar_hash=db.Column(db.String(32))
def __repr__(self):
return '<User %r>'%self.username
def __init__(self,**kwargs):
super(User,self).__init__(**kwargs)
#初始化使用缓存的MD5散列值生成Gravatar URL
if self.email is not None and self.avatar_hash is None:
self.avatar_hash=hashlib.md5(self.email.encode('utf-8')).hexdigest()
@property
def password(self):
raise AttributeError('password is not a readable attribute')
@password.setter
def password(self,password):
self.password_hash=generate_password_hash(password)
def verify_password(self,password):
return check_password_hash(self.password_hash,password)
def generate_confirmation_token(self,expiration=3600):
s=Serializer(current_app.config['SECRET_KEY'],expiration)
return s.dumps({'confirm':self.id})
def confirm(self,token):
s=Serializer(current_app.config['SECRET_KEY'])
try:
data=s.loads(token)
except:
return False
if data.get('confirm')!=self.id:
return False
self.confirmed=True
db.session.add(self)
return True
#刷新用户的最后访问时间
def ping(self):
self.last_seen=datetime.utcnow()
db.session.add(self)
#定义默认的用户角色
if self.role is None:
if self.email==current_app.config['FLASKY_ADMIN']:
self.role=Role.query.filter_by(permissions=0xff).first()
if self.role is None:
self.role=Role.query.filter_by(default=True).first()
#检查用户是否有指定权限
def can(self,permissions):
return self.role is not None and\
(self.role.permission & permissions)==permissions
def is_administrator(self):
return self.can(Permission.ADMINISTER)
#生成用户头像
def gravatar(self,size=100,default='identicon',rating='g'):
if request.is_secure:
url='http://secure.gravatar.com/avatar'
else:
url='http://www.gravatar.com/avatar'
hash=hashlib.md5(self.email.encode('utf-8')).hexdigest()
return '{url}/{hash}?s={size}&d={default}&r={rating}'.format(
url=url,hash=hash,size=size,default=default,rating=rating)
def change_email(self,token):
self.email=new_email
self.avatar_hash=hashlib.md5(self.email.encode('utf-8')).hexdigest()
db.session.add(self)
return True
def gravatar(self,size=100,default='identicon',rating='g'):
if request.is_secure:
url='http://secure.gravatar.com/avatar'
else:
url='http://www.gravatar.com/avatar'
hash=self.avatar_hash or hashlib.md5(self.email.encode('utf-8')).hexdigest()
return '{url}/{hash}?s={size}&d={default}&r={rating}'.format(url=url,hash=hash,size=size,default=default,rating=rating)
class Player(db.Model):
'''
Information about player
Information includes name, picture, position, player number, weight etc.
'''
query_class = ArticleQuery
# __tablename__ = 'Player'
# __searchable__ = ['name', 'picture', 'experience_years', 'draft_info', 'position', 'player_number', 'current_team', 'college', 'birth_info', 'weight', 'twitter', 'age', 'team_name'] # these fields will be indexed by whoosh
# __analyzer__ = SimpleAnalyzer() # configure analyzer; defaults to
# StemmingAnalyzer if not specified
id = db.Column(db.Integer, primary_key=True, unique=True, index=True)
name = db.Column(db.String(256))
picture = db.Column(db.String(256), unique=True)
experience_years = db.Column(db.String(256))
draft_info = db.Column(db.String(256))
position = db.Column(db.String(256))
player_number = db.Column(db.String(256))
current_team = db.Column(db.String(256))
college = db.Column(db.String(256))
birth_info = db.Column(db.String(256))
weight = db.Column(db.String(256))
twitter = db.Column(db.String(256))
age = db.Column(db.String(256))
youtube_link_1 = db.Column(db.String(256))
youtube_link_2 = db.Column(db.String(256))
youtube_link_3 = db.Column(db.String(256))
career_GS = db.Column(db.String(256))
career_REB = db.Column(db.String(256))
career_BLK = db.Column(db.String(256))
career_FT_PCT = db.Column(db.String(256))
career_DR = db.Column(db.String(256))
career_MIN = db.Column(db.String(256))
career_FG_PCT = db.Column(db.String(256))
career_3PM_A = db.Column(db.String(256))
career_OR = db.Column(db.String(256))
career_FGM_A = db.Column(db.String(256))
career_STL = db.Column(db.String(256))
career_TO = db.Column(db.String(256))
career_3PM_PCT = db.Column(db.String(256))
career_AST = db.Column(db.String(256))
career_GP = db.Column(db.String(256))
career_PF = db.Column(db.String(256))
career_PTS = db.Column(db.String(256))
CAREER_FTM_A = db.Column(db.String(256))
season_TO = db.Column(db.String(256))
season_GS = db.Column(db.String(256))
season_FG_PCT = db.Column(db.String(256))
season__PTS = db.Column(db.String(256))
season_OR = db.Column(db.String(256))
season_GP = db.Column(db.String(256))
season_PF = db.Column(db.String(256))
season_REB = db.Column(db.String(256))
season_FTM_A = db.Column(db.String(256))
season_BLK = db.Column(db.String(256))
season_MIN = db.Column(db.String(256))
season_STL = db.Column(db.String(256))
season_AST = db.Column(db.String(256))
season_FT_PCT = db.Column(db.String(256))
season_FGM_A = db.Column(db.String(256))
season_3P_PCT = db.Column(db.String(256))
season_DR = db.Column(db.String(256))
season_3PM_A = db.Column(db.String(256))
citation = db.Column(db.String(256))
team_name = db.Column(db.String(256), db.ForeignKey('team.name'))
search_vector = db.Column(
TSVectorType('name', 'position', 'player_number', 'current_team',
'weight', 'twitter', 'age', 'team_name'))
# __table_args__ = {'mysql_engine':'MyISAM', 'mysql_charset':'utf8', 'mysql_row_format':'dynamic'}
@property
def serialize(self):
return {
"id": self.id,
"name": self.name,
"picture": self.picture,
"experience_years": self.experience_years,
"draft_info": self.draft_info,
"position": self.position,
"player_number": self.player_number,
"current_team": self.current_team,
"college": self.college,
"birth_info": self.birth_info,
"weight": self.weight,
"twitter": self.twitter,
"age": self.age,
"youtube_link_1": self.youtube_link_1,
"youtube_link_2": self.youtube_link_2,
"youtube_link_3": self.youtube_link_3,
"career_GS": self.career_GS,
"career_REB": self.career_REB,
"career_BLK": self.career_BLK,
"career_FT_PCT": self.career_FT_PCT,
"career_DR": self.career_DR,
"career_MIN": self.career_MIN,
"career_FG_PCT": self.career_FG_PCT,
"career_3PM_A": self.career_3PM_A,
"career_OR": self.career_OR,
"career_FGM_A": self.career_FGM_A,
"career_STL": self.career_STL,
"career_TO": self.career_TO,
"career_3PM_PCT": self.career_3PM_PCT,
"career_AST": self.career_AST,
"career_GP": self.career_GP,
"career_PF": self.career_PF,
"career_PTS": self.career_PTS,
"CAREER_FTM_A": self.CAREER_FTM_A,
"season_TO": self.season_TO,
"season_GS": self.season_GS,
"season_FG_PCT": self.season_FG_PCT,
"season__PTS": self.season__PTS,
"season_OR": self.season_OR,
"season_GP": self.season_GP,
"season_PF": self.season_PF,
"season_REB": self.season_REB,
"season_FTM_A": self.season_FTM_A,
"season_BLK": self.season_BLK,
"season_MIN": self.season_MIN,
"season_STL": self.season_STL,
"season_AST": self.season_AST,
"season_FT_PCT": self.season_FT_PCT,
"season_FGM_A": self.season_FGM_A,
"season_3P_PCT": self.season_3P_PCT,
"season_DR": self.season_DR,
"season_3PM_A": self.season_3PM_A,
"citation": self.citation,
"team_name": self.team_name,
}
class Game(db.Model):
'''
Information about Game
Information include home_team, away_team, data, home_score, away_score, etc.
'''
query_class = ArticleQuery
# __tablename__ = 'Game'
# __searchable__ = ['home_team', 'away_team', 'date_string', 'home_score', 'away_score'] # these fields will be indexed by whoosh
# __analyzer__ = SimpleAnalyzer() # configure analyzer; defaults to
# StemmingAnalyzer if not specified
id = db.Column(db.Integer, primary_key=True, unique=True, index=True)
home_team = db.Column(db.String(256))
away_team = db.Column(db.String(256))
date = db.Column(BIGINT())
date_string = db.Column(db.String(256))
home_score = db.Column(db.String(256))
away_score = db.Column(db.String(256))
home_box_fgm = db.Column(db.String(256))
home_box_fga = db.Column(db.String(256))
home_box_fg3m = db.Column(db.String(256))
home_box_fg3a = db.Column(db.String(256))
home_box_ftm = db.Column(db.String(256))
home_box_fta = db.Column(db.String(256))
home_box_oreb = db.Column(db.String(256))
home_box_dreb = db.Column(db.String(256))
home_box_ast = db.Column(db.String(256))
home_box_stl = db.Column(db.String(256))
home_box_blk = db.Column(db.String(256))
home_box_to = db.Column(db.String(256))
home_box_pf = db.Column(db.String(256))
home_box_pts = db.Column(db.String(256))
home_box_plus_minus = db.Column(db.String(256))
away_box_fgm = db.Column(db.String(256))
away_box_fga = db.Column(db.String(256))
away_box_fg3m = db.Column(db.String(256))
away_box_fg3a = db.Column(db.String(256))
away_box_ftm = db.Column(db.String(256))
away_box_fta = db.Column(db.String(256))
away_box_oreb = db.Column(db.String(256))
away_box_dreb = db.Column(db.String(256))
away_box_ast = db.Column(db.String(256))
away_box_stl = db.Column(db.String(256))
away_box_blk = db.Column(db.String(256))
away_box_to = db.Column(db.String(256))
away_box_pf = db.Column(db.String(256))
away_box_pts = db.Column(db.String(256))
away_box_plus_minus = db.Column(db.String(256))
youtube_link_1 = db.Column(db.String(256))
youtube_link_2 = db.Column(db.String(256))
youtube_link_3 = db.Column(db.String(256))
search_vector = db.Column(
TSVectorType('home_team', 'away_team', 'date_string', 'home_score',
'away_score'))
# __table_args__ = {'mysql_engine':'MyISAM', 'mysql_charset':'utf8', 'mysql_row_format':'dynamic'}
@property
def serialize(self):
return {
"id": self.id,
"home_team": self.home_team,
"away_team": self.away_team,
"date": self.date,
"date_string": self.date_string,
"home_score": self.home_score,
"away_score": self.away_score,
"home_box_fgm": self.home_box_fgm,
"home_box_fga": self.home_box_fga,
"home_box_fg3m": self.home_box_fg3m,
"home_box_fg3a": self.home_box_fg3a,
"home_box_ftm": self.home_box_ftm,
"home_box_fta": self.home_box_fta,
"home_box_oreb": self.home_box_oreb,
"home_box_dreb": self.home_box_dreb,
"home_box_ast": self.home_box_ast,
"home_box_stl": self.home_box_stl,
"home_box_blk": self.home_box_blk,
"home_box_to": self.home_box_to,
"home_box_pf": self.home_box_pf,
"home_box_pts": self.home_box_pts,
"home_box_plus_minus": self.home_box_plus_minus,
"away_box_fgm": self.away_box_fgm,
"away_box_fga": self.away_box_fga,
"away_box_fg3m": self.away_box_fg3m,
"away_box_fg3a": self.away_box_fg3a,
"away_box_ftm": self.away_box_ftm,
"away_box_fta": self.away_box_fta,
"away_box_oreb": self.away_box_oreb,
"away_box_dreb": self.away_box_dreb,
"away_box_ast": self.away_box_ast,
"away_box_stl": self.away_box_stl,
"away_box_blk": self.away_box_blk,
"away_box_to": self.away_box_to,
"away_box_pf": self.away_box_pf,
"away_box_pts": self.away_box_pts,
"away_box_plus_minus": self.away_box_plus_minus,
"youtube_link_1": self.youtube_link_1,
"youtube_link_2": self.youtube_link_2,
"youtube_link_3": self.youtube_link_3,
}
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
password = db.Column(db.String(20))
email = db.Column(db.String(120), index=True, unique=True)
regdate = db.Column(db.DateTime)
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime)
posts = db.relationship('Post', backref='author', lazy='dynamic')
followed = db.relationship('User',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
@property
def is_authenticated(self):
return True
@property
def is_active(self):
return True
@property
def is_anonymous(self):
return False
def get_id(self):
try:
return unicode(self.id) # python 2
except NameError:
return str(self.id) # python 3
def __repr__(self):
return '<User %r>' % (self.username)
# Newly added for user avatars
def avatar(self, size):
return 'http://www.gravatar.com/avatar/%s?d=mm&s=%d' % (md5(
self.email.encode('utf-8')).hexdigest(), size)
#to make the username unique
@staticmethod
def make_unique_username(username):
if User.query.filter_by(username=username).first() is None:
return username
version = 2
while True:
new_username = username + str(version)
if User.query.filter_by(username=new_username).first() is None:
break
version += 1
return new_username
#follow and unfollow
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
return self
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
return self
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
return Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id).order_by(
Post.timestamp.desc())
class Team(db.Model):
'''
Information about Team
Information includes name, conference, division, site_name, city, state, mascot
'''
query_class = ArticleQuery
# __tablename__ = 'Team'
# __searchable__ = ['name', 'conference', 'division', 'site_name', 'city', 'state', 'mascot', 'twitter', 'google_maps'] # these fields will be indexed by whoosh
# __analyzer__ = SimpleAnalyzer() # configure analyzer; defaults to
# StemmingAnalyzer if not specified
players = db.relationship('Player', backref='team', lazy='dynamic')
name = db.Column(db.String(256), primary_key=True)
conference = db.Column(db.String(256))
division = db.Column(db.String(256))
site_name = db.Column(db.String(256))
city = db.Column(db.String(256))
state = db.Column(db.String(256))
mascot = db.Column(db.String(256))
twitter = db.Column(db.String(256))
citation = db.Column(db.String(256))
google_maps = db.Column(db.String(256))
search_vector = db.Column(TSVectorType('name', 'conference', 'division'))
# __table_args__ = {'mysql_engine':'MyISAM', 'mysql_charset':'utf8', 'mysql_row_format':'dynamic'}
@property
def serialize(self):
return {
"players": [i.serialize for i in self.players],
"name": self.name,
"conference": self.conference,
"division": self.division,
"site_name": self.site_name,
"city": self.city,
"state": self.state,
"mascot": self.mascot,
"twitter": self.twitter,
"citation": self.citation,
"google_maps": self.google_maps,
}
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return '<Post %r>' % (self.body)
if enable_search:
whooshalchemy.whoosh_index(app, Post)
#static table
followers = db.Table(
'followers', db.Column('follower_id', db.Integer,
db.ForeignKey('user.id')),
db.Column('followed_id', db.Integer, db.ForeignKey('user.id')))
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
password = db.Column(db.String(20))
email = db.Column(db.String(120), index=True, unique=True)
regdate = db.Column(db.DateTime)
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime)
posts = db.relationship('Post', backref='author', lazy='dynamic')
followed = db.relationship('User',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
class categories(db.Model, UserMixin):
category = db.Column(db.String, primary_key=True, nullable=False)
petcat = db.relationship('Pets', backref='type')
cantakecarecat = db.relationship('CanTakeCare', backref='type')
class Role(db.Model):
name = db.Column(db.String, primary_key=True, nullable=False, unique=True)
class Topping(db.Model):
__tablename__ = 'toppings'
id = db.Column(db.Integer, primary_key=True, index=True)
name = db.Column(db.String(25), unique=True)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True) # primary keys are required by SQLAlchemy
email = db.Column(db.String(100), unique=True)
password = db.Column(db.String(100))
name = db.Column(db.String(1000))
class Request(db.Model):
__tablename__ = 'requests'
id = db.Column(db.Integer, primary_key=True, index=True)
email = db.Column(db.String(50), unique=True)
time = db.Column(db.String(20))
class Player(db.Model):
__tablename__ = 'players'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(), nullable=False)
first_name = db.Column(db.String())
last_name = db.Column(db.String())
alternate_first_name_1 = db.Column(db.String())
alternate_first_name_2 = db.Column(db.String())
alternate_first_name_3 = db.Column(db.String())
alternate_last_name_1 = db.Column(db.String())
alternate_last_name_2 = db.Column(db.String())
alternate_last_name_3 = db.Column(db.String())
date_of_birth = db.Column(db.Date)
place_of_birth = db.Column(db.String())
nationality = db.Column(db.String())
second_nationality = db.Column(db.String())
position = db.Column(db.String(1))
shoots = db.Column(db.String())
player_type = db.Column(db.String())
position = db.Column(db.String())
seasons = db.relationship('Season', secondary='player_stats')
class Plan(db.Model):
__tablename__='plans'
id=db.Column(db.Integer,primary_key=True)
step=db.Column(db.String(64))
completion=db.Column(db.Boolean)
class TeamStats(db.Model):
__tablename__ = 'team_stats'
games_played = db.Column(db.Integer)
wins = db.Column(db.Integer)
losses = db.Column(db.Integer)
ties = db.Column(db.Integer)
overtime_wins = db.Column(db.Integer)
overtime_losses = db.Column(db.Integer)
shootout_wins = db.Column(db.Integer)
points = db.Column(db.Integer)
goals_forward = db.Column(db.Integer)
goals_against = db.Column(db.Integer)
team_id = db.Column(db.ForeignKey('teams.id'), primary_key=True)
team = db.relationship('Team', backref='team_stats')
season_id = db.Column(db.ForeignKey('seasons.id'), primary_key=True)
season = db.relationship('Season', backref='team_stats')
class Driver(db.Model):
username = db.Column(db.String, primary_key=True)
d_rating = db.Column(db.String)
class PlayerStats(db.Model):
__tablename__ = 'player_stats'
age = db.Column(db.Integer)
cap_hit = db.Column(db.Integer)
height = db.Column(db.String(10))
weight = db.Column(db.Integer)
games_played = db.Column(db.Integer)
time_on_ice = db.Column(db.REAL)
goals = db.Column(db.Integer)
assists = db.Column(db.Integer)
points = db.Column(db.Integer)
primary_points = db.Column(db.Integer)
pts_per_60 = db.Column(db.REAL)
p_pts_per_60 = db.Column(db.REAL)
pim = db.Column(db.Integer)
cf = db.Column(db.Integer)
ca = db.Column(db.Integer)
corsi_plus_minus = db.Column(db.Integer)
cf_percentage = db.Column(db.REAL)
rel_cf = db.Column(db.REAL)
gf = db.Column(db.Integer)
ga = db.Column(db.Integer)
plus_minus = db.Column(db.Integer)
pdo = db.Column(db.REAL)
zsr = db.Column(db.REAL)
# goalie stats
save_percentage = db.Column(db.REAL)
goals_against_average = db.Column(db.REAL)
player_id = db.Column(db.ForeignKey('players.id'), primary_key=True)
player = db.relationship('Player', backref='player_stats')
season_id = db.Column(db.ForeignKey('seasons.id'), primary_key=True)
season = db.relationship('Season', backref='player_stats')
team_id = db.Column(db.ForeignKey('teams.id'), primary_key=True)
team = db.relationship('Team', back_populates='players')
class notification2websites(db.Model):
id = db.Column(db.Integer, primary_key=True)
notification_uuid = db.Column(
db.String(20), db.ForeignKey("notificationheaders.notification_uuid"))
website_uuid = db.Column(db.String(20))
class Team(db.Model):
__tablename__ = 'teams'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(40), nullable=False)
abbreviation = db.Column(db.String(3))
primary_color = db.Column(db.String(30))
secondary_color = db.Column(db.String(30))
city = db.Column(db.String(30))
arena = db.Column(db.String(40))
division = db.Column(db.String(20))
conference = db.Column(db.String(20))
official_site = db.Column(db.String(50))
# self-reference for affiliated teams
team_id = db.Column(db.Integer, db.ForeignKey('teams.id'))
affiliates = db.relationship("Team", backref=db.backref('parent_team', remote_side=[id]))
league_id = db.Column(db.Integer, db.ForeignKey('leagues.id'))
league = db.relationship('League', back_populates='teams')
seasons = db.relationship('Season', secondary='team_stats')
players = db.relationship('PlayerStats', back_populates='team')
class notification2contacts(db.Model):
id = db.Column(db.Integer, primary_key=True)
notification_uuid = db.Column(
db.String(20), db.ForeignKey("notificationheaders.notification_uuid"))
contact_uuid = db.Column(
db.String(20), db.ForeignKey("notificationcontacts.contact_uuid"))
class Pizza(db.Model):
__tablename__ = 'pizzas'
id = db.Column(db.Integer, primary_key=True, index=True)
topping1_left = db.Column(db.String(25))
topping2_left = db.Column(db.String(25))
topping3_left = db.Column(db.String(25))
topping1_right = db.Column(db.String(25))
topping2_right = db.Column(db.String(25))
topping3_right = db.Column(db.String(25))
sauce = db.Column(db.String(25))
size = db.Column(db.String(10))
person1_id = db.Column(db.Integer, db.ForeignKey('people.id'))
person2_id = db.Column(db.Integer, db.ForeignKey('people.id'))
person1 = db.relationship('Person', foreign_keys=[person1_id])
person2 = db.relationship('Person', foreign_keys=[person2_id])
time_added = db.Column(db.DateTime)
def __repr__(self):
return "<{} pizza created at {}>".format(self.size.title(),
self.time_added)
class UploadFile(db.Model):
__tablename__ = 'UploadFile'
file_id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer)
vidoe_filename = db.Column(db.String(2048))
vidoe_hash_filename = db.Column(db.String(2048))
g_sensor_filename = db.Column(db.String(2048))
g_sensor_hash_filename = db.Column(db.String(2048))
accident_time = db.Column(db.String(2048))
car_to_motor = db.Column(db.String(2048))
ownership = db.Column(db.String(2048))
object_hit = db.Column(db.String(2048))
country = db.Column(db.String(2048))
description = db.Column(db.String(2048))
crush_type = db.Column(db.String(2048))
role = db.Column(db.String(2048))
insert_time = db.Column(db.DateTime, default=datetime.now)
analysis_state = db.Column(db.String(20), default='WAITING')
analysis_result = db.Column(db.String(100), default='')
def __init__(self, user_id, filename, hash_filename, g_sensor_filename,
hash_g_sensor_filename, accident_time, car_or_motor,
ownership, object_hit, country, description, crush_type,
role):
self.user_id = user_id
self.vidoe_filename = filename
self.vidoe_hash_filename = hash_filename
self.g_sensor_filename = g_sensor_filename
self.g_sensor_hash_filename = hash_g_sensor_filename
self.accident_time = accident_time
self.car_to_motor = car_or_motor
self.ownership = ownership
self.object_hit = object_hit
self.country = country
self.description = description
self.crush_type = crush_type
self.role = role
class Person(db.Model):
__tablename__ = 'people'
id = db.Column(db.Integer, primary_key=True, index=True)
email = db.Column(db.String(50))
location = db.Column(db.String(10))
class Note(db.Model):
id = db.Column(db.Integer, primary_key=True)
data = db.Column(db.String(10000))
date = db.Column(db.DateTime(timezone=True), default=func.now())
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
class User(db.Model):
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)
password = db.Column(db.String(60), unique=True, nullable=False)
image_file = db.Column(db.String(20), unique=True, default='default.jpg')
