tongtong/youlai-boot
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

wip: 字典重构临时提交

Browse Source
This commit is contained in:
Ray.Hao
2024-06-22 09:42:14 +08:00
parent 227fe38315
commit c760f1a2f8
43 changed files with 730 additions and 771 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/main/java/com/youlai/system/controller/SysDeptController.java
View File

@@ -1,6 +1,6 @@
package com.youlai.system.controller;
import com.youlai.system.plugin.dupsubmit.annotation.PreventDuplicateSubmit;
import com.youlai.system.plugin.norepeat.annotation.PreventRepeatSubmit;
import com.youlai.system.common.model.Option;
import com.youlai.system.common.result.Result;
import com.youlai.system.model.form.DeptForm;
@@ -11,7 +11,6 @@ import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
import lombok.RequiredArgsConstructor;
import org.springdoc.core.annotations.ParameterObject;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
@@ -33,7 +32,7 @@ public class SysDeptController {
@Operation(summary = "获取部门列表")
@GetMapping
public Result<List<DeptVO>> listDepartments(
@ParameterObject DeptQuery queryParams
DeptQuery queryParams
) {
List<DeptVO> list = deptService.listDepartments(queryParams);
return Result.success(list);
@@ -58,7 +57,7 @@ public class SysDeptController {
@Operation(summary = "新增部门")
@PostMapping
@PreAuthorize("@ss.hasPerm('sys:dept:add')")
@PreventDuplicateSubmit
@PreventRepeatSubmit
public Result saveDept(
@Valid @RequestBody DeptForm formData
) {

100
src/main/java/com/youlai/system/controller/SysDictController.java
View File

@@ -3,26 +3,24 @@ package com.youlai.system.controller;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.youlai.system.common.result.PageResult;
import com.youlai.system.common.result.Result;
import com.youlai.system.plugin.dupsubmit.annotation.PreventDuplicateSubmit;
import com.youlai.system.model.form.DictForm;
import com.youlai.system.model.form.DictTypeForm;
import com.youlai.system.model.query.DictPageQuery;
import com.youlai.system.model.query.DictTypePageQuery;
import com.youlai.system.model.vo.DictPageVO;
import com.youlai.system.model.vo.DictTypePageVO;
import com.youlai.system.common.model.Option;
import com.youlai.system.plugin.norepeat.annotation.PreventRepeatSubmit;
import com.youlai.system.model.form.DictForm;
import com.youlai.system.model.query.DictTypePageQuery;
import com.youlai.system.service.SysDictService;
import com.youlai.system.service.SysDictTypeService;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
import lombok.RequiredArgsConstructor;
import org.springdoc.core.annotations.ParameterObject;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 字典控制层
*
* @author Ray Hao
* @since 2.9.0
*/
@Tag(name = "06.字典接口")
@RestController
@RequestMapping("/api/v1/dict")
@@ -31,21 +29,19 @@ public class SysDictController {
private final SysDictService dictService;
private final SysDictTypeService dictTypeService;
@Operation(summary = "字典分页列表")
@GetMapping("/page")
public PageResult<DictPageVO> getDictPage(
@ParameterObject DictPageQuery queryParams
DictTypePageQuery queryParams
) {
Page<DictPageVO> result = dictService.getDictPage(queryParams);
return PageResult.success(result);
}
@Operation(summary = "字典数据表单数据")
@Operation(summary = "字典表单")
@GetMapping("/{id}/form")
public Result<DictForm> getDictForm(
@Parameter(description ="字典ID") @PathVariable Long id
@Parameter(description = "字典ID") @PathVariable Long id
) {
DictForm formData = dictService.getDictForm(id);
return Result.success(formData);
@@ -54,11 +50,9 @@ public class SysDictController {
@Operation(summary = "新增字典")
@PostMapping
@PreAuthorize("@ss.hasPerm('sys:dict:add')")
@PreventDuplicateSubmit
public Result saveDict(
@RequestBody DictForm DictForm
) {
boolean result = dictService.saveDict(DictForm);
@PreventRepeatSubmit
public Result saveDict(@RequestBody DictForm formData) {
boolean result = dictService.saveDict(formData);
return Result.judge(result);
}
@@ -76,70 +70,12 @@ public class SysDictController {
@Operation(summary = "删除字典")
@DeleteMapping("/{ids}")
@PreAuthorize("@ss.hasPerm('sys:dict:delete')")
public Result deleteDict(
@Parameter(description ="字典ID，多个以英文逗号(,)拼接") @PathVariable String ids
public Result deleteDictionaries(
@Parameter(description = "字典ID，多个以英文逗号(,)拼接") @PathVariable String ids
) {
boolean result = dictService.deleteDict(ids);
boolean result = dictService.deleteDictByIds(ids);
return Result.judge(result);
}
@Operation(summary = "字典下拉列表")
@GetMapping("/{typeCode}/options")
public Result<List<Option>> listDictOptions(
@Parameter(description ="字典类型编码") @PathVariable String typeCode
) {
List<Option> list = dictService.listDictOptions(typeCode);
return Result.success(list);
}
/*----------------------------------------------------*/
@Operation(summary = "字典类型分页列表")
@GetMapping("/types/page")
public PageResult<DictTypePageVO> getDictTypePage(
@ParameterObject DictTypePageQuery queryParams
) {
Page<DictTypePageVO> result = dictTypeService.getDictTypePage(queryParams);
return PageResult.success(result);
}
@Operation(summary = "字典类型表单数据")
@GetMapping("/types/{id}/form")
public Result<DictTypeForm> getDictTypeForm(
@Parameter(description ="字典ID") @PathVariable Long id
) {
DictTypeForm dictTypeForm = dictTypeService.getDictTypeForm(id);
return Result.success(dictTypeForm);
}
@Operation(summary = "新增字典类型")
@PostMapping("/types")
@PreAuthorize("@ss.hasPerm('sys:dict_type:add')")
@PreventDuplicateSubmit
public Result saveDictType(@RequestBody DictTypeForm dictTypeForm) {
boolean result = dictTypeService.saveDictType(dictTypeForm);
return Result.judge(result);
}
@Operation(summary = "修改字典类型")
@PutMapping("/types/{id}")
@PreAuthorize("@ss.hasPerm('sys:dict_type:edit')")
public Result updateDictType(@PathVariable Long id, @RequestBody DictTypeForm dictTypeForm) {
boolean status = dictTypeService.updateDictType(id, dictTypeForm);
return Result.judge(status);
}
@Operation(summary = "删除字典类型")
@DeleteMapping("/types/{ids}")
@PreAuthorize("@ss.hasPerm('sys:dict_type:delete')")
public Result deleteDictTypes(
@Parameter(description ="字典类型ID，多个以英文逗号(,)分割") @PathVariable String ids
) {
boolean result = dictTypeService.deleteDictTypes(ids);
return Result.judge(result);
}
}

9
src/main/java/com/youlai/system/controller/SysMenuController.java
View File

@@ -1,7 +1,7 @@
package com.youlai.system.controller;
import com.youlai.system.common.result.Result;
import com.youlai.system.plugin.dupsubmit.annotation.PreventDuplicateSubmit;
import com.youlai.system.plugin.norepeat.annotation.PreventRepeatSubmit;
import com.youlai.system.model.form.MenuForm;
import com.youlai.system.model.query.MenuQuery;
import com.youlai.system.model.vo.MenuVO;
@@ -10,12 +10,9 @@ import com.youlai.system.model.vo.RouteVO;
import com.youlai.system.service.SysMenuService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springdoc.core.annotations.ParameterObject;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
@@ -38,7 +35,7 @@ public class SysMenuController {
@Operation(summary = "菜单列表")
@GetMapping
public Result<List<MenuVO>> listMenus( @ParameterObject MenuQuery queryParams) {
public Result<List<MenuVO>> listMenus( MenuQuery queryParams) {
List<MenuVO> menuList = menuService.listMenus(queryParams);
return Result.success(menuList);
}
@@ -69,7 +66,7 @@ public class SysMenuController {
@Operation(summary = "新增菜单")
@PostMapping
@PreAuthorize("@ss.hasPerm('sys:menu:add')")
@PreventDuplicateSubmit
@PreventRepeatSubmit
public Result addMenu(@RequestBody MenuForm menuForm) {
boolean result = menuService.saveMenu(menuForm);
return Result.judge(result);

7
src/main/java/com/youlai/system/controller/SysRoleController.java
View File

@@ -1,7 +1,7 @@
package com.youlai.system.controller;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.youlai.system.plugin.dupsubmit.annotation.PreventDuplicateSubmit;
import com.youlai.system.plugin.norepeat.annotation.PreventRepeatSubmit;
import com.youlai.system.common.model.Option;
import com.youlai.system.common.result.PageResult;
import com.youlai.system.common.result.Result;
@@ -13,7 +13,6 @@ import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
import lombok.RequiredArgsConstructor;
import org.springdoc.core.annotations.ParameterObject;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
@@ -32,7 +31,7 @@ public class SysRoleController {
@Operation(summary = "角色分页列表")
@GetMapping("/page")
public PageResult<RolePageVO> getRolePage(
@ParameterObject RolePageQuery queryParams
RolePageQuery queryParams
) {
Page<RolePageVO> result = roleService.getRolePage(queryParams);
return PageResult.success(result);
@@ -48,7 +47,7 @@ public class SysRoleController {
@Operation(summary = "新增角色")
@PostMapping
@PreAuthorize("@ss.hasPerm('sys:role:add')")
@PreventDuplicateSubmit
@PreventRepeatSubmit
public Result addRole(@Valid @RequestBody RoleForm roleForm) {
boolean result = roleService.saveRole(roleForm);
return Result.judge(result);

7
src/main/java/com/youlai/system/controller/SysUserController.java
View File

@@ -7,7 +7,7 @@ import com.baomidou.mybatisplus.core.metadata.IPage;
import com.youlai.system.common.result.PageResult;
import com.youlai.system.common.result.Result;
import com.youlai.system.common.util.ExcelUtils;
import com.youlai.system.plugin.dupsubmit.annotation.PreventDuplicateSubmit;
import com.youlai.system.plugin.norepeat.annotation.PreventRepeatSubmit;
import com.youlai.system.plugin.easyexcel.UserImportListener;
import com.youlai.system.model.vo.UserImportVO;
import com.youlai.system.model.form.UserForm;
@@ -21,7 +21,6 @@ import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
import lombok.RequiredArgsConstructor;
import org.springdoc.core.annotations.ParameterObject;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
@@ -54,7 +53,7 @@ public class SysUserController {
@Operation(summary = "用户分页列表")
@GetMapping("/page")
public PageResult<UserPageVO> listPagedUsers(
@ParameterObject UserPageQuery queryParams
UserPageQuery queryParams
) {
IPage<UserPageVO> result = userService.listPagedUsers(queryParams);
return PageResult.success(result);
@@ -63,7 +62,7 @@ public class SysUserController {
@Operation(summary = "新增用户")
@PostMapping
@PreAuthorize("@ss.hasPerm('sys:user:add')")
@PreventDuplicateSubmit
@PreventRepeatSubmit
public Result saveUser(
@RequestBody @Valid UserForm userForm
) {

4
src/main/java/com/youlai/system/converter/DeptConverter.java
View File

@@ -14,9 +14,9 @@ import org.mapstruct.Mapper;
@Mapper(componentModel = "spring")
public interface DeptConverter {
DeptForm entity2Form(SysDept entity);
DeptForm convertToForm(SysDept entity);
DeptVO entity2Vo(SysDept entity);
SysDept form2Entity(DeptForm deptForm);
SysDept convertToEntity(DeptForm deptForm);
}

12
src/main/java/com/youlai/system/converter/DictConverter.java
View File

@@ -4,22 +4,20 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.youlai.system.model.entity.SysDict;
import com.youlai.system.model.form.DictForm;
import com.youlai.system.model.vo.DictPageVO;
import org.mapstruct.InheritInverseConfiguration;
import org.mapstruct.Mapper;
/**
* 字典数据项对象转换器
* 字典 对象转换器
*
* @author haoxr
* @author Ray Hao
* @since 2022/6/8
*/
@Mapper(componentModel = "spring")
public interface DictConverter {
Page<DictPageVO> entity2Page(Page<SysDict> page);
Page<DictPageVO> convertToPageVo(Page<SysDict> page);
DictForm entity2Form(SysDict entity);
DictForm convertToForm(SysDict entity);
@InheritInverseConfiguration(name="entity2Form")
SysDict form2Entity(DictForm entity);
SysDict convertToEntity(DictForm entity);
}

31
src/main/java/com/youlai/system/converter/DictItemConverter.java Normal file
View File

@@ -0,0 +1,31 @@
package com.youlai.system.converter;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.youlai.system.model.entity.SysDictItem;
import com.youlai.system.model.form.DictForm;
import com.youlai.system.model.vo.DictPageVO;
import org.mapstruct.InheritInverseConfiguration;
import org.mapstruct.Mapper;
import java.util.List;
/**
* 字典项 对象转换器
*
* @author Ray
* @since 2022/6/8
*/
@Mapper(componentModel = "spring")
public interface DictItemConverter {
Page<DictPageVO> convertToPageVo(Page<SysDictItem> page);
DictForm convertToForm(SysDictItem entity);
@InheritInverseConfiguration(name="convertToForm")
SysDictItem convertToEntity(DictForm entity);
DictForm.DictItem convertToDictItem(SysDictItem dictItem);
List<DictForm.DictItem> convertToDictForm(List<SysDictItem> dictItems);
}

23
src/main/java/com/youlai/system/converter/DictTypeConverter.java
View File

@@ -1,23 +0,0 @@
package com.youlai.system.converter;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.youlai.system.model.entity.SysDictType;
import com.youlai.system.model.form.DictTypeForm;
import com.youlai.system.model.vo.DictTypePageVO;
import org.mapstruct.Mapper;
/**
* 字典类型对象转换器
*
* @author haoxr
* @since 2022/6/8
*/
@Mapper(componentModel = "spring")
public interface DictTypeConverter {
Page<DictTypePageVO> entity2Page(Page<SysDictType> page);
DictTypeForm entity2Form(SysDictType entity);
SysDictType form2Entity(DictTypeForm entity);
}

6
src/main/java/com/youlai/system/converter/RoleConverter.java
View File

@@ -20,7 +20,7 @@ import java.util.List;
@Mapper(componentModel = "spring")
public interface RoleConverter {
Page<RolePageVO> entity2Page(Page<SysRole> page);
Page<RolePageVO> convertToPageVo(Page<SysRole> page);
@Mappings({
@Mapping(target = "value", source = "id"),
@@ -31,7 +31,7 @@ public interface RoleConverter {
List<Option> entities2Options(List<SysRole> roles);
SysRole form2Entity(RoleForm roleForm);
SysRole convertToEntity(RoleForm roleForm);
RoleForm entity2Form(SysRole entity);
RoleForm convertToForm(SysRole entity);
}

6
src/main/java/com/youlai/system/converter/UserConverter.java
View File

@@ -28,10 +28,10 @@ public interface UserConverter {
Page<UserPageVO> bo2PageVo(Page<UserBO> bo);
UserForm entity2Form(SysUser entity);
UserForm convertToForm(SysUser entity);
@InheritInverseConfiguration(name = "entity2Form")
SysUser form2Entity(UserForm entity);
@InheritInverseConfiguration(name = "convertToForm")
SysUser convertToEntity(UserForm entity);
@Mappings({
@Mapping(target = "userId", source = "id")

20
src/main/java/com/youlai/system/mapper/SysDictItemMapper.java Normal file
View File

@@ -0,0 +1,20 @@
package com.youlai.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.youlai.system.model.entity.SysDictItem;
import org.apache.ibatis.annotations.Mapper;
/**
* 字典项 访问层
*
* @author Ray Hao
* @since 2.9.0
*/
@Mapper
public interface SysDictItemMapper extends BaseMapper<SysDictItem> {
}

17
src/main/java/com/youlai/system/mapper/SysDictMapper.java
View File

@@ -1,12 +1,29 @@
package com.youlai.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.youlai.system.model.entity.SysDict;
import com.youlai.system.model.query.DictTypePageQuery;
import com.youlai.system.model.vo.DictPageVO;
import org.apache.ibatis.annotations.Mapper;
/**
* 字典 访问层
*
* @author Ray Hao
* @since 2.9.0
*/
@Mapper
public interface SysDictMapper extends BaseMapper<SysDict> {
/**
* 字典分页列表
*
* @param page 分页参数
* @param queryParams 查询参数
* @return
*/
Page<DictPageVO> getDictPage(Page<DictPageVO> page, DictTypePageQuery queryParams);
}

14
src/main/java/com/youlai/system/mapper/SysDictTypeMapper.java
View File

@@ -1,14 +0,0 @@
package com.youlai.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.youlai.system.model.entity.SysDictType;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface SysDictTypeMapper extends BaseMapper<SysDictType> {
}

66
src/main/java/com/youlai/system/model/bo/UserFormBO.java
View File

@@ -1,66 +0,0 @@
package com.youlai.system.model.bo;
import lombok.Data;
import java.util.List;
/**
* user表单持久化对象
*
* @author haoxr
* @since 2022/6/10
*/
@Data
public class UserFormBO {
/**
* 用户ID
*/
private Long id;
/**
* 用户名
*/
private String username;
/**
* 用户昵称
*/
private String nickname;
/**
* 手机号
*/
private String mobile;
/**
* 性别(1:男;2:女)
*/
private Integer gender;
/**
* 用户头像
*/
private String avatar;
/**
* 用户邮箱
*/
private String email;
/**
* 状态(1:启用;0:禁用)
*/
private Integer status;
/**
* 部门ID
*/
private Long deptId;
/**
* 角色ID集合
*/
private List<Long> roleIds;
}

38
src/main/java/com/youlai/system/model/entity/SysDict.java
View File

@@ -1,63 +1,41 @@
package com.youlai.system.model.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import java.io.Serializable;
import com.youlai.system.common.base.BaseEntity;
import lombok.Data;
/**
* 字典数据表
* 字典实体
*
* @author haoxr
* @since 2022/12/17
*/
@Data
public class SysDict implements Serializable {
public class SysDict extends BaseEntity {
/**
* 主键
* 主键
*/
@TableId(type = IdType.AUTO)
private Long id;
/**
* 字典类型编码
*/
private String typeCode;
/**
* 字典项名称
* 类型名称
*/
private String name;
/**
* 字典项值
* 类型编码
*/
private String value;
private String code;
/**
* 排序
*/
private Integer sort;
/**
* 状态(1:正常;0:禁用)
* 状态(0:正常;1:禁用)
*/
private Integer status;
/**
* 是否默认(1:是;0:否)
*/
private Integer defaulted;
/**
* 备注
*/
private String remark;
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}

28
src/main/java/com/youlai/system/model/entity/SysDictType.java → src/main/java/com/youlai/system/model/entity/SysDictItem.java
View File

@@ -2,35 +2,47 @@ package com.youlai.system.model.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.youlai.system.common.base.BaseEntity;
import java.io.Serializable;
import lombok.Data;
/**
* 字典类型实体
* 字典项实体
*
* @author haoxr
* @since 2022/12/17
*/
@Data
public class SysDictType extends BaseEntity {
public class SysDictItem implements Serializable {
/**
* 主键
* 主键
*/
@TableId(type = IdType.AUTO)
private Long id;
/**
* 类型名称
* 字典类ID
*/
private Long dictId;
/**
* 字典项名称
*/
private String name;
/**
* 类型编码
* 字典项值
*/
private String code;
private String value;
/**
* 状态(0:正常;1:禁用)
* 排序
*/
private Integer sort;
/**
* 状态（1-正常，0-禁用）
*/
private Integer status;

53
src/main/java/com/youlai/system/model/form/DictForm.java
View File

@@ -3,30 +3,57 @@ package com.youlai.system.model.form;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.Getter;
import lombok.Setter;
@Schema(description = "字典表单对象")
import java.util.List;
/**
* 字典表单对象
*
* @author Ray Hao
* @since 2.9.0
*/
@Schema(description = "字典")
@Data
public class DictForm {
@Schema(description="字典ID")
@Schema(description = "字典ID",example = "1")
private Long id;
@Schema(description="类型编码")
private String typeCode;
@Schema(description="字典名称")
@Schema(description = "字典名称",example = "性别")
private String name;
@Schema(description="字典值")
private String value;
@Schema(description = "字典编码", example ="gender")
private String code;
@Schema(description="状态(1:启用;0:禁用)")
@Schema(description = "字典状态（1-启用，0-禁用）", example = "1")
private Integer status;
@Schema(description="排序")
private Integer sort;
@Schema(description = "字典数据项列表",example = "[{\"id\":1,\"name\":\"男\",\"value\":\"1\",\"sort\":1,\"status\":1},{\"id\":2,\"name\":\"女\",\"value\":\"2\",\"sort\":2,\"status\":1}]")
private List<DictItem> dictItems;
@Schema(description = "字典数据项")
@Getter
@Setter
public static class DictItem {
@Schema(description = "字典ID")
private Long id;
@Schema(description = "字典名称")
private String name;
@Schema(description = "字典值")
private String value;
@Schema(description = "排序")
private Integer sort;
@Schema(description = "状态（1-启用，0-禁用）")
private Integer status;
}
@Schema(description = "字典备注")
private String remark;
}

26
src/main/java/com/youlai/system/model/form/DictTypeForm.java
View File

@@ -1,26 +0,0 @@
package com.youlai.system.model.form;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
@Schema(description = "字典类型")
@Data
public class DictTypeForm {
@Schema(description="字典类型ID")
private Long id;
@Schema(description="类型名称")
private String name;
@Schema(description="类型编码")
private String code;
@Schema(description="类型状态(1:启用;0:禁用)")
private Integer status;
@Schema(description = "备注")
private String remark;
}

2
src/main/java/com/youlai/system/model/query/DictPageQuery.java
View File

@@ -12,6 +12,6 @@ public class DictPageQuery extends BasePageQuery {
@Schema(description="关键字(字典项名称)")
private String keywords;
@Schema(description="字典类型编码")
@Schema(description="字典编码")
private String typeCode;
}

2
src/main/java/com/youlai/system/model/query/DictTypePageQuery.java
View File

@@ -5,7 +5,7 @@ import com.youlai.system.common.base.BasePageQuery;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
@Schema(description ="字典类型分页查询对象")
@Schema(description ="字典分页查询对象")
@Data
public class DictTypePageQuery extends BasePageQuery {

52
src/main/java/com/youlai/system/model/vo/DictPageVO.java
View File

@@ -2,22 +2,58 @@ package com.youlai.system.model.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.Getter;
import lombok.Setter;
@Schema(description ="字典分页对象")
@Data
import java.util.List;
/**
* 字典分页VO
*
* @author Ray
* @since 0.0.1
*/
@Schema(description = "字典分页对象")
@Getter
@Setter
public class DictPageVO {
@Schema(description="字典ID")
@Schema(description = "字典ID")
private Long id;
@Schema(description="字典名称")
@Schema(description = "字典名称")
private String name;
@Schema(description="字典值")
private String value;
@Schema(description = "字典编码")
private String code;
@Schema(description="状态(1:启用;0:禁用)")
@Schema(description = "字典状态（1-启用，0-禁用）")
private Integer status;
@Schema(description = "字典项列表")
private List<DictItem> dictItemList;
@Schema(description = "字典")
@Getter
@Setter
public static class DictItem {
@Schema(description = "字典项ID")
private Long id;
@Schema(description = "字典项名称")
private String name;
@Schema(description = "字典项值")
private String value;
@Schema(description = "排序")
private Integer sort;
@Schema(description = "状态（1-启用，0-禁用）")
private Integer status;
}
}

23
src/main/java/com/youlai/system/model/vo/DictTypePageVO.java
View File

@@ -1,23 +0,0 @@
package com.youlai.system.model.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
@Schema(description ="字典类型分页对象")
@Data
public class DictTypePageVO {
@Schema(description="字典类型ID")
private Long id;
@Schema(description="类型名称")
private String name;
@Schema(description="类型编码")
private String code;
@Schema(description="状态：1:启用;0:禁用")
private Integer status;
}

9
src/main/java/com/youlai/system/plugin/dupsubmit/annotation/PreventDuplicateSubmit.java → src/main/java/com/youlai/system/plugin/norepeat/annotation/PreventRepeatSubmit.java
View File

@@ -1,10 +1,13 @@
package com.youlai.system.plugin.dupsubmit.annotation;
package com.youlai.system.plugin.norepeat.annotation;
import java.lang.annotation.*;
/**
* 防止重复提交注解
* <p>
* 该注解用于方法上，防止在指定时间内的重复提交。
* 默认时间为5秒。
*
* @author haoxr
* @since 2.3.0
@@ -13,10 +16,10 @@ import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface PreventDuplicateSubmit {
public @interface PreventRepeatSubmit {
/**
* 防重提交锁过期时间(秒)
* 锁过期时间（秒）
* <p>
* 默认5秒内不允许重复提交
*/

14
src/main/java/com/youlai/system/plugin/dupsubmit/aspect/DuplicateSubmitAspect.java → src/main/java/com/youlai/system/plugin/norepeat/aspect/DuplicateSubmitAspect.java
View File

@@ -1,4 +1,4 @@
package com.youlai.system.plugin.dupsubmit.aspect;
package com.youlai.system.plugin.norepeat.aspect;
import cn.hutool.core.util.StrUtil;
import cn.hutool.jwt.JWTUtil;
@@ -6,7 +6,7 @@ import cn.hutool.jwt.RegisteredPayload;
import com.youlai.system.common.constant.SecurityConstants;
import com.youlai.system.common.exception.BusinessException;
import com.youlai.system.common.result.ResultCode;
import com.youlai.system.plugin.dupsubmit.annotation.PreventDuplicateSubmit;
import com.youlai.system.plugin.norepeat.annotation.PreventRepeatSubmit;
import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
@@ -41,17 +41,17 @@ public class DuplicateSubmitAspect {
/**
* 防重复提交切点
*/
@Pointcut("@annotation(preventDuplicateSubmit)")
public void preventDuplicateSubmitPointCut(PreventDuplicateSubmit preventDuplicateSubmit) {
@Pointcut("@annotation(preventRepeatSubmit)")
public void preventDuplicateSubmitPointCut(PreventRepeatSubmit preventRepeatSubmit) {
log.info("定义防重复提交切点");
}
@Around("preventDuplicateSubmitPointCut(preventDuplicateSubmit)")
public Object doAround(ProceedingJoinPoint pjp, PreventDuplicateSubmit preventDuplicateSubmit) throws Throwable {
@Around("preventDuplicateSubmitPointCut(preventRepeatSubmit)")
public Object doAround(ProceedingJoinPoint pjp, PreventRepeatSubmit preventRepeatSubmit) throws Throwable {
String resubmitLockKey = generateResubmitLockKey();
if (resubmitLockKey != null) {
int expire = preventDuplicateSubmit.expire(); // 防重提交锁过期时间
int expire = preventRepeatSubmit.expire(); // 防重提交锁过期时间
RLock lock = redissonClient.getLock(resubmitLockKey);
boolean lockResult = lock.tryLock(0, expire, TimeUnit.SECONDS); // 获取锁失败，直接返回 false
if (!lockResult) {

69
src/main/java/com/youlai/system/service/SysDictItemService.java Normal file
View File

@@ -0,0 +1,69 @@
package com.youlai.system.service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.youlai.system.model.entity.SysDictItem;
import com.youlai.system.model.form.DictForm;
import com.youlai.system.model.query.DictPageQuery;
import com.youlai.system.model.vo.DictPageVO;
import com.youlai.system.common.model.Option;
import java.util.List;
/**
* 字典接口
*
* @author haoxr
* @since 2023/3/4
*/
public interface SysDictItemService extends IService<SysDictItem> {
/**
* 字典数据项分页列表
*
* @param queryParams
* @return
*/
Page<DictPageVO> getDictPage(DictPageQuery queryParams);
/**
* 字典数据项表单
*
* @param id 字典数据项ID
* @return
*/
DictForm getDictForm(Long id);
/**
* 新增字典数据项
*
* @param dictForm 字典数据项表单
* @return
*/
boolean saveDict(DictForm dictForm);
/**
* 修改字典数据项
*
* @param id 字典数据项ID
* @param dictForm 字典数据项表单
* @return
*/
boolean updateDict(Long id, DictForm dictForm);
/**
* 删除字典数据项
*
* @param idsStr 字典数据项ID，多个以英文逗号(,)分割
* @return
*/
boolean deleteDict(String idsStr);
/**
* 获取字典下拉列表
*
* @param typeCode
* @return
*/
List<Option> listDictOptions(String typeCode);
}

52
src/main/java/com/youlai/system/service/SysDictService.java
View File

@@ -2,68 +2,74 @@ package com.youlai.system.service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.youlai.system.common.model.Option;
import com.youlai.system.model.entity.SysDict;
import com.youlai.system.model.form.DictForm;
import com.youlai.system.model.query.DictPageQuery;
import com.youlai.system.model.query.DictTypePageQuery;
import com.youlai.system.model.vo.DictPageVO;
import com.youlai.system.common.model.Option;
import java.util.List;
/**
* 字典接口
* 数据字典业务接口
*
* @author haoxr
* @since 2023/3/4
* @since 2022/10/12
*/
public interface SysDictService extends IService<SysDict> {
/**
* 字典数据项分页列表
*
* @param queryParams
* @return
*/
Page<DictPageVO> getDictPage(DictPageQuery queryParams);
/**
* 字典数据项表单
* 字典分页列表
*
* @param id 字典数据项ID
* @param queryParams 分页查询对象
* @return
*/
Page<DictPageVO> getDictPage(DictTypePageQuery queryParams);
/**
* 获取字典表单详情
*
* @param id 字典ID
* @return
*/
DictForm getDictForm(Long id);
/**
* 新增字典数据项
* 新增字典
*
* @param dictForm 字典数据项表单
* @param dictForm 字典表单
* @return
*/
boolean saveDict(DictForm dictForm);
/**
* 修改字典数据项
* 修改字典
*
* @param id 字典数据项ID
* @param dictForm 字典数据项表单
* @param id
* @param dictForm 字典表单
* @return
*/
boolean updateDict(Long id, DictForm dictForm);
/**
* 删除字典数据项
* 删除字典
*
* @param idsStr 字典数据项ID，多个以英文逗号(,)分割
* @param idsStr 字典ID，多个以英文逗号(,)分割
* @return
*/
boolean deleteDict(String idsStr);
boolean deleteDictByIds(String idsStr);
/**
* 获取字典下拉列表
* 获取字典的数据项
*
* @param typeCode
* @return
*/
List<Option> listDictOptions(String typeCode);
List<Option> listDictItemsByTypeCode(String typeCode);
}

73
src/main/java/com/youlai/system/service/SysDictTypeService.java
View File

@@ -1,73 +0,0 @@
package com.youlai.system.service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.youlai.system.common.model.Option;
import com.youlai.system.model.entity.SysDictType;
import com.youlai.system.model.form.DictTypeForm;
import com.youlai.system.model.query.DictTypePageQuery;
import com.youlai.system.model.vo.DictTypePageVO;
import java.util.List;
/**
* 数据字典类型业务接口
*
* @author haoxr
* @since 2022/10/12
*/
public interface SysDictTypeService extends IService<SysDictType> {
/**
* 字典类型分页列表
*
* @param queryParams 分页查询对象
* @return
*/
Page<DictTypePageVO> getDictTypePage(DictTypePageQuery queryParams);
/**
* 获取字典类型表单详情
*
* @param id 字典类型ID
* @return
*/
DictTypeForm getDictTypeForm(Long id);
/**
* 新增字典类型
*
* @param dictTypeForm 字典类型表单
* @return
*/
boolean saveDictType(DictTypeForm dictTypeForm);
/**
* 修改字典类型
*
* @param id
* @param dictTypeForm 字典类型表单
* @return
*/
boolean updateDictType(Long id, DictTypeForm dictTypeForm);
/**
* 删除字典类型
*
* @param idsStr 字典类型ID，多个以英文逗号(,)分割
* @return
*/
boolean deleteDictTypes(String idsStr);
/**
* 获取字典类型的数据项
*
* @param typeCode
* @return
*/
List<Option> listDictItemsByTypeCode(String typeCode);
}

6
src/main/java/com/youlai/system/service/impl/SysDeptServiceImpl.java
View File

@@ -141,7 +141,7 @@ public class SysDeptServiceImpl extends ServiceImpl<SysDeptMapper, SysDept> impl
Assert.isTrue(count == 0, "部门名称已存在");
// form->entity
SysDept entity = deptConverter.form2Entity(formData);
SysDept entity = deptConverter.convertToEntity(formData);
// 生成部门路径(tree_path)，格式：父节点tree_path + , + 父节点ID，用于删除部门时级联删除子部门
String treePath = generateDeptTreePath(formData.getParentId());
@@ -172,7 +172,7 @@ public class SysDeptServiceImpl extends ServiceImpl<SysDeptMapper, SysDept> impl
Assert.isTrue(count == 0, "部门名称已存在");
// form->entity
SysDept entity = deptConverter.form2Entity(formData);
SysDept entity = deptConverter.convertToEntity(formData);
entity.setId(deptId);
// 生成部门路径(tree_path)，格式：父节点tree_path + , + 父节点ID，用于删除部门时级联删除子部门
@@ -249,7 +249,7 @@ public class SysDeptServiceImpl extends ServiceImpl<SysDeptMapper, SysDept> impl
SysDept::getSort
));
return deptConverter.entity2Form(entity);
return deptConverter.convertToForm(entity);
}

165
src/main/java/com/youlai/system/service/impl/SysDictItemServiceImpl.java Normal file
View File

@@ -0,0 +1,165 @@
package com.youlai.system.service.impl;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.youlai.system.converter.DictItemConverter;
import com.youlai.system.mapper.SysDictItemMapper;
import com.youlai.system.model.entity.SysDictItem;
import com.youlai.system.model.form.DictForm;
import com.youlai.system.model.query.DictPageQuery;
import com.youlai.system.model.vo.DictPageVO;
import com.youlai.system.common.model.Option;
import com.youlai.system.service.SysDictItemService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* 数据字典 服务实现类
*
* @author haoxr
* @since 2022/10/12
*/
@Service
@RequiredArgsConstructor
public class SysDictItemServiceImpl extends ServiceImpl<SysDictItemMapper, SysDictItem> implements SysDictItemService {
private final DictItemConverter dictConverter;
/**
* 字典数据项分页列表
*
* @param queryParams
* @return
*/
@Override
public Page<DictPageVO> getDictPage(DictPageQuery queryParams) {
// 查询参数
int pageNum = queryParams.getPageNum();
int pageSize = queryParams.getPageSize();
String keywords = queryParams.getKeywords();
String typeCode = queryParams.getTypeCode();
// 查询数据
Page<SysDictItem> dictItemPage = this.page(
new Page<>(pageNum, pageSize),
new LambdaQueryWrapper<SysDictItem>()
.like(StrUtil.isNotBlank(keywords), SysDictItem::getName, keywords)
.eq(StrUtil.isNotBlank(typeCode), SysDictItem::getTypeCode, typeCode)
.select(SysDictItem::getId, SysDictItem::getName, SysDictItem::getValue, SysDictItem::getStatus)
);
// 实体转换
Page<DictPageVO> pageResult = dictConverter.convertToPageVo(dictItemPage);
return pageResult;
}
/**
* 字典数据项表单详情
*
* @param id 字典数据项ID
* @return
*/
@Override
public DictForm getDictForm(Long id) {
// 获取entity
SysDictItem entity = this.getOne(new LambdaQueryWrapper<SysDictItem>()
.eq(SysDictItem::getId, id)
.select(
SysDictItem::getId,
SysDictItem::getTypeCode,
SysDictItem::getName,
SysDictItem::getValue,
SysDictItem::getStatus,
SysDictItem::getSort,
SysDictItem::getRemark
));
Assert.isTrue(entity != null, "字典数据项不存在");
// 实体转换
DictForm dictForm = dictConverter.convertToForm(entity);
return dictForm;
}
/**
* 新增字典数据项
*
* @param dictForm 字典数据项表单
* @return
*/
@Override
public boolean saveDict(DictForm dictForm) {
// 实体对象转换 form->entity
SysDictItem entity = dictConverter.convertToEntity(dictForm);
// 持久化
boolean result = this.save(entity);
return result;
}
/**
* 修改字典数据项
*
* @param id 字典数据项ID
* @param dictForm 字典数据项表单
* @return
*/
@Override
public boolean updateDict(Long id, DictForm dictForm) {
SysDictItem entity = dictConverter.convertToEntity(dictForm);
boolean result = this.updateById(entity);
return result;
}
/**
* 删除字典数据项
*
* @param idsStr 字典数据项ID，多个以英文逗号(,)分割
* @return
*/
@Override
public boolean deleteDict(String idsStr) {
Assert.isTrue(StrUtil.isNotBlank(idsStr), "删除数据为空");
//
List<Long> ids = Arrays.asList(idsStr.split(","))
.stream()
.map(id -> Long.parseLong(id))
.collect(Collectors.toList());
// 删除字典数据项
boolean result = this.removeByIds(ids);
return result;
}
/**
* 获取字典下拉列表
*
* @param typeCode
* @return
*/
@Override
public List<Option> listDictOptions(String typeCode) {
// 数据字典项
List<SysDictItem> dictList = this.list(new LambdaQueryWrapper<SysDictItem>()
.eq(SysDictItem::getTypeCode, typeCode)
.select(SysDictItem::getValue, SysDictItem::getName)
);
// 转换下拉数据
List<Option> options = CollectionUtil.emptyIfNull(dictList)
.stream()
.map(dictItem -> new Option(dictItem.getValue(), dictItem.getName()))
.collect(Collectors.toList());
return options;
}
}

205
src/main/java/com/youlai/system/service/impl/SysDictServiceImpl.java
View File

@@ -4,25 +4,29 @@ import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.youlai.system.converter.DictConverter;
import com.youlai.system.mapper.SysDictMapper;
import com.youlai.system.converter.DictItemConverter;
import com.youlai.system.model.entity.SysDict;
import com.youlai.system.model.form.DictForm;
import com.youlai.system.model.query.DictPageQuery;
import com.youlai.system.model.vo.DictPageVO;
import com.youlai.system.model.entity.SysDictItem;
import com.youlai.system.common.model.Option;
import com.youlai.system.mapper.SysDictMapper;
import com.youlai.system.model.form.DictForm;
import com.youlai.system.model.query.DictTypePageQuery;
import com.youlai.system.model.vo.DictPageVO;
import com.youlai.system.service.SysDictItemService;
import com.youlai.system.service.SysDictService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Arrays;
import java.util.List;
import java.util.*;
import java.util.stream.Collectors;
/**
* 数据字典项业务实现类
* 数据字典业务实现类
*
* @author haoxr
* @since 2022/10/12
@@ -31,133 +35,186 @@ import java.util.stream.Collectors;
@RequiredArgsConstructor
public class SysDictServiceImpl extends ServiceImpl<SysDictMapper, SysDict> implements SysDictService {
private final SysDictItemService dictItemService;
private final DictConverter dictConverter;
private final DictItemConverter dictItemConverter;
/**
* 字典数据项分页列表
* 字典分页列表
*
* @param queryParams
* @param queryParams 分页查询对象
* @return
*/
@Override
public Page<DictPageVO> getDictPage(DictPageQuery queryParams) {
public Page<DictPageVO> getDictPage(DictTypePageQuery queryParams) {
// 查询参数
int pageNum = queryParams.getPageNum();
int pageSize = queryParams.getPageSize();
String keywords = queryParams.getKeywords();
String typeCode = queryParams.getTypeCode();
// 查询数据
Page<SysDict> dictItemPage = this.page(
new Page<>(pageNum, pageSize),
new LambdaQueryWrapper<SysDict>()
.like(StrUtil.isNotBlank(keywords), SysDict::getName, keywords)
.eq(StrUtil.isNotBlank(typeCode), SysDict::getTypeCode, typeCode)
.select(SysDict::getId, SysDict::getName, SysDict::getValue, SysDict::getStatus)
);
// 实体转换
Page<DictPageVO> pageResult = dictConverter.entity2Page(dictItemPage);
return pageResult;
return this.baseMapper.getDictPage(new Page<>(pageNum, pageSize), queryParams);
}
/**
* 字典数据项表单详情
*
* @param id 字典数据项ID
* @return
*/
@Override
public DictForm getDictForm(Long id) {
// 获取entity
SysDict entity = this.getOne(new LambdaQueryWrapper<SysDict>()
.eq(SysDict::getId, id)
.select(
SysDict::getId,
SysDict::getTypeCode,
SysDict::getName,
SysDict::getValue,
SysDict::getStatus,
SysDict::getSort,
SysDict::getRemark
));
Assert.isTrue(entity != null, "字典数据项不存在");
// 实体转换
DictForm dictForm = dictConverter.entity2Form(entity);
return dictForm;
}
/**
* 新增字典数据项
* 新增字典
*
* @param dictForm 字典数据项表单
* @param dictForm 字典表单数据
* @return
*/
@Override
public boolean saveDict(DictForm dictForm) {
// 实体对象转换 form->entity
SysDict entity = dictConverter.form2Entity(dictForm);
// 持久化
// 保存字典
SysDict entity = dictConverter.convertToEntity(dictForm);
boolean result = this.save(entity);
// 保存字典项
if (result) {
List<SysDictItem> dictItems = dictItemConverter.convertToEntity(dictForm.getDictItems());
dictItems.forEach(dictItem -> dictItem.setDictId(entity.getId()));
dictItemService.saveBatch(dictItems);
}
return result;
}
/**
* 修改字典数据项
* 获取字典表单详情
*
* @param id 字典数据项ID
* @param dictForm 字典数据项表单
* @param id 字典ID
* @return
*/
@Override
public DictForm getDictForm(Long id) {
// 获取字典
SysDict entity = this.getById(id);
Assert.isTrue(entity != null, "字典不存在");
DictForm dictForm = dictConverter.convertToForm(entity);
// 获取字典项集合
List<SysDictItem> dictItems = dictItemService.list(new LambdaQueryWrapper<SysDictItem>()
.eq(SysDictItem::getDictId, id)
);
// 转换数据项
List<DictForm.DictItem> dictItemList = dictItemConverter.convertToDictForm(dictItems);
dictForm.setDictItems(dictItemList);
return dictForm;
}
/**
* 修改字典
*
* @param id 字典ID
* @param dictForm 字典表单
* @return
*/
@Override
public boolean updateDict(Long id, DictForm dictForm) {
SysDict entity = dictConverter.form2Entity(dictForm);
// 更新字典
SysDict entity = dictConverter.convertToEntity(dictForm);
boolean result = this.updateById(entity);
if (result) {
// 更新字典项
List<AttrGroupForm.Attr> attrList = formData.getAttrs();
List<Attr> attrEntities = attrConverter.convertToEntity(attrList);
// 获取当前组的所有属性
List<Attr> currentAttrEntities = attrService.list(new LambdaQueryWrapper<Attr>()
.eq(Attr::getAttrGroupId, groupId)
);
// 获取当前数据库中存在的属性ID集合
Set<Long> currentAttrIds = currentAttrEntities.stream()
.map(Attr::getId)
.collect(Collectors.toSet());
// 获取新提交的属性ID集合
Set<Long> newAttrIds = attrEntities.stream()
.map(Attr::getId)
.filter(Objects::nonNull)
.collect(Collectors.toSet());
// 需要删除的属性ID集合（存在于数据库但不在新提交的属性中）
Set<Long> idsToDelete = new HashSet<>(currentAttrIds);
idsToDelete.removeAll(newAttrIds);
// 删除不在新提交属性中的旧属性
if (!idsToDelete.isEmpty()) {
attrService.removeByIds(idsToDelete);
}
// 更新或新增属性
for (Attr attr : attrEntities) {
if (attr.getId() != null && currentAttrIds.contains(attr.getId())) {
// 更新现有属性
attrService.updateById(attr);
} else {
// 新增属性
attr.setAttrGroupId(groupId);
attrService.save(attr);
}
}
}
return result;
}
/**
* 删除字典数据项
* 删除字典
*
* @param idsStr 字典数据项ID，多个以英文逗号(,)分割
* @param ids 字典ID，多个以英文逗号(,)分割
* @return
*/
@Override
public boolean deleteDict(String idsStr) {
Assert.isTrue(StrUtil.isNotBlank(idsStr), "删除数据为空");
//
List<Long> ids = Arrays.asList(idsStr.split(","))
.stream()
.map(id -> Long.parseLong(id))
.collect(Collectors.toList());
@Transactional
public boolean deleteDictByIds(String ids) {
Assert.isTrue(StrUtil.isNotBlank(ids), "请选择需要删除的字典");
List<String> idList = Arrays.stream(ids.split(","))
.toList();
// 删除字典数据项
boolean result = this.removeByIds(ids);
List<String> dictTypeCodes = this.list(new LambdaQueryWrapper<SysDict>()
.in(SysDict::getId, ids)
.select(SysDict::getCode))
.stream()
.map(dictType -> dictType.getCode())
.collect(Collectors.toList()
);
if (CollectionUtil.isNotEmpty(dictTypeCodes)) {
dictItemService.remove(new LambdaQueryWrapper<SysDictItem>()
.in(SysDictItem::getTypeCode, dictTypeCodes));
}
// 删除字典
boolean result = this.removeByIds(idList);
return result;
}
/**
* 获取字典下拉列表
* 获取字典的数据项
*
* @param typeCode
* @return
*/
@Override
public List<Option> listDictOptions(String typeCode) {
public List<Option> listDictItemsByTypeCode(String typeCode) {
// 数据字典项
List<SysDict> dictList = this.list(new LambdaQueryWrapper<SysDict>()
.eq(SysDict::getTypeCode, typeCode)
.select(SysDict::getValue, SysDict::getName)
List<SysDictItem> dictItems = dictItemService.list(new LambdaQueryWrapper<SysDictItem>()
.eq(SysDictItem::getTypeCode, typeCode)
.select(SysDictItem::getValue, SysDictItem::getName)
);
// 转换下拉数据
List<Option> options = CollectionUtil.emptyIfNull(dictList)
List<Option> options = CollectionUtil.emptyIfNull(dictItems)
.stream()
.map(dictItem -> new Option(dictItem.getValue(), dictItem.getName()))
.collect(Collectors.toList());
return options;
}
}

206
src/main/java/com/youlai/system/service/impl/SysDictTypeServiceImpl.java
View File

@@ -1,206 +0,0 @@
package com.youlai.system.service.impl;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.youlai.system.model.entity.SysDict;
import com.youlai.system.common.model.Option;
import com.youlai.system.converter.DictTypeConverter;
import com.youlai.system.mapper.SysDictTypeMapper;
import com.youlai.system.model.entity.SysDictType;
import com.youlai.system.model.form.DictTypeForm;
import com.youlai.system.model.query.DictTypePageQuery;
import com.youlai.system.model.vo.DictTypePageVO;
import com.youlai.system.service.SysDictService;
import com.youlai.system.service.SysDictTypeService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* 数据字典类型业务实现类
*
* @author haoxr
* @since 2022/10/12
*/
@Service
@RequiredArgsConstructor
public class SysDictTypeServiceImpl extends ServiceImpl<SysDictTypeMapper, SysDictType> implements SysDictTypeService {
private final SysDictService dictItemService;
private final DictTypeConverter dictTypeConverter;
/**
* 字典分页列表
*
* @param queryParams 分页查询对象
* @return
*/
@Override
public Page<DictTypePageVO> getDictTypePage(DictTypePageQuery queryParams) {
// 查询参数
int pageNum = queryParams.getPageNum();
int pageSize = queryParams.getPageSize();
String keywords = queryParams.getKeywords();
// 查询数据
Page<SysDictType> dictTypePage = this.page(
new Page<>(pageNum, pageSize),
new LambdaQueryWrapper<SysDictType>()
.like(StrUtil.isNotBlank(keywords), SysDictType::getName, keywords)
.or()
.like(StrUtil.isNotBlank(keywords), SysDictType::getCode, keywords)
.select(
SysDictType::getId,
SysDictType::getName,
SysDictType::getCode,
SysDictType::getStatus,
SysDictType::getRemark
)
);
// 实体转换
Page<DictTypePageVO> pageResult = dictTypeConverter.entity2Page(dictTypePage);
return pageResult;
}
/**
* 获取字典类型表单详情
*
* @param id 字典类型ID
* @return
*/
@Override
public DictTypeForm getDictTypeForm(Long id) {
// 获取entity
SysDictType entity = this.getOne(new LambdaQueryWrapper<SysDictType>()
.eq(SysDictType::getId, id)
.select(
SysDictType::getId,
SysDictType::getName,
SysDictType::getCode,
SysDictType::getStatus,
SysDictType::getRemark
));
Assert.isTrue(entity != null, "字典类型不存在");
// 实体转换
DictTypeForm dictTypeForm = dictTypeConverter.entity2Form(entity);
return dictTypeForm;
}
/**
* 新增字典类型
*
* @param dictTypeForm
* @return
*/
@Override
public boolean saveDictType(DictTypeForm dictTypeForm) {
// 实体对象转换 form->entity
SysDictType entity = dictTypeConverter.form2Entity(dictTypeForm);
// 持久化
boolean result = this.save(entity);
return result;
}
/**
* 修改字典类型
*
* @param id 字典类型ID
* @param dictTypeForm 字典类型表单
* @return
*/
@Override
public boolean updateDictType(Long id, DictTypeForm dictTypeForm) {
// 获取字典类型
SysDictType sysDictType = this.getById(id);
Assert.isTrue(sysDictType != null, "字典类型不存在");
SysDictType entity = dictTypeConverter.form2Entity(dictTypeForm);
boolean result = this.updateById(entity);
if (result) {
// 字典类型code变化，同步修改字典项的类型code
String oldCode = sysDictType.getCode();
String newCode = dictTypeForm.getCode();
if (!StrUtil.equals(oldCode, newCode)) {
dictItemService.update(new LambdaUpdateWrapper<SysDict>()
.eq(SysDict::getTypeCode, oldCode)
.set(SysDict::getTypeCode, newCode)
);
}
}
return result;
}
/**
* 删除字典类型
*
* @param idsStr 字典类型ID，多个以英文逗号(,)分割
* @return
*/
@Override
@Transactional
public boolean deleteDictTypes(String idsStr) {
Assert.isTrue(StrUtil.isNotBlank(idsStr), "删除数据为空");
List ids = Arrays.asList(idsStr.split(","))
.stream()
.collect(Collectors.toList());
// 删除字典数据项
List<String> dictTypeCodes = this.list(new LambdaQueryWrapper<SysDictType>()
.in(SysDictType::getId, ids)
.select(SysDictType::getCode))
.stream()
.map(dictType -> dictType.getCode())
.collect(Collectors.toList()
);
if (CollectionUtil.isNotEmpty(dictTypeCodes)) {
dictItemService.remove(new LambdaQueryWrapper<SysDict>()
.in(SysDict::getTypeCode, dictTypeCodes));
}
// 删除字典类型
boolean result = this.removeByIds(ids);
return result;
}
/**
* 获取字典类型的数据项
*
* @param typeCode
* @return
*/
@Override
public List<Option> listDictItemsByTypeCode(String typeCode) {
// 数据字典项
List<SysDict> dictItems = dictItemService.list(new LambdaQueryWrapper<SysDict>()
.eq(SysDict::getTypeCode, typeCode)
.select(SysDict::getValue, SysDict::getName)
);
// 转换下拉数据
List<Option> options = CollectionUtil.emptyIfNull(dictItems)
.stream()
.map(dictItem -> new Option(dictItem.getValue(), dictItem.getName()))
.collect(Collectors.toList());
return options;
}
}

3
src/main/java/com/youlai/system/service/impl/SysRoleMenuServiceImpl.java
View File

@@ -9,6 +9,7 @@ import com.youlai.system.model.entity.SysRoleMenu;
import com.youlai.system.service.SysRoleMenuService;
import jakarta.annotation.PostConstruct;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
@@ -24,6 +25,7 @@ import java.util.Set;
*/
@Service
@RequiredArgsConstructor
@Slf4j
public class SysRoleMenuServiceImpl extends ServiceImpl<SysRoleMenuMapper, SysRoleMenu> implements SysRoleMenuService {
private final RedisTemplate<String, Object> redisTemplate;
@@ -33,6 +35,7 @@ public class SysRoleMenuServiceImpl extends ServiceImpl<SysRoleMenuMapper, SysRo
*/
@PostConstruct
public void initRolePermsCache() {
log.info("初始化权限缓存... ");
refreshRolePermsCache();
}

6
src/main/java/com/youlai/system/service/impl/SysRoleServiceImpl.java
View File

@@ -70,7 +70,7 @@ public class SysRoleServiceImpl extends ServiceImpl<SysRoleMapper, SysRole> impl
);
// 实体转换
return roleConverter.entity2Page(rolePage);
return roleConverter.convertToPageVo(rolePage);
}
/**
@@ -118,7 +118,7 @@ public class SysRoleServiceImpl extends ServiceImpl<SysRoleMapper, SysRole> impl
Assert.isTrue(count == 0, "角色名称或角色编码已存在，请修改后重试！");
// 实体转换
SysRole role = roleConverter.form2Entity(roleForm);
SysRole role = roleConverter.convertToEntity(roleForm);
boolean result = this.saveOrUpdate(role);
if (result) {
@@ -143,7 +143,7 @@ public class SysRoleServiceImpl extends ServiceImpl<SysRoleMapper, SysRole> impl
@Override
public RoleForm getRoleForm(Long roleId) {
SysRole entity = this.getById(roleId);
return roleConverter.entity2Form(entity);
return roleConverter.convertToForm(entity);
}
/**

4
src/main/java/com/youlai/system/service/impl/SysUserServiceImpl.java
View File

@@ -105,7 +105,7 @@ public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> impl
Assert.isTrue(count == 0, "用户名已存在");
// 实体转换 form->entity
SysUser entity = userConverter.form2Entity(userForm);
SysUser entity = userConverter.convertToEntity(userForm);
// 设置默认加密密码
String defaultEncryptPwd = passwordEncoder.encode(SystemConstants.DEFAULT_PASSWORD);
@@ -141,7 +141,7 @@ public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> impl
Assert.isTrue(count == 0, "用户名已存在");
// form -> entity
SysUser entity = userConverter.form2Entity(userForm);
SysUser entity = userConverter.convertToEntity(userForm);
// 修改用户
boolean result = this.updateById(entity);