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

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

@@ -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) {
+    public TableDataInfo<SysDictDataVo> list(SysDictDataBo bo, PageQuery pageQuery) {
-        return dictDataService.selectPageDictDataList(dictData, 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) {
+    public void export(SysDictDataBo bo, HttpServletResponse response) {
-        List<SysDictData> list = dictDataService.selectDictDataList(dictData);
+        List<SysDictDataVo> list = dictDataService.selectDictDataList(bo);
-        ExcelUtil.exportExcel(list, "字典数据", SysDictData.class, response);
+        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) {
+    public R<List<SysDictDataVo>> dictType(@PathVariable String dictType) {
-        List<SysDictData> data = dictTypeService.selectDictDataByType(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) {
+    public R<Void> add(@Validated @RequestBody SysDictDataBo bo) {
-        dictDataService.insertDictData(dict);
+        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) {
+    public R<Void> edit(@Validated @RequestBody SysDictDataBo bo) {
-        dictDataService.updateDictData(dict);
+        dictDataService.updateDictData(bo);
         return R.ok();
     }
 

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

@@ -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) {
+    public TableDataInfo<SysDictTypeVo> list(SysDictTypeBo bo, PageQuery pageQuery) {
-        return dictTypeService.selectPageDictTypeList(dictType, 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) {
+    public void export(SysDictTypeBo bo, HttpServletResponse response) {
-        List<SysDictType> list = dictTypeService.selectDictTypeList(dictType);
+        List<SysDictTypeVo> list = dictTypeService.selectDictTypeList(bo);
-        ExcelUtil.exportExcel(list, "字典类型", SysDictType.class, response);
+        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) {
+    public R<Void> add(@Validated @RequestBody SysDictTypeBo bo) {
-        if (UserConstants.NOT_UNIQUE.equals(dictTypeService.checkDictTypeUnique(dict))) {
+        if (UserConstants.NOT_UNIQUE.equals(dictTypeService.checkDictTypeUnique(bo))) {
-            return R.fail("新增字典'" + dict.getDictName() + "'失败，字典类型已存在");
+            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) {
+    public R<Void> edit(@Validated @RequestBody SysDictTypeBo bo) {
-        if (UserConstants.NOT_UNIQUE.equals(dictTypeService.checkDictTypeUnique(dict))) {
+        if (UserConstants.NOT_UNIQUE.equals(dictTypeService.checkDictTypeUnique(bo))) {
-            return R.fail("修改字典'" + dict.getDictName() + "'失败，字典类型已存在");
+            return R.fail("修改字典'" + bo.getDictName() + "'失败，字典类型已存在");
         }
-        dictTypeService.updateDictType(dict);
+        dictTypeService.updateDictType(bo);
         return R.ok();
     }
 

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

@@ -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;
 
     /**

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

@@ -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;
 
     /**

ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/bo/SysDictDataBo.java

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

ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/bo/SysDictTypeBo.java

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

ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/vo/SysDictDataVo.java

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

ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/vo/SysDictTypeVo.java

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

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

@@ -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) {
+    default List<SysDictDataVo> selectDictDataByType(String dictType) {
-        return selectList(
+        return selectVoList(
             new LambdaQueryWrapper<SysDictData>()
                 .eq(SysDictData::getStatus, UserConstants.DICT_NORMAL)
                 .eq(SysDictData::getDictType, dictType)

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

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

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

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

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

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

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

@@ -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) {
+    public TableDataInfo<SysDictDataVo> selectPageDictDataList(SysDictDataBo bo, PageQuery pageQuery) {
-        LambdaQueryWrapper<SysDictData> lqw = new LambdaQueryWrapper<SysDictData>()
+        LambdaQueryWrapper<SysDictData> lqw = buildQueryWrapper(bo);
-            .eq(StringUtils.isNotBlank(dictData.getDictType()), SysDictData::getDictType, dictData.getDictType())
+        Page<SysDictDataVo> page = baseMapper.selectVoPage(pageQuery.build(), lqw);
-            .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);
         return TableDataInfo.build(page);
     }
 
     /**
      * 根据条件分页查询字典数据
      *
-     * @param dictData 字典数据信息
+     * @param bo 字典数据信息
      * @return 字典数据集合信息
      */
     @Override
-    public List<SysDictData> selectDictDataList(SysDictData dictData) {
+    public List<SysDictDataVo> selectDictDataList(SysDictDataBo bo) {
-        return baseMapper.selectList(new LambdaQueryWrapper<SysDictData>()
+        LambdaQueryWrapper<SysDictData> lqw = buildQueryWrapper(bo);
-            .eq(StringUtils.isNotBlank(dictData.getDictType()), SysDictData::getDictType, dictData.getDictType())
+        return baseMapper.selectVoList(lqw);
-            .like(StringUtils.isNotBlank(dictData.getDictLabel()), SysDictData::getDictLabel, dictData.getDictLabel())
+    }
-            .eq(StringUtils.isNotBlank(dictData.getStatus()), SysDictData::getStatus, dictData.getStatus())
+
-            .orderByAsc(SysDictData::getDictSort));
+    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) {
+    public SysDictDataVo selectDictDataById(Long dictCode) {
-        return baseMapper.selectById(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());

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

@@ -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) {
+    public TableDataInfo<SysDictTypeVo> selectPageDictTypeList(SysDictTypeBo bo, PageQuery pageQuery) {
-        Map<String, Object> params = dictType.getParams();
+        LambdaQueryWrapper<SysDictType> lqw = buildQueryWrapper(bo);
-        LambdaQueryWrapper<SysDictType> lqw = new LambdaQueryWrapper<SysDictType>()
+        Page<SysDictTypeVo> page = baseMapper.selectVoPage(pageQuery.build(), lqw);
-            .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);
         return TableDataInfo.build(page);
     }
 
     /**
      * 根据条件分页查询字典类型
      *
-     * @param dictType 字典类型信息
+     * @param bo 字典类型信息
      * @return 字典类型集合信息
      */
     @Override
-    public List<SysDictType> selectDictTypeList(SysDictType dictType) {
+    public List<SysDictTypeVo> selectDictTypeList(SysDictTypeBo bo) {
-        Map<String, Object> params = dictType.getParams();
+        LambdaQueryWrapper<SysDictType> lqw = buildQueryWrapper(bo);
-        return baseMapper.selectList(new LambdaQueryWrapper<SysDictType>()
+        return baseMapper.selectVoList(lqw);
-            .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())
+    private LambdaQueryWrapper<SysDictType> buildQueryWrapper(SysDictTypeBo bo) {
-            .between(params.get("beginTime") != null && params.get("endTime") != null,
+        Map<String, Object> params = bo.getParams();
-                SysDictType::getCreateTime, params.get("beginTime"), params.get("endTime")));
+        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) {
+    public List<SysDictDataVo> selectDictDataByType(String dictType) {
-        List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(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) {
+    public SysDictTypeVo selectDictTypeById(Long dictId) {
-        return baseMapper.selectById(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) {
+    public SysDictTypeVo selectDictTypeByType(String dictType) {
-        return baseMapper.selectById(new LambdaQueryWrapper<SysDictType>().eq(SysDictType::getDictType, 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())
+            .eq(SysDictType::getDictType, bo.getDictType())
-            .ne(ObjectUtil.isNotNull(dict.getDictId()), SysDictType::getDictId, dict.getDictId()));
+            .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))