修复接口

whycxzp

2021-07-26 8c189b243bfbbacb2ab1ce79f4e1ff22708f125a

 src/main/java/com/whyc/service/RoleMenuService.java

@@ -1,16 +1,22 @@
package com.whyc.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.extension.api.R;
import com.google.common.collect.Sets;
import com.whyc.dto.Response;
import com.whyc.mapper.MenuMapper;
import com.whyc.mapper.RoleMenuMapper;
import com.whyc.pojo.Menu;
import com.whyc.pojo.RoleMenu;
import org.apache.commons.compress.utils.Lists;
import org.apache.commons.lang3.math.NumberUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;

/**
 * 角色-菜单
@@ -33,6 +39,23 @@
        return menus;
    }

    public Response updateRoleMenu(int roleId,int[] menuIds){
        QueryWrapper<RoleMenu> queryWrapper = new QueryWrapper<RoleMenu>().eq("role_id",roleId);
        mapper.delete(queryWrapper);
        List<RoleMenu> roleMenus = new ArrayList<>();
        for (int menuId:menuIds) {
            RoleMenu roleMenu = new RoleMenu();
            roleMenu.setRoleId(roleId);
            roleMenu.setMenuId(menuId);
            roleMenus.add(roleMenu);
        }
        if (mapper.insertBatchSomeColumn(roleMenus)==roleMenus.size()){
            return new Response().setMsg(1,"更新成功");
        }else {
            return new Response().setMsg(0,"更新失败");
        }
    }

    public List<Menu> getRoleMenu(Integer roleId){
        List<Menu> menus = menuMapper.selectList(null);
        QueryWrapper<RoleMenu> queryWrapper = new QueryWrapper<>();
@@ -46,21 +69,98 @@
                }
            }
        }
        menus = getTree(menus);

        return menus;
    }

    public void updateRoleMenu(int roleId,List<Menu> menus){
        QueryWrapper<RoleMenu> queryWrapper = new QueryWrapper<RoleMenu>().eq("role_id",roleId);
        mapper.delete(queryWrapper);
        for (Menu menu:menus) {
            if(menu.isSelected()){
                RoleMenu roleMenu = new RoleMenu();
                roleMenu.setMenuId(menu.getId());
                roleMenu.setRoleId(roleId);
                mapper.insert(roleMenu);
    public List<Menu> getTree(List<Menu> list) {

        List<Menu> baseLists = new ArrayList<>();
        // 总菜单，出一级菜单，一级菜单没有父id
        for (Menu e: list) {
            if( e.getMenuId()==0 ){
                baseLists.add( e );
            }
        }
        // 遍历一级菜单
        for (Menu e: baseLists) {
            // 将子元素 set进一级菜单里面
            e.setSubMenus( getChild(e.getId(),list) );
        }

        return baseLists;
    }
    /**
     * 获取子节点
     * @param MenuId
     * @param Menus
     * @return
     */
    private List<Menu> getChild(Integer MenuId , List<Menu> Menus){
        List<Menu> childs = new ArrayList<>();
        for (Menu e: Menus) {
            if(e.getMenuId()!=0){
                if(e.getMenuId().equals( MenuId )){
                    // 子菜单的下级菜单
                    childs.add( e );
                }
            }
        }
        // 把子菜单的子菜单再循环一遍
        for (Menu e: childs) {
            // 继续添加子元素
            e.setSubMenus( getChild( e.getId() , Menus ) );
        }

        //停下来的条件，如果 没有子元素了，则停下来
        if( childs.size()==0 ){
            return null;
        }
        return childs;
    }



    public List<Menu> tree(int level){
        //非顶级菜单集合
        List<Menu> menuList = menuMapper.selectList(new QueryWrapper<Menu>().ne("menu_id",0));
        //顶级菜单
        List<Menu> topList = menuMapper.selectList(new QueryWrapper<Menu>().eq("menu_id",0));
        if (ObjectUtils.isNotNull(menuList)){
            //过滤条件set，指定set预期大小为非顶级菜单集合的size
            Set<Integer> set = Sets.newHashSetWithExpectedSize(menuList.size());
            //循环顶级菜单插入子菜单
            topList.forEach(menu-> getSubMenu(menu,menuList,level,set));
            return topList;
        }
        return null;
    }

    public void getSubMenu(Menu menu,List<Menu> menuList,int level,Set<Integer> set){
        //过滤树的深度等级
        if (menu.getLevel() < level || level==0){
            List<Menu> subList = Lists.newArrayList();
            menuList.stream()
                    //判断是否循环过当前对象
                    .filter(c->!set.contains(c.getId()))
                    //判断是否存在父子关系
                    .filter(c-> NumberUtils.compare(c.getMenuId(),menu.getId())==0)
                    //set集合大小不超过menuList的大小
                    .filter(c-> set.size() <= menuList.size())
                    .forEach(c->{
                        set.add(c.getId());
                        getSubMenu(c,menuList,level,set);
                        subList.add(c);
                    });
            menu.setSubMenus(subList);

        }
    }