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

package com.diagbot.facade;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.diagbot.client.CdssCoreClient;
import com.diagbot.dto.ExportCommonStaticTestDTO;
import com.diagbot.dto.ExportCommonTestDTO;
import com.diagbot.dto.ExportLisStaticTestDTO;
import com.diagbot.dto.ExportLisTestDTO;
import com.diagbot.dto.IndexBatchDTO;
import com.diagbot.dto.RespDTO;
import com.diagbot.entity.DiseaseConfig;
import com.diagbot.entity.DrugConfig;
import com.diagbot.entity.KlConcept;
import com.diagbot.entity.KlConceptStatic;
import com.diagbot.entity.KlRelation;
import com.diagbot.entity.LisConfig;
import com.diagbot.entity.OperationConfig;
import com.diagbot.entity.PacsConfig;
import com.diagbot.entity.ResultStaticInfo;
import com.diagbot.entity.ResultStaticKnowledge;
import com.diagbot.enums.ConceptTypeEnum;
import com.diagbot.enums.IsDeleteEnum;
import com.diagbot.enums.LexiconEnum;
import com.diagbot.enums.StatusEnum;
import com.diagbot.exception.CommonErrorCode;
import com.diagbot.exception.CommonException;
import com.diagbot.service.ResultStaticInfoService;
import com.diagbot.service.ResultStaticKnowledgeService;
import com.diagbot.service.impl.ResultStaticKnowledgeServiceImpl;
import com.diagbot.util.BeanUtil;
import com.diagbot.util.DateUtil;
import com.diagbot.util.ExcelUtils;
import com.diagbot.util.ListUtil;
import com.diagbot.util.RespDTOUtil;
import com.diagbot.util.StringUtil;
import com.diagbot.vo.ConceptVO;
import com.diagbot.vo.ResultStaticPageVO;
import com.diagbot.vo.RunningInfoVO;
import com.diagbot.vo.StaticKnowledgeTestVO;
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 org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;


/**
 * @Description:
 * @Author:zhaops
 * @time: 2021/1/21 15:20
 */

@Component
public class ResultStaticKnowledgeFacade extends ResultStaticKnowledgeServiceImpl {
    @Autowired
    private CdssCoreClient cdssCoreClient;
    @Autowired
    private KlConceptFacade klConceptFacade;
    @Autowired
    private KlRelationFacade klRelationFacade;
    @Autowired
    private KlConceptStaticFacade klConceptStaticFacade;

    @Autowired
    private MappingConfigFacade mappingConfigFacade;
    @Autowired
    private RunningInfoFacade runningInfoFacade;

    @Autowired
    @Qualifier("resultStaticKnowledgeServiceImpl")
    private ResultStaticKnowledgeService resultStaticKnowledgeService;
    @Autowired
    @Qualifier("resultStaticInfoServiceImpl")
    private ResultStaticInfoService resultStaticInfoService;


    /**
     * 化验静态知识测试
     *
     * @param file
     * @param testVO
     * @return
     */

    public Boolean lisTest(MultipartFile file, StaticKnowledgeTestVO testVO) {
        RunningInfoVO runningInfoVO = new RunningInfoVO();
        runningInfoVO.setCaseId(testVO.getCaseId());
        runningInfoVO.setHospitalId(testVO.getHospitalId());

        String fileName = file.getOriginalFilename();
        if (!(fileName.endsWith(".xls") || fileName.endsWith(".xlsx"))) {
            //终止运行
            runningInfoVO.setStatus(0);
            runningInfoFacade.updateStatus(runningInfoVO);
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "请导入正确的文件类型");
        }

        List<ResultStaticKnowledge> mappingList = Lists.newLinkedList();
        List<ResultStaticKnowledge> saveList = Lists.newLinkedList();
        Long hospitalId = testVO.getHospitalId();
        Date now = DateUtil.now();

        //从Excel读取数据
        List<LisConfig> lisConfigList = Lists.newLinkedList();
        try {
            lisConfigList = ExcelUtils.importExcel(file, 0, 1, LisConfig.class);
        } catch (CommonException e) {
            if (!e.getErrorCode().equals(CommonErrorCode.OK)) {
                //终止运行
                runningInfoVO.setStatus(0);
                runningInfoFacade.updateStatus(runningInfoVO);
                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "请导入正确的文件格式");
            }
        }

        Integer totleNum = 0;
        if (ListUtil.isNotEmpty(lisConfigList)) {
            totleNum = lisConfigList.size();
        } else {
            lisConfigList = Lists.newLinkedList();
        }

        //数据预处理
        for (int i = 0; i < lisConfigList.size(); i++) {
            if (StringUtil.isNotBlank(lisConfigList.get(i).getHisName())) {
                lisConfigList.get(i).setHisName(lisConfigList.get(i).getHisName().trim());
            }
            if (StringUtil.isNotBlank(lisConfigList.get(i).getHisDetailName())) {
                lisConfigList.get(i).setHisDetailName(lisConfigList.get(i).getHisDetailName().trim());
            } else {
                lisConfigList.get(i).setHisDetailName("");
            }
        }

        // 已存在数据
        Map<String, Map<String, Map<String, List<String>>>> hisConfigMap
                = mappingConfigFacade.groupByHisNameWithName(null, ConceptTypeEnum.LisPack.getKey(), Long.valueOf(hospitalId));

        //术语映射
        for (LisConfig config : lisConfigList) {
            ResultStaticKnowledge result = new ResultStaticKnowledge();
            result.setGmtCreate(now);
            result.setGmtModified(now);
            result.setMessage("");

            if (StringUtil.isBlank(config.getHisName())) {
                result.setMessage(result.getMessage() + "医院术语不允许为空；");
                mappingList.add(result);
                continue;
            }
            result.setHisName(config.getHisName());
            result.setHisDetailName(config.getHisDetailName());
            if (hisConfigMap.containsKey(result.getHisName())
                    && hisConfigMap.get(result.getHisName()).containsKey(result.getHisDetailName())) {
                Map<String, List<String>> subMap = hisConfigMap.get(result.getHisName()).get(result.getHisDetailName());
                if (subMap != null && subMap.size() > 0) {
                    for (String subKey : subMap.keySet()) {
                        ResultStaticKnowledge subResult = new ResultStaticKnowledge();
                        BeanUtil.copyProperties(result, subResult);
                        subResult.setName(subKey);
                        subResult.setHasStandName(1);
                        mappingList.add(subResult);
                    }
                } else {
                    result.setHasStandName(0);
                    result.setMessage(result.getMessage() + "标准术语不存在；");
                    mappingList.add(result);
                }
            } else {
                result.setHasStandName(0);
                result.setMessage(result.getMessage() + "标准术语不存在；");
                mappingList.add(result);
            }
        }

        //标准术语验证
        List<String> uniqueNames = mappingList
                .stream()
                .filter(i -> StringUtil.isNotBlank(i.getName()))
                .map(i -> i.getName())
                .collect(Collectors.toList());
        ConceptVO conceptVO = new ConceptVO();
        conceptVO.setNames(uniqueNames);
        conceptVO.setType(ConceptTypeEnum.LisPack.getKey());
        RespDTO<List<IndexBatchDTO>> respLisPackDTO = cdssCoreClient.getConceptNames(conceptVO);
        List<String> lisPackNames = Lists.newLinkedList();
        if (RespDTOUtil.respIsOK(respLisPackDTO)) {
            lisPackNames = respLisPackDTO.data.stream().map(IndexBatchDTO::getName).collect(Collectors.toList());
        }
        conceptVO.setType(ConceptTypeEnum.Lis.getKey());
        RespDTO<List<IndexBatchDTO>> respLisDTO = cdssCoreClient.getConceptNames(conceptVO);
        List<String> lisNames = Lists.newLinkedList();
        if (RespDTOUtil.respIsOK(respLisDTO)) {
            lisNames = respLisDTO.data.stream().map(IndexBatchDTO::getName).collect(Collectors.toList());
        }

        //判断是否有标准术语
        for (ResultStaticKnowledge result : mappingList) {
            if (result.getHasStandName() == null || result.getHasStandName().equals(0)) {
                continue;
            } else {
                if (lisPackNames.contains(result.getName()) || lisNames.contains(result.getName())) {
                    result.setHasStandName(1);
                } else {
                    result.setHasStandName(0);
                    result.setMessage(result.getMessage() + "标准术语不存在；");
                }
            }
        }

        //验证静态知识
        List<KlConcept> infoList = klConceptStaticFacade.getAllConcept();
        if (ListUtil.isEmpty(infoList)) {
            infoList = Lists.newLinkedList();
        }
        List<String> lisStaticNames = infoList.stream()
                .filter(i -> i.getLibType().equals(LexiconEnum.LisSubName.getKey()))
                .map(i -> i.getLibName())
                .distinct()
                .collect(Collectors.toList());
        List<String> lisPackStaticNames = infoList.stream()
                .filter(i -> i.getLibType().equals(LexiconEnum.LisName.getKey()))
                .map(i -> i.getLibName())
                .distinct()
                .collect(Collectors.toList());

        for (ResultStaticKnowledge result : mappingList) {
            //静态知识是否存在
            if (result.getHasStandName() != null && result.getHasStandName().equals(1)) {
                if (lisStaticNames.contains(result.getName())
                        || lisPackStaticNames.contains(result.getName())) {
                    result.setHasStaticKnowledge(1);
                } else {
                    //查找上级静态知识是否存在
                    KlConcept lisSubName = klConceptFacade.getOne(new QueryWrapper<KlConcept>()
                            .eq("is_deleted", IsDeleteEnum.N.getKey())
                            .eq("lib_name", result.getName())
                            .eq("lib_type", LexiconEnum.LisSubName.getKey()), false);
                    if (lisSubName == null) {
                        result.setHasStaticKnowledge(0);
                        result.setMessage(result.getMessage() + "缺少静态知识；");
                    } else {
                        List<KlRelation> relations = klRelationFacade.list(new QueryWrapper<KlRelation>()
                                .eq("is_deleted", IsDeleteEnum.N.getKey())
                                .eq("end_id", lisSubName.getId())
                                .eq("relation_id", 600));
                        if (ListUtil.isNotEmpty(relations)) {
                            KlConceptStatic staticInfo = klConceptStaticFacade.getOne(new QueryWrapper<KlConceptStatic>()
                                    .eq("is_deleted", IsDeleteEnum.N.getKey())
                                    .in("concept_id", relations.stream().map(i -> i.getStartId()).collect(Collectors.toList()))
                                    .eq("status", StatusEnum.Enable.getKey()), false);
                            if (staticInfo == null) {
                                result.setHasStaticKnowledge(0);
                                result.setMessage(result.getMessage() + "缺少静态知识；");
                            } else {
                                KlConcept lisName = klConceptFacade.getById(staticInfo.getConceptId());
                                result.setHasStaticKnowledge(1);
                                result.setMessage(result.getMessage() + "取上级（" + lisName.getLibName() + "）静态知识；");
                            }
                        } else {
                            result.setHasStaticKnowledge(0);
                            result.setMessage(result.getMessage() + "缺少静态知识；");
                        }
                    }
                }
            }
            saveList.add(result);
        }

        //保存
        saveResult(saveList, testVO, totleNum);
        return true;
    }


    /**
     * 辅检静态知识测试
     *
     * @param file
     * @param testVO
     * @return
     */

    public Boolean pacsTest(MultipartFile file, StaticKnowledgeTestVO testVO) {
        RunningInfoVO runningInfoVO = new RunningInfoVO();
        runningInfoVO.setCaseId(testVO.getCaseId());
        runningInfoVO.setHospitalId(testVO.getHospitalId());

        String fileName = file.getOriginalFilename();
        if (!(fileName.endsWith(".xls") || fileName.endsWith(".xlsx"))) {
            //终止运行
            runningInfoVO.setStatus(0);
            runningInfoFacade.updateStatus(runningInfoVO);
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "请导入正确的文件类型");
        }

        List<ResultStaticKnowledge> mappingList = Lists.newLinkedList();
        List<ResultStaticKnowledge> saveList = Lists.newLinkedList();
        Long hospitalId = testVO.getHospitalId();
        Date now = DateUtil.now();

        //从Excel读取数据
        List<PacsConfig> pacsConfigList = Lists.newLinkedList();
        try {
            pacsConfigList = ExcelUtils.importExcel(file, 0, 1, PacsConfig.class);
        } catch (CommonException e) {
            if (!e.getErrorCode().equals(CommonErrorCode.OK)) {
                //终止运行
                runningInfoVO.setStatus(0);
                runningInfoFacade.updateStatus(runningInfoVO);
                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "请导入正确的文件格式");
            }
        }

        Integer totleNum = 0;
        if (ListUtil.isNotEmpty(pacsConfigList)) {
            totleNum = pacsConfigList.size();
        } else {
            pacsConfigList = Lists.newLinkedList();
        }

        //数据预处理
        for (PacsConfig config : pacsConfigList) {
            if (StringUtil.isNotBlank(config.getHisName())) {
                config.setHisName(config.getHisName().trim());
            }
        }

        //重复数据过滤
        /*pacsConfigList = pacsConfigList
                .stream()
                .distinct()
                .collect(Collectors.toList());*/


        // 已存在数据
        Map<String, Map<String, Map<String, List<String>>>> hisConfigMap
                = mappingConfigFacade.groupByHisNameWithName(null, ConceptTypeEnum.Pacs.getKey(), Long.valueOf(hospitalId));
        //术语映射
        for (PacsConfig config : pacsConfigList) {
            ResultStaticKnowledge result = new ResultStaticKnowledge();
            result.setGmtCreate(now);
            result.setGmtModified(now);
            result.setMessage("");

            if (StringUtil.isBlank(config.getHisName())) {
                result.setMessage(result.getMessage() + "医院术语不允许为空；");
                mappingList.add(result);
                continue;
            }
            result.setHisName(config.getHisName());

            if (hisConfigMap.containsKey(result.getHisName())) {
                Map<String, List<String>> subMap = hisConfigMap.get(result.getHisName()).get("");
                if (subMap != null && subMap.size() > 0) {
                    for (String subKey : subMap.keySet()) {
                        ResultStaticKnowledge subResult = new ResultStaticKnowledge();
                        BeanUtil.copyProperties(result, subResult);
                        subResult.setName(subKey);
                        subResult.setHasStandName(1);
                        mappingList.add(subResult);
                    }
                } else {
                    result.setHasStandName(0);
                    result.setMessage(result.getMessage() + "标准术语不存在；");
                    mappingList.add(result);
                }
            } else {
                result.setHasStandName(0);
                result.setMessage(result.getMessage() + "标准术语不存在；");
                mappingList.add(result);
            }
        }

        //标准术语校验
        List<String> uniqueNames = mappingList.stream()
                .filter(i -> StringUtil.isNotBlank(i.getName()))
                .map(i -> i.getName())
                .distinct()
                .collect(Collectors.toList());
        ConceptVO conceptVO = new ConceptVO();
        conceptVO.setNames(uniqueNames);
        conceptVO.setType(ConceptTypeEnum.Pacs.getKey());
        RespDTO<List<IndexBatchDTO>> respDTO = cdssCoreClient.getConceptNames(conceptVO);
        List<String> names = Lists.newLinkedList();
        if (RespDTOUtil.respIsOK(respDTO)) {
            names = respDTO.data.stream().map(IndexBatchDTO::getName).collect(Collectors.toList());
        }
        for (ResultStaticKnowledge result : mappingList) {
            if (result.getHasStandName() == null || result.getHasStandName().equals(0)) {
                continue;
            } else {
                if (names.contains(result.getName())) {
                    result.setHasStandName(1);
                } else {
                    result.setHasStandName(0);
                    result.setMessage(result.getMessage() + "标准术语不存在；");
                }
            }
        }

        //静态知识
        List<KlConcept> infoList = klConceptStaticFacade.getAllConcept();
        if (ListUtil.isEmpty(infoList)) {
            infoList = Lists.newLinkedList();
        }
        List<String> pacsStaticNames = infoList.stream()
                .filter(i -> i.getLibType().equals(LexiconEnum.PacsName.getKey()))
                .map(i -> i.getLibName())
                .distinct()
                .collect(Collectors.toList());
        List<String> subPacsPackStaticNames = infoList.stream()
                .filter(i -> i.getLibType().equals(LexiconEnum.PacsSubName.getKey()))
                .map(i -> i.getLibName())
                .distinct()
                .collect(Collectors.toList());

        for (ResultStaticKnowledge result : mappingList) {
            //静态知识是否存在
            if (result.getHasStandName() != null && result.getHasStandName().equals(1)) {
                if (pacsStaticNames.contains(result.getName())
                        || subPacsPackStaticNames.contains(result.getName())) {
                    result.setHasStaticKnowledge(1);
                } else {
                    //查找上级静态知识是否存在
                    KlConcept pacsSubName = klConceptFacade.getOne(new QueryWrapper<KlConcept>()
                            .eq("is_deleted", IsDeleteEnum.N.getKey())
                            .eq("lib_name", result.getName())
                            .eq("lib_type", LexiconEnum.PacsSubName.getKey()), false);
                    if (pacsSubName == null) {
                        result.setHasStaticKnowledge(0);
                        result.setMessage(result.getMessage() + "缺少静态知识；");
                    } else {
                        List<KlRelation> relations = klRelationFacade.list(new QueryWrapper<KlRelation>()
                                .eq("is_deleted", IsDeleteEnum.N.getKey())
                                .eq("end_id", pacsSubName.getId())
                                .eq("relation_id", 600));
                        if (ListUtil.isNotEmpty(relations)) {
                            KlConceptStatic staticInfo = klConceptStaticFacade.getOne(new QueryWrapper<KlConceptStatic>()
                                    .eq("is_deleted", IsDeleteEnum.N.getKey())
                                    .in("concept_id", relations.stream().map(i -> i.getStartId()).collect(Collectors.toList()))
                                    .eq("status", StatusEnum.Enable.getKey()), false);
                            if (staticInfo == null) {
                                result.setHasStaticKnowledge(0);
                                result.setMessage(result.getMessage() + "缺少静态知识；");
                            } else {
                                KlConcept pacsName = klConceptFacade.getById(staticInfo.getConceptId());
                                result.setHasStaticKnowledge(1);
                                result.setMessage(result.getMessage() + "取上级（" + pacsName.getLibName() + "）静态知识；");
                            }
                        } else {
                            result.setHasStaticKnowledge(0);
                            result.setMessage(result.getMessage() + "缺少静态知识；");
                        }
                    }
                }
            }
            saveList.add(result);
        }

        //保存
        saveResult(saveList, testVO, totleNum);
        return true;
    }


    /**
     * 药品静态知识测试
     *
     * @param file
     * @param testVO
     * @return
     */

    public Boolean drugTest(MultipartFile file, StaticKnowledgeTestVO testVO) {
        RunningInfoVO runningInfoVO = new RunningInfoVO();
        runningInfoVO.setCaseId(testVO.getCaseId());
        runningInfoVO.setHospitalId(testVO.getHospitalId());

        String fileName = file.getOriginalFilename();
        if (!(fileName.endsWith(".xls") || fileName.endsWith(".xlsx"))) {
            //终止运行
            runningInfoVO.setStatus(0);
            runningInfoFacade.updateStatus(runningInfoVO);
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "请导入正确的文件类型");
        }

        List<ResultStaticKnowledge> mappingList = Lists.newLinkedList();
        List<ResultStaticKnowledge> saveList = Lists.newLinkedList();
        Long hospitalId = testVO.getHospitalId();
        Date now = DateUtil.now();

        //从Excel读取数据
        List<DrugConfig> drugConfigList = Lists.newLinkedList();
        try {
            drugConfigList = ExcelUtils.importExcel(file, 1, 1, DrugConfig.class);
        } catch (CommonException e) {
            if (!e.getErrorCode().equals(CommonErrorCode.OK)) {
                //终止运行
                runningInfoVO.setStatus(0);
                runningInfoFacade.updateStatus(runningInfoVO);
                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "请导入正确的文件格式");
            }
        }

        Integer totleNum = 0;
        if (ListUtil.isNotEmpty(drugConfigList)) {
            totleNum = drugConfigList.size();
        } else {
            drugConfigList = Lists.newLinkedList();
        }

        //数据预处理
        for (DrugConfig config : drugConfigList) {
            if (StringUtil.isNotBlank(config.getHisName())) {
                config.setHisName(config.getHisName().trim());
            }
        }

        //重复数据过滤
        /*drugConfigList = drugConfigList
                .stream()
                .distinct()
                .collect(Collectors.toList());*/


        // 已存在数据
        Map<String, Map<String, Map<String, List<String>>>> hisConfigMap
                = mappingConfigFacade.groupByHisNameWithName(null, ConceptTypeEnum.Drug.getKey(), Long.valueOf(hospitalId));

        //术语映射
        for (DrugConfig config : drugConfigList) {
            ResultStaticKnowledge result = new ResultStaticKnowledge();
            result.setGmtCreate(now);
            result.setGmtModified(now);
            result.setMessage("");

            if (StringUtil.isBlank(config.getHisName())) {
                result.setMessage(result.getMessage() + "医院术语不允许为空；");
                mappingList.add(result);
                continue;
            }
            result.setHisName(config.getHisName());

            if (hisConfigMap.containsKey(result.getHisName())) {
                Map<String, List<String>> subMap = hisConfigMap.get(result.getHisName()).get("");
                if (subMap != null && subMap.size() > 0) {
                    for (String subKey : subMap.keySet()) {
                        ResultStaticKnowledge subResult = new ResultStaticKnowledge();
                        BeanUtil.copyProperties(result, subResult);
                        subResult.setName(subKey);
                        subResult.setHasStandName(1);
                        mappingList.add(subResult);
                    }
                } else {
                    result.setHasStandName(0);
                    result.setMessage(result.getMessage() + "标准术语不存在；");
                    mappingList.add(result);
                }
            } else {
                result.setHasStandName(0);
                result.setMessage(result.getMessage() + "标准术语不存在；");
                mappingList.add(result);
            }
        }

        //标准术语校验
        List<String> uniqueNames = mappingList.stream()
                .filter(i -> StringUtil.isNotBlank(i.getName()))
                .map(i -> i.getName())
                .distinct()
                .collect(Collectors.toList());
        ConceptVO conceptVO = new ConceptVO();
        conceptVO.setNames(uniqueNames);
        conceptVO.setType(ConceptTypeEnum.Drug.getKey());
        RespDTO<List<IndexBatchDTO>> respDTO = cdssCoreClient.getConceptNames(conceptVO);
        List<String> names = Lists.newLinkedList();
        if (RespDTOUtil.respIsOK(respDTO)) {
            names = respDTO.data.stream().map(IndexBatchDTO::getName).collect(Collectors.toList());
        }
        for (ResultStaticKnowledge result : mappingList) {
            if (result.getHasStandName() == null || result.getHasStandName().equals(0)) {
                continue;
            } else {
                if (names.contains(result.getName())) {
                    result.setHasStandName(1);
                } else {
                    result.setHasStandName(0);
                    result.setMessage(result.getMessage() + "标准术语不存在；");
                }
            }
        }

        //验证静态知识
        List<KlConcept> infoList = klConceptStaticFacade.getAllConcept();
        if (ListUtil.isEmpty(infoList)) {
            infoList = Lists.newLinkedList();
        }
        List<String> drugStaticNames = infoList.stream()
                .filter(i -> i.getLibType().equals(LexiconEnum.Medicine.getKey()))
                .map(i -> i.getLibName())
                .distinct()
                .collect(Collectors.toList());

        for (ResultStaticKnowledge result : mappingList) {
            //静态知识是否存在
            if (result.getHasStandName() != null && result.getHasStandName().equals(1)) {
                if (drugStaticNames.contains(result.getName())) {
                    result.setHasStaticKnowledge(1);
                } else {
                    result.setHasStaticKnowledge(0);
                    result.setMessage(result.getMessage() + "缺少静态知识；");
                }
            }
            saveList.add(result);
        }

        //保存
        saveResult(saveList, testVO, totleNum);
        return true;
    }


    /**
     * 诊断静态知识测试
     *
     * @param file
     * @param testVO
     * @return
     */

    public Boolean diseaseTest(MultipartFile file, StaticKnowledgeTestVO testVO) {
        RunningInfoVO runningInfoVO = new RunningInfoVO();
        runningInfoVO.setCaseId(testVO.getCaseId());
        runningInfoVO.setHospitalId(testVO.getHospitalId());

        String fileName = file.getOriginalFilename();
        if (!(fileName.endsWith(".xls") || fileName.endsWith(".xlsx"))) {
            //终止运行
            runningInfoVO.setStatus(0);
            runningInfoFacade.updateStatus(runningInfoVO);
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "请导入正确的文件类型");
        }

        List<ResultStaticKnowledge> mappingList = Lists.newLinkedList();
        List<ResultStaticKnowledge> saveList = Lists.newLinkedList();
        Long hospitalId = testVO.getHospitalId();
        Date now = DateUtil.now();

        //从Excel读取数据
        List<DiseaseConfig> diseaseConfigList = Lists.newLinkedList();
        try {
            diseaseConfigList = ExcelUtils.importExcel(file, 0, 1, DiseaseConfig.class);
        } catch (CommonException e) {
            if (!e.getErrorCode().equals(CommonErrorCode.OK)) {
                //终止运行
                runningInfoVO.setStatus(0);
                runningInfoFacade.updateStatus(runningInfoVO);
                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "请导入正确的文件格式");
            }
        }

        Integer totleNum = 0;
        if (ListUtil.isNotEmpty(diseaseConfigList)) {
            totleNum = diseaseConfigList.size();
        } else {
            diseaseConfigList = Lists.newLinkedList();
        }

        //数据预处理
        for (DiseaseConfig config : diseaseConfigList) {
            if (StringUtil.isNotBlank(config.getHisName())) {
                config.setHisName(config.getHisName().trim());
            }
        }

        //重复数据过滤
        /*diseaseConfigList = diseaseConfigList
                .stream()
                .distinct()
                .collect(Collectors.toList());*/


        // 已存在数据
        Map<String, Map<String, Map<String, List<String>>>> hisConfigMap
                = mappingConfigFacade.groupByHisNameWithName(null, ConceptTypeEnum.Disease.getKey(), Long.valueOf(hospitalId));
        //Map<String, Map<String, List<Long>>> hisConfigMap = diseaseConfigFacade.getConfigMap(Long.valueOf(hospitalId), null, null);

        //术语映射
        for (DiseaseConfig config : diseaseConfigList) {
            ResultStaticKnowledge result = new ResultStaticKnowledge();
            result.setGmtCreate(now);
            result.setGmtModified(now);
            result.setMessage("");

            if (StringUtil.isBlank(config.getHisName())) {
                result.setMessage(result.getMessage() + "医院术语不允许为空；");
                mappingList.add(result);
                continue;
            }
            result.setHisName(config.getHisName());

            if (hisConfigMap.containsKey(result.getHisName())) {
                Map<String, List<String>> subMap = hisConfigMap.get(result.getHisName()).get("");
                if (subMap != null && subMap.size() > 0) {
                    for (String subKey : subMap.keySet()) {
                        ResultStaticKnowledge subResult = new ResultStaticKnowledge();
                        BeanUtil.copyProperties(result, subResult);
                        subResult.setName(subKey);
                        subResult.setHasStandName(1);
                        mappingList.add(subResult);
                    }
                } else {
                    result.setHasStandName(0);
                    result.setMessage(result.getMessage() + "标准术语不存在；");
                    mappingList.add(result);
                }
            } else {
                result.setHasStandName(0);
                result.setMessage(result.getMessage() + "标准术语不存在；");
                mappingList.add(result);
            }
        }

        //标准术语校验
        List<String> uniqueNames = mappingList.stream()
                .filter(i -> StringUtil.isNotBlank(i.getName()))
                .map(i -> i.getName())
                .distinct()
                .collect(Collectors.toList());
        ConceptVO conceptVO = new ConceptVO();
        conceptVO.setNames(uniqueNames);
        conceptVO.setType(ConceptTypeEnum.Disease.getKey());
        RespDTO<List<IndexBatchDTO>> respDTO = cdssCoreClient.getConceptNames(conceptVO);
        List<String> names = Lists.newLinkedList();
        if (RespDTOUtil.respIsOK(respDTO)) {
            names = respDTO.data.stream().map(IndexBatchDTO::getName).collect(Collectors.toList());
        }
        for (ResultStaticKnowledge result : mappingList) {
            if (result.getHasStandName() == null || result.getHasStandName().equals(0)) {
                continue;
            } else {
                if (names.contains(result.getName())) {
                    result.setHasStandName(1);
                } else {
                    result.setHasStandName(0);
                    result.setMessage(result.getMessage() + "标准术语不存在；");
                }
            }
        }

        //验证静态知识
        List<KlConcept> infoList = klConceptStaticFacade.getAllConcept();
        if (ListUtil.isEmpty(infoList)) {
            infoList = Lists.newLinkedList();
        }
        List<String> diseaseStaticNames = infoList.stream()
                .filter(i -> i.getLibName().equals(LexiconEnum.Disease.getKey()))
                .map(i -> i.getLibName())
                .distinct()
                .collect(Collectors.toList());

        for (ResultStaticKnowledge result : mappingList) {
            //静态知识是否存在
            if (result.getHasStandName() != null && result.getHasStandName().equals(1)) {
                if (diseaseStaticNames.contains(result.getName())) {
                    result.setHasStaticKnowledge(1);
                } else {
                    result.setHasStaticKnowledge(0);
                    result.setMessage(result.getMessage() + "缺少静态知识；");
                }
            }
            saveList.add(result);
        }

        //保存
        saveResult(saveList, testVO, totleNum);
        return true;
    }


    /**
     * 手术/操作静态知识测试
     *
     * @param file
     * @param testVO
     * @return
     */

    public Boolean operationTest(MultipartFile file, StaticKnowledgeTestVO testVO) {
        RunningInfoVO runningInfoVO = new RunningInfoVO();
        runningInfoVO.setCaseId(testVO.getCaseId());
        runningInfoVO.setHospitalId(testVO.getHospitalId());

        String fileName = file.getOriginalFilename();
        if (!(fileName.endsWith(".xls") || fileName.endsWith(".xlsx"))) {
            //终止运行
            runningInfoVO.setStatus(0);
            runningInfoFacade.updateStatus(runningInfoVO);
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "请导入正确的文件类型");
        }

        List<ResultStaticKnowledge> mappingList = Lists.newLinkedList();
        List<ResultStaticKnowledge> saveList = Lists.newLinkedList();
        Long hospitalId = testVO.getHospitalId();
        Date now = DateUtil.now();

        //从Excel读取数据
        List<OperationConfig> operationConfigList = Lists.newLinkedList();
        try {
            operationConfigList = ExcelUtils.importExcel(file, 0, 1, OperationConfig.class);
        } catch (CommonException e) {
            if (!e.getErrorCode().equals(CommonErrorCode.OK)) {
                //终止运行
                runningInfoVO.setStatus(0);
                runningInfoFacade.updateStatus(runningInfoVO);
                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "请导入正确的文件格式");
            }
        }

        Integer totleNum = 0;
        if (ListUtil.isNotEmpty(operationConfigList)) {
            totleNum = operationConfigList.size();
        } else {
            operationConfigList = Lists.newLinkedList();
        }

        //数据预处理
        for (OperationConfig config : operationConfigList) {
            if (StringUtil.isNotBlank(config.getHisName())) {
                config.setHisName(config.getHisName().trim());
            }
        }

        //重复数据过滤
       /* operationConfigList = operationConfigList
                .stream()
                .distinct()
                .collect(Collectors.toList());*/


        // 已存在数据
        Map<String, Map<String, Map<String, List<String>>>> hisConfigMap
                = mappingConfigFacade.groupByHisNameWithName(null, ConceptTypeEnum.Operation.getKey(), Long.valueOf(hospitalId));
        //Map<String, Map<String, List<Long>>> hisConfigMap = operationConfigFacade.getConfigMap(Long.valueOf(hospitalId), null, null);

        //术语映射
        for (OperationConfig config : operationConfigList) {
            ResultStaticKnowledge result = new ResultStaticKnowledge();
            result.setGmtCreate(now);
            result.setGmtModified(now);
            result.setMessage("");

            if (StringUtil.isBlank(config.getHisName())) {
                result.setMessage(result.getMessage() + "医院术语不允许为空；");
                mappingList.add(result);
                continue;
            }
            result.setHisName(config.getHisName());

            if (hisConfigMap.containsKey(result.getHisName())) {
                Map<String, List<String>> subMap = hisConfigMap.get(result.getHisName()).get("");
                if (subMap != null && subMap.size() > 0) {
                    for (String subKey : subMap.keySet()) {
                        ResultStaticKnowledge subResult = new ResultStaticKnowledge();
                        BeanUtil.copyProperties(result, subResult);
                        subResult.setName(subKey);
                        subResult.setHasStandName(1);
                        mappingList.add(subResult);
                    }
                } else {
                    result.setHasStandName(0);
                    result.setMessage(result.getMessage() + "标准术语不存在；");
                    mappingList.add(result);
                }
            } else {
                result.setHasStandName(0);
                result.setMessage(result.getMessage() + "标准术语不存在；");
                mappingList.add(result);
            }
        }

        //标准术语校验
        List<String> uniqueNames = mappingList.stream()
                .filter(i -> StringUtil.isNotBlank(i.getName()))
                .map(i -> i.getName())
                .distinct()
                .collect(Collectors.toList());
        ConceptVO conceptVO = new ConceptVO();
        conceptVO.setNames(uniqueNames);
        conceptVO.setType(ConceptTypeEnum.Operation.getKey());
        RespDTO<List<IndexBatchDTO>> respDTO = cdssCoreClient.getConceptNames(conceptVO);
        List<String> names = Lists.newLinkedList();
        if (RespDTOUtil.respIsOK(respDTO)) {
            names = respDTO.data.stream().map(IndexBatchDTO::getName).collect(Collectors.toList());
        }
        for (ResultStaticKnowledge result : mappingList) {
            if (result.getHasStandName() == null || result.getHasStandName().equals(0)) {
                continue;
            } else {
                if (names.contains(result.getName())) {
                    result.setHasStandName(1);
                } else {
                    result.setHasStandName(0);
                    result.setMessage(result.getMessage() + "标准术语不存在；");
                }
            }
        }

        //验证静态知识
        List<KlConcept> infoList = klConceptStaticFacade.getAllConcept();
        if (ListUtil.isEmpty(infoList)) {
            infoList = Lists.newLinkedList();
        }
        List<String> diseaseStaticNames = infoList.stream()
                .filter(i -> i.getLibType().equals(LexiconEnum.Operation.getKey()))
                .map(i -> i.getLibName())
                .distinct()
                .collect(Collectors.toList());

        for (ResultStaticKnowledge result : mappingList) {
            //静态知识是否存在
            if (result.getHasStandName() != null && result.getHasStandName().equals(1)) {
                if (diseaseStaticNames.contains(result.getName())) {
                    result.setHasStaticKnowledge(1);
                } else {
                    result.setHasStaticKnowledge(0);
                    result.setMessage(result.getMessage() + "缺少静态知识；");
                }
            }
            saveList.add(result);
        }

        //保存
        saveResult(saveList, testVO, totleNum);
        return true;
    }


    /**
     * 保存静态知识测试结果
     *
     * @param list
     * @param testVO
     * @return
     */

    @Transactional
    public Boolean saveResult(List<ResultStaticKnowledge> list, StaticKnowledgeTestVO testVO, Integer totleNum) {
        Date now = new Date();
        Integer unMappingNum = list.stream().filter(i -> i.getHasStandName() != null && i.getHasStandName().equals(0)).collect(Collectors.toList()).size();
        Integer withoutKnowledgeNum = list.stream().filter(i -> i.getHasStaticKnowledge() != null && i.getHasStaticKnowledge().equals(0)).collect(Collectors.toList()).size();
        QueryWrapper<ResultStaticInfo> resultStaticInfoQueryWrapper = new QueryWrapper<>();
        resultStaticInfoQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("hospital_id", testVO.getHospitalId())
                .eq("case_id", testVO.getCaseId());
        ResultStaticInfo resultInfo = resultStaticInfoService.getOne(resultStaticInfoQueryWrapper, false);
        if (resultInfo == null) {
            resultInfo = new ResultStaticInfo();
            resultInfo.setHospitalId(testVO.getHospitalId());
            resultInfo.setCaseId(testVO.getCaseId());
            resultInfo.setGmtCreate(now);
        }
        resultInfo.setGmtModified(now);
        resultInfo.setTotleNum(totleNum);
        resultInfo.setUnMappingNum(unMappingNum);
        resultInfo.setWithoutKnowledgeNum(withoutKnowledgeNum);
        resultStaticInfoService.saveOrUpdate(resultInfo);

        QueryWrapper<ResultStaticKnowledge> resultStaticKnowledgeQueryWrapper = new QueryWrapper<>();
        resultStaticKnowledgeQueryWrapper.eq("result_id", resultInfo.getId());
        resultStaticKnowledgeService.remove(resultStaticKnowledgeQueryWrapper);

        for (ResultStaticKnowledge result : list) {
            result.setType(testVO.getType());
            result.setResultId(resultInfo.getId());
        }

        resultStaticKnowledgeService.saveOrUpdateBatch(list);
        return true;
    }

    //region --------------------------导出------------------------------


    /**
     * 数据导出
     *
     * @param response
     * @param resultStaticPageVO
     */

    public void exportLisExcel(HttpServletResponse response, ResultStaticPageVO resultStaticPageVO) {
        resultStaticPageVO.setSize(-1L);
        IPage<ResultStaticKnowledge> page = this.getPage(resultStaticPageVO);
        String fileName = "检验映射测试结果导出.xls";
        List<ExportLisTestDTO> records = BeanUtil.listCopyTo(page.getRecords(), ExportLisTestDTO.class);
        ExcelUtils.exportExcel(records, null, "sheet1", ExportLisTestDTO.class, fileName, response, 12.8f);
    }


    /**
     * 数据导出
     *
     * @param response
     * @param resultStaticPageVO
     */

    public void exportLisStaticExcel(HttpServletResponse response, ResultStaticPageVO resultStaticPageVO) {
        resultStaticPageVO.setSize(-1L);
        IPage<ResultStaticKnowledge> page = this.getPage(resultStaticPageVO);
        String fileName = "检验静态知识测试结果导出.xls";
        List<ExportLisStaticTestDTO> records = BeanUtil.listCopyTo(page.getRecords(), ExportLisStaticTestDTO.class);
        ExcelUtils.exportExcel(records, null, "sheet1", ExportLisStaticTestDTO.class, fileName, response, 12.8f);
    }


    /**
     * 数据导出
     *
     * @param response
     * @param resultStaticPageVO
     */

    public void exportCommonExcel(HttpServletResponse response, ResultStaticPageVO resultStaticPageVO) {
        resultStaticPageVO.setSize(-1L);
        IPage<ResultStaticKnowledge> page = this.getPage(resultStaticPageVO);
        String fileName = "通用映射测试结果导出.xls";
        List<ExportCommonTestDTO> records = BeanUtil.listCopyTo(page.getRecords(), ExportCommonTestDTO.class);
        ExcelUtils.exportExcel(records, null, "sheet1", ExportCommonTestDTO.class, fileName, response, 12.8f);
    }


    /**
     * 数据导出
     *
     * @param response
     * @param resultStaticPageVO
     */

    public void exportCommonStaticExcel(HttpServletResponse response, ResultStaticPageVO resultStaticPageVO) {
        resultStaticPageVO.setSize(-1L);
        IPage<ResultStaticKnowledge> page = this.getPage(resultStaticPageVO);
        String fileName = "通用静态知识测试结果导出.xls";
        List<ExportCommonStaticTestDTO> records = BeanUtil.listCopyTo(page.getRecords(), ExportCommonStaticTestDTO.class);
        ExcelUtils.exportExcel(records, null, "sheet1", ExportCommonStaticTestDTO.class, fileName, response, 12.8f);
    }

    //endregion --------------------------导出------------------------------
}