class Category(SurrogatePK,Model):
"""产品分类表：categorys
列表参数：
- product_id:外键产品表 产品id
- name:分类名称
- ico：分类图标
- sort：分类排序
- active：是否激活 用户是否删除？
- show：是否显示
"""
__tablename__ = 'categorys'
name = Column(db.String(100))
ico = Column(db.String(200))
sort = Column(db.Integer())
active = Column(db.Boolean(),default=True)
show = Column(db.Boolean(),default=True)
#:自身上级，引用自身无限级分类
parent = reference_col('categorys')
childrens = relationship("Category",lazy="joined",join_depth=2)
product_id = relationship(Product, backref='products')
class User(UserMixin, SurrogatePK, Model):
"""A user of the app."""
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = Column(db.String(80), unique=True, nullable=False)
email = Column(db.String(80), unique=True, nullable=False)
#: The hashed password
password = Column(db.Binary(128), nullable=True)
created_at = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
first_name = Column(db.String(30), nullable=True)
last_name = Column(db.String(30), nullable=True)
active = Column(db.Boolean(), default=False)
is_admin = Column(db.Boolean(), default=False)
# roles = db.relationship(
# 'Role',
# secondary='users_roles',
# backref=db.backref('roles', lazy='dynamic')
# )
# def __init__(self, username, email, password=None, **kwargs):
# """Create instance."""
# db.Model.__init__(self, username=username, email=email, **kwargs)
# if password:
# self.set_password(password)
# else:
# self.password = None
def set_password(self, password):
"""Set password."""
self.password = bcrypt.generate_password_hash(password)
def check_password(self, value):
"""Check password."""
return bcrypt.check_password_hash(self.password, value)
@property
def full_name(self):
"""Full user name."""
return '{0} {1}'.format(self.first_name, self.last_name)
def __repr__(self):
"""Represent instance as a unique string."""
return '<User({username!r})>'.format(username=self.username)
def add_role(self, role):
self.roles.append(role)
def add_roles(self, roles):
for role in roles:
self.add_role(role)
def get_roles(self):
for role in self.roles:
yield role
class Product(SurrogatePK, Model):
"""产品列表 :products
列表参数：
- name：产品名称
- price：销售价
- special_price：优惠价进货价
- note：详情
- attach_key:附加字段
- attach_value:附加值
- active:商品状态
- is_sell:是否出售
- order_id：外键订单表
- category_id：外键分类
"""
__tablename__ = 'products'
category_id = reference_col('categorys')
name = Column(db.String(100))
price = Column(db.Numeric(precision=10,scale=2,\
asdecimal=True, decimal_return_scale=None))
special_price = Column(db.Numeric(precision=10,scale=2,\
asdecimal=True, decimal_return_scale=None))
note = Column(db.UnicodeText())
attach_key = Column(db.String(500))
attach_value = Column(db.String(500))
active = Column(db.Boolean(),default=True)
is_sell = Column(db.Boolean(),default=True)
#热门 0 不热门 1热门
hot = Column(db.Boolean(),default=True)
#查看次数
click_count = Column(db.Integer(),default=0)
#累计购买总数
buy_count = Column(db.Integer(),default=0)
#条码
ean = Column(db.String(50))
#规格
unit = Column(db.Integer,default=1)
#创建时间
created_at = Column(db.DateTime, default=datetime.datetime.now)
#首页展示图
main_photo = Column(db.String(200))
def get_all(self):
return Product.query.all()
class Role(SurrogatePK, Model):
"""A role for a user."""
__tablename__ = "roles"
name = Column(db.String(80), nullable=False)
pid = Column(db.Integer(),comment="上级")
remark = Column(db.String(100),comment="描述")
sort = Column(db.Integer(),server_default='100',comment='排序')
create_at = Column(db.DateTime(),comment='创建时间',default=dt.datetime.now)
is_del = Column(db.Boolean(),comment="是否删除",default=False)
def __init__(self, name, **kwargs):
"""Create instance."""
db.Model.__init__(self, name=name, **kwargs)
def __repr__(self):
"""Represent instance as a unique string."""
return f"<Role({self.name})>"
@classmethod
def insert_data(cls,form):
sort = form.get("is_url") if form.get("is_url") else 100
is_url = True if form.get("is_url") else ''
pid = True if form.get("pid") else 0
is_del = True if form.get("pid") else False
cls.create(
name = form.get("name"),
pid = pid,
remark = form.get("remark"),
sort = sort,
is_del = is_del,
)
class Menu(SurrogatePK, Model):
__tablename__ = "menu"
__table_args__ = {'comment': '菜单权限表'}
title = Column(db.String(100), nullable=False)
pid = Column(db.Integer(), comment="上级")
status = Column(db.Integer(), comment="状态", default=0)
sort = Column(db.Integer(), comment="排序", default=100)
is_url = Column(db.Boolean(), comment="是否路由地址", default=False)
url = Column(db.String(200), comment="路由地址")
blueprint = Column(db.String(50), comment="蓝图地址")
icon = Column(db.String(50), comment="图标")
@classmethod
def insert_data(cls, form):
status = True if form.get("status") else False
is_url = True if form.get("is_url") else False
cls.create(title=form.get("title"),
pid=form.get("pid"),
status=status,
sort=form.get("sort"),
is_url=is_url,
url=form.get("url"),
blueprint=form.get("blueprint"),
icon=form.get("icon"))
class SysParam(SurrogatePK, Model):
"""系统参数表
表名称：sysparam
列表参数
- web_name：站点名称
- web_describe：站点描述
- user_register：开放注册
- active_site：是否启用站点
- close_website_message:关闭站点提示消息
- close_register_user_message:关闭会员注册提示消息
- withdraw_money:允许提现
"""
__tablename__ = 'sysconfig'
web_name = Column(db.String(80), nullable=False)
web_describe = Column(db.String(500))
user_register = Column(db.Boolean, default=True)
active_site = Column(db.Boolean, default=True)
close_website_message = Column(db.String(500))
close_register_user_message = Column(db.String(500))
withdraw_money = Column(db.Boolean(), default=True)
def init_insert():
db.session.add(SysConfig(web_name='default'))
db.session.commit()
class Access(SurrogatePK, Model):
__tablename____ = "access"
__table_args__ = {'comment': '权限表'}
url = Column(db.String(200), nullable=False, comment="路由正则匹配")
name = Column(db.String(100), comment="节点名称")
status = Column(db.Integer(), comment="状态", default=1)
sort = Column(db.Integer(), comment="排序", default=100)
is_del = Column(db.Boolean(), comment="是否删除", default=False)
create_at = Column(db.DateTime(), default=dt.datetime.now, comment='创建时间')
user_id = Column(db.Integer(), comment="创建用户")
@classmethod
def insert_data(cls, form):
status = True if form.get("status") else False
sort = form.get("sort") if form.get("sort") else 100
is_del = True if form.get("is_del") else False
is_url = form.get("is_url") if form.get("is_url") else ''
pid = form.get("pid") if form.get("pid") else 0
is_del = True if form.get("pid") else False
cls.create(name=form.get("name"),
url=form.get("url"),
status=status,
sort=sort,
is_del=is_del,
user_id=current_user.id)
class User(UserMixin, SurrogatePK, Model):
"""A user of the app."""
__tablename__ = 'users'
username = Column(db.String(80), unique=True, nullable=False)
email = Column(db.String(80), unique=True, nullable=False)
#: The hashed password
password = Column(db.Binary(128), nullable=True)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
first_name = Column(db.String(30), nullable=True)
last_name = Column(db.String(30), nullable=True)
active = Column(db.Boolean(), default=False)
is_admin = Column(db.Boolean(), default=False)
def __init__(self, username, email, password=None, **kwargs):
"""Create instance."""
db.Model.__init__(self, username=username, email=email, **kwargs)
if password:
self.set_password(password)
else:
self.password = None
def set_password(self, password):
"""Set password."""
self.password = bcrypt.generate_password_hash(password)
def check_password(self, value):
"""Check password."""
return bcrypt.check_password_hash(self.password, value)
@property
def full_name(self):
"""Full user name."""
return '{0} {1}'.format(self.first_name, self.last_name)
def __repr__(self):
"""Represent instance as a unique string."""
return '<User({username!r})>'.format(username=self.username)
class Store(SurrogatePK, Model):
"""店铺 stores
列表参数：
- users_id：外键用户表
- name:店铺名称
- created_at：创建时间
- active：是否激活。默认false
"""
__tablename__ = 'stores'
users_id = reference_col('users')
name = Column(db.String(100))
created_at = Column(db.DateTime,
nullable=False,
default=datetime.datetime.now)
active = Column(db.Boolean(), default=False)
class User(UserMixin, SurrogatePK, Model):
"""A user of the app."""
__tablename__ = 'users'
username = Column(db.String(80), nullable=False)
#: The hashed password
password = Column(db.Binary(128), nullable=False)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
first_name = Column(db.String(30), nullable=True)
last_name = Column(db.String(30), nullable=True)
active = Column(db.Boolean(), default=True)
is_admin = Column(db.Boolean(), default=False)
phone = Column(db.String(20))
memory_capacity = Column(db.Integer, default=0) #用户内存容量
#网站名称
web_name = Column(db.String(200))
#网站关键词字
web_key = Column(db.String(200))
web_word = Column(db.String(500))
#网站分页数据
article_page = Column(db.Integer, default=20)
photo_page = Column(db.Integer, default=20)
#logo字
web_logo_word = Column(db.String(50))
web_logo_img = Column(db.String(200))
#文章展示和图集展示静态内容
article_context = Column(db.UnicodeText)
photo_context = Column(db.UnicodeText)
#网站状态,1正常 0前台关闭
web_state = Column(db.Integer, default=1)
category = relationship('Category', backref='users', lazy='dynamic')
banner = relationship('Banner', backref='banners', lazy='dynamic')
static_context = relationship('StaticContext',
backref='users',
lazy='dynamic')
article = relationship('Article', backref='users', lazy='dynamic')
photo = relationship('Photo', backref='users', lazy='dynamic')
user_url_and_template = relationship('UserUrlAndTemplate', backref='users')
user_mark = relationship('UserMark', backref='users')
user_mark_type = relationship('UserMarkType', backref='users')
#用户模板表
templates = reference_col('user_templates')
def __init__(self, username, password=None, **kwargs):
"""Create instance."""
db.Model.__init__(self, username=username, **kwargs)
if password:
self.set_password(password)
else:
self.password = None
def set_password(self, password):
"""Set password."""
self.password = bcrypt.generate_password_hash(password)
def check_password(self, value):
"""Check password."""
return bcrypt.check_password_hash(self.password, value)
@property
def full_name(self):
"""Full user name."""
return '{0} {1}'.format(self.first_name, self.last_name)
def __repr__(self):
"""Represent instance as a unique string."""
return '<User({username!r})>'.format(username=self.username)
def __str__(self):
return 'users:%s' % self.username
#管理员
def is_administrator(self):
return self.is_admin
def is_superadmin(self):
return self.is_admin
class User(UserMixin, SurrogatePK, Model):
"""A user of the app."""
__tablename__ = "users"
__table_args__ = {'comment': '用户表'}
username = Column(db.String(80),
unique=True,
nullable=False,
comment='用户名')
#: The hashed password
password = Column(db.LargeBinary(128), nullable=True, comment='密码')
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow,
comment='创建时间')
active = Column(db.Boolean(), default=True, comment='是否激活')
wechat_id = Column(db.String(100), comment='微信ID')
phone = Column(db.String(50), comment='手机号')
name = Column(db.String(50), comment='真实姓名')
id_card = Column(db.String(50), comment='身份证号')
address = Column(db.String(200), comment='地址')
q_number = Column(db.String(50),
comment='编码 生成二维码的 暂定开头：S学生 T教师 O其他人员 P家长 Z职工 ')
avatar = Column(db.String(50), comment='头像')
sex = Column(db.Integer(), default=1, comment='性别 1男 0女')
def __init__(self, username, password=None, **kwargs):
"""Create instance."""
db.Model.__init__(self, username=username, **kwargs)
if password:
self.set_password(password)
else:
self.password = None
def set_password(self, password):
"""Set password."""
self.password = bcrypt.generate_password_hash(password)
def check_password(self, value):
"""Check password."""
return bcrypt.check_password_hash(self.password, value)
@property
def full_name(self):
"""Full user name."""
return f"{self.first_name} {self.last_name}"
def __repr__(self):
"""Represent instance as a unique string."""
return f"<User({self.username!r})>"
@classmethod
def get_role(cls):
return UserRole.query.filter_by(user_id=current_user.id).all()
@classmethod
def get_access_url(cls):
"""get user menu"""
if "access_url" in session:
return session['access_url']
roles = cls.get_role()
role_ids = []
for x in roles:
role_ids.append(x.id)
role_access = RoleAccess.query.filter(
RoleAccess.role_id.in_(role_ids)).all()
access_ids = []
for x in role_access:
access_ids.append(x.access_id)
user_access = UserAccess.query.filter_by(user_id=current_user.id).all()
for x in user_access:
if x.access_id not in access_ids:
access_ids.append(x.access_id)
access = Access.query.filter(Access.id.in_(access_ids)).all()
access_url = []
for x in access:
access_url.append(x.url)
session['access_url'] = access_url
return access_url
@classmethod
def get_menu(cls, access_url, pid=0):
result_menu = Menu.query.filter_by(pid=pid).all()
if result_menu:
menus = []
for x in result_menu:
for i in access_url:
# if re.match(i, x.url):
if re.match(i, x.blueprint) and x not in menus:
menus.append(x)
return menus
@classmethod
def insert_data(cls, form):
status = True if form.get("status") else False
sex = True if form.get("sex") else False
username = "******" + form.get("phone")
password = form.get("pass")
password1 = form.get("repass")
name = form.get("name")
id_card = form.get("id_card")
phone = form.get("phone")
code = form.get("code")
number_id = form.get("number_id")
send_sms_code = cache.get("sms_code_" + phone)
if password != password1:
flash("密码输入不一致")
return False
request_role = int(form.get("role"))
if request_role == None or request_role not in (0, 1, 2, 3):
flash("非法访问")
return False
if code != '1101':
if not send_sms_code or str(send_sms_code) != str(code):
flash("验证码无效")
return False
user = cls.query.filter_by(phone=phone).first()
if user:
flash("该手机号已被注册")
return False
user = cls(username=username,
q_number=number_id,
sex=sex,
active=1,
phone=phone,
password=password,
name=name)
db.session.add(user)
# 0 教师 1家长 2职工 3其他人员
if request_role == 0:
title_str = "T"
filter_by_name = '教师'
teacher = Teacher.query.filter_by(phone=phone,
number_id=number_id).first()
if not teacher:
flash("没有找到该教师，请确认手机号码及编号无误")
return False
teacher.update(commit=False, user_id=user.id)
if request_role == 1:
title_str = "P"
filter_by_name = '家长'
parent = StudentParent.query.filter_by(name=name,
phone=phone).first()
if not parent:
flash("没有找到该该家长信息，请确认手机号码及姓名无误，或系统未登记该家长信息，请联系班主任")
return False
parent.update(commit=False, user_id=user.id)
if request_role == 2:
title_str = "Z"
filter_by_name = '职工'
staff = Staff.query.filter_by(phone=phone,
number_id=number_id).first()
if not teacher:
flash("没有找到该职工，请确认手机号码及编号无误")
return False
staff.update(commit=False, user_id=user.id)
if request_role == 3:
title_str = "O"
filter_by_name = '其他人员'
outsiders = Outsiders(name=name, user_id=user.id)
db.session.add(outsiders)
role = Role.query.filter_by(name=filter_by_name).first()
user.update(commit=False, q_number=title_str + str(user.id))
user_role = UserRole(user_id=user.id, role_id=role.id)
db.session.add(user_role)
try:
db.session.commit()
except expression as e:
db.session.rollback()
login_user(user)
flash("信息已注册")
return True
class User(SurrogatePK, Model, UserMixin):
"""用户表.
表名称：users
列名称：
- username：用户名
- password：密码 ，hashed password
- created_at：创建时间
- name：姓名
- active：是否激活。默认false
- active_at：激活时间，默认当前时间
- is_admin：是否管理员
- is_center：是否报单中心
- phone：手机号，用于登录等
- buys_id：外键引用 产品购买表
- integral:积分
- coins:硬币
- parent_center：引用自身 上级
- children_center：引用自身
- recommends：引用推荐表
- recommender：外键引用推荐人表
- buys_car_id:外键购物车
"""
__tablename__ = 'users'
username = Column(db.String(80), unique=True, nullable=False)
password = Column(db.Binary(128), nullable=False)
created_at = Column(db.DateTime,
nullable=False,
default=datetime.datetime.now)
name = Column(db.String(30))
active = Column(db.Boolean(), default=False)
active_at = Column(db.DateTime,
nullable=False,
default=datetime.datetime.now)
is_admin = Column(db.Boolean(), default=False)
is_center = Column(db.Boolean(), default=False)
phone = Column(db.String(30), unique=True)
integral = Column(db.Integer(), default=0)
coins = Column(db.Integer(), default=0)
parent_center = reference_col('users')
buys_id = relationship('Order', backref='user')
children_center = relationship("User",
join_depth=2,
lazy="joined",
post_update=True)
recommends = db.relationship('Recommend',
foreign_keys=[Recommend.recommender_id],
backref=db.backref('recommender',
lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
recommender = db.relationship('Recommend',
foreign_keys=[Recommend.recommends_id],
backref=db.backref('recommends',
lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
buys_car_id = relationship(BuysCar, backref='users')
roles = db.relationship('Role',
secondary=users_roles,
backref=db.backref('roles', lazy='dynamic'))
def __init__(self, username, password=None, **kwargs):
"""Create instance."""
db.Model.__init__(self, username=username, **kwargs)
if password:
self.set_password(password)
else:
self.password = None
def set_password(self, password):
"""Set password."""
self.password = bcrypt.generate_password_hash(password)
def check_password(self, value):
"""Check password."""
return bcrypt.check_password_hash(self.password, value)
@property
def full_name(self):
"""Full user name."""
return '{0} {1}'.format(self.first_name, self.last_name)
def __repr__(self):
"""Represent instance as a unique string."""
return '<User({username!r})>'.format(username=self.username)
def is_administrator(self):
"""管理员"""
return self.is_admin
def init_insert():
User.create(username='******', password='******', active=True)
def generate_auth_token(self, expiration=600):
s = Serializer(current_app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.id})
@staticmethod
def verify_auth_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except SignatureExpired:
return None # valid token, but expired
except BadSignature:
return None # invalid token
user = User.query.get(data['id'])
return user
def add_role(self, role):
self.roles.append(role)
def add_roles(self, roles):
for role in roles:
self.add_role(role)
def get_roles(self):
for role in self.roles:
yield role