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

package com.huaxu.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.huaxu.common.ToolUtil;
import com.huaxu.dao.TenantMapper;
import com.huaxu.dto.RoleRequestDto;
import com.huaxu.dto.TenantDto;
import com.huaxu.entity.Org;
import com.huaxu.entity.Role;
import com.huaxu.entity.TenantEntity;
import com.huaxu.entity.UserEntity;
import com.huaxu.model.LoginUser;
import com.huaxu.service.OrgService;
import com.huaxu.service.RoleService;
import com.huaxu.service.TenantService;
import com.huaxu.service.UserService;
import com.huaxu.util.Snowflake;
import com.huaxu.util.UserUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;


/**
 * @description 租户管理实现类
 * @auto wangli
 * @data 2020-10-26 15:44
 */
@Service("tenantService")
public class TenantServiceImpl implements TenantService {
    /**
     * 租户
     */
     @Resource
     private TenantMapper tenantMapper;
    /**
     * 用户
     */
     @Autowired
     private UserService userService;
    /**
     * 角色
     */
    @Autowired
     private RoleService roleService;
    /**
     * 机构
     */
    @Autowired
    private OrgService orgService;

    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
    @Override
    public TenantDto selectById(Integer id) {
        TenantDto tenantDto = tenantMapper.selectById(id);
        //获取租户菜单
        if(tenantDto != null){
            tenantDto.setTenantMenuIds(tenantMapper.selectTenantMenuIds(id));
        }
        return tenantDto;
    }


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

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

    /**
     * 新增数据
     *
     * @param tenantDto 实例对象
     * @return 实例对象
     */
    @Override
    public Integer insert(TenantDto tenantDto) {
        LoginUser loginUser = UserUtil.getCurrentUser();
        //创建租户信息
        if(loginUser != null){
            tenantDto.setUpdateBy(loginUser.getUsername());
            tenantDto.setCreateBy(loginUser.getUsername());
        }
        tenantDto.setDateCreate(new Date());
        tenantDto.setDateUpdate(new Date());
        tenantDto.setCode(Snowflake.generateId().toString());
        tenantDto.setStatus(1);
        tenantDto.setTenantState(1);
        tenantMapper.insert(tenantDto);

        //创建租户菜单信息
        if(tenantDto.getTenantMenuIds().size()>0){
            tenantMapper.createTenantMenu(tenantDto.getCreateBy(),tenantDto.getId(),tenantDto.getTenantMenuIds());
        }
        //创建角色
        RoleRequestDto roleRequestDto = new RoleRequestDto();
        Role role = new Role();
        role.setRoleName(tenantDto.getTenantName());
        role.setDescription(tenantDto.getTenantName() +"初始化角色");
        role.setRoleState(1);
        role.setPermissionType(1);
        role.setStatus(1);
        roleRequestDto.setRole(role);
        //查询租户菜单id
//        List<Integer > tenantMenuIds = tenantMapper.selectTenantMenuIds(tenantDto.getId());
        roleRequestDto.setIds(tenantDto.getTenantMenuIds());
        //插入角色
        roleService.insert(roleRequestDto);
        //插入角色菜单（租户菜单id）
        roleService.updateRoleMenuRelations(roleRequestDto);

        /*创建机构*/
        Org org = new Org();
        org.setOrgLeaderName(tenantDto.getUserName());
        org.setOrgLeaderPhone(tenantDto.getPhone());
        org.setOrgName(tenantDto.getTenantName());
        org.setOrgState(1);
        org.setStatus(1);
        org.setOrgType("company");  //机构类型
        org.setParentId(0);
        orgService.insert(org);


        //创建管理员信息
        UserEntity userEntity =new UserEntity();
        userEntity.setTenantId(tenantDto.getCode());
        userEntity.setCreateBy(tenantDto.getCreateBy());
        userEntity.setDateCreate(new Date());
        userEntity.setUpdateBy(tenantDto.getUpdateBy());
        userEntity.setDateUpdate(new Date());
        userEntity.setStatus(1);
        userEntity.setPhone(tenantDto.getPhone());
        userEntity.setUsername(tenantDto.getUserName());
        userEntity.setUserType("1");//租户系统管理员
        userEntity.setRoleId(role.getId().longValue()); //赋值角色
        userEntity.setCompanyOrgId(org.getId().longValue());//公司
        userEntity.setDeptOrgId(org.getId().longValue());//机构
        userService.addUser(userEntity);
        return 1;
    }


    /**
     * 修改数据
     *
     * @param tenantDto 实例对象
     * @return 实例对象
     */
    @Override
    public int update(TenantDto tenantDto) {
        LoginUser loginUser = UserUtil.getCurrentUser();
        if(tenantDto.getId() == null){
            return 0;
        }
        //修改租户信息
        if(loginUser != null){
            tenantDto.setUpdateBy(loginUser.getUsername());
        }
        tenantDto.setDateUpdate(new Date());

        tenantMapper.update(tenantDto);

        //修改租户菜单信息
        //界面传回的租户菜单id
        List<Integer > newTenantMenuIds = tenantDto.getTenantMenuIds();
        //数据库中已存在的租户菜单id
        List<Integer > oldTenantMenuIds = tenantMapper.selectTenantMenuIds(tenantDto.getId());
        //相同的暂时不改动

        //新增的菜单id（需要新增的）
        List<Integer> addTenantMenuIds = newTenantMenuIds.stream().filter(item -> !oldTenantMenuIds.contains(item)).collect(Collectors.toList());
        //创建租户菜单信息
        if(addTenantMenuIds.size()>0){
            tenantMapper.createTenantMenu(tenantDto.getUpdateBy(),tenantDto.getId(),addTenantMenuIds);
        }
        //去掉的菜单id(需要删除的)
        List<Integer> deleteTenantMenuIds = oldTenantMenuIds.stream().filter(item -> !newTenantMenuIds.contains(item)).collect(Collectors.toList());
        if(deleteTenantMenuIds.size()>0){
            tenantMapper.deleteTenantMenuIds(tenantDto.getId(),deleteTenantMenuIds);
        }
        //修改管理员信息
        UserEntity userEntity =userService.findUserById(tenantDto.getUserId());
        userEntity.setUpdateBy(tenantDto.getUpdateBy());
        userEntity.setDateUpdate(new Date());
        userEntity.setPhone(tenantDto.getPhone());
        userEntity.setUsername(tenantDto.getUserName());
        userService.updateUserById(userEntity);

        //创建角色
        RoleRequestDto roleRequestDto = new RoleRequestDto();
        Role role = roleService.selectById(userEntity.getRoleId().intValue());
        role.setRoleName(tenantDto.getTenantName());
        role.setDescription(tenantDto.getTenantName() +"初始化角色");
        roleRequestDto.setRole(role);
        //查询租户菜单id
//        List<Integer > tenantMenuIds = tenantMapper.selectTenantMenuIds(tenantDto.getId());

        roleRequestDto.setIds(newTenantMenuIds);
        //插入角色
        roleService.update(roleRequestDto);
        //插入角色菜单（租户菜单id）
        roleService.updateRoleMenuRelations(roleRequestDto);

        return 1;
    }

    /**
     * 通过主键删除数据
     *
     * @param id 主键
     * @return 是否成功
     */
    @Override
    public int deleteById(Integer id) {
        //先删除租户菜单
        tenantMapper.deleteTenantMenuIds(id,null);
        return tenantMapper.deleteById(id);
    }

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

    /**
     * 分页查询
     *
     * @return 对象列表
     */
    @Override
    public IPage<TenantDto> selectPage(IPage<TenantDto> page, TenantDto tenantDto) {
        return tenantMapper.selectPage(page, tenantDto);
    }

    public boolean checkTenantNameUnique(TenantDto tenantDto) {
        List<Integer> tenantIds = tenantMapper.countIds(tenantDto.getTenantName());

        if(tenantIds.size()>1){ //名字匹配多个结果
            return true;
        }else if(tenantIds.size() == 0 ){   //没有匹配的结果
            return false;
        }else if(ToolUtil.isEmpty(tenantDto.getId())){  //新增情况匹配到一个结果
            return true;
        }else if(!tenantDto.getId().equals(tenantIds.get(0))){ //修改时匹配到一个结果，但id不相等
            return true;
        }else { //修改时匹配到一个结果且id相等
            return false;
        }

    }

}