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 ShopCar(db.Model):
'''购物车表'''
__tablename__ = "shop_car"
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True) # 用户id
product_id = db.Column(db.Integer, db.ForeignKey('product.id'), primary_key=True) # 商品id
nums = db.Column(db.Integer, default=1, nullable=False) # 数据库中的数量
is_remove = db.Column(db.INTEGER, default=0) # 是否移除
user = db.relationship('User', backref='shop_car')
products = db.relationship("Product", backref='shop_car')
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 AgentInfo(db.Model, BaseModel):
'''代理申请信息'''
__tablename__ = 'agent'
id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 主键，自增长
name = db.Column(db.String(10), nullable=False) # 姓名
phone_number = db.Column(db.String(11)) # 手机号/联系方式
province = db.Column(db.String(10)) # 省
city = db.Column(db.String(10)) # 市
county = db.Column(db.String(10)) # 县（区）
original_wechat = db.Column(db.String(20), nullable=False) # 原始微信号
wechat_QR_code = db.Column(db.String(256)) # 粉丝截图
collection_QR_code = db.Column(db.String(256)) # 用户收款二维码
original_fans = db.Column(db.Integer) # 原始粉丝数
current_fans = db.Column(db.Integer) # 当前粉丝数
num_mobile = db.Column(db.Integer) # 手机台数
id_card_front = db.Column(db.String(256), nullable=True) # 身份证正面照/非必填
id_card_back = db.Column(db.String(256), nullable=True) # 身份证反面照/非必填
bank = db.Column(db.String(10), nullable=True) # 银行
card_number = db.Column(db.String(19), nullable=True) # 银行卡号/非必填
status = db.Column(db.String(1),default=0) # 0表示待审核 1表示审核通过 2 审核驳回
stat = db.relationship('Stat', backref='agent', uselist=False) # 申请表和统计表一对一
adorder = db.relationship('AdOrder', backref='agent', uselist=False) # 申请表和接单表一对一
is_delete = db.Column(db.String(1), default=0) # 0正常 1删除
def __repr__(self):
return '<AgentInfo %r>' % self.name
def to_dict(self):
'''将对象转换为字典数据'''
agent_dict = {
'agent_id': self.id,
'name': self.name,
'province': self.province,
'city': self.city,
'county': self.county,
'original_wechat': self.original_wechat,
'wechat_QR_code': "http://pe9wqjxpq.bkt.clouddn.com/" + self.wechat_QR_code,
'collection_QR_code': "http://pe9wqjxpq.bkt.clouddn.com/" + self.collection_QR_code,
'original_fans': self.original_fans,
'num_mobile': self.num_mobile,
'phone_number': self.phone_number,
'id_card_front': self.id_card_front,
'id_card_back': self.id_card_back,
'bank': self.bank,
'card_number': self.card_number,
'status': self.status,
}
return agent_dict
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 News(BaseModel, db.Model):
"""新闻"""
__tablename__ = "info_news"
id = db.Column(db.Integer, primary_key=True) # 新闻编号
title = db.Column(db.String(256), nullable=False) # 新闻标题
source = db.Column(db.String(64), nullable=False) # 新闻来源
digest = db.Column(db.String(512), nullable=False) # 新闻摘要
content = db.Column(db.Text, nullable=False) # 新闻内容
clicks = db.Column(db.Integer, default=0) # 浏览量
comments_count = db.Column(db.Integer, default=0) # 评论量
index_image_url = db.Column(db.String(256), default='') # 新闻列表图片路径
category_id = db.Column(db.Integer, db.ForeignKey("info_category.id"))
user_id = db.Column(db.Integer, db.ForeignKey("info_user.id")) # 当前新闻的作者id
status = db.Column(db.Integer,
default=0) # 当前新闻状态 如果为0代表审核通过，1代表审核中，-1代表审核不通过
reason = db.Column(db.String(256)) # 未通过原因，status = -1 的时候使用
# 当前新闻的所有评论
comments = db.relationship("Comment", lazy="dynamic")
def to_basic_dict(self):
"""将新闻对象信息转换为字典数据"""
resp_dict = {
"id": self.id,
"title": self.title,
"source": self.source,
"digest": self.digest,
"create_time": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"index_image_url": self.index_image_url,
"clicks": self.clicks,
}
return resp_dict
class Category(BaseModel, db.Model):
"""新闻分类"""
__tablename__ = "info_category"
id = db.Column(db.Integer, primary_key=True) # 分类编号
name = db.Column(db.String(64), nullable=False) # 分类名
news_list = db.relationship('News', backref='category', lazy='dynamic')
class Category(BaseModel, db.Model):
"""
新闻分类
BaseModel 继承 -- 实现创建时间和更新时间的补充
db.Model 数据模型 -- 实体和数据库表名建立关系
"""
# 数据库表名 -- 和当前类绑定
__tablename__ = "info_category"
"""ORM建立 属性 = 数据库字段"""
id = db.Column(db.Integer, primary_key=True) # 分类编号
name = db.Column(db.String(64), nullable=False) # 分类名
# 当前新闻分类的具体新闻 -- 关系 ( 新闻表, 反向引用--新闻表中的新闻分类, 懒加载 )
news_list = db.relationship('News', backref='category', lazy='dynamic')
def to_dict(self):
"""
把对象数据转换为字典数据
"""
# 封装字典
resp_dict = {
"id": self.id,
"create_time": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"name": self.name,
}
# 返回字典
return resp_dict
class Category(db.Model):
'''商品种类表'''
__tablename__ = "category"
c_id = db.Column(db.Integer, primary_key=True) # 种类id
c_name = db.Column(db.String(50), nullable=False) # 种类名
products = db.relationship('Product', backref='category')
class Brand(db.Model):
'''商品品牌表'''
__tablename__ = "brand"
b_id = db.Column(db.Integer, primary_key=True) # 品牌id
b_name = db.Column(db.String(50), nullable=False) # 品牌名
prducts = db.relationship('Product', backref='brand')
class Admin(db.Model):
'''管理员'''
__tablename__ = "admin"
id = db.Column(db.Integer, primary_key=True) # 编号
name = db.Column(db.String(100), unique=True) # 管理员账号
pwd = db.Column(db.String(100)) # 管理员密码
is_super = db.Column(db.SmallInteger) # 是否为超级管理员，0为超级管理员
role_id = db.Column(db.Integer, db.ForeignKey('role.id')) # 所属角色
addtime = db.Column(db.DateTime, index=True, default=datetime.now) # 添加时间
adminlogs = db.relationship("Adminlog", backref='admin') # 管理员登录日志外键关系关联
oplogs = db.relationship("Oplog", backref='admin') # 管理员操作日志外键关系关联
def __repr__(self):
return "<Admin %r>" % self.name
def check_pwd(self, pwd):
from werkzeug.security import check_password_hash
return check_password_hash(self.pwd, pwd)
class Category(BaseModel, db.Model):
__tablename__ = "info_category"
id = db.Column(db.Integer, primary_key=True) # 分类编号
name = db.Column(db.String(64), nullable=False) # 分类名
news_list = db.relationship('News', backref='category', lazy='dynamic')
def to_dict(self):
resp_dict = {"id": self.id, "name": self.name}
return resp_dict
class Category(BaseModel, db.Model):
__tablename__ = "info_category"
id = db.Column(db.Integer, primary_key=True) # 分类编号
name = db.Column(db.String(64), nullable=False) # 分类名
parent_id = db.Column(db.Integer,
db.ForeignKey("info_category.id")) # 父分类id
parent = db.relationship("Category", remote_side=[id]) # 自关联
article_list = db.relationship('Article',
backref='category',
lazy='dynamic')
def to_dict(self):
resp_dict = {
"id": self.id,
"name": self.name,
"parent_id": self.parent_id
}
return resp_dict
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "ih_user_profile"
id = db.Column(db.Integer, primary_key=True) # 用户编号
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) # 手机号
real_name = db.Column(db.String(32)) # 真实姓名
id_card = db.Column(db.String(20)) # 身份证号
avatar_url = db.Column(db.String(128)) # 用户头像路径
houses = db.relationship("House", backref="user") # 用户发布的房屋
orders = db.relationship("Order", backref="user") # 用户下的订单
@property # 将 password方法提升成一个属性，而所修饰的方法会在获取passowrd的值的时候被调用
def password(self):
raise AttributeError("当前属性不可读")
# 修饰指定名字属性的set方法，当 password 被设置值的时候就会被调用，并且会把设置的值做为参数传入
@password.setter
def password(self, value):
self.password_hash = generate_password_hash(value)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def to_dict(self):
resp_dict = {
"name":
self.name,
"avatar_url":
constants.QINIU_DOMIN_PREFIX +
self.avatar_url if self.avatar_url else "",
"mobile":
self.mobile
}
return resp_dict
def to_auth_info(self):
auth_dict = {"real_name": self.real_name, "id_card": self.id_card}
return auth_dict
class Role(db.Model):
'''角色'''
__tablename__ = "role"
id = db.Column(db.Integer, primary_key=True) # 编号
name = db.Column(db.String(100), unique=True) # 名称
auths = db.Column(db.String(600)) # 角色权限列表
addtime = db.Column(db.DateTime, index=True, default=datetime.now) # 添加时间
admins = db.relationship("Admin", backref='role') # 管理员外键关系关联
def __repr__(self):
return "<Role %r>" % self.name
class Seller(BaseModel, db.Model):
"""用户"""
__tablename__ = "seller"
id = db.Column(db.Integer, primary_key=True) # 卖家编号
mobile = db.Column(db.String(50), nullable=False) # 手机号
seller_name = db.Column(db.String(50), unique=False, nullable=False, default=mobile) # 卖家昵称
email = db.Column(db.String(50), nullable=False, default='') # 邮箱
address = db.Column(db.String(100), nullable=True) # 卖家地址
products = db.relationship('Product', backref='seller')
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True) # 用户编号
username = db.Column(db.String(20), unique=True, nullable=False) # 用户昵称
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
user_address_id = db.Column(db.Integer, nullable=True) # 地址
email = db.Column(db.String(30), nullable=True) # 用户头像路径
mobile = db.Column(db.String(20), unique=True, nullable=False) # 最后一次登录时间
is_admin = db.Column(db.Boolean, default=False) # 是否是管理员
self_signature = db.Column(db.String(255)) # 用户签名
gender = db.Column(db.Integer, default=0, nullable=True) # 性别
shipping_cars = db.relationship('ShippingAddress', backref='user', lazy='dynamic')
order_forms = db.relationship('OrderForm', backref='user', lazy='dynamic')
@property
def password(self):
raise AttributeError('当前属性不可读')
@password.setter
def password(self, value):
# self.password_hash = 加密(value)
self.password_hash = generate_password_hash(value)
def check_password(self, password):
'''校验密码'''
return check_password_hash(self.password_hash, password)
def to_dict(self):
output_data_dict = {
'id': self.id, # 用户编号
'username': self.username, # 用户昵称
'user_address_id': self.user_address_id, # 地址
'email': self.email, # 用户头像路径
'mobile': self.mobile, # 最后一次登录时间
'self_signature': self.self_signature, # 用户签名
'gender': self.gender, # 性别
}
return output_data_dict
class Subject(BaseModel, db.Model):
"""视频分类"""
__tablename__ = "subject"
id = db.Column(db.Integer, primary_key=True) # 分类编号
name = db.Column(db.String(64), nullable=False) # 分类名
cid = db.Column(db.Integer, db.ForeignKey("subject.id"))
video_list = db.relationship('Videos', backref='subject', lazy='dynamic')
def to_dict(self):
resp_dict = {"id": self.id, "name": self.name, "cid": self.cid}
return resp_dict
class Product(BaseModel, db.Model):
"""商品"""
__tablename__ = "product"
id = db.Column(db.Integer, primary_key=True, nullable=False) # 商品id
title = db.Column(db.String(255), nullable=False) # 商品标题
price = db.Column(db.INTEGER, nullable=False) # 商品价格
describe = db.Column(db.String(255), nullable=True) # 商品描述
category_id = db.Column(db.INTEGER, db.ForeignKey('category.c_id'), nullable=False) # 商品种类
all_nums = db.Column(db.INTEGER, nullable=False, default=0) # 商品数量
status = db.Column(db.INTEGER, nullable=False, default=2) # 商品状态:0上架中，1下架，2审核中
brand_id = db.Column(db.INTEGER, db.ForeignKey('brand.b_id'), nullable=False) # 品牌id
seller_id = db.Column(db.INTEGER, db.ForeignKey('seller.id'), nullable=False) # 卖家id
grade = db.Column(db.INTEGER, nullable=False, default=0) # 商品评分，默认是0
picture = db.Column(db.String(200)) # 商品图片
attrs = db.relationship('ProductSizeColor', backref='products', secondary='product_params')
def to_dict(self):
output_data_dict = {
'id': self.id, # 商品id
'title': self.title, # 商品标题
'price': self.price, # 商品价格
'describe': self.describe, # 商品描述
'category_id': self.category_id, # 商品种类
'all_nums': self.all_nums, # 商品数量
'status': self.status, # 商品状态:0上架中，1下架，2审核中
'brand_id': self.brand_id, # 品牌id
'seller_id': self.seller_id, # 卖家id
'grade': self.grade, # 商品评分，默认是0
'picture': self.picture, # 商品图片
}
return output_data_dict
def to_basic_dict(self):
output_data_dict = {
'id': self.id, # 商品id
'title': self.title, # 商品标题
'price': self.price, # 商品价格
'grade': self.grade, # 商品评分，默认是0
'picture': self.picture, # 商品图片
}
return output_data_dict
def to_head_collect_dict(self):
output_data_dict = {
'id': self.id, # 商品id
'title': self.title, # 商品标题
'price': self.price, # 商品价格
'picture': self.picture, # 商品图片
}
return output_data_dict
class Area(BaseModel, db.Model):
"""城区"""
__tablename__ = "ih_area_info"
id = db.Column(db.Integer, primary_key=True) # 区域编号
name = db.Column(db.String(32), nullable=False) # 区域名字
houses = db.relationship("House", backref="area") # 区域的房屋
def to_dict(self):
"""将对象转换为字典数据"""
area_dict = {"aid": self.id, "aname": self.name}
return area_dict
class Category(BaseModel, db.Model):
"""新闻分类"""
__tablename__ = "info_category"
id = db.Column(db.Integer, primary_key=True) # 分类编号
name = db.Column(db.String(64), nullable=False) # 分类名
news_list = db.relationship('News', backref='category', lazy='dynamic')
# 新闻分类标题栏
def to_dict(self):
return {
'id':self.id,
'name':self.name
}
class Comment(BaseModel, db.Model):
"""评论"""
__tablename__ = 'info_comment'
id = db.Column(db.Integer, primary_key=True) # 评论编号
user_id = db.Column(db.Integer,
db.ForeignKey('blog_customer.id'),
nullable=False) # 用户id
articles_id = db.Column(db.Integer,
db.ForeignKey('info_articles.id'),
nullable=False) # 文章id
content = db.Column(db.Text, nullable=False) # 评论内容
parent_id = db.Column(db.Integer, db.ForeignKey('info_comment.id')) # 父评论
parent = db.relationship('Comment', remote_side=[id]) # 自关联
like_count = db.Column(db.Integer, default=0) # 点赞次数
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 Articles(BaseModel, db.Model):
"""文章"""
__tablename__ = 'info_articles'
id = db.Column(db.Integer, primary_key=True) # 文章id
title = db.Column(db.String(256), nullable=False) # 文章标题
source = db.Column(db.String(64)) # 文章来源
digest = db.Column(db.String(512), nullable=False) # 文章摘要
content = db.Column(db.Text, nullable=False) # 文章内容
clicks = db.Column(db.Integer, default=0) # 浏览量
tag = db.Column(db.String(64)) # 标签
index_image_url = db.Column(db.String(256)) # 文章列表图片路径
category_id = db.Column(db.Integer,
db.ForeignKey('info_category.id')) # 文章分类
user_id = db.Column(db.Integer, db.ForeignKey('blog_customer.id')) # 文章作者
recommend = db.Column(db.Integer, default=0) # 推荐
comments = db.relationship('Comment', lazy='dynamic')
class Category(BaseModel, db.Model):
"""新闻分类"""
__tablename__ = "info_category"
id = db.Column(db.Integer, primary_key=True) # 分类编号
name = db.Column(db.String(64), nullable=False) # 分类名
news_list = db.relationship('News', backref='category', lazy='dynamic')
def to_dict(self):
"""后台新闻板式编辑使用,查询分类数据"""
resp_dict = {
"id": self.id,
"name": self.name,
"create_time": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
}
return resp_dict
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) # 评论内容
comment_id = db.Column(db.Integer,
db.ForeignKey("info_comment.id")) # 父评论id
back_list = db.relationship('Comment', lazy='dynamic') #,backref='comment'
like_count = db.Column(db.Integer, default=0) # 点赞条数
def to_dict(self):
return {
'id':
self.id,
'user':
User.query.get(self.user_id).to_login_dict(),
'content':
self.content,
'create_time':
self.create_time.strftime('%Y-%m-%d %H:%M:%S'),
'like_count':
self.like_count,
'backs': [
back.to_back_dict()
for back in self.back_list.order_by(Comment.id.desc())
],
'like':
False
}
def to_back_dict(self):
return {
'id': self.id,
'nick_name': User.query.get(self.user_id).nick_name,
'content': self.content
}
class News(BaseModel, db.Model):
"""新闻"""
__tablename__ = "info_news"
id = db.Column(db.Integer, primary_key=True) # 新闻编号
title = db.Column(db.String(256), nullable=False) # 新闻标题
source = db.Column(db.String(64), nullable=False) # 新闻来源
digest = db.Column(db.String(512), nullable=False) # 新闻摘要
content = db.Column(db.Text, nullable=False) # 新闻内容
clicks = db.Column(db.Integer, default=0) # 浏览量
index_image_url = db.Column(db.String(256)) # 新闻列表图片路径
category_id = db.Column(db.Integer, db.ForeignKey("info_category.id"))
user_id = db.Column(db.Integer, db.ForeignKey("info_user.id")) # 当前新闻的作者id
status = db.Column(db.Integer, default=1) # 当前新闻状态 如果为0代表审核通过，1代表审核中，-1代表审核不通过
reason = db.Column(db.String(256)) # 未通过原因，status = -1 的时候使用
# 当前新闻的所有评论
comments = db.relationship("Comment", lazy="dynamic")
def to_list_dict(self):
return {
"title":self.title,
'create_time':self.create_time,
"status":self.status,
"id":self.id
}
# 点击排行
def to_click_dict(self):
return {
'id':self.id,
'title':self.title
}
# 新闻分类展示
def to_index_dict(self):
return {
'id':self.id,
'title':self.title,
# 'index_image_url':constants.QINIU_DOMIN_PREFIX+self.index_image_url,
'index_image_url':self.index_image_url,
'digest':self.digest,
'create_time':self.create_time,
'source':self.source
}
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True) # 用户编号
nick_name = db.Column(db.Unicode(32), unique=True, nullable=False) # 用户昵称
mobile = db.Column(db.String(11), unique=True) # 手机号
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
email = db.Column(db.String(30), unique=True) # 邮箱
update_time = db.Column(db.DateTime,
default=datetime.now,
onupdate=datetime.now)
is_admin = db.Column(db.Boolean, default=False)
collection_videos = db.relationship("Videos",
secondary=tb_user_collection,
lazy="dynamic") # 用户收藏的
@property
def password(self):
raise AttributeError("当前属性不允许读取")
@password.setter
def password(self, value):
# self.password_hash = 对value加密
self.password_hash = generate_password_hash(value)
def check_password(self, password):
"""校验密码"""
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,
"is_admin": self.is_admin,
"register": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"last_login": self.update_time.strftime("%Y-%m-%d %H:%M:%S"),
}
return resp_dict
class Comment(BaseModel, db.Model):
"""
评论
BaseModel 继承 -- 实现创建时间和更新时间的补充
db.Model 数据模型 -- 实体和数据库表名建立关系
"""
# 数据库表名 -- 和当前类绑定
__tablename__ = "info_comment"
"""ORM建立 属性 = 数据库字段"""
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]) # 自关联
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 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]) # 自关联
backs_list=db.relationship('Comment',lazy='dynamic')
#,backref='parent',
# remote_side=['parent_id']
like_count = db.Column(db.Integer, default=0) # 点赞条数
def to_dict(self):
user = User.query.get(self.user_id)
return {
"id": self.id,
"create_time": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"content": self.content,
'user': user.to_login_dict(),
"news_id": self.news_id,
"like_count": self.like_count,
# 回复
'backs': [back.to_back_dict() for back in self.backs_list],
# 是否点赞
'is_like': False
}
def to_back_dict(self):
user = User.query.get(self.user_id)
return {
"id":self.id,
"nick_user":user.nick_name,
"content":self.content
}
