Source/BladeX/blade-service/blade-system/src/main/java/org/springblade/system/service/impl/TenantServiceImpl.java

@@ -16,10 +16,16 @@
 */
package org.springblade.system.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import javafx.geometry.Pos;
import lombok.AllArgsConstructor;
import lombok.RequiredArgsConstructor;
import org.apache.ibatis.mapping.Environment;
import org.springblade.common.constant.TenantConstant;
import org.springblade.core.cache.utils.CacheUtil;
import org.springblade.core.log.exception.ServiceException;
import org.springblade.core.mp.base.BaseServiceImpl;
@@ -38,13 +44,17 @@
import org.springblade.system.user.entity.User;
import org.springblade.system.user.enums.UserEnum;
import org.springblade.system.user.feign.IUserClient;
import org.springblade.system.vo.TenantVO;
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 org.springframework.web.bind.annotation.PostMapping;

import java.util.ArrayList;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import javax.annotation.PostConstruct;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;

import static org.springblade.common.constant.TenantConstant.*;
@@ -56,7 +66,7 @@
 * @author Chill
 */
@Service
@AllArgsConstructor
@RequiredArgsConstructor
public class TenantServiceImpl extends BaseServiceImpl<TenantMapper, Tenant> implements ITenantService {

   private final TenantId tenantId;
@@ -67,6 +77,25 @@
   private final IRoleMenuService roleMenuService;
   private final IDictBizService dictBizService;
   private final IUserClient userClient;
   /**
    * 获取是否允许自行控制三员是否开启
    */
   @Value("${ssa.ssa-enable}")
   private Boolean ssaEnable;
   /**
    * 获取默认三员管理员的名称
    */
   @Value("#{'${ssa.ssa-names}'.split(',')}")
   private List<String> ssaNames;
   /**
    * 三员管理菜单配置
    */
   @Value("#{'${ssa.sys-menus}'.split(',')}")
   private List<String> sysMenus;
   @Value("#{'${ssa.sec-menus}'.split(',')}")
   private List<String> secMenus;
   @Value("#{'${ssa.audit-menus}'.split(',')}")
   private List<String> auditMenus;

   @Override
   public IPage<Tenant> selectTenantPage(IPage<Tenant> page, Tenant tenant) {
@@ -80,82 +109,79 @@

   @Override
   @Transactional(rollbackFor = Exception.class)
   public boolean submitTenant(Tenant tenant) {
   public boolean submitTenant(TenantVO tenant) {
      if (Func.isEmpty(tenant.getId())) {
         // 获取到未删除租户总数，生成新的租户id
         List<Tenant> tenants = baseMapper.selectList(Wrappers.<Tenant>query().lambda().eq(Tenant::getIsDeleted, BladeConstant.DB_NOT_DELETED));
         List<String> codes = tenants.stream().map(Tenant::getTenantId).collect(Collectors.toList());
         String tenantId = getTenantId(codes);
         tenant.setTenantId(tenantId);
         // 获取参数配置的账号额度
         int accountNumber = Func.toInt(ParamCache.getValue(ACCOUNT_NUMBER_KEY), DEFAULT_ACCOUNT_NUMBER);
         tenant.setAccountNumber(accountNumber);
         // 新建租户对应的默认角色
         Role role = new Role();
         role.setTenantId(tenantId);
         role.setParentId(BladeConstant.TOP_PARENT_ID);
         role.setRoleName("管理员");
         role.setRoleAlias("admin");
         role.setSort(2);
         role.setIsDeleted(BladeConstant.DB_NOT_DELETED);
         roleService.save(role);
         // 新建租户对应的角色菜单权限
         LinkedList<Menu> userMenus = new LinkedList<>();
         // 获取参数配置的默认菜单集合，逗号隔开
         List<String> menuCodes = Func.toStrList(ParamCache.getValue(ACCOUNT_MENU_CODE_KEY));
         List<Menu> menus = getMenus((menuCodes.size() > 0 ? menuCodes : MENU_CODES), userMenus);
         List<RoleMenu> roleMenus = new ArrayList<>();
         menus.forEach(menu -> {
            RoleMenu roleMenu = new RoleMenu();
            roleMenu.setMenuId(menu.getId());
            roleMenu.setRoleId(role.getId());
            roleMenus.add(roleMenu);
         });
         roleMenuService.saveBatch(roleMenus);
         // 新建租户对应的默认部门
         Dept dept = new Dept();
         dept.setTenantId(tenantId);
         dept.setParentId(BladeConstant.TOP_PARENT_ID);
         dept.setAncestors(String.valueOf(BladeConstant.TOP_PARENT_ID));
         dept.setDeptName(tenant.getTenantName());
         dept.setFullName(tenant.getTenantName());
         dept.setDeptCategory(1);
         dept.setSort(2);
         dept.setIsDeleted(BladeConstant.DB_NOT_DELETED);
         deptService.save(dept);
         // 新建租户对应的默认岗位
         Post post = new Post();
         post.setTenantId(tenantId);
         post.setCategory(1);
         post.setPostCode("ceo");
         post.setPostName("首席执行官");
         post.setSort(1);
         postService.save(post);
         // 新建租户对应的默认业务字典
         LinkedList<DictBiz> dictBizs = new LinkedList<>();
         List<DictBiz> dictBizList = getDictBizs(tenantId, dictBizs);
         dictBizService.saveBatch(dictBizList);
         // 新建租户对应的默认管理用户
         User user = new User();
         user.setTenantId(tenantId);
         user.setName("admin");
         user.setRealName("admin");
         user.setAccount("admin");
         // 获取参数配置的密码
         String password = Func.toStr(ParamCache.getValue(PASSWORD_KEY), DEFAULT_PASSWORD);
         user.setPassword(password);
         user.setRoleId(String.valueOf(role.getId()));
         user.setDeptId(String.valueOf(dept.getId()));
         user.setPostId(String.valueOf(post.getId()));
         user.setBirthday(new Date());
         user.setSex(1);
         user.setUserType(UserEnum.WEB.getCategory());
         user.setIsDeleted(BladeConstant.DB_NOT_DELETED);
         boolean temp = super.saveOrUpdate(tenant);
         R<Boolean> result = userClient.saveUser(user);
         if (!result.isSuccess()) {
            throw new ServiceException(result.getMsg());
         // 配置为false，并且前端传输的参数为false就不需要创建三员
         if(!this.ssaEnable && !tenant.getMembersFlag()){
            // 不开启三员管理时直接创建一个最高权限的管理员
            Role role = new Role(tenantId,BladeConstant.TOP_PARENT_ID,"超级管理员",1,"admin",BladeConstant.DB_NOT_DELETED);
            roleService.save(role);
            // 新建租户对应的角色菜单权限
            saveRoleMenus(role, MENU_CODES);
            // 新建租户对应的默认部门
            Dept dept = generateDept(tenantId, tenant);
            deptService.save(dept);
            // 新建租户对应的默认岗位
            Post postInfo = generatePost(tenantId, 1, "ceo", "首席执行官", 1);
            postService.save(postInfo);
            // 新建租户对应的默认业务字典
            LinkedList<DictBiz> dictBizs = new LinkedList<>();
            List<DictBiz> dictBizList = getDictBizs(tenantId, dictBizs);
            dictBizService.saveBatch(dictBizList);
            // 新建租户对应的默认管理用户
            User userInfo = generateUser(tenantId, role, dept, postInfo);
            // 先保存租户
            boolean temp = super.saveOrUpdate(tenant);
            // 创建用户
            R<Boolean> result = userClient.saveUser(userInfo);
            if (!result.isSuccess()) {
               throw new ServiceException(result.getMsg());
            }
            return temp;
         }else {
            // 新建租户对应的默认角色
            List<Role> roles = new ArrayList<>();
            Role roleSys = new Role(tenantId,BladeConstant.TOP_PARENT_ID,"系统管理员",1,this.ssaNames.get(0),BladeConstant.DB_NOT_DELETED);
            Role roleSec = new Role(tenantId,BladeConstant.TOP_PARENT_ID,"安全管理员",2,this.ssaNames.get(1),BladeConstant.DB_NOT_DELETED);
            Role roleAudit = new Role(tenantId,BladeConstant.TOP_PARENT_ID,"审计管理员",3,this.ssaNames.get(2),BladeConstant.DB_NOT_DELETED);
            roles.add(roleSys);
            roles.add(roleSec);
            roles.add(roleAudit);
            roleService.saveBatch(roles);
            // 新建租户对应的角色菜单权限
            saveRoleMenus(roleSys,this.sysMenus); //系统管理员角色菜单权限
            saveRoleMenus(roleSec,this.secMenus); //安全管理员角色菜单权限
            saveRoleMenus(roleAudit,this.auditMenus); //审计管理员角色菜单权限
            // 新建租户对应的默认部门
            Dept dept = generateDept(tenantId, tenant);
            deptService.save(dept);
            // 新建租户对应的默认岗位
            Post postCeo = generatePost(tenantId, 1, "sysAdmin", "系统管理员", 1);
            Post postCto = generatePost(tenantId,1,"secAdmin","安全管理员",4);
            Post postCio = generatePost(tenantId,1,"auditAdmin","审计管理员",5);
            postService.saveBatch(Arrays.asList(postCeo,postCto,postCio));
            // 新建租户对应的默认业务字典
            LinkedList<DictBiz> dictBizs = new LinkedList<>();
            List<DictBiz> dictBizList = getDictBizs(tenantId, dictBizs);
            dictBizService.saveBatch(dictBizList);
            // 新建租户对应的默认管理用户
            User userSys = generateUser(tenantId, roleSys, dept, postCeo);
            User userSec = generateUser(tenantId,roleSec,dept,postCto);
            User userAudit = generateUser(tenantId,roleAudit,dept,postCio);
            // 先保存租户
            boolean temp = super.saveOrUpdate(tenant);
            // 创建用户
            R<Boolean> result = userClient.saveUserList(Arrays.asList(userSys,userSec,userAudit));
            if (!result.isSuccess()) {
               throw new ServiceException(result.getMsg());
            }
            return temp;
         }
         return temp;
      } else {
         CacheUtil.clear(SYS_CACHE, tenant.getTenantId());
         return super.saveOrUpdate(tenant);
@@ -180,22 +206,87 @@
   }

   @Override
   public boolean setting(Integer accountNumber, Date expireTime, String ids) {
      List<String> tenantIds = this.list(Wrappers.<Tenant>query().lambda().in(Tenant::getId, ids))
         .stream().map(tenant -> Func.toStr(tenant.getTenantId())).distinct().collect(Collectors.toList());
      CacheUtil.clear(SYS_CACHE, tenantIds);
      Func.toLongList(ids).forEach(id -> {
         Kv kv = Kv.create().set("accountNumber", accountNumber).set("expireTime", expireTime).set("id", id);
         String licenseKey = DesUtil.encryptToHex(JsonUtil.toJson(kv), DES_KEY);
         update(
            Wrappers.<Tenant>update().lambda()
               .set(Tenant::getAccountNumber, accountNumber)
               .set(Tenant::getExpireTime, expireTime)
               .set(Tenant::getLicenseKey, licenseKey)
               .eq(Tenant::getId, id)
         );
   public List<Map<String,Object>> selectMaps(){
      List<Map<String, Object>> maps = listMaps(new QueryWrapper<Tenant>().select("TENANT_ID", "TENANT_NAME"));
      System.out.println(maps);
      return maps;
   }

   @Override
   public boolean findIsOpen() {
      return this.ssaEnable;
   }

   /**
    * 创建租户下的默认岗位
    * @param tenantId
    * @param sort
    */
   private Post generatePost(String tenantId,Integer categ,String postCode,String postName,Integer sort){
      Post post = new Post();
      post.setTenantId(tenantId);
      post.setCategory(categ);
      post.setPostCode(postCode);
      post.setPostName(postName);
      post.setSort(sort);
      return post;
   }

   /**
    * 创建默认用户，并进行相关权限设置
    */
   private User generateUser(String tenantId, Role role, Dept dept, Post post){
      User user = new User();
      user.setTenantId(tenantId);
      user.setName(role.getRoleAlias());
      user.setRealName(role.getRoleName());
      user.setAccount(role.getRoleAlias());
      // 获取参数配置的密码
      String password = Func.toStr(ParamCache.getValue(PASSWORD_KEY), DEFAULT_PASSWORD);
      user.setPassword(password);
      user.setRoleId(String.valueOf(role.getId()));
      user.setDeptId(String.valueOf(dept.getId()));
      user.setPostId(String.valueOf(post.getId()));
      user.setBirthday(new Date());
      user.setSex(1);
      user.setUserType(UserEnum.WEB.getCategory());
      user.setIsDeleted(BladeConstant.DB_NOT_DELETED);
      return user;
   }

   /**
    * 保存用户对应的关联信息
    * @param role
    */
   private void saveRoleMenus(Role role,List<String> stringMenus){
      LinkedList<Menu> userMenus = new LinkedList<>();
      // 获取参数配置的默认菜单集合，逗号隔开
      List<String> menuCodes = Func.toStrList(ParamCache.getValue(ACCOUNT_MENU_CODE_KEY));
      List<Menu> menus = getMenus((menuCodes.size() > 0 ? menuCodes : stringMenus), userMenus);
      List<RoleMenu> roleMenus = new ArrayList<>();
      //创建所有菜单角色关联对象
      menus.forEach(menu -> {
         roleMenus.add(new RoleMenu(menu.getId(),role.getId()));
      });
      return true;
      roleMenuService.saveBatch(roleMenus);
   }

   /**
    * 创建默认部门
    * @param tenantId
    * @param tenant
    */
   private Dept generateDept(String tenantId,Tenant tenant){
      Dept dept = new Dept();
      dept.setTenantId(tenantId);
      dept.setParentId(BladeConstant.TOP_PARENT_ID);
      dept.setAncestors(String.valueOf(BladeConstant.TOP_PARENT_ID));
      dept.setDeptName(tenant.getTenantName());
      dept.setFullName(tenant.getTenantName());
      dept.setDeptCategory(1);
      dept.setSort(2);
      dept.setIsDeleted(BladeConstant.DB_NOT_DELETED);
      return dept;
   }

   private String getTenantId(List<String> codes) {
@@ -248,6 +339,5 @@
         recursionDictBiz(tenantId, oldSubParentId, newSubParentId, dictBizs);
      });
   }


}