2024-1-4 字典表

src/main/java/com/spring/modules/sys/controller/DictDataController.java

@@ -0,0 +1,190 @@
+package com.spring.modules.sys.controller;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.spring.common.utils.R;
+import com.spring.modules.sys.entity.DictData;
+import com.spring.modules.sys.entity.DictType;
+import com.spring.modules.sys.service.DictDataService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.util.StringUtils;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/sys/dictData")
+public class DictDataController {
+    @Autowired
+    private DictDataService dictDataService;
+
+    /**
+     * 新增字典数据
+     * @param dictData
+     * author           zelian_wu
+     * date             2024-1-3
+     * @return
+     */
+    @PostMapping("/save")
+    public R saveDictData(@RequestBody DictData dictData){
+        if (Objects.isNull(dictData)){
+            throw new RuntimeException("字典数据为空");
+        }
+        if (StringUtils.hasText(dictData.getIsDefault()) && dictData.getIsDefault().equals("Y")){
+            List<DictData> list = dictDataService.list(new LambdaQueryWrapper<DictData>().eq(DictData::getDictType, dictData.getDictType()).eq(DictData::getSite, dictData.getSite()).eq(DictData::getIsDefault,"Y"));
+            if (null != list && !list.isEmpty()){
+                throw new RuntimeException("当前字典已存在默认值");
+            }
+        }
+        if (dictDataService.save(dictData)) {
+            return R.ok("保存成功!");
+        }
+        return R.error("保存失败!");
+    }
+
+    /**
+     * 删除字典数据
+     * @param dictData
+     * author           zelian_wu
+     * date             2024-1-3
+     * @return
+     */
+    @PostMapping("/remove")
+    public R removeDictData(@RequestBody DictData dictData){
+        if (Objects.isNull(dictData)||Objects.isNull(dictData.getDictCode())){
+            throw new RuntimeException("字典数据为空");
+        }
+        if (dictDataService.lambdaUpdate().set(DictData::getStatus,"N").eq(DictData::getDictCode,dictData.getDictCode()).update()) {
+            return R.ok("操作成功!");
+        }
+        return R.error("操作失败");
+    }
+    /**
+     * 删除字典数据
+     * @param dictData
+     * author           zelian_wu
+     * date             2024-1-3
+     * @return
+     */
+    @PostMapping("/del")
+    public R delDictData(@RequestBody DictData dictData){
+        if (Objects.isNull(dictData)||Objects.isNull(dictData.getDictCode())){
+            throw new RuntimeException("字典数据为空");
+        }
+        if (dictDataService.removeById(dictData.getDictCode())) {
+            return R.ok("操作成功!");
+        }
+        return R.error("操作失败");
+    }
+    /**
+     * 批量删除字典数据
+     * @param dictDataList
+     * author           zelian_wu
+     * date             2024-1-4
+     * @return
+     */
+    @PostMapping("/delBatch")
+    public R delBatchDictData(@RequestBody List<DictData> dictDataList){
+        if (Objects.isNull(dictDataList)||dictDataList.isEmpty()){
+            throw new RuntimeException("未勾选字典数据");
+        }
+        List<Long> codes = dictDataList.stream().map(dictData -> {
+            if (Objects.isNull(dictData.getDictCode())) {
+                throw new RuntimeException("勾选字典数据中,存在空值");
+            }
+            return dictData.getDictCode();
+        }).collect(Collectors.toList());
+        if (dictDataService.removeByIds(codes)){
+            return R.ok("操作成功!");
+        }
+        return R.error("操作失败");
+    }
+
+    /**
+     * 修改字典数据
+     * @param dictData
+     * author           zelian_wu
+     * date             2024-1-3
+     * @return
+     */
+    @PostMapping("/update")
+    public R updateDictData(@RequestBody DictData dictData){
+        if (Objects.isNull(dictData)||Objects.isNull(dictData.getDictCode())){
+            throw new RuntimeException("字典数据为空");
+        }
+        if (StringUtils.hasText(dictData.getIsDefault()) && dictData.getIsDefault().equals("Y")){
+            List<DictData> list = dictDataService.list(new LambdaQueryWrapper<DictData>().eq(DictData::getDictType, dictData.getDictType()).eq(DictData::getSite, dictData.getSite()).eq(DictData::getIsDefault,"Y"));
+            if (null != list && !list.isEmpty()){
+                throw new RuntimeException("当前字典已存在默认值");
+            }
+        }
+        if (dictDataService.updateById(dictData)) {
+            return R.ok("保存成功!");
+        }
+        return R.error("保存失败!");
+    }
+
+    /**
+     * 分页查询 字典数据
+     * @param no        当前页
+     * @param size      每页条数
+     * @param site      工厂编码
+     * @param dictType  字典类型
+     * @param dictLabel 字典标签
+     * @param status    状态
+     * author           zelian_wu
+     * date             2024-1-3
+     * @return
+     */
+    @GetMapping("/{no}/{size}")
+    public R selectDictDataPage(@PathVariable Integer no,
+                                @PathVariable Integer size,
+                                String site,
+                                String dictType,
+                                String dictLabel,
+                                String status){
+        if (!StringUtils.hasText(site)){
+            throw new RuntimeException("工厂编码为空!");
+        }
+        LambdaQueryWrapper<DictData> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(DictData::getSite,site);
+        if (StringUtils.hasText(dictType)){
+            wrapper.eq(DictData::getDictType,dictType);
+        }
+        if (StringUtils.hasText(dictLabel)){
+            wrapper.eq(DictData::getDictLabel,dictLabel);
+        }
+        if (StringUtils.hasText(status)){
+            wrapper.eq(DictData::getStatus,status);
+        }
+        wrapper.orderByAsc(DictData::getDictSort);
+        Page<DictData> page = dictDataService.page(new Page<DictData>(no, size), wrapper);
+        return R.ok().put("rows",page.getRecords()).put("total",page.getTotal());
+    }
+
+    /**
+     * 查询 字典数据
+     * @param site      工厂编码
+     * @param dictType  字典类型
+     * author           zelian_wu
+     * date             2024-1-4
+     * @return
+     */
+    @GetMapping("/list")
+    public R selectDictDataList(String site,String dictType){
+        if (!StringUtils.hasText(site)){
+            throw new RuntimeException("工厂编码为空!");
+        }
+        if (!StringUtils.hasText(dictType)){
+            throw new RuntimeException("字典类型为空!");
+        }
+        LambdaQueryWrapper<DictData> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(DictData::getSite,site);
+        wrapper.eq(DictData::getDictType,dictType);
+        wrapper.orderByAsc(DictData::getDictSort);
+        return R.ok().put("rows",dictDataService.list(wrapper));
+    }
+}

src/main/java/com/spring/modules/sys/controller/DictTypeController.java

@@ -0,0 +1,176 @@
+package com.spring.modules.sys.controller;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.spring.common.utils.R;
+import com.spring.modules.sys.entity.DictData;
+import com.spring.modules.sys.entity.DictType;
+import com.spring.modules.sys.service.DictTypeService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.util.StringUtils;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/sys/dictType")
+public class DictTypeController {
+    @Autowired
+    private DictTypeService dictTypeService;
+
+    /**
+     * 新增字典类型
+     * @param dictType
+     * author           zelian_wu
+     * date             2024-1-3
+     * @return
+     */
+    @PostMapping("/save")
+    public R saveDictType(@RequestBody DictType dictType){
+        if (Objects.isNull(dictType)){
+            throw new RuntimeException("字典编码为空");
+        }
+        if (dictTypeService.save(dictType)) {
+            return R.ok("保存成功!");
+        }
+        return R.error("保持失败");
+    }
+
+    /**
+     * 删除字典类型
+     * @param dictType
+     * author           zelian_wu
+     * date             2024-1-3
+     * @return
+     */
+    @PostMapping("/remove")
+    public R removeDictType(@RequestBody DictType dictType){
+        if (Objects.isNull(dictType)||Objects.isNull(dictType.getDictId())){
+            throw new RuntimeException("字典编码为空");
+        }
+        if (dictTypeService.lambdaUpdate().set(DictType::getStatus,"N").eq(DictType::getDictId,dictType.getDictId()).update()) {
+            return R.ok("操作成功!");
+        }
+        return R.error("操作失败");
+    }
+    /**
+     * 删除字典类型
+     * @param dictType
+     * author           zelian_wu
+     * date             2024-1-4
+     * @return
+     */
+    @PostMapping("/del")
+    public R delDictType(@RequestBody DictType dictType){
+        if (Objects.isNull(dictType)||Objects.isNull(dictType.getDictId())){
+            throw new RuntimeException("字典编码为空");
+        }
+        if (dictTypeService.removeById(dictType.getDictId())) {
+            return R.ok("操作成功!");
+        }
+        return R.error("操作失败");
+    }
+    /**
+     * 批量删除字典类型
+     * @param dictTypeList
+     * author           zelian_wu
+     * date             2024-1-4
+     * @return
+     */
+    @PostMapping("/delBatch")
+    public R delBatchDictData(@RequestBody List<DictType> dictTypeList){
+        if (Objects.isNull(dictTypeList)||dictTypeList.isEmpty()){
+            throw new RuntimeException("未勾选字典类型");
+        }
+        List<Long> ids = dictTypeList.stream().map(dictData -> {
+            if (Objects.isNull(dictData.getDictId())) {
+                throw new RuntimeException("勾选字典类型中,存在空值");
+            }
+            return dictData.getDictId();
+        }).collect(Collectors.toList());
+        if (dictTypeService.removeByIds(ids)){
+            return R.ok("操作成功!");
+        }
+        return R.error("操作失败");
+    }
+
+    /**
+     * 修改子弹类型
+     * @param dictType
+     * author           zelian_wu
+     * date             2024-1-3
+     * @return
+     */
+    @PostMapping("/update")
+    public R updateDictType(@RequestBody DictType dictType){
+        if (Objects.isNull(dictType)||Objects.isNull(dictType.getDictId())){
+            throw new RuntimeException("字典编码为空");
+        }
+        if (dictTypeService.updateById(dictType)) {
+            return R.ok("保存成功!");
+        }
+        return R.error("保存失败");
+    }
+
+    /**
+     * 分页查询 字典类型
+     * @param no        当前页
+     * @param size      每页条数
+     * @param site      工厂编码
+     * @param dictName  类型名称
+     * @param dictType  字典类型
+     * @param status    状态
+     * author           zelian_wu
+     * date             2024-1-3
+     * @return
+     */
+    @GetMapping("/{no}/{size}")
+    public R selectDictTypePage(@PathVariable("no")Integer no,
+                                @PathVariable("size")Integer size,
+                                String site,
+                                String dictName,
+                                String dictType,
+                                String status){
+        if (!StringUtils.hasText(site)){
+            throw new RuntimeException("工厂编码为空");
+        }
+        LambdaQueryWrapper<DictType> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(DictType::getSite,site);
+        if (StringUtils.hasText(dictName)){
+            wrapper.like(DictType::getDictName,dictName);
+        }
+        if (StringUtils.hasText(dictType)){
+            wrapper.like(DictType::getDictType,dictType);
+        }
+        if (StringUtils.hasText(status)){
+            wrapper.eq(DictType::getStatus,status);
+        }
+        Page<DictType> page = dictTypeService.page(new Page<DictType>(no, size),wrapper);
+        return R.ok().put("rows",page.getRecords()).put("total",page.getTotal());
+    }
+
+    /**
+     * 查询 字典类型
+     * @param site      工厂编码
+     * @param dictType  类型
+     * author           zelian_wu
+     * date             2024-1-4
+     * @return
+     */
+    @GetMapping("/list")
+    public R selectDictTypeList(String site, String dictType){
+        if (!StringUtils.hasText(site)){
+            throw new RuntimeException("工厂编码为空");
+        }
+        LambdaQueryWrapper<DictType> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(DictType::getSite,site);
+        if (StringUtils.hasText(dictType)){
+            wrapper.like(DictType::getDictType,dictType);
+        }
+        return R.ok().put("rows",dictTypeService.list(wrapper));
+    }
+
+
+}

src/main/java/com/spring/modules/sys/dao/DictDataDao.java

@@ -0,0 +1,9 @@
+package com.spring.modules.sys.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.spring.modules.sys.entity.DictData;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface DictDataDao extends BaseMapper<DictData> {
+}

src/main/java/com/spring/modules/sys/dao/DictTypeDao.java

@@ -0,0 +1,9 @@
+package com.spring.modules.sys.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.spring.modules.sys.entity.DictType;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface DictTypeDao extends BaseMapper<DictType> {
+}

src/main/java/com/spring/modules/sys/entity/DictData.java

@@ -0,0 +1,87 @@
+package com.spring.modules.sys.entity;
+
+
+import com.baomidou.mybatisplus.annotation.*;
+import lombok.Data;
+
+import java.io.Serializable;
+
+import java.util.Date;
+
+/**
+* 字典数据表
+* @TableName sys_dict_data
+*/
+@TableName("sys_dict_data")
+@Data
+public class DictData implements Serializable {
+
+    /**
+    * 字典编码
+    */
+    @TableId(type = IdType.AUTO)
+    private Long dictCode;
+    /**
+    * 字典排序
+    */
+    private Integer dictSort;
+    /**
+    * 字典标签
+    */
+    private String dictLabel;
+    /**
+    * 字典键值
+    */
+    private String dictValue;
+    /**
+    * 字典类型
+    */
+    private String dictType;
+    /**
+    * 样式属性（其他样式扩展）
+    */
+    private String cssClass;
+    /**
+    * 表格回显样式
+    */
+    private String listClass;
+    /**
+    * 是否默认（Y是 N否）
+    */
+    private String isDefault;
+    /**
+    * 状态（Y正常 N停用）
+    */
+    private String status;
+    /**
+    * 创建者
+    */
+    private String createBy;
+    /**
+    * 创建时间
+    */
+    @TableField(value = "create_time",fill = FieldFill.INSERT,updateStrategy = FieldStrategy.NEVER)
+    private Date createDate;
+    /**
+    * 更新者
+    */
+    private String updateBy;
+    /**
+    * 更新时间
+    */
+    @TableField(value = "update_time",fill = FieldFill.UPDATE,insertStrategy = FieldStrategy.NEVER)
+    private Date updateDate;
+    /**
+    * 备注
+    */
+    private String remark;
+    /**
+     * 工厂编码
+     */
+    private String site;
+    /**
+     * 是否系统(Y是系统,N不是系统字段)
+     */
+    private String isSystem;
+
+}

src/main/java/com/spring/modules/sys/entity/DictType.java

@@ -0,0 +1,64 @@
+package com.spring.modules.sys.entity;
+
+import java.io.Serializable;
+import java.util.Date;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
+import org.springframework.format.annotation.DateTimeFormat;
+
+
+/**
+* 字典类型表
+* @TableName sys_dict_type
+*/
+@TableName("sys_dict_type")
+@Data
+public class DictType implements Serializable {
+
+    /**
+    * 字典主键
+    */
+    @TableId(type = IdType.AUTO)
+    private Long dictId;
+    /**
+    * 字典名称
+    */
+    private String dictName;
+    /**
+    * 字典类型
+    */
+    private String dictType;
+    /**
+    * 状态(Y正常,N停用)
+    */
+    private String status;
+    /**
+    * 创建者
+    */
+    private String createBy;
+    /**
+    * 创建时间
+    */
+    @TableField(value = "create_time",fill = FieldFill.INSERT,updateStrategy = FieldStrategy.NEVER)
+    private Date createDate;
+    /**
+    * 更新者
+    */
+    private String updateBy;
+    /**
+    * 更新时间
+    */
+    @TableField(value = "update_time",fill = FieldFill.UPDATE,insertStrategy = FieldStrategy.NEVER)
+    private Date updateDate;
+    /**
+    * 备注
+    */
+    private String remark;
+    /**
+     * 工厂编码
+     */
+    private String site;
+
+}

src/main/java/com/spring/modules/sys/service/DictDataService.java

@@ -0,0 +1,7 @@
+package com.spring.modules.sys.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.spring.modules.sys.entity.DictData;
+
+public interface DictDataService extends IService<DictData> {
+}

src/main/java/com/spring/modules/sys/service/DictTypeService.java

@@ -0,0 +1,10 @@
+package com.spring.modules.sys.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.spring.modules.sys.entity.DictType;
+
+import java.util.List;
+
+public interface DictTypeService extends IService<DictType> {
+
+}

src/main/java/com/spring/modules/sys/service/impl/DictDataServiceImpl.java

@@ -0,0 +1,14 @@
+package com.spring.modules.sys.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.spring.modules.sys.dao.DictDataDao;
+import com.spring.modules.sys.entity.DictData;
+import com.spring.modules.sys.service.DictDataService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+@Service
+@Slf4j
+public class DictDataServiceImpl extends ServiceImpl<DictDataDao, DictData> implements DictDataService {
+
+}

src/main/java/com/spring/modules/sys/service/impl/DictTypeServiceImpl.java

@@ -0,0 +1,17 @@
+package com.spring.modules.sys.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.spring.modules.sys.dao.DictTypeDao;
+import com.spring.modules.sys.entity.DictType;
+import com.spring.modules.sys.service.DictTypeService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+import java.util.List;
+
+@Service
+@Slf4j
+public class DictTypeServiceImpl extends ServiceImpl<DictTypeDao, DictType> implements DictTypeService {
+
+}