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

package com.jzg.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jzg.commons.entity.dto.SysSystemAddParam;
import com.jzg.commons.entity.dto.SysSystemEditParam;
import com.jzg.commons.entity.dto.SysSystemParam;
import com.jzg.commons.entity.enums.YesNoEnum;
import com.jzg.commons.entity.po.*;
import com.jzg.commons.entity.vo.SysSystemPermsVo;
import com.jzg.commons.entity.vo.SysSystemVo;
import com.jzg.commons.entity.vo.UpAndDownVo;
import com.jzg.commons.util.StringUtils;
import com.jzg.mapper.*;
import com.jzg.service.SysSystemService;
import com.jzg.commons.util.MinioUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 租户管理表 服务层处理 sys_system
 *
 * @author dongxin
 */
@Service
public class SysSystemServiceImpl extends ServiceImpl<SysSystemMapper, SysSystem>
    implements SysSystemService {

    @Autowired
    private SysRolePermsMapper sysRolePermsMapper;
    @Autowired
    private SysUploadFilesMapper sysUploadFilesMapper;
    @Autowired
    private SysUserMapper sysUserMapper;
    @Autowired
    private SysRoleMapper sysRoleMapper;
    @Autowired
    private SysUserRoleMapper sysUserRoleMapper;
    @Autowired
    private SysDeptMapper sysDeptMapper;
    @Autowired
    private SysConfigMapper sysConfigMapper;
    @Autowired
    private SysUserJzgInfoMapper sysUserJzgInfoMapper;
    @Autowired
    private SysUserPlateInfoMapper sysUserPlateInfoMapper;
    @Autowired
    private MinioUtils minioUtils;
    @Value("${minio.bucket-name}")
    private String bucketName;

    @Override
    public boolean updatePerms(SysSystemPermsVo sysSystemPermsVo) {
        String permsStr = sysSystemPermsVo.getPermsStr();
        List<SysConfig> configs = sysConfigMapper.selectList(new LambdaQueryWrapper<SysConfig>()
                .eq(SysConfig::getType, 1).eq(SysConfig::getSystemCode,sysSystemPermsVo.getSystemCode()));
        SysConfig config;
        if(CollUtil.isEmpty(configs)){
            config = new SysConfig();
            config.setSysConfig(permsStr);
            config.setType(1);
            config.setSystemCode(sysSystemPermsVo.getSystemCode());
            sysConfigMapper.insert(config);
        }else{
            config = configs.get(0);
            config.setSysConfig(permsStr);
            sysConfigMapper.updateById(config);
        }
        // 获取租户管理员角色id
        LambdaQueryWrapper<SysRole> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(SysRole::getSystemCode, sysSystemPermsVo.getSystemCode())
                .like(SysRole::getName,"管理员");
        List<SysRole> roles = sysRoleMapper.selectList(queryWrapper);

        LambdaQueryWrapper<SysRolePerms> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysRolePerms::getRoleId,roles.get(0).getId());
        sysRolePermsMapper.delete(wrapper);
        List<SysRolePerms> perms = new ArrayList<>();
        sysSystemPermsVo.getPerms().forEach(per->{
            SysRolePerms sysSystemPerms = new SysRolePerms();
            sysSystemPerms.setRoleId(roles.get(0).getId());
            sysSystemPerms.setPermsId(per.getPermsId());
            sysSystemPerms.setPerms(per.getPerms());
            perms.add(sysSystemPerms);
        });
        return !sysRolePermsMapper.insert(perms).isEmpty();
    }

    @Override
    public List<SysRolePerms> getSystemPerms(String systemCode) {
        LambdaQueryWrapper<SysRole> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(SysRole::getSystemCode, systemCode)
                .like(SysRole::getName,"管理员");
        List<SysRole> roles = sysRoleMapper.selectList(queryWrapper);
        List<SysRolePerms> sysSystemPerms = sysRolePermsMapper.selectList(new LambdaQueryWrapper<SysRolePerms>()
                .eq(SysRolePerms::getRoleId, roles.get(0).getId()));
        return sysSystemPerms;
    }

    @Override
    public boolean updateConfig(SysConfig config) {
        List<SysConfig> configs = sysConfigMapper.selectList(new LambdaQueryWrapper<SysConfig>()
                .eq(SysConfig::getType, 0));
        if(CollUtil.isEmpty(configs)){
            config.setType(0);
            sysConfigMapper.insert(config);
        }else{
            config.setId(configs.get(0).getId());
            sysConfigMapper.updateById(config);
        }
        return true;
    }

    @Override
    public SysConfig getSystemConfig() {
        List<SysConfig> configs = sysConfigMapper.selectList(new LambdaQueryWrapper<SysConfig>()
                .eq(SysConfig::getType, 0));
        return configs.get(0);
    }

    /**
     * 根据SystemCode 查询 System对象
     * @param systemCode
     * @return
     */
    @Override
    public SysSystem getBySystemCode(String systemCode ) {
        return this.getOne(new LambdaQueryWrapper<SysSystem>()
                .eq(SysSystem::getSysCode, systemCode)
                .eq(SysSystem::getAvailable, YesNoEnum.YES.getCode())
                .eq(SysSystem::getIsDelete, YesNoEnum.NO.getCode()));
    }

    /**
     * 根据systemCode 判断是否存在数据
     * @param systemCode
     * @return
     */
    @Override
    public boolean isExistsCode(String systemCode ,String id) {
        long count = this.count(new LambdaQueryWrapper<SysSystem>()
                .eq(SysSystem::getSysCode, systemCode)
                .ne(StringUtils.isNotNull(id),SysSystem::getId, id)
        );
        return count > 0;
    }

    @Override
    public boolean isExistsName(String systemName, String id) {
        long count = this.count(new LambdaQueryWrapper<SysSystem>()
                .eq(SysSystem::getSysCode, systemName)
                .ne(StringUtils.isNotNull(id),SysSystem::getId, id)
        );
        return count > 0;
    }

    @Override
    public Page<SysSystemVo> queryPage(Page page, SysSystemParam param) {
        Page<SysSystemVo> sysPage = baseMapper.queryPage(page, param);
        List<SysSystemVo> sysSystemList = sysPage.getRecords();
        if(CollUtil.isNotEmpty(sysSystemList)){
            // 查询所有机构
            List<SysDept> deptList = sysDeptMapper.selectList(new LambdaQueryWrapper<>());
            Map<String,List<SysDept>> deptMap = deptList.stream()
                    .collect(Collectors.groupingBy(SysDept::getSystemCode));
            sysSystemList.forEach(sysSystem->{
                SysUploadFiles files = sysUploadFilesMapper.selectById(sysSystem.getSysIcon());
                if(StringUtils.isNotNull(files)){
                    sysSystem.setSysIconUrl(minioUtils.getPresignedObjectUrl(bucketName,files.getFileName()));
                }
                if(deptMap.containsKey(sysSystem.getSysCode())){
                    int count = deptMap.get(sysSystem.getSysCode()).size();
                    sysSystem.setDeptCount(count);
                }
            });
        }
        return sysPage;
    }

    @Override
    public SysSystemVo queryById(String sysId) {
        SysSystem system = this.getById(sysId);
        SysSystemVo vo = new SysSystemVo();
        BeanUtils.copyProperties(system,vo);
        if(StringUtils.isNotEmpty(vo.getSysIcon())){
            SysUploadFiles files = sysUploadFilesMapper.selectById(system.getSysIcon());
            if(StringUtils.isNotNull(files)){
                vo.setSysIconUrl(minioUtils.getPresignedObjectUrl(bucketName,files.getFileName()));
            }
        }
        SysUser user = sysUserMapper.selectById(system.getUserId());
        vo.setUserName(user.getUsername());
        vo.setUserAccount(user.getMobile());
        return vo;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void sysAdd(SysSystemAddParam param) {
        SysSystem sysSystem = new SysSystem();
        BeanUtils.copyProperties(param, sysSystem);
        sysSystem.setIsTenant(1);
        sysSystem.setAvailable(1);
        sysSystem.setParentId("1");
        this.save(sysSystem);

        /** 初始化租户管理员信息 */
        List<SysUser> userList = sysUserMapper.selectList(new LambdaQueryWrapper<SysUser>()
                .eq(SysUser::getMobile, param.getUserAccount())
        );
        String userId = null;
        if(CollUtil.isNotEmpty(userList)){
            userId = userList.get(0).getId();
        }else{
            // 新增管理员用户
            SysUser user = new SysUser(param);
            sysUserMapper.insert(user);
            userId = user.getId();
        }
        // 新增用户机构关联信息
        SysUserPlateInfo info = new SysUserPlateInfo();
        info.setUserId(userId);
        info.setSystemCode(sysSystem.getSysCode());
        info.setIsEnable(1);
        sysUserPlateInfoMapper.insert(info);
        // 查询该租户是否有管理员角色
        LambdaQueryWrapper<SysRole> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(SysRole::getSystemCode, sysSystem.getSysCode())
                .like(SysRole::getName,"管理员");
        List<SysRole> roles = sysRoleMapper.selectList(queryWrapper);
        SysRole role;
        // 新增管理员角色
        if(CollUtil.isNotEmpty(roles)){
            role = roles.get(0);
        }else{
            role = new SysRole(sysSystem.getSysCode());
            sysRoleMapper.insert(role);
        }
        // 关联用户角色
        SysUserRole userRole = new SysUserRole();
        userRole.setUserId(userId);
        userRole.setRoleId(role.getId());
        sysUserRoleMapper.insert(userRole);
        // 租户绑定管理员信息
        sysSystem.setUserId(userId);
        this.updateById(sysSystem);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void sysEdit(SysSystemEditParam param) {
        SysSystem sysSystem = new SysSystem();
        BeanUtils.copyProperties(param, sysSystem);
        updateById(sysSystem);
        SysSystem system = getById(sysSystem.getId());
        // 修改管理员信息

        List<SysUser> userList = sysUserMapper.selectList(new LambdaQueryWrapper<SysUser>()
                .eq(SysUser::getMobile, param.getUserAccount())
        );
        SysUser sysUser;
        if(CollUtil.isNotEmpty(userList)){
            sysUser = userList.get(0);
            sysUser.setUsername(param.getUserName());
            sysUserMapper.updateById(sysUser);
        }else{
            // 新增管理员用户
            sysUser = new SysUser(param);
            sysUserMapper.insert(sysUser);
            // 新增用户机构关联信息
            SysUserPlateInfo info = new SysUserPlateInfo();
            info.setUserId(sysUser.getId());
            info.setSystemCode(sysSystem.getSysCode());
            info.setIsEnable(1);
            sysUserPlateInfoMapper.insert(info);
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void upAndDown(UpAndDownVo upAndDownVo) {
        if(YesNoEnum.YES.equals(upAndDownVo.getOpType())) {
            upAndDownVo.getIds().forEach(id->{
                reDeploy(Convert.toStr(id));
            });
        } else {
            upAndDownVo.getIds().forEach(id->{
                unDeploy(Convert.toStr(id));
            });
        }
    }

    @Override
    public void unDeploy(String id) {
        SysSystem sysSystem = new SysSystem();
        sysSystem.setId(id);
        sysSystem.setAvailable(YesNoEnum.NO.getCode());
        baseMapper.updateById(sysSystem);
    }

    @Override
    public void reDeploy(String id) {
        SysSystem sysSystem = new SysSystem();
        sysSystem.setId(id);
        sysSystem.setAvailable(YesNoEnum.YES.getCode());
        baseMapper.updateById(sysSystem);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean sysDelete(SysSystemVo sysSystemVo) {
        if(baseMapper.deleteById(sysSystemVo.getId()) > 0){
            return true;
        }
        return false;
    }

    @Override
    public String sysDeleteValid(List<String> ids) {
        List<SysSystem> systemList = baseMapper.selectBatchIds(ids);
        String errorStr = null;
        if(CollUtil.isNotEmpty(systemList)){
            for (SysSystem sysSystem : systemList) {
                List<String> deptIdList = sysDeptMapper.selectList(new LambdaQueryWrapper<SysDept>()
                        .select(SysDept::getId)
                        .eq(SysDept::getSystemCode, sysSystem.getSysCode())).stream()
                        .map(SysDept::getId).collect(Collectors.toList());
                if (CollUtil.isNotEmpty(deptIdList)) {
                    errorStr = "租户["+sysSystem.getSysName()+"]还有部分子机构，请将这些子机构删除后，再进行删除！";
                    return errorStr;
                }

                Long count = sysUserPlateInfoMapper.selectCount(new LambdaQueryWrapper<SysUserPlateInfo>()
                        .eq(SysUserPlateInfo::getSystemCode, sysSystem.getSysCode())
                        .eq(SysUserPlateInfo::getIsEnable, 1)
                        .eq(SysUserPlateInfo::getIsDelete, 0));

                if(count > 0){
                    errorStr = "租户["+sysSystem.getSysName()+"]还有部分员工，请将这些员工变更机构或者删除后，再进行删除！";
                    return errorStr;
                }
            }
        }
        return errorStr;
    }

    @Override
    public boolean deleteByIds(List<String> ids) {
        return baseMapper.deleteByIds(ids) > 0;
    }

}