diagbotcloud/cdssman-service/src/main/java/com/diagbot/facade/KlDiseaseFacade.java

package com.diagbot.facade;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.diagbot.client.UserServiceClient;
import com.diagbot.dto.DiseaseAllDetailDTO;
import com.diagbot.dto.DiseaseDetailDTO;
import com.diagbot.dto.DiseasePageDTO;
import com.diagbot.dto.DiseaseSubDetailDTO;
import com.diagbot.dto.DiseaseTreeDetailDTO;
import com.diagbot.dto.KlConceptAllDTO;
import com.diagbot.dto.KlConceptSimDTO;
import com.diagbot.dto.KlDiseaseDTO;
import com.diagbot.dto.RespDTO;
import com.diagbot.entity.CommonParam;
import com.diagbot.entity.KlConcept;
import com.diagbot.entity.KlDisease;
import com.diagbot.entity.KlLexiconRelationship;
import com.diagbot.enums.DiseaseRelationTypeEnum;
import com.diagbot.enums.IsDeleteEnum;
import com.diagbot.enums.LexiconEnum;
import com.diagbot.enums.RelationLibTypeEnum;
import com.diagbot.service.impl.KlDiseaseServiceImpl;
import com.diagbot.util.BeanUtil;
import com.diagbot.util.EntityUtil;
import com.diagbot.util.ListUtil;
import com.diagbot.util.RespDTOUtil;
import com.diagbot.util.StringUtil;
import com.diagbot.vo.ConceptRelationVO;
import com.diagbot.vo.DiseaseDeleteVO;
import com.diagbot.vo.DiseasePageVO;
import com.diagbot.vo.GetDiseaseDetailVO;
import com.diagbot.vo.KlDiseaseVO;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.apache.commons.collections4.MapUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;


/**
 * @author wangfeng
 * @Description:
 * @date 2021-03-09 15:33
 */
@Component
public class KlDiseaseFacade extends KlDiseaseServiceImpl {
    @Autowired
    KlLexiconRelationshipFacade klLexiconRelationshipFacade;
    @Autowired
    KlConceptFacade klConceptFacade;
    @Autowired
    UserServiceClient userServiceClient;

    /**
     * 诊断依据分页查询
     *
     * @param klConceptInfoVO
     * @return
     */
    public IPage<DiseasePageDTO> getDiseasePageAll(DiseasePageVO klConceptInfoVO) {
        IPage<DiseasePageDTO> diseasePage = this.getDiseasePage(klConceptInfoVO);
        List<String> userIds = diseasePage.getRecords().stream()
                .map(i -> i.getModifier()).distinct().collect(Collectors.toList());
        RespDTO<Map<String, String>> respDTO = userServiceClient.getUserInfoByIds(userIds);
        RespDTOUtil.respNGDealCover(respDTO, "获取用户信息失败");
        diseasePage.getRecords().forEach(i -> {
            i.setModifierName(respDTO.data.get(i.getModifier()));
        });
        return diseasePage;
    }

    public List<KlConcept> getDiseaseAll(DiseaseDeleteVO diseaseDeleteVO) {
        List<KlConcept> klConceptss = new ArrayList<>();
        List<DiseasePageDTO> diseasePage = this.getDiseaseAlls(diseaseDeleteVO);
        List<String> diseases = diseasePage.stream().map(x -> x.getDisName()).collect(Collectors.toList());
        String disName = diseaseDeleteVO.getDisName();
        if (StringUtil.isNotEmpty(disName)) {
            List<KlConcept> klConcepts = klConceptFacade.list(new QueryWrapper<KlConcept>()
                    .eq("is_deleted", IsDeleteEnum.N.getKey())
                    .like("lib_name", disName.trim())
                    .eq("lib_type", 100));
            Map<String, List<KlConcept>> libNameMap = EntityUtil.makeEntityListMap(klConcepts, "libName");
            if (MapUtils.isNotEmpty(libNameMap) && ListUtil.isNotEmpty(diseases)) {
                libNameMap.forEach((x, y) -> {
                    if (!diseases.contains(x)) {
                        klConceptss.addAll(y);
                    }
                });
            }
        }

        return klConceptss;
    }


    /**
     * 某个诊断依据的具体数据
     *
     * @param getDiseaseDetailVO
     * @return
     */
    public DiseaseTreeDetailDTO getDetail(GetDiseaseDetailVO getDiseaseDetailVO) {
        List<Integer> relations = Arrays.asList(501, 502, 503, 504, 505, 506, 507, 508, 509,510);
        List<KlLexiconRelationship> klLexiconRelationships = klLexiconRelationshipFacade.list(new QueryWrapper<KlLexiconRelationship>()
                .eq("is_deleted", IsDeleteEnum.N.getKey())
                .in("code", relations)
                .orderByAsc("code"));
        Map<Integer, String> relation_name = klLexiconRelationships.stream().collect(Collectors.toMap(KlLexiconRelationship::getCode, KlLexiconRelationship::getName, (key1, key2) -> key2));
        DiseaseTreeDetailDTO diseaseTreeDetailDTO = new DiseaseTreeDetailDTO();

        DiseaseDetailDTO diseaseDetailDTO = new DiseaseDetailDTO();
        Map<Integer, DiseaseSubDetailDTO> disSubDetailMap = Maps.newHashMap();
        List<DiseaseAllDetailDTO> diseaseAllDetailDTOS = this.getDiseaseDetail(getDiseaseDetailVO);
        if (ListUtil.isNotEmpty(diseaseAllDetailDTOS)) {
            diseaseAllDetailDTOS.forEach(x -> {
                diseaseDetailDTO.setSid(x.getSid());
                diseaseDetailDTO.setDisName(x.getDisName());
                if (disSubDetailMap.containsKey(x.getRid())) {
                    DiseaseSubDetailDTO diseaseSubDetailDTO = disSubDetailMap.get(x.getRid());

                    diseaseSubDetailDTO.setRid(x.getRid());
                    diseaseSubDetailDTO.setRname(x.getRname());
                    List<KlConcept> details = diseaseSubDetailDTO.getDetails();
                    diseaseSubDetailDTO.setDetails(details);
                    KlConcept klConcept = new KlConcept();
                    klConcept.setId(x.getEid());
                    klConcept.setLibName(x.getItemName());
                    details.add(klConcept);

                    disSubDetailMap.put(x.getRid(), diseaseSubDetailDTO);
                } else {
                    DiseaseSubDetailDTO diseaseSubDetailDTO = new DiseaseSubDetailDTO();

                    diseaseSubDetailDTO.setRid(x.getRid());
                    diseaseSubDetailDTO.setRname(x.getRname());
                    List<KlConcept> details = Lists.newArrayList();
                    diseaseSubDetailDTO.setDetails(details);
                    KlConcept klConcept = new KlConcept();
                    klConcept.setId(x.getEid());
                    klConcept.setLibName(x.getItemName());
                    details.add(klConcept);

                    disSubDetailMap.put(x.getRid(), diseaseSubDetailDTO);
                }

            });
        }
        List<DiseaseSubDetailDTO> datas = Lists.newArrayList();
        List<List<String>> types = Lists.newArrayList();
        relation_name.forEach((x, y) -> {
            List<String> split = Arrays.asList(DiseaseRelationTypeEnum.getName(x).split("&"));
            List<Integer> collect = Arrays.stream(RelationLibTypeEnum.getName(x).split("&")).map(z -> Integer.parseInt(z)).collect(Collectors.toList());
            types.add(split);
            if (disSubDetailMap.containsKey(x)) {
                DiseaseSubDetailDTO diseaseSubDetailDTO = disSubDetailMap.get(x);
                diseaseSubDetailDTO.setLibType(collect);
                datas.add(diseaseSubDetailDTO);
            } else {
                DiseaseSubDetailDTO diseaseSubDetailDTO = new DiseaseSubDetailDTO();
                diseaseSubDetailDTO.setLibType(collect);
                diseaseSubDetailDTO.setRname(relation_name.get(x));
                diseaseSubDetailDTO.setRid(x);
                datas.add(diseaseSubDetailDTO);
            }
        });
        diseaseDetailDTO.setDatas(datas);
        diseaseTreeDetailDTO.setDiseaseDetailDTO(diseaseDetailDTO);
        diseaseTreeDetailDTO.setTypes(types);
        return diseaseTreeDetailDTO;
    }

    /**
     * 保存疾病扩展表
     *
     * @param commonParam
     * @param klDiseaseVO
     * @return
     */
    public boolean saveAll(CommonParam commonParam, KlDiseaseVO klDiseaseVO) {
        // 先删除疾病扩展表
        this.remove(new QueryWrapper<KlDisease>().eq("concept_id", commonParam.getConceptId()));
        // 重新插入扩展表
        KlDisease klDisease = new KlDisease();
        BeanUtil.copyProperties(klDiseaseVO, klDisease);
        klDisease.setConceptId(commonParam.getConceptId());
        klDisease.setGmtModified(commonParam.getNow());
        klDisease.setGmtCreate(commonParam.getNow());
        klDisease.setCreator(commonParam.getPerson());
        klDisease.setModifier(commonParam.getPerson());
        return this.save(klDisease);
    }

    /**
     * 疾病扩展获取
     *
     * @param conceptId
     * @param klConceptAllDTO
     */
    public void getKlDisease(Long conceptId, KlConceptAllDTO klConceptAllDTO) {
        KlDisease klDisease = this.getOne(new QueryWrapper<KlDisease>()
                .eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("concept_id", conceptId), false);
        if (klDisease == null) {
            return;
        }
        KlDiseaseDTO klDiseaseDTO = new KlDiseaseDTO();
        BeanUtil.copyProperties(klDisease, klDiseaseDTO);

        List<Integer> relationIdList = Lists.newArrayList(
                RelationLibTypeEnum.relationDept.getKey(),
                RelationLibTypeEnum.relationPart.getKey(),
                RelationLibTypeEnum.relationSystem.getKey()
        );
        ConceptRelationVO conceptRelationVO = new ConceptRelationVO();
        conceptRelationVO.setConceptId(conceptId);
        conceptRelationVO.setRelationList(relationIdList);
        Map<Integer, List<KlConceptSimDTO>> map = klConceptFacade.getRelationConceptFac(conceptRelationVO);
        if (map.get(LexiconEnum.Part.getKey()) != null) { // 关联部位
            klDiseaseDTO.setPartList(map.get(LexiconEnum.Part.getKey()));
        }
        if (map.get(LexiconEnum.Dept.getKey()) != null) { // 关联部位
            klDiseaseDTO.setDeptList(map.get(LexiconEnum.Dept.getKey()));
        }
        if (map.get(LexiconEnum.DisSysType.getKey()) != null) { // 关联诊断系统分类
            klDiseaseDTO.setSystemTypeList(map.get(LexiconEnum.DisSysType.getKey()));
        }
        klConceptAllDTO.setKlDiseaseDTO(klDiseaseDTO);
    }
}