Merge remote-tracking branch 'origin/boot3.0' into boot3.0

# Conflicts:
#	cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/service/impl/SysPostServiceImpl.java

cloud-common/cloud-common-system/src/main/java/com/muyu/common/system/domain/SysDictData.java

@@ -102,4 +102,5 @@ public class SysDictData extends BaseEntity {
     public boolean getDefault () {
         return SysWhetherEnum.isYes(this.isDefault);
     }
+
 }

cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/controller/SysDictDataController.java

@@ -11,8 +11,13 @@ import com.muyu.common.log.enums.BusinessType;
 import com.muyu.common.security.annotation.RequiresPermissions;
 import com.muyu.common.security.utils.SecurityUtils;
 import com.muyu.common.system.domain.SysDictData;
+import com.muyu.system.domain.model.SysDictDataAddModel;
 import com.muyu.system.domain.model.SysDictDataPageQueryModel;
+import com.muyu.system.domain.model.SysDictDataUpdModel;
+import com.muyu.system.domain.rep.SysDictDataAddReq;
 import com.muyu.system.domain.rep.SysDictDataListReq;
+import com.muyu.system.domain.rep.SysDictDataUpdReq;
+import com.muyu.system.domain.resp.SysDictDataListResp;
 import com.muyu.system.service.SysDictDataService;
 import com.muyu.system.service.SysDictTypeService;
 import jakarta.servlet.http.HttpServletResponse;
@@ -22,6 +27,7 @@ import org.springframework.web.bind.annotation.*;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  * 数据字典信息
@@ -37,15 +43,31 @@ public class SysDictDataController extends BaseController {
     @Autowired
     private SysDictTypeService dictTypeService;
 
+    /**
+     * 查询字典数据列表
+     * @param sysDictDataListReq
+     * @return
+     */
     @RequiresPermissions("system:dict:list")
     @PostMapping("/list")
-    public Result<DataPageResp<SysDictData>> list (@RequestBody SysDictDataListReq sysDictDataListReq) {
+    public Result<DataPageResp<SysDictDataListResp>> list (@RequestBody SysDictDataListReq sysDictDataListReq) {
-        PageQueryModel<SysDictData> sysDictDataPageQueryModel = dictDataService.selectDictDataList(SysDictDataPageQueryModel.reqBuild(sysDictDataListReq));
+        List<SysDictData> sysDictDataList = dictDataService.selectDictDataList(SysDictDataPageQueryModel.reqBuild(sysDictDataListReq)).getDataList();
+        List<SysDictDataListResp> sysDictDataListRespList = sysDictDataList.stream().map(
+                sysDictData -> SysDictDataListResp.buildResp(sysDictData)
+        ).distinct().collect(Collectors.toList());
+        PageQueryModel<SysDictDataListResp> sysDictDataListRespPageQueryModel = new PageQueryModel<>();
+        sysDictDataListRespPageQueryModel.setTotal(sysDictDataListRespList.size());
+        sysDictDataListRespPageQueryModel.setDataList(sysDictDataListRespList);
         return Result.success(
-                DataPageResp.of(sysDictDataPageQueryModel)
+                DataPageResp.of(sysDictDataListRespPageQueryModel)
         );
     }
 
+    /**
+     * 导出字典数据列表
+     * @param response
+     * @param sysDictDataListReq
+     */
     @Log(title = "字典数据", businessType = BusinessType.EXPORT)
     @RequiresPermissions("system:dict:export")
     @PostMapping("/export")
@@ -83,21 +105,21 @@ public class SysDictDataController extends BaseController {
     @RequiresPermissions("system:dict:add")
     @Log(title = "字典数据", businessType = BusinessType.INSERT)
     @PostMapping
-    public Result<String> add (@Validated @RequestBody SysDictData dict) {
+    public Result<String> add (@Validated @RequestBody SysDictDataAddReq sysDictDataAddReq) {
-        dict.setCreateBy(SecurityUtils.getUsername());
+        sysDictDataAddReq.setCreateBy(SecurityUtils.getUsername());
-        dictDataService.insertDictData(dict);
+        dictDataService.insertDictData(SysDictDataAddModel.buildAddModel(sysDictDataAddReq));
         return Result.success();
     }
 
     /**
      * 修改保存字典类型
      */
-    @RequiresPermissions("system:dict:edit")
+    //@RequiresPermissions("system:dict:edit")
     @Log(title = "字典数据", businessType = BusinessType.UPDATE)
     @PutMapping
-    public Result<String> edit (@Validated @RequestBody SysDictData dict) {
+    public Result<String> edit (@Validated @RequestBody SysDictDataUpdReq sysDictDataUpdReq) {
-        dict.setUpdateBy(SecurityUtils.getUsername());
+        sysDictDataUpdReq.setUpdateBy(SecurityUtils.getUsername());
-        dictDataService.updateDictData(dict);
+        dictDataService.updateDictData(SysDictDataUpdModel.buildUpdModel(sysDictDataUpdReq));
         return Result.success();
     }
 

cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/controller/SysDictTypeController.java

@@ -9,6 +9,14 @@ import com.muyu.common.log.enums.BusinessType;
 import com.muyu.common.security.annotation.RequiresPermissions;
 import com.muyu.common.security.utils.SecurityUtils;
 import com.muyu.common.system.domain.SysDictType;
+import com.muyu.system.domain.model.SysDictTypeAddModel;
+import com.muyu.system.domain.model.SysDictTypeListModel;
+import com.muyu.system.domain.model.SysDictTypePageQueryModel;
+import com.muyu.system.domain.model.SysDictTypeUpdModel;
+import com.muyu.system.domain.rep.SysDictTypeAddReq;
+import com.muyu.system.domain.rep.SysDictTypeListReq;
+import com.muyu.system.domain.rep.SysDictTypeUpdReq;
+import com.muyu.system.domain.resp.SysDictTypeListResp;
 import com.muyu.system.service.SysDictTypeService;
 import jakarta.servlet.http.HttpServletResponse;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -16,6 +24,7 @@ import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  * 数据字典信息
@@ -30,18 +39,24 @@ public class SysDictTypeController extends BaseController {
 
     @RequiresPermissions("system:dict:list")
     @PostMapping("/list")
-    public Result<DataPageResp<SysDictType>> list (@RequestBody SysDictType dictType) {
+    public Result<DataPageResp<SysDictTypeListResp>> list (@RequestBody SysDictTypeListReq sysDictTypeListReq) {
-        List<SysDictType> list = dictTypeService.selectDictTypeList(dictType);
+        List<SysDictTypeListResp> dictTypeListResps = dictTypeService.selectDictTypeList(SysDictTypePageQueryModel.reqBuild(sysDictTypeListReq))
-        return Result.success(new DataPageResp<>(0,list));
+                .stream()
+                .map(SysDictTypeListResp::buildResp)
+                .collect(Collectors.toList());
+        return Result.success(new DataPageResp<>(dictTypeListResps.size(), dictTypeListResps));
     }
 
     @Log(title = "字典类型", businessType = BusinessType.EXPORT)
     @RequiresPermissions("system:dict:export")
     @PostMapping("/export")
-    public void export (HttpServletResponse response, SysDictType dictType) {
+    public void export (HttpServletResponse response, SysDictTypeListReq sysDictTypeListReq) {
-        List<SysDictType> list = dictTypeService.selectDictTypeList(dictType);
+        List<SysDictTypeListResp> dictTypeListResps = dictTypeService.selectDictTypeList(SysDictTypePageQueryModel.reqBuild(sysDictTypeListReq))
-        ExcelUtil<SysDictType> util = new ExcelUtil<SysDictType>(SysDictType.class);
+                .stream()
-        util.exportExcel(response, list, "字典类型");
+                .map(SysDictTypeListResp::buildResp)
+                .collect(Collectors.toList());
+        ExcelUtil<SysDictTypeListResp> util = new ExcelUtil<SysDictTypeListResp>(SysDictTypeListResp.class);
+        util.exportExcel(response, dictTypeListResps, "字典类型");
     }
 
     /**
@@ -59,12 +74,12 @@ public class SysDictTypeController extends BaseController {
     @RequiresPermissions("system:dict:add")
     @Log(title = "字典类型", businessType = BusinessType.INSERT)
     @PostMapping
-    public Result add (@Validated @RequestBody SysDictType dict) {
+    public Result add (@Validated @RequestBody SysDictTypeAddReq sysDictTypeAddReq) {
-        if (!dictTypeService.checkDictTypeUnique(dict)) {
+        if (!dictTypeService.checkDictTypeUnique(SysDictTypeAddModel.buildModel(sysDictTypeAddReq))) {
-            return error("新增字典'" + dict.getDictName() + "'失败，字典类型已存在");
+            return error("新增字典'" + sysDictTypeAddReq.getDictName() + "'失败，字典类型已存在");
         }
-        dict.setCreateBy(SecurityUtils.getUsername());
+        sysDictTypeAddReq.setCreateBy(SecurityUtils.getUsername());
-        dictTypeService.insertDictType(dict);
+        dictTypeService.insertDictType(SysDictTypeAddModel.buildModel(sysDictTypeAddReq));
         return Result.success();
     }
 
@@ -74,12 +89,12 @@ public class SysDictTypeController extends BaseController {
     @RequiresPermissions("system:dict:edit")
     @Log(title = "字典类型", businessType = BusinessType.UPDATE)
     @PutMapping
-    public Result edit (@Validated @RequestBody SysDictType dict) {
+    public Result edit (@Validated @RequestBody SysDictTypeUpdReq sysDictTypeUpdReq) {
-        if (!dictTypeService.checkDictTypeUnique(dict)) {
+        if (!dictTypeService.checkDictTypeUnique(SysDictTypeUpdModel.buildUpdModel(sysDictTypeUpdReq))) {
-            return error("修改字典'" + dict.getDictName() + "'失败，字典类型已存在");
+            return error("修改字典'" + sysDictTypeUpdReq.getDictName() + "'失败，字典类型已存在");
         }
-        dict.setUpdateBy(SecurityUtils.getUsername());
+        sysDictTypeUpdReq.setUpdateBy(SecurityUtils.getUsername());
-        dictTypeService.updateDictType(dict);
+        dictTypeService.updateDictType(SysDictTypeUpdModel.buildUpdModel(sysDictTypeUpdReq));
         return Result.success();
     }
 

cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/model/SysDictDataAddModel.java

@@ -0,0 +1,85 @@
+package com.muyu.system.domain.model;
+
+import com.muyu.system.domain.rep.SysDictDataAddReq;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 数据字典添加模型
+ *
+ * @author
+ * @version 1.0
+ * @date 2025/2/23 19:29
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class SysDictDataAddModel {
+    /**
+     * 字典编码
+     */
+    private Long dictCode;
+
+    /**
+     * 字典排序
+     */
+    private Long dictSort;
+
+    /**
+     * 字典标签
+     */
+    private String dictLabel;
+
+    /**
+     * 字典键值
+     */
+    private String dictValue;
+
+    /**
+     * 字典类型
+     */
+    private String dictType;
+
+    /**
+     * 样式属性（其他样式扩展）
+     */
+    private String cssClass;
+
+    /**
+     * 表格字典样式
+     */
+    private String listClass;
+
+    /**
+     * 是否默认（Y是 N否）
+     */
+    private String isDefault;
+
+    /**
+     * 状态（0正常 1停用）
+     */
+    private String status;
+
+    /**
+     * 构建模型
+     *
+     * @param sysDictDataAddReq 请求对象
+     * @return 添加对象
+     */
+    public static SysDictDataAddModel buildAddModel(SysDictDataAddReq sysDictDataAddReq) {
+        return SysDictDataAddModel.builder()
+                .dictCode(sysDictDataAddReq.getDictCode())
+                .dictSort(sysDictDataAddReq.getDictSort())
+                .dictLabel(sysDictDataAddReq.getDictLabel())
+                .dictValue(sysDictDataAddReq.getDictValue())
+                .dictType(sysDictDataAddReq.getDictType())
+                .cssClass(sysDictDataAddReq.getCssClass())
+                .listClass(sysDictDataAddReq.getListClass())
+                .isDefault(sysDictDataAddReq.getIsDefault())
+                .status(sysDictDataAddReq.getStatus())
+                .build();
+    }
+}

cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/model/SysDictDataListModel.java

@@ -0,0 +1,69 @@
+package com.muyu.system.domain.model;
+
+import com.muyu.common.core.annotation.Excel;
+import com.muyu.common.core.web.domain.BaseEntity;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+/**
+ *
+ * 字典数据返回列表模型
+ * @author SunLY
+ * @version 1.0
+ * @date 2025/2/23 21:24
+ */
+@Data
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+public class SysDictDataListModel extends BaseEntity {
+    /**
+     * 字典编码
+     */
+    @Excel(name = "字典编码", cellType = Excel.ColumnType.NUMERIC)
+    private Long dictCode;
+
+    /**
+     * 字典排序
+     */
+    @Excel(name = "字典排序", cellType = Excel.ColumnType.NUMERIC)
+    private Long dictSort;
+
+    /**
+     * 字典标签
+     */
+    @Excel(name = "字典标签")
+    private String dictLabel;
+
+    /**
+     * 字典键值
+     */
+    @Excel(name = "字典键值")
+    private String dictValue;
+
+    /**
+     * 字典类型
+     */
+    @Excel(name = "字典类型")
+    private String dictType;
+
+    /**
+     * 样式属性（其他样式扩展）
+     */
+    private String cssClass;
+
+    /**
+     * 表格字典样式
+     */
+    private String listClass;
+
+    /**
+     * 是否默认（Y是 N否）
+     */
+    @Excel(name = "是否默认", readConverterExp = "Y=是,N=否")
+    private String isDefault;
+}

cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/model/SysDictDataPageQueryModel.java

@@ -31,6 +31,9 @@ public class SysDictDataPageQueryModel extends QueryModel<SysDictDataPageQueryMo
      */
     private String status;
 
+
+
+
     public static SysDictDataPageQueryModel reqBuild(SysDictDataListReq sysDictDataListReq) {
         SysDictDataPageQueryModel sysDictDataPageQueryModel = SysDictDataPageQueryModel.builder()
                 .dictType(sysDictDataListReq.getDictType())

cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/model/SysDictDataUpdModel.java

@@ -0,0 +1,113 @@
+package com.muyu.system.domain.model;
+
+import com.muyu.common.core.enums.SysWhetherEnum;
+import com.muyu.common.core.web.domain.BaseEntity;
+import com.muyu.system.domain.rep.SysDictDataUpdReq;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+/**
+ * 数据字典修改模型
+ *
+ * @author SunLY
+ * @version 1.0
+ * @date 2025/2/23 19:29
+ */
+@Data
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+public class SysDictDataUpdModel extends BaseEntity {
+    /**
+     * 字典编码
+     */
+    private Long dictCode;
+
+    /**
+     * 字典排序
+     */
+    private Long dictSort;
+
+    /**
+     * 字典标签
+     */
+    private String dictLabel;
+
+    /**
+     * 字典键值
+     */
+    private String dictValue;
+
+    /**
+     * 字典类型
+     */
+    private String dictType;
+
+    /**
+     * 样式属性（其他样式扩展）
+     */
+    private String cssClass;
+
+    /**
+     * 表格字典样式
+     */
+    private String listClass;
+
+    /**
+     * 是否默认（Y是 N否）
+     */
+    private String isDefault;
+
+    /**
+     * 状态（0正常 1停用）
+     */
+    private String status;
+
+    @NotBlank(message = "字典标签不能为空")
+    @Size(min = 0, max = 100, message = "字典标签长度不能超过100个字符")
+    public String getDictLabel () {
+        return dictLabel;
+    }
+
+    @NotBlank(message = "字典键值不能为空")
+    @Size(min = 0, max = 100, message = "字典键值长度不能超过100个字符")
+    public String getDictValue () {
+        return dictValue;
+    }
+
+    @NotBlank(message = "字典类型不能为空")
+    @Size(min = 0, max = 100, message = "字典类型长度不能超过100个字符")
+    public String getDictType () {
+        return dictType;
+    }
+
+    @Size(min = 0, max = 100, message = "样式属性长度不能超过100个字符")
+    public String getCssClass () {
+        return cssClass;
+    }
+
+    public boolean getDefault () {
+        return SysWhetherEnum.isYes(this.isDefault);
+    }
+
+    public static SysDictDataUpdModel buildUpdModel(SysDictDataUpdReq sysDictDataUpdReq){
+        return SysDictDataUpdModel.builder()
+                .dictCode(sysDictDataUpdReq.getDictCode())
+                .dictSort(sysDictDataUpdReq.getDictSort())
+                .dictLabel(sysDictDataUpdReq.getDictLabel())
+                .dictValue(sysDictDataUpdReq.getDictValue())
+                .dictType(sysDictDataUpdReq.getDictType())
+                .cssClass(sysDictDataUpdReq.getCssClass())
+                .listClass(sysDictDataUpdReq.getListClass())
+                .isDefault(sysDictDataUpdReq.getIsDefault())
+                .status(sysDictDataUpdReq.getStatus())
+                .build();
+    }
+
+}

cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/model/SysDictTypeAddModel.java

@@ -0,0 +1,58 @@
+package com.muyu.system.domain.model;
+
+import com.muyu.common.core.web.domain.BaseEntity;
+import com.muyu.system.domain.rep.SysDictTypeAddReq;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.Size;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+/**
+ *
+ * 数据字典类型添加模型
+ * @author
+ * @version 1.0
+ * @date 2025/2/24 1:35
+ */
+@Data
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+public class SysDictTypeAddModel extends BaseEntity {
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 字典主键
+     */
+    private Long dictId;
+
+    /**
+     * 字典名称
+     */
+    private String dictName;
+
+    /**
+     * 字典类型
+     */
+    private String dictType;
+
+    /**
+     * 状态（0正常 1停用）
+     */
+    private String status;
+
+    public static SysDictTypeAddModel buildModel(SysDictTypeAddReq sysDictTypeAddReq){
+        return SysDictTypeAddModel.builder()
+                .dictId(sysDictTypeAddReq.getDictId())
+                .dictName(sysDictTypeAddReq.getDictName())
+                .dictType(sysDictTypeAddReq.getDictType())
+                .status(sysDictTypeAddReq.getStatus())
+                .build();
+    }
+
+}

cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/model/SysDictTypeListModel.java

@@ -0,0 +1,59 @@
+package com.muyu.system.domain.model;
+
+import com.muyu.common.core.annotation.Excel;
+import com.muyu.common.core.annotation.Excel.ColumnType;
+import com.muyu.common.core.web.domain.BaseEntity;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.Size;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+/**
+ * 字典类型列表模型
+ *
+ * @author
+ */
+@Data
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+public class SysDictTypeListModel extends BaseEntity {
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 字典主键
+     */
+    @Excel(name = "字典主键", cellType = ColumnType.NUMERIC)
+    private Long dictId;
+
+    /**
+     * 字典名称
+     */
+    @Excel(name = "字典名称")
+    private String dictName;
+
+    /**
+     * 字典类型
+     */
+    @Excel(name = "字典类型")
+    private String dictType;
+
+    /**
+     * 状态（0正常 1停用）
+     */
+    @Excel(name = "状态", readConverterExp = "0=正常,1=停用")
+    private String status;
+
+    @NotBlank(message = "字典名称不能为空")
+    @Size(min = 0, max = 100, message = "字典类型名称长度不能超过100个字符")
+    public String getDictName () {
+        return dictName;
+    }
+
+
+}

cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/model/SysDictTypePageQueryModel.java

@@ -1,5 +1,7 @@
 package com.muyu.system.domain.model;
 
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.fasterxml.jackson.annotation.JsonInclude;
 import com.muyu.common.core.web.model.QueryModel;
 import com.muyu.system.domain.rep.SysDictTypeListReq;
 import lombok.AllArgsConstructor;
@@ -9,6 +11,8 @@ import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
 
 import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
 
 /**
  * 参数配置 分页 模型
@@ -45,6 +49,24 @@ public class SysDictTypePageQueryModel extends QueryModel<SysDictTypePageQueryMo
      */
     private Date endTime;
 
+    /**
+     * 请求参数
+     */
+    @JsonInclude(JsonInclude.Include.NON_EMPTY)
+    @TableField(exist = false)
+    private Map<String, Object> params;
+
+    public Map<String, Object> getParams () {
+        if (params == null) {
+            params = new HashMap<>();
+        }
+        return params;
+    }
+
+    public void setParams (Map<String, Object> params) {
+        this.params = params;
+    }
+
     public static SysDictTypePageQueryModel reqBuild(SysDictTypeListReq sysDictTypeListReq) {
         SysDictTypePageQueryModel sysDictTypePageQueryModel = SysDictTypePageQueryModel.builder()
                 .dictName(sysDictTypeListReq.getDictName())

cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/model/SysDictTypeUpdModel.java

@@ -0,0 +1,58 @@
+package com.muyu.system.domain.model;
+
+import com.muyu.common.core.web.domain.BaseEntity;
+import com.muyu.system.domain.rep.SysDictTypeUpdReq;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.Size;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+/**
+ *
+ * 数据字典类型修改模型
+ * @author
+ * @version 1.0
+ * @date 2025/2/24 1:35
+ */
+@Data
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+public class SysDictTypeUpdModel extends BaseEntity {
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 字典主键
+     */
+    private Long dictId;
+
+    /**
+     * 字典名称
+     */
+    private String dictName;
+
+    /**
+     * 字典类型
+     */
+    private String dictType;
+
+    /**
+     * 状态（0正常 1停用）
+     */
+
+    private String status;
+
+   public static SysDictTypeUpdModel buildUpdModel(SysDictTypeUpdReq sysDictTypeUpdReq) {
+       return SysDictTypeUpdModel.builder()
+               .dictId(sysDictTypeUpdReq.getDictId())
+               .dictName(sysDictTypeUpdReq.getDictName())
+               .dictType(sysDictTypeUpdReq.getDictType())
+               .status(sysDictTypeUpdReq.getStatus())
+               .build();
+   }
+}

cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/rep/SysConfigAddReq.java

@@ -41,4 +41,6 @@ public class SysConfigAddReq {
      * 备注
      */
     private String remark;
+
+
 }

cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/rep/SysDictDataAddReq.java

@@ -0,0 +1,96 @@
+package com.muyu.system.domain.rep;
+
+import com.muyu.common.core.annotation.Excel;
+import com.muyu.common.core.enums.SysWhetherEnum;
+import com.muyu.common.core.web.domain.BaseEntity;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+import lombok.*;
+import lombok.experimental.SuperBuilder;
+
+/**
+ * 数据字典添加对象
+ *
+ * @author
+ * @version 1.0
+ * @date 2025/2/23 19:29
+ */
+@Data
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+public class SysDictDataAddReq extends BaseEntity {
+    /**
+     * 字典编码
+     */
+    private Long dictCode;
+
+    /**
+     * 字典排序
+     */
+    private Long dictSort;
+
+    /**
+     * 字典标签
+     */
+    private String dictLabel;
+
+    /**
+     * 字典键值
+     */
+    private String dictValue;
+
+    /**
+     * 字典类型
+     */
+    private String dictType;
+
+    /**
+     * 样式属性（其他样式扩展）
+     */
+    private String cssClass;
+
+    /**
+     * 表格字典样式
+     */
+    private String listClass;
+
+    /**
+     * 是否默认（Y是 N否）
+     */
+    private String isDefault;
+
+    /**
+     * 状态（0正常 1停用）
+     */
+    private String status;
+
+    @NotBlank(message = "字典标签不能为空")
+    @Size(min = 0, max = 100, message = "字典标签长度不能超过100个字符")
+    public String getDictLabel () {
+        return dictLabel;
+    }
+
+    @NotBlank(message = "字典键值不能为空")
+    @Size(min = 0, max = 100, message = "字典键值长度不能超过100个字符")
+    public String getDictValue () {
+        return dictValue;
+    }
+
+    @NotBlank(message = "字典类型不能为空")
+    @Size(min = 0, max = 100, message = "字典类型长度不能超过100个字符")
+    public String getDictType () {
+        return dictType;
+    }
+
+    @Size(min = 0, max = 100, message = "样式属性长度不能超过100个字符")
+    public String getCssClass () {
+        return cssClass;
+    }
+
+    public boolean getDefault () {
+        return SysWhetherEnum.isYes(this.isDefault);
+    }
+
+}

cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/rep/SysDictDataUpdReq.java

@@ -0,0 +1,98 @@
+package com.muyu.system.domain.rep;
+
+import com.muyu.common.core.enums.SysWhetherEnum;
+import com.muyu.common.core.web.domain.BaseEntity;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+/**
+ * 数据字典修改对象
+ *
+ * @author
+ * @version 1.0
+ * @date 2025/2/23 19:29
+ */
+@Data
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+public class SysDictDataUpdReq extends BaseEntity {
+    /**
+     * 字典编码
+     */
+    private Long dictCode;
+
+    /**
+     * 字典排序
+     */
+    private Long dictSort;
+
+    /**
+     * 字典标签
+     */
+    private String dictLabel;
+
+    /**
+     * 字典键值
+     */
+    private String dictValue;
+
+    /**
+     * 字典类型
+     */
+    private String dictType;
+
+    /**
+     * 样式属性（其他样式扩展）
+     */
+    private String cssClass;
+
+    /**
+     * 表格字典样式
+     */
+    private String listClass;
+
+    /**
+     * 是否默认（Y是 N否）
+     */
+    private String isDefault;
+
+    /**
+     * 状态（0正常 1停用）
+     */
+    private String status;
+
+    @NotBlank(message = "字典标签不能为空")
+    @Size(min = 0, max = 100, message = "字典标签长度不能超过100个字符")
+    public String getDictLabel () {
+        return dictLabel;
+    }
+
+    @NotBlank(message = "字典键值不能为空")
+    @Size(min = 0, max = 100, message = "字典键值长度不能超过100个字符")
+    public String getDictValue () {
+        return dictValue;
+    }
+
+    @NotBlank(message = "字典类型不能为空")
+    @Size(min = 0, max = 100, message = "字典类型长度不能超过100个字符")
+    public String getDictType () {
+        return dictType;
+    }
+
+    @Size(min = 0, max = 100, message = "样式属性长度不能超过100个字符")
+    public String getCssClass () {
+        return cssClass;
+    }
+
+    public boolean getDefault () {
+        return SysWhetherEnum.isYes(this.isDefault);
+    }
+
+}

cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/rep/SysDictTypeAddReq.java

@@ -0,0 +1,62 @@
+package com.muyu.system.domain.rep;
+
+import com.muyu.common.core.annotation.Excel;
+import com.muyu.common.core.web.domain.BaseEntity;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.Size;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+/**
+ *
+ * 数据字典类型添加对象
+ * @author
+ * @version 1.0
+ * @date 2025/2/24 1:35
+ */
+@Data
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+public class SysDictTypeAddReq extends BaseEntity {
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 字典主键
+     */
+    private Long dictId;
+
+    /**
+     * 字典名称
+     */
+    private String dictName;
+
+    /**
+     * 字典类型
+     */
+    private String dictType;
+
+    /**
+     * 状态（0正常 1停用）
+     */
+
+    private String status;
+
+    @NotBlank(message = "字典名称不能为空")
+    @Size(min = 0, max = 100, message = "字典类型名称长度不能超过100个字符")
+    public String getDictName () {
+        return dictName;
+    }
+
+    @NotBlank(message = "字典类型不能为空")
+    @Size(min = 0, max = 100, message = "字典类型类型长度不能超过100个字符")
+    @Pattern(regexp = "^[a-z][a-z0-9_]*$", message = "字典类型必须以字母开头，且只能为（小写字母，数字，下滑线）")
+    public String getDictType () {
+        return dictType;
+    }
+}

cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/rep/SysDictTypeUpdReq.java

@@ -0,0 +1,60 @@
+package com.muyu.system.domain.rep;
+
+import com.muyu.common.core.web.domain.BaseEntity;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.Size;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+/**
+ *
+ * 数据字典类型修改对象
+ * @author
+ * @version 1.0
+ * @date 2025/2/24 1:35
+ */
+@Data
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+public class SysDictTypeUpdReq extends BaseEntity {
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 字典主键
+     */
+    private Long dictId;
+
+    /**
+     * 字典名称
+     */
+    private String dictName;
+
+    /**
+     * 字典类型
+     */
+    private String dictType;
+
+    /**
+     * 状态（0正常 1停用）
+     */
+    private String status;
+
+    @NotBlank(message = "字典名称不能为空")
+    @Size(min = 0, max = 100, message = "字典类型名称长度不能超过100个字符")
+    public String getDictName () {
+        return dictName;
+    }
+
+    @NotBlank(message = "字典类型不能为空")
+    @Size(min = 0, max = 100, message = "字典类型类型长度不能超过100个字符")
+    @Pattern(regexp = "^[a-z][a-z0-9_]*$", message = "字典类型必须以字母开头，且只能为（小写字母，数字，下滑线）")
+    public String getDictType () {
+        return dictType;
+    }
+}

cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/resp/SysDictDataListResp.java

@@ -0,0 +1,88 @@
+package com.muyu.system.domain.resp;
+
+import com.muyu.common.core.annotation.Excel;
+import com.muyu.common.core.web.domain.BaseEntity;
+import com.muyu.common.system.domain.SysDictData;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+/**
+ * @author SunLY
+ * @version 1.0
+ * @date 2025/2/23 21:24
+ */
+@Data
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+public class SysDictDataListResp extends BaseEntity {
+    /**
+     * 字典编码
+     */
+    @Excel(name = "字典编码", cellType = Excel.ColumnType.NUMERIC)
+    private Long dictCode;
+
+    /**
+     * 字典排序
+     */
+    @Excel(name = "字典排序", cellType = Excel.ColumnType.NUMERIC)
+    private Long dictSort;
+
+    /**
+     * 字典标签
+     */
+    @Excel(name = "字典标签")
+    private String dictLabel;
+
+    /**
+     * 字典键值
+     */
+    @Excel(name = "字典键值")
+    private String dictValue;
+
+    /**
+     * 字典类型
+     */
+    @Excel(name = "字典类型")
+    private String dictType;
+
+    /**
+     * 样式属性（其他样式扩展）
+     */
+    private String cssClass;
+
+    /**
+     * 表格字典样式
+     */
+    private String listClass;
+
+    /**
+     * 是否默认（Y是 N否）
+     */
+    @Excel(name = "是否默认", readConverterExp = "Y=是,N=否")
+    private String isDefault;
+
+    /**
+     * 状态（0正常 1停用）
+     */
+    @Excel(name = "状态", readConverterExp = "0=正常,1=停用")
+    private String status;
+
+    public static SysDictDataListResp buildResp(SysDictData sysDictData){
+        return SysDictDataListResp.builder()
+                .dictCode(sysDictData.getDictCode())
+                .dictSort(sysDictData.getDictSort())
+                .dictLabel(sysDictData.getDictLabel())
+                .dictValue(sysDictData.getDictValue())
+                .dictType(sysDictData.getDictType())
+                .cssClass(sysDictData.getCssClass())
+                .listClass(sysDictData.getListClass())
+                .isDefault(sysDictData.getIsDefault())
+                .status(sysDictData.getStatus())
+                .build();
+    }
+}

cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/resp/SysDictTypeListResp.java

@@ -0,0 +1,68 @@
+package com.muyu.system.domain.resp;
+
+import com.muyu.common.core.annotation.Excel;
+import com.muyu.common.core.annotation.Excel.ColumnType;
+import com.muyu.common.core.web.domain.BaseEntity;
+import com.muyu.system.domain.model.SysDictTypeListModel;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.Size;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+/**
+ * 字典类型列表
+ *
+ * @author
+ */
+@Data
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+public class SysDictTypeListResp extends BaseEntity {
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 字典主键
+     */
+    @Excel(name = "字典主键", cellType = ColumnType.NUMERIC)
+    private Long dictId;
+
+    /**
+     * 字典名称
+     */
+    @Excel(name = "字典名称")
+    private String dictName;
+
+    /**
+     * 字典类型
+     */
+    @Excel(name = "字典类型")
+    private String dictType;
+
+    /**
+     * 状态（0正常 1停用）
+     */
+    @Excel(name = "状态", readConverterExp = "0=正常,1=停用")
+    private String status;
+
+    @NotBlank(message = "字典名称不能为空")
+    @Size(min = 0, max = 100, message = "字典类型名称长度不能超过100个字符")
+    public String getDictName () {
+        return dictName;
+    }
+
+
+    public static SysDictTypeListResp buildResp(SysDictTypeListModel sysDictTypeListModel) {
+        return SysDictTypeListResp.builder()
+                .dictId(sysDictTypeListModel.getDictId())
+                .dictName(sysDictTypeListModel.getDictName())
+                .dictType(sysDictTypeListModel.getDictType())
+                .status(sysDictTypeListModel.getStatus())
+                .build();
+    }
+}

cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/service/SysDictDataService.java

@@ -3,7 +3,10 @@ package com.muyu.system.service;
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.muyu.common.core.web.page.PageQueryModel;
 import com.muyu.common.system.domain.SysDictData;
+import com.muyu.system.domain.model.SysDictDataAddModel;
 import com.muyu.system.domain.model.SysDictDataPageQueryModel;
+import com.muyu.system.domain.model.SysDictDataUpdModel;
+import com.muyu.system.domain.rep.SysDictDataUpdReq;
 
 import java.util.List;
 
@@ -51,16 +54,16 @@ public interface SysDictDataService extends IService<SysDictData> {
     /**
      * 新增保存字典数据信息
      *
-     * @param dictData 字典数据信息
+     * @param sysDictDataAddModel 字典数据信息
      */
-    public void insertDictData (SysDictData dictData);
+    public void insertDictData (SysDictDataAddModel sysDictDataAddModel);
 
     /**
      * 修改保存字典数据信息
      *
-     * @param dictData 字典数据信息
+     * @param sysDictDataUpdModel 字典数据信息
      */
-    public void updateDictData (SysDictData dictData);
+    public void updateDictData (SysDictDataUpdModel sysDictDataUpdModel);
 
     PageQueryModel<SysDictData> pageQuery(SysDictDataPageQueryModel sysDictDataPageQueryModel);
 

cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/service/SysDictTypeService.java

@@ -4,7 +4,10 @@ import com.baomidou.mybatisplus.extension.service.IService;
 import com.muyu.common.core.web.page.PageQueryModel;
 import com.muyu.common.system.domain.SysDictData;
 import com.muyu.common.system.domain.SysDictType;
+import com.muyu.system.domain.model.SysDictTypeAddModel;
+import com.muyu.system.domain.model.SysDictTypeListModel;
 import com.muyu.system.domain.model.SysDictTypePageQueryModel;
+import com.muyu.system.domain.model.SysDictTypeUpdModel;
 
 import java.util.List;
 
@@ -17,11 +20,11 @@ public interface SysDictTypeService extends IService<SysDictType> {
     /**
      * 根据条件分页查询字典类型
      *
-     * @param dictType 字典类型信息
+     * @param sysDictTypePageQueryModel 字典类型信息
      *
      * @return 字典类型集合信息
      */
-    public List<SysDictType> selectDictTypeList (SysDictType dictType);
+    public List<SysDictTypeListModel> selectDictTypeList (SysDictTypePageQueryModel sysDictTypePageQueryModel);
 
     /**
      * 根据所有字典类型
@@ -82,27 +85,36 @@ public interface SysDictTypeService extends IService<SysDictType> {
     /**
      * 新增保存字典类型信息
      *
-     * @param dictType 字典类型信息
+     * @param sysDictTypeAddModel 字典类型信息
      *
      * @return 结果
      */
-    public void insertDictType (SysDictType dictType);
+    public void insertDictType (SysDictTypeAddModel sysDictTypeAddModel);
 
     /**
      * 修改保存字典类型信息
      *
-     * @param dictType 字典类型信息
+     * @param sysDictTypeUpdModel 字典类型信息
      */
-    public void updateDictType (SysDictType dictType);
+    public void updateDictType (SysDictTypeUpdModel sysDictTypeUpdModel);
 
     /**
      * 校验字典类型称是否唯一
      *
-     * @param dictType 字典类型
+     * @param sysDictTypeAddModel 字典类型
      *
      * @return 结果
      */
-    public boolean checkDictTypeUnique (SysDictType dictType);
+    public boolean checkDictTypeUnique (SysDictTypeAddModel sysDictTypeAddModel);
+
+    /**
+     * 校验字典类型称是否唯一
+     *
+     * @param sysDictTypeUpdModel 字典类型
+     *
+     * @return 结果
+     */
+    public boolean checkDictTypeUnique (SysDictTypeUpdModel sysDictTypeUpdModel);
 
 
     PageQueryModel<SysDictType> pageQuery(SysDictTypePageQueryModel sysDictTypePageQueryModel);

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

@@ -9,7 +9,9 @@ import com.muyu.common.core.utils.StringUtils;
 import com.muyu.common.core.web.page.PageQueryModel;
 import com.muyu.common.security.utils.DictUtils;
 import com.muyu.common.system.domain.SysDictData;
+import com.muyu.system.domain.model.SysDictDataAddModel;
 import com.muyu.system.domain.model.SysDictDataPageQueryModel;
+import com.muyu.system.domain.model.SysDictDataUpdModel;
 import com.muyu.system.mapper.SysDictDataMapper;
 import com.muyu.system.service.SysDictDataService;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -25,15 +27,12 @@ import java.util.List;
  */
 @Service
 public class SysDictDataServiceImpl extends ServiceImpl<SysDictDataMapper, SysDictData> implements SysDictDataService {
-    @Autowired
-    private SysDictDataMapper dictDataMapper;
-
 
 
     /**
      * 根据条件分页查询字典数据
      *
-     * @param dictData 字典数据信息
+     * @param pageQueryModel 字典数据信息
      *
      * @return 字典数据集合信息
      */
@@ -101,26 +100,48 @@ public class SysDictDataServiceImpl extends ServiceImpl<SysDictDataMapper, SysDi
     /**
      * 新增保存字典数据信息
      *
-     * @param data 字典数据信息
+     * @param sysDictDataAddModel 字典数据信息
      */
     @Override
-    public void insertDictData (SysDictData data) {
+    public void insertDictData (SysDictDataAddModel sysDictDataAddModel) {
-        if (this.save(data)) {
+        SysDictData sysDictData = SysDictData.builder()
-            List<SysDictData> dictDataList = this.selectDictDataByType(data.getDictType());
+                .dictCode(sysDictDataAddModel.getDictCode())
-            DictUtils.setDictCache(data.getDictType(), dictDataList);
+                .dictSort(sysDictDataAddModel.getDictSort())
+                .dictLabel(sysDictDataAddModel.getDictLabel())
+                .dictValue(sysDictDataAddModel.getDictValue())
+                .dictType(sysDictDataAddModel.getDictType())
+                .cssClass(sysDictDataAddModel.getCssClass())
+                .listClass(sysDictDataAddModel.getListClass())
+                .isDefault(sysDictDataAddModel.getIsDefault())
+                .status(sysDictDataAddModel.getStatus())
+                .build();
+        if (this.save(sysDictData)) {
+            List<SysDictData> dictDataList = this.selectDictDataByType(sysDictData.getDictType());
+            DictUtils.setDictCache(sysDictData.getDictType(), dictDataList);
         }
     }
 
     /**
      * 修改保存字典数据信息
      *
-     * @param data 字典数据信息
+     * @param sysDictDataUpdModel 字典数据信息
      */
     @Override
-    public void updateDictData (SysDictData data) {
+    public void updateDictData (SysDictDataUpdModel sysDictDataUpdModel) {
-        if (this.updateById(data)) {
+        SysDictData sysDictData = SysDictData.builder()
-            List<SysDictData> dictDataList = this.selectDictDataByType(data.getDictType());
+                .dictCode(sysDictDataUpdModel.getDictCode())
-            DictUtils.setDictCache(data.getDictType(), dictDataList);
+                .dictSort(sysDictDataUpdModel.getDictSort())
+                .dictLabel(sysDictDataUpdModel.getDictLabel())
+                .dictValue(sysDictDataUpdModel.getDictValue())
+                .dictType(sysDictDataUpdModel.getDictType())
+                .cssClass(sysDictDataUpdModel.getCssClass())
+                .listClass(sysDictDataUpdModel.getListClass())
+                .isDefault(sysDictDataUpdModel.getIsDefault())
+                .status(sysDictDataUpdModel.getStatus())
+                .build();
+        if (this.updateById(sysDictData)) {
+            List<SysDictData> dictDataList = this.selectDictDataByType(sysDictData.getDictType());
+            DictUtils.setDictCache(sysDictData.getDictType(), dictDataList);
         }
     }
 

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

@@ -10,7 +10,10 @@ import com.muyu.common.core.web.page.PageQueryModel;
 import com.muyu.common.security.utils.DictUtils;
 import com.muyu.common.system.domain.SysDictData;
 import com.muyu.common.system.domain.SysDictType;
+import com.muyu.system.domain.model.SysDictTypeAddModel;
+import com.muyu.system.domain.model.SysDictTypeListModel;
 import com.muyu.system.domain.model.SysDictTypePageQueryModel;
+import com.muyu.system.domain.model.SysDictTypeUpdModel;
 import com.muyu.system.mapper.SysDictTypeMapper;
 import com.muyu.system.service.SysDictDataService;
 import com.muyu.system.service.SysDictTypeService;
@@ -30,8 +33,7 @@ import java.util.stream.Collectors;
  */
 @Service
 public class SysDictTypeServiceImpl extends ServiceImpl<SysDictTypeMapper, SysDictType> implements SysDictTypeService {
-    @Autowired
+
-    private SysDictTypeMapper dictTypeMapper;
 
     @Autowired
     private SysDictDataService sysDictDataService;
@@ -59,24 +61,34 @@ public class SysDictTypeServiceImpl extends ServiceImpl<SysDictTypeMapper, SysDi
     /**
      * 根据条件分页查询字典类型
      *
-     * @param dictType 字典类型信息
+     * @param sysDictTypePageQueryModel 字典类型信息
      *
      * @return 字典类型集合信息
      */
     @Override
-    public List<SysDictType> selectDictTypeList (SysDictType dictType) {
+    public List<SysDictTypeListModel> selectDictTypeList (SysDictTypePageQueryModel sysDictTypePageQueryModel) {
         LambdaQueryWrapper<SysDictType> lambdaQueryWrapper = new LambdaQueryWrapper<>();
-        lambdaQueryWrapper.like(StringUtils.isNotEmpty(dictType.getDictName()),SysDictType::getDictName, dictType.getDictName());
+        lambdaQueryWrapper.like(StringUtils.isNotEmpty(sysDictTypePageQueryModel.getDictName()),SysDictType::getDictName, sysDictTypePageQueryModel.getDictName());
-        lambdaQueryWrapper.eq(StringUtils.isNotEmpty(dictType.getStatus()),SysDictType::getStatus, dictType.getStatus());
+        lambdaQueryWrapper.eq(StringUtils.isNotEmpty(sysDictTypePageQueryModel.getStatus()),SysDictType::getStatus, sysDictTypePageQueryModel.getStatus());
-        lambdaQueryWrapper.like(StringUtils.isNotEmpty(dictType.getDictType()),SysDictType::getDictType, dictType.getDictType());
+        lambdaQueryWrapper.like(StringUtils.isNotEmpty(sysDictTypePageQueryModel.getDictType()),SysDictType::getDictType, sysDictTypePageQueryModel.getDictType());
-        Map<String, Object> params = dictType.getParams();
+        Map<String, Object> params = sysDictTypePageQueryModel.getParams();
         Date beginTime = (Date) params.get("beginTime");
         Date endTime = (Date) params.get("endTime");
         lambdaQueryWrapper.between(
                 beginTime != null && endTime != null,
                 SysDictType::getCreateTime, beginTime, endTime
         );
-        return this.list(lambdaQueryWrapper);
+        List<SysDictType> sysDictTypeList = this.list(lambdaQueryWrapper);
+        List<SysDictTypeListModel> sysDictTypeListModelList = sysDictTypeList.stream().map(
+                sysDictType -> SysDictTypeListModel.builder()
+                        .dictId(sysDictType.getDictId())
+                        .dictName(sysDictType.getDictName())
+                        .dictType(sysDictType.getDictType())
+                        .status(sysDictType.getStatus())
+                        .remark(sysDictType.getRemark())
+                        .build()
+        ).distinct().collect(Collectors.toList());
+        return sysDictTypeListModelList;
     }
 
     /**
@@ -191,25 +203,38 @@ public class SysDictTypeServiceImpl extends ServiceImpl<SysDictTypeMapper, SysDi
     /**
      * 新增保存字典类型信息
      *
-     * @param dict 字典类型信息
+     * @param sysDictTypeAddModel 字典类型信息
      *
      * @return 结果
      */
     @Override
-    public void insertDictType (SysDictType dict) {
+    public void insertDictType (SysDictTypeAddModel sysDictTypeAddModel) {
-        if (this.save(dict)) {
+        SysDictType sysDictType = SysDictType.builder()
-            DictUtils.setDictCache(dict.getDictType(), null);
+                .dictName(sysDictTypeAddModel.getDictName())
+                .dictType(sysDictTypeAddModel.getDictType())
+                .status(sysDictTypeAddModel.getStatus())
+                .remark(sysDictTypeAddModel.getRemark())
+                .build();
+        if (this.save(sysDictType)) {
+            DictUtils.setDictCache(sysDictType.getDictType(), null);
         }
     }
 
     /**
      * 修改保存字典类型信息
      *
-     * @param dict 字典类型信息
+     * @param sysDictTypeUpdModel 字典类型信息
      */
     @Override
     @Transactional(rollbackFor = Exception.class)
-    public void updateDictType (SysDictType dict) {
+    public void updateDictType (SysDictTypeUpdModel sysDictTypeUpdModel) {
+        SysDictType dict = SysDictType.builder()
+                .dictId(sysDictTypeUpdModel.getDictId())
+                .dictName(sysDictTypeUpdModel.getDictName())
+                .dictType(sysDictTypeUpdModel.getDictType())
+                .status(sysDictTypeUpdModel.getStatus())
+                .remark(sysDictTypeUpdModel.getRemark())
+                .build();
         SysDictType oldDict = this.getById(dict.getDictId());
         sysDictDataService.updateDictDataType(oldDict.getDictType(), dict.getDictType());
         if (this.updateById(dict)) {
@@ -221,17 +246,30 @@ public class SysDictTypeServiceImpl extends ServiceImpl<SysDictTypeMapper, SysDi
     /**
      * 校验字典类型称是否唯一
      *
-     * @param dict 字典类型
+     * @param sysDictTypeAddModel 字典类型
      *
      * @return 结果
      */
     @Override
-    public boolean checkDictTypeUnique (SysDictType dict) {
+    public boolean checkDictTypeUnique (SysDictTypeAddModel sysDictTypeAddModel) {
-        Assert.notNull(dict.getDictType(), "字典类型不可为空");
+        Assert.notNull(sysDictTypeAddModel.getDictType(), "字典类型不可为空");
-        Long dictId = StringUtils.isNull(dict.getDictId()) ? -1L : dict.getDictId();
+        Long dictId = StringUtils.isNull(sysDictTypeAddModel.getDictId()) ? -1L : sysDictTypeAddModel.getDictId();
         LambdaQueryWrapper<SysDictType> lambdaQueryWrapper = new LambdaQueryWrapper<>();
-        lambdaQueryWrapper.eq(SysDictType::getDictType, dict.getDictType());
+        lambdaQueryWrapper.eq(SysDictType::getDictType, sysDictTypeAddModel.getDictType());
-        lambdaQueryWrapper.ne(dict.getDictId() != null, SysDictType::getDictId, dictId);
+        lambdaQueryWrapper.ne(sysDictTypeAddModel.getDictId() != null, SysDictType::getDictId, dictId);
+        if (this.count(lambdaQueryWrapper) > 0) {
+            return UserConstants.NOT_UNIQUE;
+        }
+        return UserConstants.UNIQUE;
+    }
+
+    @Override
+    public boolean checkDictTypeUnique(SysDictTypeUpdModel sysDictTypeUpdModel) {
+        Assert.notNull(sysDictTypeUpdModel.getDictType(), "字典类型不可为空");
+        Long dictId = StringUtils.isNull(sysDictTypeUpdModel.getDictId()) ? -1L : sysDictTypeUpdModel.getDictId();
+        LambdaQueryWrapper<SysDictType> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.eq(SysDictType::getDictType, sysDictTypeUpdModel.getDictType());
+        lambdaQueryWrapper.ne(sysDictTypeUpdModel.getDictId() != null, SysDictType::getDictId, dictId);
         if (this.count(lambdaQueryWrapper) > 0) {
             return UserConstants.NOT_UNIQUE;
         }