def is_in_scope(admin_id, path):
'''
路由权限判断
'''
s = db.session()
try:
admin = s.query(Admin).filter(Admin.admin_id == admin_id).first()
if not admin:
return str('管理员不存在')
if not admin.isLock:
return str('管理员被禁用')
role = s.query(Role).filter(Role.id == admin.role_id).first()
route = []
if role:
for i in role.routes:
route.append(i.to_json())
for i in route:
if i['path'] == path:
return True
return False
except Exception, e:
print e
return False
def CreateLogRequest(self, params):
'''
新建日志
'''
try:
s = db.session()
if not params['username']:
return True
type = 0
if params['path'] == '/v1/Admin/Login':
type = 1
if str(params['content']) == '管理员被禁用':
params['status'] = 2
item = Log(
ip=params['ip'],
method=params['method'],
path=params['path'],
username=params['username'],
status=params['status'],
time=params['time'],
content=str(params['content']),
params=str(params['params']),
type=type
)
s.add(item)
s.commit()
return True
except Exception, e:
print e
return False
def __init_menus(self, data, parentId, role_id):
s = db.session()
for m in data:
menu_id = uuid.uuid4()
menu = self.__create_menu(m, menu_id, parentId)
if m.has_key('interface'):
interfaces = []
for f in m['interface']:
interface = self.__create_interface(f, uuid.uuid4(), menu_id)
s.add(interface)
s.commit()
interfaces.append(interface)
menu.interfaces = interfaces
s.add(menu)
role = s.query(Role).filter(Role.role_id == role_id).first()
menus = []
for i in role.menus:
menus.append(i)
menus.append(menu)
role.menus = menus
s.commit()
if m.has_key('children'):
self.__init_menus(m['children'], menu_id, role_id)
def CreateAdminRequest(self, params):
'''
新建管理员
'''
s = db.session()
try:
if params['role_id'] == 1:
return str('不能设为为超级管理员')
admin = s.query(Admin).filter(Admin.username == params['username']).first()
if admin:
return str('管理员已存在')
item = Admin(
admin_id=uuid.uuid4(),
username=params['username'],
password=Config().get_md5(params['password']),
sex=int(params['sex']),
nickname=params['nickname'],
role_id=int(params['role_id']),
avatarUrl=params['avatarUrl']
)
s.add(item)
s.commit()
return True
except Exception as e:
s.rollback()
print e
return str(e.message)
def is_in_scope(admin_id, path):
'''
路由权限判断
'''
s = db.session()
try:
admin = s.query(Admin).filter(Admin.admin_id == admin_id).first()
if not admin:
return str('管理员不存在')
if admin.is_disabled:
return str('管理员被禁用')
role = s.query(Role).filter(Role.role_id == admin.role_id,
Role.is_disabled == False).first()
if role:
i = role.interfaces.filter(Interface.is_disabled == False,
Interface.path == path)
if i:
return True
m = role.menus.filter(Menu.is_disabled == False, Menu.path == path)
if m:
return True
r = s.query(Route).filter(Route.path == path,
Route.is_disabled == False).first()
if r:
return True
return False
except Exception, e:
print e
return False
def ModifyRoleRequest(self, role_id, params):
'''
修改权限信息
'''
s = db.session()
try:
role = s.query(Role).filter(Role.role_id == role_id).first()
if not role:
return str('数据不存在')
route = s.query(Route).filter(
Route.route_id.in_(params['route_id'])).all()
menu = s.query(Menu).filter(Menu.menu_id.in_(
params['menu_id'])).all()
role.name = params['name']
role.checkKey = params['checkKey']
role.routes = route
role.menus = menu
s.commit()
return True
except Exception as e:
print e
s.rollback()
return str(e.message)
def QueryDocumentByParamRequest(self,
params,
page=1,
page_size=20,
order_by='create_time'):
'''
文档列表
'''
s = db.session()
try:
Int = ['type', 'deleted', 'folder_id']
data = {}
for i in Int:
if params.has_key(i):
data[i] = params[i]
result = Document.query.filter_by(**data).filter(
Document.name.like("%" + params['name'] + "%") if params.
has_key('name') else text('')).order_by(order_by).paginate(
page, page_size, error_out=False)
return {
'data': [value.to_json() for value in result.items],
'total': result.total
}
except Exception as e:
print e
return str(e.message)
def ModifyInterfaceRequest(self, interface_id, params):
'''
修改接口信息
'''
s = db.session()
try:
interface = s.query(Interface).filter(
Interface.interface_id == interface_id).first()
if not interface:
return str('接口不存在')
AllowableFields = [
'name', 'path', 'method', 'description', 'menu_id'
]
data = {}
for i in params:
if i in AllowableFields and params.has_key(i):
data[i] = params[i]
s.query(Interface).filter(
Interface.interface_id == interface_id).update(data)
s.commit()
return True
except Exception as e:
print e
s.rollback()
return str(e.message)
def QueryDocumentByParamRequest(self,
params,
page=1,
page_size=20,
order_by='create_time'):
'''
文档列表
'''
s = db.session()
try:
deleted = Document.deleted == (True if params['deleted'] == 'true'
else False)
folder = Document.folder_id == params['folder_id']
if params['folder_id'] == '0':
folder = or_(Document.folder_id == params['folder_id'],
Document.folder_id == None)
status = text('')
if params.has_key('status'):
status = Document.status == int(params['status'])
result = Document.query.filter(folder, deleted,
status).order_by(order_by).paginate(
page,
page_size,
error_out=False)
return {
'data': [value.to_json() for value in result.items],
'total': result.total
}
except Exception as e:
print e
return str(e.message)
def QueryAdminByParamRequest(self,
params,
page=1,
page_size=20,
order_by='id'):
'''
管理员列表
'''
s = db.session()
try:
data = {}
for i in ['role_id', 'isLock']:
if params.has_key(i):
data[i] = params[i]
result = Admin.query.filter_by(**data).order_by(order_by).paginate(
page, page_size, error_out=False)
return {
'data': [value.to_json() for value in result.items],
'total': result.total
}
except Exception as e:
print e
return str(e.message)
def CreateDocumentRequest(self, file, params):
'''
新建文档
'''
s = db.session()
try:
# 上传
file_name = file.filename
ext = self.file_extension(file_name)
size = len(file.read())
file.seek(0)
fn = '/' + str(time.strftime('%Y/%m/%d'))
if not os.path.exists(document_dir + fn):
os.makedirs(document_dir + fn)
path = fn + '/' + str(uuid.uuid1()) + '.' + ext
file.save(document_dir + path)
item = Document(document_id=uuid.uuid4(),
admin_id=params['admin_id'],
name=file_name,
type=params['type'],
ext=ext,
path=path,
size=size)
s.add(item)
s.commit()
return path
except Exception as e:
s.rollback()
print e
return str(e.message)
def GetAdminRequest(self, username, password):
'''
查询管理员
'''
s = db.session()
try:
admin = s.query(Admin).filter(Admin.username == username, Admin.password == Config().get_md5(password)).first()
if not admin:
return str('管理员不存在')
if not admin.isLock:
return str('管理员被禁用')
data = admin.to_json()
route = []
menu = []
interface = []
role = s.query(Role).filter(Role.id == admin.role_id).first()
if role:
for i in role.routes:
route.append(i.to_json())
for i in role.menus:
menu.append(i.to_json())
interfaces = s.query(Interface).filter(Interface.menu_id == i.menu_id).all()
interface = interface + [i.to_json() for i in interfaces]
data['routes'] = route
data['menus'] = menu
data['interface'] = interface
return data
except Exception as e:
print e
return str(e.message)
def ModifyRouteRequest(self, route_id, params):
'''
修改路由信息
'''
s = db.session()
try:
route = s.query(Route).filter(Route.route_id == route_id).first()
if not route:
return str('路由不存在')
AllowableFields = [
'parent_id', 'name', 'path', 'title', 'component',
'componentPath', 'cache'
]
data = {}
for i in params:
if i in AllowableFields and params.has_key(i):
data[i] = params[i]
s.query(Route).filter(Route.route_id == route_id).update(data)
s.commit()
return True
except Exception as e:
print e
s.rollback()
return str(e.message)
def CreateDropRequest(self):
try:
db.drop_all()
db.create_all()
s = db.session()
admin = Admin(
admin_id=uuid.uuid4(),
username=u'Admin',
password=Config().get_md5('123456'),
avatarUrl='',
role_id=1
)
s.add(admin)
s.commit()
role_id = uuid.uuid4()
role = Role(role_id=role_id, name=u'超级管理员', checkKey='[]')
s.add(role)
s.commit()
self.__init_routes(init_route, '0', role_id)
self.__init_menus(init_menu, '0', role_id)
return True
except Exception as e:
print e
return str(e.message)
def ModifyAdminRequest(self, admin_id, params):
'''
修改管理员信息
'''
s = db.session()
try:
if params['role_id'] == 1:
return str('不能设为为超级管理员')
admin = s.query(Admin).filter(Admin.admin_id == admin_id).first()
if not admin:
return str('管理员不存在')
if not admin.isLock:
return str('管理员被禁用')
AllowableFields = ['password', 'nickname', 'sex', 'role_id', 'avatarUrl']
data = {}
for i in params:
if i in AllowableFields and params.has_key(i):
data[i] = params[i]
s.query(Admin).filter(Admin.admin_id == admin_id).update(data)
s.commit()
return True
except Exception as e:
print e
s.rollback()
return str(e.message)
def LockMenuRequest(self, menu_id, isLock):
'''
禁用菜单
'''
s = db.session()
try:
menu = s.query(Menu).filter(Menu.menu_id == menu_id).first()
if isLock:
parent = s.query(Menu).filter(Menu.menu_id == menu.parent_id,
Menu.isLock == False).first()
if parent:
return str('父菜单处于禁用状态, 该菜单不能启用')
menu.isLock = isLock
s.commit()
if not isLock:
s.query(Menu).filter(Menu.parent_id == menu_id,
Menu.isLock == True).update(
{Menu.isLock: False})
s.commit()
return True
except Exception as e:
print e
s.rollback()
return str(e.message)
def ModifyMenuRequest(self, menu_id, params):
'''
修改菜单信息
'''
s = db.session()
try:
menu = s.query(Menu).filter(Menu.menu_id == menu_id).first()
if not menu:
return str('菜单不存在')
AllowableFields = [
'parent_id', 'title', 'path', 'icon', 'sort', 'type'
]
data = {}
for i in params:
if i in AllowableFields and params.has_key(i):
data[i] = params[i]
s.query(Menu).filter(Menu.menu_id == menu_id).update(data)
s.commit()
return True
except Exception as e:
print e
s.rollback()
return str(e.message)
def checkDb():
try:
s = db.session()
res = s.query(InitSql).first()
return res.isInit
except Exception as e:
return str('数据库未连接或者其他错误请查看错误信息：' + e.message)
def is_in_scope(admin_id, path):
'''
路由权限判断
'''
s = db.session()
try:
admin = s.query(Admin).filter(Admin.admin_id == admin_id).first()
if not admin:
return str('管理员不存在')
if not admin.isLock:
return str('管理员被禁用')
role = s.query(Role).filter(Role.id == admin.role_id,
Role.isLock == True).first()
if role:
route = role.routes.filter(Route.isLock == True,
Route.path == path)
if route:
return True
else:
interface = role.menus.join(Interface).filter(
Menu.isLock == True, Interface.path == path)
if interface:
return True
return False
except Exception, e:
print e
return False
def DelFolderRequest(self, folder_id, isFolder=True):
'''
删除文件夹
isFolder True：删除关联文件夹 False：关联文件夹移到根目录
关联文档默认到根目录
'''
s = db.session()
try:
folder = s.query(Folder).filter(
Folder.folder_id == folder_id).first()
if not folder:
return str('文件夹不存在')
folder_list = s.query(Folder).filter(
Folder.parent_id == folder_id).all()
if not isFolder:
for i in folder_list:
s.query(Document).filter(
Document.folder_id == i.folder_id).update(
{Document.folder_id: '0'})
folder_list.update({Folder.parent_id: '0'})
else:
folder_list.delete()
s.commit()
return True
except Exception as e:
print e
s.rollback()
return str(e.message)
def QueryInterfaceByParamRequest(self,
params,
page=1,
page_size=20,
order_by='id'):
'''
接口列表
'''
s = db.session()
try:
Int = ['menu_id', 'isLock', 'method']
data = {}
for i in Int:
if params.has_key(i):
data[i] = params[i]
result = Interface.query.filter_by(**data).filter(
Interface.name.like("%" + params['name'] + "%") if params.
has_key('name') else '').order_by(order_by).paginate(
page, page_size, error_out=False)
data = []
for value in result.items:
data.append(value.to_json())
return {'data': data, 'total': result.total}
except Exception as e:
print e
return str(e.message)
def __init_routes(self, data, pid):
s = db.session()
for r in data:
route_id = uuid.uuid4()
route = self.__create_route(r, route_id, pid)
s.add(route)
s.commit()
if r.has_key('children'):
self.__init_routes(r['children'], route_id)
def before_first_request():
# 运行models，以创建不存在的表
try:
db.create_all()
s = db.session()
res = s.query(InitSql).first()
if not res:
s.add(InitSql(isInit=False))
s.commit()
except:
return ResultDeal(code=-1, msg=u'数据库未连接错误或者出现错误')
def QueryFolderByParamRequest(self):
'''
文件夹列表
'''
s = db.session()
try:
result = Folder.query.order_by(Folder.id).all()
return [value.to_json() for value in result]
except Exception as e:
print e
return str(e.message)
def GetMenuToInterfaceRequest(self, menu_id):
'''
获取菜单下级联的API接口
'''
s = db.session()
try:
menu = s.query(Menu).filter(Menu.menu_id == menu_id).first()
return [i.to_json() for i in menu.interfaces]
except Exception as e:
print e
s.rollback()
return str(e.message)
def LockAdminRequest(self, admin_id, is_disabled):
'''
禁用管理员
'''
s = db.session()
try:
s.query(Admin).filter(Admin.admin_id.in_(admin_id)).update({Admin.is_disabled: is_disabled}, synchronize_session=False)
s.commit()
return True
except Exception as e:
print e
s.rollback()
return str(e.message)
def LockRouteRequest(self, route_id, is_disabled):
'''
禁用路由
'''
s = db.session()
try:
s.query(Route).filter(Route.route_id.in_(route_id)).update({Route.is_disabled: is_disabled}, synchronize_session=False)
s.commit()
return True
except Exception as e:
print e
s.rollback()
return str(e.message)
def LockInterfaceRequest(self, interface_id, isLock):
'''
禁用接口
'''
s = db.session()
try:
s.query(Interface).filter(Interface.interface_id.in_(interface_id)).update({Interface.isLock: isLock}, synchronize_session=False)
s.commit()
return True
except Exception as e:
print e
s.rollback()
return str(e.message)
def LockRoleRequest(self, role_id, isLock):
'''
禁用权限
'''
s = db.session()
try:
s.query(Role).filter(Role.role_id.in_(role_id)).update(
{Role.isLock: isLock})
s.commit()
return True
except Exception as e:
print e
s.rollback()
return str(e.message)
def GetInterfaceRequest(self, interface_id):
'''
查询接口
'''
s = db.session()
try:
interface = s.query(Interface).filter(Interface.interface_id == interface_id).first()
if not interface:
return str('接口不存在')
return interface.to_json()
except Exception as e:
print e
return str(e.message)
