cdss/src/main/java/com/diagbot/facade/ConceptInfoFacade.java

package com.diagbot.facade;

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.client.CdssCoreClient;
import com.diagbot.dto.ConceptDetailDTO;
import com.diagbot.dto.ConceptInfoDTO;
import com.diagbot.dto.DictionaryInfoDTO;
import com.diagbot.dto.RespDTO;
import com.diagbot.dto.StaticKnowledgeDTO;
import com.diagbot.dto.StaticKnowledgeDetailDTO;
import com.diagbot.dto.StaticKnowledgeIndexDTO;
import com.diagbot.entity.ConceptDetail;
import com.diagbot.entity.ConceptInfo;
import com.diagbot.enums.StaticTypeEnum;
import com.diagbot.enums.IsDeleteEnum;
import com.diagbot.exception.CommonErrorCode;
import com.diagbot.exception.CommonException;
import com.diagbot.service.ConceptDetailService;
import com.diagbot.service.impl.ConceptInfoServiceImpl;
import com.diagbot.util.BeanUtil;
import com.diagbot.util.DateUtil;
import com.diagbot.util.EntityUtil;
import com.diagbot.util.ListUtil;
import com.diagbot.util.RespDTOUtil;
import com.diagbot.util.StringUtil;
import com.diagbot.util.SysUserUtils;
import com.diagbot.vo.ChangeStatusVO;
import com.diagbot.vo.ConceptDetailVO;
import com.diagbot.vo.ConceptInfoPageVO;
import com.diagbot.vo.ConceptInfoVO;
import com.diagbot.vo.HasStaticKnowledgeVO;
import com.diagbot.vo.IdVO;
import com.diagbot.vo.StaticKnowledgeHISVO;
import com.diagbot.vo.StaticKnowledgeIndexVO;
import com.diagbot.vo.StaticKnowledgeVO;
import com.google.common.collect.Lists;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

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

/**
 * @Description:
 * @Author:zhaops
 * @time: 2020/8/19 14:17
 */
@Component
public class ConceptInfoFacade extends ConceptInfoServiceImpl {
    @Autowired
    private CdssCoreClient cdssCoreClient;
    @Autowired
    private DictionaryFacade dictionaryFacade;
    @Autowired
    private ConceptDetailFacade conceptDetailFacade;
    @Autowired
    @Qualifier("conceptDetailServiceImpl")
    private ConceptDetailService conceptDetailService;
    @Autowired
    private LisConfigFacade lisConfigFacade;
    @Autowired
    private PacsConfigFacade pacsConfigFacade;
    @Autowired
    private DrugConfigFacade drugConfigFacade;
    @Autowired
    private DiseaseConfigFacade diseaseConfigFacade;
    @Autowired
    private OperationConfigFacade operationConfigFacade;

    /**
     * 返回带静态知识的检索结果
     *
     * @param staticKnowledgeIndexVO
     * @return
     */
    public List<StaticKnowledgeIndexDTO> staticKnowledgeIndexWithInfo(StaticKnowledgeIndexVO staticKnowledgeIndexVO) {
        List<StaticKnowledgeIndexDTO> staticKnowledgeIndexDTOList = staticKnowledgeIndex(staticKnowledgeIndexVO);
        //过滤没有静态知识的检索结果
        staticKnowledgeIndexDTOList = staticKnowledgeIndexDTOList
                .stream()
                .filter(i -> i.getHasInfo().equals(1))
                .collect(Collectors.toList());
        if (staticKnowledgeIndexDTOList.size() > 100) {
            staticKnowledgeIndexDTOList = staticKnowledgeIndexDTOList.subList(0, 100);
        }
        return staticKnowledgeIndexDTOList;
    }

    /**
     * 返回不带静态知识的检索结果
     *
     * @param staticKnowledgeIndexVO
     * @return
     */
    public List<StaticKnowledgeIndexDTO> staticKnowledgeIndexWithoutInfo(StaticKnowledgeIndexVO staticKnowledgeIndexVO) {
        List<StaticKnowledgeIndexDTO> staticKnowledgeIndexDTOList = staticKnowledgeIndex(staticKnowledgeIndexVO);
        //过滤没有静态知识的检索结果
        staticKnowledgeIndexDTOList = staticKnowledgeIndexDTOList
                .stream()
                .filter(i -> i.getHasInfo().equals(0))
                .collect(Collectors.toList());
        if (staticKnowledgeIndexDTOList.size() > 100) {
            staticKnowledgeIndexDTOList = staticKnowledgeIndexDTOList.subList(0, 100);
        }
        return staticKnowledgeIndexDTOList;
    }

    /**
     * 医学知识（静态信息）检索
     *
     * @param staticKnowledgeIndexVO
     * @return
     */
    public List<StaticKnowledgeIndexDTO> staticKnowledgeIndex(StaticKnowledgeIndexVO staticKnowledgeIndexVO) {
        List<StaticKnowledgeIndexDTO> retList = Lists.newLinkedList();
        //静态知识检索顺序
        List<DictionaryInfoDTO> dicStaticIndexList = dictionaryFacade.getListByGroupType(7);
        //页面术语类型和图谱映射
        List<DictionaryInfoDTO> dicTypeMappingList = dictionaryFacade.getListByGroupType(8);

        List<StaticKnowledgeIndexDTO> staticKnowledgeIndexDTOList = Lists.newLinkedList();
        RespDTO<List<StaticKnowledgeIndexDTO>> respDTO = cdssCoreClient.staticKnowledgeIndex(staticKnowledgeIndexVO);
        RespDTOUtil.respNGDealCover(respDTO, "检索失败");
        staticKnowledgeIndexDTOList = respDTO.data;
        if (ListUtil.isNotEmpty(staticKnowledgeIndexDTOList)) {
            //typeName转换
            staticKnowledgeIndexDTOList.forEach(item -> {
                item.setTypeName(convertTypeName(item.getTypeName(), 2, dicTypeMappingList));
            });
            //是否有静态知识
            List<String> conNameList = staticKnowledgeIndexDTOList
                    .stream()
                    .map(i -> i.getName())
                    .collect(Collectors.toList());
            QueryWrapper<ConceptInfo> conceptInfoQueryWrapper = new QueryWrapper<>();
            conceptInfoQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey());
            conceptInfoQueryWrapper.in("name", conNameList);
            List<ConceptInfo> conceptInfoList = this.list(conceptInfoQueryWrapper);
            /*int n = 0;
            do {
                List<String> subConNameList = new ArrayList<>();
                if (n + 1000 < conNameList.size()) {
                    subConNameList = conNameList.subList(n, n + 1000);
                } else {
                    subConNameList = conNameList.subList(n, conNameList.size());
                }
                conceptInfoQueryWrapper = new QueryWrapper<>();
                conceptInfoQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey());
                conceptInfoQueryWrapper.in("name", subConNameList);
                List<ConceptInfo> subConceptInfoList = this.list(conceptInfoQueryWrapper);
                if (ListUtil.isNotEmpty(subConceptInfoList)) {
                    conceptInfoList.addAll(subConceptInfoList);
                }
                n += 1000;
            } while (conceptInfoList.size() < 100 && n < conNameList.size());*/

            //staticKnowledgeIndexDTOList = staticKnowledgeIndexDTOList.subList(0, n);

            if (ListUtil.isNotEmpty(conceptInfoList)) {
                //typeName转换
                conceptInfoList.forEach(item -> {
                    item.setType(convertTypeName(item.getType(), 2, dicTypeMappingList));
                });
                Map<String, ConceptInfo> infoMap
                        = EntityUtil.makeEntityMapByKeys(conceptInfoList, "_", "name", "type");
                for (StaticKnowledgeIndexDTO item : staticKnowledgeIndexDTOList) {
                    if (infoMap.containsKey(item.getName() + "_" + item.getTypeName())) {
                        item.setId(infoMap.get(item.getName() + "_" + item.getTypeName()).getId());
                    }
                }
                List<Long> conceptIdList = conceptInfoList.stream()
                        .map(i -> i.getId())
                        .collect(Collectors.toList());
                if (ListUtil.isNotEmpty(conceptIdList)) {
                    QueryWrapper<ConceptDetail> conceptDetailQueryWrapper = new QueryWrapper<>();
                    //conceptDetailQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey());
                    conceptDetailQueryWrapper.in("concept_id", conceptIdList);
                    List<ConceptDetail> conceptDetailList = conceptDetailFacade.list(conceptDetailQueryWrapper);
                    Map<Long, List<ConceptDetail>> detailMap
                            = EntityUtil.makeEntityListMap(conceptDetailList, "conceptId");
                    for (StaticKnowledgeIndexDTO item : staticKnowledgeIndexDTOList) {
                        if (item.getId() == null
                                || !detailMap.containsKey(item.getId())) {
                            item.setHasInfo(0);
                            item.setHasStaticKnowledge(0);
                            item.setHasClinicalPathway(0);
                            item.setHasNotice((0));
                            item.setHasTreatInfo(0);
                            continue;
                        }
                        for (ConceptDetail detail : detailMap.get(item.getId())) {
                            item.setHasInfo(1);
                            if (detail.getIsDeleted().equals(IsDeleteEnum.Y.getKey())) {
                                continue;
                            }
                            List<String> contentTypeList = Arrays.asList(detail.getContentType().split(","));
                            if (contentTypeList.contains("1")) {
                                item.setHasStaticKnowledge(1);
                            }
                            if (contentTypeList.contains("2")) {
                                item.setHasNotice(1);
                            }
                            if (contentTypeList.contains("3")) {
                                item.setHasClinicalPathway(1);
                            }
                            if (contentTypeList.contains("4")) {
                                item.setHasTreatInfo(1);
                            }
                        }
                    }
                }
            }

            //排序
            Map<String, List<StaticKnowledgeIndexDTO>> map
                    = EntityUtil.makeEntityListMap(staticKnowledgeIndexDTOList, "typeName");
            for (DictionaryInfoDTO dic : dicStaticIndexList) {
                if (dic.getName().equals("检验")) {
                    if (map.containsKey(ConceptTypeEnum.LisPack.getName())) {
                        retList.addAll(map.get(ConceptTypeEnum.LisPack.getName()));
                    }
                    if (map.containsKey(ConceptTypeEnum.Lis.getName())) {
                        retList.addAll(map.get(ConceptTypeEnum.Lis.getName()));
                    }
                } else if (map.containsKey(dic.getName())) {
                    retList.addAll(map.get(dic.getName()));
                }
            }
        }
        return retList;
    }


    /**
     * 页面获取静态知识
     *
     * @param staticKnowledgeVO
     * @return
     */
    public StaticKnowledgeDTO getStaticKnowledge(StaticKnowledgeVO staticKnowledgeVO) {
        StaticKnowledgeDTO staticKnowledgeDTO = new StaticKnowledgeDTO();
        String typeName = StaticTypeEnum.getName(staticKnowledgeVO.getType());
        List<DictionaryInfoDTO> dicList = dictionaryFacade.getListByGroupType(8);
        typeName = convertTypeName(typeName, 1, dicList);

        QueryWrapper<ConceptInfo> conceptInfoQueryWrapper = new QueryWrapper<>();
        conceptInfoQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("name", staticKnowledgeVO.getName())
                .eq("type", typeName);
        ConceptInfo conceptInfo = this.getOne(conceptInfoQueryWrapper, false);

        if (conceptInfo == null) {
            throw new CommonException(CommonErrorCode.IS_EXISTS, "缺少静态信息");
        }

        BeanUtil.copyProperties(conceptInfo, staticKnowledgeDTO);
        Long conceptId = conceptInfo.getId();
        QueryWrapper<ConceptDetail> conceptDetailQueryWrapper = new QueryWrapper<>();
        conceptDetailQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("concept_id", conceptId);
        if (ListUtil.isNotEmpty(staticKnowledgeVO.getContentTypes())) {
            String sql = "";
            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 + ")";
                conceptDetailQueryWrapper.apply(sql);
            }
        }
        conceptDetailQueryWrapper.orderByAsc("order_no");
        List<ConceptDetail> conceptDetailList = conceptDetailFacade.list(conceptDetailQueryWrapper);
        List<StaticKnowledgeDetailDTO> detailList
                = BeanUtil.listCopyTo(conceptDetailList, 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.setDetails(detailMap);
        return staticKnowledgeDTO;
    }

    /**
     * 医院端获取静态知识（对接）
     *
     * @param staticKnowledgeHISVO
     * @return
     */
    public List<StaticKnowledgeDTO> getStaticKnowledgeForHIS(StaticKnowledgeHISVO staticKnowledgeHISVO) {

        List<StaticKnowledgeDTO> retList = Lists.newArrayList();
        String typeName = StaticTypeEnum.getName(staticKnowledgeHISVO.getType());
        List<DictionaryInfoDTO> dicList = dictionaryFacade.getListByGroupType(8);
        typeName = convertTypeName(typeName, 1, dicList);

        //术语映射
        List<String> uniqueNameList = getUniqueNames(staticKnowledgeHISVO);
        if (ListUtil.isEmpty(uniqueNameList)) {
            return retList;
        }

        QueryWrapper<ConceptInfo> conceptInfoQueryWrapper = new QueryWrapper<>();
        conceptInfoQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .in("name", uniqueNameList)
                .eq("type", typeName);
        List<ConceptInfo> conceptInfoList = this.list(conceptInfoQueryWrapper);

        if (ListUtil.isEmpty(conceptInfoList)) {
            return retList;
        }

        retList = BeanUtil.listCopyTo(conceptInfoList, StaticKnowledgeDTO.class);
        List<Long> conceptIdList = conceptInfoList.stream().map(i -> i.getId()).collect(Collectors.toList());
        QueryWrapper<ConceptDetail> conceptDetailQueryWrapper = new QueryWrapper<>();
        conceptDetailQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .in("concept_id", conceptIdList);
        if (ListUtil.isNotEmpty(staticKnowledgeHISVO.getContentTypes())) {
            String sql = "";
            for (Integer contentType : staticKnowledgeHISVO.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 + ")";
            }
            conceptDetailQueryWrapper.apply(sql);
        }
        conceptDetailQueryWrapper.orderByAsc("concept_id", "order_no");
        List<ConceptDetail> conceptDetailList = conceptDetailFacade.list(conceptDetailQueryWrapper);
        List<StaticKnowledgeDetailDTO> detailList
                = BeanUtil.listCopyTo(conceptDetailList, StaticKnowledgeDetailDTO.class);
        Map<Long, List<StaticKnowledgeDetailDTO>> conceptMap
                = EntityUtil.makeEntityListMap(detailList, "conceptId");
        for (StaticKnowledgeDTO staticKnowledgeDTO : retList) {
            List<StaticKnowledgeDetailDTO> subDetailList = conceptMap.get(staticKnowledgeDTO.getId());
            if (ListUtil.isNotEmpty(subDetailList)) {
                List<StaticKnowledgeDetailDTO> introduceList = subDetailList
                        .stream()
                        .filter(i -> Arrays.asList(i.getContentType().split(",")).contains("1"))
                        .collect(Collectors.toList());
                List<StaticKnowledgeDetailDTO> noticeList = subDetailList
                        .stream()
                        .filter(i -> Arrays.asList(i.getContentType().split(",")).contains("2"))
                        .collect(Collectors.toList());
                List<StaticKnowledgeDetailDTO> clinicalPathwayList = subDetailList
                        .stream()
                        .filter(i -> Arrays.asList(i.getContentType().split(",")).contains("3"))
                        .collect(Collectors.toList());
                List<StaticKnowledgeDetailDTO> treatInfoList = subDetailList
                        .stream()
                        .filter(i -> Arrays.asList(i.getContentType().split(",")).contains("4"))
                        .collect(Collectors.toList());
                Map<String, List<StaticKnowledgeDetailDTO>> subDetailMap = new HashMap<>();
                if (ListUtil.isEmpty(staticKnowledgeHISVO.getContentTypes()) || staticKnowledgeHISVO.getContentTypes().contains(0)) {
                    if (ListUtil.isNotEmpty(introduceList)) {
                        subDetailMap.put("静态知识", introduceList);
                    }
                    if (ListUtil.isNotEmpty(noticeList)) {
                        subDetailMap.put("注意事项", noticeList);
                    }
                    if (ListUtil.isNotEmpty(clinicalPathwayList)) {
                        subDetailMap.put("临床路径", clinicalPathwayList);
                    }
                    if (ListUtil.isNotEmpty(treatInfoList)) {
                        subDetailMap.put("治疗方案", treatInfoList);
                    }
                } else {
                    if (ListUtil.isNotEmpty(introduceList) && staticKnowledgeHISVO.getContentTypes().contains(1)) {
                        subDetailMap.put("静态知识", introduceList);
                    }
                    if (ListUtil.isNotEmpty(noticeList) && staticKnowledgeHISVO.getContentTypes().contains(2)) {
                        subDetailMap.put("注意事项", noticeList);
                    }
                    if (ListUtil.isNotEmpty(clinicalPathwayList) && staticKnowledgeHISVO.getContentTypes().contains(3)) {
                        subDetailMap.put("临床路径", clinicalPathwayList);
                    }
                    if (ListUtil.isNotEmpty(treatInfoList) && staticKnowledgeHISVO.getContentTypes().contains(4)) {
                        subDetailMap.put("治疗方案", treatInfoList);
                    }
                }
                staticKnowledgeDTO.setDetails(subDetailMap);
            }
        }
        return retList;
    }

    /**
     * 页面术语类型和图谱标签名称相互转换
     *
     * @param typeName
     * @param flag     1-页面术语类型转图谱标签名称,2- 图谱标签名称转页面术语类型
     * @param dicList
     * @return
     */
    public String convertTypeName(String typeName, Integer flag, List<DictionaryInfoDTO> dicList) {
        if (ListUtil.isNotEmpty(dicList)) {
            Map<String, String> nameValMap = new HashMap<>();
            if (flag.equals(1)) {
                nameValMap = EntityUtil.makeMapWithKeyValue(dicList, "name", "val");
            } else if (flag.equals(2)) {
                nameValMap = EntityUtil.makeMapWithKeyValue(dicList, "val", "name");
            }
            if (nameValMap.containsKey(typeName)) {
                return nameValMap.get(typeName);
            }
        }
        return typeName;
    }

    /**
     * @param staticKnowledgeHISVO
     * @return
     */
    public List<String> getUniqueNames(StaticKnowledgeHISVO staticKnowledgeHISVO) {
        String hospitalId = SysUserUtils.getCurrentHospitalID();
        List<String> nameList = null;
        switch (staticKnowledgeHISVO.getType()) {
            case 1:
                Map<String, Map<String, Long>> disConfigMap
                        = diseaseConfigFacade.getConfigMap(Long.valueOf(hospitalId),
                        ListUtil.arrayToList(new String[] { staticKnowledgeHISVO.getHisName() }), null);
                if (disConfigMap != null) {
                    nameList = new ArrayList<>(disConfigMap.get(staticKnowledgeHISVO.getHisName()).keySet());
                }
                break;
            case 2:
                Map<String, Map<String, Long>> drugConfigMap
                        = drugConfigFacade.getConfigMapWithoutForm(Long.valueOf(hospitalId),
                        ListUtil.arrayToList(new String[] { staticKnowledgeHISVO.getHisName() }), null);
                if (drugConfigMap != null) {
                    nameList = new ArrayList<>(drugConfigMap.get(staticKnowledgeHISVO.getHisName()).keySet());
                }
                break;
            case 3:
            case 4:
                Map<String, Map<String, Map<String, Long>>> lisConfigMap
                        = lisConfigFacade.getConfigMap(Long.valueOf(hospitalId),
                        ListUtil.arrayToList(new String[] { staticKnowledgeHISVO.getHisName() }), null);
                if (lisConfigMap != null) {
                    if (StringUtil.isBlank(staticKnowledgeHISVO.getHisDetailName())) {
                        staticKnowledgeHISVO.setHisDetailName("");
                    }
                    if (lisConfigMap.containsKey(staticKnowledgeHISVO.getHisName())) {
                        if (lisConfigMap.get(staticKnowledgeHISVO.getHisName()).containsKey(staticKnowledgeHISVO.getHisDetailName())) {
                            nameList = new ArrayList<>(lisConfigMap.get(staticKnowledgeHISVO.getHisName())
                                    .get(staticKnowledgeHISVO.getHisDetailName()).keySet());
                        }
                    }
                }
                break;
            case 5:
                Map<String, Map<String, Long>> pacsConfigMap
                        = pacsConfigFacade.getConfigMap(Long.valueOf(hospitalId),
                        ListUtil.arrayToList(new String[] { staticKnowledgeHISVO.getHisName() }), null);
                if (pacsConfigMap != null) {
                    nameList = new ArrayList<>(pacsConfigMap.get(staticKnowledgeHISVO.getHisName()).keySet());
                }
                break;
            case 6:
                Map<String, Map<String, Long>> operationConfigMap
                        = operationConfigFacade.getConfigMap(Long.valueOf(hospitalId),
                        ListUtil.arrayToList(new String[] { staticKnowledgeHISVO.getHisName() }), null);
                if (operationConfigMap != null) {
                    nameList = new ArrayList<>(operationConfigMap.get(staticKnowledgeHISVO.getHisName()).keySet());
                }
                break;
            default:
                break;

        }
        nameList = nameList
                .stream()
                .distinct()
                .collect(Collectors.toList());
        return nameList;
    }

    /**
     * 列表
     *
     * @param conceptInfoPageVO
     * @return
     */
    public IPage<ConceptInfoDTO> getPage(ConceptInfoPageVO conceptInfoPageVO) {
        List<DictionaryInfoDTO> dicList = dictionaryFacade.getListByGroupType(8);
        if (StringUtil.isNotBlank(conceptInfoPageVO.getType())) {
            String typeName
                    = convertTypeName(StaticTypeEnum.getName(Integer.valueOf(conceptInfoPageVO.getType())), 1, dicList);
            conceptInfoPageVO.setTypeName(typeName);
        }
        IPage<ConceptInfoDTO> page = super.getPage(conceptInfoPageVO);
        List<ConceptInfoDTO> records = page.getRecords();
        if (ListUtil.isNotEmpty(records)) {
            records.forEach(record -> {
                String typeName = convertTypeName(record.getType(), 2, dicList);
                record.setTypeName(typeName);
                record.setType(String.valueOf(StaticTypeEnum.getKey(typeName)));
            });
        }
        page.setRecords(records);
        return page;
    }

    /**
     * 保存记录（新增or修改）
     *
     * @param conceptInfoVO
     * @return
     */
    public Boolean saveOrUpdateRecord(ConceptInfoVO conceptInfoVO) {
        String userId = SysUserUtils.getCurrentPrincipleID();
        Date now = DateUtil.now();
        List<DictionaryInfoDTO> dicList = dictionaryFacade.getListByGroupType(8);
        //术语类型转换
        String typeName = convertTypeName(StaticTypeEnum.getName(Integer.valueOf(conceptInfoVO.getType())), 1, dicList);
        conceptInfoVO.setTypeName(typeName);
        ConceptInfo conceptInfo = new ConceptInfo();

        if (conceptInfoVO.getId() != null) {
            conceptInfo = this.getById(conceptInfoVO.getId());
            if (conceptInfo != null
                    && !conceptInfo.getName().equals(conceptInfoVO.getName())) {
                throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "标准术语名称不允许修改");
            }
        } else {
            QueryWrapper<ConceptInfo> conceptInfoQueryWrapper = new QueryWrapper<>();
            conceptInfoQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                    .eq("name", conceptInfoVO.getName())
                    .eq("type", typeName);
            conceptInfo = this.getOne(conceptInfoQueryWrapper, false);
            //术语不存在，保存术语信息
            if (conceptInfo == null) {
                conceptInfo = new ConceptInfo();
                conceptInfo.setCreator(userId);
                conceptInfo.setGmtCreate(now);
            }
        }
        conceptInfo.setName(conceptInfoVO.getName());
        conceptInfo.setClinicalPathwayName(conceptInfoVO.getClinicalPathwayName());
        conceptInfo.setNoticeName(conceptInfoVO.getNoticeName());
        conceptInfo.setType(typeName);
        conceptInfo.setModifier(userId);
        conceptInfo.setGmtModified(now);

        //是否包含静态信息，包含启用和禁用
        List<ConceptDetail> oldDetails = null;
        QueryWrapper<ConceptDetail> conceptDetailQueryWrapper = new QueryWrapper<>();
        if (conceptInfo.getId() != null) {
            conceptDetailQueryWrapper.eq("concept_id", conceptInfo.getId());
            oldDetails = conceptDetailFacade.list(conceptDetailQueryWrapper);
        }
        if (conceptInfoVO.getId() == null
                && ListUtil.isNotEmpty(oldDetails)) {
            throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "静态信息已添加，不允许重复添加");
        }
        if (ListUtil.isEmpty(oldDetails)
                && ListUtil.isNotEmpty(conceptInfoVO.getDetails())) {
            //TODO 更新图谱是否有静态信息
            HasStaticKnowledgeVO hasStaticKnowledgeVO = new HasStaticKnowledgeVO();
            hasStaticKnowledgeVO.setName(conceptInfoVO.getName());
            hasStaticKnowledgeVO.setType(typeName);
            hasStaticKnowledgeVO.setHasInfo(1);
            RespDTO<Boolean> respDTO = cdssCoreClient.updateHasInfoStatus(hasStaticKnowledgeVO);
            //更新失败
            if (RespDTOUtil.respIsNG(respDTO)) {

            }
        }

        //删除已有静态信息
        if (conceptInfo.getId() != null) {
            conceptDetailFacade.remove(conceptDetailQueryWrapper);
        }

        //更新术语信息
        this.saveOrUpdate(conceptInfo);

        //插入新的静态信息
        List<ConceptDetail> conceptDetailList = Lists.newLinkedList();
        if (ListUtil.isNotEmpty(conceptInfoVO.getDetails())) {
            for (ConceptDetailVO detailVO : conceptInfoVO.getDetails()) {
                ConceptDetail conceptDetail = new ConceptDetail();
                BeanUtil.copyProperties(detailVO, conceptDetail);
                conceptDetail.setConceptId(conceptInfo.getId());
                conceptDetail.setCreator(userId);
                conceptDetail.setGmtCreate(now);
                conceptDetail.setModifier(userId);
                conceptDetail.setGmtModified(now);
                conceptDetailList.add(conceptDetail);
            }
            conceptDetailService.saveBatch(conceptDetailList);
        }
        return true;
    }

    /**
     * 启用禁用
     *
     * @param changeStatusVO
     * @return
     */
    public Boolean changeStatus(ChangeStatusVO changeStatusVO) {
        String userId = SysUserUtils.getCurrentPrincipleID();
        Date now = DateUtil.now();
        UpdateWrapper<ConceptDetail> conceptDetailUpdateWrapper = new UpdateWrapper<>();
        conceptDetailUpdateWrapper.eq("concept_id", changeStatusVO.getId())
                .set("gmt_modified", now)
                .set("modifier", userId)
                .set("is_deleted", changeStatusVO.getIsDeleted());
        conceptDetailService.update(conceptDetailUpdateWrapper);
        return true;
    }

    /**
     * 是否已存在
     *
     * @param conceptInfoVO
     * @return
     */
    public Boolean isExist(ConceptInfoVO conceptInfoVO) {
        List<DictionaryInfoDTO> dicList = dictionaryFacade.getListByGroupType(8);
        //术语类型转换
        String typeName = convertTypeName(StaticTypeEnum.getName(Integer.valueOf(conceptInfoVO.getType())), 1, dicList);
        conceptInfoVO.setTypeName(typeName);
        QueryWrapper<ConceptInfo> conceptInfoQueryWrapper = new QueryWrapper<>();
        conceptInfoQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("name", conceptInfoVO.getName())
                .eq("type", typeName);
        ConceptInfo conceptInfo = this.getOne(conceptInfoQueryWrapper, false);
        if (conceptInfo == null) {
            return false;
        }
        QueryWrapper<ConceptDetail> conceptDetailQueryWrapper = new QueryWrapper<>();
        conceptDetailQueryWrapper.eq("concept_id", conceptInfo.getId());
        List<ConceptDetail> conceptDetailList = conceptDetailService.list(conceptDetailQueryWrapper);
        if (ListUtil.isEmpty(conceptDetailList)) {
            return false;
        }
        return true;
    }

    /**
     * 根据术语id获取静态信息
     *
     * @param idVO
     * @return
     */
    public ConceptInfoDTO getRecordById(IdVO idVO) {
        List<DictionaryInfoDTO> dicList = dictionaryFacade.getListByGroupType(8);
        ConceptInfoDTO conceptInfoDTO = new ConceptInfoDTO();
        ConceptInfo conceptInfo = this.getById(idVO.getId());
        if (conceptInfo == null) {
            return null;
        }
        BeanUtil.copyProperties(conceptInfo, conceptInfoDTO);
        QueryWrapper<ConceptDetail> conceptDetailQueryWrapper = new QueryWrapper<>();
        conceptDetailQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("concept_id", idVO.getId())
                .orderByAsc("order_no");
        List<ConceptDetail> conceptDetailList = conceptDetailFacade.list(conceptDetailQueryWrapper);
        if (ListUtil.isNotEmpty(conceptDetailList)) {
            List<ConceptDetailDTO> details = BeanUtil.listCopyTo(conceptDetailList, ConceptDetailDTO.class);
            conceptInfoDTO.setDetails(details);
            //启用状态、修改人、修改时间为明细的内容
            String typeName = convertTypeName(conceptInfoDTO.getType(), 2, dicList);
            conceptInfoDTO.setTypeName(typeName);
            conceptInfoDTO.setType(String.valueOf(StaticTypeEnum.getKey(typeName)));
            conceptInfoDTO.setModifier(conceptDetailList.get(0).getModifier());
            conceptInfoDTO.setGmtModified(conceptDetailList.get(0).getGmtModified());
            conceptInfoDTO.setIsDeleted(conceptDetailList.get(0).getIsDeleted());
        }
        return conceptInfoDTO;
    }

    /**
     * 获取静态知识map Map<name_type,List<ConceptDetail>>
     *
     * @param nameList
     * @return
     */
    public Map<String, List<ConceptDetail>> getDetailByConcept(List<String> nameList) {
        Map<String, List<ConceptDetail>> retMap = new HashMap<>();
        List<DictionaryInfoDTO> dicList = dictionaryFacade.getListByGroupType(8);
        QueryWrapper<ConceptInfo> conceptInfoQueryWrapper = new QueryWrapper<>();
        conceptInfoQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey());
        if (ListUtil.isNotEmpty(nameList)) {
            conceptInfoQueryWrapper.in("name", nameList);
        }
        List<ConceptInfo> conceptInfoList = this.list(conceptInfoQueryWrapper);
        Map<Long, ConceptInfo> conceptMap = EntityUtil.makeEntityMap(conceptInfoList, "id");

        if (ListUtil.isNotEmpty(conceptInfoList)) {
            List<Long> conceptIds = conceptInfoList.stream()
                    .map(i -> i.getId())
                    .collect(Collectors.toList());

            QueryWrapper<ConceptDetail> conceptDetailQueryWrapper = new QueryWrapper<>();
            conceptDetailQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                    .in("concept_id", conceptIds);
            List<ConceptDetail> conceptDetailList = conceptDetailFacade.list(conceptDetailQueryWrapper);
            Map<Long, List<ConceptDetail>> detailMap
                    = EntityUtil.makeEntityListMap(conceptDetailList, "conceptId");

            for (Map.Entry<Long, ConceptInfo> entry : conceptMap.entrySet()) {
                if (detailMap.containsKey(entry.getKey())) {
                    retMap.put(entry.getValue().getName() + "_" + convertTypeName(entry.getValue().getType(), 2, dicList), detailMap.get(entry.getKey()));
                }
            }
        }
        return retMap;
    }
}