class Article(db.Model):
__tablename__ = 'article'
id = db.Column(db.Integer(), primary_key=True)
# 书名
title = db.Column(db.String(32), nullable=False)
# 双向关系
tag = db.relationship('Tag', secondary=article_tag, backref='article')
class User(UserMixin, Base, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(10), unique=True, index=True)
password_hash = db.Column(db.String(128))
sex = db.Column(db.Boolean, default=True)
age = db.Column(db.Integer, default=20)
email = db.Column(db.String(50))
icon = db.Column(db.String(40), default='default.jpg')
confirm = db.Column(db.Boolean, default=False) #当前用户是否激活
"""
参数1 引用关系的模型
参数2 backref 反向引用的字段 给posts模型 添加了一个user属性 这个属性是替代uid 来进行对象的查询的 uid这个字段用不上
参数3 加载数据条目（如何加载）
dynamic 返回query对象 也就是你所看到的sql语句
默认是select.... 返回 一个列表 装有所有帖子对象的列表
不用的原因：不能呢个通过过滤器 再次筛选或者其它操作
"""
# posts = db.relationship('Posts',backref='user',lazy='dynamic')
posts = db.relationship('Posts', backref='user', lazy='dynamic')
@property
def password(self):
raise AttributeError('密码不可读')
#将明文密码 变成hash加密在赋给 字段属性 password_hash
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
#验证用户密码
def check_password(self, password):
return check_password_hash(self.password_hash, password)
# 生成token 通过邮件发送token值 进行账户的激活
def generate_token(self):
s = Seralize(current_app.config['SECRET_KEY'])
return s.dumps({'id': self.id})
#检测token值是否正确
@staticmethod
def check_token(token):
s = Seralize(current_app.config['SECRET_KEY'])
try:
Dict = s.loads(token) #加载出token的字典
id = Dict['id'] #拿到用户的id
u = User.query.get(id) #查询id的对象是否存在 在则为 <user n> 否则为None
if not u:
raise ValueError
#以上的代码只有出现问题 则都执行except
except:
return False
#判断账户是否没有激活 没有则激活 激活了则返回True
if not u.confirm:
u.confirm = True
u.save()
return True
class User(UserMixin,Base,db.Model):
id=db.Column(db.Integer,primary_key=True)
username=db.Column(db.String(12),unique=True,index=True)
userpass_hash=db.Column(db.String(128))
sex=db.Column(db.Boolean,default=True)
birth = db.Column(db.String(20))
email=db.Column(db.String(50))
icon = db.Column(db.String(40), default='default.jpg')
confirm=db.Column(db.Boolean,default=False)
#给User模型设置一个外键接口，对接Posts模型与User模型下的user表，采用带参数（dynamic）的方式对接。
posts=db.relationship('Posts',backref='user',lazy='dynamic')
#用property和setter的方法将方法变成像属性一样可以被调用，方便对其进行赋值，比较，判断等。
@property
#将password变成属性，当调用User.password时，抛出错误，让密码不可读。
def password(self):
raise AttributeError('密码不可读')
@password.setter
#给password属性设置方法，将用户输入的密码进行hash加密。
def password(self,userpass):
self.userpass_hash=generate_password_hash(userpass)
#定义检查密码的方法
def check_password(self,password):
return check_password_hash(self.userpass_hash,password)
#定义生成token的方法
def generate_token(self):
#用字符串作为参数将Seralize实例化，
s = Seralize(current_app.config['SECRET_KEY'])
#调用dumps方法以数据id为令牌，生成加密字符串；token为json类型.
return s.dumps({'id':self.id})
@staticmethod
def check_token(token):
#用同样的字符串生成构造token时完全一样的实例化对象。
s=Seralize(current_app.config['SECRET_KEY'])
#在能得到token的情况下try
try:
#用实例化对象解析邮箱传递给路由的token。得到Dict。
Dict=s.loads(token)
#取出Dict的id。
id=Dict['id']
#查找数据库中是否存在这个id，如果存在，u为True，否则为Flase。
u=User.query.get(id)
if not u:
#如果不存在，抛出错误，不再执行后续代码。
raise ValueError
#得不到token就except
except:
#得不到token就返回错误
return False
#得到了token，并且解析到数据库中有对应的id。并且激活状态为Flase时，执行下列代码。
if not u.confirm:
#更改激活状态并保存
u.confirm = True
u.save()
#随便返回一个真值，让其他情况下代码正常运行。
return True
class Superuser(UserMixin, db.Model):
__table__name = 'superuser'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(12), index=True)
password_hash = db.Column(db.String(128))
'''
参数1模型名称。参数2 反响引用字段名称，参数3,加载方式，提供对象
'''
# users =db.relationship('User'，backref='stu111', lazy=True)
# users = db.relationship('User',backref='superuser',lazy='dynamic')
# uid = db.relationship('User',secondary='superanduser',backref=db.backref('superuser',lazy='dynamic'),lazy='dynamic')
users = db.relationship('User', backref='superuser', lazy='dynamic')
icon = db.Column(db.String(70), default='admin.jpg')
#生成token的方法
def generate_token(self):
s = Seralize(current_app.config['SECRET_KEY'])
return s.dumps({'id': self.id})
@staticmethod
def check_token(token):
s = Seralize(current_app.config['SECRET_KEY'])
#从当前token中拿出字典
try:
id = s.loads(token)['id']
except:
return False
s = Superuser.query.get(id)
if not s:
return False
def check_password_hash(self, password):
return check_password_hash(self.password_hash, password)
#定义一个删除电影的方法
def remove_posts(self, pid):
post = Posts.query.get(id=pid)
if not post:
return False
#如果存在该电影信息
#1.判断是否有user收藏该电影，将该post剔除收藏的posts
# User.query.filter_by()
# Users=User.query.filter(favorite.id=pid)
# for i in users:
db.session.delete(post)
db.session.commit()
class Email(db.Model):
__tablename__ = 'emails'
id = db.Column(db.Integer(), primary_key=True)
email = db.Column(db.String(64))
# 一对多
# 声明外键 一般放在多的一方
# db.ForeignKey(表名.主键)
t_id = db.Column(db.Integer, db.ForeignKey('teachers.id'))
# Teacher.mail << ==== >>Email.teacher 双向关系
# 反向查询
teacher = db.relationship('Teacher', backref='mail')
def __repr__(self):
return self.email
class User(UserMixin, Base, db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(12),
index=True,
nullable=False,
unique=True)
password_hash = db.Column(db.String(128))
email = db.Column(db.String(50), unique=True)
icon = db.Column(db.String(70), default='default.jpg')
lastLogin = db.Column(db.DateTime)
registerTime = db.Column(db.DateTime, default=datetime.utcnow)
confirm = db.Column(db.Boolean, default=True)
favorites = db.relationship('Movie',
secondary='collections',
backref=db.backref('users', lazy='dynamic'),
lazy='dynamic')
@property
def password(self):
raise AttributeError
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def is_favorite(self, pid):
favorites = self.favorites.all()
for i in favorites:
if i.id == pid:
return True
return False
def add_favorite(self, pid):
self.favorites.append(Movie.query.get(pid))
db.session.commit()
def remove_favorite(self, pid):
self.favorites.remove(Movie.query.get(pid))
db.session.commit()
def __str__(self):
return self.username
class Posts(DB_Base, db.Model):
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(20), index=True) # 标题
article = db.Column(db.Text) # md格式正文
pid = db.Column(db.Integer, default=0) # 父id
path = db.Column(db.Text, default='0,') # 路径
visit = db.Column(db.Integer, default=0) # 文章访问量
timestamp = db.Column(db.DateTime, default=datetime.utcnow) # 发表时间
state = db.Column(db.Integer, default=0) # 是否所有人可见
img = db.Column(db.String(70)) # 图片
tags = db.relationship('Categorys',
secondary=posts_categorys,
backref=db.backref('posts'))
u_id = db.Column(db.Integer, db.ForeignKey('user.id')) # 关联主表user的自增id
class User(UserMixin, Base, db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(12), index=True, unique=True)
password_hash = db.Column(db.String(128))
sex = db.Column(db.Boolean, default=True)
age = db.Column(db.Integer, default=18)
email = db.Column(db.String(50), unique=True) #邮箱
icon = db.Column(db.String(70), default='default.jpg') #头像
lastLogin = db.Column(db.DateTime) #上次登录时间
registerTime = db.Column(db.DateTime, default=datetime.utcnow) #注册时间
confirm = db.Column(db.Boolean, default=False) #激活状态 默认不激活
"""
添加反向引用的关系
参数1 和哪一个模型建立关联
参数2 给参数1的模型添加一个模型属性 user
参数3 加载时机 dynamic返回查询的对象 可以链式调用 如果不填加/select 则u.posts直接返回数据的结果 不能进行model的过滤器的链式调用
u.posts.all() 获取所有u对象发表的博客
p.user 获取当前发表博客的用户对象
"""
posts = db.relationship('Posts', backref='user', lazy='dynamic')
# secondary 指定多对多关系 查询的指定中间表
#zhangsan.favorites.append(博客对象)
#zhangsan.favorites.remove(博客对象)
#zhangsan.favorites.all() #用户收藏了哪些博客
#p.user.all() #都被谁收藏了
favorites = db.relationship('Posts',
secondary='collections',
backref=db.backref('users', lazy='dynamic'),
lazy='dynamic')
#密码加密处理
@property
def password(self):
raise AttributeError
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
#检测密码正确性
def check_password(self, password):
return check_password_hash(self.password_hash, password)
#token值的生成
def generate_token(self):
s = Seralize(current_app.config['SECRET_KEY']) #生成token对象
return s.dumps({'id': self.id}) #通过给定字典生成token字符串
#账户的激活
@staticmethod
def check_token(token):
try:
s = Seralize(current_app.config['SECRET_KEY']) # 生成token对象
id = int(s.loads(token)['id']) #通过token值加载出字典
u = User.query.get(id) #拿到访问者的对象
u.confirm = True #修改激活状态
u.save() #保存
return True
except:
return False
#定义一个判断是否收藏的方法
def is_favorite(self, pid):
favorites = self.favorites.all()
for i in favorites:
if i.id == pid:
return True
return False
#收藏
def add_favorite(self, pid):
self.favorites.append(Posts.query.get(pid))
db.session.commit()
#取消收藏
def remove_favorite(self, pid):
self.favorites.remove(Posts.query.get(pid))
db.session.commit()
def __str__(self):
return self.username
class User(UserMixin, Base, db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(15), unique=True, index=True)
password_hash = db.Column(db.String(128))
sex = db.Column(db.Boolean, default=True)
age = db.Column(db.Integer, default=20)
email = db.Column(db.String(50))
icon = db.Column(db.String(40), default='default.jpg')
confirm = db.Column(db.Boolean, default=False)
register_date = db.Column(db.DateTime, default=None)
lastlogin_date = db.Column(db.DateTime, default=None)
lastlogin_date_cache = db.Column(db.DateTime, default=None)
#posts
#参数一：引用关系模型
#参数二：backref：反向引用的字段 给posts模型添加了一个user属性
# 这个属性是替换uid进行查询的，uid用不上
#参数三：加载数据条目(如何加载)，dynamic表示不添加，返回query对象，也就是sql语句
# 默认值为：select，返回一个装有所有帖子对象的列表，不能通过过滤筛选或者其他操作
#帖子名.user返回用户名
#通过设置backref='user'，同时Posts表增加uid外键字段关联user表的id，使Posts.user.字段名可以访问user表的字段
#例如：Posts.user返回<user 1>这种格式的数据
posts = db.relationship('Posts', backref='user', lazy='dynamic')
#db.backref:帖子被收藏的用户也是多的关系
#secondary设置中间表
#设置backref=db.backref('users',lazy='dynamic')，通过Posts.user查找收藏该帖子的所有用户，
# 使用db.backref('users',lazy='dynamic')是因为Posts.user返回多条数据，需要设置dynamic使返回值为sql语句(posts字段返回一条数据所以不需要)
#例如Posts.users返回sql查询语句，for i in Posts.users,i返回<user 1><user 2>...
favorite = db.relationship('Posts',
secondary='collections',
backref=db.backref('users', lazy='dynamic'),
lazy='dynamic')
#外层dynamic为user.favorite(type类型为：<class 'sqlalchemy.orm.dynamic.AppenderBaseQuery'>)服务，db.backref中的dynamic为posts.users服务
#使用user.favorite.append(Posts.query.get(id))和user.favorite.remove(Posts.query.get(id))更新该字段
@property
def password(self):
raise AttributeError('密码不可读')
#将明文密码变成哈希加密，再赋值给password_hash字段
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
# 验证密码
def check_password(self, password):
return check_password_hash(self.password_hash, password)
#生成token 通过邮件发送token值 进行账户激活
def generate_token(self):
s = Seralize(current_app.config['SECRET_KEY'])
return s.dumps({'id': self.id}) #将
#测试token是否正确
@staticmethod
def check_token(token):
s = Seralize(current_app.config['SECRET_KEY'])
try:
Dict = s.loads(token) #加载注册时传来的token字典
id = Dict['id'] #拿到用户id
u = User.query.get(id) #查询id对象是否存在
if not u:
raise ValueError
except: #token过期不正确
return False
#判断账户是否未激活 没有则激活，激活了则返回True
if not u.confirm:
u.confirm = True
u.save()
return True
def return_token(token):
s = Seralize(current_app.config['SECRET_KEY'])
try:
Dict = s.loads(token) #加载注册时传来的token字典
id = Dict['id'] #拿到用户id
u = User.query.get(id) #查询id对象是否存在
if not u:
raise ValueError
except: #token过期不正确
return False
return u
#判断是否收藏
def is_favorite(self, pid):
data = self.favorite.all()
# for p in data:
# if p.id == pid:
# return True
if list(filter(lambda p: p.id == pid, data)):
return True
return False
def add_favorite(self, pid):
self.favorite.append(Posts.query.get(pid))
def remove_favorite(self, pid):
self.favorite.remove(Posts.query.get(pid))
class User(UserMixin, db.Model, DB_Base):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True) # 自增ID
username = db.Column(db.String(12), index=True, unique=True) # 用户名
password_hash = db.Column(db.String(128)) # 密码 密文
sex = db.Column(db.Boolean, default=True) # 性别
age = db.Column(db.Integer, default=18) # 年龄 默认18
email = db.Column(db.String(50), unique=True) # 邮箱
icon = db.Column(db.String(70), default='default.png') # 头像 默认为default.jpg
lastLogin = db.Column(db.DateTime) # 上次登录时间
registerTime = db.Column(db.DateTime, default=datetime.utcnow) # 注册时间
confirm = db.Column(db.Boolean, default=False) # 激活状态 默认未激活（需要发送邮件进行激活）
# 设置模型引用关系
"""
Posts 建立引用关系的模型
backref 是给关联的模型 添加一个查询的属性 叫user
lazy 加载的时机 返回查询集(可以添加连贯操作) 如果不给lazy属性值 默认则为select模式(一旦调用posts 则返回的为数据 那么就不能在进行连贯操作 添加其它过滤器)
"""
posts = db.relationship('Posts', backref='user', lazy='dynamic')
# 建立多对多
"""
secondary 多对多模型指定查询数据的中间表
u.favorites.all() 查询用户对象u收藏了哪些博客
p.users.all() 查询博客都被谁收藏了
"""
favorites = db.relationship('Posts',
secondary='collections',
backref=db.backref('users', lazy='dynamic'),
lazy='dynamic')
# 密码加密处理的装饰器
@property
def password(self):
raise AttributeError
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
# 检验密码正确性的方法
def check_password(self, password):
return check_password_hash(self.password_hash, password)
# 生成token 用于账户激活(也就是知道是哪个用户过来激活的)
def generate_token(self):
s = Seralize(current_app.config['SECRET_KEY'])
return s.dumps({'id': self.id}) # 返回加密后的字符串
# 检测传递过来的token值 进行账户的激活
@staticmethod
def check_token(token):
s = Seralize(current_app.config['SECRET_KEY'])
try:
id = s.loads(token)['id']
u = User.query.get(id)
if not u:
return False
u.confirm = True
u.save()
return True
except:
return False
# 判断是否收藏的方法
def is_favorite(self, pid):
posts = self.favorites.all() # 查询当前用户的所有收藏
for p in posts:
if p.id == pid:
return True
return False
# 收藏
def add_favorite(self, pid):
self.favorites.append(Posts.query.get(int(pid)))
db.session.commit()
# 取消收藏
def delete_favorite(self, pid):
self.favorites.remove(Posts.query.get(int(pid)))
db.session.commit()
class User(UserMixin,db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer,primary_key=True)
username = db.Column(db.String(13),unique=True)
password_hash = db.Column(db.String(128))
age = db.Column(db.Integer,default=18)
sex = db.Column(db.Boolean,default=True)
email = db.Column(db.String(50))
icon = db.Column(db.String(37),default='default.jpg')
confirm = db.Column(db.Boolean,default=False) #当前用户激活状态 默认未激活
"""
db.relationship 建立模型关系 在表中不存在 提供的模型之间的操作
Posts 和哪个模型建立关系
backref 反向引用字段名称 给添加关系的模型 添加一个属性 user
lazy 加载时机 对象的方式
"""
posts = db.relationship('Posts',backref='user',lazy='dynamic')
#添加关系的模型
#多对多中 指定读取数据的中间表的名称
favorites = db.relationship('Posts',secondary='collections',backref=db.backref('users',lazy='dynamic'),lazy='dynamic')
@property
def password(self):
raise AttributeError('属性不存在')
@password.setter
def password(self, password):
#将密码在内部加密 在传递
self.password_hash = generate_password_hash(password)
#生成token的方法 执行这个函数之前必须数据已经插入到数据库 并获取id值
def generate_token(self):
s = Seralize(current_app.config['SECRET_KEY'])
return s.dumps({'id':self.id})
#用户激活
@staticmethod
def check_token(token):
try:
#生成token对象
s = Seralize(current_app.config['SECRET_KEY'])
Dict = s.loads(token) #加载出字典
uid = Dict['id'] #获取用访问的id
# 获取 访问过来人的对象
u = User.query.get(uid)
if not u:
raise ValueError
except:
return False
#判断是否没有激活 没有激活 则激活 否则返回真
if not u.confirm:
u.confirm = True
db.session.add(u)
return True
#验证密码
def check_password(self,password):
return check_password_hash(self.password_hash,password)