PCS/PCS/src/main/java/cn/cslg/permission/service/TenantService.java

package cn.cslg.permission.service;

import cn.cslg.permission.common.model.vo.*;
import cn.cslg.permission.common.utils.*;
import cn.cslg.permission.common.utils.SecurityUtils.SecurityUtils;
import cn.cslg.permission.common.utils.message.MessageUtils;
import cn.cslg.permission.domain.*;
import cn.cslg.permission.domain.sys.SysDictItem;
import cn.cslg.permission.mapper.AssoTenantVipTypeFunctionMapper;
import cn.cslg.permission.mapper.SysDictItemMapper;
import cn.cslg.permission.mapper.TenantEntityMapper;
import cn.cslg.permission.service.associate.PersonRoleService;
import cn.cslg.permission.service.associate.RoleFunctionDataService;
import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.extra.mail.MailUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import io.swagger.v3.oas.models.security.SecurityScheme;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.formula.functions.T;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author 沈永艺
 * @date 2022-8-2
 * @description 租户类 Service 层
 */

@Slf4j
@Service
@RequiredArgsConstructor(onConstructor_ = {@Lazy})
public class TenantService extends ServiceImpl<TenantEntityMapper, Tenant> {
    private final PersonnelService personnelService;
    private final DepartmentService departmentService;
    private final RoleFunctionDataService roleFunctionDataService;
    private final PersonRoleService personRoleService;
    private final DeleteService deleteService;
    private final CacheUtils cacheUtils;
    private final AssoTenantVipTypeFunctionMapper assoTenantVipTypeFunctionMapper;  //租户会员类型id和功能的关联表的Mapper层装配
    private final ClientService clientService;
    private final TenantService tenantService;
    private final InvitationService invitationService;
    private final LoginUtils loginUtils;
    private final RoleService roleService;
    private final SysDictItemMapper sysDictItemMapper;
    private final MessageUtils mailUtils;

    @Transactional(rollbackFor = Exception.class)
    public Integer addTenant(TenantVO tenantVO) {
        log.info("开始处理【新增租户】的业务，参数为：{}", tenantVO);

        Personnel personnel = new Personnel();

        //检查管理员账号是否已存在
        LambdaQueryWrapper<Personnel> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Personnel::getPersonnelUserName, tenantVO.getUsername());
        List<Personnel> personnelList = personnelService.list(queryWrapper);
        if (personnelList.size() != 0) {
            return -1;
        }


        //租户表保存租户信息
        Tenant tenant = new Tenant();
        tenant
                .setTenantName(tenantVO.getName())
                .setTenantAddress(tenantVO.getAddress())
                .setTenantContacts(tenantVO.getContacts())
                .setTenantEmail(tenantVO.getEmail())
                .setTenantDescription((tenantVO.getDescribe()))
                .setTenantQuota((tenantVO.getNumber()))
                .setTenantStatus(tenantVO.getState())
                .setTenantType(tenantVO.getType())
                .setTenantVipType(tenantVO.getTenantVipType());
        if (tenantVO.getAddType() == null) {
            tenant.setCreateUser(StpUtil.getLoginIdAsInt());
        }
        //数据入租户表
        boolean suc = tenant.insert();

        if (suc) {
            //更新客户表数据
            if (tenantVO.getClientId() != null && tenantVO.getClientId() > 0) {
                Client client = clientService.getById(tenantVO.getClientId());
                client.setTenantId(tenant.getId());
                client.updateById();
            }

            //更新人员表数据，保存管理员用户
            PersonnelVO personnelVO1 = new PersonnelVO();
            personnelVO1
                    .setUsername(tenantVO.getUsername())
                    .setName(tenantVO.getContacts())
                    .setEmail(tenantVO.getEmail())
                    .setState(tenantVO.getState())
                    .setPassword(tenantVO.getPassword())
                    .setTenant(tenant.getId())
                    .setAddType(1);
            personnel = personnelService.addPersonnel(personnelVO1);
            tenant.setPersonnelId(personnel.getId());
            tenant.updateById();
        }

        //角色功能权限关联表,角色表保存信息
        //根据租户会员类型查询功能权限
        Integer tenantVipType = tenantVO.getTenantVipType();
        List<AssoTenantVipTypeAndFunctionVO> assoTenantVipTypeAndFunctionVOS = assoTenantVipTypeFunctionMapper.selectByTenantVipTypeId(tenantVipType);
        List<List<Integer>> functions = new ArrayList<>();
        for (AssoTenantVipTypeAndFunctionVO assoTenantVipTypeAndFunctionVO : assoTenantVipTypeAndFunctionVOS) {
            String functionModifyPath = assoTenantVipTypeAndFunctionVO.getFunctionModifyPath();
            //将以逗号分隔的功能组件树字符串路径转换为Integer集合
            List<Integer> function = Arrays.stream(functionModifyPath.split(",")).map(Integer::parseInt).collect(Collectors.toList());
            functions.add(function);
        }

        List<RoleVO.Permission> permissions = new ArrayList<>();
        List<Integer> ids = new ArrayList<>(); //作为判断是否有重复functionId的标识
        functions.forEach(item -> {
                    if (item.size() > 1) {
                        //从第二个开始遍历
                        for (int i = 1; i < item.size(); i++) {
                            if (!ids.contains(item.get(i))) {
                                ids.add(item.get(i));
                                RoleVO.Permission permission = new RoleVO.Permission();
                                DataVO dataVO = new DataVO();
                                dataVO.setId(0);
                                permission.setData(dataVO);
                                permission.setFunctionId(item.get(i));
                                permissions.add(permission);
                            }
                        }
                    }
                }
        );

        //数据入角色功能数据权限关联表
        RoleVO roleVO = new RoleVO();
        roleVO.setTenant(tenant.getId());
        roleVO.setName(tenantVO.getName() + "管理员");
        roleVO.setRemark("管理租户下所拥有的功能");
        roleVO.setPermissionData(permissions);
        //数据入角色表
        Role role = new Role();
        role
                .setRoleName(roleVO.getName())
                .setRoleDescription(roleVO.getRemark())
                .setTenantId(roleVO.getTenant())
                .setRoleType(2);
        role.insert();

        //数据入角色表后拿到角色id，装载角色id
        roleVO.setId(role.getId());
        //数据入角色功能数据权限关联表
        roleFunctionDataService.add(roleVO);

        //数据入角色人员关联表
        List<Integer> roles = new ArrayList<>();
        roles.add(role.getId());
        personRoleService.addAssociatePerRole(roles, personnel.getId());
        return tenant.getId();
    }

    @Transactional(rollbackFor = Exception.class)
    public void deleteTenant(TenantVO tenantVO) {
        log.info("开始处理【删除租户】的业务，参数为：{}", tenantVO.getId());

        try {
            Tenant tenant = new Tenant();
            Integer tenantId = tenantVO.getId();
            tenant.setId(tenantId);
            //根据id删除租户
            tenant.deleteById();

            //删除关联数据
            UpdateWrapper<Client> wrapper = new UpdateWrapper<>();
            wrapper.set("TENANT_ID", null).eq("TENANT_ID", tenant.getId());
            //客户表更新数据
            clientService.update(wrapper);
            //删除和租户有关的所有关联表数据
            deleteService.deleteTenantAsso(tenantId);
        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            e.printStackTrace();
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public void updateTenant(TenantVO tenantVO) {
        log.info("开始处理【修改租户】的业务，参数为：{}", tenantVO);

        try {
            //修改租户
            Tenant tenant = new Tenant();
            tenant.setTenantName(tenantVO.getName())
                    .setTenantAddress(tenantVO.getAddress())
                    .setTenantContacts(tenantVO.getContacts())
                    .setTenantEmail(tenantVO.getEmail())
                    .setTenantDescription((tenantVO.getDescribe()))
                    .setTenantQuota((tenantVO.getNumber()))
                    .setTenantStatus(tenantVO.getState())
                    .setTenantType(tenantVO.getType())
                    .setTenantVipType(tenantVO.getTenantVipType())
                    .setPersonnelId(tenantVO.getPersonnelId())
                    .setId(tenantVO.getId());
            tenant.updateById();

            //修改人员
            PersonnelVO personnelVO1 = new PersonnelVO();
            personnelVO1.setUsername(tenantVO.getUsername());
            personnelVO1.setPassword(tenantVO.getPassword());
            personnelVO1.setId(tenant.getPersonnelId().toString());
            personnelService.updatePersonnel(personnelVO1);

            //修改关联客户
            //更新客户
            if (tenantVO.getClientId() != null && tenantVO.getClientId() > 0) {
                UpdateWrapper<Client> wrapper = new UpdateWrapper<>();
                wrapper.set("TENANT_ID", null).eq("TENANT_ID", tenant.getId());
                clientService.update(wrapper);
                Client client = clientService.getById(tenantVO.getClientId());
                client.setTenantId(tenant.getId());
                client.updateById();
            }

            //更新部门
            LambdaQueryWrapper<Department> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            lambdaQueryWrapper
                    .eq(Department::getTenantId, tenant.getId());
            List<Department> tenantIds = departmentService.list(lambdaQueryWrapper);
            tenantIds.forEach(item -> item.setTenantName(tenantVO.getName()));
            departmentService.updateBatchById(tenantIds);
        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            e.printStackTrace();
        }
    }

    public String getTenantList() {
        LambdaQueryWrapper<Tenant> lambdaQueryWrapper = new LambdaQueryWrapper<>();

        //根据租户状态(1启用0停用)查询启用的租户列表
        lambdaQueryWrapper.eq(Tenant::getTenantStatus, 1);
        SecurityUtils.startDataScope("/admin/client/check");
        List<Tenant> tenantPeople = this.list(lambdaQueryWrapper);
        return Response.success(setTenantToVO(tenantPeople));
    }

    /**
     * 查询租户id和名称
     * @return
     */
    public List<Tenant> getTenantIdAndName(List<Integer> tenantIds) {
        List<Tenant> tenants = new ArrayList<>();
        LambdaQueryWrapper<Tenant> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Tenant::getTenantStatus, 1);
        if(tenantIds.size() > 0){
            queryWrapper.in(Tenant::getId,tenantIds);
            tenants = this.list(queryWrapper);
        } else {
            tenants = this.list(queryWrapper);
        }
        return tenants;
    }

    public String queryPageList(TenantVO tenantVO) {
        LambdaQueryWrapper<Tenant> lambdaQueryWrapper = new LambdaQueryWrapper<>();

        //根据租户名称或是租户联系地址或是租户描述模糊查询租户列表
        lambdaQueryWrapper.and((wrapper) -> wrapper.like(Tenant::getTenantName, tenantVO.getName())
                .or()
                .like(Tenant::getTenantAddress, tenantVO.getName())
                .or()
                .like(Tenant::getTenantDescription, tenantVO.getName()));
        SecurityUtils.startDataScope("/admin/client/check");
        List<Tenant> tenantPeople = this.page(new Page<>(tenantVO.getCurrent(), tenantVO.getSize()), lambdaQueryWrapper).getRecords();
        SecurityUtils.startDataScope("/admin/client/check");
        long count = this.count(lambdaQueryWrapper);
        return Response.success(setTenantToVO(tenantPeople), DataUtils.setPageColumn(tenantVO.getSize(), tenantVO.getCurrent(), Math.toIntExact(count)));
    }

    public IPage<Tenant> getTenants(Integer tenantId, String tenantName, Integer current, Integer size) {
        IPage<Tenant> tenants;
        Tenant tenant = tenantService.getById(tenantId);
        List<Integer> ids = new ArrayList<>();
        ids.add(tenantId);
        //当租户类型为服务机构时，获得该租户所有客户的租户
        if (tenant.getTenantType().equals("1")) {
            List<Integer> temIds = clientService.queryTenantClients(tenantId);
            ids.addAll(temIds);
        }
        LambdaQueryWrapper<Tenant> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //根据租户id获得客户列表
        lambdaQueryWrapper.in(Tenant::getId, ids)
                .like(Tenant::getTenantName, tenantName)
                .eq(Tenant::getTenantStatus, 1);
        tenants = this.page(new Page<>(current, size), lambdaQueryWrapper);
        return tenants;
    }

    private Object setTenantToVO(List<Tenant> tenantList) {
        List<TenantVO> tenantVOs = new ArrayList<>();
        for (Tenant tenant : tenantList) {
            TenantVO tenantVO = new TenantVO();
            Integer personnelId = tenant.getPersonnelId();
            Personnel personnel = personnelService.getById(personnelId);
            String personnelUserName = "";
            if (personnel != null) {
                personnelUserName = personnel.getPersonnelUserName();
            }
            tenantVO
                    .setId(tenant.getId())
                    .setAddress(tenant.getTenantAddress())
                    .setName(tenant.getTenantName())
                    .setContacts(tenant.getTenantContacts())
                    .setEmail(tenant.getTenantEmail())
                    .setDescribe(tenant.getTenantDescription())
                    .setNumber(tenant.getTenantQuota())
                    .setState(tenant.getTenantStatus())
                    .setType(tenant.getTenantType())
                    .setTenantVipType(tenant.getTenantVipType())
                    .setUsername(personnelUserName)
                    .setPersonnelId(tenant.getPersonnelId());
//                    .setFunction(lst)
//                    .setFunctionList(tenantFunctionService.getFunction(tenant.getId()));

            tenantVOs.add(tenantVO);
        }
        return tenantVOs;
    }

    @Transactional(rollbackFor = Exception.class)
    public void addByInvitation(TenantVO tenantVo) {
        //根据邀请码查询是否存在
        LambdaQueryWrapper<Invitation> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Invitation::getInvitation, tenantVo.getInvitation());
        List<Invitation> invitations = invitationService.list(wrapper);
        if (invitations == null || invitations.size() == 0) {
            ThrowException.throwXiaoShiException("邀请码不存在");
        }
        Invitation invitation = invitations.get(0);
        if (invitation.getIsInvalid().equals(1)) {
            ThrowException.throwXiaoShiException("邀请码已被使用");
        }

        tenantVo.setTenantVipType(invitation.getVipType());
        tenantVo.setNumber(1);
        tenantVo.setType(0 + "");
        tenantVo.setAddType(1);
        tenantVo.setState(1);
        tenantVo.setName(invitation.getName());
        //如果联系人信息没有传来，就使用邀请码中的联系人信息
        if (tenantVo.getContacts() == null || tenantVo.getContacts().equals("")) {
            tenantVo.setContacts(invitation.getContacts());
        }
        tenantVo.setUsername(invitation.getEmail());
        //如果联系地址信息没有传来，就使用邀请码中的联系地址信息
        if (tenantVo.getAddress() == null || tenantVo.getAddress().equals("")) {
            tenantVo.setAddress(invitation.getAddress());
        }
        //租户id
        Integer tenantId = invitation.getTenant();
        if (tenantId != null) {
            //根据租户id获得租户管理员id
            LambdaQueryWrapper<Role> wrapper1 = new LambdaQueryWrapper<>();
            wrapper1.eq(Role::getTenantId, invitation.getTenant())
                    .eq(Role::getRoleType, 2);
            List<Role> roles = roleService.list(wrapper1);
            if (roles.size() == 0) {
                ThrowException.throwXiaoShiException("租户已创建，但未有租户管理员角色");
            }
            //保存管理员用户
            PersonnelVO personnelVO1 = new PersonnelVO();
            personnelVO1
                    .setUsername(tenantVo.getUsername())
                    .setName(tenantVo.getContacts())
                    .setEmail(tenantVo.getEmail())
                    .setState(tenantVo.getState())
                    .setPassword(tenantVo.getPassword())
                    .setTenant(tenantId)
                    .setAddType(1);
            Personnel personnel = personnelService.addPersonnel(personnelVO1);
            invitation.setPersonnelId(personnel.getId());
            Role role = roles.get(0);
            List<Integer> temrole = new ArrayList<>();
            temrole.add(role.getId());
            personRoleService.addAssociatePerRole(temrole, personnel.getId());
        } else {
            tenantId = this.addTenant2(tenantVo, invitation);
            if (tenantId < 0) {
                ThrowException.throwXiaoShiException("人员的账号已存在");
            }
            //查找同公司的激活码
            invitation.setIsInvalid(1);
            //邀请码表更新信息
            invitation.updateById();

        }
        //查找同公司的激活码
        invitation.setIsInvalid(1);
        //邀请码表更新信息
        invitation.updateById();
        //更新所有该公司的激活码的租户id
        UpdateWrapper<Invitation> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("COMPANY_NAME", invitation.getCompanyName()).set("TENANT", tenantId);
        invitationService.update(null, updateWrapper);
    }

    @Transactional(rollbackFor = Exception.class)
    public void addByInvitation2(TenantVO tenantVo) {
        //根据验证码查询是否存在
        LambdaQueryWrapper<Invitation> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Invitation::getInvitation, tenantVo.getInvitation());
        List<Invitation> invitations = invitationService.list(wrapper);
        if (invitations == null || invitations.size() == 0) {
            ThrowException.throwXiaoShiException("邀请码不存在");
        }
        Invitation invitation = invitations.get(0);
        if (invitation.getIsInvalid().equals(1)) {
            ThrowException.throwXiaoShiException("邀请码已被使用");
        }
        //保存管理员用户
        Integer personId = invitation.getPersonnelId();
        if (personId == null) {
            ThrowException.throwXiaoShiException("此邀请码初始数据有误，请联系管理员");
        }
        //根据人员id获得人员信息
        Personnel personnel = personnelService.getById(personId);
        personnel.setPersonnelPassword(SecureUtil.md5(tenantVo.getPassword()));
        personnel.setPersonnelStatus(1);
        personnel.updateById();
        //邀请码表更新信息
        invitation.setIsInvalid(1);
        invitation.updateById();
    }

    @Transactional(rollbackFor = Exception.class)
    public void addByInvitation3(TenantVO tenantVo) {
        log.info("开始处理【根据邀请码添加租户】的业务，参数为：{}", tenantVo);

        //检查邀请码是否存在
        LambdaQueryWrapper<Invitation> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Invitation::getInvitation, tenantVo.getInvitation());
        List<Invitation> invitations = invitationService.list(wrapper);
        if (invitations == null || invitations.size() == 0) {
            ThrowException.throwXiaoShiException("邀请码不存在");
        }

        //检查邀请码是否有效（1无效 0有效）
        Invitation invitation = invitations.get(0);
        if (invitation.getIsInvalid().equals(1)) {
            ThrowException.throwXiaoShiException("邀请码已被使用");
        }

        //邀请码表更新信息
        //地址
        invitation.setAddress(tenantVo.getAddress());
        //电话
        invitation.setPhoneNumber(tenantVo.getPhoneNumber());
        //联系人
        invitation.setContacts(tenantVo.getContacts());
        //邮箱
        invitation.setEmail(tenantVo.getEmail());
        //租户名称
        invitation.setName(tenantVo.getName());
        invitation.setIsInvalid(1);
        invitation.updateById();

        //从字典表里获得配置联系人数
        LambdaQueryWrapper<SysDictItem> wrapper1 = new LambdaQueryWrapper<>();
        wrapper1.eq(SysDictItem::getDictParentKey, "ADMIN_EMAIL");
        List<SysDictItem> sysDictItems = sysDictItemMapper.selectList(wrapper1);
        sysDictItems.forEach(item -> {
            Map<String, Object> map = new LinkedHashMap<>();
            map.put("title", "激活码审核通知");
            map.put("template", "mail/adminEmail.html");
            map.put("value1", item.getDictChildLabel());
            map.put("img", "/logo.png");
            map.put("email", item.getDictChildValue());
            map.put("value2", invitation.getInvitation());
            map.put("value3", invitation.getName());
            map.put("value4", invitation.getContacts());
            map.put("value5", invitation.getEmail());
            map.put("value6", invitation.getPhoneNumber());
            map.put("value7", invitation.getAddress());
            mailUtils.sendEmailMessage(map);
        });

    }

    public Invitation queryByInvitation(String invitation) {
        log.info("开始处理【根据邀请码查询租户】的业务，参数为：{}", invitation);

        LambdaQueryWrapper<Invitation> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Invitation::getInvitation, invitation);
        List<Invitation> invitations = invitationService.list(wrapper);
        if (invitations == null || invitations.size() == 0) {
            ThrowException.throwXiaoShiException("邀请码不存在");
        }
        return invitations.get(0);

    }

    @Transactional(rollbackFor = Exception.class)
    public Integer addTenant2(TenantVO tenantVO, Invitation invitation) {
        Personnel personnel = new Personnel();

        LambdaQueryWrapper<Personnel> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Personnel::getPersonnelUserName, tenantVO.getUsername());
        List<Personnel> personnelList = personnelService.list(queryWrapper);
        if (personnelList.size() != 0) {
            return -1;
        }
        //租户表保存租户信息
        Tenant tenant = new Tenant();
        tenant
                .setTenantName(tenantVO.getName())
                .setTenantAddress(tenantVO.getAddress())
                .setTenantContacts(tenantVO.getContacts())
                .setTenantEmail(tenantVO.getEmail())
                .setTenantDescription((tenantVO.getDescribe()))
                .setTenantQuota((tenantVO.getNumber()))
                .setTenantStatus(tenantVO.getState())
                .setTenantType(tenantVO.getType())
                .setTenantVipType(tenantVO.getTenantVipType());
        if (tenantVO.getAddType() == null) {
            tenant.setCreateUser(StpUtil.getLoginIdAsInt());
        }
        boolean suc = tenant.insert();
        if (suc) {
            //更新客户
            if (tenantVO.getClientId() != null && tenantVO.getClientId() > 0) {
                Client client = clientService.getById(tenantVO.getClientId());
                client.setTenantId(tenant.getId());
                client.updateById();
            }
            //保存管理员用户
            PersonnelVO personnelVO1 = new PersonnelVO();
            personnelVO1
                    .setUsername(tenantVO.getUsername())
                    .setName(tenantVO.getContacts())
                    .setEmail(tenantVO.getEmail())
                    .setState(tenantVO.getState())
                    .setPassword(tenantVO.getPassword())
                    .setTenant(tenant.getId())
                    .setAddType(1);
            personnel = personnelService.addPersonnel(personnelVO1);
            invitation.setPersonnelId(personnel.getId());
            tenant.setPersonnelId(personnel.getId());
            tenant.updateById();
        }

        //角色功能权限关联表,角色表保存信息
        //根据租户会员类型查询功能权限
        Integer tenantVipType = tenantVO.getTenantVipType();
        List<AssoTenantVipTypeAndFunctionVO> assoTenantVipTypeAndFunctionVOS = assoTenantVipTypeFunctionMapper.selectByTenantVipTypeId(tenantVipType);
        List<List<Integer>> functions = new ArrayList<>();
        for (AssoTenantVipTypeAndFunctionVO assoTenantVipTypeAndFunctionVO : assoTenantVipTypeAndFunctionVOS) {
            String functionModifyPath = assoTenantVipTypeAndFunctionVO.getFunctionModifyPath();
            //将以逗号分隔的功能组件树字符串路径转换为Integer集合
            List<Integer> function = Arrays.stream(functionModifyPath.split(",")).map(Integer::parseInt).collect(Collectors.toList());
            functions.add(function);
        }

        List<RoleVO.Permission> permissions = new ArrayList<>();
        List<Integer> ids = new ArrayList<>(); //作为判断是否有重复functionId的标识
        functions.forEach(item -> {
                    if (item.size() > 1) {
                        //从第二个开始遍历
                        for (int i = 1; i < item.size(); i++) {
                            if (!ids.contains(item.get(i))) {
                                ids.add(item.get(i));
                                RoleVO.Permission permission = new RoleVO.Permission();
                                DataVO dataVO = new DataVO();
                                dataVO.setId(0);
                                permission.setData(dataVO);
                                permission.setFunctionId(item.get(i));
                                permissions.add(permission);
                            }
                        }
                    }
                }
        );

        RoleVO roleVO = new RoleVO();
        roleVO.setTenant(tenant.getId());
        roleVO.setName(tenantVO.getName() + "管理员");
        roleVO.setRemark("管理租户下所拥有的功能");
        roleVO.setPermissionData(permissions);
        Role role = new Role();
        role
                .setRoleName(roleVO.getName())
                .setRoleDescription(roleVO.getRemark())
                .setTenantId(roleVO.getTenant())
                .setRoleType(2);
        role.insert();
        roleVO.setId(role.getId());
        roleFunctionDataService.add(roleVO);
        List<Integer> roles = new ArrayList<>();
        roles.add(role.getId());
        personRoleService.addAssociatePerRole(roles, personnel.getId());
        return tenant.getId();
    }

    public List<SysDictItem> getAdminEmailPersons() {
        LambdaQueryWrapper<SysDictItem> wrapper1 = new LambdaQueryWrapper<>();
        wrapper1.eq(SysDictItem::getDictParentKey, "ADMIN_EMAIL");
        List<SysDictItem> sysDictItems = sysDictItemMapper.selectList(wrapper1);
        return sysDictItems;
    }


}