术语映射导入导出

cdssman-service/src/main/java/com/diagbot/entity/DeptConfig.java

@@ -8,6 +8,7 @@ import com.baomidou.mybatisplus.annotation.TableName;
 import javax.validation.constraints.NotBlank;
 import java.io.Serializable;
 import java.util.Date;
+import java.util.Objects;
 
 /**
  * <p>
@@ -61,20 +62,20 @@ public class DeptConfig implements Serializable {
     /**
      * 医院科室名称
      */
-    @Excel(name = "医院科室名称", width = 40, orderNum = "2")
+    @Excel(name = "医院科室名称", width = 40, orderNum = "2", isImportField = "true")
     @NotBlank(message = "请输入医院科室名称")
     private String hisName;
 
     /**
      * 医院科室编码
      */
-    @Excel(name = "医院科室编码", width = 40, orderNum = "1")
+    @Excel(name = "医院科室编码", width = 40, orderNum = "1", isImportField = "true")
     private String hisCode;
 
     /**
      * 标准科室名称
      */
-    @Excel(name = "标准科室名称", width = 40, orderNum = "4")
+    @Excel(name = "标准科室名称", width = 40, orderNum = "4", isImportField = "true")
     @NotBlank(message = "请输入标准科室名称")
     private String uniqueName;
 
@@ -188,4 +189,25 @@ public class DeptConfig implements Serializable {
                 ", uniqueCode=" + uniqueCode +
                 "}";
     }
-}
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+        DeptConfig deptConfig = (DeptConfig) o;
+        return Objects.equals(id, deptConfig.id)
+                && Objects.equals(isDeleted, deptConfig.isDeleted)
+                && Objects.equals(hospitalId, deptConfig.hospitalId)
+                && Objects.equals(hisName, deptConfig.hisName)
+                && Objects.equals(hisCode, deptConfig.hisCode)
+                && Objects.equals(uniqueName, deptConfig.uniqueName)
+                && Objects.equals(uniqueCode, deptConfig.uniqueCode);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, isDeleted, hospitalId, hisName, hisCode, uniqueName, uniqueCode);
+    }
+}

cdssman-service/src/main/java/com/diagbot/entity/DiseaseConfig.java

@@ -8,6 +8,7 @@ import com.baomidou.mybatisplus.annotation.TableName;
 import javax.validation.constraints.NotBlank;
 import java.io.Serializable;
 import java.util.Date;
+import java.util.Objects;
 
 /**
  * <p>
@@ -61,21 +62,21 @@ public class DiseaseConfig implements Serializable {
     /**
      * 医院诊断名称
      */
-    @Excel(name = "医院诊断名称", width = 40, orderNum = "1")
+    @Excel(name = "医院诊断名称", width = 40, orderNum = "1", isImportField = "true")
     @NotBlank(message = "请输入医院诊断名称")
     private String hisName;
 
     /**
      * 标准诊断名称
      */
-    @Excel(name = "标准诊断名称", width = 40, orderNum = "3")
+    @Excel(name = "标准诊断名称", width = 40, orderNum = "3", isImportField = "true")
     @NotBlank(message = "请输入标准诊断名称")
     private String uniqueName;
 
     /**
      * ICD-10编码
      */
-    @Excel(name = "ICD-10编码", width = 40, orderNum = "2")
+    @Excel(name = "ICD-10编码", width = 40, orderNum = "2", isImportField = "true")
     private String icdCode;
 
     public Long getId() {
@@ -173,4 +174,24 @@ public class DiseaseConfig implements Serializable {
                 ", icdCode=" + icdCode +
                 "}";
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+        DiseaseConfig diseaseConfig = (DiseaseConfig) o;
+        return Objects.equals(id, diseaseConfig.id)
+                && Objects.equals(isDeleted, diseaseConfig.isDeleted)
+                && Objects.equals(hospitalId, diseaseConfig.hospitalId)
+                && Objects.equals(hisName, diseaseConfig.hisName)
+                && Objects.equals(uniqueName, diseaseConfig.uniqueName)
+                && Objects.equals(icdCode, diseaseConfig.icdCode);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, isDeleted, hospitalId, hisName, uniqueName, icdCode);
+    }
 }

cdssman-service/src/main/java/com/diagbot/entity/DrugConfig.java

@@ -8,6 +8,7 @@ import com.baomidou.mybatisplus.annotation.TableName;
 import javax.validation.constraints.NotBlank;
 import java.io.Serializable;
 import java.util.Date;
+import java.util.Objects;
 
 /**
  * <p>
@@ -61,15 +62,17 @@ public class DrugConfig implements Serializable {
     /**
      * 医院药品名称
      */
-    @Excel(name = "医院药品名称", width = 40, orderNum = "1")
+    @Excel(name = "医院药品名称", width = 40, orderNum = "1", isImportField = "true")
     @NotBlank(message = "请输入医院药品名称")
+    //@Size(max = 80, min = 1,message = "医院药品名称长度需要在1-80字符长度之间")
     private String hisName;
 
     /**
      * 标准药品名称
      */
-    @Excel(name = "标准药品名称", width = 40, orderNum = "2")
+    @Excel(name = "标准药品名称", width = 40, orderNum = "2", isImportField = "true")
     @NotBlank(message = "请输入标准药品名称")
+    //@Size(max = 80, min = 1,message = "标准药品名称长度需要在1-80字符长度之间")
     private String uniqueName;
 
     /**
@@ -81,7 +84,7 @@ public class DrugConfig implements Serializable {
     /**
      * 剂型
      */
-    @Excel(name = "药品剂型", width = 20, orderNum = "3")
+    @Excel(name = "药品剂型(不填、注射剂、片剂、缓释片、胶囊剂、滴丸剂)", width = 60, orderNum = "3", isImportField = "true")
     private String form;
 
     public Long getId() {
@@ -188,4 +191,25 @@ public class DrugConfig implements Serializable {
                 ", form=" + form +
                 "}";
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+        DrugConfig drugConfig = (DrugConfig) o;
+        return Objects.equals(id, drugConfig.id)
+                && Objects.equals(isDeleted, drugConfig.isDeleted)
+                && Objects.equals(hospitalId, drugConfig.hospitalId)
+                && Objects.equals(hisName, drugConfig.hisName)
+                && Objects.equals(form, drugConfig.form)
+                && Objects.equals(uniqueName, drugConfig.uniqueName)
+                && Objects.equals(uniqueCode, drugConfig.uniqueCode);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, isDeleted, hospitalId, hisName, form, uniqueName, uniqueCode);
+    }
 }

cdssman-service/src/main/java/com/diagbot/entity/LisConfig.java

@@ -9,6 +9,7 @@ import lombok.Data;
 import javax.validation.constraints.NotBlank;
 import java.io.Serializable;
 import java.util.Date;
+import java.util.Objects;
 
 /**
  * <p>
@@ -63,20 +64,20 @@ public class LisConfig implements Serializable {
     /**
      * 检验套餐
      */
-    @Excel(name = "检验套餐", width = 40, orderNum = "1")
+    @Excel(name = "检验套餐", width = 40, orderNum = "1", isImportField = "true")
     @NotBlank(message = "请输入检验套餐")
     private String hisName;
 
     /**
      * 检验细项
      */
-    @Excel(name = "检验细项", width = 40, orderNum = "2")
+    @Excel(name = "检验细项", width = 40, orderNum = "2", isImportField = "true")
     private String hisDetailName;
 
     /**
      * 标准检验项目
      */
-    @Excel(name = "标准检验项目", width = 40, orderNum = "4")
+    @Excel(name = "标准检验项目", width = 40, orderNum = "4", isImportField = "true")
     @NotBlank(message = "请输入标准检验项目")
     private String uniqueName;
 
@@ -190,4 +191,25 @@ public class LisConfig implements Serializable {
                 ", uniqueCode=" + uniqueCode +
                 "}";
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+        LisConfig lisConfig = (LisConfig) o;
+        return Objects.equals(id, lisConfig.id)
+                && Objects.equals(isDeleted, lisConfig.isDeleted)
+                && Objects.equals(hospitalId, lisConfig.hospitalId)
+                && Objects.equals(hisName, lisConfig.hisName)
+                && Objects.equals(hisDetailName, lisConfig.hisDetailName)
+                && Objects.equals(uniqueName, lisConfig.uniqueName)
+                && Objects.equals(uniqueCode, lisConfig.uniqueCode);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, isDeleted, hospitalId, hisName, hisDetailName, uniqueName, uniqueCode);
+    }
 }

cdssman-service/src/main/java/com/diagbot/entity/OperationConfig.java

@@ -8,6 +8,7 @@ import com.baomidou.mybatisplus.annotation.TableName;
 import javax.validation.constraints.NotBlank;
 import java.io.Serializable;
 import java.util.Date;
+import java.util.Objects;
 
 /**
  * <p>
@@ -61,14 +62,14 @@ public class OperationConfig implements Serializable {
     /**
      * 医院手术/操作名称
      */
-    @Excel(name = "医院手术/操作名称", width = 40, orderNum = "1")
+    @Excel(name = "医院手术/操作名称", width = 40, orderNum = "1", isImportField = "true")
     @NotBlank(message = "请输入医院手术/操作名称")
     private String hisName;
 
     /**
      * 标准手术/操作名称
      */
-    @Excel(name = "标准手术/操作名称", width = 40, orderNum = "3")
+    @Excel(name = "标准手术/操作名称", width = 40, orderNum = "3", isImportField = "true")
     @NotBlank(message = "请输入标准手术/操作名称")
     private String uniqueName;
 
@@ -173,4 +174,24 @@ public class OperationConfig implements Serializable {
                 ", uniqueCode=" + uniqueCode +
                 "}";
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+        OperationConfig operationConfig = (OperationConfig) o;
+        return Objects.equals(id, operationConfig.id)
+                && Objects.equals(isDeleted, operationConfig.isDeleted)
+                && Objects.equals(hospitalId, operationConfig.hospitalId)
+                && Objects.equals(hisName, operationConfig.hisName)
+                && Objects.equals(uniqueName, operationConfig.uniqueName)
+                && Objects.equals(uniqueCode, operationConfig.uniqueCode);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, isDeleted, hospitalId, hisName, uniqueName, uniqueCode);
+    }
 }

cdssman-service/src/main/java/com/diagbot/entity/PacsConfig.java

@@ -8,6 +8,7 @@ import com.baomidou.mybatisplus.annotation.TableName;
 import javax.validation.constraints.NotBlank;
 import java.io.Serializable;
 import java.util.Date;
+import java.util.Objects;
 
 /**
  * <p>
@@ -61,14 +62,14 @@ public class PacsConfig implements Serializable {
     /**
      * 医院检查项目
      */
-    @Excel(name = "医院检查项目", width = 40, orderNum = "1")
+    @Excel(name = "医院检查项目", width = 40, orderNum = "1", isImportField = "true")
     @NotBlank(message = "请输入医院检查项目")
     private String hisName;
 
     /**
      * 标准检查项目
      */
-    @Excel(name = "标准检查项目", width = 40, orderNum = "3")
+    @Excel(name = "标准检查项目", width = 40, orderNum = "3", isImportField = "true")
     @NotBlank(message = "请输入标准检查项目")
     private String uniqueName;
 
@@ -173,4 +174,24 @@ public class PacsConfig implements Serializable {
                 ", uniqueCode=" + uniqueCode +
                 "}";
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+        PacsConfig pacsConfig = (PacsConfig) o;
+        return Objects.equals(id, pacsConfig.id)
+                && Objects.equals(isDeleted, pacsConfig.isDeleted)
+                && Objects.equals(hospitalId, pacsConfig.hospitalId)
+                && Objects.equals(hisName, pacsConfig.hisName)
+                && Objects.equals(uniqueName, pacsConfig.uniqueName)
+                && Objects.equals(uniqueCode, pacsConfig.uniqueCode);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, isDeleted, hospitalId, hisName, uniqueName, uniqueCode);
+    }
 }

cdssman-service/src/main/java/com/diagbot/entity/TransfusionConfig.java

@@ -8,6 +8,7 @@ import com.baomidou.mybatisplus.annotation.TableName;
 import javax.validation.constraints.NotBlank;
 import java.io.Serializable;
 import java.util.Date;
+import java.util.Objects;
 
 /**
  * <p>
@@ -61,15 +62,15 @@ public class TransfusionConfig implements Serializable {
     /**
      * 医院用血类型
      */
-    @Excel(name = "医院用血类型", width = 40, orderNum = "1")
-    @NotBlank(message = "请输入医院用血类型")
+    @Excel(name = "医院输血类型", width = 40, orderNum = "1", isImportField = "true")
+    @NotBlank(message = "请输入医院输血类型")
     private String hisName;
 
     /**
      * 标准用血术语
      */
-    @Excel(name = "标准用血术语", width = 40, orderNum = "3")
-    @NotBlank(message = "请输入标准用血术语")
+    @Excel(name = "标准输血类型", width = 40, orderNum = "3", isImportField = "true")
+    @NotBlank(message = "请输入标准输血类型")
     private String uniqueName;
 
     /**
@@ -173,4 +174,24 @@ public class TransfusionConfig implements Serializable {
                 ", uniqueCode=" + uniqueCode +
                 "}";
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+        TransfusionConfig transfusionConfig = (TransfusionConfig) o;
+        return Objects.equals(id, transfusionConfig.id)
+                && Objects.equals(isDeleted, transfusionConfig.isDeleted)
+                && Objects.equals(hospitalId, transfusionConfig.hospitalId)
+                && Objects.equals(hisName, transfusionConfig.hisName)
+                && Objects.equals(uniqueName, transfusionConfig.uniqueName)
+                && Objects.equals(uniqueCode, transfusionConfig.uniqueCode);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, isDeleted, hospitalId, hisName, uniqueName, uniqueCode);
+    }
 }

cdssman-service/src/main/java/com/diagbot/facade/DeptConfigFacade.java

@@ -253,13 +253,32 @@ public class DeptConfigFacade {
 
         //1、数据完整性校验
         //2、去除前后空格
+        //过滤空数据，保留重复数据，方便计行
+        deptConfigList = deptConfigList.stream()
+                .filter(i -> StringUtil.isNotBlank(i.getHisName())
+                        || StringUtil.isNotBlank(i.getHisCode())
+                        || StringUtil.isNotBlank(i.getUniqueCode())
+                        || StringUtil.isNotBlank(i.getUniqueName()))
+                .collect(Collectors.toList());
+        if (ListUtil.isEmpty(deptConfigList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+
+        List<String> emptyNumList = Lists.newLinkedList();
         for (int i = 0; i < deptConfigList.size(); i++) {
             if (StringUtil.isBlank(deptConfigList.get(i).getHisName())
                     || StringUtil.isBlank(deptConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+                emptyNumList.add(String.valueOf(i + 2));
+            }
+            if (StringUtil.isNotBlank(deptConfigList.get(i).getHisName())) {
+                deptConfigList.get(i).setHisName(deptConfigList.get(i).getHisName().trim());
+            }
+            if (StringUtil.isNotBlank(deptConfigList.get(i).getHisCode())) {
+                deptConfigList.get(i).setHisCode(deptConfigList.get(i).getHisCode().trim());
+            }
+            if (StringUtil.isNotBlank(deptConfigList.get(i).getUniqueName())) {
+                deptConfigList.get(i).setUniqueName(deptConfigList.get(i).getUniqueName().trim());
             }
-            deptConfigList.get(i).setHisName(deptConfigList.get(i).getHisName().trim());
-            deptConfigList.get(i).setUniqueName(deptConfigList.get(i).getUniqueName().trim());
             if (StringUtil.isNotBlank(deptConfigList.get(i).getUniqueCode())) {
                 deptConfigList.get(i).setUniqueCode(deptConfigList.get(i).getUniqueCode().trim());
             } else {
@@ -267,13 +286,19 @@ public class DeptConfigFacade {
             }
         }
 
+        if (ListUtil.isNotEmpty(emptyNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数（不计入空行）存在不完整数据："
+                    + emptyNumList.stream().collect(Collectors.joining("、"))
+                    + "。导入取消，请修改后再试。\n");
+        }
+
         // 验证数据是否已存在，已存在的先删除
         // 没id的删除重新插入，有id的更新
         List<Long> deleteIds = Lists.newLinkedList();
         Map<String, Map<String, Long>> configMap
                 = getConfigMap(Long.valueOf(hospitalId), null, null);
         deptConfigList.forEach(deptConfig -> {
-            deptConfig.setHospitalId(Long.valueOf(hospitalId));
+            deptConfig.setHospitalId(hospitalId);
             deptConfig.setModifier(userId);
             deptConfig.setGmtModified(now);
             if (deptConfig.getId() == null) {
@@ -289,6 +314,7 @@ public class DeptConfigFacade {
         });
 
         //标准术语校验
+        List<String> errorNumList = Lists.newLinkedList();
         List<String> uniqueNames = deptConfigList.stream()
                 .map(i -> i.getUniqueName())
                 .distinct()
@@ -301,10 +327,15 @@ public class DeptConfigFacade {
         List<String> names = respDTO.data;
         for (int i = 0; i < deptConfigList.size(); i++) {
             if (!names.contains(deptConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                        "【" + deptConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+                errorNumList.add(String.valueOf(i + 2));
             }
         }
+        if (ListUtil.isNotEmpty(errorNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                    "以下行数（不计入空行）标准术语与数据库术语不匹配："
+                            + errorNumList.stream().collect(Collectors.joining("、"))
+                            + "。导入取消，请修改后再试。");
+        }
 
         //重复数据过滤
         deptConfigList = deptConfigList

cdssman-service/src/main/java/com/diagbot/facade/DiseaseConfigFacade.java

@@ -245,13 +245,27 @@ public class DiseaseConfigFacade {
 
         //1、数据完整性校验
         //2、去除前后空格
+        //过滤空数据，保留重复数据，方便计行
+        diseaseConfigList = diseaseConfigList.stream()
+                .filter(i -> StringUtil.isNotBlank(i.getHisName())
+                        || StringUtil.isNotBlank(i.getIcdCode())
+                        || StringUtil.isNotBlank(i.getUniqueName()))
+                .collect(Collectors.toList());
+        if (ListUtil.isEmpty(diseaseConfigList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+        List<String> emptyNumList = Lists.newLinkedList();
         for (int i = 0; i < diseaseConfigList.size(); i++) {
             if (StringUtil.isBlank(diseaseConfigList.get(i).getHisName())
                     || StringUtil.isBlank(diseaseConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+                emptyNumList.add(String.valueOf(i + 2));
+            }
+            if (StringUtil.isNotBlank(diseaseConfigList.get(i).getHisName())) {
+                diseaseConfigList.get(i).setHisName(diseaseConfigList.get(i).getHisName().trim());
+            }
+            if (StringUtil.isNotBlank(diseaseConfigList.get(i).getUniqueName())) {
+                diseaseConfigList.get(i).setUniqueName(diseaseConfigList.get(i).getUniqueName().trim());
             }
-            diseaseConfigList.get(i).setHisName(diseaseConfigList.get(i).getHisName().trim());
-            diseaseConfigList.get(i).setUniqueName(diseaseConfigList.get(i).getUniqueName().trim());
             if (StringUtil.isNotBlank(diseaseConfigList.get(i).getIcdCode())) {
                 diseaseConfigList.get(i).setIcdCode(diseaseConfigList.get(i).getIcdCode().trim());
             } else {
@@ -259,6 +273,13 @@ public class DiseaseConfigFacade {
             }
         }
 
+        if (ListUtil.isNotEmpty(emptyNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数（不计入空行）存在不完整数据："
+                    + emptyNumList.stream().collect(Collectors.joining("、"))
+                    + "。导入取消，请修改后再试。\n");
+        }
+
+
         // 验证数据是否已存在，已存在的先删除
         // 没id的删除重新插入，有id的更新
         List<Long> deleteIds = Lists.newLinkedList();
@@ -281,6 +302,7 @@ public class DiseaseConfigFacade {
         });
 
         //标准术语校验
+        List<String> errorNumList = Lists.newLinkedList();
         List<String> uniqueNames = diseaseConfigList.stream()
                 .map(i -> i.getUniqueName())
                 .distinct()
@@ -293,10 +315,15 @@ public class DiseaseConfigFacade {
         List<String> names = respDTO.data;
         for (int i = 0; i < diseaseConfigList.size(); i++) {
             if (!names.contains(diseaseConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                        "【" + diseaseConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+                errorNumList.add(String.valueOf(i + 2));
             }
         }
+        if (ListUtil.isNotEmpty(errorNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                    "以下行数（不计入空行）标准术语与数据库术语不匹配："
+                            + errorNumList.stream().collect(Collectors.joining("、"))
+                            + "。导入取消，请修改后再试。");
+        }
 
         //重复数据过滤
         diseaseConfigList = diseaseConfigList

cdssman-service/src/main/java/com/diagbot/facade/DrugConfigFacade.java

@@ -4,6 +4,7 @@ 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.diagbot.client.CdssCoreClient;
+import com.diagbot.dto.DictionaryInfoDTO;
 import com.diagbot.dto.HosRelationNumDTO;
 import com.diagbot.dto.RespDTO;
 import com.diagbot.entity.DrugConfig;
@@ -50,6 +51,8 @@ public class DrugConfigFacade {
     private DrugConfigService drugConfigService;
     @Autowired
     private CdssCoreClient cdssCoreClient;
+    @Autowired
+    private DictionaryFacade dictionaryFacade;
 
     /**
      * 判断是否已存在
@@ -282,13 +285,43 @@ public class DrugConfigFacade {
 
         //1、数据完整性校验
         //2、去除前后空格
+        //过滤空数据，保留重复数据，方便计行
+        drugConfigList = drugConfigList.stream()
+                .filter(i -> StringUtil.isNotBlank(i.getHisName())
+                        || StringUtil.isNotBlank(i.getForm())
+                        || StringUtil.isNotBlank(i.getUniqueCode())
+                        || StringUtil.isNotBlank(i.getUniqueName()))
+                .collect(Collectors.toList());
+        if (ListUtil.isEmpty(drugConfigList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+        List<String> emptyNumList = Lists.newLinkedList();
+        //药品剂型
+        List<DictionaryInfoDTO> dicTypeMappingList = dictionaryFacade.getListByGroupType(9);
+        List<String> formList = dicTypeMappingList.stream()
+                .filter(i -> StringUtil.isNotBlank(i.getName()))
+                .map(i -> i.getName())
+                .distinct()
+                .collect(Collectors.toList());
+        List<String> formErrNumList = Lists.newLinkedList();
         for (int i = 0; i < drugConfigList.size(); i++) {
             if (StringUtil.isBlank(drugConfigList.get(i).getHisName())
                     || StringUtil.isBlank(drugConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+                emptyNumList.add(String.valueOf(i + 2));
+            }
+            if (StringUtil.isNotBlank(drugConfigList.get(i).getHisName())) {
+                drugConfigList.get(i).setHisName(drugConfigList.get(i).getHisName().trim());
+            }
+            if (StringUtil.isNotBlank(drugConfigList.get(i).getUniqueName())) {
+                drugConfigList.get(i).setUniqueName(drugConfigList.get(i).getUniqueName().trim());
+            }
+            if (StringUtil.isNotBlank(drugConfigList.get(i).getForm())) {
+                if (!formList.contains(drugConfigList.get(i).getForm())) {
+                    formErrNumList.add(String.valueOf(i + 2));
+                } else {
+                    drugConfigList.get(i).setForm(drugConfigList.get(i).getForm().trim());
+                }
             }
-            drugConfigList.get(i).setHisName(drugConfigList.get(i).getHisName().trim());
-            drugConfigList.get(i).setUniqueName(drugConfigList.get(i).getUniqueName().trim());
             if (StringUtil.isNotBlank(drugConfigList.get(i).getUniqueCode())) {
                 drugConfigList.get(i).setUniqueCode(drugConfigList.get(i).getUniqueCode().trim());
             } else {
@@ -296,6 +329,17 @@ public class DrugConfigFacade {
             }
         }
 
+        if (ListUtil.isNotEmpty(emptyNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数（不计入空行）存在不完整数据："
+                    + emptyNumList.stream().collect(Collectors.joining("、"))
+                    + "。导入取消，请修改后再试。\n");
+        }
+        if (ListUtil.isNotEmpty(formErrNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数（不计入空行）药品剂型与数据库药品剂型不匹配："
+                    + formErrNumList.stream().collect(Collectors.joining("、"))
+                    + "。导入取消，请修改后再试。\n");
+        }
+
         List<String> hisNames = drugConfigList
                 .stream()
                 .map(i -> i.getHisName())
@@ -330,6 +374,7 @@ public class DrugConfigFacade {
         });
 
         //标准术语校验
+        List<String> errorNumList = Lists.newLinkedList();
         ConceptVO conceptVO = new ConceptVO();
         conceptVO.setNames(uniqueNames);
         conceptVO.setType(ConceptTypeEnum.Drug.getKey());
@@ -338,10 +383,15 @@ public class DrugConfigFacade {
         List<String> names = respDTO.data;
         for (int i = 0; i < drugConfigList.size(); i++) {
             if (!names.contains(drugConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                        "【" + drugConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+                errorNumList.add(String.valueOf(i + 2));
             }
         }
+        if (ListUtil.isNotEmpty(errorNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                    "以下行数（不计入空行）标准术语与数据库术语不匹配："
+                            + errorNumList.stream().collect(Collectors.joining("、"))
+                            + "。导入取消，请修改后再试。");
+        }
 
         //重复数据过滤
         drugConfigList = drugConfigList

cdssman-service/src/main/java/com/diagbot/facade/LisConfigFacade.java

@@ -282,13 +282,28 @@ public class LisConfigFacade{
 
         //1、数据完整性校验
         //2、去除前后空格
+        //过滤空数据，保留重复数据，方便计行
+        lisConfigList = lisConfigList.stream()
+                .filter(i -> StringUtil.isNotBlank(i.getHisName())
+                        || StringUtil.isNotBlank(i.getHisDetailName())
+                        || StringUtil.isNotBlank(i.getUniqueCode())
+                        || StringUtil.isNotBlank(i.getUniqueName()))
+                .collect(Collectors.toList());
+        if (ListUtil.isEmpty(lisConfigList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+        List<String> emptyNumList = Lists.newLinkedList();
         for (int i = 0; i < lisConfigList.size(); i++) {
             if (StringUtil.isBlank(lisConfigList.get(i).getHisName())
                     || StringUtil.isBlank(lisConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+                emptyNumList.add(String.valueOf(i + 2));
+            }
+            if (StringUtil.isNotBlank(lisConfigList.get(i).getHisName())) {
+                lisConfigList.get(i).setHisName(lisConfigList.get(i).getHisName().trim());
+            }
+            if (StringUtil.isNotBlank(lisConfigList.get(i).getUniqueName())) {
+                lisConfigList.get(i).setUniqueName(lisConfigList.get(i).getUniqueName().trim());
             }
-            lisConfigList.get(i).setHisName(lisConfigList.get(i).getHisName().trim());
-            lisConfigList.get(i).setUniqueName(lisConfigList.get(i).getUniqueName().trim());
             if (StringUtil.isNotBlank(lisConfigList.get(i).getUniqueCode())) {
                 lisConfigList.get(i).setUniqueCode(lisConfigList.get(i).getUniqueCode().trim());
             } else {
@@ -296,6 +311,12 @@ public class LisConfigFacade{
             }
         }
 
+        if (ListUtil.isNotEmpty(emptyNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数（不计入空行）存在不完整数据："
+                    + emptyNumList.stream().collect(Collectors.joining("、"))
+                    + "。导入取消，请修改后再试。\n");
+        }
+
         List<String> hisNames = lisConfigList
                 .stream()
                 .map(i -> i.getHisName())
@@ -339,6 +360,7 @@ public class LisConfigFacade{
         });
 
         //标准术语校验
+        List<String> errorNumList = Lists.newLinkedList();
         ConceptVO conceptVO = new ConceptVO();
         conceptVO.setNames(uniqueNames);
         conceptVO.setType(ConceptTypeEnum.LisPack.getKey());
@@ -352,10 +374,15 @@ public class LisConfigFacade{
         for (int i = 0; i < lisConfigList.size(); i++) {
             if (!lisPackNames.contains(lisConfigList.get(i).getUniqueName())
                     && !lisNames.contains(lisConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                        "【" + lisConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+                errorNumList.add(String.valueOf(i + 2));
             }
         }
+        if (ListUtil.isNotEmpty(errorNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                    "以下行数（不计入空行）标准术语与数据库术语不匹配："
+                            + errorNumList.stream().collect(Collectors.joining("、"))
+                            + "。导入取消，请修改后再试。");
+        }
 
         //重复数据过滤
         lisConfigList = lisConfigList

cdssman-service/src/main/java/com/diagbot/facade/OperationConfigFacade.java

@@ -255,13 +255,27 @@ public class OperationConfigFacade {
 
         //1、数据完整性校验
         //2、去除前后空格
+        //过滤空数据，保留重复数据，方便计行
+        operationConfigList = operationConfigList.stream()
+                .filter(i -> StringUtil.isNotBlank(i.getHisName())
+                        || StringUtil.isNotBlank(i.getUniqueCode())
+                        || StringUtil.isNotBlank(i.getUniqueName()))
+                .collect(Collectors.toList());
+        if (ListUtil.isEmpty(operationConfigList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+        List<String> emptyNumList = Lists.newLinkedList();
         for (int i = 0; i < operationConfigList.size(); i++) {
             if (StringUtil.isBlank(operationConfigList.get(i).getHisName())
                     || StringUtil.isBlank(operationConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+                emptyNumList.add(String.valueOf(i + 2));
+            }
+            if (StringUtil.isNotBlank(operationConfigList.get(i).getHisName())) {
+                operationConfigList.get(i).setHisName(operationConfigList.get(i).getHisName().trim());
+            }
+            if (StringUtil.isNotBlank(operationConfigList.get(i).getUniqueName())) {
+                operationConfigList.get(i).setUniqueName(operationConfigList.get(i).getUniqueName().trim());
             }
-            operationConfigList.get(i).setHisName(operationConfigList.get(i).getHisName().trim());
-            operationConfigList.get(i).setUniqueName(operationConfigList.get(i).getUniqueName().trim());
             if (StringUtil.isNotBlank(operationConfigList.get(i).getUniqueCode())) {
                 operationConfigList.get(i).setUniqueCode(operationConfigList.get(i).getUniqueCode().trim());
             } else {
@@ -269,6 +283,12 @@ public class OperationConfigFacade {
             }
         }
 
+        if (ListUtil.isNotEmpty(emptyNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数（不计入空行）存在不完整数据："
+                    + emptyNumList.stream().collect(Collectors.joining("、"))
+                    + "。导入取消，请修改后再试。\n");
+        }
+
         // 验证数据是否已存在，已存在的先删除
         // 没id的删除重新插入，有id的更新
         List<Long> deleteIds = Lists.newLinkedList();
@@ -291,6 +311,7 @@ public class OperationConfigFacade {
         });
 
         //标准术语校验
+        List<String> errorNumList = Lists.newLinkedList();
         List<String> uniqueNames = operationConfigList.stream()
                 .map(i -> i.getUniqueName())
                 .distinct()
@@ -303,10 +324,15 @@ public class OperationConfigFacade {
         List<String> names = respDTO.data;
         for (int i = 0; i < operationConfigList.size(); i++) {
             if (!names.contains(operationConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                        "【" + operationConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+                errorNumList.add(String.valueOf(i + 2));
             }
         }
+        if (ListUtil.isNotEmpty(errorNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                    "以下行数（不计入空行）标准术语与数据库术语不匹配："
+                            + errorNumList.stream().collect(Collectors.joining("、"))
+                            + "。导入取消，请修改后再试。");
+        }
 
         //重复数据过滤
         operationConfigList = operationConfigList

cdssman-service/src/main/java/com/diagbot/facade/PacsConfigFacade.java

@@ -253,13 +253,27 @@ public class PacsConfigFacade {
 
         //1、数据完整性校验
         //2、去除前后空格
+        //过滤空数据，保留重复数据，方便计行
+        pacsConfigList = pacsConfigList.stream()
+                .filter(i -> StringUtil.isNotBlank(i.getHisName())
+                        || StringUtil.isNotBlank(i.getUniqueCode())
+                        || StringUtil.isNotBlank(i.getUniqueName()))
+                .collect(Collectors.toList());
+        if (ListUtil.isEmpty(pacsConfigList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+        List<String> emptyNumList = Lists.newLinkedList();
         for (int i = 0; i < pacsConfigList.size(); i++) {
             if (StringUtil.isBlank(pacsConfigList.get(i).getHisName())
                     || StringUtil.isBlank(pacsConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+                emptyNumList.add(String.valueOf(i + 2));
+            }
+            if (StringUtil.isNotBlank(pacsConfigList.get(i).getHisName())) {
+                pacsConfigList.get(i).setHisName(pacsConfigList.get(i).getHisName().trim());
+            }
+            if (StringUtil.isNotBlank(pacsConfigList.get(i).getUniqueName())) {
+                pacsConfigList.get(i).setUniqueName(pacsConfigList.get(i).getUniqueName().trim());
             }
-            pacsConfigList.get(i).setHisName(pacsConfigList.get(i).getHisName().trim());
-            pacsConfigList.get(i).setUniqueName(pacsConfigList.get(i).getUniqueName().trim());
             if (StringUtil.isNotBlank(pacsConfigList.get(i).getUniqueCode())) {
                 pacsConfigList.get(i).setUniqueCode(pacsConfigList.get(i).getUniqueCode().trim());
             } else {
@@ -267,6 +281,12 @@ public class PacsConfigFacade {
             }
         }
 
+        if (ListUtil.isNotEmpty(emptyNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数（不计入空行）存在不完整数据："
+                    + emptyNumList.stream().collect(Collectors.joining("、"))
+                    + "。导入取消，请修改后再试。\n");
+        }
+
         // 验证数据是否已存在，已存在的先删除
         // 没id的删除重新插入，有id的更新
         List<Long> deleteIds = Lists.newLinkedList();
@@ -289,6 +309,7 @@ public class PacsConfigFacade {
         });
 
         //标准术语校验
+        List<String> errorNumList = Lists.newLinkedList();
         List<String> uniqueNames = pacsConfigList.stream()
                 .map(i -> i.getUniqueName())
                 .distinct()
@@ -301,10 +322,15 @@ public class PacsConfigFacade {
         List<String> names = respDTO.data;
         for (int i = 0; i < pacsConfigList.size(); i++) {
             if (!names.contains(pacsConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                        "【" + pacsConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+                errorNumList.add(String.valueOf(i + 2));
             }
         }
+        if (ListUtil.isNotEmpty(errorNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                    "以下行数（不计入空行）标准术语与数据库术语不匹配："
+                            + errorNumList.stream().collect(Collectors.joining("、"))
+                            + "。导入取消，请修改后再试。");
+        }
 
         //重复数据过滤
         pacsConfigList = pacsConfigList

cdssman-service/src/main/java/com/diagbot/facade/TransfusionConfigFacade.java

@@ -253,13 +253,27 @@ public class TransfusionConfigFacade {
 
         //1、数据完整性校验
         //2、去除前后空格
+        //过滤空数据，保留重复数据，方便计行
+        transfusionConfigList = transfusionConfigList.stream()
+                .filter(i -> StringUtil.isNotBlank(i.getHisName())
+                        || StringUtil.isNotBlank(i.getUniqueCode())
+                        || StringUtil.isNotBlank(i.getUniqueName()))
+                .collect(Collectors.toList());
+        if (ListUtil.isEmpty(transfusionConfigList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+        List<String> emptyNumList = Lists.newLinkedList();
         for (int i = 0; i < transfusionConfigList.size(); i++) {
             if (StringUtil.isBlank(transfusionConfigList.get(i).getHisName())
                     || StringUtil.isBlank(transfusionConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+                emptyNumList.add(String.valueOf(i + 2));
+            }
+            if (StringUtil.isNotBlank(transfusionConfigList.get(i).getHisName())) {
+                transfusionConfigList.get(i).setHisName(transfusionConfigList.get(i).getHisName().trim());
+            }
+            if (StringUtil.isNotBlank(transfusionConfigList.get(i).getUniqueName())) {
+                transfusionConfigList.get(i).setUniqueName(transfusionConfigList.get(i).getUniqueName().trim());
             }
-            transfusionConfigList.get(i).setHisName(transfusionConfigList.get(i).getHisName().trim());
-            transfusionConfigList.get(i).setUniqueName(transfusionConfigList.get(i).getUniqueName().trim());
             if (StringUtil.isNotBlank(transfusionConfigList.get(i).getUniqueCode())) {
                 transfusionConfigList.get(i).setUniqueCode(transfusionConfigList.get(i).getUniqueCode().trim());
             } else {
@@ -267,6 +281,12 @@ public class TransfusionConfigFacade {
             }
         }
 
+        if (ListUtil.isNotEmpty(emptyNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数（不计入空行）存在不完整数据："
+                    + emptyNumList.stream().collect(Collectors.joining("、"))
+                    + "。导入取消，请修改后再试。\n");
+        }
+
         // 验证数据是否已存在，已存在的先删除
         // 没id的删除重新插入，有id的更新
         List<Long> deleteIds = Lists.newLinkedList();
@@ -289,6 +309,7 @@ public class TransfusionConfigFacade {
         });
 
         //标准术语校验
+        List<String> errorNumList = Lists.newLinkedList();
         List<String> uniqueNames = transfusionConfigList.stream()
                 .map(i -> i.getUniqueName())
                 .distinct()
@@ -301,10 +322,15 @@ public class TransfusionConfigFacade {
         List<String> names = respDTO.data;
         for (int i = 0; i < transfusionConfigList.size(); i++) {
             if (!names.contains(transfusionConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                        "【" + transfusionConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+                errorNumList.add(String.valueOf(i + 2));
             }
         }
+        if (ListUtil.isNotEmpty(errorNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                    "以下行数（不计入空行）标准术语与数据库术语不匹配："
+                            + errorNumList.stream().collect(Collectors.joining("、"))
+                            + "。导入取消，请修改后再试。");
+        }
 
         //重复数据过滤
         transfusionConfigList = transfusionConfigList