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])