repo stringclasses 1k
values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 6
values | commit_sha stringclasses 1k
values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysGatewayRouteService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysGatewayRouteService.java | package org.jeecg.modules.system.service;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.system.entity.SysGatewayRoute;
import java.util.List;
/**
* @Description: gateway路由管理
* @Author: jeecg-boot
* @Date: 2020-05-26
* @Version: V1.0
*/
public interface ISysGatewayRouteService extends IService<SysGatewayRoute> {
/**
* 添加所有的路由信息到redis
* @param key
*/
void addRoute2Redis(String key);
/**
* 删除路由
* @param id
*/
void deleteById(String id);
/**
* 保存路由配置
* @param array
*/
void updateAll(JSONObject array);
/**
* 清空redis中的route信息
*/
void clearRedis();
/**
* 还原逻辑删除
* @param ids
*/
void revertLogicDeleted(List<String> ids);
/**
* 彻底删除
* @param ids
*/
void deleteLogicDeleted(List<String> ids);
/**
* 复制路由
* @param id
* @return
*/
SysGatewayRoute copyRoute(String id);
/**
* 获取删除列表
* @return
*/
List<SysGatewayRoute> getDeletelist();
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysThirdAccountService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysThirdAccountService.java | package org.jeecg.modules.system.service;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.system.entity.SysThirdAccount;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.model.ThirdLoginModel;
import java.util.List;
/**
* @Description: 第三方登录账号表
* @Author: jeecg-boot
* @Date: 2020-11-17
* @Version: V1.0
*/
public interface ISysThirdAccountService extends IService<SysThirdAccount> {
/**
* 更新第三方账户信息
* @param sysUser SysUser对象
* @param thirdUserUuid 第三方id
*/
void updateThirdUserId(SysUser sysUser,String thirdUserUuid);
/**
* 创建第三方用户
* @param phone 手机号
* @param thirdUserUuid 第三方id
* @return SysUser
*/
SysUser createUser(String phone, String thirdUserUuid, Integer tenantId);
/**
* 根据本地userId查询数据
* @param sysUserId 用户id
* @param thirdType 第三方登录类型
* @return SysThirdAccount
*/
SysThirdAccount getOneBySysUserId(String sysUserId, String thirdType);
/**
* 根据第三方userId查询数据
* @param thirdUserId 第三方id
* @param thirdType 第三方登录类型
* @return SysThirdAccount
*/
SysThirdAccount getOneByThirdUserId(String thirdUserId, String thirdType);
/**
* 通过 sysUsername 集合批量查询
*
* @param sysUsernameArr username集合
* @param thirdType 第三方类型
* @return
*/
List<SysThirdAccount> listThirdUserIdByUsername(String[] sysUsernameArr, String thirdType, Integer tenantId);
/**
* 创建新用户
*
* @param tlm 第三方登录信息
* @return SysThirdAccount
* @return tenantId 租户id
*/
SysThirdAccount saveThirdUser(ThirdLoginModel tlm, Integer tenantId);
/**
* 绑定第三方账号(登录后根据用户id绑定第三方账号)
* @param sysThirdAccount
*/
SysThirdAccount bindThirdAppAccountByUserId(SysThirdAccount sysThirdAccount);
/**
* 根据第三方 UUID和第三方类别获取第三方用户数据
* @param unionid
* @param thirdType
* @param tenantId
* @param thirdUserId
* @return
*/
SysThirdAccount getOneByUuidAndThirdType(String unionid, String thirdType,Integer tenantId,String thirdUserId);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysFormFileService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysFormFileService.java | package org.jeecg.modules.system.service;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.system.entity.SysFormFile;
/**
* @Description: 表单评论文件
* @Author: jeecg-boot
* @Date: 2022-07-21
* @Version: V1.0
*/
public interface ISysFormFileService extends IService<SysFormFile> {
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysFillRuleService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysFillRuleService.java | package org.jeecg.modules.system.service;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.system.entity.SysFillRule;
/**
* @Description: 填值规则
* @Author: jeecg-boot
* @Date: 2019-11-07
* @Version: V1.0
*/
public interface ISysFillRuleService extends IService<SysFillRule> {
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysDictService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysDictService.java | package org.jeecg.modules.system.service;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.common.system.vo.DictModel;
import org.jeecg.common.system.vo.DictQuery;
import org.jeecg.modules.system.entity.SysDict;
import org.jeecg.modules.system.entity.SysDictItem;
import org.jeecg.modules.system.model.DuplicateCheckVo;
import org.jeecg.modules.system.model.TreeSelectModel;
import org.jeecg.modules.system.vo.lowapp.SysDictVo;
import java.util.List;
import java.util.Map;
/**
* <p>
* 字典表 服务类
* </p>
*
* @Author zhangweijian
* @since 2018-12-28
*/
public interface ISysDictService extends IService<SysDict> {
/**
* 校验数据是否可用，不存在重复数据
*
* @param duplicateCheckVo
* @return
*/
@Deprecated
public boolean duplicateCheckData(DuplicateCheckVo duplicateCheckVo);
/**
* 通过字典code获取字典数据
* @param code
* @return
*/
public List<DictModel> queryDictItemsByCode(String code);
/**
* 查询有效的数据字典项
* @param code
* @return
*/
List<DictModel> queryEnableDictItemsByCode(String code);
/**
* 通过多个字典code获取字典数据
*
* @param dictCodeList
* @return key = 字典code，value=对应的字典选项
*/
Map<String, List<DictModel>> queryDictItemsByCodeList(List<String> dictCodeList);
/**
* 登录加载系统字典
* @return
*/
public Map<String,List<DictModel>> queryAllDictItems();
/**
* 查通过查询指定table的 text code 获取字典
* @param tableFilterSql
* @param text
* @param code
* @return
*/
@Deprecated
List<DictModel> queryTableDictItemsByCode(String tableFilterSql, String text, String code);
/**
* 通过查询指定table的 text code 获取字典（指定查询条件）
* @param table
* @param text
* @param code
* @param filterSql
* @return
*/
@Deprecated
public List<DictModel> queryTableDictItemsByCodeAndFilter(String table, String text, String code, String filterSql);
/**
* 通过字典code及字典项的value获取字典文本
* @param code
* @param key
* @return
*/
public String queryDictTextByKey(String code, String key);
/**
* 可通过多个字典code查询翻译文本
* @param dictCodeList 多个字典code
* @param keys 数据列表
* @return
*/
Map<String, List<DictModel>> queryManyDictByKeys(List<String> dictCodeList, List<String> keys);
/**
* 通过查询指定table的 text code key 获取字典值
* @param table
* @param text
* @param code
* @param key
* @return
*/
@Deprecated
String queryTableDictTextByKey(String table, String text, String code, String key);
/**
* 通过查询指定table的 text code key 获取字典值，可批量查询
*
* @param table
* @param text
* @param code
* @param keys
* @param dataSource 数据源
* @return
*/
List<DictModel> queryTableDictTextByKeys(String table, String text, String code, List<String> keys, String dataSource);
/**
* 通过查询指定table的 text code key 获取字典值，包含value
* @param table 表名
* @param text
* @param code
* @param keys
* @return
*/
@Deprecated
List<String> queryTableDictByKeys(String table, String text, String code, String keys);
/**
* 通过查询指定table的 text code key 获取字典值，包含value
* @param table
* @param text
* @param code
* @param keys
* @param delNotExist
* @return
*/
@Deprecated
List<String> queryTableDictByKeys(String table, String text, String code, String keys,boolean delNotExist);
/**
* 根据字典类型删除关联表中其对应的数据
*
* @param sysDict
* @return
*/
boolean deleteByDictId(SysDict sysDict);
/**
* 添加一对多
* @param sysDict
* @param sysDictItemList
* @return Integer
*/
public Integer saveMain(SysDict sysDict, List<SysDictItem> sysDictItemList);
/**
* 查询所有部门 作为字典信息 id -->value,departName -->text
* @return
*/
public List<DictModel> queryAllDepartBackDictModel();
/**
* 查询所有用户 作为字典信息 username -->value,realname -->text
* @return
*/
public List<DictModel> queryAllUserBackDictModel();
// /**
// * 通过关键字查询字典表
// * @param table
// * @param text
// * @param code
// * @param keyword
// * @return
// */
// @Deprecated
// public List<DictModel> queryTableDictItems(String table, String text, String code,String keyword);
/**
* 查询字典表数据 只查询前10条
* @param table
* @param text
* @param code
* @param keyword
* @param condition
* @param pageSize 每页条数
* @return
*/
@Deprecated
public List<DictModel> queryLittleTableDictItems(String table, String text, String code, String condition, String keyword, int pageNo, int pageSize);
/**
* 查询字典表所有数据
* @param table
* @param text
* @param code
* @param condition
* @param keyword
* @return
*/
@Deprecated
public List<DictModel> queryAllTableDictItems(String table, String text, String code, String condition, String keyword);
/**
* 根据表名、显示字段名、存储字段名 查询树
* @param table
* @param text
* @param code
* @param pidField
* @param pid
* @param hasChildField
* @param query
* @return
*/
@Deprecated
List<TreeSelectModel> queryTreeList(Map<String, String> query,String table, String text, String code, String pidField,String pid,String hasChildField,int converIsLeafVal);
/**
* 真实删除
* @param id
*/
public void deleteOneDictPhysically(String id);
/**
* 修改delFlag
* @param delFlag
* @param id
*/
public void updateDictDelFlag(int delFlag,String id);
/**
* 查询被逻辑删除的数据
* @return
*/
public List<SysDict> queryDeleteList(String tenantId);
/**
* 分页查询
* @param query
* @param pageSize
* @param pageNo
* @return
*/
@Deprecated
public List<DictModel> queryDictTablePageList(DictQuery query,int pageSize, int pageNo);
/**
* 获取字典数据
* @param dictCode 字典code
* @param dictCode 表名,文本字段,code字段 | 举例：sys_user,realname,id
* @return
*/
List<DictModel> getDictItems(String dictCode);
/**
* 【JSearchSelectTag下拉搜索组件专用接口】
* 大数据量的字典表 走异步加载 即前端输入内容过滤数据
*
* @param dictCode 字典code格式：table,text,code
* @param keyword
* @param pageNo
* @param pageSize 每页条数
* @return
*/
List<DictModel> loadDict(String dictCode, String keyword, Integer pageNo, Integer pageSize);
/**
* 根据应用id获取字典列表和详情
* @param lowAppId
* @return
*/
List<SysDictVo> getDictListByLowAppId(String lowAppId);
/**
* 创建字典
* @param sysDictVo
*/
String addDictByLowAppId(SysDictVo sysDictVo);
/**
* 编辑字典
* @param sysDictVo
*/
void editDictByLowAppId(SysDictVo sysDictVo);
/**
* 还原逻辑删除
* @param ids
*/
boolean revertLogicDeleted(List<String> ids);
/**
* 彻底删除数据
* @param ids
*/
boolean removeLogicDeleted(List<String> ids);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysCategoryService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysCategoryService.java | package org.jeecg.modules.system.service;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.modules.system.entity.SysCategory;
import org.jeecg.modules.system.model.TreeSelectModel;
import java.util.List;
import java.util.Map;
/**
* @Description: 分类字典
* @Author: jeecg-boot
* @Date: 2019-05-29
* @Version: V1.0
*/
public interface ISysCategoryService extends IService<SysCategory> {
/**根节点父ID的值*/
public static final String ROOT_PID_VALUE = "0";
/**
* 存在子节点
*/
public static final String HAS_CHILD = "1";
/**
* 添加分类字典
* @param sysCategory
*/
void addSysCategory(SysCategory sysCategory);
/**
* 修改分类字典
* @param sysCategory
*/
void updateSysCategory(SysCategory sysCategory);
/**
* 根据父级编码加载分类字典的数据
* @param pcode
* @return
* @throws JeecgBootException
*/
public List<TreeSelectModel> queryListByCode(String pcode) throws JeecgBootException;
/**
* 根据pid查询子节点集合
* @param pid
* @return
*/
public List<TreeSelectModel> queryListByPid(String pid);
/**
* 根据pid查询子节点集合,支持查询条件
* @param pid
* @param condition
* @return
*/
public List<TreeSelectModel> queryListByPid(String pid, Map<String,String> condition);
/**
* 根据code查询id
* @param code
* @return
*/
public String queryIdByCode(String code);
/**
* 删除节点时同时删除子节点及修改父级节点
* @param ids
*/
void deleteSysCategory(String ids);
/**
* 分类字典控件数据回显[表单页面]
*
* @param ids
* @return
*/
List<String> loadDictItem(String ids);
/**
* 分类字典控件数据回显[表单页面]
*
* @param ids
* @param delNotExist 是否移除不存在的项，设为false如果某个key不存在数据库中，则直接返回key本身
* @return
*/
List<String> loadDictItem(String ids, boolean delNotExist);
/**
* 【仅导入使用】分类字典控件反向翻译
*
* @param names
* @param delNotExist 是否移除不存在的项，设为false如果某个key不存在数据库中，则直接返回key本身
* @return
*/
List<String> loadDictItemByNames(String names, boolean delNotExist);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysDepartRolePermissionService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysDepartRolePermissionService.java | package org.jeecg.modules.system.service;
import org.jeecg.modules.system.entity.SysDepartRolePermission;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* @Description: 部门角色权限
* @Author: jeecg-boot
* @Date: 2020-02-12
* @Version: V1.0
*/
public interface ISysDepartRolePermissionService extends IService<SysDepartRolePermission> {
/**
* 保存授权 将上次的权限和这次作比较 差异处理提高效率
* @param roleId
* @param permissionIds
* @param lastPermissionIds
*/
public void saveDeptRolePermission(String roleId,String permissionIds,String lastPermissionIds);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/IThirdAppService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/IThirdAppService.java | package org.jeecg.modules.system.service;
import org.jeecg.common.api.dto.message.MessageDTO;
import org.jeecg.modules.system.vo.thirdapp.SyncInfoVo;
import java.util.List;
/**
* 第三方App对接
* @author: jeecg-boot
*/
public interface IThirdAppService {
/**
* 获取AccessToken
* @return String
*/
String getAccessToken();
/**
* 将本地部门同步到第三方App<br>
* 同步方向：本地 --> 第三方APP
* 同步逻辑：<br>
* 1. 先判断是否同步过，有则修改，无则创建；<br>
* 2. 本地没有但第三方App里有则删除第三方App里的。
* @param ids
* @return 成功返回true
*/
SyncInfoVo syncLocalDepartmentToThirdApp(String ids);
// /**
// * 将第三方App部门同步到本地<br>
// * 同步方向：第三方APP --> 本地
// * 同步逻辑：<br>
// * 1. 先判断是否同步过，有则修改，无则创建；<br>
// * 2. 本地没有但第三方App里有则删除第三方App里的。
// * @param ids
// * @return 成功返回true
// */
// SyncInfoVo syncThirdAppDepartmentToLocal(String ids);
/**
* 将本地用户同步到第三方App<br>
* 同步方向：本地 --> 第三方APP <br>
* 同步逻辑：先判断是否同步过，有则修改、无则创建<br>
* 注意：同步人员的状态，比如离职、禁用、逻辑删除等。
* (特殊点：1、目前逻辑特意做的不删除用户，防止企业微信提前上线，用户已经存在，但是平台无此用户。
* 企业微信支持禁用账号；钉钉不支持
* 2、企业微信里面是手机号激活，只能用户自己改，不允许通过接口改)
* @param ids
* @return 成功返回空数组，失败返回错误信息
*/
SyncInfoVo syncLocalUserToThirdApp(String ids);
// /**
// * 将第三方App用户同步到本地<br>
// * 同步方向：第三方APP --> 本地 <br>
// * 同步逻辑：先判断是否同步过，有则修改、无则创建<br>
// * 注意：同步人员的状态，比如离职、禁用、逻辑删除等。
// *
// * @return 成功返回空数组，失败返回错误信息
// */
// SyncInfoVo syncThirdAppUserToLocal();
/**
* 根据本地用户ID，删除第三方APP的用户
*
* @param userIdList 本地用户ID列表
* @return 0表示成功，其他值表示失败
*/
int removeThirdAppUser(List<String> userIdList);
/**
* 发送消息
*
* @param message
* @param verifyConfig 是否验证配置（未启用的APP会拒绝发送）
* @return
*/
boolean sendMessage(MessageDTO message, boolean verifyConfig);
/**
* 发送消息
* @param message
* @return boolean
*/
boolean sendMessage(MessageDTO message);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysTenantPackService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysTenantPackService.java | package org.jeecg.modules.system.service;
import org.jeecg.modules.system.entity.SysTenantPack;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.system.entity.SysTenantPackUser;
import java.util.List;
/**
* @Description: 租户产品包
* @Author: jeecg-boot
* @Date: 2022-12-31
* @Version: V1.0
*/
public interface ISysTenantPackService extends IService<SysTenantPack> {
/**
* 新增产品包并将菜单插入关系表
* @param sysTenantPack
*/
void addPackPermission(SysTenantPack sysTenantPack);
/**
* 设置菜单id
* @param records
* @return
*/
List<SysTenantPack> setPermissions(List<SysTenantPack> records);
/**
* 编辑产品包并将菜单插入关系表
* @param sysTenantPack
*/
void editPackPermission(SysTenantPack sysTenantPack);
/**
* 删除租户产品包
* @param ids
*/
void deleteTenantPack(String ids);
/**
* 退出租户
* @param tenantId
* @param s
*/
void exitTenant(String tenantId, String s);
/**
* 创建租户的时候默认创建3个 产品包
* @param tenantId
*/
void addDefaultTenantPack(Integer tenantId);
/**
* 保存产品包
* @param sysTenantPack
*/
String saveOne(SysTenantPack sysTenantPack);
/**
* 保存产品包和人员的关系
* @param sysTenantPackUser
*/
void savePackUser(SysTenantPackUser sysTenantPackUser);
/**
* 根据租户ID和编码查询
* @param tenantId
* @param packCode
* @return
*/
SysTenantPack getSysTenantPack(Integer tenantId ,String packCode);
/**
* 添加由管理员创建的默认产品包
* @param id
*/
void addTenantDefaultPack(Integer id);
/**
* 同步默认的套餐
* for [QQYUN-11032]【jeecg】租户套餐管理增加初始化套餐包按钮
* @param tenantId
* @author chenrui
* @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);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysDataLogService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysDataLogService.java | package org.jeecg.modules.system.service;
import org.jeecg.modules.system.entity.SysDataLog;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* @Description: 数据日志service接口
* @author: jeecg-boot
*/
public interface ISysDataLogService extends IService<SysDataLog> {
/**
* 添加数据日志
* @param tableName
* @param dataId
* @param dataContent
*/
public void addDataLog(String tableName, String dataId, String dataContent);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysDepartRoleService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysDepartRoleService.java | package org.jeecg.modules.system.service;
import org.jeecg.modules.system.entity.SysDepartRole;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* @Description: 部门角色
* @Author: jeecg-boot
* @Date: 2020-02-12
* @Version: V1.0
*/
public interface ISysDepartRoleService extends IService<SysDepartRole> {
/**
* 根据用户id，部门id查询可授权所有部门角色
* @param orgCode
* @param userId
* @return
*/
List<SysDepartRole> queryDeptRoleByDeptAndUser(String orgCode, String userId);
/**
* 删除部门角色和对应关联表信息
* @param ids
*/
void deleteDepartRole(List<String> ids);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysRoleService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysRoleService.java | package org.jeecg.modules.system.service;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import org.apache.ibatis.annotations.Param;
import org.jeecg.common.api.vo.Result;
import org.jeecg.modules.system.entity.SysRole;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.springframework.web.multipart.MultipartFile;
import java.util.List;
/**
* <p>
* 角色表 服务类
* </p>
*
* @Author scott
* @since 2018-12-19
*/
public interface ISysRoleService extends IService<SysRole> {
/**
* 查询全部的角色（不做租户隔离）
* @param page
* @param role
* @return
*/
Page<SysRole> listAllSysRole(@Param("page") Page<SysRole> page, SysRole role);
/**
* 查询角色是否存在不做租户隔离
*
* @param roleCode
* @return
*/
SysRole getRoleNoTenant(@Param("roleCode") String roleCode);
/**
* 导入 excel ，检查 roleCode 的唯一性
*
* @param file
* @param params
* @return
* @throws Exception
*/
Result importExcelCheckRoleCode(MultipartFile file, ImportParams params) throws Exception;
/**
* 删除角色
* @param roleid
* @return
*/
public boolean deleteRole(String roleid);
/**
* 批量删除角色
* @param roleids
* @return
*/
public boolean deleteBatchRole(String[] roleids);
/**
* 根据角色id和当前租户判断当前角色是否存在这个租户中
* @param id
* @return
*/
Long getRoleCountByTenantId(String id, Integer tenantId);
/**
* 验证是否为admin角色
*
* @param ids
*/
void checkAdminRoleRejectDel(String ids);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysDataSourceService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysDataSourceService.java | package org.jeecg.modules.system.service;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.common.api.vo.Result;
import org.jeecg.modules.system.entity.SysDataSource;
/**
* @Description: 多数据源管理
* @Author: jeecg-boot
* @Date: 2019-12-25
* @Version: V1.0
*/
public interface ISysDataSourceService extends IService<SysDataSource> {
/**
* 添加数据源
* @param sysDataSource
* @return
*/
Result saveDataSource(SysDataSource sysDataSource);
/**
* 修改数据源
* @param sysDataSource
* @return
*/
Result editDataSource(SysDataSource sysDataSource);
/**
* 删除数据源
* @param id
* @return
*/
Result deleteDataSource(String id);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysCheckRuleService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysCheckRuleService.java | package org.jeecg.modules.system.service;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.system.entity.SysCheckRule;
/**
* @Description: 编码校验规则
* @Author: jeecg-boot
* @Date: 2020-02-04
* @Version: V1.0
*/
public interface ISysCheckRuleService extends IService<SysCheckRule> {
/**
* 通过 code 获取规则
*
* @param ruleCode
* @return
*/
SysCheckRule getByCode(String ruleCode);
/**
* 通过用户设定的自定义校验规则校验传入的值
*
* @param checkRule
* @param value
* @return 返回 null代表通过校验，否则就是返回的错误提示文本
*/
JSONObject checkValue(SysCheckRule checkRule, String value);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysTableWhiteListService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysTableWhiteListService.java | package org.jeecg.modules.system.service;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.system.entity.SysTableWhiteList;
import java.util.Map;
/**
* @Description: 系统表白名单
* @Author: jeecg-boot
* @Date: 2023-09-12
* @Version: V1.0
*/
public interface ISysTableWhiteListService extends IService<SysTableWhiteList> {
/**
* 新增
*
* @param sysTableWhiteList
* @return
*/
boolean add(SysTableWhiteList sysTableWhiteList);
/**
* 编辑
*
* @param sysTableWhiteList
* @return
*/
boolean edit(SysTableWhiteList sysTableWhiteList);
/**
* 通过id删除，可批量删除
*
* @param ids 多个使用逗号分割
* @return
*/
boolean deleteByIds(String ids);
/**
* 自动添加到数据库中
*
* @param tableName
* @param fieldName
* @return
*/
SysTableWhiteList autoAdd(String tableName, String fieldName);
/**
* 以map的方式获取所有数据
* key=tableName，value=fieldName
*
* @return
*/
Map<String, String> getAllConfigMap();
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysPositionService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysPositionService.java | package org.jeecg.modules.system.service;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.system.entity.SysPosition;
import java.util.List;
/**
* @Description: 职务表
* @Author: jeecg-boot
* @Date: 2019-09-19
* @Version: V1.0
*/
public interface ISysPositionService extends IService<SysPosition> {
/**
* 通过code查询
* @param code 职务编码
* @return SysPosition
*/
SysPosition getByCode(String code);
/**
* 通过用户id获取职位名称列表
* @param userId
* @return
*/
List<SysPosition> getPositionList(String userId);
/**
* 获取职位名称
* @param postList
* @return
*/
String getPositionName(List<String> postList);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysUserRoleService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysUserRoleService.java | package org.jeecg.modules.system.service;
import java.util.Map;
import org.jeecg.modules.system.entity.SysUserRole;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 用户角色表 服务类
* </p>
*
* @Author scott
* @since 2018-12-21
*/
public interface ISysUserRoleService extends IService<SysUserRole> {
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysUserPositionService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysUserPositionService.java | package org.jeecg.modules.system.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.entity.SysUserPosition;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* @Description: 用户职位关系表
* @Author: jeecg-boot
* @Date: 2023-02-14
* @Version: V1.0
*/
public interface ISysUserPositionService extends IService<SysUserPosition> {
/**
* 获取职位用户列表
* @param page
* @param positionId
* @return
*/
IPage<SysUser> getPositionUserList(Page<SysUser> page, String positionId);
/**
* 添加成员到用户职位关系表
* @param userIds
* @param positionId
*/
void saveUserPosition(String userIds, String positionId);
/**
* 通过职位id删除用户职位关系表
* @param positionId
*/
void removeByPositionId(String positionId);
/**
* 移除成员
* @param userIds
* @param positionId
*/
void removePositionUser(String userIds, String positionId);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysDepartPermissionService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysDepartPermissionService.java | package org.jeecg.modules.system.service;
import org.jeecg.modules.system.entity.SysDepartPermission;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.system.entity.SysPermissionDataRule;
import java.util.List;
/**
* @Description: 部门权限表
* @Author: jeecg-boot
* @Date: 2020-02-11
* @Version: V1.0
*/
public interface ISysDepartPermissionService extends IService<SysDepartPermission> {
/**
* 保存授权 将上次的权限和这次作比较 差异处理提高效率
* @param departId
* @param permissionIds
* @param lastPermissionIds
*/
public void saveDepartPermission(String departId,String permissionIds,String lastPermissionIds);
/**
* 根据部门id，菜单id获取数据规则
* @param permissionId 菜单id
* @param departId 部门id
* @return
*/
List<SysPermissionDataRule> getPermRuleListByDeptIdAndPermId(String departId,String permissionId);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysAnnouncementSendService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysAnnouncementSendService.java | package org.jeecg.modules.system.service;
import java.util.List;
import org.jeecg.modules.system.entity.SysAnnouncementSend;
import org.jeecg.modules.system.model.AnnouncementSendModel;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* @Description: 用户通告阅读标记表
* @Author: jeecg-boot
* @Date: 2019-02-21
* @Version: V1.0
*/
public interface ISysAnnouncementSendService extends IService<SysAnnouncementSend> {
/**
* 获取我的消息
* @param announcementSendModel
* @param page 当前页数
* @return
*/
public Page<AnnouncementSendModel> getMyAnnouncementSendPage(Page<AnnouncementSendModel> page,AnnouncementSendModel announcementSendModel);
/**
* 根据消息发送记录ID获取消息内容
* @return
*/
AnnouncementSendModel getOne(String sendId);
/**
* 获取当前用户已阅读的内容
*
* @param id
* @return
*/
long getReadCountByUserId(String id);
/**
* 根据多个id批量删除已阅读的数量
*
* @param ids
*/
void deleteBatchByIds(String ids);
/**
* 根据id更新阅读状态
* @param busId
* @param busType
*/
void updateReadFlagByBusId(String busId, String busType);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysUserService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysUserService.java | package org.jeecg.modules.system.service;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.system.vo.SysUserCacheInfo;
import org.jeecg.modules.system.entity.SysRoleIndex;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.model.SysUserSysDepPostModel;
import org.jeecg.modules.system.model.SysUserSysDepartModel;
import org.jeecg.modules.system.vo.SysUserExportVo;
import org.jeecg.modules.system.vo.lowapp.DepartAndUserInfo;
import org.jeecg.modules.system.vo.lowapp.UpdateDepartInfo;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.servlet.ModelAndView;
import jakarta.servlet.http.HttpServletRequest;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* <p>
* 用户表 服务类
* </p>
*
* @Author scott
* @since 2018-12-20
*/
public interface ISysUserService extends IService<SysUser> {
/**
* 查询用户数据列表
*
* @param req
* @param queryWrapper
* @param pageSize
* @param pageNo
* @return
*/
Result<IPage<SysUser>> queryPageList(HttpServletRequest req, QueryWrapper<SysUser> queryWrapper, Integer pageSize, Integer pageNo);
/**
* 重置密码
*
* @param username
* @param oldpassword
* @param newpassword
* @param confirmpassword
* @return
*/
public Result<?> resetPassword(String username, String oldpassword, String newpassword, String confirmpassword);
/**
* 修改密码
*
* @param sysUser
* @return
*/
public Result<?> changePassword(SysUser sysUser);
/**
* 删除用户
* @param userId
* @return
*/
public boolean deleteUser(String userId);
/**
* 批量删除用户
* @param userIds
* @return
*/
public boolean deleteBatchUsers(String userIds);
/**
* 根据用户名查询
* @param username 用户名
* @return SysUser
*/
public SysUser getUserByName(String username);
/**
* 添加用户和用户角色关系
* @param user
* @param roles
*/
public void addUserWithRole(SysUser user,String roles);
/**
* 修改用户和用户角色关系
* @param user
* @param roles
*/
public void editUserWithRole(SysUser user,String roles);
/**
* 获取用户的授权角色
* @param username
* @return
*/
public List<String> getRole(String username);
/**
* 获取根据登录用户的角色获取动态首页
*
* @param username
* @param version 前端UI版本
* @return
*/
public SysRoleIndex getDynamicIndexByUserRole(String username,String version);
/**
* 查询用户信息包括 部门信息
* @param username
* @return
*/
@Deprecated
public SysUserCacheInfo getCacheUser(String username);
/**
* 根据部门Id查询
* @param page
* @param departId 部门id
* @param username 用户账户名称
* @return
*/
public IPage<SysUser> getUserByDepId(Page<SysUser> page, String departId, String username);
/**
* 根据部门Ids查询
* @param page
* @param departIds 部门id集合
* @param username 用户账户名称
* @return
*/
public IPage<SysUser> getUserByDepIds(Page<SysUser> page, List<String> departIds, String username);
/**
* 根据 userIds查询，查询用户所属部门的名称（多个部门名逗号隔开）
* @param userIds
* @return
*/
public Map<String,String> getDepNamesByUserIds(List<String> userIds);
/**
* 根据部门 Id 和 QueryWrapper 查询
*
* @param page
* @param departId
* @param queryWrapper
* @return
*/
// public IPage<SysUser> getUserByDepartIdAndQueryWrapper(Page<SysUser> page, String departId, QueryWrapper<SysUser> queryWrapper);
/**
* 根据 orgCode 查询用户，包括子部门下的用户
*
* @param orgCode
* @param userParams 用户查询条件，可为空
* @param page 分页参数
* @return
*/
IPage<SysUserSysDepartModel> queryUserByOrgCode(String orgCode, SysUser userParams, IPage page);
/**
* 根据角色Id查询
* @param page
* @param roleId 角色id
* @param username 用户账户
* @param realname 用户姓名
* @return
*/
public IPage<SysUser> getUserByRoleId(Page<SysUser> page,String roleId, String username, String realname);
/**
* 通过用户名获取用户角色集合
*
* @param username 用户名
* @return 角色集合
*/
Set<String> getUserRolesSet(String username);
/**
* 通过用户名获取用户角色集合
*
* @param userId 用户id
* @return 角色集合
*/
Set<String> getUserRoleSetById(String userId);
/**
* 通过用户名获取用户权限集合
*
* @param userId 用户id
* @return 权限集合
*/
Set<String> getUserPermissionsSet(String userId);
/**
* 根据用户名设置部门ID
* @param username
* @param orgCode
*/
void updateUserDepart(String username,String orgCode,Integer loginTenantId);
/**
* 根据手机号获取用户名和密码
* @param phone 手机号
* @return SysUser
*/
public SysUser getUserByPhone(String phone);
/**
* 根据邮箱获取用户
* @param email 邮箱
* @return SysUser
*/
public SysUser getUserByEmail(String email);
/**
* 添加用户和用户部门关系
* @param user
* @param selectedParts
*/
void addUserWithDepart(SysUser user, String selectedParts);
/**
* 编辑用户和用户部门关系
* @param user
* @param departs
*/
void editUserWithDepart(SysUser user, String departs);
/**
* 校验用户是否有效
* @param sysUser
* @return
*/
Result checkUserIsEffective(SysUser sysUser);
/**
* 查询被逻辑删除的用户
* @return List<SysUser>
*/
List<SysUser> queryLogicDeleted();
/**
* 查询被逻辑删除的用户（可拼装查询条件）
* @param wrapper
* @return List<SysUser>
*/
List<SysUser> queryLogicDeleted(LambdaQueryWrapper<SysUser> wrapper);
/**
* 还原被逻辑删除的用户
* @param userIds 存放用户id集合
* @param updateEntity
* @return boolean
*/
boolean revertLogicDeleted(List<String> userIds, SysUser updateEntity);
/**
* 彻底删除被逻辑删除的用户
* @param userIds 存放用户id集合
* @return boolean
*/
boolean removeLogicDeleted(List<String> userIds);
/**
* 更新手机号、邮箱空字符串为 null
* @return boolean
*/
@Transactional(rollbackFor = Exception.class)
boolean updateNullPhoneEmail();
/**
* 保存第三方用户信息
* @param sysUser
*/
void saveThirdUser(SysUser sysUser);
/**
* 根据部门Ids查询
* @param departIds 部门id集合
* @param username 用户账户名称
* @return
*/
List<SysUser> queryByDepIds(List<String> departIds, String username);
/**
* 保存用户
*
* @param user 用户
* @param selectedRoles 选择的角色id，多个以逗号隔开
* @param selectedDeparts 选择的部门id，多个以逗号隔开
* @param relTenantIds 多个租户id
* @param izSyncPack 是否需要同步租户套餐包
*/
void saveUser(SysUser user, String selectedRoles, String selectedDeparts, String relTenantIds, boolean izSyncPack);
/**
* 编辑用户
* @param user 用户
* @param roles 选择的角色id，多个以逗号隔开
* @param departs 选择的部门id，多个以逗号隔开
* @param relTenantIds 多个租户id
* @param updateFromPage 更新来自的页面 [TV360X-1686]
*/
void editUser(SysUser user, String roles, String departs, String relTenantIds, String updateFromPage);
/**
* userId转为username
* @param userIdList
* @return List<String>
*/
List<String> userIdToUsername(Collection<String> userIdList);
/**
* 获取用户信息 字段信息是加密后的 【加密用户信息】
* @param username
* @return
*/
LoginUser getEncodeUserInfo(String username);
/**
* 用户离职
* @param username
*/
void userQuit(String username);
/**
* 获取离职人员列表
* @param tenantId 租户id
* @return
*/
List<SysUser> getQuitList(Integer tenantId);
/**
* 更新刪除状态和离职状态
* @param userIds 存放用户id集合
* @param sysUser
* @return boolean
*/
void updateStatusAndFlag(List<String> userIds, SysUser sysUser);
/**
* 设置登录租户
* @param sysUser
* @return
*/
Result<JSONObject> setLoginTenant(SysUser sysUser, JSONObject obj, String username, Result<JSONObject> result);
//--- author:taoyan date:20221231 for: QQYUN-3515【应用】应用下的组织机构管理功能，细节实现 ---
/**
* 批量编辑用户信息
* @param json
*/
void batchEditUsers(JSONObject json);
/**
* 根据关键词查询用户和部门
* @param keyword
* @return
*/
DepartAndUserInfo searchByKeyword(String keyword);
/**
* 查询 部门修改的信息
* @param departId
* @return
*/
UpdateDepartInfo getUpdateDepartInfo(String departId);
/**
* 修改部门相关信息
* @param updateDepartInfo
*/
void doUpdateDepartInfo(UpdateDepartInfo updateDepartInfo);
/**
* 设置负责人 取消负责人
* @param json
*/
void changeDepartChargePerson(JSONObject json);
//--- author:taoyan date:20221231 for: QQYUN-3515【应用】应用下的组织机构管理功能，细节实现 ---
/**
* 编辑租户用户
* @param sysUser
* @param tenantId
* @param departs
*/
void editTenantUser(SysUser sysUser, String tenantId, String departs, String roles);
/**
* 修改用户账号状态
* @param id 账号id
* @param status 账号状态
*/
void updateStatus(String id, String status);
/**
* 导出应用下的用户Excel
* @param request
* @return
*/
ModelAndView exportAppUser(HttpServletRequest request);
/**
* 导入应用下的用户
* @param request
* @return
*/
Result<?> importAppUser(HttpServletRequest request);
/**
* 验证用户是否为管理员
* @param ids
*/
void checkUserAdminRejectDel(String ids);
/**
* 修改手机号
*
* @param json
* @param username
*/
void changePhone(JSONObject json, String username);
/**
* 发送短信验证码
*
* @param jsonObject
* @param username 用户名
* @param ipAddress ip地址
*/
void sendChangePhoneSms(JSONObject jsonObject, String username, String ipAddress);
/**
* 发送注销用户手机号验证密码[敲敲云专用]
* @param jsonObject
* @param username
* @param ipAddress
*/
void sendLogOffPhoneSms(JSONObject jsonObject, String username, String ipAddress);
/**
* 用户注销[敲敲云专用]
* @param jsonObject
* @param username
*/
void userLogOff(JSONObject jsonObject, String username);
/**
* 获取部门和用户关系的导出信息
* @param pageList
*/
List<SysUserExportVo> getDepartAndRoleExportMsg(List<SysUser> pageList);
/**
* 导入用户
*
* @param request
*/
Result<?> importSysUser(HttpServletRequest request);
/**
* 没有绑定手机号 直接修改密码
*
* @param oldPassword
* @param password
* @param username
*/
void updatePasswordNotBindPhone(String oldPassword, String password, String username);
/**
* 根据用户名称查询用户和部门信息
* @param userName
* @return
*/
Map<String, String> queryUserAndDeptByName(String userName);
/**
* 查询部门、岗位下的用户 包括子部门下的用户
*
* @param orgCode
* @param userParams
* @param page
* @return
*/
IPage<SysUserSysDepPostModel> queryDepartPostUserByOrgCode(String orgCode, SysUser userParams, IPage page);
/**
* 根据 orgCode 查询用户信息（部门全路径，主岗位和兼职岗位的信息），包括公司、子公司、部门
*
* @param orgCode
* @param userParams
* @param page
* @return
*/
IPage<SysUserSysDepPostModel> queryDepartUserByOrgCode(String orgCode, SysUser userParams, IPage page);
/**
* 通讯录点击用户获取用户详情（包含用户基本信息、部门全路径、主岗位兼职岗位全路径）
*
* @param userId
* @return
*/
SysUserSysDepPostModel getUserDetailByUserId(String userId);
/**
* 登录获取用户部门信息
* @param jsonObject
* @return
*/
Result loginGetUserDeparts(JSONObject jsonObject);
/**
* 根据用户名查询重置成系统密码
* @param usernames
*/
void resetToSysPassword(String usernames);
/**
* 更新用户设备ID
* @param clientId
* @param userId
*/
void updateClientId(String clientId,String userId);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysPermissionDataRuleService.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/ISysPermissionDataRuleService.java | package org.jeecg.modules.system.service;
import java.util.List;
import org.jeecg.modules.system.entity.SysPermissionDataRule;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 菜单权限规则 服务类
* </p>
*
* @Author huangzhilin
* @since 2019-04-01
*/
public interface ISysPermissionDataRuleService extends IService<SysPermissionDataRule> {
/**
* 根据菜单id查询其对应的权限数据
*
* @param permissionId
* @return List<SysPermissionDataRule>
*/
List<SysPermissionDataRule> getPermRuleListByPermId(String permissionId);
/**
* 根据页面传递的参数查询菜单权限数据
* @param permRule
* @return
*/
List<SysPermissionDataRule> queryPermissionRule(SysPermissionDataRule permRule);
/**
* 根据菜单ID和用户名查找数据权限配置信息
* @param permissionId
* @param username
* @return
*/
List<SysPermissionDataRule> queryPermissionDataRules(String username,String permissionId);
/**
* 新增菜单权限配置 修改菜单rule_flag
* @param sysPermissionDataRule
*/
public void savePermissionDataRule(SysPermissionDataRule sysPermissionDataRule);
/**
* 删除菜单权限配置 判断菜单还有无权限
* @param dataRuleId
*/
public void deletePermissionDataRule(String dataRuleId);
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysUserPositionServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysUserPositionServiceImpl.java | package org.jeecg.modules.system.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysPosition;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.entity.SysUserPosition;
import org.jeecg.modules.system.mapper.SysUserMapper;
import org.jeecg.modules.system.mapper.SysUserPositionMapper;
import org.jeecg.modules.system.service.ISysUserPositionService;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.stream.Collectors;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
/**
* @Description: 用户职位关系表
* @Author: jeecg-boot
* @Date: 2023-02-14
* @Version: V1.0
*/
@Service
public class SysUserPositionServiceImpl extends ServiceImpl<SysUserPositionMapper, SysUserPosition> implements ISysUserPositionService {
@Autowired
private SysUserPositionMapper sysUserPositionMapper;
@Autowired
private SysUserMapper userMapper;
@Override
public IPage<SysUser> getPositionUserList(Page<SysUser> page, String positionId) {
return page.setRecords(sysUserPositionMapper.getPositionUserList(page, positionId));
}
@Override
public void saveUserPosition(String userIds, String positionId) {
String[] userIdArray = userIds.split(SymbolConstant.COMMA);
//存在的用户
StringBuilder userBuilder = new StringBuilder();
for (String userId : userIdArray) {
//获取成员是否存在于职位中
Long count = sysUserPositionMapper.getUserPositionCount(userId, positionId);
if (count == 0) {
//插入到用户职位关系表里面
SysUserPosition userPosition = new SysUserPosition();
userPosition.setPositionId(positionId);
userPosition.setUserId(userId);
sysUserPositionMapper.insert(userPosition);
} else {
userBuilder.append(userId).append(SymbolConstant.COMMA);
}
}
//如果用户id存在，说明已存在用户职位关系表中,提示用户已存在
String uIds = userBuilder.toString();
if (oConvertUtils.isNotEmpty(uIds)) {
//查询用户列表
List<SysUser> sysUsers = userMapper.selectBatchIds(Arrays.asList(uIds.split(SymbolConstant.COMMA)));
String realnames = sysUsers.stream().map(SysUser::getRealname).collect(Collectors.joining(SymbolConstant.COMMA));
throw new JeecgBootException(realnames + "已存在该职位中");
}
}
@Override
public void removeByPositionId(String positionId) {
sysUserPositionMapper.removeByPositionId(positionId);
}
@Override
public void removePositionUser(String userIds, String positionId) {
String[] userIdArray = userIds.split(SymbolConstant.COMMA);
sysUserPositionMapper.removePositionUser(Arrays.asList(userIdArray),positionId);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysThirdAppConfigServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysThirdAppConfigServiceImpl.java | package org.jeecg.modules.system.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.modules.system.entity.SysThirdAppConfig;
import org.jeecg.modules.system.mapper.SysThirdAppConfigMapper;
import org.jeecg.modules.system.service.ISysThirdAppConfigService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @Description: 第三方配置表
* @Author: jeecg-boot
* @Date: 2023-02-03
* @Version: V1.0
*/
@Service
@Slf4j
public class SysThirdAppConfigServiceImpl extends ServiceImpl<SysThirdAppConfigMapper, SysThirdAppConfig> implements ISysThirdAppConfigService {
@Autowired
private SysThirdAppConfigMapper configMapper;
@Override
public List<SysThirdAppConfig> getThirdConfigListByThirdType(int tenantId) {
return configMapper.getThirdConfigListByThirdType(tenantId);
}
@Override
public SysThirdAppConfig getThirdConfigByThirdType(Integer tenantId, String thirdType) {
return configMapper.getThirdConfigByThirdType(tenantId,thirdType);
}
@Override
public List<SysThirdAppConfig> getThirdAppConfigByClientId(String clientId) {
LambdaQueryWrapper<SysThirdAppConfig> query = new LambdaQueryWrapper<>();
query.eq(SysThirdAppConfig::getClientId,clientId);
List<SysThirdAppConfig> sysThirdAppConfigs = configMapper.selectList(query);
return sysThirdAppConfigs;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysPermissionServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysPermissionServiceImpl.java | package org.jeecg.modules.system.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
import org.jeecg.modules.system.entity.SysPermission;
import org.jeecg.modules.system.entity.SysPermissionDataRule;
import org.jeecg.modules.system.entity.SysRoleIndex;
import org.jeecg.modules.system.mapper.SysDepartPermissionMapper;
import org.jeecg.modules.system.mapper.SysDepartRolePermissionMapper;
import org.jeecg.modules.system.mapper.SysPermissionMapper;
import org.jeecg.modules.system.mapper.SysRolePermissionMapper;
import org.jeecg.modules.system.model.TreeModel;
import org.jeecg.modules.system.service.ISysPermissionDataRuleService;
import org.jeecg.modules.system.service.ISysPermissionService;
import org.jeecg.modules.system.service.ISysRoleIndexService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import jakarta.annotation.Resource;
import java.util.*;
/**
* <p>
* 菜单权限表 服务实现类
* </p>
*
* @Author scott
* @since 2018-12-21
*/
@Service
public class SysPermissionServiceImpl extends ServiceImpl<SysPermissionMapper, SysPermission> implements ISysPermissionService {
@Resource
private SysPermissionMapper sysPermissionMapper;
@Resource
private ISysPermissionDataRuleService permissionDataRuleService;
@Resource
private SysRolePermissionMapper sysRolePermissionMapper;
@Resource
private SysDepartPermissionMapper sysDepartPermissionMapper;
@Resource
private SysDepartRolePermissionMapper sysDepartRolePermissionMapper;
@Autowired
private ISysRoleIndexService roleIndexService;
@Override
public void switchVue3Menu() {
sysPermissionMapper.backupVue2Menu();
sysPermissionMapper.changeVue3Menu();
}
@Override
public List<TreeModel> queryListByParentId(String parentId) {
return sysPermissionMapper.queryListByParentId(parentId);
}
/**
* 真实删除
*/
@Override
@Transactional(rollbackFor = Exception.class)
@CacheEvict(value = CacheConstant.SYS_DATA_PERMISSIONS_CACHE,allEntries=true)
public void deletePermission(String id) throws JeecgBootException {
SysPermission sysPermission = this.getById(id);
if(sysPermission==null) {
throw new JeecgBootException("未找到菜单信息");
}
String pid = sysPermission.getParentId();
if(oConvertUtils.isNotEmpty(pid)) {
Long count = this.count(new QueryWrapper<SysPermission>().lambda().eq(SysPermission::getParentId, pid));
if(count==1) {
//若父节点无其他子节点，则该父节点是叶子节点
this.sysPermissionMapper.setMenuLeaf(pid, 1);
}
}
sysPermissionMapper.deleteById(id);
// 该节点可能是子节点但也可能是其它节点的父节点,所以需要级联删除
this.removeChildrenBy(sysPermission.getId());
//关联删除
Map map = new HashMap(5);
map.put("permission_id",id);
//删除数据规则
this.deletePermRuleByPermId(id);
//删除角色授权表
sysRolePermissionMapper.deleteByMap(map);
//删除部门权限表
sysDepartPermissionMapper.deleteByMap(map);
//删除部门角色授权
sysDepartRolePermissionMapper.deleteByMap(map);
}
/**
* 根据父id删除其关联的子节点数据
*
* @return
*/
public void removeChildrenBy(String parentId) {
LambdaQueryWrapper<SysPermission> query = new LambdaQueryWrapper<>();
// 封装查询条件parentId为主键,
query.eq(SysPermission::getParentId, parentId);
// 查出该主键下的所有子级
List<SysPermission> permissionList = this.list(query);
if (permissionList != null && permissionList.size() > 0) {
// id
String id = "";
// 查出的子级数量
Long num = Long.valueOf(0);
// 如果查出的集合不为空, 则先删除所有
this.remove(query);
// 再遍历刚才查出的集合, 根据每个对象,查找其是否仍有子级
for (int i = 0, len = permissionList.size(); i < len; i++) {
id = permissionList.get(i).getId();
Map map = new HashMap(5);
map.put("permission_id",id);
//删除数据规则
this.deletePermRuleByPermId(id);
//删除角色授权表
sysRolePermissionMapper.deleteByMap(map);
//删除部门权限表
sysDepartPermissionMapper.deleteByMap(map);
//删除部门角色授权
sysDepartRolePermissionMapper.deleteByMap(map);
num = this.count(new LambdaQueryWrapper<SysPermission>().eq(SysPermission::getParentId, id));
// 如果有, 则递归
if (num > 0) {
this.removeChildrenBy(id);
}
}
}
}
/**
* 逻辑删除
*/
@Override
@CacheEvict(value = CacheConstant.SYS_DATA_PERMISSIONS_CACHE,allEntries=true)
//@CacheEvict(value = CacheConstant.SYS_DATA_PERMISSIONS_CACHE,allEntries=true,condition="#sysPermission.menuType==2")
public void deletePermissionLogical(String id) throws JeecgBootException {
SysPermission sysPermission = this.getById(id);
if(sysPermission==null) {
throw new JeecgBootException("未找到菜单信息");
}
String pid = sysPermission.getParentId();
Long count = this.count(new QueryWrapper<SysPermission>().lambda().eq(SysPermission::getParentId, pid));
if(count==1) {
//若父节点无其他子节点，则该父节点是叶子节点
this.sysPermissionMapper.setMenuLeaf(pid, 1);
}
sysPermission.setDelFlag(1);
this.updateById(sysPermission);
}
@Override
@CacheEvict(value = CacheConstant.SYS_DATA_PERMISSIONS_CACHE,allEntries=true)
public void addPermission(SysPermission sysPermission) throws JeecgBootException {
//----------------------------------------------------------------------
//判断是否是一级菜单，是的话清空父菜单
if(CommonConstant.MENU_TYPE_0.equals(sysPermission.getMenuType())) {
sysPermission.setParentId(null);
}
//----------------------------------------------------------------------
String pid = sysPermission.getParentId();
if(oConvertUtils.isNotEmpty(pid)) {
//设置父节点不为叶子节点
this.sysPermissionMapper.setMenuLeaf(pid, 0);
}
sysPermission.setCreateTime(new Date());
sysPermission.setDelFlag(0);
sysPermission.setLeaf(true);
this.save(sysPermission);
}
@Override
@CacheEvict(value = CacheConstant.SYS_DATA_PERMISSIONS_CACHE,allEntries=true)
public void editPermission(SysPermission sysPermission) throws JeecgBootException {
SysPermission p = this.getById(sysPermission.getId());
//TODO 该节点判断是否还有子节点
if(p==null) {
throw new JeecgBootException("未找到菜单信息");
}else {
sysPermission.setUpdateTime(new Date());
//----------------------------------------------------------------------
//Step1.判断是否是一级菜单，是的话清空父菜单ID
if(CommonConstant.MENU_TYPE_0.equals(sysPermission.getMenuType())) {
sysPermission.setParentId("");
}
//Step2.判断菜单下级是否有菜单，无则设置为叶子节点
Long count = this.count(new QueryWrapper<SysPermission>().lambda().eq(SysPermission::getParentId, sysPermission.getId()));
if(count==0) {
sysPermission.setLeaf(true);
}
//----------------------------------------------------------------------
this.updateById(sysPermission);
//如果当前菜单的父菜单变了，则需要修改新父菜单和老父菜单的，叶子节点状态
String pid = sysPermission.getParentId();
boolean flag = (oConvertUtils.isNotEmpty(pid) && !pid.equals(p.getParentId())) || oConvertUtils.isEmpty(pid)&&oConvertUtils.isNotEmpty(p.getParentId());
if (flag) {
//a.设置新的父菜单不为叶子节点
this.sysPermissionMapper.setMenuLeaf(pid, 0);
//b.判断老的菜单下是否还有其他子菜单，没有的话则设置为叶子节点
Long cc = this.count(new QueryWrapper<SysPermission>().lambda().eq(SysPermission::getParentId, p.getParentId()));
if(cc==0) {
if(oConvertUtils.isNotEmpty(p.getParentId())) {
this.sysPermissionMapper.setMenuLeaf(p.getParentId(), 1);
}
}
}
// 同步更改默认菜单
SysRoleIndex defIndexCfg = this.roleIndexService.queryDefaultIndex();
boolean isDefIndex = defIndexCfg.getUrl().equals(p.getUrl());
if (isDefIndex) {
this.roleIndexService.updateDefaultIndex(sysPermission.getUrl(), sysPermission.getComponent(), sysPermission.isRoute());
}
}
}
@Override
public List<SysPermission> queryByUser(String userId) {
List<SysPermission> permissionList = this.sysPermissionMapper.queryByUser(userId);
//================= begin 开启租户的时候 如果没有test角色，默认加入test角色================
if (MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL) {
if (permissionList == null) {
permissionList = new ArrayList<>();
}
List<SysPermission> testRoleList = sysPermissionMapper.queryPermissionByTestRoleId();
// 代码逻辑说明: [QQYUN-5168]【vue3】为什么出现两个菜单 菜单根据id去重
for (SysPermission permission: testRoleList) {
boolean hasPerm = permissionList.stream().anyMatch(a->a.getId().equals(permission.getId()));
if(!hasPerm){
permissionList.add(permission);
}
}
}
//================= end 开启租户的时候 如果没有test角色，默认加入test角色================
return permissionList;
}
/**
* 根据permissionId删除其关联的SysPermissionDataRule表中的数据
*/
@Override
public void deletePermRuleByPermId(String id) {
LambdaQueryWrapper<SysPermissionDataRule> query = new LambdaQueryWrapper<>();
query.eq(SysPermissionDataRule::getPermissionId, id);
Long countValue = this.permissionDataRuleService.count(query);
if(countValue > 0) {
this.permissionDataRuleService.remove(query);
}
}
/**
* 获取模糊匹配规则的数据权限URL
*/
@Override
@Cacheable(value = CacheConstant.SYS_DATA_PERMISSIONS_CACHE)
public List<String> queryPermissionUrlWithStar() {
return this.baseMapper.queryPermissionUrlWithStar();
}
@Override
public boolean hasPermission(String username, SysPermission sysPermission) {
int count = baseMapper.queryCountByUsername(username,sysPermission);
if(count>0){
return true;
}else{
return false;
}
}
@Override
public boolean hasPermission(String username, String url) {
SysPermission sysPermission = new SysPermission();
sysPermission.setUrl(url);
int count = baseMapper.queryCountByUsername(username,sysPermission);
if(count>0){
return true;
}else{
return false;
}
}
@Override
public List<SysPermission> queryDepartPermissionList(String departId) {
return sysPermissionMapper.queryDepartPermissionList(departId);
}
@Override
public boolean checkPermDuplication(String id, String url,Boolean alwaysShow) {
QueryWrapper<SysPermission> qw=new QueryWrapper();
qw.lambda().eq(true,SysPermission::getUrl,url).ne(oConvertUtils.isNotEmpty(id),SysPermission::getId,id).eq(true,SysPermission::isAlwaysShow,alwaysShow);
return count(qw)==0;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysPositionServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysPositionServiceImpl.java | package org.jeecg.modules.system.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.modules.system.entity.SysPosition;
import org.jeecg.modules.system.mapper.SysPositionMapper;
import org.jeecg.modules.system.service.ISysPositionService;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Description: 职务表
* @Author: jeecg-boot
* @Date: 2019-09-19
* @Version: V1.0
*/
@Service
public class SysPositionServiceImpl extends ServiceImpl<SysPositionMapper, SysPosition> implements ISysPositionService {
@Override
public SysPosition getByCode(String code) {
LambdaQueryWrapper<SysPosition> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SysPosition::getCode, code);
return super.getOne(queryWrapper);
}
@Override
public List<SysPosition> getPositionList(String userId) {
return this.baseMapper.getPositionList(userId);
}
@Override
public String getPositionName(List<String> postList) {
List<SysPosition> positionNameList = this.baseMapper.getPositionName(postList);
if (null != positionNameList && positionNameList.size()>0) {
return positionNameList.stream().map(SysPosition::getName).collect(Collectors.joining(SymbolConstant.COMMA));
}
return "";
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysRoleServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysRoleServiceImpl.java | package org.jeecg.modules.system.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.util.ImportExcelUtil;
import org.jeecg.modules.system.entity.SysRole;
import org.jeecg.modules.system.mapper.SysRoleMapper;
import org.jeecg.modules.system.mapper.SysUserMapper;
import org.jeecg.modules.system.service.ISysRoleService;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* <p>
* 角色表 服务实现类
* </p>
*
* @Author scott
* @since 2018-12-19
*/
@Service
public class SysRoleServiceImpl extends ServiceImpl<SysRoleMapper, SysRole> implements ISysRoleService {
@Autowired
SysRoleMapper sysRoleMapper;
@Autowired
SysUserMapper sysUserMapper;
@Override
public Page<SysRole> listAllSysRole(Page<SysRole> page, SysRole role) {
return page.setRecords(sysRoleMapper.listAllSysRole(page,role));
}
@Override
public SysRole getRoleNoTenant(String roleCode) {
return sysRoleMapper.getRoleNoTenant(roleCode);
}
@Override
public Result importExcelCheckRoleCode(MultipartFile file, ImportParams params) throws Exception {
List<Object> listSysRoles = ExcelImportUtil.importExcel(file.getInputStream(), SysRole.class, params);
int totalCount = listSysRoles.size();
List<String> errorStrs = new ArrayList<>();
// 去除 listSysRoles 中重复的数据
for (int i = 0; i < listSysRoles.size(); i++) {
String roleCodeI =((SysRole)listSysRoles.get(i)).getRoleCode();
for (int j = i + 1; j < listSysRoles.size(); j++) {
String roleCodeJ =((SysRole)listSysRoles.get(j)).getRoleCode();
// 发现重复数据
if (roleCodeI.equals(roleCodeJ)) {
errorStrs.add("第 " + (j + 1) + " 行的 roleCode 值：" + roleCodeI + " 已存在，忽略导入");
listSysRoles.remove(j);
break;
}
}
}
// 去掉 sql 中的重复数据
Integer errorLines=0;
Integer successLines=0;
List<String> list = ImportExcelUtil.importDateSave(listSysRoles, ISysRoleService.class, errorStrs, CommonConstant.SQL_INDEX_UNIQ_SYS_ROLE_CODE);
errorLines+=list.size();
successLines+=(listSysRoles.size()-errorLines);
return ImportExcelUtil.imporReturnRes(errorLines,successLines,list);
}
@Override
@Transactional(rollbackFor = Exception.class)
public boolean deleteRole(String roleid) {
//1.删除角色和用户关系
sysRoleMapper.deleteRoleUserRelation(roleid);
//2.删除角色和权限关系
sysRoleMapper.deleteRolePermissionRelation(roleid);
//3.删除角色
this.removeById(roleid);
return true;
}
@Override
@Transactional(rollbackFor = Exception.class)
public boolean deleteBatchRole(String[] roleIds) {
//1.删除角色和用户关系
sysUserMapper.deleteBathRoleUserRelation(roleIds);
//2.删除角色和权限关系
sysUserMapper.deleteBathRolePermissionRelation(roleIds);
//3.删除角色
this.removeByIds(Arrays.asList(roleIds));
return true;
}
@Override
public Long getRoleCountByTenantId(String id, Integer tenantId) {
return sysRoleMapper.getRoleCountByTenantId(id,tenantId);
}
@Override
public void checkAdminRoleRejectDel(String ids) {
LambdaQueryWrapper<SysRole> query = new LambdaQueryWrapper<>();
query.in(SysRole::getId,Arrays.asList(ids.split(SymbolConstant.COMMA)));
query.eq(SysRole::getRoleCode,"admin");
Long adminRoleCount = sysRoleMapper.selectCount(query);
if(adminRoleCount>0){
throw new JeecgBootException("admin角色，不允许删除！");
}
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysGatewayRouteServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysGatewayRouteServiceImpl.java | package org.jeecg.modules.system.service.impl;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.RandomUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.base.BaseMap;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.GlobalConstants;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysGatewayRoute;
import org.jeecg.modules.system.mapper.SysGatewayRouteMapper;
import org.jeecg.modules.system.service.ISysGatewayRouteService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
/**
* @Description: gateway路由管理
* @Author: jeecg-boot
* @Date: 2020-05-26
* @Version: V1.0
*/
@Service
@Slf4j
public class SysGatewayRouteServiceImpl extends ServiceImpl<SysGatewayRouteMapper, SysGatewayRoute> implements ISysGatewayRouteService {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
private static final String STRING_STATUS = "status";
private static final SimpleDateFormat dateFormat = new SimpleDateFormat("MMdd");
@Override
public void addRoute2Redis(String key) {
List<SysGatewayRoute> ls = this.list(new LambdaQueryWrapper<SysGatewayRoute>());
redisTemplate.opsForValue().set(key, JSON.toJSONString(ls));
}
@Override
public void deleteById(String id) {
//1.将状态修改成禁用
SysGatewayRoute route = new SysGatewayRoute();
route.setId(id);
route.setStatus(0);
this.baseMapper.updateById(route);
this.removeById(id);
//2.刷新路由
this.resreshRouter(id);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void updateAll(JSONObject json) {
log.info("--gateway 路由配置修改--");
try {
json = json.getJSONObject("router");
String id = json.getString("id");
// 代码逻辑说明: oracle路由网关新增小bug /issues/I4EV2J
SysGatewayRoute route;
if(oConvertUtils.isEmpty(id)){
route = new SysGatewayRoute();
}else{
route = getById(id);
}
if (ObjectUtil.isEmpty(route)) {
route = new SysGatewayRoute();
}
route.setRouterId(json.getString("routerId"));
route.setName(json.getString("name"));
route.setPredicates(json.getString("predicates"));
//初始化删除状态
route.setDelFlag(CommonConstant.DEL_FLAG_0);
String filters = json.getString("filters");
if (ObjectUtil.isEmpty(filters)) {
filters = "[]";
}
route.setFilters(filters);
route.setUri(json.getString("uri"));
if (json.get(STRING_STATUS) == null) {
route.setStatus(1);
} else {
route.setStatus(json.getInteger(STRING_STATUS));
}
this.saveOrUpdate(route);
resreshRouter(null);
} catch (Exception e) {
log.error("路由配置解析失败", e);
resreshRouter(null);
e.printStackTrace();
}
}
/**
* 更新redis路由缓存
*/
private void resreshRouter(String delRouterId) {
//更新redis路由缓存
addRoute2Redis(CacheConstant.GATEWAY_ROUTES);
BaseMap params = new BaseMap();
params.put(GlobalConstants.HANDLER_NAME, GlobalConstants.LODER_ROUDER_HANDLER);
params.put("delRouterId", delRouterId);
//刷新网关
redisTemplate.convertAndSend(GlobalConstants.REDIS_TOPIC_NAME, params);
}
@Override
public void clearRedis() {
redisTemplate.opsForValue().set(CacheConstant.GATEWAY_ROUTES, null);
}
/**
* 还原逻辑删除
* @param ids
*/
@Override
public void revertLogicDeleted(List<String> ids) {
this.baseMapper.revertLogicDeleted(ids);
resreshRouter(null);
}
/**
* 彻底删除
* @param ids
*/
@Override
public void deleteLogicDeleted(List<String> ids) {
this.baseMapper.deleteLogicDeleted(ids);
resreshRouter(ids.get(0));
}
/**
* 路由复制
* @param id
* @return
*/
@Override
@Transactional(rollbackFor = Exception.class)
public SysGatewayRoute copyRoute(String id) {
log.info("--gateway 路由复制--");
SysGatewayRoute targetRoute = new SysGatewayRoute();
try {
SysGatewayRoute sourceRoute = this.baseMapper.selectById(id);
//1.复制路由
BeanUtils.copyProperties(sourceRoute,targetRoute);
//1.1 获取当前日期
String formattedDate = dateFormat.format(new Date());
String copyRouteName = sourceRoute.getName() + "_copy_";
//1.2 判断数据库是否存在
Long count = this.baseMapper.selectCount(new LambdaQueryWrapper<SysGatewayRoute>().eq(SysGatewayRoute::getName, copyRouteName + formattedDate));
//1.3 新的路由名称
copyRouteName += count > 0?RandomUtil.randomNumbers(4):formattedDate;
targetRoute.setId(null);
targetRoute.setName(copyRouteName);
targetRoute.setCreateTime(new Date());
targetRoute.setStatus(0);
targetRoute.setDelFlag(CommonConstant.DEL_FLAG_0);
this.baseMapper.insert(targetRoute);
//2.刷新路由
resreshRouter(null);
} catch (Exception e) {
log.error("路由配置解析失败", e);
resreshRouter(null);
e.printStackTrace();
}
return targetRoute;
}
/**
* 查询删除列表
* @return
*/
@Override
public List<SysGatewayRoute> getDeletelist() {
return baseMapper.queryDeleteList();
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/ImportFileServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/ImportFileServiceImpl.java | package org.jeecg.modules.system.service.impl;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.util.CommonUtils;
import org.jeecgframework.poi.excel.imports.base.ImportFileServiceI;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
/**
* excel导入 实现类
* @author: jeecg-boot
*/
@Slf4j
@Service
public class ImportFileServiceImpl implements ImportFileServiceI {
@Value("${jeecg.path.upload}")
private String upLoadPath;
@Value(value="${jeecg.uploadType}")
private String uploadType;
@Override
public String doUpload(byte[] data) {
return CommonUtils.uploadOnlineImage(data, upLoadPath, "import", uploadType);
}
@Override
public String doUpload(byte[] data, String saveUrl) {
// 代码逻辑说明: [QQYUN-10902]AutoPoi Excel表格导入有问题，还会报个错。 #7703------------
String bizPath = "import";
if(null != saveUrl && !saveUrl.isEmpty()){
bizPath = saveUrl;
}
return CommonUtils.uploadOnlineImage(data, upLoadPath, bizPath, uploadType);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysDepartRolePermissionServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysDepartRolePermissionServiceImpl.java | package org.jeecg.modules.system.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.jeecg.common.util.IpUtils;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysDepartRolePermission;
import org.jeecg.modules.system.mapper.SysDepartRolePermissionMapper;
import org.jeecg.modules.system.service.ISysDepartRolePermissionService;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import jakarta.servlet.http.HttpServletRequest;
import java.util.*;
/**
* @Description: 部门角色权限
* @Author: jeecg-boot
* @Date: 2020-02-12
* @Version: V1.0
*/
@Service
public class SysDepartRolePermissionServiceImpl extends ServiceImpl<SysDepartRolePermissionMapper, SysDepartRolePermission> implements ISysDepartRolePermissionService {
@Override
public void saveDeptRolePermission(String roleId, String permissionIds, String lastPermissionIds) {
String ip = "";
try {
//获取request
HttpServletRequest request = SpringContextUtils.getHttpServletRequest();
//获取IP地址
ip = IpUtils.getIpAddr(request);
} catch (Exception e) {
ip = "127.0.0.1";
}
List<String> add = getDiff(lastPermissionIds,permissionIds);
if(add!=null && add.size()>0) {
List<SysDepartRolePermission> list = new ArrayList<SysDepartRolePermission>();
for (String p : add) {
if(oConvertUtils.isNotEmpty(p)) {
SysDepartRolePermission rolepms = new SysDepartRolePermission(roleId, p);
rolepms.setOperateDate(new Date());
rolepms.setOperateIp(ip);
list.add(rolepms);
}
}
this.saveBatch(list);
}
List<String> delete = getDiff(permissionIds,lastPermissionIds);
if(delete!=null && delete.size()>0) {
for (String permissionId : delete) {
this.remove(new QueryWrapper<SysDepartRolePermission>().lambda().eq(SysDepartRolePermission::getRoleId, roleId).eq(SysDepartRolePermission::getPermissionId, permissionId));
}
}
}
/**
* 从diff中找出main中没有的元素
* @param main
* @param diff
* @return
*/
private List<String> getDiff(String main, String diff){
if(oConvertUtils.isEmpty(diff)) {
return null;
}
if(oConvertUtils.isEmpty(main)) {
return Arrays.asList(diff.split(","));
}
String[] mainArr = main.split(",");
String[] diffArr = diff.split(",");
Map<String, Integer> map = new HashMap(5);
for (String string : mainArr) {
map.put(string, 1);
}
List<String> res = new ArrayList<String>();
for (String key : diffArr) {
if(oConvertUtils.isNotEmpty(key) && !map.containsKey(key)) {
res.add(key);
}
}
return res;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysDepartRoleUserServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysDepartRoleUserServiceImpl.java | package org.jeecg.modules.system.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysDepartRole;
import org.jeecg.modules.system.entity.SysDepartRoleUser;
import org.jeecg.modules.system.mapper.SysDepartRoleMapper;
import org.jeecg.modules.system.mapper.SysDepartRoleUserMapper;
import org.jeecg.modules.system.service.ISysDepartRoleUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import java.util.stream.Collectors;
/**
* @Description: 部门角色人员信息
* @Author: jeecg-boot
* @Date: 2020-02-13
* @Version: V1.0
*/
@Service
public class SysDepartRoleUserServiceImpl extends ServiceImpl<SysDepartRoleUserMapper, SysDepartRoleUser> implements ISysDepartRoleUserService {
@Autowired
private SysDepartRoleMapper sysDepartRoleMapper;
@Override
public void deptRoleUserAdd(String userId, String newRoleId, String oldRoleId) {
List<String> add = getDiff(oldRoleId,newRoleId);
if(add!=null && add.size()>0) {
List<SysDepartRoleUser> list = new ArrayList<>();
for (String roleId : add) {
if(oConvertUtils.isNotEmpty(roleId)) {
SysDepartRoleUser rolepms = new SysDepartRoleUser(userId, roleId);
list.add(rolepms);
}
}
this.saveBatch(list);
}
List<String> remove = getDiff(newRoleId,oldRoleId);
if(remove!=null && remove.size()>0) {
for (String roleId : remove) {
this.remove(new QueryWrapper<SysDepartRoleUser>().lambda().eq(SysDepartRoleUser::getUserId, userId).eq(SysDepartRoleUser::getDroleId, roleId));
}
}
}
@Override
@Transactional(rollbackFor = Exception.class)
public void removeDeptRoleUser(List<String> userIds, String depId) {
for(String userId : userIds){
List<SysDepartRole> sysDepartRoleList = sysDepartRoleMapper.selectList(new QueryWrapper<SysDepartRole>().eq("depart_id",depId));
List<String> roleIds = sysDepartRoleList.stream().map(SysDepartRole::getId).collect(Collectors.toList());
if(roleIds != null && roleIds.size()>0){
QueryWrapper<SysDepartRoleUser> query = new QueryWrapper<>();
query.eq("user_id",userId).in("drole_id",roleIds);
this.remove(query);
}
}
}
/**
* 从diff中找出main中没有的元素
* @param main
* @param diff
* @return
*/
private List<String> getDiff(String main, String diff){
if(oConvertUtils.isEmpty(diff)) {
return null;
}
if(oConvertUtils.isEmpty(main)) {
return Arrays.asList(diff.split(","));
}
String[] mainArr = main.split(",");
String[] diffArr = diff.split(",");
Map<String, Integer> map = new HashMap(5);
for (String string : mainArr) {
map.put(string, 1);
}
List<String> res = new ArrayList<String>();
for (String key : diffArr) {
if(oConvertUtils.isNotEmpty(key) && !map.containsKey(key)) {
res.add(key);
}
}
return res;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysTenantServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysTenantServiceImpl.java | 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;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.api.dto.message.BusMessageDTO;
import org.jeecg.common.api.dto.message.MessageDTO;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.exception.JeecgBootBizTipException;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.DateUtils;
import org.jeecg.common.util.PasswordUtil;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.common.constant.enums.SysAnnmentTypeEnum;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.aop.TenantLog;
import org.jeecg.modules.system.entity.*;
import org.jeecg.modules.system.mapper.*;
import org.jeecg.modules.system.service.ISysTenantPackService;
import org.jeecg.modules.system.service.ISysTenantService;
import org.jeecg.modules.system.service.ISysUserService;
import org.jeecg.modules.system.vo.tenant.*;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.stream.Collectors;
/**
* @Description: 租户实现类
* @author: jeecg-boot
*/
@Service("sysTenantServiceImpl")
@Slf4j
public class SysTenantServiceImpl extends ServiceImpl<SysTenantMapper, SysTenant> implements ISysTenantService {
@Autowired
ISysUserService userService;
@Autowired
private SysUserTenantMapper userTenantMapper;
@Autowired
private SysTenantMapper tenantMapper;
@Autowired
private ISysTenantPackService sysTenantPackService;
@Autowired
private SysTenantPackUserMapper sysTenantPackUserMapper;
@Autowired
private ISysBaseAPI sysBaseApi;
@Autowired
private SysUserDepartMapper sysUserDepartMapper;
@Autowired
private SysTenantPackMapper sysTenantPackMapper;
@Autowired
private SysPackPermissionMapper sysPackPermissionMapper;
@Override
public List<SysTenant> queryEffectiveTenant(Collection<Integer> idList) {
if(oConvertUtils.listIsEmpty(idList)){
return null;
}
LambdaQueryWrapper<SysTenant> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.in(SysTenant::getId, idList);
queryWrapper.eq(SysTenant::getStatus, Integer.valueOf(CommonConstant.STATUS_1));
//此处查询忽略时间条件
return super.list(queryWrapper);
}
@Override
public Long countUserLinkTenant(String id) {
LambdaQueryWrapper<SysUserTenant> query = new LambdaQueryWrapper<>();
query.eq(SysUserTenant::getTenantId,id);
query.eq(SysUserTenant::getStatus,CommonConstant.STATUS_1);
// 查找出已被关联的用户数量
return userTenantMapper.selectCount(query);
}
@Override
public boolean removeTenantById(String id) {
// 查找出已被关联的用户数量
return super.removeById(Integer.parseInt(id));
}
@Override
@CacheEvict(value={CacheConstant.SYS_USERS_CACHE}, allEntries=true)
public void invitationUserJoin(String ids, String phone,String username) {
String[] idArray = ids.split(SymbolConstant.COMMA);
String userId = null;
SysUser userByPhone = null;
// 代码逻辑说明: 【QQYUN-4605】后台的邀请谁加入租户，没办法选不是租户下的用户，通过手机号邀请------------
if(oConvertUtils.isNotEmpty(phone)){
userByPhone = userService.getUserByPhone(phone);
//说明用户不存在
if(null == userByPhone){
throw new JeecgBootException("当前用户不存在，请核对手机号");
}
userId = userByPhone.getId();
}else{
userByPhone = userService.getUserByName(username);
//说明用户不存在
if(null == userByPhone){
throw new JeecgBootException("当前用户不存在，请核对手机号");
}
userId = userByPhone.getId();
}
//循环租户id
for (String id:idArray) {
//获取被邀请人是否已存在
SysUserTenant userTenant = userTenantMapper.getUserTenantByTenantId(userId, Integer.valueOf(id));
if(null == userTenant){
SysUserTenant relation = new SysUserTenant();
relation.setUserId(userId);
relation.setTenantId(Integer.valueOf(id));
relation.setStatus(CommonConstant.USER_TENANT_NORMAL);
userTenantMapper.insert(relation);
//给当前用户添加租户下的所有套餐
this.addPackUser(userId,id);
//邀请用户加入租户，发送消息
this.sendInvitationTenantMessage(userByPhone,id);
}else{
// 代码逻辑说明: 【QQYUN-5885】邀请用户加入提示不准确------------
String tenantErrorInfo = getTenantErrorInfo(userTenant.getStatus());
String errMsg = "手机号用户:" + userByPhone.getPhone() + " 昵称：" + userByPhone.getRealname() + "，" + tenantErrorInfo;
throw new JeecgBootException(errMsg);
}
}
}
/**
* 低代码下发送邀请加入租户消息
*
* @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) {
String[] userIdArray = userIds.split(SymbolConstant.COMMA);
for (String userId:userIdArray) {
// 代码逻辑说明: [QQYUN-3371]租户逻辑改造，改成关系表------------
LambdaQueryWrapper<SysUserTenant> query = new LambdaQueryWrapper<>();
query.eq(SysUserTenant::getTenantId,tenantId);
query.eq(SysUserTenant::getUserId,userId);
userTenantMapper.delete(query);
//代码逻辑说明: 【QQYUN-13720】移出用户当前租户，没有系统提醒---
// 给移除人员发送消息
SysTenantPackUser sysTenantPackUser = new SysTenantPackUser();
sysTenantPackUser.setTenantId(Integer.valueOf(tenantId));
sysTenantPackUser.setUserId(userId);
sendMsgForDelete(sysTenantPackUser);
}
//租户移除用户，直接删除用户租户产品包
sysTenantPackUserMapper.deletePackUserByTenantId(Integer.valueOf(tenantId),Arrays.asList(userIds.split(SymbolConstant.COMMA)));
}
@Override
@CacheEvict(value={CacheConstant.SYS_USERS_CACHE}, allEntries=true)
public Integer saveTenantJoinUser(SysTenant sysTenant, String userId) {
//添加租户
this.saveTenant(sysTenant);
// 添加租户产品包
Integer tenantId = sysTenant.getId();
sysTenantPackService.addDefaultTenantPack(tenantId);
//添加租户到关系表
return tenantId;
}
@Override
public void saveTenant(SysTenant sysTenant){
//获取租户id
sysTenant.setId(this.tenantIdGenerate());
sysTenant.setHouseNumber(RandomUtil.randomStringUpper(6));
sysTenant.setDelFlag(CommonConstant.DEL_FLAG_0);
this.save(sysTenant);
//代码逻辑说明:【QQYUN-5723】1、把当前创建人加入到租户关系里面------------
//当前登录人的id
LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
this.saveTenantRelation(sysTenant.getId(),loginUser.getId());
}
@Override
@CacheEvict(value={CacheConstant.SYS_USERS_CACHE}, allEntries=true)
public Integer joinTenantByHouseNumber(SysTenant sysTenant, String userId) {
LambdaQueryWrapper<SysTenant> query = new LambdaQueryWrapper<>();
query.eq(SysTenant::getHouseNumber,sysTenant.getHouseNumber());
SysTenant one = this.getOne(query);
//需要返回租户id(用于前台更新缓存),返回0则代表当前租户门牌号不存在
if(null == one){
return 0;
}else{
LambdaQueryWrapper<SysUserTenant> relationQuery = new LambdaQueryWrapper<>();
relationQuery.eq(SysUserTenant::getTenantId,one.getId());
relationQuery.eq(SysUserTenant::getUserId,userId);
SysUserTenant relation = userTenantMapper.selectOne(relationQuery);
if(relation != null){
String msg = "";
if(CommonConstant.USER_TENANT_UNDER_REVIEW.equals(relation.getStatus())){
msg = ",状态:审核中";
}else if(CommonConstant.USER_TENANT_REFUSE.equals(relation.getStatus())){
throw new JeecgBootBizTipException("管理员已拒绝您加入租户,请联系租户管理员");
}else if(CommonConstant.USER_TENANT_QUIT.equals(relation.getStatus())){
msg = ",状态:已离职";
}
throw new JeecgBootBizTipException("您已是该租户成员"+msg);
}
//用户加入门牌号审核中状态
SysUserTenant tenant = new SysUserTenant();
tenant.setTenantId(one.getId());
tenant.setUserId(userId);
tenant.setStatus(CommonConstant.USER_TENANT_UNDER_REVIEW);
userTenantMapper.insert(tenant);
// QQYUN-4526【应用】组织加入通知
sendMsgForApplyJoinTenant(userId, one);
return tenant.getTenantId();
}
}
@Override
public Integer countCreateTenantNum(String userId) {
return this.userTenantMapper.countCreateTenantNum(userId);
}
@Override
public IPage<SysTenant> getRecycleBinPageList(Page<SysTenant> page, SysTenant sysTenant) {
return page.setRecords(tenantMapper.getRecycleBinPageList(page,sysTenant));
}
@Override
@CacheEvict(value={CacheConstant.SYS_USERS_CACHE}, allEntries=true)
public void deleteTenantLogic(String ids) {
String[] idArray = ids.split(SymbolConstant.COMMA);
List<Integer> list = new ArrayList<>();
//转成int类型
for (String id:idArray) {
list.add(Integer.valueOf(id));
}
//删除租户
tenantMapper.deleteByTenantId(list);
//删除租户下的用户
userTenantMapper.deleteUserByTenantId(list);
//删除租户下的产品包
this.deleteTenantPackByTenantId(list);
}
@Override
public void revertTenantLogic(String ids) {
String[] idArray = ids.split(SymbolConstant.COMMA);
List<Integer> list = new ArrayList<>();
//转成int类型
for (String id:idArray) {
list.add(Integer.valueOf(id));
}
//还原租户
tenantMapper.revertTenantLogic(list);
}
/**
* 添加租户到关系表
* @param tenantId
* @param userId
*/
@CacheEvict(value={CacheConstant.SYS_USERS_CACHE}, allEntries=true)
public Integer saveTenantRelation(Integer tenantId,String userId) {
SysUserTenant relation = new SysUserTenant();
relation.setTenantId(tenantId);
relation.setUserId(userId);
relation.setStatus(CommonConstant.USER_TENANT_NORMAL);
userTenantMapper.insert(relation);
return relation.getTenantId();
}
/**
* 获取租户id
* @return
*/
public int tenantIdGenerate(){
synchronized (this){
//获取最大值id
// 代码逻辑说明: 数据库没有租户的时候，如果为空的话会报错sql返回类型不匹配------------
int maxTenantId = oConvertUtils.getInt(tenantMapper.getMaxTenantId(),0);
if(maxTenantId >= 1000){
return maxTenantId + 1;
}else{
return 1000;
}
}
}
@Override
public void exitUserTenant(String userId, String username, String tenantId) {
int tId = Integer.parseInt(tenantId);
//获取所有租户信息
List<String> userIdsByTenantId = userTenantMapper.getUserIdsByTenantId(tId);
//查询当前租户是否为拥有者
SysTenant sysTenant = tenantMapper.selectById(tId);
//如果是拥有着
if (username.equals(sysTenant.getCreateBy())) {
//判断当前租户信息位数
if (null != userIdsByTenantId && userIdsByTenantId.size() > 1) {
//需要指配拥有者
throw new JeecgBootException("assignedOwen");
} else if (null != userIdsByTenantId && userIdsByTenantId.size() == 1) {
//只有拥有者的时候需要去注销租户
throw new JeecgBootException("cancelTenant");
} else {
throw new JeecgBootException("退出租户失败，租户信息已不存在");
}
} else {
//不是拥有者直接删除
this.leaveTenant(userId, tenantId);
this.leveUserProcess(userId, tenantId);
}
}
@Override
public void changeOwenUserTenant(String userId, String tId) {
//查询当前用户是否存在该租户下
// 代码逻辑说明: 租户id应该是传过来的，不应该是当前租户的------------
int tenantId = oConvertUtils.getInt(tId, 0);
SysTenant sysTenant = tenantMapper.selectById(tenantId);
if(null == sysTenant){
throw new JeecgBootException("退出租户失败，不存在此租户");
}
String createBy = sysTenant.getCreateBy();
Integer count = userTenantMapper.userTenantIzExist(userId, tenantId);
if (count == 0) {
throw new JeecgBootException("退出租户失败，此租户下没有该用户");
}
//获取用户信息
SysUser user = userService.getById(userId);
//变更拥有者
SysTenant tenant = new SysTenant();
tenant.setCreateBy(user.getUsername());
tenant.setId(tenantId);
tenantMapper.updateById(tenant);
//删除当前登录用户的租户信息
//update-begin---author:wangshuai ---date:20230705 for：旧拥有者退出后，需要将就拥有者的用户租户关系改成已离职------------
//获取原创建人的用户id
SysUser userByName = userService.getUserByName(createBy);
LambdaQueryWrapper<SysUserTenant> query = new LambdaQueryWrapper<>();
query.eq(SysUserTenant::getUserId,userByName.getId());
query.eq(SysUserTenant::getTenantId,tenantId);
SysUserTenant userTenant = new SysUserTenant();
userTenant.setStatus(CommonConstant.USER_TENANT_QUIT);
userTenantMapper.update(userTenant,query);
//离职流程
this.leveUserProcess(userId, String.valueOf(tenantId));
}
/**
* 触发离职流程
*
* @param userId
* @param tenantId
* @param tenantId
*/
private void leveUserProcess(String userId, String tenantId) {
LoginUser userInfo = new LoginUser();
SysUser user = userService.getById(userId);
}
@Override
public Result<String> invitationUser(String phone, String departId) {
Result<String> result = new Result<>();
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
//1、查询用户信息,判断用户是否存在
SysUser userByPhone = userService.getUserByPhone(phone);
if(null == userByPhone){
result.setSuccess(false);
result.setMessage("用户不存在");
return result;
}
int tenantId = oConvertUtils.getInt(TenantContext.getTenant(), 0);
//2.判断当前邀请人是否存在租户列表中
Integer userCount = userTenantMapper.userTenantIzExist(sysUser.getId(), tenantId);
if(userCount == 0){
result.setSuccess(false);
result.setMessage("当前管理员没有邀请权限");
return result;
}
//3.插入到租户信息，已存在的不予许插入
//获取被邀请人是否已存在
SysUserTenant sysUserTenant = userTenantMapper.getUserTenantByTenantId(userByPhone.getId(), tenantId);
//用户已存在
if(null != sysUserTenant){
result.setSuccess(false);
String tenantErrorInfo = getTenantErrorInfo(sysUserTenant.getStatus());
String msg = "手机号用户:" + userByPhone.getPhone() + " 昵称：" + userByPhone.getRealname() + "，" + tenantErrorInfo;
result.setMessage(msg);
return result;
}
//4.需要用户手动同意加入
String status = CommonConstant.USER_TENANT_INVITE;
//5.当前用户不存在租户中,就需要将用户添加到租户中
SysUserTenant tenant = new SysUserTenant();
tenant.setTenantId(tenantId);
tenant.setUserId(userByPhone.getId());
tenant.setStatus(status);
userTenantMapper.insert(tenant);
result.setSuccess(true);
result.setMessage("邀请成员成功，成员同意后方可加入");
//6.保存用户部门关系
if(oConvertUtils.isNotEmpty(departId)){
//保存用户部门关系
this.saveUserDepart(userByPhone.getId(),departId);
}
// QQYUN-4527【应用】邀请成员加入组织，发送消息提醒
sendMsgForInvitation(userByPhone, tenantId, sysUser.getRealname());
return result;
}
@Override
public TenantDepartAuthInfo getTenantDepartAuthInfo(Integer tenantId) {
SysTenant sysTenant = this.getById(tenantId);
if(sysTenant==null) {
return null;
}
TenantDepartAuthInfo info = new TenantDepartAuthInfo();
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
String userId = sysUser.getId();
boolean superAdmin = false;
// 查询pack表
List<String> packCodeList = baseMapper.queryUserPackCode(tenantId, userId);
if(packCodeList==null || packCodeList.size()==0){
//如果没有数据 判断租户创建人是不是当前用户
if(sysTenant.getCreateBy().equals(sysUser.getUsername())){
sysTenantPackService.addDefaultTenantPack(tenantId);
superAdmin = true;
}else{
superAdmin = false;
}
}
if(superAdmin == false){
List<TenantPackUserCount> packCountList = baseMapper.queryTenantPackUserCount(tenantId);
info.setPackCountList(packCountList);
}
info.setSysTenant(sysTenant);
info.setSuperAdmin(superAdmin);
info.setPackCodes(packCodeList);
return info;
}
@Override
public List<TenantPackUserCount> queryTenantPackUserCount(Integer tenantId) {
return baseMapper.queryTenantPackUserCount(tenantId);
}
@Override
public TenantPackModel queryTenantPack(TenantPackModel model) {
Integer tenantId = model.getTenantId();
String packCode = model.getPackCode();
SysTenantPack sysTenantPack = sysTenantPackService.getSysTenantPack(tenantId, packCode);
if(sysTenantPack!=null){
TenantPackModel tenantPackModel = new TenantPackModel();
tenantPackModel.setPackName(sysTenantPack.getPackName());
tenantPackModel.setPackId(sysTenantPack.getId());
// 查询用户
List<TenantPackUser> userList = getTenantPackUserList(tenantId, sysTenantPack.getId(), 1);
tenantPackModel.setUserList(userList);
return tenantPackModel;
}
return null;
}
@Override
public void addBatchTenantPackUser(SysTenantPackUser sysTenantPackUser) {
String userIds = sysTenantPackUser.getUserId();
if(oConvertUtils.isNotEmpty(userIds)){
ISysTenantService currentService = SpringContextUtils.getApplicationContext().getBean(ISysTenantService.class);
String realNames = sysTenantPackUser.getRealname();
String[] userIdArray = userIds.split(",");
String[] realNameArray = realNames.split(",");
for(int i=0;i<userIdArray.length;i++){
String userId = userIdArray[i];
String realName = realNameArray[i];
SysTenantPackUser entity = new SysTenantPackUser(sysTenantPackUser, userId, realName);
LambdaQueryWrapper<SysTenantPackUser> query = new LambdaQueryWrapper<SysTenantPackUser>()
.eq(SysTenantPackUser::getTenantId, entity.getTenantId())
.eq(SysTenantPackUser::getPackId, entity.getPackId())
.eq(SysTenantPackUser::getUserId, entity.getUserId());
SysTenantPackUser packUser = sysTenantPackUserMapper.selectOne(query);
if(packUser==null || packUser.getId()==null){
currentService.addTenantPackUser(entity);
}else{
if(packUser.getStatus()==0){
packUser.setPackName(entity.getPackName());
packUser.setRealname(realName);
currentService.addTenantPackUser(packUser);
}
}
}
}
}
@TenantLog(2)
@Override
public void addTenantPackUser(SysTenantPackUser sysTenantPackUser) {
if(sysTenantPackUser.getId()==null){
sysTenantPackUserMapper.insert(sysTenantPackUser);
}else{
sysTenantPackUser.setStatus(1);
sysTenantPackUserMapper.updateById(sysTenantPackUser);
}
}
@TenantLog(4)
@Override
public void deleteTenantPackUser(SysTenantPackUser sysTenantPackUser) {
LambdaQueryWrapper<SysTenantPackUser> query = new LambdaQueryWrapper<SysTenantPackUser>()
.eq(SysTenantPackUser::getUserId, sysTenantPackUser.getUserId())
.eq(SysTenantPackUser::getPackId, sysTenantPackUser.getPackId());
sysTenantPackUserMapper.delete(query);
// QQYUN-4525【组织管理】管理员 2.管理员权限被移除时，给移除人员发送消息
sendMsgForDelete(sysTenantPackUser);
}
@Override
public List<TenantPackUser> getTenantPackApplyUsers(Integer tenantId) {
return getTenantPackUserList(tenantId, null, 0);
}
/**
* 获取租户下 某个产品包的用户
* 或者是 租户下产品包的申请用户
* @param tenantId
* @param packId
* @param packUserStatus
* @return
*/
private List<TenantPackUser> getTenantPackUserList(Integer tenantId, String packId, Integer packUserStatus){
// 查询用户
List<TenantPackUser> userList = baseMapper.queryPackUserList(tenantId, packId, packUserStatus);
if(userList!=null && userList.size()>0){
List<String> userIdList = userList.stream().map(i->i.getId()).collect(Collectors.toList());
// 部门
List<UserDepart> depList = baseMapper.queryUserDepartList(userIdList);
// 职位 TODO
// 遍历用户 往用户中添加 部门信息和职位信息
for(TenantPackUser user: userList){
for(UserDepart dep: depList){
if(user.getId().equals(dep.getUserId())){
user.addDepart(dep.getDepartName());
}
}
}
}
return userList;
}
@Override
public void doApplyTenantPackUser(SysTenantPackUser sysTenantPackUser) {
LambdaQueryWrapper<SysTenantPack> query1 = new LambdaQueryWrapper<SysTenantPack>()
.eq(SysTenantPack::getTenantId, sysTenantPackUser.getTenantId())
.eq(SysTenantPack::getPackCode, sysTenantPackUser.getPackCode());
SysTenantPack pack = sysTenantPackService.getOne(query1);
if(pack!=null){
sysTenantPackUser.setStatus(0);
sysTenantPackUser.setPackId(pack.getId());
LambdaQueryWrapper<SysTenantPackUser> query = new LambdaQueryWrapper<SysTenantPackUser>()
.eq(SysTenantPackUser::getTenantId, sysTenantPackUser.getTenantId())
.eq(SysTenantPackUser::getPackId, sysTenantPackUser.getPackId())
.eq(SysTenantPackUser::getUserId, sysTenantPackUser.getUserId());
Long count = sysTenantPackUserMapper.selectCount(query);
if(count==null || count==0){
sysTenantPackUserMapper.insert(sysTenantPackUser);
}
// QQYUN-4524【组织关联】管理员 1.管理员权限申请-> 给相关管理员 发送通知消息
sendMsgForApply(sysTenantPackUser.getUserId(), pack);
}
}
/**
* 申请管理员权限发消息
* @param userId
* @param pack
*/
private void sendMsgForApply(String userId, SysTenantPack pack){
// 发消息
SysUser user = userService.getById(userId);
Integer tenantId = pack.getTenantId();
SysTenant sysTenant = this.baseMapper.querySysTenant(tenantId);
String packCode = pack.getPackCode();
List<String> packCodeList = Arrays.asList(packCode.split(","));
List<String> userList = sysTenantPackUserMapper.queryTenantPackUserNameList(tenantId, packCodeList);
MessageDTO messageDTO = new MessageDTO();
messageDTO.setToAll(false);
messageDTO.setToUser(String.join(",", userList));
messageDTO.setFromUser("system");
String title = user.getRealname()+" 申请加入 "+sysTenant.getName()+" 的"+pack.getPackName()+"的成员。";
messageDTO.setTitle(title);
Map<String, Object> data = new HashMap<>();
messageDTO.setData(data);
messageDTO.setContent(title);
messageDTO.setType("system");
sysBaseApi.sendTemplateMessage(messageDTO);
}
/**
* 移除管理员权限发消息
* @param sysTenantPackUser
*/
private void sendMsgForDelete(SysTenantPackUser sysTenantPackUser){
// 发消息
SysUser user = userService.getById(sysTenantPackUser.getUserId());
SysTenant sysTenant = this.baseMapper.querySysTenant(sysTenantPackUser.getTenantId());
LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
MessageDTO messageDTO = new MessageDTO();
messageDTO.setToAll(false);
messageDTO.setToUser(user.getUsername());
//低代码下移出用户已做提醒，用户移出没有套餐包名称的概念
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<>();
data.put("realname", loginUser.getRealname());
data.put("tenantName", sysTenant.getName());
data.put("packName", sysTenantPackUser.getPackName());
messageDTO.setData(data);
messageDTO.setType("system");
messageDTO.setContent(title);
sysBaseApi.sendTemplateMessage(messageDTO);
}
/**
* 加入组织申请 发消息
* @param userId
* @param sysTenant
*/
private void sendMsgForApplyJoinTenant(String userId, SysTenant sysTenant){
// 发消息
SysUser user = userService.getById(userId);
// 给超级管理员 和组织管理员发消息
String codes = "superAdmin,accountAdmin";
List<String> packCodeList = Arrays.asList(codes.split(","));
List<String> userList = sysTenantPackUserMapper.queryTenantPackUserNameList(sysTenant.getId(), packCodeList);
MessageDTO messageDTO = new MessageDTO();
messageDTO.setToAll(false);
messageDTO.setToUser(String.join(",", userList));
messageDTO.setFromUser("system");
String title = user.getRealname()+" 申请加入 "+sysTenant.getName()+"。";
messageDTO.setTitle(title);
Map<String, Object> data = new HashMap<>();
messageDTO.setData(data);
messageDTO.setType("system");
messageDTO.setContent(title);
sysBaseApi.sendTemplateMessage(messageDTO);
}
/**
* 邀请成员 发消息
* @param user
* @param tenantId
* @param realname
*/
private void sendMsgForInvitation(SysUser user, Integer tenantId, String realname){
// 发消息
SysTenant sysTenant = this.baseMapper.querySysTenant(tenantId);
BusMessageDTO messageDTO = new BusMessageDTO();
messageDTO.setToAll(false);
messageDTO.setToUser(user.getUsername());
messageDTO.setFromUser("system");
// 代码逻辑说明: 【QQYUN-5730】租户邀请加入提示消息应该显示邀请人的名字------------
String title = realname + " 邀请您加入 "+sysTenant.getName()+"。";
messageDTO.setTitle(title);
Map<String, Object> data = new HashMap<>();
messageDTO.setData(data);
messageDTO.setContent(title);
messageDTO.setType("system");
// 代码逻辑说明: 【QQYUN-7168】邀请成员时，会报错，但实际已经邀请成功了---
messageDTO.setCategory(CommonConstant.MSG_CATEGORY_1);
// 代码逻辑说明: 【QQYUN-5726】邀请加入租户加个按钮直接跳转过去------------
messageDTO.setBusType(SysAnnmentTypeEnum.TENANT_INVITE.getType());
sysBaseApi.sendBusAnnouncement(messageDTO);
}
@Override
public void passApply(SysTenantPackUser sysTenantPackUser) {
LambdaQueryWrapper<SysTenantPackUser> query = new LambdaQueryWrapper<SysTenantPackUser>()
.eq(SysTenantPackUser::getTenantId, sysTenantPackUser.getTenantId())
.eq(SysTenantPackUser::getPackId, sysTenantPackUser.getPackId())
.eq(SysTenantPackUser::getUserId, sysTenantPackUser.getUserId());
SysTenantPackUser packUser = sysTenantPackUserMapper.selectOne(query);
if(packUser!=null && packUser.getId()!=null && packUser.getStatus()==0){
ISysTenantService currentService = SpringContextUtils.getApplicationContext().getBean(ISysTenantService.class);
packUser.setPackName(sysTenantPackUser.getPackName());
packUser.setRealname(sysTenantPackUser.getRealname());
currentService.addTenantPackUser(packUser);
//超级管理员成功加入发送系统消息
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | true |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysDepartRoleServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysDepartRoleServiceImpl.java | package org.jeecg.modules.system.service.impl;
import org.jeecg.modules.system.entity.SysDepartRole;
import org.jeecg.modules.system.mapper.SysDepartRoleMapper;
import org.jeecg.modules.system.mapper.SysDepartRolePermissionMapper;
import org.jeecg.modules.system.mapper.SysDepartRoleUserMapper;
import org.jeecg.modules.system.service.ISysDepartRoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
* @Description: 部门角色
* @Author: jeecg-boot
* @Date: 2020-02-12
* @Version: V1.0
*/
@Service
public class SysDepartRoleServiceImpl extends ServiceImpl<SysDepartRoleMapper, SysDepartRole> implements ISysDepartRoleService {
@Autowired
SysDepartRolePermissionMapper sysDepartRolePermissionMapper;
@Autowired
SysDepartRoleUserMapper sysDepartRoleUserMapper;
@Override
public List<SysDepartRole> queryDeptRoleByDeptAndUser(String orgCode, String userId) {
return this.baseMapper.queryDeptRoleByDeptAndUser(orgCode,userId);
}
/**
* 删除部门角色和对应关联表信息
* @param ids
*/
@Override
@Transactional(rollbackFor = Exception.class)
public void deleteDepartRole(List<String> ids) {
this.baseMapper.deleteBatchIds(ids);
this.sysDepartRolePermissionMapper.deleteByRoleIds(ids);
this.sysDepartRoleUserMapper.deleteByRoleIds(ids);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysLogServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysLogServiceImpl.java | package org.jeecg.modules.system.service.impl;
import java.sql.SQLException;
import java.util.Date;
import java.util.List;
import java.util.Map;
import jakarta.annotation.Resource;
import com.baomidou.mybatisplus.annotation.DbType;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.common.util.CommonUtils;
import org.jeecg.modules.system.entity.SysLog;
import org.jeecg.modules.system.mapper.SysLogMapper;
import org.jeecg.modules.system.service.ISysLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
/**
* <p>
* 系统日志表 服务实现类
* </p>
*
* @Author zhangweijian
* @since 2018-12-26
*/
@Service
public class SysLogServiceImpl extends ServiceImpl<SysLogMapper, SysLog> implements ISysLogService {
@Resource
private SysLogMapper sysLogMapper;
/**
* @功能：清空所有日志记录
*/
@Override
public void removeAll() {
sysLogMapper.removeAll();
}
@Override
public Long findTotalVisitCount() {
return sysLogMapper.findTotalVisitCount();
}
@Override
public Long findTodayVisitCount(Date dayStart, Date dayEnd) {
return sysLogMapper.findTodayVisitCount(dayStart,dayEnd);
}
@Override
public Long findTodayIp(Date dayStart, Date dayEnd) {
return sysLogMapper.findTodayIp(dayStart,dayEnd);
}
@Override
public List<Map<String,Object>> findVisitCount(Date dayStart, Date dayEnd) {
DbType dbType = CommonUtils.getDatabaseTypeEnum();
return sysLogMapper.findVisitCount(dayStart, dayEnd,dbType.getDb());
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysTenantPackServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysTenantPackServiceImpl.java | 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;
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.SysTenantPack;
import org.jeecg.modules.system.entity.SysTenantPackUser;
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;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import java.util.stream.Collectors;
/**
* @Description: 租户产品包
* @Author: jeecg-boot
* @Date: 2022-12-31
* @Version: V1.0
*/
@Service
public class SysTenantPackServiceImpl extends ServiceImpl<SysTenantPackMapper, SysTenantPack> implements ISysTenantPackService {
@Autowired
private SysTenantPackMapper sysTenantPackMapper;
@Autowired
private SysTenantPackUserMapper sysTenantPackUserMapper;
@Autowired
private SysPackPermissionMapper sysPackPermissionMapper;
@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)) {
String packId = sysTenantPack.getId();
String[] permissionIdArray = permissionIds.split(SymbolConstant.COMMA);
for (String permissionId : permissionIdArray) {
this.addPermission(packId, permissionId);
}
}
//如果是自定义套餐包的情况下再将新增套餐和用户关系
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)) {
// 查询已存在的用户
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) {
SysTenantPackUser tenantPackUser = new SysTenantPackUser(tenantId, packId, userId);
sysTenantPackUserMapper.insert(tenantPackUser);
}
}
}
}
@Override
public List<SysTenantPack> setPermissions(List<SysTenantPack> records) {
for (SysTenantPack pack : records) {
List<String> permissionIds = sysPackPermissionMapper.getPermissionsByPackId(pack.getId());
if (null != permissionIds && permissionIds.size() > 0) {
String ids = String.join(SymbolConstant.COMMA, permissionIds);
pack.setPermissionIds(ids);
}
}
return records;
}
@Override
public void editPackPermission(SysTenantPack sysTenantPack) {
//数据库汇总的id
List<String> oldPermissionIds = sysPackPermissionMapper.getPermissionsByPackId(sysTenantPack.getId());
//前台传过来的需要修改的id
String permissionIds = sysTenantPack.getPermissionIds();
//如果传过来的菜单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)) {
//找到新的租户id与原来的租户id不同之处，进行删除
List<String> permissionList = oldPermissionIds.stream().filter(item -> !permissionIds.contains(item)).collect(Collectors.toList());
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);
}
}
}
//找到原来菜单id与新的菜单id不同之处,进行新增
List<String> permissionAddList = Arrays.stream(permissionIds.split(SymbolConstant.COMMA)).filter(item -> !oldPermissionIds.contains(item)).collect(Collectors.toList());
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
@Transactional(rollbackFor = Exception.class)
public void deleteTenantPack(String ids) {
String[] idsArray = ids.split(SymbolConstant.COMMA);
for (String id : idsArray) {
this.deletePackPermission(id,null);
//删除产品包下面的用户
this.deletePackUser(id);
sysTenantPackMapper.deleteById(id);
}
}
@Override
public void exitTenant(String tenantId, String userId) {
this.getById(tenantId);
}
@Override
public void addDefaultTenantPack(Integer tenantId) {
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);
query.eq(SysTenantPack::getPackCode, TenantConstant.SUPER_ADMIN);
SysTenantPack sysTenantPackSuperAdmin = currentService.getOne(query);
String packId = "";
if(null == sysTenantPackSuperAdmin){
packId = currentService.saveOne(superAdminPack);
}else{
packId = sysTenantPackSuperAdmin.getId();
}
//step.1.2 补充人员与套餐包的关系数据
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
SysTenantPackUser packUser = new SysTenantPackUser(tenantId, packId, sysUser.getId());
packUser.setRealname(sysUser.getRealname());
packUser.setPackName(superAdminPack.getPackName());
currentService.savePackUser(packUser);
//step.2 创建租户套餐包(组织账户管理员)和 添加人员关系数据
query.eq(SysTenantPack::getTenantId,tenantId);
query.eq(SysTenantPack::getPackCode, TenantConstant.ACCOUNT_ADMIN);
SysTenantPack sysTenantPackAccountAdmin = currentService.getOne(query);
if(null == sysTenantPackAccountAdmin){
// 创建超级管理员
SysTenantPack accountAdminPack = new SysTenantPack(tenantId, "组织账户管理员", TenantConstant.ACCOUNT_ADMIN);
accountAdminPack.setIzSysn(CommonConstant.STATUS_0);
currentService.saveOne(accountAdminPack);
}
//step.3 创建租户套餐包(组织应用管理员)
query.eq(SysTenantPack::getTenantId,tenantId);
query.eq(SysTenantPack::getPackCode, TenantConstant.APP_ADMIN);
SysTenantPack sysTenantPackAppAdmin = currentService.getOne(query);
if(null == sysTenantPackAppAdmin){
// 创建超级管理员
SysTenantPack appAdminPack = new SysTenantPack(tenantId, "组织应用管理员", TenantConstant.APP_ADMIN);
appAdminPack.setIzSysn(CommonConstant.STATUS_0);
currentService.saveOne(appAdminPack);
}
}
@TenantLog(2)
@Override
public String saveOne(SysTenantPack sysTenantPack) {
sysTenantPackMapper.insert(sysTenantPack);
return sysTenantPack.getId();
}
@TenantLog(2)
@Override
public void savePackUser(SysTenantPackUser sysTenantPackUser) {
sysTenantPackUser.setStatus(1);
sysTenantPackUserMapper.insert(sysTenantPackUser);
}
@Override
public SysTenantPack getSysTenantPack(Integer tenantId, String packCode) {
LambdaQueryWrapper<SysTenantPack> query = new LambdaQueryWrapper<SysTenantPack>()
.eq(SysTenantPack::getPackCode, packCode)
.eq(SysTenantPack::getTenantId, tenantId);
List<SysTenantPack> list = baseMapper.selectList(query);
if(list!=null && list.size()>0){
SysTenantPack pack = list.get(0);
if(pack!=null && pack.getId()!=null){
return pack;
}
}
return null;
}
/**
* 添加菜单
*
* @param packId
* @param permissionId
*/
public void addPermission(String packId, String permissionId) {
SysPackPermission permission = new SysPackPermission();
permission.setPermissionId(permissionId);
permission.setPackId(packId);
sysPackPermissionMapper.insert(permission);
}
/**
* 根据包名id和菜单id删除关系表
*
* @param packId
* @param permissionId
*/
public void deletePackPermission(String packId, String permissionId) {
LambdaQueryWrapper<SysPackPermission> query = new LambdaQueryWrapper<>();
query.eq(SysPackPermission::getPackId, packId);
if (oConvertUtils.isNotEmpty(permissionId)) {
query.eq(SysPackPermission::getPermissionId, permissionId);
}
sysPackPermissionMapper.delete(query);
}
@Override
public void addTenantDefaultPack(Integer tenantId) {
LambdaQueryWrapper<SysTenantPack> query = new LambdaQueryWrapper<>();
query.eq(SysTenantPack::getPackType,"default");
List<SysTenantPack> sysTenantPacks = sysTenantPackMapper.selectList(query);
// 取当前租户用户列表
List<String> userIds = sysUserTenantMapper.getUserIdsByTenantId(tenantId);
for (SysTenantPack sysTenantPack: sysTenantPacks) {
// 代码逻辑说明: 【QQYUN-14007】演示系统，初始化租户套餐很慢---
syncDefaultPack2CurrentTenant(tenantId, sysTenantPack, userIds);
}
}
@Override
public void syncDefaultPack(Integer tenantId) {
// 查询默认套餐包
LambdaQueryWrapper<SysTenantPack> query = new LambdaQueryWrapper<>();
query.eq(SysTenantPack::getPackType,"default");
List<SysTenantPack> sysDefaultTenantPacks = sysTenantPackMapper.selectList(query);
// 查询当前租户套餐包
query = new LambdaQueryWrapper<>();
query.eq(SysTenantPack::getPackType,"custom");
query.eq(SysTenantPack::getTenantId, tenantId);
List<SysTenantPack> currentTenantPacks = sysTenantPackMapper.selectList(query);
// 代码逻辑说明: 【QQYUN-14007】演示系统，初始化租户套餐很慢---
Map<String, SysTenantPack> currentTenantPackMap;
if (oConvertUtils.listIsNotEmpty(currentTenantPacks)) {
currentTenantPackMap = currentTenantPacks.stream().collect(Collectors.toMap(SysTenantPack::getPackName, o -> o, (existing, replacement) -> existing));
} else {
currentTenantPackMap = new HashMap<String, SysTenantPack>();
}
// 预取当前租户用户列表，避免在循环中重复查询
List<String> userIds = sysUserTenantMapper.getUserIdsByTenantId(tenantId);
// 计算需要同步的默认套餐包列表
List<SysTenantPack> packsToSync = sysDefaultTenantPacks.stream()
.filter(p -> !currentTenantPackMap.containsKey(p.getPackName()))
.collect(Collectors.toList());
// 并行同步缺失的套餐包
packsToSync.parallelStream().forEach(defaultPacks -> {
syncDefaultPack2CurrentTenant(tenantId, defaultPacks, userIds);
});
}
/**
* 同步默认套餐包到当前租户
* for [QQYUN-11032]【jeecg】租户套餐管理增加初始化套餐包按钮
* @param tenantId 目标租户
* @param defaultPacks 默认套餐包
* @author chenrui
* @date 2025/2/5 19:41
*/
private void syncDefaultPack2CurrentTenant(Integer tenantId, SysTenantPack defaultPacks, List<String> userIds) {
SysTenantPack pack = new SysTenantPack();
BeanUtils.copyProperties(defaultPacks,pack);
pack.setTenantId(tenantId);
pack.setPackType("custom");
pack.setId("");
sysTenantPackMapper.insert(pack);
List<String> permissionsByPackId = sysPackPermissionMapper.getPermissionsByPackId(defaultPacks.getId());
List<SysPackPermission> permissionList = new ArrayList<>();
for (String permission:permissionsByPackId) {
SysPackPermission packPermission = new SysPackPermission();
packPermission.setPackId(pack.getId());
packPermission.setPermissionId(permission);
permissionList.add(packPermission);
}
if(CollectionUtil.isNotEmpty(permissionList)){
sysPackPermissionMapper.insert(permissionList);
}
//如果需要自动分配给用户时候再去添加用户与套餐的关系数据
if(oConvertUtils.isNotEmpty(defaultPacks.getIzSysn()) && CommonConstant.STATUS_1.equals(defaultPacks.getIzSysn())) {
List<SysTenantPackUser> packUserList = new ArrayList<>();
if (oConvertUtils.isNotEmpty(userIds)) {
for (String userId : userIds) {
//根据租户id和套餐id添加用户与套餐关系数据
SysTenantPackUser tenantPackUser = new SysTenantPackUser(tenantId, pack.getId(), userId);
packUserList.add(tenantPackUser);
}
sysTenantPackUserMapper.insert(packUserList);
}
}
}
/**
* 删除产品包下面的用户
* @param packId
*/
private void deletePackUser(String packId) {
LambdaQueryWrapper<SysTenantPackUser> query = new LambdaQueryWrapper<>();
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());
}
}
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysPackPermissionServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysPackPermissionServiceImpl.java | package org.jeecg.modules.system.service.impl;
import org.jeecg.modules.system.entity.SysPackPermission;
import org.jeecg.modules.system.mapper.SysPackPermissionMapper;
import org.jeecg.modules.system.service.ISysPackPermissionService;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
/**
* @Description: 产品包菜单关系表
* @Author: jeecg-boot
* @Date: 2022-12-31
* @Version: V1.0
*/
@Service
public class SysPackPermissionServiceImpl extends ServiceImpl<SysPackPermissionMapper, SysPackPermission> implements ISysPackPermissionService {
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysFillRuleServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysFillRuleServiceImpl.java | package org.jeecg.modules.system.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.jeecg.modules.system.entity.SysFillRule;
import org.jeecg.modules.system.mapper.SysFillRuleMapper;
import org.jeecg.modules.system.service.ISysFillRuleService;
import org.springframework.stereotype.Service;
/**
* @Description: 填值规则
* @Author: jeecg-boot
* @Date: 2019-11-07
* @Version: V1.0
*/
@Service("sysFillRuleServiceImpl")
public class SysFillRuleServiceImpl extends ServiceImpl<SysFillRuleMapper, SysFillRule> implements ISysFillRuleService {
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysDictItemServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysDictItemServiceImpl.java | package org.jeecg.modules.system.service.impl;
import org.jeecg.modules.system.entity.SysDictItem;
import org.jeecg.modules.system.mapper.SysDictItemMapper;
import org.jeecg.modules.system.service.ISysDictItemService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* <p>
* 服务实现类
* </p>
*
* @Author zhangweijian
* @since 2018-12-28
*/
@Service
public class SysDictItemServiceImpl extends ServiceImpl<SysDictItemMapper, SysDictItem> implements ISysDictItemService {
@Autowired
private SysDictItemMapper sysDictItemMapper;
@Override
public List<SysDictItem> selectItemsByMainId(String mainId) {
return sysDictItemMapper.selectItemsByMainId(mainId);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysAnnouncementServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysAnnouncementServiceImpl.java | package org.jeecg.modules.system.service.impl;
import cn.hutool.core.io.IoUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.compress.archivers.zip.Zip64Mode;
import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.FileDownloadUtils;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.config.JeecgBaseConfig;
import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
import org.jeecg.modules.system.entity.SysAnnouncement;
import org.jeecg.modules.system.entity.SysAnnouncementSend;
import org.jeecg.modules.system.mapper.SysAnnouncementMapper;
import org.jeecg.modules.system.mapper.SysAnnouncementSendMapper;
import org.jeecg.modules.system.mapper.SysUserMapper;
import org.jeecg.modules.system.service.ISysAnnouncementSendService;
import org.jeecg.modules.system.service.ISysAnnouncementService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLEncoder;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @Description: 系统通告表
* @Author: jeecg-boot
* @Date: 2019-01-02
* @Version: V1.0
*/
@Service
@Slf4j
public class SysAnnouncementServiceImpl extends ServiceImpl<SysAnnouncementMapper, SysAnnouncement> implements ISysAnnouncementService {
/**
* 补数据改成后台模式
*/
public static ExecutorService completeNoteThreadPool = new ThreadPoolExecutor(0, 1024, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
@Resource
private SysAnnouncementMapper sysAnnouncementMapper;
@Resource
private SysUserMapper sysUserMapper;
@Resource
private SysAnnouncementSendMapper sysAnnouncementSendMapper;
@Autowired
private ISysAnnouncementSendService sysAnnouncementSendService;
@Autowired
private JeecgBaseConfig jeecgBaseConfig;
@Transactional(rollbackFor = Exception.class)
@Override
public void saveAnnouncement(SysAnnouncement sysAnnouncement) {
if(sysAnnouncement.getMsgType().equals(CommonConstant.MSG_TYPE_ALL)) {
sysAnnouncementMapper.insert(sysAnnouncement);
}else {
// 1.插入通告表记录
sysAnnouncementMapper.insert(sysAnnouncement);
// 2.插入用户通告阅读标记表记录
String userId = sysAnnouncement.getUserIds();
// 代码逻辑说明: [issues/5503]【公告】通知无法接收
if(StringUtils.isNotBlank(userId) && userId.endsWith(",")){
userId = userId.substring(0, (userId.length()-1));
}
String[] userIds = userId.split(",");
String anntId = sysAnnouncement.getId();
Date refDate = new Date();
for(int i=0;i<userIds.length;i++) {
SysAnnouncementSend announcementSend = new SysAnnouncementSend();
announcementSend.setAnntId(anntId);
announcementSend.setUserId(userIds[i]);
announcementSend.setReadFlag(CommonConstant.NO_READ_FLAG);
announcementSend.setReadTime(refDate);
sysAnnouncementSendMapper.insert(announcementSend);
}
}
}
/**
* @功能：编辑消息信息
*/
@Transactional(rollbackFor = Exception.class)
@Override
public boolean upDateAnnouncement(SysAnnouncement sysAnnouncement) {
// 1.更新系统信息表数据
sysAnnouncementMapper.updateById(sysAnnouncement);
String userId = sysAnnouncement.getUserIds();
if(oConvertUtils.isNotEmpty(userId)&&sysAnnouncement.getMsgType().equals(CommonConstant.MSG_TYPE_UESR)) {
// 2.补充新的通知用户数据
String[] userIds = userId.substring(0, (userId.length()-1)).split(",");
String anntId = sysAnnouncement.getId();
Date refDate = new Date();
for(int i=0;i<userIds.length;i++) {
LambdaQueryWrapper<SysAnnouncementSend> queryWrapper = new LambdaQueryWrapper<SysAnnouncementSend>();
queryWrapper.eq(SysAnnouncementSend::getAnntId, anntId);
queryWrapper.eq(SysAnnouncementSend::getUserId, userIds[i]);
List<SysAnnouncementSend> announcementSends=sysAnnouncementSendMapper.selectList(queryWrapper);
if(announcementSends.size()<=0) {
SysAnnouncementSend announcementSend = new SysAnnouncementSend();
announcementSend.setAnntId(anntId);
announcementSend.setUserId(userIds[i]);
announcementSend.setReadFlag(CommonConstant.NO_READ_FLAG);
announcementSend.setReadTime(refDate);
sysAnnouncementSendMapper.insert(announcementSend);
}
}
// 3. 删除多余通知用户数据
Collection<String> delUserIds = Arrays.asList(userIds);
LambdaQueryWrapper<SysAnnouncementSend> queryWrapper = new LambdaQueryWrapper<SysAnnouncementSend>();
queryWrapper.notIn(SysAnnouncementSend::getUserId, delUserIds);
queryWrapper.eq(SysAnnouncementSend::getAnntId, anntId);
sysAnnouncementSendMapper.delete(queryWrapper);
}
return true;
}
/**
* 流程执行完成保存消息通知
* @param title 标题
* @param msgContent 信息内容
*/
@Override
public void saveSysAnnouncement(String title, String msgContent) {
SysAnnouncement announcement = new SysAnnouncement();
announcement.setTitile(title);
announcement.setMsgContent(msgContent);
announcement.setSender("JEECG BOOT");
announcement.setPriority(CommonConstant.PRIORITY_L);
announcement.setMsgType(CommonConstant.MSG_TYPE_ALL);
announcement.setSendStatus(CommonConstant.HAS_SEND);
announcement.setSendTime(new Date());
announcement.setDelFlag(CommonConstant.DEL_FLAG_0.toString());
sysAnnouncementMapper.insert(announcement);
}
@Override
public Page<SysAnnouncement> querySysCementPageByUserId(Page<SysAnnouncement> page, String userId, String msgCategory, Integer tenantId, Date beginDate) {
if (page.getSize() == -1) {
return page.setRecords(sysAnnouncementMapper.querySysCementListByUserId(null, userId, msgCategory,tenantId,beginDate));
} else {
return page.setRecords(sysAnnouncementMapper.querySysCementListByUserId(page, userId, msgCategory,tenantId,beginDate));
}
}
@Override
public Integer getUnreadMessageCountByUserId(String userId, Date beginDate, String noticeType) {
return sysAnnouncementMapper.getUnreadMessageCountByUserId(userId, beginDate, noticeType);
}
@Override
public void completeAnnouncementSendInfo() {
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
String userId = sysUser.getId();
List<String> announcementIds = this.getNotSendedAnnouncementlist(userId);
List<SysAnnouncementSend> sysAnnouncementSendList = new ArrayList<>();
if (!CollectionUtils.isEmpty(announcementIds)) {
for (String commentId : announcementIds) {
SysAnnouncementSend announcementSend = new SysAnnouncementSend();
announcementSend.setAnntId(commentId);
announcementSend.setUserId(userId);
announcementSend.setReadFlag(CommonConstant.NO_READ_FLAG);
sysAnnouncementSendList.add(announcementSend);
}
}
if (!CollectionUtils.isEmpty(sysAnnouncementSendList)) {
sysAnnouncementSendService.saveBatch(sysAnnouncementSendList);
}
}
@Override
public void batchInsertSysAnnouncementSend(String commentId, Integer tenantId) {
if (MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL && oConvertUtils.isNotEmpty(tenantId)) {
log.info("补全公告与用户的关系数据，租户ID = {}", tenantId);
} else {
tenantId = null;
}
List<String> userIdList = sysUserMapper.getTenantUserIdList(tenantId);
List<SysAnnouncementSend> sysAnnouncementSendList = new ArrayList<>();
if (!CollectionUtils.isEmpty(userIdList)) {
for (String userId : userIdList) {
SysAnnouncementSend announcementSend = new SysAnnouncementSend();
announcementSend.setAnntId(commentId);
announcementSend.setUserId(userId);
announcementSend.setReadFlag(CommonConstant.NO_READ_FLAG);
sysAnnouncementSendList.add(announcementSend);
}
}
if (!CollectionUtils.isEmpty(sysAnnouncementSendList)) {
log.info("补全公告与用户的关系数据，sysAnnouncementSendList size = {}", sysAnnouncementSendList.size());
sysAnnouncementSendService.saveBatch(sysAnnouncementSendList);
}
}
@Override
public List<SysAnnouncement> querySysMessageList(int pageSize, int pageNo, String fromUser, String starFlag, String busType, String msgCategory, Date beginDate, Date endDate, String noticeType) {
// //1. 补全send表的数据
// completeNoteThreadPool.execute(()->{
// completeAnnouncementSendInfo();
// });
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
log.debug(" 获取登录人 LoginUser id: {}", sysUser.getId());
Page<SysAnnouncement> page = new Page<SysAnnouncement>(pageNo,pageSize);
List<SysAnnouncement> list = baseMapper.queryAllMessageList(page, sysUser.getId(), fromUser, starFlag, busType, msgCategory,beginDate, endDate, noticeType);
return list;
}
@Override
public void updateReaded(List<String> annoceIdList) {
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
sysAnnouncementSendMapper.updateReaded(sysUser.getId(), annoceIdList);
}
@Override
public void clearAllUnReadMessage() {
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
sysAnnouncementSendMapper.clearAllUnReadMessage(sysUser.getId());
}
/**
* 查询用户未读的通知公告，防止SQL注入写法调整
* @param userId
* @return
*/
@Override
public List<String> getNotSendedAnnouncementlist(String userId) {
return sysAnnouncementMapper.getNotSendedAnnouncementlist(new Date(), userId);
}
/**
* 更新访问量
* @param id
* @param increaseCount
*/
@Override
public void updateVisitsNum(String id, int increaseCount) {
SysAnnouncement sysAnnouncement = sysAnnouncementMapper.selectById(id);
if (oConvertUtils.isNotEmpty(sysAnnouncement)) {
int visits = oConvertUtils.getInt(sysAnnouncement.getVisitsNum(), 0);
int totalValue = increaseCount + visits;
sysAnnouncement.setVisitsNum(totalValue);
sysAnnouncementMapper.updateById(sysAnnouncement);
log.info("通知公告：{} 访问次数+1，总访问数量：{}", sysAnnouncement.getTitile(), sysAnnouncement.getVisitsNum());
}
}
/**
* 批量下载文件
* @param id
* @param request
* @param response
*/
@Override
public void downLoadFiles(String id, HttpServletRequest request, HttpServletResponse response) {
// 参数校验
if (oConvertUtils.isEmpty(id)) {
response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
return;
}
// 获取文章信息
SysAnnouncement sysAnnouncement = this.baseMapper.selectById(id);
if (oConvertUtils.isEmpty(sysAnnouncement)) {
response.setStatus(HttpServletResponse.SC_NOT_FOUND);
return;
}
//设置HTTP响应头：准备文件下载
response.reset();
response.setCharacterEncoding("utf-8");
response.setContentType("application/force-download");
ZipArchiveOutputStream zous = null;
try {
// 生成ZIP文件名：使用文章标题+时间戳避免重名
String title = sysAnnouncement.getTitile() + new Date().getTime();
String zipName = URLEncoder.encode( title + ".zip", "UTF-8").replaceAll("\\+", "%20");
response.setHeader("Content-Disposition", "attachment;filename*=utf-8''" + zipName);
// 创建ZIP输出流：直接输出到HTTP响应流
zous = new ZipArchiveOutputStream(response.getOutputStream());
zous.setUseZip64(Zip64Mode.AsNeeded);// 支持大文件
// 批量下载文件
String[] fileUrls = sysAnnouncement.getFiles().split(",");
// 遍历所有文件URL
for (int i = 0; i < fileUrls.length; i++) {
String fileUrl = fileUrls[i].trim();
if (oConvertUtils.isEmpty(fileUrl)) {
continue;
}
// 生成ZIP内文件名：避免重名，添加序号
String fileName = FileDownloadUtils.generateFileName(fileUrl, i, fileUrls.length);
String uploadUrl = jeecgBaseConfig.getPath().getUpload();
// 下载单个文件并添加到ZIP
FileDownloadUtils.downLoadSingleFile(fileUrl,fileName,uploadUrl, zous);
}
// 完成ZIP写入
zous.finish();
// 刷新缓冲区确保数据发送
response.flushBuffer();
} catch (IOException e) {
log.error("文件下载失败"+e.getMessage(), e);
response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
} finally {
// 确保流关闭，防止资源泄漏
IoUtil.close(zous);
}
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/ThirdAppWechatEnterpriseServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/ThirdAppWechatEnterpriseServiceImpl.java | package org.jeecg.modules.system.service.impl;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.jeecg.qywx.api.base.JwAccessTokenAPI;
import com.jeecg.qywx.api.core.common.AccessToken;
import com.jeecg.qywx.api.department.JwDepartmentAPI;
import com.jeecg.qywx.api.department.vo.DepartMsgResponse;
import com.jeecg.qywx.api.department.vo.Department;
import com.jeecg.qywx.api.message.JwMessageAPI;
import com.jeecg.qywx.api.message.vo.*;
import com.jeecg.qywx.api.user.JwUserAPI;
import com.jeecg.qywx.api.user.vo.User;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.jeecg.common.api.dto.message.MessageDTO;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.constant.enums.MessageTypeEnum;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.util.PasswordUtil;
import org.jeecg.common.util.RestUtil;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.config.JeecgBaseConfig;
import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
import org.jeecg.modules.system.entity.*;
import org.jeecg.modules.system.mapper.*;
import org.jeecg.modules.system.model.SysDepartTreeModel;
import org.jeecg.modules.system.service.*;
import org.jeecg.modules.system.vo.thirdapp.JwDepartmentTreeVo;
import org.jeecg.modules.system.vo.thirdapp.JwSysUserDepartVo;
import org.jeecg.modules.system.vo.thirdapp.JwUserDepartVo;
import org.jeecg.modules.system.vo.thirdapp.SyncInfoVo;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Collectors;
/**
* 第三方App对接：企业微信实现类
* @author: jeecg-boot
*/
@Slf4j
@Service
public class ThirdAppWechatEnterpriseServiceImpl implements IThirdAppService {
@Autowired
JeecgBaseConfig jeecgBaseConfig;
@Autowired
private ISysDepartService sysDepartService;
@Autowired
private SysUserMapper userMapper;
@Autowired
private ISysThirdAccountService sysThirdAccountService;
@Autowired
private ISysUserDepartService sysUserDepartService;
@Autowired
private ISysPositionService sysPositionService;
@Autowired
private SysAnnouncementSendMapper sysAnnouncementSendMapper;
@Autowired
private SysThirdAppConfigMapper configMapper;
@Autowired
private SysTenantMapper sysTenantMapper;
@Autowired
private SysUserTenantMapper sysUserTenantMapper;
@Autowired
private SysThirdAccountMapper sysThirdAccountMapper;
@Autowired
private SysTenantMapper tenantMapper;
/**
* errcode
*/
private static final String ERR_CODE = "errcode";
/**
* 第三方APP类型，当前固定为 wechat_enterprise
*/
public final String THIRD_TYPE = "wechat_enterprise";
@Override
public String getAccessToken() {
// 代码逻辑说明: [QQYUN-3440]新建企业微信和钉钉配置表，通过租户模式隔离------------
SysThirdAppConfig config = this.getWeChatThirdAppConfig();
String corpId = config.getClientId();
String secret = config.getClientSecret();
AccessToken accessToken = JwAccessTokenAPI.getAccessToken(corpId, secret);
if (accessToken != null) {
return accessToken.getAccesstoken();
}
log.warn("获取AccessToken失败");
return null;
}
/** 获取APPToken，新版企业微信的秘钥是分开的 */
public String getAppAccessToken(SysThirdAppConfig config) {
// 代码逻辑说明: [QQYUN-3440]新建企业微信和钉钉配置表，通过租户模式隔离------------
String corpId = config.getClientId();
// 如果没有配置APP秘钥，就说明是老企业，可以通用秘钥
String secret = config.getClientSecret();
AccessToken accessToken = JwAccessTokenAPI.getAccessToken(corpId, secret);
if (accessToken != null) {
return accessToken.getAccesstoken();
}
log.warn("获取AccessToken失败");
return null;
}
@Override
public SyncInfoVo syncLocalDepartmentToThirdApp(String ids) {
SyncInfoVo syncInfo = new SyncInfoVo();
String accessToken = this.getAccessToken();
if (accessToken == null) {
syncInfo.addFailInfo("accessToken获取失败！");
return syncInfo;
}
// 获取企业微信所有的部门
List<Department> departments = JwDepartmentAPI.getAllDepartment(accessToken);
if (departments == null) {
syncInfo.addFailInfo("获取企业微信所有部门失败！");
return syncInfo;
}
// 删除企业微信有但本地没有的部门（以本地部门数据为主）(以为企业微信不能创建同名部门，所以只能先删除）
List<JwDepartmentTreeVo> departmentTreeList = JwDepartmentTreeVo.listToTree(departments);
this.deleteDepartRecursion(departmentTreeList, accessToken, true);
// 获取本地所有部门树结构
List<SysDepartTreeModel> sysDepartsTree = sysDepartService.queryTreeList();
// -- 企业微信不能创建新的顶级部门，所以新的顶级部门的parentId就为1
Department parent = new Department();
parent.setId("1");
// 递归同步部门
departments = JwDepartmentAPI.getAllDepartment(accessToken);
this.syncDepartmentRecursion(sysDepartsTree, departments, parent, accessToken);
return syncInfo;
}
/**
* 递归删除部门以及子部门，由于企业微信不允许删除带有成员和子部门的部门，所以需要递归删除下子部门，然后把部门成员移动端根部门下
* @param children
* @param accessToken
* @param ifLocal
*/
private void deleteDepartRecursion(List<JwDepartmentTreeVo> children, String accessToken, boolean ifLocal) {
for (JwDepartmentTreeVo departmentTree : children) {
String depId = departmentTree.getId();
// 过滤根部门
if (!"1".equals(depId)) {
// 判断本地是否有该部门
if (ifLocal) {
LambdaQueryWrapper<SysDepart> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SysDepart::getQywxIdentifier, depId);
SysDepart sysDepart = sysDepartService.getOne(queryWrapper);
// 本地有该部门，不删除
if (sysDepart != null) {
if (departmentTree.hasChildren()) {
this.deleteDepartRecursion(departmentTree.getChildren(), accessToken, true);
}
continue;
}
}
// 判断是否有成员，有就移动到根部门
List<User> departUserList = JwUserAPI.getUsersByDepartid(depId, "1", null, accessToken);
if (departUserList != null && departUserList.size() > 0) {
for (User user : departUserList) {
User updateUser = new User();
updateUser.setUserid(user.getUserid());
updateUser.setDepartment(new Integer[]{1});
JwUserAPI.updateUser(updateUser, accessToken);
}
}
// 有子部门优先删除子部门
if (departmentTree.hasChildren()) {
this.deleteDepartRecursion(departmentTree.getChildren(), accessToken, false);
}
// 执行删除操作
JwDepartmentAPI.deleteDepart(depId, accessToken);
}
}
}
/**
* 递归同步部门到第三方APP
* @param sysDepartsTree
* @param departments
* @param parent
* @param accessToken
*/
private void syncDepartmentRecursion(List<SysDepartTreeModel> sysDepartsTree, List<Department> departments, Department parent, String accessToken) {
if (sysDepartsTree != null && sysDepartsTree.size() != 0) {
for1:
for (SysDepartTreeModel depart : sysDepartsTree) {
for (Department department : departments) {
// id相同，代表已存在，执行修改操作
if (department.getId().equals(depart.getQywxIdentifier())) {
this.sysDepartToQwDepartment(depart, department, parent.getId());
JwDepartmentAPI.updateDepart(department, accessToken);
// 紧接着同步子级
this.syncDepartmentRecursion(depart.getChildren(), departments, department, accessToken);
// 跳出外部循环
continue for1;
}
}
// 循环到此说明是新部门，直接调接口创建
Department newDepartment = this.sysDepartToQwDepartment(depart, parent.getId());
DepartMsgResponse response = JwDepartmentAPI.createDepartment(newDepartment, accessToken);
// 创建成功，将返回的id绑定到本地
if (response != null && response.getId() != null) {
SysDepart sysDepart = new SysDepart();
sysDepart.setId(depart.getId());
sysDepart.setQywxIdentifier(response.getId().toString());
sysDepartService.updateById(sysDepart);
Department newParent = new Department();
newParent.setId(response.getId().toString());
// 紧接着同步子级
this.syncDepartmentRecursion(depart.getChildren(), departments, newParent, accessToken);
}
// 收集错误信息
// this.syncUserCollectErrInfo(errCode, sysUser, errInfo);
}
}
}
public SyncInfoVo syncThirdAppDepartmentToLocal(Integer tenantId, Map<String,String> map) {
SyncInfoVo syncInfo = new SyncInfoVo();
String accessToken = this.getAccessToken();
if (accessToken == null) {
syncInfo.addFailInfo("accessToken获取失败！");
return syncInfo;
}
// 获取企业微信所有的部门
List<Department> departments = JwDepartmentAPI.getAllDepartment(accessToken);
if (departments == null) {
syncInfo.addFailInfo("企业微信部门信息获取失败！");
return syncInfo;
}
String username = JwtUtil.getUserNameByToken(SpringContextUtils.getHttpServletRequest());
// 将list转为tree
List<JwDepartmentTreeVo> departmentTreeList = JwDepartmentTreeVo.listToTree(departments);
// 递归同步部门
this.syncDepartmentToLocalRecursion(departmentTreeList, null, username, syncInfo, tenantId, map);
return syncInfo;
}
/**
* 递归同步部门到本地
*/
private void syncDepartmentToLocalRecursion(List<JwDepartmentTreeVo> departmentTreeList, String sysParentId, String username, SyncInfoVo syncInfo,Integer tenantId, Map<String,String> map) {
if (departmentTreeList != null && departmentTreeList.size() != 0) {
for (JwDepartmentTreeVo departmentTree : departmentTreeList) {
String depId = departmentTree.getId();
LambdaQueryWrapper<SysDepart> queryWrapper = new LambdaQueryWrapper<>();
// 根据 qywxIdentifier 字段和租户id查询，租户id默认为0
queryWrapper.eq(SysDepart::getQywxIdentifier, depId);
queryWrapper.eq(SysDepart::getTenantId, tenantId);
SysDepart sysDepart = sysDepartService.getOne(queryWrapper);
if (sysDepart != null) {
// 执行更新操作
SysDepart updateSysDepart = this.qwDepartmentToSysDepart(departmentTree, sysDepart);
// 代码逻辑说明: 【issues/6017】企业微信同步部门时没有最顶层的部门名，同步用户时，用户没有部门信息---
if (sysParentId != null && !"0".equals(sysParentId)) {
updateSysDepart.setParentId(sysParentId);
}
try {
sysDepartService.updateDepartDataById(updateSysDepart, username);
String str = String.format("部门 %s 更新成功！", updateSysDepart.getDepartName());
syncInfo.addSuccessInfo(str);
map.put(depId,updateSysDepart.getId());
} catch (Exception e) {
this.syncDepartCollectErrInfo(e, departmentTree, syncInfo);
}
if (departmentTree.hasChildren()) {
// 紧接着同步子级
this.syncDepartmentToLocalRecursion(departmentTree.getChildren(), updateSysDepart.getId(), username, syncInfo, tenantId, map);
}
} else {
// 执行新增操作
SysDepart newSysDepart = this.qwDepartmentToSysDepart(departmentTree, null);
if (sysParentId != null && !"0".equals(sysParentId)) {
newSysDepart.setParentId(sysParentId);
// 2 = 组织机构
newSysDepart.setOrgCategory("2");
} else {
// 1 = 公司
newSysDepart.setOrgCategory("1");
}
newSysDepart.setTenantId(tenantId);
try {
sysDepartService.saveDepartData(newSysDepart, username);
String str = String.format("部门 %s 创建成功！", newSysDepart.getDepartName());
syncInfo.addSuccessInfo(str);
map.put(depId,newSysDepart.getId());
} catch (Exception e) {
this.syncDepartCollectErrInfo(e, departmentTree, syncInfo);
}
// 紧接着同步子级
if (departmentTree.hasChildren()) {
this.syncDepartmentToLocalRecursion(departmentTree.getChildren(), newSysDepart.getId(), username, syncInfo, tenantId, map);
}
}
}
}
}
@Override
public SyncInfoVo syncLocalUserToThirdApp(String ids) {
SyncInfoVo syncInfo = new SyncInfoVo();
String accessToken = this.getAccessToken();
if (accessToken == null) {
syncInfo.addFailInfo("accessToken获取失败！");
return syncInfo;
}
// 获取企业微信所有的用户
// List<User> qwUsers = JwUserAPI.getDetailUsersByDepartid("1", null, null, accessToken);
// 获取企业微信所有的用户（只能获取userid）
List<User> qwUsers = JwUserAPI.getUserIdList(accessToken);
if (qwUsers == null) {
syncInfo.addFailInfo("企业微信用户列表查询失败！");
return syncInfo;
}
List<SysUser> sysUsers;
if (StringUtils.isNotBlank(ids)) {
String[] idList = ids.split(",");
LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.in(SysUser::getId, (Object[]) idList);
// 获取本地指定用户
sysUsers = userMapper.selectList(queryWrapper);
} else {
// 获取本地所有用户
sysUsers = userMapper.selectList(Wrappers.emptyWrapper());
}
// 循环判断新用户和需要更新的用户
for1:
for (SysUser sysUser : sysUsers) {
// 外部模拟登陆临时账号，不同步
if ("_reserve_user_external".equals(sysUser.getUsername())) {
continue;
}
/*
* 判断是否同步过的逻辑：
* 1. 查询 sys_third_account（第三方账号表）是否有数据，如果有代表已同步
* 2. 本地表里没有，就先用手机号判断，不通过再用username判断。
*/
User qwUser;
SysThirdAccount sysThirdAccount = sysThirdAccountService.getOneBySysUserId(sysUser.getId(), THIRD_TYPE);
for (User qwUserTemp : qwUsers) {
if (sysThirdAccount == null || oConvertUtils.isEmpty(sysThirdAccount.getThirdUserId()) || !sysThirdAccount.getThirdUserId().equals(qwUserTemp.getUserid())) {
// sys_third_account 表匹配失败，尝试用手机号匹配
// 新版企业微信调整了API，现在只能通过userid来判断是否同步过了
// String phone = sysUser.getPhone();
// if (!(oConvertUtils.isEmpty(phone) || phone.equals(qwUserTemp.getMobile()))) {
// 手机号匹配失败，再尝试用username匹配
String username = sysUser.getUsername();
if (!(oConvertUtils.isEmpty(username) || username.equals(qwUserTemp.getUserid()))) {
// username 匹配失败，直接跳到下一次循环继续
continue;
}
// }
}
// 循环到此说明用户匹配成功，进行更新操作
qwUser = this.sysUserToQwUser(sysUser, qwUserTemp);
int errCode = JwUserAPI.updateUser(qwUser, accessToken);
// 收集错误信息
this.syncUserCollectErrInfo(errCode, sysUser, syncInfo);
this.thirdAccountSaveOrUpdate(sysThirdAccount, sysUser.getId(), qwUser.getUserid(),qwUser.getName(), null);
// 更新完成，直接跳到下一次外部循环继续
continue for1;
}
// 循环到此说明是新用户，直接调接口创建
qwUser = this.sysUserToQwUser(sysUser);
int errCode = JwUserAPI.createUser(qwUser, accessToken);
// 收集错误信息
boolean apiSuccess = this.syncUserCollectErrInfo(errCode, sysUser, syncInfo);
if (apiSuccess) {
this.thirdAccountSaveOrUpdate(sysThirdAccount, sysUser.getId(), qwUser.getUserid(),qwUser.getName(), null);
}
}
return syncInfo;
}
// @Override
// public SyncInfoVo syncThirdAppUserToLocal() {
// SyncInfoVo syncInfo = new SyncInfoVo();
// String accessToken = this.getAccessToken();
// if (accessToken == null) {
// syncInfo.addFailInfo("accessToken获取失败！");
// return syncInfo;
// }
// // 获取企业微信所有的用户
// List<User> qwUsersList = JwUserAPI.getDetailUsersByDepartid("1", null, null, accessToken);
// if (qwUsersList == null) {
// syncInfo.addFailInfo("企业微信用户列表查询失败！");
// return syncInfo;
// }
// //查询本地用户
// List<SysUser> sysUsersList = userMapper.selectList(Wrappers.emptyWrapper());
// // 循环判断新用户和需要更新的用户
// for (User qwUser : qwUsersList) {
// /*
// * 判断是否同步过的逻辑：
// * 1. 查询 sys_third_account（第三方账号表）是否有数据，如果有代表已同步
// * 2. 本地表里没有，就先用手机号判断，不通过再用username判断。
// */
// SysThirdAccount sysThirdAccount = sysThirdAccountService.getOneByThirdUserId(qwUser.getUserid(), THIRD_TYPE);
// List<SysUser> collect = sysUsersList.stream().filter(user -> (qwUser.getMobile().equals(user.getPhone()) || qwUser.getUserid().equals(user.getUsername()))
// ).collect(Collectors.toList());
//
// if (collect != null && collect.size() > 0) {
// SysUser sysUserTemp = collect.get(0);
// // 循环到此说明用户匹配成功，进行更新操作
// SysUser updateSysUser = this.qwUserToSysUser(qwUser, sysUserTemp);
// try {
// userMapper.updateById(updateSysUser);
// String str = String.format("用户 %s(%s) 更新成功！", updateSysUser.getRealname(), updateSysUser.getUsername());
// syncInfo.addSuccessInfo(str);
// } catch (Exception e) {
// this.syncUserCollectErrInfo(e, qwUser, syncInfo);
// }
//
// this.thirdAccountSaveOrUpdate(sysThirdAccount, updateSysUser.getId(), qwUser.getUserid());
// // 更新完成，直接跳到下一次外部循环继续
// }else{
// // 没匹配到用户则走新增逻辑
// SysUser newSysUser = this.qwUserToSysUser(qwUser);
// try {
// userMapper.insert(newSysUser);
// String str = String.format("用户 %s(%s) 创建成功！", newSysUser.getRealname(), newSysUser.getUsername());
// syncInfo.addSuccessInfo(str);
// } catch (Exception e) {
// this.syncUserCollectErrInfo(e, qwUser, syncInfo);
// }
// this.thirdAccountSaveOrUpdate(sysThirdAccount, newSysUser.getId(), qwUser.getUserid());
// }
// }
// return syncInfo;
// }
/**
* 保存或修改第三方登录表
*
* @param sysThirdAccount 第三方账户表对象，为null就新增数据，否则就修改
* @param sysUserId 本地系统用户ID
* @param qwUserId 企业微信用户ID
* @param wechatRealName 企业微信用户真实姓名
*/
private void thirdAccountSaveOrUpdate(SysThirdAccount sysThirdAccount, String sysUserId, String qwUserId, String wechatRealName, Integer tenantId) {
if (sysThirdAccount == null) {
sysThirdAccount = new SysThirdAccount();
sysThirdAccount.setSysUserId(sysUserId);
sysThirdAccount.setStatus(1);
sysThirdAccount.setDelFlag(0);
sysThirdAccount.setThirdType(THIRD_TYPE);
if(oConvertUtils.isNotEmpty(tenantId)){
sysThirdAccount.setTenantId(tenantId);
}
}
sysThirdAccount.setThirdUserId(qwUserId);
sysThirdAccount.setThirdUserUuid(qwUserId);
sysThirdAccount.setRealname(wechatRealName);
sysThirdAccountService.saveOrUpdate(sysThirdAccount);
}
/**
* 【同步用户】收集同步过程中的错误信息
*/
private boolean syncUserCollectErrInfo(int errCode, SysUser sysUser, SyncInfoVo syncInfo) {
if (errCode != 0) {
String msg = "";
// https://open.work.weixin.qq.com/api/doc/90000/90139/90313
switch (errCode) {
case 40003:
msg = "无效的UserID";
break;
case 60129:
msg = "手机和邮箱不能都为空";
break;
case 60102:
msg = "UserID已存在";
break;
case 60103:
msg = "手机号码不合法";
break;
case 60104:
msg = "手机号码已存在";
break;
default:
}
String str = String.format("用户 %s(%s) 同步失败！错误码：%s——%s", sysUser.getUsername(), sysUser.getRealname(), errCode, msg);
syncInfo.addFailInfo(str);
return false;
} else {
String str = String.format("用户 %s(%s) 同步成功！", sysUser.getUsername(), sysUser.getRealname());
syncInfo.addSuccessInfo(str);
return true;
}
}
private boolean syncUserCollectErrInfo(Exception e, User qwUser, SyncInfoVo syncInfo) {
String msg;
if (e instanceof DuplicateKeyException) {
msg = e.getCause().getMessage();
} else {
msg = e.getMessage();
}
String str = String.format("用户 %s(%s) 同步失败！错误信息：%s", qwUser.getUserid(), qwUser.getName(), msg);
syncInfo.addFailInfo(str);
return false;
}
private boolean syncDepartCollectErrInfo(Exception e, Department department, SyncInfoVo syncInfo) {
String msg;
if (e instanceof DuplicateKeyException) {
msg = e.getCause().getMessage();
} else {
msg = e.getMessage();
}
String str = String.format("部门 %s(%s) 同步失败！错误信息：%s", department.getName(), department.getId(), msg);
syncInfo.addFailInfo(str);
return false;
}
/**
* 【同步用户】将SysUser转为企业微信的User对象（创建新用户）
*/
private User sysUserToQwUser(SysUser sysUser) {
User user = new User();
// 通过 username 来关联
user.setUserid(sysUser.getUsername());
return this.sysUserToQwUser(sysUser, user);
}
/**
* 【同步用户】将SysUser转为企业微信的User对象（更新旧用户）
*/
private User sysUserToQwUser(SysUser sysUser, User user) {
user.setName(sysUser.getRealname());
user.setMobile(sysUser.getPhone());
// 查询并同步用户部门关系
List<SysDepart> departList = this.getUserDepart(sysUser);
if (departList != null) {
List<Integer> departmentIdList = new ArrayList<>();
// 企业微信 1表示为上级，0表示非上级
List<Integer> isLeaderInDept = new ArrayList<>();
// 当前用户管理的部门
List<String> manageDepartIdList = new ArrayList<>();
if (oConvertUtils.isNotEmpty(sysUser.getDepartIds())) {
manageDepartIdList = Arrays.asList(sysUser.getDepartIds().split(","));
}
for (SysDepart sysDepart : departList) {
// 企业微信的部门id
if (oConvertUtils.isNotEmpty(sysDepart.getQywxIdentifier())) {
try {
departmentIdList.add(Integer.parseInt(sysDepart.getQywxIdentifier()));
} catch (NumberFormatException ignored) {
continue;
}
// 判断用户身份，是否为上级
if (CommonConstant.USER_IDENTITY_2.equals(sysUser.getUserIdentity())) {
// 判断当前部门是否为该用户管理的部门
isLeaderInDept.add(manageDepartIdList.contains(sysDepart.getId()) ? 1 : 0);
} else {
isLeaderInDept.add(0);
}
}
}
user.setDepartment(departmentIdList.toArray(new Integer[]{}));
// 个数必须和参数department的个数一致，表示在所在的部门内是否为上级。1表示为上级，0表示非上级。在审批等应用里可以用来标识上级审批人
user.setIs_leader_in_dept(isLeaderInDept.toArray(new Integer[]{}));
}
if (user.getDepartment() == null || user.getDepartment().length == 0) {
// 没有找到匹配部门，同步到根部门下
user.setDepartment(new Integer[]{1});
user.setIs_leader_in_dept(new Integer[]{0});
}
// 职务翻译
// 代码逻辑说明: [QQYUN-3980]组织管理中 职位功能 职位表加租户id 加职位-用户关联表------------
List<SysPosition> positionList = sysPositionService.getPositionList(sysUser.getId());
if(null != positionList && positionList.size()>0){
String positionName = positionList.stream().map(SysPosition::getName).collect(Collectors.joining(SymbolConstant.COMMA));
user.setPosition(positionName);
}
if (sysUser.getSex() != null) {
user.setGender(sysUser.getSex().toString());
}
user.setEmail(sysUser.getEmail());
// 启用/禁用成员（状态），规则不同，需要转换
// 企业微信规则：1表示启用成员，0表示禁用成员
// JEECG规则：1正常，2冻结
if (sysUser.getStatus() != null) {
if (CommonConstant.USER_UNFREEZE.equals(sysUser.getStatus()) || CommonConstant.USER_FREEZE.equals(sysUser.getStatus())) {
user.setEnable(sysUser.getStatus() == 1 ? 1 : 0);
} else {
user.setEnable(1);
}
}
// 座机号
user.setTelephone(sysUser.getTelephone());
// --- 企业微信没有逻辑删除的功能
// 代码逻辑说明: 本地逻辑删除的用户，在企业微信里禁用 -----
if (CommonConstant.DEL_FLAG_1.equals(sysUser.getDelFlag())) {
user.setEnable(0);
}
return user;
}
/**
* 查询用户和部门的关系
*/
private List<SysDepart> getUserDepart(SysUser sysUser) {
// 根据用户部门关系表查询出用户的部门
LambdaQueryWrapper<SysUserDepart> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SysUserDepart::getUserId, sysUser.getId());
List<SysUserDepart> sysUserDepartList = sysUserDepartService.list(queryWrapper);
if (sysUserDepartList.size() == 0) {
return null;
}
// 根据用户部门
LambdaQueryWrapper<SysDepart> departQueryWrapper = new LambdaQueryWrapper<>();
List<String> departIdList = sysUserDepartList.stream().map(SysUserDepart::getDepId).collect(Collectors.toList());
departQueryWrapper.in(SysDepart::getId, departIdList);
List<SysDepart> departList = sysDepartService.list(departQueryWrapper);
return departList.size() == 0 ? null : departList;
}
/**
* 【同步用户】将企业微信的User对象转为SysUser（创建新用户）
*/
private SysUser qwUserToSysUser(User user) {
SysUser sysUser = new SysUser();
sysUser.setDelFlag(0);
sysUser.setStatus(1);
// 通过 username 来关联
sysUser.setUsername(user.getUserid());
// 密码默认为 “123456”，随机加盐
String password = "123456", salt = oConvertUtils.randomGen(8);
String passwordEncode = PasswordUtil.encrypt(sysUser.getUsername(), password, salt);
sysUser.setSalt(salt);
sysUser.setPassword(passwordEncode);
return this.qwUserToSysUser(user, sysUser);
}
/**
* 【同步用户】将企业微信的User对象转为SysUser（更新旧用户）
*/
private SysUser qwUserToSysUser(User qwUser, SysUser oldSysUser) {
SysUser sysUser = new SysUser();
BeanUtils.copyProperties(oldSysUser, sysUser);
sysUser.setRealname(qwUser.getName());
sysUser.setPost(qwUser.getPosition());
// 设置工号，由于企业微信没有工号的概念，所以只能用 userId 代替
if (oConvertUtils.isEmpty(sysUser.getWorkNo())) {
sysUser.setWorkNo(qwUser.getUserid());
}
try {
sysUser.setSex(Integer.parseInt(qwUser.getGender()));
} catch (NumberFormatException ignored) {
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | true |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysBaseApiImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysBaseApiImpl.java | package org.jeecg.modules.system.service.impl;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.aliyuncs.exceptions.ClientException;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.google.common.base.Joiner;
import com.jeecg.dingtalk.api.core.response.Response;
import freemarker.core.TemplateClassResolver;
import freemarker.template.Configuration;
import freemarker.template.Template;
import freemarker.template.TemplateException;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.api.dto.AiragFlowDTO;
import org.jeecg.common.api.dto.DataLogDTO;
import org.jeecg.common.api.dto.OnlineAuthDTO;
import org.jeecg.common.api.dto.PushMessageDTO;
import org.jeecg.common.api.dto.message.*;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.UrlMatchEnum;
import org.jeecg.common.constant.*;
import org.jeecg.common.constant.enums.*;
import org.jeecg.common.desensitization.util.SensitiveInfoUtil;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.common.system.query.QueryCondition;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.system.query.QueryRuleEnum;
import org.jeecg.common.system.vo.*;
import org.jeecg.common.util.*;
import org.jeecg.common.util.dynamic.db.FreemarkerParseFactory;
import org.jeecg.config.firewall.SqlInjection.IDictTableWhiteListHandler;
import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
import org.jeecg.modules.airag.flow.service.IAiragFlowService;
import org.jeecg.modules.message.entity.SysMessageTemplate;
import org.jeecg.modules.message.handle.impl.DdSendMsgHandle;
import org.jeecg.modules.message.handle.impl.EmailSendMsgHandle;
import org.jeecg.modules.message.handle.impl.QywxSendMsgHandle;
import org.jeecg.modules.message.handle.impl.SystemSendMsgHandle;
import org.jeecg.modules.message.service.ISysMessageTemplateService;
import org.jeecg.modules.message.websocket.WebSocket;
import org.jeecg.modules.system.entity.*;
import org.jeecg.modules.system.mapper.*;
import org.jeecg.modules.system.service.*;
import org.jeecg.modules.system.util.SecurityUtil;
import org.jeecg.modules.system.vo.lowapp.SysDictVo;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.ui.freemarker.FreeMarkerTemplateUtils;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.CollectionUtils;
import org.springframework.util.PathMatcher;
import jakarta.annotation.Resource;
import org.springframework.web.client.RestClientException;
import org.springframework.web.client.RestTemplate;
import javax.sql.DataSource;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
import java.util.*;
import java.util.stream.Collectors;
/**
* @Description: 底层共通业务API，提供其他独立模块调用
* @Author: scott
* @Date:2019-4-20
* @Version:V1.0
*/
@Slf4j
@Service
public class SysBaseApiImpl implements ISysBaseAPI {
/** 当前系统数据库类型 */
private static String DB_TYPE = "";
// uniapp 推送调用api地址
@Value("${jeecg.unicloud.pushUrl:}")
private String jeecgPushUrl;
@Autowired
private RestTemplate restTemplate;
@Autowired
private ISysMessageTemplateService sysMessageTemplateService;
@Resource
private SysUserMapper userMapper;
@Resource
private SysUserRoleMapper sysUserRoleMapper;
@Autowired
private ISysDepartService sysDepartService;
@Autowired
private ISysDictService sysDictService;
@Resource
private SysAnnouncementMapper sysAnnouncementMapper;
@Resource
private SysAnnouncementSendMapper sysAnnouncementSendMapper;
@Resource
private WebSocket webSocket;
@Resource
private SysRoleMapper roleMapper;
@Resource
private SysDepartMapper departMapper;
@Resource
private SysCategoryMapper categoryMapper;
@Autowired
private ISysDataSourceService dataSourceService;
@Autowired
private ISysUserDepartService sysUserDepartService;
@Autowired
private ISysUserDepPostService sysUserDepPostService;
@Resource
private SysPermissionMapper sysPermissionMapper;
@Autowired
private ISysPermissionDataRuleService sysPermissionDataRuleService;
@Autowired
private ThirdAppWechatEnterpriseServiceImpl wechatEnterpriseService;
@Autowired
private ThirdAppDingtalkServiceImpl dingtalkService;
@Autowired
ISysCategoryService sysCategoryService;
@Autowired
private ISysUserService sysUserService;
@Autowired
private ISysDataLogService sysDataLogService;
@Autowired
private ISysRoleService sysRoleService;
@Autowired
private ISysUserTenantService sysUserTenantService;
@Autowired
private ISysUserRoleService sysUserRoleService;
@Autowired
private ISysUserPositionService sysUserPositionService;
@Autowired
private IDictTableWhiteListHandler dictTableWhiteListHandler;
@Autowired
private ISysAnnouncementService sysAnnouncementService;
@Autowired
IAiragFlowService airagFlowService;
@Override
//@SensitiveDecode
public LoginUser getUserByName(String username) {
// 代码逻辑说明: VUEN-1276 【v3流程图】测试bug 1、通过我发起的流程或者流程实例，查看历史，流程图预览问题
if (oConvertUtils.isEmpty(username)) {
return null;
}
LoginUser user = sysUserService.getEncodeUserInfo(username);
//相同类中方法间调用时脱敏解密 Aop会失效，获取用户信息太重要，此处采用原生解密方法，不采用@SensitiveDecodeAble注解方式
try {
SensitiveInfoUtil.handlerObject(user, false);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return user;
}
@Override
@Cacheable(cacheNames=CommonConstant.SYS_USER_ID_MAPPING_CACHE, key="#username")
public String getUserIdByName(String username) {
if (oConvertUtils.isEmpty(username)) {
return null;
}
String userId = userMapper.getUserIdByName(username);
return userId;
}
@Override
public String translateDictFromTable(String table, String text, String code, String key) {
return sysDictService.queryTableDictTextByKey(table, text, code, key);
}
@Override
public String translateDict(String code, String key) {
return sysDictService.queryDictTextByKey(code, key);
}
@Override
public List<SysPermissionDataRuleModel> queryPermissionDataRule(String component, String requestPath, String username) {
List<SysPermission> currentSyspermission = null;
if(oConvertUtils.isNotEmpty(component)) {
//1.通过注解属性pageComponent 获取菜单
LambdaQueryWrapper<SysPermission> query = new LambdaQueryWrapper<SysPermission>();
query.eq(SysPermission::getDelFlag,0);
query.eq(SysPermission::getComponent, component);
currentSyspermission = sysPermissionMapper.selectList(query);
}else {
//1.直接通过前端请求地址查询菜单
LambdaQueryWrapper<SysPermission> query = new LambdaQueryWrapper<SysPermission>();
query.eq(SysPermission::getMenuType,2);
query.eq(SysPermission::getDelFlag,0);
// 代码逻辑说明: 解决参数顺序问题
List<String> allPossiblePaths = this.getOnlinePossiblePaths(requestPath);
log.debug("获取的菜单地址= {}", allPossiblePaths.toString());
if(allPossiblePaths.size()==1){
query.eq(SysPermission::getUrl, requestPath);
}else{
query.in(SysPermission::getUrl, allPossiblePaths);
}
currentSyspermission = sysPermissionMapper.selectList(query);
//2.未找到 再通过自定义匹配URL 获取菜单
if(currentSyspermission==null || currentSyspermission.size()==0) {
//通过自定义URL匹配规则 获取菜单（实现通过菜单配置数据权限规则，实际上针对获取数据接口进行数据规则控制）
String userMatchUrl = UrlMatchEnum.getMatchResultByUrl(requestPath);
LambdaQueryWrapper<SysPermission> queryQserMatch = new LambdaQueryWrapper<SysPermission>();
// 代码逻辑说明: online菜单如果配置成一级菜单 权限查询不到 取消menuType = 1
//queryQserMatch.eq(SysPermission::getMenuType, 1);
queryQserMatch.eq(SysPermission::getDelFlag, 0);
queryQserMatch.eq(SysPermission::getUrl, userMatchUrl);
if(oConvertUtils.isNotEmpty(userMatchUrl)){
currentSyspermission = sysPermissionMapper.selectList(queryQserMatch);
}
}
//3.未找到 再通过正则匹配获取菜单
if(currentSyspermission==null || currentSyspermission.size()==0) {
//通过正则匹配权限配置
String regUrl = getRegexpUrl(requestPath);
if(regUrl!=null) {
currentSyspermission = sysPermissionMapper.selectList(new LambdaQueryWrapper<SysPermission>().eq(SysPermission::getMenuType,2).eq(SysPermission::getUrl, regUrl).eq(SysPermission::getDelFlag,0));
}
}
}
if(currentSyspermission!=null && currentSyspermission.size()>0){
List<SysPermissionDataRuleModel> dataRules = new ArrayList<SysPermissionDataRuleModel>();
for (SysPermission sysPermission : currentSyspermission) {
// 代码逻辑说明: 数据权限规则编码不规范，项目存在相同包名和类名 #722
List<SysPermissionDataRule> temp = sysPermissionDataRuleService.queryPermissionDataRules(username, sysPermission.getId());
if(temp!=null && temp.size()>0) {
//dataRules.addAll(temp);
dataRules = oConvertUtils.entityListToModelList(temp,SysPermissionDataRuleModel.class);
}
}
return dataRules;
}
return null;
}
/**
* 匹配前端传过来的地址 匹配成功返回正则地址
* AntPathMatcher匹配地址
*()* 匹配0个或多个字符
*()**匹配0个或多个目录
*/
private String getRegexpUrl(String url) {
List<String> list = sysPermissionMapper.queryPermissionUrlWithStar();
if(list!=null && list.size()>0) {
for (String p : list) {
PathMatcher matcher = new AntPathMatcher();
if(matcher.match(p, url)) {
return p;
}
}
}
return null;
}
@Override
public SysUserCacheInfo getCacheUser(String username) {
SysUserCacheInfo info = new SysUserCacheInfo();
info.setOneDepart(true);
LoginUser user = this.getUserByName(username);
// try {
// //相同类中方法间调用时脱敏@SensitiveDecodeAble解密 Aop失效处理
// SensitiveInfoUtil.handlerObject(user, false);
// } catch (IllegalAccessException e) {
// e.printStackTrace();
// }
if(user!=null) {
info.setSysUserId(user.getId());
info.setSysUserCode(user.getUsername());
info.setSysUserName(user.getRealname());
info.setSysOrgCode(user.getOrgCode());
info.setSysOrgId(user.getOrgId());
info.setSysRoleCode(user.getRoleCode());
}else{
return null;
}
//多部门支持in查询
List<SysDepart> list = departMapper.queryUserDeparts(user.getId());
List<String> sysMultiOrgCode = new ArrayList<String>();
if(list==null || list.size()==0) {
//当前用户无部门
//sysMultiOrgCode.add("0");
}else if(list.size()==1) {
sysMultiOrgCode.add(list.get(0).getOrgCode());
}else {
info.setOneDepart(false);
for (SysDepart dpt : list) {
sysMultiOrgCode.add(dpt.getOrgCode());
}
}
info.setSysMultiOrgCode(sysMultiOrgCode);
return info;
}
@Override
public LoginUser getUserById(String id) {
if(oConvertUtils.isEmpty(id)) {
return null;
}
LoginUser loginUser = new LoginUser();
SysUser sysUser = userMapper.selectById(id);
if(sysUser==null) {
return null;
}
BeanUtils.copyProperties(sysUser, loginUser);
//去掉用户敏感信息
loginUser.setPassword(null);
loginUser.setRelTenantIds(null);
loginUser.setDepartIds(null);
return loginUser;
}
@Override
public List<String> getRolesByUsername(String username) {
return sysUserRoleMapper.getRoleByUserName(username);
}
@Override
public List<String> getRolesByUserId(String userId) {
return sysUserRoleMapper.getRoleCodeByUserId(userId);
}
@Override
public List<String> getDepartIdsByUsername(String username) {
List<SysDepart> list = sysDepartService.queryDepartsByUsername(username);
List<String> result = new ArrayList<>(list.size());
for (SysDepart depart : list) {
result.add(depart.getId());
}
return result;
}
@Override
public List<String> getDepartIdsByUserId(String userId) {
return sysDepartService.queryDepartsByUserId(userId);
}
@Override
public Set<String> getDepartParentIdsByUsername(String username) {
List<SysDepart> list = sysDepartService.queryDepartsByUsername(username);
Set<String> result = new HashSet<>(list.size());
for (SysDepart depart : list) {
result.add(depart.getParentId());
}
return result;
}
@Override
public Set<String> getDepartParentIdsByDepIds(Set<String> depIds) {
LambdaQueryWrapper<SysDepart> departQuery = new LambdaQueryWrapper<SysDepart>().in(SysDepart::getId, depIds);
List<SysDepart> departList = departMapper.selectList(departQuery);
if(CollectionUtils.isEmpty(departList)){
return null;
}
Set<String> parentIds = departList.stream()
.map(SysDepart::getParentId)
.collect(Collectors.toSet());
return parentIds;
}
@Override
public List<String> getDepartNamesByUsername(String username) {
List<SysDepart> list = sysDepartService.queryDepartsByUsername(username);
List<String> result = new ArrayList<>(list.size());
for (SysDepart depart : list) {
result.add(depart.getDepartName());
}
return result;
}
@Override
public DictModel getParentDepartId(String departId) {
SysDepart depart = departMapper.getParentDepartId(departId);
DictModel model = new DictModel(depart.getId(),depart.getParentId());
return model;
}
@Override
@Cacheable(value = CacheConstant.SYS_DICT_CACHE,key = "#code", unless = "#result == null ")
public List<DictModel> queryDictItemsByCode(String code) {
return sysDictService.queryDictItemsByCode(code);
}
@Override
@Cacheable(value = CacheConstant.SYS_ENABLE_DICT_CACHE,key = "#code", unless = "#result == null ")
public List<DictModel> queryEnableDictItemsByCode(String code) {
return sysDictService.queryEnableDictItemsByCode(code);
}
@Override
public List<DictModel> queryTableDictItemsByCode(String tableFilterSql, String text, String code) {
//【Online+系统】字典表加权限控制机制逻辑，想法不错 LOWCOD-799
if(tableFilterSql.indexOf(SymbolConstant.SYS_VAR_PREFIX)>=0){
tableFilterSql = QueryGenerator.getSqlRuleValue(tableFilterSql);
}
return sysDictService.queryTableDictItemsByCode(tableFilterSql, text, code);
}
@Override
public List<DictModel> queryAllDepartBackDictModel() {
return sysDictService.queryAllDepartBackDictModel();
}
@Override
public void sendSysAnnouncement(MessageDTO message) {
this.sendSysAnnouncement(message.getFromUser(),
message.getToUser(),
message.getTitle(),
message.getContent(),
message.getCategory(),
message.getNoticeType());
try {
// 同步发送第三方APP消息
wechatEnterpriseService.sendMessage(message, true);
dingtalkService.sendMessage(message, true);
} catch (Exception e) {
log.error("同步发送第三方APP消息失败！", e);
}
}
@Override
public void sendBusAnnouncement(BusMessageDTO message) {
sendBusAnnouncement(message.getFromUser(),
message.getToUser(),
message.getTitle(),
message.getContent(),
message.getCategory(),
message.getBusType(),
message.getBusId(),
message.getNoticeType());
try {
// 同步发送第三方APP消息
wechatEnterpriseService.sendMessage(message, true);
dingtalkService.sendMessage(message, true);
} catch (Exception e) {
log.error("同步发送第三方APP消息失败！", e);
}
}
@Override
public void sendTemplateAnnouncement(TemplateMessageDTO message) {
String templateCode = message.getTemplateCode();
String title = message.getTitle();
Map<String,String> tmplateParam = message.getTemplateParam();
String fromUser = message.getFromUser();
String toUser = message.getToUser();
List<SysMessageTemplate> sysSmsTemplates = sysMessageTemplateService.selectByCode(templateCode);
if(sysSmsTemplates==null||sysSmsTemplates.size()==0){
throw new JeecgBootException("消息模板不存在，模板编码："+templateCode);
}
SysMessageTemplate sysSmsTemplate = sysSmsTemplates.get(0);
//模板标题
title = title==null?sysSmsTemplate.getTemplateName():title;
//模板内容
String content = sysSmsTemplate.getTemplateContent();
if(tmplateParam!=null) {
for (Map.Entry<String, String> entry : tmplateParam.entrySet()) {
String str = "${" + entry.getKey() + "}";
if(oConvertUtils.isNotEmpty(title)){
title = title.replace(str, entry.getValue());
}
content = content.replace(str, entry.getValue());
}
}
String mobileOpenUrl = null;
if(tmplateParam!=null && oConvertUtils.isNotEmpty(tmplateParam.get(CommonConstant.MSG_HREF_URL))){
mobileOpenUrl = tmplateParam.get(CommonConstant.MSG_HREF_URL);
}
SysAnnouncement announcement = new SysAnnouncement();
announcement.setTitile(title);
announcement.setMsgContent(content);
announcement.setSender(fromUser);
announcement.setPriority(CommonConstant.PRIORITY_M);
announcement.setMsgType(CommonConstant.MSG_TYPE_UESR);
announcement.setSendStatus(CommonConstant.HAS_SEND);
announcement.setSendTime(new Date());
announcement.setMsgCategory(CommonConstant.MSG_CATEGORY_2);
announcement.setDelFlag(String.valueOf(CommonConstant.DEL_FLAG_0));
// 代码逻辑说明: [QQYUN-12999]系统通知，系统通知时间更新，但是排到下面了
announcement.setIzTop(CommonConstant.IZ_TOP_0);
sysAnnouncementMapper.insert(announcement);
// 2.插入用户通告阅读标记表记录
String userId = toUser;
String[] userIds = userId.split(",");
String anntId = announcement.getId();
for(int i=0;i<userIds.length;i++) {
if(oConvertUtils.isNotEmpty(userIds[i])) {
SysUser sysUser = userMapper.getUserByName(userIds[i]);
if(sysUser==null) {
continue;
}
SysAnnouncementSend announcementSend = new SysAnnouncementSend();
announcementSend.setAnntId(anntId);
announcementSend.setUserId(sysUser.getId());
announcementSend.setReadFlag(CommonConstant.NO_READ_FLAG);
sysAnnouncementSendMapper.insert(announcementSend);
JSONObject obj = new JSONObject();
obj.put(WebsocketConst.MSG_CMD, WebsocketConst.CMD_USER);
obj.put(WebsocketConst.MSG_USER_ID, sysUser.getId());
obj.put(WebsocketConst.MSG_ID, announcement.getId());
obj.put(WebsocketConst.MSG_TXT, announcement.getTitile());
webSocket.sendMessage(sysUser.getId(), obj.toJSONString());
}
}
try {
// 同步企业微信、钉钉的消息通知
dingtalkService.sendActionCardMessage(announcement, mobileOpenUrl, true);
wechatEnterpriseService.sendTextCardMessage(announcement, mobileOpenUrl, true);
} catch (Exception e) {
log.error("同步发送第三方APP消息失败！", e);
}
}
@Override
public void sendBusTemplateAnnouncement(BusTemplateMessageDTO message) {
String templateCode = message.getTemplateCode();
String title = message.getTitle();
Map<String,String> tmplateParam = message.getTemplateParam();
String fromUser = message.getFromUser();
String toUser = message.getToUser();
String busId = message.getBusId();
String busType = message.getBusType();
List<SysMessageTemplate> sysSmsTemplates = sysMessageTemplateService.selectByCode(templateCode);
if(sysSmsTemplates==null||sysSmsTemplates.size()==0){
throw new JeecgBootException("消息模板不存在，模板编码："+templateCode);
}
SysMessageTemplate sysSmsTemplate = sysSmsTemplates.get(0);
//模板标题
title = title==null?sysSmsTemplate.getTemplateName():title;
//模板内容
String content = sysSmsTemplate.getTemplateContent();
if(tmplateParam!=null) {
for (Map.Entry<String, String> entry : tmplateParam.entrySet()) {
String str = "${" + entry.getKey() + "}";
if (entry.getValue() != null) {
title = title.replace(str, entry.getValue());
content = content.replace(str, entry.getValue());
}
}
}
SysAnnouncement announcement = new SysAnnouncement();
announcement.setTitile(title);
announcement.setMsgContent(content);
announcement.setSender(fromUser);
announcement.setPriority(CommonConstant.PRIORITY_M);
announcement.setMsgType(CommonConstant.MSG_TYPE_UESR);
announcement.setSendStatus(CommonConstant.HAS_SEND);
announcement.setSendTime(new Date());
// 代码逻辑说明: [QQYUN-12999]系统通知，系统通知时间更新，但是排到下面了
announcement.setIzTop(CommonConstant.IZ_TOP_0);
if(tmplateParam!=null && oConvertUtils.isNotEmpty(tmplateParam.get(CommonSendStatus.MSG_ABSTRACT_JSON))){
announcement.setMsgAbstract(tmplateParam.get(CommonSendStatus.MSG_ABSTRACT_JSON));
}
String mobileOpenUrl = null;
if(tmplateParam!=null && oConvertUtils.isNotEmpty(tmplateParam.get(CommonConstant.MSG_HREF_URL))){
mobileOpenUrl = tmplateParam.get(CommonConstant.MSG_HREF_URL);
}
// 如果传递扩展json，说明是个性化业务，有意见remark则设置为通知内容
if(oConvertUtils.isJson(announcement.getMsgAbstract())) {
// 获取announcement.getMsgAbstract()的字段remark
JSONObject jsonObject = JSON.parseObject(announcement.getMsgAbstract());
String remark = jsonObject.containsKey("remark")? jsonObject.getString("remark"): null;
if(oConvertUtils.isNotEmpty(remark)){
announcement.setMsgContent(remark);
}
}
announcement.setMsgCategory(CommonConstant.MSG_CATEGORY_2);
announcement.setDelFlag(String.valueOf(CommonConstant.DEL_FLAG_0));
announcement.setBusId(busId);
announcement.setBusType(busType);
announcement.setOpenType(SysAnnmentTypeEnum.getByType(busType).getOpenType());
announcement.setOpenPage(SysAnnmentTypeEnum.getByType(busType).getOpenPage());
sysAnnouncementMapper.insert(announcement);
// 2.插入用户通告阅读标记表记录
String userId = toUser;
String[] userIds = userId.split(",");
String anntId = announcement.getId();
for(int i=0;i<userIds.length;i++) {
if(oConvertUtils.isNotEmpty(userIds[i])) {
SysUser sysUser = userMapper.getUserByName(userIds[i]);
if(sysUser==null) {
continue;
}
SysAnnouncementSend announcementSend = new SysAnnouncementSend();
announcementSend.setAnntId(anntId);
announcementSend.setUserId(sysUser.getId());
announcementSend.setReadFlag(CommonConstant.NO_READ_FLAG);
sysAnnouncementSendMapper.insert(announcementSend);
JSONObject obj = new JSONObject();
obj.put(WebsocketConst.MSG_CMD, WebsocketConst.CMD_USER);
obj.put(WebsocketConst.MSG_USER_ID, sysUser.getId());
obj.put(WebsocketConst.MSG_ID, announcement.getId());
obj.put(WebsocketConst.MSG_TXT, announcement.getTitile());
webSocket.sendMessage(sysUser.getId(), obj.toJSONString());
}
}
try {
// 钉钉的消息通知
dingtalkService.sendActionCardMessage(announcement, mobileOpenUrl, true);
// 企业微信通知
wechatEnterpriseService.sendTextCardMessage(announcement, mobileOpenUrl, true);
} catch (Exception e) {
log.error("同步发送第三方APP消息失败！", e);
}
}
@Override
public String parseTemplateByCode(TemplateDTO templateDTO) {
String templateCode = templateDTO.getTemplateCode();
Map<String, String> map = templateDTO.getTemplateParam();
List<SysMessageTemplate> sysSmsTemplates = sysMessageTemplateService.selectByCode(templateCode);
if(sysSmsTemplates==null||sysSmsTemplates.size()==0){
throw new JeecgBootException("消息模板不存在，模板编码："+templateCode);
}
SysMessageTemplate sysSmsTemplate = sysSmsTemplates.get(0);
//模板内容
String content = sysSmsTemplate.getTemplateContent();
if(map!=null) {
for (Map.Entry<String, String> entry : map.entrySet()) {
String str = "${" + entry.getKey() + "}";
content = content.replace(str, entry.getValue());
}
}
return content;
}
@Override
public void updateSysAnnounReadFlag(String busType, String busId) {
SysAnnouncement announcement = sysAnnouncementMapper.selectOne(new QueryWrapper<SysAnnouncement>().eq("bus_type",busType).eq("bus_id",busId));
if(announcement != null){
LoginUser sysUser = (LoginUser)SecurityUtils.getSubject().getPrincipal();
String userId = sysUser.getId();
LambdaUpdateWrapper<SysAnnouncementSend> updateWrapper = new UpdateWrapper().lambda();
updateWrapper.set(SysAnnouncementSend::getReadFlag, CommonConstant.HAS_READ_FLAG);
updateWrapper.set(SysAnnouncementSend::getReadTime, new Date());
updateWrapper.eq(SysAnnouncementSend::getAnntId,announcement.getId());
updateWrapper.eq(SysAnnouncementSend::getUserId,userId);
//updateWrapper.last("where annt_id ='"+announcement.getId()+"' and user_id ='"+userId+"'");
SysAnnouncementSend announcementSend = new SysAnnouncementSend();
sysAnnouncementSendMapper.update(announcementSend, updateWrapper);
}
}
/**
* 获取数据库类型
* @param dataSource
* @return
* @throws SQLException
*/
private String getDatabaseTypeByDataSource(DataSource dataSource) throws SQLException{
if("".equals(DB_TYPE)) {
Connection connection = dataSource.getConnection();
try {
DatabaseMetaData md = connection.getMetaData();
String dbType = md.getDatabaseProductName().toLowerCase();
if(dbType.indexOf(DataBaseConstant.DB_TYPE_MYSQL.toLowerCase())>=0) {
DB_TYPE = DataBaseConstant.DB_TYPE_MYSQL;
}else if(dbType.indexOf(DataBaseConstant.DB_TYPE_ORACLE.toLowerCase())>=0) {
DB_TYPE = DataBaseConstant.DB_TYPE_ORACLE;
}else if(dbType.indexOf(DataBaseConstant.DB_TYPE_SQLSERVER.toLowerCase())>=0||dbType.indexOf(DataBaseConstant.DB_TYPE_SQL_SERVER_BLANK)>=0) {
DB_TYPE = DataBaseConstant.DB_TYPE_SQLSERVER;
}else if(dbType.indexOf(DataBaseConstant.DB_TYPE_POSTGRESQL.toLowerCase())>=0) {
DB_TYPE = DataBaseConstant.DB_TYPE_POSTGRESQL;
}else if(dbType.indexOf(DataBaseConstant.DB_TYPE_MARIADB.toLowerCase())>=0) {
DB_TYPE = DataBaseConstant.DB_TYPE_MARIADB;
}else {
log.error("数据库类型:[" + dbType + "]不识别!");
//throw new JeecgBootException("数据库类型:["+dbType+"]不识别!");
}
} catch (Exception e) {
log.error(e.getMessage(), e);
}finally {
connection.close();
}
}
return DB_TYPE;
}
@Override
public List<DictModel> queryAllDict() {
// 查询并排序
QueryWrapper<SysDict> queryWrapper = new QueryWrapper<SysDict>();
queryWrapper.orderByAsc("create_time");
List<SysDict> dicts = sysDictService.list(queryWrapper);
// 封装成 model
List<DictModel> list = new ArrayList<DictModel>();
for (SysDict dict : dicts) {
list.add(new DictModel(dict.getDictCode(), dict.getDictName()));
}
return list;
}
@Override
public List<SysCategoryModel> queryAllSysCategory() {
List<SysCategory> ls = categoryMapper.selectList(null);
List<SysCategoryModel> res = oConvertUtils.entityListToModelList(ls,SysCategoryModel.class);
return res;
}
@Override
public List<DictModel> queryFilterTableDictInfo(String table, String text, String code, String filterSql) {
return sysDictService.queryTableDictItemsByCodeAndFilter(table,text,code,filterSql);
}
@Override
public List<String> queryTableDictByKeys(String table, String text, String code, String[] keyArray) {
return sysDictService.queryTableDictByKeys(table,text,code,Joiner.on(",").join(keyArray));
}
@Override
public List<ComboModel> queryAllUserBackCombo() {
List<ComboModel> list = new ArrayList<ComboModel>();
List<SysUser> userList = userMapper.selectList(new QueryWrapper<SysUser>().eq("status",1).eq("del_flag",0));
for(SysUser user : userList){
ComboModel model = new ComboModel();
model.setTitle(user.getRealname());
model.setId(user.getId());
model.setUsername(user.getUsername());
list.add(model);
}
return list;
}
@Override
public JSONObject queryAllUser(String userIds, Integer pageNo, Integer pageSize) {
JSONObject json = new JSONObject();
QueryWrapper<SysUser> queryWrapper = new QueryWrapper<SysUser>().eq("status",1).eq("del_flag",0);
List<ComboModel> list = new ArrayList<ComboModel>();
Page<SysUser> page = new Page<SysUser>(pageNo, pageSize);
IPage<SysUser> pageList = userMapper.selectPage(page, queryWrapper);
for(SysUser user : pageList.getRecords()){
ComboModel model = new ComboModel();
model.setUsername(user.getUsername());
model.setTitle(user.getRealname());
model.setId(user.getId());
model.setEmail(user.getEmail());
if(oConvertUtils.isNotEmpty(userIds)){
String[] temp = userIds.split(",");
for(int i = 0; i<temp.length;i++){
if(temp[i].equals(user.getId())){
model.setChecked(true);
}
}
}
list.add(model);
}
json.put("list",list);
json.put("total",pageList.getTotal());
return json;
}
public List<ComboModel> queryAllRole() {
List<ComboModel> list = new ArrayList<ComboModel>();
List<SysRole> roleList = roleMapper.selectList(new QueryWrapper<SysRole>());
for(SysRole role : roleList){
ComboModel model = new ComboModel();
model.setTitle(role.getRoleName());
model.setId(role.getId());
list.add(model);
}
return list;
}
@Override
public List<ComboModel> queryAllRole(String[] roleIds) {
List<ComboModel> list = new ArrayList<ComboModel>();
List<SysRole> roleList = roleMapper.selectList(new QueryWrapper<SysRole>());
for(SysRole role : roleList){
ComboModel model = new ComboModel();
model.setTitle(role.getRoleName());
model.setId(role.getId());
model.setRoleCode(role.getRoleCode());
if(oConvertUtils.isNotEmpty(roleIds)) {
for (int i = 0; i < roleIds.length; i++) {
if (roleIds[i].equals(role.getId())) {
model.setChecked(true);
}
}
}
list.add(model);
}
return list;
}
@Override
public List<String> getRoleIdsByUsername(String username) {
return sysUserRoleMapper.getRoleIdByUserName(username);
}
@Override
public String getDepartIdsByOrgCode(String orgCode) {
return departMapper.queryDepartIdByOrgCode(orgCode);
}
@Override
public List<SysDepartModel> getAllSysDepart() {
List<SysDepartModel> departModelList = new ArrayList<SysDepartModel>();
List<SysDepart> departList = departMapper.selectList(new QueryWrapper<SysDepart>().eq("del_flag","0"));
for(SysDepart depart : departList){
SysDepartModel model = new SysDepartModel();
BeanUtils.copyProperties(depart,model);
departModelList.add(model);
}
return departModelList;
}
@Override
public DynamicDataSourceModel getDynamicDbSourceById(String dbSourceId) {
SysDataSource dbSource = dataSourceService.getById(dbSourceId);
if(dbSource!=null && StringUtils.isNotBlank(dbSource.getDbPassword())){
String dbPassword = dbSource.getDbPassword();
String decodedStr = SecurityUtil.jiemi(dbPassword);
dbSource.setDbPassword(decodedStr);
}
return new DynamicDataSourceModel(dbSource);
}
@Override
public DynamicDataSourceModel getDynamicDbSourceByCode(String dbSourceCode) {
SysDataSource dbSource = dataSourceService.getOne(new LambdaQueryWrapper<SysDataSource>().eq(SysDataSource::getCode, dbSourceCode));
if(dbSource!=null && StringUtils.isNotBlank(dbSource.getDbPassword())){
String dbPassword = dbSource.getDbPassword();
String decodedStr = SecurityUtil.jiemi(dbPassword);
dbSource.setDbPassword(decodedStr);
}
return new DynamicDataSourceModel(dbSource);
}
@Override
public List<String> getDeptHeadByDepId(String deptId) {
log.debug(" getDeptHeadByDepId 根据部门ID获取负责人，deptId：{}", deptId);
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | true |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysDepartPermissionServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysDepartPermissionServiceImpl.java | package org.jeecg.modules.system.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysDepartPermission;
import org.jeecg.modules.system.entity.SysDepartRole;
import org.jeecg.modules.system.entity.SysDepartRolePermission;
import org.jeecg.modules.system.entity.SysPermissionDataRule;
import org.jeecg.modules.system.mapper.SysDepartPermissionMapper;
import org.jeecg.modules.system.mapper.SysDepartRoleMapper;
import org.jeecg.modules.system.mapper.SysDepartRolePermissionMapper;
import org.jeecg.modules.system.mapper.SysPermissionDataRuleMapper;
import org.jeecg.modules.system.service.ISysDepartPermissionService;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.transaction.annotation.Transactional;
import jakarta.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;
/**
* @Description: 部门权限表
* @Author: jeecg-boot
* @Date: 2020-02-11
* @Version: V1.0
*/
@Service
public class SysDepartPermissionServiceImpl extends ServiceImpl<SysDepartPermissionMapper, SysDepartPermission> implements ISysDepartPermissionService {
@Resource
private SysPermissionDataRuleMapper ruleMapper;
@Resource
private SysDepartRoleMapper sysDepartRoleMapper;
@Resource
private SysDepartRolePermissionMapper departRolePermissionMapper;
@Override
@Transactional(rollbackFor = Exception.class)
public void saveDepartPermission(String departId, String permissionIds, String lastPermissionIds) {
//1.对比要新增的权限
List<String> add = getDiff(lastPermissionIds,permissionIds);
if(add!=null && add.size()>0) {
List<SysDepartPermission> list = new ArrayList<SysDepartPermission>();
for (String p : add) {
if(oConvertUtils.isNotEmpty(p)) {
SysDepartPermission rolepms = new SysDepartPermission(departId, p);
list.add(rolepms);
}
}
this.saveBatch(list);
}
//2.对比要删除的权限
List<String> delete = getDiff(permissionIds,lastPermissionIds);
if(delete!=null && delete.size()>0) {
for (String permissionId : delete) {
//2.1 删除部门对应的权限
this.remove(new QueryWrapper<SysDepartPermission>().lambda()
.eq(SysDepartPermission::getDepartId, departId)
.eq(SysDepartPermission::getPermissionId, permissionId));
//2.2 删除部门权限时，删除部门角色中已授权的权限
List<SysDepartRole> sysDepartRoleList = sysDepartRoleMapper.selectList(new LambdaQueryWrapper<SysDepartRole>().eq(SysDepartRole::getDepartId,departId));
List<String> roleIds = sysDepartRoleList.stream().map(SysDepartRole::getId).collect(Collectors.toList());
if(roleIds != null && roleIds.size()>0){
departRolePermissionMapper.delete(new LambdaQueryWrapper<SysDepartRolePermission>()
.eq(SysDepartRolePermission::getPermissionId,permissionId)
// 代码逻辑说明: [issue/#5339]部门管理下部门赋权代码逻辑缺少判断条件
.in(SysDepartRolePermission::getRoleId,roleIds)
);
}
}
}
}
@Override
public List<SysPermissionDataRule> getPermRuleListByDeptIdAndPermId(String departId, String permissionId) {
SysDepartPermission departPermission = this.getOne(new QueryWrapper<SysDepartPermission>().lambda().eq(SysDepartPermission::getDepartId, departId).eq(SysDepartPermission::getPermissionId, permissionId));
if(departPermission != null && oConvertUtils.isNotEmpty(departPermission.getDataRuleIds())){
LambdaQueryWrapper<SysPermissionDataRule> query = new LambdaQueryWrapper<SysPermissionDataRule>();
query.in(SysPermissionDataRule::getId, Arrays.asList(departPermission.getDataRuleIds().split(",")));
query.orderByDesc(SysPermissionDataRule::getCreateTime);
List<SysPermissionDataRule> permRuleList = this.ruleMapper.selectList(query);
return permRuleList;
}else{
return null;
}
}
/**
* 从diff中找出main中没有的元素
* @param main
* @param diff
* @return
*/
private List<String> getDiff(String main,String diff){
if(oConvertUtils.isEmpty(diff)) {
return null;
}
if(oConvertUtils.isEmpty(main)) {
return Arrays.asList(diff.split(","));
}
String[] mainArr = main.split(",");
String[] diffArr = diff.split(",");
Map<String, Integer> map = new HashMap(5);
for (String string : mainArr) {
map.put(string, 1);
}
List<String> res = new ArrayList<String>();
for (String key : diffArr) {
if(oConvertUtils.isNotEmpty(key) && !map.containsKey(key)) {
res.add(key);
}
}
return res;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysDataSourceServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysDataSourceServiceImpl.java | package org.jeecg.modules.system.service.impl;
import com.baomidou.dynamic.datasource.DynamicRoutingDataSource;
import com.baomidou.dynamic.datasource.creator.DataSourceProperty;
import com.baomidou.dynamic.datasource.creator.druid.DruidDataSourceCreator;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang.StringUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.util.dynamic.db.DataSourceCachePool;
import org.jeecg.modules.system.entity.SysDataSource;
import org.jeecg.modules.system.mapper.SysDataSourceMapper;
import org.jeecg.modules.system.service.ISysDataSourceService;
import org.jeecg.modules.system.util.SecurityUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.sql.DataSource;
/**
* @Description: 多数据源管理
* @Author: jeecg-boot
* @Date: 2019-12-25
* @Version: V1.0
*/
@Service
public class SysDataSourceServiceImpl extends ServiceImpl<SysDataSourceMapper, SysDataSource> implements ISysDataSourceService {
@Autowired
private DruidDataSourceCreator dataSourceCreator;
@Autowired
private DataSource dataSource;
@Override
public Result saveDataSource(SysDataSource sysDataSource) {
try {
long count = checkDbCode(sysDataSource.getCode());
if (count > 0) {
return Result.error("数据源编码已存在");
}
String dbPassword = sysDataSource.getDbPassword();
if (StringUtils.isNotBlank(dbPassword)) {
String encrypt = SecurityUtil.jiami(dbPassword);
sysDataSource.setDbPassword(encrypt);
}
boolean result = save(sysDataSource);
if (result) {
//动态创建数据源
//addDynamicDataSource(sysDataSource, dbPassword);
}
} catch (Exception e) {
e.printStackTrace();
}
return Result.OK("添加成功！");
}
@Override
public Result editDataSource(SysDataSource sysDataSource) {
try {
SysDataSource d = getById(sysDataSource.getId());
DataSourceCachePool.removeCache(d.getCode());
String dbPassword = sysDataSource.getDbPassword();
if (StringUtils.isNotBlank(dbPassword)) {
String encrypt = SecurityUtil.jiami(dbPassword);
sysDataSource.setDbPassword(encrypt);
}
Boolean result=updateById(sysDataSource);
if(result){
//先删除老的数据源
// removeDynamicDataSource(d.getCode());
//添加新的数据源
//addDynamicDataSource(sysDataSource,dbPassword);
}
} catch (Exception e) {
e.printStackTrace();
}
return Result.OK("编辑成功!");
}
@Override
public Result deleteDataSource(String id) {
SysDataSource sysDataSource = getById(id);
DataSourceCachePool.removeCache(sysDataSource.getCode());
removeById(id);
return Result.OK("删除成功!");
}
/**
* 动态添加数据源 【注册mybatis动态数据源】
*
* @param sysDataSource 添加数据源数据对象
* @param dbPassword 未加密的密码
*/
private void addDynamicDataSource(SysDataSource sysDataSource, String dbPassword) {
DataSourceProperty dataSourceProperty = new DataSourceProperty();
dataSourceProperty.setUrl(sysDataSource.getDbUrl());
dataSourceProperty.setPassword(dbPassword);
dataSourceProperty.setDriverClassName(sysDataSource.getDbDriver());
dataSourceProperty.setUsername(sysDataSource.getDbUsername());
DynamicRoutingDataSource ds = (DynamicRoutingDataSource) dataSource;
DataSource dataSource = dataSourceCreator.createDataSource(dataSourceProperty);
try {
ds.addDataSource(sysDataSource.getCode(), dataSource);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 删除数据源
* @param code
*/
private void removeDynamicDataSource(String code) {
DynamicRoutingDataSource ds = (DynamicRoutingDataSource) dataSource;
ds.removeDataSource(code);
}
/**
* 检查数据源编码是否存在
*
* @param dbCode
* @return
*/
private long checkDbCode(String dbCode) {
QueryWrapper<SysDataSource> qw = new QueryWrapper();
qw.lambda().eq(true, SysDataSource::getCode, dbCode);
return count(qw);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysDictServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysDictServiceImpl.java | package org.jeecg.modules.system.service.impl;
import cn.hutool.core.util.RandomUtil;
import com.baomidou.dynamic.datasource.toolkit.DynamicDataSourceContextHolder;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.DataBaseConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.system.util.ResourceUtil;
import org.jeecg.common.system.vo.DictModel;
import org.jeecg.common.system.vo.DictModelMany;
import org.jeecg.common.system.vo.DictQuery;
import org.jeecg.common.util.CommonUtils;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.common.util.SqlInjectionUtil;
import org.jeecg.common.util.dynamic.db.DbTypeUtils;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
import org.jeecg.modules.system.entity.SysDict;
import org.jeecg.modules.system.entity.SysDictItem;
import org.jeecg.modules.system.mapper.SysDictItemMapper;
import org.jeecg.modules.system.mapper.SysDictMapper;
import org.jeecg.modules.system.model.DuplicateCheckVo;
import org.jeecg.modules.system.model.TreeSelectModel;
import org.jeecg.modules.system.security.DictQueryBlackListHandler;
import org.jeecg.modules.system.service.ISysDictService;
import org.jeecg.modules.system.vo.lowapp.SysDictVo;
import org.mybatis.spring.MyBatisSystemException;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import java.util.*;
import java.util.stream.Collectors;
/**
* <p>
* 字典表 服务实现类
* </p>
*
* @Author zhangweijian
* @since 2018-12-28
*/
@Service
@Slf4j
public class SysDictServiceImpl extends ServiceImpl<SysDictMapper, SysDict> implements ISysDictService {
@Autowired
private SysDictMapper sysDictMapper;
@Autowired
private SysDictItemMapper sysDictItemMapper;
@Autowired
private DictQueryBlackListHandler dictQueryBlackListHandler;
@Lazy
@Autowired
private ISysBaseAPI sysBaseAPI;
@Lazy
@Autowired
private RedisUtil redisUtil;
@Override
public boolean duplicateCheckData(DuplicateCheckVo duplicateCheckVo) {
Long count = null;
// 1.针对采用 ${}写法的表名和字段进行转义和check
String table = SqlInjectionUtil.getSqlInjectTableName(duplicateCheckVo.getTableName());
String fieldName = SqlInjectionUtil.getSqlInjectField(duplicateCheckVo.getFieldName());
duplicateCheckVo.setTableName(table);
duplicateCheckVo.setFieldName(fieldName);
// 2.SQL注入check（只限制非法串改数据库）
//关联表字典（举例：sys_user,realname,id）
SqlInjectionUtil.filterContentMulti(table, fieldName);
String checkSql = table + SymbolConstant.COMMA + fieldName + SymbolConstant.COMMA;
// 【QQYUN-6533】表字典白名单check
sysBaseAPI.dictTableWhiteListCheckByDict(table, fieldName);
// 3.表字典黑名单check
dictQueryBlackListHandler.isPass(checkSql);
// 4.执行SQL 查询是否存在值
try{
// 代码逻辑说明: [TV360X-49]postgres日期、年月日时分秒唯一校验报错------------
if(DbTypeUtils.dbTypeIsPostgre(CommonUtils.getDatabaseTypeEnum())){
duplicateCheckVo.setFieldName("CAST("+duplicateCheckVo.getFieldName()+" as text)");
}
if (StringUtils.isNotBlank(duplicateCheckVo.getDataId())) {
// [1].编辑页面校验
count = sysDictMapper.duplicateCheckCountSql(duplicateCheckVo);
} else {
// [2].添加页面校验
count = sysDictMapper.duplicateCheckCountSqlNoDataId(duplicateCheckVo);
}
}catch(MyBatisSystemException e){
log.error(e.getMessage(), e);
String errorCause = "查询异常,请检查唯一校验的配置！";
throw new JeecgBootException(errorCause);
}
// 4.返回结果
if (count == null || count == 0) {
// 该值可用
return true;
} else {
// 该值不可用
log.info("该值不可用，系统中已存在！");
return false;
}
}
/**
* 通过查询指定code 获取字典
* @param code
* @return
*/
@Override
@Cacheable(value = CacheConstant.SYS_DICT_CACHE,key = "#code", unless = "#result == null ")
public List<DictModel> queryDictItemsByCode(String code) {
log.debug("无缓存dictCache的时候调用这里！");
return sysDictMapper.queryDictItemsByCode(code);
}
@Override
@Cacheable(value = CacheConstant.SYS_ENABLE_DICT_CACHE,key = "#code", unless = "#result == null ")
public List<DictModel> queryEnableDictItemsByCode(String code) {
log.debug("无缓存dictCache的时候调用这里！");
return sysDictMapper.queryEnableDictItemsByCode(code);
}
@Override
public Map<String, List<DictModel>> queryDictItemsByCodeList(List<String> dictCodeList) {
List<DictModelMany> list = sysDictMapper.queryDictItemsByCodeList(dictCodeList);
Map<String, List<DictModel>> dictMap = new HashMap(5);
for (DictModelMany dict : list) {
List<DictModel> dictItemList = dictMap.computeIfAbsent(dict.getDictCode(), i -> new ArrayList<>());
// 代码逻辑说明: QQYUN-5183【简流】多字段拼接-多选框、下拉框 等需要翻译的字段
//dict.setDictCode(null);
dictItemList.add(new DictModel(dict.getValue(), dict.getText(), dict.getColor()));
}
return dictMap;
}
@Override
public Map<String, List<DictModel>> queryAllDictItems() {
log.debug(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
long start = System.currentTimeMillis();
Map<String, List<DictModel>> sysAllDictItems = new HashMap(5);
List<Integer> tenantIds = null;
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if (MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL) {
tenantIds = new ArrayList<>();
tenantIds.add(0);
if (TenantContext.getTenant() != null) {
tenantIds.add(oConvertUtils.getInt(TenantContext.getTenant()));
}
}
//------------------------------------------------------------------------------------------------
List<DictModelMany> sysDictItemList = sysDictMapper.queryAllDictItems(tenantIds);
// 使用groupingBy根据dictCode分组
sysAllDictItems = sysDictItemList.stream()
.collect(Collectors.groupingBy(DictModelMany::getDictCode,
Collectors.mapping(d -> new DictModel(d.getValue(), d.getText(), d.getColor()), Collectors.toList())));
log.debug(" >>> 1 获取系统字典项耗时（SQL）：" + (System.currentTimeMillis() - start) + "毫秒");
Map<String, List<DictModel>> enumRes = ResourceUtil.getEnumDictData();
sysAllDictItems.putAll(enumRes);
log.debug(" >>> 2 获取系统字典项耗时（Enum）：" + (System.currentTimeMillis() - start) + "毫秒");
log.debug(" >>> end 获取系统字典库总耗时：" + (System.currentTimeMillis() - start) + "毫秒");
log.debug(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
//log.debug("-------登录加载系统字典-----" + sysAllDictItems.toString());
return sysAllDictItems;
}
/**
* 通过查询指定code 获取字典值text
* @param code
* @param key
* @return
*/
@Override
@Cacheable(value = CacheConstant.SYS_DICT_CACHE,key = "#code+':'+#key", unless = "#result == null ")
public String queryDictTextByKey(String code, String key) {
log.debug("无缓存dictText的时候调用这里！");
return sysDictMapper.queryDictTextByKey(code, key);
}
@Override
public Map<String, List<DictModel>> queryManyDictByKeys(List<String> dictCodeList, List<String> keys) {
List<DictModelMany> list = sysDictMapper.queryManyDictByKeys(dictCodeList, keys);
Map<String, List<DictModel>> dictMap = new HashMap(5);
for (DictModelMany dict : list) {
List<DictModel> dictItemList = dictMap.computeIfAbsent(dict.getDictCode(), i -> new ArrayList<>());
dictItemList.add(new DictModel(dict.getValue(), dict.getText()));
}
// 代码逻辑说明: 系统字典数据应该包括自定义的java类-枚举
Map<String, List<DictModel>> enumRes = ResourceUtil.queryManyDictByKeys(dictCodeList, keys);
dictMap.putAll(enumRes);
return dictMap;
}
/**
* 通过查询指定table的 text code 获取字典
* dictTableCache采用redis缓存有效期10分钟
* @param tableFilterSql
* @param text
* @param code
* @return
*/
@Override
@Deprecated
public List<DictModel> queryTableDictItemsByCode(String tableFilterSql, String text, String code) {
log.debug("无缓存dictTableList的时候调用这里！");
String str = tableFilterSql+","+text+","+code;
// 【QQYUN-6533】表字典白名单check
sysBaseAPI.dictTableWhiteListCheckByDict(tableFilterSql, text, code);
// 1.表字典黑名单check
if(!dictQueryBlackListHandler.isPass(str)){
log.error(dictQueryBlackListHandler.getError());
return null;
}
// 2.分割SQL获取表名和条件
String table = null;
String filterSql = null;
if(tableFilterSql.toLowerCase().indexOf(DataBaseConstant.SQL_WHERE)>0){
String[] arr = tableFilterSql.split(" (?i)where ");
table = arr[0];
filterSql = oConvertUtils.getString(arr[1], null);
}else{
table = tableFilterSql;
}
// 3.SQL注入check
SqlInjectionUtil.filterContentMulti(table, text, code);
SqlInjectionUtil.specialFilterContentForDictSql(filterSql);
// 4.针对采用 ${}写法的表名和字段进行转义和check
table = SqlInjectionUtil.getSqlInjectTableName(table);
text = SqlInjectionUtil.getSqlInjectField(text);
code = SqlInjectionUtil.getSqlInjectField(code);
//return sysDictMapper.queryTableDictItemsByCode(tableFilterSql,text,code);
table = table.toLowerCase();
return sysDictMapper.queryTableDictWithFilter(table,text,code,filterSql);
}
@Override
public List<DictModel> queryTableDictItemsByCodeAndFilter(String table, String text, String code, String filterSql) {
log.debug("无缓存dictTableList的时候调用这里！");
// 1.SQL注入校验（只限制非法串改数据库）
SqlInjectionUtil.specialFilterContentForDictSql(table);
SqlInjectionUtil.filterContentMulti(text, code);
SqlInjectionUtil.specialFilterContentForDictSql(filterSql);
String str = table+","+text+","+code;
// 【QQYUN-6533】表字典白名单check
sysBaseAPI.dictTableWhiteListCheckByDict(table, text, code);
// 2.表字典黑名单 Check
if(!dictQueryBlackListHandler.isPass(str)){
log.error(dictQueryBlackListHandler.getError());
return null;
}
// 3.针对采用 ${}写法的表名和字段进行转义和check
table = SqlInjectionUtil.getSqlInjectTableName(table);
text = SqlInjectionUtil.getSqlInjectField(text);
code = SqlInjectionUtil.getSqlInjectField(code);
table = table.toLowerCase();
return sysDictMapper.queryTableDictWithFilter(table,text,code,filterSql);
}
/**
* 通过查询指定table的 text code 获取字典值text
* dictTableCache采用redis缓存有效期10分钟
* @param table
* @param text
* @param code
* @param key
* @return
*/
@Override
@Cacheable(value = CacheConstant.SYS_DICT_TABLE_CACHE, unless = "#result == null ")
public String queryTableDictTextByKey(String table,String text,String code, String key) {
log.debug("无缓存dictTable的时候调用这里！");
String str = table+","+text+","+code;
// 【QQYUN-6533】表字典白名单check
sysBaseAPI.dictTableWhiteListCheckByDict(table, text, code);
// 1.表字典黑名单check
if(!dictQueryBlackListHandler.isPass(str)){
log.error(dictQueryBlackListHandler.getError());
return null;
}
// 2.sql注入check
SqlInjectionUtil.filterContentMulti(table, text, code, key);
// 3.针对采用 ${}写法的表名和字段进行转义和check
table = SqlInjectionUtil.getSqlInjectTableName(table);
text = SqlInjectionUtil.getSqlInjectField(text);
code = SqlInjectionUtil.getSqlInjectField(code);
List<DictModel> dictModeList = sysDictMapper.queryTableDictByKeysAndFilterSql(table, text, code, null, Arrays.asList(key));
if(CollectionUtils.isEmpty(dictModeList)){
return null;
}else{
return dictModeList.get(0).getText();
}
//此方法删除（20230902）
//return sysDictMapper.queryTableDictTextByKey(table,text,code,key);
}
@Override
public List<DictModel> queryTableDictTextByKeys(String table, String text, String code, List<String> codeValues, String dataSource) {
String str = table+","+text+","+code;
//update-begin---author:chenrui ---date:20231221 for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
// 是否自定义数据源
boolean isCustomDataSource = oConvertUtils.isNotEmpty(dataSource);
// 如果是自定义数据源就不检查表字典白名单
if (!isCustomDataSource) {
// 【QQYUN-6533】表字典白名单check
sysBaseAPI.dictTableWhiteListCheckByDict(table, text, code);
// 1.表字典黑名单check
if (!dictQueryBlackListHandler.isPass(str)) {
log.error(dictQueryBlackListHandler.getError());
return null;
}
}
// 2.分割SQL获取表名和条件
String filterSql = null;
if(table.toLowerCase().indexOf(DataBaseConstant.SQL_WHERE)>0){
String[] arr = table.split(" (?i)where ");
table = arr[0];
filterSql = arr[1];
}
// 3.SQL注入check
SqlInjectionUtil.filterContentMulti(table, text, code);
SqlInjectionUtil.specialFilterContentForDictSql(filterSql);
// 4.针对采用 ${}写法的表名和字段进行转义和check
table = SqlInjectionUtil.getSqlInjectTableName(table);
text = SqlInjectionUtil.getSqlInjectField(text);
code = SqlInjectionUtil.getSqlInjectField(code);
// 切换为字典表的数据源
if (isCustomDataSource) {
DynamicDataSourceContextHolder.push(dataSource);
}
//update-begin---author:jarysun ---date:20251020 for：[issues/#9002]解决表字典查询出现异常之后，数据源不能恢复问题------------
List<DictModel> restData = null;
try {
restData = sysDictMapper.queryTableDictByKeysAndFilterSql(table, text, code, filterSql, codeValues);
} finally {
// 清理自定义的数据源
if (isCustomDataSource) {
DynamicDataSourceContextHolder.clear();
}
}
//update-end---author:jarysun ---date:20251020 for：[issues/#9002]解决表字典查询出现异常之后，数据源不能恢复问题------------
return restData;
}
@Override
public List<String> queryTableDictByKeys(String table, String text, String code, String keys) {
String str = table+","+text+","+code;
// 【QQYUN-6533】表字典白名单check
sysBaseAPI.dictTableWhiteListCheckByDict(table, text, code);
// 1.表字典黑名单check
if(!dictQueryBlackListHandler.isPass(str)){
log.error(dictQueryBlackListHandler.getError());
return null;
}
return this.queryTableDictByKeys(table, text, code, keys, true);
}
/**
* 通过查询指定table的 text code 获取字典，包含text和value
* dictTableCache采用redis缓存有效期10分钟
* @param table
* @param text
* @param code
* @param codeValuesStr (逗号分隔)
* @param delNotExist 是否移除不存在的项，默认为true，设为false如果某个key不存在数据库中，则直接返回key本身
* @return
*/
@Override
public List<String> queryTableDictByKeys(String table, String text, String code, String codeValuesStr, boolean delNotExist) {
if(oConvertUtils.isEmpty(codeValuesStr)){
return null;
}
//1.分割sql获取表名 和 条件sql
String filterSql = null;
if(table.toLowerCase().indexOf("where")!=-1){
String[] arr = table.split(" (?i)where ");
table = arr[0];
filterSql = arr[1];
}
// 2.SQL注入check
SqlInjectionUtil.filterContentMulti(table, text, code);
SqlInjectionUtil.specialFilterContentForDictSql(filterSql);
String str = table+","+text+","+code;
// 【QQYUN-6533】表字典白名单check
sysBaseAPI.dictTableWhiteListCheckByDict(table, text, code);
// 3.表字典黑名单check
if(!dictQueryBlackListHandler.isPass(str)){
log.error(dictQueryBlackListHandler.getError());
return null;
}
// 4.针对采用 ${}写法的表名和字段进行转义和check
table = SqlInjectionUtil.getSqlInjectTableName(table);
text = SqlInjectionUtil.getSqlInjectField(text);
code = SqlInjectionUtil.getSqlInjectField(code);
//字典条件值
String[] codeValues = codeValuesStr.split(",");
// 5.查询字典数据
List<DictModel> dicts = sysDictMapper.queryTableDictByKeysAndFilterSql(SqlInjectionUtil.getSqlInjectTableName(table),
SqlInjectionUtil.getSqlInjectField(text), SqlInjectionUtil.getSqlInjectField(code), filterSql, Arrays.asList(codeValues));
List<String> texts = new ArrayList<>(dicts.size());
// 6.查询出来的顺序可能是乱的，需要排个序
for (String conditionalVal : codeValues) {
List<DictModel> res = dicts.stream().filter(i -> conditionalVal.equals(i.getValue())).collect(Collectors.toList());
if (res.size() > 0) {
texts.add(res.get(0).getText());
} else if (!delNotExist) {
texts.add(conditionalVal);
}
}
return texts;
}
/**
* 根据字典类型id删除关联表中其对应的数据
*/
@Override
public boolean deleteByDictId(SysDict sysDict) {
sysDict.setDelFlag(CommonConstant.DEL_FLAG_1);
return this.updateById(sysDict);
}
@Override
@Transactional(rollbackFor = Exception.class)
public Integer saveMain(SysDict sysDict, List<SysDictItem> sysDictItemList) {
int insert=0;
try{
insert = sysDictMapper.insert(sysDict);
if (sysDictItemList != null) {
for (SysDictItem entity : sysDictItemList) {
// 代码逻辑说明: [JTC-1168]如果字典项值为空，则字典项忽略导入------------
if(oConvertUtils.isEmpty(entity.getItemValue())){
return -1;
}
entity.setDictId(sysDict.getId());
entity.setStatus(1);
sysDictItemMapper.insert(entity);
}
}
}catch(Exception e){
return insert;
}
return insert;
}
@Override
public List<DictModel> queryAllDepartBackDictModel() {
return baseMapper.queryAllDepartBackDictModel();
}
@Override
public List<DictModel> queryAllUserBackDictModel() {
return baseMapper.queryAllUserBackDictModel();
}
// @Override
// public List<DictModel> queryTableDictItems(String table, String text, String code, String keyword) {
// return baseMapper.queryTableDictItems(table, text, code, "%"+keyword+"%");
// }
@Override
public List<DictModel> queryLittleTableDictItems(String tableSql, String text, String code, String condition, String keyword, int pageNo, int pageSize) {
int current = oConvertUtils.getInt(pageNo, 1);
Page<DictModel> page = new Page<DictModel>(current, pageSize);
page.setSearchCount(false);
//为了防止sql（jeecg提供了防注入的方法，可以在拼接 SQL 语句时自动对参数进行转义，避免SQL注入攻击）
// 1. 针对采用 ${}写法的表名和字段进行转义和check
String table = SqlInjectionUtil.getSqlInjectTableName(CommonUtils.getTableNameByTableSql(tableSql));
text = SqlInjectionUtil.getSqlInjectField(text);
code = SqlInjectionUtil.getSqlInjectField(code);
// 2. 查询条件SQL (获取条件sql方法含sql注入校验)
String filterSql = getFilterSql(tableSql, text, code, condition, keyword);
// 3. 返回表字典数据
IPage<DictModel> pageList = baseMapper.queryPageTableDictWithFilter(page, table, text, code, filterSql);
return pageList.getRecords();
}
/**
* 获取条件语句 (下拉搜索组件 支持传入排序信息 查询排序)
*
* @param text
* @param code
* @param condition
* @param keyword
* @return
*/
private String getFilterSql(String tableSql, String text, String code, String condition, String keyword){
String filterSql = "";
String keywordSql = null;
String sqlWhere = "where ";
String sqlAnd = " and ";
//【JTC-631】判断如果 table 携带了 where 条件，那么就使用 and 查询，防止报错
boolean tableHasWhere = tableSql.toLowerCase().contains(sqlWhere);
if (tableHasWhere) {
sqlWhere = CommonUtils.getFilterSqlByTableSql(tableSql);
}
// 下拉搜索组件 支持传入排序信息 查询排序
String orderField = "", orderType = "";
if (oConvertUtils.isNotEmpty(keyword)) {
// 关键字里面如果写入了 排序信息 xxxxx[orderby:create_time,desc]
String orderKey = "[orderby";
if (keyword.indexOf(orderKey) >= 0 && keyword.endsWith("]")) {
String orderInfo = keyword.substring(keyword.indexOf(orderKey) + orderKey.length() + 1, keyword.length() - 1);
keyword = keyword.substring(0, keyword.indexOf(orderKey));
String[] orderInfoArray = orderInfo.split(SymbolConstant.COMMA);
orderField = orderInfoArray[0];
orderType = orderInfoArray[1];
}
if (oConvertUtils.isNotEmpty(keyword)) {
// 判断是否是多选
if (keyword.contains(SymbolConstant.COMMA)) {
// 代码逻辑说明: JTC-529【表单设计器】 编辑页面报错，in参数采用双引号导致 ----
String inKeywords = "'" + String.join("','", keyword.split(",")) + "'";
keywordSql = "(" + text + " in (" + inKeywords + ") or " + code + " in (" + inKeywords + "))";
} else {
keywordSql = "("+text + " like '%"+keyword+"%' or "+ code + " like '%"+keyword+"%')";
}
}
}
//下拉搜索组件 支持传入排序信息 查询排序
// 代码逻辑说明: [QQYUN-8514]Online表单中 下拉搜索框 搜索时报sql错误，生成的SQL多了一个 “and" ------------
if (oConvertUtils.isNotEmpty(condition) && oConvertUtils.isNotEmpty(keywordSql)) {
filterSql += sqlWhere + (tableHasWhere ? sqlAnd : " ") + condition + sqlAnd + keywordSql;
} else if (oConvertUtils.isNotEmpty(condition)) {
filterSql += sqlWhere + (tableHasWhere ? sqlAnd : " ") + condition;
} else if (oConvertUtils.isNotEmpty(keywordSql)) {
filterSql += sqlWhere + (tableHasWhere ? sqlAnd : " ") + keywordSql;
} else if (tableHasWhere) {
filterSql += sqlWhere;
}
// 增加排序逻辑
if (oConvertUtils.isNotEmpty(orderField)) {
filterSql += " order by " + orderField + " " + orderType;
}
// 处理返回条件
// 1.1 返回条件SQL（去掉开头的 where ）
final String wherePrefix = "(?i)where "; // (?i) 表示不区分大小写
String filterSqlString = filterSql.trim().replaceAll(wherePrefix, "");
// 1.2 条件SQL进行漏洞 check
SqlInjectionUtil.specialFilterContentForDictSql(filterSqlString);
// 1.3 判断如何返回条件是 order by开头则前面拼上 1=1
if (oConvertUtils.isNotEmpty(filterSqlString) && filterSqlString.trim().toUpperCase().startsWith("ORDER")) {
filterSqlString = " 1=1 " + filterSqlString;
}
return filterSqlString;
}
@Override
public List<DictModel> queryAllTableDictItems(String table, String text, String code, String condition, String keyword) {
// 1.获取条件sql
String filterSql = getFilterSql(table, text, code, condition, keyword);
// 为了防止sql（jeecg提供了防注入的方法，可以在拼接 SQL 语句时自动对参数进行转义，避免SQL注入攻击）
// 2.针对采用 ${}写法的表名和字段进行转义和check
table = SqlInjectionUtil.getSqlInjectTableName(table);
text = SqlInjectionUtil.getSqlInjectField(text);
code = SqlInjectionUtil.getSqlInjectField(code);
List<DictModel> ls = baseMapper.queryTableDictWithFilter(table, text, code, filterSql);
return ls;
}
@Override
public List<TreeSelectModel> queryTreeList(Map<String, String> query, String table, String text, String code, String pidField, String pid, String hasChildField, int converIsLeafVal) {
//为了防止sql（jeecg提供了防注入的方法，可以在拼接 SQL 语句时自动对参数进行转义，避免SQL注入攻击）
// 1.针对采用 ${}写法的表名和字段进行转义和check
//update-begin---author:chenrui ---date:20251015 for：[QQYUN-13741]【客户问题 南自】online表单自定义树 表后边加条件时 不生效------------
// 分割SQL获取表名和条件
String filterSql = null;
if(table.toLowerCase().indexOf(DataBaseConstant.SQL_WHERE)>0){
String[] arr = table.split(" (?i)where ");
table = arr[0];
filterSql = oConvertUtils.getString(arr[1], null);
}
table = SqlInjectionUtil.getSqlInjectTableName(table);
text = SqlInjectionUtil.getSqlInjectField(text);
code = SqlInjectionUtil.getSqlInjectField(code);
pidField = SqlInjectionUtil.getSqlInjectField(pidField);
hasChildField = SqlInjectionUtil.getSqlInjectField(hasChildField);
if(oConvertUtils.isEmpty(text) || oConvertUtils.isEmpty(code)){
log.warn("text={}，code={}", text, code);
log.warn("加载树字典参数有误，text和code不允许为空！");
return null;
}
// 2.检测最终SQL是否存在SQL注入风险
String dictCode = table + "," + text + "," + code;
SqlInjectionUtil.filterContentMulti(dictCode);
SqlInjectionUtil.specialFilterContentForDictSql(filterSql);
// 【QQYUN-6533】表字典白名单check
sysBaseAPI.dictTableWhiteListCheckByDict(table, text, code);
// 3.表字典SQL表名黑名单 Check
if(!dictQueryBlackListHandler.isPass(dictCode)){
log.error("Sql异常：{}", dictQueryBlackListHandler.getError());
return null;
}
// 4.检测查询条件是否存在SQL注入
Map<String, String> queryParams = queryParams = new HashMap<>(4);
if (query != null) {
for (Map.Entry<String, String> searchItem : query.entrySet()) {
String fieldName = searchItem.getKey();
queryParams.put(SqlInjectionUtil.getSqlInjectField(fieldName), searchItem.getValue());
}
}
// 代码逻辑说明: [QQYUN-13741]【客户问题 南自】online表单自定义树 表后边加条件时 不生效------------
if(oConvertUtils.isNotEmpty(filterSql)){
queryParams.put("_tableFilterSql", filterSql);
}
return baseMapper.queryTreeList(queryParams, table, text, code, pidField, pid, hasChildField, converIsLeafVal);
}
@Override
public void deleteOneDictPhysically(String id) {
this.baseMapper.deleteOneById(id);
this.sysDictItemMapper.delete(new LambdaQueryWrapper<SysDictItem>().eq(SysDictItem::getDictId,id));
}
@Override
public void updateDictDelFlag(int delFlag, String id) {
baseMapper.updateDictDelFlag(delFlag,id);
}
@Override
public List<SysDict> queryDeleteList(String tenantId) {
// 代码逻辑说明: 【QQYUN-8340】回收站查找软删除记录时，没有判断是否启用多租户，造成可以查找并回收其他租户的数据 #5907---
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
if(oConvertUtils.isEmpty(tenantId)){
return new ArrayList<>();
}
return baseMapper.queryDeleteListBtTenantId(oConvertUtils.getInt(tenantId));
}
return baseMapper.queryDeleteList();
}
@Override
public List<DictModel> queryDictTablePageList(DictQuery query, int pageSize, int pageNo) {
Page page = new Page(pageNo,pageSize,false);
//为了防止sql（jeecg提供了防注入的方法，可以在拼接 SQL 语句时自动对参数进行转义，避免SQL注入攻击）
// 1. 针对采用 ${}写法的表名和字段进行转义和check
String table = SqlInjectionUtil.getSqlInjectTableName(query.getTable());
String text = SqlInjectionUtil.getSqlInjectTableName(query.getText());
String code = SqlInjectionUtil.getSqlInjectTableName(query.getCode());
query.setCode(table);
query.setTable(text);
query.setText(code);
String dictCode = table+","+text+","+code;
// 【QQYUN-6533】表字典白名单check
sysBaseAPI.dictTableWhiteListCheckByDict(table, text, code);
// 2.表字典黑名单check
if(!dictQueryBlackListHandler.isPass(dictCode)){
log.error(dictQueryBlackListHandler.getError());
return null;
}
// 3.SQL注入check
SqlInjectionUtil.filterContentMulti(dictCode);
Page<DictModel> pageList = baseMapper.queryDictTablePageList(page, query);
return pageList.getRecords();
}
@Override
public List<DictModel> getDictItems(String dictCode) {
List<DictModel> ls;
if (dictCode.contains(SymbolConstant.COMMA)) {
//关联表字典（举例：sys_user,realname,id）
String[] params = dictCode.split(",");
if (params.length < 3) {
// 字典Code格式不正确
return null;
}
if (params.length == 4) {
ls = this.queryTableDictItemsByCodeAndFilter(params[0], params[1], params[2], params[3]);
} else if (params.length == 3) {
ls = this.queryTableDictItemsByCode(params[0], params[1], params[2]);
} else {
// 字典Code格式不正确
return null;
}
} else {
//字典表
ls = this.queryDictItemsByCode(dictCode);
}
// 代码逻辑说明: 字典获取可以获取枚举类的数据
if (ls == null || ls.size() == 0) {
Map<String, List<DictModel>> map = ResourceUtil.getEnumDictData();
if (map.containsKey(dictCode)) {
return map.get(dictCode);
}
}
return ls;
}
@Override
public List<DictModel> loadDict(String dictCode, String keyword, Integer pageNo, Integer pageSize) {
// 【QQYUN-6533】表字典白名单check
sysBaseAPI.dictTableWhiteListCheckByDict(dictCode);
// 1.表字典黑名单check
if(!dictQueryBlackListHandler.isPass(dictCode)){
log.error(dictQueryBlackListHandler.getError());
return null;
}
// 2.字典SQL注入风险check
SqlInjectionUtil.specialFilterContentForDictSql(dictCode);
if (dictCode.contains(SymbolConstant.COMMA)) {
// 代码逻辑说明: 下拉搜索不支持表名后加查询条件
String[] params = dictCode.split(",");
String condition = null;
if (params.length != 3 && params.length != 4) {
// 字典Code格式不正确
return null;
} else if (params.length == 4) {
condition = params[3];
// 代码逻辑说明: online表单下拉搜索框表字典配置#{sys_org_code}报错 #3500
if(condition.indexOf(SymbolConstant.SYS_VAR_PREFIX)>=0){
condition = QueryGenerator.getSqlRuleValue(condition);
}
}
// 字典Code格式不正确 [表名为空]
if(oConvertUtils.isEmpty(params[0])){
return null;
}
List<DictModel> ls;
if (pageSize != null) {
ls = this.queryLittleTableDictItems(params[0], params[1], params[2], condition, keyword, pageNo,pageSize);
} else {
ls = this.queryAllTableDictItems(params[0], params[1], params[2], condition, keyword);
}
return ls;
} else {
// 字典Code格式不正确
return null;
}
}
@Override
public List<SysDictVo> getDictListByLowAppId(String lowAppId) {
int tenantId = oConvertUtils.getInt(TenantContext.getTenant(), 0);
List<SysDict> list = baseMapper.getDictListByLowAppId(lowAppId,tenantId);
//查询字典下面的字典项
List<SysDictVo> dictVoList = new ArrayList<>();
for (SysDict dict:list) {
SysDictVo dictVo = new SysDictVo();
BeanUtils.copyProperties(dict,dictVo);
List<SysDictItem> sysDictItems = sysDictItemMapper.selectItemsByMainId(dict.getId());
dictVo.setDictItemsList(sysDictItems);
dictVoList.add(dictVo);
}
return dictVoList;
}
@Override
public String addDictByLowAppId(SysDictVo sysDictVo) {
String[] dictResult = this.addDict(sysDictVo.getDictName(),sysDictVo.getLowAppId(),sysDictVo.getTenantId());
String id = dictResult[0];
String code = dictResult[1];
this.addDictItem(id,sysDictVo.getDictItemsList());
return code;
}
@Override
public void editDictByLowAppId(SysDictVo sysDictVo) {
String id = sysDictVo.getId();
SysDict dict = baseMapper.selectById(id);
if(null == dict){
throw new JeecgBootException("字典数据不存在");
}
//判断应用id和数据库中的是否一致，不一致不让修改
if(!dict.getLowAppId().equals(sysDictVo.getLowAppId())){
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | true |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysDepartServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysDepartServiceImpl.java | package org.jeecg.modules.system.service.impl;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ArrayUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import io.netty.util.internal.StringUtil;
import org.apache.commons.lang.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.FillRuleConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.constant.enums.DepartCategoryEnum;
import org.jeecg.common.exception.JeecgBootBizTipException;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.*;
import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
import org.jeecg.modules.system.entity.*;
import org.jeecg.modules.system.mapper.*;
import org.jeecg.modules.system.model.DepartIdModel;
import org.jeecg.modules.system.model.SysDepartTreeModel;
import org.jeecg.modules.system.service.ISysDepartService;
import org.jeecg.modules.system.util.FindsDepartsChildrenUtil;
import org.jeecg.modules.system.vo.*;
import org.jeecg.modules.system.vo.lowapp.ExportDepartVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import java.util.*;
import java.util.function.Consumer;
import java.util.stream.Collectors;
/**
* <p>
* 部门表 服务实现类
* <p>
*
* @Author Steve
* @Since 2019-01-22
*/
@Service
public class SysDepartServiceImpl extends ServiceImpl<SysDepartMapper, SysDepart> implements ISysDepartService {
@Autowired
private SysUserDepartMapper userDepartMapper;
@Autowired
private SysDepartRoleMapper sysDepartRoleMapper;
@Autowired
private SysDepartPermissionMapper departPermissionMapper;
@Autowired
private SysDepartRolePermissionMapper departRolePermissionMapper;
@Autowired
private SysDepartRoleUserMapper departRoleUserMapper;
@Autowired
private SysUserMapper sysUserMapper;
@Autowired
private SysDepartMapper departMapper;
@Autowired
private SysPositionMapper sysPositionMapper;
@Autowired
private RedisUtil redisUtil;
@Autowired
private SysUserDepPostMapper sysUserDepPostMapper;
@Override
public List<SysDepartTreeModel> queryMyDeptTreeList(String departIds) {
//根据部门id获取所负责部门
LambdaQueryWrapper<SysDepart> query = new LambdaQueryWrapper<SysDepart>();
String[] codeArr = this.getMyDeptParentOrgCode(departIds);
// 代码逻辑说明: 【QQYUN-7320】查询部门没数据，导致报错空指针---
if(ArrayUtil.isEmpty(codeArr)){
return null;
}
for(int i=0;i<codeArr.length;i++){
query.or().likeRight(SysDepart::getOrgCode,codeArr[i]);
}
query.eq(SysDepart::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
query.ne(SysDepart::getOrgCategory,DepartCategoryEnum.DEPART_CATEGORY_POST.getValue());
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的 SASS 控制
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
query.eq(SysDepart::getTenantId, oConvertUtils.getInt(TenantContext.getTenant(), 0));
}
//------------------------------------------------------------------------------------------------
query.orderByAsc(SysDepart::getDepartOrder);
//将父节点ParentId设为null
List<SysDepart> listDepts = this.list(query);
for(int i=0;i<codeArr.length;i++){
for(SysDepart dept : listDepts){
if(dept.getOrgCode().equals(codeArr[i])){
dept.setParentId(null);
}
}
}
// 调用wrapTreeDataToTreeList方法生成树状数据
List<SysDepartTreeModel> listResult = FindsDepartsChildrenUtil.wrapTreeDataToTreeList(listDepts);
return listResult;
}
/**
* queryTreeList 对应 queryTreeList 查询所有的部门数据,以树结构形式响应给前端
*/
@Override
//@Cacheable(value = CacheConstant.SYS_DEPARTS_CACHE)
public List<SysDepartTreeModel> queryTreeList() {
LambdaQueryWrapper<SysDepart> query = new LambdaQueryWrapper<SysDepart>();
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
query.eq(SysDepart::getTenantId, oConvertUtils.getInt(TenantContext.getTenant(), 0));
}
//------------------------------------------------------------------------------------------------
query.eq(SysDepart::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
// 代码逻辑说明: 【QQYUN-13427】部门选择组件修改:需要过滤掉岗位 只保留 公司 子公司 部门---
query.ne(SysDepart::getOrgCategory, DepartCategoryEnum.DEPART_CATEGORY_POST.getValue());
query.orderByAsc(SysDepart::getDepartOrder);
List<SysDepart> list = this.list(query);
//设置用户id,让前台显示
this.setUserIdsByDepList(list);
// 调用wrapTreeDataToTreeList方法生成树状数据
List<SysDepartTreeModel> listResult = FindsDepartsChildrenUtil.wrapTreeDataToTreeList(list);
return listResult;
}
/**
* queryTreeList 根据部门id查询,前端回显调用
*/
@Override
public List<SysDepartTreeModel> queryTreeList(String ids) {
List<SysDepartTreeModel> listResult=new ArrayList<>();
LambdaQueryWrapper<SysDepart> query = new LambdaQueryWrapper<SysDepart>();
query.eq(SysDepart::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
// 代码逻辑说明: 【QQYUN-13427】部门选择组件修改:需要过滤掉岗位 只保留 公司 子公司 部门---
query.ne(SysDepart::getOrgCategory,DepartCategoryEnum.DEPART_CATEGORY_POST.getValue());
if(oConvertUtils.isNotEmpty(ids)){
query.in(true,SysDepart::getId,ids.split(","));
}
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
query.eq(SysDepart::getTenantId, oConvertUtils.getInt(TenantContext.getTenant(), 0));
}
//------------------------------------------------------------------------------------------------
query.orderByAsc(SysDepart::getDepartOrder);
List<SysDepart> list= this.list(query);
for (SysDepart depart : list) {
listResult.add(new SysDepartTreeModel(depart));
}
return listResult;
}
//@Cacheable(value = CacheConstant.SYS_DEPART_IDS_CACHE)
@Override
public List<DepartIdModel> queryDepartIdTreeList() {
LambdaQueryWrapper<SysDepart> query = new LambdaQueryWrapper<SysDepart>();
query.eq(SysDepart::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
query.eq(SysDepart::getTenantId, oConvertUtils.getInt(TenantContext.getTenant(), 0));
}
//------------------------------------------------------------------------------------------------
query.orderByAsc(SysDepart::getDepartOrder);
List<SysDepart> list = this.list(query);
// 调用wrapTreeDataToTreeList方法生成树状数据
List<DepartIdModel> listResult = FindsDepartsChildrenUtil.wrapTreeDataToDepartIdTreeList(list);
return listResult;
}
/**
* saveDepartData 对应 add 保存用户在页面添加的新的部门对象数据
*/
@Override
@Transactional(rollbackFor = Exception.class)
public void saveDepartData(SysDepart sysDepart, String username) {
if (sysDepart != null && username != null) {
// 代码逻辑说明: [QQYUN-4163]给部门表加个是否有子节点------------
if (oConvertUtils.isEmpty(sysDepart.getParentId())) {
sysDepart.setParentId("");
}else{
//将父部门的设成不是叶子结点
departMapper.setMainLeaf(sysDepart.getParentId(),CommonConstant.NOT_LEAF);
}
//String s = UUID.randomUUID().toString().replace("-", "");
sysDepart.setId(IdWorker.getIdStr(sysDepart));
// 先判断该对象有无父级ID,有则意味着不是最高级,否则意味着是最高级
// 获取父级ID
String parentId = sysDepart.getParentId();
// 代码逻辑说明: 部门编码规则生成器做成公用配置
JSONObject formData = new JSONObject();
formData.put("parentId",parentId);
String[] codeArray = (String[]) FillRuleUtil.executeRule(FillRuleConstant.DEPART,formData);
sysDepart.setOrgCode(codeArray[0]);
String orgType = codeArray[1];
sysDepart.setOrgType(String.valueOf(orgType));
sysDepart.setCreateTime(new Date());
sysDepart.setDelFlag(CommonConstant.DEL_FLAG_0.toString());
//新添加的部门是叶子节点
sysDepart.setIzLeaf(CommonConstant.IS_LEAF);
// 【QQYUN-7172】数据库默认值兼容
if (oConvertUtils.isEmpty(sysDepart.getOrgCategory())) {
if (oConvertUtils.isEmpty(sysDepart.getParentId())) {
sysDepart.setOrgCategory("1");
} else {
sysDepart.setOrgCategory("2");
}
}
this.save(sysDepart);
//新增部门的时候新增负责部门
if(oConvertUtils.isNotEmpty(sysDepart.getDirectorUserIds())){
this.addDepartByUserIds(sysDepart,sysDepart.getDirectorUserIds());
}
}
}
/**
* saveDepartData 的调用方法,生成部门编码和部门类型（作废逻辑）
* @deprecated
* @param parentId
* @return
*/
private String[] generateOrgCode(String parentId) {
// 代码逻辑说明: 组织机构添加数据代码调整
LambdaQueryWrapper<SysDepart> query = new LambdaQueryWrapper<SysDepart>();
LambdaQueryWrapper<SysDepart> query1 = new LambdaQueryWrapper<SysDepart>();
String[] strArray = new String[2];
// 创建一个List集合,存储查询返回的所有SysDepart对象
List<SysDepart> departList = new ArrayList<>();
// 定义新编码字符串
String newOrgCode = "";
// 定义旧编码字符串
String oldOrgCode = "";
// 定义部门类型
String orgType = "";
// 如果是最高级,则查询出同级的org_code, 调用工具类生成编码并返回
if (StringUtil.isNullOrEmpty(parentId)) {
// 线判断数据库中的表是否为空,空则直接返回初始编码
query1.eq(SysDepart::getParentId, "").or().isNull(SysDepart::getParentId);
query1.orderByDesc(SysDepart::getOrgCode);
departList = this.list(query1);
if(departList == null || departList.size() == 0) {
strArray[0] = YouBianCodeUtil.getNextYouBianCode(null);
strArray[1] = "1";
return strArray;
}else {
SysDepart depart = departList.get(0);
oldOrgCode = depart.getOrgCode();
orgType = depart.getOrgType();
newOrgCode = YouBianCodeUtil.getNextYouBianCode(oldOrgCode);
}
} else { // 反之则查询出所有同级的部门,获取结果后有两种情况,有同级和没有同级
// 封装查询同级的条件
query.eq(SysDepart::getParentId, parentId);
// 降序排序
query.orderByDesc(SysDepart::getOrgCode);
// 查询出同级部门的集合
List<SysDepart> parentList = this.list(query);
// 查询出父级部门
SysDepart depart = this.getById(parentId);
// 获取父级部门的Code
String parentCode = depart.getOrgCode();
// 根据父级部门类型算出当前部门的类型
orgType = String.valueOf(Integer.valueOf(depart.getOrgType()) + 1);
// 处理同级部门为null的情况
if (parentList == null || parentList.size() == 0) {
// 直接生成当前的部门编码并返回
newOrgCode = YouBianCodeUtil.getSubYouBianCode(parentCode, null);
} else { //处理有同级部门的情况
// 获取同级部门的编码,利用工具类
String subCode = parentList.get(0).getOrgCode();
// 返回生成的当前部门编码
newOrgCode = YouBianCodeUtil.getSubYouBianCode(parentCode, subCode);
}
}
// 返回最终封装了部门编码和部门类型的数组
strArray[0] = newOrgCode;
strArray[1] = orgType;
return strArray;
}
/**
* removeDepartDataById 对应 delete方法 根据ID删除相关部门数据
*
*/
/*
* @Override
*
* @Transactional public boolean removeDepartDataById(String id) {
* System.out.println("要删除的ID 为=============================>>>>>"+id); boolean
* flag = this.removeById(id); return flag; }
*/
/**
* updateDepartDataById 对应 edit 根据部门主键来更新对应的部门数据
*/
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean updateDepartDataById(SysDepart sysDepart, String username) {
if (sysDepart != null && username != null) {
sysDepart.setUpdateTime(new Date());
sysDepart.setUpdateBy(username);
//验证部门类型
this.verifyOrgCategory(sysDepart);
this.updateById(sysDepart);
//修改部门管理的时候，修改负责部门
this.updateChargeDepart(sysDepart);
//redis清除缓存key
redisUtil.removeAll(CommonConstant.DEPART_NAME_REDIS_KEY_PRE);
return true;
} else {
return false;
}
}
/**
* 验证部门类型
*
* @param sysDepart
*/
private void verifyOrgCategory(SysDepart sysDepart) {
//update-begin---author:wangshuai---date:2025-08-21---for: 当部门类型为岗位的时候，需要查看是否存在下级，存在下级无法变更为岗位---
//如果是岗位的情况下，不能存在子级
if (oConvertUtils.isNotEmpty(sysDepart.getOrgCategory()) && DepartCategoryEnum.DEPART_CATEGORY_POST.getValue().equals(sysDepart.getOrgCategory())) {
long count = this.count(new QueryWrapper<SysDepart>().lambda().eq(SysDepart::getParentId, sysDepart.getId()));
if (count > 0) {
throw new JeecgBootBizTipException("当前子公司/部门下存在子级，无法变更为岗位!");
}
}
//如果是子公司的情况下，则上级不能为部门或者岗位
if (oConvertUtils.isNotEmpty(sysDepart.getOrgCategory()) && DepartCategoryEnum.DEPART_CATEGORY_SUB_COMPANY.getValue().equals(sysDepart.getOrgCategory())
&& oConvertUtils.isNotEmpty(sysDepart.getParentId())) {
LambdaQueryWrapper<SysDepart> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SysDepart::getId, sysDepart.getParentId());
queryWrapper.in(SysDepart::getOrgCategory, DepartCategoryEnum.DEPART_CATEGORY_POST.getValue(), DepartCategoryEnum.DEPART_CATEGORY_DEPART.getValue());
long count = this.count(queryWrapper);
if (count > 0) {
throw new JeecgBootBizTipException("当前父级为部门或岗位，无法变更为子公司!");
}
}
//如果是部门的情况下，下级不能为子公司或者公司
if (oConvertUtils.isNotEmpty(sysDepart.getOrgCategory()) && DepartCategoryEnum.DEPART_CATEGORY_DEPART.getValue().equals(sysDepart.getOrgCategory())) {
LambdaQueryWrapper<SysDepart> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SysDepart::getParentId, sysDepart.getId());
queryWrapper.in(SysDepart::getOrgCategory, DepartCategoryEnum.DEPART_CATEGORY_COMPANY.getValue(), DepartCategoryEnum.DEPART_CATEGORY_SUB_COMPANY.getValue());
long count = this.count(queryWrapper);
if (count > 0) {
throw new JeecgBootBizTipException("当前子级存在子公司，无法变更为部门!");
}
}
}
@Override
@Transactional(rollbackFor = Exception.class)
public void deleteBatchWithChildren(List<String> ids) {
//存放子级的id
List<String> idList = new ArrayList<String>();
//存放父级的id
List<String> parentIdList = new ArrayList<>();
for(String id: ids) {
idList.add(id);
//此步骤是为了删除子级
this.checkChildrenExists(id, idList);
// 代码逻辑说明: 【QQYUN-5757】批量删除部门时未正确置为叶子节点 ------------
SysDepart depart = this.getDepartById(id);
if (oConvertUtils.isNotEmpty(depart.getParentId())) {
if (!parentIdList.contains(depart.getParentId())) {
parentIdList.add(depart.getParentId());
}
}
}
this.removeByIds(idList);
//再删除前需要获取父级id，不然会一直为空
this.setParentDepartIzLeaf(parentIdList);
//根据部门id获取部门角色id
List<String> roleIdList = new ArrayList<>();
LambdaQueryWrapper<SysDepartRole> query = new LambdaQueryWrapper<>();
query.select(SysDepartRole::getId).in(SysDepartRole::getDepartId, idList);
List<SysDepartRole> depRoleList = sysDepartRoleMapper.selectList(query);
for(SysDepartRole deptRole : depRoleList){
roleIdList.add(deptRole.getId());
}
//根据部门id删除用户与部门关系
userDepartMapper.delete(new LambdaQueryWrapper<SysUserDepart>().in(SysUserDepart::getDepId,idList));
//根据部门id删除部门授权
departPermissionMapper.delete(new LambdaQueryWrapper<SysDepartPermission>().in(SysDepartPermission::getDepartId,idList));
//根据部门id删除部门角色
sysDepartRoleMapper.delete(new LambdaQueryWrapper<SysDepartRole>().in(SysDepartRole::getDepartId,idList));
if(roleIdList != null && roleIdList.size()>0){
//根据角色id删除部门角色授权
departRolePermissionMapper.delete(new LambdaQueryWrapper<SysDepartRolePermission>().in(SysDepartRolePermission::getRoleId,roleIdList));
//根据角色id删除部门角色用户信息
departRoleUserMapper.delete(new LambdaQueryWrapper<SysDepartRoleUser>().in(SysDepartRoleUser::getDroleId,roleIdList));
}
//删除岗位信息
this.deleteDepartPostByDepIds(idList);
}
@Override
public List<String> getSubDepIdsByDepId(String departId) {
return this.baseMapper.getSubDepIdsByDepId(departId);
}
@Override
public List<String> getMySubDepIdsByDepId(String departIds) {
//根据部门id获取所负责部门
String[] codeArr = this.getMyDeptParentOrgCode(departIds);
if(codeArr==null || codeArr.length==0){
return null;
}
return this.baseMapper.getSubDepIdsByOrgCodes(codeArr);
}
/**
* <p>
* 根据关键字搜索相关的部门数据
* </p>
*/
@Override
public List<SysDepartTreeModel> searchByKeyWord(String keyWord, String myDeptSearch, String departIds, String orgCategory, String depIds) {
LambdaQueryWrapper<SysDepart> query = new LambdaQueryWrapper<SysDepart>();
List<SysDepartTreeModel> newList = new ArrayList<>();
//myDeptSearch不为空时为我的部门搜索，只搜索所负责部门
if(!StringUtil.isNullOrEmpty(myDeptSearch)){
//departIds 为空普通用户或没有管理部门
if(StringUtil.isNullOrEmpty(departIds)){
return newList;
}
//根据部门id获取所负责部门
String[] codeArr = this.getMyDeptParentOrgCode(departIds);
// 代码逻辑说明: /issues/3311 当用户属于两个部门的时候，且这两个部门没有上下级关系，我的部门-部门名称查询条件模糊搜索失效！
if (codeArr != null && codeArr.length > 0) {
query.nested(i -> {
for (String s : codeArr) {
i.or().likeRight(SysDepart::getOrgCode, s);
}
});
}
query.eq(SysDepart::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
}
query.like(SysDepart::getDepartName, keyWord);
//需要根据部门类型进行数据筛选
if(oConvertUtils.isNotEmpty(orgCategory)){
query.in(SysDepart::getOrgCategory, Arrays.asList(orgCategory.split(SymbolConstant.COMMA)));
}else{
query.ne(SysDepart::getOrgCategory,DepartCategoryEnum.DEPART_CATEGORY_POST.getValue());
}
//如果前端传过来的部门id不为空的时候，说明是系统用户根据所属部门选择主岗位或者兼职岗位，需要进行数据过滤
if(oConvertUtils.isNotEmpty(depIds)){
List<String> codeList = baseMapper.getDepCodeByDepIds(Arrays.asList(depIds.split(SymbolConstant.COMMA)));
if(CollectionUtil.isNotEmpty(codeList)){
query.and(i -> {
for (String code : codeList) {
i.or().likeRight(SysDepart::getOrgCode,code);
}
});
}
}
// 代码逻辑说明: [bugfree号]组织机构搜索回显优化--------------------
SysDepartTreeModel model = new SysDepartTreeModel();
List<SysDepart> departList = this.list(query);
if(departList.size() > 0) {
for(SysDepart depart : departList) {
model = new SysDepartTreeModel(depart);
model.setChildren(null);
newList.add(model);
}
return newList;
}
return null;
}
/**
* 根据部门id删除并且删除其可能存在的子级任何部门
*/
@Override
@Transactional(rollbackFor = Exception.class)
public boolean delete(String id) {
List<String> idList = new ArrayList<>();
idList.add(id);
this.checkChildrenExists(id, idList);
//清空部门树内存
//FindsDepartsChildrenUtil.clearDepartIdModel();
boolean ok = this.removeByIds(idList);
//根据部门id获取部门角色id
List<String> roleIdList = new ArrayList<>();
LambdaQueryWrapper<SysDepartRole> query = new LambdaQueryWrapper<>();
query.select(SysDepartRole::getId).in(SysDepartRole::getDepartId, idList);
List<SysDepartRole> depRoleList = sysDepartRoleMapper.selectList(query);
for(SysDepartRole deptRole : depRoleList){
roleIdList.add(deptRole.getId());
}
//根据部门id删除用户与部门关系
userDepartMapper.delete(new LambdaQueryWrapper<SysUserDepart>().in(SysUserDepart::getDepId,idList));
//根据部门id删除部门授权
departPermissionMapper.delete(new LambdaQueryWrapper<SysDepartPermission>().in(SysDepartPermission::getDepartId,idList));
//根据部门id删除部门角色
sysDepartRoleMapper.delete(new LambdaQueryWrapper<SysDepartRole>().in(SysDepartRole::getDepartId,idList));
if(roleIdList != null && roleIdList.size()>0){
//根据角色id删除部门角色授权
departRolePermissionMapper.delete(new LambdaQueryWrapper<SysDepartRolePermission>().in(SysDepartRolePermission::getRoleId,roleIdList));
//根据角色id删除部门角色用户信息
departRoleUserMapper.delete(new LambdaQueryWrapper<SysDepartRoleUser>().in(SysDepartRoleUser::getDroleId,roleIdList));
}
return ok;
}
/**
* delete 方法调用
* @param id
* @param idList
*/
private void checkChildrenExists(String id, List<String> idList) {
LambdaQueryWrapper<SysDepart> query = new LambdaQueryWrapper<SysDepart>();
query.eq(SysDepart::getParentId,id);
List<SysDepart> departList = this.list(query);
if(departList != null && departList.size() > 0) {
for(SysDepart depart : departList) {
idList.add(depart.getId());
this.checkChildrenExists(depart.getId(), idList);
}
}
}
@Override
public List<SysDepart> queryUserDeparts(String userId) {
List<SysDepart> sysDeparts = baseMapper.queryUserDeparts(userId);
sysDeparts.stream()
.filter(depart -> oConvertUtils.isNotEmpty(depart) &&
oConvertUtils.isNotEmpty(depart.getOrgCode()))
.forEach(depart -> {
String orgCategory = depart.getOrgCategory();
if(DepartCategoryEnum.DEPART_CATEGORY_DEPART.getValue().equalsIgnoreCase(orgCategory)){
String departPathName = this.getDepartPathNameByOrgCode(depart.getOrgCode(), "");
depart.setDepartPathName(departPathName);
}
});
return sysDeparts;
}
@Override
public List<SysDepart> queryDepartsByUsername(String username) {
return baseMapper.queryDepartsByUsername(username);
}
@Override
public List<String> queryDepartsByUserId(String userId) {
List<String> list = baseMapper.queryDepartsByUserId(userId);
return list;
}
/**
* 根据用户所负责部门ids获取父级部门编码
* @param departIds
* @return
*/
private String[] getMyDeptParentOrgCode(String departIds){
//根据部门id查询所负责部门
LambdaQueryWrapper<SysDepart> query = new LambdaQueryWrapper<SysDepart>();
query.eq(SysDepart::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
if(oConvertUtils.isNotEmpty(departIds)){
query.in(SysDepart::getId, Arrays.asList(departIds.split(",")));
}
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
query.eq(SysDepart::getTenantId, oConvertUtils.getInt(TenantContext.getTenant(), 0));
}
//------------------------------------------------------------------------------------------------
query.orderByAsc(SysDepart::getOrgCode);
List<SysDepart> list = this.list(query);
//查找根部门
if(list == null || list.size()==0){
return null;
}
String orgCode = this.getMyDeptParentNode(list);
String[] codeArr = orgCode.split(",");
return codeArr;
}
/**
* 获取负责部门父节点
* @param list
* @return
*/
private String getMyDeptParentNode(List<SysDepart> list){
Map<String,String> map = new HashMap(5);
//1.先将同一公司归类
for(SysDepart dept : list){
String code = dept.getOrgCode().substring(0,3);
if(map.containsKey(code)){
String mapCode = map.get(code)+","+dept.getOrgCode();
map.put(code,mapCode);
}else{
map.put(code,dept.getOrgCode());
}
}
StringBuffer parentOrgCode = new StringBuffer();
//2.获取同一公司的根节点
for(String str : map.values()){
String[] arrStr = str.split(",");
parentOrgCode.append(",").append(this.getMinLengthNode(arrStr));
}
return parentOrgCode.substring(1);
}
/**
* 获取同一公司中部门编码长度最小的部门
* @param str
* @return
*/
private String getMinLengthNode(String[] str){
int min =str[0].length();
StringBuilder orgCodeBuilder = new StringBuilder(str[0]);
for(int i =1;i<str.length;i++){
if(str[i].length()<=min){
min = str[i].length();
orgCodeBuilder.append(SymbolConstant.COMMA).append(str[i]);
}
}
return orgCodeBuilder.toString();
}
/**
* 获取部门树信息根据关键字
* @param keyWord
* @return
*/
@Override
public List<SysDepartTreeModel> queryTreeByKeyWord(String keyWord) {
LambdaQueryWrapper<SysDepart> query = new LambdaQueryWrapper<SysDepart>();
query.eq(SysDepart::getDelFlag, CommonConstant.DEL_FLAG_0.toString());
query.orderByAsc(SysDepart::getDepartOrder);
List<SysDepart> list = this.list(query);
// 调用wrapTreeDataToTreeList方法生成树状数据
List<SysDepartTreeModel> listResult = FindsDepartsChildrenUtil.wrapTreeDataToTreeList(list);
List<SysDepartTreeModel> treelist =new ArrayList<>();
if(StringUtils.isNotBlank(keyWord)){
this.getTreeByKeyWord(keyWord,listResult,treelist);
}else{
return listResult;
}
return treelist;
}
/**
* 根据parentId查询部门树
* @param parentId
* @param ids 前端回显传递
* @param primaryKey 主键字段（id或者orgCode）
* @return
*/
@Override
public List<SysDepartTreeModel> queryTreeListByPid(String parentId,String ids, String primaryKey) {
Consumer<LambdaQueryWrapper<SysDepart>> square = i -> {
if (oConvertUtils.isNotEmpty(ids)) {
if (CommonConstant.DEPART_KEY_ORG_CODE.equals(primaryKey)) {
i.in(SysDepart::getOrgCode, ids.split(SymbolConstant.COMMA));
} else {
i.in(SysDepart::getId, ids.split(SymbolConstant.COMMA));
}
} else {
if(oConvertUtils.isEmpty(parentId)){
i.and(q->q.isNull(true,SysDepart::getParentId).or().eq(true,SysDepart::getParentId,""));
}else{
i.eq(true,SysDepart::getParentId,parentId);
}
}
};
LambdaQueryWrapper<SysDepart> lqw=new LambdaQueryWrapper<>();
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的 SASS 控制
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
lqw.eq(SysDepart::getTenantId, oConvertUtils.getInt(TenantContext.getTenant(), 0));
}
//------------------------------------------------------------------------------------------------
lqw.eq(true,SysDepart::getDelFlag,CommonConstant.DEL_FLAG_0.toString());
// 代码逻辑说明: 【QQYUN-13427】部门选择组件修改:需要过滤掉岗位 只保留 公司 子公司 部门---
lqw.ne(SysDepart::getOrgCategory,DepartCategoryEnum.DEPART_CATEGORY_POST.getValue());
lqw.func(square);
// 代码逻辑说明: [VUEN-1143]排序不对，vue3和2应该都有问题，应该按照升序排------------
lqw.orderByAsc(SysDepart::getDepartOrder);
List<SysDepart> list = list(lqw);
//设置用户id,让前台显示
this.setUserIdsByDepList(list);
List<SysDepartTreeModel> records = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
SysDepart depart = list.get(i);
// 代码逻辑说明: 【QQYUN-13427】部门选择组件修改:需要过滤掉岗位 只保留 公司 子公司 部门---
long count = getNoDepartPostCount(depart.getId());
if(count == 0){
depart.setIzLeaf(CommonConstant.IS_LEAF);
}
SysDepartTreeModel treeModel = new SysDepartTreeModel(depart);
//TODO 异步树加载key拼接__+时间戳,以便于每次展开节点会刷新数据
//treeModel.setKey(treeModel.getKey()+"__"+System.currentTimeMillis());
records.add(treeModel);
}
return records;
}
/**
* 获取部门数量
* @param departId
* @return
*/
private long getNoDepartPostCount(String departId) {
LambdaQueryWrapper<SysDepart> queryNoPosition = new LambdaQueryWrapper<>();
queryNoPosition.ne(SysDepart::getOrgCategory,DepartCategoryEnum.DEPART_CATEGORY_POST.getValue());
queryNoPosition.eq(SysDepart::getParentId,departId);
return this.count(queryNoPosition);
}
/**
* 部门管理异步树
*
* @param parentId
* @param ids
* @param primaryKey
* @param departIds
* @return
*/
@Override
public List<SysDepartTreeModel> queryDepartAndPostTreeSync(String parentId, String ids, String primaryKey,
String departIds, String orgName) {
Consumer<LambdaQueryWrapper<SysDepart>> square = i -> {
if (oConvertUtils.isNotEmpty(ids)) {
if (CommonConstant.DEPART_KEY_ORG_CODE.equals(primaryKey)) {
i.in(SysDepart::getOrgCode, ids.split(SymbolConstant.COMMA));
} else {
i.in(SysDepart::getId, ids.split(SymbolConstant.COMMA));
}
} else {
if(oConvertUtils.isEmpty(parentId)){
// 代码逻辑说明: 如果前端传过来的部门id不为空的时候，说明是系统用户根据所属部门选择主岗位或者兼职岗位---
if(oConvertUtils.isNotEmpty(departIds)){
i.in(SysDepart::getId,Arrays.asList(departIds.split(SymbolConstant.COMMA)));
}else{
if(oConvertUtils.isEmpty(orgName)){
i.and(q->q.isNull(true,SysDepart::getParentId).or().eq(true,SysDepart::getParentId,""));
}else{
i.like(SysDepart::getDepartName, orgName);
}
}
}else{
i.eq(true,SysDepart::getParentId,parentId);
}
}
};
LambdaQueryWrapper<SysDepart> lqw=new LambdaQueryWrapper<>();
//是否开启系统管理模块的 SASS 控制
if(MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL){
lqw.eq(SysDepart::getTenantId, oConvertUtils.getInt(TenantContext.getTenant(), 0));
}
lqw.eq(true,SysDepart::getDelFlag,CommonConstant.DEL_FLAG_0.toString());
lqw.func(square);
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | true |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysDataLogServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysDataLogServiceImpl.java | package org.jeecg.modules.system.service.impl;
import org.jeecg.modules.system.entity.SysDataLog;
import org.jeecg.modules.system.mapper.SysDataLogMapper;
import org.jeecg.modules.system.service.ISysDataLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
/**
* @Description: 系统数据日志实现类
* @author: jeecg-boot
*/
@Service
public class SysDataLogServiceImpl extends ServiceImpl<SysDataLogMapper,SysDataLog> implements ISysDataLogService {
@Autowired
private SysDataLogMapper logMapper;
/**
* 添加数据日志
*/
@Override
public void addDataLog(String tableName, String dataId, String dataContent) {
String versionNumber = "0";
String dataVersion = logMapper.queryMaxDataVer(tableName, dataId);
if(dataVersion != null ) {
versionNumber = String.valueOf(Integer.parseInt(dataVersion)+1);
}
SysDataLog log = new SysDataLog();
log.setDataTable(tableName);
log.setDataId(dataId);
log.setDataContent(dataContent);
log.setDataVersion(versionNumber);
log.autoSetCreateName();
this.save(log);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysCheckRuleServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysCheckRuleServiceImpl.java | package org.jeecg.modules.system.service.impl;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang.StringUtils;
import org.jeecg.modules.system.entity.SysCheckRule;
import org.jeecg.modules.system.mapper.SysCheckRuleMapper;
import org.jeecg.modules.system.service.ISysCheckRuleService;
import org.springframework.stereotype.Service;
import java.util.regex.Pattern;
/**
* @Description: 编码校验规则
* @Author: jeecg-boot
* @Date: 2020-02-04
* @Version: V1.0
*/
@Service
public class SysCheckRuleServiceImpl extends ServiceImpl<SysCheckRuleMapper, SysCheckRule> implements ISysCheckRuleService {
/**
* 位数特殊符号，用于检查整个值，而不是裁剪某一段
*/
private final String CHECK_ALL_SYMBOL = "*";
@Override
public SysCheckRule getByCode(String ruleCode) {
LambdaQueryWrapper<SysCheckRule> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SysCheckRule::getRuleCode, ruleCode);
return super.getOne(queryWrapper);
}
/**
* 通过用户设定的自定义校验规则校验传入的值
*
* @param checkRule
* @param value
* @return 返回 null代表通过校验，否则就是返回的错误提示文本
*/
@Override
public JSONObject checkValue(SysCheckRule checkRule, String value) {
if (checkRule != null && StringUtils.isNotBlank(value)) {
String ruleJson = checkRule.getRuleJson();
if (StringUtils.isNotBlank(ruleJson)) {
// 开始截取的下标，根据规则的顺序递增，但是 * 号不计入递增范围
int beginIndex = 0;
JSONArray rules = JSON.parseArray(ruleJson);
for (int i = 0; i < rules.size(); i++) {
JSONObject result = new JSONObject();
JSONObject rule = rules.getJSONObject(i);
// 位数
String digits = rule.getString("digits");
result.put("digits", digits);
// 验证规则
String pattern = rule.getString("pattern");
result.put("pattern", pattern);
// 未通过时的提示文本
String message = rule.getString("message");
result.put("message", message);
// 根据用户设定的区间，截取字符串进行验证
String checkValue;
// 是否检查整个值而不截取
if (CHECK_ALL_SYMBOL.equals(digits)) {
checkValue = value;
} else {
int num = Integer.parseInt(digits);
int endIndex = beginIndex + num;
// 如果结束下标大于给定的值的长度，则取到最后一位
endIndex = endIndex > value.length() ? value.length() : endIndex;
// 如果开始下标大于结束下标，则说明用户还尚未输入到该位置，直接赋空值
if (beginIndex > endIndex) {
checkValue = "";
} else {
checkValue = value.substring(beginIndex, endIndex);
}
result.put("beginIndex", beginIndex);
result.put("endIndex", endIndex);
beginIndex += num;
}
result.put("checkValue", checkValue);
boolean passed = Pattern.matches(pattern, checkValue);
result.put("passed", passed);
// 如果没有通过校验就返回错误信息
if (!passed) {
return result;
}
}
}
}
return null;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysCategoryServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysCategoryServiceImpl.java | package org.jeecg.modules.system.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.jeecg.common.constant.FillRuleConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.util.FillRuleUtil;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysCategory;
import org.jeecg.modules.system.mapper.SysCategoryMapper;
import org.jeecg.modules.system.model.TreeSelectModel;
import org.jeecg.modules.system.service.ISysCategoryService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import java.util.stream.Collectors;
/**
* @Description: 分类字典
* @Author: jeecg-boot
* @Date: 2019-05-29
* @Version: V1.0
*/
@Service
public class SysCategoryServiceImpl extends ServiceImpl<SysCategoryMapper, SysCategory> implements ISysCategoryService {
@Override
public void addSysCategory(SysCategory sysCategory) {
String categoryCode = "";
String categoryPid = ISysCategoryService.ROOT_PID_VALUE;
String parentCode = null;
if(oConvertUtils.isNotEmpty(sysCategory.getPid())){
categoryPid = sysCategory.getPid();
//PID 不是根节点 说明需要设置父节点 hasChild 为1
if(!ISysCategoryService.ROOT_PID_VALUE.equals(categoryPid)){
SysCategory parent = baseMapper.selectById(categoryPid);
parentCode = parent.getCode();
if(parent!=null && !ISysCategoryService.HAS_CHILD.equals(parent.getHasChild())){
parent.setHasChild(ISysCategoryService.HAS_CHILD);
baseMapper.updateById(parent);
}
}
}
// 代码逻辑说明: 分类字典编码规则生成器做成公用配置
JSONObject formData = new JSONObject();
formData.put("pid",categoryPid);
categoryCode = (String) FillRuleUtil.executeRule(FillRuleConstant.CATEGORY,formData);
sysCategory.setCode(categoryCode);
sysCategory.setPid(categoryPid);
baseMapper.insert(sysCategory);
}
@Override
public void updateSysCategory(SysCategory sysCategory) {
if(oConvertUtils.isEmpty(sysCategory.getPid())){
sysCategory.setPid(ISysCategoryService.ROOT_PID_VALUE);
}else{
//如果当前节点父ID不为空 则设置父节点的hasChild 为1
SysCategory parent = baseMapper.selectById(sysCategory.getPid());
if(parent!=null && !ISysCategoryService.HAS_CHILD.equals(parent.getHasChild())){
parent.setHasChild(ISysCategoryService.HAS_CHILD);
baseMapper.updateById(parent);
}
}
baseMapper.updateById(sysCategory);
}
@Override
public List<TreeSelectModel> queryListByCode(String pcode) throws JeecgBootException{
String pid = ROOT_PID_VALUE;
if(oConvertUtils.isNotEmpty(pcode)) {
List<SysCategory> list = baseMapper.selectList(new LambdaQueryWrapper<SysCategory>().eq(SysCategory::getCode, pcode));
if(list==null || list.size() ==0) {
throw new JeecgBootException("该编码【"+pcode+"】不存在，请核实!");
}
if(list.size()>1) {
throw new JeecgBootException("该编码【"+pcode+"】存在多个，请核实!");
}
pid = list.get(0).getId();
}
return baseMapper.queryListByPid(pid,null);
}
@Override
public List<TreeSelectModel> queryListByPid(String pid) {
if(oConvertUtils.isEmpty(pid)) {
pid = ROOT_PID_VALUE;
}
return baseMapper.queryListByPid(pid,null);
}
@Override
public List<TreeSelectModel> queryListByPid(String pid, Map<String, String> condition) {
if(oConvertUtils.isEmpty(pid)) {
pid = ROOT_PID_VALUE;
}
return baseMapper.queryListByPid(pid,condition);
}
@Override
public String queryIdByCode(String code) {
return baseMapper.queryIdByCode(code);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void deleteSysCategory(String ids) {
String allIds = this.queryTreeChildIds(ids);
String pids = this.queryTreePids(ids);
//1.删除时将节点下所有子节点一并删除
this.baseMapper.deleteBatchIds(Arrays.asList(allIds.split(",")));
//2.将父节点中已经没有下级的节点，修改为没有子节点
if(oConvertUtils.isNotEmpty(pids)){
LambdaUpdateWrapper<SysCategory> updateWrapper = new UpdateWrapper<SysCategory>()
.lambda()
.in(SysCategory::getId,Arrays.asList(pids.split(",")))
.set(SysCategory::getHasChild,"0");
this.update(updateWrapper);
}
}
/**
* 查询节点下所有子节点
* @param ids
* @return
*/
private String queryTreeChildIds(String ids) {
//获取id数组
String[] idArr = ids.split(",");
StringBuffer sb = new StringBuffer();
for (String pidVal : idArr) {
if(pidVal != null){
if(!sb.toString().contains(pidVal)){
if(sb.toString().length() > 0){
sb.append(",");
}
sb.append(pidVal);
this.getTreeChildIds(pidVal,sb);
}
}
}
return sb.toString();
}
/**
* 查询需修改标识的父节点ids
* @param ids
* @return
*/
private String queryTreePids(String ids) {
StringBuffer sb = new StringBuffer();
//获取id数组
String[] idArr = ids.split(",");
for (String id : idArr) {
if(id != null){
SysCategory category = this.baseMapper.selectById(id);
//根据id查询pid值
String metaPid = category.getPid();
//查询此节点上一级是否还有其他子节点
LambdaQueryWrapper<SysCategory> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SysCategory::getPid,metaPid);
queryWrapper.notIn(SysCategory::getId,Arrays.asList(idArr));
List<SysCategory> dataList = this.baseMapper.selectList(queryWrapper);
boolean flag = (dataList == null || dataList.size()==0) && !Arrays.asList(idArr).contains(metaPid)
&& !sb.toString().contains(metaPid);
if(flag){
//如果当前节点原本有子节点 现在木有了，更新状态
sb.append(metaPid).append(",");
}
}
}
if(sb.toString().endsWith(SymbolConstant.COMMA)){
sb = sb.deleteCharAt(sb.length() - 1);
}
return sb.toString();
}
/**
* 递归 根据父id获取子节点id
* @param pidVal
* @param sb
* @return
*/
private StringBuffer getTreeChildIds(String pidVal,StringBuffer sb){
LambdaQueryWrapper<SysCategory> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SysCategory::getPid,pidVal);
List<SysCategory> dataList = baseMapper.selectList(queryWrapper);
if(dataList != null && dataList.size()>0){
for(SysCategory category : dataList) {
if(!sb.toString().contains(category.getId())){
sb.append(",").append(category.getId());
}
this.getTreeChildIds(category.getId(), sb);
}
}
return sb;
}
@Override
public List<String> loadDictItem(String ids) {
return this.loadDictItem(ids, true);
}
@Override
public List<String> loadDictItem(String ids, boolean delNotExist) {
String[] idArray = ids.split(",");
LambdaQueryWrapper<SysCategory> query = new LambdaQueryWrapper<>();
query.in(SysCategory::getId, Arrays.asList(idArray));
// 查询数据
List<SysCategory> list = super.list(query);
// 取出name并返回
List<String> textList;
// 代码逻辑说明: 新增delNotExist参数，设为false不删除数据库里不存在的key ----
if (delNotExist) {
textList = list.stream().map(SysCategory::getName).collect(Collectors.toList());
} else {
textList = new ArrayList<>();
for (String id : idArray) {
List<SysCategory> res = list.stream().filter(i -> id.equals(i.getId())).collect(Collectors.toList());
textList.add(res.size() > 0 ? res.get(0).getName() : id);
}
}
return textList;
}
@Override
public List<String> loadDictItemByNames(String names, boolean delNotExist) {
List<String> nameList = Arrays.asList(names.split(SymbolConstant.COMMA));
LambdaQueryWrapper<SysCategory> query = new LambdaQueryWrapper<>();
query.select(SysCategory::getId, SysCategory::getName);
query.in(SysCategory::getName, nameList);
// 查询数据
List<SysCategory> list = super.list(query);
// 取出id并返回
return nameList.stream().map(name -> {
SysCategory res = list.stream().filter(i -> name.equals(i.getName())).findFirst().orElse(null);
if (res == null) {
return delNotExist ? null : name;
}
return res.getId();
}).filter(Objects::nonNull).collect(Collectors.toList());
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysUserRoleServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysUserRoleServiceImpl.java | package org.jeecg.modules.system.service.impl;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import org.jeecg.modules.system.entity.SysRole;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.entity.SysUserRole;
import org.jeecg.modules.system.mapper.SysUserRoleMapper;
import org.jeecg.modules.system.service.ISysRoleService;
import org.jeecg.modules.system.service.ISysUserRoleService;
import org.jeecg.modules.system.service.ISysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
/**
* <p>
* 用户角色表 服务实现类
* </p>
*
* @Author scott
* @since 2018-12-21
*/
@Service
public class SysUserRoleServiceImpl extends ServiceImpl<SysUserRoleMapper, SysUserRole> implements ISysUserRoleService {
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/ThirdAppDingtalkServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/ThirdAppDingtalkServiceImpl.java | package org.jeecg.modules.system.service.impl;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.jeecg.dingtalk.api.base.JdtBaseAPI;
import com.jeecg.dingtalk.api.core.response.Response;
import com.jeecg.dingtalk.api.core.util.HttpUtil;
import com.jeecg.dingtalk.api.core.vo.AccessToken;
import com.jeecg.dingtalk.api.core.vo.PageResult;
import com.jeecg.dingtalk.api.department.JdtDepartmentAPI;
import com.jeecg.dingtalk.api.department.vo.Department;
import com.jeecg.dingtalk.api.message.JdtMessageAPI;
import com.jeecg.dingtalk.api.message.vo.ActionCardMessage;
import com.jeecg.dingtalk.api.message.vo.MarkdownMessage;
import com.jeecg.dingtalk.api.message.vo.Message;
import com.jeecg.dingtalk.api.message.vo.TextMessage;
import com.jeecg.dingtalk.api.oauth2.JdtOauth2API;
import com.jeecg.dingtalk.api.oauth2.vo.ContactUser;
import com.jeecg.dingtalk.api.user.JdtUserAPI;
import com.jeecg.dingtalk.api.user.body.GetUserListBody;
import com.jeecg.dingtalk.api.user.vo.User;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.jeecg.common.api.dto.message.MessageDTO;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.constant.enums.MessageTypeEnum;
import org.jeecg.common.exception.JeecgBootBizTipException;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.util.*;
import org.jeecg.config.JeecgBaseConfig;
import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
import org.jeecg.modules.system.entity.*;
import org.jeecg.modules.system.mapper.*;
import org.jeecg.modules.system.model.SysDepartTreeModel;
import org.jeecg.modules.system.model.ThirdLoginModel;
import org.jeecg.modules.system.service.*;
import org.jeecg.modules.system.vo.thirdapp.JdtDepartmentTreeVo;
import org.jeecg.modules.system.vo.thirdapp.SyncInfoVo;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.stream.Collectors;
/**
* 第三方App对接：钉钉实现类
* @author: jeecg-boot
*/
@Slf4j
@Service
public class ThirdAppDingtalkServiceImpl implements IThirdAppService {
@Autowired
JeecgBaseConfig jeecgBaseConfig;
@Autowired
private ISysDepartService sysDepartService;
@Autowired
private SysUserMapper userMapper;
@Autowired
private ISysThirdAccountService sysThirdAccountService;
@Autowired
private ISysUserDepartService sysUserDepartService;
@Autowired
private ISysPositionService sysPositionService;
@Autowired
private SysAnnouncementSendMapper sysAnnouncementSendMapper;
@Autowired
private SysThirdAppConfigMapper configMapper;
@Autowired
private SysUserTenantMapper userTenantMapper;
@Autowired
private SysTenantMapper tenantMapper;
/**
* 第三方APP类型，当前固定为 dingtalk
*/
public final String THIRD_TYPE = "dingtalk";
@Override
public String getAccessToken() {
// 代码逻辑说明: [QQYUN-3440]新建企业微信和钉钉配置表，通过租户模式隔离------------
SysThirdAppConfig config = getDingThirdAppConfig();
if(null != config){
return getTenantAccessToken(config);
}
log.warn("租户下未配置钉钉");
return null;
}
// update：2022-1-21，updateBy：sunjianlei; for 【JTC-704】【钉钉】部门同步成功，实际没成，后台提示ip白名单
@Override
public SyncInfoVo syncLocalDepartmentToThirdApp(String ids) {
SyncInfoVo syncInfo = new SyncInfoVo();
String accessToken = this.getAccessToken();
if (accessToken == null) {
syncInfo.addFailInfo("accessToken获取失败！");
return syncInfo;
}
// 获取【钉钉】所有的部门
List<Response<Department>> departments = JdtDepartmentAPI.listAllResponse(accessToken);
// 删除钉钉有但本地没有的部门（以本地部门数据为主）（钉钉不能创建同名部门，只能先删除）
List<SysDepart> sysDepartList = sysDepartService.list();
for1:
for (Response<Department> departmentRes : departments) {
// 判断部门是否查询成功
if (!departmentRes.isSuccess()) {
syncInfo.addFailInfo(departmentRes.getErrmsg());
// 88 是 ip 不在白名单的错误码，如果遇到此错误码，后面的操作都可以不用进行了，因为肯定都是失败的
if (new Integer(88).equals(departmentRes.getErrcode())) {
return syncInfo;
}
continue;
}
Department department = departmentRes.getResult();
for (SysDepart depart : sysDepartList) {
// id相同，代表已存在，不删除
String sourceIdentifier = department.getSource_identifier();
if (sourceIdentifier != null && sourceIdentifier.equals(depart.getId())) {
continue for1;
}
}
// 循环到此说明本地没有，删除
int deptId = department.getDept_id();
// 钉钉不允许删除带有用户的部门，所以需要判断下，将有用户的部门的用户移动至根部门
Response<List<String>> userIdRes = JdtUserAPI.getUserListIdByDeptId(deptId, accessToken);
if (userIdRes.isSuccess() && userIdRes.getResult().size() > 0) {
for (String userId : userIdRes.getResult()) {
User updateUser = new User();
updateUser.setUserid(userId);
updateUser.setDept_id_list(1);
JdtUserAPI.update(updateUser, accessToken);
}
}
JdtDepartmentAPI.delete(deptId, accessToken);
}
// 获取本地所有部门树结构
List<SysDepartTreeModel> sysDepartsTree = sysDepartService.queryTreeList();
// -- 钉钉不能创建新的顶级部门，所以新的顶级部门的parentId就为1
Department parent = new Department();
parent.setDept_id(1);
// 递归同步部门
departments = JdtDepartmentAPI.listAllResponse(accessToken);
this.syncDepartmentRecursion(sysDepartsTree, departments, parent, accessToken, syncInfo);
return syncInfo;
}
/**
* 递归同步部门到本地
* @param sysDepartsTree
* @param departments
* @param parent
* @param accessToken
* @param syncInfo
*/
public void syncDepartmentRecursion(List<SysDepartTreeModel> sysDepartsTree, List<Response<Department>> departments, Department parent, String accessToken, SyncInfoVo syncInfo) {
if (sysDepartsTree != null && sysDepartsTree.size() != 0) {
for1:
for (SysDepartTreeModel depart : sysDepartsTree) {
for (Response<Department> departmentRes : departments) {
// 判断部门是否查询成功
if (!departmentRes.isSuccess()) {
syncInfo.addFailInfo(departmentRes.getErrmsg());
continue;
}
Department department = departmentRes.getResult();
// id相同，代表已存在，执行修改操作
String sourceIdentifier = department.getSource_identifier();
if (sourceIdentifier != null && sourceIdentifier.equals(depart.getId())) {
this.sysDepartToDtDepartment(depart, department, parent.getDept_id());
Response<JSONObject> response = JdtDepartmentAPI.update(department, accessToken);
if (response.isSuccess()) {
// 紧接着同步子级
this.syncDepartmentRecursion(depart.getChildren(), departments, department, accessToken, syncInfo);
}
// 收集错误信息
this.syncDepartCollectErrInfo(response, depart, syncInfo);
// 跳出外部循环
continue for1;
}
}
// 循环到此说明是新部门，直接调接口创建
Department newDepartment = this.sysDepartToDtDepartment(depart, parent.getDept_id());
Response<Integer> response = JdtDepartmentAPI.create(newDepartment, accessToken);
// 创建成功，将返回的id绑定到本地
if (response.getResult() != null) {
Department newParent = new Department();
newParent.setDept_id(response.getResult());
// 紧接着同步子级
this.syncDepartmentRecursion(depart.getChildren(), departments, newParent, accessToken, syncInfo);
}
// 收集错误信息
this.syncDepartCollectErrInfo(response, depart, syncInfo);
}
}
}
// @Override
// public SyncInfoVo syncThirdAppDepartmentToLocal(String ids) {
// SyncInfoVo syncInfo = new SyncInfoVo();
// String accessToken = this.getAccessToken();
// if (accessToken == null) {
// syncInfo.addFailInfo("accessToken获取失败！");
// return syncInfo;
// }
// // 获取【钉钉】所有的部门
// List<Department> departments = JdtDepartmentAPI.listAll(accessToken);
// String username = JwtUtil.getUserNameByToken(SpringContextUtils.getHttpServletRequest());
// List<JdtDepartmentTreeVo> departmentTreeList = JdtDepartmentTreeVo.listToTree(departments);
// // 递归同步部门
// this.syncDepartmentToLocalRecursion(departmentTreeList, null, username, syncInfo, accessToken,false);
// return syncInfo;
// }
public void syncDepartmentToLocalRecursion(List<JdtDepartmentTreeVo> departmentTreeList, String sysParentId, String username, SyncInfoVo syncInfo, String accessToken,Boolean syncUser,Integer tenantId) {
if (departmentTreeList != null && departmentTreeList.size() != 0) {
// 记录已经同步过的用户id，当有多个部门的情况时，只同步一次
Set<String> syncedUserIdSet = new HashSet<>();
for (JdtDepartmentTreeVo departmentTree : departmentTreeList) {
LambdaQueryWrapper<SysDepart> queryWrapper = new LambdaQueryWrapper<>();
// 根据 source_identifier 字段查询
// 代码逻辑说明: 【issues/6017】钉钉同步部门时没有最顶层的部门名，同步用户时，用户没有部门信息---
queryWrapper.and(item -> item.eq(SysDepart::getId, departmentTree.getSource_identifier()).or().eq(SysDepart::getDingIdentifier,departmentTree.getDept_id()));
SysDepart sysDepart = sysDepartService.getOne(queryWrapper);
if (sysDepart != null) {
// 执行更新操作
SysDepart updateSysDepart = this.dtDepartmentToSysDepart(departmentTree, sysDepart);
if (sysParentId != null) {
updateSysDepart.setParentId(sysParentId);
//更新父级部门不是叶子结点
sysDepartService.updateIzLeaf(sysParentId,CommonConstant.NOT_LEAF);
}
try {
sysDepartService.updateDepartDataById(updateSysDepart, username);
String str = String.format("部门 %s 更新成功！", updateSysDepart.getDepartName());
syncInfo.addSuccessInfo(str);
} catch (Exception e) {
this.syncDepartCollectErrInfo(e, departmentTree, syncInfo);
}
if (departmentTree.hasChildren()) {
// 紧接着同步子级
this.syncDepartmentToLocalRecursion(departmentTree.getChildren(), updateSysDepart.getId(), username, syncInfo, accessToken,syncUser,tenantId);
}
//判断是否需要同步用户
if(syncUser){
this.addDepartUser(updateSysDepart.getId(),departmentTree.getDept_id(), accessToken, syncInfo, syncedUserIdSet,tenantId);
}
} else {
// 执行新增操作
SysDepart newSysDepart = this.dtDepartmentToSysDepart(departmentTree, null);
if (sysParentId != null) {
newSysDepart.setParentId(sysParentId);
// 2 = 组织机构
newSysDepart.setOrgCategory("2");
} else {
// 1 = 公司
newSysDepart.setOrgCategory("1");
}
try {
if(oConvertUtils.isEmpty(departmentTree.getParent_id())){
newSysDepart.setDingIdentifier(departmentTree.getDept_id().toString());
}
newSysDepart.setTenantId(tenantId);
sysDepartService.saveDepartData(newSysDepart, username);
// 更新钉钉 source_identifier
Department updateDtDepart = new Department();
updateDtDepart.setDept_id(departmentTree.getDept_id());
updateDtDepart.setSource_identifier(newSysDepart.getId());
//为空说明是最顶级部门，最顶级部门不允许修改操作
if(oConvertUtils.isNotEmpty(newSysDepart.getParentId())){
Response response = JdtDepartmentAPI.update(updateDtDepart, accessToken);
if (!response.isSuccess()) {
throw new RuntimeException(response.getErrmsg());
}
}
String str = String.format("部门 %s 创建成功！", newSysDepart.getDepartName());
syncInfo.addSuccessInfo(str);
//判断是否需要同步用户
if(syncUser){
this.addDepartUser(newSysDepart.getId(),departmentTree.getDept_id(), accessToken, syncInfo, syncedUserIdSet,tenantId);
}
} catch (Exception e) {
this.syncDepartCollectErrInfo(e, departmentTree, syncInfo);
}
// 紧接着同步子级
if (departmentTree.hasChildren()) {
this.syncDepartmentToLocalRecursion(departmentTree.getChildren(), newSysDepart.getId(), username, syncInfo, accessToken,syncUser,tenantId);
}
}
}
}
}
private boolean syncDepartCollectErrInfo(Exception e, Department department, SyncInfoVo syncInfo) {
String msg;
if (e instanceof DuplicateKeyException) {
msg = e.getCause().getMessage();
} else {
msg = e.getMessage();
}
String str = String.format("部门 %s(%s) 同步失败！错误信息：%s", department.getName(), department.getDept_id(), msg);
syncInfo.addFailInfo(str);
return false;
}
/**
* 【同步部门】收集同步过程中的错误信息
*/
private boolean syncDepartCollectErrInfo(Response<?> response, SysDepartTreeModel depart, SyncInfoVo syncInfo) {
if (!response.isSuccess()) {
String str = String.format("部门 %s(%s) 同步失败！错误码：%s——%s", depart.getDepartName(), depart.getOrgCode(), response.getErrcode(), response.getErrmsg());
syncInfo.addFailInfo(str);
return false;
} else {
String str = String.format("部门户 %s(%s) 同步成功！", depart.getDepartName(), depart.getOrgCode());
syncInfo.addSuccessInfo(str);
return true;
}
}
@Override
public SyncInfoVo syncLocalUserToThirdApp(String ids) {
SyncInfoVo syncInfo = new SyncInfoVo();
String accessToken = this.getAccessToken();
if (accessToken == null) {
syncInfo.addFailInfo("accessToken获取失败！");
return syncInfo;
}
List<SysUser> sysUsers;
if (StringUtils.isNotBlank(ids)) {
String[] idList = ids.split(",");
LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.in(SysUser::getId, (Object[]) idList);
// 获取本地指定用户
sysUsers = userMapper.selectList(queryWrapper);
} else {
// 获取本地所有用户
sysUsers = userMapper.selectList(Wrappers.emptyWrapper());
}
// 查询钉钉所有的部门，用于同步用户和部门的关系
List<Department> allDepartment = JdtDepartmentAPI.listAll(accessToken);
for (SysUser sysUser : sysUsers) {
// 外部模拟登陆临时账号，不同步
if ("_reserve_user_external".equals(sysUser.getUsername())) {
continue;
}
// 钉钉用户信息，不为null代表已同步过
Response<User> dtUserInfo;
/*
* 判断是否同步过的逻辑：
* 1. 查询 sys_third_account（第三方账号表）是否有数据，如果有代表已同步
* 2. 本地表里没有，就先用手机号判断，不通过再用username(用户账号)判断。
*/
SysThirdAccount sysThirdAccount = sysThirdAccountService.getOneBySysUserId(sysUser.getId(), THIRD_TYPE);
if (sysThirdAccount != null && oConvertUtils.isNotEmpty(sysThirdAccount.getThirdUserId())) {
// sys_third_account 表匹配成功，通过第三方userId查询出第三方userInfo
dtUserInfo = JdtUserAPI.getUserById(sysThirdAccount.getThirdUserId(), accessToken);
} else {
// 手机号匹配
Response<String> thirdUserId = JdtUserAPI.getUseridByMobile(sysUser.getPhone(), accessToken);
// 手机号匹配成功
if (thirdUserId.isSuccess() && oConvertUtils.isNotEmpty(thirdUserId.getResult())) {
// 通过查询到的userId查询用户详情
dtUserInfo = JdtUserAPI.getUserById(thirdUserId.getResult(), accessToken);
} else {
// 手机号匹配失败，尝试使用username匹配
dtUserInfo = JdtUserAPI.getUserById(sysUser.getUsername(), accessToken);
}
}
String dtUserId;
// api 接口是否执行成功
boolean apiSuccess;
// 已同步就更新，否则就创建
if (dtUserInfo != null && dtUserInfo.isSuccess() && dtUserInfo.getResult() != null) {
User dtUser = dtUserInfo.getResult();
dtUserId = dtUser.getUserid();
User updateQwUser = this.sysUserToDtUser(sysUser, dtUser, allDepartment);
Response<JSONObject> updateRes = JdtUserAPI.update(updateQwUser, accessToken);
// 收集成功/失败信息
apiSuccess = this.syncUserCollectErrInfo(updateRes, sysUser, syncInfo);
} else {
User newQwUser = this.sysUserToDtUser(sysUser, allDepartment);
Response<String> createRes = JdtUserAPI.create(newQwUser, accessToken);
dtUserId = createRes.getResult();
// 收集成功/失败信息
apiSuccess = this.syncUserCollectErrInfo(createRes, sysUser, syncInfo);
}
// api 接口执行成功，并且 sys_third_account 表匹配失败，就向 sys_third_account 里插入一条数据
boolean flag = (sysThirdAccount == null || oConvertUtils.isEmpty(sysThirdAccount.getThirdUserId()));
if (apiSuccess && flag) {
if (sysThirdAccount == null) {
sysThirdAccount = new SysThirdAccount();
sysThirdAccount.setSysUserId(sysUser.getId());
sysThirdAccount.setStatus(1);
sysThirdAccount.setDelFlag(0);
sysThirdAccount.setThirdType(THIRD_TYPE);
}
// 设置第三方app用户ID
sysThirdAccount.setThirdUserId(dtUserId);
sysThirdAccountService.saveOrUpdate(sysThirdAccount);
}
}
return syncInfo;
}
// @Override
// public SyncInfoVo syncThirdAppUserToLocal() {
// SyncInfoVo syncInfo = new SyncInfoVo();
// String accessToken = this.getAccessToken();
// if (accessToken == null) {
// syncInfo.addFailInfo("accessToken获取失败！");
// return syncInfo;
// }
//
// // 获取本地用户
// List<SysUser> sysUsersList = userMapper.selectList(Wrappers.emptyWrapper());
//
// // 查询钉钉所有的部门，用于同步用户和部门的关系
// List<Department> allDepartment = JdtDepartmentAPI.listAll(accessToken);
// // 根据钉钉部门查询所有钉钉用户，用于反向同步到本地
// List<User> ddUserList = this.getDtAllUserByDepartment(allDepartment, accessToken);
// // 记录已经同步过的用户id，当有多个部门的情况时，只同步一次
// Set<String> syncedUserIdSet = new HashSet<>();
//
// for (User dtUserInfo : ddUserList) {
// if (syncedUserIdSet.contains(dtUserInfo.getUserid())) {
// continue;
// }
// syncedUserIdSet.add(dtUserInfo.getUserid());
// SysThirdAccount sysThirdAccount = sysThirdAccountService.getOneByThirdUserId(dtUserInfo.getUserid(), THIRD_TYPE);
// List<SysUser> collect = sysUsersList.stream().filter(user -> (dtUserInfo.getMobile().equals(user.getPhone()) || dtUserInfo.getUserid().equals(user.getUsername()))
// ).collect(Collectors.toList());
// if (collect != null && collect.size() > 0) {
// SysUser sysUserTemp = collect.get(0);
// // 循环到此说明用户匹配成功，进行更新操作
// SysUser updateSysUser = this.dtUserToSysUser(dtUserInfo, sysUserTemp);
// try {
// userMapper.updateById(updateSysUser);
// String str = String.format("用户 %s(%s) 更新成功！", updateSysUser.getRealname(), updateSysUser.getUsername());
// syncInfo.addSuccessInfo(str);
// } catch (Exception e) {
// this.syncUserCollectErrInfo(e, dtUserInfo, syncInfo);
// }
// //第三方账号关系表
// this.thirdAccountSaveOrUpdate(sysThirdAccount, updateSysUser.getId(), dtUserInfo.getUserid());
// }else{
// // 如果没有匹配到用户，则走创建逻辑
// SysUser newSysUser = this.dtUserToSysUser(dtUserInfo);
// try {
// userMapper.insert(newSysUser);
// String str = String.format("用户 %s(%s) 创建成功！", newSysUser.getRealname(), newSysUser.getUsername());
// syncInfo.addSuccessInfo(str);
// } catch (Exception e) {
// this.syncUserCollectErrInfo(e, dtUserInfo, syncInfo);
// }
// //第三方账号关系表
// this.thirdAccountSaveOrUpdate(null, newSysUser.getId(), dtUserInfo.getUserid());
// }
// }
// return syncInfo;
// }
// private List<User> getDtAllUserByDepartment(List<Department> allDepartment, String accessToken) {
// // 根据钉钉部门查询所有钉钉用户，用于反向同步到本地
// List<User> userList = new ArrayList<>();
// for (Department department : allDepartment) {
// this.getUserListByDeptIdRecursion(department.getDept_id(), 0, userList, accessToken);
// }
// return userList;
// }
/**
* 递归查询所有用户
*/
private void getUserListByDeptIdRecursion(int deptId, int cursor, List<User> userList, String accessToken) {
// 根据钉钉部门查询所有钉钉用户，用于反向同步到本地
GetUserListBody getUserListBody = new GetUserListBody(deptId, cursor, 100);
Response<PageResult<User>> response = JdtUserAPI.getUserListByDeptId(getUserListBody, accessToken);
if (response.isSuccess()) {
PageResult<User> page = response.getResult();
userList.addAll(page.getList());
if (page.getHas_more()) {
this.getUserListByDeptIdRecursion(deptId, page.getNext_cursor(), userList, accessToken);
}
}
}
/**
* 保存或修改第三方登录表
*
* @param sysThirdAccount 第三方账户表对象，为null就新增数据，否则就修改
* @param sysUserId 本地系统用户ID
* @param user 钉钉用户
*/
private void thirdAccountSaveOrUpdate(SysThirdAccount sysThirdAccount, String sysUserId, User user, Integer tenantId) {
if (sysThirdAccount == null) {
sysThirdAccount = new SysThirdAccount();
sysThirdAccount.setSysUserId(sysUserId);
sysThirdAccount.setThirdUserUuid(user.getUnionid());
sysThirdAccount.setStatus(1);
sysThirdAccount.setTenantId(tenantId);
sysThirdAccount.setDelFlag(0);
sysThirdAccount.setThirdType(THIRD_TYPE);
}
sysThirdAccount.setThirdUserId(user.getUserid());
if(oConvertUtils.isEmpty(sysThirdAccount.getRealname())){
sysThirdAccount.setRealname(user.getName());
}
sysThirdAccountService.saveOrUpdate(sysThirdAccount);
}
/**
* 【同步用户】收集同步过程中的错误信息
*/
private boolean syncUserCollectErrInfo(Response<?> response, SysUser sysUser, SyncInfoVo syncInfo) {
if (!response.isSuccess()) {
String str = String.format("用户 %s(%s) 同步失败！错误码：%s——%s", sysUser.getUsername(), sysUser.getRealname(), response.getErrcode(), response.getErrmsg());
syncInfo.addFailInfo(str);
return false;
} else {
String str = String.format("用户 %s(%s) 同步成功！", sysUser.getUsername(), sysUser.getRealname());
syncInfo.addSuccessInfo(str);
return true;
}
}
/**
* 【同步用户】收集同步过程中的错误信息
*/
private boolean syncUserCollectErrInfo(Exception e, User dtUser, SyncInfoVo syncInfo) {
String msg;
if (e instanceof DuplicateKeyException) {
msg = e.getCause().getMessage();
String emailUniq = "uniq_sys_user_email";
if(msg.contains(emailUniq)){
msg = "邮箱重复，请更换邮箱";
}
String workNoUniq="uniq_sys_user_work_no";
if(msg.contains(workNoUniq)){
msg = "工号重复，请更换工号";
}
} else {
msg = e.getMessage();
}
String str = String.format("用户 %s(%s) 同步失败！错误信息：%s", dtUser.getUserid(), dtUser.getName(), msg);
syncInfo.addFailInfo(str);
return false;
}
/**
* 【同步用户】将SysUser转为【钉钉】的User对象（创建新用户）
*/
private User sysUserToDtUser(SysUser sysUser, List<Department> allDepartment) {
User user = new User();
// 通过 username 来关联
user.setUserid(sysUser.getUsername());
return this.sysUserToDtUser(sysUser, user, allDepartment);
}
/**
* 【同步用户】将SysUser转为【钉钉】的User对象（更新旧用户）
*/
private User sysUserToDtUser(SysUser sysUser, User user, List<Department> allDepartment) {
user.setName(sysUser.getRealname());
user.setMobile(sysUser.getPhone());
user.setTelephone(sysUser.getTelephone());
user.setJob_number(sysUser.getWorkNo());
// 职务翻译
//获取用户职位名称
List<SysPosition> positionList = sysPositionService.getPositionList(sysUser.getId());
if(null != positionList && positionList.size()>0){
String positionName = positionList.stream().map(SysPosition::getName).collect(Collectors.joining(SymbolConstant.COMMA));
user.setTitle(positionName);
}
user.setEmail(sysUser.getEmail());
// 查询并同步用户部门关系
List<SysDepart> departList = this.getUserDepart(sysUser);
if (departList != null) {
List<Integer> departmentIdList = new ArrayList<>();
for (SysDepart sysDepart : departList) {
// 企业微信的部门id
Department department = this.getDepartmentByDepartId(sysDepart.getId(), allDepartment);
if (department != null) {
departmentIdList.add(department.getDept_id());
}
}
user.setDept_id_list(departmentIdList.toArray(new Integer[]{}));
user.setDept_order_list(null);
}
if (oConvertUtils.isEmpty(user.getDept_id_list())) {
// 没有找到匹配部门，同步到根部门下
user.setDept_id_list(1);
user.setDept_order_list(null);
}
// --- 钉钉没有逻辑删除功能
// sysUser.getDelFlag()
// --- 钉钉没有冻结、启用禁用功能
// sysUser.getStatus()
return user;
}
/**
* 【同步用户】将【钉钉】的User对象转为SysUser（创建新用户）
*/
private SysUser dtUserToSysUser(User dtUser) {
SysUser sysUser = new SysUser();
sysUser.setDelFlag(0);
// 通过 username 来关联
sysUser.setUsername(dtUser.getMobile());
// 密码默认为为手机号加门牌号，随机加盐
String password = "", salt = oConvertUtils.randomGen(8);
int tenantId = oConvertUtils.getInt(TenantContext.getTenant(), 0);
if(tenantId>0){
SysTenant tenant = tenantMapper.selectById(tenantId);
password = tenant.getHouseNumber()+dtUser.getMobile();
}else{
password = dtUser.getMobile();
}
String passwordEncode = PasswordUtil.encrypt(sysUser.getUsername(), password, salt);
sysUser.setSalt(salt);
sysUser.setPassword(passwordEncode);
// 代码逻辑说明: 钉钉同步到本地的人员没有状态，导致同步之后无法登录 #I3ZC2L
sysUser.setStatus(1);
sysUser.setLastPwdUpdateTime(new Date());
return this.dtUserToSysUser(dtUser, sysUser);
}
/**
* 【同步用户】将【钉钉】的User对象转为SysUser（更新旧用户）
*/
private SysUser dtUserToSysUser(User dtUser, SysUser oldSysUser) {
SysUser sysUser = new SysUser();
BeanUtils.copyProperties(oldSysUser, sysUser);
sysUser.setTelephone(dtUser.getTelephone());
//如果真实姓名为空的情况下，才会改真实姓名
if(oConvertUtils.isEmpty(oldSysUser.getRealname())){
sysUser.setRealname(dtUser.getName());
}
// 因为唯一键约束的原因，如果原数据和旧数据相同，就不更新
if (oConvertUtils.isNotEmpty(dtUser.getEmail()) && !dtUser.getEmail().equals(sysUser.getEmail())) {
sysUser.setEmail(dtUser.getEmail());
} else {
sysUser.setEmail(null);
}
// 因为唯一键约束的原因，如果原数据和旧数据相同，就不更新
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | true |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysCommentServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysCommentServiceImpl.java | package org.jeecg.modules.system.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.jeecg.common.api.dto.message.MessageDTO;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.constant.enums.FileTypeEnum;
import org.jeecg.common.constant.enums.MessageTypeEnum;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.common.system.vo.SysFilesModel;
import org.jeecg.common.util.CommonUtils;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.common.util.filter.SsrfFileTypeFilter;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysComment;
import org.jeecg.modules.system.entity.SysFormFile;
import org.jeecg.modules.system.mapper.SysCommentMapper;
import org.jeecg.modules.system.mapper.SysFormFileMapper;
import org.jeecg.modules.system.service.ISysCommentService;
import org.jeecg.modules.system.vo.SysCommentFileVo;
import org.jeecg.modules.system.vo.SysCommentVO;
import org.jeecg.modules.system.vo.UserAvatar;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import jakarta.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @Description: 系统评论回复表
* @Author: jeecg-boot
* @Date: 2022-07-19
* @Version: V1.0
*/
@Service
public class SysCommentServiceImpl extends ServiceImpl<SysCommentMapper, SysComment> implements ISysCommentService {
@Autowired
private ISysBaseAPI sysBaseApi;
@Autowired
private SysFormFileMapper sysFormFileMapper;
// @Autowired
// private IEasyOaBaseApi easyOaBseApi;
@Autowired
private RedisUtil redisUtil;
@Value(value = "${jeecg.path.upload}")
private String uploadpath;
@Value(value = "${jeecg.uploadType}")
private String uploadType;
/**
* sysFormFile中的表名
*/
private static final String SYS_FORM_FILE_TABLE_NAME = "sys_comment";
@Override
public List<SysCommentVO> queryFormCommentInfo(SysComment sysComment) {
String tableName = sysComment.getTableName();
String dataId = sysComment.getTableDataId();
//获取评论信息
List<SysCommentVO> list = this.baseMapper.queryCommentList(tableName, dataId);
// 获取评论相关人员
Set<String> personSet = new HashSet<>();
if(list!=null && list.size()>0){
for(SysCommentVO vo: list){
if(oConvertUtils.isNotEmpty(vo.getFromUserId())){
personSet.add(vo.getFromUserId());
}
if(oConvertUtils.isNotEmpty(vo.getToUserId())){
personSet.add(vo.getToUserId());
}
}
}
if(personSet.size()>0){
//获取用户信息
Map<String, UserAvatar> userAvatarMap = queryUserAvatar(personSet);
for(SysCommentVO vo: list){
String formId = vo.getFromUserId();
String toId = vo.getToUserId();
// 设置头像、用户名
if(oConvertUtils.isNotEmpty(formId)){
UserAvatar fromUser = userAvatarMap.get(formId);
if(fromUser!=null){
vo.setFromUserId_dictText(fromUser.getRealname());
vo.setFromUserAvatar(fromUser.getAvatar());
}
}
if(oConvertUtils.isNotEmpty(toId)){
UserAvatar toUser = userAvatarMap.get(toId);
if(toUser!=null){
vo.setToUserId_dictText(toUser.getRealname());
vo.setToUserAvatar(toUser.getAvatar());
}
}
}
}
return list;
}
@Transactional(rollbackFor = Exception.class)
@Override
public void saveOneFileComment(HttpServletRequest request) {
String existFileId = request.getParameter("fileId");
if(oConvertUtils.isEmpty(existFileId)){
String savePath = "";
// 获取业务路径
String bizPath = request.getParameter("biz");
// 获取上传文件对象
MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
MultipartFile file = multipartRequest.getFile("file");
// 文件安全校验，防止上传漏洞文件
try {
SsrfFileTypeFilter.checkUploadFileType(file, bizPath);
} catch (Exception e) {
throw new JeecgBootException(e);
}
if (oConvertUtils.isEmpty(bizPath)) {
bizPath = CommonConstant.UPLOAD_TYPE_OSS.equals(uploadType) ? "upload" : "";
}
if (CommonConstant.UPLOAD_TYPE_LOCAL.equals(uploadType)) {
savePath = this.uploadLocal(file, bizPath);
} else {
savePath = CommonUtils.upload(file, bizPath, uploadType);
}
String orgName = file.getOriginalFilename();
// 获取文件名
orgName = CommonUtils.getFileName(orgName);
//文件大小
long size = file.getSize();
//文件类型
String type = orgName.substring(orgName.lastIndexOf("."), orgName.length());
FileTypeEnum fileType = FileTypeEnum.getByType(type);
//保存至 SysFiles
SysFilesModel sysFiles = new SysFilesModel();
sysFiles.setFileName(orgName);
sysFiles.setUrl(savePath);
sysFiles.setFileType(fileType.getValue());
sysFiles.setStoreType("temp");
if (size > 0) {
sysFiles.setFileSize(Double.parseDouble(String.valueOf(size)));
}
String fileId = String.valueOf(IdWorker.getId());
sysFiles.setId(fileId);
String tenantId = oConvertUtils.getString(TenantContext.getTenant());
sysFiles.setTenantId(tenantId);
// //update-begin---author:wangshuai---date:2024-01-04---for:【QQYUN-7821】知识库后端迁移---
// easyOaBseApi.addSysFiles(sysFiles);
// //update-end---author:wangshuai---date:2024-01-04---for:【QQYUN-7821】知识库后端迁移---
//保存至 SysFormFile
String tableName = SYS_FORM_FILE_TABLE_NAME;
String tableDataId = request.getParameter("commentId");
SysFormFile sysFormFile = new SysFormFile();
sysFormFile.setTableName(tableName);
sysFormFile.setFileType(fileType.getValue());
sysFormFile.setTableDataId(tableDataId);
sysFormFile.setFileId(fileId);
sysFormFileMapper.insert(sysFormFile);
}else{
// //update-begin---author:wangshuai---date:2024-01-04---for:【QQYUN-7821】知识库后端迁移---
// SysFilesModel sysFiles = easyOaBseApi.getFileById(existFileId);
// //update-end---author:wangshuai---date:2024-01-04---for:【QQYUN-7821】知识库后端迁移---
// if(sysFiles!=null){
//保存至 SysFormFile
String tableName = SYS_FORM_FILE_TABLE_NAME;
String tableDataId = request.getParameter("commentId");
SysFormFile sysFormFile = new SysFormFile();
sysFormFile.setTableName(tableName);
sysFormFile.setFileType("");
sysFormFile.setTableDataId(tableDataId);
sysFormFile.setFileId(existFileId);
sysFormFileMapper.insert(sysFormFile);
// }
}
}
/**
* app端回复评论保存文件
* @param request
*/
@Transactional(rollbackFor = Exception.class)
@Override
public void appSaveOneFileComment(HttpServletRequest request) {
String orgName = request.getParameter("fileName");
String fileSize = request.getParameter("fileSize");
String savePath = request.getParameter("savePath");
// 获取文件名
orgName = CommonUtils.getFileName(orgName);
//文件大小
long size = Long.valueOf(fileSize);
//文件类型
String type = orgName.substring(orgName.lastIndexOf("."), orgName.length());
FileTypeEnum fileType = FileTypeEnum.getByType(type);
//保存至 SysFiles
SysFilesModel sysFiles = new SysFilesModel();
sysFiles.setFileName(orgName);
sysFiles.setUrl(savePath);
sysFiles.setFileType(fileType.getValue());
sysFiles.setStoreType("temp");
if (size > 0) {
sysFiles.setFileSize(Double.parseDouble(String.valueOf(size)));
}
String defaultValue = "0";
String fileId = String.valueOf(IdWorker.getId());
sysFiles.setId(fileId);
String tenantId = oConvertUtils.getString(TenantContext.getTenant());
sysFiles.setTenantId(tenantId);
// //update-begin---author:wangshuai---date:2024-01-04---for:【QQYUN-7821】知识库后端迁移---
// easyOaBseApi.addSysFiles(sysFiles);
// //update-end---author:wangshuai---date:2024-01-04---for:【QQYUN-7821】知识库后端迁移---
//保存至 SysFormFile
String tableName = SYS_FORM_FILE_TABLE_NAME;
String tableDataId = request.getParameter("commentId");
SysFormFile sysFormFile = new SysFormFile();
sysFormFile.setTableName(tableName);
sysFormFile.setFileType(fileType.getValue());
sysFormFile.setTableDataId(tableDataId);
sysFormFile.setFileId(fileId);
sysFormFileMapper.insert(sysFormFile);
}
@Override
public List<SysCommentFileVo> queryFormFileList(String tableName, String formDataId) {
List<SysCommentFileVo> list = baseMapper.queryFormFileList(tableName, formDataId);
return list;
}
@Override
public String saveOne(SysComment sysComment) {
this.save(sysComment);
//发送系统消息
String content = sysComment.getCommentContent();
if (content.indexOf("@") >= 0) {
Set<String> set = getCommentUsername(content);
if (set.size() > 0) {
String users = String.join(",", set);
MessageDTO md = new MessageDTO();
md.setTitle("有人在表单评论中提到了你");
md.setContent(content);
md.setToAll(false);
md.setToUser(users);
md.setFromUser("system");
md.setType(MessageTypeEnum.XT.getType());
// 代码逻辑说明: QQYUN-4744【系统通知】6、系统通知@人后，对方看不到是哪个表单@的，没有超链接
String tableName = sysComment.getTableName();
String prefix = "desform:";
if (tableName != null) {
// 表单设计器
if (tableName.startsWith(prefix)) {
Map<String, Object> data = new HashMap<>();
data.put(CommonConstant.NOTICE_MSG_BUS_TYPE, "comment");
JSONObject params = new JSONObject();
params.put("code", tableName.substring(prefix.length()));
params.put("dataId", sysComment.getTableDataId());
params.put("type", "designForm");
data.put(CommonConstant.NOTICE_MSG_SUMMARY, params);
md.setData(data);
}
// Online表单，判断是否携带id
else if (oConvertUtils.isNotEmpty(sysComment.getTableId())) {
Map<String, Object> data = new HashMap<>();
data.put(CommonConstant.NOTICE_MSG_BUS_TYPE, "comment");
JSONObject params = new JSONObject();
params.put("code", tableName);
params.put("formId", sysComment.getTableId());
params.put("dataId", sysComment.getTableDataId());
params.put("type", "cgform");
data.put(CommonConstant.NOTICE_MSG_SUMMARY, params);
md.setData(data);
}
}
sysBaseApi.sendTemplateMessage(md);
}
}
return sysComment.getId();
}
@Override
public void deleteOne(String id) {
this.removeById(id);
//还要删除关联文件
LambdaQueryWrapper<SysFormFile> query = new LambdaQueryWrapper<SysFormFile>()
.eq(SysFormFile::getTableDataId, id)
.eq(SysFormFile::getTableName, SYS_FORM_FILE_TABLE_NAME);
this.sysFormFileMapper.delete(query);
}
/**
* 通过正则获取评论中的用户账号
*
* @return
*/
private Set<String> getCommentUsername(String content) {
Set<String> set = new HashSet<String>(3);
String reg = "(@(.*?)\\[(.*?)\\])";
Pattern p = Pattern.compile(reg);
Matcher m = p.matcher(content);
while (m.find()) {
if (m.groupCount() == 3) {
String username = m.group(3);
set.add(username);
}
}
return set;
}
/**
* 本地文件上传
*
* @param mf 文件
* @param bizPath 自定义路径
* @return
*/
private String uploadLocal(MultipartFile mf, String bizPath) {
try {
// 文件安全校验，防止上传漏洞文件
SsrfFileTypeFilter.checkUploadFileType(mf, bizPath);
} catch (Exception e) {
throw new JeecgBootException(e);
}
try {
String ctxPath = uploadpath;
String fileName = null;
File file = new File(ctxPath + File.separator + bizPath + File.separator);
if (!file.exists()) {
file.mkdirs();// 创建文件根目录
}
String orgName = mf.getOriginalFilename();// 获取文件名
orgName = CommonUtils.getFileName(orgName);
if (orgName.indexOf(".") != -1) {
fileName = orgName.substring(0, orgName.lastIndexOf(".")) + "_" + System.currentTimeMillis() + orgName.substring(orgName.indexOf("."));
} else {
fileName = orgName + "_" + System.currentTimeMillis();
}
String savePath = file.getPath() + File.separator + fileName;
File savefile = new File(savePath);
FileCopyUtils.copy(mf.getBytes(), savefile);
String dbpath = null;
if (oConvertUtils.isNotEmpty(bizPath)) {
dbpath = bizPath + File.separator + fileName;
} else {
dbpath = fileName;
}
if (dbpath.contains("\\")) {
dbpath = dbpath.replace("\\", "/");
}
return dbpath;
} catch (IOException e) {
log.error(e.getMessage(), e);
}
return "";
}
/**
* 查询用户信息
* @param idSet
* @return
*/
private Map<String, UserAvatar> queryUserAvatar(Set<String> idSet){
List<UserAvatar> list = this.baseMapper.queryUserAvatarList(idSet);
Map<String, UserAvatar> map = new HashMap<>();
if(list!=null && list.size()>0){
for(UserAvatar user: list){
map.put(user.getId(), user);
}
}
return map;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysPermissionDataRuleImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysPermissionDataRuleImpl.java | package org.jeecg.modules.system.service.impl;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import jakarta.annotation.Resource;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysPermission;
import org.jeecg.modules.system.entity.SysPermissionDataRule;
import org.jeecg.modules.system.mapper.SysPermissionDataRuleMapper;
import org.jeecg.modules.system.mapper.SysPermissionMapper;
import org.jeecg.modules.system.service.ISysPermissionDataRuleService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
/**
* <p>
* 菜单权限规则 服务实现类
* </p>
*
* @Author huangzhilin
* @since 2019-04-01
*/
@Service
public class SysPermissionDataRuleImpl extends ServiceImpl<SysPermissionDataRuleMapper, SysPermissionDataRule>
implements ISysPermissionDataRuleService {
@Resource
private SysPermissionMapper sysPermissionMapper;
/**
* 根据菜单id查询其对应的权限数据
*/
@Override
public List<SysPermissionDataRule> getPermRuleListByPermId(String permissionId) {
LambdaQueryWrapper<SysPermissionDataRule> query = new LambdaQueryWrapper<SysPermissionDataRule>();
query.eq(SysPermissionDataRule::getPermissionId, permissionId);
query.orderByDesc(SysPermissionDataRule::getCreateTime);
List<SysPermissionDataRule> permRuleList = this.list(query);
return permRuleList;
}
/**
* 根据前端传递的权限名称和权限值参数来查询权限数据
*/
@Override
public List<SysPermissionDataRule> queryPermissionRule(SysPermissionDataRule permRule) {
QueryWrapper<SysPermissionDataRule> queryWrapper = QueryGenerator.initQueryWrapper(permRule, null);
return this.list(queryWrapper);
}
@Override
public List<SysPermissionDataRule> queryPermissionDataRules(String username,String permissionId) {
List<String> idsList = this.baseMapper.queryDataRuleIds(username, permissionId);
// 代码逻辑说明: 数据权限失效问题处理--------------------
if(idsList==null || idsList.size()==0) {
return null;
}
Set<String> set = new HashSet<String>();
for (String ids : idsList) {
if(oConvertUtils.isEmpty(ids)) {
continue;
}
String[] arr = ids.split(",");
for (String id : arr) {
if(oConvertUtils.isNotEmpty(id) && !set.contains(id)) {
set.add(id);
}
}
}
if(set.size()==0) {
return null;
}
return this.baseMapper.selectList(new QueryWrapper<SysPermissionDataRule>().in("id", set).eq("status",CommonConstant.STATUS_1));
}
@Override
@Transactional(rollbackFor = Exception.class)
public void savePermissionDataRule(SysPermissionDataRule sysPermissionDataRule) {
this.save(sysPermissionDataRule);
SysPermission permission = sysPermissionMapper.selectById(sysPermissionDataRule.getPermissionId());
boolean flag = permission != null && (permission.getRuleFlag() == null || permission.getRuleFlag().equals(CommonConstant.RULE_FLAG_0));
if(flag) {
permission.setRuleFlag(CommonConstant.RULE_FLAG_1);
sysPermissionMapper.updateById(permission);
}
}
@Override
@Transactional(rollbackFor = Exception.class)
public void deletePermissionDataRule(String dataRuleId) {
SysPermissionDataRule dataRule = this.baseMapper.selectById(dataRuleId);
if(dataRule!=null) {
this.removeById(dataRuleId);
Long count = this.baseMapper.selectCount(new LambdaQueryWrapper<SysPermissionDataRule>().eq(SysPermissionDataRule::getPermissionId, dataRule.getPermissionId()));
//注:同一个事务中删除后再查询是会认为数据已被删除的 若事务回滚上述删除无效
if(count==null || count==0) {
SysPermission permission = sysPermissionMapper.selectById(dataRule.getPermissionId());
if(permission!=null && permission.getRuleFlag().equals(CommonConstant.RULE_FLAG_1)) {
permission.setRuleFlag(CommonConstant.RULE_FLAG_0);
sysPermissionMapper.updateById(permission);
}
}
}
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysFormFileServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysFormFileServiceImpl.java | package org.jeecg.modules.system.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.jeecg.modules.system.entity.SysFormFile;
import org.jeecg.modules.system.mapper.SysFormFileMapper;
import org.jeecg.modules.system.service.ISysFormFileService;
import org.springframework.stereotype.Service;
/**
* @Description: 表单评论文件
* @Author: jeecg-boot
* @Date: 2022-07-21
* @Version: V1.0
*/
@Service
public class SysFormFileServiceImpl extends ServiceImpl<SysFormFileMapper, SysFormFile> implements ISysFormFileService {
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysRoleIndexServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysRoleIndexServiceImpl.java | package org.jeecg.modules.system.service.impl;
import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.constant.DefIndexConst;
import org.jeecg.modules.system.entity.SysRoleIndex;
import org.jeecg.modules.system.mapper.SysRoleIndexMapper;
import org.jeecg.modules.system.service.ISysRoleIndexService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.List;
/**
* @Description: 角色首页配置
* @Author: jeecg-boot
* @Date: 2022-03-25
* @Version: V1.0
*/
@Service("sysRoleIndexServiceImpl")
public class SysRoleIndexServiceImpl extends ServiceImpl<SysRoleIndexMapper, SysRoleIndex> implements ISysRoleIndexService {
@Autowired
private RedisUtil redisUtil;
@Override
@Cacheable(cacheNames = DefIndexConst.CACHE_KEY, key = "'" + DefIndexConst.DEF_INDEX_ALL + "'")
public SysRoleIndex queryDefaultIndex() {
LambdaQueryWrapper<SysRoleIndex> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SysRoleIndex::getRoleCode, DefIndexConst.DEF_INDEX_ALL);
queryWrapper.eq(SysRoleIndex::getStatus, CommonConstant.STATUS_1);
SysRoleIndex entity = super.getOne(queryWrapper);
// 保证不为空
if (entity == null) {
entity = this.initDefaultIndex();
}
return entity;
}
@Override
public boolean updateDefaultIndex(String url, String component, boolean isRoute) {
// 1. 先查询出配置信息
LambdaQueryWrapper<SysRoleIndex> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SysRoleIndex::getRoleCode, DefIndexConst.DEF_INDEX_ALL);
SysRoleIndex entity = super.getOne(queryWrapper);
boolean success = false;
// 2. 如果不存在则新增
if (entity == null) {
entity = this.newDefIndexConfig(url, component, isRoute);
success = super.save(entity);
} else {
// 3. 如果存在则更新
entity.setUrl(url);
entity.setComponent(component);
entity.setRoute(isRoute);
entity.setRelationType(CommonConstant.HOME_RELATION_DEFAULT);
success = super.updateById(entity);
}
// 4. 清理缓存
if (success) {
this.cleanDefaultIndexCache();
}
return success;
}
@Override
public SysRoleIndex initDefaultIndex() {
return this.newDefIndexConfig(DefIndexConst.DEF_INDEX_URL, DefIndexConst.DEF_INDEX_COMPONENT, true);
}
/**
* 创建默认首页配置
*
* @param indexComponent
* @return
*/
private SysRoleIndex newDefIndexConfig(String indexUrl, String indexComponent, boolean isRoute) {
SysRoleIndex entity = new SysRoleIndex();
entity.setRoleCode(DefIndexConst.DEF_INDEX_ALL);
entity.setUrl(indexUrl);
entity.setComponent(indexComponent);
entity.setRoute(isRoute);
entity.setStatus(CommonConstant.STATUS_1);
entity.setRelationType(CommonConstant.HOME_RELATION_DEFAULT);
return entity;
}
@Override
public void cleanDefaultIndexCache() {
redisUtil.del(DefIndexConst.CACHE_KEY + "::" + DefIndexConst.DEF_INDEX_ALL);
}
/**
* 切换默认门户
* @param sysRoleIndex
*/
@Override
public void changeDefHome(SysRoleIndex sysRoleIndex) {
// 1. 先查询出配置信息
String username = sysRoleIndex.getRoleCode();
//当前状态(1:工作台/门户 0：菜单默认)
String status = sysRoleIndex.getStatus();
LambdaQueryWrapper<SysRoleIndex> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SysRoleIndex::getRoleCode, username);
queryWrapper.eq(SysRoleIndex::getRelationType,CommonConstant.HOME_RELATION_USER);
queryWrapper.orderByAsc(SysRoleIndex::getPriority);
List<SysRoleIndex> list = super.list(queryWrapper);
boolean success = false;
if(CommonConstant.STATUS_1.equalsIgnoreCase(status)){
// 2. 如果存在则编辑
if (!CollectionUtils.isEmpty(list)) {
sysRoleIndex.setId(list.get(0).getId());
sysRoleIndex.setStatus(CommonConstant.STATUS_1);
sysRoleIndex.setRoute(true);
success = super.updateById(sysRoleIndex);
} else {
// 3. 如果不存在则新增
sysRoleIndex.setRelationType(CommonConstant.HOME_RELATION_USER);
sysRoleIndex.setStatus(CommonConstant.STATUS_1);
sysRoleIndex.setRoute(true);
success = super.save(sysRoleIndex);
}
}else {
// 0：菜单默认，则是菜单默认首页
if (!CollectionUtils.isEmpty(list)) {
//将用户级别的首页配置状态设置成0
for (int i = 0; i < list.size(); i++) {
SysRoleIndex roleIndex = list.get(i);
roleIndex.setStatus(CommonConstant.STATUS_0);
success = super.updateById(roleIndex);
}
}
}
// 4. 清理缓存
if (success) {
this.cleanDefaultIndexCache();
redisUtil.del(DefIndexConst.CACHE_TYPE + username);
}
// 5. 缓存类型
//当前地址
String url = sysRoleIndex.getUrl();
//首页类型(默认首页)
String type = DefIndexConst.HOME_TYPE_MENU;
if(oConvertUtils.isNotEmpty(url) && CommonConstant.STATUS_1.equalsIgnoreCase(status)){
type = url.contains(DefIndexConst.HOME_TYPE_SYSTEM) ? DefIndexConst.HOME_TYPE_SYSTEM : DefIndexConst.HOME_TYPE_PERSONAL;
}
redisUtil.set(DefIndexConst.CACHE_TYPE + username,type);
}
/**
* 更新其他全局默认的状态值
*
* @param roleCode
* @param status
* @param id
*/
@Override
public void updateOtherDefaultStatus(String roleCode, String status, String id) {
//roleCode是全局默认
if(oConvertUtils.isNotEmpty(roleCode) && DefIndexConst.DEF_INDEX_ALL.equals(roleCode)){
//状态为开启状态
if(oConvertUtils.isNotEmpty(status) && CommonConstant.STATUS_1.equals(status)){
LambdaQueryWrapper<SysRoleIndex> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SysRoleIndex::getRoleCode,roleCode);
queryWrapper.eq(SysRoleIndex::getStatus,CommonConstant.STATUS_1);
queryWrapper.ne(SysRoleIndex::getId,id);
queryWrapper.select(SysRoleIndex::getId);
List<SysRoleIndex> list = this.list(queryWrapper);
if(CollectionUtil.isNotEmpty(list)){
list.forEach(sysRoleIndex -> {
sysRoleIndex.setStatus(CommonConstant.STATUS_0);
});
this.updateBatchById(list);
}
}
}
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysAnnouncementSendServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysAnnouncementSendServiceImpl.java | package org.jeecg.modules.system.service.impl;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import jakarta.annotation.Resource;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysAnnouncement;
import org.jeecg.modules.system.entity.SysAnnouncementSend;
import org.jeecg.modules.system.mapper.SysAnnouncementMapper;
import org.jeecg.modules.system.mapper.SysAnnouncementSendMapper;
import org.jeecg.modules.system.model.AnnouncementSendModel;
import org.jeecg.modules.system.service.ISysAnnouncementSendService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
/**
* @Description: 用户通告阅读标记表
* @Author: jeecg-boot
* @Date: 2019-02-21
* @Version: V1.0
*/
@Service
public class SysAnnouncementSendServiceImpl extends ServiceImpl<SysAnnouncementSendMapper, SysAnnouncementSend> implements ISysAnnouncementSendService {
@Resource
private SysAnnouncementSendMapper sysAnnouncementSendMapper;
@Autowired
private SysAnnouncementMapper sysAnnouncementMapper;
@Override
public Page<AnnouncementSendModel> getMyAnnouncementSendPage(Page<AnnouncementSendModel> page,
AnnouncementSendModel announcementSendModel) {
return page.setRecords(sysAnnouncementSendMapper.getMyAnnouncementSendList(page, announcementSendModel));
}
@Override
public AnnouncementSendModel getOne(String sendId) {
return sysAnnouncementSendMapper.getOne(sendId);
}
/**
* 获取当前用户已阅读数量
*
* @param id
* @return
*/
@Override
public long getReadCountByUserId(String id) {
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
return sysAnnouncementSendMapper.getReadCountByUserId(id, sysUser.getId());
}
/**
* 根据多个id批量删除已阅读的数量
*
* @param ids
*/
@Override
public void deleteBatchByIds(String ids) {
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
//根据用户id和阅读表的id获取所有阅读的数据
List<String> sendIds = sysAnnouncementSendMapper.getReadAnnSendByUserId(Arrays.asList(ids.split(SymbolConstant.COMMA)),sysUser.getId());
if(CollectionUtil.isNotEmpty(sendIds)){
this.removeByIds(sendIds);
}
}
/**
* 根据busId更新阅读状态
* @param busId
* @param busType
*/
@Override
public void updateReadFlagByBusId(String busId, String busType) {
SysAnnouncement announcement = sysAnnouncementMapper.selectOne(new QueryWrapper<SysAnnouncement>().eq("bus_type",busType).eq("bus_id",busId));
if(oConvertUtils.isNotEmpty(announcement)){
LoginUser sysUser = (LoginUser)SecurityUtils.getSubject().getPrincipal();
String userId = sysUser.getId();
LambdaUpdateWrapper<SysAnnouncementSend> updateWrapper = new UpdateWrapper().lambda();
updateWrapper.set(SysAnnouncementSend::getReadFlag, CommonConstant.HAS_READ_FLAG);
updateWrapper.set(SysAnnouncementSend::getReadTime, new Date());
updateWrapper.eq(SysAnnouncementSend::getAnntId,announcement.getId());
updateWrapper.eq(SysAnnouncementSend::getUserId,userId);
SysAnnouncementSend announcementSend = new SysAnnouncementSend();
sysAnnouncementSendMapper.update(announcementSend, updateWrapper);
}
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysRolePermissionServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysRolePermissionServiceImpl.java | package org.jeecg.modules.system.service.impl;
import java.util.*;
import org.jeecg.common.util.IpUtils;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysRolePermission;
import org.jeecg.modules.system.mapper.SysRolePermissionMapper;
import org.jeecg.modules.system.service.ISysRolePermissionService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
import jakarta.servlet.http.HttpServletRequest;
/**
* <p>
* 角色权限表 服务实现类
* </p>
*
* @Author scott
* @since 2018-12-21
*/
@Service
public class SysRolePermissionServiceImpl extends ServiceImpl<SysRolePermissionMapper, SysRolePermission> implements ISysRolePermissionService {
@Override
public void saveRolePermission(String roleId, String permissionIds) {
String ip = "";
try {
//获取request
HttpServletRequest request = SpringContextUtils.getHttpServletRequest();
//获取IP地址
ip = IpUtils.getIpAddr(request);
} catch (Exception e) {
ip = "127.0.0.1";
}
LambdaQueryWrapper<SysRolePermission> query = new QueryWrapper<SysRolePermission>().lambda().eq(SysRolePermission::getRoleId, roleId);
this.remove(query);
List<SysRolePermission> list = new ArrayList<SysRolePermission>();
String[] arr = permissionIds.split(",");
for (String p : arr) {
if(oConvertUtils.isNotEmpty(p)) {
SysRolePermission rolepms = new SysRolePermission(roleId, p);
rolepms.setOperateDate(new Date());
rolepms.setOperateIp(ip);
list.add(rolepms);
}
}
this.saveBatch(list);
}
@Override
public void saveRolePermission(String roleId, String permissionIds, String lastPermissionIds) {
String ip = "";
try {
//获取request
HttpServletRequest request = SpringContextUtils.getHttpServletRequest();
//获取IP地址
ip = IpUtils.getIpAddr(request);
} catch (Exception e) {
ip = "127.0.0.1";
}
List<String> add = getDiff(lastPermissionIds,permissionIds);
if(add!=null && add.size()>0) {
List<SysRolePermission> list = new ArrayList<SysRolePermission>();
for (String p : add) {
if(oConvertUtils.isNotEmpty(p)) {
SysRolePermission rolepms = new SysRolePermission(roleId, p);
rolepms.setOperateDate(new Date());
rolepms.setOperateIp(ip);
list.add(rolepms);
}
}
this.saveBatch(list);
}
List<String> delete = getDiff(permissionIds,lastPermissionIds);
if(delete!=null && delete.size()>0) {
for (String permissionId : delete) {
this.remove(new QueryWrapper<SysRolePermission>().lambda().eq(SysRolePermission::getRoleId, roleId).eq(SysRolePermission::getPermissionId, permissionId));
}
}
}
/**
* 从diff中找出main中没有的元素
* @param main
* @param diff
* @return
*/
private List<String> getDiff(String main,String diff){
if(oConvertUtils.isEmpty(diff)) {
return null;
}
if(oConvertUtils.isEmpty(main)) {
return Arrays.asList(diff.split(","));
}
String[] mainArr = main.split(",");
String[] diffArr = diff.split(",");
Map<String, Integer> map = new HashMap(5);
for (String string : mainArr) {
map.put(string, 1);
}
List<String> res = new ArrayList<String>();
for (String key : diffArr) {
if(oConvertUtils.isNotEmpty(key) && !map.containsKey(key)) {
res.add(key);
}
}
return res;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysThirdAccountServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysThirdAccountServiceImpl.java | package org.jeecg.modules.system.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jeecg.dingtalk.api.base.JdtBaseAPI;
import com.jeecg.dingtalk.api.core.response.Response;
import com.jeecg.dingtalk.api.core.vo.AccessToken;
import com.jeecg.dingtalk.api.user.JdtUserAPI;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.DateUtils;
import org.jeecg.common.util.PasswordUtil;
import org.jeecg.common.util.UUIDGenerator;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysRole;
import org.jeecg.modules.system.entity.SysThirdAccount;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.entity.SysUserRole;
import org.jeecg.modules.system.mapper.SysRoleMapper;
import org.jeecg.modules.system.mapper.SysThirdAccountMapper;
import org.jeecg.modules.system.mapper.SysUserMapper;
import org.jeecg.modules.system.mapper.SysUserRoleMapper;
import org.jeecg.modules.system.model.ThirdLoginModel;
import org.jeecg.modules.system.service.ISysThirdAccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
/**
* @Description: 第三方登录账号表
* @Author: jeecg-boot
* @Date: 2020-11-17
* @Version: V1.0
*/
@Service
@Slf4j
public class SysThirdAccountServiceImpl extends ServiceImpl<SysThirdAccountMapper, SysThirdAccount> implements ISysThirdAccountService {
@Autowired
private SysThirdAccountMapper sysThirdAccountMapper;
@Autowired
private SysUserMapper sysUserMapper;
@Autowired
private SysRoleMapper sysRoleMapper;
@Autowired
private SysUserRoleMapper sysUserRoleMapper;
@Value("${justauth.type.DINGTALK.client-id:}")
private String dingTalkClientId;
@Value("${justauth.type.DINGTALK.client-secret:}")
private String dingTalkClientSecret;
@Override
public void updateThirdUserId(SysUser sysUser,String thirdUserUuid) {
//修改第三方登录账户表使其进行添加用户id
LambdaQueryWrapper<SysThirdAccount> query = new LambdaQueryWrapper<>();
query.eq(SysThirdAccount::getThirdUserUuid,thirdUserUuid);
//扫码登录更新用户创建的时候存的是默认租户，更新的时候也需要根据默认租户来查询，同一个公司下UUID是一样的，不同应用需要区分租户。
query.eq(SysThirdAccount::getTenantId,CommonConstant.TENANT_ID_DEFAULT_VALUE);
SysThirdAccount account = sysThirdAccountMapper.selectOne(query);
SysThirdAccount sysThirdAccount = new SysThirdAccount();
sysThirdAccount.setSysUserId(sysUser.getId());
//根据当前用户id和登录方式查询第三方登录表
LambdaQueryWrapper<SysThirdAccount> thirdQuery = new LambdaQueryWrapper<>();
thirdQuery.eq(SysThirdAccount::getSysUserId,sysUser.getId());
thirdQuery.eq(SysThirdAccount::getThirdType,account.getThirdType());
thirdQuery.eq(SysThirdAccount::getThirdUserUuid,thirdUserUuid);
thirdQuery.eq(SysThirdAccount::getTenantId,CommonConstant.TENANT_ID_DEFAULT_VALUE);
SysThirdAccount sysThirdAccounts = sysThirdAccountMapper.selectOne(thirdQuery);
if(sysThirdAccounts!=null){
sysThirdAccount.setThirdUserId(sysThirdAccounts.getThirdUserId());
sysThirdAccountMapper.deleteById(sysThirdAccounts.getId());
}
//更新用户账户表sys_user_id
sysThirdAccountMapper.update(sysThirdAccount,query);
}
@Override
public SysUser createUser(String phone, String thirdUserUuid, Integer tenantId) {
//先查询第三方，获取登录方式
LambdaQueryWrapper<SysThirdAccount> query = new LambdaQueryWrapper<>();
query.eq(SysThirdAccount::getThirdUserUuid,thirdUserUuid);
query.eq(SysThirdAccount::getTenantId,tenantId);
SysThirdAccount account = sysThirdAccountMapper.selectOne(query);
//通过用户名查询数据库是否已存在
SysUser userByName = sysUserMapper.getUserByName(thirdUserUuid);
if(null!=userByName){
//如果账号存在的话，则自动加上一个时间戳
String format = DateUtils.yyyymmddhhmmss.get().format(new Date());
thirdUserUuid = thirdUserUuid + format;
}
//添加用户
SysUser user = new SysUser();
user.setActivitiSync(CommonConstant.ACT_SYNC_1);
user.setDelFlag(CommonConstant.DEL_FLAG_0);
user.setStatus(1);
user.setUsername(thirdUserUuid);
user.setPhone(phone);
//设置初始密码
String salt = oConvertUtils.randomGen(8);
user.setSalt(salt);
String passwordEncode = PasswordUtil.encrypt(user.getUsername(), "123456", salt);
user.setPassword(passwordEncode);
user.setRealname(account.getRealname());
user.setAvatar(account.getAvatar());
String s = this.saveThirdUser(user);
//更新用户第三方账户表的userId
SysThirdAccount sysThirdAccount = new SysThirdAccount();
sysThirdAccount.setSysUserId(s);
sysThirdAccount.setTenantId(tenantId);
sysThirdAccountMapper.update(sysThirdAccount,query);
return user;
}
public String saveThirdUser(SysUser sysUser) {
//保存用户
String userid = UUIDGenerator.generate();
sysUser.setId(userid);
sysUserMapper.insert(sysUser);
//获取第三方角色
SysRole sysRole = sysRoleMapper.selectOne(new LambdaQueryWrapper<SysRole>().eq(SysRole::getRoleCode, "third_role"));
//保存用户角色
SysUserRole userRole = new SysUserRole();
userRole.setRoleId(sysRole.getId());
userRole.setUserId(userid);
sysUserRoleMapper.insert(userRole);
return userid;
}
@Override
public SysThirdAccount getOneBySysUserId(String sysUserId, String thirdType) {
LambdaQueryWrapper<SysThirdAccount> queryWrapper = new LambdaQueryWrapper<>();
log.info("getSysUserId: {} ,getThirdType: {}",sysUserId,thirdType);
queryWrapper.eq(SysThirdAccount::getSysUserId, sysUserId);
queryWrapper.eq(SysThirdAccount::getThirdType, thirdType);
return super.getOne(queryWrapper);
}
@Override
public SysThirdAccount getOneByThirdUserId(String thirdUserId, String thirdType) {
LambdaQueryWrapper<SysThirdAccount> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SysThirdAccount::getThirdUserId, thirdUserId);
queryWrapper.eq(SysThirdAccount::getThirdType, thirdType);
return super.getOne(queryWrapper);
}
@Override
public List<SysThirdAccount> listThirdUserIdByUsername(String[] sysUsernameArr, String thirdType, Integer tenantId) {
return sysThirdAccountMapper.selectThirdIdsByUsername(sysUsernameArr, thirdType,tenantId);
}
@Override
public SysThirdAccount saveThirdUser(ThirdLoginModel tlm, Integer tenantId) {
SysThirdAccount user = new SysThirdAccount();
user.setDelFlag(CommonConstant.DEL_FLAG_0);
user.setStatus(1);
user.setThirdType(tlm.getSource());
user.setAvatar(tlm.getAvatar());
user.setRealname(tlm.getUsername());
user.setThirdUserUuid(tlm.getUuid());
user.setTenantId(tenantId);
//=============begin 判断如果是钉钉的情况下，需要将第三方的用户id查询出来，发送模板的时候有用==========
if(CommonConstant.DINGTALK.toLowerCase().equals(tlm.getSource())){
AccessToken accessToken = JdtBaseAPI.getAccessToken(dingTalkClientId, dingTalkClientSecret);
Response<String> getUserIdRes = JdtUserAPI.getUseridByUnionid(tlm.getUuid(), accessToken.getAccessToken());
if (getUserIdRes.isSuccess()) {
user.setThirdUserId(getUserIdRes.getResult());
}else{
user.setThirdUserId(tlm.getUuid());
}
//=============end 判断如果是钉钉的情况下，需要将第三方的用户id查询出来，发送模板的时候有用==========
}else{
user.setThirdUserId(tlm.getUuid());
}
super.save(user);
return user;
}
@Override
public SysThirdAccount bindThirdAppAccountByUserId(SysThirdAccount sysThirdAccount) {
String thirdUserUuid = sysThirdAccount.getThirdUserUuid();
String thirdType = sysThirdAccount.getThirdType();
//获取当前登录用户
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
//当前第三方用户已被其他用户所绑定
SysThirdAccount oneByThirdUserId = this.getOneByUuidAndThirdType(thirdUserUuid, thirdType,CommonConstant.TENANT_ID_DEFAULT_VALUE, null);
if(null != oneByThirdUserId){
//如果不为空，并且第三方表和当前登录的用户一致，直接返回
if(oConvertUtils.isNotEmpty(oneByThirdUserId.getSysUserId()) && oneByThirdUserId.getSysUserId().equals(sysUser.getId())){
return oneByThirdUserId;
}else if(oConvertUtils.isNotEmpty(oneByThirdUserId.getSysUserId())){
//如果第三方表的用户id不为空，那就说明已经绑定过了
throw new JeecgBootException("该敲敲云账号已被其它第三方账号绑定,请解绑或绑定其它敲敲云账号");
}else{
//更新第三方表信息用户id
oneByThirdUserId.setSysUserId(sysUser.getId());
oneByThirdUserId.setThirdType(thirdType);
sysThirdAccountMapper.updateById(oneByThirdUserId);
return oneByThirdUserId;
}
}else{
throw new JeecgBootException("账号绑定失败,请稍后重试");
}
}
@Override
public SysThirdAccount getOneByUuidAndThirdType(String unionid, String thirdType,Integer tenantId,String thirdUserId) {
LambdaQueryWrapper<SysThirdAccount> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SysThirdAccount::getThirdType, thirdType);
// 代码逻辑说明: 如果第三方用户id为空那么就不走第三方用户查询逻辑，因为扫码登录third_user_id是唯一的，没有重复的情况---
if(oConvertUtils.isNotEmpty(thirdUserId)){
queryWrapper.and((wrapper) ->wrapper.eq(SysThirdAccount::getThirdUserUuid,unionid).or().eq(SysThirdAccount::getThirdUserId,thirdUserId));
}else{
queryWrapper.eq(SysThirdAccount::getThirdUserUuid, unionid);
}
queryWrapper.eq(SysThirdAccount::getTenantId, tenantId);
return super.getOne(queryWrapper);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysUserServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysUserServiceImpl.java | package org.jeecg.modules.system.service.impl;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.RandomUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.aliyuncs.exceptions.ClientException;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.api.dto.message.MessageDTO;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.FillRuleConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.constant.PasswordConstant;
import org.jeecg.common.constant.enums.*;
import org.jeecg.common.desensitization.annotation.SensitiveEncode;
import org.jeecg.common.exception.JeecgBootBizTipException;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.system.vo.SysUserCacheInfo;
import org.jeecg.common.util.*;
import org.jeecg.common.util.encryption.AesEncryptUtil;
import org.jeecg.config.JeecgBaseConfig;
import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
import org.jeecg.modules.base.service.BaseCommonService;
import org.jeecg.modules.message.handle.impl.SystemSendMsgHandle;
import org.jeecg.modules.system.entity.*;
import org.jeecg.modules.system.mapper.*;
import org.jeecg.modules.system.model.SysLoginModel;
import org.jeecg.modules.system.model.SysUserSysDepPostModel;
import org.jeecg.modules.system.model.SysUserSysDepartModel;
import org.jeecg.modules.system.service.*;
import org.jeecg.modules.system.util.ImportSysUserCache;
import org.jeecg.modules.system.vo.*;
import org.jeecg.modules.system.vo.lowapp.AppExportUserVo;
import org.jeecg.modules.system.vo.lowapp.DepartAndUserInfo;
import org.jeecg.modules.system.vo.lowapp.DepartInfo;
import org.jeecg.modules.system.vo.lowapp.UpdateDepartInfo;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.jetbrains.annotations.Nullable;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.context.annotation.Lazy;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;
/**
* <p>
* 用户表 服务实现类
* </p>
*
* @Author: scott
* @Date: 2018-12-20
*/
@Service
@Slf4j
public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> implements ISysUserService {
@Autowired
private SysUserMapper userMapper;
@Autowired
private SysPermissionMapper sysPermissionMapper;
@Autowired
private SysUserRoleMapper sysUserRoleMapper;
@Autowired
private SysUserDepartMapper sysUserDepartMapper;
@Autowired
private SysDepartMapper sysDepartMapper;
@Autowired
private SysRoleMapper sysRoleMapper;
@Autowired
private SysDepartRoleUserMapper departRoleUserMapper;
@Autowired
private SysDepartRoleMapper sysDepartRoleMapper;
@Resource
private BaseCommonService baseCommonService;
@Autowired
private SysThirdAccountMapper sysThirdAccountMapper;
@Autowired
ThirdAppWechatEnterpriseServiceImpl wechatEnterpriseService;
@Autowired
ThirdAppDingtalkServiceImpl dingtalkService;
@Autowired
ISysRoleIndexService sysRoleIndexService;
@Autowired
SysTenantMapper sysTenantMapper;
@Autowired
private SysUserTenantMapper relationMapper;
@Autowired
private SysUserTenantMapper userTenantMapper;
@Autowired
private SysUserPositionMapper sysUserPositionMapper;
@Autowired
private SysPositionMapper sysPositionMapper;
@Autowired
private SystemSendMsgHandle systemSendMsgHandle;
@Autowired
private ISysThirdAccountService sysThirdAccountService;
@Autowired
private RedisUtil redisUtil;
@Autowired
private SysTenantPackUserMapper packUserMapper;
@Autowired
private SysUserDepPostMapper depPostMapper;
@Autowired
private JeecgBaseConfig jeecgBaseConfig;
/**
* 管理员账号
*/
public static final String[] ADMIN_ACCOUNT = new String[]{"admin"};
@Override
public Result<IPage<SysUser>> queryPageList(HttpServletRequest req, QueryWrapper<SysUser> queryWrapper, Integer pageSize, Integer pageNo) {
Result<IPage<SysUser>> result = new Result<IPage<SysUser>>();
//部门ID
String departId = req.getParameter("departId");
if (oConvertUtils.isNotEmpty(departId)) {
//代码逻辑说明:【JHHB-762】用户管理需要支持按组织架构查询用户（支持多选）---
//兼容多个部门id
LambdaQueryWrapper<SysUserDepart> query = new LambdaQueryWrapper<>();
if(departId.contains(SymbolConstant.COMMA)) {
query.in(SysUserDepart::getDepId, Arrays.asList(departId.split(SymbolConstant.COMMA)));
} else {
query.eq(SysUserDepart::getDepId, departId);
}
List<SysUserDepart> list = sysUserDepartMapper.selectList(query);
List<String> userIds = list.stream().map(SysUserDepart::getUserId).collect(Collectors.toList());
// 代码逻辑说明: [issues/I4XTYB]查询用户时，当部门id 下没有分配用户时接口报错------------
if (oConvertUtils.listIsNotEmpty(userIds)) {
queryWrapper.in("id", userIds);
} else {
return Result.OK();
}
}
//用户ID
String code = req.getParameter("code");
if (oConvertUtils.isNotEmpty(code)) {
queryWrapper.in("id", Arrays.asList(code.split(",")));
pageSize = code.split(",").length;
}
// 代码逻辑说明: JTC-372 【用户冻结问题】 online授权、用户组件，选择用户都能看到被冻结的用户
String status = req.getParameter("status");
if (oConvertUtils.isNotEmpty(status)) {
queryWrapper.eq("status", Integer.parseInt(status));
}
// 代码逻辑说明: 【QQYUN-8110】在线通讯录支持设置权限(只能看分配的技术支持)---
String tenantId = TokenUtils.getTenantIdByRequest(req);
String lowAppId = TokenUtils.getLowAppIdByRequest(req);
// Object bean = ResourceUtil.getImplementationClass(DataEnhanceEnum.getClassPath(tenantId,lowAppId));
// if(null != bean){
// UserFilterEnhance userEnhanceService = (UserFilterEnhance) bean;
// LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
// List<String> userIds = userEnhanceService.getUserIds(sysUser.getId());
// if(CollectionUtil.isNotEmpty(userIds)){
// queryWrapper.in("id", userIds);
// }
// }
//TODO 外部模拟登陆临时账号，列表不显示
queryWrapper.ne("username", "_reserve_user_external");
// 代码逻辑说明: 【JHHB-765】需要能设置排序---
queryWrapper.orderByAsc("sort");
queryWrapper.orderByDesc("create_time");
Page<SysUser> page = new Page<SysUser>(pageNo, pageSize);
IPage<SysUser> pageList = this.page(page, queryWrapper);
//批量查询用户的所属部门
//step.1 先拿到全部的 useids
//step.2 通过 useids，一次性查询用户的所属部门名字
List<String> userIds = pageList.getRecords().stream().map(SysUser::getId).collect(Collectors.toList());
if (userIds != null && userIds.size() > 0) {
Map<String, String> useDepNames = this.getDepNamesByUserIds(userIds);
pageList.getRecords().forEach(item -> {
item.setOrgCodeTxt(useDepNames.get(item.getId()));
//增加所属部门id,前台需要展示
List<String> departs = sysDepartMapper.queryDepartsByUserId(item.getId());
if(oConvertUtils.isNotEmpty(departs)){
item.setBelongDepIds(String.join(SymbolConstant.COMMA, departs));
}
//查询用户的租户ids
List<Integer> list = userTenantMapper.getTenantIdsByUserId(item.getId());
if (oConvertUtils.isNotEmpty(list)) {
item.setRelTenantIds(StringUtils.join(list.toArray(), SymbolConstant.COMMA));
} else {
item.setRelTenantIds("");
}
Integer posTenantId = null;
if (MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL) {
posTenantId = oConvertUtils.getInt(TenantContext.getTenant(), 0);;
}
//查询用户职位关系表(获取租户下面的)
// 代码逻辑说明: 【QQYUN-7028】用户职务保存后未回显---
List<String> positionList = sysUserPositionMapper.getPositionIdByUserTenantId(item.getId(),posTenantId);
item.setPost(CommonUtils.getSplitText(positionList,SymbolConstant.COMMA));
//是否根据租户隔离(敲敲云用户列表专用，用于展示是否同步钉钉)
if (MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL) {
//查询账号表是否已同步钉钉
LambdaQueryWrapper<SysThirdAccount> query = new LambdaQueryWrapper<>();
query.eq(SysThirdAccount::getSysUserId,item.getId());
query.eq(SysThirdAccount::getTenantId, tenantId);
//目前只有同步钉钉
query.eq(SysThirdAccount::getThirdType, MessageTypeEnum.DD.getType());
//不为空代表已同步钉钉
List<SysThirdAccount> account = sysThirdAccountService.list(query);
if(CollectionUtil.isNotEmpty(account)){
item.setIzBindThird(true);
}
}
//查询部门的兼职岗位
List<String> depPostList = depPostMapper.getDepPostByUserId(item.getId());
if(CollectionUtil.isNotEmpty(depPostList)){
item.setOtherDepPostId(StringUtils.join(depPostList.toArray(), SymbolConstant.COMMA));
}
});
}
result.setSuccess(true);
result.setResult(pageList);
//log.info(pageList.toString());
return result;
}
@Override
@CacheEvict(value = {CacheConstant.SYS_USERS_CACHE}, allEntries = true)
public Result<?> resetPassword(String username, String oldpassword, String newpassword, String confirmpassword) {
SysUser user = userMapper.getUserByName(username);
String passwordEncode = PasswordUtil.encrypt(username, oldpassword, user.getSalt());
if (!user.getPassword().equals(passwordEncode)) {
return Result.error("旧密码输入错误!");
}
if (oConvertUtils.isEmpty(newpassword)) {
return Result.error("新密码不允许为空!");
}
if (!newpassword.equals(confirmpassword)) {
return Result.error("两次输入密码不一致!");
}
String password = PasswordUtil.encrypt(username, newpassword, user.getSalt());
this.userMapper.update(new SysUser().setPassword(password), new LambdaQueryWrapper<SysUser>().eq(SysUser::getId, user.getId()));
return Result.ok("密码重置成功!");
}
@Override
@CacheEvict(value = {CacheConstant.SYS_USERS_CACHE}, allEntries = true)
public Result<?> changePassword(SysUser sysUser) {
String salt = oConvertUtils.randomGen(8);
sysUser.setSalt(salt);
String password = sysUser.getPassword();
String passwordEncode = PasswordUtil.encrypt(sysUser.getUsername(), password, salt);
sysUser.setPassword(passwordEncode);
sysUser.setLastPwdUpdateTime(new Date());
this.userMapper.updateById(sysUser);
return Result.ok("密码修改成功!");
}
@Override
@CacheEvict(value={CacheConstant.SYS_USERS_CACHE}, allEntries=true)
@Transactional(rollbackFor = Exception.class)
public boolean deleteUser(String userId) {
//1.验证当前用户是管理员账号 admin
//验证用户是否为管理员
this.checkUserAdminRejectDel(userId);
//2.删除用户
this.removeById(userId);
return false;
}
@Override
@CacheEvict(value={CacheConstant.SYS_USERS_CACHE}, allEntries=true)
@Transactional(rollbackFor = Exception.class)
public boolean deleteBatchUsers(String userIds) {
//1.验证当前用户是管理员账号 admin
this.checkUserAdminRejectDel(userIds);
//2.删除用户
this.removeByIds(Arrays.asList(userIds.split(",")));
return false;
}
@Override
public SysUser getUserByName(String username) {
SysUser sysUser = userMapper.getUserByName(username);
//查询用户的租户ids
if(sysUser!=null){
List<Integer> list = userTenantMapper.getTenantIdsByUserId(sysUser.getId());
if (oConvertUtils.isNotEmpty(list)) {
sysUser.setRelTenantIds(StringUtils.join(list.toArray(), SymbolConstant.COMMA));
} else {
sysUser.setRelTenantIds("");
}
}
return sysUser;
}
@Override
@Transactional(rollbackFor = Exception.class)
public void addUserWithRole(SysUser user, String roles) {
this.save(user);
if(oConvertUtils.isNotEmpty(roles)) {
String[] arr = roles.split(",");
for (String roleId : arr) {
SysUserRole userRole = new SysUserRole(user.getId(), roleId);
sysUserRoleMapper.insert(userRole);
}
}
}
@Override
@CacheEvict(value= {CacheConstant.SYS_USERS_CACHE}, allEntries=true)
@Transactional(rollbackFor = Exception.class)
public void editUserWithRole(SysUser user, String roles) {
this.updateById(user);
//先删后加
sysUserRoleMapper.delete(new QueryWrapper<SysUserRole>().lambda().eq(SysUserRole::getUserId, user.getId()));
if(oConvertUtils.isNotEmpty(roles)) {
String[] arr = roles.split(",");
for (String roleId : arr) {
SysUserRole userRole = new SysUserRole(user.getId(), roleId);
sysUserRoleMapper.insert(userRole);
}
}
}
@Override
public List<String> getRole(String username) {
return sysUserRoleMapper.getRoleByUserName(username);
}
/**
* 获取动态首页路由配置
*
* @param username
* @param version
* @return
*/
@Override
public SysRoleIndex getDynamicIndexByUserRole(String username, String version) {
SysRoleIndex roleIndex = new SysRoleIndex();
//只有 X-Version=v3 的时候，才读取sys_role_index表获取角色首页配置
boolean isV3 = CommonConstant.VERSION_V3.equals(version);
if (isV3) {
//1.先查询 用户USER级别 的所有首页配置
if(oConvertUtils.isNotEmpty(username)){
LambdaQueryWrapper<SysRoleIndex> routeIndexUserQuery = new LambdaQueryWrapper<>();
//角色首页状态0：未开启 1：开启
routeIndexUserQuery.eq(SysRoleIndex::getStatus, CommonConstant.STATUS_1);
routeIndexUserQuery.eq(SysRoleIndex::getRelationType, CommonConstant.HOME_RELATION_USER);
routeIndexUserQuery.eq(SysRoleIndex::getRoleCode, username);
//优先级正序排序
routeIndexUserQuery.orderByAsc(SysRoleIndex::getPriority);
List<SysRoleIndex> list = sysRoleIndexService.list(routeIndexUserQuery);
if (CollectionUtils.isNotEmpty(list)) {
roleIndex = list.get(0);
}else{
//2.用户没有配置，再查询 角色ROLE级别 的所有首页配置
LambdaQueryWrapper<SysRoleIndex> routeIndexQuery = new LambdaQueryWrapper<>();
//角色首页状态0：未开启 1：开启
routeIndexQuery.eq(SysRoleIndex::getStatus, CommonConstant.STATUS_1);
//角色所有首页配置
routeIndexQuery.eq(SysRoleIndex::getRelationType, CommonConstant.HOME_RELATION_ROLE);
//当前用户角色
List<String> roles = sysUserRoleMapper.getRoleByUserName(username);
String componentUrl = RoleIndexConfigEnum.getIndexByRoles(roles);
roleIndex = new SysRoleIndex(componentUrl);
//用户所有角色
// 代码逻辑说明: [QQYUN-13187]【新用户登录报错】没有添加角色时 报错
if(CollectionUtil.isNotEmpty(roles)){
routeIndexQuery.in(SysRoleIndex::getRoleCode, roles);
}
//优先级正序排序
routeIndexQuery.orderByAsc(SysRoleIndex::getPriority);
list = sysRoleIndexService.list(routeIndexQuery);
if (CollectionUtils.isNotEmpty(list)) {
roleIndex = list.get(0);
}
}
}
}
if (oConvertUtils.isEmpty(roleIndex.getComponent())) {
if (isV3) {
// 如果角色没有配置首页，则使用默认首页
return sysRoleIndexService.queryDefaultIndex();
} else {
// 非v3返回null
return null;
}
}
return roleIndex;
}
/**
* 通过用户名获取用户角色集合
* @param username 用户名
* @return 角色集合
*/
@Override
public Set<String> getUserRolesSet(String username) {
// 查询用户拥有的角色集合
List<String> roles = sysUserRoleMapper.getRoleByUserName(username);
log.info("-------通过数据库读取用户拥有的角色Rules------username： " + username + ",Roles size: " + (roles == null ? 0 : roles.size()));
return new HashSet<>(roles);
}
/**
* 通过用户名获取用户角色集合
* @param userId 用户ID
* @return 角色集合
*/
@Override
public Set<String> getUserRoleSetById(String userId) {
// 查询用户拥有的角色集合
List<String> roles = sysUserRoleMapper.getRoleCodeByUserId(userId);
log.info("-------通过数据库读取用户拥有的角色Rules------userId： " + userId + ",Roles size: " + (roles == null ? 0 : roles.size()));
return new HashSet<>(roles);
}
/**
* 通过用户名获取用户权限集合
*
* @param userId 用户ID
* @return 权限集合
*/
@Override
public Set<String> getUserPermissionsSet(String userId) {
Set<String> permissionSet = new HashSet<>();
List<SysPermission> permissionList = sysPermissionMapper.queryByUser(userId);
//================= begin 开启租户的时候 如果没有test角色，默认加入test角色================
if (MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL) {
if (permissionList == null) {
permissionList = new ArrayList<>();
}
List<SysPermission> testRoleList = sysPermissionMapper.queryPermissionByTestRoleId();
permissionList.addAll(testRoleList);
}
//================= end 开启租户的时候 如果没有test角色，默认加入test角色================
for (SysPermission po : permissionList) {
// // TODO URL规则有问题？
// if (oConvertUtils.isNotEmpty(po.getUrl())) {
// permissionSet.add(po.getUrl());
// }
if (oConvertUtils.isNotEmpty(po.getPerms())) {
permissionSet.add(po.getPerms());
}
}
log.info("-------通过数据库读取用户拥有的权限Perms------userId： "+ userId+",Perms size: "+ (permissionSet==null?0:permissionSet.size()) );
return permissionSet;
}
/**
* 升级SpringBoot2.6.6,不允许循环依赖
* @author:qinfeng
* @update: 2022-04-07
* @param username
* @return
*/
@Override
public SysUserCacheInfo getCacheUser(String username) {
SysUserCacheInfo info = new SysUserCacheInfo();
info.setOneDepart(true);
if(oConvertUtils.isEmpty(username)) {
return null;
}
//查询用户信息
SysUser sysUser = userMapper.getUserByName(username);
if(sysUser!=null) {
info.setSysUserCode(sysUser.getUsername());
info.setSysUserName(sysUser.getRealname());
info.setSysOrgCode(sysUser.getOrgCode());
}
//多部门支持in查询
List<SysDepart> list = sysDepartMapper.queryUserDeparts(sysUser.getId());
List<String> sysMultiOrgCode = new ArrayList<String>();
if(list==null || list.size()==0) {
//当前用户无部门
//sysMultiOrgCode.add("0");
}else if(list.size()==1) {
sysMultiOrgCode.add(list.get(0).getOrgCode());
}else {
info.setOneDepart(false);
for (SysDepart dpt : list) {
sysMultiOrgCode.add(dpt.getOrgCode());
}
}
info.setSysMultiOrgCode(sysMultiOrgCode);
return info;
}
/**
* 根据部门Id查询
* @param page
* @param departId 部门id
* @param username 用户账户名称
* @return
*/
@Override
public IPage<SysUser> getUserByDepId(Page<SysUser> page, String departId,String username) {
return userMapper.getUserByDepId(page, departId,username);
}
@Override
public IPage<SysUser> getUserByDepIds(Page<SysUser> page, List<String> departIds, String username) {
return userMapper.getUserByDepIds(page, departIds,username);
}
@Override
public Map<String, String> getDepNamesByUserIds(List<String> userIds) {
List<SysUserDepVo> list = this.baseMapper.getDepNamesByUserIds(userIds);
Map<String, String> res = new HashMap(5);
list.forEach(item -> {
if (res.get(item.getUserId()) == null) {
res.put(item.getUserId(), item.getDepartName());
} else {
res.put(item.getUserId(), res.get(item.getUserId()) + "," + item.getDepartName());
}
}
);
return res;
}
/* @Override
public IPage<SysUser> getUserByDepartIdAndQueryWrapper(Page<SysUser> page, String departId, QueryWrapper<SysUser> queryWrapper) {
LambdaQueryWrapper<SysUser> lambdaQueryWrapper = queryWrapper.lambda();
lambdaQueryWrapper.eq(SysUser::getDelFlag, CommonConstant.DEL_FLAG_0);
lambdaQueryWrapper.inSql(SysUser::getId, "SELECT user_id FROM sys_user_depart WHERE dep_id = '" + departId + "'");
return userMapper.selectPage(page, lambdaQueryWrapper);
}*/
@Override
public IPage<SysUserSysDepartModel> queryUserByOrgCode(String orgCode, SysUser userParams, IPage page) {
List<SysUserSysDepartModel> list = baseMapper.getUserByOrgCode(page, orgCode, userParams);
//根据部门orgCode查询部门，需要将职位id进行传递
for (SysUserSysDepartModel model:list) {
List<String> positionList = sysUserPositionMapper.getPositionIdByUserId(model.getId());
model.setPost(CommonUtils.getSplitText(positionList,SymbolConstant.COMMA));
}
Integer total = baseMapper.getUserByOrgCodeTotal(orgCode, userParams);
IPage<SysUserSysDepartModel> result = new Page<>(page.getCurrent(), page.getSize(), total);
result.setRecords(list);
return result;
}
/**
* 根据角色Id查询
* @param page
* @param roleId 角色id
* @param username 用户账户名称
* @param realname 用户姓名
* @return
*/
@Override
public IPage<SysUser> getUserByRoleId(Page<SysUser> page, String roleId, String username, String realname) {
// 代码逻辑说明: [QQYUN-3980]组织管理中 职位功能 职位表加租户id 加职位-用户关联表------------
IPage<SysUser> userRoleList = userMapper.getUserByRoleId(page, roleId, username,realname);
List<SysUser> records = userRoleList.getRecords();
if (null != records && records.size() > 0) {
List<String> userIds = records.stream().map(SysUser::getId).collect(Collectors.toList());
Map<String, String> useDepNames = this.getDepNamesByUserIds(userIds);
for (SysUser sysUser : userRoleList.getRecords()) {
//设置部门
sysUser.setOrgCodeTxt(useDepNames.get(sysUser.getId()));
//设置用户职位id
this.userPositionId(sysUser);
}
}
return userRoleList;
}
@Override
@CacheEvict(value= {CacheConstant.SYS_USERS_CACHE}, key="#username")
public void updateUserDepart(String username,String orgCode,Integer loginTenantId) {
baseMapper.updateUserDepart(username, orgCode,loginTenantId);
}
@Override
public SysUser getUserByPhone(String phone) {
return userMapper.getUserByPhone(phone);
}
@Override
public SysUser getUserByEmail(String email) {
return userMapper.getUserByEmail(email);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void addUserWithDepart(SysUser user, String selectedParts) {
// this.save(user); //保存角色的时候已经添加过一次了
if(oConvertUtils.isNotEmpty(selectedParts)) {
String[] arr = selectedParts.split(",");
for (String deaprtId : arr) {
SysUserDepart userDeaprt = new SysUserDepart(user.getId(), deaprtId);
sysUserDepartMapper.insert(userDeaprt);
}
}
}
@Override
@Transactional(rollbackFor = Exception.class)
@CacheEvict(value={CacheConstant.SYS_USERS_CACHE}, allEntries=true)
public void editUserWithDepart(SysUser user, String departs) {
//更新角色的时候已经更新了一次了，可以再跟新一次
this.updateById(user);
String[] arr = {};
if(oConvertUtils.isNotEmpty(departs)){
arr = departs.split(",");
}
//查询已关联部门
List<SysUserDepart> userDepartList = sysUserDepartMapper.selectList(new QueryWrapper<SysUserDepart>().lambda().eq(SysUserDepart::getUserId, user.getId()));
if(userDepartList != null && userDepartList.size()>0){
for(SysUserDepart depart : userDepartList ){
//修改已关联部门删除部门用户角色关系
if(!Arrays.asList(arr).contains(depart.getDepId())){
List<SysDepartRole> sysDepartRoleList = sysDepartRoleMapper.selectList(
new QueryWrapper<SysDepartRole>().lambda().eq(SysDepartRole::getDepartId,depart.getDepId()));
List<String> roleIds = sysDepartRoleList.stream().map(SysDepartRole::getId).collect(Collectors.toList());
if(roleIds != null && roleIds.size()>0){
departRoleUserMapper.delete(new QueryWrapper<SysDepartRoleUser>().lambda().eq(SysDepartRoleUser::getUserId, user.getId())
.in(SysDepartRoleUser::getDroleId,roleIds));
}
}
}
}
//先删后加
sysUserDepartMapper.delete(new QueryWrapper<SysUserDepart>().lambda().eq(SysUserDepart::getUserId, user.getId()));
if(oConvertUtils.isNotEmpty(departs)) {
for (String departId : arr) {
SysUserDepart userDepart = new SysUserDepart(user.getId(), departId);
sysUserDepartMapper.insert(userDepart);
}
}
}
/**
* 校验用户是否有效
* @param sysUser
* @return
*/
@Override
public Result<?> checkUserIsEffective(SysUser sysUser) {
Result<?> result = new Result<Object>();
//情况1：根据用户信息查询，该用户不存在
if (sysUser == null) {
result.error500("该用户不存在，请注册");
baseCommonService.addLog("用户登录失败，用户不存在！", CommonConstant.LOG_TYPE_1, null);
return result;
}
//情况2：根据用户信息查询，该用户已注销
// 代码逻辑说明: if条件永远为falsebug------------
if (CommonConstant.DEL_FLAG_1.equals(sysUser.getDelFlag())) {
baseCommonService.addLog("用户登录失败，用户名:" + sysUser.getUsername() + "已注销！", CommonConstant.LOG_TYPE_1, null);
result.error500("该用户已注销");
return result;
}
//情况3：根据用户信息查询，该用户已冻结
if (CommonConstant.USER_FREEZE.equals(sysUser.getStatus())) {
baseCommonService.addLog("用户登录失败，用户名:" + sysUser.getUsername() + "已冻结！", CommonConstant.LOG_TYPE_1, null);
result.error500("该用户已冻结");
return result;
}
return result;
}
@Override
public List<SysUser> queryLogicDeleted() {
// 代码逻辑说明: 回收站查询未离职的------------
LambdaQueryWrapper<SysUser> wrapper = new LambdaQueryWrapper<>();
wrapper.ne(SysUser::getStatus, CommonConstant.USER_QUIT);
return this.queryLogicDeleted(wrapper);
}
@Override
public List<SysUser> queryLogicDeleted(LambdaQueryWrapper<SysUser> wrapper) {
if (wrapper == null) {
wrapper = new LambdaQueryWrapper<>();
}
wrapper.eq(SysUser::getDelFlag, CommonConstant.DEL_FLAG_1);
return userMapper.selectLogicDeleted(wrapper);
}
@Override
@CacheEvict(value={CacheConstant.SYS_USERS_CACHE}, allEntries=true)
public boolean revertLogicDeleted(List<String> userIds, SysUser updateEntity) {
return userMapper.revertLogicDeleted(userIds, updateEntity) > 0;
}
@Override
@Transactional(rollbackFor = Exception.class)
public boolean removeLogicDeleted(List<String> userIds) {
// 1. 删除用户
int line = userMapper.deleteLogicDeleted(userIds);
// 2. 删除用户部门关系
line += sysUserDepartMapper.delete(new LambdaQueryWrapper<SysUserDepart>().in(SysUserDepart::getUserId, userIds));
//3. 删除用户角色关系
line += sysUserRoleMapper.delete(new LambdaQueryWrapper<SysUserRole>().in(SysUserRole::getUserId, userIds));
//4.同步删除第三方App的用户
try {
dingtalkService.removeThirdAppUser(userIds);
wechatEnterpriseService.removeThirdAppUser(userIds);
} catch (Exception e) {
log.error("同步删除第三方App的用户失败：", e);
}
//5. 删除第三方用户表（因为第4步需要用到第三方用户表，所以在他之后删）
line += sysThirdAccountMapper.delete(new LambdaQueryWrapper<SysThirdAccount>().in(SysThirdAccount::getSysUserId, userIds));
//6. 删除租户用户中间表的数据
line += userTenantMapper.delete(new LambdaQueryWrapper<SysUserTenant>().in(SysUserTenant::getUserId,userIds));
return line != 0;
}
@Override
@Transactional(rollbackFor = Exception.class)
public boolean updateNullPhoneEmail() {
userMapper.updateNullByEmptyString("email");
userMapper.updateNullByEmptyString("phone");
return true;
}
@Override
public void saveThirdUser(SysUser sysUser) {
//保存用户
String userid = UUIDGenerator.generate();
sysUser.setId(userid);
baseMapper.insert(sysUser);
//获取第三方角色
SysRole sysRole = sysRoleMapper.selectOne(new LambdaQueryWrapper<SysRole>().eq(SysRole::getRoleCode, "third_role"));
//保存用户角色
SysUserRole userRole = new SysUserRole();
userRole.setRoleId(sysRole.getId());
userRole.setUserId(userid);
sysUserRoleMapper.insert(userRole);
}
@Override
public List<SysUser> queryByDepIds(List<String> departIds, String username) {
return userMapper.queryByDepIds(departIds,username);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void saveUser(SysUser user, String selectedRoles, String selectedDeparts, String relTenantIds, boolean izSyncPack) {
if(null == user.getSort()){
user.setSort(CommonConstant.DEFAULT_USER_SORT);
}
//step.1 保存用户
this.save(user);
//获取用户保存前台传过来的租户id并添加到租户
this.saveUserTenant(user.getId(),relTenantIds, izSyncPack);
//step.2 保存角色
if(oConvertUtils.isNotEmpty(selectedRoles)) {
String[] arr = selectedRoles.split(",");
for (String roleId : arr) {
SysUserRole userRole = new SysUserRole(user.getId(), roleId);
sysUserRoleMapper.insert(userRole);
}
}
//step.3 保存所属部门
if(oConvertUtils.isNotEmpty(selectedDeparts)) {
String[] arr = selectedDeparts.split(",");
for (String deaprtId : arr) {
SysUserDepart userDeaprt = new SysUserDepart(user.getId(), deaprtId);
sysUserDepartMapper.insert(userDeaprt);
}
}
//step.4 保存职位
this.saveUserPosition(user.getId(),user.getPost());
//step5 保存兼职岗位
this.saveUserOtherDepPost(user.getId(),user.getOtherDepPostId());
}
@Override
@Transactional(rollbackFor = Exception.class)
@CacheEvict(value={CacheConstant.SYS_USERS_CACHE}, allEntries=true)
public void editUser(SysUser user, String roles, String departs, String relTenantIds, String updateFromPage) {
//获取用户编辑前台传过来的租户id
this.editUserTenants(user.getId(),relTenantIds);
if(null == user.getSort()){
user.setSort(CommonConstant.DEFAULT_USER_SORT);
}
//step.1 修改用户基础信息
this.updateById(user);
//step.2 修改角色
if (oConvertUtils.isEmpty(updateFromPage) || !"deptUsers".equalsIgnoreCase(updateFromPage)) {
// 处理用户角色 先删后加 , 如果是在部门用户页面修改用户,不处理用户角色,因为该页面无法编辑用户角色.
sysUserRoleMapper.delete(new QueryWrapper<SysUserRole>().lambda().eq(SysUserRole::getUserId, user.getId()));
if (oConvertUtils.isNotEmpty(roles)) {
String[] arr = roles.split(",");
for (String roleId : arr) {
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | true |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysUserDepartServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysUserDepartServiceImpl.java | package org.jeecg.modules.system.service.impl;
import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.config.TenantContext;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.constant.enums.DepartCategoryEnum;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.config.mybatis.MybatisPlusSaasConfig;
import org.jeecg.modules.system.entity.SysDepart;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.entity.SysUserDepart;
import org.jeecg.modules.system.mapper.SysUserDepartMapper;
import org.jeecg.modules.system.mapper.SysUserMapper;
import org.jeecg.modules.system.mapper.SysUserTenantMapper;
import org.jeecg.modules.system.model.DepartIdModel;
import org.jeecg.modules.system.service.ISysDepartService;
import org.jeecg.modules.system.service.ISysUserDepartService;
import org.jeecg.modules.system.service.ISysUserService;
import org.jeecg.modules.system.vo.SysUserDepVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.stream.Collectors;
/**
* <P>
* 用户部门表实现类
* <p/>
* @Author ZhiLin
*@since 2019-02-22
*/
@Service
public class SysUserDepartServiceImpl extends ServiceImpl<SysUserDepartMapper, SysUserDepart> implements ISysUserDepartService {
@Autowired
private ISysDepartService sysDepartService;
@Lazy
@Autowired
private ISysUserService sysUserService;
@Autowired
private SysUserMapper sysUserMapper;
@Autowired
private SysUserTenantMapper userTenantMapper;
/**
* 根据用户id查询部门信息
*/
@Override
public List<DepartIdModel> queryDepartIdsOfUser(String userId) {
LambdaQueryWrapper<SysUserDepart> queryUserDep = new LambdaQueryWrapper<SysUserDepart>();
LambdaQueryWrapper<SysDepart> queryDep = new LambdaQueryWrapper<SysDepart>();
try {
queryUserDep.eq(SysUserDepart::getUserId, userId);
List<String> depIdList = new ArrayList<>();
List<DepartIdModel> depIdModelList = new ArrayList<>();
List<SysUserDepart> userDepList = this.list(queryUserDep);
if(userDepList != null && userDepList.size() > 0) {
for(SysUserDepart userDepart : userDepList) {
depIdList.add(userDepart.getDepId());
}
// 代码逻辑说明: 判断是否开启租户saas模式，开启需要根据当前租户查询------------
if (MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL) {
Integer tenantId = oConvertUtils.getInt(TenantContext.getTenant(), 0);
queryDep.eq(SysDepart::getTenantId,tenantId);
}
queryDep.in(SysDepart::getId, depIdList);
List<SysDepart> depList = sysDepartService.list(queryDep);
//jeecg-boot/issues/3906
if(depList != null && depList.size() > 0) {
for(SysDepart depart : depList) {
depIdModelList.add(new DepartIdModel().convertByUserDepart(depart));
}
}
return depIdModelList;
}
}catch(Exception e) {
e.fillInStackTrace();
}
return null;
}
/**
* 根据部门id查询用户信息
*/
@Override
public List<SysUser> queryUserByDepId(String depId) {
LambdaQueryWrapper<SysUserDepart> queryUserDep = new LambdaQueryWrapper<SysUserDepart>();
queryUserDep.eq(SysUserDepart::getDepId, depId);
List<String> userIdList = new ArrayList<>();
List<SysUserDepart> uDepList = this.list(queryUserDep);
if(uDepList != null && uDepList.size() > 0) {
for(SysUserDepart uDep : uDepList) {
userIdList.add(uDep.getUserId());
}
List<SysUser> userList = (List<SysUser>) sysUserMapper.selectBatchIds(userIdList);
if(CollectionUtil.isNotEmpty(userList)){
// 代码逻辑说明: JHHB-812 人员按照排序展示
userList.sort(Comparator.comparing(SysUser::getSort,
Comparator.nullsFirst(Comparator.naturalOrder())));
// 代码逻辑说明: 接口调用查询返回结果不能返回密码相关信息
for (SysUser sysUser : userList) {
sysUser.setSalt("");
sysUser.setPassword("");
}
}
return userList;
}
return new ArrayList<SysUser>();
}
/**
* 根据部门code，查询当前部门和下级部门的 用户信息
*/
@Override
public List<SysUser> queryUserByDepCode(String depCode,String realname) {
// 代码逻辑说明: 根据部门选择用户接口代码优化
if(oConvertUtils.isNotEmpty(realname)){
realname = realname.trim();
}
List<SysUser> userList = this.baseMapper.queryDepartUserList(depCode, realname);
Map<String, SysUser> map = new HashMap(5);
for (SysUser sysUser : userList) {
// 返回的用户数据去掉密码信息
sysUser.setSalt("");
sysUser.setPassword("");
map.put(sysUser.getId(), sysUser);
}
return new ArrayList<SysUser>(map.values());
}
/**
*
* @param departId
* @param username
* @param realname
* @param pageSize
* @param pageNo
* @param id
* @param isMultiTranslate 是否多字段翻译
* @return
*/
@Override
public IPage<SysUser> queryDepartUserPageList(String departId, String username, String realname, int pageSize, int pageNo,String id,String isMultiTranslate) {
IPage<SysUser> pageList = null;
// 部门ID不存在 直接查询用户表即可
Page<SysUser> page = new Page<SysUser>(pageNo, pageSize);
if(oConvertUtils.isEmpty(departId)){
LambdaQueryWrapper<SysUser> query = new LambdaQueryWrapper<>();
// 代码逻辑说明: [JTC-297]已冻结用户仍可设置为代理人------------
query.eq(SysUser::getStatus,Integer.parseInt(CommonConstant.STATUS_1));
// 代码逻辑说明: 逗号分割多个用户翻译问题------------
if(oConvertUtils.isNotEmpty(username)){
String COMMA = ",";
if(oConvertUtils.isNotEmpty(isMultiTranslate) && username.contains(COMMA)){
String[] usernameArr = username.split(COMMA);
query.in(SysUser::getUsername,usernameArr);
}else {
query.like(SysUser::getUsername, username);
}
}
// 代码逻辑说明: JHHB-304 流程转办 人员选择时，加姓名搜索------------
if(oConvertUtils.isNotEmpty(realname)){
String COMMA = ",";
if(oConvertUtils.isNotEmpty(isMultiTranslate) && realname.contains(COMMA)){
String[] realnameArr = realname.split(COMMA);
query.in(SysUser::getRealname,realnameArr);
}else {
query.like(SysUser::getRealname, realname);
}
}
// 代码逻辑说明: [VUEN-1238]邮箱回复时，发送到显示的为用户id------------
if(oConvertUtils.isNotEmpty(id)){
// 代码逻辑说明: 【TV360X-1482】写信，选择用户后第一次回显没翻译------------
String COMMA = ",";
if(oConvertUtils.isNotEmpty(isMultiTranslate) && id.contains(COMMA)){
String[] idArr = id.split(COMMA);
query.in(SysUser::getId, Arrays.asList(idArr));
}else {
query.eq(SysUser::getId, id);
}
}
// 代码逻辑说明: [VUEN-2121]临时用户不能直接显示------------
query.ne(SysUser::getUsername,"_reserve_user_external");
// 代码逻辑说明: 【JHHB-765】需要能设置排序---
query.orderByAsc(SysUser::getSort);
query.orderByDesc(SysUser::getCreateTime);
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if (MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL) {
String tenantId = oConvertUtils.getString(TenantContext.getTenant(), "0");
// 代码逻辑说明: [QQYUN-3371]租户逻辑改造，改成关系表------------
List<String> userIdList = userTenantMapper.getUserIdsByTenantId(Integer.valueOf(tenantId));
if(null!=userIdList && userIdList.size()>0){
query.in(SysUser::getId,userIdList);
}
}
//------------------------------------------------------------------------------------------------
pageList = sysUserMapper.selectPage(page, query);
}else{
// 有部门ID 需要走自定义sql
SysDepart sysDepart = sysDepartService.getById(departId);
pageList = this.baseMapper.queryDepartUserPageList(page, sysDepart.getOrgCode(), username, realname);
}
List<SysUser> userList = pageList.getRecords();
if(userList!=null && userList.size()>0){
List<String> userIds = userList.stream().map(SysUser::getId).collect(Collectors.toList());
Map<String, SysUser> map = new LinkedHashMap(5);
if(userIds!=null && userIds.size()>0){
// 查部门名称
Map<String,String> useDepNames = this.getDepNamesByUserIds(userIds);
userList.forEach(item->{
//TODO 临时借用这个字段用于页面展示
item.setOrgCodeTxt(useDepNames.get(item.getId()));
item.setSalt("");
item.setPassword("");
// 去重
map.put(item.getId(), item);
});
}
pageList.setRecords(new ArrayList<SysUser>(map.values()));
}
return pageList;
}
@Override
public IPage<SysUser> getUserInformation(Integer tenantId, String departId, String keyword, Integer pageSize, Integer pageNo) {
IPage<SysUser> pageList = null;
// 部门ID不存在 直接查询用户表即可
Page<SysUser> page = new Page<>(pageNo, pageSize);
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
if(oConvertUtils.isEmpty(departId)){
LambdaQueryWrapper<SysUser> query = new LambdaQueryWrapper<>();
query.eq(SysUser::getStatus,Integer.parseInt(CommonConstant.STATUS_1));
query.ne(SysUser::getUsername,"_reserve_user_external");
// 支持租户隔离
if (tenantId != null) {
List<String> userIds = userTenantMapper.getUserIdsByTenantId(tenantId);
if(oConvertUtils.listIsNotEmpty(userIds)){
query.in(SysUser::getId, userIds);
}else{
query.eq(SysUser::getId,"通过租户ID查不到用户");
}
}
//排除自己
query.ne(SysUser::getId,sysUser.getId());
if(StringUtils.isNotEmpty(keyword)){
//这个语法可以将or用括号包起来，避免数据查不到
query.and((wrapper) -> wrapper.like(SysUser::getUsername, keyword).or().like(SysUser::getRealname,keyword));
}
pageList = sysUserMapper.selectPage(page, query);
}else{
// 有部门ID 需要走自定义sql
SysDepart sysDepart = sysDepartService.getById(departId);
// 代码逻辑说明: 部门排除自己------------
pageList = this.baseMapper.getUserInformation(page, sysDepart.getOrgCode(), keyword,sysUser.getId());
}
return pageList;
}
@Override
public IPage<SysUser> getUserInformation(Integer tenantId, String departId,String roleId, String keyword, Integer pageSize, Integer pageNo, String excludeUserIdList, String includeUsernameList) {
IPage<SysUser> pageList = null;
// 部门ID不存在 直接查询用户表即可
Page<SysUser> page = new Page<>(pageNo, pageSize);
LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
List<String> userIdList = new ArrayList<>();
List<String> inUsernameList = new ArrayList<>();
if(oConvertUtils.isNotEmpty(excludeUserIdList)){
userIdList = Arrays.asList(excludeUserIdList.split(SymbolConstant.COMMA));
}
if(oConvertUtils.isNotEmpty(includeUsernameList)){
inUsernameList = Arrays.asList(includeUsernameList.split(SymbolConstant.COMMA));
}
if(oConvertUtils.isNotEmpty(departId)){
// 有部门ID 需要走自定义sql
SysDepart sysDepart = sysDepartService.getById(departId);
// 代码逻辑说明: 【QQYUN-8239】用户角色，添加用户 返回2页数据，实际只显示一页---
pageList = this.baseMapper.getProcessUserList(page, sysDepart.getOrgCode(), keyword, tenantId, userIdList);
} else if (oConvertUtils.isNotEmpty(roleId)) {
// 代码逻辑说明: 【QQYUN-8239】用户角色，添加用户 返回2页数据，实际只显示一页---
pageList = this.sysUserMapper.selectUserListByRoleId(page, roleId, keyword, tenantId,userIdList);
} else{
LambdaQueryWrapper<SysUser> query = new LambdaQueryWrapper<>();
query.eq(SysUser::getStatus,Integer.parseInt(CommonConstant.STATUS_1));
query.ne(SysUser::getUsername,"_reserve_user_external");
if(inUsernameList!=null && inUsernameList.size()>0){
query.in(SysUser::getUsername, inUsernameList);
}
// 代码逻辑说明: 【QQYUN-8239】用户角色，添加用户 返回2页数据，实际只显示一页---
if(oConvertUtils.isNotEmpty(excludeUserIdList)){
query.notIn(SysUser::getId,Arrays.asList(excludeUserIdList.split(SymbolConstant.COMMA)));
}
// 支持租户隔离
if (tenantId != null) {
List<String> userIds = userTenantMapper.getUserIdsByTenantId(tenantId);
if(oConvertUtils.listIsNotEmpty(userIds)){
query.in(SysUser::getId, userIds);
}else{
query.eq(SysUser::getId,"通过租户ID查不到用户");
}
}
if(StringUtils.isNotEmpty(keyword)){
//这个语法可以将or用括号包起来，避免数据查不到
query.and((wrapper) -> wrapper.like(SysUser::getUsername, keyword).or().like(SysUser::getRealname,keyword));
}
// 【JHHB-811】添加排序
query.orderByAsc(SysUser::getSort).orderByDesc(SysUser::getCreateTime);
pageList = sysUserMapper.selectPage(page, query);
}
// 批量查询用户的所属部门
// step.1 先拿到全部的 useids
// step.2 通过 useids，一次性查询用户的所属部门名字
List<String> userIds = pageList.getRecords().stream().map(SysUser::getId).collect(Collectors.toList());
if (userIds.size() > 0) {
Map<String, String> useDepNames = sysUserService.getDepNamesByUserIds(userIds);
pageList.getRecords().forEach(item -> item.setOrgCodeTxt(useDepNames.get(item.getId())));
}
return pageList;
}
@Override
public List<SysUser> getUsersByDepartTenantId(String departId, Integer tenantId) {
return baseMapper.getUsersByDepartTenantId(departId,tenantId);
}
/**
* 升级SpringBoot2.6.6,不允许循环依赖
* @param userIds
* @return
*/
private Map<String, String> getDepNamesByUserIds(List<String> userIds) {
List<SysUserDepVo> list = sysUserMapper.getDepNamesByUserIds(userIds);
Map<String, String> res = new HashMap(5);
list.forEach(item -> {
if (res.get(item.getUserId()) == null) {
res.put(item.getUserId(), item.getDepartName());
} else {
res.put(item.getUserId(), res.get(item.getUserId()) + "," + item.getDepartName());
}
}
);
return res;
}
/**
* 查询部门岗位下的用户
* @param departId
* @param username
* @param realname
* @param pageSize
* @param pageNo
* @param id
* @param isMultiTranslate
* @return
*/
@Override
public IPage<SysUser> queryDepartPostUserPageList(String departId, String username, String realname, Integer pageSize, Integer pageNo, String id, String isMultiTranslate) {
Page<SysUser> page = new Page<SysUser>(pageNo, pageSize);
if (oConvertUtils.isEmpty(departId)) {
// 部门ID不存在 直接查询用户表即可
return getDepPostListByIdUserName(username,id,isMultiTranslate,page);
} else {
// 有部门ID 需要走部门岗位用户查询
return getDepartPostListByIdUserRealName(departId,username,realname,page);
}
}
/**
* 根据部门id和用户名获取部门岗位用户分页列表
*
* @param id
* @param username
* @param isMultiTranslate
* @param page
* @return
*/
private IPage<SysUser> getDepPostListByIdUserName(String username, String id, String isMultiTranslate, Page<SysUser> page) {
//需要查询部门下的用户，故将写成自定义sql，非Lambda表达式的用法
List<String> userIdList = new ArrayList<>();
List<String> userNameList = new ArrayList<>();
String userId = "";
String userName = "";
if (oConvertUtils.isNotEmpty(username)) {
String COMMA = ",";
if (oConvertUtils.isNotEmpty(isMultiTranslate) && username.contains(COMMA)) {
String[] usernameArr = username.split(COMMA);
userNameList.addAll(Arrays.asList(usernameArr));
} else {
userName = username;
}
}
if (oConvertUtils.isNotEmpty(id)) {
String COMMA = ",";
if (oConvertUtils.isNotEmpty(isMultiTranslate) && id.contains(COMMA)) {
String[] idArr = id.split(COMMA);
userIdList.addAll(Arrays.asList(idArr));
} else {
userId = "";
}
}
//------------------------------------------------------------------------------------------------
//是否开启系统管理模块的多租户数据隔离【SAAS多租户模式】
if (MybatisPlusSaasConfig.OPEN_SYSTEM_TENANT_CONTROL) {
String tenantId = oConvertUtils.getString(TenantContext.getTenant(), "0");
List<String> userIdsList = userTenantMapper.getUserIdsByTenantId(Integer.valueOf(tenantId));
if (null != userIdsList && !userIdsList.isEmpty()) {
userIdList.addAll(userIdsList);
}
}
//------------------------------------------------------------------------------------------------
return sysUserMapper.getDepPostListByIdUserName(page,userIdList,userId,userName,userNameList);
}
/**
* 根据部门id、用户名和真实姓名获取部门岗位用户分页列表
*
* @param departId
* @param username
* @param realname
* @param page
* @return
*/
private IPage<SysUser> getDepartPostListByIdUserRealName(String departId, String username, String realname, Page<SysUser> page) {
SysDepart sysDepart = sysDepartService.getById(departId);
return sysUserMapper.getDepartPostListByIdUserRealName(page, username, realname, sysDepart.getOrgCode());
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysTableWhiteListServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysTableWhiteListServiceImpl.java | package org.jeecg.modules.system.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.config.firewall.SqlInjection.IDictTableWhiteListHandler;
import org.jeecg.modules.system.entity.SysTableWhiteList;
import org.jeecg.modules.system.mapper.SysTableWhiteListMapper;
import org.jeecg.modules.system.service.ISysTableWhiteListService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import java.util.*;
/**
* @Description: 系统表白名单
* @Author: jeecg-boot
* @Date: 2023-09-12
* @Version: V1.0
*/
@Slf4j
@Service
public class SysTableWhiteListServiceImpl extends ServiceImpl<SysTableWhiteListMapper, SysTableWhiteList> implements ISysTableWhiteListService {
@Lazy
@Autowired
IDictTableWhiteListHandler whiteListHandler;
@Override
public boolean add(SysTableWhiteList sysTableWhiteList) {
this.checkEntity(sysTableWhiteList);
if (super.save(sysTableWhiteList)) {
// 清空缓存
whiteListHandler.clear();
return true;
}
return false;
}
@Override
public boolean edit(SysTableWhiteList sysTableWhiteList) {
this.checkEntity(sysTableWhiteList);
if (super.updateById(sysTableWhiteList)) {
// 清空缓存
whiteListHandler.clear();
return true;
}
return false;
}
/**
* 检查需要新增或更新的实体是否符合规范
*
* @param sysTableWhiteList
*/
private void checkEntity(SysTableWhiteList sysTableWhiteList) {
if (sysTableWhiteList == null) {
throw new JeecgBootException("操作失败，实体为空！");
}
if (oConvertUtils.isEmpty(sysTableWhiteList.getTableName())) {
throw new JeecgBootException("操作失败，表名不能为空！");
}
if (oConvertUtils.isEmpty(sysTableWhiteList.getFieldName())) {
throw new JeecgBootException("操作失败，字段名不能为空！");
}
// 将表名和字段名转换成小写
sysTableWhiteList.setTableName(sysTableWhiteList.getTableName().toLowerCase());
sysTableWhiteList.setFieldName(sysTableWhiteList.getFieldName().toLowerCase());
// 如果status为空，则默认启用
if (oConvertUtils.isEmpty(sysTableWhiteList.getStatus())) {
sysTableWhiteList.setStatus(CommonConstant.STATUS_1);
}
}
@Override
public boolean deleteByIds(String ids) {
if (oConvertUtils.isEmpty(ids)) {
return false;
}
List<String> idList = Arrays.asList(ids.split(","));
if (super.removeByIds(idList)) {
// 清空缓存
whiteListHandler.clear();
return true;
}
return false;
}
@Override
public SysTableWhiteList autoAdd(String tableName, String fieldName) {
if (oConvertUtils.isEmpty(tableName)) {
throw new JeecgBootException("操作失败，表名不能为空！");
}
if (oConvertUtils.isEmpty(fieldName)) {
throw new JeecgBootException("操作失败，字段名不能为空！");
}
// 统一转换成小写
tableName = tableName.toLowerCase();
fieldName = fieldName.toLowerCase();
// 查询是否已经存在
LambdaQueryWrapper<SysTableWhiteList> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SysTableWhiteList::getTableName, tableName);
SysTableWhiteList getEntity = super.getOne(queryWrapper);
if (getEntity != null) {
// 如果已经存在，并且已禁用，则抛出异常
if (CommonConstant.STATUS_0.equals(getEntity.getStatus())) {
throw new JeecgBootException("[白名单] 表名已存在，但是已被禁用，请先启用！tableName=" + tableName);
}
// 合并字段
Set<String> oldFieldSet = new HashSet<>(Arrays.asList(getEntity.getFieldName().split(",")));
Set<String> newFieldSet = new HashSet<>(Arrays.asList(fieldName.split(",")));
oldFieldSet.addAll(newFieldSet);
getEntity.setFieldName(String.join(",", oldFieldSet));
this.checkEntity(getEntity);
super.updateById(getEntity);
log.info("修改表单白名单项，表名：{}，oldFieldSet： {}，newFieldSet：{}", tableName, oldFieldSet.toArray(), newFieldSet.toArray());
return getEntity;
} else {
// 新增白名单项
SysTableWhiteList saveEntity = new SysTableWhiteList();
saveEntity.setTableName(tableName);
saveEntity.setFieldName(fieldName);
saveEntity.setStatus(CommonConstant.STATUS_1);
this.checkEntity(saveEntity);
super.save(saveEntity);
log.info("新增表单白名单项: 表名：{}，配置 > {}", tableName, saveEntity.toString());
return saveEntity;
}
}
@Override
public Map<String, String> getAllConfigMap() {
Map<String, String> map = new HashMap<>();
List<SysTableWhiteList> allData = super.list();
for (SysTableWhiteList item : allData) {
// 只有启用的才放入map
if (CommonConstant.STATUS_1.equals(item.getStatus())) {
// 表名和字段名都转成小写，防止大小写不一致
map.put(item.getTableName().toLowerCase(), item.getFieldName().toLowerCase());
}
}
return map;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysUserDepPostServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysUserDepPostServiceImpl.java | package org.jeecg.modules.system.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.jeecg.modules.system.entity.SysUserDepPost;
import org.jeecg.modules.system.mapper.SysUserDepPostMapper;
import org.jeecg.modules.system.service.ISysUserDepPostService;
import org.springframework.stereotype.Service;
/**
* @Description: 部门岗位用户实现类
* @author: wangshuai
* @date: 2025/9/5 11:46
*/
@Service
public class SysUserDepPostServiceImpl extends ServiceImpl<SysUserDepPostMapper, SysUserDepPost> implements ISysUserDepPostService {
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysUserTenantServiceImpl.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/service/impl/SysUserTenantServiceImpl.java | package org.jeecg.modules.system.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.commons.lang.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.constant.CacheConstant;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.CommonUtils;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysTenant;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.entity.SysUserTenant;
import org.jeecg.modules.system.mapper.SysTenantPackUserMapper;
import org.jeecg.modules.system.mapper.SysUserMapper;
import org.jeecg.modules.system.mapper.SysUserPositionMapper;
import org.jeecg.modules.system.mapper.SysUserTenantMapper;
import org.jeecg.modules.system.service.ISysUserTenantService;
import org.jeecg.modules.system.vo.SysUserDepVo;
import org.jeecg.modules.system.vo.SysUserTenantVo;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.transaction.annotation.Transactional;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @Description: sys_user_tenant_relation
* @Author: jeecg-boot
* @Date: 2022-12-23
* @Version: V1.0
*/
@Service
public class SysUserTenantServiceImpl extends ServiceImpl<SysUserTenantMapper, SysUserTenant> implements ISysUserTenantService {
@Autowired
private SysUserTenantMapper userTenantMapper;
@Autowired
private SysUserMapper userMapper;
@Autowired
private SysUserPositionMapper userPositionMapper;
@Autowired
private SysTenantPackUserMapper packUserMapper;
@Override
public Page<SysUser> getPageUserList(Page<SysUser> page, Integer userTenantId, SysUser user) {
return page.setRecords(userTenantMapper.getPageUserList(page,userTenantId,user));
}
@Override
public List<SysUser> setUserTenantIds(List<SysUser> records) {
if(null == records || records.size() == 0){
return records;
}
for (SysUser sysUser:records) {
//查询租户id
List<Integer> list = userTenantMapper.getTenantIdsByUserId(sysUser.getId());
if(oConvertUtils.isNotEmpty(list)){
sysUser.setRelTenantIds(StringUtils.join(list.toArray(), SymbolConstant.COMMA));
}else{
sysUser.setRelTenantIds("");
}
}
return records;
}
@Override
public List<String> getUserIdsByTenantId(Integer tenantId) {
return userTenantMapper.getUserIdsByTenantId(tenantId);
}
@Override
public List<Integer> getTenantIdsByUserId(String userId) {
return userTenantMapper.getTenantIdsByUserId(userId);
}
@Override
public List<SysUserTenantVo> getTenantListByUserId(String userId, List<String> userTenantStatus) {
List<SysUserTenantVo> tenantListByUserId = userTenantMapper.getTenantListByUserId(userId, userTenantStatus);
// 代码逻辑说明: 【QQYUN-7283】1.已经是会员的租户，不是管理员时，没有购买按钮---
String noVip = "default";
tenantListByUserId.forEach((item) ->{
if(oConvertUtils.isNotEmpty(item.getMemberType()) && !noVip.equals(item.getMemberType())){
//查询是不是管理员
Long count = packUserMapper.izHaveBuyAuth(item.getId(), Integer.valueOf(item.getTenantUserId()));
if(count!=0){
item.setTenantAdmin(true);
}
}
});
return tenantListByUserId;
}
@Override
public void updateUserTenantStatus(String id, String tenantId, String userTenantStatus) {
if (oConvertUtils.isEmpty(tenantId)) {
throw new JeecgBootException("租户数据为空");
}
LambdaQueryWrapper<SysUserTenant> query = new LambdaQueryWrapper<>();
query.eq(SysUserTenant::getUserId, id);
query.eq(SysUserTenant::getTenantId, Integer.valueOf(tenantId));
SysUserTenant userTenant = userTenantMapper.selectOne(query);
if (null == userTenant) {
throw new JeecgBootException("租户数据为空");
}
SysUserTenant tenant = new SysUserTenant();
tenant.setStatus(userTenantStatus);
this.update(tenant, query);
}
@Override
public IPage<SysUserTenantVo> getUserTenantPageList(Page<SysUserTenantVo> page, List<String> status, SysUser user, Integer tenantId) {
List<SysUserTenantVo> tenantPageList = userTenantMapper.getUserTenantPageList(page, status, user, tenantId);
List<String> userIds = tenantPageList.stream().map(SysUserTenantVo::getId).collect(Collectors.toList());
if (userIds != null && userIds.size() > 0) {
Map<String, String> useDepNames = this.getDepNamesByUserIds(userIds);
tenantPageList.forEach(item -> {
item.setOrgCodeTxt(useDepNames.get(item.getId()));
//查询用户的租户ids
List<Integer> list = userTenantMapper.getTenantIdsNoStatus(item.getId());
if (oConvertUtils.isNotEmpty(list)) {
item.setRelTenantIds(StringUtils.join(list.toArray(), SymbolConstant.COMMA));
} else {
item.setRelTenantIds("");
}
//查询用户职位，将租户id传到前台
List<String> positionList = userPositionMapper.getPositionIdByUserId(item.getId());
item.setPost(CommonUtils.getSplitText(positionList,SymbolConstant.COMMA));
});
}
return page.setRecords(tenantPageList);
}
/**
* 根据用户id获取部门名称
*
* @param userIds
* @return
*/
public Map<String, String> getDepNamesByUserIds(List<String> userIds) {
List<SysUserDepVo> list = userMapper.getDepNamesByUserIds(userIds);
Map<String, String> res = new HashMap(5);
list.forEach(item -> {
if (res.get(item.getUserId()) == null) {
res.put(item.getUserId(), item.getDepartName());
} else {
res.put(item.getUserId(), res.get(item.getUserId()) + "," + item.getDepartName());
}
}
);
return res;
}
@Override
@CacheEvict(value={CacheConstant.SYS_USERS_CACHE}, allEntries=true)
@Transactional(rollbackFor = Exception.class)
public void putCancelQuit(List<String> userIds, Integer tenantId) {
userTenantMapper.putCancelQuit(userIds, tenantId);
}
@Override
public Integer userTenantIzExist(String userId, Integer tenantId) {
return userTenantMapper.userTenantIzExist(userId,tenantId);
}
@Override
public IPage<SysTenant> getTenantPageListByUserId(Page<SysTenant> page, String userId, List<String> userTenantStatus,SysUserTenantVo sysUserTenantVo) {
return page.setRecords(userTenantMapper.getTenantPageListByUserId(page,userId,userTenantStatus,sysUserTenantVo));
}
@CacheEvict(value={CacheConstant.SYS_USERS_CACHE}, allEntries=true)
@Override
public void agreeJoinTenant(String userId, Integer tenantId) {
userTenantMapper.agreeJoinTenant(userId,tenantId);
}
@Override
public void refuseJoinTenant(String userId, Integer tenantId) {
userTenantMapper.refuseJoinTenant(userId,tenantId);
}
@Override
public SysUserTenant getUserTenantByTenantId(String userId, Integer tenantId) {
return userTenantMapper.getUserTenantByTenantId(userId,tenantId);
}
@Override
public Long getUserCount(Integer tenantId, String tenantStatus) {
return userTenantMapper.getUserCount(tenantId,tenantStatus);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/excelstyle/ExcelExportSysUserStyle.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/excelstyle/ExcelExportSysUserStyle.java | package org.jeecg.modules.system.excelstyle;
import org.apache.poi.ss.usermodel.*;
import org.jeecgframework.poi.excel.export.styler.ExcelExportStylerDefaultImpl;
/**
* @Description: 导入用户获取标题头部样式 覆盖默认样式
*
* @author: wangshuai
* @date: 2025/8/28 14:05
*/
public class ExcelExportSysUserStyle extends ExcelExportStylerDefaultImpl {
public ExcelExportSysUserStyle(Workbook workbook) {
super(workbook);
}
/**
* 获取标题样式
*
* @param color
* @return
*/
public CellStyle getHeaderStyle(short color) {
CellStyle titleStyle = this.workbook.createCellStyle();
Font font = this.workbook.createFont();
font.setFontHeightInPoints((short)12);
titleStyle.setFont(font);
titleStyle.setAlignment(HorizontalAlignment.LEFT);
titleStyle.setVerticalAlignment(VerticalAlignment.CENTER);
titleStyle.setWrapText(true);
return titleStyle;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/rule/OrgCodeRule.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/rule/OrgCodeRule.java | package org.jeecg.modules.system.rule;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.netty.util.internal.StringUtil;
import org.jeecg.common.handler.IFillRuleHandler;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.common.util.YouBianCodeUtil;
import org.jeecg.modules.system.entity.SysDepart;
import org.jeecg.modules.system.service.ISysDepartService;
import java.util.ArrayList;
import java.util.List;
/**
* @Author scott
* @Date 2019/12/9 11:33
* @Description: 机构编码生成规则
*/
public class OrgCodeRule implements IFillRuleHandler {
@Override
public Object execute(JSONObject params, JSONObject formData) {
ISysDepartService sysDepartService = (ISysDepartService) SpringContextUtils.getBean("sysDepartServiceImpl");
LambdaQueryWrapper<SysDepart> query = new LambdaQueryWrapper<SysDepart>();
LambdaQueryWrapper<SysDepart> query1 = new LambdaQueryWrapper<SysDepart>();
// 创建一个List集合,存储查询返回的所有SysDepart对象
List<SysDepart> departList = new ArrayList<>();
String[] strArray = new String[2];
//定义部门类型
String orgType = "";
// 定义新编码字符串
String newOrgCode = "";
// 定义旧编码字符串
String oldOrgCode = "";
String parentId = null;
if (formData != null && formData.size() > 0) {
Object obj = formData.get("parentId");
if (obj != null) {
parentId = obj.toString();
}
} else {
if (params != null) {
Object obj = params.get("parentId");
if (obj != null) {
parentId = obj.toString();
}
}
}
//如果是最高级,则查询出同级的org_code, 调用工具类生成编码并返回
if (StringUtil.isNullOrEmpty(parentId)) {
// 线判断数据库中的表是否为空,空则直接返回初始编码
//获取最大值code的部门信息
// 代码逻辑说明: [QQYUN-4209]租户隔离下部门新建不了------------
Page<SysDepart> page = new Page<>(1,1);
IPage<SysDepart> pageList = sysDepartService.getMaxCodeDepart(page,"");
List<SysDepart> records = pageList.getRecords();
if (null==records || records.size()==0) {
strArray[0] = YouBianCodeUtil.getNextYouBianCode(null);
strArray[1] = "1";
return strArray;
} else {
SysDepart depart = records.get(0);
oldOrgCode = depart.getOrgCode();
orgType = depart.getOrgType();
newOrgCode = YouBianCodeUtil.getNextYouBianCode(oldOrgCode);
}
} else {//反之则查询出所有同级的部门,获取结果后有两种情况,有同级和没有同级
//获取自己部门最大值orgCode部门信息
// 代码逻辑说明: [QQYUN-4209]租户隔离下部门新建不了------------
Page<SysDepart> page = new Page<>(1,1);
IPage<SysDepart> pageList = sysDepartService.getMaxCodeDepart(page,parentId);
List<SysDepart> records = pageList.getRecords();
// 查询出父级部门
SysDepart depart = sysDepartService.getDepartById(parentId);
// 获取父级部门的Code
String parentCode = depart.getOrgCode();
// 根据父级部门类型算出当前部门的类型
orgType = String.valueOf(Integer.valueOf(depart.getOrgType()) + 1);
// 处理同级部门为null的情况
if (null == records || records.size()==0) {
// 直接生成当前的部门编码并返回
newOrgCode = YouBianCodeUtil.getSubYouBianCode(parentCode, null);
} else { //处理有同级部门的情况
// 获取同级部门的编码,利用工具类
String subCode = records.get(0).getOrgCode();
// 返回生成的当前部门编码
newOrgCode = YouBianCodeUtil.getSubYouBianCode(parentCode, subCode);
}
}
// 返回最终封装了部门编码和部门类型的数组
strArray[0] = newOrgCode;
strArray[1] = orgType;
return strArray;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/rule/CategoryCodeRule.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/rule/CategoryCodeRule.java | package org.jeecg.modules.system.rule;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.handler.IFillRuleHandler;
import org.jeecg.common.util.SpringContextUtils;
import org.jeecg.common.util.YouBianCodeUtil;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.system.entity.SysCategory;
import org.jeecg.modules.system.mapper.SysCategoryMapper;
import java.util.List;
/**
* @Author scott
* @Date 2019/12/9 11:32
* @Description: 分类字典编码生成规则
*/
@Slf4j
public class CategoryCodeRule implements IFillRuleHandler {
public static final String ROOT_PID_VALUE = "0";
@Override
public Object execute(JSONObject params, JSONObject formData) {
log.info("系统自定义编码规则[category_code_rule]，params：{} ，formData： {}", params, formData);
String categoryPid = ROOT_PID_VALUE;
String categoryCode = null;
if (formData != null && formData.size() > 0) {
Object obj = formData.get("pid");
if (oConvertUtils.isNotEmpty(obj)) {
categoryPid = obj.toString();
}
} else {
if (params != null) {
Object obj = params.get("pid");
if (oConvertUtils.isNotEmpty(obj)) {
categoryPid = obj.toString();
}
}
}
/*
* 分成三种情况
* 1.数据库无数据 调用YouBianCodeUtil.getNextYouBianCode(null);
* 2.添加子节点，无兄弟元素 YouBianCodeUtil.getSubYouBianCode(parentCode,null);
* 3.添加子节点有兄弟元素 YouBianCodeUtil.getNextYouBianCode(lastCode);
* */
//找同类 确定上一个最大的code值
SysCategoryMapper baseMapper = (SysCategoryMapper) SpringContextUtils.getBean("sysCategoryMapper");
// 代码逻辑说明: 【issues/4846】开启saas多租户功能后，租户管理员在添加分类字典时，报错------------
Page<SysCategory> page = new Page<>(1,1);
List<SysCategory> list = baseMapper.getMaxCategoryCodeByPage(page,categoryPid);
if (list == null || list.size() == 0) {
if (ROOT_PID_VALUE.equals(categoryPid)) {
//情况1
categoryCode = YouBianCodeUtil.getNextYouBianCode(null);
} else {
//情况2
SysCategory parent = (SysCategory) baseMapper.selectSysCategoryById(categoryPid);
categoryCode = YouBianCodeUtil.getSubYouBianCode(parent.getCode(), null);
}
} else {
//情况3
categoryCode = YouBianCodeUtil.getNextYouBianCode(list.get(0).getCode());
}
return categoryCode;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/rule/OrderNumberRule.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/rule/OrderNumberRule.java | package org.jeecg.modules.system.rule;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.math.RandomUtils;
import org.jeecg.common.handler.IFillRuleHandler;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 填值规则Demo：生成订单号
* 【测试示例】
*/
public class OrderNumberRule implements IFillRuleHandler {
@Override
public Object execute(JSONObject params, JSONObject formData) {
String prefix = "CN";
//订单前缀默认为CN 如果规则参数不为空，则取自定义前缀
if (params != null) {
Object obj = params.get("prefix");
if (obj != null) prefix = obj.toString();
}
SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss");
int random = RandomUtils.nextInt(90) + 10;
String value = prefix + format.format(new Date()) + random;
// 根据formData的值的不同，生成不同的订单号
String name = formData.getString("name");
if (!StringUtils.isEmpty(name)) {
value += name;
}
return value;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/cache/AuthStateRedisCache.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/cache/AuthStateRedisCache.java | package org.jeecg.modules.system.cache;
import jakarta.annotation.PostConstruct;
import me.zhyd.oauth.cache.AuthCacheConfig;
import me.zhyd.oauth.cache.AuthStateCache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import java.util.concurrent.TimeUnit;
public class AuthStateRedisCache implements AuthStateCache {
@Autowired
private RedisTemplate<String, String> redisTemplate;
private ValueOperations<String, String> valueOperations;
@PostConstruct
public void init() {
valueOperations = redisTemplate.opsForValue();
}
/**
* 存入缓存，默认3分钟
*
* @param key 缓存key
* @param value 缓存内容
*/
@Override
public void cache(String key, String value) {
valueOperations.set(key, value, AuthCacheConfig.timeout, TimeUnit.MILLISECONDS);
}
/**
* 存入缓存
*
* @param key 缓存key
* @param value 缓存内容
* @param timeout 指定缓存过期时间（毫秒）
*/
@Override
public void cache(String key, String value, long timeout) {
valueOperations.set(key, value, timeout, TimeUnit.MILLISECONDS);
}
/**
* 获取缓存内容
*
* @param key 缓存key
* @return 缓存内容
*/
@Override
public String get(String key) {
return valueOperations.get(key);
}
/**
* 是否存在key，如果对应key的value值已过期，也返回false
*
* @param key 缓存key
* @return true：存在key，并且value没过期；false：key不存在或者已过期
*/
@Override
public boolean containsKey(String key) {
return redisTemplate.hasKey(key);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/SysUserSysDepartModel.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/SysUserSysDepartModel.java | package org.jeecg.modules.system.model;
import lombok.Data;
import org.jeecg.modules.system.entity.SysDepart;
import org.jeecg.modules.system.entity.SysUser;
/**
* 包含 SysUser 和 SysDepart 的 Model
*
* @author sunjianlei
*/
@Data
public class SysUserSysDepartModel {
private String id;
private String realname;
private String workNo;
private String post;
private String telephone;
private String email;
private String phone;
private String departId;
private String departName;
private String avatar;
private String sex;
private String birthday;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/SysUserSysDepPostModel.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/SysUserSysDepPostModel.java | package org.jeecg.modules.system.model;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import org.jeecg.common.aspect.annotation.Dict;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;
/**
* @Description: 部门用户和部门岗位用户的Model
* @author: wangshuai
* @date: 2025/9/5 16:43
*/
@Data
public class SysUserSysDepPostModel {
/**
* 用户ID
*/
private String id;
/**
* 用户名
*/
private String username;
/* 真实姓名 */
private String realname;
/**
* 头像
*/
@Excel(name = "头像", width = 15, type = 2)
private String avatar;
/**
* 生日
*/
@Excel(name = "生日", width = 15, format = "yyyy-MM-dd")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date birthday;
/**
* 性别（1：男 2：女）
*/
@Excel(name = "性别", width = 15, dicCode = "sex")
@Dict(dicCode = "sex")
private Integer sex;
/**
* 电子邮件
*/
@Excel(name = "电子邮件", width = 15)
private String email;
/**
* 电话
*/
@Excel(name = "电话", width = 15)
private String phone;
/**
* 状态(1：正常 2：冻结 ）
*/
@Excel(name = "状态", width = 15, dicCode = "user_status")
@Dict(dicCode = "user_status")
private Integer status;
/**
* 删除状态（0，正常，1已删除）
*/
@Excel(name = "删除状态", width = 15, dicCode = "del_flag")
@TableLogic
private Integer delFlag;
/**
* 座机号
*/
@Excel(name = "座机号", width = 15)
private String telephone;
/**
* 身份（0 普通成员 1 上级）
*/
@Excel(name = "（1普通成员 2上级）", width = 15)
private Integer userIdentity;
/**
* 负责部门
*/
@Excel(name = "负责部门", width = 15, dictTable = "sys_depart", dicText = "depart_name", dicCode = "id")
@Dict(dictTable = "sys_depart", dicText = "depart_name", dicCode = "id")
private String departIds;
/**
* 多租户ids临时用，不持久化数据库(数据库字段不存在)
*/
private String relTenantIds;
/**
* 同步工作流引擎(1-同步 0-不同步)
*/
private String activitiSync;
/**
* 主岗位
*/
@Excel(name = "主岗位", width = 15, dictTable = "sys_depart", dicText = "depart_name", dicCode = "id")
@Dict(dictTable = "sys_depart", dicText = "depart_name", dicCode = "id")
private String mainDepPostId;
/**
* 兼职岗位
*/
@Excel(name = "兼职岗位", width = 15, dictTable = "sys_depart", dicText = "depart_name", dicCode = "id")
@Dict(dictTable = "sys_depart", dicText = "depart_name", dicCode = "id")
@TableField(exist = false)
private String otherDepPostId;
/**
* 部门名称
*/
private String departName;
/**
* 主岗位
*/
private String postName;
/**
* 兼职岗位
*/
private String otherPostName;
/**
* 部门text
*/
private String orgCodeTxt;
/**
* 职务
*/
private String post;
/**
* 部门编码
*/
private String orgCode;
/**
* 职务（字典）
*/
private String positionType;
/**
* 排序
*/
private Integer sort;
/**
* 是否隐藏联系方式 0否1是
*/
private String izHideContact;
/**
* 工号
*/
private String workNo;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/DepartIdModel.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/DepartIdModel.java | package org.jeecg.modules.system.model;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import org.jeecg.modules.system.entity.SysDepart;
/**
* <p>
* 部门表 封装树结构的部门的名称的实体类
* <p>
*
* @Author Steve
* @Since 2019-01-22
*
*/
public class DepartIdModel implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
private String key;
/**
* 主键ID
*/
private String value;
/**
* 部门编码
*/
private String code;
/**
* 部门名称
*/
private String title;
List<DepartIdModel> children = new ArrayList<>();
/**
* 将SysDepartTreeModel的部分数据放在该对象当中
* @param treeModel
* @return
*/
public DepartIdModel convert(SysDepartTreeModel treeModel) {
this.key = treeModel.getId();
this.value = treeModel.getId();
this.title = treeModel.getDepartName();
return this;
}
/**
* 该方法为用户部门的实现类所使用
* @param sysDepart
* @return
*/
public DepartIdModel convertByUserDepart(SysDepart sysDepart) {
this.key = sysDepart.getId();
this.value = sysDepart.getId();
this.code = sysDepart.getOrgCode();
this.title = sysDepart.getDepartName();
return this;
}
public List<DepartIdModel> getChildren() {
return children;
}
public void setChildren(List<DepartIdModel> children) {
this.children = children;
}
public static long getSerialVersionUID() {
return serialVersionUID;
}
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/DuplicateCheckVo.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/DuplicateCheckVo.java | package org.jeecg.modules.system.model;
import java.io.Serializable;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
/**
* @Title: DuplicateCheckVo
* @Description: 重复校验VO
* @Author 张代浩
* @Date 2019-03-25
* @Version V1.0
*/
@Data
@Schema(description="重复校验数据模型")
public class DuplicateCheckVo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 表名
*/
@Schema(description="表名",name="tableName",example="sys_log")
private String tableName;
/**
* 字段名
*/
@Schema(description="字段名",name="fieldName",example="id")
private String fieldName;
/**
* 字段值
*/
@Schema(description="字段值",name="fieldVal",example="1000")
private String fieldVal;
/**
* 数据ID
*/
@Schema(description="数据ID",name="dataId",example="2000")
private String dataId;
} | java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/SysPermissionTree.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/SysPermissionTree.java | package org.jeecg.modules.system.model;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.jeecg.modules.system.entity.SysPermission;
/**
* @Description: 菜单树，封装树结构
* @author: jeecg-boot
*/
public class SysPermissionTree implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
private String id;
private String key;
private String title;
/**
* 父id
*/
private String parentId;
/**
* 菜单名称
*/
private String name;
/**
* 菜单权限编码
*/
private String perms;
/**
* 权限策略1显示2禁用
*/
private String permsType;
/**
* 菜单图标
*/
private String icon;
/**
* 组件
*/
private String component;
/**
* 组件名字
*/
private String componentName;
/**
* 跳转网页链接
*/
private String url;
/**
* 一级菜单跳转地址
*/
private String redirect;
/**
* 菜单排序
*/
private Double sortNo;
/**
* 类型（0：一级菜单；1：子菜单 ；2：按钮权限）
*/
private Integer menuType;
/**
* 是否叶子节点: 1:是 0:不是
*/
private boolean isLeaf;
/**
* 是否路由菜单: 0:不是 1:是（默认值1）
*/
private boolean route;
/**
* 是否路缓存页面: 0:不是 1:是（默认值1）
*/
private boolean keepAlive;
/**
* 描述
*/
private String description;
/**
* 删除状态 0正常 1已删除
*/
private Integer delFlag;
/**
* 创建人
*/
private String createBy;
/**
* 创建时间
*/
private Date createTime;
/**
* 更新人
*/
private String updateBy;
/**
* 更新时间
*/
private Date updateTime;
/**alwaysShow*/
private boolean alwaysShow;
/**是否隐藏路由菜单: 0否,1是（默认值0）*/
private boolean hidden;
/**按钮权限状态(0无效1有效)*/
private java.lang.String status;
/*update_begin author:wuxianquan date:20190908 for:model增加字段 */
/** 外链菜单打开方式 0/内部打开 1/外部打开 */
private boolean internalOrExternal;
/*update_end author:wuxianquan date:20190908 for:model增加字段 */
/*update_begin author:liusq date:20230601 for:【issues/4986】model增加hideTab字段 */
/**
* 是否隐藏Tab: 0否,1是（默认值0）
*/
private boolean hideTab;
/*update_end author:liusq date:20230601 for:【issues/4986】model增加hideTab字段 */
public SysPermissionTree() {
}
public SysPermissionTree(SysPermission permission) {
this.key = permission.getId();
this.id = permission.getId();
this.perms = permission.getPerms();
this.permsType = permission.getPermsType();
this.component = permission.getComponent();
this.componentName = permission.getComponentName();
this.createBy = permission.getCreateBy();
this.createTime = permission.getCreateTime();
this.delFlag = permission.getDelFlag();
this.description = permission.getDescription();
this.icon = permission.getIcon();
this.isLeaf = permission.isLeaf();
this.menuType = permission.getMenuType();
this.name = permission.getName();
this.parentId = permission.getParentId();
this.sortNo = permission.getSortNo();
this.updateBy = permission.getUpdateBy();
this.updateTime = permission.getUpdateTime();
this.redirect = permission.getRedirect();
this.url = permission.getUrl();
this.hidden = permission.isHidden();
this.route = permission.isRoute();
this.keepAlive = permission.isKeepAlive();
this.alwaysShow= permission.isAlwaysShow();
/*update_begin author:wuxianquan date:20190908 for:赋值 */
this.internalOrExternal = permission.isInternalOrExternal();
/*update_end author:wuxianquan date:20190908 for:赋值 */
this.title=permission.getName();
/*update_end author:liusq date:20230601 for:【issues/4986】model增加hideTab字段 */
this.hideTab = permission.isHideTab();
/*update_end author:liusq date:20230601 for:【issues/4986】model增加hideTab字段 */
if (!permission.isLeaf()) {
this.children = new ArrayList<SysPermissionTree>();
}
this.status = permission.getStatus();
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
private List<SysPermissionTree> children;
public boolean isLeaf() {
return isLeaf;
}
public void setLeaf(boolean leaf) {
isLeaf = leaf;
}
public boolean isKeepAlive() {
return keepAlive;
}
public void setKeepAlive(boolean keepAlive) {
this.keepAlive = keepAlive;
}
public boolean isAlwaysShow() {
return alwaysShow;
}
public void setAlwaysShow(boolean alwaysShow) {
this.alwaysShow = alwaysShow;
}
public List<SysPermissionTree> getChildren() {
return children;
}
public void setChildren(List<SysPermissionTree> children) {
this.children = children;
}
public String getRedirect() {
return redirect;
}
public void setRedirect(String redirect) {
this.redirect = redirect;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getParentId() {
return parentId;
}
public void setParentId(String parentId) {
this.parentId = parentId;
}
public boolean isHidden() {
return hidden;
}
public void setHidden(boolean hidden) {
this.hidden = hidden;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getIcon() {
return icon;
}
public void setIcon(String icon) {
this.icon = icon;
}
public String getComponent() {
return component;
}
public void setComponent(String component) {
this.component = component;
}
public String getComponentName() {
return componentName;
}
public void setComponentName(String componentName) {
this.componentName = componentName;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public Double getSortNo() {
return sortNo;
}
public void setSortNo(Double sortNo) {
this.sortNo = sortNo;
}
public Integer getMenuType() {
return menuType;
}
public void setMenuType(Integer menuType) {
this.menuType = menuType;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public boolean isRoute() {
return route;
}
public void setRoute(boolean route) {
this.route = route;
}
public Integer getDelFlag() {
return delFlag;
}
public void setDelFlag(Integer delFlag) {
this.delFlag = delFlag;
}
public String getCreateBy() {
return createBy;
}
public void setCreateBy(String createBy) {
this.createBy = createBy;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public String getUpdateBy() {
return updateBy;
}
public void setUpdateBy(String updateBy) {
this.updateBy = updateBy;
}
public Date getUpdateTime() {
return updateTime;
}
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
public String getPerms() {
return perms;
}
public void setPerms(String perms) {
this.perms = perms;
}
public boolean getIsLeaf() {
return isLeaf;
}
public void setIsLeaf(boolean isLeaf) {
this.isLeaf = isLeaf;
}
public String getPermsType() {
return permsType;
}
public void setPermsType(String permsType) {
this.permsType = permsType;
}
public java.lang.String getStatus() {
return status;
}
public void setStatus(java.lang.String status) {
this.status = status;
}
/*update_begin author:wuxianquan date:20190908 for:get set方法 */
public boolean isInternalOrExternal() {
return internalOrExternal;
}
public void setInternalOrExternal(boolean internalOrExternal) {
this.internalOrExternal = internalOrExternal;
}
/*update_end author:wuxianquan date:20190908 for:get set 方法 */
public boolean isHideTab() {
return hideTab;
}
public void setHideTab(boolean hideTab) {
this.hideTab = hideTab;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/TreeModel.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/TreeModel.java | package org.jeecg.modules.system.model;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.jeecg.modules.system.entity.SysPermission;
/**
* 树形列表用到
* @author: jeecg-boot
*/
public class TreeModel implements Serializable {
private static final long serialVersionUID = 4013193970046502756L;
private String key;
private String title;
private String slotTitle;
private Boolean isLeaf;
private String icon;
private Integer ruleFlag;
private Map<String,String> scopedSlots;
public Map<String, String> getScopedSlots() {
return scopedSlots;
}
public void setScopedSlots(Map<String, String> scopedSlots) {
this.scopedSlots = scopedSlots;
}
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public Boolean getIsLeaf() {
return isLeaf;
}
public void setIsLeaf(Boolean isLeaf) {
this.isLeaf = isLeaf;
}
public String getIcon() {
return icon;
}
public void setIcon(String icon) {
this.icon = icon;
}
private List<TreeModel> children;
public List<TreeModel> getChildren() {
return children;
}
public void setChildren(List<TreeModel> children) {
this.children = children;
}
public TreeModel() {
}
public TreeModel(SysPermission permission) {
this.key = permission.getId();
this.icon = permission.getIcon();
this.parentId = permission.getParentId();
this.title = permission.getName();
this.slotTitle = permission.getName();
this.value = permission.getId();
this.isLeaf = permission.isLeaf();
this.label = permission.getName();
if(!permission.isLeaf()) {
this.children = new ArrayList<TreeModel>();
}
}
public TreeModel(String key,String parentId,String slotTitle,Integer ruleFlag,boolean isLeaf) {
this.key = key;
this.parentId = parentId;
this.ruleFlag=ruleFlag;
this.slotTitle = slotTitle;
Map<String,String> map = new HashMap(5);
map.put("title", "hasDatarule");
this.scopedSlots = map;
this.isLeaf = isLeaf;
this.value = key;
if(!isLeaf) {
this.children = new ArrayList<TreeModel>();
}
}
private String parentId;
private String label;
private String value;
public String getParentId() {
return parentId;
}
public void setParentId(String parentId) {
this.parentId = parentId;
}
/**
* @return the label
*/
public String getLabel() {
return label;
}
/**
* @param label the label to set
*/
public void setLabel(String label) {
this.label = label;
}
/**
* @return the value
*/
public String getValue() {
return value;
}
/**
* @param value the value to set
*/
public void setValue(String value) {
this.value = value;
}
public String getSlotTitle() {
return slotTitle;
}
public void setSlotTitle(String slotTitle) {
this.slotTitle = slotTitle;
}
public Integer getRuleFlag() {
return ruleFlag;
}
public void setRuleFlag(Integer ruleFlag) {
this.ruleFlag = ruleFlag;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/AnnouncementSendModel.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/AnnouncementSendModel.java | package org.jeecg.modules.system.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
import java.util.List;
/**
* @Description: 用户通告阅读标记表
* @Author: jeecg-boot
* @Date: 2019-02-21
* @Version: V1.0
*/
@Data
public class AnnouncementSendModel implements Serializable {
private static final long serialVersionUID = 1L;
/**id*/
@TableId(type = IdType.ASSIGN_ID)
private java.lang.String id;
/**通告id*/
private java.lang.String anntId;
/**用户id*/
private java.lang.String userId;
/**标题*/
private java.lang.String titile;
/**内容*/
private java.lang.String msgContent;
/**发布人*/
private java.lang.String sender;
/**优先级（L低，M中，H高）*/
private java.lang.String priority;
/**阅读状态*/
private java.lang.Integer readFlag;
/**发布时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date sendTime;
/**页数*/
private java.lang.Integer pageNo;
/**大小*/
private java.lang.Integer pageSize;
/**
* 消息类型1:通知公告2:系统消息
*/
private java.lang.String msgCategory;
/**
* 业务id
*/
private java.lang.String busId;
/**
* 业务类型
*/
private java.lang.String busType;
/**
* 打开方式 组件：component 路由：url
*/
private java.lang.String openType;
/**
* 组件/路由 地址
*/
private java.lang.String openPage;
/**
* 业务类型查询（0.非bpm业务）
*/
private java.lang.String bizSource;
/**
* 摘要
*/
private java.lang.String msgAbstract;
/**
* 发布开始日期
*/
private java.lang.String sendTimeBegin;
/**
* 发布结束日期
*/
private java.lang.String sendTimeEnd;
/**
* 附件
*/
private java.lang.String files;
/**
* 访问量
*/
private java.lang.Integer visitsNum;
/**
* 是否置顶（0否 1是）
*/
private java.lang.Integer izTop;
/**
* 通知类型(plan:日程计划 | flow:流程消息 | meeting:会议 | file:知识库 | collab:协同通知 | supe:督办通知 | attendance:考勤)
*/
private java.lang.String noticeType;
/**
* 通告类型数组
*/
private List<String> noticeTypeList;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/SysDepartTreeModel.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/SysDepartTreeModel.java | package org.jeecg.modules.system.model;
import org.jeecg.modules.system.entity.SysDepart;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Objects;
/**
* <p>
* 部门表 存储树结构数据的实体类
* <p>
*
* @Author Steve
* @Since 2019-01-22
*/
public class SysDepartTreeModel implements Serializable{
private static final long serialVersionUID = 1L;
/** 对应SysDepart中的id字段,前端数据树中的key*/
private String key;
/** 对应SysDepart中的id字段,前端数据树中的value*/
private String value;
/** 对应depart_name字段,前端数据树中的title*/
private String title;
private boolean isLeaf;
// 以下所有字段均与SysDepart相同
private String id;
private String parentId;
private String departName;
private String departNameEn;
private String departNameAbbr;
private Integer departOrder;
private String description;
private String orgCategory;
private String orgType;
private String orgCode;
private String mobile;
private String fax;
private String address;
private String memo;
private String status;
private String delFlag;
private String qywxIdentifier;
private String createBy;
private Date createTime;
private String updateBy;
private Date updateTime;
/**部门负责人ids
* [JTC-119]在部门管理菜单下设置部门负责人，新增字段部门负责人ids
* */
private String directorUserIds;
/**职务*/
private String positionId;
/**上级岗位id*/
private String depPostParentId;
private List<SysDepartTreeModel> children = new ArrayList<>();
/**
* 将SysDepart对象转换成SysDepartTreeModel对象
* @param sysDepart
*/
public SysDepartTreeModel(SysDepart sysDepart) {
this.key = sysDepart.getId();
this.value = sysDepart.getId();
this.title = sysDepart.getDepartName();
this.id = sysDepart.getId();
this.parentId = sysDepart.getParentId();
this.departName = sysDepart.getDepartName();
this.departNameEn = sysDepart.getDepartNameEn();
this.departNameAbbr = sysDepart.getDepartNameAbbr();
this.departOrder = sysDepart.getDepartOrder();
this.description = sysDepart.getDescription();
this.orgCategory = sysDepart.getOrgCategory();
this.orgType = sysDepart.getOrgType();
this.orgCode = sysDepart.getOrgCode();
this.mobile = sysDepart.getMobile();
this.fax = sysDepart.getFax();
this.address = sysDepart.getAddress();
this.memo = sysDepart.getMemo();
this.status = sysDepart.getStatus();
this.delFlag = sysDepart.getDelFlag();
this.qywxIdentifier = sysDepart.getQywxIdentifier();
this.createBy = sysDepart.getCreateBy();
this.createTime = sysDepart.getCreateTime();
this.updateBy = sysDepart.getUpdateBy();
this.updateTime = sysDepart.getUpdateTime();
this.directorUserIds = sysDepart.getDirectorUserIds();
this.positionId = sysDepart.getPositionId();
this.depPostParentId = sysDepart.getDepPostParentId();
if(0 == sysDepart.getIzLeaf()){
this.isLeaf = false;
}else{
this.isLeaf = true;
}
}
public boolean getIsLeaf() {
return isLeaf;
}
public void setIsLeaf(boolean isleaf) {
this.isLeaf = isleaf;
}
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public List<SysDepartTreeModel> getChildren() {
return children;
}
public void setChildren(List<SysDepartTreeModel> children) {
if (children==null){
this.isLeaf=true;
}
this.children = children;
}
public String getParentId() {
return parentId;
}
public void setParentId(String parentId) {
this.parentId = parentId;
}
public static long getSerialVersionUID() {
return serialVersionUID;
}
public String getDepartName() {
return departName;
}
public void setDepartName(String departName) {
this.departName = departName;
}
public String getOrgCategory() {
return orgCategory;
}
public void setOrgCategory(String orgCategory) {
this.orgCategory = orgCategory;
}
public String getOrgType() {
return orgType;
}
public void setOrgType(String orgType) {
this.orgType = orgType;
}
public String getOrgCode() {
return orgCode;
}
public void setOrgCode(String orgCode) {
this.orgCode = orgCode;
}
public String getMobile() {
return mobile;
}
public void setMobile(String mobile) {
this.mobile = mobile;
}
public String getFax() {
return fax;
}
public void setFax(String fax) {
this.fax = fax;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getMemo() {
return memo;
}
public void setMemo(String memo) {
this.memo = memo;
}
public String getDepartNameEn() {
return departNameEn;
}
public void setDepartNameEn(String departNameEn) {
this.departNameEn = departNameEn;
}
public String getDepartNameAbbr() {
return departNameAbbr;
}
public void setDepartNameAbbr(String departNameAbbr) {
this.departNameAbbr = departNameAbbr;
}
public Integer getDepartOrder() {
return departOrder;
}
public void setDepartOrder(Integer departOrder) {
this.departOrder = departOrder;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getDelFlag() {
return delFlag;
}
public void setDelFlag(String delFlag) {
this.delFlag = delFlag;
}
public String getQywxIdentifier() {
return qywxIdentifier;
}
public void setQywxIdentifier(String qywxIdentifier) {
this.qywxIdentifier = qywxIdentifier;
}
public String getCreateBy() {
return createBy;
}
public void setCreateBy(String createBy) {
this.createBy = createBy;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public String getUpdateBy() {
return updateBy;
}
public void setUpdateBy(String updateBy) {
this.updateBy = updateBy;
}
public Date getUpdateTime() {
return updateTime;
}
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
public SysDepartTreeModel() { }
public String getDirectorUserIds() {
return directorUserIds;
}
public void setDirectorUserIds(String directorUserIds) {
this.directorUserIds = directorUserIds;
}
public String getPositionId() {
return positionId;
}
public void setPositionId(String positionId) {
this.positionId = positionId;
}
public String getDepPostParentId() {
return depPostParentId;
}
public void setDepPostParentId(String depPostParentId) {
this.depPostParentId = depPostParentId;
}
/**
* 重写equals方法
*/
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
SysDepartTreeModel model = (SysDepartTreeModel) o;
return Objects.equals(id, model.id) &&
Objects.equals(parentId, model.parentId) &&
Objects.equals(departName, model.departName) &&
Objects.equals(departNameEn, model.departNameEn) &&
Objects.equals(departNameAbbr, model.departNameAbbr) &&
Objects.equals(departOrder, model.departOrder) &&
Objects.equals(description, model.description) &&
Objects.equals(orgCategory, model.orgCategory) &&
Objects.equals(orgType, model.orgType) &&
Objects.equals(orgCode, model.orgCode) &&
Objects.equals(mobile, model.mobile) &&
Objects.equals(fax, model.fax) &&
Objects.equals(address, model.address) &&
Objects.equals(memo, model.memo) &&
Objects.equals(status, model.status) &&
Objects.equals(delFlag, model.delFlag) &&
Objects.equals(qywxIdentifier, model.qywxIdentifier) &&
Objects.equals(createBy, model.createBy) &&
Objects.equals(createTime, model.createTime) &&
Objects.equals(updateBy, model.updateBy) &&
Objects.equals(updateTime, model.updateTime) &&
Objects.equals(directorUserIds, model.directorUserIds) &&
Objects.equals(positionId, model.positionId) &&
Objects.equals(depPostParentId, model.depPostParentId) &&
Objects.equals(children, model.children);
}
/**
* 重写hashCode方法
*/
@Override
public int hashCode() {
return Objects.hash(id, parentId, departName, departNameEn, departNameAbbr,
departOrder, description, orgCategory, orgType, orgCode, mobile, fax, address,
memo, status, delFlag, qywxIdentifier, createBy, createTime, updateBy, updateTime,
children,directorUserIds, positionId, depPostParentId);
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/SysDictTree.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/SysDictTree.java | package org.jeecg.modules.system.model;
import java.io.Serializable;
import java.util.Date;
import org.jeecg.modules.system.entity.SysDict;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* <p>
* 字典表
* </p>
*
* @Author zhangweijian
* @since 2018-12-28
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SysDictTree implements Serializable {
private static final long serialVersionUID = 1L;
private String key;
private String title;
/**
* id
*/
@TableId(type = IdType.ASSIGN_ID)
private String id;
/**
* 字典类型,0 string,1 number类型,2 boolean
* 前端js对stirng类型和number类型 boolean 类型敏感，需要区分。在select 标签匹配的时候会用到
* 默认为string类型
*/
private Integer type;
/**
* 字典名称
*/
private String dictName;
/**
* 字典编码
*/
private String dictCode;
/**
* 描述
*/
private String description;
/**
* 删除状态
*/
private Integer delFlag;
/**
* 创建人
*/
private String createBy;
/**
* 创建时间
*/
private Date createTime;
/**
* 更新人
*/
private String updateBy;
/**
* 更新时间
*/
private Date updateTime;
public SysDictTree(SysDict node) {
this.id = node.getId();
this.key = node.getId();
this.title = node.getDictName();
this.dictCode = node.getDictCode();
this.description = node.getDescription();
this.delFlag = node.getDelFlag();
this.type = node.getType();
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/ThirdLoginModel.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/ThirdLoginModel.java | package org.jeecg.modules.system.model;
import lombok.Data;
import java.io.Serializable;
/**
* 第三方登录 信息存储
* @author: jeecg-boot
*/
@Data
public class ThirdLoginModel implements Serializable {
private static final long serialVersionUID = 4098628709290780891L;
/**
* 第三方登录 来源
*/
private String source;
/**
* 第三方登录 uuid
*/
private String uuid;
/**
* 第三方登录 username
*/
private String username;
/**
* 第三方登录 头像
*/
private String avatar;
/**
* 账号 后缀第三方登录 防止账号重复
*/
private String suffix;
/**
* 操作码 防止被攻击
*/
private String operateCode;
public ThirdLoginModel(){
}
/**
* 构造器
* @param source
* @param uuid
* @param username
* @param avatar
*/
public ThirdLoginModel(String source,String uuid,String username,String avatar){
this.source = source;
this.uuid = uuid;
this.username = username;
this.avatar = avatar;
}
/**
* 获取登录账号名
* @return
*/
public String getUserLoginAccount(){
if(suffix==null){
return this.uuid;
}
return this.uuid + this.suffix;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/SysLoginModel.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/SysLoginModel.java | package org.jeecg.modules.system.model;
import io.swagger.v3.oas.annotations.media.Schema;
/**
* 登录表单
*
* @Author scott
* @since 2019-01-18
*/
@Schema(description="登录对象")
public class SysLoginModel {
@Schema(description = "账号")
private String username;
@Schema(description = "密码")
private String password;
@Schema(description = "登录部门")
private String loginOrgCode;
@Schema(description = "验证码")
private String captcha;
@Schema(description = "验证码key")
private String checkKey;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getCaptcha() {
return captcha;
}
public void setCaptcha(String captcha) {
this.captcha = captcha;
}
public String getCheckKey() {
return checkKey;
}
public void setCheckKey(String checkKey) {
this.checkKey = checkKey;
}
public String getLoginOrgCode() {
return loginOrgCode;
}
public void setLoginOrgCode(String loginOrgCode) {
this.loginOrgCode = loginOrgCode;
}
} | java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/TreeSelectModel.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/model/TreeSelectModel.java | package org.jeecg.modules.system.model;
import java.io.Serializable;
import java.util.List;
/**
* 树形下拉框
* @author: jeecg-boot
*/
public class TreeSelectModel implements Serializable {
private static final long serialVersionUID = 9016390975325574747L;
private String key;
private String title;
/**
* 是否叶子节点
*/
private boolean isLeaf;
private String icon;
private String parentId;
private String value;
private String code;
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public String getParentId() {
return parentId;
}
public void setParentId(String parentId) {
this.parentId = parentId;
}
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public boolean isLeaf() {
return isLeaf;
}
public void setLeaf(boolean isLeaf) {
this.isLeaf = isLeaf;
}
public String getIcon() {
return icon;
}
public void setIcon(String icon) {
this.icon = icon;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
private List<TreeSelectModel> children;
public List<TreeSelectModel> getChildren() {
return children;
}
public void setChildren(List<TreeSelectModel> children) {
this.children = children;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysTenantPackUser.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysTenantPackUser.java | package org.jeecg.modules.system.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
/**
* @Description: 租户产品包用户关系表
* @Author: jeecg-boot
* @Date: 2023-02-16
* @Version: V1.0
*/
@Data
@TableName("sys_tenant_pack_user")
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = false)
@Schema(description="租户产品包用户关系表")
public class SysTenantPackUser implements Serializable {
private static final long serialVersionUID = 1L;
/**id*/
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "id")
private java.lang.String id;
/**租户产品包ID*/
@Excel(name = "租户产品包ID", width = 15)
@Schema(description = "租户产品包ID")
private java.lang.String packId;
/**用户ID*/
@Excel(name = "用户ID", width = 15)
@Schema(description = "用户ID")
private java.lang.String userId;
/**租户ID*/
@Excel(name = "租户ID", width = 15)
@Schema(description = "租户ID")
private java.lang.Integer tenantId;
/**创建人*/
@Schema(description = "创建人")
private java.lang.String createBy;
/**创建时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@Schema(description = "创建时间")
private java.util.Date createTime;
/**更新人*/
@Schema(description = "更新人")
private java.lang.String updateBy;
/**更新时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@Schema(description = "更新时间")
private java.util.Date updateTime;
private transient String realname;
private transient String packName;
private transient String packCode;
/**
* 状态(申请状态0 正常状态1)
*/
private Integer status;
public SysTenantPackUser(){
}
public SysTenantPackUser(Integer tenantId, String packId, String userId) {
this.packId = packId;
this.userId = userId;
this.tenantId = tenantId;
this.status = 1;
}
public SysTenantPackUser(SysTenantPackUser param, String userId, String realname) {
this.userId = userId;
this.realname = realname;
this.packId = param.getPackId();
this.tenantId = param.getTenantId();
this.packName = param.getPackName();
this.status = 1;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysPackPermission.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysPackPermission.java | package org.jeecg.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* @Description: 产品包菜单关系表
* @Author: jeecg-boot
* @Date: 2022-12-31
* @Version: V1.0
*/
@Data
@TableName("sys_tenant_pack_perms")
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = false)
@Schema(description="产品包菜单关系表")
public class SysPackPermission implements Serializable {
private static final long serialVersionUID = 1L;
/**主键编号*/
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键编号")
private String id;
/**租户产品包名称*/
@Excel(name = "租户产品包名称", width = 15)
@Schema(description = "租户产品包名称")
private String packId;
/**菜单id*/
@Excel(name = "菜单id", width = 15)
@Schema(description = "菜单id")
private String permissionId;
/**创建人*/
@Schema(description = "创建人")
private String createBy;
/**创建时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@Schema(description = "创建时间")
private Date createTime;
/**更新人*/
@Schema(description = "更新人")
private String updateBy;
/**更新时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@Schema(description = "更新时间")
private Date updateTime;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysCheckRule.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysCheckRule.java | package org.jeecg.modules.system.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;
/**
* @Description: 编码校验规则
* @Author: jeecg-boot
* @Date: 2020-02-04
* @Version: V1.0
*/
@Data
@TableName("sys_check_rule")
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@Schema(description="编码校验规则")
public class SysCheckRule {
/**
* 主键id
*/
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键id")
private String id;
/**
* 规则名称
*/
@Excel(name = "规则名称", width = 15)
@Schema(description = "规则名称")
private String ruleName;
/**
* 规则Code
*/
@Excel(name = "规则Code", width = 15)
@Schema(description = "规则Code")
private String ruleCode;
/**
* 规则JSON
*/
@Excel(name = "规则JSON", width = 15)
@Schema(description = "规则JSON")
private String ruleJson;
/**
* 规则描述
*/
@Excel(name = "规则描述", width = 15)
@Schema(description = "规则描述")
private String ruleDescription;
/**
* 更新人
*/
@Excel(name = "更新人", width = 15)
@Schema(description = "更新人")
private String updateBy;
/**
* 更新时间
*/
@Excel(name = "更新时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@Schema(description = "更新时间")
private Date updateTime;
/**
* 创建人
*/
@Excel(name = "创建人", width = 15)
@Schema(description = "创建人")
private String createBy;
/**
* 创建时间
*/
@Excel(name = "创建时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@Schema(description = "创建时间")
private Date createTime;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysLog.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysLog.java | package org.jeecg.modules.system.entity;
import java.util.Date;
import org.jeecg.common.aspect.annotation.Dict;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* <p>
* 系统日志表
* </p>
*
* @Author zhangweijian
* @since 2018-12-26
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SysLog implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
@TableId(type = IdType.ASSIGN_ID)
private String id;
/**
* 创建人
*/
private String createBy;
/**
* 创建时间
*/
@Excel(name = "创建时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 更新人
*/
private String updateBy;
/**
* 更新时间
*/
private Date updateTime;
/**
* 耗时
*/
@Excel(name = "耗时（毫秒）", width = 15)
private Long costTime;
/**
* IP
*/
@Excel(name = "IP", width = 15)
private String ip;
/**
* 请求参数
*/
private String requestParam;
/**
* 请求类型
*/
private String requestType;
/**
* 请求路径
*/
private String requestUrl;
/**
* 请求方法
*/
private String method;
/**
* 操作人用户名称
*/
private String username;
/**
* 操作人用户账户
*/
@Excel(name = "操作人", width = 15)
private String userid;
/**
* 操作详细日志
*/
@Excel(name = "日志内容", width = 50)
private String logContent;
/**
* 日志类型（1登录日志，2操作日志）
*/
@Dict(dicCode = "log_type")
private Integer logType;
/**
* 操作类型（1查询，2添加，3修改，4删除,5导入，6导出）
*/
@Dict(dicCode = "operate_type")
private Integer operateType;
/**
* 客户终端类型 pc:电脑端 app:手机端 h5:移动网页端
*/
@Excel(name = "客户端类型", width = 15, dicCode = "client_type")
@Dict(dicCode = "client_type")
private String clientType;
/**
* 租户ID
*/
private Integer tenantId;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysUserRole.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysUserRole.java | package org.jeecg.modules.system.entity;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* <p>
* 用户角色表
* </p>
*
* @Author scott
* @since 2018-12-21
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SysUserRole implements Serializable {
private static final long serialVersionUID = 1L;
@TableId(type = IdType.ASSIGN_ID)
private String id;
/**
* 用户id
*/
private String userId;
/**
* 角色id
*/
private String roleId;
/**租户ID*/
private java.lang.Integer tenantId;
public SysUserRole() {
}
public SysUserRole(String userId, String roleId) {
this.userId = userId;
this.roleId = roleId;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysUser.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysUser.java | package org.jeecg.modules.system.entity;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.fasterxml.jackson.annotation.JsonProperty;
import org.jeecg.common.aspect.annotation.Dict;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* <p>
* 用户表
* </p>
*
* @Author scott
* @since 2018-12-20
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SysUser implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
@TableId(type = IdType.ASSIGN_ID)
private String id;
/**
* 登录账号
*/
@Excel(name = "登录账号", width = 15)
private String username;
/**
* 真实姓名
*/
@Excel(name = "真实姓名", width = 15)
private String realname;
/**
* 密码
*/
@JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
private String password;
/**
* md5密码盐
*/
@JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
private String salt;
/**
* 头像
*/
@Excel(name = "头像", width = 15,type = 2)
private String avatar;
/**
* 生日
*/
@Excel(name = "生日", width = 15, format = "yyyy-MM-dd")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date birthday;
/**
* 性别（1：男 2：女）
*/
@Excel(name = "性别", width = 15,dicCode="sex")
@Dict(dicCode = "sex")
private Integer sex;
/**
* 电子邮件
*/
@Excel(name = "电子邮件", width = 15)
private String email;
/**
* 电话
*/
@Excel(name = "电话", width = 15)
private String phone;
/**
* 登录选择部门编码
*/
private String orgCode;
/**
* 登录选择租户ID
*/
private Integer loginTenantId;
/**部门名称*/
private transient String orgCodeTxt;
/**
* 状态(1：正常 2：冻结 ）
*/
@Excel(name = "状态", width = 15,dicCode="user_status")
@Dict(dicCode = "user_status")
private Integer status;
/**
* 删除状态（0，正常，1已删除）
*/
@Excel(name = "删除状态", width = 15,dicCode="del_flag")
@TableLogic
private Integer delFlag;
/**
* 工号，唯一键
*/
@Excel(name = "工号", width = 15)
private String workNo;
/**
* 职务，关联职务表
*/
@Excel(name = "职务", width = 15)
@Dict(dictTable ="sys_position",dicText = "name",dicCode = "id")
@TableField(exist = false)
private String post;
/**
* 座机号
*/
@Excel(name = "座机号", width = 15)
private String telephone;
/**
* 创建人
*/
private String createBy;
/**
* 创建时间
*/
private Date createTime;
/**
* 更新人
*/
private String updateBy;
/**
* 更新时间
*/
private Date updateTime;
/**
* 同步工作流引擎1同步0不同步
*/
private Integer activitiSync;
/**
* 身份（0 普通成员 1 上级）
*/
@Excel(name="（1普通成员 2上级）",width = 15)
private Integer userIdentity;
/**
* 负责部门
*/
@Excel(name="负责部门",width = 15,dictTable ="sys_depart",dicText = "depart_name",dicCode = "id")
@Dict(dictTable ="sys_depart",dicText = "depart_name",dicCode = "id")
private String departIds;
/**
* 多租户ids临时用，不持久化数据库(数据库字段不存在)
*/
@TableField(exist = false)
private String relTenantIds;
/**设备id uniapp推送用*/
private String clientId;
/**
* 登录首页地址
*/
@TableField(exist = false)
private String homePath;
/**
* 职位名称
*/
@TableField(exist = false)
private String postText;
/**
* 流程状态
*/
private String bpmStatus;
/**
* 是否已经绑定第三方
*/
@TableField(exist = false)
private boolean izBindThird;
/**
* 个性签名
*/
private String sign;
/**
* 是否开启个性签名
*/
private Integer signEnable;
/**
* 主岗位
*/
@Excel(name="主岗位",width = 15,dictTable ="sys_depart",dicText = "depart_name",dicCode = "id")
@Dict(dictTable ="sys_depart",dicText = "depart_name",dicCode = "id")
private String mainDepPostId;
/**
* 兼职岗位
*/
@Excel(name="兼职岗位",width = 15,dictTable ="sys_depart",dicText = "depart_name",dicCode = "id")
@Dict(dictTable ="sys_depart",dicText = "depart_name",dicCode = "id")
@TableField(exist = false)
private String otherDepPostId;
/**
* 职务(字典)
*/
@Excel(name = "职务", width = 15, dicCode = "user_position")
@Dict(dicCode = "user_position")
private String positionType;
/**
* 上一次修改密码的时间
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date lastPwdUpdateTime;
/**
* 登录时，选择的部门，临时用，不持久化数据库(数据库字段不存在)
*/
@TableField(exist = false)
private String loginOrgCode;
/**
* 排序
*/
private Integer sort;
/**
* 是否隐藏联系方式 0否1是
*/
private String izHideContact;
/**
* 所属部门的id
*/
@TableField(exist = false)
private String belongDepIds;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysDepartPermission.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysDepartPermission.java | package org.jeecg.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableField;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
/**
* @Description: 部门权限表
* @Author: jeecg-boot
* @Date: 2020-02-11
* @Version: V1.0
*/
@Data
@TableName("sys_depart_permission")
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@Schema(description="部门权限表")
public class SysDepartPermission {
/**id*/
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "id")
private java.lang.String id;
/**部门id*/
@Excel(name = "部门id", width = 15)
@Schema(description = "部门id")
private java.lang.String departId;
/**权限id*/
@Excel(name = "权限id", width = 15)
@Schema(description = "权限id")
private java.lang.String permissionId;
/**数据规则id*/
@Schema(description = "数据规则id")
private java.lang.String dataRuleIds;
public SysDepartPermission() {
}
public SysDepartPermission(String departId, String permissionId) {
this.departId = departId;
this.permissionId = permissionId;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysUserPosition.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysUserPosition.java | package org.jeecg.modules.system.entity;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import java.util.Date;
import io.swagger.v3.oas.annotations.media.Schema;
/**
* @Description: 用户职位关系表
* @Author: jeecg-boot
* @Date: 2023-02-14
* @Version: V1.0
*/
@Schema(description="用户职位关系表")
@Data
@TableName("sys_user_position")
public class SysUserPosition implements Serializable {
private static final long serialVersionUID = 1L;
/**主键*/
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键")
private String id;
/**用户id*/
@Excel(name = "用户id", width = 15)
@Schema(description = "用户id")
private String userId;
/**职位id*/
@Schema(description = "职位id")
private String positionId;
/**创建人*/
@Schema(description = "创建人")
private String createBy;
/**创建时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@Schema(description = "创建时间")
private Date createTime;
/**修改人*/
@Schema(description = "修改人")
private String updateBy;
/**修改时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@Schema(description = "修改时间")
private Date updateTime;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysRoleIndex.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysRoleIndex.java | package org.jeecg.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableField;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.jeecg.common.aspect.annotation.Dict;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
/**
* @Description: 角色首页配置
* @Author: liusq
* @Date: 2022-03-25
* @Version: V1.0
*/
@Data
@TableName("sys_role_index")
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@Schema(description="角色首页配置")
public class SysRoleIndex {
/**id*/
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "id")
private java.lang.String id;
/**角色编码*/
@Excel(name = "角色编码", width = 15)
@Schema(description = "角色编码")
private java.lang.String roleCode;
/**路由地址*/
@Excel(name = "路由地址", width = 15)
@Schema(description = "路由地址")
private java.lang.String url;
/**路由地址*/
@Excel(name = "路由地址", width = 15)
@Schema(description = "组件")
private java.lang.String component;
/**
* 是否路由菜单: 0:不是 1:是（默认值1）
*/
@Excel(name = "是否路由菜单", width = 15)
@Schema(description = "是否路由菜单")
@TableField(value="is_route")
private Boolean route;
/**优先级*/
@Excel(name = "优先级", width = 15)
@Schema(description = "优先级")
private java.lang.Integer priority;
/**路由地址*/
@Excel(name = "状态", width = 15)
@Schema(description = "状态")
private java.lang.String status;
/**创建人登录名称*/
@Excel(name = "创建人登录名称", width = 15)
@Schema(description = "创建人登录名称")
private java.lang.String createBy;
/**创建日期*/
@Excel(name = "创建日期", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
@Schema(description = "创建日期")
private java.util.Date createTime;
/**更新人登录名称*/
@Excel(name = "更新人登录名称", width = 15)
@Schema(description = "更新人登录名称")
private java.lang.String updateBy;
/**更新日期*/
@Excel(name = "更新日期", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
@Schema(description = "更新日期")
private java.util.Date updateTime;
/**所属部门*/
@Excel(name = "所属部门", width = 15)
@Schema(description = "所属部门")
private java.lang.String sysOrgCode;
/**关联类型(ROLE:角色 USER:表示用户)*/
@Schema(description = "关联类型")
@Excel(name = "关联类型", width = 15, dicCode = "relation_type")
@Dict(dicCode = "relation_type")
private java.lang.String relationType;
public SysRoleIndex() {
}
public SysRoleIndex(String componentUrl){
this.component = componentUrl;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysDepartRolePermission.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysDepartRolePermission.java | package org.jeecg.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableField;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
/**
* @Description: 部门角色权限
* @Author: jeecg-boot
* @Date: 2020-02-12
* @Version: V1.0
*/
@Data
@TableName("sys_depart_role_permission")
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@Schema(description="部门角色权限")
public class SysDepartRolePermission {
/**id*/
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "id")
private java.lang.String id;
/**部门id*/
@Excel(name = "部门id", width = 15)
@Schema(description = "部门id")
private java.lang.String departId;
/**角色id*/
@Excel(name = "角色id", width = 15)
@Schema(description = "角色id")
private java.lang.String roleId;
/**权限id*/
@Excel(name = "权限id", width = 15)
@Schema(description = "权限id")
private java.lang.String permissionId;
/**dataRuleIds*/
@Excel(name = "dataRuleIds", width = 15)
@Schema(description = "dataRuleIds")
private java.lang.String dataRuleIds;
/** 操作时间 */
@Excel(name = "操作时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
@Schema(description = "操作时间")
private java.util.Date operateDate;
/** 操作ip */
private java.lang.String operateIp;
public SysDepartRolePermission() {
}
public SysDepartRolePermission(String roleId, String permissionId) {
this.roleId = roleId;
this.permissionId = permissionId;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysAnnouncementSend.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysAnnouncementSend.java | package org.jeecg.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
/**
* @Description: 用户通告阅读标记表
* @Author: jeecg-boot
* @Date: 2019-02-21
* @Version: V1.0
*/
@Data
@TableName("sys_announcement_send")
public class SysAnnouncementSend implements Serializable {
private static final long serialVersionUID = 1L;
/**id*/
@TableId(type = IdType.ASSIGN_ID)
private java.lang.String id;
/**通告id*/
private java.lang.String anntId;
/**用户id*/
private java.lang.String userId;
/**阅读状态（0未读，1已读）*/
private java.lang.Integer readFlag;
/**阅读时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date readTime;
/**创建人*/
private java.lang.String createBy;
/**创建时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date createTime;
/**更新人*/
private java.lang.String updateBy;
/**更新时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private java.util.Date updateTime;
/**
* 是否标星 当值为1是标星消息
*/
private String starFlag;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysPermissionDataRule.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysPermissionDataRule.java | package org.jeecg.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* <p>
* 菜单权限规则表
* </p>
*
* @Author huangzhilin
* @since 2019-03-29
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SysPermissionDataRule implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
@TableId(type = IdType.ASSIGN_ID)
private String id;
/**
* 对应的菜单id
*/
private String permissionId;
/**
* 规则名称
*/
private String ruleName;
/**
* 字段
*/
private String ruleColumn;
/**
* 条件
*/
private String ruleConditions;
/**
* 规则值
*/
private String ruleValue;
/**
* 状态值 1有效 0无效
*/
private String status;
/**
* 创建时间
*/
private Date createTime;
/**
* 创建人
*/
private String createBy;
/**
* 修改时间
*/
private Date updateTime;
/**
* 修改人
*/
private String updateBy;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysUserDepart.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysUserDepart.java | package org.jeecg.modules.system.entity;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
/**
* @Description: 用户部门
* @author: jeecg-boot
*/
@Data
@TableName("sys_user_depart")
public class SysUserDepart implements Serializable {
private static final long serialVersionUID = 1L;
/**主键id*/
@TableId(type = IdType.ASSIGN_ID)
private String id;
/**用户id*/
private String userId;
/**部门id*/
private String depId;
public SysUserDepart(String id, String userId, String depId) {
super();
this.id = id;
this.userId = userId;
this.depId = depId;
}
public SysUserDepart(String userId, String departId) {
this.userId = userId;
this.depId = departId;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysTenant.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysTenant.java | package org.jeecg.modules.system.entity;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import org.jeecg.common.aspect.annotation.Dict;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
import java.util.Date;
/**
* 租户信息
* @author: jeecg-boot
*/
@Data
@TableName("sys_tenant")
public class SysTenant implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 编码
*/
private Integer id;
/**
* 名称
*/
private String name;
/**
* 创建人
*/
@Dict(dictTable ="sys_user",dicText = "realname",dicCode = "username")
private String createBy;
/**
* 创建时间
*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 开始时间
*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date beginDate;
/**
* 结束时间
*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date endDate;
/**
* 状态 1正常 0冻结
*/
@Dict(dicCode = "tenant_status")
private Integer status;
/**
* 所属行业
*/
@Dict(dicCode = "trade")
private String trade;
/**
* 公司规模
*/
@Dict(dicCode = "company_size")
private String companySize;
/**
* 公司地址
*/
private String companyAddress;
/**
* 公司logo
*/
private String companyLogo;
/**
* 门牌号
*/
private String houseNumber;
/**
* 工作地点
*/
private String workPlace;
/**
* 二级域名(暂时无用,预留字段)
*/
private String secondaryDomain;
/**
* 登录背景图片(暂时无用，预留字段)
*/
private String loginBkgdImg;
/**
* 职级
*/
@Dict(dicCode = "company_rank")
private String position;
/**
* 部门
*/
@Dict(dicCode = "company_department")
private String department;
@TableLogic
private Integer delFlag;
/**更新人登录名称*/
private String updateBy;
/**更新日期*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date updateTime;
/**
* 允许申请管理员 1允许 0不允许
*/
private Integer applyStatus;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysTenantPack.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysTenantPack.java | package org.jeecg.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* @Description: 租户产品包
* @Author: jeecg-boot
* @Date: 2022-12-31
* @Version: V1.0
*/
@Data
@TableName("sys_tenant_pack")
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = false)
@Schema(description="租户产品包")
public class SysTenantPack implements Serializable {
private static final long serialVersionUID = 1L;
/**主键id*/
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键id")
private String id;
/**租户id*/
@Excel(name = "租户id", width = 15)
@Schema(description = "租户id")
private Integer tenantId;
/**产品包名*/
@Excel(name = "产品包名", width = 15)
@Schema(description = "产品包名")
private String packName;
/**开启状态(0 未开启 1开启)*/
@Excel(name = "开启状态(0 未开启 1开启)", width = 15)
@Schema(description = "开启状态(0 未开启 1开启)")
private String status;
/**备注*/
@Excel(name = "备注", width = 15)
@Schema(description = "备注")
private String remarks;
/**创建人*/
@Schema(description = "创建人")
private String createBy;
/**创建时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@Schema(description = "创建时间")
private Date createTime;
/**更新人*/
@Schema(description = "更新人")
private String updateBy;
/**更新时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
@Schema(description = "更新时间")
private Date updateTime;
/**产品包类型(default 默认产品包 custom 自定义产品包)*/
@Excel(name = "产品包类型", width = 15)
@Schema(description = "产品包类型")
private String packType;
/**
* 是否自动分配给用户(0 否 1是)
*/
@Excel(name = "是否自动分配给用户(0 否 1是)", width = 15)
@Schema(description = "是否自动分配给用户")
private String izSysn;
/**菜单id 临时字段用于新增编辑菜单id传递*/
@TableField(exist = false)
private String permissionIds;
/**
* 编码
*/
private String packCode;
public SysTenantPack(){
}
public SysTenantPack(Integer tenantId, String packName, String packCode){
this.tenantId = tenantId;
this.packCode = packCode;
this.packName = packName;
this.status = "1";
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysPermission.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysPermission.java | package org.jeecg.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import org.jeecg.common.aspect.annotation.Dict;
import org.jeecg.modules.system.constant.DefIndexConst;
/**
* <p>
* 菜单权限表
* </p>
*
* @Author scott
* @since 2018-12-21
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SysPermission implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
@TableId(type = IdType.ASSIGN_ID)
private String id;
/**
* 父id
*/
private String parentId;
/**
* 菜单名称
*/
private String name;
/**
* 菜单权限编码，例如：“sys:schedule:list,sys:schedule:info”,多个逗号隔开
*/
private String perms;
/**
* 权限策略1显示2禁用
*/
private String permsType;
/**
* 菜单图标
*/
private String icon;
/**
* 组件
*/
private String component;
/**
* 组件名字
*/
private String componentName;
/**
* 路径
*/
private String url;
/**
* 一级菜单跳转地址
*/
private String redirect;
/**
* 菜单排序
*/
private Double sortNo;
/**
* 类型（0：一级菜单；1：子菜单 ；2：按钮权限）
*/
@Dict(dicCode = "menu_type")
private Integer menuType;
/**
* 是否叶子节点: 1:是 0:不是
*/
@TableField(value="is_leaf")
private boolean leaf;
/**
* 是否路由菜单: 0:不是 1:是（默认值1）
*/
@TableField(value="is_route")
private boolean route;
/**
* 是否缓存页面: 0:不是 1:是（默认值1）
*/
@TableField(value="keep_alive")
private boolean keepAlive;
/**
* 描述
*/
private String description;
/**
* 创建人
*/
private String createBy;
/**
* 删除状态 0正常 1已删除
*/
private Integer delFlag;
/**
* 是否配置菜单的数据权限 1是0否 默认0
*/
private Integer ruleFlag;
/**
* 是否隐藏路由菜单: 0否,1是（默认值0）
*/
private boolean hidden;
/**
* 是否隐藏Tab: 0否,1是（默认值0）
*/
private boolean hideTab;
/**
* 创建时间
*/
private Date createTime;
/**
* 更新人
*/
private String updateBy;
/**
* 更新时间
*/
private Date updateTime;
/**按钮权限状态(0无效1有效)*/
private java.lang.String status;
/**alwaysShow*/
private boolean alwaysShow;
/*update_begin author:wuxianquan date:20190908 for:实体增加字段 */
/** 外链菜单打开方式 0/内部打开 1/外部打开 */
private boolean internalOrExternal;
/*update_end author:wuxianquan date:20190908 for:实体增加字段 */
public SysPermission() {
}
public SysPermission(boolean index) {
if(index) {
this.id = "9502685863ab87f0ad1134142788a385";
this.name = DefIndexConst.DEF_INDEX_NAME;
this.component = DefIndexConst.DEF_INDEX_COMPONENT;
this.componentName = "dashboard-analysis";
this.url = DefIndexConst.DEF_INDEX_URL;
this.icon="home";
this.menuType=0;
this.sortNo=0.0;
this.ruleFlag=0;
this.delFlag=0;
this.alwaysShow=false;
this.route=true;
this.keepAlive=true;
this.leaf=true;
this.hidden=false;
}
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysPosition.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysPosition.java | package org.jeecg.modules.system.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import org.jeecg.common.aspect.annotation.Dict;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
/**
* @Description: 职务级别
* @Author: jeecg-boot
* @Date: 2019-09-19
* @Version: V1.0
*/
@Data
@TableName("sys_position")
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@Schema(description="职务级别表")
public class SysPosition {
/**
* id
*/
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "id")
private java.lang.String id;
/**
* 职务编码
*/
@Excel(name = "职务编码", width = 15)
@Schema(description = "职务编码")
private java.lang.String code;
/**
* 职务级别名称
*/
@Excel(name = "职务级别名称", width = 15)
@Schema(description = "职务级别名称")
private java.lang.String name;
/**
* 职级
*/
//@Excel(name = "职级", width = 15,dicCode ="position_rank")
@Schema(description = "职务等级")
private java.lang.Integer postLevel;
/**
* 公司id
*/
@Schema(description = "公司id")
private java.lang.String companyId;
/**
* 创建人
*/
@Schema(description = "创建人")
private java.lang.String createBy;
/**
* 创建时间
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@Schema(description = "创建时间")
private java.util.Date createTime;
/**
* 修改人
*/
@Schema(description = "修改人")
private java.lang.String updateBy;
/**
* 修改时间
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@Schema(description = "修改时间")
private java.util.Date updateTime;
/**
* 组织机构编码
*/
@Schema(description = "组织机构编码")
private java.lang.String sysOrgCode;
/**租户ID*/
@Schema(description = "租户ID")
private java.lang.Integer tenantId;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysTableWhiteList.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysTableWhiteList.java | package org.jeecg.modules.system.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
/**
* @Description: 系统表白名单
* @Author: jeecg-boot
* @Date: 2023-09-12
* @Version: V1.0
*/
@Data
@TableName("sys_table_white_list")
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@Schema(description="系统表白名单")
public class SysTableWhiteList {
/**
* 主键id
*/
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键id")
private java.lang.String id;
/**
* 允许的表名
*/
@Excel(name = "允许的表名", width = 15)
@Schema(description = "允许的表名")
private java.lang.String tableName;
/**
* 允许的字段名，多个用逗号分割
*/
@Excel(name = "允许的字段名", width = 15)
@Schema(description = "允许的字段名")
private java.lang.String fieldName;
/**
* 状态，1=启用，0=禁用
*/
@Excel(name = "状态", width = 15)
@Schema(description = "状态")
private java.lang.String status;
/**
* 创建人
*/
@Excel(name = "创建人", width = 15)
@Schema(description = "创建人")
private java.lang.String createBy;
/**
* 创建时间
*/
@Excel(name = "创建时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@Schema(description = "创建时间")
private java.util.Date createTime;
/**
* 更新人
*/
@Excel(name = "更新人", width = 15)
@Schema(description = "更新人")
private java.lang.String updateBy;
/**
* 更新时间
*/
@Excel(name = "更新时间", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@Schema(description = "更新时间")
private java.util.Date updateTime;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysDepartRoleUser.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysDepartRoleUser.java | package org.jeecg.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableField;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
/**
* @Description: 部门角色人员信息
* @Author: jeecg-boot
* @Date: 2020-02-13
* @Version: V1.0
*/
@Data
@TableName("sys_depart_role_user")
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@Schema(description="部门角色人员信息")
public class SysDepartRoleUser {
/**主键id*/
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键id")
private java.lang.String id;
/**用户id*/
@Excel(name = "用户id", width = 15)
@Schema(description = "用户id")
private java.lang.String userId;
/**角色id*/
@Excel(name = "角色id", width = 15)
@Schema(description = "角色id")
private java.lang.String droleId;
public SysDepartRoleUser() {
}
public SysDepartRoleUser(String userId, String droleId) {
this.userId = userId;
this.droleId = droleId;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysAnnouncement.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysAnnouncement.java | package org.jeecg.modules.system.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import org.jeecg.common.aspect.annotation.Dict;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
/**
* @Description: 系统通告表
* @Author: jeecg-boot
* @Date: 2019-01-02
* @Version: V1.0
*/
@Data
@TableName("sys_announcement")
public class SysAnnouncement implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
@TableId(type = IdType.ASSIGN_ID)
private java.lang.String id;
/**
* 标题
*/
@Excel(name = "标题", width = 15)
private java.lang.String titile;
/**
* 内容
*/
@Excel(name = "内容", width = 30)
private java.lang.String msgContent;
/**
* 开始时间
*/
@Excel(name = "开始时间", width = 15, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private java.util.Date startTime;
/**
* 结束时间
*/
@Excel(name = "结束时间", width = 15, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private java.util.Date endTime;
/**
* 发布人
*/
@Excel(name = "发布人", width = 15)
private java.lang.String sender;
/**
* 优先级（L低，M中，H高）
*/
@Excel(name = "优先级", width = 15, dicCode = "priority")
@Dict(dicCode = "priority")
private java.lang.String priority;
/**
* 消息类型1:通知公告2:系统消息
*/
@Excel(name = "消息类型", width = 15, dicCode = "msg_category")
@Dict(dicCode = "msg_category")
private java.lang.String msgCategory;
/**
* 通告对象类型（USER:指定用户，ALL:全体用户）
*/
@Excel(name = "通告对象类型", width = 15, dicCode = "msg_type")
@Dict(dicCode = "msg_type")
private java.lang.String msgType;
/**
* 发布状态（0未发布，1已发布，2已撤销）
*/
@Excel(name = "发布状态", width = 15, dicCode = "send_status")
@Dict(dicCode = "send_status")
private java.lang.String sendStatus;
/**
* 发布时间
*/
@Excel(name = "发布时间", width = 15, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private java.util.Date sendTime;
/**
* 撤销时间
*/
@Excel(name = "撤销时间", width = 15, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private java.util.Date cancelTime;
/**
* 删除状态（0，正常，1已删除）
*/
private java.lang.String delFlag;
/**
* 创建人
*/
private java.lang.String createBy;
/**
* 创建时间
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private java.util.Date createTime;
/**
* 更新人
*/
private java.lang.String updateBy;
/**
* 更新时间
*/
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private java.util.Date updateTime;
/**
* 指定用户
**/
private java.lang.String userIds;
/**
* 业务类型(email:邮件 bpm:流程 tenant_invite:租户邀请)
*/
private java.lang.String busType;
/**
* 业务id
*/
private java.lang.String busId;
/**
* 打开方式 组件：component 路由：url
*/
private java.lang.String openType;
/**
* 组件/路由 地址
*/
private java.lang.String openPage;
/**
* 摘要/扩展业务参数
*
* 示例：
* 1 摘要值
* 放假安排
* 2 跳转流程的参数值
* {"taskDetail":true,"procInsId":"1706547306004377602","taskId":"task630958764530507776"}
*/
private java.lang.String msgAbstract;
/**
* 钉钉task_id，用于撤回消息
*/
private String dtTaskId;
/**
* 阅读状态 1表示已经阅读
*/
private transient String readFlag;
/**
* 标星状态 1表示标星
*/
private transient String starFlag;
/**
* 发送记录ID
*/
private transient String sendId;
/**租户ID*/
private java.lang.Integer tenantId;
/**
* 枚举：org.jeecg.common.constant.enums.NoticeTypeEnum
* 通知类型(system:系统消息、file:知识库、flow:流程、plan:日程计划、meeting:会议)
*/
private String noticeType;
/**附件字段*/
private java.lang.String files;
/**访问次数*/
private java.lang.Integer visitsNum;
/**是否置顶（0否 1是）*/
private java.lang.Integer izTop;
/**是否审批（0否 1是）*/
private java.lang.String izApproval;
/**流程状态*/
private java.lang.String bpmStatus;
/**消息归类*/
private java.lang.String msgClassify;
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
jeecgboot/JeecgBoot | https://github.com/jeecgboot/JeecgBoot/blob/e533af285c68b205f4ee8cf059d34fbb21d222d3/jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysRolePermission.java | jeecg-boot/jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/system/entity/SysRolePermission.java | package org.jeecg.modules.system.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 角色权限表
* </p>
*
* @Author scott
* @since 2018-12-21
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SysRolePermission implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
@TableId(type = IdType.ASSIGN_ID)
private String id;
/**
* 角色id
*/
private String roleId;
/**
* 权限id
*/
private String permissionId;
/**
* 数据权限
*/
private String dataRuleIds;
/**
* 操作时间
*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date operateDate;
/**
* 操作ip
*/
private String operateIp;
public SysRolePermission() {
}
public SysRolePermission(String roleId, String permissionId) {
this.roleId = roleId;
this.permissionId = permissionId;
}
}
| java | Apache-2.0 | e533af285c68b205f4ee8cf059d34fbb21d222d3 | 2026-01-04T14:45:57.045651Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.