shayu/dk-sass-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
77
2024-05-14 18:54:08 +08:00
parent 517d91a0a8
commit 874b33557d
71 changed files with 1637 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
ruoyi-system/src/main/java/com/ruoyi/system/service/ISysTenantPackageService.java Normal file
View File

@@ -0,0 +1,57 @@
package com.ruoyi.system.service;
import com.ruoyi.component.mybatis.core.page.PageQuery;
import com.ruoyi.component.mybatis.core.page.TableDataInfo;
import com.ruoyi.system.domain.bo.SysTenantPackageBo;
import com.ruoyi.system.domain.vo.SysTenantPackageVo;
import java.util.Collection;
import java.util.List;
/**
* 租户套餐Service接口
*
* @author Michelle.Chung
*/
public interface ISysTenantPackageService {
/**
* 查询租户套餐
*/
SysTenantPackageVo queryById(Long packageId);
/**
* 查询租户套餐列表
*/
TableDataInfo<SysTenantPackageVo> queryPageList(SysTenantPackageBo bo, PageQuery pageQuery);
/**
* 查询租户套餐已启用列表
*/
List<SysTenantPackageVo> selectList();
/**
* 查询租户套餐列表
*/
List<SysTenantPackageVo> queryList(SysTenantPackageBo bo);
/**
* 新增租户套餐
*/
Boolean insertByBo(SysTenantPackageBo bo);
/**
* 修改租户套餐
*/
Boolean updateByBo(SysTenantPackageBo bo);
/**
* 修改套餐状态
*/
int updatePackageStatus(SysTenantPackageBo bo);
/**
* 校验并批量删除租户套餐信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

82
ruoyi-system/src/main/java/com/ruoyi/system/service/ISysTenantService.java Normal file
View File

@@ -0,0 +1,82 @@
package com.ruoyi.system.service;
import com.ruoyi.component.mybatis.core.page.PageQuery;
import com.ruoyi.component.mybatis.core.page.TableDataInfo;
import com.ruoyi.system.domain.bo.SysTenantBo;
import com.ruoyi.system.domain.vo.SysTenantVo;
import java.util.Collection;
import java.util.List;
/**
* 租户Service接口
*
* @author Michelle.Chung
*/
public interface ISysTenantService {
/**
* 查询租户
*/
SysTenantVo queryById(Long id);
/**
* 基于租户ID查询租户
*/
SysTenantVo queryByTenantId(String tenantId);
/**
* 查询租户列表
*/
TableDataInfo<SysTenantVo> queryPageList(SysTenantBo bo, PageQuery pageQuery);
/**
* 查询租户列表
*/
List<SysTenantVo> queryList(SysTenantBo bo);
/**
* 新增租户
*/
Boolean insertByBo(SysTenantBo bo);
/**
* 修改租户
*/
Boolean updateByBo(SysTenantBo bo);
/**
* 修改租户状态
*/
int updateTenantStatus(SysTenantBo bo);
/**
* 校验租户是否允许操作
*/
void checkTenantAllowed(String tenantId);
/**
* 校验并批量删除租户信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
/**
* 校验企业名称是否唯一
*/
boolean checkCompanyNameUnique(SysTenantBo bo);
/**
* 校验账号余额
*/
boolean checkAccountBalance(String tenantId);
/**
* 校验有效期
*/
boolean checkExpireTime(String tenantId);
/**
* 同步租户套餐
*/
Boolean syncTenantPackage(String tenantId, Long packageId);
}

146
ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysTenantPackageServiceImpl.java Normal file
View File

@@ -0,0 +1,146 @@
package com.ruoyi.system.service.impl;
import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.component.core.constant.TenantConstants;
import com.ruoyi.component.core.exception.ServiceException;
import com.ruoyi.component.core.util.BeanConvertUtil;
import com.ruoyi.component.core.util.StringUtils;
import com.ruoyi.component.mybatis.core.page.PageQuery;
import com.ruoyi.component.mybatis.core.page.TableDataInfo;
import com.ruoyi.system.domain.SysTenant;
import com.ruoyi.system.domain.SysTenantPackage;
import com.ruoyi.system.domain.bo.SysTenantPackageBo;
import com.ruoyi.system.domain.vo.SysTenantPackageVo;
import com.ruoyi.system.mapper.SysTenantMapper;
import com.ruoyi.system.mapper.SysTenantPackageMapper;
import com.ruoyi.system.service.ISysTenantPackageService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
/**
* 租户套餐Service业务层处理
*
* @author Michelle.Chung
*/
@Service
public class SysTenantPackageServiceImpl implements ISysTenantPackageService {
@Resource
private SysTenantPackageMapper baseMapper;
@Resource
private SysTenantMapper tenantMapper;
/**
* 查询租户套餐
*/
@Override
public SysTenantPackageVo queryById(Long packageId){
return baseMapper.selectVoById(packageId);
}
/**
* 查询租户套餐列表
*/
@Override
public TableDataInfo<SysTenantPackageVo> queryPageList(SysTenantPackageBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<SysTenantPackage> lqw = buildQueryWrapper(bo);
Page<SysTenantPackageVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
@Override
public List<SysTenantPackageVo> selectList() {
return baseMapper.selectVoList(new LambdaQueryWrapper<SysTenantPackage>()
.eq(SysTenantPackage::getStatus, TenantConstants.NORMAL));
}
/**
* 查询租户套餐列表
*/
@Override
public List<SysTenantPackageVo> queryList(SysTenantPackageBo bo) {
LambdaQueryWrapper<SysTenantPackage> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<SysTenantPackage> buildQueryWrapper(SysTenantPackageBo bo) {
LambdaQueryWrapper<SysTenantPackage> lqw = Wrappers.lambdaQuery();
lqw.like(StringUtils.isNotBlank(bo.getPackageName()), SysTenantPackage::getPackageName, bo.getPackageName());
lqw.eq(StringUtils.isNotBlank(bo.getStatus()), SysTenantPackage::getStatus, bo.getStatus());
lqw.orderByAsc(SysTenantPackage::getPackageId);
return lqw;
}
/**
* 新增租户套餐
*/
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean insertByBo(SysTenantPackageBo bo) {
SysTenantPackage add = BeanConvertUtil.convertTo(bo, SysTenantPackage::new);
// 保存菜单id
List<Long> menuIds = Arrays.asList(bo.getMenuIds());
if (CollUtil.isNotEmpty(menuIds)) {
add.setMenuIds(StringUtils.join(menuIds, ", "));
} else {
add.setMenuIds("");
}
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setPackageId(add.getPackageId());
}
return flag;
}
/**
* 修改租户套餐
*/
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean updateByBo(SysTenantPackageBo bo) {
SysTenantPackage update = BeanConvertUtil.convertTo(bo, SysTenantPackage::new);
// 保存菜单id
List<Long> menuIds = Arrays.asList(bo.getMenuIds());
if (CollUtil.isNotEmpty(menuIds)) {
update.setMenuIds(StringUtils.join(menuIds, ", "));
} else {
update.setMenuIds("");
}
return baseMapper.updateById(update) > 0;
}
/**
* 修改套餐状态
*
* @param bo 套餐信息
* @return 结果
*/
@Override
public int updatePackageStatus(SysTenantPackageBo bo) {
SysTenantPackage tenantPackage = BeanConvertUtil.convertTo(bo, SysTenantPackage::new);
return baseMapper.updateById(tenantPackage);
}
/**
* 批量删除租户套餐
*/
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
boolean exists = tenantMapper.exists(new LambdaQueryWrapper<SysTenant>().in(SysTenant::getPackageId, ids));
if (exists) {
throw new ServiceException("租户套餐已被使用");
}
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

382
ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysTenantServiceImpl.java Normal file
View File

@@ -0,0 +1,382 @@
package com.ruoyi.system.service.impl;
import cn.dev33.satoken.secure.BCrypt;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.RandomUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.component.core.constant.CacheNames;
import com.ruoyi.component.core.constant.Constants;
import com.ruoyi.component.core.constant.TenantConstants;
import com.ruoyi.component.core.exception.ServiceException;
import com.ruoyi.component.core.util.BeanConvertUtil;
import com.ruoyi.component.core.util.StringUtils;
import com.ruoyi.component.core.util.spring.SpringUtils;
import com.ruoyi.component.mybatis.core.page.PageQuery;
import com.ruoyi.component.mybatis.core.page.TableDataInfo;
import com.ruoyi.system.domain.*;
import com.ruoyi.system.domain.bo.SysTenantBo;
import com.ruoyi.system.domain.vo.SysTenantVo;
import com.ruoyi.system.mapper.*;
import com.ruoyi.system.service.ISysTenantService;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
/**
* 租户Service业务层处理
*
* @author Michelle.Chung
*/
@Service
public class SysTenantServiceImpl implements ISysTenantService {
@Resource
private SysTenantMapper baseMapper;
@Resource
private SysTenantPackageMapper tenantPackageMapper;
@Resource
private SysUserMapper userMapper;
@Resource
private SysDeptMapper deptMapper;
@Resource
private SysRoleMapper roleMapper;
@Resource
private SysRoleMenuMapper roleMenuMapper;
@Resource
private SysRoleDeptMapper roleDeptMapper;
@Resource
private SysUserRoleMapper userRoleMapper;
@Resource
private SysDictTypeMapper dictTypeMapper;
@Resource
private SysDictDataMapper dictDataMapper;
@Resource
private SysConfigMapper configMapper;
/**
* 查询租户
*/
@Override
public SysTenantVo queryById(Long id) {
return baseMapper.selectVoById(id);
}
/**
* 基于租户ID查询租户
*/
@Cacheable(cacheNames = CacheNames.SYS_TENANT, key = "#tenantId")
@Override
public SysTenantVo queryByTenantId(String tenantId) {
return baseMapper.selectVoOne(new LambdaQueryWrapper<SysTenant>().eq(SysTenant::getTenantId, tenantId));
}
/**
* 查询租户列表
*/
@Override
public TableDataInfo<SysTenantVo> queryPageList(SysTenantBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<SysTenant> lqw = buildQueryWrapper(bo);
Page<SysTenantVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询租户列表
*/
@Override
public List<SysTenantVo> queryList(SysTenantBo bo) {
LambdaQueryWrapper<SysTenant> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<SysTenant> buildQueryWrapper(SysTenantBo bo) {
LambdaQueryWrapper<SysTenant> lqw = Wrappers.lambdaQuery();
lqw.eq(StringUtils.isNotBlank(bo.getTenantId()), SysTenant::getTenantId, bo.getTenantId());
lqw.like(StringUtils.isNotBlank(bo.getContactUserName()), SysTenant::getContactUserName, bo.getContactUserName());
lqw.eq(StringUtils.isNotBlank(bo.getContactPhone()), SysTenant::getContactPhone, bo.getContactPhone());
lqw.like(StringUtils.isNotBlank(bo.getCompanyName()), SysTenant::getCompanyName, bo.getCompanyName());
lqw.eq(StringUtils.isNotBlank(bo.getLicenseNumber()), SysTenant::getLicenseNumber, bo.getLicenseNumber());
lqw.eq(StringUtils.isNotBlank(bo.getAddress()), SysTenant::getAddress, bo.getAddress());
lqw.eq(StringUtils.isNotBlank(bo.getIntro()), SysTenant::getIntro, bo.getIntro());
lqw.like(StringUtils.isNotBlank(bo.getDomain()), SysTenant::getDomain, bo.getDomain());
lqw.eq(bo.getPackageId() != null, SysTenant::getPackageId, bo.getPackageId());
lqw.eq(bo.getExpireTime() != null, SysTenant::getExpireTime, bo.getExpireTime());
lqw.eq(bo.getAccountCount() != null, SysTenant::getAccountCount, bo.getAccountCount());
lqw.eq(StringUtils.isNotBlank(bo.getStatus()), SysTenant::getStatus, bo.getStatus());
lqw.orderByAsc(SysTenant::getId);
return lqw;
}
/**
* 新增租户
*/
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean insertByBo(SysTenantBo bo) {
SysTenant add = BeanConvertUtil.convertTo(bo, SysTenant::new);
// 获取所有租户编号
List<String> tenantIds = baseMapper.selectObjs(
new LambdaQueryWrapper<SysTenant>().select(SysTenant::getTenantId));
String tenantId = generateTenantId(tenantIds);
add.setTenantId(tenantId);
boolean flag = baseMapper.insert(add) > 0;
if (!flag) {
throw new ServiceException("创建租户失败");
}
bo.setId(add.getId());
// 根据套餐创建角色
Long roleId = createTenantRole(tenantId, bo.getPackageId());
// 创建部门: 公司名是部门名称
SysDept dept = new SysDept();
dept.setTenantId(tenantId);
dept.setDeptName(bo.getCompanyName());
dept.setParentId(Constants.TOP_PARENT_ID);
dept.setAncestors(Constants.TOP_PARENT_ID.toString());
deptMapper.insert(dept);
Long deptId = dept.getDeptId();
// 角色和部门关联表
SysRoleDept roleDept = new SysRoleDept();
roleDept.setRoleId(roleId);
roleDept.setDeptId(deptId);
roleDeptMapper.insert(roleDept);
// 创建系统用户
SysUser user = new SysUser();
user.setTenantId(tenantId);
user.setUserName(bo.getUsername());
user.setNickName(bo.getUsername());
user.setPassword(BCrypt.hashpw(bo.getPassword()));
user.setDeptId(deptId);
userMapper.insert(user);
//新增系统用户后，默认当前用户为部门的负责人
SysDept sd = new SysDept();
sd.setLeader(user.getUserName());
sd.setDeptId(deptId);
deptMapper.updateById(sd);
// 用户和角色关联表
SysUserRole userRole = new SysUserRole();
userRole.setUserId(user.getUserId());
userRole.setRoleId(roleId);
userRoleMapper.insert(userRole);
String defaultTenantId = TenantConstants.DEFAULT_TENANT_ID;
List<SysDictType> dictTypeList = dictTypeMapper.selectList(
new LambdaQueryWrapper<SysDictType>().eq(SysDictType::getTenantId, defaultTenantId));
List<SysDictData> dictDataList = dictDataMapper.selectList(
new LambdaQueryWrapper<SysDictData>().eq(SysDictData::getTenantId, defaultTenantId));
for (SysDictType dictType : dictTypeList) {
dictType.setDictId(null);
dictType.setTenantId(tenantId);
}
for (SysDictData dictData : dictDataList) {
dictData.setDictCode(null);
dictData.setTenantId(tenantId);
}
dictTypeMapper.insertBatch(dictTypeList);
dictDataMapper.insertBatch(dictDataList);
List<SysConfig> sysConfigList = configMapper.selectList(
new LambdaQueryWrapper<SysConfig>().eq(SysConfig::getTenantId, defaultTenantId));
for (SysConfig config : sysConfigList) {
config.setConfigId(null);
config.setTenantId(tenantId);
}
configMapper.insertBatch(sysConfigList);
return true;
}
/**
* 生成租户id
*
* @param tenantIds 已有租户id列表
* @return 租户id
*/
private String generateTenantId(List<String> tenantIds) {
// 随机生成6位
String numbers = RandomUtil.randomNumbers(6);
// 判断是否存在，如果存在则重新生成
if (tenantIds.contains(numbers)) {
generateTenantId(tenantIds);
}
return numbers;
}
/**
* 根据租户菜单创建租户角色
*
* @param tenantId 租户编号
* @param packageId 租户套餐id
* @return 角色id
*/
private Long createTenantRole(String tenantId, Long packageId) {
// 获取租户套餐
SysTenantPackage tenantPackage = tenantPackageMapper.selectById(packageId);
if (ObjectUtil.isNull(tenantPackage)) {
throw new ServiceException("套餐不存在");
}
// 获取套餐菜单id
List<Long> menuIds = StringUtils.splitTo(tenantPackage.getMenuIds(), Convert::toLong);
// 创建角色
SysRole role = new SysRole();
role.setTenantId(tenantId);
role.setRoleName(TenantConstants.TENANT_ADMIN_ROLE_NAME);
role.setRoleKey(TenantConstants.TENANT_ADMIN_ROLE_KEY);
role.setRoleSort(1);
role.setStatus(TenantConstants.NORMAL);
roleMapper.insert(role);
Long roleId = role.getRoleId();
// 创建角色菜单
List<SysRoleMenu> roleMenus = new ArrayList<>(menuIds.size());
menuIds.forEach(menuId -> {
SysRoleMenu roleMenu = new SysRoleMenu();
roleMenu.setRoleId(roleId);
roleMenu.setMenuId(menuId);
roleMenus.add(roleMenu);
});
roleMenuMapper.insertBatch(roleMenus);
return roleId;
}
/**
* 修改租户
*/
@CacheEvict(cacheNames = CacheNames.SYS_TENANT, key = "#bo.tenantId")
@Override
public Boolean updateByBo(SysTenantBo bo) {
SysTenant tenant = BeanConvertUtil.convertTo(bo, SysTenant::new);
tenant.setTenantId(null);
tenant.setPackageId(null);
return baseMapper.updateById(tenant) > 0;
}
/**
* 修改租户状态
*
* @param bo 租户信息
* @return 结果
*/
@CacheEvict(cacheNames = CacheNames.SYS_TENANT, key = "#bo.tenantId")
@Override
public int updateTenantStatus(SysTenantBo bo) {
SysTenant tenant = BeanConvertUtil.convertTo(bo, SysTenant::new);
return baseMapper.updateById(tenant);
}
/**
* 校验租户是否允许操作
*
* @param tenantId 租户ID
*/
@Override
public void checkTenantAllowed(String tenantId) {
if (ObjectUtil.isNotNull(tenantId) && TenantConstants.DEFAULT_TENANT_ID.equals(tenantId)) {
throw new ServiceException("不允许操作管理租户");
}
}
/**
* 批量删除租户
*/
@CacheEvict(cacheNames = CacheNames.SYS_TENANT, allEntries = true)
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if (isValid) {
// 做一些业务上的校验,判断是否需要校验
if (ids.contains(TenantConstants.SUPER_ADMIN_ID)) {
throw new ServiceException("超管租户不能删除");
}
}
return baseMapper.deleteBatchIds(ids) > 0;
}
/**
* 校验企业名称是否唯一
*/
@Override
public boolean checkCompanyNameUnique(SysTenantBo bo) {
boolean exist = baseMapper.exists(new LambdaQueryWrapper<SysTenant>()
.eq(SysTenant::getCompanyName, bo.getCompanyName())
.ne(ObjectUtil.isNotNull(bo.getTenantId()), SysTenant::getTenantId, bo.getTenantId()));
return !exist;
}
/**
* 校验账号余额
*/
@Override
public boolean checkAccountBalance(String tenantId) {
SysTenantVo tenant = SpringUtils.getAopProxy(this).queryByTenantId(tenantId);
// 如果余额为-1代表不限制
if (tenant.getAccountCount() == -1) {
return true;
}
Long userNumber = userMapper.selectCount(new LambdaQueryWrapper<>());
// 如果余额大于0代表还有可用名额
return tenant.getAccountCount() - userNumber > 0;
}
/**
* 校验有效期
*/
@Override
public boolean checkExpireTime(String tenantId) {
SysTenantVo tenant = SpringUtils.getAopProxy(this).queryByTenantId(tenantId);
// 如果未设置过期时间代表不限制
if (ObjectUtil.isNull(tenant.getExpireTime())) {
return true;
}
// 如果当前时间在过期时间之前则通过
return new Date().before(tenant.getExpireTime());
}
/**
* 同步租户套餐
*/
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean syncTenantPackage(String tenantId, Long packageId) {
SysTenantPackage tenantPackage = tenantPackageMapper.selectById(packageId);
List<SysRole> roles = roleMapper.selectList(
new LambdaQueryWrapper<SysRole>().eq(SysRole::getTenantId, tenantId));
List<Long> roleIds = new ArrayList<>(roles.size() - 1);
List<Long> menuIds = StringUtils.splitTo(tenantPackage.getMenuIds(), Convert::toLong);
roles.forEach(item -> {
if (TenantConstants.TENANT_ADMIN_ROLE_KEY.equals(item.getRoleKey())) {
List<SysRoleMenu> roleMenus = new ArrayList<>(menuIds.size());
menuIds.forEach(menuId -> {
SysRoleMenu roleMenu = new SysRoleMenu();
roleMenu.setRoleId(item.getRoleId());
roleMenu.setMenuId(menuId);
roleMenus.add(roleMenu);
});
roleMenuMapper.delete(new LambdaQueryWrapper<SysRoleMenu>().eq(SysRoleMenu::getRoleId, item.getRoleId()));
roleMenuMapper.insertBatch(roleMenus);
} else {
roleIds.add(item.getRoleId());
}
});
if (!roleIds.isEmpty()) {
roleMenuMapper.delete(
new LambdaQueryWrapper<SysRoleMenu>().in(SysRoleMenu::getRoleId, roleIds).notIn(!menuIds.isEmpty(), SysRoleMenu::getMenuId, menuIds));
}
return true;
}
}