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.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.commons.util.idgen.IdGenerate;
import com.jzg.mapper.*;
import com.jzg.service.SysSystemService;
import com.jzg.commons.util.PasswordUtils;
import com.jzg.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.Collections;
import java.util.List;
import java.util.stream.Collectors;

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

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

    @Override
    public boolean updatePerms(SysSystemPermsVo sysSystemPermsVo) {
        List<SysSystemPerms> perms = new ArrayList<>();
        sysSystemPermsVo.getPerms().forEach(per->{
            SysSystemPerms sysSystemPerms = new SysSystemPerms();
            sysSystemPerms.setId(IdGenerate.nextId());
            sysSystemPerms.setSystemCode(sysSystemPerms.getSystemCode());
            sysSystemPerms.setPermsId(per.getPermsId());
            sysSystemPerms.setPerms(per.getPerms());
            perms.add(sysSystemPerms);
        });
        return !sysSystemPermsMapper.insert(perms).isEmpty();
    }

    @Override
    public List<SysSystemPerms> getSystemPerms(String systemCode) {
        List<SysSystemPerms> sysSystemPerms = sysSystemPermsMapper.selectList(new LambdaQueryWrapper<SysSystemPerms>()
                .eq(SysSystemPerms::getSystemCode, systemCode));

        return sysSystemPerms;
    }

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

    /**
     * 根据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<SysSystem> queryPage(Page page, SysSystemVo sysSystemVo) {
        LambdaQueryWrapper<SysSystem> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(StringUtils.isNotEmpty(sysSystemVo.getProvinceId()),
                        SysSystem::getProvinceId, sysSystemVo.getProvinceId())
                .eq(StringUtils.isNotEmpty(sysSystemVo.getCityId()),
                        SysSystem::getCityId, sysSystemVo.getCityId())
                .eq(StringUtils.isNotEmpty(sysSystemVo.getDistrictId()),
                        SysSystem::getDistrictId, sysSystemVo.getDistrictId())
                .eq(StringUtils.isNotNull(sysSystemVo.getSysType()),
                        SysSystem::getSysType, sysSystemVo.getSysType())
                .eq(StringUtils.isNotEmpty(sysSystemVo.getSearchValue()),
                        SysSystem::getSysName, sysSystemVo.getSearchValue()).or()
                .eq(StringUtils.isNotEmpty(sysSystemVo.getSearchValue()),
                        SysSystem::getSysCode, sysSystemVo.getSearchValue())
                .eq(StringUtils.isNotEmpty(sysSystemVo.getContactValue()),
                        SysSystem::getContact, sysSystemVo.getContactValue()).or()
                .eq(StringUtils.isNotEmpty(sysSystemVo.getContactValue()),
                        SysSystem::getTelephone, sysSystemVo.getContactValue())
                .eq(SysSystem::getIsTenant, 1)
                .ne(SysSystem::getParentId, 0);
        Page<SysSystem> sysPage = page(page, wrapper);
        List<SysSystem> sysSystemList = sysPage.getRecords();
        if(CollUtil.isNotEmpty(sysSystemList)){
            sysSystemList.forEach(sysSystem->{
                SysUploadFiles files = sysUploadFilesMapper.selectById(sysSystem.getSysIcon());
                if(StringUtils.isNotNull(files)){
                    sysSystem.setSysIconUrl(minioUtils.getPresignedObjectUrl(bucketName,files.getFileName()));
                }
            });
        }
        return sysPage;
    }

    @Override
    public SysSystem queryById(String sysId) {
        SysSystem system = this.getById(sysId);

        if(StringUtils.isNotEmpty(system.getSysIcon())){
            SysUploadFiles files = sysUploadFilesMapper.selectById(system.getSysIcon());
            if(StringUtils.isNotNull(files)){
                system.setSysIconUrl(minioUtils.getPresignedObjectUrl(bucketName,files.getFileName()));
            }
        }
        SysUser user = sysUserMapper.selectById(system.getUserId());
        system.setUserName(user.getUsername());
        system.setUserAccount(user.getMobile());
        return system;
    }

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

        /** 初始化租户管理员信息 */
        // 新增管理员用户
        SysUser user = new SysUser(sysSystemVo);
        sysUserMapper.insert(user);
        // 新增用户机构关联信息
        SysUserJzgInfo info = new SysUserJzgInfo();
        info.setUserId(user.getId());
        info.setDeptId("");// 后期放最顶级的机构
        sysUserJzgInfoMapper.insert(info);
        // 新增管理员角色
        SysRole role = new SysRole(sysSystem.getSysCode());
        sysRoleMapper.insert(role);
        // 关联用户角色
        SysUserRole userRole = new SysUserRole();
        userRole.setUserId(user.getId());
        userRole.setRoleId(role.getId());
        sysUserRoleMapper.insert(userRole);
        // 租户绑定管理员信息
        sysSystem.setUserId(user.getId());
        this.updateById(sysSystem);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void sysEdit(SysSystemVo sysSystemVo) {
        SysSystem sysSystem = new SysSystem();
        BeanUtils.copyProperties(sysSystemVo, sysSystem);
        updateById(sysSystem);
        SysSystem system = getById(sysSystem.getId());
        // 修改管理员信息
        SysUser user = sysUserMapper.selectById(system.getUserId());
        user.setUsername(sysSystemVo.getUserName());
        String encryptedPassword = PasswordUtils.encode(sysSystemVo.getPassword(),user.getSalt());
        user.setPassword(encryptedPassword);
        user.setMobile(sysSystemVo.getUserAccount());
        sysUserMapper.updateById(user);
    }

    @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 List<String> sysDeleteValidDept(SysSystemVo sysSystemVo) {
        List<String> deptIdList = sysDeptMapper.selectList(new LambdaQueryWrapper<SysDept>()
                        .select(SysDept::getId)
                        .eq(SysDept::getSystemCode, sysSystemVo.getSysCode())).stream()
                .map(SysDept::getId).collect(Collectors.toList());
        return deptIdList;
    }

    @Override
    public boolean sysDeleteValidUser(List<String> ids) {
        Long count = sysUserJzgInfoMapper.selectCount(new LambdaQueryWrapper<SysUserJzgInfo>()
                .in(SysUserJzgInfo::getUserId, ids));
        if(count <= 0){
            return true;
        }
        return false;
    }

}