Merge pull request #1080 from xinnan-tech/manager-api-dict

数据字典接口开发

main/manager-api/src/main/java/xiaozhi/modules/sys/controller/AdminController.java

@@ -58,7 +58,6 @@ public class AdminController {
         dto.setLimit((String) params.get(Constant.LIMIT));
         dto.setPage((String) params.get(Constant.PAGE));
         ValidatorUtils.validateEntity(dto);
-        ValidatorUtils.validateEntity(dto);
         PageData<AdminPageUserVO> page = sysUserService.page(dto);
         return new Result<PageData<AdminPageUserVO>>().ok(page);
     }

main/manager-api/src/main/java/xiaozhi/modules/sys/controller/SysDictDataController.java

@@ -0,0 +1,96 @@
+package xiaozhi.modules.sys.controller;
+
+import java.util.Map;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.shiro.authz.annotation.RequiresPermissions;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.Parameters;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.AllArgsConstructor;
+import xiaozhi.common.constant.Constant;
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.utils.Result;
+import xiaozhi.common.validator.ValidatorUtils;
+import xiaozhi.modules.sys.dto.SysDictDataDTO;
+import xiaozhi.modules.sys.service.SysDictDataService;
+import xiaozhi.modules.sys.vo.SysDictDataVO;
+
+/**
+ * 字典数据管理
+ *
+ * @author czc
+ * @since 2025-04-30
+ */
+@AllArgsConstructor
+@RestController
+@RequestMapping("/admin/dict/data")
+@Tag(name = "字典数据管理")
+public class SysDictDataController {
+    private final SysDictDataService sysDictDataService;
+
+    @GetMapping("/page")
+    @Operation(summary = "分页查询字典数据")
+    @RequiresPermissions("sys:role:superAdmin")
+    @Parameters({@Parameter(name = "dictTypeId", description = "字典类型ID", required = true),
+        @Parameter(name = "dictLabel", description = "数据标签"), @Parameter(name = "dictValue", description = "数据值"),
+        @Parameter(name = Constant.PAGE, description = "当前页码，从1开始", required = true),
+        @Parameter(name = Constant.LIMIT, description = "每页显示记录数", required = true)})
+    public Result<PageData<SysDictDataVO>> page(@Parameter(hidden = true) @RequestParam Map<String, Object> params) {
+        ValidatorUtils.validateEntity(params);
+        // 强制校验dictTypeId是否存在
+        if (!params.containsKey("dictTypeId") || StringUtils.isEmpty(String.valueOf(params.get("dictTypeId")))) {
+            return new Result<PageData<SysDictDataVO>>().error("dictTypeId不能为空");
+        }
+
+        PageData<SysDictDataVO> page = sysDictDataService.page(params);
+        return new Result<PageData<SysDictDataVO>>().ok(page);
+    }
+
+    @GetMapping("/{id}")
+    @Operation(summary = "获取字典数据详情")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<SysDictDataVO> get(@PathVariable("id") Long id) {
+        SysDictDataVO vo = sysDictDataService.get(id);
+        return new Result<SysDictDataVO>().ok(vo);
+    }
+
+    @PostMapping("/save")
+    @Operation(summary = "新增字典数据")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<Void> save(@RequestBody SysDictDataDTO dto) {
+        ValidatorUtils.validateEntity(dto);
+        sysDictDataService.save(dto);
+        return new Result<>();
+    }
+
+    @PutMapping("/update")
+    @Operation(summary = "修改字典数据")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<Void> update(@RequestBody SysDictDataDTO dto) {
+        ValidatorUtils.validateEntity(dto);
+        sysDictDataService.update(dto);
+        return new Result<>();
+    }
+
+    @DeleteMapping("/delete")
+    @Operation(summary = "删除字典数据")
+    @RequiresPermissions("sys:role:superAdmin")
+    @Parameter(name = "ids", description = "ID数组", required = true)
+    public Result<Void> delete(@RequestBody Long[] ids) {
+        sysDictDataService.delete(ids);
+        return new Result<>();
+    }
+
+}

main/manager-api/src/main/java/xiaozhi/modules/sys/controller/SysDictTypeController.java

@@ -0,0 +1,93 @@
+package xiaozhi.modules.sys.controller;
+
+import java.util.Map;
+
+import org.apache.shiro.authz.annotation.RequiresPermissions;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.Parameters;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.AllArgsConstructor;
+import xiaozhi.common.constant.Constant;
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.utils.Result;
+import xiaozhi.common.validator.ValidatorUtils;
+import xiaozhi.modules.sys.dto.SysDictTypeDTO;
+import xiaozhi.modules.sys.service.SysDictTypeService;
+import xiaozhi.modules.sys.vo.SysDictTypeVO;
+
+/**
+ * 字典类型管理
+ *
+ * @author czc
+ * @since 2025-04-30
+ */
+@AllArgsConstructor
+@RestController
+@RequestMapping("/admin/dict/type")
+@Tag(name = "字典类型管理")
+public class SysDictTypeController {
+    private final SysDictTypeService sysDictTypeService;
+
+    @GetMapping("/page")
+    @Operation(summary = "分页查询字典类型")
+    @RequiresPermissions("sys:role:superAdmin")
+    @Parameters({@Parameter(name = "dictType", description = "字典类型编码"),
+        @Parameter(name = "dictName", description = "字典类型名称"),
+        @Parameter(name = Constant.PAGE, description = "当前页码，从1开始", required = true),
+        @Parameter(name = Constant.LIMIT, description = "每页显示记录数", required = true)})
+    public Result<PageData<SysDictTypeVO>> page(@Parameter(hidden = true) @RequestParam Map<String, Object> params) {
+        ValidatorUtils.validateEntity(params);
+        PageData<SysDictTypeVO> page = sysDictTypeService.page(params);
+        return new Result<PageData<SysDictTypeVO>>().ok(page);
+    }
+
+    @GetMapping("/{id}")
+    @Operation(summary = "获取字典类型详情")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<SysDictTypeVO> get(@PathVariable("id") Long id) {
+        SysDictTypeVO vo = sysDictTypeService.get(id);
+        return new Result<SysDictTypeVO>().ok(vo);
+    }
+
+    @PostMapping("/save")
+    @Operation(summary = "保存字典类型")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<Void> save(@RequestBody SysDictTypeDTO dto) {
+        // 参数校验
+        ValidatorUtils.validateEntity(dto);
+
+        sysDictTypeService.save(dto);
+        return new Result<>();
+    }
+
+    @PutMapping("/update")
+    @Operation(summary = "修改字典类型")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<Void> update(@RequestBody SysDictTypeDTO dto) {
+        // 参数校验
+        ValidatorUtils.validateEntity(dto);
+
+        sysDictTypeService.update(dto);
+        return new Result<>();
+    }
+
+    @DeleteMapping("/delete")
+    @Operation(summary = "删除字典类型")
+    @RequiresPermissions("sys:role:superAdmin")
+    @Parameter(name = "ids", description = "ID数组", required = true)
+    public Result<Void> delete(@RequestBody Long[] ids) {
+        sysDictTypeService.delete(ids);
+        return new Result<>();
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/sys/dao/SysDictDataDao.java

@@ -1,12 +1,8 @@
 package xiaozhi.modules.sys.dao;
 
-import java.util.List;
-
 import org.apache.ibatis.annotations.Mapper;
 
 import xiaozhi.common.dao.BaseDao;
-import xiaozhi.modules.sys.dto.SysDictDataDTO;
-import xiaozhi.modules.sys.entity.DictData;
 import xiaozhi.modules.sys.entity.SysDictDataEntity;
 
 /**
@@ -15,10 +11,4 @@ import xiaozhi.modules.sys.entity.SysDictDataEntity;
 @Mapper
 public interface SysDictDataDao extends BaseDao<SysDictDataEntity> {
 
-    /**
-     * 字典数据列表
-     */
-    List<DictData> getDictDataList();
-
-    List<SysDictDataDTO> getDataByTypeCode(String dictType);
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/dao/SysDictTypeDao.java

@@ -1,11 +1,8 @@
 package xiaozhi.modules.sys.dao;
 
-import java.util.List;
-
 import org.apache.ibatis.annotations.Mapper;
 
 import xiaozhi.common.dao.BaseDao;
-import xiaozhi.modules.sys.entity.DictType;
 import xiaozhi.modules.sys.entity.SysDictTypeEntity;
 
 /**
@@ -14,9 +11,4 @@ import xiaozhi.modules.sys.entity.SysDictTypeEntity;
 @Mapper
 public interface SysDictTypeDao extends BaseDao<SysDictTypeEntity> {
 
-    /**
-     * 字典类型列表
-     */
-    List<DictType> getDictTypeList();
-
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/dto/SysDictTypeDTO.java

@@ -51,5 +51,6 @@ public class SysDictTypeDTO implements Serializable {
 
     @Schema(description = "更新时间")
     @JsonProperty(access = JsonProperty.Access.READ_ONLY)
+    @JsonFormat(pattern = DateUtils.DATE_TIME_PATTERN)
     private Date updateDate;
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/entity/DictData.java

@@ -1,16 +0,0 @@
-package xiaozhi.modules.sys.entity;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-
-import lombok.Data;
-
-/**
- * 字典数据
- */
-@Data
-public class DictData {
-    @JsonIgnore
-    private Long dictTypeId;
-    private String dictLabel;
-    private String dictValue;
-}

main/manager-api/src/main/java/xiaozhi/modules/sys/entity/DictType.java

@@ -1,19 +0,0 @@
-package xiaozhi.modules.sys.entity;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-
-import lombok.Data;
-
-/**
- * 字典类型
- */
-@Data
-public class DictType {
-    @JsonIgnore
-    private Long id;
-    private String dictType;
-    private List<DictData> dataList = new ArrayList<>();
-}

main/manager-api/src/main/java/xiaozhi/modules/sys/entity/SysDictTypeEntity.java

@@ -18,7 +18,7 @@ import xiaozhi.common.entity.BaseEntity;
 @TableName("sys_dict_type")
 public class SysDictTypeEntity extends BaseEntity {
     /**
-     * 字典类型
+     * 字典类型编码
      */
     private String dictType;
     /**

main/manager-api/src/main/java/xiaozhi/modules/sys/service/SysDictDataService.java

@@ -6,20 +6,48 @@ import xiaozhi.common.page.PageData;
 import xiaozhi.common.service.BaseService;
 import xiaozhi.modules.sys.dto.SysDictDataDTO;
 import xiaozhi.modules.sys.entity.SysDictDataEntity;
+import xiaozhi.modules.sys.vo.SysDictDataVO;
 
 /**
  * 数据字典
  */
 public interface SysDictDataService extends BaseService<SysDictDataEntity> {
 
-    PageData<SysDictDataDTO> page(Map<String, Object> params);
+    /**
+     * 分页查询数据字典信息
+     *
+     * @param params 查询参数，包含分页信息和查询条件
+     * @return 返回数据字典的分页查询结果
+     */
+    PageData<SysDictDataVO> page(Map<String, Object> params);
 
-    SysDictDataDTO get(Long id);
+    /**
+     * 根据ID获取数据字典实体
+     *
+     * @param id 数据字典实体的唯一标识
+     * @return 返回数据字典实体的详细信息
+     */
+    SysDictDataVO get(Long id);
 
+    /**
+     * 保存新的数据字典项
+     *
+     * @param dto 数据字典项的保存数据传输对象
+     */
     void save(SysDictDataDTO dto);
 
+    /**
+     * 更新数据字典项
+     *
+     * @param dto 数据字典项的更新数据传输对象
+     */
     void update(SysDictDataDTO dto);
 
+    /**
+     * 删除数据字典项
+     *
+     * @param ids 要删除的数据字典项的ID数组
+     */
     void delete(Long[] ids);
 
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/service/SysDictTypeService.java

@@ -6,25 +6,55 @@ import java.util.Map;
 import xiaozhi.common.page.PageData;
 import xiaozhi.common.service.BaseService;
 import xiaozhi.modules.sys.dto.SysDictTypeDTO;
-import xiaozhi.modules.sys.entity.DictType;
 import xiaozhi.modules.sys.entity.SysDictTypeEntity;
+import xiaozhi.modules.sys.vo.SysDictTypeVO;
 
 /**
  * 数据字典
  */
 public interface SysDictTypeService extends BaseService<SysDictTypeEntity> {
 
-    PageData<SysDictTypeDTO> page(Map<String, Object> params);
+    /**
+     * 分页查询字典类型信息
+     *
+     * @param params 查询参数，包含分页信息和查询条件
+     * @return 返回分页的字典类型数据
+     */
+    PageData<SysDictTypeVO> page(Map<String, Object> params);
 
-    SysDictTypeDTO get(Long id);
+    /**
+     * 根据ID获取字典类型信息
+     *
+     * @param id 字典类型ID
+     * @return 返回字典类型对象
+     */
+    SysDictTypeVO get(Long id);
 
+    /**
+     * 保存字典类型信息
+     *
+     * @param dto 字典类型数据传输对象
+     */
     void save(SysDictTypeDTO dto);
 
+    /**
+     * 更新字典类型信息
+     *
+     * @param dto 字典类型数据传输对象
+     */
     void update(SysDictTypeDTO dto);
 
+    /**
+     * 删除字典类型信息
+     *
+     * @param ids 要删除的字典类型ID数组
+     */
     void delete(Long[] ids);
 
-    List<DictType> getAllList();
+    /**
-
+     * 列出所有字典类型信息
-    List<DictType> getDictTypeList();
+     *
+     * @return 返回字典类型列表
+     */
+    List<SysDictTypeVO> list(Map<String, Object> params);
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/service/impl/SysDictDataServiceImpl.java

@@ -1,43 +1,58 @@
 package xiaozhi.modules.sys.service.impl;
 
 import java.util.Arrays;
+import java.util.List;
 import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 
+import lombok.AllArgsConstructor;
+import xiaozhi.common.exception.RenException;
 import xiaozhi.common.page.PageData;
 import xiaozhi.common.service.impl.BaseServiceImpl;
 import xiaozhi.common.utils.ConvertUtils;
 import xiaozhi.modules.sys.dao.SysDictDataDao;
+import xiaozhi.modules.sys.dao.SysUserDao;
 import xiaozhi.modules.sys.dto.SysDictDataDTO;
 import xiaozhi.modules.sys.entity.SysDictDataEntity;
+import xiaozhi.modules.sys.entity.SysUserEntity;
 import xiaozhi.modules.sys.service.SysDictDataService;
+import xiaozhi.modules.sys.vo.SysDictDataVO;
 
 /**
  * 字典类型
  */
 @Service
+@AllArgsConstructor
 public class SysDictDataServiceImpl extends BaseServiceImpl<SysDictDataDao, SysDictDataEntity>
-        implements SysDictDataService {
+    implements SysDictDataService {
+    private final SysUserDao sysUserDao;
 
     @Override
-    public PageData<SysDictDataDTO> page(Map<String, Object> params) {
+    public PageData<SysDictDataVO> page(Map<String, Object> params) {
-        IPage<SysDictDataEntity> page = baseDao.selectPage(
+        IPage<SysDictDataEntity> page = baseDao.selectPage(getPage(params, "sort", true), getWrapper(params));
-                getPage(params, "sort", true),
-                getWrapper(params));
 
-        return getPageData(page, SysDictDataDTO.class);
+        PageData<SysDictDataVO> pageData = getPageData(page, SysDictDataVO.class);
+
+        setUserName(pageData.getList());
+
+        return pageData;
     }
 
     private QueryWrapper<SysDictDataEntity> getWrapper(Map<String, Object> params) {
-        String dictTypeId = (String) params.get("dictTypeId");
+        String dictTypeId = (String)params.get("dictTypeId");
-        String dictLabel = (String) params.get("dictLabel");
+        String dictLabel = (String)params.get("dictLabel");
-        String dictValue = (String) params.get("dictValue");
+        String dictValue = (String)params.get("dictValue");
 
         QueryWrapper<SysDictDataEntity> wrapper = new QueryWrapper<>();
         wrapper.eq("dict_type_id", Long.parseLong(dictTypeId));
@@ -48,15 +63,18 @@ public class SysDictDataServiceImpl extends BaseServiceImpl<SysDictDataDao, SysD
     }
 
     @Override
-    public SysDictDataDTO get(Long id) {
+    public SysDictDataVO get(Long id) {
         SysDictDataEntity entity = baseDao.selectById(id);
 
-        return ConvertUtils.sourceToTarget(entity, SysDictDataDTO.class);
+        return ConvertUtils.sourceToTarget(entity, SysDictDataVO.class);
     }
 
     @Override
     @Transactional(rollbackFor = Exception.class)
     public void save(SysDictDataDTO dto) {
+        // 相同字典类型的标签不能相同
+        checkDictValueUnique(dto.getDictTypeId(), dto.getDictValue(), null);
+
         SysDictDataEntity entity = ConvertUtils.sourceToTarget(dto, SysDictDataEntity.class);
 
         insert(entity);
@@ -65,6 +83,9 @@ public class SysDictDataServiceImpl extends BaseServiceImpl<SysDictDataDao, SysD
     @Override
     @Transactional(rollbackFor = Exception.class)
     public void update(SysDictDataDTO dto) {
+        // 相同字典类型的标签不能相同
+        checkDictValueUnique(dto.getDictTypeId(), dto.getDictValue(), String.valueOf(dto.getId()));
+
         SysDictDataEntity entity = ConvertUtils.sourceToTarget(dto, SysDictDataEntity.class);
 
         updateById(entity);
@@ -76,4 +97,40 @@ public class SysDictDataServiceImpl extends BaseServiceImpl<SysDictDataDao, SysD
         // 删除
         deleteBatchIds(Arrays.asList(ids));
     }
+
+    /**
+     * 设置用户名
+     *
+     * @param sysDictDataList 字典类型集合
+     */
+    private void setUserName(List<SysDictDataVO> sysDictDataList) {
+        // 收集所有用户 ID
+        Set<Long> userIds = sysDictDataList.stream().flatMap(vo -> Stream.of(vo.getCreator(), vo.getUpdater()))
+            .filter(Objects::nonNull).collect(Collectors.toSet());
+
+        // 设置更新者和创建者名称
+        if (!userIds.isEmpty()) {
+            List<SysUserEntity> sysUserEntities = sysUserDao.selectBatchIds(userIds);
+            // 把List转成Map，Map<Long, String>
+            Map<Long, String> userNameMap = sysUserEntities.stream().collect(Collectors.toMap(SysUserEntity::getId,
+                SysUserEntity::getUsername, (existing, replacement) -> existing));
+
+            sysDictDataList.forEach(vo -> {
+                vo.setCreatorName(userNameMap.get(vo.getCreator()));
+                vo.setUpdaterName(userNameMap.get(vo.getUpdater()));
+            });
+        }
+    }
+
+    private void checkDictValueUnique(Long dictTypeId, String dictValue, String excludeId) {
+        LambdaQueryWrapper<SysDictDataEntity> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(SysDictDataEntity::getDictTypeId, dictTypeId).eq(SysDictDataEntity::getDictLabel, dictValue);
+        if (StringUtils.isNotBlank(excludeId)) {
+            queryWrapper.ne(SysDictDataEntity::getId, excludeId);
+        }
+        boolean exists = baseDao.exists(queryWrapper);
+        if (exists) {
+            throw new RenException("字典标签重复");
+        }
+    }
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/service/impl/SysDictTypeServiceImpl.java

@@ -3,47 +3,56 @@ package xiaozhi.modules.sys.service.impl;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 
 import lombok.AllArgsConstructor;
+import xiaozhi.common.exception.RenException;
 import xiaozhi.common.page.PageData;
 import xiaozhi.common.service.impl.BaseServiceImpl;
 import xiaozhi.common.utils.ConvertUtils;
-import xiaozhi.modules.sys.dao.SysDictDataDao;
 import xiaozhi.modules.sys.dao.SysDictTypeDao;
+import xiaozhi.modules.sys.dao.SysUserDao;
 import xiaozhi.modules.sys.dto.SysDictTypeDTO;
-import xiaozhi.modules.sys.entity.DictData;
-import xiaozhi.modules.sys.entity.DictType;
 import xiaozhi.modules.sys.entity.SysDictTypeEntity;
+import xiaozhi.modules.sys.entity.SysUserEntity;
 import xiaozhi.modules.sys.service.SysDictTypeService;
+import xiaozhi.modules.sys.vo.SysDictTypeVO;
 
 /**
  * 字典类型
  */
-@AllArgsConstructor
 @Service
+@AllArgsConstructor
 public class SysDictTypeServiceImpl extends BaseServiceImpl<SysDictTypeDao, SysDictTypeEntity>
-        implements SysDictTypeService {
+    implements SysDictTypeService {
-    private final SysDictDataDao sysDictDataDao;
+
+    private final SysUserDao sysUserDao;
 
     @Override
-    public PageData<SysDictTypeDTO> page(Map<String, Object> params) {
+    public PageData<SysDictTypeVO> page(Map<String, Object> params) {
-        IPage<SysDictTypeEntity> page = baseDao.selectPage(
+        IPage<SysDictTypeEntity> page = baseDao.selectPage(getPage(params, "sort", true), getWrapper(params));
-                getPage(params, "sort", true),
-                getWrapper(params));
 
-        return getPageData(page, SysDictTypeDTO.class);
+        PageData<SysDictTypeVO> pageData = getPageData(page, SysDictTypeVO.class);
+
+        setUserName(pageData.getList());
+
+        return pageData;
     }
 
     private QueryWrapper<SysDictTypeEntity> getWrapper(Map<String, Object> params) {
-        String dictType = (String) params.get("dictType");
+        String dictType = (String)params.get("dictType");
-        String dictName = (String) params.get("dictName");
+        String dictName = (String)params.get("dictName");
 
         QueryWrapper<SysDictTypeEntity> wrapper = new QueryWrapper<>();
         wrapper.like(StringUtils.isNotBlank(dictType), "dict_type", dictType);
@@ -53,15 +62,21 @@ public class SysDictTypeServiceImpl extends BaseServiceImpl<SysDictTypeDao, SysD
     }
 
     @Override
-    public SysDictTypeDTO get(Long id) {
+    public SysDictTypeVO get(Long id) {
         SysDictTypeEntity entity = baseDao.selectById(id);
+        if (entity == null) {
+            throw new RenException("字典类型不存在");
+        }
 
-        return ConvertUtils.sourceToTarget(entity, SysDictTypeDTO.class);
+        return ConvertUtils.sourceToTarget(entity, SysDictTypeVO.class);
     }
 
     @Override
     @Transactional(rollbackFor = Exception.class)
     public void save(SysDictTypeDTO dto) {
+        // 字典类型编码不能重复
+        checkDictTypeUnique(dto.getDictType(), null);
+
         SysDictTypeEntity entity = ConvertUtils.sourceToTarget(dto, SysDictTypeEntity.class);
 
         insert(entity);
@@ -70,6 +85,9 @@ public class SysDictTypeServiceImpl extends BaseServiceImpl<SysDictTypeDao, SysD
     @Override
     @Transactional(rollbackFor = Exception.class)
     public void update(SysDictTypeDTO dto) {
+        // 字典类型编码不能重复
+        checkDictTypeUnique(dto.getDictType(), String.valueOf(dto.getId()));
+
         SysDictTypeEntity entity = ConvertUtils.sourceToTarget(dto, SysDictTypeEntity.class);
 
         updateById(entity);
@@ -83,22 +101,48 @@ public class SysDictTypeServiceImpl extends BaseServiceImpl<SysDictTypeDao, SysD
     }
 
     @Override
-    public List<DictType> getAllList() {
+    public List<SysDictTypeVO> list(Map<String, Object> params) {
-        List<DictType> typeList = baseDao.getDictTypeList();
+        List<SysDictTypeEntity> entityList = baseDao.selectList(getWrapper(params));
-        List<DictData> dataList = sysDictDataDao.getDictDataList();
+        List<SysDictTypeVO> sysDictTypeVOList = ConvertUtils.sourceToTarget(entityList, SysDictTypeVO.class);
-        for (DictType type : typeList) {
+        // 设置用户名
-            for (DictData data : dataList) {
+        setUserName(sysDictTypeVOList);
-                if (type.getId().equals(data.getDictTypeId())) {
+
-                    type.getDataList().add(data);
+        return sysDictTypeVOList;
-                }
+    }
-            }
+
+    /**
+     * 设置用户名
+     *
+     * @param sysDictTypeList 字典类型集合
+     */
+    private void setUserName(List<SysDictTypeVO> sysDictTypeList) {
+        // 收集所有用户 ID
+        Set<Long> userIds = sysDictTypeList.stream().flatMap(vo -> Stream.of(vo.getCreator(), vo.getUpdater()))
+            .filter(Objects::nonNull).collect(Collectors.toSet());
+
+        // 设置更新者和创建者名称
+        if (!userIds.isEmpty()) {
+            List<SysUserEntity> sysUserEntities = sysUserDao.selectBatchIds(userIds);
+            // 把List转成Map，Map<Long, String>
+            Map<Long, String> userNameMap = sysUserEntities.stream().collect(Collectors.toMap(SysUserEntity::getId,
+                SysUserEntity::getUsername, (existing, replacement) -> existing));
+
+            sysDictTypeList.forEach(vo -> {
+                vo.setCreatorName(userNameMap.get(vo.getCreator()));
+                vo.setUpdaterName(userNameMap.get(vo.getUpdater()));
+            });
         }
-        return typeList;
     }
 
-    @Override
+    private void checkDictTypeUnique(String dictType, String excludeId) {
-    public List<DictType> getDictTypeList() {
+        LambdaQueryWrapper<SysDictTypeEntity> queryWrapper = new LambdaQueryWrapper<>();
-        return baseDao.getDictTypeList();
+        queryWrapper.eq(SysDictTypeEntity::getDictType, dictType);
+        if (StringUtils.isNotBlank(excludeId)) {
+            queryWrapper.ne(SysDictTypeEntity::getId, excludeId);
+        }
+        boolean exists = baseDao.exists(queryWrapper);
+        if (exists) {
+            throw new RenException("字典类型编码重复");
+        }
     }
-
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/service/impl/SysUserUtilServiceImpl.java

@@ -20,7 +20,9 @@ public class SysUserUtilServiceImpl extends BaseServiceImpl<SysUserDao, SysUserE
     @Override
     public void assignUsername(Long userId, Consumer<String> setter) {
         String userIdKey = RedisKeys.getUserIdKey(userId);
-        String username = redisUtils.get(userIdKey).toString();
+
+        Object value = redisUtils.get(userIdKey);
+        String username = (value != null) ? value.toString() : null;
         if(username != null){
             setter.accept(username);
         }else {

main/manager-api/src/main/java/xiaozhi/modules/sys/vo/SysDictDataVO.java

@@ -0,0 +1,50 @@
+package xiaozhi.modules.sys.vo;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.util.Date;
+
+/**
+ * 字典数据VO
+ */
+@Data
+@Schema(description = "字典数据VO")
+public class SysDictDataVO implements Serializable {
+    @Schema(description = "主键")
+    private Long id;
+
+    @Schema(description = "字典类型ID")
+    private Long dictTypeId;
+
+    @Schema(description = "字典标签")
+    private String dictLabel;
+
+    @Schema(description = "字典值")
+    private String dictValue;
+
+    @Schema(description = "备注")
+    private String remark;
+
+    @Schema(description = "排序")
+    private Integer sort;
+
+    @Schema(description = "创建者")
+    private Long creator;
+
+    @Schema(description = "创建者名称")
+    private String creatorName;
+
+    @Schema(description = "创建时间")
+    private Date createDate;
+
+    @Schema(description = "更新者")
+    private Long updater;
+
+    @Schema(description = "更新者名称")
+    private String updaterName;
+
+    @Schema(description = "更新时间")
+    private Date updateDate;
+}

main/manager-api/src/main/java/xiaozhi/modules/sys/vo/SysDictTypeVO.java

@@ -0,0 +1,47 @@
+package xiaozhi.modules.sys.vo;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.util.Date;
+
+/**
+ * 字典类型VO
+ */
+@Data
+@Schema(description = "字典类型VO")
+public class SysDictTypeVO implements Serializable {
+    @Schema(description = "主键")
+    private Long id;
+
+    @Schema(description = "字典类型")
+    private String dictType;
+
+    @Schema(description = "字典名称")
+    private String dictName;
+
+    @Schema(description = "备注")
+    private String remark;
+
+    @Schema(description = "排序")
+    private Integer sort;
+
+    @Schema(description = "创建者")
+    private Long creator;
+
+    @Schema(description = "创建者名称")
+    private String creatorName;
+
+    @Schema(description = "创建时间")
+    private Date createDate;
+
+    @Schema(description = "更新者")
+    private Long updater;
+
+    @Schema(description = "更新者名称")
+    private String updaterName;
+
+    @Schema(description = "更新时间")
+    private Date updateDate;
+}

main/manager-api/src/main/resources/mapper/sys/SysDictDataDao.xml

@@ -3,11 +3,4 @@
 
 <mapper namespace="xiaozhi.modules.sys.dao.SysDictDataDao">
 
-    <select id="getDictDataList" resultType="xiaozhi.modules.sys.entity.DictData">
-        select dict_type_id, dict_label, dict_value from sys_dict_data order by dict_type_id, sort
-    </select>
-
-    <select id="getDataByTypeCode" resultType="xiaozhi.modules.sys.dto.SysDictDataDTO">
-        select * from sys_dict_data WHERE DICT_TYPE_ID =(SELECT id FROM SYS_DICT_TYPE WHERE DICT_TYPE = #{dictType}) order by sort;
-    </select>
 </mapper>

main/manager-api/src/main/resources/mapper/sys/SysDictTypeDao.xml

@@ -3,8 +3,4 @@
 
 <mapper namespace="xiaozhi.modules.sys.dao.SysDictTypeDao">
 
-    <select id="getDictTypeList" resultType="xiaozhi.modules.sys.entity.DictType">
-        select id, dict_type from sys_dict_type order by dict_type, sort
-    </select>
-
 </mapper>