class User(db.Model, BaseModel):
'''用户表'''
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 主键，自增长
username = db.Column(db.String(20)) # 用户名
phone_number = db.Column(db.String(11))
password = db.Column(db.String(20)) # 密码
password_hash = db.Column(db.String(255)) # 密码哈希值
position = db.Column(db.String(1),default=1) # 1公司代理负责人 2财务 3注册代理 5:超管
def __repr__(self):
return '<User %r>' % self.username
def set_password(self, password):
'''在用户注册的时候使用，会调用generate_password_hash()并将password参数传给它，将它的返回值存储在列属性password_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)
def to_dict(self):
'''将对象转换为字典数据'''
user_dict = {
"user_id": self.id,
"username": self.username,
"password": self.password,
"password_hash": self.password_hash,
"position": self.position,
"create_time": self.create_time.strftime("%Y-%m-%d %H:%M:%S")
}
return user_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) # 加密的密码
last_login = db.Column(db.DateTime, default=datetime.now) # 最后一次登录时间
is_admin = db.Column(db.Boolean, default=False)
@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,
}
return resp_dict
def to_admin_dict(self):
resp_dict = {
"id": self.id,
"nick_name": self.nick_name,
"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 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 AdOrder(db.Model, BaseModel):
'''粉丝量到一定量然后广告接单'''
__tablename__ = 'adorder'
id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 主键，自增长
agent_id = db.Column(db.Integer, db.ForeignKey('agent.id'))
date_of_order = db.Column(db.DateTime, default=datetime.now) # 接单日
push_time = db.Column(db.DateTime) # 推送广告时间/可以写多个时间
ad_count = db.Column(db.Integer, nullable=False) # 广告数量
screenshots = db.Column(db.String(256)) # 截图
amount = db.Column(db.Integer) # 金额/单价
check_out_date = db.Column(db.DateTime) # 结算日
state = db.Column(db.Boolean, default=0, index=True) # 结算状态: 0表示未结算付款，1表示已结算付款
remark = db.Column(db.String(50)) # 备注
def __repr__(self):
return '<AdOrder %r>' % self.id
def to_dict(self):
'''将对象转换为字典数据'''
adorder_dict = {
'adorder_id': self.id,
'agent_id': self.agent_id,
'date_of_order': self.date_of_order,
'push_time': self.push_time,
'ad_count': self.ad_count,
'screenshots': self.screenshots,
'amount': self.amount,
'check_out_date': self.check_out_date,
'state': self.state,
'remark': self.remark,
}
return adorder_dict
class ShippingAddress(BaseModel, db.Model):
"""收货地址"""
__tablename__ = "shipping_address"
id = db.Column(db.Integer, primary_key=True) # 收件地址id
user_id = db.Column(db.Integer, db.ForeignKey('user.id')) # 用户编号
address = db.Column(db.String(100), nullable=False) # 地址
nickname = db.Column(db.String(20), nullable=False) # 收件人姓名
phoneNumber = db.Column(db.String(30), nullable=False) # 收件人手机号
class Article(BaseModel, db.Model):
__tablename__ = "info_article"
id = db.Column(db.Integer, primary_key=True) # 文章编号
title = db.Column(db.String(256), nullable=False) # 文章标题
source_id = db.Column(db.Integer,
db.ForeignKey('info_article_source.id')) # 文章来源
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_name = db.Column(db.String(25), default='张小强')
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_review_dict(self): # 发布状态查看
resp_dict = {
"id": self.id,
"title": self.title,
"create_time": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"status": self.status,
"reason": self.reason if self.reason else ""
}
return resp_dict
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
def to_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"),
"content": self.content,
"clicks": self.clicks,
"category": self.category.to_dict(),
"index_image_url": self.index_image_url,
"author": self.user_name,
}
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 Oplog(db.Model):
'''操作日志'''
__tablename__ = "oplog"
id = db.Column(db.Integer, primary_key=True) # 编号
admin_id = db.Column(db.Integer, db.ForeignKey('admin.id')) # 所属管理员
ip = db.Column(db.String(100)) # 登录IP
reason = db.Column(db.String(600)) # 操作原因
addtime = db.Column(db.DateTime, index=True, default=datetime.now) # 登录时间
def __repr__(self):
return "<Oplog %r>" % self.id
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 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 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 ProductSizeColor(db.Model):
'''商品型号颜色表'''
__tablename__ = "product_size_color"
id = db.Column(db.Integer, primary_key=True) # 商品型号颜色id
color_name = db.Column(db.String(20), nullable=False) # 颜色名
size_name = db.Column(db.String(20), nullable=False) # 型号表
def to_dict(self):
output_data_dict = {
'id': self.id,
'color_name': self.color_name,
'size_name': self.size_name
}
return output_data_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 Carousels(BaseModel, db.Model):
"""轮播图"""
__tablename__ = 'info_carousels'
id = db.Column(db.Integer, primary_key=True) # 编号
name = db.Column(db.String(64)) # 轮播图名字
categ = db.Column(db.Integer, nullable=False) # 种类
class Facility(BaseModel, db.Model):
"""设施信息"""
__tablename__ = "ih_facility_info"
id = db.Column(db.Integer, primary_key=True) # 设施编号
name = db.Column(db.String(32), nullable=False) # 设施名字
class Users(BaseModel, db.Model):
__tablename__ = 'user_info'
id = db.Column(db.Integer, primary_key=True)
nickname = db.Column(db.String(20), unique=True)
user_name = db.Column(db.String(16), unique=True, nullable=False)
password = db.Column(db.String(16), nullable=False)
mobile = db.Column(db.String(11), nullable=False)
def to_dic(self):
dic = {
'user_id': self.id,
'nickname': self.nickname,
'user_name': self.user_name,
'mobile': self.mobile
}
return dic
class File(BaseModel, db.Model):
__tablename__ = 'info_file'
id = db.Column(db.Integer, primary_key=True)
file_name = db.Column(db.String(32), unique=True, nullable=False)
file_address = db.Column(db.String(35), nullable=False)
file_folder = db.Column(db.Integer, nullable=False)
def to_dic(self):
dic = {
'file_id': self.id,
'file_name': self.file_name,
'file_address': self.file_address,
'file_folder': self.file_folder
}
return dic
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 User(BaseModel, db.Model):
"""用户"""
__tablename__ = "info_user"
id = db.Column(db.Integer, primary_key=True) # 用户编号
openid = db.Column(db.String(32), unique=True, nullable=False) # 手机号
nickname = db.Column(db.String(32), unique=True, nullable=False) # 密码
headimgurl = db.Column(db.String(255), unique=True, nullable=False) # 密码
def to_dict(self):
resp_dict = {
"id": self.id,
"openid": self.openid,
"nickname": self.nickname,
"headimgurl": self.headimgurl,
}
return resp_dict
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 WechatUrl(BaseModel, db.Model):
"""微信公众号带参数二维码"""
__tablename__ = "wechat_url"
id = db.Column(db.Integer, primary_key=True) # 用户编号
course_name = db.Column(db.String(32), nullable=False, unique=True) # 课程名称
params = db.Column(db.String(32), unique=True, nullable=False) # 参数
url = db.Column(db.String(255), unique=True, nullable=False) # 密码
def to_dict(self):
resp_dict = {
"id": self.id,
"course_name": self.course_name,
"params": self.params,
"url": self.url,
}
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 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 IndexCategory(BaseModel, db.Model):
"""新闻分类"""
__tablename__ = "info_index"
id = db.Column(db.Integer, primary_key=True) # 分类编号
name = db.Column(db.String(64), nullable=False) # 分类名
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) # 分类名
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 HouseImage(BaseModel, db.Model):
"""房屋图片"""
__tablename__ = "ih_house_image"
id = db.Column(db.Integer, primary_key=True)
house_id = db.Column(db.Integer,
db.ForeignKey("ih_house_info.id"),
nullable=False) # 房屋编号
url = db.Column(db.String(256), nullable=False) # 图片的路径
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) # 用户编号
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
