github
/
jeecg-boot
mirror of https://github.com/jeecgboot/jeecg-boot
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

【v3.8.3】租户大改造

pull/8786/merge
JEECG 2025-09-14 11:50:37 +08:00
parent 7829cf18d7
commit 1cf4054e76
7 changed files with 301 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/mapper/SysTenantPackMapper.java
View File

@ -3,6 +3,7 @@ package org.jeecg.modules.system.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.jeecg.modules.system.entity.SysTenantPack;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
@ -20,4 +21,12 @@ public interface SysTenantPackMapper extends BaseMapper<SysTenantPack> {
* @param tenantIdList
*/
void deletePackByTenantIds(@Param("tenantIdList") List<Integer> tenantIdList);
/**
* 根据租户id和产品包的code获取租户套餐id
*
* @param tenantId
*/
@Select("select id from sys_tenant_pack where tenant_id = #{tenantId} and (pack_code not in('superAdmin','accountAdmin','appAdmin') or pack_code is null) and iz_sysn = '1'")
List<String> getPackIdByPackCodeAndTenantId(@Param("tenantId") Integer tenantId);
}

21
jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/mapper/SysTenantPackUserMapper.java
View File

@ -3,6 +3,8 @@ package org.jeecg.modules.system.mapper;
import com.baomidou.mybatisplus.annotation.InterceptorIgnore;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.jeecg.modules.system.entity.SysTenantPack;
import org.jeecg.modules.system.entity.SysTenantPackUser;
import java.util.List;
@ -44,4 +46,23 @@ public interface SysTenantPackUserMapper extends BaseMapper<SysTenantPackUser> {
* @param
*/
void deletePackUserByTenantIds(@Param("tenantIds") List<Integer> tenantIds);
/**
* 根据用户id和租户id获取当前租户用户下的产品包id
*
* @param tenantId
* @param userId
* @return
*/
@Select("select pack_id from sys_tenant_pack_user where tenant_id = #{tenantId} and user_id = #{userId}")
List<String> getPackIdByTenantIdAndUserId(@Param("tenantId") Integer tenantId, @Param("userId") String userId);
/**
* 根据租户id获取用户的产品包列表
*
* @param tenantId
* @return
*/
@Select("select id,pack_name,pack_code,pack_type from sys_tenant_pack where tenant_id = #{tenantId}")
List<SysTenantPack> getPackListByTenantId(@Param("tenantId") Integer tenantId);
}

2
jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/mapper/xml/SysUserTenantMapper.xml
View File

@ -70,7 +70,7 @@
<!--联查用户和租户审核状态-->
<select id="getUserTenantPageList" resultType="org.jeecg.modules.system.vo.SysUserTenantVo">
SELECT su.id,su.realname,su.username,su.email,su.phone,su.avatar,su.work_no,su.org_code,sut.status,st.create_by
SELECT su.id,su.realname,su.username,su.email,su.phone,su.avatar,su.work_no,su.org_code,sut.status,su.create_time,st.create_by
FROM sys_user_tenant sut
RIGHT JOIN sys_user su on sut.user_id = su.id and su.del_flag = 0
JOIN sys_tenant st ON sut.tenant_id = st.id

17
jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysTenantPackService.java
View File

@ -87,4 +87,21 @@ public interface ISysTenantPackService extends IService<SysTenantPack> {
* @date 2025/2/5 19:08
*/
void syncDefaultPack(Integer tenantId);
/**
* 根据用户id和当前的租户id获取产品包的id
*
* @param userId
* @param tenantId
* @return
*/
List<String> getPackIdByUserIdAndTenantId(String userId, Integer tenantId);
/**
* 根据租户id获取用户的产品包列表
*
* @param tenantId
* @return
*/
List<SysTenantPack> getPackListByTenantId(String tenantId);
}

7
jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysTenantService.java
View File

@ -240,4 +240,11 @@ public interface ISysTenantService extends IService<SysTenant> {
* @param tenantId
*/
void deleteUser(SysUser sysUser, Integer tenantId);
/**
* 为用户添加租户下所有套餐
* @param userId
* @param tenantId
*/
void addPackUser(String userId, String tenantId);
}

184
jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysTenantPackServiceImpl.java
View File

@ -1,7 +1,9 @@
package org.jeecg.modules.system.service.impl;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.RandomUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.constant.TenantConstant;
import org.jeecg.common.system.vo.LoginUser;
@ -9,13 +11,10 @@ import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.aop.TenantLog;
import org.jeecg.modules.system.entity.SysPackPermission;
import org.jeecg.modules.system.entity.SysTenant;
import org.jeecg.modules.system.entity.SysTenantPack;
import org.jeecg.modules.system.entity.SysTenantPackUser;
import org.jeecg.modules.system.mapper.SysPackPermissionMapper;
import org.jeecg.modules.system.mapper.SysRoleMapper;
import org.jeecg.modules.system.mapper.SysTenantPackMapper;
import org.jeecg.modules.system.mapper.SysTenantPackUserMapper;
import org.jeecg.modules.system.entity.SysUserTenant;
import org.jeecg.modules.system.mapper.*;
import org.jeecg.modules.system.service.ISysTenantPackService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
@ -51,8 +50,16 @@ public class SysTenantPackServiceImpl extends ServiceImpl<SysTenantPackMapper, S
@Autowired
private SysRoleMapper sysRoleMapper;
@Autowired
private SysUserTenantMapper sysUserTenantMapper;
@Override
public void addPackPermission(SysTenantPack sysTenantPack) {
//如果是默认租户套餐包，则需要设置code编码，再编辑默认套餐找自定义套餐的时候用到
if(CommonConstant.TENANT_PACK_DEFAULT.equals(sysTenantPack.getPackType())){
String packCode = CommonConstant.TENANT_PACK_DEFAULT + RandomUtil.randomNumbers(4).toLowerCase();
sysTenantPack.setPackCode(packCode);
}
sysTenantPackMapper.insert(sysTenantPack);
String permissionIds = sysTenantPack.getPermissionIds();
if (oConvertUtils.isNotEmpty(permissionIds)) {
@ -63,6 +70,48 @@ public class SysTenantPackServiceImpl extends ServiceImpl<SysTenantPackMapper, S
}
}
//如果是自定义套餐包的情况下再将新增套餐和用户关系
if(!CommonConstant.TENANT_PACK_DEFAULT.equals(sysTenantPack.getPackType())) {
//如果需要自动分配给用户时候再去添加用户与套餐的关系数据
if(oConvertUtils.isNotEmpty(sysTenantPack.getIzSysn()) && CommonConstant.STATUS_1.equals(sysTenantPack.getIzSysn())) {
//根据租户id和套餐id添加用户与套餐关系数据
this.addPackUserByPackTenantId(sysTenantPack.getTenantId(), sysTenantPack.getId());
}
}
}
/**
* 根据租户id和套餐id添加用户与套餐关系数据
*
* @param tenantId
* @param packId
*/
private void addPackUserByPackTenantId(Integer tenantId, String packId) {
if (null != tenantId && tenantId != 0) {
List<String> userIds = sysUserTenantMapper.getUserIdsByTenantId(tenantId);
if (CollectionUtil.isNotEmpty(userIds)) {
//update-begin---author:wangshuai---date:2025-09-03---for: 编辑时需要查看有没有未分配的用户---
// 查询已存在的用户
LambdaQueryWrapper<SysTenantPackUser> query = new LambdaQueryWrapper<>();
query.eq(SysTenantPackUser::getTenantId, tenantId);
query.eq(SysTenantPackUser::getPackId, packId);
query.in(SysTenantPackUser::getUserId, userIds);
List<SysTenantPackUser> existingUsers = sysTenantPackUserMapper.selectList(query);
// 提取已存在的用户ID
List<String> existingUserIds = existingUsers.stream()
.map(SysTenantPackUser::getUserId)
.toList();
// 过滤出需要新增的用户ID
List<String> newUserIds = userIds.stream()
.filter(userId -> !existingUserIds.contains(userId))
.toList();
for (String userId : newUserIds) {
//update-end---author:wangshuai---date:2025-09-03---for: 编辑时需要查看有没有未分配的用户---
SysTenantPackUser tenantPackUser = new SysTenantPackUser(tenantId, packId, userId);
sysTenantPackUserMapper.insert(tenantPackUser);
}
}
}
}
@Override
@ -86,9 +135,17 @@ public class SysTenantPackServiceImpl extends ServiceImpl<SysTenantPackMapper, S
//如果传过来的菜单id为空，那么就删除数据库中所有菜单
if (oConvertUtils.isEmpty(permissionIds)) {
this.deletePackPermission(sysTenantPack.getId(), null);
//如果是默认套餐包，需要删除其他关联默认产品包下的角色与菜单的关系
if(CommonConstant.TENANT_PACK_DEFAULT.equals(sysTenantPack.getPackType())){
this.deleteDefaultPackPermission(sysTenantPack.getPackCode(), null);
}
} else if (oConvertUtils.isNotEmpty(permissionIds) && oConvertUtils.isEmpty(oldPermissionIds)) {
//如果传过来的菜单id不为空但是数据库的菜单id为空，那么就新增
this.addPermission(sysTenantPack.getId(), permissionIds);
//如果是默认套餐包，需要新增其他关联默认产品包下的角色与菜单的关系
if(CommonConstant.TENANT_PACK_DEFAULT.equals(sysTenantPack.getPackType())){
this.addDefaultPackPermission(sysTenantPack.getPackCode(), permissionIds);
}
} else {
//都不为空，需要比较，进行添加或删除
if (oConvertUtils.isNotEmpty(oldPermissionIds)) {
@ -97,6 +154,10 @@ public class SysTenantPackServiceImpl extends ServiceImpl<SysTenantPackMapper, S
if (permissionList.size() > 0) {
for (String permission : permissionList) {
this.deletePackPermission(sysTenantPack.getId(), permission);
//如果是默认套餐包，需要删除其他关联默认产品包下的角色与菜单的关系
if(CommonConstant.TENANT_PACK_DEFAULT.equals(sysTenantPack.getPackType())){
this.deleteDefaultPackPermission(sysTenantPack.getPackCode(), permission);
}
}
}
@ -105,11 +166,29 @@ public class SysTenantPackServiceImpl extends ServiceImpl<SysTenantPackMapper, S
if (permissionAddList.size() > 0) {
for (String permission : permissionAddList) {
this.addPermission(sysTenantPack.getId(), permission);
//如果是默认套餐包，需要新增其他关联默认产品包下的角色与菜单的关系
if(CommonConstant.TENANT_PACK_DEFAULT.equals(sysTenantPack.getPackType())){
this.addDefaultPackPermission(sysTenantPack.getPackCode(), permission);
}
}
}
}
}
sysTenantPackMapper.updateById(sysTenantPack);
//如果是默认套餐包，则更新和当前匹配默认套餐包匹配的数据
if(CommonConstant.TENANT_PACK_DEFAULT.equals(sysTenantPack.getPackType())){
//同步同 packCode 下的相关套餐包数据
this.syncRelatedPackDataByDefaultPack(sysTenantPack);
}
//如果是自定义套餐包的情况下再将新增套餐和用户关系
if(!CommonConstant.TENANT_PACK_DEFAULT.equals(sysTenantPack.getPackType())) {
//如果需要自动分配给用户时候再去添加用户与套餐的关系数据
if(oConvertUtils.isNotEmpty(sysTenantPack.getIzSysn()) && CommonConstant.STATUS_1.equals(sysTenantPack.getIzSysn())) {
//根据租户id和套餐id添加用户与套餐关系数据
this.addPackUserByPackTenantId(sysTenantPack.getTenantId(), sysTenantPack.getId());
}
}
}
@Override
@ -134,7 +213,7 @@ public class SysTenantPackServiceImpl extends ServiceImpl<SysTenantPackMapper, S
ISysTenantPackService currentService = SpringContextUtils.getApplicationContext().getBean(ISysTenantPackService.class);
// 创建租户超级管理员
SysTenantPack superAdminPack = new SysTenantPack(tenantId, "超级管理员", TenantConstant.SUPER_ADMIN);
superAdminPack.setIzSysn(CommonConstant.STATUS_0);
//step.1 创建租户套餐包（超级管理员）
LambdaQueryWrapper<SysTenantPack> query = new LambdaQueryWrapper<>();
query.eq(SysTenantPack::getTenantId,tenantId);
@ -160,6 +239,7 @@ public class SysTenantPackServiceImpl extends ServiceImpl<SysTenantPackMapper, S
if(null == sysTenantPackAccountAdmin){
// 创建超级管理员
SysTenantPack accountAdminPack = new SysTenantPack(tenantId, "组织账户管理员", TenantConstant.ACCOUNT_ADMIN);
accountAdminPack.setIzSysn(CommonConstant.STATUS_0);
currentService.saveOne(accountAdminPack);
}
@ -170,6 +250,7 @@ public class SysTenantPackServiceImpl extends ServiceImpl<SysTenantPackMapper, S
if(null == sysTenantPackAppAdmin){
// 创建超级管理员
SysTenantPack appAdminPack = new SysTenantPack(tenantId, "组织应用管理员", TenantConstant.APP_ADMIN);
appAdminPack.setIzSysn(CommonConstant.STATUS_0);
currentService.saveOne(appAdminPack);
}
@ -287,6 +368,18 @@ public class SysTenantPackServiceImpl extends ServiceImpl<SysTenantPackMapper, S
packPermission.setPermissionId(permission);
sysPackPermissionMapper.insert(packPermission);
}
//如果需要自动分配给用户时候再去添加用户与套餐的关系数据
if(oConvertUtils.isNotEmpty(defaultPacks.getIzSysn()) && CommonConstant.STATUS_1.equals(defaultPacks.getIzSysn())) {
//查询当前租户下的用户
List<String> userIds = sysUserTenantMapper.getUserIdsByTenantId(tenantId);
if (oConvertUtils.isNotEmpty(userIds)) {
for (String userId : userIds) {
//根据租户id和套餐id添加用户与套餐关系数据
SysTenantPackUser tenantPackUser = new SysTenantPackUser(tenantId, pack.getId(), userId);
sysTenantPackUserMapper.insert(tenantPackUser);
}
}
}
}
/**
@ -298,4 +391,81 @@ public class SysTenantPackServiceImpl extends ServiceImpl<SysTenantPackMapper, S
query.eq(SysTenantPackUser::getPackId, packId);
sysTenantPackUserMapper.delete(query);
}
@Override
public List<String> getPackIdByUserIdAndTenantId(String userId, Integer tenantId) {
return sysTenantPackUserMapper.getPackIdByTenantIdAndUserId(tenantId, userId);
}
@Override
public List<SysTenantPack> getPackListByTenantId(String tenantId) {
return sysTenantPackUserMapper.getPackListByTenantId(oConvertUtils.getInt(tenantId));
}
/**
* 根据套餐包的code 新增其他关联默认产品包下的角色与菜单的关系
*
* @param packCode
* @param permission
*/
private void addDefaultPackPermission(String packCode, String permission) {
if (oConvertUtils.isEmpty(packCode)) {
return;
}
//查询当前匹配非默认套餐包的其他默认套餐包
LambdaQueryWrapper<SysTenantPack> query = new LambdaQueryWrapper<>();
query.ne(SysTenantPack::getPackType, CommonConstant.TENANT_PACK_DEFAULT);
query.eq(SysTenantPack::getPackCode, packCode);
List<SysTenantPack> otherDefaultPacks = sysTenantPackMapper.selectList(query);
for (SysTenantPack pack : otherDefaultPacks) {
//新增套餐包用户菜单权限
this.addPermission(pack.getId(), permission);
}
}
/**
* 根据套餐包的code 删除其他关联默认套餐包下的角色与菜单的关系
*
* @param packCode
* @param permissionId
*/
private void deleteDefaultPackPermission(String packCode, String permissionId) {
if (oConvertUtils.isEmpty(packCode)) {
return;
}
//查询当前匹配非默认套餐包的其他默认套餐包
LambdaQueryWrapper<SysTenantPack> query = new LambdaQueryWrapper<>();
query.ne(SysTenantPack::getPackType, CommonConstant.TENANT_PACK_DEFAULT);
query.eq(SysTenantPack::getPackCode, packCode);
List<SysTenantPack> defaultPacks = sysTenantPackMapper.selectList(query);
for (SysTenantPack pack : defaultPacks) {
//删除套餐权限
deletePackPermission(pack.getId(), permissionId);
}
}
/**
* 同步同 packCode 下的相关套餐包数据
*
* @param sysTenantPack
*/
private void syncRelatedPackDataByDefaultPack(SysTenantPack sysTenantPack) {
//查询与默认套餐相同code的套餐
LambdaQueryWrapper<SysTenantPack> query = new LambdaQueryWrapper<>();
query.ne(SysTenantPack::getPackType, CommonConstant.TENANT_PACK_DEFAULT);
query.eq(SysTenantPack::getPackCode, sysTenantPack.getPackCode());
List<SysTenantPack> relatedPacks = sysTenantPackMapper.selectList(query);
for (SysTenantPack pack : relatedPacks) {
//更新自定义套餐
pack.setPackName(sysTenantPack.getPackName());
pack.setStatus(sysTenantPack.getStatus());
pack.setRemarks(sysTenantPack.getRemarks());
pack.setIzSysn(sysTenantPack.getIzSysn());
sysTenantPackMapper.updateById(pack);
//同步默认套餐报下的所有用户已
if (oConvertUtils.isNotEmpty(sysTenantPack.getIzSysn()) && CommonConstant.STATUS_1.equals(sysTenantPack.getIzSysn())) {
this.addPackUserByPackTenantId(pack.getTenantId(), pack.getId());
}
}
}
}

70
jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysTenantServiceImpl.java
View File

@ -1,5 +1,6 @@
package org.jeecg.modules.system.service.impl;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.RandomUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
@ -136,6 +137,12 @@ public class SysTenantServiceImpl extends ServiceImpl<SysTenantMapper, SysTenant
relation.setTenantId(Integer.valueOf(id));
relation.setStatus(CommonConstant.USER_TENANT_NORMAL);
userTenantMapper.insert(relation);
//给当前用户添加租户下的所有套餐
this.addPackUser(userId,id);
//update-begin---author:wangshuai---date:2025-09-06---for:【QQYUN-13720】邀请用户加入租户，没有系统提醒，移除有---
//邀请用户加入租户，发送消息
this.sendInvitationTenantMessage(userByPhone,id);
//update-end---author:wangshuai---date:2025-09-06---for:【QQYUN-13720】邀请用户加入租户，没有系统提醒，移除有---
}else{
//update-begin---author:wangshuai ---date:20230711 for：【QQYUN-5723】2、用户已经在租户里了，再次要求提示成功，应该提示用户已经存在------------
//update-begin---author:wangshuai ---date:20230724 for：【QQYUN-5885】邀请用户加入提示不准确------------
@ -150,6 +157,30 @@ public class SysTenantServiceImpl extends ServiceImpl<SysTenantMapper, SysTenant
}
}
/**
* 低代码下发送邀请加入租户消息
*
* @param user
* @param id
*/
private void sendInvitationTenantMessage(SysUser user, String id) {
LoginUser sysUser = (LoginUser)SecurityUtils.getSubject().getPrincipal();
// 发消息
SysTenant sysTenant = this.baseMapper.querySysTenant((Integer.valueOf(id)));
MessageDTO messageDTO = new MessageDTO();
messageDTO.setToAll(false);
messageDTO.setToUser(user.getUsername());
messageDTO.setFromUser("system");
String title = sysUser.getRealname() + " 邀请您加入了 "+sysTenant.getName()+"。";
messageDTO.setTitle(title);
Map<String, Object> data = new HashMap<>();
messageDTO.setData(data);
messageDTO.setContent(title);
messageDTO.setType("system");
messageDTO.setCategory(CommonConstant.MSG_CATEGORY_1);
sysBaseApi.sendSysAnnouncement(messageDTO);
}
@Override
@CacheEvict(value={CacheConstant.SYS_USERS_CACHE}, allEntries=true)
public void leaveTenant(String userIds, String tenantId) {
@ -161,6 +192,13 @@ public class SysTenantServiceImpl extends ServiceImpl<SysTenantMapper, SysTenant
query.eq(SysUserTenant::getUserId,userId);
userTenantMapper.delete(query);
//update-end---author:wangshuai ---date:20221223 for：[QQYUN-3371]租户逻辑改造，改成关系表------------
//update-begin---author:wangshuai---date:2025-09-06---for:【QQYUN-13720】移出用户当前租户，没有系统提醒---
// 给移除人员发送消息
SysTenantPackUser sysTenantPackUser = new SysTenantPackUser();
sysTenantPackUser.setTenantId(Integer.valueOf(tenantId));
sysTenantPackUser.setUserId(userId);
sendMsgForDelete(sysTenantPackUser);
//update-end---author:wangshuai---date:2025-09-06---for:【QQYUN-13720】移出用户当前租户，没有系统提醒---
}
//租户移除用户，直接删除用户租户产品包
sysTenantPackUserMapper.deletePackUserByTenantId(Integer.valueOf(tenantId),Arrays.asList(userIds.split(SymbolConstant.COMMA)));
@ -648,7 +686,13 @@ public class SysTenantServiceImpl extends ServiceImpl<SysTenantMapper, SysTenant
MessageDTO messageDTO = new MessageDTO();
messageDTO.setToAll(false);
messageDTO.setToUser(user.getUsername());
String title = "您已被 "+loginUser.getRealname()+" 从 "+sysTenant.getName()+"的"+sysTenantPackUser.getPackName()+"中移除。";
//低代码下移出用户已做提醒，用户移出没有套餐包名称的概念
String title = "";
if(oConvertUtils.isNotEmpty(sysTenantPackUser.getPackName())){
title = "您已被 "+loginUser.getRealname()+" 从 "+sysTenant.getName()+"的"+sysTenantPackUser.getPackName()+"中移除。";
} else {
title = "您已被 "+loginUser.getRealname()+" 从 "+sysTenant.getName() + "中移除。";
}
messageDTO.setTitle(title);
messageDTO.setFromUser("system");
Map<String, Object> data = new HashMap<>();
@ -973,4 +1017,28 @@ public class SysTenantServiceImpl extends ServiceImpl<SysTenantMapper, SysTenant
userService.removeLogicDeleted(Collections.singletonList(userId));
}
/**
* 为用户添加租户下所有套餐
*
* @param userId 用户id
* @param tenantId 租户id
*/
public void addPackUser(String userId, String tenantId) {
//根据租户id和产品包的code获取租户套餐id
List<String> packIds = sysTenantPackMapper.getPackIdByPackCodeAndTenantId(oConvertUtils.getInt(tenantId));
if (CollectionUtil.isNotEmpty(packIds)) {
for (String packId : packIds) {
SysTenantPackUser sysTenantPackUser = new SysTenantPackUser();
sysTenantPackUser.setUserId(userId);
sysTenantPackUser.setTenantId(oConvertUtils.getInt(tenantId));
sysTenantPackUser.setPackId(packId);
sysTenantPackUser.setStatus(CommonConstant.STATUS_1_INT);
try {
this.addTenantPackUser(sysTenantPackUser);
} catch (Exception e) {
log.warn("添加用户套餐包失败，原因：" + e.getMessage());
}
}
}
}
}