def followed_posts(self):
return Meal.query.join(followers, (followers.c.followed_id == Meal.user_id)).filter(followers.c.follower_id == self.id).order_by(Meal.timestamp.desc())
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password = db.Column(db.String(128))
meals = db.relationship('Meal', backref='author', lazy='dynamic')
authenticated = db.Column(db.Boolean, default=False)
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')
def __repr__(self):
return '<User %r>' % (self.username)
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()
def followed_posts(self):
return Meal.query.join(followers, (followers.c.followed_id == Meal.user_id)).filter(followers.c.follower_id == self.id).order_by(Meal.timestamp.desc())
class User(UserMixin, db.Model):
'''
:var User.id - Id of user
:var User.username - Username of user
:var User.email - Email of user
:var User.password_hash - encrypted user's password
:var User.posts - relationship to posts table in database
(ie. the way to link a blog post to the user that authored it
is to add a reference to the user's ID. This shows a one-to-many
relationship since one user writes MANY posts)
:var User.zips - relationship to Process table in database
:var User.params - relationship to paramas table where all processing parameters
are saved for each task run. (from single_pick.html)
:var User.tasks - relationships to tasks table where task summaries will be saved
:var User.notifications - Table for user notifications (will show under navbar)
:var User.about_me - Saves User's Bio
:var User.last_seen - Saves User's most recent logon time
'''
id = db.Column(db.Integer, primary_key = True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(128), index=True, unique = True)
password_hash = db.Column(db.String(128))
posts = db.relationship('Post', backref='author', lazy='dynamic')
zips = db.relationship('Process', backref='author', lazy='dynamic' )
params = db.relationship('Paramas', backref='author', lazy='dynamic' )
tasks = db.relationship('Task', backref='user', lazy='dynamic')
notifications = db.relationship('Notification', backref='user',lazy='dynamic')
recent_searchs = db.Column(db.String(140))
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
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')
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
'''
:param password: password taken from register.html
:return: Encrypted version of password
'''
self.password_hash = gen_hash(password)
def check_password(self, password):
'''
:param password: password taken from login.html
:return: True or False, if false not permitted to login to account.
'''
return check_hash(self.password_hash, password)
def avatar(self, size):
'''
:param size: Size of user's profile image in pixels.
(**Note: for users with no avatar, identicon is generated)
:return: url of user's avatar scaled to requested size in pixels
'''
digest=md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
def get_email(self):
'''
:return: lower case version of User's email.
'''
my_email = self.email.lower()
return my_email
def follow(self,user):
'''
:param user: Checks if current user following selected user id
:return: appends user id to follow table if not already folowing
'''
if not self.is_following(user):
self.followed.append(user)
def unfollow(self,user):
'''
:param user: if current user.id is following selected user.id
:return: removed selected user.id from followed column of current user.id
'''
if self.is_following(user):
self.followed.remove(user)
def is_following(self,user):
'''
:param user: Current user.id
:return: Count of every user current(user.id) is following
'''
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
'''
:return: filters for post of followers
(ie ranks most recent posts including their own)
'''
followed = Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id)
own = Post.query.filter_by(user_id=self.id)
return followed.union(own).order_by(Post.timestamp.desc())
def all_posts(self):
'''
:return: All posts saves in Post table (ie all users)
'''
own=Post.query.order_by(Post.timestamp.desc())
return own
def own_posts(self):
'''
:return: Selects all of user's posts. Ranked from current to less current.
'''
own = Post.query.filter_by(user_id=self.id)
return own.order_by(Post.timestamp.desc())
def own_params(self):
'''
:return: Returns a query of all the users saved parameters before processing uploaded .zip of IGEM images
'''
own = Paramas.query.filter_by(user_id=self.id)
return own.order_by(Paramas.timestamp.desc())
def own_zips(self):
'''
:return: All the most recent paths of saved .zips. Only valid after first task is completed
'''
own = Process.query.filter_by(user_id=self.id)
return own.order_by(Process.timestamp.desc())
def get_uploads(self):
'''
:return: returns all paths of uploaded .zips
(for processing in tasks.py, uploaded .zip file deleted when complete)
'''
zips = Process.query.filter_by(user_id=self.id)
choice = zips.order_by(Process.timestamp.desc()).first()
return choice.archive_filename
def is_number(s):
'''
:return: Boolean iff a number. True or False
'''
try:
float(s)
return True
except ValueError:
return False
def launch_task(self, name, desciption, *args, **kwargs):
'''
:param name: Task name
:param desciption: Task description
:param args:
:param kwargs:
:return:
'''
rq_job = current_app.task_queue.enqueue('app.tasks.' + name, self.id, *args, **kwargs)
task = Task(id=rq_job.get_id(), name=name, user=self)
db.session.add(task)
def get_tasks_in_progress(self):
'''
:return: Returns current tasks in progress
'''
return Task.query.filter_by(user=self, complete=False).all()
def get_task_in_progress(self, name):
'''
:param name: Name of a specific, unfinished task.
:return: Returns the task in progress filtered out by its name.
'''
return Task.query.filter_by(name=name, user=self,
complete=False).first()
def get_completed_tasks(self):
'''
:return: Returns list of completed tasks.
'''
return Task.query.filter_by(user=self, complete=True).all()
def add_notification(self, name, data):
'''
:param name: Notification id/name
:param data: Notification description
:return: new notification
'''
self.notifications.filter_by(name=name).delete()
n = Notification(name=name, payload_json=json.dumps(data), user=self)
db.session.add(n)
return n
def get_reset_password_token(self, expires_in=600):
return jwt.encode(
{'reset_password': self.id, 'exp': time() + expires_in},
current_app.config['SECRET_KEY'], algorithm='HS256').decode('utf-8')
@staticmethod
def verify_reset_password_token(token):
try:
id = jwt.decode(token, current_app.config['SECRET_KEY'],
algorithms=['HS256'])['reset_password']
except:
return
return User.query.get(id)
class User(UserMixin, db.Model):
"""用户"""
"""flask_login需要实现is_authenticated,is_activate,is_anonymous,get_id,
借助UserMixin进行通常实现"""
# 唯一索引
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
# 在一对多中的‘一’定义relationship，backref定义‘多’对象字段的名称
# lazy定义关系数据库查询将如何发布
posts = db.relationship('Post', backref='author', lazy='dynamic')
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
# 关注列表
followed = db.relationship(
# 自引用，左右两侧都是user，secondary指向关系的关联表(上面定义的followers)
'User',
secondary=followers,
# 通过关联表关联左侧(关注者)的条件，即follower_id字段与这个user的id匹配
# followers.c.follower_id表达式引用了该关系表中的follower_id列
primaryjoin=(followers.c.follower_id == id),
# 通过关联表关联右侧(被关注者)的条件，
secondaryjoin=(followers.c.followed_id == id),
# backref定义右侧实体如何访问该关系。左侧followed，右侧followers
# lazy参数定义查询的执行方式。backref内应用于右侧，在外应用于左侧
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
def set_password(self, password):
"""保存密码的哈希"""
self.password_hash = generate_password_hash(password)
def check_password(self, password):
"""检查密码"""
return check_password_hash(self.password_hash, password)
def get_reset_password_token(self, expires_in=600):
"""创建加密令牌"""
return jwt.encode(
#有效载荷，到期时间，加密密钥，加密算法
{
'reset_password': self.id,
'exp': time() + expires_in
},
current_app.config['SECRET_KEY'],
algorithm='HS256').decode('utf-8')
# 静态方法不会接受类作为第一个参数，可以直接从类中调用
@staticmethod
def verify_reset_password_token(token):
"""验证令牌"""
try:
id = jwt.decode(token,
current_app.config['SECRET_KEY'],
algorithm=['HS256'])['reset_password']
except:
return
return User.query.get(id)
def avatar(self, size):
"""使用用户的邮箱从gravatar网站获取头像"""
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=robohash&s={}'.format(
digest, size)
def follow(self, user):
"""关注"""
if not self.is_following(user):
self.followed.append(user)
def unfollow(self, user):
"""取消关注"""
if self.is_following(user):
self.followed.remove(user)
def is_following(self, user):
"""是否关注某用户"""
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
"""查询关注用户的posts"""
# 关注用户的posts
followed_post = Post.query.join(
# 先对post进行联结(join)操作，第一个参数是关联表(followers)，第二个参数是
# 联结条件。会创建一个将posts表数据和followers表数据组合起来的临时表
followers,
(followers.c.followed_id == Post.user_id)).filter(
# 再过滤(filter)只剩该用户关注的用户的post
followers.c.follower_id == self.id)
# 自己的posts
own_post = Post.query.filter_by(user_id=self.id)
# 按时间降序返回
return followed_post.union(own_post).order_by(Post.timestamp.desc())
def __repr__(self):
"""打印"""
return '<User {}>'.format(self.username)
class ARWorldMap(db.Model):
__tablename__ = 'arworldmaps'
id = db.Column(db.Integer, primary_key=True)
worldmap = db.Column(db.LargeBinary)
nodes = db.relationship('nodes', backref='arworldmaps', lazy='dynamic')
class Recipe(db.Model):
__tablename__ = 'recipe'
recipe_id = db.Column(db.Integer, primary_key=True)
recipe_name = db.Column(db.String())
recipe_desc = db.Column(db.String())
recipe_prep_time = db.Column(db.Integer())
recipe_cook_time = db.Column(db.Integer())
recipe_total_time = db.Column(db.Integer())
serving_size = db.Column(db.Integer())
diet_vegan = db.Column(db.Boolean())
diet_vegetarian = db.Column(db.Boolean())
diet_gluten = db.Column(db.Boolean())
meal_breakfast = db.Column(db.Boolean())
meal_lunch = db.Column(db.Boolean())
meal_dinner = db.Column(db.Boolean())
recipe_url = db.Column(db.String())
recipe_image_url = db.Column(db.String())
created_by = db.Column(db.Integer(),
db.ForeignKey('app_user.id'),
nullable=False)
insert_datetime = db.Column(db.DateTime())
recipe_deleted = db.Column(db.Boolean())
ingredient = db.relationship('Ingredient', backref='ingredient', lazy=True)
recipe_step = db.relationship('Recipe_Step',
backref='recipe_step',
lazy=True)
user_recipe = db.relationship('User_Recipe',
backref='user_recipe1',
lazy=True)
current_meal = db.relationship('Current_Meal',
backref='current_meal1',
lazy=True)
favorite_recipe = db.relationship('Favorite_Recipe',
backref='favorite_recipe1',
lazy=True)
shopping_list = db.relationship('Shopping_List',
backref="shopping_list1",
lazy=True)
def __init__(self, recipe_name, recipe_desc, recipe_prep_time,
recipe_cook_time, recipe_total_time, serving_size,
diet_vegetarian, diet_vegan, diet_gluten, meal_breakfast,
meal_lunch, meal_dinner, recipe_url, recipe_image_url,
created_by, insert_datetime):
self.recipe_name = recipe_name
self.recipe_desc = recipe_desc
self.recipe_prep_time = recipe_prep_time
self.recipe_cook_time = recipe_cook_time
self.recipe_total_time = recipe_total_time
self.serving_size = serving_size
self.diet_vegetarian = diet_vegetarian
self.diet_vegan = diet_vegan
self.diet_gluten = diet_gluten
self.meal_breakfast = meal_breakfast
self.meal_lunch = meal_lunch
self.meal_dinner = meal_dinner
self.recipe_url = recipe_url
self.recipe_image_url = recipe_image_url
self.created_by = created_by
self.insert_datetime = insert_datetime
def __repr__(self):
return '<id {}>'.format(self.recipe_id)
def creator(cls):
return db.relationship(
'User',
primaryjoin='User.id == %s.creator_id' % cls.__name__,
remote_side='User.id')
def last_modified_by(cls):
return db.relationship(
"AppUser",
foreign_keys=lambda: cls.last_modified_by_id
)
class User(UserMixin, db.Model):
"""
用户数据Model
"""
# 表名
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
# unique=True：字段不允许重复出现，index=True：该字段为索引，提升查询效率
username = db.Column(db.String(64), unique=True, index=True)
email = db.Column(db.String(64), unique=True, index=True)
password_hash = db.Column(db.String(128))
confirmed = db.Column(db.Boolean, default=False)
# 外键，值为roles表中对应行的id
role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
location = db.Column(db.String(64))
about_me = db.Column(db.Text)
# 注册日期，default参数可以用函数作为参数，需要生成默认值时，会调用对应函数
member_since = db.Column(db.DateTime(), default=datetime.utcnow)
# 最后访问日期
last_seen = db.Column(db.DateTime(), default=datetime.utcnow)
# 邮箱地址的md5值
avatar_hash = db.Column(db.String(32))
blogs = db.relationship('Blog', backref='user', lazy='dynamic')
comments = db.relationship('Comment', backref='user', lazy='dynamic')
favourites = db.relationship('Favourite', backref='user', lazy='dynamic')
# 用户权限
permissions = db.Column(db.Integer)
def __init__(self, **kw):
super(User, self).__init__(**kw)
if self.role is None:
# 如果是管理员账号，则赋予该user管理员角色
if self.email == current_app.config['NICEBLOG_ADMIN']:
self.role = Role.query.filter_by(name='Administrator').first()
self.permissions = 15
else:
self.role = Role.query.filter_by(default=True).first()
self.permissions = 3
if self.email is not None and self.avatar_hash is None:
self.avatar_hash = self.gravatar_hash()
@property
def password(self):
raise AttributeError('password属性不可读')
# 计算密码的散列值
@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}).decode('utf-8')
# 校验令牌字符串
def confirm(self, token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
# 反序列化
data = s.loads(token.encode('utf-8'))
except:
return False
if data.get('confirm') != self.id:
return False
self.confirmed = True
db.session.add(self)
return True
def generate_reset_token(self, expiration=3600):
s = Serializer(current_app.config['SECRET_KEY'], expiration)
return s.dumps({'reset': self.id}).decode('utf-8')
@staticmethod
def reset_password(token, new_password):
"""
重置密码
:param token:
:param new_password:
:return:
"""
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token.encode('utf-8'))
except:
return False
user = User.query.get(data.get('reset'))
if user is None:
return False
user.password = new_password
db.session.add(user)
return True
def can(self, permission):
"""
权限检查
:param permission:
:return:
"""
return self.has_permission(permission)
def is_administrator(self):
"""
是否是管理员
:return:
"""
return self.can(Permission.ADMIN)
def can_favourite(self):
return self.can(Permission.FAVOURITE)
def can_comment(self):
return self.can(Permission.COMMENT)
def ping(self):
"""
更新最后访问日期
:return:
"""
self.last_seen = datetime.utcnow()
db.session.add(self)
def gravatar_hash(self):
return hashlib.md5(self.email.lower().encode('utf-8')).hexdigest()
def gravatar(self, size=100, default='identicon', rating='g'):
"""
生成用户头像地址
:param size:图片大小
:param default:指定图片生成器
:param rating:图片级别
:return:
"""
if request.is_secure:
url = 'https://secure.gravatar.com/avatar'
else:
url = 'http://www.gravatar.com/avatar'
hash = self.avatar_hash or self.gravatar_hash()
return '{url}/{hash}?s={size}&d={default}&r={rating}'.format(
url=url, hash=hash, size=size, default=default, rating=rating)
def generate_auth_token(self, expiration):
"""
生成api接口访问的认证令牌
"""
s = Serializer(current_app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.id}).decode('utf-8')
@staticmethod
def verify_auth_token(token):
"""
检验令牌
"""
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return None
return User.query.get(data['id'])
def to_json(self):
"""
完成User数据模型到JSON格式化的序列化字典转换
"""
json_user = {
'id': self.id,
'username': self.username,
'email': self.email,
'location': self.location,
'about_me': self.about_me,
'member_since': self.member_since,
'token': self.generate_auth_token(3600 * 24 * 7)
}
return json_user
def add_permission(self, permission):
if not self.has_permission(permission):
self.permissions += permission
def remove_permission(self, permission):
if self.has_permission(permission):
self.permissions -= permission
def reset_permissions(self):
self.permissions = 0
def has_permission(self, permission):
return self.permissions & permission == permission
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
email = db.Column(db.String(64), unique=False, nullable=True)
enabled = db.Column(db.Boolean, default=True, nullable=False)
first_seen = db.Column(db.DateTime, default=datetime.utcnow)
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
admin = db.Column(db.Boolean, default=False)
show_ads = db.Column(db.Boolean, default=True)
logs_resolved = db.relationship('Log',
backref='resolved_by_user',
lazy='dynamic',
cascade='all')
challenges = db.relationship('Challenge',
backref='user',
lazy='dynamic',
cascade="all")
# Set default order by
__mapper_args__ = {"order_by": [db.asc(first_seen)]}
ACCOUNT_ID_TO_STEAM_ID_CORRECTION = 76561197960265728
def __init__(self, _id=None, name=None, enabled=True):
self.id = _id
self.name = name
self.enabled = enabled
def __repr__(self):
return self.name
def get_id(self):
return unicode(self.id)
def is_active(self):
return self.enabled
def is_anonymous(self):
return False
def is_authenticated(self):
return True
def is_admin(self):
return self.admin
def update_last_seen(self):
# Called every page load for current_user
self.last_seen = datetime.utcnow()
db.session.add(self)
db.session.commit()
def update_steam_name(self):
# Called every page load for current_user (API is cached)
steam_account_info = steam.user.profile(self.steam_id)
try:
if steam_account_info is not None:
if self.name is not steam_account_info.persona:
self.name = steam_account_info.persona
db.session.add(self)
db.session.commit()
except steam.api.HTTPError:
pass
def allows_ads(self):
return self.show_ads
@property
def steam_id(self):
return self.id + User.ACCOUNT_ID_TO_STEAM_ID_CORRECTION
def get_active_challenge(self):
return self.challenges.filter(
Challenge.start_at <= datetime.utcnow(),
Challenge.end_at >= datetime.utcnow()).first()
class Task(db.Model):
__tablename__ = 'Task'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255), nullable=False)
typ = db.Column(db.String(32), nullable=False)
style = db.Column(db.String(64))
pid = db.Column(db.Integer, db.ForeignKey('Task.id'))
#sid = db.Column(db.Integer, db.ForeignKey('Information.id'))
#eid = db.Column(db.Integer, db.ForeignKey('Information.id'))
#splan = orm.column_property(
# select([Information.id]).\
# where(Information.tid==id).\
# where(Information.type=='plan'). \
# order_by(Information.start). \
# correlate_except(Information))
@hybrid_property
def eplan(self):
# return db.session.query(Information).filter(Information.tid==self.id).filter(Information.type=='plan').order_by(desc(Information.finish)).first()
return self.info.filter(Information.type == 'plan').order_by(
desc(Information.finish)).first()
@hybrid_property
def splan(self):
return self.info.filter(Information.type == 'plan').order_by(
asc(Information.start)).first()
@hybrid_property
def parent(self):
return Task.query.filter(Task.id == self.pid).first()
# splan = db.relationship('Information',foreign_keys='Task.sid', primaryjoin='Information.tid==Task.sid')
sub = db.relationship('Task', lazy='dynamic')
info = db.relationship('Information',
foreign_keys='Information.tid',
primaryjoin='Information.tid==Task.id',
backref='task',
lazy='dynamic')
def __init__(self, title='', pid=0, typ='', style=''):
self.title = title
self.pid = pid
self.typ = typ
self.style = style
@orm.reconstructor
def init_and_load(self):
# self.plan = self.sub.filter(Information.type=='plan').order_by(Information.finish).all()
# 获取计划的开始和最终Information
# self.splan = self.info.filter(Information.type=='plan').order_by(Information.start).first()
# self.eplan = self.info.filter(Information.type=='plan').order_by(desc(Information.finish)).first()
# l = len(self.plan)
# self.owner = self.plan[-1].owner if l else ''
# self.finish = self.plan[-1].finish if l else ''
# self.status = self.plan[-1].status if l else ''
pass
def complete(self, idx=[]):
self.identity = 'Task' + '_'.join(map(str, idx))
return self
def __str__(self):
return '[Task:{0}] id={1} typ={2} style={3}'.format(
self.title, self.id, self.typ, self.style)
class Pub(db.Model):
__tablename__ = 'pubs'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
cocktails = db.relationship('Cocktail', backref='pubs')
class Book(db.Model):
__tablename__ = 'books'
id = db.Column(db.Integer, primary_key=True)
isbn = db.Column(db.String(16), unique=True)
title = db.Column(db.String(128))
subtitle = db.Column(db.String(128))
authors = db.Column(db.String(128))
translator = db.Column(db.String(64))
publisher = db.Column(db.String(64))
thumbnail = db.Column(db.String(128))
publishedDate = db.Column(db.String(32))
pageCount = db.Column(db.Integer)
numbers = db.Column(db.Integer, default=5)
summary = db.deferred(db.Column(db.Text, default=""))
summary_html = db.deferred(db.Column(db.Text))
hidden = db.Column(db.Boolean, default=0)
logs = db.relationship('Log',
backref=db.backref('book', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
comments = db.relationship('Comment',
backref='book',
lazy='dynamic',
cascade='all, delete-orphan')
@property
def tags_string(self):
return ",".join([tag.name for tag in self.tags.all()])
@tags_string.setter
def tags_string(self, value):
self.tags = []
tags_list = value.split(u',')
for str in tags_list:
tag = Tag.query.filter(Tag.name.ilike(str)).first()
if tag is None:
tag = Tag(name=str)
self.tags.append(tag)
db.session.add(self)
db.session.commit()
def can_borrow(self):
return (not self.hidden) and self.can_borrow_number() > 0
def can_borrow_number(self):
return self.numbers - Log.query.filter_by(book_id=self.id,
returned=0).count()
@staticmethod
def on_changed_summary(target, value, oldvalue, initiaor):
allowed_tags = [
'a', 'abbr', 'acronym', 'b', 'blockquote', 'code', 'em', 'i', 'li',
'ol', 'pre', 'strong', 'ul', 'h1', 'h2', 'h3', 'p'
]
target.summary_html = bleach.linkify(
bleach.clean(markdown(value, output_format='html'),
tags=allowed_tags,
strip=True))
def __repr__(self):
return u'<Book %r>' % self.title
def last_modified_by(cls):
return db.relationship(
'User',
primaryjoin='User.id == %s.last_modified_by_id' % cls.__name__,
remote_side='User.id' )
class WorkCategories(BaseCategories, db.Model):
"""定义拼搏主题分类信息"""
__tablename__ = "tb_work_category"
work_article_list = db.relationship("Work_Article",
backref="work_category",
lazy="dynamic")
class Blog(db.Model):
"""
博客数据Model
"""
__tablename__ = 'blogs'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(128))
summary = db.Column(db.Text)
content = db.Column(db.Text)
content_html = db.Column(db.Text)
# 发布日期
publish_date = db.Column(db.DateTime, index=True)
# 最后的编辑日期
edit_date = db.Column(db.DateTime, index=True)
# 外键，和User表对应
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
# 是否是草稿
draft = db.Column(db.Boolean)
# 是否禁用评论
disable_comment = db.Column(db.Boolean, default=False)
# 被浏览的次数
views = db.Column(db.Integer, default=0)
comments = db.relationship('Comment', backref='blog', lazy='dynamic')
favourites = db.relationship('Favourite', backref='blog', lazy='dynamic')
def is_current_user_favourite(self):
"""
当前用户是否喜欢了该文章
"""
if self.favourites and self.favourites.filter_by(
user_id=current_user.id).first():
return True
else:
return False
# @staticmethod
# def on_changed_content(target, value, oldvalue, initiator):
# """
# 在服务端完成Markdown到Html的转换
# """
# target.content_html = bleach.linkify(markdown(value, output_format='html',
# extensions=['markdown.extensions.extra']))
def to_json(self):
"""
完成Blog数据模型到JSON格式化的序列化字典转换
"""
json_blog = {
'id':
self.id,
'title':
self.title,
'summary':
self.summary,
'content_html':
url_for('api.blog_preview', blog_id=self.id, _external=True),
'publish_date':
self.publish_date,
'labels': [label.name for label in self.labels.all()],
'views':
self.views,
'comment_count':
self.comments.count(),
'favourite_count':
self.favourites.count()
}
return json_blog
@staticmethod
def fake_blogs(count=50):
"""
生成测试数据
:param count:
:return:
"""
fake = Faker()
u = User.query.filter_by(role_id=2).first()
for i in range(count):
blog = Blog(title=fake.text()[0:20],
summary=fake.text(),
content=fake.text(),
draft=False,
publish_date=datetime.utcnow(),
edit_date=datetime.utcnow(),
user=u)
db.session.add(blog)
db.session.commit()
def address(cls):
return db.relationship("Address", uselist=False)
class Country(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, unique=True, convert_unicode=True)
region_id = db.Column(db.Integer, db.ForeignKey('region.id'))
region = db.relationship("Region", backref="regions")
with the product database.
Args:
db.Model initialized from sqlalchemy
"""
__tablename__ = 'stores'
id = db.Column(db.Integer, primary_key = True)
storename = db.Column(db.String(64), index=True, nullable=False)
storeurl = db.Column(db.String(64), index=True, nullable=False)
storedescription = db.Column(db.String(120), index=True, nullable=False)
storeaddress = db.Column(db.String(120), index=True, nullable=False)
storecity = db.Column(db.String(64), index=True, nullable=False)
storestate = db.Column(db.String(64), index=True, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
product = db.relationship('Product', backref='store', lazy='dynamic', cascade="all, delete-orphan")
def __repr__(self):
return '<Store %r>' % (self.storename)
class Product(db.Model):
"""Database table for products, having a many to one relationship with the Store database.
Args:
db.Model initialized from sqlalchemy
"""
__tablename__ = 'products'
id = db.Column(db.Integer, primary_key=True)
productname = db.Column(db.String(64), index=True, nullable=False)
class Warehouse(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
location_id = db.Column(db.Integer, db.ForeignKey('location.id'))
location = db.relationship("Location", backref="locations")
warehouse = db.relationship("Inventory", back_populates="warehouse")
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), unique=True)
email = db.Column(db.String(50), unique=True)
password = db.Column(db.String(255), nullable=False)
registered_on = db.Column(db.DateTime, default=datetime.datetime.utcnow)
is_staff = db.Column(db.Boolean)
is_moderator = db.Column(db.Boolean)
<<<<<<< HEAD
is_auth = db.Column(db.Boolean)
=======
active = db.Column(db.Boolean)
role = db.relationship('Role', secondary=roles_users, backref='users', lazy='dynamic')
>>>>>>> 1c0f406646b0c0631778c0ad9dedf6fd2043fa02
posts = db.relationship('Post', backref='author', lazy='dynamic')
comments = db.relationship('Comment', backref='author', lazy='dynamic')
def __init__(self, username, email, password):
self.username = username
self.email = email
self.set_password(password)
def set_password(self, password_hash):
self.password = encrypt_password(password_hash)
#def check_password(self, password_hash):
# return bcrypt.check_password_hash(self.password, password_hash)
class Conversation(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id_1 = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user_id_2 = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
messages = db.relationship('Message', backref='author', lazy='dynamic')
class Course(db.Model):
__tablename__ = 'courses'
id = db.Column(db.Integer, unique=True, primary_key=True)
name = db.Column(db.String(80), index=True) # 课程名称
dept_id = db.Column(db.Integer, db.ForeignKey('depts.id'))
_image = db.Column(db.String(100))
terms = db.relationship('CourseTerm',
backref='course',
order_by='desc(CourseTerm.term)',
lazy='joined')
classes = db.relationship('CourseClass', backref='course', lazy='joined')
_dept = db.relationship('Dept', backref='courses', lazy='joined')
teachers = db.relationship('Teacher',
secondary=course_teachers,
backref=db.backref('courses', lazy='dynamic'),
order_by='Teacher.id',
lazy="joined")
reviews = db.relationship(
'Review',
backref='course',
order_by='desc(Review.upvote_count), desc(Review.id)',
lazy='dynamic')
notes = db.relationship('Note',
backref='course',
order_by='desc(Note.upvote_count), desc(Note.id)',
lazy='dynamic')
forum_threads = db.relationship('ForumThread',
backref='course',
order_by='desc(ForumThread.id)',
lazy='dynamic')
shares = db.relationship(
'Share',
backref='course',
order_by='desc(Share.upvote_count), desc(Share.id)',
lazy='dynamic')
#followers : backref to User
#upvote_users: backref to User
#downvote_users: backref to User
#review_users: backref to User
_course_rate = db.relationship('CourseRate',
backref='course',
uselist=False,
lazy='joined')
@property
def teacher_id_list(self):
return [teacher.id for teacher in self.teachers]
def __repr__(self):
return self.name + '(' + ','.join(map(str, self.teacher_id_list)) + ')'
@classmethod
def create(cls, cno, term, **kwargs):
if cls.query.filter_by(cno=cno, term=term).first():
return None
course = Course(cno=cno, term=term, **kwargs)
course.course_rate = CourseRate()
db.session.add(course)
db.session.commit()
return course
@property
def url(self):
return url_for('course.view_course', course_id=self.id)
@property
def link(self):
if self.teachers_count > 0:
teacher_names = '（' + self.teacher_names_display + '）'
else:
teacher_names = ''
return Markup('<a href="' + self.url +
'">') + Markup.escape(self.name +
teacher_names) + Markup('</a>')
@property
def dept(self):
return self._dept.name
@property
def course_rate(self):
if self._course_rate:
return self._course_rate
else:
self._course_rate = CourseRate()
self.save()
return self._course_rate
@property
def rate(self):
return self.course_rate
def save(self):
db.session.add(self)
db.session.commit()
return self
@property
def teacher(self):
if len(self.teachers) >= 1:
return self.teachers[0]
else:
return None
@property
def related_courses(self):
'''return the courses that are the same name'''
return self.query.filter_by(name=self.name).all()
@property
def history_courses(self):
'''returns the courses having the same course number'''
return self.query.filter_by(courseries=self.courseries).all()
@property
def course_major_display(self):
if self.course_major == None:
return '未知'
def reviewed_by(self, user=current_user):
# the following is much more efficient than
# "user in self.review_users"
try:
return self in user.reviewed_course
except:
return False
@property
def reviewed(self):
return self.reviewed_by(current_user)
@property
def review_count(self):
return self.course_rate.review_count
@property
def upvote_count(self):
return self.course_rate.upvote_count
@property
def downvote_count(self):
return self.course_rate.downvote_count
def upvote(self, user=current_user):
user.courses_upvoted.append(self)
self.course_rate.upvote_count += 1
db.session.add(self)
db.session.commit()
return True
def un_upvote(self, user=current_user):
user.courses_upvoted.remove(self)
self.course_rate.upvote_count -= 1
db.session.add(self)
db.session.add(user)
db.session.commit()
return True
def downvote(self, user=current_user):
user.courses_downvoted.append(self)
self.course_rate.downvote_count += 1
db.session.add(self)
db.session.add(user)
db.session.commit()
return True
def un_downvote(self, user=current_user):
user.courses_downvoted.remove(self)
self.course_rate.downvote_count -= 1
db.session.add(self)
db.session.add(user)
db.session.commit()
return True
@property
def voted(self, user=current_user):
if user in self.upvote_users or user in self.downvote_users:
return True
return False
@property
def upvoted(self, user=current_user):
if user in self.upvote_users:
return True
return False
@property
def downvoted(self, user=current_user):
if user in self.downvote_users:
return True
return False
def follow(self, user=current_user):
if user in self.followers:
return False
self.followers.append(user)
self.course_rate.follow_count += 1
db.session.commit()
return True
def unfollow(self, user=current_user):
if not user in self.followers:
return False
self.followers.remove(user)
self.course_rate.follow_count -= 1
db.session.commit()
return True
@property
def following(self, user=current_user):
try:
return self in user.courses_following
except:
return False
@property
def follow_count(self):
return self.course_rate.follow_count
@property
def students(self):
from .user import Student, join_course
return Student.query.join(join_course).join(CourseClass).filter(
CourseClass.course_id == self.id).all()
@property
def student_count(self):
return len(self.students)
def join(self, user=current_user):
if not user.is_student or user.info in self.students:
return False
self.students.append(user.info)
db.session.commit()
return True
def quit(self, user=current_user):
if not user.is_student or not user.info in self.students:
return False
self.students.remove(user.info)
db.session.commit()
return True
@property
def teachers_count(self):
return len(self.teachers)
@property
def teacher_names_display(self):
if self.teachers_count == 0:
return 'Unknown'
else:
return ', '.join([teacher.name for teacher in self.teachers])
@property
def image(self):
if self._image:
return '/uploads/images/' + self._image
return '/static/image/user.png'
@property
def joined_users(self):
return User.query.join(Student).filter(
Student.user_id == User.id).join(CourseClass).filter(
self.id == CourseClass.course_id).join(join_course).filter(
join_course.c.class_id == CourseClass.id,
join_course.c.student_id == Student.sno).all()
@property
def latest_term(self):
return self.terms[0]
@property
def term_ids(self):
return [t.term for t in self.terms]
# sqlalchemy uses __getattr__, so we cannot use it
# copy properties from latest_term
@property
def courseries(self):
return self.latest_term.courseries
@property
def kcid(self):
return self.latest_term.kcid
@property
def course_major(self):
return self.latest_term.course_major
@property
def course_type(self):
return self.latest_term.course_type
@property
def course_level(self):
return self.latest_term.course_level
@property
def grading_type(self):
return self.latest_term.grading_type
@property
def teaching_material(self):
return self.latest_term.teaching_material
@property
def reference_material(self):
return self.latest_term.reference_material
@property
def student_requirements(self):
return self.latest_term.student_requirements
@property
def description(self):
return self.latest_term.description
@property
def description_eng(self):
return self.latest_term.description_eng
@property
def introduction(self):
return self.latest_term.introduction
@property
def homepage(self):
return self.latest_term.homepage
@property
def credit(self):
return self.latest_term.credit
@property
def hours(self):
return self.latest_term.hours
@property
def hours_per_week(self):
return self.latest_term.hours_per_week
@property
def class_numbers(self):
return self.latest_term.class_numbers
@property
def campus(self):
return self.latest_term.campus
@property
def start_week(self):
return self.latest_term.start_week
@property
def end_week(self):
return self.latest_term.end_week
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
posts = db.relationship('Post', backref='author', lazy='dynamic')
about_me = db.Column(db.String(280))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
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')
def __repr__(self):
return f'<User {self.username}>'
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
# Get link for user's avatar. Create new is user doesn't have one.
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return f'https://www.gravatar.com/avatar/{digest}?d=robohash&s={size}'
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
def is_following(self, user):
return self.followed.filter(followers.c.followed_id == user.id).count() > 0
# Get posts of people this user follows along with own posts of the user
def get_followed_posts(self):
# Get others' posts
followed = Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id)
# Get own posts
own = Post.query.filter_by(user_id=self.id)
# Merge them and sort by date
return followed.union(own).order_by(Post.timestamp.desc())
def get_reset_password_token(self, expires_in=600):
return jwt.encode({'reset_password': self.id, 'exp': time() + expires_in}, current_app.config['SECRET_KEY'],
algorithm='HS256').decode('utf-8')
@staticmethod
def verify_reset_password_token(token):
try:
user_id = jwt.decode(token, current_app.config['SECRET_KEY'], algorithm=['HS256'])['reset_password']
# You don't need to check expiration manually - it is being checked automatically
except:
return
return User.query.get(user_id)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
posts = db.relationship('Post', backref='author', lazy='dynamic')
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
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')
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def __repr__(self):
return '<User %s>' % self.username
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/%s?d=identicon&s=%s' \
% (digest, size)
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
followed = Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id)
own = Post.query.filter_by(user_id=self.id)
return followed.union(own).order_by(Post.timestamp.desc())
def get_reset_password_token(self, expires_in=600):
return jwt.encode(
{
'reset_password': self.id,
'exp': time() + expires_in
},
app.config['SECRET_KEY'],
algorithm='HS256').decode('utf-8')
@staticmethod
def verify_reset_password_token(token):
try:
id = jwt.decode(token,
app.config['SECRET_KEY'],
algorithms=['HS256'])['reset_password']
except:
return
return User.query.get(id)
class User(UserMixin, PaginatedAPIMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
__table_args__ = {'extend_existing': True}
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
firstName = db.Column(db.String(64))
lastName = db.Column(db.String(64))
mobileNumber = db.Column(db.String(12))
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
tasks = db.relationship('TaskModel', backref='user', lazy='dynamic')
posts = db.relationship('PostModel', backref='author', lazy='dynamic')
fygoals = db.relationship('FyGoalModel', backref='author', lazy='dynamic')
token = db.Column(db.String(32), index=True, unique=True)
token_expiration = db.Column(db.DateTime)
assignments = db.relationship('AssignmentModel',
foreign_keys='AssignmentModel.student_id',
backref='author',
lazy='dynamic')
messages_sent = db.relationship('MessageModel',
foreign_keys='MessageModel.sender_id',
backref='author',
lazy='dynamic')
messages_received = db.relationship(
'MessageModel',
foreign_keys='MessageModel.recipient_id',
backref='recipient',
lazy='dynamic')
last_message_read_time = db.Column(db.DateTime)
notifications = db.relationship('NotificationModel',
backref='user',
lazy='dynamic')
fypriorities = db.relationship('FyPrioritiesModel',
backref='user',
lazy='dynamic')
fygoals = db.relationship('FyGoalModel', backref='user', lazy='dynamic')
barriers = db.relationship('BarriersModel', backref='user', lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
def get_reset_password_token(self, expires_in=600):
return jwt.encode(
{
'reset_password': self.id,
'exp': time() + expires_in
},
current_app.config['SECRET_KEY'],
algorithm='HS256').decode('utf-8')
@staticmethod
def verify_reset_password_token(token):
try:
id = jwt.decode(token,
current_app.config['SECRET_KEY'],
algorithms=['HS256'])['reset_password']
except:
return
return User.query.get(id)
def new_messages(self):
last_read_time = self.last_message_read_time or datetime(1900, 1, 1)
return MessageModel.query.filter_by(recipient=self).filter(
MessageModel.timestamp > last_read_time).count()
def add_notification(self, name, data):
self.notifications.filter_by(name=name).delete()
n = NotificationModel(name=name,
payload_json=json.dumps(data),
user=self)
db.session.add(n)
return n
def launch_task(self, name, description, *args, **kwargs):
rq_job = current_app.task_queue.enqueue('app.tasks.' + name, self.id,
*args, **kwargs)
task = TaskModel(id=rq_job.get_id(),
name=name,
description=description,
user=self)
db.session.add(task)
return task
def get_tasks_in_progress(self):
return TaskModel.query.filter_by(user=self, complete=False).all()
def get_task_in_progress(self, name):
return TaskModel.query.filter_by(name=name, user=self,
complete=False).first()
#The to_dict function
def to_dict(self, include_email=False):
data = {
'id': self.id,
'username': self.username,
'last_seen': self.last_seen.isoformat() + 'Z',
'about_me': self.about_me,
'post_count': self.posts.count(),
'_links': {
'self': url_for('api.get_user', id=self.id),
'avatar': self.avatar(128)
}
}
if include_email:
data['email'] = self.email
return data
def from_dict(self, data, new_user=False):
for field in ['username', 'email', 'about_me']:
if field in data:
setattr(self, field, data[field])
if new_user and 'password' in data:
self.set_password(data['password'])
def get_token(self, expires_in=3600):
now = datetime.utcnow()
if self.token and self.token_expiration > now + timedelta(seconds=60):
return self.token
self.token = base64.b64encode(os.urandom(24)).decode('utf-8')
self.token_expiration = now + timedelta(seconds=expires_in)
db.session.add(self)
return self.token
def revoke_token(self):
self.token_expiration = datetime.utcnow() - timedelta(seconds=1)
@staticmethod
def check_token(token):
user = User.query.filter_by(token=token).first()
if user is None or user.token_expiration < datetime.utcnow():
return None
return user
class TeamType(db.Model):
__tablename__ = 'teamType'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30))
shortName = db.Column(db.String(15))
teams = db.relationship("Team", backref="type", lazy=False)
class User(db.Model):
""" creates an entry of the user in the database """
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
first_name = db.Column(db.String(20))
last_name = db.Column(db.String(20))
username = db.Column(db.String(30), unique=True, index=True)
email = db.Column(db.String(120), unique=True)
password = db.Column(db.String(120))
ip_address = db.Column(db.String(24))
last_login = db.Column(db.DateTime, default=datetime.datetime.utcnow)
is_active = db.Column(db.Boolean(), nullable=False, default=False)
date_created = db.Column(db.DateTime, default=datetime.datetime.utcnow)
date_updated = db.Column(db.DateTime,
default=datetime.datetime.utcnow,
onupdate=datetime.datetime.utcnow)
shops = db.relationship('Shops', backref='users', lazy='dynamic')
shop_items = db.relationship('Items', backref='users', lazy='dynamic')
shop_services = db.relationship('Services',
backref='users',
lazy='dynamic')
def __init__(self, first_name, last_name, username, email, password):
""" Intialize the user with the first name, last name, username,
email and his password
"""
self.first_name = first_name
self.last_name = last_name
self.username = username
self.email = email
self.password = Bcrypt().generate_password_hash(password).decode()
def password_is_valid(self, password):
"""
Checks the password against it's hash to validates the user's password
"""
return Bcrypt().check_password_hash(self.password, password)
def __repr__(self):
return "{}, {}, {}".format(self.first_name, self.last_name,
self.last_login)
def generate_token(self, id):
""" Generates the access token"""
try:
# set up a payload with an expiration time
payload = {
'exp': datetime.datetime.utcnow() + timedelta(minutes=30),
'iat': datetime.datetime.utcnow(),
'sub': id
}
# create the byte string token using the payload and the SECRET key
jwt_string = jwt.encode(payload,
current_app.config.get('SECRET'),
algorithm='HS256')
return jwt_string
except Exception as e:
# return an error in string format if an exception occurs
return str(e)
@staticmethod
def decode_token(token):
"""Decodes the access token from the Authorization header."""
try:
# try to decode the token using our SECRET variable
payload = jwt.decode(token, current_app.config.get('SECRET'))
return payload['sub']
except jwt.ExpiredSignatureError:
# the token is expired, return an error string
return "Expired token. Please login to get a new token"
except jwt.InvalidTokenError:
# the token is invalid, return an error string
return "Invalid token. Please register or login"
def save(self):
""" add new user to database"""
db.session.add(self)
db.session.commit()
def delete(self):
""" delete user from database """
db.session.delete(self)
db.session.commit()
class User(
UserMixin, db.Model
): #User Mixin is a Flask-Login sub class which adds functionality the login requires for the user model
"""Model representation of users in the website"""
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
posts = db.relationship('Post', backref='author', lazy='dynamic')
about_me = db.Column(db.String(140))
representative = db.Column(db.String(100))
constituency = db.Column(db.String(100))
postcode = db.Column(db.String(64))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
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')
messages_sent = db.relationship('Message',
foreign_keys='Message.sender_id',
backref='author',
lazy='dynamic')
messages_received = db.relationship('Message',
foreign_keys='Message.recipient_id',
backref='recipient',
lazy='dynamic')
last_message_read_time = db.Column(db.DateTime)
notifications = db.relationship('Notification',
backref='user',
lazy='dynamic')
def __repr__(self):
"""represents a user object"""
return '<User {}>'.format(self.username)
def set_password(self, password):
"""sets the password of a user and stores in a hash table"""
self.password_hash = generate_password_hash(password)
def check_password(self, password):
"""checks a users password to that of the hashtable"""
return check_password_hash(self.password_hash, password)
def set_representativeandconst(self):
"""sets a users representative and constituency"""
self.representative = oa.get_representatives(int(
self.postcode))[0]['full_name']
self.constituency = oa.get_representatives(
self.postcode)[0]['constituency']
self.personid = oa.get_representatives(self.postcode)[0]['person_id']
def openaustraliadata(self):
"""returns the postcode for a user"""
return self.postcode
def avatar(self, size):
"""returns a avatar for a user"""
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
def follow(self, user):
"""allows the current user to follow another user"""
if not self.is_following(user):
self.followed.append(user)
def unfollow(self, user):
"""allows the current user to unfollow another user"""
if self.is_following(user):
self.followed.remove(user)
def is_following(self, user):
"""indicates whether one user is following another user"""
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
"""shows the posts of a users follow feed"""
followed = Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id
) #joins the posts with the same user.id and followed id
own = Post.query.filter_by(
user_id=self.id) #create query which takes the users own posts
return followed.union(own).order_by(Post.timestamp.desc(
)) #joins both queries above together to generate the users newsfeed
def get_reset_password_token(self, expires_in=600):
"""generates token required for user to reset password"""
return jwt.encode(
{
'reset_password': self.id,
'exp': time() + expires_in
},
current_app.config['SECRET_KEY'],
algorithm='HS256').decode('utf-8')
@staticmethod #static method means it can be invoked without passing a member of a class to it
def verify_reset_password_token(token):
"""verifies token required for user to reset password"""
try:
id = jwt.decode(token,
current_app.config['SECRET_KEY'],
algorithms=['HS256'])['reset_password']
except:
return
return User.query.get(id)
def new_messages(self):
"""shows how many new messages has gotten since checking the messaging page"""
last_read_time = self.last_message_read_time or datetime(1900, 1, 1)
return Message.query.filter_by(recipient=self).filter(
Message.timestamp > last_read_time).count()
def add_notification(self, name, data):
"""add notifications"""
self.notifications.filter_by(name=name).delete()
n = Notification(name=name, payload_json=json.dumps(data), user=self)
db.session.add(n)
return n
class OAuth(OAuthConsumerMixin, db.Model):
user_id = db.Column(db.Integer, db.ForeignKey(User.id))
user = db.relationship(User)
class FreeCategories(BaseCategories, db.Model):
"""定义自由主题分类信息"""
__tablename__ = "tb_free_category"
free_article_list = db.relationship("Free_Article",
backref="free_category",
lazy="dynamic")
class Token(db.Model):
id = db.Column(db.Integer, primary_key=True)
uuid = db.Column(db.String, unique=True)
user_id = db.Column(db.Integer, db.ForeignKey(User.id), nullable=False)
user = db.relationship(User)
class ThinkingCategories(BaseCategories, db.Model):
"""定义宁静主题分类信息"""
__tablename__ = "tb_thinking_category"
thinking_article_list = db.relationship("Thinking_Article",
backref="thinking_category",
lazy="dynamic")
class User(PaginateAPIMixin, UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
posts = db.relationship('Post', backref='author', lazy='dynamic')
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
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')
messages_sent = db.relationship('Message',
foreign_keys='Message.sender_id',
backref='author',
lazy='dynamic')
messages_received = db.relationship('Message',
foreign_keys='Message.recipient_id',
backref='recipient',
lazy='dynamic')
last_message_read_time = db.Column(db.DateTime)
notifications = db.relationship('Notification',
backref='user',
lazy='dynamic')
tasks = db.relationship('Task', backref='user', lazy='dynamic')
token = db.Column(db.String(32), index=True, unique=True)
token_expiration = db.Column(db.DateTime)
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.\
format(digest, size)
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
def followed_posts(self):
followed = Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id)
own = Post.query.filter_by(user_id=self.id)
return followed.union(own).order_by(Post.timestamp.desc())
def get_reset_password_token(self, expires_in=600):
return jwt.encode(
{
'reset_password.txt': self.id,
'exp': time() + expires_in
},
current_app.config['SECRET_KEY'],
algorithm='HS256').decode('utf-8')
@staticmethod
def verify_reset_password_token(token):
try:
id = jwt.decode(token,
current_app.config['SECRET_KEY'],
algorithms=['HS256'])['reset_password.txt']
except jwt.exceptions.DecodeError:
return
return User.query.get(id)
def new_messages(self):
last_read_time = self.last_message_read_time or datetime(1900, 1, 1)
return Message.query.filter_by(recipient=self).filter(
Message.timestamp > last_read_time).count()
def add_notification(self, name, data):
self.notifications.filter_by(name=name).delete()
n = Notification(name=name, payload_json=json.dumps(data), user=self)
db.session.add(n)
return n
def launch_task(self, name, description, *args, **kwargs):
rq_job = current_app.task_queue.enqueue('app.tasks.' + name, self.id,
*args, **kwargs)
task = Task(id=rq_job.get_id(),
name=name,
description=description,
user=self)
db.session.add(task)
return task
def get_tasks_in_progress(self):
return Task.query.filter_by(user=self, complete=False).all()
def get_task_in_progress(self, name):
return Task.query.filter_by(user=self, name=name,
complete=False).first()
def to_dict(self, include_email=False):
data = {
'id': self.id,
'username': self.username,
'last_seen': self.last_seen.isoformat() + 'Z',
'about_me': self.about_me,
'post_count': self.posts.count(),
'follower_count': self.followers.count(),
'followed_count': self.followed.count(),
'_links': {
'self': url_for('api.get_user', id=self.id),
'followers': url_for('api.get_followers', id=self.id),
'followed': url_for('api.get_followed', id=self.id),
'avatar': self.avatar(128)
}
}
if include_email:
data['email'] = self.email
return data
def from_dict(self, data, new_user=False):
for field in ['username', 'email', 'about_me']:
if field in data:
setattr(self, field, data[field])
if new_user and 'password' in data:
self.set_password(data['password'])
def get_token(self, expires_in=3600):
now = datetime.utcnow()
if self.token and self.token_expiration > now + timedelta(seconds=60):
return self.token
self.token = base64.b64encode(os.urandom(24)).decode('utf-8')
self.token_expiration = now + timedelta(seconds=expires_in)
db.session.add(self)
return self.token
def revoke_token(self):
self.token_expiration = datetime.utcnow() - timedelta(seconds=1)
@staticmethod
def check_token(token):
user = User.query.filter_by(token=token).first()
if user is None or user.token_expiration < datetime.utcnow():
return None
return user
def agency(cls):
return db.relationship("Agency", uselist=False)
class Admin(db.Model):
__tablename__ = 'Admin'
id = db.Column('user_id',db.Integer , primary_key=True)
username = db.Column(db.String(25), unique=True , index=True)
password = db.Column(db.String(128))
ravello_username = db.Column(db.String(35))
ravello_password = db.Column(db.BLOB())
users = db.relationship('User', backref=db.backref('admin', lazy=True))
clients = db.relationship('Client', backref=db.backref('admin', lazy=True))
blueprint = db.relationship('Blueprint', backref=db.backref('admin', lazy=True))
def __init__(self, username, password, ravello_username, ravello_password):
self.username = username
self.password = self.hash_password(password)
self.ravello_username = ravello_username
self.ravello_password = encrypt(config.key, ravello_password)
def hash_password(self, pword):
hashed = phash.hash(pword)
print(str(hashed))
return hashed
def verify_password(self, pword):
print(phash.verify(pword, self.password))
return phash.verify(pword, self.password)
def insert(self):
try:
db.session.add(self)
db.session.commit()
return True
except BaseException as e:
print('exception occurred, rolling back db')
print(str(e))
db.session.rollback()
return False
def __str__(self):
return self.username + ' ' + self.password
def create_user(self, client_username, client_password, hostname):
user = User(client_username, client_password, hostname, self.id)
user.insert()
def create_clients(self, quantity):
password = decrypt(config.key, self.ravello_password)
ravello = Ravello(self.ravello_username, password)
apps = ravello.create_applications(quantity, bp_id=self.blueprint[0].bp_id)
if not apps:
return None
for app in apps:
client = Client(self.id, str(app[0]), app[1], str(app[2]), self.blueprint[0].id)
print(self.blueprint[0].id)
print(client.bp_id)
self.insert_client(client)
def insert_client(self, client):
try:
db.session.add(client)
db.session.commit()
return True
except BaseException as e:
print('exception occurred, rolling back db')
print(str(e))
db.session.rollback()
return False
def get_blueprint(self):
print('getting blueprint')
password = decrypt(config.key, self.ravello_password)
ravello = Ravello(self.ravello_username, password)
bp_id, description = ravello.get_gold_image()
print(bp_id, description)
if not self.blueprint:
bp = Blueprint(self.id, str(bp_id), description)
print(bp.serialize())
bp.insert()
return bp.serialize()
if self.blueprint[0].bp_id == str(bp_id):
print('2')
return self.blueprint[0].serialize()
else:
print('3')
db.session.delete(self.blueprint[0])
db.session.commit()
bp = Blueprint(self.id, bp_id, description)
bp.insert()
return bp.serialize()
def set_blueprint_connection(self, rdp_uname, rdp_pword):
blueprint = Blueprint.query.get(self.blueprint[0].id)
blueprint.rdp_uname = rdp_uname
blueprint.rdp_pword = encrypt(config.key, rdp_pword)
print(blueprint.rdp_uname)
print(blueprint.rdp_pword)
db.session.commit()
return True
def sample_annotations(self):
return db.relationship('ProjectSampleAnnotations', backref=db.backref('project'), lazy='dynamic',
cascade='save-update, merge, delete, expunge')
class User(db.Model):
"""This class defines the users table """
__tablename__ = 'users'
# Define the columns of the users table, starting with the primary key
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(256), nullable=False, unique=True)
password = db.Column(db.String(256), nullable=False)
expenses = db.relationship(
'ExpenseTracker', order_by='ExpenseTracker.id', cascade="all, delete-orphan")
def __init__(self, email, password):
"""Initialize the user with an email and a password."""
self.email = email
self.password = Bcrypt().generate_password_hash(password).decode()
def password_is_valid(self, password):
"""
Checks the password against it's hash to validates the user's password
"""
return Bcrypt().check_password_hash(self.password, password)
def save(self):
"""Save a user to the database.
This includes creating a new user and editing one.
"""
db.session.add(self)
db.session.commit()
def generate_token(self, user_id):
""" Generates the access token"""
try:
# set up a payload with an expiration time
payload = {
'exp': datetime.utcnow() + timedelta(hours=5),
'iat': datetime.utcnow(),
'sub': user_id
}
# create the byte string token using the payload and the SECRET key
jwt_string = jwt.encode(
payload,
Config.SECRET,
algorithm='HS256'
)
return jwt_string
except Exception as e:
# return an error in string format if an exception occurs
return str(e)
@staticmethod
def decode_token(token):
"""Decodes the access token from the Authorization header."""
try:
# try to decode the token using our SECRET variable
payload = jwt.decode(token, Config.SECRET)
return payload['sub']
except jwt.ExpiredSignatureError:
# the token is expired, return an error string
return "Expired token. Please login to get a new token"
except jwt.InvalidTokenError:
# the token is invalid, return an error string
return "Invalid token. Please register or login"
def created_by(cls):
return db.relationship(
"AppUser",
foreign_keys=lambda: cls.created_by_id
)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
posts = db.relationship('Post', backref='author', lazy='dynamic')
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
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')
messages_sent = db.relationship('Message',
foreign_keys='Message.sender_id',
backref='author',
lazy='dynamic')
messages_received = db.relationship('Message',
foreign_keys='Message.recipient_id',
backref='recipient',
lazy='dynamic')
last_message_read_time = db.Column(db.DateTime)
notifications = db.relationship('Notification',
backref='user',
lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
followed = Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id)
own = Post.query.filter_by(user_id=self.id)
return followed.union(own).order_by(Post.timestamp.desc())
def get_reset_password_token(self, expires_in=600):
return jwt.encode(
{
'reset_password': self.id,
'exp': time() + expires_in
},
current_app.config['SECRET_KEY'],
algorithm='HS256').decode('utf-8')
@staticmethod
def verify_reset_password_token(token):
try:
id = jwt.decode(token,
current_app.config['SECRET_KEY'],
algorithms=['HS256'])['reset_password']
except:
return
return User.query.get(id)
def new_messages(self):
last_read_time = self.last_message_read_time or datetime(1900, 1, 1)
return Message.query.filter_by(recipient=self).filter(
Message.timestamp > last_read_time).count()
def add_notification(self, name, data):
self.notifications.filter_by(name=name).delete()
n = Notification(name=name, payload_json=json.dumps(data), user=self)
db.session.add(n)
return n
def bin_estimator(self):
return db.relationship('BinEstimatorProject', lazy='select', foreign_keys=[self.bin_estimator_id])
class User(db.Model):
"""
Table schema
"""
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
registered_on = db.Column(db.DateTime, nullable=False)
buckets = db.relationship('Bucket', backref='bucket', lazy='dynamic')
silos = db.relationship('Silo', backref='silo', lazy='dynamic')
def __init__(self, email, password):
self.email = email
self.password = bcrypt.generate_password_hash(password, app.config.get('BCRYPT_LOG_ROUNDS')) \
.decode('utf-8')
self.registered_on = datetime.datetime.now()
def save(self):
"""
Persist the user in the database
:param user:
:return:
"""
db.session.add(self)
db.session.commit()
if not len(self.silos.all()):
s = Silo(owner_id=self.id)
db.session.add(s)
db.session.commit()
return self.encode_auth_token(self.id)
def encode_auth_token(self, user_id):
"""
Encode the Auth token
:param user_id: User's Id
:return:
"""
try:
payload = {
'exp':
datetime.datetime.utcnow() + datetime.timedelta(
days=app.config.get('AUTH_TOKEN_EXPIRY_DAYS'),
seconds=app.config.get('AUTH_TOKEN_EXPIRY_SECONDS')),
'iat':
datetime.datetime.utcnow(),
'sub':
user_id
}
return jwt.encode(payload,
app.config['SECRET_KEY'],
algorithm='HS256')
except Exception as e:
return e
def get_silo(self):
return self.silos[0] if len(self.silos.all()) else None
def json(self):
return {
'id': self.id,
'email': self.email,
}
@staticmethod
def decode_auth_token(token):
"""
Decoding the token to get the payload and then return the user Id in 'sub'
:param token: Auth Token
:return:
"""
try:
payload = jwt.decode(token,
app.config['SECRET_KEY'],
algorithms='HS256')
is_token_blacklisted = BlackListToken.check_blacklist(token)
if is_token_blacklisted:
return 'Token was Blacklisted, Please login In'
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired, Please sign in again'
except jwt.InvalidTokenError:
return 'Invalid token. Please sign in again'
@staticmethod
def get_by_id(user_id):
"""
Filter a user by Id.
:param user_id:
:return: User or None
"""
return User.query.filter_by(id=user_id).first()
@staticmethod
def get_by_email(email):
"""
Check a user by their email address
:param email:
:return:
"""
return User.query.filter_by(email=email).first()
def locus_set(self):
return db.relationship('LocusSet', cascade='save-update, merge')
def quantification_bias_estimator(self):
return db.relationship('QuantificationBiasEstimatorProject', lazy='select',
foreign_keys=[self.quantification_bias_estimator_id])
