virtual-patient/virtual-patient-web/src/main/java/com/supervision/service/impl/AskPrimaryServiceImpl.java

package com.supervision.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.supervision.exception.BusinessException;
import com.supervision.model.Process;
import com.supervision.model.*;
import com.supervision.pojo.vo.*;
import com.supervision.service.*;
import com.supervision.util.UserUtil;
import com.supervision.vo.ask.*;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

@Service
@RequiredArgsConstructor
public class AskPrimaryServiceImpl implements AskPrimaryService {

    private final DiagnosisPrimaryService diagnosisPrimaryService;

    private final DiseaseService diseaseService;

    private final DiagnosisAncillaryRecordService diagnosisAncillaryRecordService;

    private final DiagnosisPhysicalRecordService diagnosisPhysicalRecordService;

    private final DiagnosisQaRecordService diagnosisQaRecordService;

    private final ProcessService processService;

    private final DiagnosisPrimaryRelationService diagnosisPrimaryRelationService;

    private final ProcessMedicalService processMedicalService;

    @Override
    public List<DiagnosisPrimaryVO> queryAskPrimaryList(String processId) {
        List<DiagnosisPrimaryVO> resVoList = diagnosisPrimaryService.queryAskPrimaryListByProcessId(processId);
        List<DiagnosisPrimaryRelation> list = diagnosisPrimaryRelationService.lambdaQuery().eq(DiagnosisPrimaryRelation::getProcessId, processId).list();
        if (CollUtil.isNotEmpty(list)) {
            Map<String, List<DiagnosisPrimaryRelation>> relationMap = list.stream().collect(Collectors.groupingBy(DiagnosisPrimaryRelation::getPrimaryId));
            for (DiagnosisPrimaryVO diagnosisPrimaryVO : resVoList) {
                List<DiagnosisPrimaryRelation> relationList = relationMap.get(diagnosisPrimaryVO.getId());
                if (CollUtil.isNotEmpty(relationList)) {
                    Map<Integer, List<String>> relationIdMap = relationList.stream()
                            .collect(Collectors.groupingBy(DiagnosisPrimaryRelation::getType, Collectors.mapping(DiagnosisPrimaryRelation::getRelationId, Collectors.toList())));
                    diagnosisPrimaryVO.setAskIdList(Optional.ofNullable(relationIdMap.get(1)).orElseGet(ArrayList::new));
                    diagnosisPrimaryVO.setPhysicalIdList(Optional.ofNullable(relationIdMap.get(2)).orElseGet(ArrayList::new));
                    diagnosisPrimaryVO.setAncillaryIdList(Optional.ofNullable(relationIdMap.get(3)).orElseGet(ArrayList::new));
                }
            }
        }
        return resVoList;
    }

    @Override
    public List<Disease> queryPrimaryCanChooseList() {
        // 初步诊断列表可选的疾病为单一疾病
        return diseaseService.lambdaQuery().list();
    }

    @Override
    public DiagnosisPrimaryVO queryPrimaryDetailInfo(String primaryId) {
        DiagnosisPrimaryVO diagnosisPrimaryVO = diagnosisPrimaryService.queryAskPrimaryListByPrimaryId(primaryId);
        List<DiagnosisPrimaryRelation> relationList = diagnosisPrimaryRelationService.lambdaQuery()
                .eq(DiagnosisPrimaryRelation::getPrimaryId, primaryId)
                .list();
        if (CollUtil.isNotEmpty(relationList)) {
            Map<Integer, List<String>> relationIdMap = relationList.stream()
                    .collect(Collectors.groupingBy(DiagnosisPrimaryRelation::getType, Collectors.mapping(DiagnosisPrimaryRelation::getRelationId, Collectors.toList())));
            diagnosisPrimaryVO.setAskIdList(Optional.ofNullable(relationIdMap.get(1)).orElseGet(ArrayList::new));
            diagnosisPrimaryVO.setPhysicalIdList(Optional.ofNullable(relationIdMap.get(2)).orElseGet(ArrayList::new));
            diagnosisPrimaryVO.setAncillaryIdList(Optional.ofNullable(relationIdMap.get(3)).orElseGet(ArrayList::new));
        }
        return diagnosisPrimaryVO;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void modifyPrimaryDiseaseInfo(ModifyPrimaryDiseaseInfoReqVO reqVO) {
        DiagnosisPrimary diagnosisPrimary = diagnosisPrimaryService.getById(reqVO.getId());
        diagnosisPrimaryService.lambdaUpdate().set(DiagnosisPrimary::getPatientDiseaseInfo, reqVO.getPatientDiseaseInfo())
                .eq(DiagnosisPrimary::getId, reqVO.getId()).update();
        // 然后这里保存初步诊断依据的修改
        // 首先查到已经存在的列表
        List<DiagnosisPrimaryRelation> list = diagnosisPrimaryRelationService.lambdaQuery().eq(DiagnosisPrimaryRelation::getPrimaryId, reqVO.getId()).list();
        Map<Integer, List<DiagnosisPrimaryRelation>> groupByTypeMap = list.stream().collect(Collectors.groupingBy(DiagnosisPrimaryRelation::getType));
        // 保存问诊
        List<DiagnosisPrimaryRelation> askExistList = groupByTypeMap.getOrDefault(1, new ArrayList<>());
        if (CollUtil.isNotEmpty(reqVO.getAskIdList())) {
            List<String> existIdList = askExistList.stream().map(DiagnosisPrimaryRelation::getRelationId).collect(Collectors.toList());
            List<String> newIdList = reqVO.getAskIdList().stream().filter(id -> !existIdList.contains(id)).collect(Collectors.toList());
            saveDiagnosisPrimaryRelation(newIdList, diagnosisPrimary.getProcessId(), diagnosisPrimary.getId(), 1);
        }
        // 保存体格检查
        List<DiagnosisPrimaryRelation> physicalIdExistList = groupByTypeMap.getOrDefault(2, new ArrayList<>());
        if (CollUtil.isNotEmpty(reqVO.getPhysicalIdList())) {
            List<String> existIdList = physicalIdExistList.stream().map(DiagnosisPrimaryRelation::getRelationId).collect(Collectors.toList());
            List<String> newIdList = reqVO.getPhysicalIdList().stream().filter(id -> !existIdList.contains(id)).collect(Collectors.toList());
            saveDiagnosisPrimaryRelation(newIdList, diagnosisPrimary.getProcessId(), diagnosisPrimary.getId(), 2);
        }
        // 保存辅助检查
        List<DiagnosisPrimaryRelation> ancillaryExistList = groupByTypeMap.getOrDefault(3, new ArrayList<>());
        if (CollUtil.isNotEmpty(reqVO.getAncillaryIdList())) {
            List<String> existIdList = ancillaryExistList.stream().map(DiagnosisPrimaryRelation::getRelationId).collect(Collectors.toList());
            List<String> newIdList = reqVO.getAncillaryIdList().stream().filter(id -> !existIdList.contains(id)).collect(Collectors.toList());
            saveDiagnosisPrimaryRelation(newIdList, diagnosisPrimary.getProcessId(), diagnosisPrimary.getId(), 3);
        }

    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void savePrimary(SaveDiagnosisPrimaryReqVO reqVO) {
        // 新增初步诊断之前,校验是否已经存在相同的初步诊断,如果有了,则不允许重复添加
        Integer count = diagnosisPrimaryService.lambdaQuery().eq(DiagnosisPrimary::getProcessId, reqVO.getProcessId())
                .eq(DiagnosisPrimary::getPrimaryDiagnosisId, reqVO.getPrimaryDiagnosisId()).count();
        if (0 < count) {
            throw new BusinessException("已经存在该疾病的初步诊断");
        }
        DiagnosisPrimary diagnosisPrimary = BeanUtil.toBean(reqVO, DiagnosisPrimary.class);
        diagnosisPrimary.setExcludeFlag(null);
        diagnosisPrimary.setCreateUserId(UserUtil.getUser().getId());

        String primaryDiagnosisId = diagnosisPrimary.getPrimaryDiagnosisId();
        Assert.notEmpty(primaryDiagnosisId, "疾病不能为空");
        List<DiagnosisPrimary> dbList = diagnosisPrimaryService.lambdaQuery().eq(DiagnosisPrimary::getPrimaryDiagnosisId, primaryDiagnosisId)
                .eq(DiagnosisPrimary::getProcessId, diagnosisPrimary.getProcessId()).list();
        Assert.isTrue(CollectionUtil.isEmpty(dbList), "初步诊断已存在");

        diagnosisPrimaryService.save(diagnosisPrimary);
        // 然后开始保存初步诊断关键的诊断

        saveDiagnosisPrimaryRelation(reqVO.getAskIdList(), diagnosisPrimary.getProcessId(), diagnosisPrimary.getId(), 1);
        saveDiagnosisPrimaryRelation(reqVO.getPhysicalIdList(), diagnosisPrimary.getProcessId(), diagnosisPrimary.getId(), 2);
        saveDiagnosisPrimaryRelation(reqVO.getAncillaryIdList(), diagnosisPrimary.getProcessId(), diagnosisPrimary.getId(), 3);
    }

    private void saveDiagnosisPrimaryRelation(List<String> itemList, String processId, String primaryId, Integer type) {
        if (CollUtil.isNotEmpty(itemList)) {
            List<DiagnosisPrimaryRelation> ancillaryRelationList = itemList.stream().map(e -> {
                DiagnosisPrimaryRelation relation = new DiagnosisPrimaryRelation();
                relation.setProcessId(processId);
                relation.setPrimaryId(primaryId);
                relation.setType(type);
                relation.setRelationId(e);
                relation.setCreateUserId(UserUtil.getUser().getId());
                return relation;
            }).collect(Collectors.toList());
            diagnosisPrimaryRelationService.saveBatch(ancillaryRelationList);
        }
    }

    @Override
    public RecordForPrimaryChooseVO queryRecordForPrimaryChoose(String processId) {
        RecordForPrimaryChooseVO resVO = new RecordForPrimaryChooseVO();
        // 查询语音问诊记录
        List<DiagnosisQaRecord> list = diagnosisQaRecordService.lambdaQuery().eq(DiagnosisQaRecord::getProcessId, processId).orderByAsc(DiagnosisQaRecord::getCreateTime).list();
        List<ChooseNode> askRecordList = list.stream().map(e -> {
            ChooseNode chooseNode = new ChooseNode();
            chooseNode.setNodeId(e.getId());
            chooseNode.setName(e.getQuestion());
            return chooseNode;

        }).collect(Collectors.toList());
        resVO.setAskList(askRecordList);
        // 查询体格检查记录
        List<AskPhysicalHistoryResVO> physicalHistoryList = diagnosisPhysicalRecordService.queryAskPhysicalHistory(processId);
        List<ChooseNode> physicalList = physicalHistoryList.stream().map(e -> {
            ChooseNode chooseNode = new ChooseNode();
            chooseNode.setNodeId(e.getId());
            if (StrUtil.isEmpty(e.getLocationName())) {
                chooseNode.setName(e.getToolName());
            } else {
                chooseNode.setName(StrUtil.join(" | ", e.getToolName(), e.getLocationName()));
            }
            return chooseNode;
        }).collect(Collectors.toList());
        resVO.setPhysicalList(physicalList);
        List<AskAncillaryHistoryResVO> ancillaryHistoryList = diagnosisAncillaryRecordService.queryAncillaryRecord(processId);
        List<ChooseNode> ancillaryList = ancillaryHistoryList.stream().map(e -> {
            ChooseNode chooseNode = new ChooseNode();
            chooseNode.setNodeId(e.getId());
            chooseNode.setName(e.getItemName());
            return chooseNode;
        }).collect(Collectors.toList());
        resVO.setAncillaryList(ancillaryList);
        return resVO;
    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public void confirmPrimaryByAskEnd(PrimaryConfirmReqVO reqVO) {
        List<PrimaryConfirmNodeReqVO> reqVOList = reqVO.getPrimaryConfirmList();
        Optional<PrimaryConfirmNodeReqVO> any = reqVOList.stream().findAny();
        if (!any.isPresent()) {
            throw new BusinessException("初步诊断不能为空");
        }
        // 如果 != 1 ,不是暂存,那么就校验电子病历是否填写
        if (ObjectUtil.isEmpty(reqVO.getTempSaveFlag()) || 1 != reqVO.getTempSaveFlag()) {
            // 校验,如果没有填写病历,那么就不允许诊毕
            Integer count = processMedicalService.lambdaQuery().eq(ProcessMedical::getProcessId, reqVO.getProcessId()).count();
            if (count < 1) {
                throw new BusinessException("电子病历未填写,请填写电子病例后诊毕");
            }
        }


        for (PrimaryConfirmNodeReqVO node : reqVOList) {
            // 如果 != 1 ,不是暂存,那么就校验初步诊断是否填写
            if (ObjectUtil.isEmpty(reqVO.getTempSaveFlag()) || 1 != reqVO.getTempSaveFlag()) {
                if (ObjectUtil.isEmpty(node.getExcludeFlag()) && 0 != node.getExcludeFlag() && 1 != node.getExcludeFlag()) {
                    throw new BusinessException("是否排除不能为空或诊断不正确");
                }
            }
            // 修改初步诊断是否被排除
            diagnosisPrimaryService.lambdaUpdate().set(DiagnosisPrimary::getExcludeFlag, node.getExcludeFlag())
                    .eq(DiagnosisPrimary::getId, node.getPrimaryId()).update();
            // 保存证实诊断依据
            saveDiagnosticBasis(node.getDiagnosticBasisList());
        }
        // 如果 != 1 ,说明是诊毕,这时就诊毕
        if (ObjectUtil.isEmpty(reqVO.getTempSaveFlag()) || 1 != reqVO.getTempSaveFlag()) {
            // 然后将process的状态改为诊毕
            processService.lambdaUpdate().set(Process::getStatus, 1).eq(Process::getId, reqVO.getProcessId()).update();
        }

    }

    private void saveDiagnosticBasis(List<DiagnosticBasisForPrimaryReqVO> diagnosticBasisList) {
        for (DiagnosticBasisForPrimaryReqVO node : diagnosticBasisList) {
            if (1 == node.getType()) {
                diagnosisQaRecordService.lambdaUpdate().set(DiagnosisQaRecord::getBasisConfirmFlag, node.getBasisConfirmFlag())
                        .set(DiagnosisQaRecord::getBasisIdentificationFlag, node.getBasisIdentificationFlag())
                        .eq(DiagnosisQaRecord::getId, node.getId()).update();
                continue;
            }
            if (2 == node.getType()) {
                diagnosisPhysicalRecordService.lambdaUpdate().set(DiagnosisPhysicalRecord::getBasisConfirmFlag, node.getBasisConfirmFlag())
                        .set(DiagnosisPhysicalRecord::getBasisIdentificationFlag, node.getBasisIdentificationFlag())
                        .eq(DiagnosisPhysicalRecord::getId, node.getId()).update();
                continue;
            }
            if (3 == node.getType()) {
                diagnosisAncillaryRecordService.lambdaUpdate().set(DiagnosisAncillaryRecord::getBasisConfirmFlag, node.getBasisConfirmFlag())
                        .set(DiagnosisAncillaryRecord::getBasisIdentificationFlag, node.getBasisIdentificationFlag())
                        .eq(DiagnosisAncillaryRecord::getId, node.getId()).update();
            }

        }
    }

    @Override
    public void deletePrimary(String id) {
        // 如果本项初步诊断已经做过了辅助检查和体格检查,则不允许删除
        DiagnosisPrimary primary = diagnosisPrimaryService.getById(id);
        Integer ancillaryCount = diagnosisAncillaryRecordService.lambdaQuery().eq(DiagnosisAncillaryRecord::getProcessId, primary.getProcessId()).count();
        if (ancillaryCount > 0) {
            throw new BusinessException("仅支持删除没有做过体格、辅助检查的初步诊断项目");
        }
        Integer physicalCount = diagnosisPhysicalRecordService.lambdaQuery().eq(DiagnosisPhysicalRecord::getProcessId, primary.getProcessId()).count();
        if (physicalCount > 0) {
            throw new BusinessException("仅支持删除没有做过体格、辅助检查的初步诊断项目");
        }
        diagnosisPrimaryService.lambdaUpdate().eq(DiagnosisPrimary::getId, id).remove();
    }

    /**
     * 确诊页面,初步诊断填写初步诊断依据
     *
     * @param processId 流程ID
     * @return 结果
     */
    @Override
    public List<DiagnosticBasisForPrimaryResVO> queryDiagnosticBasisListForPrimary(String processId, String primaryId) {
        List<DiagnosticBasisForPrimaryResVO> resList = diagnosisPrimaryService.queryDiagnosticBasisListForPrimary(processId);
        if (CollUtil.isEmpty(resList)) {
            return resList;
        }
        // 找到process对应的所有的初步诊断
        List<DiagnosisPrimaryVO> diagnosisPrimaryVOS = diagnosisPrimaryService.queryAskPrimaryListByProcessId(processId);
        Map<String, String> diseaseNameMap = diagnosisPrimaryVOS.stream().peek(vo -> {
                    if (StrUtil.isEmpty(vo.getPrimaryDiseaseName())) {
                        vo.setPrimaryDiseaseName("");
                    }
                })
                .collect(Collectors.toMap(DiagnosisPrimaryVO::getId, DiagnosisPrimaryVO::getPrimaryDiseaseName));
        // 查询诊疗记录对应的所有检查记录
        List<DiagnosisPrimaryRelation> relationList = diagnosisPrimaryRelationService.lambdaQuery().eq(DiagnosisPrimaryRelation::getProcessId, processId).list();
        // 根据relationId进行分组
        Map<String, List<DiagnosisPrimaryRelation>> relationMap = relationList.stream().collect(Collectors.groupingBy(DiagnosisPrimaryRelation::getRelationId));

        List<DiagnosticBasisForPrimaryResVO> result = new ArrayList<>();
        for (DiagnosticBasisForPrimaryResVO node : resList) {
            List<DiagnosisPrimaryRelation> relationPrimaryList = relationMap.get(node.getId());
            if (CollUtil.isEmpty(relationPrimaryList)) {
                continue;
            }
            Set<String> primarySet = relationPrimaryList.stream().map(DiagnosisPrimaryRelation::getPrimaryId).collect(Collectors.toSet());

            if (CollUtil.isNotEmpty(primarySet)) {
                // 如果初步诊断ID的参数不为空,那么说明只查某一个初步诊断的数据
                if (StrUtil.isNotBlank(primaryId)) {
                    if (primarySet.contains(primaryId)) {
                        // 如果有,就只保留这一个初步诊断依据的
                        primarySet.removeIf(e -> !e.equals(primaryId));
                    } else {
                        // 如果没有,就直接跳过
                        continue;
                    }
                }
                List<String> diseaseNameList = new ArrayList<>();
                primarySet.forEach(e -> diseaseNameList.add(diseaseNameMap.get(e)));
                node.setPrimaryIdList(new ArrayList<>(primarySet));
                node.setPrimaryName(StrUtil.join(";", diseaseNameList));
                result.add(node);
            }

        }

        return result;
    }


}