class UserAlarmRecord(db.Model):
__tablename__ = 'user_alarm_record'
id = db.Column(db.String(24), default=objectid, primary_key=True)
type = db.Column(db.Integer,
default=0,
comment='参考创建信息类型 (0,119 1,疏散,2,传感器，3,求救)')
content = db.Column(db.String(255), comment='报警内容')
if_confirm = db.Column(db.Boolean, default=False, comment='是否关闭')
home_id = db.Column(db.String(24),
db.ForeignKey('home.id'),
comment='报警关联家庭id')
home = db.relationship('Home')
ins_id = db.Column(db.String(24), db.ForeignKey('ins.id'), comment='机构id')
reference_alarm_id = db.Column(db.String(24), comment='参考创建信息id')
user_id = db.Column(db.String(24),
db.ForeignKey('user.id'),
comment='发布人id')
user = db.relationship('User')
note = db.Column(db.String(255), comment='备注')
origin = db.Column(db.String(255), comment='创建来源')
mark = db.Column(db.String(255), comment='来源备注')
time = db.Column(db.DateTime,
default=datetime.datetime.now(),
comment='创建时间')
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
@property
def password(self):
return self.pwd
# 使用user.password='******'设置时存入生成的散列密码
@password.setter
def password(self, new_password):
self.pwd = generate_password_hash(new_password)
def check_pwd(self, try_password):
return check_password_hash(self.pwd, try_password)
class BankCard(db.Model):
__tablename__ = "bankcard"
def __init__(self, name, card, user_id):
self.name = name
self.card = card
self.user_id = user_id
@classmethod
def card_exist(cls, card, cardid=None):
"""验证卡号是否存在"""
if cardid is None:
return BankCard.query.filter_by(card=card).first()
else:
return BankCard.query.filter(BankCard.id != cardid,
BankCard.card == card).first()
@classmethod
def id_exist(cls, id):
"""验证ID是否存在"""
return BankCard.query.filter_by(id=id).first()
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32)) #开户行
card = db.Column(db.String(25), unique=True) #银行卡号
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
billflows = db.relationship('BillFlow', backref='bankcard')
userp2ps = db.relationship('UserP2P', backref='bankcard')
class Ins(db.Model):
__tablename__ = 'ins'
id = db.Column(db.String(24), default=objectid, primary_key=True)
type = db.Column(db.String(255), comment='机构类型')
name = db.Column(db.String(50), comment='机构名称')
ins_picture = db.Column(db.String(255), comment='机构图片')
location_id = db.Column(db.String(50),
db.ForeignKey('location.id'),
comment='位置')
ins_address = db.Column(db.String(255), comment='机构地址')
note = db.Column(db.Text, comment='备注')
latitude = db.Column(db.Float(asdecimal=True), comment='纬度')
longitude = db.Column(db.Float(asdecimal=True), comment='经度')
admin_user_id = db.Column(db.String(24),
db.ForeignKey('user.id'),
comment='管理员id')
community = db.relationship('Community',
secondary=t_community_ins,
backref=db.backref('f1_community',
lazy='dynamic'),
lazy='dynamic')
user = db.relationship('User',
secondary=t_user_ins,
backref=db.backref('f_user', lazy='dynamic'),
lazy='dynamic')
disabled = db.Column(db.Boolean,
nullable=False,
default=False,
comment='是否可用')
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) #是否为超级管理员
role_id = db.Column(db.Integer, db.ForeignKey('role.id')) #所属角色
add_time = 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 "<Model Admin {}>".format(self.name)
@staticmethod
def insert_init_admin():
from werkzeug.security import generate_password_hash
admin = Admin(name='admin',
pwd=generate_password_hash('admin'),
is_super=0,
role_id=1)
db.session.add(admin)
db.session.commit()
class Cate(db.Model):
cid = db.Column(db.Integer, primary_key=True)
cname = db.Column(db.String(64), index=True, unique=True, nullable=True)
# 建立关联关系的对象 懒加载
"""
参数一 argument 关联的对象的类名
参数二 lazy 不能用于多对一 或者一对一上
可选项:
1> select 默认值 一条sql一句把所有的相关的数据全部查出来
2> dynamic 只查询主表的数据,生成查询子表的sql 当我们需要使用子表的数据的时候在去查询
3> immediate 等主表数据查询完成之后再去查询子表数据
back_populates 方向引用(当两个对象需要双向引用的时候使用)
值对应双向引用对象的字段
# backref backref='cate' 例如可以使用 shop.cate
uselist=None, 如果想建立一对一的关系 直接在 uselist=false
order_by=False,指定查询子表的排序字段
"""
# 解决开发中有些时候查询主表相关联的子表的数据过大时
# 默认是 select 立即加载
# dynamic 懒加载 只会加载主表的数据,不会把子表的数据也加载进内存(只会生成sql语句,
# 当我们需要用到数据的时候,去执行查询吧数据加载进内存)
shops = db.relationship('Shop', back_populates='cate', order_by=Shop.sid, lazy='dynamic')
# 只能用于一对多 还多对多 能通过一的一方的查询吧多的一方也查询出来
shops = db.relationship('Shop', back_populates='cate', lazy='dynamic')
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.String(24), default=objectid, primary_key=True)
disabled = db.Column(db.Boolean,
nullable=False,
default=False,
comment='是否停用 (1、禁用 0、正常)')
contract_tel = db.Column(db.String(20), comment='用户电话')
username = db.Column(db.String(20), index=True, comment='用户名)')
password = db.Column(db.String(32), comment='密码')
email = db.Column(db.String(60), comment='email')
#salt = db.Column(db.String(50), comment='加密盐')
createTime = db.Column(db.DateTime,
default=datetime.datetime.now,
comment='创建时间')
#lastTime = db.Column(db.DateTime, comment='最后登陆时间')
user_role = db.relationship('UserRole',
foreign_keys=[UserRole.user_id],
backref=db.backref('f_user_role',
lazy='joined'),
lazy='dynamic')
#real_name = db.Column(db.String(50), comment='姓名')
sensor_visable = db.Column(db.Boolean, default=True, comment='传感器是否可见')
ins = db.relationship('Ins',
secondary=t_user_ins,
backref=db.backref('f_ins', lazy='dynamic'),
lazy='dynamic')
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True) # 编号
name = db.Column(db.String(100), unique=True) # 昵称
pwd = db.Column(db.String(100)) # 密码,使用哈希密码
email = db.Column(db.String(100), unique=True) # 邮箱
phone = db.Column(db.String(11), unique=True) # 手机号码
info = db.Column(db.Text) # 个性简介
face = db.Column(db.String(255), unique=True) # 头像
addtime = db.Column(db.DateTime, index=True, default=datetime.now) # 注册时间
uuid = db.Column(db.String(255), unique=True) # 唯一标志符
userlogs = db.relationship('Userlog', backref='user') # 会员日志外键关系关联
comments = db.relationship('Comment', backref='user') # 评论外键关系关联
moviecols = db.relationship('Moviecol', backref='user') # 收藏外键关系关联
def __repr__(self):
return "<User %r>" % self.name
@property
def password(self):
return self.pwd
# 使用user.password='******'设置时存入生成的散列密码
@password.setter
def password(self, new_password):
self.pwd = generate_password_hash(new_password)
def check_pwd(self, try_password):
return check_password_hash(self.pwd, try_password)
class Comment(Base):
__tablename__ = 'comments'
id = Column(Integer, primary_key=True)
content = Column(Text)
created = Column(DateTime, default=datetime.now)
commenter_name = Column(String(64))
commenter_email = Column(String(64))
# 头像相关
avatar_hash = Column(String(32))
article_id = Column(Integer, ForeignKey('articles.id'))
disabled = Column(Boolean, default=False)
comment_type = Column(db.String(64), default='comment')
reply_to = Column(String(128), default='notReply')
followed = db.relationship('Follow',
foreign_keys=[Follow.follower_id],
backref=db.backref('follower', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
followers = db.relationship('Follow',
foreign_keys=[Follow.followed_id],
backref=db.backref('followed', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
@property
def replys(self):
return [i.follower for i in self.followers]
# 根据email 生成图像
def __init__(self, **kwargs):
super(Comment, self).__init__(**kwargs)
if self.commenter_email is not None and self.avatar_hash is None:
self.avatar_hash = hashlib.md5(
self.commenter_email.encode('utf-8')).hexdigest()
def gravatar(self, size=40, default='identicon', rating='g'):
if request.is_secure:
url = 'https://secure.gravatar.com/avatar'
else:
url = 'http://www.gravatar.com/avatar'
hash = self.avatar_hash or hashlib.md5(
self.commenter_email.encode('utf-8')).hexdigest()
return '{url}/{hash}?s={size}&d={default}&r={rating}'.format(
url=url, hash=hash, size=size, default=default, rating=rating)
def followed_name(self):
if self.is_reply():
return self.followed.first().followed.commenter_name
def __repr__(self):
return '<Comment %r>' % self.id
def __str__(self):
return self.id
class Shop(db.Model):
sid = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), index=True, unique=True, nullable=True)
# 建立外键关联字段 可以使用表名.字段 也可以使用类名.属性
# cid = db.Column(db.Integer, db.ForeignKey(Cate.cid))
# 只是单纯建立外键关系
cid = db.Column(db.Integer, db.ForeignKey('cate.cid'))
# 如果想建立关系 也就是说想通过子表查询出
cate = db.relationship('Cate', back_populates='shops')
detail = db.relationship('Detail', backref='shop', uselist=False)
class FacilityIns(db.Model):
__tablename__ = 'facility_ins'
id = db.Column(db.String(24), default=objectid, primary_key=True)
facility_id = db.Column(db.String(24),
db.ForeignKey('facility.id'),
comment='设施id')
facility = db.relationship('Facility')
ins_id = db.Column(db.String(24), db.ForeignKey('ins.id'), comment='机构id')
ins = db.relationship('Ins')
note = db.Column(db.String(200), comment='备注')
count = db.Column(db.Integer, comment='设施数量')
expire_time = db.Column(db.DateTime, comment='过期时间')
class UserRole(db.Model):
__tablename__ = 'user_role'
id = db.Column(db.String(24), default=objectid, primary_key=True)
user_id = db.Column(db.String(24), db.ForeignKey('user.id'), index=True)
role_id = db.Column(db.String(24), db.ForeignKey('role.id'), index=True)
disable = db.Column(db.Boolean, nullable=False, default=False)
role = db.relationship('Role',
backref=db.backref('f1_role', lazy='dynamic'),
lazy='joined')
user = db.relationship('User',
backref=db.backref('f1_user', lazy='dynamic'),
lazy='joined')
class Category(Base):
__tablename__ = 'categories'
id = Column(Integer, primary_key=True)
order = Column(Integer)
name = Column(String(128), unique=True)
parent_id = Column(Integer(), ForeignKey('categories.id'))
# parent = db.relationship('Category',
# primaryjoin='Category.parent_id == Category.id',
# remote_side=id, backref=db.backref("children"))
introduction = Column(Text, default=None)
articles = db.relationship('Article', backref='category', lazy='dynamic')
# 设置默认排序使用
__mapper_args__ = {'order_by': [name]}
# 用于在主页面点击类别 定位到那个类别
@property
def link(self):
return url_for('web.category', id=self.id, _external=True)
@property
def count(self):
ls = db.session.query(Category.id).all()
cate_ids = [cate_id for cate_id in ls]
return Article.query.public().filter(
Article.category_id.in_(cate_ids)).count()
def __repr__(self):
return '<Category %r>' % self.name
def __str__(self):
return self.name
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer(), autoincrement=True, primary_key=True)
name = db.Column(db.String(64))
login = db.Column(db.String(64), unique=True)
password = db.Column(db.String(255))
is_active = db.Column(db.Boolean(), server_default=expression.text('True'), nullable=False) # 这里使用 expression.true() 似乎不起作用
roles = db.relationship(
'Role',
secondary=users_roles,
backref=db.backref('users', lazy='dynamic')
)
def set_password(self, password):
return pbkdf2_sha256.hash(password)
def check_password(self, password):
return pbkdf2_sha256.verify(password, self.password)
def is_authenticated(self):
return not isinstance(self, AnonymousUserMixin)
def is_anonymous(self):
return isinstance(self, AnonymousUserMixin)
def get_id(self):
return self.id
def __repr__(self):
return '<Model User {}>'.format(self.name)
class SensorAlarm(db.Model):
__tablename__ = 'sensor_alarm'
id = db.Column(db.String(24),
default=objectid,
primary_key=True,
comment='')
sensor_id = db.Column(db.String(24),
db.ForeignKey('sensor.id'),
comment='网关id')
sensor = db.relationship('Sensor')
gateway_id = db.Column(db.String(24),
db.ForeignKey('gateway.id'),
comment='关联网关id')
note = db.Column(db.String(255), comment='报警内容')
sensor_type = db.Column(db.Integer,
comment='传感器类型 (0.烟雾 1.温度 2.燃气 3.电流,4)')
var_type = db.Column(db.String(24), comment='变量类型')
unit = db.Column(db.String(24), comment='变量单位')
alarm_value = db.Column(db.String(24), comment='报警数值')
alarm_time = db.Column(db.DateTime,
default=datetime.datetime.now(),
comment='报警时间')
#confirm_time = db.Column(db.DateTime, comment='确认时间')
is_timeout = db.Column(db.Boolean, default=False, comment='是否超时')
# user_id = db.Column(db.String(24), db.ForeignKey('user.id'), comment='确认人id')
# user = db.relationship('User')
is_confirm = db.Column(db.Boolean, default=False, comment='是否确认')
class Stream(db.Model):
id = db.Column(db.Integer, auto_increment=True, primary_key=True)
name = db.Column(db.String(255), nullable=False)
stream_url = db.Column(db.String(255), nullable=True)
stream_type = db.Column(db.String(255), nullable=False)
stream_file = db.Column(db.LargeBinary, nullable=True)
plates = db.relationship("Plate", backref="stream", lazy='dynamic')
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False, index=True)
def __init__(self, name, stream_url, stream_type, stream_file, user_id):
self.name = name
self.stream_url = stream_url
self.stream_type = stream_type
self.stream_file = stream_file
self.user_id = user_id
def get_decoded_file(self):
return cv2.imdecode(np.frombuffer(self.stream_file, np.uint8), -1)
def to_json(self):
# decoded_file = self.stream_file.decode("utf-8", "ignore") if self.stream_file != None else self.stream_file
return {"id": self.id, "name": self.name, "stream_url": self.stream_url, "stream_type": self.stream_type, "owner": self.user_id}
def __repr__(self):
return '<Stream %r>' % self.id
class Home(db.Model):
__tablename__ = 'home'
id = db.Column(db.String(24), default=objectid, primary_key=True)
name = db.Column(db.String(255), comment='家庭名称')
community_id = db.Column(db.String(24),
db.ForeignKey('community.id'),
comment='社区id')
community = db.relationship('Community')
admin_user_id = db.Column(db.String(24),
db.ForeignKey('user.id'),
comment='创建者id')
detail_address = db.Column(db.String(255), comment='家庭地址')
link_name = db.Column(db.String(50), comment='主人姓名')
telephone = db.Column(db.String(50), comment='电话号码')
longitude = db.Column(db.Float(asdecimal=True), comment='经度')
latitude = db.Column(db.Float(asdecimal=True), comment='纬度')
alternate_phone = db.Column(db.String(50), comment='备用电话')
gateway_id = db.Column(db.String(50),
db.ForeignKey('gateway.id'),
comment='网关id')
disabled = db.Column(db.Boolean,
nullable=False,
default=False,
comment='是否可用')
class Note(Base):
"""
公告表
"""
__tablename__ = "notes"
content = db.Column(db.String(255), nullable=False, comment="公告内容")
level = db.Column(db.Integer(), default=0, comment="排序")
start_date = db.Column(db.Date(), default="", comment="起始时间")
end_date = db.Column(db.Date(), default="", comment="结束时间")
admin_id = db.Column(db.Integer(), db.ForeignKey('admins.id'))
admin = db.relationship('Admin', backref=db.backref('notes', lazy="dynamic"))
@classmethod
def _query_search(cls, query, _keyword):
if _keyword is not None:
keyword = '%' + str(_keyword) + '%'
return query.filter(or_(cls.content.like(keyword), ))
return query
def create(self, data):
with db.auto_commit():
self.set_attrs(data)
self.active = 1
self.admin = current_user
self.created_at = time_now()
self.updated_at = time_now()
db.session.add(self)
class Sensor(db.Model):
__tablename__ = 'sensor'
id = db.Column(db.String(24), default=objectid, primary_key=True)
gateway_id = db.Column(db.String(24),
db.ForeignKey('gateway.id'),
comment='网关id')
gateway = db.relationship('Gateway')
set_type = db.Column(db.String(24),
default='0',
comment='0:不设定，1:自设定，2:智能设定')
online = db.Column(db.Boolean, comment='是否在线')
sensor_place = db.Column(db.String(255), comment='位置')
sensor_type = db.Column(db.Integer,
comment='传感器类型 (0.烟雾,1.温度 2.燃气 3.智能插座,4.电磁阀)')
max_value = db.Column(db.Float, comment='阈值')
alarms_history = db.relationship('SensorAlarm', lazy='dynamic')
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
users = db.relationship('User', backref='role') #反向引用查询管联，一对一时 uselist=False
def __repr__(self):
return '<Role %r>' % self.name
class P2P(db.Model):
__tablename__ = "p2p"
def __init__(self, name, url, funds_deposit, risk_deposit):
self.name = name
self.url = url
self.funds_deposit = funds_deposit
self.risk_deposit = risk_deposit
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), unique=True) #平台名称
url = db.Column(db.String(255), unique=True) #平台URL
funds_deposit = db.Column(db.Boolean, default=False) #资金存管
risk_deposit = db.Column(db.Boolean, default=False) #风险金存管
invests = db.relationship('Invest', backref="p2p") #投资记录外键关联关系
userp2ps = db.relationship('UserP2P', backref="p2p") #用户平台外键关联关系
billflows = db.relationship("BillFlow", backref="p2p") #资金流水外键关联关系
class Grade(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(40))
# 对应的学生(不会生成字段，只是为了声明)
# db.relationship('关系模型类', backref='当前模型表名')
# db.relationship('关系模型类', backref='当前模型表名', lazy=True)
students = db.relationship('Student', backref='grade', lazy=True)
class Admin(db.Model):
__tablename__ = "admin"
__table_args__ = {"useexisting": True}
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 Tag(db.Model):
__tablename__ = "tag"
id = db.Column(db.Integer, primary_key=True) # 编号
name = db.Column(db.String(100), unique=True) # 标题
addtime = db.Column(db.DateTime, index=True, default=datetime.now) # 添加时间
movies = db.relationship("Movie", backref='tag') # 电影外键关系关联
def __repr__(self):
return "<Tag %r>" % self.name
class Role(db.Model):
role_id = db.Column(db.Integer, primary_key=True)
role_name = db.Column(db.String(64), nullable=False, index=True, unique=True)
desc = db.Column(db.Text)
permissions = db.relationship('Permission', secondary=relation)
def __init__(self, role_name, desc):
self.role_name = role_name
self.desc = desc
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 Role(db.Model):
__tablename__ = 'role'
id = db.Column(db.String(24), default=objectid, primary_key=True)
name = db.Column(db.String(30), nullable=False)
disabled = db.Column(db.Boolean,
nullable=False,
default=True,
comment='是否可用')
description = db.Column(db.String(60), comment='权限描述')
user_role = db.relationship('UserRole',
foreign_keys=[UserRole.role_id],
backref=db.backref('F_user_role',
lazy='joined'),
lazy='dynamic')
menus = db.relationship('Menu',
secondary=t_role_menu,
backref=db.backref('role_menus', lazy='dynamic'),
lazy='dynamic')
class Menu(db.Model):
__tablename__ = 'menu'
id = db.Column(db.String(24), default=objectid, primary_key=True)
p_id = db.Column(db.String(24), db.ForeignKey('menu.id'), comment='父id')
children = db.relationship("Menu")
parent = db.relationship("Menu", remote_side=[id])
label = db.Column(db.String(20), nullable=False, comment='标签')
level = db.Column(db.SmallInteger, comment='层级')
type = db.Column(db.SmallInteger, comment='类型')
style = db.Column(db.String(50), comment='样式')
disabled = db.Column(db.Boolean, default=False, comment='是否可用')
roles = db.relationship('Role',
secondary=t_role_menu,
backref=db.backref('menu_roles', lazy='dynamic'),
lazy='dynamic')
path = db.Column(db.String(200), comment='和url什么区别???')
order = db.Column(db.SmallInteger, comment='?????')
url = db.Column(db.String(200), comment='和path什么区别???')
class Shop(db.Model):
shop_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(512), index=True)
sub_title = db.Column(db.String(512), index=True)
original_price = db.Column(db.Integer)
promote_price = db.Column(db.Integer)
stock = db.Column(db.Integer)
cate_id = db.Column(db.Integer, db.ForeignKey('cate.cid'))
create_date = db.Column(db.DateTime)
cate = db.relationship('Cate', back_populates='shops')
class Role(Base):
"""
角色表
"""
__tablename__ = "roles"
name = db.Column(db.String(length=20), nullable=False, comment="角色名", unique=True)
label = db.Column(db.String(length=50), nullable=False, comment="角色介绍", unique=True)
permissions = db.relationship('Permission', backref="roles", lazy="dynamic", secondary=role_permission)
@staticmethod
def get_menu_for_role():
return Menu.query.filter_by().filter(Menu.active == 1, Menu.pid > 0).order_by(Menu.level.asc()).all()
def _get_permissions(self, ids):
return Permission.query.filter_by().filter(Permission.id.in_(ids),
Permission.active == 1).all()
def create(self, data):
permission_ids = request.form.getlist('permissions[]')
# 添加时把权限添加进去
with db.auto_commit():
self.set_attrs(data)
self.active = 1
self.created_at = time_now()
self.updated_at = time_now()
if permission_ids:
self.permissions = self._get_permissions(permission_ids)
db.session.add(self)
def update(self, data, edit_one_field=None):
"""
edit_one_field 是否表内单个编辑 标识
:param data:
:param flag:
:return:
"""
permission_ids = request.form.getlist('permissions[]')
# 添加时把权限添加进去
with db.auto_commit():
if not edit_one_field:
self.set_attrs(data)
self.permissions = self._get_permissions(permission_ids)
else:
self.set_attr(data)
@classmethod
def _query_search(cls, query, _keyword):
if _keyword is not None:
keyword = '%' + str(_keyword) + '%'
return query.filter(or_(cls.name.like(keyword), cls.label.like(keyword)))
return query
