Hass/xiaozhi-esp32-server
1
0
Fork 0
mirror of https://github.com/xinnan-tech/xiaozhi-esp32-server.git synced 2026-07-22 15:13:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

数字字典接口开发

Browse Source
This commit is contained in:
zccaif
2025-04-30 22:46:55 +08:00
parent bb2143d9a0
commit 48f7ef2023
18 changed files with 498 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files
main/manager-api/src/main/java/xiaozhi/modules/sys/controller/AdminController.java
-1
View File
@@ -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
+96
View File
@@ -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
+93
View File
@@ -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
-10
View File
@@ -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
-8
View File
@@ -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
+1
View File
@@ -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
-16
View File
@@ -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
-19
View File
@@ -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
+1 -1
View File
@@ -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
+30 -2
View File
@@ -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
+36 -6
View File
@@ -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
+68 -11
View File
@@ -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) {
IPage<SysDictDataEntity> page = baseDao.selectPage(
getPage(params, "sort", true),
getWrapper(params));
public PageData<SysDictDataVO> page(Map<String, Object> params) {
IPage<SysDictDataEntity> page = baseDao.selectPage(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 dictLabel = (String) params.get("dictLabel");
String dictValue = (String) params.get("dictValue");
String dictTypeId = (String)params.get("dictTypeId");
String dictLabel = (String)params.get("dictLabel");
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
+73 -29
View File
@@ -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 {
private final SysDictDataDao sysDictDataDao;
implements SysDictTypeService {
private final SysUserDao sysUserDao;
@Override
public PageData<SysDictTypeDTO> page(Map<String, Object> params) {
IPage<SysDictTypeEntity> page = baseDao.selectPage(
getPage(params, "sort", true),
getWrapper(params));
public PageData<SysDictTypeVO> page(Map<String, Object> params) {
IPage<SysDictTypeEntity> page = baseDao.selectPage(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 dictName = (String) params.get("dictName");
String dictType = (String)params.get("dictType");
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() {
List<DictType> typeList = baseDao.getDictTypeList();
List<DictData> dataList = sysDictDataDao.getDictDataList();
for (DictType type : typeList) {
for (DictData data : dataList) {
if (type.getId().equals(data.getDictTypeId())) {
type.getDataList().add(data);
}
}
public List<SysDictTypeVO> list(Map<String, Object> params) {
List<SysDictTypeEntity> entityList = baseDao.selectList(getWrapper(params));
List<SysDictTypeVO> sysDictTypeVOList = ConvertUtils.sourceToTarget(entityList, SysDictTypeVO.class);
// 设置用户名
setUserName(sysDictTypeVOList);
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
public List<DictType> getDictTypeList() {
return baseDao.getDictTypeList();
private void checkDictTypeUnique(String dictType, String excludeId) {
LambdaQueryWrapper<SysDictTypeEntity> queryWrapper = new LambdaQueryWrapper<>();
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
+3 -1
View File
@@ -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
+50
View File
@@ -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
+47
View File
@@ -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
-7
View File
@@ -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
-4
View File
@@ -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>