diagbotcloud/aipt-service/src/main/java/com/diagbot/facade/ConceptFacade.java

package com.diagbot.facade;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.diagbot.dto.ConceptBaseDTO;
import com.diagbot.dto.ConceptRetrievalDTO;
import com.diagbot.dto.ConceptWithOrderRes;
import com.diagbot.dto.RetrievalDTO;
import com.diagbot.entity.Concept;
import com.diagbot.entity.wrapper.ConceptWrapper;
import com.diagbot.enums.ConceptTypeEnum;
import com.diagbot.enums.IsDeleteEnum;
import com.diagbot.enums.LexiconRSTypeEnum;
import com.diagbot.enums.LexiconTypeEnum;
import com.diagbot.exception.CommonErrorCode;
import com.diagbot.exception.CommonException;
import com.diagbot.service.impl.ConceptServiceImpl;
import com.diagbot.util.BeanUtil;
import com.diagbot.util.IntegerUtil;
import com.diagbot.util.ListUtil;
import com.diagbot.util.ParamConvertUtil;
import com.diagbot.util.StringUtil;
import com.diagbot.vo.ConceptBaseVO;
import com.diagbot.vo.ConceptExistVO;
import com.diagbot.vo.ConceptFindVO;
import com.diagbot.vo.ConceptSearchVO;
import com.diagbot.vo.ConceptUsualVO;
import com.diagbot.vo.GetStaticKnowledgeVO;
import com.diagbot.vo.RetrievalVO;
import com.google.common.collect.Lists;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @Description:
 * @Author:zhaops
 * @time: 2019/5/6 15:04
 */
@Component
public class ConceptFacade extends ConceptServiceImpl {
    @Autowired
    ConceptDetailFacade conceptDetailFacade;

    /**
     * 验证存在并且获取概念基本信息
     *
     * @param conceptBaseVO 概念名称和类型
     * @return 概念基本信息
     */
    public Concept exist(ConceptBaseVO conceptBaseVO) {
        QueryWrapper<Concept> conceptQueryWrapper = new QueryWrapper<>();
        conceptQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("lib_name", conceptBaseVO.getName())
                .eq("lib_type", conceptBaseVO.getLibType());
        Concept concept = this.getOne(conceptQueryWrapper);
        if (concept == null) {
            throw new CommonException(CommonErrorCode.NOT_EXISTS, "概念不存在");
        }
        return concept;
    }

    /**
     * 获取概念基本信息
     *
     * @param conceptBaseVO
     * @return
     */
    public Concept getConcept(ConceptBaseVO conceptBaseVO) {
        QueryWrapper<Concept> conceptQueryWrapper = new QueryWrapper<>();
        conceptQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("lib_name", conceptBaseVO.getName())
                .eq("lib_type", conceptBaseVO.getLibType());
        Concept concept = this.getOne(conceptQueryWrapper);
        return concept;
    }

    /**
     * 根据概念Id列表获取概念列表Map
     *
     * @param conceptSearchVO 搜索参数
     * @return 术语id和术语 Map
     */
    public Map<Long, String> getConceptMap(ConceptSearchVO conceptSearchVO) {
        //入参验证
        if (ListUtil.isEmpty(conceptSearchVO.getConceptIds())) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "术语列表不能为空");
        }

        //获取结构
        List<Concept> concepts
                = this.getListByIds(conceptSearchVO.getConceptIds());

        //出参封装
        Map<Long, String> map = new HashMap<>();
        if (ListUtil.isNotEmpty(concepts)) {
            map = concepts.stream().collect(Collectors.toMap(r -> r.getId(), r -> r.getLibName()));
        }
        return map;
    }

    /**
     * 根据概念Id列表获取概念列表Map
     *
     * @param conceptFindVO 搜索参数
     * @return 术语id和术语 Map
     */
    public Map<Long, String> getConceptCondMap(ConceptFindVO conceptFindVO) {
        //入参验证
        if (ListUtil.isEmpty(conceptFindVO.getConceptIds())) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "术语列表不能为空");
        }

        if (IntegerUtil.isNull(conceptFindVO.getAge())) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "年龄不能为空");
        }

        if (IntegerUtil.isNull(conceptFindVO.getSexType())) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "性别不能为空");
        }

        //获取结构
        List<ConceptBaseDTO> concepts
                = this.getConceptConMap(conceptFindVO);

        //出参封装
        Map<Long, String> map = new HashMap<>();
        if (ListUtil.isNotEmpty(concepts)) {
            map = concepts.stream().collect(Collectors.toMap(r -> r.getConceptId(), r -> r.getName()));
        }
        return map;
    }

    /**
     * 根据概念Id列表获取概念列表
     *
     * @param ids
     * @return
     */
    public List<Concept> getListByIds(List<Long> ids) {
        QueryWrapper<Concept> conceptQueryWrapper = new QueryWrapper<>();
        conceptQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .in("id", ids);
        List<Concept> list = this.list(conceptQueryWrapper);
        return list;
    }

    /**
     * 根据名称和词性获取概念列表
     *
     * @param nameList
     * @param libType
     * @return
     */
    public List<Concept> getListByNamesAndType(List<String> nameList, Integer libType) {
        QueryWrapper<Concept> conceptQueryWrapper = new QueryWrapper<>();
        conceptQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .in("lib_name", nameList);
        if (libType != null) {
            conceptQueryWrapper.eq("lib_type", libType);
        }
        List<Concept> list = this.list(conceptQueryWrapper);
        return list;
    }

    /**
     * 根据名称获取概念list
     *
     * @param nameList
     * @return
     */
    public List<Concept> getListByNames(List<String> nameList) {
        QueryWrapper<Concept> conceptQueryWrapper = new QueryWrapper<>();
        conceptQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .in("lib_name", nameList);
        List<Concept> list = this.list(conceptQueryWrapper);
        return list;
    }

    /**
     * 根据名称和类型获取概念列表Map
     *
     * @param conceptExistVO 搜索参数
     * @return 术语id和术语 Map
     */
    public Map<String, Long> getConceptMap(ConceptExistVO conceptExistVO) {
        // 入参验证
        if (ListUtil.isEmpty(conceptExistVO.getNameList())) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "名称列表不能为空");
        }

        if (conceptExistVO.getType() != null) {
            Integer libType = ParamConvertUtil.conceptConvert2Lib(conceptExistVO.getType());
            if (libType == null) {
                throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "类型不匹配");
            }
            conceptExistVO.setLibType(libType);
        }

        //获取结构
        List<Concept> concepts
                = this.getListByNamesAndType(conceptExistVO.getNameList(), conceptExistVO.getLibType());

        //出参封装
        Map<String, Long> map = new HashMap<>();
        if (ListUtil.isNotEmpty(concepts)) {
            map = concepts.stream().collect(Collectors.toMap(r -> r.getLibName(), r -> r.getId()));
        }
        return map;
    }


    /**
     * 获取常用标签
     *
     * @param conceptUsualVO
     * @return
     */
    public List<ConceptBaseDTO> getConceptUsual(ConceptUsualVO conceptUsualVO) {
        //入参验证
        List<Integer> inputTyps = new ArrayList<>();
        inputTyps.add(ConceptTypeEnum.Symptom.getKey());
        inputTyps.add(ConceptTypeEnum.Vital.getKey());
        inputTyps.add(ConceptTypeEnum.Lis.getKey());
        inputTyps.add(ConceptTypeEnum.Pacs.getKey());

        if (!inputTyps.contains(conceptUsualVO.getType())) {
            throw new CommonException(CommonErrorCode.NOT_EXISTS, "超出范围");
        }

        //获取标签内容
        ConceptWrapper conceptWrapper = new ConceptWrapper();
        conceptWrapper.setStartName(conceptUsualVO.getDeptName());//科室名称
        conceptWrapper.setStartType(LexiconTypeEnum.DEPARTMENT.getKey());
        conceptWrapper.setRelationType(LexiconRSTypeEnum.ORDER_BY.getKey());
        conceptWrapper.setEndAge(conceptUsualVO.getAge());//年龄
        conceptWrapper.setEndSex(conceptUsualVO.getSexType());//性别
        //找出标签类型对应的类型id
        conceptWrapper.setEndType(ParamConvertUtil.conceptConvert2Lib(conceptUsualVO.getType()));//标签类型
        List<ConceptWithOrderRes> concepts = this.getConceptWithOrder(conceptWrapper);
        List<ConceptBaseDTO> list = new ArrayList();
        //封装
        ConceptBaseDTO conceptBaseDTO = new ConceptBaseDTO();
        for (ConceptWithOrderRes conceptWithOrderRes : concepts) {
            conceptBaseDTO = new ConceptBaseDTO();
            conceptBaseDTO.setConceptId(conceptWithOrderRes.getEndId());
            conceptBaseDTO.setName(conceptWithOrderRes.getEndName());
            list.add(conceptBaseDTO);
        }
        return list;
    }

    /**
     * 概念id检索
     *
     * @param retrievalVO
     * @return
     */
    public List<ConceptRetrievalDTO> retrivelConceptInfo(RetrievalVO retrievalVO) {
        Boolean bla = true;
        if (null != retrievalVO.getType()) {
            if (retrievalVO.getType().intValue() == ConceptTypeEnum.Lis.getKey()) {//如果是化验，添加化验子项类型
                retrievalVO.setDetailType(LexiconTypeEnum.LIS_DETAILS.getKey());
                bla = true;
            } else if (retrievalVO.getType().intValue() == ConceptTypeEnum.Past.getKey()
                    || retrievalVO.getType().intValue() == ConceptTypeEnum.Other.getKey()) {//如果是其他史设置其他史类型
                List<Integer> typeList = new ArrayList<>();
                typeList.add(LexiconTypeEnum.HISTORY_OF_PAST_DISEASES.getKey());
                typeList.add(LexiconTypeEnum.HISTORY_OF_TRAUMA.getKey());
                typeList.add(LexiconTypeEnum.HISTORY_OF_SURGERY.getKey());
                typeList.add(LexiconTypeEnum.HISTORY_OF_BLOOD_TRANSFUSION.getKey());
                typeList.add(LexiconTypeEnum.INFECTIOUS_DISEASE_HISTORY.getKey());
                typeList.add(LexiconTypeEnum.BAD_HABITS.getKey());
                typeList.add(LexiconTypeEnum.MARITAL_HISTORY.getKey());
                typeList.add(LexiconTypeEnum.HISTORY_OF_MARRIAGE_AND_CHILDBEARING.getKey());
                typeList.add(LexiconTypeEnum.BIRTH_HISTORY.getKey());
                typeList.add(LexiconTypeEnum.FAMILY_HISTORY.getKey());
                typeList.add(LexiconTypeEnum.FOOD_ALLERGY_HISTORY.getKey());
                typeList.add(LexiconTypeEnum.HISTORY_OF_DRUG_ALLERGY.getKey());
                typeList.add(LexiconTypeEnum.FAMILY_RELATED_INFECTIOUS_DISEASE_HISTORY.getKey());
                retrievalVO.setOtherType(typeList);
                bla = false;
            }
            if (bla) {
                retrievalVO.setType(ParamConvertUtil.conceptConvert2Lib(retrievalVO.getType()));
            }
        }
        List<ConceptRetrievalDTO> conceptRetrievalDTOS = Lists.newArrayList();
        if (retrievalVO.getIsStatic().equals(1)) {
            conceptRetrievalDTOS = this.staticKnowledge(retrievalVO);
        } else {
            conceptRetrievalDTOS = this.retrievalConcept(retrievalVO);
        }

        List<ConceptRetrievalDTO> res = new ArrayList<>();
        List<Long> selfList = new ArrayList<>(); // 本体
        List<Long> subList = new ArrayList<>(); // 子项
        List<String> conceptNameList = new ArrayList<>();//名称结果集保证数据唯一
        List<Long> uniqueIdList = new ArrayList<>();
        for (ConceptRetrievalDTO bean : conceptRetrievalDTOS) {
            if (StringUtil.isNotEmpty(bean.getParentName())) { // 重置showType
                bean.setShowType(2L);
            }
            if (bean.getShowType().intValue() == 1) { // 本体
                selfList.add(bean.getSelfId());
            } else if (bean.getShowType().intValue() == 2) { // 子项
                subList.add(bean.getSelfId());
            }
        }
        // 有本体，过滤同义词和子项；无本体，有子项，过滤同义词
        for (ConceptRetrievalDTO bean : conceptRetrievalDTOS) {
            if (bean.getShowType().intValue() == 1) {
                if(retrievalVO.getIsSonShow().intValue() == 0){//isSonShow为0执行检索去重逻辑
                    res.add(bean);
                }else {//sSonShow不为0执行静态知识检索去重逻辑
                    if(bean.getUniqueId() != null && bean.getUniqueId() != 0){
                        if(!uniqueIdList.contains(bean.getUniqueId())){
                            res.add(bean);
                            uniqueIdList.add(bean.getUniqueId());
                        }
                    }else {
                        res.add(bean);
                    }
                }
            } else if (bean.getShowType().intValue() == 2) {
                if(retrievalVO.getIsSonShow().intValue() == 0){//isSonShow为0执行检索去重逻辑
                    if (!selfList.contains(bean.getParentId()) && !conceptNameList.contains(bean.getParentName()) ) {
                        conceptNameList.add(bean.getParentName());
                        res.add(bean);
                    }
                } else {//sSonShow不为0执行静态知识检索去重逻辑
                    if(bean.getUniqueId() != null && bean.getUniqueId() != 0){
                        if(!uniqueIdList.contains(bean.getUniqueId())){
                            res.add(bean);
                            uniqueIdList.add(bean.getUniqueId());
                        }
                    }
                }
            } else if (bean.getShowType().intValue() == 0) {
                if(retrievalVO.getIsSonShow().intValue() == 0){//isSonShow为0执行检索去重逻辑
                    if (!selfList.contains(bean.getSelfId()) && !subList.contains(bean.getSelfId()) && !conceptNameList.contains(bean.getSelfName())) {
                        conceptNameList.add(bean.getSelfName());
                        res.add(bean);
                    }
                }else {//SonShow不为0执行静态知识检索去重逻辑
                    if(bean.getUniqueId() != null && bean.getUniqueId() != 0){
                        if(!uniqueIdList.contains(bean.getUniqueId())){
                            res.add(bean);
                            uniqueIdList.add(bean.getUniqueId());
                        }
                    }else {
                        res.add(bean);
                    }
                }
            }
        }
        //把本体的sameName过滤掉
        for (ConceptRetrievalDTO conceptRetrievalDTO : res) {
            if (conceptRetrievalDTO.getSameName() != null && conceptRetrievalDTO.getSameName().equals(conceptRetrievalDTO.getSelfName())) {
                conceptRetrievalDTO.setSameName(null);
            }
            conceptRetrievalDTO.setType(ParamConvertUtil.libConvert2Concept(conceptRetrievalDTO.getLibTypeId().intValue()));
        }
        return res;
    }


    /**
     * 静态知识标签检索
     *
     * @param getStaticKnowledgeVO
     * @return
     */
    public List<RetrievalDTO> getStaticKnowledge(GetStaticKnowledgeVO getStaticKnowledgeVO) {
        List<RetrievalDTO> retrievalDTOS = new ArrayList<>();
        RetrievalVO retrievalVO = new RetrievalVO();
        RetrievalDTO retrievalDTO = new RetrievalDTO();
        BeanUtil.copyProperties(getStaticKnowledgeVO, retrievalVO);
        retrievalVO.setIsSonShow(1);
        retrievalVO.setIsStatic(1);
        List<Integer> types = new ArrayList<>();
        for (Integer type : getStaticKnowledgeVO.getTypes()) {
            if(type.intValue() == ConceptTypeEnum.Lis.getKey()){//单独设置化验类型
                retrievalVO.setType(type);
            }else {//查询时去掉化验
                types.add(ParamConvertUtil.conceptConvert2Lib(type));
            }
        }
        //设置类型为诊断、药品、辅检
        retrievalVO.setOtherType(types);
        //获取标签信息
        List<ConceptRetrievalDTO> conceptRetrievalDTOList = this.retrivelConceptInfo(retrievalVO);
        List<RetrievalDTO> staticRetrievalList = new ArrayList<>();
        if (ListUtil.isNotEmpty(conceptRetrievalDTOList)) {
            //封装
            for (ConceptRetrievalDTO conceptRetrievalDTO : conceptRetrievalDTOList) {
                retrievalDTO = new RetrievalDTO();
                retrievalDTO.setConceptId(conceptRetrievalDTO.getSelfId());
                retrievalDTO.setName(conceptRetrievalDTO.getSelfName());
                retrievalDTO.setUniqueName(conceptRetrievalDTO.getUniqueName());
                if (StringUtil.isNotEmpty(conceptRetrievalDTO.getParentName())) {//parent不为空时说明有子项，返回父级id
                    retrievalDTO.setConceptId(conceptRetrievalDTO.getParentId());
                    retrievalDTO.setName(conceptRetrievalDTO.getParentName());
                    retrievalDTO.setRetrievalName(conceptRetrievalDTO.getSelfName());
                }
                if (StringUtil.isNotEmpty(conceptRetrievalDTO.getSameName())) {//同义词
                    retrievalDTO.setRetrievalName(conceptRetrievalDTO.getSameName());
                }
                retrievalDTO.setLibTypeId(conceptRetrievalDTO.getLibTypeId());
                retrievalDTO.setLibTypeName(conceptRetrievalDTO.getLibTypeName());
                retrievalDTO.setType(conceptRetrievalDTO.getType());
                retrievalDTO.setShowType(conceptRetrievalDTO.getShowType());
                retrievalDTOS.add(retrievalDTO);
            }
        }
        for (RetrievalDTO retrievalDTOInfo : retrievalDTOS) {
            retrievalDTO = new RetrievalDTO();
            BeanUtil.copyProperties(retrievalDTOInfo, retrievalDTO);
            staticRetrievalList.add(retrievalDTO);
        }
        return staticRetrievalList;
    }


    /**
     * 检索词库获取标准词
     *
     * @param conceptBaseVO
     * @return
     */
    public List<ConceptBaseDTO> indexConceptFac(ConceptBaseVO conceptBaseVO) {
        return this.indexConcept(conceptBaseVO);
    }
}