jzg/platform/src/main/java/com/jzg/service/impl/UserRoleServiceImpl.java

package com.jzg.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jzg.commons.annotation.IgnoreTenant;
import com.jzg.commons.constants.SystemConstants;
import com.jzg.commons.core.base.BaseController;
import com.jzg.commons.core.base.HistoryDataService;
import com.jzg.commons.entity.po.*;
import com.jzg.commons.entity.vo.RolePermissionVo;
import com.jzg.commons.entity.vo.SysRoleDataScopeVo;
import com.jzg.commons.entity.vo.SysRoleVo;
import com.jzg.commons.exception.SystemException;
import com.jzg.commons.util.idgen.IdGenerate;
import com.jzg.mapper.*;
import com.jzg.service.SysSystemService;
import com.jzg.service.UserRoleService;
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;
import java.util.Objects;
import java.util.stream.Collectors;

@Service
public class UserRoleServiceImpl extends ServiceImpl<SysRoleMapper, SysRole> implements UserRoleService, HistoryDataService {

    @Autowired
    SysSystemService sysSystemService;

    @Autowired
    SysMenuMapper sysMenuMapper;

    @Autowired
    SysRolePermsMapper sysRolePermsMapper;

    @Autowired
    SysUserRoleMapper sysUserRoleMapper;

    @Autowired
    SysRoleDataScopeMapper sysRoleDataScopeMapper;

    @Autowired
    SysRoleDataScopeLinkMapper sysRoleDataScopeLinkMapper;

    @Autowired
    BaseController baseController;

    @IgnoreTenant
    @Override
    public List<RolePermissionVo> getAllRoleMenu() {
        List<RolePermissionVo> allRoleMenu = baseMapper.getAllRoleMenu();
        return allRoleMenu;
    }

    @Override
    public SysRoleVo roleGet(String roleId) {
        String userSystemCode = baseController.getUserSystemCode();
        SysRole sysRole = baseMapper.selectOne(new LambdaQueryWrapper<SysRole>()
                .eq(SysRole::getId,roleId)
                .eq(SysRole::getSystemCode,userSystemCode));
        if(Objects.isNull(sysRole)){
            throw new SystemException("角色不存在");
        }
        List<SysRolePerms> sysRolePerms = sysRolePermsMapper.getByRoleIdNew(roleId);
        SysRoleVo sysRoleVo = new SysRoleVo(sysRole,sysRolePerms);

        //获取角色数据权限
        SysRoleDataScope sysRoleDataScope = sysRoleDataScopeMapper.selectOne(new LambdaQueryWrapper<SysRoleDataScope>()
                .eq(SysRoleDataScope::getRoleId, roleId));
        if(!Objects.isNull(sysRoleDataScope)) {
            SysRoleDataScopeVo vo = new SysRoleDataScopeVo();
            vo.setDataMark(sysRoleDataScope.getDataMark());
            if (!sysRoleDataScope.equals("2")) {
                List<SysRoleDataScopeLink> sysRoleDataScopeLinks = sysRoleDataScopeLinkMapper.selectList(new LambdaQueryWrapper<SysRoleDataScopeLink>()
                        .eq(SysRoleDataScopeLink::getRoleId, roleId));
                vo.setDeptIds(sysRoleDataScopeLinks.stream().map(x -> x.getDeptId()).collect(Collectors.toList()));
            }
            sysRoleVo.setDataScope(vo);
        }

        return sysRoleVo;
    }

    @Override
    public boolean isExist(String roleName) {
        return baseMapper.selectCount(new LambdaQueryWrapper<SysRole>()
                .eq(SysRole::getName,roleName)) > 0;
    }

    @Override
    public boolean isExist(String roleName, String id) {
        return baseMapper.selectCount(new LambdaQueryWrapper<SysRole>()
                .eq(SysRole::getName,roleName)
                .ne(SysRole::getId,id)) > 0;
    }


    @Transactional
    @Override
    public boolean roleAdd(SysRoleVo sysRoleVo) {
        sysRoleVo.setId(IdGenerate.nextId());
        SysRole sysRole = sysRoleVo.getSysRole();
        List<SysRolePerms> sysRolePermsList = new ArrayList<>();
        sysRoleVo.getPerms().forEach(item->{
            SysRolePerms perms = new SysRolePerms();
            perms.setId(IdGenerate.nextId());
            perms.setRoleId(sysRole.getId());
            perms.setPermsId(item.getId());
            perms.setPerms(item.getAuth());
            sysRolePermsList.add(perms);
        });
        SysRoleDataScope sysRoleDataScope = new SysRoleDataScope();
        sysRoleDataScope.setRoleId(sysRole.getId());
        if(Objects.nonNull(sysRoleVo.getDataScope())) {
            sysRoleDataScope.setDataMark(sysRoleVo.getDataScope().getDataMark());
            sysRoleDataScopeMapper.insert(sysRoleDataScope);
            if (sysRoleVo.getDataScope().getDataMark().equals("2") || sysRoleVo.getDataScope().getDataMark().equals("1")) {
                List<SysRoleDataScopeLink> sysRoleDataScopeLinks = new ArrayList<>();
                if (!Objects.isNull(sysRoleVo.getDataScope().getDeptIds())) {
                    if (!sysRoleVo.getDataScope().getDeptIds().isEmpty()) {
                        sysRoleVo.getDataScope().getDeptIds().forEach(item -> {
                            SysRoleDataScopeLink sysRoleDataScopeLink = new SysRoleDataScopeLink();
                            sysRoleDataScopeLink.setId(IdGenerate.nextId());
                            sysRoleDataScopeLink.setRoleId(sysRole.getId());
                            sysRoleDataScopeLink.setDeptId(item);
                            sysRoleDataScopeLinks.add(sysRoleDataScopeLink);
                        });
                    }
                }
                sysRoleDataScopeLinkMapper.insert(sysRoleDataScopeLinks);
            }
        }

        if(sysRolePermsMapper.insert(sysRolePermsList).stream().count() > 0 && baseMapper.insert(sysRole) > 0){
            return true;
        }
        return false;
    }

    @Transactional
    @Override
    public boolean roleUpdate(SysRoleVo sysRoleVo) {
        SysRole sysRole = sysRoleVo.getSysRole();
        List<SysRolePerms> sysRolePermsList = new ArrayList<>();
        sysRoleVo.getPerms().forEach(item->{
            SysRolePerms perms = new SysRolePerms();
            perms.setId(IdGenerate.nextId());
            perms.setRoleId(sysRole.getId());
            perms.setPermsId(item.getId());
            perms.setPerms(item.getAuth());
            perms.setHalfChecked(item.getHalfChecked());
            sysRolePermsList.add(perms);
        });
        baseMapper.updateById(sysRole);
        sysRolePermsMapper.delete(new LambdaQueryWrapper<SysRolePerms>()
                .eq(SysRolePerms::getRoleId,sysRole.getId()));
        //更新用户数据权限
        sysRoleDataScopeMapper.delete(new LambdaQueryWrapper<SysRoleDataScope>()
               .eq(SysRoleDataScope::getRoleId,sysRole.getId()));
        sysRoleDataScopeLinkMapper.delete(new LambdaQueryWrapper<SysRoleDataScopeLink>()
              .eq(SysRoleDataScopeLink::getRoleId,sysRole.getId()));

        //保存角色数据权限  如果是平台则直接跳过
        if(!baseController.getUserSystemCode().equals(SystemConstants.SYSTEM_PLATFORM.getCode())) {
            SysRoleDataScope sysRoleDataScope = new SysRoleDataScope();
            sysRoleDataScope.setId(IdGenerate.nextId());
            sysRoleDataScope.setRoleId(sysRole.getId());
            sysRoleDataScope.setDataMark(sysRoleVo.getDataScope().getDataMark());
            sysRoleDataScopeMapper.insert(sysRoleDataScope);
            if (sysRoleDataScope.getDataMark().equals("2") || sysRoleDataScope.getDataMark().equals("1")) {
                List<SysRoleDataScopeLink> sysRoleDataScopeLinks = new ArrayList<>();
                if(!Objects.isNull(sysRoleVo.getDataScope().getDeptIds())) {
                    if (!sysRoleVo.getDataScope().getDeptIds().isEmpty()) {
                        sysRoleVo.getDataScope().getDeptIds().forEach(item -> {
                            SysRoleDataScopeLink sysRoleDataScopeLink = new SysRoleDataScopeLink();
                            sysRoleDataScopeLink.setId(IdGenerate.nextId());
                            sysRoleDataScopeLink.setRoleId(sysRole.getId());
                            sysRoleDataScopeLink.setDeptId(item);
                            sysRoleDataScopeLinks.add(sysRoleDataScopeLink);
                        });
                    }
                }
                sysRoleDataScopeLinkMapper.insert(sysRoleDataScopeLinks);
            }else if (sysRoleDataScope.getDataMark().equals("3")){
                List<SysRoleDataScopeLink> sysRoleDataScopeLinks = new ArrayList<>();
                sysRoleVo.getDataScope().getDeptIds().forEach(item->{
                    SysRoleDataScopeLink sysRoleDataScopeLink = new SysRoleDataScopeLink();
                    sysRoleDataScopeLink.setId(IdGenerate.nextId());
                    sysRoleDataScopeLink.setRoleId(sysRole.getId());
                    sysRoleDataScopeLink.setDeptId(item);
                    sysRoleDataScopeLinks.add(sysRoleDataScopeLink);
                });
                sysRoleDataScopeLinkMapper.insert(sysRoleDataScopeLinks);
            }
        }

        if(sysRolePermsMapper.insert(sysRolePermsList).stream().count() > 0 && baseMapper.updateById(sysRole) > 0){
            return true;
        }
        return false;
    }

    @Override
    public boolean roleDelete(SysRoleVo sysRoleVo) {
        if(baseMapper.selectCount(new LambdaQueryWrapper<SysRole>()
                .eq(SysRole::getId, sysRoleVo.getId())) == 0){
            throw new SystemException("角色信息不存在");
        }
        if(sysRolePermsMapper.delete(new LambdaQueryWrapper<SysRolePerms>()
                .eq(SysRolePerms::getRoleId, sysRoleVo.getId())) > 0 && baseMapper.deleteById(sysRoleVo.getId()) > 0){
            return true;
        }
        return false;
    }

    @Override
    public boolean roleDeleteValid(SysRoleVo sysRoleVo) {
        if(sysRoleVo.getId().equals("admin")){
            throw new SystemException("admin角色无法删除");
        }
        Long count = baseMapper.selectCount(new LambdaQueryWrapper<SysRole>()
                .eq(SysRole::getId, sysRoleVo.getId())
        );
        if(count <= 0){
            throw new SystemException("找不到该角色");
        }
        count = sysUserRoleMapper.selectCount(new LambdaQueryWrapper<SysUserRole>()
                .eq(SysUserRole::getRoleId, sysRoleVo.getId()));
        if(count > 0){
            return false;
        }
        return true;
    }


    @Override
    public Object getHistoryData(String id) {
        SysRole sysRole = baseMapper.selectById(id);
        return sysRole;
    }
}