class State(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
state = db.Column(db.TEXT())
last_lang = db.Column(db.TEXT())
task_id = db.Column(db.TEXT(), default=None)
created_at = db.Column(db.DateTime, index=True, default=datetime.utcnow)
def __repr__(self):
return 'State {id}, State {state}'.format(id=self.id, state=self.state)
class Work(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), unique=True)
dev = db.Column(db.String(64))
audit = db.Column(db.String(64))
srole = db.Column(db.Integer, default=0)
sql_content = db.Column(db.TEXT(16777215))
db_config = db.Column(db.String(64))
backup = db.Column(db.Boolean, default=True)
status = db.Column(db.Integer, nullable=False)
create_time = db.Column(db.DateTime, default=datetime.now())
finish_time = db.Column(db.DateTime)
man_review_time = db.Column(db.DateTime)
auto_review = db.Column(db.TEXT(16777215))
execute_result = db.Column(db.TEXT(16777215))
class Invoice(db.Model):
__tablename__ = 'invoice'
id = db.Column('id', db.String(128), primary_key=True, nullable=False)
to_name = db.Column('to_name', db.String(128), nullable=False)
to_address = db.Column('to_address', db.String(128), nullable=False)
to_city_state = db.Column('to_city_state', db.String(128), nullable=False)
from_name = db.Column('from_name', db.String(128), nullable=False)
from_address = db.Column('from_address', db.String(128), nullable=False)
from_city_state = db.Column('from_city_state',
db.String(128),
nullable=False)
items = db.Column('items', db.TEXT(), nullable=False)
payment_method = db.Column('payment_method',
db.String(128),
nullable=False)
payment_email = db.Column('payment_email', db.String(256), nullable=False)
warranty_description = db.Column('warranty_description',
db.Text(),
nullable=False)
warranty_period = db.Column('warranty_period',
db.String(128),
nullable=False)
notes_description = db.Column('notes_description',
db.Text(),
nullable=True)
issued_date = db.Column('issued_date', db.Date(), nullable=False)
type = db.Column('type', db.String(64), nullable=False, default="Quote")
total = db.Column('total', db.Integer(), nullable=False)
hidden = db.Column('hidden', db.Boolean(), nullable=False, default=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
class adminUserList(db.Model):
__tablename__ = "adminUserList"
id = db.Column(db.Integer, primary_key=True,unique=True,comment='id')
user_name=db.Column(db.String(100),comment='用户名')
name = db.Column(db.String(100),comment='名字')
pwd=db.Column(db.String(200),comment='密码')
sex=db.Column(db.INT,comment='性别')#0男 1女 2保密
email = db.Column(db.String(100), unique=True,comment='邮箱') # 邮箱 唯一
phone = db.Column(db.String(11), unique=True,comment='电话') # 手机号码 唯一
avatar=db.Column(db.TEXT(length=6553666),comment='头像') #65536设置的mysql表字段为mediumblob 可存储16M的blob
reg_time=db.Column(db.DateTime,index=True, default=datetime.now,comment='注册时间')
def to_json(self):
'''返回给前端的字段'''
return {
'id': self.id,
'userName': self.user_name,
'name':self.name,
'sex':self.sex,
'email':self.email,
'phone':self.phone,
'avatar':self.avatar,
'createTime': str(self.reg_time),
}
def verify_password(self, password):
pwdMd5 = md5(password)
if self.pwd == pwdMd5:
print('MD5加密之后的密文比较', self.pwd, pwdMd5)
return True
else:
return False
class Tipster(db.Model):
__tablename__ = "TipsterPerformance"
ID = db.Column(db.Integer, primary_key=True)
Name = db.Column(db.String(40))
TipsterScore = db.Column(db.Float)
NumberWinners = db.Column(db.Integer)
Seconds = db.Column(db.Integer)
Thirds = db.Column(db.Integer)
Fourths = db.Column(db.Integer)
TotalRaces = db.Column(db.Integer)
WinStrikeRate = db.Column(db.Float)
NumberFavorites = db.Column(db.Integer)
PerformanceSequence = db.Column(db.TEXT())
MaxLosingStreak = db.Column(db.Integer)
MinWinningStreak = db.Column(db.Integer)
Last10 = db.Column(db.String(40))
def __init__(self, Name, TipsterScore, NumberWinners, Seconds, Thirds, Fourths, TotalRaces, WinStrikeRate, NumberFavorites,
PerformanceSequence, MaxLosingStreak, MinWinningStreak, Last10):
self.Name = Name
self.TipsterScore = TipsterScore
self.NumberWinners = NumberWinners
self.Seconds = Seconds
self.Thirds = Thirds
self.Fourths = Fourths
self.TotalRaces = TotalRaces
self.WinStrikeRate = WinStrikeRate
self.NumberFavorites = NumberFavorites
self.PerformanceSequence = PerformanceSequence
self.MaxLosingStreak = MaxLosingStreak
self.MinWinningStreak = MinWinningStreak
self.Last10 = Last10
class User(db.Model):
__tablename__ = 'users'
uid = db.Column(db.INT, primary_key=True)
email = db.Column(db.VARCHAR(256))
password = db.Column(db.VARCHAR(256))
name = db.Column(db.VARCHAR(256))
realname = db.Column(db.VARCHAR(256))
portrait = db.Column(db.VARCHAR(256))
permit = db.Column(db.INT, default=1)
gender = db.Column(db.INT)
age = db.Column(db.INT)
school = db.Column(db.VARCHAR(256))
selfinfo = db.Column(db.TEXT(65536))
regtime = db.Column(db.DATETIME, default=datetime.utcnow)
totshare = db.Column(db.INT, default=0)
totques = db.Column(db.INT, default=0)
totans = db.Column(db.INT, default=0)
"""
Follower = db.relationship("Follow" , foreign_keys=[Follow.FollewerUID],
back_populates="FollewerUID")
Following = db.relationship("Follow",foreign_keys=[Follow.FollowedUID],
back_populates="FollowedUID")
"""
def __init__(self, login):
self.LOGIN = login
def to_dict(self):
return {
c.name: getattr(self, c.name, None)
for c in self.__table__.columns
}
class Session(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
requests = db.relationship('Request', backref='session', lazy='dynamic')
confirmation_number = db.Column(db.String(256))
department = db.Column(db.TEXT())
created_at = db.Column(db.DateTime, index=True, default=datetime.utcnow)
def __repr__(self):
return 'Session {id}, User ID {user_id}'.format(id=self.id,
user_id=self.user_id)
@property
def serialize(self):
"""Return object data in easily serializable format"""
return {
'id': self.id,
'confirmation_number': self.confirmation_number,
'department': self.department,
'created_at': dump_datetime(self.created_at),
'requests': self.serialize_requests
}
@property
def serialize_requests(self):
"""
Return object's relations in easily serializable format.
NB! Calls many2many's serialize property.
"""
return [item.serialize for item in self.requests]
class Player(db.Model):
__tablename__ = "players"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100))
country = db.Column(db.String(100))
position = db.Column(db.String(1))
height = db.Column(db.Float(precision=2, asdecimal=False))
weight = db.Column(db.Integer())
picture = db.Column(db.String(300), nullable=True)
feature = db.Column(db.TEXT(1000), nullable=True)
default_leg = db.Column(db.String(34), nullable=True)
birth_date = db.Column(db.DateTime)
activate = db.Column(db.Boolean, unique=False, default=True)
teams = db.relationship('Team', secondary='teams_players')
def __init__(self, name, country, position, height, weight, picture,
feature, default_leg, birth_date):
self.name = name
self.country = country
self.position = position
self.height = height
self.weight = weight
self.picture = picture
self.feature = feature
self.default_leg = default_leg
self.birth_date = birth_date
def __repr__(self):
return "<Player %r>" % self.name
class User(db.Model):
id = db.Column(db.String(200), primary_key=True)
email = db.Column(db.String(150), nullable=False, unique=True)
first_name = db.Column(db.String(150), nullable=False)
last_name = db.Column(db.String(150), nullable=True)
username = db.Column(db.String(150), nullable=False)
password = db.Column(db.String(150), nullable=False)
last_passwords = db.Column(db.TEXT(), nullable=True)
created_on = db.Column(db.DateTime, nullable=False)
expiry_token = db.Column(db.String(50), nullable=True)
expiry_date = db.Column(db.DateTime, nullable=True)
sso = db.Column(db.Boolean, nullable=True)
locked = db.Column(db.Boolean, nullable=True)
provider = db.Column(db.String(50), nullable=True)
profile_picture = db.Column(LONGTEXT())
last_login = db.Column(db.DateTime)
extra_data = db.Column(db.TEXT())
gender = db.Column(db.String(10), nullable=True)
country = db.Column(db.String(100), nullable=True)
def to_dict(self):
fields = {}
for field in [
x for x in dir(self)
if not x.startswith("_") and x != 'metadata'
]:
data = self.__getattribute__(field)
if type(data) is datetime.datetime:
data = data.strftime('%Y-%m-%dT%H:%M:%SZ')
if type(data) is datetime.date:
data = data.strftime('%Y-%m-%d')
if not hasattr(data, '__call__'):
try:
json.dumps(data)
if field[-4:] == "List" and type(data) is not list:
fields[field] = [
x for x in data.split(",") if x.strip() != ""
]
else:
fields[field] = data
except TypeError:
if type(data) is decimal.Decimal:
fields[field] = float(data)
else:
fields[field] = None
return fields
class Answer(db.Model):
__tablename__ = 'answer'
aid = db.Column(db.INT, primary_key=True)
qid = db.Column(db.INT, db.ForeignKey('question.qid'))
writeruid = db.Column(db.INT, db.ForeignKey('users.id'))
content = db.Column(db.TEXT(65535))
pubtime = db.Column(db.DATETIME, default=datetime.utcnow)
like = db.Column(db.INT, default=0)
class Page(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128))
price = db.Column(db.Float)
html = db.Column(db.TEXT(collation='utf8mb4_unicode_ci'))
listing_id = db.Column(db.Integer, db.ForeignKey('listing.id'))
timestamp = db.Column(db.DateTime,
index=True,
default=datetime.datetime.utcnow)
class Reviews(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
location = db.Column(db.Integer, db.ForeignKey('location.id'))
user = db.Column(db.Integer, db.ForeignKey('user.id'))
rating = db.Column(db.Integer, nullable=False)
review = db.Column(db.TEXT())
# Method to debug by printing out results of creation when calling the object alone
def __repr__(self):
return 'ID: {}, Location: {}, User: {}, Rating: {}, Review: {}'.format(self.id, self.location, self.user,
self.rating, self.review)
class Story(db.Model):
__tablename__ = 'storys'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64))
text = db.Column(db.TEXT(16777215))
annotations = db.relationship('Annotation', backref='story')
def __repr__(self):
return '<Book %r>' % self.name
class Comment(db.Model):
__tablename__ = 'comment'
cid = db.Column(db.INT, primary_key=True)
sid = db.Column(db.INT, db.ForeignKey('share.sid'))
writerid = db.Column(db.INT, db.ForeignKey('users.uid'))
content = db.Column(db.TEXT(65536))
pubtime = db.Column(db.DATETIME, default=datetime.utcnow)
def to_dict(self):
return {
c.name: getattr(self, c.name, None)
for c in self.__table__.columns
}
class Noteevents(db.Model):
row_id = db.Column(db.Integer, primary_key=True, nullable=False)
subject_id = db.Column(db.Integer, nullable=False)
hadm_id = db.Column(db.Integer)
chartdate = db.Column(db.TIMESTAMP())
charttime = db.Column(db.TIMESTAMP())
storetime = db.Column(db.TIMESTAMP())
category = db.Column(db.VARCHAR(length=50))
description = db.Column(db.VARCHAR(length=255))
cgid = db.Column(db.Integer)
iserror = db.Column(db.CHAR(length=1))
text = db.Column(db.TEXT())
admissions = db.relationship('Admissions', backref='noteevents', lazy=True)
class Items(db.Model):
"""This class represents the Items table."""
__tablename__ = "Items"
postedDate = db.Column(db.DATE())
itemID = db.Column(db.Integer, primary_key=True)
buyerID = db.Column(db.Integer)
userID = db.Column(db.Integer,
db.ForeignKey('Users.userID'),
primary_key=True)
name = db.Column(db.VARCHAR(100))
category = db.Column(db.VARCHAR(100))
cost = db.Column(db.Integer)
description = db.Column(db.TEXT())
sold = db.Column(db.BOOLEAN)
class Question(db.Model):
__tablename__ = 'question'
qid = db.Column(db.INT, primary_key=True)
label = db.Column(db.VARCHAR(256))
content = db.Column(db.TEXT(65536))
writeruid = db.Column(db.INT, db.ForeignKey('users.uid'))
newnum = db.Column(db.INT)
def to_dict(self):
return {
c.name: getattr(self, c.name, None)
for c in self.__table__.columns
}
class Share(db.Model):
__tablename__ = 'share'
sid = db.Column(db.INT, primary_key=True)
writeruid = db.Column(db.INT, db.ForeignKey('users.uid'))
label = db.Column(db.VARCHAR(256))
image = db.Column(db.VARCHAR(256))
content = db.Column(db.TEXT(65536))
pubtime = db.Column(db.DATETIME, default=datetime.utcnow)
newnum = db.Column(db.INT, default=0)
star = db.Column(db.INT, default=0)
def to_dict(self):
return {
c.name: getattr(self, c.name, None)
for c in self.__table__.columns
}
class Question(db.Model):
__tablename__ = 'question'
qid = db.Column(db.INT, primary_key=True)
writeruid = db.Column(db.INT, db.ForeignKey('users.id'))
label = db.Column(db.VARCHAR(255))
content = db.Column(db.TEXT(65535))
newnum = db.Column(db.INT)
answers = db.relationship('Answer', backref='question')
pubtime = db.Column(db.DATETIME, default=datetime.utcnow)
def to_dict(self):
return {
c.name: getattr(self, c.name, None)
for c in self.__table__.columns
}
class Cfg_settings(db.Model):
__tablename__ = "cfg_settings"
key = db.Column(db.String(512), index=True, primary_key=True)
date_created = db.Column(db.DateTime(timezone=True), default=db.func.current_timestamp())
date_modified = db.Column(db.DateTime(timezone=True), default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
public = db.Column(db.Boolean, index=True, default=True)
value = db.Column(db.TEXT())
description = db.Column(db.String(512))
def to_dict(self):
return dict(
date_created=self.date_created.isoformat(),
date_modified=self.date_modified.isoformat(),
key=self.key,
value=self.value,
description=self.description
)
def __repr__(self):
return '<Cfg_settings %s>' % (self.key)
@staticmethod
def get_private_setting(key):
try:
setting = db.session.query(Cfg_settings).filter(Cfg_settings.public == False).filter(
Cfg_settings.key == key).first()
return setting.value if setting else None
except:
return None
@staticmethod
def get_setting(key):
try:
setting = db.session.query(Cfg_settings).filter(Cfg_settings.key == key).first()
return setting.value if setting else None
except:
return None
@staticmethod
def get_settings(key_like):
try:
return db.session.query(Cfg_settings).filter(Cfg_settings.key.like(key_like)).all()
except:
return None
class Post(db.Model):
id = db.Column(db.Integer(), primary_key=True)
title = db.column(db.String(140), nullable=False)
slug = db.column(db.String(140), unique=True)
body = db.column(db.TEXT(), nullable=False)
created = db.column(db.DateTime(), nullable=False)
def __init__(self, *args, **kwargs):
super(Post, self).__init__(*args, **kwargs)
self.generate_slug()
def generate_slug(self):
if self.title:
self.slug = slugify(self.title)
def __repr__(self):
return f'<Post id is {self.id}, title is {self.title}>'
class Share(db.Model):
__tablename__ = 'share'
sid = db.Column(db.INT, primary_key=True)
writeruid = db.Column(db.INT, db.ForeignKey('users.id'))
label = db.Column(db.VARCHAR(255))
image = db.Column(db.VARCHAR(255), default="/static/share_images/1.png")
content = db.Column(db.TEXT(65535))
pubtime = db.Column(db.DATETIME, default=datetime.utcnow)
newnum = db.Column(db.INT, default=0)
like = db.Column(db.INT, default=0)
comments = db.relationship('Comment', backref='share')
def to_dict(self):
return {
c.name: getattr(self, c.name, None)
for c in self.__table__.columns
}
class Request(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
session_id = db.Column(db.Integer, db.ForeignKey('session.id'))
request = db.Column(db.TEXT())
created_at = db.Column(db.DateTime, index=True, default=datetime.utcnow)
def __repr__(self):
return 'Request {id}, Text {request}'.format(id=self.id,
request=self.request)
@property
def serialize(self):
"""Return object data in easily serializable format"""
return {
'id': self.id,
'request': self.request,
'created_at': dump_datetime(self.created_at)
}
class Post(db.Model):
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.String(140), nullable=False)
slug = db.Column(db.String(140), nullable=False, unique=True)
body = db.Column(db.TEXT(), nullable=False)
created = db.Column(db.DateTime(), default=datetime.now())
def __init__(self, *args, **kwargs):
super(Post, self).__init__(*args, **kwargs)
self.generate_slug()
tags = db.relationship('Tag',
secondary=post_tags,
backref=db.backref('posts', lazy='dynamic'))
def generate_slug(self):
if self.title:
self.slug = slugify(self.title)
def __repr__(self):
return f'<Post id is {self.id}, title is {self.title}>'
class Maintenance(db.Model):
id = db.Column(db.Integer, primary_key=True)
provider_maintenance_id = db.Column(db.String(128), nullable=True)
start = db.Column(db.TIME)
end = db.Column(db.TIME)
timezone = db.Column(db.String(128), nullable=True)
cancelled = db.Column(db.INT, default=0)
rescheduled = db.Column(db.INT, default=0)
rescheduled_id = db.Column(db.Integer,
db.ForeignKey('maintenance.id'),
nullable=True)
location = db.Column(db.String(2048), index=True, nullable=True)
reason = db.Column(db.TEXT(), nullable=True)
received_dt = db.Column(db.DateTime)
started = db.Column(db.INT, default=0)
ended = db.Column(db.INT, default=0)
updates = db.relationship('MaintUpdate',
backref='maintenance',
lazy='dynamic')
def __repr__(self):
return f'<Maintenance {self.provider_maintenance_id}>'
class Todo(db.Model):
id = db.Column(db.String(200), primary_key=True)
title = db.Column(db.String(50), nullable=False)
user_id = db.Column(db.String(200))
content = db.Column(db.TEXT(), nullable=True)
status = db.Column(db.Boolean, nullable=True)
created_on = db.Column(db.DateTime)
alarm_time = db.Column(db.DateTime, nullable=True)
def to_dict(self):
fields = {}
for field in [
x for x in dir(self)
if not x.startswith("_") and x != 'metadata'
]:
data = self.__getattribute__(field)
if type(data) is datetime.datetime:
data = data.strftime('%Y-%m-%dT%H:%M:%SZ')
if type(data) is datetime.date:
data = data.strftime('%Y-%m-%d')
if not hasattr(data, '__call__'):
try:
json.dumps(data)
if field[-4:] == "List" and type(data) is not list:
fields[field] = [
x for x in data.split(",") if x.strip() != ""
]
else:
fields[field] = data
except TypeError:
if type(data) is decimal.Decimal:
fields[field] = float(data)
else:
fields[field] = None
return fields
class t_SystemPerformance(db.Model):
__tablename__ = "t_systemperformance"
id = db.Column(db.Integer, primary_key=True)
t_system_id= db.Column(db.Integer, ForeignKey('t_system.id'))
tipsterscore = db.Column(db.Float)
winners = db.Column(db.Integer)
seconds = db.Column(db.Integer)
thirds = db.Column(db.Integer)
fourths = db.Column(db.Integer)
totalraces = db.Column(db.Integer)
winsr = db.Column(db.Float)
favorites = db.Column(db.Integer)
perf_seq = db.Column(db.TEXT())
maxlosingstreak = db.Column(db.Integer)
maxwinningstreak = db.Column(db.Integer)
last10 = db.Column(db.String(40))
updated = db.Column(db.TIMESTAMP)
updated_date = db.Column(db.Date)
def __init__(self, t_system_id, tipsterscore, winners, seconds, thirds, fourths, totalraces, winsr, favorites,
perf_seq, maxlosingstreak, maxwinningstreak, last10, updated=datetime.utcnow()):
self.t_system_id = t_system_id
self.tipsterscore = tipsterscore
self.winners = winners
self.seconds = seconds
self.thirds = thirds
self.fourths = fourths
self.totalraces = totalraces
self.winsr = winsr
self.favorites = favorites
self.perf_seq = perf_seq
self.maxlosingstreak = maxlosingstreak
self.maxwinningstreak = maxwinningstreak
self.last10 = last10
self.updated = updated
self.updated_date = updated.date()
class MaintUpdate(db.Model):
id = db.Column(db.Integer, primary_key=True)
maintenance_id = db.Column(db.Integer, db.ForeignKey('maintenance.id'))
comment = db.Column(db.TEXT())
updated = db.Column(db.DateTime, default=datetime.utcnow)
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.INT, primary_key=True)
email = db.Column(db.VARCHAR(255))
password = db.Column(db.VARCHAR(512))
confirmed = db.Column(db.BOOLEAN, default=False)
username = db.Column(db.VARCHAR(255))
realname = db.Column(db.VARCHAR(255))
has_img = db.Column(db.INT, default=0)
portrait = db.Column(db.VARCHAR(255))
permit = db.Column(db.INT, default=1)
gender = db.Column(db.INT)
age = db.Column(db.INT)
school = db.Column(db.VARCHAR(255))
selfinfo = db.Column(db.TEXT(65535))
regtime = db.Column(db.DATETIME, default=datetime.utcnow)
totshare = db.Column(db.INT, default=0)
totques = db.Column(db.INT, default=0)
totans = db.Column(db.INT, default=0)
has_img = db.Column(db.BOOLEAN, default=0)
shares = db.relationship('Share', backref='writer')
questions = db.relationship('Question', backref='writer')
comments = db.relationship('Comment', backref='writer')
answers = db.relationship('Answer', backref='writer')
followed = db.relationship('Follow',
foreign_keys=[Follow.follower_id],
backref=db.backref('follower', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
followers = db.relationship('Follow',
foreign_keys=[Follow.followed_id],
backref=db.backref('followed', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
def to_dict(self):
return {
c.name: getattr(self, c.name, None)
for c in self.__table__.columns
}
def generate_password(self, pwd):
self.password = generate_password_hash(pwd)
def verify_password(self, pwd):
return check_password_hash(self.password, pwd)
def generate_confirmation_token(self):
s = Serializer(app.config['SECRET_KEY'], expires_in=3600)
token = s.dumps({'uid': self.id})
print(token)
return token
def confirm(self, token):
s = Serializer(app.config['SECRET_KEY'], expires_in=3600)
token = token[2:-1]
print(token)
try:
data = s.loads(token)
except:
print('datafalse')
return False
if data.get('uid') != self.id:
return False
self.confirmed = True
db.session.add(self)
db.session.commit()
return True
def follow(self, user):
if not self.is_following(user):
f = Follow(follower=self, followed=user)
db.session.add(f)
def unfollow(self, user):
f = self.followed.filter_by(followed_id=user.id).first()
if f:
db.session.delete(f)
def is_following(self, user):
if user.id is None:
return False
return self.followed.filter_by(followed_id=user.id).first() is not None
def is_followed_by(self, user):
if user.id is None:
return False
return self.followers.filter_by(
follower_id=user.id).first() is not None
def __repr__(self):
return '<User %r>' % self.username
class user(db.Model,UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.VARCHAR(64),unique=True)
location = db.Column(db.String(64))
image_hash = db.Column(db.String(32))
about_me = db.Column(db.TEXT())
register_time = db.Column(db.DateTime(),default=datetime.now)
last_time = db.Column(db.DateTime(),default=datetime.now)
email = db.Column(db.VARCHAR(64),unique=True)
new_email = db.Column(db.VARCHAR(64),default="nomail")
password_hash = db.Column(db.String(128))
confirmed = db.Column(db.BOOLEAN, default=False)
role_id = db.Column(db.Integer,db.ForeignKey("roles.id"))
posts = db.relationship("Post", backref = "user", lazy = 'dynamic')
followers = db.relationship("follow",
foreign_keys = [follow.follower_id],
backref = db.backref("follower", lazy = 'joined'),
lazy = 'dynamic',
cascade='all, delete-orphan')
followeds = db.relationship("follow",
foreign_keys = [follow.followed_id],
backref = db.backref("followed",lazy='joined'),
lazy = 'dynamic',
cascade='all, delete-orphan')
comments = db.relationship("Comment", backref = "user",lazy = "dynamic")
def __init__(self, **kwargs):
super(user, self).__init__(**kwargs)
if self.role is None:
if self.email == current_app.config["MAIL_USERNAME"]:
self.role = role.query.filter_by(permission = 0xff).first()
else:
self.role = role.query.filter_by(default = True).first()
if self.email is not None and self.image_hash is None:
self.image_hash = hashlib.md5(self.email.encode("utf-8")).hexdigest()
self.follow(self)
def can(self,permissions):
return self.role is not None and (self.role.permission & permissions == permissions)
def is_administer(self):
return self.can(Permission.ADMINISTER)
def visted(self):
self.last_time = datetime.now()
db.session.add(self)
db.session.commit()
def follow(self, tmpuser):
if not self.is_following(tmpuser):
f = follow(follower = self, followed = tmpuser)
db.session.add(f)
def unfollow(self, tmpuser):
if self.is_following(tmpuser):
f = self.followers.filter_by(followed_id = tmpuser.id).first()
db.session.delete(f)
def is_following(self,tmpuser):
return self.followers.filter_by(followed_id = tmpuser.id).first() is not None
def is_followed_by(self,tmpuser):
return self.followeds.filter_by(follower_id = tmpuser.id).first() is not None
@property
def password(self):
return AttributeError("password can not readable")
@property
def get_followed_posts(self):
return Post.query.join(follow, follow.followed_id == Post.user_id).filter(follow.follower_id == self.id)
@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 generator_confirmed_token(self, expire = 3600, email = ""):
secret = JsonSecret(current_app.config["SECRET_KEY"], expire)
if email == "":
return secret.dumps({"confirmed":self.id})
else:
return secret.dumps({"new_email":email})
def get_image_url(self, size = 100, default = "monsterid", rating = "g"):
if request.is_secure:
url = "https://secure.gravatar.com/avatar"
else:
url = "https://gravatar.com/avatar"
hash = self.image_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)
def confirmed_email(self, token):
secret = JsonSecret(current_app.config["SECRET_KEY"])
try:
data = secret.loads(token)
except:
return False
if data.get("confirmed") == self.id:
self.confirmed = True
db.session.add(self)
return True
elif data.get("new_email") == self.new_email:
self.email = self.new_email
self.image_hash = hashlib.md5(self.email.encode('utf-8')).hexdigest()
self.new_email = "nomail"
db.session.add(self)
return True
else:
return False
@staticmethod
def generate_fake(count = 100):
from sqlalchemy.exc import IntegrityError
from random import seed
import forgery_py
seed()
for i in range(count):
email = forgery_py.internet.email_address()
if user.query.filter_by(email = email).first():
continue
username = forgery_py.internet.user_name()
if user.query.filter_by(username = username).first():
continue
u = user(email = email,
username = username,
password = forgery_py.lorem_ipsum.word(),
confirmed = True,
location = forgery_py.address.city(),
about_me = forgery_py.lorem_ipsum.sentence(),
last_time = forgery_py.date.date(True))
db.session.add(u)
db.session.commit()
@staticmethod
def add_self_followed():
for tmpuser in user.query.all():
if not tmpuser.is_following(tmpuser):
tmpuser.follow(tmpuser)
db.session.add(tmpuser)
db.session.commit()