abu/wzj-boot
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

发布 2.2.1

Browse Source
This commit is contained in:
疯狂的狮子li 2021-05-29 19:23:45 +08:00
parent 96cdd2490d
commit fab58a4f77
22 changed files with 609 additions and 502 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ruoyi-ui/package.json
View File

@ -1,6 +1,6 @@
{ {
"name": "ruoyi-vue-plus", "name": "ruoyi-vue-plus",
"version": "2.2.0", "version": "2.2.1",
"description": "RuoYi-Vue-Plus后台管理系统", "description": "RuoYi-Vue-Plus后台管理系统",
"author": "LionLi", "author": "LionLi",
"license": "MIT", "license": "MIT",

6
ruoyi-ui/src/api/system/config.js
View File

@ -51,10 +51,10 @@ export function delConfig(configId) {
}) })
} }
// 清理参数缓存 // 刷新参数缓存
export function clearCache() { export function refreshCache() {
return request({ return request({
url: '/system/config/clearCache', url: '/system/config/refreshCache',
method: 'delete' method: 'delete'
}) })
} }

6
ruoyi-ui/src/api/system/dict/type.js
View File

@ -43,10 +43,10 @@ export function delType(dictId) {
}) })
} }
// 清理参数缓存 // 刷新字典缓存
export function clearCache() { export function refreshCache() {
return request({ return request({
url: '/system/dict/type/clearCache', url: '/system/dict/type/refreshCache',
method: 'delete' method: 'delete'
}) })
} }

13
ruoyi-ui/src/views/index.vue
View File

@ -80,6 +80,17 @@
<span>更新日志</span> <span>更新日志</span>
</div> </div>
<el-collapse accordion> <el-collapse accordion>
<el-collapse-item title="v2.2.1 - 2021-5-29">
<ol>
<li>add 增加 security 权限框架 @Async 异步注解配置</li>
<li>update 优化数据权限sql 解决MP apply注入附带 AND 语法问题</li>
<li>update 优化dataScope参数防止注入</li>
<li>update 优化参数&字典缓存操作</li>
<li>update 增加修改包名文档</li>
<li>update 文档增加演示图例</li>
<li>fix 修复部门类sql符号错误</li>
</ol>
</el-collapse-item>
<el-collapse-item title="v2.2.0 - 2021-5-25"> <el-collapse-item title="v2.2.0 - 2021-5-25">
<ol> <ol>
<li>同步升级 RuoYi-Vue 3.5.0</li> <li>同步升级 RuoYi-Vue 3.5.0</li>
@ -180,7 +191,7 @@ export default {
data() { data() {
return { return {
// 版本号 // 版本号
version: "2.2.0", version: "2.2.1",
}; };
}, },
methods: { methods: {

14
ruoyi-ui/src/views/system/config/index.vue
View File

@ -99,9 +99,9 @@
plain plain
icon="el-icon-refresh" icon="el-icon-refresh"
size="mini" size="mini"
@click="handleClearCache" @click="handleRefreshCache"
v-hasPermi="['system:config:remove']" v-hasPermi="['system:config:remove']"
>清理缓存</el-button> >刷新缓存</el-button>
</el-col> </el-col>
<right-toolbar :showSearch.sync="showSearch" @queryTable="getList"></right-toolbar> <right-toolbar :showSearch.sync="showSearch" @queryTable="getList"></right-toolbar>
</el-row> </el-row>
@ -181,7 +181,7 @@
</template> </template>
<script> <script>
import { listConfig, getConfig, delConfig, addConfig, updateConfig, exportConfig, clearCache } from "@/api/system/config"; import { listConfig, getConfig, delConfig, addConfig, updateConfig, exportConfig, refreshCache } from "@/api/system/config";
export default { export default {
name: "Config", name: "Config",
@ -355,10 +355,10 @@ export default {
this.exportLoading = false; this.exportLoading = false;
}) })
}, },
/** 清理缓存按钮操作 */ /** 刷新缓存按钮操作 */
handleClearCache() { handleRefreshCache() {
clearCache().then(response => { refreshCache().then(() => {
this.msgSuccess("清理成功"); this.msgSuccess("刷新成功");
}); });
} }
} }

14
ruoyi-ui/src/views/system/dict/index.vue
View File

@ -105,9 +105,9 @@
plain plain
icon="el-icon-refresh" icon="el-icon-refresh"
size="mini" size="mini"
@click="handleClearCache" @click="handleRefreshCache"
v-hasPermi="['system:dict:remove']" v-hasPermi="['system:dict:remove']"
>清理缓存</el-button> >刷新缓存</el-button>
</el-col> </el-col>
<right-toolbar :showSearch.sync="showSearch" @queryTable="getList"></right-toolbar> <right-toolbar :showSearch.sync="showSearch" @queryTable="getList"></right-toolbar>
</el-row> </el-row>
@ -189,7 +189,7 @@
</template> </template>
<script> <script>
import { listType, getType, delType, addType, updateType, exportType, clearCache } from "@/api/system/dict/type"; import { listType, getType, delType, addType, updateType, exportType, refreshCache } from "@/api/system/dict/type";
export default { export default {
name: "Dict", name: "Dict",
@ -359,10 +359,10 @@ export default {
this.exportLoading = false; this.exportLoading = false;
}) })
}, },
/** 清理缓存按钮操作 */ /** 刷新缓存按钮操作 */
handleClearCache() { handleRefreshCache() {
clearCache().then(response => { refreshCache().then(() => {
this.msgSuccess("清理成功"); this.msgSuccess("刷新成功");
}); });
} }
} }

10
ruoyi/src/main/java/com/ruoyi/common/utils/DictUtils.java
View File

@ -155,6 +155,16 @@ public class DictUtils
return StrUtil.strip(propertyString.toString(), null, separator); return StrUtil.strip(propertyString.toString(), null, separator);
} }
/**
* 删除指定字典缓存
*
* @param key 字典键
*/
public static void removeDictCache(String key)
{
SpringUtils.getBean(RedisCache.class).deleteObject(getCacheKey(key));
}
/** /**
* 清空字典缓存 * 清空字典缓存
*/ */

41
ruoyi/src/main/java/com/ruoyi/framework/aspectj/DataScopeAspect.java
View File

@ -68,6 +68,7 @@ public class DataScopeAspect
@Before("dataScopePointCut()") @Before("dataScopePointCut()")
public void doBefore(JoinPoint point) throws Throwable public void doBefore(JoinPoint point) throws Throwable
{ {
clearDataScope(point);
handleDataScope(point); handleDataScope(point);
} }
@ -144,18 +145,8 @@ public class DataScopeAspect
if (StrUtil.isNotBlank(sqlString.toString())) if (StrUtil.isNotBlank(sqlString.toString()))
{ {
Object params = joinPoint.getArgs()[0]; putDataScope(joinPoint, sqlString.substring(4));
if (Validator.isNotNull(params)) }
{
try {
Method getParams = params.getClass().getDeclaredMethod("getParams", null);
Map<String, Object> invoke = (Map<String, Object>) getParams.invoke(params, null);
invoke.put(DATA_SCOPE, " AND (" + sqlString.substring(4) + ")");
} catch (Exception e) {
e.printStackTrace();
}
}
}
} }
/** /**
@ -173,4 +164,30 @@ public class DataScopeAspect
} }
return null; return null;
} }
/**
* 拼接权限sql前先清空params.dataScope参数防止注入
*/
private void clearDataScope(final JoinPoint joinPoint)
{
Object params = joinPoint.getArgs()[0];
if (Validator.isNotNull(params))
{
putDataScope(joinPoint, "");
}
}
private static void putDataScope(JoinPoint joinPoint, String sql) {
Object params = joinPoint.getArgs()[0];
if (Validator.isNotNull(params))
{
try {
Method getParams = params.getClass().getDeclaredMethod("getParams", null);
Map<String, Object> invoke = (Map<String, Object>) getParams.invoke(params, null);
invoke.put(DATA_SCOPE, sql);
} catch (Exception e) {
// 方法未找到 不处理
}
}
}
} }

10
ruoyi/src/main/java/com/ruoyi/system/mapper/SysDictDataMapper.java
View File

@ -1,8 +1,11 @@
package com.ruoyi.system.mapper; package com.ruoyi.system.mapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.common.core.domain.entity.SysDictData; import com.ruoyi.common.core.domain.entity.SysDictData;
import com.ruoyi.common.core.page.BaseMapperPlus; import com.ruoyi.common.core.page.BaseMapperPlus;
import java.util.List;
/** /**
* 字典表 数据层 * 字典表 数据层
* *
@ -10,4 +13,11 @@ import com.ruoyi.common.core.page.BaseMapperPlus;
*/ */
public interface SysDictDataMapper extends BaseMapperPlus<SysDictData> { public interface SysDictDataMapper extends BaseMapperPlus<SysDictData> {
default List<SysDictData> selectDictDataByType(String dictType) {
return selectList(
new LambdaQueryWrapper<SysDictData>()
.eq(SysDictData::getStatus, "0")
.eq(SysDictData::getDictType, dictType)
.orderByAsc(SysDictData::getDictSort));
}
} }

16
ruoyi/src/main/java/com/ruoyi/system/service/ISysConfigService.java
View File

@ -62,12 +62,22 @@ public interface ISysConfigService extends IServicePlus<SysConfig> {
* @param configIds 需要删除的参数ID * @param configIds 需要删除的参数ID
* @return 结果 * @return 结果
*/ */
public int deleteConfigByIds(Long[] configIds); public void deleteConfigByIds(Long[] configIds);
/** /**
* 清空缓存数据 * 加载参数缓存数据
*/ */
public void clearCache(); public void loadingConfigCache();
/**
* 清空参数缓存数据
*/
public void clearConfigCache();
/**
* 重置参数缓存数据
*/
public void resetConfigCache();
/** /**
* 校验参数键名是否唯一 * 校验参数键名是否唯一

2
ruoyi/src/main/java/com/ruoyi/system/service/ISysDictDataService.java
View File

@ -47,7 +47,7 @@ public interface ISysDictDataService extends IServicePlus<SysDictData> {
* @param dictCodes 需要删除的字典数据ID * @param dictCodes 需要删除的字典数据ID
* @return 结果 * @return 结果
*/ */
public int deleteDictDataByIds(Long[] dictCodes); public void deleteDictDataByIds(Long[] dictCodes);
/** /**
* 新增保存字典数据信息 * 新增保存字典数据信息

16
ruoyi/src/main/java/com/ruoyi/system/service/ISysDictTypeService.java
View File

@ -62,12 +62,22 @@ public interface ISysDictTypeService extends IServicePlus<SysDictType> {
* @param dictIds 需要删除的字典ID * @param dictIds 需要删除的字典ID
* @return 结果 * @return 结果
*/ */
public int deleteDictTypeByIds(Long[] dictIds); public void deleteDictTypeByIds(Long[] dictIds);
/** /**
* 清空缓存数据 * 加载字典缓存数据
*/ */
public void clearCache(); public void loadingDictCache();
/**
* 清空字典缓存数据
*/
public void clearDictCache();
/**
* 重置字典缓存数据
*/
public void resetDictCache();
/** /**
* 新增保存字典类型信息 * 新增保存字典类型信息

337
ruoyi/src/main/java/com/ruoyi/system/service/impl/SysConfigServiceImpl.java
View File

@ -20,7 +20,6 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct; import javax.annotation.PostConstruct;
import java.util.Arrays;
import java.util.Collection; import java.util.Collection;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@ -33,175 +32,191 @@ import java.util.Map;
@Service @Service
public class SysConfigServiceImpl extends ServiceImpl<SysConfigMapper, SysConfig> implements ISysConfigService { public class SysConfigServiceImpl extends ServiceImpl<SysConfigMapper, SysConfig> implements ISysConfigService {
@Autowired @Autowired
private RedisCache redisCache; private SysConfigMapper configMapper;
/** @Autowired
* 项目启动时，初始化参数到缓存 private RedisCache redisCache;
*/
@PostConstruct
public void init() {
List<SysConfig> configsList = baseMapper.selectList(new LambdaQueryWrapper<>());
for (SysConfig config : configsList) {
redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue());
}
}
@Override /**
public TableDataInfo<SysConfig> selectPageConfigList(SysConfig config) { * 项目启动时，初始化参数到缓存
Map<String, Object> params = config.getParams(); */
LambdaQueryWrapper<SysConfig> lqw = new LambdaQueryWrapper<SysConfig>() @PostConstruct
.like(StrUtil.isNotBlank(config.getConfigName()), SysConfig::getConfigName, config.getConfigName()) public void init() {
.eq(StrUtil.isNotBlank(config.getConfigType()), SysConfig::getConfigType, config.getConfigType()) loadingConfigCache();
.like(StrUtil.isNotBlank(config.getConfigKey()), SysConfig::getConfigKey, config.getConfigKey()) }
.apply(Validator.isNotEmpty(params.get("beginTime")),
"date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')",
params.get("beginTime"))
.apply(Validator.isNotEmpty(params.get("endTime")),
"date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')",
params.get("endTime"));
return PageUtils.buildDataInfo(page(PageUtils.buildPage(), lqw));
}
/** @Override
* 查询参数配置信息 public TableDataInfo<SysConfig> selectPageConfigList(SysConfig config) {
* Map<String, Object> params = config.getParams();
* @param configId 参数配置ID LambdaQueryWrapper<SysConfig> lqw = new LambdaQueryWrapper<SysConfig>()
* @return 参数配置信息 .like(StrUtil.isNotBlank(config.getConfigName()), SysConfig::getConfigName, config.getConfigName())
*/ .eq(StrUtil.isNotBlank(config.getConfigType()), SysConfig::getConfigType, config.getConfigType())
@Override .like(StrUtil.isNotBlank(config.getConfigKey()), SysConfig::getConfigKey, config.getConfigKey())
@DataSource(DataSourceType.MASTER) .apply(Validator.isNotEmpty(params.get("beginTime")),
public SysConfig selectConfigById(Long configId) { "date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')",
return baseMapper.selectById(configId); params.get("beginTime"))
} .apply(Validator.isNotEmpty(params.get("endTime")),
"date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')",
params.get("endTime"));
return PageUtils.buildDataInfo(page(PageUtils.buildPage(), lqw));
}
/** /**
* 根据键名查询参数配置信息 * 查询参数配置信息
* *
* @param configKey 参数key * @param configId 参数配置ID
* @return 参数键值 * @return 参数配置信息
*/ */
@Override @Override
public String selectConfigByKey(String configKey) { @DataSource(DataSourceType.MASTER)
String configValue = Convert.toStr(redisCache.getCacheObject(getCacheKey(configKey))); public SysConfig selectConfigById(Long configId) {
if (Validator.isNotEmpty(configValue)) { return baseMapper.selectById(configId);
return configValue; }
}
SysConfig retConfig = baseMapper.selectOne(new LambdaQueryWrapper<SysConfig>()
.eq(SysConfig::getConfigKey, configKey));
if (Validator.isNotNull(retConfig)) {
redisCache.setCacheObject(getCacheKey(configKey), retConfig.getConfigValue());
return retConfig.getConfigValue();
}
return StrUtil.EMPTY;
}
/** /**
* 查询参数配置列表 * 根据键名查询参数配置信息
* *
* @param config 参数配置信息 * @param configKey 参数key
* @return 参数配置集合 * @return 参数键值
*/ */
@Override @Override
public List<SysConfig> selectConfigList(SysConfig config) { public String selectConfigByKey(String configKey) {
Map<String, Object> params = config.getParams(); String configValue = Convert.toStr(redisCache.getCacheObject(getCacheKey(configKey)));
LambdaQueryWrapper<SysConfig> lqw = new LambdaQueryWrapper<SysConfig>() if (Validator.isNotEmpty(configValue)) {
.like(StrUtil.isNotBlank(config.getConfigName()), SysConfig::getConfigName, config.getConfigName()) return configValue;
.eq(StrUtil.isNotBlank(config.getConfigType()), SysConfig::getConfigType, config.getConfigType()) }
.like(StrUtil.isNotBlank(config.getConfigKey()), SysConfig::getConfigKey, config.getConfigKey()) SysConfig retConfig = baseMapper.selectOne(new LambdaQueryWrapper<SysConfig>()
.apply(Validator.isNotEmpty(params.get("beginTime")), .eq(SysConfig::getConfigKey, configKey));
"date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')", if (Validator.isNotNull(retConfig)) {
params.get("beginTime")) redisCache.setCacheObject(getCacheKey(configKey), retConfig.getConfigValue());
.apply(Validator.isNotEmpty(params.get("endTime")), return retConfig.getConfigValue();
"date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')", }
params.get("endTime")); return StrUtil.EMPTY;
return baseMapper.selectList(lqw); }
}
/** /**
* 新增参数配置 * 查询参数配置列表
* *
* @param config 参数配置信息 * @param config 参数配置信息
* @return 结果 * @return 参数配置集合
*/ */
@Override @Override
public int insertConfig(SysConfig config) { public List<SysConfig> selectConfigList(SysConfig config) {
int row = baseMapper.insert(config); Map<String, Object> params = config.getParams();
if (row > 0) { LambdaQueryWrapper<SysConfig> lqw = new LambdaQueryWrapper<SysConfig>()
redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue()); .like(StrUtil.isNotBlank(config.getConfigName()), SysConfig::getConfigName, config.getConfigName())
} .eq(StrUtil.isNotBlank(config.getConfigType()), SysConfig::getConfigType, config.getConfigType())
return row; .like(StrUtil.isNotBlank(config.getConfigKey()), SysConfig::getConfigKey, config.getConfigKey())
} .apply(Validator.isNotEmpty(params.get("beginTime")),
"date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')",
params.get("beginTime"))
.apply(Validator.isNotEmpty(params.get("endTime")),
"date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')",
params.get("endTime"));
return baseMapper.selectList(lqw);
}
/** /**
* 修改参数配置 * 新增参数配置
* *
* @param config 参数配置信息 * @param config 参数配置信息
* @return 结果 * @return 结果
*/ */
@Override @Override
public int updateConfig(SysConfig config) { public int insertConfig(SysConfig config) {
int row = baseMapper.updateById(config); int row = baseMapper.insert(config);
if (row > 0) { if (row > 0) {
redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue()); redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue());
} }
return row; return row;
} }
/** /**
* 批量删除参数信息 * 修改参数配置
* *
* @param configIds 需要删除的参数ID * @param config 参数配置信息
* @return 结果 * @return 结果
*/ */
@Override @Override
public int deleteConfigByIds(Long[] configIds) { public int updateConfig(SysConfig config) {
for (Long configId : configIds) { int row = baseMapper.updateById(config);
SysConfig config = selectConfigById(configId); if (row > 0) {
if (StrUtil.equals(UserConstants.YES, config.getConfigType())) { redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue());
throw new CustomException(String.format("内置参数【%1$s】不能删除 ", config.getConfigKey())); }
} return row;
} }
int count = baseMapper.deleteBatchIds(Arrays.asList(configIds));
if (count > 0) {
Collection<String> keys = redisCache.keys(Constants.SYS_CONFIG_KEY + "*");
redisCache.deleteObject(keys);
}
return count;
}
/** /**
* 清空缓存数据 * 批量删除参数信息
*/ *
@Override * @param configIds 需要删除的参数ID
public void clearCache() { * @return 结果
Collection<String> keys = redisCache.keys(Constants.SYS_CONFIG_KEY + "*"); */
redisCache.deleteObject(keys); @Override
} public void deleteConfigByIds(Long[] configIds) {
for (Long configId : configIds) {
SysConfig config = selectConfigById(configId);
if (StrUtil.equals(UserConstants.YES, config.getConfigType())) {
throw new CustomException(String.format("内置参数【%1$s】不能删除 ", config.getConfigKey()));
}
configMapper.deleteById(configId);
redisCache.deleteObject(getCacheKey(config.getConfigKey()));
}
}
/** /**
* 校验参数键名是否唯一 * 加载参数缓存数据
* */
* @param config 参数配置信息 @Override
* @return 结果 public void loadingConfigCache() {
*/ List<SysConfig> configsList = selectConfigList(new SysConfig());
@Override for (SysConfig config : configsList) {
public String checkConfigKeyUnique(SysConfig config) { redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue());
Long configId = Validator.isNull(config.getConfigId()) ? -1L : config.getConfigId(); }
SysConfig info = baseMapper.selectOne(new LambdaQueryWrapper<SysConfig>().eq(SysConfig::getConfigKey, config.getConfigKey())); }
if (Validator.isNotNull(info) && info.getConfigId().longValue() != configId.longValue()) {
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/** /**
* 设置cache key * 清空参数缓存数据
* */
* @param configKey 参数键 @Override
* @return 缓存键key public void clearConfigCache() {
*/ Collection<String> keys = redisCache.keys(Constants.SYS_CONFIG_KEY + "*");
private String getCacheKey(String configKey) { redisCache.deleteObject(keys);
return Constants.SYS_CONFIG_KEY + configKey; }
}
/**
* 重置参数缓存数据
*/
@Override
public void resetConfigCache() {
clearConfigCache();
loadingConfigCache();
}
/**
* 校验参数键名是否唯一
*
* @param config 参数配置信息
* @return 结果
*/
@Override
public String checkConfigKeyUnique(SysConfig config) {
Long configId = Validator.isNull(config.getConfigId()) ? -1L : config.getConfigId();
SysConfig info = baseMapper.selectOne(new LambdaQueryWrapper<SysConfig>().eq(SysConfig::getConfigKey, config.getConfigKey()));
if (Validator.isNotNull(info) && info.getConfigId().longValue() != configId.longValue()) {
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
/**
* 设置cache key
*
* @param configKey 参数键
* @return 缓存键key
*/
private String getCacheKey(String configKey) {
return Constants.SYS_CONFIG_KEY + configKey;
}
} }

184
ruoyi/src/main/java/com/ruoyi/system/service/impl/SysDictDataServiceImpl.java
View File

@ -11,7 +11,6 @@ import com.ruoyi.system.mapper.SysDictDataMapper;
import com.ruoyi.system.service.ISysDictDataService; import com.ruoyi.system.service.ISysDictDataService;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.util.Arrays;
import java.util.List; import java.util.List;
/** /**
@ -22,100 +21,103 @@ import java.util.List;
@Service @Service
public class SysDictDataServiceImpl extends ServiceImpl<SysDictDataMapper, SysDictData> implements ISysDictDataService { public class SysDictDataServiceImpl extends ServiceImpl<SysDictDataMapper, SysDictData> implements ISysDictDataService {
@Override @Override
public TableDataInfo<SysDictData> selectPageDictDataList(SysDictData dictData) { public TableDataInfo<SysDictData> selectPageDictDataList(SysDictData dictData) {
LambdaQueryWrapper<SysDictData> lqw = new LambdaQueryWrapper<SysDictData>() LambdaQueryWrapper<SysDictData> lqw = new LambdaQueryWrapper<SysDictData>()
.eq(StrUtil.isNotBlank(dictData.getDictType()), SysDictData::getDictType, dictData.getDictType()) .eq(StrUtil.isNotBlank(dictData.getDictType()), SysDictData::getDictType, dictData.getDictType())
.like(StrUtil.isNotBlank(dictData.getDictLabel()), SysDictData::getDictLabel, dictData.getDictLabel()) .like(StrUtil.isNotBlank(dictData.getDictLabel()), SysDictData::getDictLabel, dictData.getDictLabel())
.eq(StrUtil.isNotBlank(dictData.getStatus()), SysDictData::getStatus, dictData.getStatus()) .eq(StrUtil.isNotBlank(dictData.getStatus()), SysDictData::getStatus, dictData.getStatus())
.orderByAsc(SysDictData::getDictSort); .orderByAsc(SysDictData::getDictSort);
return PageUtils.buildDataInfo(page(PageUtils.buildPage(),lqw)); return PageUtils.buildDataInfo(page(PageUtils.buildPage(), lqw));
} }
/** /**
* 根据条件分页查询字典数据 * 根据条件分页查询字典数据
* *
* @param dictData 字典数据信息 * @param dictData 字典数据信息
* @return 字典数据集合信息 * @return 字典数据集合信息
*/ */
@Override @Override
public List<SysDictData> selectDictDataList(SysDictData dictData) { public List<SysDictData> selectDictDataList(SysDictData dictData) {
return list(new LambdaQueryWrapper<SysDictData>() return list(new LambdaQueryWrapper<SysDictData>()
.eq(StrUtil.isNotBlank(dictData.getDictType()), SysDictData::getDictType, dictData.getDictType()) .eq(StrUtil.isNotBlank(dictData.getDictType()), SysDictData::getDictType, dictData.getDictType())
.like(StrUtil.isNotBlank(dictData.getDictLabel()), SysDictData::getDictLabel, dictData.getDictLabel()) .like(StrUtil.isNotBlank(dictData.getDictLabel()), SysDictData::getDictLabel, dictData.getDictLabel())
.eq(StrUtil.isNotBlank(dictData.getStatus()), SysDictData::getStatus, dictData.getStatus()) .eq(StrUtil.isNotBlank(dictData.getStatus()), SysDictData::getStatus, dictData.getStatus())
.orderByAsc(SysDictData::getDictSort)); .orderByAsc(SysDictData::getDictSort));
} }
/** /**
* 根据字典类型和字典键值查询字典数据信息 * 根据字典类型和字典键值查询字典数据信息
* *
* @param dictType 字典类型 * @param dictType 字典类型
* @param dictValue 字典键值 * @param dictValue 字典键值
* @return 字典标签 * @return 字典标签
*/ */
@Override @Override
public String selectDictLabel(String dictType, String dictValue) { public String selectDictLabel(String dictType, String dictValue) {
return getOne(new LambdaQueryWrapper<SysDictData>() return getOne(new LambdaQueryWrapper<SysDictData>()
.select(SysDictData::getDictLabel) .select(SysDictData::getDictLabel)
.eq(SysDictData::getDictType, dictType) .eq(SysDictData::getDictType, dictType)
.eq(SysDictData::getDictValue, dictValue)) .eq(SysDictData::getDictValue, dictValue))
.getDictLabel(); .getDictLabel();
} }
/** /**
* 根据字典数据ID查询信息 * 根据字典数据ID查询信息
* *
* @param dictCode 字典数据ID * @param dictCode 字典数据ID
* @return 字典数据 * @return 字典数据
*/ */
@Override @Override
public SysDictData selectDictDataById(Long dictCode) { public SysDictData selectDictDataById(Long dictCode) {
return getById(dictCode); return getById(dictCode);
} }
/** /**
* 批量删除字典数据信息 * 批量删除字典数据信息
* *
* @param dictCodes 需要删除的字典数据ID * @param dictCodes 需要删除的字典数据ID
* @return 结果 * @return 结果
*/ */
@Override @Override
public int deleteDictDataByIds(Long[] dictCodes) { public void deleteDictDataByIds(Long[] dictCodes) {
int row = baseMapper.deleteBatchIds(Arrays.asList(dictCodes)); for (Long dictCode : dictCodes) {
if (row > 0) { SysDictData data = selectDictDataById(dictCode);
DictUtils.clearDictCache(); baseMapper.deleteById(dictCode);
} List<SysDictData> dictDatas = baseMapper.selectDictDataByType(data.getDictType());
return row; DictUtils.setDictCache(data.getDictType(), dictDatas);
} }
}
/** /**
* 新增保存字典数据信息 * 新增保存字典数据信息
* *
* @param dictData 字典数据信息 * @param data 字典数据信息
* @return 结果 * @return 结果
*/ */
@Override @Override
public int insertDictData(SysDictData dictData) { public int insertDictData(SysDictData data) {
int row = baseMapper.insert(dictData); int row = baseMapper.insert(data);
if (row > 0) { if (row > 0) {
DictUtils.clearDictCache(); List<SysDictData> dictDatas = baseMapper.selectDictDataByType(data.getDictType());
} DictUtils.setDictCache(data.getDictType(), dictDatas);
return row; }
} return row;
}
/** /**
* 修改保存字典数据信息 * 修改保存字典数据信息
* *
* @param dictData 字典数据信息 * @param data 字典数据信息
* @return 结果 * @return 结果
*/ */
@Override @Override
public int updateDictData(SysDictData dictData) { public int updateDictData(SysDictData data) {
int row = baseMapper.updateById(dictData); int row = baseMapper.updateById(data);
if (row > 0) { if (row > 0) {
DictUtils.clearDictCache(); List<SysDictData> dictDatas = baseMapper.selectDictDataByType(data.getDictType());
} DictUtils.setDictCache(data.getDictType(), dictDatas);
return row; }
} return row;
}
} }

374
ruoyi/src/main/java/com/ruoyi/system/service/impl/SysDictTypeServiceImpl.java
View File

@ -21,7 +21,6 @@ import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import javax.annotation.PostConstruct; import javax.annotation.PostConstruct;
import java.util.Arrays;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@ -33,197 +32,208 @@ import java.util.Map;
@Service @Service
public class SysDictTypeServiceImpl extends ServiceImpl<SysDictTypeMapper, SysDictType> implements ISysDictTypeService { public class SysDictTypeServiceImpl extends ServiceImpl<SysDictTypeMapper, SysDictType> implements ISysDictTypeService {
@Autowired @Autowired
private SysDictDataMapper dictDataMapper; private SysDictTypeMapper dictTypeMapper;
/** @Autowired
* 项目启动时，初始化字典到缓存 private SysDictDataMapper dictDataMapper;
*/
@PostConstruct
public void init() {
List<SysDictType> dictTypeList = list();
for (SysDictType dictType : dictTypeList) {
List<SysDictData> dictDatas = dictDataMapper.selectList(
new LambdaQueryWrapper<SysDictData>()
.eq(SysDictData::getStatus, 0)
.eq(SysDictData::getDictType, dictType.getDictType())
.orderByAsc(SysDictData::getDictSort));
DictUtils.setDictCache(dictType.getDictType(), dictDatas);
}
}
@Override /**
public TableDataInfo<SysDictType> selectPageDictTypeList(SysDictType dictType) { * 项目启动时，初始化字典到缓存
Map<String, Object> params = dictType.getParams(); */
LambdaQueryWrapper<SysDictType> lqw = new LambdaQueryWrapper<SysDictType>() @PostConstruct
.like(StrUtil.isNotBlank(dictType.getDictName()), SysDictType::getDictName, dictType.getDictName()) public void init() {
.eq(StrUtil.isNotBlank(dictType.getStatus()), SysDictType::getStatus, dictType.getStatus()) loadingDictCache();
.like(StrUtil.isNotBlank(dictType.getDictType()), SysDictType::getDictType, dictType.getDictType()) }
.apply(Validator.isNotEmpty(params.get("beginTime")),
"date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')",
params.get("beginTime"))
.apply(Validator.isNotEmpty(params.get("endTime")),
"date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')",
params.get("endTime"));
return PageUtils.buildDataInfo(page(PageUtils.buildPage(),lqw));
}
/** @Override
* 根据条件分页查询字典类型 public TableDataInfo<SysDictType> selectPageDictTypeList(SysDictType dictType) {
* Map<String, Object> params = dictType.getParams();
* @param dictType 字典类型信息 LambdaQueryWrapper<SysDictType> lqw = new LambdaQueryWrapper<SysDictType>()
* @return 字典类型集合信息 .like(StrUtil.isNotBlank(dictType.getDictName()), SysDictType::getDictName, dictType.getDictName())
*/ .eq(StrUtil.isNotBlank(dictType.getStatus()), SysDictType::getStatus, dictType.getStatus())
@Override .like(StrUtil.isNotBlank(dictType.getDictType()), SysDictType::getDictType, dictType.getDictType())
public List<SysDictType> selectDictTypeList(SysDictType dictType) { .apply(Validator.isNotEmpty(params.get("beginTime")),
Map<String, Object> params = dictType.getParams(); "date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')",
return list(new LambdaQueryWrapper<SysDictType>() params.get("beginTime"))
.like(StrUtil.isNotBlank(dictType.getDictName()),SysDictType::getDictName, dictType.getDictName()) .apply(Validator.isNotEmpty(params.get("endTime")),
.eq(StrUtil.isNotBlank(dictType.getStatus()),SysDictType::getStatus, dictType.getStatus()) "date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')",
.like(StrUtil.isNotBlank(dictType.getDictType()),SysDictType::getDictType, dictType.getDictType()) params.get("endTime"));
.apply(Validator.isNotEmpty(params.get("beginTime")), return PageUtils.buildDataInfo(page(PageUtils.buildPage(), lqw));
"date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')", }
params.get("beginTime"))
.apply(Validator.isNotEmpty(params.get("endTime")),
"date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')",
params.get("endTime")));
}
/** /**
* 根据所有字典类型 * 根据条件分页查询字典类型
* *
* @return 字典类型集合信息 * @param dictType 字典类型信息
*/ * @return 字典类型集合信息
@Override */
public List<SysDictType> selectDictTypeAll() { @Override
return list(); public List<SysDictType> selectDictTypeList(SysDictType dictType) {
} Map<String, Object> params = dictType.getParams();
return list(new LambdaQueryWrapper<SysDictType>()
.like(StrUtil.isNotBlank(dictType.getDictName()), SysDictType::getDictName, dictType.getDictName())
.eq(StrUtil.isNotBlank(dictType.getStatus()), SysDictType::getStatus, dictType.getStatus())
.like(StrUtil.isNotBlank(dictType.getDictType()), SysDictType::getDictType, dictType.getDictType())
.apply(Validator.isNotEmpty(params.get("beginTime")),
"date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')",
params.get("beginTime"))
.apply(Validator.isNotEmpty(params.get("endTime")),
"date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')",
params.get("endTime")));
}
/** /**
* 根据字典类型查询字典数据 * 根据所有字典类型
* *
* @param dictType 字典类型 * @return 字典类型集合信息
* @return 字典数据集合信息 */
*/ @Override
@Override public List<SysDictType> selectDictTypeAll() {
public List<SysDictData> selectDictDataByType(String dictType) { return list();
List<SysDictData> dictDatas = DictUtils.getDictCache(dictType); }
if (CollUtil.isNotEmpty(dictDatas)) {
return dictDatas;
}
dictDatas = dictDataMapper.selectList(new LambdaQueryWrapper<SysDictData>()
.eq(SysDictData::getStatus, 0)
.eq(SysDictData::getDictType, dictType)
.orderByAsc(SysDictData::getDictSort));
if (CollUtil.isNotEmpty(dictDatas)) {
DictUtils.setDictCache(dictType, dictDatas);
return dictDatas;
}
return null;
}
/** /**
* 根据字典类型ID查询信息 * 根据字典类型查询字典数据
* *
* @param dictId 字典类型ID * @param dictType 字典类型
* @return 字典类型 * @return 字典数据集合信息
*/ */
@Override @Override
public SysDictType selectDictTypeById(Long dictId) { public List<SysDictData> selectDictDataByType(String dictType) {
return getById(dictId); List<SysDictData> dictDatas = DictUtils.getDictCache(dictType);
} if (CollUtil.isNotEmpty(dictDatas)) {
return dictDatas;
}
dictDatas = dictDataMapper.selectDictDataByType(dictType);
if (CollUtil.isNotEmpty(dictDatas)) {
DictUtils.setDictCache(dictType, dictDatas);
return dictDatas;
}
return null;
}
/** /**
* 根据字典类型查询信息 * 根据字典类型ID查询信息
* *
* @param dictType 字典类型 * @param dictId 字典类型ID
* @return 字典类型 * @return 字典类型
*/ */
@Override @Override
public SysDictType selectDictTypeByType(String dictType) { public SysDictType selectDictTypeById(Long dictId) {
return getOne(new LambdaQueryWrapper<SysDictType>().eq(SysDictType::getDictType, dictType)); return getById(dictId);
} }
/** /**
* 批量删除字典类型信息 * 根据字典类型查询信息
* *
* @param dictIds 需要删除的字典ID * @param dictType 字典类型
* @return 结果 * @return 字典类型
*/ */
@Override @Override
public int deleteDictTypeByIds(Long[] dictIds) { public SysDictType selectDictTypeByType(String dictType) {
for (Long dictId : dictIds) { return getOne(new LambdaQueryWrapper<SysDictType>().eq(SysDictType::getDictType, dictType));
SysDictType dictType = selectDictTypeById(dictId); }
if (dictDataMapper.selectCount(new LambdaQueryWrapper<SysDictData>()
.eq(SysDictData::getDictType, dictType.getDictType())) > 0) {
throw new CustomException(String.format("%1$s已分配,不能删除", dictType.getDictName()));
}
}
int count = baseMapper.deleteBatchIds(Arrays.asList(dictIds));
if (count > 0) {
DictUtils.clearDictCache();
}
return count;
}
/** /**
* 清空缓存数据 * 批量删除字典类型信息
*/ *
@Override * @param dictIds 需要删除的字典ID
public void clearCache() { * @return 结果
DictUtils.clearDictCache(); */
} @Override
public void deleteDictTypeByIds(Long[] dictIds) {
for (Long dictId : dictIds) {
SysDictType dictType = selectDictTypeById(dictId);
if (dictDataMapper.selectCount(new LambdaQueryWrapper<SysDictData>()
.eq(SysDictData::getDictType, dictType.getDictType())) > 0) {
throw new CustomException(String.format("%1$s已分配,不能删除", dictType.getDictName()));
}
dictTypeMapper.deleteById(dictId);
DictUtils.removeDictCache(dictType.getDictType());
}
}
/** /**
* 新增保存字典类型信息 * 加载字典缓存数据
* */
* @param dictType 字典类型信息 @Override
* @return 结果 public void loadingDictCache() {
*/ List<SysDictType> dictTypeList = list();
@Override for (SysDictType dictType : dictTypeList) {
public int insertDictType(SysDictType dictType) { List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(dictType.getDictType());
int row = baseMapper.insert(dictType); DictUtils.setDictCache(dictType.getDictType(), dictDatas);
if (row > 0) { }
DictUtils.clearDictCache(); }
}
return row;
}
/** /**
* 修改保存字典类型信息 * 清空字典缓存数据
* */
* @param dictType 字典类型信息 @Override
* @return 结果 public void clearDictCache() {
*/ DictUtils.clearDictCache();
@Override }
@Transactional
public int updateDictType(SysDictType dictType) {
SysDictType oldDict = getById(dictType.getDictId());
dictDataMapper.update(null, new LambdaUpdateWrapper<SysDictData>()
.set(SysDictData::getDictType, dictType.getDictType())
.eq(SysDictData::getDictType, oldDict.getDictType()));
int row = baseMapper.updateById(dictType);
if (row > 0) {
DictUtils.clearDictCache();
}
return row;
}
/** /**
* 校验字典类型称是否唯一 * 重置字典缓存数据
* */
* @param dict 字典类型 @Override
* @return 结果 public void resetDictCache() {
*/ clearDictCache();
@Override loadingDictCache();
public String checkDictTypeUnique(SysDictType dict) { }
Long dictId = Validator.isNull(dict.getDictId()) ? -1L : dict.getDictId();
SysDictType dictType = getOne(new LambdaQueryWrapper<SysDictType>() /**
.eq(SysDictType::getDictType, dict.getDictType()) * 新增保存字典类型信息
.last("limit 1")); *
if (Validator.isNotNull(dictType) && dictType.getDictId().longValue() != dictId.longValue()) { * @param dict 字典类型信息
return UserConstants.NOT_UNIQUE; * @return 结果
} */
return UserConstants.UNIQUE; @Override
} public int insertDictType(SysDictType dict) {
int row = baseMapper.insert(dict);
if (row > 0) {
DictUtils.setDictCache(dict.getDictType(), null);
}
return row;
}
/**
* 修改保存字典类型信息
*
* @param dict 字典类型信息
* @return 结果
*/
@Override
@Transactional
public int updateDictType(SysDictType dict) {
SysDictType oldDict = getById(dict.getDictId());
dictDataMapper.update(null, new LambdaUpdateWrapper<SysDictData>()
.set(SysDictData::getDictType, dict.getDictType())
.eq(SysDictData::getDictType, oldDict.getDictType()));
int row = baseMapper.updateById(dict);
if (row > 0) {
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(dict.getDictType());
DictUtils.setDictCache(dict.getDictType(), dictDatas);
}
return row;
}
/**
* 校验字典类型称是否唯一
*
* @param dict 字典类型
* @return 结果
*/
@Override
public String checkDictTypeUnique(SysDictType dict) {
Long dictId = Validator.isNull(dict.getDictId()) ? -1L : dict.getDictId();
SysDictType dictType = getOne(new LambdaQueryWrapper<SysDictType>()
.eq(SysDictType::getDictType, dict.getDictType())
.last("limit 1"));
if (Validator.isNotNull(dictType) && dictType.getDictId().longValue() != dictId.longValue()) {
return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
} }

13
ruoyi/src/main/java/com/ruoyi/web/controller/system/SysConfigController.java
View File

@ -20,7 +20,7 @@ import java.util.List;
/** /**
* 参数配置 信息操作处理 * 参数配置 信息操作处理
* *
* @author ruoyi * @author ruoyi
*/ */
@RestController @RestController
@ -110,18 +110,19 @@ public class SysConfigController extends BaseController
@DeleteMapping("/{configIds}") @DeleteMapping("/{configIds}")
public AjaxResult remove(@PathVariable Long[] configIds) public AjaxResult remove(@PathVariable Long[] configIds)
{ {
return toAjax(configService.deleteConfigByIds(configIds)); configService.deleteConfigByIds(configIds);
return success();
} }
/** /**
* 清空缓存 * 刷新参数缓存
*/ */
@PreAuthorize("@ss.hasPermi('system:config:remove')") @PreAuthorize("@ss.hasPermi('system:config:remove')")
@Log(title = "参数管理", businessType = BusinessType.CLEAN) @Log(title = "参数管理", businessType = BusinessType.CLEAN)
@DeleteMapping("/clearCache") @DeleteMapping("/refreshCache")
public AjaxResult clearCache() public AjaxResult refreshCache()
{ {
configService.clearCache(); configService.resetConfigCache();
return AjaxResult.success(); return AjaxResult.success();
} }
} }

5
ruoyi/src/main/java/com/ruoyi/web/controller/system/SysDictDataController.java
View File

@ -21,7 +21,7 @@ import java.util.List;
/** /**
* 数据字典信息 * 数据字典信息
* *
* @author ruoyi * @author ruoyi
*/ */
@RestController @RestController
@ -107,6 +107,7 @@ public class SysDictDataController extends BaseController
@DeleteMapping("/{dictCodes}") @DeleteMapping("/{dictCodes}")
public AjaxResult remove(@PathVariable Long[] dictCodes) public AjaxResult remove(@PathVariable Long[] dictCodes)
{ {
return toAjax(dictDataService.deleteDictDataByIds(dictCodes)); dictDataService.deleteDictDataByIds(dictCodes);
return success();
} }
} }

13
ruoyi/src/main/java/com/ruoyi/web/controller/system/SysDictTypeController.java
View File

@ -19,7 +19,7 @@ import java.util.List;
/** /**
* 数据字典信息 * 数据字典信息
* *
* @author ruoyi * @author ruoyi
*/ */
@RestController @RestController
@ -96,18 +96,19 @@ public class SysDictTypeController extends BaseController
@DeleteMapping("/{dictIds}") @DeleteMapping("/{dictIds}")
public AjaxResult remove(@PathVariable Long[] dictIds) public AjaxResult remove(@PathVariable Long[] dictIds)
{ {
return toAjax(dictTypeService.deleteDictTypeByIds(dictIds)); dictTypeService.deleteDictTypeByIds(dictIds);
return success();
} }
/** /**
* 清空缓存 * 刷新字典缓存
*/ */
@PreAuthorize("@ss.hasPermi('system:dict:remove')") @PreAuthorize("@ss.hasPermi('system:dict:remove')")
@Log(title = "字典类型", businessType = BusinessType.CLEAN) @Log(title = "字典类型", businessType = BusinessType.CLEAN)
@DeleteMapping("/clearCache") @DeleteMapping("/refreshCache")
public AjaxResult clearCache() public AjaxResult refreshCache()
{ {
dictTypeService.clearCache(); dictTypeService.resetDictCache();
return AjaxResult.success(); return AjaxResult.success();
} }

2
ruoyi/src/main/resources/application-dev.yml
View File

@ -76,4 +76,4 @@ spring:
# 连接池的最大数据库连接数 # 连接池的最大数据库连接数
max-active: 8 max-active: 8
# #连接池最大阻塞等待时间（使用负值表示没有限制） # #连接池最大阻塞等待时间（使用负值表示没有限制）
max-wait: -1ms max-wait: -1ms

13
ruoyi/src/main/resources/mapper/system/SysDeptMapper.xml
View File

@ -40,7 +40,9 @@
AND status = #{status} AND status = #{status}
</if> </if>
<!-- 数据范围过滤 --> <!-- 数据范围过滤 -->
${params.dataScope} <if test="params.dataScope != null and params.dataScope != ''">
AND ( ${params.dataScope} )
</if>
order by d.parent_id, d.order_num order by d.parent_id, d.order_num
</select> </select>
@ -49,11 +51,10 @@
from sys_dept d from sys_dept d
left join sys_role_dept rd on d.dept_id = rd.dept_id left join sys_role_dept rd on d.dept_id = rd.dept_id
where rd.role_id = #{roleId} where rd.role_id = #{roleId}
<if test="deptCheckStrictly"> <if test="deptCheckStrictly">
and d.dept_id not in (select d.parent_id from sys_dept d inner join sys_role_dept rd on d.dept_id = and d.dept_id not in (select d.parent_id from sys_dept d inner join sys_role_dept rd on d.dept_id = rd.dept_id and rd.role_id = #{roleId})
rd.dept_id and rd.role_id = #{roleId}) </if>
</if>
order by d.parent_id, d.order_num order by d.parent_id, d.order_num
</select> </select>
</mapper> </mapper>

10
ruoyi/src/main/resources/mapper/system/SysRoleMapper.xml
View File

@ -58,7 +58,9 @@
and date_format(r.create_time,'%y%m%d') &lt;= date_format(#{role.params.endTime},'%y%m%d') and date_format(r.create_time,'%y%m%d') &lt;= date_format(#{role.params.endTime},'%y%m%d')
</if> </if>
<!-- 数据范围过滤 --> <!-- 数据范围过滤 -->
${role.params.dataScope} <if test="role.params.dataScope != null and role.params.dataScope != ''">
AND ( ${role.params.dataScope} )
</if>
order by r.role_sort order by r.role_sort
</select> </select>
@ -81,7 +83,9 @@
and date_format(r.create_time,'%y%m%d') &lt;= date_format(#{params.endTime},'%y%m%d') and date_format(r.create_time,'%y%m%d') &lt;= date_format(#{params.endTime},'%y%m%d')
</if> </if>
<!-- 数据范围过滤 --> <!-- 数据范围过滤 -->
${params.dataScope} <if test="params.dataScope != null and params.dataScope != ''">
AND ( ${params.dataScope} )
</if>
order by r.role_sort order by r.role_sort
</select> </select>
@ -103,4 +107,4 @@
WHERE r.del_flag = '0' and u.user_name = #{userName} WHERE r.del_flag = '0' and u.user_name = #{userName}
</select> </select>
</mapper> </mapper>

10
ruoyi/src/main/resources/mapper/system/SysUserMapper.xml
View File

@ -106,7 +106,9 @@
ancestors) )) ancestors) ))
</if> </if>
<!-- 数据范围过滤 --> <!-- 数据范围过滤 -->
${user.params.dataScope} <if test="user.params.dataScope != null and user.params.dataScope != ''">
AND ( ${user.params.dataScope} )
</if>
</select> </select>
<select id="selectUserList" parameterType="SysUser" resultMap="SysUserResult"> <select id="selectUserList" parameterType="SysUser" resultMap="SysUserResult">
@ -135,7 +137,9 @@
ancestors) )) ancestors) ))
</if> </if>
<!-- 数据范围过滤 --> <!-- 数据范围过滤 -->
${params.dataScope} <if test="params.dataScope != null and params.dataScope != ''">
AND ( ${params.dataScope} )
</if>
</select> </select>
<select id="selectUserByUserName" parameterType="String" resultMap="SysUserResult"> <select id="selectUserByUserName" parameterType="String" resultMap="SysUserResult">
@ -149,4 +153,4 @@
</select> </select>
</mapper> </mapper>