Merge remote-tracking branch 'origin/dev/neo2mysql20210120' into dev/neo2mysql20210120

src/main/java/com/diagbot/enums/LexiconEnum.java

@@ -0,0 +1,102 @@
+package com.diagbot.enums;
+
+import com.diagbot.core.KeyedNamed;
+import lombok.Setter;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2021/2/24 10:46
+ */
+public enum LexiconEnum implements KeyedNamed {
+
+    Disease(100,"疾病"),
+    Medicine(101,"药品通用名"),
+    Form(102,"药品剂型"),
+    Symptom(103,"症状"),
+    Vital(104,"体格检查项目"),
+    VitalResult(105,"体格检查结果"),
+    Operation(106,"手术和操作"),
+    LisName(107,"实验室检查套餐"),
+    LisSubName(108,"实验室检查子项目"),
+    PacsName(109,"辅助检查项目"),
+    PacsSubName(110,"辅助检查子项目"),
+    PacsDescribe(111,"辅助检查描述"),
+    PacsResult(112,"辅助检查结果"),
+    Transfusion(113,"输血类型"),
+    Anesthesia(114,"麻醉"),
+    Dept(115,"科室"),
+    Gender(116,"性别"),
+    Group(117,"人群"),
+    Food(118,"食物"),
+    Allergen(119,"其他过敏原"),
+    Device(120,"医疗器械及物品"),
+    AdministrationRoute(121,"给药途径"),
+    Part(122,"部位"),
+    Nurse(123,"护理"),
+    Scale(124,"量表"),
+    Unit(125,"单位"),
+    ICD10Class(300,"ICD10疾病类别"),
+    MedChemClass(301,"药品化学物质类别"),
+    MedZhiLiaoClass(302,"药品治疗学类别"),
+    MedYaoLiClass(303,"药品药理学类别"),
+    MedJiePouClass(304,"药品解剖学类别"),
+    SymptomClass(305,"症状类别"),
+    OperationClass(306,"手术和操作类别"),
+    ICD10ClassNode(400,"ICD10疾病类别根节点"),
+    DeptDiseaseNode(401,"科室疾病类别根节点"),
+    MedChemClassNode(402,"药品化学物质类别根节点"),
+    MedZhiLiaoClassNode(403,"药品治疗学类别根节点"),
+    MedYaoLiClassNode(404,"药品药理学类别根节点"),
+    MedJiePouClassNode(405,"药品解剖学类别根节点"),
+    SymptomClassNode(406,"症状类别根节点"),
+    OperationClassNode(407,"手术和操作类别根节点"),
+    LisClassNode(408,"实验室检查类别根节点"),
+    PacsClassNode(409,"辅助检查类别根节点"),
+    Age(410,"年龄");
+
+
+    @Setter
+    private int key;
+
+    @Setter
+    private String name;
+
+    LexiconEnum(int key, String name) {
+        this.key = key;
+        this.name = name;
+    }
+
+    public static LexiconEnum getEnum(int key) {
+        for (LexiconEnum item : LexiconEnum.values()) {
+            if (item.key == key) {
+                return item;
+            }
+        }
+        return null;
+    }
+
+    public static LexiconEnum getEnum(String value) {
+        for (LexiconEnum item : LexiconEnum.values()) {
+            if (item.getName().equals(value)) {
+                return item;
+            }
+        }
+        return null;
+    }
+
+    public static String getName(int key) {
+        LexiconEnum item = getEnum(key);
+        return item != null ? item.name : null;
+    }
+
+    @Override
+    public int getKey() {
+        return key;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+}

src/main/java/com/diagbot/enums/StatusEnum.java

@@ -0,0 +1,50 @@
+package com.diagbot.enums;
+
+import com.diagbot.core.KeyedNamed;
+import lombok.Setter;
+
+/**
+ * @author wangfeng
+ * @Description:
+ * @date 2018年11月21日 下午2:31:42
+ */
+public enum StatusEnum implements KeyedNamed {
+    Disable(0, "禁用"),
+    Enable(1, "启用");
+
+    @Setter
+    private int key;
+
+    @Setter
+    private String name;
+
+    StatusEnum(int key, String name) {
+        this.key = key;
+        this.name = name;
+    }
+
+    public static StatusEnum getEnum(int key) {
+        for (StatusEnum item : StatusEnum.values()) {
+            if (item.key == key) {
+                return item;
+            }
+        }
+        return null;
+    }
+
+    public static String getName(int key) {
+        StatusEnum item = getEnum(key);
+        return item != null ? item.name : null;
+    }
+
+    @Override
+    public int getKey() {
+        return key;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+}
+

src/main/java/com/diagbot/facade/KlConceptDetailFacade.java

@@ -0,0 +1,13 @@
+package com.diagbot.facade;
+
+import com.diagbot.service.impl.KlConceptDetailServiceImpl;
+import org.springframework.stereotype.Component;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2021/2/24 11:25
+ */
+@Component
+public class KlConceptDetailFacade extends KlConceptDetailServiceImpl {
+}

src/main/java/com/diagbot/facade/KlConceptStaticFacade.java

@@ -1,8 +1,31 @@
 package com.diagbot.facade;
 
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.diagbot.dto.StaticKnowledgeDTO;
+import com.diagbot.dto.StaticKnowledgeDetailDTO;
+import com.diagbot.entity.KlConcept;
+import com.diagbot.entity.KlConceptDetail;
+import com.diagbot.entity.KlConceptStatic;
+import com.diagbot.entity.KlRelation;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.enums.LexiconEnum;
+import com.diagbot.enums.StatusEnum;
+import com.diagbot.exception.CommonErrorCode;
+import com.diagbot.exception.CommonException;
 import com.diagbot.service.impl.KlConceptStaticServiceImpl;
+import com.diagbot.util.BeanUtil;
+import com.diagbot.util.ListUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.StaticKnowledgeVO;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
 /**
  * @Description:
  * @Author:zhaops
@@ -10,4 +33,175 @@ import org.springframework.stereotype.Component;
  */
 @Component
 public class KlConceptStaticFacade extends KlConceptStaticServiceImpl {
+    @Autowired
+    private KlConceptFacade klConceptFacade;
+    @Autowired
+    private KlRelationFacade klRelationFacade;
+    @Autowired
+    private KlConceptDetailFacade klConceptDetailFacade;
+    @Autowired
+    private DictionaryFacade dictionaryFacade;
+
+    /**
+     * 页面获取静态知识
+     *
+     * @param staticKnowledgeVO
+     * @return
+     */
+    public StaticKnowledgeDTO getStaticKnowledge(StaticKnowledgeVO staticKnowledgeVO) {
+        StaticKnowledgeDTO staticKnowledgeDTO = new StaticKnowledgeDTO();
+        Integer type = convertType(staticKnowledgeVO.getType());
+        if (type == null) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_ERROR, "请输入正确类型（1-诊断、2-药品、3-检验套餐、4-检验细项、5-检查、6-检查子项、7-手术和操作）");
+        }
+        staticKnowledgeVO.setType(type);
+
+        KlConcept concept = klConceptFacade.getOne(new QueryWrapper<KlConcept>()
+                .eq("is_deleted", IsDeleteEnum.N.getKey())
+                .eq("lib_name", staticKnowledgeVO.getName())
+                .eq("lib_type", type), false);
+        if (concept == null) {
+            throw new CommonException(CommonErrorCode.NOT_EXISTS, "标准词不存在");
+        }
+
+        KlConceptStatic staticInfo = this.getOne(new QueryWrapper<KlConceptStatic>()
+                .eq("is_deleted", IsDeleteEnum.N.getKey())
+                .eq("concept_id", concept.getId())
+                .eq("status", StatusEnum.Enable.getKey()), false);
+
+        if (staticInfo == null) {
+            //检验子项或检查子项向上级取静态知识
+            if (type.equals(LexiconEnum.LisSubName.getKey())
+                    || type.equals(LexiconEnum.PacsSubName.getKey())) {
+                List<KlRelation> relations = klRelationFacade.list(new QueryWrapper<KlRelation>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("end_id", concept.getId())
+                        .eq("relation_id", 600));
+                if (ListUtil.isNotEmpty(relations)) {
+                    staticInfo = this.getOne(new QueryWrapper<KlConceptStatic>()
+                            .eq("is_deleted", IsDeleteEnum.N.getKey())
+                            .in("concept_id", relations.stream().map(i -> i.getStartId()).collect(Collectors.toList()))
+                            .eq("status", StatusEnum.Enable.getKey()), false);
+                    if (staticInfo == null) {
+                        throw new CommonException(CommonErrorCode.NOT_EXISTS, "缺少静态信息");
+                    }
+                    concept = klConceptFacade.getById(staticInfo.getConceptId());
+                } else {
+                    throw new CommonException(CommonErrorCode.NOT_EXISTS, "缺少静态信息");
+                }
+            } else {
+                throw new CommonException(CommonErrorCode.NOT_EXISTS, "缺少静态信息");
+            }
+        }
+
+        //详情信息
+        String sql = "";
+        if (ListUtil.isNotEmpty(staticKnowledgeVO.getContentTypes())) {
+
+            for (Integer contentType : staticKnowledgeVO.getContentTypes()) {
+                if (contentType.equals(0)) {
+                    sql = "";
+                    break;
+                }
+                if (StringUtil.isNotBlank(sql)) {
+                    sql += " or ";
+                }
+                sql += "find_in_set(" + contentType + ",content_type)";
+            }
+            if (StringUtil.isNotBlank(sql)) {
+                sql = "(" + sql + ")";
+            }
+        }
+        List<KlConceptDetail> details = klConceptDetailFacade.list(new QueryWrapper<KlConceptDetail>()
+                .eq("is_deleted", IsDeleteEnum.N.getKey())
+                .eq("concept_id", concept.getId())
+                .apply(sql)
+                .orderByAsc("order_no"));
+
+        List<StaticKnowledgeDetailDTO> detailList
+                = BeanUtil.listCopyTo(details, StaticKnowledgeDetailDTO.class);
+        List<StaticKnowledgeDetailDTO> introduceList = detailList
+                .stream()
+                .filter(i -> Arrays.asList(i.getContentType().split(",")).contains("1"))
+                .collect(Collectors.toList());
+        List<StaticKnowledgeDetailDTO> noticeList = detailList
+                .stream()
+                .filter(i -> Arrays.asList(i.getContentType().split(",")).contains("2"))
+                .collect(Collectors.toList());
+        List<StaticKnowledgeDetailDTO> clinicalPathwayList = detailList
+                .stream()
+                .filter(i -> Arrays.asList(i.getContentType().split(",")).contains("3"))
+                .collect(Collectors.toList());
+        List<StaticKnowledgeDetailDTO> treatInfoList = detailList
+                .stream()
+                .filter(i -> Arrays.asList(i.getContentType().split(",")).contains("4"))
+                .collect(Collectors.toList());
+        Map<String, List<StaticKnowledgeDetailDTO>> detailMap = new HashMap<>();
+        if (ListUtil.isEmpty(staticKnowledgeVO.getContentTypes()) || staticKnowledgeVO.getContentTypes().contains(0)) {
+            if (ListUtil.isNotEmpty(introduceList)) {
+                detailMap.put("静态知识", introduceList);
+            }
+            if (ListUtil.isNotEmpty(noticeList)) {
+                detailMap.put("注意事项", noticeList);
+            }
+            if (ListUtil.isNotEmpty(clinicalPathwayList)) {
+                detailMap.put("临床路径", clinicalPathwayList);
+            }
+            if (ListUtil.isNotEmpty(treatInfoList)) {
+                detailMap.put("治疗方案", treatInfoList);
+            }
+        } else {
+            if (ListUtil.isNotEmpty(introduceList) && staticKnowledgeVO.getContentTypes().contains(1)) {
+                detailMap.put("静态知识", introduceList);
+            }
+            if (ListUtil.isNotEmpty(noticeList) && staticKnowledgeVO.getContentTypes().contains(2)) {
+                detailMap.put("注意事项", noticeList);
+            }
+            if (ListUtil.isNotEmpty(clinicalPathwayList) && staticKnowledgeVO.getContentTypes().contains(3)) {
+                detailMap.put("临床路径", clinicalPathwayList);
+            }
+            if (ListUtil.isNotEmpty(treatInfoList) && staticKnowledgeVO.getContentTypes().contains(4)) {
+                detailMap.put("治疗方案", treatInfoList);
+            }
+        }
+
+        staticKnowledgeDTO.setId(concept.getId());
+        staticKnowledgeDTO.setName(concept.getLibName());
+        staticKnowledgeDTO.setType(concept.getLibType().toString());
+        staticKnowledgeDTO.setClinicalPathwayName(staticInfo.getClinicalPathwayName());
+        staticKnowledgeDTO.setNoticeName(staticInfo.getNoticeName());
+        staticKnowledgeDTO.setDetails(detailMap);
+        return staticKnowledgeDTO;
+    }
+
+    public Integer convertType(Integer type) {
+        Integer retType = null;
+        //1-诊断、2-药品、3-检验套餐、4-检验细项、5-检查、6-检查子项、7-手术和操作
+        switch (type) {
+            case 1:
+                retType = LexiconEnum.Disease.getKey();
+                break;
+            case 2:
+                retType = LexiconEnum.Medicine.getKey();
+                break;
+            case 3:
+                retType = LexiconEnum.LisName.getKey();
+                break;
+            case 4:
+                retType = LexiconEnum.LisSubName.getKey();
+                break;
+            case 5:
+                retType = LexiconEnum.PacsName.getKey();
+                break;
+            case 6:
+                retType = LexiconEnum.PacsSubName.getKey();
+                break;
+            case 7:
+                retType = LexiconEnum.Operation.getKey();
+                break;
+            default:
+                break;
+        }
+        return retType;
+    }
 }

src/main/java/com/diagbot/facade/MedRetrievalFacade.java

@@ -59,16 +59,16 @@ public class MedRetrievalFacade {
          */
         switch (retrievalVO.getType()) {
             case 1:
-                medRetrievalVO.setTypeId(107L);
-                medRetrievalVO.getTypeIds().add(107L);
+                medRetrievalVO.setTypeId(107);
+                medRetrievalVO.getTypeIds().add(107);
                 indexList = klConceptFacade.index(medRetrievalVO);
                 if (ListUtil.isNotEmpty(indexList)) {
                     retrievalDTO.setLisNames(indexList.stream().map(i -> i.getName()).collect(Collectors.toList()));
                 }
                 break;
             case 2:
-                medRetrievalVO.setTypeId(108L);
-                medRetrievalVO.getTypeIds().add(108L);
+                medRetrievalVO.setTypeId(108);
+                medRetrievalVO.getTypeIds().add(108);
                 indexList = klConceptFacade.index(medRetrievalVO);
                 if (ListUtil.isNotEmpty(indexList)) {
                     List<LisDetailDTO> lisDetails = Lists.newLinkedList();
@@ -87,56 +87,56 @@ public class MedRetrievalFacade {
                 }
                 break;
             case 3:
-                medRetrievalVO.setTypeId(109L);
-                medRetrievalVO.getTypeIds().addAll(Arrays.asList(new Long[] { 109L, 110L }));
+                medRetrievalVO.setTypeId(109);
+                medRetrievalVO.getTypeIds().addAll(Arrays.asList(new Integer[] { 109, 110 }));
                 indexList = klConceptFacade.index(medRetrievalVO);
                 if (ListUtil.isNotEmpty(indexList)) {
                     retrievalDTO.setPacsNames(indexList.stream().map(i -> i.getName()).collect(Collectors.toList()));
                 }
                 break;
             case 4:
-                medRetrievalVO.setTypeId(100L);
-                medRetrievalVO.getTypeIds().add(100L);
+                medRetrievalVO.setTypeId(100);
+                medRetrievalVO.getTypeIds().add(100);
                 indexList = klConceptFacade.index(medRetrievalVO);
                 if (ListUtil.isNotEmpty(indexList)) {
                     retrievalDTO.setDiseaseNames(BeanUtil.listCopyTo(indexList, DiseaseInfoDTO.class));
                 }
                 break;
             case 5:
-                medRetrievalVO.setTypeId(101L);
-                medRetrievalVO.getTypeIds().add(101L);
+                medRetrievalVO.setTypeId(101);
+                medRetrievalVO.getTypeIds().add(101);
                 indexList = klConceptFacade.index(medRetrievalVO);
                 if (ListUtil.isNotEmpty(indexList)) {
                     retrievalDTO.setDrugNames(BeanUtil.listCopyTo(indexList, DrugInfoDTO.class));
                 }
                 break;
             case 6:
-                medRetrievalVO.setTypeId(106L);
-                medRetrievalVO.getTypeIds().add(106L);
+                medRetrievalVO.setTypeId(106);
+                medRetrievalVO.getTypeIds().add(106);
                 indexList = klConceptFacade.index(medRetrievalVO);
                 if (ListUtil.isNotEmpty(indexList)) {
                     retrievalDTO.setOperationNames(BeanUtil.listCopyTo(indexList, OperationInfoDTO.class));
                 }
                 break;
             case 7:
-                medRetrievalVO.setTypeId(115L);
-                medRetrievalVO.getTypeIds().add(115L);
+                medRetrievalVO.setTypeId(115);
+                medRetrievalVO.getTypeIds().add(115);
                 indexList = klConceptFacade.index(medRetrievalVO);
                 if (ListUtil.isNotEmpty(indexList)) {
                     retrievalDTO.setDeptNames(indexList.stream().map(i -> i.getName()).collect(Collectors.toList()));
                 }
                 break;
             case 8:
-                medRetrievalVO.setTypeId(113L);
-                medRetrievalVO.getTypeIds().add(113L);
+                medRetrievalVO.setTypeId(113);
+                medRetrievalVO.getTypeIds().add(113);
                 indexList = klConceptFacade.index(medRetrievalVO);
                 if (ListUtil.isNotEmpty(indexList)) {
                     retrievalDTO.setTransfusionNames(indexList.stream().map(i -> i.getName()).collect(Collectors.toList()));
                 }
                 break;
             case 9:
-                medRetrievalVO.setTypeId(103L);
-                medRetrievalVO.getTypeIds().add(103L);
+                medRetrievalVO.setTypeId(103);
+                medRetrievalVO.getTypeIds().add(103);
                 indexList = klConceptFacade.index(medRetrievalVO);
                 if (ListUtil.isNotEmpty(indexList)) {
                     retrievalDTO.setSymptomNames(indexList.stream().map(i -> i.getName()).collect(Collectors.toList()));
@@ -167,24 +167,24 @@ public class MedRetrievalFacade {
         //检索类型（多选）：0-全部、1-诊断、2-药品、3-检验、4-检查、5-手术和操作
         if (ListUtil.isEmpty(types)
                 || (ListUtil.isNotEmpty(types) && types.contains(0))) {
-            staticKnowledgeIndexVO.getTypeIds().addAll(Arrays.asList(new Long[] { 100L, 101L, 106L, 107L, 108L, 109L, 110L }));
+            staticKnowledgeIndexVO.getTypeIds().addAll(Arrays.asList(new Integer[] { 100, 101, 106, 107, 108, 109, 110 }));
         } else {
             if (types.contains(1)) {
-                staticKnowledgeIndexVO.getTypeIds().add(100L);
+                staticKnowledgeIndexVO.getTypeIds().add(100);
             }
             if (types.contains(2)) {
-                staticKnowledgeIndexVO.getTypeIds().add(101L);
+                staticKnowledgeIndexVO.getTypeIds().add(101);
             }
             if (types.contains(3)) {
-                staticKnowledgeIndexVO.getTypeIds().add(107L);
-                staticKnowledgeIndexVO.getTypeIds().add(108L);
+                staticKnowledgeIndexVO.getTypeIds().add(107);
+                staticKnowledgeIndexVO.getTypeIds().add(108);
             }
             if (types.contains(5)) {
-                staticKnowledgeIndexVO.getTypeIds().add(109L);
-                staticKnowledgeIndexVO.getTypeIds().add(110L);
+                staticKnowledgeIndexVO.getTypeIds().add(109);
+                staticKnowledgeIndexVO.getTypeIds().add(110);
             }
             if (types.contains(6)) {
-                staticKnowledgeIndexVO.getTypeIds().add(106L);
+                staticKnowledgeIndexVO.getTypeIds().add(106);
             }
         }
 

src/main/java/com/diagbot/vo/MedRetrievalVO.java

@@ -13,6 +13,6 @@ import java.util.List;
 @Getter
 @Setter
 public class MedRetrievalVO extends RetrievalVO {
-    private Long typeId;
-    private List<Long> typeIds;
+    private Integer typeId;
+    private List<Integer> typeIds;
 }

src/main/java/com/diagbot/vo/StaticKnowledgeIndexVO.java

@@ -34,7 +34,7 @@ public class StaticKnowledgeIndexVO {
     private Integer hasInfo;
 
     @ApiModelProperty(hidden = true)
-    private List<Long> typeIds;
+    private List<Integer> typeIds;
 
     @ApiModelProperty(hidden = true)
     private Integer size;

src/main/java/com/diagbot/vo/StaticKnowledgeVO.java

@@ -0,0 +1,30 @@
+package com.diagbot.vo;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.validation.constraints.NotNull;
+import java.util.List;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/8/20 14:50
+ */
+@Getter
+@Setter
+public class StaticKnowledgeVO {
+    /**
+     * 标准术语名称
+     */
+    private String name;
+    /**
+     * 术语类型
+     */
+    @NotNull(message = "请输入术语类型：1-诊断、2-药品、3-检验套餐、4-检验细项、5-检查、6-检查子项、7-手术和操作")
+    private Integer type;
+    /**
+     * 内容类型：1-化验、辅检、手术和操作、诊断、药品静态信息，2-注意事项，3-临床路径，4-治疗方案
+     */
+    private List<Integer> contentTypes;
+}

src/main/java/com/diagbot/web/KlConceptStaticController.java

@@ -0,0 +1,40 @@
+package com.diagbot.web;
+
+import com.diagbot.annotation.SysLogger;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.StaticKnowledgeDTO;
+import com.diagbot.facade.KlConceptStaticFacade;
+import com.diagbot.vo.StaticKnowledgeVO;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.validation.Valid;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2021/2/24 11:34
+ */
+@RestController
+@RequestMapping("/kl/concept_static")
+@Api(value = "静态知识维护相关API", tags = { "静态知识维护相关API" })
+public class KlConceptStaticController {
+    @Autowired
+    KlConceptStaticFacade klConceptStaticFacade;
+
+    @ApiOperation(value = "页面获取静态知识[zhaops]",
+            notes = "type： 类型：1-诊断、2-药品、3-检验套餐、4-检验细项、5-检查、6-检查子项、7-手术和操作 <br>" +
+                    "contentTypes： 内容类型（多选）：1-静态信息、2-注意事项、3-临床路径、4-治疗方案<br>" +
+                    "name： 标准术语名称<br>")
+    @PostMapping("/getStaticKnowledge")
+    @SysLogger("getStaticKnowledge")
+    public RespDTO<StaticKnowledgeDTO> getStaticKnowledge(@Valid @RequestBody StaticKnowledgeVO staticKnowledgeVO) {
+        StaticKnowledgeDTO data = klConceptStaticFacade.getStaticKnowledge(staticKnowledgeVO);
+        return RespDTO.onSuc(data);
+    }
+}

src/main/resources/mapper/KlConceptStaticMapper.xml

@@ -16,4 +16,27 @@
         <result column="notice_name" property="noticeName" />
     </resultMap>
 
+    <select id="getStaticInfo" resultType="com.diagbot.entity.KlConceptStatic">
+        SELECT
+        b.*
+        FROM
+        kl_concept a,
+        kl_concept_static b,
+        kl_lexicon c
+        WHERE
+        a.is_deleted = 'N'
+        AND b.is_deleted = 'N'
+        AND c.is_deleted = 'N'
+        AND a.id = b.concept_id
+        AND a.lib_type = c.CODE
+        <if test="status!=null and status!=''">
+            AND b.`status` = #{status}
+        </if>
+        <if test="name!=null and name!=''">
+            AND a.lib_name = #{name}
+        </if>
+        <if test="typeName!=null and typeName!=''">
+            AND c.NAME = #{typeName}
+        </if>
+    </select>
 </mapper>