删除修改字段校验规则接口

daqe-center/src/main/java/com/lantone/daqe/facade/ColumnVerifyManagementFacade.java

@@ -1,6 +1,7 @@
 package com.lantone.daqe.facade;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.lantone.common.enums.IsDeleteEnum;
 import com.lantone.common.exception.Asserts;
@@ -26,14 +27,17 @@ import com.lantone.daqe.facade.base.RegularMappingFacade;
 import com.lantone.daqe.facade.base.StandardvalueInfoFacade;
 import com.lantone.daqe.vo.AddColumnVerifyVO;
 import com.lantone.daqe.vo.ColumnInfoVO;
+import com.lantone.daqe.vo.DelColumnVerifyVO;
 import com.lantone.daqe.vo.GetColumnNameVO;
 import com.lantone.daqe.vo.GetColumnVerifyPageVO;
 import com.lantone.daqe.vo.GetRegularVO;
 import com.lantone.daqe.vo.GetTableNameVO;
+import com.lantone.daqe.vo.UpdateColumnVerifyVO;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
 
+import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 
@@ -72,7 +76,7 @@ public class ColumnVerifyManagementFacade {
     /**
      * 下拉框获取数据库表中列数据表名称信息
      *
-     * @param
+     * @param getTableNameVO
      * @return: 数据库表中列数据表名称信息
      */
     public List<GetTableNameDTO> getTableName(GetTableNameVO getTableNameVO) {
@@ -89,7 +93,7 @@ public class ColumnVerifyManagementFacade {
     /**
      * 下拉框获取数据库表中列数据字段名称信息
      *
-     * @param
+     * @param getColumnNameVO
      * @return: 数据库表中列数据字段名称信息
      */
     public List<GetColumnNameDTO> getColumnName(GetColumnNameVO getColumnNameVO) {
@@ -106,7 +110,7 @@ public class ColumnVerifyManagementFacade {
     /**
      * 下拉框获取正则式名称
      *
-     * @param
+     * @param getRegularVO
      * @return: 正则式名称
      */
     public List<GetRegularDTO> getRegular(GetRegularVO getRegularVO) {
@@ -121,7 +125,7 @@ public class ColumnVerifyManagementFacade {
     /**
      * 新增字段校验规则
      *
-     * @param
+     * @param addColumnVerifyVO
      * @return: 是否成功
      */
     public Boolean addColumnVerify(AddColumnVerifyVO addColumnVerifyVO) {
@@ -236,9 +240,278 @@ public class ColumnVerifyManagementFacade {
                     }
                 }
             }
-            return true;
         }
-        Asserts.fail("请输入表字段信息");
+        return true;
+    }
+
+    /**
+     * 删除字段校验规则
+     *
+     * @param delColumnVerifyVO
+     * @return: 是否成功
+     */
+    public Boolean delColumnVerify(DelColumnVerifyVO delColumnVerifyVO) {
+        Boolean nonnullInfo = true;
+        Boolean tandardvalueInfo = true;
+        Boolean regular = true;
+        List<Long> ids = delColumnVerifyVO.getIds();
+        List<ColumnVerify> columnVerifyList = columnVerifyFacade.getBaseMapper().selectList(new QueryWrapper<ColumnVerify>()
+                .eq("is_deleted", IsDeleteEnum.N.getKey())
+                .in("column_id", ids)
+        );
+        if (ListUtil.isEmpty(columnVerifyList)) {
+            Asserts.fail("删除失败，不存在所需删除数据！");
+        }
+        //所删正则ID
+        List<Long> regularId = new ArrayList<>();
+        //非空判断ID
+        List<Long> nonnullId = new ArrayList<>();
+        //关键值ID
+        List<Long> standardValueId = new ArrayList<>();
+        for (ColumnVerify columnVerify : columnVerifyList) {
+            String type = columnVerify.getType();
+            //非空
+            if (ColumnVerifyTypeEnum.NONNULL_TYPE.getKey().equals(type)) {
+                nonnullId.add(columnVerify.getVerifyId());
+            }
+            //关键值
+            if (ColumnVerifyTypeEnum.STANDARD_TYPE.getKey().equals(type)) {
+                standardValueId.add(columnVerify.getVerifyId());
+            }
+            //正则
+            if (ColumnVerifyTypeEnum.REGULAR_TYPE.getKey().equals(type)) {
+                regularId.add(columnVerify.getVerifyId());
+            }
+        }
+        //非空
+        if (ListUtil.isNotEmpty(nonnullId)) {
+            nonnullInfo = nonnullInfoFacade.update(new UpdateWrapper<NonnullInfo>()
+                    .eq("is_deleted", IsDeleteEnum.N.getKey())
+                    .in("id", nonnullId)
+                    .set("is_deleted", IsDeleteEnum.Y.getKey())
+                    .set("gmt_modified", new Date())
+            );
+        }
+        //关键值
+        if (ListUtil.isNotEmpty(standardValueId)) {
+            tandardvalueInfo = standardvalueInfoFacade.update(new UpdateWrapper<StandardvalueInfo>()
+                    .eq("is_deleted", IsDeleteEnum.N.getKey())
+                    .in("id", standardValueId)
+                    .set("is_deleted", IsDeleteEnum.Y.getKey())
+                    .set("gmt_modified", new Date())
+            );
+        }
+        //正则
+        if (ListUtil.isNotEmpty(regularId)) {
+            regular = regularMappingFacade.update(new UpdateWrapper<RegularMapping>()
+                    .eq("is_deleted", IsDeleteEnum.N.getKey())
+                    .in("id", regularId)
+                    .set("is_deleted", IsDeleteEnum.Y.getKey())
+                    .set("gmt_modified", new Date())
+            );
+        }
+        if (nonnullInfo && tandardvalueInfo && regular) {
+            boolean update = columnVerifyFacade.update(new UpdateWrapper<ColumnVerify>()
+                    .eq("is_deleted", IsDeleteEnum.N.getKey())
+                    .in("column_id", ids)
+                    .set("is_deleted", IsDeleteEnum.Y.getKey())
+                    .set("gmt_modified", new Date())
+            );
+            if (update) {
+                return true;
+            }
+        }
+        Asserts.fail("删除失败");
         return false;
     }
+
+    /**
+     * 修改字段校验规则
+     *
+     * @param updateColumnVerifyVO
+     * @return: 是否成功
+     */
+    public Boolean updateColumnVerify(UpdateColumnVerifyVO updateColumnVerifyVO) {
+        List<ColumnInfoVO> columnList = updateColumnVerifyVO.getColumnList();
+        AddColumnVerifyVO addColumnVerifyVO = new AddColumnVerifyVO();
+        ArrayList<ColumnInfoVO> columnInfoAdd = new ArrayList<>();
+        ArrayList<ColumnInfoVO> columnInfoUpdate = new ArrayList<>();
+        //查出表列信息ID
+        List<Long> columnInfoIdAdd = new ArrayList<>();
+        List<Long> columnInfoIdUpdate = new ArrayList<>();
+        for (ColumnInfoVO columnInfoVO : columnList) {
+            ColumnInfo columnInfo = columnInfoFacade.getBaseMapper().selectOne(new QueryWrapper<ColumnInfo>()
+                    .eq("is_deleted", IsDeleteEnum.N.getKey())
+                    .eq(StringUtil.isNotBlank(columnInfoVO.getTableCname()), "table_cname", columnInfoVO.getTableCname())
+                    .eq(StringUtil.isNotBlank(columnInfoVO.getTableEname()), "table_ename", columnInfoVO.getTableEname())
+                    .eq(StringUtil.isNotBlank(columnInfoVO.getColumnCname()), "column_cname", columnInfoVO.getColumnCname())
+                    .eq(StringUtil.isNotBlank(columnInfoVO.getColumnEname()), "column_ename", columnInfoVO.getColumnEname())
+            );
+            Long columnId = columnInfo.getId();
+            ColumnVerify columnVerify = columnVerifyFacade.getById(columnId);
+            if (columnVerify != null) {
+                //库中已有维护
+                columnInfoIdUpdate.add(columnId);
+                columnInfoUpdate.add(columnInfoVO);
+            } else {
+                //库中暂无维护
+                columnInfoIdAdd.add(columnId);
+                columnInfoAdd.add(columnInfoVO);
+            }
+        }
+        if (ListUtil.isNotEmpty(columnInfoAdd)) {
+            addColumnVerifyVO.setHospitalId(updateColumnVerifyVO.getHospitalId());
+            addColumnVerifyVO.setColumnList(updateColumnVerifyVO.getColumnList());
+            addColumnVerifyVO.setIsRequired(updateColumnVerifyVO.getIsRequired());
+            addColumnVerifyVO.setRegularId(updateColumnVerifyVO.getRegularId());
+            addColumnVerifyVO.setRegularName(updateColumnVerifyVO.getRegularName());
+            addColumnVerifyVO.setStandardValueList(updateColumnVerifyVO.getStandardValueList());
+            addColumnVerifyVO.setDescription(updateColumnVerifyVO.getDescription());
+            //库中暂无走新增流程
+            addColumnVerify(addColumnVerifyVO);
+        }
+        //库中已有走修改流程
+        if (ListUtil.isNotEmpty(columnInfoIdUpdate)) {
+            for (Long columnId : columnInfoIdUpdate) {
+                ColumnInfo columnInfo = columnInfoFacade.getById(columnId);
+                ColumnVerify columnVerify = new ColumnVerify();
+                columnVerify.setColumnId(columnId);
+                columnVerify.setColumnCname(columnInfo.getColumnCname());
+                columnVerify.setColumnEname(columnInfo.getColumnEname());
+                columnVerify.setTableCname(columnInfo.getTableCname());
+                columnVerify.setTableEname(columnInfo.getTableEname());
+                if (updateColumnVerifyVO.getRegularId() != null) {
+                    //插入正则维护表
+                    //先判断是否该字段信息是否已关联正则
+                    RegularMapping selectOneMapping = regularMappingFacade.getBaseMapper().selectOne(new QueryWrapper<RegularMapping>()
+                            .eq("column_id", columnId)
+                            .eq("is_deleted", IsDeleteEnum.N.getKey())
+                    );
+                    if (selectOneMapping != null) {
+                        //已关联正则走修改
+                        regularMappingFacade.update(new UpdateWrapper<RegularMapping>()
+                                .eq("column_id", columnId)
+                                .eq("is_deleted", IsDeleteEnum.N.getKey())
+                                .set("regular_id", updateColumnVerifyVO.getRegularId())
+                                .set("gmt_modified", new Date())
+                        );
+                        Long mappingId = selectOneMapping.getId();
+                        //修改总表
+                        columnVerifyFacade.update(new UpdateWrapper<ColumnVerify>()
+                                .eq("column_id", columnId)
+                                .eq("type", ColumnVerifyTypeEnum.REGULAR_TYPE.getKey())
+                                .eq("verify_id", mappingId)
+                                .set("verify_val", updateColumnVerifyVO.getRegularName())
+                        );
+                    } else {
+                        //未关联正则走新增
+                        RegularMapping regularMapping = new RegularMapping();
+                        regularMapping.setColumnId(columnId);
+                        regularMapping.setGmtCreate(new Date());
+                        regularMapping.setRegularId(updateColumnVerifyVO.getRegularId());
+                        try {
+                            regularMappingFacade.getBaseMapper().insert(regularMapping);
+                        } catch (Exception e) {
+                            Asserts.fail("关联正则失败,请重试！");
+                        }
+                        Long regularMappingId = regularMapping.getId();
+                        //插入总表
+                        columnVerify.setType(ColumnVerifyTypeEnum.REGULAR_TYPE.getKey());
+                        columnVerify.setVerifyId(regularMappingId);
+                        columnVerify.setVerifyVal(updateColumnVerifyVO.getRegularName());
+                        columnVerify.setDescription(updateColumnVerifyVO.getDescription());
+                        columnVerify.setGmtCreate(new Date());
+                        try {
+                            columnVerifyFacade.getBaseMapper().insert(columnVerify);
+                        } catch (Exception e) {
+                            Asserts.fail("保存失败");
+                        }
+                    }
+                }
+                if (updateColumnVerifyVO.getIsRequired() != null) {
+                    //插入表字段的非空校验维护表
+                    //先判断是否该字段信息是否已存在非空规则
+                    NonnullInfo selectOneInfo = nonnullInfoFacade.getBaseMapper().selectOne(new QueryWrapper<NonnullInfo>()
+                            .eq("column_id", columnId)
+                            .eq("is_deleted", IsDeleteEnum.N.getKey())
+                    );
+                    if (selectOneInfo != null) {
+                        //已关联非空校验走修改
+                        nonnullInfoFacade.update(new UpdateWrapper<NonnullInfo>()
+                                .eq("column_id", columnId)
+                                .eq("is_deleted", IsDeleteEnum.N.getKey())
+                                .set("is_required", updateColumnVerifyVO.getIsRequired())
+                                .set("gmt_modified", new Date())
+                        );
+                        Long mappingId = selectOneInfo.getId();
+                        //修改总表
+                        columnVerifyFacade.update(new UpdateWrapper<ColumnVerify>()
+                                .eq("column_id", columnId)
+                                .eq("type", ColumnVerifyTypeEnum.NONNULL_TYPE.getKey())
+                                .eq("verify_id", mappingId)
+                                .set("verify_val", updateColumnVerifyVO.getIsRequired())
+                        );
+                    } else {
+                        NonnullInfo nonnullInfo = new NonnullInfo();
+                        nonnullInfo.setColumnId(columnId);
+                        nonnullInfo.setGmtCreate(new Date());
+                        nonnullInfo.setIsRequired(updateColumnVerifyVO.getIsRequired());
+                        try {
+                            nonnullInfoFacade.getBaseMapper().insert(nonnullInfo);
+                        } catch (Exception e) {
+                            Asserts.fail("关联是否非空失败,请重试！");
+                        }
+                        Long nonnullInfoId = nonnullInfo.getId();
+                        //插入总表
+                        columnVerify.setType(ColumnVerifyTypeEnum.NONNULL_TYPE.getKey());
+                        columnVerify.setVerifyId(nonnullInfoId);
+                        columnVerify.setVerifyVal(updateColumnVerifyVO.getIsRequired());
+                        columnVerify.setDescription(updateColumnVerifyVO.getDescription());
+                        columnVerify.setGmtCreate(new Date());
+                        try {
+                            columnVerifyFacade.getBaseMapper().insert(columnVerify);
+                        } catch (Exception e) {
+                            Asserts.fail("保存失败");
+                        }
+                    }
+                }
+                if (ListUtil.isNotEmpty(updateColumnVerifyVO.getStandardValueList())) {
+                    //插入关键字信息维护表
+                    List<String> standardValueList = updateColumnVerifyVO.getStandardValueList();
+                    //先删除之前的关联然后直接插入
+                    standardvalueInfoFacade.remove(new QueryWrapper<StandardvalueInfo>()
+                            .eq("column_id", columnId)
+                    );
+                    columnVerifyFacade.remove(new QueryWrapper<ColumnVerify>()
+                            .eq("column_id", columnId)
+                            .eq("type", ColumnVerifyTypeEnum.STANDARD_TYPE.getKey())
+                    );
+                    for (String standardValue : standardValueList) {
+                        StandardvalueInfo standardvalueInfo = new StandardvalueInfo();
+                        standardvalueInfo.setColumnId(columnId);
+                        standardvalueInfo.setGmtCreate(new Date());
+                        standardvalueInfo.setVal(standardValue);
+                        try {
+                            standardvalueInfoFacade.getBaseMapper().insert(standardvalueInfo);
+                        } catch (Exception e) {
+                            Asserts.fail("关联关键字失败,请重试！");
+                        }
+                        Long standardvalueInfoId = standardvalueInfo.getId();
+                        //插入总表
+                        columnVerify.setType(ColumnVerifyTypeEnum.STANDARD_TYPE.getKey());
+                        columnVerify.setVerifyId(standardvalueInfoId);
+                        columnVerify.setVerifyVal(standardValue);
+                        columnVerify.setDescription(updateColumnVerifyVO.getDescription());
+                        columnVerify.setGmtCreate(new Date());
+                        try {
+                            columnVerifyFacade.getBaseMapper().insert(columnVerify);
+                        } catch (Exception e) {
+                            Asserts.fail("保存失败");
+                        }
+                    }
+                }
+            }
+        }
+        return true;
+    }
 }

daqe-center/src/main/java/com/lantone/daqe/vo/ColumnInfoVO.java

@@ -19,15 +19,15 @@ import java.io.Serializable;
 public class ColumnInfoVO implements Serializable {
     private static final long serialVersionUID = -4822420650132733065L;
 
-    @ApiModelProperty(value = "表名称(中文)")
+    @ApiModelProperty(value = "表名称(中文)", required = true)
     private String tableCname;
 
-    @ApiModelProperty(value = "表名称(英文)")
+    @ApiModelProperty(value = "表名称(英文)", required = true)
     private String tableEname;
 
-    @ApiModelProperty(value = "字段名称(中文)")
+    @ApiModelProperty(value = "字段名称(中文)", required = true)
     private String columnCname;
 
-    @ApiModelProperty(value = "字段名称(英文)")
+    @ApiModelProperty(value = "字段名称(英文)", required = true)
     private String columnEname;
 }

daqe-center/src/main/java/com/lantone/daqe/vo/DelColumnVerifyVO.java

@@ -0,0 +1,27 @@
+package com.lantone.daqe.vo;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.validation.constraints.NotEmpty;
+import java.io.Serializable;
+import java.util.List;
+
+/**
+ * @Description:
+ * @author： zhanghang
+ * @time: 2022/3/7 16:19
+ */
+@ApiModel(value = "通过id删除字段校验规则-接口入参")
+@Getter
+@Setter
+public class DelColumnVerifyVO implements Serializable {
+
+    private static final long serialVersionUID = -1062780829648593735L;
+
+    @ApiModelProperty(value = "校验规则字段id", required = true)
+    @NotEmpty(message = "校验规则字段id不能为空")
+    private List<Long> ids;
+}

daqe-center/src/main/java/com/lantone/daqe/vo/UpdateColumnVerifyVO.java

@@ -0,0 +1,49 @@
+package com.lantone.daqe.vo;
+
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.validation.constraints.NotNull;
+import java.io.Serializable;
+import java.util.List;
+
+/**
+ * @Description: 修改字段校验规则-接口入参
+ * @author： zhanghang
+ * @time: 2022/3/4 16:03
+ */
+@ApiModel(value = "修改字段校验规则-接口入参")
+@Getter
+@Setter
+public class UpdateColumnVerifyVO implements Serializable {
+
+
+    private static final long serialVersionUID = 9022047248318049371L;
+    @ApiModelProperty(value = "组织机构ID", required = true)
+    @NotNull(message = "组织机构ID不能为空")
+    private Long hospitalId;
+
+    @ApiModelProperty(value = "表字段信息", required = true)
+    @NotNull(message = "表信息不能为空")
+    List<ColumnInfoVO> columnList;
+
+    @ApiModelProperty(value = "是否必填,0:否，1:是")
+    String isRequired;
+
+    @ApiModelProperty(value = "正则式ID")
+    Long regularId;
+
+    @ApiModelProperty(value = "正则式名称")
+    String regularName;
+
+    @ApiModelProperty(value = "标准值")
+    List<String> standardValueList;
+
+    @ApiModelProperty(value = "说明")
+    String description;
+
+
+}

daqe-center/src/main/java/com/lantone/daqe/web/ColumnVerifyManagementController.java

@@ -8,10 +8,12 @@ import com.lantone.daqe.dto.GetRegularDTO;
 import com.lantone.daqe.dto.GetTableNameDTO;
 import com.lantone.daqe.facade.ColumnVerifyManagementFacade;
 import com.lantone.daqe.vo.AddColumnVerifyVO;
+import com.lantone.daqe.vo.DelColumnVerifyVO;
 import com.lantone.daqe.vo.GetColumnNameVO;
 import com.lantone.daqe.vo.GetColumnVerifyPageVO;
 import com.lantone.daqe.vo.GetRegularVO;
 import com.lantone.daqe.vo.GetTableNameVO;
+import com.lantone.daqe.vo.UpdateColumnVerifyVO;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -69,4 +71,18 @@ public class ColumnVerifyManagementController {
     public CommonResult<Boolean> addColumnVerify(@RequestBody AddColumnVerifyVO addColumnVerifyVO) {
         return CommonResult.success(columnVerifyManagementFacade.addColumnVerify(addColumnVerifyVO));
     }
+
+    @ApiOperation(value = "删除字段校验规则 [by:zhanghang]")
+    @PostMapping("/delColumnVerify")
+    @Transactional
+    public CommonResult<Boolean> delColumnVerify(@RequestBody DelColumnVerifyVO delColumnVerifyVO) {
+        return CommonResult.success(columnVerifyManagementFacade.delColumnVerify(delColumnVerifyVO));
+    }
+
+    @ApiOperation(value = "修改字段校验规则 [by:zhanghang]")
+    @PostMapping("/updateColumnVerify")
+    @Transactional
+    public CommonResult<Boolean> updateColumnVerify(@RequestBody UpdateColumnVerifyVO updateColumnVerifyVO) {
+        return CommonResult.success(columnVerifyManagementFacade.updateColumnVerify(updateColumnVerifyVO));
+    }
 }