content: package com.ruoyi.system.service.impl;
  
  import java.text.MessageFormat;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.LinkedHashMap;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Service;
  import com.ruoyi.common.constant.UserConstants;
  import com.ruoyi.common.utils.StringUtils;
  import com.ruoyi.system.domain.SysMenu;
  import com.ruoyi.system.domain.SysRole;
  import com.ruoyi.system.domain.SysUser;
  import com.ruoyi.system.mapper.SysMenuMapper;
  import com.ruoyi.system.mapper.SysRoleMenuMapper;
  import com.ruoyi.system.service.ISysMenuService;
  
  /**
   * 菜单 业务层处理
   * 
   * @author ruoyi
   */
  @Service
  public class SysMenuServiceImpl implements ISysMenuService
  {
      public static final String PREMISSION_STRING = "perms[\"{0}\"]";
  
      @Autowired
      private SysMenuMapper menuMapper;
  
      @Autowired
      private SysRoleMenuMapper roleMenuMapper;
  
      /**
       * 根据用户查询菜单
       * 
       * @param user 用户信息
       * @return 菜单列表
       */
      @Override
      public List<SysMenu> selectMenusByUser(SysUser user)
      {
          List<SysMenu> menus = new LinkedList<SysMenu>();
          // 管理员显示所有菜单信息
          if (user.isAdmin())
          {
              menus = menuMapper.selectMenuNormalAll();
          }
          else
          {
              menus = menuMapper.selectMenusByUserId(user.getUserId());
          }
          return getChildPerms(menus, 0);
      }
  
      /**
       * 查询菜单集合
       * 
       * @return 所有菜单信息
       */
      @Override
      public List<SysMenu> selectMenuList(SysMenu menu)
      {
          return menuMapper.selectMenuList(menu);
      }
  
      /**
       * 查询菜单集合
       * 
       * @return 所有菜单信息
       */
      @Override
      public List<SysMenu> selectMenuAll()
      {
          return menuMapper.selectMenuAll();
      }
  
      /**
       * 根据用户ID查询权限
       * 
       * @param userId 用户ID
       * @return 权限列表
       */
      @Override
      public Set<String> selectPermsByUserId(Long userId)
      {
          List<String> perms = menuMapper.selectPermsByUserId(userId);
          Set<String> permsSet = new HashSet<>();
          for (String perm : perms)
          {
              if (StringUtils.isNotEmpty(perm))
              {
                  permsSet.addAll(Arrays.asList(perm.trim().split(",")));
              }
          }
          return permsSet;
      }
  
      /**
       * 根据角色ID查询菜单
       * 
       * @param role 角色对象
       * @return 菜单列表
       */
      @Override
      public List<Map<String, Object>> roleMenuTreeData(SysRole role)
      {
          Long roleId = role.getRoleId();
          List<Map<String, Object>> trees = new ArrayList<Map<String, Object>>();
          List<SysMenu> menuList = menuMapper.selectMenuAll();
          if (StringUtils.isNotNull(roleId))
          {
              List<String> roleMenuList = menuMapper.selectMenuTree(roleId);
              trees = getTrees(menuList, true, roleMenuList, true);
          }
          else
          {
              trees = getTrees(menuList, false, null, true);
          }
          return trees;
      }
  
      /**
       * 查询所有菜单
       * 
       * @return 菜单列表
       */
      @Override
      public List<Map<String, Object>> menuTreeData()
      {
          List<Map<String, Object>> trees = new ArrayList<Map<String, Object>>();
          List<SysMenu> menuList = menuMapper.selectMenuAll();
          trees = getTrees(menuList, false, null, false);
          return trees;
      }
  
      /**
       * 查询系统所有权限
       * 
       * @return 权限列表
       */
      @Override
      public LinkedHashMap<String, String> selectPermsAll()
      {
          LinkedHashMap<String, String> section = new LinkedHashMap<>();
          List<SysMenu> permissions = menuMapper.selectMenuAll();
          if (StringUtils.isNotEmpty(permissions))
          {
              for (SysMenu menu : permissions)
              {
                  section.put(menu.getUrl(), MessageFormat.format(PREMISSION_STRING, menu.getPerms()));
              }
          }
          return section;
      }
  
      /**
       * 对象转菜单树
       * 
       * @param menuList 菜单列表
       * @param isCheck 是否需要选中
       * @param roleMenuList 角色已存在菜单列表
       * @param permsFlag 是否需要显示权限标识
       * @return
       */
      public List<Map<String, Object>> getTrees(List<SysMenu> menuList, boolean isCheck, List<String> roleMenuList,
              boolean permsFlag)
      {
          List<Map<String, Object>> trees = new ArrayList<Map<String, Object>>();
          for (SysMenu menu : menuList)
          {
              Map<String, Object> deptMap = new HashMap<String, Object>();
              deptMap.put("id", menu.getMenuId());
              deptMap.put("pId", menu.getParentId());
              deptMap.put("name", transMenuName(menu, roleMenuList, permsFlag));
              deptMap.put("title", menu.getMenuName());
              if (isCheck)
              {
                  deptMap.put("checked", roleMenuList.contains(menu.getMenuId() + menu.getPerms()));
              }
              else
              {
                  deptMap.put("checked", false);
              }
              trees.add(deptMap);
          }
          return trees;
      }
  
      public String transMenuName(SysMenu menu, List<String> roleMenuList, boolean permsFlag)
      {
          StringBuffer sb = new StringBuffer();
          sb.append(menu.getMenuName());
          if (permsFlag)
          {
              sb.append("<font color=\"#888\">&nbsp;&nbsp;&nbsp;" + menu.getPerms() + "</font>");
          }
          return sb.toString();
      }
  
      /**
       * 删除菜单管理信息
       * 
       * @param menuId 菜单ID
       * @return 结果
       */
      @Override
      public int deleteMenuById(Long menuId)
      {
          return menuMapper.deleteMenuById(menuId);
      }
  
      /**
       * 根据菜单ID查询信息
       * 
       * @param menuId 菜单ID
       * @return 菜单信息
       */
      @Override
      public SysMenu selectMenuById(Long menuId)
      {
          return menuMapper.selectMenuById(menuId);
      }
  
      /**
       * 查询子菜单数量
       * 
       * @param parentId 父级菜单ID
       * @return 结果
       */
      @Override
      public int selectCountMenuByParentId(Long parentId)
      {
          return menuMapper.selectCountMenuByParentId(parentId);
      }
  
      /**
       * 查询菜单使用数量
       * 
       * @param menuId 菜单ID
       * @return 结果
       */
      @Override
      public int selectCountRoleMenuByMenuId(Long menuId)
      {
          return roleMenuMapper.selectCountRoleMenuByMenuId(menuId);
      }
  
      /**
       * 新增保存菜单信息
       * 
       * @param menu 菜单信息
       * @return 结果
       */
      @Override
      public int insertMenu(SysMenu menu)
      {
          return menuMapper.insertMenu(menu);
      }
  
      /**
       * 修改保存菜单信息
       * 
       * @param menu 菜单信息
       * @return 结果
       */
      @Override
      public int updateMenu(SysMenu menu)
      {
          return menuMapper.updateMenu(menu);
      }
  
      /**
       * 校验菜单名称是否唯一
       * 
       * @param menu 菜单信息
       * @return 结果
       */
      @Override
      public String checkMenuNameUnique(SysMenu menu)
      {
          Long menuId = StringUtils.isNull(menu.getMenuId()) ? -1L : menu.getMenuId();
          SysMenu info = menuMapper.checkMenuNameUnique(menu.getMenuName(), menu.getParentId());
          if (StringUtils.isNotNull(info) && info.getMenuId().longValue() != menuId.longValue())
          {
              return UserConstants.MENU_NAME_NOT_UNIQUE;
          }
          return UserConstants.MENU_NAME_UNIQUE;
      }
  
      /**
       * 根据父节点的ID获取所有子节点
       * 
       * @param list 分类表
       * @param parentId 传入的父节点ID
       * @return String
       */
      public List<SysMenu> getChildPerms(List<SysMenu> list, int parentId)
      {
          List<SysMenu> returnList = new ArrayList<SysMenu>();
          for (Iterator<SysMenu> iterator = list.iterator(); iterator.hasNext();)
          {
              SysMenu t = (SysMenu) iterator.next();
              // 一、根据传入的某个父节点ID,遍历该父节点的所有子节点
              if (t.getParentId() == parentId)
              {
                  recursionFn(list, t);
                  returnList.add(t);
              }
          }
          return returnList;
      }
  
      /**
       * 递归列表
       * 
       * @param list
       * @param t
       */
      private void recursionFn(List<SysMenu> list, SysMenu t)
      {
          // 得到子节点列表
          List<SysMenu> childList = getChildList(list, t);
          t.setChildren(childList);
          for (SysMenu tChild : childList)
          {
              if (hasChild(list, tChild))
              {
                  // 判断是否有子节点
                  Iterator<SysMenu> it = childList.iterator();
                  while (it.hasNext())
                  {
                      SysMenu n = (SysMenu) it.next();
                      recursionFn(list, n);
                  }
              }
          }
      }
  
      /**
       * 得到子节点列表
       */
      private List<SysMenu> getChildList(List<SysMenu> list, SysMenu t)
      {
          List<SysMenu> tlist = new ArrayList<SysMenu>();
          Iterator<SysMenu> it = list.iterator();
          while (it.hasNext())
          {
              SysMenu n = (SysMenu) it.next();
              if (n.getParentId().longValue() == t.getMenuId().longValue())
              {
                  tlist.add(n);
              }
          }
          return tlist;
      }
  
      /**
       * 判断是否有子节点
       */
      private boolean hasChild(List<SysMenu> list, SysMenu t)
      {
          return getChildList(list, t).size() > 0 ? true : false;
      }
  }
  