【v3.8.3】租户大改造

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

@@ -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);
 }

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

@@ -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);
 }

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

@@ -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

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

@@ -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);
 }

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

@@ -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);
 }

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

@@ -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.entity.SysUserTenant;
-import org.jeecg.modules.system.mapper.SysRoleMapper;
+import org.jeecg.modules.system.mapper.*;
-import org.jeecg.modules.system.mapper.SysTenantPackMapper;
-import org.jeecg.modules.system.mapper.SysTenantPackUserMapper;
 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());
+            }
+        }
+    }
 }

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

@@ -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());
+                }
+            }
+        }
+    }
 }