class Order(BaseModel, db.Model):
"""订单"""
__tablename__ = "ih_order_info"
id = db.Column(db.Integer, primary_key=True) # 订单编号
user_id = db.Column(db.Integer,
db.ForeignKey("ih_user_profile.id"),
nullable=False) # 下订单的用户编号
house_id = db.Column(db.Integer,
db.ForeignKey("ih_house_info.id"),
nullable=False) # 预订的房间编号
begin_date = db.Column(db.DateTime, nullable=False) # 预订的起始时间
end_date = db.Column(db.DateTime, nullable=False) # 预订的结束时间
days = db.Column(db.Integer, nullable=False) # 预订的总天数
house_price = db.Column(db.Integer, nullable=False) # 房屋的单价
amount = db.Column(db.Integer, nullable=False) # 订单的总金额
status = db.Column( # 订单的状态
db.Enum(
"WAIT_ACCEPT", # 待接单,
"WAIT_PAYMENT", # 待支付
"PAID", # 已支付
"WAIT_COMMENT", # 待评价
"COMPLETE", # 已完成
"CANCELED", # 已取消
"REJECTED" # 已拒单
),
default="WAIT_ACCEPT",
index=True)
comment = db.Column(db.Text) # 订单的评论信息或者拒单原因
def to_dict(self):
"""将订单信息转换为字典数据"""
order_dict = {
"order_id":
self.id,
"title":
self.house.title,
"img_url":
constants.QINIU_DOMIN_PREFIX +
self.house.index_image_url if self.house.index_image_url else "",
"start_date":
self.begin_date.strftime("%Y-%m-%d"),
"end_date":
self.end_date.strftime("%Y-%m-%d"),
"ctime":
self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"days":
self.days,
"amount":
self.amount,
"status":
self.status,
"comment":
self.comment if self.comment else ""
}
return order_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 BlogCustomer(BaseModel, db.Model):
"""用户信息"""
__tablename__ = 'blog_customer'
id = db.Column(db.Integer, primary_key=True) # id
name = db.Column(db.String(32), nullable=True) # 姓名
nick_name = db.Column(db.String(32), unique=True, nullable=False) # 昵称
avatar_url = db.Column(db.String(128)) # 头像
password_hash = db.Column(db.String(128), nullable=False) # 密码hash
mobile = db.Column(db.String(11)) # 手机号
job = db.Column(db.String(64)) # 职业
gender = db.Column(db.Enum('MAN', 'WOMAN'), default='MAN') # 性别
last_login = db.Column(db.DateTime, default=datetime.now) # 最后登录时间
is_admin = db.Column(db.Boolean, default=False) # 是否是管理员
is_author = db.Column(db.Boolean, default=False) # 是否是博主
signature = db.Column(db.String(512)) # 用户签名
email = db.Column(db.String(64), nullable=False) # 邮箱,注册时可用
website = db.Column(db.TEXT) # 简介
area = db.Column(db.String(128)) # 地址
wechat = db.Column(db.String(32)) # 微信
wechat_url = db.Column(db.String(128)) # 微信url
qq = db.Column(db.String(32)) # QQ
qq_url = db.Column(db.String(128)) # QQurl
keep = db.Column(db.String(128)) # 保留字段
keep_url = db.Column(db.String(128)) # 保留url
collection_news = db.relationship('Articles',
secondary=tb_user_collection,
lazy='dynamic')
def make_password_hash(self, password):
# 将未加密的密码执行加密操作
self.password_hash = generate_password_hash(password)
# 重写getter方法
@property
def password(self):
raise AttributeError('当前属性不可读')
# 重写setter方法
@password.setter
def password(self, password):
# 将未加密的密码调用generate_password_hash进行hash加密处理
self.password_hash = generate_password_hash(password)
def check_password(self, password):
# 将未加密的密码传入,使用check_password_hash进行对比,正确为true
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=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__ = "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")
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
@property
def password(self):
raise AttributeError("该属性不能直接读取")
@password.setter
def password(self, value):
self.password_hash = generate_password_hash(value)
def check_passoword(self, password):
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=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
