Flask学习「一」（按钮,角色,菜单,用户,权限）

user_role_model = api.model('RoleUserRole', {
 'role_id_list': fields.String('role id list 以逗号隔开","'),
 'user_id': fields.Integer
 })

@api.route('/role_by_user')

class RoleByUser(Resource):
 @api.expect(page_parser)
 ‘’‘
 查询已经分配过角色的用户 以用户为主体
 ’‘’
 def get(self):
 # 自定义验证传入参数是否合法
 form = RoleByUserForm().validate_for_api()
 #实现代码模块化 将可复用查询条件拆分出来 放在最后定义成了一个单独的方法
 task_filter = _form_and_task(form)
 user_id = form.user_id.data
 # 增加查询条件
 task_filter.append(UserRole.user_id == user_id)
 page = Role.query.outerjoin(UserRole, Role.id == UserRole.role_id) 
 # task_filter为可变参数，可以传入元组/列表
 .filter(task_filter).order_by(
 # sqlalchemy根据创建时间排序
 text('role.create_time desc')
 # paginate()分页对象 传入定义号的页数
 ).paginate()
 return Role().page(page)
@api.route('/role_by_not_user')
 class RoleByNotUser(Resource):
 # 和上面的类似 查询未分配角色的用户
 @api.expect(page_parser)
 def get(self):
 form = RoleByUserForm().validate_for_api()
 task_filter = _form_and_task(form)
 user_id = form.user_id.data
 # UserRole.user_id != user_id 查询未分配角色的用户
 task_filter.append(UserRole.user_id != user_id)
 page = Role.query.outerjoin(UserRole, Role.id == UserRole.role_id) 
 .filter(*task_filter).order_by(
 text('role.create_time desc')
 ).paginate()
 return Role().page(page)
 # 新增 一个用户可能对应多个角色 传入role_id_list
 @api.expect(user_role_model)
 def post(self):
 form = RoleUserPostForm().validate_for_api()
 user_id, role_id_list = form.user_id.data, form.role_id_list.data
 # 传入role_id_list使用“,”分开 使用split从每个“,”处分开
 if role_id_list:
 user_role_list = []
 role_id_list = role_id_list.split(',')
 # 遍历role_id_list 将每个role_id存入上面定义的user_role_list列表中
 # 调用我们自定义的save_all方法 将每个role_id存入UserRole表
 for role_id in role_id_list:
 user_role = UserRole()
 user_role.role_id = role_id
 user_role.user_id = int(user_id)
 user_role_list.append(user_role)
 UserRole().save_all(user_role_list)
’‘’
 权限设置
 ’‘’
 role_action_menu_parser = reqparse.RequestParser()
 role_action_menu_parser.add_argument('role_id', type=int, required=True, location='args')
menu_action_lists = api.model('RoleActionMenuList', {
 'mid': fields.Integer,
 'type': fields.Integer
 })

role_action_menu_model = api.model('RoleActionMenu', {
 'menu_action_list': fields.List(fields.Nested(menu_action_lists)),
 'role_id': fields.Integer
 })

menu_action_tree = namedtuple('MenuActionTree', ['id', 'name', 'parent_id', 'lay', 'is_select', 'has_child', 'type'])
@api.route('/role_action_menu')
 class RoleActionMenu(Resource):
 @api.expect(role_action_menu_parser)
 ‘’‘
 查询该角色所能查到的所有的菜单和按钮
 ’‘’
 def get(self):
 form = RoleIdForm().validate_for_api()
 role_id = form.role_id.data
 menus = Menu.query.filter().all()  # 菜单
 actions = Action.query.filter().all()  # 按钮
 # 通过自定义树形菜单和按钮列表，通过role_id查询拼接当前角色所能看到的菜单和按钮
 # 分别构造拼接菜单和按钮树形集合 并将菜单和按钮的树形合并
 menu_action_trees = _menu_tree(role_id, menus)
 menu_action_trees += _action_tree(role_id, actions, menus)
 # 通过自定义get_tree方法将最后合并好的数据集合转化为json传给前台
 tree = get_tree(menu_action_trees)
 return tree
 ‘’‘
 新增角色菜单和按钮
 ’‘’
 @api.expect(role_action_menu_model)
 def post(self):
 form = RoleMenuActionForm().validate_for_api()
 role_id, menu_action_list = form.role_id.data, form.menu_action_list.data
 # 过滤 区分菜单和按钮
 if menu_action_list:
 role_action = list(filter(lambda x: x['type'] == 1, menu_action_list))
 role_menu = list(filter(lambda x: x['type'] == 0, menu_action_list))
 # 使用自定义方法分别储存菜单和按钮到role_menu和role_action表
 with db.auto_commit():
 _save_menu(role_id, role_menu)
 _save_action(role_id, role_action)

def _save_menu(role_id, role_menu):
 # 每次在存之前我们先删除该角色之前存储过的菜单
 RoleMenu.query.filter_by(role_id=role_id).delete()
 new_role_menu = []
 # 遍历role_menu表 通过role_id将给该角色添加菜单
 for m in role_menu:
 role_menu = RoleMenu()
 role_menu.role_id = role_id
 role_menu.menu_id = m['mid']
 new_role_menu.append(role_menu)
 RoleMenu().save_all(new_role_menu)

def _save_action(role_id, role_action):
 # 和菜单一样 在新增之前我们要删除之前存储过的按钮
 RoleAction.query.filter_by(role_id=role_id).delete()
 new_role_action = []
 # 遍历role_acton表通过role_id将给该角色添加角色
 for m in role_action:
 role_action = RoleAction()
 role_action.role_id = role_id
 role_action.action_id = m['mid']
 new_role_action.append(role_action)
 RoleAction().save_all(new_role_action)

def _action_tree(role_id, actions, menus):
 menu_action_trees = []
 role_actions = RoleAction.query.filter(UserRole.role_id == role_id).all()
 for action in actions:
 action_parent = list(filter(lambda x: x.id == action.menu_id, menus))
 # 判断层级
 if len(action_parent) > 0:
 lay = action_parent[0].lay + 1
 else:
 lay = 0
 # 是否选中 1-选中 0-未选中
 is_select = [False for role_action in role_actions if role_action.action_id == action.id]
 if is_select:
 is_select = 1
 else:
 is_select = 0
 # 按照前面定义命名元组参数顺序按照顺序传入对应参数
 mct = menu_action_tree(
 str(action.id) + '

action分割
 action.name,
 action.menu_id,
 lay,
 is_select,
 0,  # 按钮是最后一级
 1  # 0-菜单 1-按钮
 )

    menu_action_trees.append(mct)
return menu_action_trees

def _menu_tree(role_id, menus):
 menu_action_trees = []
 role_menus = RoleMenu.query.filter(UserRole.role_id == role_id).all()
 for menu in menus:
 # 通过列表推导式判断有无选中
 is_select = [False for role_menu in role_menus if role_menu.menu_id == menu.id]
 if is_select:
 is_select = 1
 else:
 is_select = 0
 mct = menu_action_tree(
 menu.id,
 menu.name,
 menu.parent_id,
 menu.lay,
 is_select,
 0,  # 不好判断暂定为0
 0  # 0-菜单 1-按钮
 )

    menu_action_trees.append(mct)
return menu_action_trees

def _form_and_task(form):
 name = form.name.data
 task_filter = [
 Role.name.like('%' + name + '%') if name is not None else text(''),
 ]
 return task_filter