class Comment(BaseModel, db.Model):
"""评论"""
__tablename__ = "info_comment"
id = db.Column(db.Integer, primary_key=True) # 评论编号
user_id = db.Column(db.Integer,
db.ForeignKey("info_user.id"),
nullable=False) # 用户id
news_id = db.Column(db.Integer,
db.ForeignKey("info_news.id"),
nullable=False) # 新闻id
content = db.Column(db.Text, nullable=False) # 评论内容
parent_id = db.Column(db.Integer,
db.ForeignKey("info_comment.id")) # 父评论id
# parent = db.relationship("Comment", remote_side=[id]) # 设置自关联多对一关系属性时, 需要设置remote_side
children = db.relationship("Comment",
backref=db.backref("parent", remote_side=[id]))
like_count = db.Column(db.Integer, default=0) # 点赞条数
def to_dict(self):
resp_dict = {
"id": self.id,
"create_time": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"content": self.content,
"parent": self.parent.to_dict() if self.parent else None,
"user": User.query.get(self.user_id).to_dict(),
"news_id": self.news_id,
"like_count": self.like_count
}
return resp_dict
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "info_user"
id = db.Column(db.Integer, primary_key=True) # 用户编号
nick_name = db.Column(db.String(32), unique=True, nullable=False) # 用户昵称
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
mobile = db.Column(db.String(11), unique=True, nullable=False) # 手机号
avatar_url = db.Column(db.String(256)) # 用户头像路径
last_login = db.Column(db.DateTime, default=datetime.now) # 最后一次登录时间
is_admin = db.Column(db.Boolean, default=False)
signature = db.Column(db.String(512)) # 用户签名
gender = db.Column( # 订单的状态
db.Enum(
"MAN", # 男
"WOMAN" # 女
),
default="MAN")
# 当前用户收藏的所有新闻
collection_news = db.relationship("News", secondary=tb_user_collection, lazy="dynamic") # 用户收藏的新闻
# 用户所有的粉丝，添加了反向引用followed，代表用户都关注了哪些人(自关联多对多时,需要设置primaryjoin和secondaryjoin)
followers = db.relationship('User',
secondary=tb_user_follows,
# 关系属性根据哪个外键查, primaryjoin就设置哪个外键, 另一个设置为secondaryjoin
primaryjoin=(id == tb_user_follows.c.followed_id),
secondaryjoin=(id == tb_user_follows.c.follower_id),
backref=db.backref('followed', lazy='dynamic'),
lazy='dynamic')
# 当前用户所发布的新闻
news_list = db.relationship('News', backref='user', lazy='dynamic')
def to_dict(self):
resp_dict = {
"id": self.id,
"nick_name": self.nick_name,
"avatar_url": constants.QINIU_DOMIN_PREFIX + self.avatar_url if self.avatar_url else "",
"mobile": self.mobile,
"gender": self.gender if self.gender else "MAN",
"signature": self.signature if self.signature else "",
"followers_count": self.followers.count(),
"news_count": self.news_list.count()
}
return resp_dict
def to_admin_dict(self):
resp_dict = {
"id": self.id,
"nick_name": self.nick_name,
"mobile": self.mobile,
"register": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"last_login": self.last_login.strftime("%Y-%m-%d %H:%M:%S"),
}
return resp_dict
class OrderForm(BaseModel, db.Model):
"""订单"""
__tablename__ = "order_form"
id = db.Column(db.Integer, primary_key=True, autoincrement=True, nullable=True) # 订单id
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False, primary_key=True) # 用户id
address_id = db.Column(db.INTEGER, db.ForeignKey('shipping_address.id'), nullable=False,
primary_key=True) # 地址id
status = db.Column(db.INTEGER, nullable=False, default=0) # 定单状态，0代付款，1待发货，2待收货，3已签收，4已取消,-1未支付
payment_method = db.Column(db.INTEGER, nullable=False) # 付款方式，0支付宝，1银联，2ebay，3微信，-1未支付
products = db.relationship('Product', backref='order_form', secondary='order_product', lazy='dynamic')
address = db.relationship('ShippingAddress', backref=db.backref('order_form', uselist=False))
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "info_user"
id = db.Column(db.Integer, primary_key=True) # 用户编号
nick_name = db.Column(db.String(32), unique=True, nullable=False) # 用户昵称
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
mobile = db.Column(db.String(11), unique=True, nullable=False) # 手机号
avatar_url = db.Column(db.String(256)) # 用户头像路径
last_login = db.Column(db.DateTime, default=datetime.now) # 最后一次登录时间
is_admin = db.Column(db.Boolean, default=False) # 记录用户是否为管理员
signature = db.Column(db.String(512)) # 用户签名
gender = db.Column( # 订单的状态
db.Enum(
"MAN", # 男
"WOMAN" # 女
),
default="MAN")
# 当前用户收藏的所有新闻
collection_news = db.relationship("News",
secondary=tb_user_collection,
lazy="dynamic") # 用户收藏的新闻
# 当前用户点赞的所有的评论
like_comments = db.relationship("Comment",
secondary="info_comment_like",
lazy="dynamic")
# 用户所有的粉丝，添加了反向引用followed，代表用户都关注了哪些人(自关联多对多时,需要设置primaryjoin和secondaryjoin)
followers = db.relationship(
'User',
secondary=tb_user_follows,
# 自关联多对多关系属性必须设置primaryjoin和secondaryjoin
primaryjoin=(
id == tb_user_follows.c.followed_id
), # 该关系属性根据哪个外键查, primaryjoin就设置哪个外键, 另一个设置为secondaryjoin
secondaryjoin=(id == tb_user_follows.c.follower_id),
backref=db.backref('followed', lazy='dynamic'),
lazy='dynamic')
# 当前用户所发布的新闻
news_list = db.relationship('News', backref='user', lazy='dynamic')
def check_password(self, password):
return check_password_hash(self.password_hash, password)
# 使用计算型属性来封装加密过程，对于用户来说只需要进行属性赋值，计算等过程由装饰器完成
@property
def password(self):
raise AttributeError("明文密码不可取")
@password.setter
def password(self, value):
self.password_hash = generate_password_hash(value)
def to_dict(self): # 将模型对象中的数据转存到字典中, 在内部完成格式转换和格式判断，不需要以后
resp_dict = {
"id":
self.id,
"nick_name":
self.nick_name,
"avatar_url":
constants.QINIU_DOMIN_PREFIX +
self.avatar_url if self.avatar_url else "",
"mobile":
self.mobile,
"gender":
self.gender if self.gender else "MAN",
"signature":
self.signature if self.signature else "",
"followers_count":
self.followers.count(),
"news_count":
self.news_list.count()
}
return resp_dict
def to_admin_dict(self):
resp_dict = {
"id": self.id,
"nick_name": self.nick_name,
"mobile": self.mobile,
"register": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"last_login": self.last_login.strftime("%Y-%m-%d %H:%M:%S"),
}
return resp_dict
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "info_user"
id = db.Column(db.Integer, primary_key=True) # 用户编号
nick_name = db.Column(db.String(32), unique=True, nullable=False) # 用户昵称
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
mobile = db.Column(db.String(11), unique=True, nullable=False) # 手机号
avatar_url = db.Column(db.String(256),default='user_pic.png') # 用户头像路径
last_login = db.Column(db.DateTime, default=datetime.now) # 最后一次登录时间
is_admin = db.Column(db.Boolean, default=False)
signature = db.Column(db.String(512)) # 用户签名
gender = db.Column( # 订单的状态
db.Enum(
"MAN", # 男
"WOMAN" # 女
),
default="MAN")
# 当前用户收藏的所有新闻：维护的是User和News的多对多的关系
collection_news = db.relationship("News", secondary=tb_user_news_collection, lazy="dynamic") # 用户收藏的新闻
authors = db.relationship(
'User',
lazy='dynamic',
secondary=tb_user_author,
backref=db.backref('fans', lazy='dynamic'),
#当使用对象abc.authors调用时，查询语句中的条件通过primaryjoin指定
#如果authors表示作者，则abc表示用户
primaryjoin=id == tb_user_author.c.user_id,
#当使用对象abc.users调用时，查询语句中的条件通过sencondaryjoin指定
#如果users表示用户，则abc表示作者
secondaryjoin=id == tb_user_author.c.author_id
)
# 当前用户所发布的新闻：relationship维护的是User和News的一对多的关系
# backref:维护的是多对一
news_list = db.relationship('News', backref='author', lazy='dynamic')
# 登录
def to_login_dict(self):
return {
'id':self.id,
'nick_name':self.nick_name,
# 'avatar_url':'/static/news/images/'+self.avatar_url
"avatar_url":constants.QINIU_DOMIN_PREFIX+self.avatar_url,
"create_time":self.create_time,
"update_time":self.update_time,
"mobile":self.mobile
}
def to_dict(self):
return {
"id":self.id,
"nick_name":self.nick_name,
"avatar_url":constants.QINIU_DOMIN_PREFIX+self.avatar_url,
"gender":self.gender,
"signature":self.signature,
"news_list":self.news_list
}
# def set_password(self,password):
# self.password_hash=加密函数(password)
@property
def password(self):
"""
这个方法时password属性的getter方法
:return: 我的思想是：不让通过这个属性读取密码，所以抛异常
"""
raise AttributeError('can not read')
@password.setter
def password(self, value):
"""
这个方法时password属性的setter方法
:param value: 外界传入的明文密码
:return: 密文密码
"""
self.password_hash = generate_password_hash(value)
# def set_passwordhash_with_password(self, password):
# from werkzeug.security import generate_password_hash, check_password_hash
# self.password_hash = generate_password_hash(password)
def check_password(self, password):
"""
校验密码
:param password: 外界传入的密码明文
:return: 如果校验通过，返回True。反之，返回False
"""
return check_password_hash(self.password_hash, password)
class User(BaseModel, db.Model):
"""
用户信息
BaseModel 继承 -- 实现创建时间和更新时间的补充
db.Model 数据模型 -- 实体和数据库表名建立关系
"""
# 数据库表名 -- 和当前类绑定
__tablename__ = "info_user"
"""ORM建立 属性 = 数据库字段"""
id = db.Column(db.Integer, primary_key=True) # 用户编号
nick_name = db.Column(db.String(32), unique=True, nullable=False) # 用户昵称
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
mobile = db.Column(db.String(11), unique=True, nullable=False) # 手机号
avatar_url = db.Column(db.String(256)) # 用户头像路径
last_login = db.Column(db.DateTime, default=datetime.now) # 最后一次登录时间
is_admin = db.Column(db.Boolean, default=False) # 是否管理员
signature = db.Column(db.String(512)) # 用户签名
gender = db.Column( # 性别
db.Enum(
"MAN", # 男
"WOMAN" # 女
),
default="MAN") # 默认 男
"""db.relationship设置关系"""
# 当前用户收藏的所有新闻 -- 关系 ( 新闻表, 中间表, 懒加载 )
collection_news = db.relationship("News",
secondary=tb_user_collection,
lazy="dynamic") # 用户收藏的新闻
# 用户所有的粉丝, 添加了反向引用followed, 代表用户都关注了哪些人
followers = db.relationship(
'User', # 用户表
secondary=tb_user_follows, # 中间表
primaryjoin=id == tb_user_follows.c.followed_id, # 主要加入
secondaryjoin=id == tb_user_follows.c.follower_id, # 次要加入
backref=db.backref('followed', lazy='dynamic'), # 反向引用 ( 被关注表, 懒加载 )
lazy='dynamic') # 懒加载
# 用户针对新闻的评论信息 -- 关系 ( 评论表, 反向引用--用户表 )
comments = db.relationship("Comment", backref="user")
# 用户点过赞的评论信息 -- 关系 ( 评论表, 中间表, 懒加载 )
like_comments = db.relationship("Comment",
secondary="info_comment_like",
lazy='dynamic')
# 当前用户所发布的新闻 -- 关系 ( 新闻表, 反向引用--用户表, 懒加载 )
news_list = db.relationship('News', backref='user', lazy='dynamic')
# # 粉丝总数
# followers_count = 0
# # 新闻总数
# news_count = 0
# 装饰器 -- 读取
@property
def password(self):
# 禁止读取
raise AttributeError("当前属性不可读")
# 装饰器 -- set
@password.setter
def password(self, value):
"""
设置password
:param value: 值
:return:
"""
# 获取加密后的值 -- 对原密码进行加密
self.password_hash = generate_password_hash(value)
def check_passowrd(self, password):
"""
检测密码
:param password: 密码
:return:
"""
# 解密后, 对比密码是否正确
return check_password_hash(self.password_hash, password)
#
# # 装饰器 -- get
# @property
# def news_count(self):
# count = 0
# for _ in self.news_list:
# count += 1
# return count
#
# # 装饰器 -- get
# @property
# def followers_count(self):
# count = 0
# for _ in self.followers:
# count += 1
# return count
def to_dict(self):
"""
把对象数据转换为字典数据
"""
# 封装字典
resp_dict = {
"id": self.id,
"nick_name": self.nick_name,
"mobile": self.mobile,
"avatar_url": self.avatar_url,
"is_admin": self.is_admin,
"signature": self.signature,
"gender": self.gender,
"last_login": self.last_login.strftime("%Y-%m-%d %H:%M:%S"),
"create_time": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"update_time": self.update_time.strftime("%Y-%m-%d %H:%M:%S"),
"followers_count": self.followers.count(),
"news_count": self.news_list.count()
}
# 返回字典
return resp_dict
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "info_user"
id = db.Column(db.Integer, primary_key=True) # 用户编号
nick_name = db.Column(db.String(32), unique=True, nullable=False) # 用户昵称
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
mobile = db.Column(db.String(11), unique=True, nullable=False) # 手机号
avatar_url = db.Column(db.String(256)) # 用户头像路径
last_login = db.Column(db.DateTime, default=datetime.now) # 最后一次登录时间
is_admin = db.Column(db.Boolean, default=False)
signature = db.Column(db.String(512)) # 用户签名
gender = db.Column( # 订单的状态
db.Enum(
"MAN", # 男
"WOMAN" # 女
),
default="MAN")
# 当前用户收藏的所有新闻
collection_news = db.relationship("News", secondary=tb_user_collection, lazy="dynamic") # 用户收藏的新闻
# 用户所有的粉丝，添加了反向引用followed，代表用户都关注了哪些人
followers = db.relationship('User',
secondary=tb_user_follows,
primaryjoin=id == tb_user_follows.c.followed_id,
secondaryjoin=id == tb_user_follows.c.follower_id,
backref=db.backref('followed', lazy='dynamic'),
lazy='dynamic')
# 当前用户所发布的新闻
news_list = db.relationship('News', backref='user', lazy='dynamic')
@property
def password(self):
raise AttributeError("当前属性不可读")
@password.setter
def password(self, value):
self.password_hash = generate_password_hash(value)
def check_passowrd(self, password):
return check_password_hash(self.password_hash, password)
def to_dict(self):
resp_dict = {
"id": self.id,
"nick_name": self.nick_name,
"avatar_url": constants.QINIU_DOMIN_PREFIX + self.avatar_url if self.avatar_url else "",
"mobile": self.mobile,
"gender": self.gender if self.gender else "MAN",
"signature": self.signature if self.signature else "",
"followers_count": self.followers.count(),
"news_count": self.news_list.count()
}
return resp_dict
def to_admin_dict(self):
resp_dict = {
"id": self.id,
"nick_name": self.nick_name,
"mobile": self.mobile,
"register": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"last_login": self.last_login.strftime("%Y-%m-%d %H:%M:%S"),
}
return resp_dict
# 以下代码定义password属性的setter 和getter方法
@property
def password(self):
raise ArithmeticError('can not read')
# 明文密码加密
@password.setter
def password(self, value):
self.password_hash = generate_password_hash(value)
def check_password(self, value):
"""
检验密码
:param value: 传入的明文密码
:return: 返回Ture/False
"""
return check_password_hash(value)
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "info_user"
id = db.Column(db.Integer, primary_key=True) # 用户编号
nick_name = db.Column(db.String(32), unique=True, nullable=False) # 用户昵称
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
mobile = db.Column(db.String(11), unique=True, nullable=False) # 手机号
avatar_url = db.Column(db.String(256)) # 用户头像路径
last_login = db.Column(db.DateTime, default=datetime.now) # 最后一次登录时间
is_admin = db.Column(db.Boolean, default=False)
signature = db.Column(db.String(512)) # 用户签名
gender = db.Column( # 性别
db.Enum(
"MAN", # 男
"WOMAN" # 女
),
default="MAN")
# 当前用户收藏的所有新闻
collection_news = db.relationship("News",
secondary=tb_user_collection,
lazy="dynamic") # 用户收藏的新闻
# 用户所有的粉丝，添加了反向引用followed，代表用户都关注了哪些人
followers = db.relationship(
'User',
secondary=tb_user_follows,
primaryjoin=id == tb_user_follows.c.followed_id,
secondaryjoin=id == tb_user_follows.c.follower_id,
backref=db.backref('followed', lazy='dynamic'),
lazy='dynamic')
# 用户针对新闻的评论信息
comments = db.relationship("Comment", backref="user")
# 用户点过赞的评论信息
like_comments = db.relationship("Comment",
secondary="info_comment_like",
lazy='dynamic')
# 当前用户所发布的新闻
news_list = db.relationship('News', backref='user', lazy='dynamic')
@property
def password(self):
raise AttributeError("当前属性不可读")
@password.setter
def password(self, value):
self.password_hash = generate_password_hash(value)
def check_passowrd(self, password):
# 检验密码是否正确，正确为true
return check_password_hash(self.password_hash, password)
def to_dict(self):
"""将用户对象信息转换为字典数据"""
resp_dict = {
"id": self.id,
"nick_name": self.nick_name,
"mobile": self.mobile,
"avatar_url": self.avatar_url,
"create_time": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"last_login": self.last_login.strftime("%Y-%m-%d %H:%M:%S"),
"gender": self.gender,
"signature": self.signature,
}
return resp_dict
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "info_user"
id = db.Column(db.Integer, primary_key=True) # 用户编号
nick_name = db.Column(db.String(32), unique=True, nullable=False) # 用户昵称
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
mobile = db.Column(db.String(11), unique=True, nullable=False) # 手机号
avatar_url = db.Column(db.String(256)) # 用户头像路径
last_login = db.Column(db.DateTime, default=datetime.now) # 最后一次登录时间
is_admin = db.Column(db.Boolean, default=False)
signature = db.Column(db.String(512)) # 用户签名
gender = db.Column( # 订单的状态
db.Enum(
'MAN',
'WOMAN',
name='gender_types',
),
default="MAN")
# 当前用户收藏的所有新闻
collection_news = db.relationship("News",
secondary=tb_user_collection,
lazy="dynamic") # 用户收藏的新闻
# 用户所有的粉丝，添加了反向引用followed，代表用户都关注了哪些人
followers = db.relationship(
'User',
secondary=tb_user_follows,
primaryjoin=id == tb_user_follows.c.followed_id,
secondaryjoin=id == tb_user_follows.c.follower_id,
backref=db.backref('followed', lazy='dynamic'),
lazy='dynamic')
# 当前用户所发布的新闻
news_list = db.relationship('News', backref='user', lazy='dynamic')
#使用@property装饰的方法,可以当成属性来使用,比如: print(user.password)
@property
def password(self):
raise AttributeError("当前属性不可读")
#@password.setter给password方法,加了一个设置方法, 比如: user.password = '******'
@password.setter
def password(self, value):
#使用了系统的generate_password_hash方法,使用的是sha256算法加密
self.password_hash = generate_password_hash(value)
def check_password(self, password):
#系统提供的校验密码的方法,check_password_hash,传递密文和明文,返回的是True或者False
return check_password_hash(self.password_hash, password)
def to_dict(self):
resp_dict = {
"id":
self.id,
"nick_name":
self.nick_name,
"avatar_url":
constants.QINIU_DOMIN_PREFIX +
self.avatar_url if self.avatar_url else "",
"mobile":
self.mobile,
"gender":
self.gender if self.gender else "MAN",
"signature":
self.signature if self.signature else "",
"followers_count":
self.followers.count(),
"news_count":
self.news_list.count()
}
return resp_dict
def to_admin_dict(self):
resp_dict = {
"id": self.id,
"nick_name": self.nick_name,
"mobile": self.mobile,
"register": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"last_login": self.last_login.strftime("%Y-%m-%d %H:%M:%S"),
}
return resp_dict
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "info_user"
id = db.Column(db.Integer, primary_key=True) # 用户编号
nick_name = db.Column(db.String(32), unique=True, nullable=False) # 用户昵称
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
mobile = db.Column(db.String(11), unique=True, nullable=False) # 手机号
avatar_url = db.Column(db.String(256), default='user_pic.png') # 用户头像路径
last_login = db.Column(db.DateTime, default=datetime.now) # 最后一次登录时间
is_admin = db.Column(db.Boolean, default=False)
signature = db.Column(db.String(512)) # 用户签名
gender = db.Column( # 性别的状态
db.Enum(
"MAN", # 男
"WOMAN" # 女
),
default="MAN")
# 当前用户收藏的所有新闻：维护的是User和News的多对多的关系
collection_news = db.relationship("News",
secondary=tb_user_news_collection,
lazy="dynamic") # 用户收藏的新闻
authors = db.relationship(
'User',
lazy='dynamic',
secondary=tb_user_author,
backref=db.backref('users', lazy='dynamic'),
#当前对象调用authors属性时，使用primaryjoin条件
primaryjoin=id == tb_user_author.c.user_id,
#当前对象调用backref属性即users时，使用secondaryjoin条件
secondaryjoin=id == tb_user_author.c.author_id)
# 当前用户所发布的新闻：relationship维护的是User和News的一对多的关系
# backref:维护的是多对一
news_list = db.relationship('News', backref='user', lazy='dynamic')
@property
def password(self):
"""
这个方法时password属性的getter方法
:return: 我的思想是：不让通过这个属性读取密码，所以抛异常
"""
raise AttributeError('can not read')
@password.setter
def password(self, value):
"""
这个方法时password属性的setter方法
:param value: 外界传入的明文密码
:return: 密文密码
"""
self.password_hash = generate_password_hash(value)
#对象.password(参数)===>对象.password=参数
# def set_passwordhash_with_password(self, password):
# from werkzeug.security import generate_password_hash, check_password_hash
# self.password_hash = generate_password_hash(password)
def check_password(self, password):
"""
校验密码
:param password: 外界传入的密码明文
:return: 如果校验通过，返回True。反之，返回False
"""
return check_password_hash(self.password_hash, password)
def to_login_dict(self):
return {
'id': self.id,
'nick_name': self.nick_name,
# 'avatar_url':'/static/news/images/'+self.avatar_url
'avatar_url': constants.QINIU_DOMIN_PREFIX + self.avatar_url
}
def to_dict(self):
return {
'id': self.id,
'nick_name': self.nick_name,
'signature': self.signature if self.signature else '',
'gender': self.gender,
'total_news': self.news_list.count(),
'total_fans': self.users.count(),
'avatar_url': constants.QINIU_DOMIN_PREFIX + self.avatar_url
}
def to_admin_dict(self):
return {
'id': self.id,
'nick_name': self.nick_name,
'create_time': self.create_time,
'update_time': self.update_time,
'mobile': self.mobile
}
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "info_user"
id = db.Column(db.Integer, primary_key=True) # 用户编号
nick_name = db.Column(db.String(32), unique=True, nullable=False) # 用户昵称
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
mobile = db.Column(db.String(11), unique=True, nullable=False) # 手机号
avatar_url = db.Column(db.String(256)) # 用户头像路径
last_login = db.Column(db.DateTime, default=datetime.now) # 最后一次登录时间
is_admin = db.Column(db.Boolean, default=False)
signature = db.Column(db.String(512)) # 用户签名
gender = db.Column( # 订单的状态
db.Enum(
"MAN", # 男
"WOMAN" # 女
),
default="MAN")
# 当前用户收藏的所有新闻：维护的是User和News的多对多的关系
collection_news = db.relationship("News",
secondary=tb_user_news_collection,
lazy="dynamic") # 用户收藏的新闻
authors = db.relationship('User',
lazy='dynamic',
secondary=tb_user_author,
primaryjoin=id == tb_user_author.c.user_id,
secondaryjoin=id == tb_user_author.c.author_id,
backref=db.backref('users', lazy='dynamic'))
# 当前用户所发布的新闻：relationship维护的是User和News的一对多的关系
# backref:维护的是多对一
news_list = db.relationship('News', backref='user', lazy='dynamic')
def to_dict(self):
"""用于将模型对象转字典，方便渲染模板和给ajax响应json数据
提示：本次操作需要了解一下,因为Django当中会继续这类操作，在DRF中会讲一个概念"序列化"
将模型对象转字典 ： 就是序列化（一般用于做数据的响应前的操作）
"""
resp_dict = {
"id":
self.id,
"nick_name":
self.nick_name,
# http://oyucyko3w.bkt.clouddn.com/Fg-7WDaDihkttxOclQqZkMC3KUqf
"avatar_url":
constants.QINIU_DOMIN_PREFIX +
self.avatar_url if self.avatar_url else "",
"mobile":
self.mobile,
"gender":
self.gender if self.gender else "MAN",
"signature":
self.signature if self.signature else "",
"followers_count":
self.followers.count(),
"news_count":
self.news_list.count()
}
return resp_dict
def to_admin_dict(self):
resp_dict = {
"id": self.id,
"nick_name": self.nick_name,
"mobile": self.mobile,
"register": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"last_login": self.last_login.strftime("%Y-%m-%d %H:%M:%S"),
}
return resp_dict
@property
def password(self):
"""
这个方法时password属性的getter方法
:return: 我的思想是：不让通过这个属性读取密码，所以抛异常
"""
raise AttributeError('can not read')
@password.setter
def password(self, value):
"""
这个方法时password属性的setter方法
:param value: 外界传入的明文密码
:return: 密文密码
"""
self.password_hash = generate_password_hash(value)
# def set_passwordhash_with_password(self, password):
# from werkzeug.security import generate_password_hash, check_password_hash
# self.password_hash = generate_password_hash(password)
def check_password(self, password):
"""
校验密码
:param password: 外界传入的密码明文
:return: 如果校验通过，返回True。反之，返回False
"""
return check_password_hash(self.password_hash, password)
class User(BaseModel, db.Model):
__tablename__ = "info_user"
id = db.Column(db.Integer, primary_key=True) # 用户编号
nick_name = db.Column(db.String(32), unique=True, nullable=False) # 用户昵称
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
mobile = db.Column(db.String(11), unique=True, nullable=False) # 手机号
avatar_url = db.Column(db.String(256)) # 用户头像路径
last_login = db.Column(db.DateTime, default=datetime.now) # 最后一次登录时间
is_admin = db.Column(db.Boolean, default=False)
signature = db.Column(db.String(512)) # 用户签名
gender = db.Column( # 订单的状态
db.Enum(
"MAN", # 男
"WOMAN" # 女
),
default="MAN")
# 当前用户收藏的所有新闻
collection_news = db.relationship("News",
secondary="info_user_collection",
lazy="dynamic") # 用户收藏的新闻
# 当前用户点赞的所有评论
like_comments = db.relationship("Comment",
secondary="info_comment_like",
lazy="dynamic")
# 用户所有的粉丝 自关联多对多关系属性,需要设置primaryjoin和secondaryjoin
followers = db.relationship(
'User',
secondary="info_user_fans",
# 该关系属性根据哪个外键查, primaryjoin就设置哪个外键, 另一个设置为secondaryjoin
primaryjoin="UserFollow.followed_id==User.id",
secondaryjoin="UserFollow.follower_id==User.id",
backref=db.backref('followed', lazy='dynamic'),
lazy='dynamic')
# 当前用户所发布的新闻
news_list = db.relationship('News', backref='user', lazy='dynamic')
# 计算型属性: 对属性赋值/取值时, 会调用对应的方法, 可以在方法中封装一些处理
@property
def password(self):
raise AttributeError("该属性不可取值")
@password.setter
def password(self, value):
# 封装加密过程
self.password_hash = generate_password_hash(value)
def check_passoword(self, password):
"""
校验密码
:param password: 用户输入的明文
:return: True表示校验成功
"""
return check_password_hash(self.password_hash, password)
def to_dict(self): # 将模型中的数据转存到了字典中, 并且封装了数据的判断和格式转换
resp_dict = {
"id":
self.id,
"nick_name":
self.nick_name,
"avatar_url":
constants.QINIU_DOMIN_PREFIX +
self.avatar_url if self.avatar_url else "",
"mobile":
self.mobile,
"gender":
self.gender if self.gender else "MAN",
"signature":
self.signature if self.signature else "",
"followers_count":
self.followers.count(),
"news_count":
self.news_list.count()
}
return resp_dict
def to_admin_dict(self):
resp_dict = {
"id": self.id,
"nick_name": self.nick_name,
"mobile": self.mobile,
"register": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"last_login": self.last_login.strftime("%Y-%m-%d %H:%M:%S"),
}
return resp_dict
