经典病例后台功能添加(bug修改)

src/main/java/com/diagbot/dto/ClassicCaseDTO.java

@@ -0,0 +1,40 @@
+package com.diagbot.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/8/20 15:51
+ */
+@Getter
+@Setter
+public class ClassicCaseDTO {
+    /**
+     * 标准术语id
+     */
+    private Long id;
+    /**
+     * 标准术语
+     */
+    private String name;
+
+    /**
+     * 词性
+     */
+    private String type;
+
+    /**
+     * 静态知识明细
+     */
+    private Map<String, List<ClassicCaseDetailDTO>> details;
+
+    /**
+     * 量表结构
+     */
+    private ConceptScaleDTO scale;
+}

src/main/java/com/diagbot/dto/ClassicCaseDetailDTO.java

@@ -0,0 +1,43 @@
+package com.diagbot.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2021/2/24 13:39
+ */
+@Getter
+@Setter
+public class ClassicCaseDetailDTO {
+    /**
+     * 提示概念id
+     */
+    private Long conceptId;
+
+    /**
+     * 提示明细标题
+     */
+    private String title;
+
+    /**
+     * 提示明细内容
+     */
+    private String content;
+
+    /**
+     * 纯文本
+     */
+    private String text;
+
+    /**
+     * 提示明细序号
+     */
+    private Integer orderNo;
+
+    /**
+     * 内容类型（多选）：1-化验、辅检、手术和操作、诊断、药品静态信息，2-注意事项，3-临床路径，4-治疗方案，5-诊疗指南
+     */
+    private String contentType;
+}

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

@@ -84,7 +84,7 @@ public enum LexiconEnum implements KeyedNamed {
     LisClassNode(408,"实验室检查类别根节点"),
     PacsClassNode(409,"辅助检查类别根节点"),
     Age(410,"年龄"),
-    ClassicCase(411,"经典病例");
+    ClassicCase(411,"经典病历");
 
 
     @Setter

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

@@ -19,16 +19,13 @@ import com.diagbot.service.impl.KlDiseaseServiceImpl;
 import com.diagbot.util.*;
 import com.diagbot.vo.*;
 import com.google.common.collect.Lists;
-import org.apache.commons.lang3.StringUtils;
+import io.micrometer.core.instrument.util.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Component;
 import org.springframework.web.multipart.MultipartFile;
 
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.stream.Collectors;
 
 /**
@@ -71,7 +68,88 @@ public class KlClassicCaseFacade extends KlClassicCaseServiceImpl {
     KlConceptService klConceptService;
 
     /**
-     * 经典病例分页查询
+     * 获取经典病历
+     *
+     * @param staticKnowledgeVO
+     * @return
+     */
+    public ClassicCaseDTO getClassicCaseInfo(StaticKnowledgeVO staticKnowledgeVO) {
+        ClassicCaseDTO classicCaseDTO = new ClassicCaseDTO();
+        Integer type = convertType(staticKnowledgeVO.getType(), 1);
+        if (type == null) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_ERROR, "请输入正确类型（11-经典病例）");
+        }
+        staticKnowledgeVO.setType(type);
+
+        KlConcept concept = klConceptFacade.getOne(new QueryWrapper<KlConcept>()
+                .eq("is_deleted", IsDeleteEnum.N.getKey())
+                .eq("lib_name", staticKnowledgeVO.getName())
+                .eq("status", StatusEnum.Enable.getKey())
+                .eq("lib_type", type), false);
+
+        Integer sameType = 0;
+
+        KlClassicCase caseInfo = this.getOne(new QueryWrapper<KlClassicCase>()
+                .eq("is_deleted", IsDeleteEnum.N.getKey())
+                .eq("concept_id", concept.getId())
+                .eq("status", StatusEnum.Enable.getKey()), false);
+        if (caseInfo != null) {
+            staticKnowledgeVO.setType(sameType);
+        }
+
+        //经典病例详情
+//        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<KlCaseDetail> details = klCaseDetailFacade.list(new QueryWrapper<KlCaseDetail>()
+                .eq("is_deleted", IsDeleteEnum.N.getKey())
+                .eq("concept_id", concept.getId())
+//                .apply(sql)
+                .orderByAsc("order_no"));
+
+        List<ClassicCaseDetailDTO> detailList
+                = BeanUtil.listCopyTo(details, ClassicCaseDetailDTO.class);
+        List<ClassicCaseDetailDTO> introduceList = detailList
+                .stream()
+                .collect(Collectors.toList());
+        //Map<String, List<StaticKnowledgeDetailDTO>> detailMap = new HashMap<>();
+        Map<String, List<ClassicCaseDetailDTO>> detailMap = new HashMap<>();
+        if (ListUtil.isNotEmpty(introduceList) && staticKnowledgeVO.getContentTypes().contains(1)) {
+            detailMap.put("经典病历", introduceList);
+        }
+
+        if (type.equals(LexiconEnum.Scale.getKey())) {
+            //量表详情
+            ScaleVO scaleVO = new ScaleVO();
+            BeanUtil.copyProperties(staticKnowledgeVO, scaleVO);
+            classicCaseDTO.setScale(getScaleStructure(scaleVO, concept.getId()));
+        }
+
+        classicCaseDTO.setDetails(detailMap);
+        classicCaseDTO.setId(concept.getId());
+        classicCaseDTO.setName(concept.getLibName());
+        Integer retType = convertType(concept.getLibType(), 2);
+        classicCaseDTO.setType(retType == null ? "" : retType.toString());
+
+        return classicCaseDTO;
+    }
+
+    /**
+     * 经典病历分页查询
      *
      * @param klClassicCasePageVO
      * @return
@@ -148,7 +226,7 @@ public class KlClassicCaseFacade extends KlClassicCaseServiceImpl {
     }
 
     /**
-     * 根据经典病例id获取病例信息
+     * 根据经典病历id获取病历信息
      *
      * @param idVO
      * @return
@@ -264,7 +342,7 @@ public class KlClassicCaseFacade extends KlClassicCaseServiceImpl {
             detail.setGmtModified(now);
         });
 
-        //保存经典病例基础信息
+        //保存经典病历基础信息
         this.saveOrUpdate(classicCase);
 
         //删除已有明细
@@ -367,4 +445,117 @@ public class KlClassicCaseFacade extends KlClassicCaseServiceImpl {
         return retType;
     }
 
+    /**
+     * 获取量表结构
+     *
+     * @param conceptId
+     * @return
+     */
+    public ConceptScaleDTO getScaleStructure(ScaleVO scaleVO, Long conceptId) {
+        ConceptScaleDTO retDTO = new ConceptScaleDTO();
+        List<KlConceptScale> scaleList = klConceptScaleFacade.list(new QueryWrapper<KlConceptScale>()
+                .eq("is_deleted", IsDeleteEnum.N.getKey())
+                .eq("concept_id", conceptId)
+                .orderByAsc("text_type", "group_num", "order_no"));
+        if (ListUtil.isEmpty(scaleList)) {
+            return null;
+        }
+        List<ConceptScaleDetailDTO> scaleDetailList = BeanUtil.listCopyTo(scaleList, ConceptScaleDetailDTO.class);
+        if (null != scaleVO) {
+            List<String> codeList = new ArrayList<>();
+            codeList = scaleDetailList.stream().filter(s -> StringUtils.isNotBlank(s.getRuleCode())).map(ac -> ac.getRuleCode()).collect(Collectors.toList());
+            scaleVO.setCodeList(codeList);
+            ScaleDTO scaleDTO = klRegulationBaseFacade.process(scaleVO);
+            List<String> codeListNew = scaleDTO.getCodeList(); //Arrays.asList("100001", "100013");
+            if (ListUtil.isNotEmpty(codeListNew)) {
+                for (String str : codeListNew) {
+                    for (ConceptScaleDetailDTO data2 : scaleDetailList) {
+                        if (null != data2.getRuleCode() && data2.getRuleCode().equals(str)) {
+                            data2.setMatch(1);
+                        }
+                    }
+                }
+            }
+        }
+
+        if (null != scaleVO) {
+            List<String> codeList = new ArrayList<>();
+            codeList = scaleDetailList.stream().map(ac -> ac.getRuleCode()).collect(Collectors.toList());
+            scaleVO.setCodeList(codeList);
+            ScaleDTO scaleDTO = klRegulationBaseFacade.process(scaleVO);
+            List<String> codeListNew = scaleDTO.getCodeList(); //Arrays.asList("100001", "100013");
+            if (ListUtil.isNotEmpty(codeListNew)) {
+                for (String str : codeListNew) {
+                    for (ConceptScaleDetailDTO data2 : scaleDetailList) {
+                        if (null != data2.getRuleCode() && data2.getRuleCode().equals(str)) {
+                            data2.setMatch(1);
+                        }
+                    }
+                }
+            }
+        }
+
+        Map<Long, List<ConceptScaleDetailDTO>> parentMap
+                = scaleDetailList.stream().sorted(Comparator.comparing(ConceptScaleDetailDTO::getTextType).thenComparing(ConceptScaleDetailDTO::getGroupNum)).collect(Collectors.groupingBy(ConceptScaleDetailDTO::getParentId));
+        List<ConceptScaleDetailDTO> retScacleDetailList = parentMap.get(-1L);
+        if (ListUtil.isEmpty(retScacleDetailList)) {
+            return null;
+        }
+        List<ConceptScaleSubDTO> retList = Lists.newLinkedList();
+        Map<Integer, List<ConceptScaleDetailDTO>> groupMap
+                = retScacleDetailList.stream().collect(Collectors.groupingBy(ConceptScaleDetailDTO::getGroupNum));
+        for (Map.Entry<Integer, List<ConceptScaleDetailDTO>> entry : groupMap.entrySet()) {
+            ConceptScaleSubDTO subItem = new ConceptScaleSubDTO();
+            subItem.setGroupNum(entry.getKey());
+            subItem.setDetailList(entry.getValue());
+            retList.add(subItem);
+        }
+        for (ConceptScaleSubDTO subDTO : retList) {
+            scaleRecursion(subDTO, parentMap);
+        }
+        //排序
+        for (ConceptScaleSubDTO data : retList) {
+            if (ListUtil.isNotEmpty(data.getDetailList())) {
+                for (ConceptScaleDetailDTO datasub : data.getDetailList()) {
+                    if (ListUtil.isNotEmpty(datasub.getSubList())) {
+                        datasub.setSubList(datasub.getSubList().stream().sorted(Comparator.comparing(ConceptScaleSubDTO::getGroupNum)).collect(Collectors.toList()));
+                    }
+
+                }
+            }
+        }
+        retDTO.setScaleDetails(retList);
+        return retDTO;
+    }
+
+    /**
+     * 递归
+     *
+     * @param item
+     * @param treeMap
+     */
+    public ConceptScaleSubDTO scaleRecursion(ConceptScaleSubDTO item,
+                                             Map<Long, List<ConceptScaleDetailDTO>> treeMap) {
+        List<ConceptScaleDetailDTO> list = item.getDetailList();
+        if (ListUtil.isNotEmpty(list)) {
+            for (ConceptScaleDetailDTO detail : list) {
+                List<ConceptScaleDetailDTO> subDetailList = treeMap.get(detail.getId());
+                if (ListUtil.isNotEmpty(subDetailList)) {
+                    Map<Integer, List<ConceptScaleDetailDTO>> subMap
+                            = subDetailList.stream().collect(Collectors.groupingBy(ConceptScaleDetailDTO::getGroupNum));
+                    List<ConceptScaleSubDTO> subList = Lists.newLinkedList();
+                    for (Map.Entry<Integer, List<ConceptScaleDetailDTO>> subEntry : subMap.entrySet()) {
+                        ConceptScaleSubDTO subDTO = new ConceptScaleSubDTO();
+                        subDTO.setGroupNum(subEntry.getKey());
+                        subDTO.setDetailList(subEntry.getValue());
+                        scaleRecursion(subDTO, treeMap);
+                        subList.add(subDTO);
+                    }
+                    detail.setSubList(subList);
+                }
+            }
+        }
+        return item;
+    }
+
 }

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

@@ -4,18 +4,7 @@ import com.alibaba.druid.support.spring.stat.annotation.Stat;
 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.dto.ConceptDetailDTO;
-import com.diagbot.dto.ConceptScaleDTO;
-import com.diagbot.dto.ConceptScaleDetailDTO;
-import com.diagbot.dto.ConceptScaleSubDTO;
-import com.diagbot.dto.DictionaryInfoDTO;
-import com.diagbot.dto.KlConceptDetailDTO;
-import com.diagbot.dto.KlConceptStaticDTO;
-import com.diagbot.dto.KlScaleByIdDTO;
-import com.diagbot.dto.ScaleDTO;
-import com.diagbot.dto.StaticKnowledgeDTO;
-import com.diagbot.dto.StaticKnowledgeDetailDTO;
-import com.diagbot.dto.StaticKnowledgeIndexPageDTO;
+import com.diagbot.dto.*;
 import com.diagbot.entity.KlConcept;
 import com.diagbot.entity.KlConceptDetail;
 import com.diagbot.entity.KlConceptScale;
@@ -741,6 +730,9 @@ public class KlConceptStaticFacade extends KlConceptStaticServiceImpl {
                 case 10:
                     retType = LexiconEnum.Law.getKey();
                     break;
+                case 11:
+                    retType = LexiconEnum.ClassicCase.getKey();
+                    break;
                 default:
                     break;
             }
@@ -765,6 +757,8 @@ public class KlConceptStaticFacade extends KlConceptStaticServiceImpl {
                 retType = 9;
             } else if (type.equals(LexiconEnum.Law.getKey())) {
                 retType = 10;
+            } else if (type.equals(LexiconEnum.ClassicCase.getKey())) {
+                retType = 11;
             }
         }
         return retType;

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

@@ -306,7 +306,7 @@ public class MedRetrievalFacade {
     }
 
     /**
-     * 经典病例检索
+     * 经典病历检索
      *
      * @param staticKnowledgeIndexVO
      * @return

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

@@ -50,6 +50,17 @@ public class KlConceptStaticController {
         return RespDTO.onSuc(data);
     }
 
+    @ApiOperation(value = "获取经典病历",
+            notes = "type： 类型：11-经典病历 <br>" +
+                    "contentTypes： 内容类型：11-经典病历<br>" +
+                    "name： 标准术语名称<br>")
+    @PostMapping("/getClassicCaseInfo")
+    @SysLogger("getClassicCaseInfo")
+    public RespDTO<ClassicCaseDTO> getClassicCaseInfo(@Valid @RequestBody StaticKnowledgeVO staticKnowledgeVO) {
+        ClassicCaseDTO data = klClassicCaseFacade.getClassicCaseInfo(staticKnowledgeVO);
+        return RespDTO.onSuc(data);
+    }
+
     @ApiOperation(value = "获取静态知识列表[zhaops]",
             notes = "type： 类型：1-诊断、2-药品、3-检验套餐、4-检验细项、5-检查、6-检查子项、7-手术和操作、8-量表、9-护理、10-政策法规  <br>" +
                     "name： 术语名称<br>" +
@@ -64,8 +75,8 @@ public class KlConceptStaticController {
         return RespDTO.onSuc(page);
     }
 
-    @ApiOperation(value = "获取经典病例列表",
-            notes = "type： 类型：11-经典病例  <br>" +
+    @ApiOperation(value = "获取经典病历列表",
+            notes = "type： 类型：11-经典病历  <br>" +
                     "name： 术语名称<br>" +
                     "status： 启用状态：1-启用、0-禁用<br>")
     @PostMapping("/getClassicCase")
@@ -109,10 +120,10 @@ public class KlConceptStaticController {
         return RespDTO.onSuc(data);
     }
 
-    @ApiOperation(value = "保存经典病例-新增或修改",
+    @ApiOperation(value = "保存经典病历-新增或修改",
             notes = "id： id <br>" +
                     "name： 术语名称 <br>" +
-                    "type： 类型：11-经典病例  <br>" +
+                    "type： 类型：11-经典病历  <br>" +
                     "source：数据来源：0-医院端、1-云平台，默认0 <br>" +
                     "details： 明细<br>" +
                     "scale：评估量表<br>")
@@ -135,7 +146,7 @@ public class KlConceptStaticController {
         return RespDTO.onSuc(data);
     }
 
-    @ApiOperation(value = "经典病例启用禁用",
+    @ApiOperation(value = "经典病历启用禁用",
             notes = "id： 术语id <br>" +
                     "status： 启用状态（0：禁用，1：启用）<br>")
     @PostMapping("/changeCaseStatus")
@@ -155,7 +166,7 @@ public class KlConceptStaticController {
         return RespDTO.onSuc(data);
     }
 
-    @ApiOperation(value = "根据经典病例id获取静态信息",
+    @ApiOperation(value = "根据经典病历id获取病历信息",
             notes = "id： 术语id <br>")
     @PostMapping("/getCaseById")
     @SysLogger("getCaseById")

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

@@ -58,8 +58,8 @@ public class RetrievalController {
         return RespDTO.onSuc(data);
     }
 
-    @ApiOperation(value = "经典病例检索",
-            notes = "types： 类型：11-经典病例 <br>" +
+    @ApiOperation(value = "经典病历检索",
+            notes = "types： 类型：11-经典病历 <br>" +
                     "inputStr： 检索内容<br>")
     @PostMapping("/classicCaseIndex")
     public RespDTO<List<ClassicCaseIndexDTO>> classicCaseIndex(@Valid @RequestBody StaticKnowledgeIndexVO staticKnowledgeIndexVO) {

src/main/resources/mapper/KlConceptMapper.xml

@@ -767,7 +767,9 @@
     </select>
 
     <select id="caseIndex" resultType="com.diagbot.dto.ClassicCaseIndexDTO">
-        SELECT
+        SELECT t.*
+        FROM
+        (SELECT
         t1.id AS id,
         t1.lib_name AS NAME,
         t2.NAME AS retrievalName,
@@ -783,27 +785,27 @@
         AND t2.is_deleted = 'N'
         AND t3.is_deleted = 'N'
         AND t1.status = 1
-        AND
-        (
         <if test="inputStr!=null and inputStr!=''">
-            t2.spell LIKE ( concat('%',LOWER(#{inputStr}),'%'))
+            AND ( t2.name LIKE concat('%',#{inputStr},'%')
             OR
-            t2.name LIKE concat('%',#{inputStr},'%')
+            LOWER(t2.spell) LIKE LOWER( concat('%',#{inputStr},'%')))
         </if>
-        )
+        ) t
+        LEFT JOIN kl_classic_case t4 ON t.id = t4.concept_id
+        WHERE
         <if test="hasInfo!=null ">
             <choose>
                 <when test="hasInfo==0">
-                    AND t2.concept_id IS NULL
+                    t4.concept_id IS NULL
                 </when>
                 <when test="hasInfo==1">
-                    AND t2.concept_id IS NOT NULL
+                    t4.concept_id IS NOT NULL
                 </when>
             </choose>
         </if>
         <if test="typeIds != null and typeIds.size > 0">
             <foreach item="typeId" collection="typeIds" open="and(" separator="or" close=")">
-                t2.type_id =#{typeId}
+                t.type =#{typeId}
             </foreach>
         </if>
         <if test="size!=null">