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

package com.diagbot.facade;

import com.diagbot.client.CdssCoreClient;
import com.diagbot.dto.BillMsg;
import com.diagbot.dto.IndicationDTO;
import com.diagbot.dto.PushBaseDTO;
import com.diagbot.dto.PushDTO;
import com.diagbot.dto.PushPlanDTO;
import com.diagbot.dto.RespDTO;
import com.diagbot.dto.TreatDTO;
import com.diagbot.entity.ConceptDetail;
import com.diagbot.enums.StaticTypeEnum;
import com.diagbot.util.BeanUtil;
import com.diagbot.util.ListUtil;
import com.diagbot.util.RespDTOUtil;
import com.diagbot.util.StringUtil;
import com.diagbot.vo.IndicationPushVO;
import com.diagbot.vo.PushPlanVO;
import com.diagbot.vo.PushVO;
import com.diagbot.vo.SearchData;
import com.google.common.collect.Lists;
import org.apache.commons.collections4.MapUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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

/**
 * @Description:
 * @Author:zhaops
 * @time: 2020/8/4 14:08
 */
@Component
public class PushFacade {
    @Autowired
    private AssembleFacade assembleFacade;
    @Autowired
    private CdssCoreClient cdssCoreClient;
    @Autowired
    private ConceptInfoFacade conceptInfoFacade;

    /**
     * 基础推理-症状、查体、化验、辅检、诊断
     *
     * @param pushVO
     */
    public PushDTO push(PushVO pushVO) {
        if (pushVO.getDiseaseName() != null
                && StringUtil.isBlank(pushVO.getDiseaseName().getName())
                && StringUtil.isBlank(pushVO.getDiseaseName().getUniqueName())) {
            pushVO.setDiseaseName(null);
        }
        SearchData searchData = new SearchData();
        BeanUtil.copyProperties(pushVO, searchData);
        //入参映射
        searchData = assembleFacade.assembleData(searchData);
        BeanUtil.copyProperties(searchData, pushVO);
        RespDTO<PushDTO> resp = cdssCoreClient.push(pushVO);
        RespDTOUtil.respNGDeal(resp, "远程调用推理接口失败");
        PushDTO data = resp.data;
        //------------------测试数据开始------------------
        //        PushDTO data = testDataPush();
        //------------------测试数据结束------------------
        //出参映射
        data = assembleFacade.assemblePushDTO(data, pushVO.getHospitalId());
        //是否有静态信息
        if (pushVO.getGetStaticKnowledge() != null
                && pushVO.getGetStaticKnowledge().equals(1)) {
            data = getStaticKnoledge(data);
        }
        //一般治疗
        if (data != null) {
            data.setTreat(retGeneraTreat(data, pushVO.getHospitalId()));
        }
        return data;
    }

    /**
     * 提示信息相关推理-危急值、开单合理项、药品禁忌等
     *
     * @param indicationPushVO
     */
    public IndicationDTO indicationPush(IndicationPushVO indicationPushVO) {
        SearchData searchData = new SearchData();
        BeanUtil.copyProperties(indicationPushVO, searchData);
        //入参映射
        searchData = assembleFacade.assembleData(searchData);
        BeanUtil.copyProperties(searchData, indicationPushVO);
        RespDTO<IndicationDTO> resp = cdssCoreClient.indication(indicationPushVO);
        RespDTOUtil.respNGDeal(resp, "远程调用推理接口失败");
        IndicationDTO indicationDTO = resp.data;
        return indicationDTO;
    }

    /**
     * 推理持续检验检查计划
     *
     * @param pushPlanVO
     * @return
     */
    public PushPlanDTO pushPlan(PushPlanVO pushPlanVO) {
        SearchData searchData = new SearchData();
        BeanUtil.copyProperties(pushPlanVO, searchData);
        //入参映射
        searchData = assembleFacade.assembleData(searchData);
        BeanUtil.copyProperties(searchData, pushPlanVO);
        RespDTO<PushPlanDTO> resp = cdssCoreClient.pushPlan(pushPlanVO);
        RespDTOUtil.respNGDeal(resp, "远程调用推理接口失败");
        PushPlanDTO pushPlanDTO = resp.data;
        return pushPlanDTO;
    }

    /**
     * 推理结果标志是否包含静态知识
     *
     * @param pushDTO
     * @return
     */
    public PushDTO getStaticKnoledge(PushDTO pushDTO) {
        List<String> conceptNameList = Lists.newLinkedList();
        List<PushBaseDTO> conceptBaseList = Lists.newArrayList();
        if (ListUtil.isNotEmpty(pushDTO.getLis())) {
            conceptBaseList.addAll(pushDTO.getLis());
        }
        if (ListUtil.isNotEmpty(pushDTO.getPacs())) {
            conceptBaseList.addAll(pushDTO.getPacs());
        }
        if (pushDTO.getDis() != null) {
            for (Map.Entry<String, List<PushBaseDTO>> entry : pushDTO.getDis().entrySet()) {
                if (ListUtil.isNotEmpty(entry.getValue())) {
                    conceptBaseList.addAll(entry.getValue());
                }
            }
        }
        if (ListUtil.isNotEmpty(pushDTO.getMedicines())) {
            conceptBaseList.addAll(pushDTO.getMedicines());
        }
        if (ListUtil.isNotEmpty(pushDTO.getOperations())) {
            conceptBaseList.addAll(pushDTO.getOperations());
        }
        if (ListUtil.isNotEmpty(conceptBaseList)) {
            conceptNameList = conceptBaseList.stream()
                    .map(i -> i.getName())
                    .collect(Collectors.toList());

            Map<String, List<ConceptDetail>> conceptDetailMap = conceptInfoFacade.getDetailByConcept(conceptNameList);
            if (pushDTO.getDis() != null) {
                for (Map.Entry<String, List<PushBaseDTO>> entry : pushDTO.getDis().entrySet()) {
                    if (ListUtil.isNotEmpty(entry.getValue())) {
                        entry.getValue().forEach(item -> {
                            if (conceptDetailMap.containsKey(item.getName() + "_" + StaticTypeEnum.getName(1))) {
                                item.setHasInfo(1);
                            }
                        });
                    }
                }
            }
            if (ListUtil.isNotEmpty(pushDTO.getLis())) {
                pushDTO.getLis().forEach(item -> {
                    if (conceptDetailMap.containsKey(item.getName() + "_" + StaticTypeEnum.getName(3))) {
                        item.setHasInfo(1);
                    }
                });
            }
            if (ListUtil.isNotEmpty(pushDTO.getPacs())) {
                pushDTO.getPacs().forEach(item -> {
                    if (conceptDetailMap.containsKey(item.getName() + "_" + StaticTypeEnum.getName(5))) {
                        item.setHasInfo(1);
                    }
                });
            }
            if (ListUtil.isNotEmpty(pushDTO.getMedicines())) {
                pushDTO.getMedicines().forEach(item -> {
                    if (conceptDetailMap.containsKey(item.getName() + "_" + StaticTypeEnum.getName(2))) {
                        item.setHasInfo(1);
                    }
                });
            }
            if (ListUtil.isNotEmpty(pushDTO.getOperations())) {
                pushDTO.getOperations().forEach(item -> {
                    if (conceptDetailMap.containsKey(item.getName() + "_" + StaticTypeEnum.getName(6))) {
                        item.setHasInfo(1);
                    }
                });
            }
        }
        return pushDTO;
    }

    /**
     * 查找一般治疗
     *
     * @param pushDTO
     * @param hospitalId
     * @return
     */
    public List<TreatDTO> retGeneraTreat(PushDTO pushDTO, Long hospitalId) {
        List<TreatDTO> retGeneraTreat = pushDTO.getTreat();
        if (ListUtil.isNotEmpty(retGeneraTreat)) {
            List<String> conceptNameList = retGeneraTreat.stream()
                    .filter(i -> StringUtil.isNotBlank(i.getUniqueName()))
                    .map(i -> i.getUniqueName())
                    .collect(Collectors.toList());
            Map<String, List<ConceptDetail>> conceptDetailMap = conceptInfoFacade.getDetailByConcept(conceptNameList);
            if (conceptDetailMap == null || conceptDetailMap.size() == 0) {
                return retGeneraTreat;
            }
            for (TreatDTO treatDTO : retGeneraTreat) {
                if (StringUtil.isNotBlank(treatDTO.getUniqueName())) {
                    String key = treatDTO.getUniqueName() + "_" + StaticTypeEnum.getName(1);
                    if (conceptDetailMap.containsKey(key)) {
                        List<ConceptDetail> conceptDetailList = conceptDetailMap.get(key);
                        treatDTO.setGeneraTreat(conceptDetailList
                                .stream()
                                .filter(i -> Arrays.asList(i.getContentType().split(",")).contains("4"))
                                .collect(Collectors.toList())
                                .get(0).getContent());
                    }
                }
            }
        }
        return retGeneraTreat;
    }


    /**
     * 推理测试数据设置
     *
     * @return 推理测试数据
     */
    private PushDTO testDataPush() {
        PushDTO data = new PushDTO();
        //症状
        if (ListUtil.isEmpty(data.getSymptom())) {
            List<PushBaseDTO> symptom = Lists.newArrayList();
            PushBaseDTO sympItem1 = new PushBaseDTO();
            sympItem1.setName("发热");
            symptom.add(sympItem1);
            PushBaseDTO sympItem2 = new PushBaseDTO();
            sympItem2.setName("咳嗽");
            symptom.add(sympItem2);
            data.setSymptom(symptom);
        }
        //体格检查
        if (ListUtil.isEmpty(data.getVital())) {
            List<PushBaseDTO> vital = Lists.newArrayList();
            PushBaseDTO vital1 = new PushBaseDTO();
            vital1.setName("肾区叩痛阳性");
            vital.add(vital1);
            PushBaseDTO vital2 = new PushBaseDTO();
            vital2.setName("血压升高");
            vital.add(vital2);
            data.setVital(vital);
        }
        //检验
        if (ListUtil.isEmpty(data.getLis())) {
            List<PushBaseDTO> lis = Lists.newArrayList();
            PushBaseDTO lis1 = new PushBaseDTO();
            lis1.setName("血常规");
            lis.add(lis1);
            PushBaseDTO lis2 = new PushBaseDTO();
            lis2.setName("尿常规");
            lis.add(lis2);
            PushBaseDTO lis3 = new PushBaseDTO();
            lis3.setName("幽门螺杆菌抗体测定");
            lis.add(lis3);
            data.setLis(lis);
        }
        //检查
        if (ListUtil.isEmpty(data.getPacs())) {
            List<PushBaseDTO> pacs = Lists.newArrayList();
            PushBaseDTO pacs1 = new PushBaseDTO();
            pacs1.setName("普通胃镜检查");
            pacs.add(pacs1);
            PushBaseDTO pacs2 = new PushBaseDTO();
            pacs2.setName("经直肠前列腺彩超检查");
            pacs.add(pacs2);
            data.setPacs(pacs);
        }
        //药品
        if (ListUtil.isEmpty(data.getMedicines())) {
            List<PushBaseDTO> medicines = Lists.newArrayList();
            PushBaseDTO medicines1 = new PushBaseDTO();
            medicines1.setName("钙通道阻滞剂");
            medicines.add(medicines1);
            PushBaseDTO medicines2 = new PushBaseDTO();
            medicines2.setName("盐酸肾上腺素注射液");
            medicines.add(medicines2);
            data.setMedicines(medicines);
        }
        //手术和操作
        if (ListUtil.isEmpty(data.getOperations())) {
            List<PushBaseDTO> operations = Lists.newArrayList();
            PushBaseDTO operations1 = new PushBaseDTO();
            operations1.setName("前列腺按摩");
            operations.add(operations1);
            PushBaseDTO operations2 = new PushBaseDTO();
            operations2.setName("经皮冠状动脉介入治疗(PCI)");
            operations.add(operations2);
            data.setOperations(operations);
        }
        //诊断
        if (MapUtils.isEmpty(data.getDis())) {
            List<PushBaseDTO> dis = Lists.newArrayList();
            PushBaseDTO disItem1 = new PushBaseDTO();
            disItem1.setName("急性胰腺炎");
            dis.add(disItem1);
            PushBaseDTO disItem2 = new PushBaseDTO();
            disItem2.setName("无晶状体眼");
            dis.add(disItem2);
            Map<String, List<PushBaseDTO>> disMap = new HashMap<>();
            disMap.put("可能诊断", dis);
            List<PushBaseDTO> dis2 = Lists.newArrayList();
            dis2.addAll(dis);
            PushBaseDTO disItem3 = new PushBaseDTO();
            disItem3.setName("糖尿病");
            dis2.add(disItem3);
            disMap.put("鉴别诊断", dis2);
            data.setDis(disMap);
        }
        //一般治疗
        if (ListUtil.isEmpty(data.getTreat())) {
            List<TreatDTO> treat = new ArrayList<>();
            TreatDTO treatDTO1 = new TreatDTO();
            treatDTO1.setName("无晶状体眼");
            treatDTO1.setUniqueName("无晶状体眼");
            treat.add(treatDTO1);
            data.setTreat(treat);
        }
        return data;
    }

    /**
     * 提醒测试数据
     *
     * @return 提醒测试数据
     */
    private IndicationDTO indicationTestData() {
        IndicationDTO indicationDTO = new IndicationDTO();
        List<BillMsg> billMsgList = Lists.newArrayList();
        BillMsg item1 = new BillMsg();
        item1.setMsg("该患者年龄15,不宜开左氧氟沙星");
        item1.setOrderName("左氧氟沙星");
        item1.setOrderStandName("左氧氟沙星");
        item1.setContent("年龄15");
        item1.setType("禁忌年龄");
        billMsgList.add(item1);
        indicationDTO.setBillMsgList(billMsgList);
        List<BillMsg> criticalValList = Lists.newArrayList();
        BillMsg item2 = new BillMsg();
        item2.setMsg("该患者血常规血小板计数30,请留意");
        item2.setOrderName("");
        item2.setOrderStandName("");
        item2.setContent("血常规血小板计数30");
        item2.setType("血常规血小板计数30");
        criticalValList.add(item2);
        indicationDTO.setCriticalValList(criticalValList);
        //加入高危假数据
        if (ListUtil.isEmpty(indicationDTO.getHighRiskList())) {
            List<BillMsg> highRiskList = Lists.newArrayList();
            BillMsg item3 = new BillMsg();
            item3.setMsg("盐酸肾上腺素注射液为高风险药品，请留意(假数据)");
            item3.setOrderName("盐酸肾上腺素注射液");
            item3.setOrderStandName("盐酸肾上腺素注射液");
            item3.setContent("");
            item3.setType("药品");
            highRiskList.add(item3);
            indicationDTO.setHighRiskList(highRiskList);
        }
        //加入其他提醒假数据
        if (ListUtil.isEmpty(indicationDTO.getOtherList())) {
            List<BillMsg> otherList = new ArrayList<>();
            BillMsg other = new BillMsg();
            other.setMsg("该患者血小板计数＜10×10^9/L，建议输注血小板。(假数据)");
            other.setOrderName("血小板");
            other.setOrderStandName("血小板");
            other.setContent("");
            other.setType("输血");
            otherList.add(other);
            indicationDTO.setOtherList(otherList);
        }
        return indicationDTO;
    }
}