Code/user_center/src/main/java/com/huaxu/service/impl/RoleServiceImpl.java

package com.huaxu.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.api.R;
import com.huaxu.dao.RoleMapper;
import com.huaxu.dao.RoleMenuMapper;
import com.huaxu.dao.RoleOrgMapper;
import com.huaxu.dto.RoleDto;
import com.huaxu.dto.RoleRequestDto;
import com.huaxu.entity.*;
import com.huaxu.model.LoginUser;
import com.huaxu.service.RoleService;
import com.huaxu.util.ByteArrayUtils;
import com.huaxu.util.RedisUtil;
import com.huaxu.util.UserUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;

/**
 * 角色(Role表)服务实现类
 *
 * @author makejava
 * @since 2020-10-27 09:13:27
 */
@Service("roleService")
public class RoleServiceImpl implements RoleService {
    @Autowired
    private RoleMapper roleMapper;
    @Autowired
    private RoleOrgMapper roleOrgMapper;
    @Autowired
    private RoleMenuMapper roleMenuMapper;
    @Autowired
    private RedisUtil redisUtil;

    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
    @Override
    public Role selectById(Integer id) {
        return this.roleMapper.selectById(id);
    }


    /**
     * 查询所有
     *
     * @return 实例对象的集合
     */
    @Override
    public List<Role> selectAll() {
        return this.roleMapper.selectAll();
    }

    /**
     * 根据条件查询
     *
     * @return 实例对象的集合
     */
    @Override
    public List<Role> selectList(Role role) {
        return this.roleMapper.selectList(role);
    }

    /**
     * 新增数据
     *
     * @param roleRequestDto 实例对象
     * @return 实例对象
     */
    @Override
    @Transactional
    public int insert(RoleRequestDto roleRequestDto) {
        configDataPermission(roleRequestDto);
        Role role = roleRequestDto.getRole();
        LoginUser currentUser = UserUtil.getCurrentUser();
        role.setTenantId(currentUser.getTenantId());
        role.setCreateBy(currentUser.getUsername());
        return this.roleMapper.insert(role);
    }

    /**
     * 批量新增
     *
     * @param roles 实例对象的集合
     * @return 生效的条数
     */
    @Override
    public int batchInsert(List<Role> roles) {
        return this.roleMapper.batchInsert(roles);
    }

    /**
     * 修改数据
     *
     * @param roleRequestDto 实例对象
     * @return 实例对象
     */
    @Override
    @Transactional
    public int update(RoleRequestDto roleRequestDto) {
        Role role=roleRequestDto.getRole();

        if(role.getStatus()==-1){
            Role roleUser = roleMapper.findRoleUser(role);
            if(roleUser!=null){
                return -1;
            }
            //删除用户与角色的关系
            roleMapper.deleteRoleUser(role);
            //删除用户与菜单关系
            roleMapper.deleteRoleMenu(role);
        }
        //將禁用的角色放入redis，作为登出判断
        if(role.getRoleState()==-1){
            String roleKey="disableRole:"+role.getId();
            redisUtil.setExpire(roleKey.getBytes(), ByteArrayUtils.objectToBytes("1").get(), 60*60*24);//15分钟过期

        } if(role.getRoleState()==0){
            String roleKey="disableRole:"+role.getId();
            redisUtil.del(roleKey.getBytes());

        }
        LoginUser currentUser = UserUtil.getCurrentUser();
        role.setUpdateBy(currentUser.getUsername());
        configDataPermission(roleRequestDto);
        return this.roleMapper.update(role);
    }
    private void configDataPermission(RoleRequestDto roleRequestDto){
        if(roleRequestDto.getRole().getPermissionType()==5){
            RoleOrg roleOrgDelete=new RoleOrg();
            Integer roleId=roleRequestDto.getRole().getId();
            roleOrgDelete.setRoleId(roleId);
            roleOrgMapper.update(roleOrgDelete);
            List<Integer> orgIds = roleRequestDto.getIds();
            List<RoleOrg>roleOrgs=new ArrayList<>();
            orgIds.forEach(id->{
                RoleOrg roleOrg = new RoleOrg();
                roleOrg.setRoleId(roleId);
                roleOrg.setOrgId(id);
                roleOrgs.add(roleOrg);
            });

            roleOrgMapper.batchInsert(roleOrgs);
        }
    }
    /**
     * 通过主键删除数据
     *
     * @param id 主键
     * @return 是否成功
     */
    @Override
    public int deleteById(Integer id) {
        return this.roleMapper.deleteById(id);
    }

    /**
     * 查询总数据数
     *
     * @return 数据总数
     */
    @Override
    public int count() {
        return this.roleMapper.count();
    }

    /**
     * 分页查询
     *
     * @return 对象列表
     */
    @Override
    public IPage<RoleDto> selectPage(Role role, IPage<RoleDto> page) {
        LoginUser currentUser = UserUtil.getCurrentUser();
        role.setTenantId(currentUser.getTenantId());
        return this.roleMapper.selectPage(page, role);
    }

    @Override
    public List<UserEntity> findUsersByRole(Role role) {
        return  roleMapper.findUsersByRole(role);
    }

    @Override
    @Transactional
    public int updateRoleMenuRelations(RoleRequestDto dto) {
        Integer roleId =dto.getRole().getId();
        List<Integer> menuIds = dto.getIds();
        List<RoleMenu>menus=new ArrayList<>();
        roleMapper.deleteRoleMenu(dto.getRole());
        menuIds.forEach(id->{
            RoleMenu roleMenu=new RoleMenu();
            roleMenu.setRoleId(roleId);
            roleMenu.setMenuId(id);
            menus.add(roleMenu);
        });
        roleMenuMapper.batchInsert(menus);
        return 0;
    }
}