ruoyi
/
cloud-server
12
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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
boot3.0
21407 2025-02-24 11:53:47 +08:00
parent 0720b476c5 9f89f3afa6
commit 11d790a0f4
22 changed files with 1127 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

@ -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) {
PageQueryModel<SysDictData> sysDictDataPageQueryModel = dictDataService.selectDictDataList(SysDictDataPageQueryModel.reqBuild(sysDictDataListReq));
public Result<DataPageResp<SysDictDataListResp>> list (@RequestBody SysDictDataListReq 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) {
dict.setCreateBy(SecurityUtils.getUsername());
dictDataService.insertDictData(dict);
public Result<String> add (@Validated @RequestBody SysDictDataAddReq sysDictDataAddReq) {
sysDictDataAddReq.setCreateBy(SecurityUtils.getUsername());
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) {
dict.setUpdateBy(SecurityUtils.getUsername());
dictDataService.updateDictData(dict);
public Result<String> edit (@Validated @RequestBody SysDictDataUpdReq sysDictDataUpdReq) {
sysDictDataUpdReq.setUpdateBy(SecurityUtils.getUsername());
dictDataService.updateDictData(SysDictDataUpdModel.buildUpdModel(sysDictDataUpdReq));
return Result.success();
}

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

@ -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) {
List<SysDictType> list = dictTypeService.selectDictTypeList(dictType);
return Result.success(new DataPageResp<>(0,list));
public Result<DataPageResp<SysDictTypeListResp>> list (@RequestBody SysDictTypeListReq sysDictTypeListReq) {
List<SysDictTypeListResp> dictTypeListResps = dictTypeService.selectDictTypeList(SysDictTypePageQueryModel.reqBuild(sysDictTypeListReq))
.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) {
List<SysDictType> list = dictTypeService.selectDictTypeList(dictType);
ExcelUtil<SysDictType> util = new ExcelUtil<SysDictType>(SysDictType.class);
util.exportExcel(response, list, "字典类型");
public void export (HttpServletResponse response, SysDictTypeListReq sysDictTypeListReq) {
List<SysDictTypeListResp> dictTypeListResps = dictTypeService.selectDictTypeList(SysDictTypePageQueryModel.reqBuild(sysDictTypeListReq))
.stream()
.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) {
if (!dictTypeService.checkDictTypeUnique(dict)) {
return error("新增字典'" + dict.getDictName() + "'失败，字典类型已存在");
public Result add (@Validated @RequestBody SysDictTypeAddReq sysDictTypeAddReq) {
if (!dictTypeService.checkDictTypeUnique(SysDictTypeAddModel.buildModel(sysDictTypeAddReq))) {
return error("新增字典'" + sysDictTypeAddReq.getDictName() + "'失败，字典类型已存在");
}
dict.setCreateBy(SecurityUtils.getUsername());
dictTypeService.insertDictType(dict);
sysDictTypeAddReq.setCreateBy(SecurityUtils.getUsername());
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) {
if (!dictTypeService.checkDictTypeUnique(dict)) {
return error("修改字典'" + dict.getDictName() + "'失败，字典类型已存在");
public Result edit (@Validated @RequestBody SysDictTypeUpdReq sysDictTypeUpdReq) {
if (!dictTypeService.checkDictTypeUnique(SysDictTypeUpdModel.buildUpdModel(sysDictTypeUpdReq))) {
return error("修改字典'" + sysDictTypeUpdReq.getDictName() + "'失败，字典类型已存在");
}
dict.setUpdateBy(SecurityUtils.getUsername());
dictTypeService.updateDictType(dict);
sysDictTypeUpdReq.setUpdateBy(SecurityUtils.getUsername());
dictTypeService.updateDictType(SysDictTypeUpdModel.buildUpdModel(sysDictTypeUpdReq));
return Result.success();
}

85
cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/model/SysDictDataAddModel.java 100644
View File

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

69
cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/model/SysDictDataListModel.java 100644
View File

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

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

@ -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())

113
cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/model/SysDictDataUpdModel.java 100644
View File

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

58
cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/model/SysDictTypeAddModel.java 100644
View File

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

59
cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/model/SysDictTypeListModel.java 100644
View File

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

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

@ -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())

58
cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/model/SysDictTypeUpdModel.java 100644
View File

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

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

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

96
cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/rep/SysDictDataAddReq.java 100644
View File

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

98
cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/rep/SysDictDataUpdReq.java 100644
View File

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

62
cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/rep/SysDictTypeAddReq.java 100644
View File

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

60
cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/rep/SysDictTypeUpdReq.java 100644
View File

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

88
cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/resp/SysDictDataListResp.java 100644
View File

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

68
cloud-modules/cloud-modules-system/src/main/java/com/muyu/system/domain/resp/SysDictTypeListResp.java 100644
View File

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

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

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

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

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

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

@ -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) {
if (this.save(data)) {
List<SysDictData> dictDataList = this.selectDictDataByType(data.getDictType());
DictUtils.setDictCache(data.getDictType(), dictDataList);
public void insertDictData (SysDictDataAddModel sysDictDataAddModel) {
SysDictData sysDictData = SysDictData.builder()
.dictCode(sysDictDataAddModel.getDictCode())
.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) {
if (this.updateById(data)) {
List<SysDictData> dictDataList = this.selectDictDataByType(data.getDictType());
DictUtils.setDictCache(data.getDictType(), dictDataList);
public void updateDictData (SysDictDataUpdModel sysDictDataUpdModel) {
SysDictData sysDictData = SysDictData.builder()
.dictCode(sysDictDataUpdModel.getDictCode())
.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);
}
}

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

@ -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.eq(StringUtils.isNotEmpty(dictType.getStatus()),SysDictType::getStatus, dictType.getStatus());
lambdaQueryWrapper.like(StringUtils.isNotEmpty(dictType.getDictType()),SysDictType::getDictType, dictType.getDictType());
Map<String, Object> params = dictType.getParams();
lambdaQueryWrapper.like(StringUtils.isNotEmpty(sysDictTypePageQueryModel.getDictName()),SysDictType::getDictName, sysDictTypePageQueryModel.getDictName());
lambdaQueryWrapper.eq(StringUtils.isNotEmpty(sysDictTypePageQueryModel.getStatus()),SysDictType::getStatus, sysDictTypePageQueryModel.getStatus());
lambdaQueryWrapper.like(StringUtils.isNotEmpty(sysDictTypePageQueryModel.getDictType()),SysDictType::getDictType, sysDictTypePageQueryModel.getDictType());
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) {
if (this.save(dict)) {
DictUtils.setDictCache(dict.getDictType(), null);
public void insertDictType (SysDictTypeAddModel sysDictTypeAddModel) {
SysDictType sysDictType = SysDictType.builder()
.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) {
Assert.notNull(dict.getDictType(), "字典类型不可为空");
Long dictId = StringUtils.isNull(dict.getDictId()) ? -1L : dict.getDictId();
public boolean checkDictTypeUnique (SysDictTypeAddModel sysDictTypeAddModel) {
Assert.notNull(sysDictTypeAddModel.getDictType(), "字典类型不可为空");
Long dictId = StringUtils.isNull(sysDictTypeAddModel.getDictId()) ? -1L : sysDictTypeAddModel.getDictId();
LambdaQueryWrapper<SysDictType> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(SysDictType::getDictType, dict.getDictType());
lambdaQueryWrapper.ne(dict.getDictId() != null, SysDictType::getDictId, dictId);
lambdaQueryWrapper.eq(SysDictType::getDictType, sysDictTypeAddModel.getDictType());
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;
}