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.enums.StaticSearchTypeEnum;
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, false);
        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, false);
        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) {
        List<Concept> list = new ArrayList<>();
        if (ListUtil.isNotEmpty(ids)) {
            QueryWrapper<Concept> conceptQueryWrapper = new QueryWrapper<>();
            conceptQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                    .in("id", ids);
            list = this.list(conceptQueryWrapper);
        }
        return list;
    }

    /**
     * 根据名称和词性获取概念列表
     *
     * @param nameList
     * @param libType
     * @return
     */
    public List<Concept> getListByNamesAndType(List<String> nameList, Integer libType) {
        List<Concept> list = new ArrayList<>();
        if (ListUtil.isNotEmpty(nameList)) {
            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 = this.list(conceptQueryWrapper);
        }
        return list;
    }

    /**
     * 根据名称获取概念list
     *
     * @param nameList
     * @return
     */
    public List<Concept> getListByNames(List<String> nameList) {
        List<Concept> list = new ArrayList<>();
        if (ListUtil.isNotEmpty(nameList)) {
            QueryWrapper<Concept> conceptQueryWrapper = new QueryWrapper<>();
            conceptQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                    .in("lib_name", nameList);
            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());
                typeList.add(LexiconTypeEnum.RELATIVES.getKey());
                typeList.add(LexiconTypeEnum.MARRIAGE.getKey());
                typeList.add(LexiconTypeEnum.FOOD.getKey());
                typeList.add(LexiconTypeEnum.HISTORY.getKey());
                typeList.add(LexiconTypeEnum.OPERATION.getKey());
                typeList.add(LexiconTypeEnum.PERSONAL_HISTORY.getKey());
                typeList.add(LexiconTypeEnum.PERSONAL_HISTORY_DESCRIPTION.getKey());
                retrievalVO.setOtherType(typeList);
                retrievalVO.setType(null);
                bla = false;
            }
            if (bla) {
                retrievalVO.setType(ParamConvertUtil.conceptConvert2Lib(retrievalVO.getType()));
            }
        }
        List<ConceptRetrievalDTO> conceptRetrievalDTOS = Lists.newArrayList();
        conceptRetrievalDTOS = this.retrievalConcept(retrievalVO);
        List<ConceptRetrievalDTO> res = new ArrayList<>();
        List<Long> selfList = new ArrayList<>(); // 本体
        List<Long> subList = new ArrayList<>(); // 子项
        List<String> conceptNameList = 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 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 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);
                    }
                }
            }
        }
        //把本体的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) {
        RetrievalVO retrievalVO = new RetrievalVO();
        BeanUtil.copyProperties(getStaticKnowledgeVO, retrievalVO);
        List<Integer> types = retrievalVO.getTypes();
        if (ListUtil.isEmpty(types)) {
            // 添加词库搜索类型
            types.add(StaticSearchTypeEnum.DIAGNOSIS.getKey());
            types.add(StaticSearchTypeEnum.DRUGS.getKey());
            types.add(StaticSearchTypeEnum.SYMPTOM.getKey());
            types.add(StaticSearchTypeEnum.LIS_PACKAGE.getKey());
            types.add(StaticSearchTypeEnum.PACS_ITEMS.getKey());
            types.add(StaticSearchTypeEnum.OPERATION.getKey());
            types.add(StaticSearchTypeEnum.GAUGE.getKey());
            getStaticKnowledgeVO.setTypes(types);
        }
        List<Integer> typesIn = new ArrayList<>();
        // 是否包含化验
        if (types.contains(LexiconTypeEnum.LIS_PACKAGE.getKey())) {
            retrievalVO.setHasLis(true); //
        }
        // 是否包含量表
        if (types.contains(LexiconTypeEnum.GAUGE.getKey())) {
            retrievalVO.setHasGauge(true); // 包含量表
        }
        for (Integer type : types) {
            // 化验和量表单独处理，不需要遍历
            if (LexiconTypeEnum.LIS_PACKAGE.getKey() != type.intValue()
                    && LexiconTypeEnum.GAUGE.getKey() != type.intValue()) {
                typesIn.add(type);
            }
        }
        retrievalVO.setTypesIn(typesIn);

        List<RetrievalDTO> staticRetrievalList = this.staticKnowledge(retrievalVO);
        for (RetrievalDTO retrievalDTO : staticRetrievalList) {
            retrievalDTO.setType(ParamConvertUtil.libConvert2Concept(retrievalDTO.getLibTypeId().intValue()));
            if ((retrievalDTO.getShowType().intValue() == 1)
                    || (retrievalDTO.getShowType().intValue() == 21)) {//去除本体retrivalName和（父项--子项）组合的retrivalName
                retrievalDTO.setRetrievalName(null);
            }
        }
        return staticRetrievalList;
    }


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