class Tag(db.Model):
__tablename__ = 'Tag'
tagId = db.Column(db.BigInteger,
primary_key=True,
nullable=False,
autoincrement=True)
parentId = db.Column(db.BigInteger,
db.ForeignKey('Tag.tagId'),
nullable=True)
name = db.Column(db.Unicode(30), nullable=False)
description = db.Column(db.Text, nullable=False)
popularity = db.Column(db.Integer, default=0, nullable=False)
tagUsers = db.relationship('UserTag',
foreign_keys=[UserTag.userId],
backref=db.backref('users', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
articles = db.relationship('ArticleTag',
foreign_keys=[ArticleTag.articleId],
backref=db.backref('articles', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
problems = db.relationship('ProblemTag',
foreign_keys=[QuestionTag.questionId],
backref=db.backref('problems', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
class Question(db.Model):
__tablename__ = 'Question'
questionId = db.Column(db.BigInteger,
primary_key=True,
nullable=False,
autoincrement=True)
userId = db.Column(db.BigInteger,
db.ForeignKey('User.id', ondelete='CASCADE'))
title = db.Column(db.Unicode(100), nullable=False)
content = db.Column(db.Text, nullable=False)
publicTime = db.Column(db.DateTime, default=datetime.now(), nullable=False)
answers = db.relationship('Answer',
backref=db.backref('answers'),
lazy='dynamic',
cascade='all, delete-orphan')
tags = db.relationship('QuestionTag',
backref=db.backref('tags'),
lazy='dynamic',
cascade='all, delete-orphan')
favoriteUsers = db.relationship('FavoriteQuestion',
backref=db.backref('favorite_users'),
lazy='dynamic',
cascade='all, delete-orphan')
@staticmethod
def generate_fake(count=100):
seed()
user_count = User.query.count()
for i in range(count):
user = User.query.offset(randint(0, user_count - 1)).first()
title = forgery_py.lorem_ipsum.sentence()
if len(title) > 50:
title = title[:20]
question = Question(userId=user.id,
title=title,
content=forgery_py.lorem_ipsum.sentences(
randint(1, 3)),
publicTime=forgery_py.date.date(True))
db.session.add(question)
try:
db.session.commit()
except:
db.session.rollback()
def get_user(self):
return User.query.filter(User.id == self.userId).first().username
def is_user_favorite(self, user):
return 'true' if self.questionId in map(
lambda x: x.questionId, user.favoriteQuestions.all()) else 'false'
def get_type(self):
return 'question'
class Menu(db.Model):
__tablename__ = 'menus'
id = db.Column(db.Integer, primary_key=True)
exclude_columns = ['created_at', 'updated_at']
auth_name = Column(db.String(32), nullable=False, index=True)
path = Column(db.String(256), nullable=False)
level = Column(db.Integer, nullable=True)
created_at = Column(db.Date, nullable=True, default=datetime.now)
updated_at = Column(db.Date, nullable=True, default=datetime.now)
parent_id = db.Column(db.Integer, db.ForeignKey('menus.id'))
children = db.relationship('Menu', back_populates='parent')
parent = db.relationship('Menu',
back_populates='children',
remote_side=[id])
# role_id = Column(db.Integer, db.ForeignKey('roles.id'))
# role = relationship('Role', backref=db.backref('menus', order_by=id))
# roles = relationship('Role', secondary=association_table, back_populates="menus")
# 将back_populates修改为db.backref() 指定 lazy = 'dynamic' 参数，关系两侧返回的查询都可接受额外的过滤器
roles = relationship('Role',
secondary=association_table,
backref=db.backref("menus", lazy='dynamic'))
def __init__(self, auth_name, path, **kwargs):
db.Model.__init__(self, auth_name=auth_name, path=path, **kwargs)
class Edit(db.Model):
__tablename__ = 'edit'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(50), nullable=False)
content = db.Column(db.Text, nullable=False)
datetime = db.Column(db.DateTime, default=datetime.now)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', backref=db.backref('edits'))
class User(db.Model):
__tablename__ = 'User'
userId = db.Column(db.BigInteger,
primary_key=True,
nullable=False,
autoincrement=True)
userName = db.Column(db.Unicode(20), nullable=False)
email = db.Column(db.Unicode(64), nullable=False)
phone = db.Column(db.CHAR(11), nullable=False)
password = db.Column(db.Unicode(100), nullable=False)
headImage = db.Column(db.Unicode(256), nullable=False)
permission = db.Column(db.CHAR(1), nullable=False)
introduction = db.Column(db.Text, default='这家伙很懒，什么也没有写~', nullable=False)
tags = db.relationship('UserTag',
foreign_keys=[UserTag.tagId],
backref=db.backref('tags'),
lazy='dynamic',
cascade='all, delete-orphan')
articles = db.relationship('Article', backref=db.backref('articles'))
questions = db.relationship('Question', backref=db.backref('questions'))
drafts = db.relationship('Draft', backref=db.backref('drafts'))
answers = db.relationship('Answer', backref=db.backref('answers'))
followed = db.relationship('Follow',
foreign_keys=[Follow.followerId],
backref=db.backref('follower', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
followers = db.relationship('Follow',
foreign_keys=[Follow.followedId],
backref=db.backref('followed', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
favoriteArticles = db.relationship(
'FavoriteArticle',
foreign_keys=[FavoriteArticle.articleId],
backref=db.backref('articles', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
favoriteQuestions = db.relationship(
'FavoriteQuestion',
foreign_keys=[FavoriteQuestion.questionId],
backref=db.backref('questions', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
notifications = db.relationship('Notification',
backref=db.backref('notifications'))
class Question(db.Model):
__tablename__ = 'Question'
questionId = db.Column(db.BigInteger,
primary_key=True,
nullable=False,
autoincrement=True)
title = db.Column(db.Unicode(100), nullable=False)
content = db.Column(db.Text, nullable=False)
publicTime = db.Column(db.DateTime, default=datetime.now(), nullable=False)
answers = db.relationship('Answer', backref=db.backref('answers'))
tags = db.relationship('QuestionTag',
foreign_keys=[QuestionTag.tagId],
backref=db.backref('tags', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
favoriteUsers = db.relationship('FavoriteQuestion',
foreign_keys=[FavoriteQuestion.userId],
lazy='dynamic',
cascade='all, delete-orphan')
class Answer(db.Model):
__tablename__ = 'Answer'
answerId = db.Column(db.BigInteger,
primary_key=True,
nullable=False,
autoincrement=True)
userId = db.Column(db.BigInteger,
db.ForeignKey('User.id', ondelete='CASCADE'),
nullable=False)
questionId = db.Column(db.BigInteger,
db.ForeignKey('Question.questionId',
ondelete='CASCADE'),
nullable=False)
content = db.Column(db.Text, nullable=False)
answerTime = db.Column(db.DateTime, default=datetime.now(), nullable=False)
answerComments = db.relationship('AnswerComment',
backref=db.backref('comments'),
lazy='dynamic',
cascade='all, delete-orphan')
likeUsers = db.relationship('LikeAnswer',
backref=db.backref('like_users'),
lazy='dynamic',
cascade='all, delete-orphan')
unlikeUsers = db.relationship('UnlikeAnswer',
backref=db.backref('unlike_users'),
lazy='dynamic',
cascade='all, delete-orphan')
def get_user(self):
return User.query.filter(User.id == self.userId).first().username
def get_question(self):
return Question.query.filter(
Question.questionId == self.questionId).first()
def is_user_like(self, user):
return 'true' if self.answerId in map(
lambda x: x.answerId, user.likeAnswers.all()) else 'false'
def is_user_unlike(self, user):
return 'true' if self.answerId in map(
lambda x: x.answerId, user.unlikeAnswers.all()) else 'false'
class Publisher(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(20), unique=True)
address = db.Column(db.String(20))
city = db.Column(db.String(20))
province = db.Column(db.String(20))
country = db.Column(db.String(30))
website = db.Column(db.String(30))
books = db.relationship('Book',
backref=db.backref('publishers'),
secondary=collection)
class Tag(db.Model):
__tablename__ = 'Tag'
tagId = db.Column(db.BigInteger,
primary_key=True,
nullable=False,
autoincrement=True)
parentId = db.Column(db.BigInteger,
db.ForeignKey('Tag.tagId', ondelete='CASCADE'),
nullable=True)
name = db.Column(db.Unicode(30), nullable=False)
description = db.Column(db.Text, nullable=False)
popularity = db.Column(db.Integer, default=0, nullable=False)
tagUsers = db.relationship('UserTag',
backref=db.backref('users'),
lazy='dynamic',
cascade='all, delete-orphan')
articles = db.relationship('ArticleTag',
backref=db.backref('articles'),
lazy='dynamic',
cascade='all, delete-orphan')
problems = db.relationship('QuestionTag',
backref=db.backref('problems'),
lazy='dynamic',
cascade='all, delete-orphan')
def __init__(self, parentId, name, description, popularity):
self.parentId = parentId
self.name = name
self.description = description
self.popularity = popularity
def get_child_tags(self):
return Tag.query.filter(Tag.parentId == self.tagId).all()
# 将类转为字典，然后响应json
def as_dict(obj):
return dict((col.name, getattr(obj, col.name)) \
for col in class_mapper(obj.__class__).mapped_table.c)
class Article(db.Model):
__tablename__ = 'Article'
articleId = db.Column(db.BigInteger,
primary_key=True,
nullable=False,
autoincrement=True)
userId = db.Column(db.BigInteger,
db.ForeignKey('User.userId'),
nullable=False)
title = db.Column(db.Unicode(100), nullable=False)
content = db.Column(db.Text, nullable=False)
publicTime = db.Column(db.DateTime, default=datetime.now(), nullable=False)
tags = db.relationship('ArticleTag',
foreign_keys=[ArticleTag.tagId],
backref=db.backref('tags', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
favoriteUsers = db.relationship('FavoriteArticle',
foreign_keys=[FavoriteArticle.userId],
backref=db.backref('favoriteUsers',
lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
class AnswerComment(db.Model):
__tablename__ = 'AnswerComment'
commentId = db.Column(db.BigInteger,
primary_key=True,
nullable=False,
autoincrement=True)
parentId = db.Column(db.BigInteger,
db.ForeignKey('AnswerComment.commentId'),
nullable=True)
userId = db.Column(db.BigInteger,
db.ForeignKey('User.userId'),
nullable=False)
content = db.Column(db.Text, nullable=False)
commentTime = db.Column(db.DateTime,
default=datetime.now(),
nullable=False)
childComments = db.relationship('AnswerComment',
backref=db.backref('childComments'))
class Manager(db.Model):
__tablename__ = 'm_manager'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
account = db.Column(db.String(255), nullable=True)
name = db.Column(db.String(255), nullable=True)
description = db.Column(db.String(255), nullable=True)
password = db.Column(db.String(255), nullable=True)
createtime = db.Column(db.DateTime, default=datetime.now)
parent_id = db.Column(db.Integer, nullable=True)
# permission = db.relationship('permission',backref='m_manager')
project = db.relationship('Project',
secondary='manager_project',
backref='m_manager')
permission = db.relationship('Permission',
secondary='manager_permission',
backref='m_manager')
language = db.relationship('Language',
secondary='manager_language',
backref=db.backref('m_manager', lazy='dynamic'))
class Order(db.Model):
__tablename__ = 'order'
id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
CustomId = db.Column(db.Integer, db.ForeignKey('custom.id'))
ProductId = db.Column(db.String(30))
OrderNum = db.Column(db.String(30))
OrderDate = db.Column(db.Date)
OrderStatus = db.Column(db.String(30))
OrderMoney = db.Column(db.String(30))
products = db.relationship('Product',
secondary=po,
backref=db.backref('order'))
sends = db.relationship('Send', backref='order', uselist=False)
def __repr__(self):
return self.OrderId, self.CustomId, self.ProductId, self.OrderNum, \
self.OrderDate, self.OrderStatus, self.OrderMoney
class User(db.Model):
# 包含在exclude_columns 的列不会新建
# exclude_columns = ['created_at', 'updated_at']
__tablename__ = 'users'
id = Column(db.Integer, primary_key=True)
created_at = Column(db.Date, nullable=True, default=datetime.now)
updated_at = Column(db.Date, nullable=True, default=datetime.now)
username = Column(db.String(32), nullable=False, index=True)
password = Column(db.String(256), nullable=False)
email = Column(db.String(32), nullable=False, index=True)
# status = Column(db.Integer(), default=1, doc='1代表激活')
status = Column(db.Boolean(), default=True, doc='1代表激活')
del_flag = Column(db.Integer(), default=0, doc='0代表未删除')
role_id = Column(db.Integer, db.ForeignKey('roles.id'))
role = relationship('Role', backref=db.backref('users', order_by=username))
orders = db.relationship('Order', back_populates='user', lazy='dynamic')
def __init__(self, username, email, password=None, **kwargs):
db.Model.__init__(self, username=username, email=email, **kwargs)
if password:
self.set_password(password)
else:
self.password = None
@classmethod
def s_query(cls):
"""查询激活状态的user，未被删除
"""
return cls.query.filter_by(del_flag=0)
def set_password(self, password):
"""Set password."""
self.password = bcrypt.generate_password_hash(password)
def check_password(self, value):
"""Check password."""
return bcrypt.check_password_hash(self.password, value)
@property
def token(self):
return _default_jwt_encode_handler(self).decode('utf-8')
class User(UserMixin, db.Model):
__tablename__ = 'User'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.Unicode(20), nullable=False, unique=True)
email = db.Column(db.Unicode(64), nullable=False, unique=True)
phone = db.Column(db.CHAR(11), nullable=False, unique=True)
password = db.Column(db.Unicode(100), nullable=False)
# headImage = db.Column(db.Unicode(256), default='static/image/defaultImage.jpg', nullable=False)
avatar_hash = db.Column(db.String(32))
permission = db.Column(db.CHAR(1), default=0, nullable=False)
introduction = db.Column(db.Text, default='这家伙很懒，什么也没有写~', nullable=False)
confirmed = db.Column(db.Boolean, default=False)
tags = db.relationship('UserTag',
backref=db.backref('tags'),
lazy='dynamic',
cascade='all, delete-orphan')
articles = db.relationship('Article',
backref=db.backref('articles'),
lazy='dynamic',
cascade='all, delete-orphan')
questions = db.relationship('Question',
backref=db.backref('questions'),
lazy='dynamic',
cascade='all, delete-orphan')
drafts = db.relationship('Draft',
backref=db.backref('drafts'),
lazy='dynamic',
cascade='all, delete-orphan')
user_answers = db.relationship('Answer',
backref=db.backref('user_answers'),
lazy='dynamic',
cascade='all, delete-orphan')
followed = db.relationship(
'Follow',
foreign_keys=[Follow.followerId], # 用户关注的用户: user.followed
backref=db.backref('follower',
lazy='joined'), # 关注用户的用户: user.follower
lazy='dynamic',
cascade='all, delete-orphan')
followers = db.relationship('Follow',
foreign_keys=[Follow.followedId],
backref=db.backref('followed', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
favoriteArticles = db.relationship('FavoriteArticle',
backref=db.backref('favorite_articles'),
lazy='dynamic',
cascade='all, delete-orphan')
favoriteQuestions = db.relationship(
'FavoriteQuestion',
backref=db.backref('favorite_questions'),
lazy='dynamic',
cascade='all, delete-orphan')
notifications = db.relationship('Notification',
backref=db.backref('notifications'),
lazy='dynamic',
cascade='all, delete-orphan')
likeArticles = db.relationship('LikeArticle',
backref=db.backref('likeArticles'),
lazy='dynamic',
cascade='all, delete-orphan')
likeAnswers = db.relationship('LikeAnswer',
backref=db.backref('likeAnswers'),
lazy='dynamic',
cascade='all, delete-orphan')
unlikeArticles = db.relationship('UnlikeArticle',
backref=db.backref('unlikeArticles'),
lazy='dynamic',
cascade='all, delete-orphan')
unlikeAnswers = db.relationship('UnlikeAnswer',
backref=db.backref('unlikeAnswers'),
lazy='dynamic',
cascade='all, delete-orphan')
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
if self.email is not None and self.avatar_hash is None:
self.avatar_hash = hashlib.md5(
self.email.encode('utf-8')).hexdigest()
# 将类转为字典，然后响应json
def as_dict(obj):
return dict((col.name, getattr(obj, col.name)) \
for col in class_mapper(obj.__class__).mapped_table.c)
def generate_confirmation_token(self, expiration=3600):
s = Serializer(current_app.config['SECRET_KEY'], expiration)
return s.dumps({'confirm': self.id})
def confirm(self, token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return False
if data.get('confirm') != self.id:
return False
self.confirmed = True
db.session.add(self)
# db.session.commit()
return True
def generate_reset_token(self, expiration=3600):
s = Serializer(current_app.config['SECRET_KEY'], expiration)
return s.dumps({'reset': self.id})
def reset_password(self, token, new_password):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return False
if data.get('reset') != self.id:
return False
self.password = new_password
db.session.add(self)
return True
@staticmethod
def generate_fake(count=100):
seed()
for i in range(count):
u = User(email=forgery_py.internet.email_address(),
phone="18787053797",
username=forgery_py.internet.user_name(True),
password=forgery_py.lorem_ipsum.word(),
introduction=forgery_py.lorem_ipsum.sentence(),
confirmed=True)
db.session.add(u)
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
def is_following(self, user):
return self.followed.filter_by(followedId=user.id).first() is not None
def is_followed_by(self, user):
return self.followers.filter_by(followerId=user.id).first() is not None
def follow(self, user):
if not self.is_following(user):
f = Follow(followerId=self.id, followedId=user.id)
db.session.add(f)
db.session.commit()
def unfollow(self, user):
f = self.followed.filter_by(followedId=user.id).first()
if f:
db.session.delete(f)
db.session.commit()
def get_all_tags(self):
return Tag.query.filter(Tag.parentId != None).all()
def gravatar(self, size=100, default='identicon', rating='g'):
if request.is_secure:
url = 'https://secure.gravatar.com/avatar'
else:
url = 'http://www.gravatar.com/avatar'
hash = self.avatar_hash or hashlib.md5(
self.email.encode('utf-8')).hexdigest()
return '{url}/{hash}?s={size}&d={default}&r={rating}'.format(
url=url, hash=hash, size=size, default=default, rating=rating)
class Article(db.Model):
__tablename__ = 'Article'
articleId = db.Column(db.BigInteger,
primary_key=True,
nullable=False,
autoincrement=True)
userId = db.Column(db.BigInteger,
db.ForeignKey('User.id', ondelete='CASCADE'),
nullable=False)
title = db.Column(db.Unicode(100), nullable=False)
content = db.Column(db.Text, nullable=False)
publicTime = db.Column(db.DateTime, default=datetime.now(), nullable=False)
articleComments = db.relationship('ArticleComment',
backref=db.backref('comments'),
lazy='dynamic',
cascade='all, delete-orphan')
tags = db.relationship('ArticleTag',
backref=db.backref('tags'),
lazy='dynamic',
cascade='all, delete-orphan')
favoriteUsers = db.relationship('FavoriteArticle',
backref=db.backref('favoriteUsers'),
lazy='dynamic',
cascade='all, delete-orphan')
likeUsers = db.relationship('LikeArticle',
backref=db.backref('like_users'),
lazy='dynamic',
cascade='all, delete-orphan')
unlikeUsers = db.relationship('UnlikeArticle',
backref=db.backref('unlike_users'),
lazy='dynamic',
cascade='all, delete-orphan')
@staticmethod
def generate_fake(count=100):
seed()
user_count = User.query.count()
for i in range(count):
user = User.query.offset(randint(0, user_count - 1)).first()
title = forgery_py.lorem_ipsum.sentence()
if len(title) > 50:
title = title[:20]
article = Article(userId=user.id,
title=title,
content=forgery_py.lorem_ipsum.sentences(
randint(1, 3)),
publicTime=forgery_py.date.date(True))
db.session.add(article)
try:
db.session.commit()
except:
db.session.rollback()
def get_user(self):
return User.query.filter(User.id == self.userId).first().username
def get_user_object(self):
return User.query.filter(User.id == self.userId).first()
def get_article_comments(self):
return ArticleComment.query.filter(
ArticleComment.articleId == self.articleId,
ArticleComment.parentId == None).all()
def is_user_favorite(self, user):
return 'true' if self.articleId in map(
lambda x: x.articleId, user.favoriteArticles.all()) else 'false'
def is_user_like(self, user):
return 'true' if self.articleId in map(
lambda x: x.articleId, user.likeArticles.all()) else 'false'
def is_user_unlike(self, user):
return 'true' if self.articleId in map(
lambda x: x.articleId, user.unlikeArticles.all()) else 'false'
def get_type(self):
return 'article'
class User(UserMixin, db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
nullable=False)
username = db.Column(db.String(50), nullable=False, unique=True)
password_hash = db.Column(db.String(128))
email = db.Column(db.String(128), nullable=False, unique=True)
confirmed = db.Column(db.Boolean, default=False)
icon = db.Column(db.String(64), default='default.jpg')
#lazy 在这里是懒加载 dynamic表示不加载数据但是提供查询
#如果一对一的关系 需要加上 uselist=Flase
posts = db.relationship("Posts", backref="user", lazy="dynamic")
#当前用户通过 user 访问 posts 表中的字段
#用户 跟 博客有关系
#用户 跟第三张表 也有关系
favorites = db.relationship('Posts',
secondary='collections',
backref=db.backref('users', lazy='dynamic'),
lazy='dynamic')
#密码不能读 而且永不返回
@property
def password(self):
raise AttributeError("密码不可读的帅哥")
#设置密码的时候 保存的是加密后的hash值
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
#校验密码是否正确 正确 true 错误 false
#先加密 再跟数据库比较
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
#生成token 通过邮箱发送给用户
def generate_active_token(self, expires_in=3600):
s = Serializer(current_app.config['SECRET_KEY'], expires_in=expires_in)
return s.dumps({'id': self.id})
# 验证token 方法
@staticmethod
def check_active_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return False
#这个id是从 token中解析出来的 然后根据id 到数据库中查找 对应的数据进行更新
u = User.query.get(data.get('id'))
if not u:
flash("该用户不存在")
return False
if not u.confirmed:
u.confirmed = True
db.session.add(u)
return True
#判断是否收藏
def is_favorite(self, pid):
#获取所有收藏的博客
favorites = self.favorites.all()
posts = list(filter(lambda p: p.id == pid, favorites))
if len(posts) > 0:
return True
return False
#添加收藏
def add_favorite(self, pid):
p = Posts.query.get(pid)
self.favorites.append(p)
#取消收藏
def del_favorite(self, pid):
p = Posts.query.get(pid)
self.favorites.remove(p)
class Users(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(20), unique=True)
password_hash = db.Column(db.String(128))
email = db.Column(db.String(64), unique=True)
confirmed = db.Column(db.Boolean, default=False)
icon = db.Column(db.String(64), default='default.jpg')
#通过backref反向访问posts属性
posts = db.relationship('Posts', backref="user", lazy='dynamic')
#添加收藏功能
favorites = db.relationship('Posts',
secondary='collections',
backref=db.backref('useres', lazy='dynamic'),
lazy='dynamic')
@property
def password(self):
raise AttributeError('密码不可读')
@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)
#生成token
def generate_active_token(self, expires_in=3600):
s = Serializer(current_app.config['SECRET_KEY'], expires_in=expires_in)
return s.dumps({'id': self.id})
#检测token
@staticmethod
def check_active_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return False
u = Users.query.get(data['id'])
if not u:
return False
if not u.confirmed:
u.confirmed = True
db.session.add(u)
db.session.commit()
return True
# 登录成功以后执行的回调函数
@login_manager.user_loader
def load_user(uid):
return Users.query.get(int(uid))
#判断用户是否收藏了
def is_favorite(self, pid):
#先获取所有收藏的博
favorites = self.favorites.all()
post = list(filter(lambda p: p.id == pid, favorites))
if len(post) > 0:
return True
return False
#添加收藏
def add_favorite(self, pid):
p = Posts.query.get(pid) #先根据id查出来
self.favorites.append(p) #然后追加到第三张表中
def del_favorite(self, pid):
p = Posts.query.get(pid) #先根据id查出来
self.favorites.remove(p) #从第三张表中移除
class Book(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(50), unique=True)
date = db.Column(db.DateTime, default=datetime.datetime.now)
author_id = db.Column(db.Integer, db.ForeignKey('author.id'))
author = db.relationship('Author', backref=db.backref('books'))