opensource/RuoYi-Vue-Plus
2
0
Fork 1
mirror of https://gitee.com/dromara/RuoYi-Vue-Plus.git synced 2026-09-21 02:25:56 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

update 更新 system 相关表接口 (sys_dict_data, sys_dict_type) 新增 Bo | Vo 类, 更改请求以及响应参数 ;

Browse Source
This commit is contained in:
zlyx 2023-02-01 16:36:15 +08:00
parent 177a73a71c
commit b050b7e3ee
14 changed files with 442 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/controller/system/SysDictDataController.java
View File

@ -10,6 +10,8 @@ import com.ruoyi.system.domain.SysDictData;
import com.ruoyi.common.mybatis.core.page.TableDataInfo;
import com.ruoyi.common.log.enums.BusinessType;
import com.ruoyi.common.excel.utils.ExcelUtil;
import com.ruoyi.system.domain.bo.SysDictDataBo;
import com.ruoyi.system.domain.vo.SysDictDataVo;
import com.ruoyi.system.service.ISysDictDataService;
import com.ruoyi.system.service.ISysDictTypeService;
import lombok.RequiredArgsConstructor;
@ -39,8 +41,8 @@ public class SysDictDataController extends BaseController {
*/
@SaCheckPermission("system:dict:list")
@GetMapping("/list")
public TableDataInfo<SysDictData> list(SysDictData dictData, PageQuery pageQuery) {
return dictDataService.selectPageDictDataList(dictData, pageQuery);
public TableDataInfo<SysDictDataVo> list(SysDictDataBo bo, PageQuery pageQuery) {
return dictDataService.selectPageDictDataList(bo, pageQuery);
}
/**
@ -49,9 +51,9 @@ public class SysDictDataController extends BaseController {
@Log(title = "字典数据", businessType = BusinessType.EXPORT)
@SaCheckPermission("system:dict:export")
@PostMapping("/export")
public void export(SysDictData dictData, HttpServletResponse response) {
List<SysDictData> list = dictDataService.selectDictDataList(dictData);
ExcelUtil.exportExcel(list, "字典数据", SysDictData.class, response);
public void export(SysDictDataBo bo, HttpServletResponse response) {
List<SysDictDataVo> list = dictDataService.selectDictDataList(bo);
ExcelUtil.exportExcel(list, "字典数据", SysDictDataVo.class, response);
}
/**
@ -61,7 +63,7 @@ public class SysDictDataController extends BaseController {
*/
@SaCheckPermission("system:dict:query")
@GetMapping(value = "/{dictCode}")
public R<SysDictData> getInfo(@PathVariable Long dictCode) {
public R<SysDictDataVo> getInfo(@PathVariable Long dictCode) {
return R.ok(dictDataService.selectDictDataById(dictCode));
}
@ -71,8 +73,8 @@ public class SysDictDataController extends BaseController {
* @param dictType 字典类型
*/
@GetMapping(value = "/type/{dictType}")
public R<List<SysDictData>> dictType(@PathVariable String dictType) {
List<SysDictData> data = dictTypeService.selectDictDataByType(dictType);
public R<List<SysDictDataVo>> dictType(@PathVariable String dictType) {
List<SysDictDataVo> data = dictTypeService.selectDictDataByType(dictType);
if (ObjectUtil.isNull(data)) {
data = new ArrayList<>();
}
@ -85,8 +87,8 @@ public class SysDictDataController extends BaseController {
@SaCheckPermission("system:dict:add")
@Log(title = "字典数据", businessType = BusinessType.INSERT)
@PostMapping
public R<Void> add(@Validated @RequestBody SysDictData dict) {
dictDataService.insertDictData(dict);
public R<Void> add(@Validated @RequestBody SysDictDataBo bo) {
dictDataService.insertDictData(bo);
return R.ok();
}
@ -96,8 +98,8 @@ public class SysDictDataController extends BaseController {
@SaCheckPermission("system:dict:edit")
@Log(title = "字典数据", businessType = BusinessType.UPDATE)
@PutMapping
public R<Void> edit(@Validated @RequestBody SysDictData dict) {
dictDataService.updateDictData(dict);
public R<Void> edit(@Validated @RequestBody SysDictDataBo bo) {
dictDataService.updateDictData(bo);
return R.ok();
}

30
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/controller/system/SysDictTypeController.java
View File

@ -10,6 +10,8 @@ import com.ruoyi.system.domain.SysDictType;
import com.ruoyi.common.mybatis.core.page.TableDataInfo;
import com.ruoyi.common.log.enums.BusinessType;
import com.ruoyi.common.excel.utils.ExcelUtil;
import com.ruoyi.system.domain.bo.SysDictTypeBo;
import com.ruoyi.system.domain.vo.SysDictTypeVo;
import com.ruoyi.system.service.ISysDictTypeService;
import lombok.RequiredArgsConstructor;
import org.springframework.validation.annotation.Validated;
@ -36,8 +38,8 @@ public class SysDictTypeController extends BaseController {
*/
@SaCheckPermission("system:dict:list")
@GetMapping("/list")
public TableDataInfo<SysDictType> list(SysDictType dictType, PageQuery pageQuery) {
return dictTypeService.selectPageDictTypeList(dictType, pageQuery);
public TableDataInfo<SysDictTypeVo> list(SysDictTypeBo bo, PageQuery pageQuery) {
return dictTypeService.selectPageDictTypeList(bo, pageQuery);
}
/**
@ -46,9 +48,9 @@ public class SysDictTypeController extends BaseController {
@Log(title = "字典类型", businessType = BusinessType.EXPORT)
@SaCheckPermission("system:dict:export")
@PostMapping("/export")
public void export(SysDictType dictType, HttpServletResponse response) {
List<SysDictType> list = dictTypeService.selectDictTypeList(dictType);
ExcelUtil.exportExcel(list, "字典类型", SysDictType.class, response);
public void export(SysDictTypeBo bo, HttpServletResponse response) {
List<SysDictTypeVo> list = dictTypeService.selectDictTypeList(bo);
ExcelUtil.exportExcel(list, "字典类型", SysDictTypeVo.class, response);
}
/**
@ -58,7 +60,7 @@ public class SysDictTypeController extends BaseController {
*/
@SaCheckPermission("system:dict:query")
@GetMapping(value = "/{dictId}")
public R<SysDictType> getInfo(@PathVariable Long dictId) {
public R<SysDictTypeVo> getInfo(@PathVariable Long dictId) {
return R.ok(dictTypeService.selectDictTypeById(dictId));
}
@ -68,11 +70,11 @@ public class SysDictTypeController extends BaseController {
@SaCheckPermission("system:dict:add")
@Log(title = "字典类型", businessType = BusinessType.INSERT)
@PostMapping
public R<Void> add(@Validated @RequestBody SysDictType dict) {
if (UserConstants.NOT_UNIQUE.equals(dictTypeService.checkDictTypeUnique(dict))) {
return R.fail("新增字典'" + dict.getDictName() + "'失败，字典类型已存在");
public R<Void> add(@Validated @RequestBody SysDictTypeBo bo) {
if (UserConstants.NOT_UNIQUE.equals(dictTypeService.checkDictTypeUnique(bo))) {
return R.fail("新增字典'" + bo.getDictName() + "'失败，字典类型已存在");
}
dictTypeService.insertDictType(dict);
dictTypeService.insertDictType(bo);
return R.ok();
}
@ -82,11 +84,11 @@ public class SysDictTypeController extends BaseController {
@SaCheckPermission("system:dict:edit")
@Log(title = "字典类型", businessType = BusinessType.UPDATE)
@PutMapping
public R<Void> edit(@Validated @RequestBody SysDictType dict) {
if (UserConstants.NOT_UNIQUE.equals(dictTypeService.checkDictTypeUnique(dict))) {
return R.fail("修改字典'" + dict.getDictName() + "'失败，字典类型已存在");
public R<Void> edit(@Validated @RequestBody SysDictTypeBo bo) {
if (UserConstants.NOT_UNIQUE.equals(dictTypeService.checkDictTypeUnique(bo))) {
return R.fail("修改字典'" + bo.getDictName() + "'失败，字典类型已存在");
}
dictTypeService.updateDictType(dict);
dictTypeService.updateDictType(bo);
return R.ok();
}

24
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/SysDictData.java
View File

@ -1,19 +1,12 @@
package com.ruoyi.system.domain;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ruoyi.common.core.constant.UserConstants;
import com.ruoyi.common.mybatis.core.domain.BaseEntity;
import com.ruoyi.common.excel.annotation.ExcelDictFormat;
import com.ruoyi.common.excel.convert.ExcelDictConvert;
import lombok.Data;
import lombok.EqualsAndHashCode;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;
/**
* 字典数据表 sys_dict_data
*
@ -23,50 +16,37 @@ import jakarta.validation.constraints.Size;
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("sys_dict_data")
@ExcelIgnoreUnannotated
public class SysDictData extends BaseEntity {
/**
* 字典编码
*/
@ExcelProperty(value = "字典编码")
@TableId(value = "dict_code")
private Long dictCode;
/**
* 字典排序
*/
@ExcelProperty(value = "字典排序")
private Integer dictSort;
/**
* 字典标签
*/
@ExcelProperty(value = "字典标签")
@NotBlank(message = "字典标签不能为空")
@Size(min = 0, max = 100, message = "字典标签长度不能超过{max}个字符")
private String dictLabel;
/**
* 字典键值
*/
@ExcelProperty(value = "字典键值")
@NotBlank(message = "字典键值不能为空")
@Size(min = 0, max = 100, message = "字典键值长度不能超过{max}个字符")
private String dictValue;
/**
* 字典类型
*/
@ExcelProperty(value = "字典类型")
@NotBlank(message = "字典类型不能为空")
@Size(min = 0, max = 100, message = "字典类型长度不能超过{max}个字符")
private String dictType;
/**
* 样式属性（其他样式扩展）
*/
@Size(min = 0, max = 100, message = "样式属性长度不能超过{max}个字符")
private String cssClass;
/**
@ -77,15 +57,11 @@ public class SysDictData extends BaseEntity {
/**
* 是否默认（Y是 N否）
*/
@ExcelProperty(value = "是否默认", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "sys_yes_no")
private String isDefault;
/**
* 状态（0正常 1停用）
*/
@ExcelProperty(value = "状态", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "sys_normal_disable")
private String status;
/**

19
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/SysDictType.java
View File

@ -1,19 +1,11 @@
package com.ruoyi.system.domain;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ruoyi.common.mybatis.core.domain.BaseEntity;
import com.ruoyi.common.excel.annotation.ExcelDictFormat;
import com.ruoyi.common.excel.convert.ExcelDictConvert;
import lombok.Data;
import lombok.EqualsAndHashCode;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import jakarta.validation.constraints.Size;
/**
* 字典类型表 sys_dict_type
*
@ -23,38 +15,27 @@ import jakarta.validation.constraints.Size;
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("sys_dict_type")
@ExcelIgnoreUnannotated
public class SysDictType extends BaseEntity {
/**
* 字典主键
*/
@ExcelProperty(value = "字典主键")
@TableId(value = "dict_id")
private Long dictId;
/**
* 字典名称
*/
@ExcelProperty(value = "字典名称")
@NotBlank(message = "字典名称不能为空")
@Size(min = 0, max = 100, message = "字典类型名称长度不能超过{max}个字符")
private String dictName;
/**
* 字典类型
*/
@ExcelProperty(value = "字典类型")
@NotBlank(message = "字典类型不能为空")
@Size(min = 0, max = 100, message = "字典类型类型长度不能超过{max}个字符")
@Pattern(regexp = "^[a-z][a-z0-9_]*$", message = "字典类型必须以字母开头，且只能为（小写字母，数字，下滑线）")
private String dictType;
/**
* 状态（0正常 1停用）
*/
@ExcelProperty(value = "状态", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "sys_normal_disable")
private String status;
/**

86
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/bo/SysDictDataBo.java Normal file
View File

@ -0,0 +1,86 @@
package com.ruoyi.system.domain.bo;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import jakarta.validation.constraints.*;
import com.ruoyi.common.mybatis.core.domain.BaseEntity;
/**
* 字典数据业务对象 sys_dict_data
*
* @author ruoyi
* @date 2023-02-01
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class SysDictDataBo extends BaseEntity {
/**
* 字典编码
*/
@NotNull(message = "字典编码不能为空", groups = { EditGroup.class })
private Long dictCode;
/**
* 字典排序
*/
private Integer dictSort;
/**
* 字典标签
*/
@NotBlank(message = "字典标签不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(min = 0, max = 100, message = "字典标签长度不能超过{max}个字符")
private String dictLabel;
/**
* 字典键值
*/
@NotBlank(message = "字典键值不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(min = 0, max = 100, message = "字典键值长度不能超过{max}个字符")
private String dictValue;
/**
* 字典类型
*/
@NotBlank(message = "字典类型不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(min = 0, max = 100, message = "字典类型长度不能超过{max}个字符")
private String dictType;
/**
* 样式属性（其他样式扩展）
*/
@Size(min = 0, max = 100, message = "样式属性长度不能超过{max}个字符")
private String cssClass;
/**
* 表格回显样式
*/
private String listClass;
/**
* 是否默认（Y是 N否）
*/
private String isDefault;
/**
* 状态（0正常 1停用）
*/
private String status;
/**
* 创建部门
*/
private Long createDept;
/**
* 备注
*/
private String remark;
}

59
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/bo/SysDictTypeBo.java Normal file
View File

@ -0,0 +1,59 @@
package com.ruoyi.system.domain.bo;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import jakarta.validation.constraints.*;
import com.ruoyi.common.mybatis.core.domain.BaseEntity;
/**
* 字典类型业务对象 sys_dict_type
*
* @author ruoyi
* @date 2023-02-01
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class SysDictTypeBo extends BaseEntity {
/**
* 字典主键
*/
@NotNull(message = "字典主键不能为空", groups = { EditGroup.class })
private Long dictId;
/**
* 字典名称
*/
@NotBlank(message = "字典名称不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(min = 0, max = 100, message = "字典类型名称长度不能超过{max}个字符")
private String dictName;
/**
* 字典类型
*/
@NotBlank(message = "字典类型不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(min = 0, max = 100, message = "字典类型类型长度不能超过{max}个字符")
@Pattern(regexp = "^[a-z][a-z0-9_]*$", message = "字典类型必须以字母开头，且只能为（小写字母，数字，下滑线）")
private String dictType;
/**
* 状态（0正常 1停用）
*/
private String status;
/**
* 创建部门
*/
private Long createDept;
/**
* 备注
*/
private String remark;
}

92
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/vo/SysDictDataVo.java Normal file
View File

@ -0,0 +1,92 @@
package com.ruoyi.system.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.excel.annotation.ExcelDictFormat;
import com.ruoyi.common.excel.convert.ExcelDictConvert;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
/**
* 字典数据视图对象 sys_dict_data
*
* @author ruoyi
* @date 2023-02-01
*/
@Data
@ExcelIgnoreUnannotated
public class SysDictDataVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 字典编码
*/
@ExcelProperty(value = "字典编码")
private Long dictCode;
/**
* 字典排序
*/
@ExcelProperty(value = "字典排序")
private Integer dictSort;
/**
* 字典标签
*/
@ExcelProperty(value = "字典标签")
private String dictLabel;
/**
* 字典键值
*/
@ExcelProperty(value = "字典键值")
private String dictValue;
/**
* 字典类型
*/
@ExcelProperty(value = "字典类型")
private String dictType;
/**
* 样式属性（其他样式扩展）
*/
private String cssClass;
/**
* 表格回显样式
*/
private String listClass;
/**
* 是否默认（Y是 N否）
*/
@ExcelProperty(value = "是否默认", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "sys_yes_no")
private String isDefault;
/**
* 状态（0正常 1停用）
*/
@ExcelProperty(value = "状态", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "sys_normal_disable")
private String status;
/**
* 备注
*/
@ExcelProperty(value = "备注")
private String remark;
/**
* 创建时间
*/
private Date createTime;
}

63
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/vo/SysDictTypeVo.java Normal file
View File

@ -0,0 +1,63 @@
package com.ruoyi.system.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.excel.annotation.ExcelDictFormat;
import com.ruoyi.common.excel.convert.ExcelDictConvert;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
/**
* 字典类型视图对象 sys_dict_type
*
* @author ruoyi
* @date 2023-02-01
*/
@Data
@ExcelIgnoreUnannotated
public class SysDictTypeVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 字典主键
*/
@ExcelProperty(value = "字典主键")
private Long dictId;
/**
* 字典名称
*/
@ExcelProperty(value = "字典名称")
private String dictName;
/**
* 字典类型
*/
@ExcelProperty(value = "字典类型")
private String dictType;
/**
* 状态（0正常 1停用）
*/
@ExcelProperty(value = "状态", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "sys_normal_disable")
private String status;
/**
* 备注
*/
@ExcelProperty(value = "备注")
private String remark;
/**
* 创建时间
*/
private Date createTime;
}

7
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/mapper/SysDictDataMapper.java
View File

@ -4,6 +4,7 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.common.core.constant.UserConstants;
import com.ruoyi.system.domain.SysDictData;
import com.ruoyi.common.mybatis.core.mapper.BaseMapperPlus;
import com.ruoyi.system.domain.vo.SysDictDataVo;
import java.util.List;
@ -12,10 +13,10 @@ import java.util.List;
*
* @author Lion Li
*/
public interface SysDictDataMapper extends BaseMapperPlus<SysDictDataMapper, SysDictData, SysDictData> {
public interface SysDictDataMapper extends BaseMapperPlus<SysDictDataMapper, SysDictData, SysDictDataVo> {
default List<SysDictData> selectDictDataByType(String dictType) {
return selectList(
default List<SysDictDataVo> selectDictDataByType(String dictType) {
return selectVoList(
new LambdaQueryWrapper<SysDictData>()
.eq(SysDictData::getStatus, UserConstants.DICT_NORMAL)
.eq(SysDictData::getDictType, dictType)

3
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/mapper/SysDictTypeMapper.java
View File

@ -2,12 +2,13 @@ package com.ruoyi.system.mapper;
import com.ruoyi.system.domain.SysDictType;
import com.ruoyi.common.mybatis.core.mapper.BaseMapperPlus;
import com.ruoyi.system.domain.vo.SysDictTypeVo;
/**
* 字典表 数据层
*
* @author Lion Li
*/
public interface SysDictTypeMapper extends BaseMapperPlus<SysDictTypeMapper, SysDictType, SysDictType> {
public interface SysDictTypeMapper extends BaseMapperPlus<SysDictTypeMapper, SysDictType, SysDictTypeVo> {
}

19
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/service/ISysDictDataService.java
View File

@ -1,8 +1,9 @@
package com.ruoyi.system.service;
import com.ruoyi.common.mybatis.core.page.PageQuery;
import com.ruoyi.system.domain.SysDictData;
import com.ruoyi.common.mybatis.core.page.TableDataInfo;
import com.ruoyi.system.domain.bo.SysDictDataBo;
import com.ruoyi.system.domain.vo.SysDictDataVo;
import java.util.List;
@ -14,15 +15,15 @@ import java.util.List;
public interface ISysDictDataService {
TableDataInfo<SysDictData> selectPageDictDataList(SysDictData dictData, PageQuery pageQuery);
TableDataInfo<SysDictDataVo> selectPageDictDataList(SysDictDataBo bo, PageQuery pageQuery);
/**
* 根据条件分页查询字典数据
*
* @param dictData 字典数据信息
* @param bo 字典数据信息
* @return 字典数据集合信息
*/
List<SysDictData> selectDictDataList(SysDictData dictData);
List<SysDictDataVo> selectDictDataList(SysDictDataBo bo);
/**
* 根据字典类型和字典键值查询字典数据信息
@ -39,7 +40,7 @@ public interface ISysDictDataService {
* @param dictCode 字典数据ID
* @return 字典数据
*/
SysDictData selectDictDataById(Long dictCode);
SysDictDataVo selectDictDataById(Long dictCode);
/**
* 批量删除字典数据信息
@ -51,16 +52,16 @@ public interface ISysDictDataService {
/**
* 新增保存字典数据信息
*
* @param dictData 字典数据信息
* @param bo 字典数据信息
* @return 结果
*/
List<SysDictData> insertDictData(SysDictData dictData);
List<SysDictDataVo> insertDictData(SysDictDataBo bo);
/**
* 修改保存字典数据信息
*
* @param dictData 字典数据信息
* @param bo 字典数据信息
* @return 结果
*/
List<SysDictData> updateDictData(SysDictData dictData);
List<SysDictDataVo> updateDictData(SysDictDataBo bo);
}

28
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/service/ISysDictTypeService.java
View File

@ -1,9 +1,11 @@
package com.ruoyi.system.service;
import com.ruoyi.common.mybatis.core.page.PageQuery;
import com.ruoyi.system.domain.SysDictData;
import com.ruoyi.system.domain.SysDictType;
import com.ruoyi.common.mybatis.core.page.TableDataInfo;
import com.ruoyi.system.domain.bo.SysDictTypeBo;
import com.ruoyi.system.domain.vo.SysDictDataVo;
import com.ruoyi.system.domain.vo.SysDictTypeVo;
import java.util.List;
@ -15,15 +17,15 @@ import java.util.List;
public interface ISysDictTypeService {
TableDataInfo<SysDictType> selectPageDictTypeList(SysDictType dictType, PageQuery pageQuery);
TableDataInfo<SysDictTypeVo> selectPageDictTypeList(SysDictTypeBo bo, PageQuery pageQuery);
/**
* 根据条件分页查询字典类型
*
* @param dictType 字典类型信息
* @param bo 字典类型信息
* @return 字典类型集合信息
*/
List<SysDictType> selectDictTypeList(SysDictType dictType);
List<SysDictTypeVo> selectDictTypeList(SysDictTypeBo bo);
/**
* 根据所有字典类型
@ -38,7 +40,7 @@ public interface ISysDictTypeService {
* @param dictType 字典类型
* @return 字典数据集合信息
*/
List<SysDictData> selectDictDataByType(String dictType);
List<SysDictDataVo> selectDictDataByType(String dictType);
/**
* 根据字典类型ID查询信息
@ -46,7 +48,7 @@ public interface ISysDictTypeService {
* @param dictId 字典类型ID
* @return 字典类型
*/
SysDictType selectDictTypeById(Long dictId);
SysDictTypeVo selectDictTypeById(Long dictId);
/**
* 根据字典类型查询信息
@ -54,7 +56,7 @@ public interface ISysDictTypeService {
* @param dictType 字典类型
* @return 字典类型
*/
SysDictType selectDictTypeByType(String dictType);
SysDictTypeVo selectDictTypeByType(String dictType);
/**
* 批量删除字典信息
@ -81,24 +83,24 @@ public interface ISysDictTypeService {
/**
* 新增保存字典类型信息
*
* @param dictType 字典类型信息
* @param bo 字典类型信息
* @return 结果
*/
List<SysDictData> insertDictType(SysDictType dictType);
List<SysDictTypeVo> insertDictType(SysDictTypeBo bo);
/**
* 修改保存字典类型信息
*
* @param dictType 字典类型信息
* @param bo 字典类型信息
* @return 结果
*/
List<SysDictData> updateDictType(SysDictType dictType);
List<SysDictDataVo> updateDictType(SysDictTypeBo bo);
/**
* 校验字典类型称是否唯一
*
* @param dictType 字典类型
* @param bo 字典类型
* @return 结果
*/
String checkDictTypeUnique(SysDictType dictType);
String checkDictTypeUnique(SysDictTypeBo bo);
}

55
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysDictDataServiceImpl.java
View File

@ -1,6 +1,8 @@
package com.ruoyi.system.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.constant.CacheNames;
import com.ruoyi.common.mybatis.core.page.PageQuery;
@ -9,6 +11,8 @@ import com.ruoyi.common.mybatis.core.page.TableDataInfo;
import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.redis.utils.CacheUtils;
import com.ruoyi.system.domain.bo.SysDictDataBo;
import com.ruoyi.system.domain.vo.SysDictDataVo;
import com.ruoyi.system.mapper.SysDictDataMapper;
import com.ruoyi.system.service.ISysDictDataService;
import lombok.RequiredArgsConstructor;
@ -29,29 +33,32 @@ public class SysDictDataServiceImpl implements ISysDictDataService {
private final SysDictDataMapper baseMapper;
@Override
public TableDataInfo<SysDictData> selectPageDictDataList(SysDictData dictData, PageQuery pageQuery) {
LambdaQueryWrapper<SysDictData> lqw = new LambdaQueryWrapper<SysDictData>()
.eq(StringUtils.isNotBlank(dictData.getDictType()), SysDictData::getDictType, dictData.getDictType())
.like(StringUtils.isNotBlank(dictData.getDictLabel()), SysDictData::getDictLabel, dictData.getDictLabel())
.eq(StringUtils.isNotBlank(dictData.getStatus()), SysDictData::getStatus, dictData.getStatus())
.orderByAsc(SysDictData::getDictSort);
Page<SysDictData> page = baseMapper.selectPage(pageQuery.build(), lqw);
public TableDataInfo<SysDictDataVo> selectPageDictDataList(SysDictDataBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<SysDictData> lqw = buildQueryWrapper(bo);
Page<SysDictDataVo> page = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(page);
}
/**
* 根据条件分页查询字典数据
*
* @param dictData 字典数据信息
* @param bo 字典数据信息
* @return 字典数据集合信息
*/
@Override
public List<SysDictData> selectDictDataList(SysDictData dictData) {
return baseMapper.selectList(new LambdaQueryWrapper<SysDictData>()
.eq(StringUtils.isNotBlank(dictData.getDictType()), SysDictData::getDictType, dictData.getDictType())
.like(StringUtils.isNotBlank(dictData.getDictLabel()), SysDictData::getDictLabel, dictData.getDictLabel())
.eq(StringUtils.isNotBlank(dictData.getStatus()), SysDictData::getStatus, dictData.getStatus())
.orderByAsc(SysDictData::getDictSort));
public List<SysDictDataVo> selectDictDataList(SysDictDataBo bo) {
LambdaQueryWrapper<SysDictData> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<SysDictData> buildQueryWrapper(SysDictDataBo bo) {
LambdaQueryWrapper<SysDictData> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getDictSort() != null, SysDictData::getDictSort, bo.getDictSort());
lqw.like(StringUtils.isNotBlank(bo.getDictLabel()), SysDictData::getDictLabel, bo.getDictLabel());
lqw.eq(StringUtils.isNotBlank(bo.getDictType()), SysDictData::getDictType, bo.getDictType());
lqw.eq(StringUtils.isNotBlank(bo.getStatus()), SysDictData::getStatus, bo.getStatus());
lqw.orderByAsc(SysDictData::getDictSort);
return lqw;
}
/**
@ -77,8 +84,8 @@ public class SysDictDataServiceImpl implements ISysDictDataService {
* @return 字典数据
*/
@Override
public SysDictData selectDictDataById(Long dictCode) {
return baseMapper.selectById(dictCode);
public SysDictDataVo selectDictDataById(Long dictCode) {
return baseMapper.selectVoById(dictCode);
}
/**
@ -89,7 +96,7 @@ public class SysDictDataServiceImpl implements ISysDictDataService {
@Override
public void deleteDictDataByIds(Long[] dictCodes) {
for (Long dictCode : dictCodes) {
SysDictData data = selectDictDataById(dictCode);
SysDictData data = baseMapper.selectById(dictCode);
baseMapper.deleteById(dictCode);
CacheUtils.evict(CacheNames.SYS_DICT, data.getDictType());
}
@ -98,12 +105,13 @@ public class SysDictDataServiceImpl implements ISysDictDataService {
/**
* 新增保存字典数据信息
*
* @param data 字典数据信息
* @param bo 字典数据信息
* @return 结果
*/
@CachePut(cacheNames = CacheNames.SYS_DICT, key = "#data.dictType")
@CachePut(cacheNames = CacheNames.SYS_DICT, key = "#bo.dictType")
@Override
public List<SysDictData> insertDictData(SysDictData data) {
public List<SysDictDataVo> insertDictData(SysDictDataBo bo) {
SysDictData data = BeanUtil.toBean(bo, SysDictData.class);
int row = baseMapper.insert(data);
if (row > 0) {
return baseMapper.selectDictDataByType(data.getDictType());
@ -114,12 +122,13 @@ public class SysDictDataServiceImpl implements ISysDictDataService {
/**
* 修改保存字典数据信息
*
* @param data 字典数据信息
* @param bo 字典数据信息
* @return 结果
*/
@CachePut(cacheNames = CacheNames.SYS_DICT, key = "#data.dictType")
@CachePut(cacheNames = CacheNames.SYS_DICT, key = "#bo.dictType")
@Override
public List<SysDictData> updateDictData(SysDictData data) {
public List<SysDictDataVo> updateDictData(SysDictDataBo bo) {
SysDictData data = BeanUtil.toBean(bo, SysDictData.class);
int row = baseMapper.updateById(data);
if (row > 0) {
return baseMapper.selectDictDataByType(data.getDictType());

91
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysDictTypeServiceImpl.java
View File

@ -1,10 +1,12 @@
package com.ruoyi.system.service.impl;
import cn.dev33.satoken.context.SaHolder;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.constant.CacheConstants;
import com.ruoyi.common.core.constant.CacheNames;
@ -19,6 +21,9 @@ import com.ruoyi.common.core.utils.StreamUtils;
import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.redis.utils.CacheUtils;
import com.ruoyi.common.core.utils.SpringUtils;
import com.ruoyi.system.domain.bo.SysDictTypeBo;
import com.ruoyi.system.domain.vo.SysDictDataVo;
import com.ruoyi.system.domain.vo.SysDictTypeVo;
import com.ruoyi.system.mapper.SysDictDataMapper;
import com.ruoyi.system.mapper.SysDictTypeMapper;
import com.ruoyi.system.service.ISysDictTypeService;
@ -44,33 +49,33 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService, DictService
private final SysDictDataMapper dictDataMapper;
@Override
public TableDataInfo<SysDictType> selectPageDictTypeList(SysDictType dictType, PageQuery pageQuery) {
Map<String, Object> params = dictType.getParams();
LambdaQueryWrapper<SysDictType> lqw = new LambdaQueryWrapper<SysDictType>()
.like(StringUtils.isNotBlank(dictType.getDictName()), SysDictType::getDictName, dictType.getDictName())
.eq(StringUtils.isNotBlank(dictType.getStatus()), SysDictType::getStatus, dictType.getStatus())
.like(StringUtils.isNotBlank(dictType.getDictType()), SysDictType::getDictType, dictType.getDictType())
.between(params.get("beginTime") != null && params.get("endTime") != null,
SysDictType::getCreateTime, params.get("beginTime"), params.get("endTime"));
Page<SysDictType> page = baseMapper.selectPage(pageQuery.build(), lqw);
public TableDataInfo<SysDictTypeVo> selectPageDictTypeList(SysDictTypeBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<SysDictType> lqw = buildQueryWrapper(bo);
Page<SysDictTypeVo> page = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(page);
}
/**
* 根据条件分页查询字典类型
*
* @param dictType 字典类型信息
* @param bo 字典类型信息
* @return 字典类型集合信息
*/
@Override
public List<SysDictType> selectDictTypeList(SysDictType dictType) {
Map<String, Object> params = dictType.getParams();
return baseMapper.selectList(new LambdaQueryWrapper<SysDictType>()
.like(StringUtils.isNotBlank(dictType.getDictName()), SysDictType::getDictName, dictType.getDictName())
.eq(StringUtils.isNotBlank(dictType.getStatus()), SysDictType::getStatus, dictType.getStatus())
.like(StringUtils.isNotBlank(dictType.getDictType()), SysDictType::getDictType, dictType.getDictType())
.between(params.get("beginTime") != null && params.get("endTime") != null,
SysDictType::getCreateTime, params.get("beginTime"), params.get("endTime")));
public List<SysDictTypeVo> selectDictTypeList(SysDictTypeBo bo) {
LambdaQueryWrapper<SysDictType> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<SysDictType> buildQueryWrapper(SysDictTypeBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<SysDictType> lqw = Wrappers.lambdaQuery();
lqw.like(StringUtils.isNotBlank(bo.getDictName()), SysDictType::getDictName, bo.getDictName());
lqw.like(StringUtils.isNotBlank(bo.getDictType()), SysDictType::getDictType, bo.getDictType());
lqw.eq(StringUtils.isNotBlank(bo.getStatus()), SysDictType::getStatus, bo.getStatus());
lqw.between(params.get("beginTime") != null && params.get("endTime") != null,
SysDictType::getCreateTime, params.get("beginTime"), params.get("endTime"));
return lqw;
}
/**
@ -91,8 +96,8 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService, DictService
*/
@Cacheable(cacheNames = CacheNames.SYS_DICT, key = "#dictType")
@Override
public List<SysDictData> selectDictDataByType(String dictType) {
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(dictType);
public List<SysDictDataVo> selectDictDataByType(String dictType) {
List<SysDictDataVo> dictDatas = dictDataMapper.selectDictDataByType(dictType);
if (CollUtil.isNotEmpty(dictDatas)) {
return dictDatas;
}
@ -106,8 +111,8 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService, DictService
* @return 字典类型
*/
@Override
public SysDictType selectDictTypeById(Long dictId) {
return baseMapper.selectById(dictId);
public SysDictTypeVo selectDictTypeById(Long dictId) {
return baseMapper.selectVoById(dictId);
}
/**
@ -118,8 +123,8 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService, DictService
*/
@Cacheable(cacheNames = CacheNames.SYS_DICT, key = "#dictType")
@Override
public SysDictType selectDictTypeByType(String dictType) {
return baseMapper.selectById(new LambdaQueryWrapper<SysDictType>().eq(SysDictType::getDictType, dictType));
public SysDictTypeVo selectDictTypeByType(String dictType) {
return baseMapper.selectVoById(new LambdaQueryWrapper<SysDictType>().eq(SysDictType::getDictType, dictType));
}
/**
@ -130,7 +135,7 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService, DictService
@Override
public void deleteDictTypeByIds(Long[] dictIds) {
for (Long dictId : dictIds) {
SysDictType dictType = selectDictTypeById(dictId);
SysDictType dictType = baseMapper.selectById(dictId);
if (dictDataMapper.exists(new LambdaQueryWrapper<SysDictData>()
.eq(SysDictData::getDictType, dictType.getDictType()))) {
throw new ServiceException(String.format("%1$s已分配,不能删除", dictType.getDictName()));
@ -145,11 +150,11 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService, DictService
*/
@Override
public void loadingDictCache() {
List<SysDictData> dictDataList = dictDataMapper.selectList(
List<SysDictDataVo> dictDataList = dictDataMapper.selectVoList(
new LambdaQueryWrapper<SysDictData>().eq(SysDictData::getStatus, UserConstants.DICT_NORMAL));
Map<String, List<SysDictData>> dictDataMap = StreamUtils.groupByKey(dictDataList, SysDictData::getDictType);
Map<String, List<SysDictDataVo>> dictDataMap = StreamUtils.groupByKey(dictDataList, SysDictDataVo::getDictType);
dictDataMap.forEach((k,v) -> {
List<SysDictData> dictList = StreamUtils.sorted(v, Comparator.comparing(SysDictData::getDictSort));
List<SysDictDataVo> dictList = StreamUtils.sorted(v, Comparator.comparing(SysDictDataVo::getDictSort));
CacheUtils.put(CacheNames.SYS_DICT, k, dictList);
});
}
@ -174,12 +179,13 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService, DictService
/**
* 新增保存字典类型信息
*
* @param dict 字典类型信息
* @param bo 字典类型信息
* @return 结果
*/
@CachePut(cacheNames = CacheNames.SYS_DICT, key = "#dict.dictType")
@CachePut(cacheNames = CacheNames.SYS_DICT, key = "#bo.dictType")
@Override
public List<SysDictData> insertDictType(SysDictType dict) {
public List<SysDictTypeVo> insertDictType(SysDictTypeBo bo) {
SysDictType dict = BeanUtil.toBean(bo, SysDictType.class);
int row = baseMapper.insert(dict);
if (row > 0) {
return new ArrayList<>();
@ -190,13 +196,14 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService, DictService
/**
* 修改保存字典类型信息
*
* @param dict 字典类型信息
* @param bo 字典类型信息
* @return 结果
*/
@CachePut(cacheNames = CacheNames.SYS_DICT, key = "#dict.dictType")
@CachePut(cacheNames = CacheNames.SYS_DICT, key = "#bo.dictType")
@Override
@Transactional(rollbackFor = Exception.class)
public List<SysDictData> updateDictType(SysDictType dict) {
public List<SysDictDataVo> updateDictType(SysDictTypeBo bo) {
SysDictType dict = BeanUtil.toBean(bo, SysDictType.class);
SysDictType oldDict = baseMapper.selectById(dict.getDictId());
dictDataMapper.update(null, new LambdaUpdateWrapper<SysDictData>()
.set(SysDictData::getDictType, dict.getDictType())
@ -212,14 +219,14 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService, DictService
/**
* 校验字典类型称是否唯一
*
* @param dict 字典类型
* @param bo 字典类型
* @return 结果
*/
@Override
public String checkDictTypeUnique(SysDictType dict) {
public String checkDictTypeUnique(SysDictTypeBo bo) {
boolean exist = baseMapper.exists(new LambdaQueryWrapper<SysDictType>()
.eq(SysDictType::getDictType, dict.getDictType())
.ne(ObjectUtil.isNotNull(dict.getDictId()), SysDictType::getDictId, dict.getDictId()));
.eq(SysDictType::getDictType, bo.getDictType())
.ne(ObjectUtil.isNotNull(bo.getDictId()), SysDictType::getDictId, bo.getDictId()));
if (exist) {
return UserConstants.NOT_UNIQUE;
}
@ -238,13 +245,13 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService, DictService
@Override
public String getDictLabel(String dictType, String dictValue, String separator) {
// 优先从本地缓存获取
List<SysDictData> datas = (List<SysDictData>) SaHolder.getStorage().get(CacheConstants.SYS_DICT_KEY + dictType);
List<SysDictDataVo> datas = (List<SysDictDataVo>) SaHolder.getStorage().get(CacheConstants.SYS_DICT_KEY + dictType);
if (ObjectUtil.isNull(datas)) {
datas = SpringUtils.getAopProxy(this).selectDictDataByType(dictType);
SaHolder.getStorage().set(CacheConstants.SYS_DICT_KEY + dictType, datas);
}
Map<String, String> map = StreamUtils.toMap(datas, SysDictData::getDictValue, SysDictData::getDictLabel);
Map<String, String> map = StreamUtils.toMap(datas, SysDictDataVo::getDictValue, SysDictDataVo::getDictLabel);
if (StringUtils.containsAny(dictValue, separator)) {
return Arrays.stream(dictValue.split(separator))
.map(v -> map.getOrDefault(v, StringUtils.EMPTY))
@ -266,13 +273,13 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService, DictService
@Override
public String getDictValue(String dictType, String dictLabel, String separator) {
// 优先从本地缓存获取
List<SysDictData> datas = (List<SysDictData>) SaHolder.getStorage().get(CacheConstants.SYS_DICT_KEY + dictType);
List<SysDictDataVo> datas = (List<SysDictDataVo>) SaHolder.getStorage().get(CacheConstants.SYS_DICT_KEY + dictType);
if (ObjectUtil.isNull(datas)) {
datas = SpringUtils.getAopProxy(this).selectDictDataByType(dictType);
SaHolder.getStorage().set(CacheConstants.SYS_DICT_KEY + dictType, datas);
}
Map<String, String> map = StreamUtils.toMap(datas, SysDictData::getDictLabel, SysDictData::getDictValue);
Map<String, String> map = StreamUtils.toMap(datas, SysDictDataVo::getDictLabel, SysDictDataVo::getDictValue);
if (StringUtils.containsAny(dictLabel, separator)) {
return Arrays.stream(dictLabel.split(separator))
.map(l -> map.getOrDefault(l, StringUtils.EMPTY))