content: package com.ruoyi.system.service.impl;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Service;
  import org.springframework.transaction.annotation.Transactional;
  import com.ruoyi.common.annotation.DataScope;
  import com.ruoyi.common.constant.UserConstants;
  import com.ruoyi.common.core.domain.entity.SysRole;
  import com.ruoyi.common.core.domain.entity.SysUser;
  import com.ruoyi.common.core.text.Convert;
  import com.ruoyi.common.exception.ServiceException;
  import com.ruoyi.common.utils.ShiroUtils;
  import com.ruoyi.common.utils.StringUtils;
  import com.ruoyi.common.utils.spring.SpringUtils;
  import com.ruoyi.system.domain.SysRoleDept;
  import com.ruoyi.system.domain.SysRoleMenu;
  import com.ruoyi.system.domain.SysUserRole;
  import com.ruoyi.system.mapper.SysRoleDeptMapper;
  import com.ruoyi.system.mapper.SysRoleMapper;
  import com.ruoyi.system.mapper.SysRoleMenuMapper;
  import com.ruoyi.system.mapper.SysUserRoleMapper;
  import com.ruoyi.system.service.ISysRoleService;
  
  /**
   * 角色 业务层处理
   * 
   * @author ruoyi
   */
  @Service
  public class SysRoleServiceImpl implements ISysRoleService
  {
      @Autowired
      private SysRoleMapper roleMapper;
  
      @Autowired
      private SysRoleMenuMapper roleMenuMapper;
  
      @Autowired
      private SysUserRoleMapper userRoleMapper;
  
      @Autowired
      private SysRoleDeptMapper roleDeptMapper;
  
      /**
       * 根据条件分页查询角色数据
       * 
       * @param role 角色信息
       * @return 角色数据集合信息
       */
      @Override
      @DataScope(deptAlias = "d")
      public List<SysRole> selectRoleList(SysRole role)
      {
          return roleMapper.selectRoleList(role);
      }
  
      /**
       * 根据用户ID查询权限
       * 
       * @param userId 用户ID
       * @return 权限列表
       */
      @Override
      public Set<String> selectRoleKeys(Long userId)
      {
          List<SysRole> perms = roleMapper.selectRolesByUserId(userId);
          Set<String> permsSet = new HashSet<>();
          for (SysRole perm : perms)
          {
              if (StringUtils.isNotNull(perm))
              {
                  permsSet.addAll(Arrays.asList(perm.getRoleKey().trim().split(",")));
              }
          }
          return permsSet;
      }
  
      /**
       * 根据用户ID查询角色
       * 
       * @param userId 用户ID
       * @return 角色列表
       */
      @Override
      public List<SysRole> selectRolesByUserId(Long userId)
      {
          List<SysRole> userRoles = roleMapper.selectRolesByUserId(userId);
          List<SysRole> roles = selectRoleAll();
          for (SysRole role : roles)
          {
              for (SysRole userRole : userRoles)
              {
                  if (role.getRoleId().longValue() == userRole.getRoleId().longValue())
                  {
                      role.setFlag(true);
                      break;
                  }
              }
          }
          return roles;
      }
  
      /**
       * 查询所有角色
       * 
       * @return 角色列表
       */
      @Override
      public List<SysRole> selectRoleAll()
      {
          return SpringUtils.getAopProxy(this).selectRoleList(new SysRole());
      }
  
      /**
       * 通过角色ID查询角色
       * 
       * @param roleId 角色ID
       * @return 角色对象信息
       */
      @Override
      public SysRole selectRoleById(Long roleId)
      {
          return roleMapper.selectRoleById(roleId);
      }
  
      /**
       * 通过角色ID删除角色
       * 
       * @param roleId 角色ID
       * @return 结果
       */
      @Override
      @Transactional
      public boolean deleteRoleById(Long roleId)
      {
          // 删除角色与菜单关联
          roleMenuMapper.deleteRoleMenuByRoleId(roleId);
          // 删除角色与部门关联
          roleDeptMapper.deleteRoleDeptByRoleId(roleId);
          return roleMapper.deleteRoleById(roleId) > 0 ? true : false;
      }
  
      /**
       * 批量删除角色信息
       * 
       * @param ids 需要删除的数据ID
       * @throws Exception
       */
      @Override
      @Transactional
      public int deleteRoleByIds(String ids)
      {
          Long[] roleIds = Convert.toLongArray(ids);
          for (Long roleId : roleIds)
          {
              checkRoleAllowed(new SysRole(roleId));
              SysRole role = selectRoleById(roleId);
              if (countUserRoleByRoleId(roleId) > 0)
              {
                  throw new ServiceException(String.format("%1$s已分配,不能删除", role.getRoleName()));
              }
          }
          // 删除角色与菜单关联
          roleMenuMapper.deleteRoleMenu(roleIds);
          // 删除角色与部门关联
          roleDeptMapper.deleteRoleDept(roleIds);
          return roleMapper.deleteRoleByIds(roleIds);
      }
  
      /**
       * 新增保存角色信息
       * 
       * @param role 角色信息
       * @return 结果
       */
      @Override
      @Transactional
      public int insertRole(SysRole role)
      {
          // 新增角色信息
          roleMapper.insertRole(role);
          return insertRoleMenu(role);
      }
  
      /**
       * 修改保存角色信息
       * 
       * @param role 角色信息
       * @return 结果
       */
      @Override
      @Transactional
      public int updateRole(SysRole role)
      {
          // 修改角色信息
          roleMapper.updateRole(role);
          // 删除角色与菜单关联
          roleMenuMapper.deleteRoleMenuByRoleId(role.getRoleId());
          return insertRoleMenu(role);
      }
  
      /**
       * 修改数据权限信息
       * 
       * @param role 角色信息
       * @return 结果
       */
      @Override
      @Transactional
      public int authDataScope(SysRole role)
      {
          // 修改角色信息
          roleMapper.updateRole(role);
          // 删除角色与部门关联
          roleDeptMapper.deleteRoleDeptByRoleId(role.getRoleId());
          // 新增角色和部门信息（数据权限）
          return insertRoleDept(role);
      }
  
      /**
       * 新增角色菜单信息
       * 
       * @param role 角色对象
       */
      public int insertRoleMenu(SysRole role)
      {
          int rows = 1;
          // 新增用户与角色管理
          List<SysRoleMenu> list = new ArrayList<SysRoleMenu>();
          for (Long menuId : role.getMenuIds())
          {
              SysRoleMenu rm = new SysRoleMenu();
              rm.setRoleId(role.getRoleId());
              rm.setMenuId(menuId);
              list.add(rm);
          }
          if (list.size() > 0)
          {
              rows = roleMenuMapper.batchRoleMenu(list);
          }
          return rows;
      }
  
      /**
       * 新增角色部门信息(数据权限)
       *
       * @param role 角色对象
       */
      public int insertRoleDept(SysRole role)
      {
          int rows = 1;
          // 新增角色与部门（数据权限）管理
          List<SysRoleDept> list = new ArrayList<SysRoleDept>();
          for (Long deptId : role.getDeptIds())
          {
              SysRoleDept rd = new SysRoleDept();
              rd.setRoleId(role.getRoleId());
              rd.setDeptId(deptId);
              list.add(rd);
          }
          if (list.size() > 0)
          {
              rows = roleDeptMapper.batchRoleDept(list);
          }
          return rows;
      }
  
      /**
       * 校验角色名称是否唯一
       * 
       * @param role 角色信息
       * @return 结果
       */
      @Override
      public String checkRoleNameUnique(SysRole role)
      {
          Long roleId = StringUtils.isNull(role.getRoleId()) ? -1L : role.getRoleId();
          SysRole info = roleMapper.checkRoleNameUnique(role.getRoleName());
          if (StringUtils.isNotNull(info) && info.getRoleId().longValue() != roleId.longValue())
          {
              return UserConstants.ROLE_NAME_NOT_UNIQUE;
          }
          return UserConstants.ROLE_NAME_UNIQUE;
      }
  
      /**
       * 校验角色权限是否唯一
       * 
       * @param role 角色信息
       * @return 结果
       */
      @Override
      public String checkRoleKeyUnique(SysRole role)
      {
          Long roleId = StringUtils.isNull(role.getRoleId()) ? -1L : role.getRoleId();
          SysRole info = roleMapper.checkRoleKeyUnique(role.getRoleKey());
          if (StringUtils.isNotNull(info) && info.getRoleId().longValue() != roleId.longValue())
          {
              return UserConstants.ROLE_KEY_NOT_UNIQUE;
          }
          return UserConstants.ROLE_KEY_UNIQUE;
      }
  
      /**
       * 校验角色是否允许操作
       * 
       * @param role 角色信息
       */
      @Override
      public void checkRoleAllowed(SysRole role)
      {
          if (StringUtils.isNotNull(role.getRoleId()) && role.isAdmin())
          {
              throw new ServiceException("不允许操作超级管理员角色");
          }
      }
  
      /**
       * 校验角色是否有数据权限
       * 
       * @param roleId 角色id
       */
      @Override
      public void checkRoleDataScope(Long roleId)
      {
          if (!SysUser.isAdmin(ShiroUtils.getUserId()))
          {
              SysRole role = new SysRole();
              role.setRoleId(roleId);
              List<SysRole> roles = SpringUtils.getAopProxy(this).selectRoleList(role);
              if (StringUtils.isEmpty(roles))
              {
                  throw new ServiceException("没有权限访问角色数据！");
              }
          }
      }
  
      /**
       * 通过角色ID查询角色使用数量
       * 
       * @param roleId 角色ID
       * @return 结果
       */
      @Override
      public int countUserRoleByRoleId(Long roleId)
      {
          return userRoleMapper.countUserRoleByRoleId(roleId);
      }
  
      /**
       * 角色状态修改
       * 
       * @param role 角色信息
       * @return 结果
       */
      @Override
      public int changeStatus(SysRole role)
      {
          return roleMapper.updateRole(role);
      }
  
      /**
       * 取消授权用户角色
       * 
       * @param userRole 用户和角色关联信息
       * @return 结果
       */
      @Override
      public int deleteAuthUser(SysUserRole userRole)
      {
          return userRoleMapper.deleteUserRoleInfo(userRole);
      }
  
      /**
       * 批量取消授权用户角色
       * 
       * @param roleId 角色ID
       * @param userIds 需要删除的用户数据ID
       * @return 结果
       */
      @Override
      public int deleteAuthUsers(Long roleId, String userIds)
      {
          return userRoleMapper.deleteUserRoleInfos(roleId, Convert.toLongArray(userIds));
      }
  
      /**
       * 批量选择授权用户角色
       * 
       * @param roleId 角色ID
       * @param userIds 需要删除的用户数据ID
       * @return 结果
       */
      @Override
      public int insertAuthUsers(Long roleId, String userIds)
      {
          Long[] users = Convert.toLongArray(userIds);
          // 新增用户与角色管理
          List<SysUserRole> list = new ArrayList<SysUserRole>();
          for (Long userId : users)
          {
              SysUserRole ur = new SysUserRole();
              ur.setUserId(userId);
              ur.setRoleId(roleId);
              list.add(ur);
          }
          return userRoleMapper.batchUserRole(list);
      }
  }
  