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

package com.supervision.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import com.supervision.exception.BusinessException;
import com.supervision.model.*;
import com.supervision.model.Process;
import com.supervision.pojo.vo.AskPhysicalResultReqVO;
import com.supervision.pojo.vo.ConfigPhysicalToolResVO;
import com.supervision.service.*;
import com.supervision.util.UserUtil;
import com.supervision.vo.ask.DiagnosisPhysicalRecordVo;
import com.supervision.vo.ask.AskPhysicalHistoryResVO;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

@Service
@RequiredArgsConstructor
public class AskPhysicalServiceImpl implements AskPhysicalService {

    private final ConfigPhysicalLocationService locationService;

    private final ConfigPhysicalToolService toolService;

    private final DiseasePhysicalService diseasePhysicalService;

    private final DiagnosisPhysicalRecordService diagnosisPhysicalRecordService;

    private final ProcessService processService;

    @Override
    public List<ConfigPhysicalToolResVO> queryPhysicalToolList() {

        List<ConfigPhysicalTool> list = toolService.lambdaQuery().list();
        return list.stream().collect(Collectors.groupingBy(ConfigPhysicalTool::getType)).entrySet().stream().map(e ->{
            ConfigPhysicalToolResVO tool = new ConfigPhysicalToolResVO();
            tool.setToolType(e.getKey());
            int priority = 999;
            if (CollectionUtil.isNotEmpty(e.getValue()) && null != e.getValue().get(0).getTypePriority()) {
                priority = e.getValue().get(0).getTypePriority();
            }
            tool.setPriority(priority);
            tool.setToolList(e.getValue());
            return tool;
        }).sorted(Comparator.comparingInt(ConfigPhysicalToolResVO::getPriority)).collect(Collectors.toList());
    }

    @Override
    public DiagnosisPhysicalRecordVo queryAskPhysicalResult(AskPhysicalResultReqVO reqVO) {
        // 首先根据process_id查新到流程ID
        Process process = Optional.ofNullable(processService.getById(reqVO.getProcessId())).orElseThrow(() -> new BusinessException("未找到流程ID"));
        ConfigPhysicalTool tool = Optional.ofNullable(toolService.getById(reqVO.getToolId())).orElseThrow(() -> new BusinessException("工具不支持"));
        // 是否需要具体的部位,0否1是
        ConfigPhysicalLocation location = new ConfigPhysicalLocation();
        if (1 == tool.getRequireLocation()) {
            if (StrUtil.isBlank(reqVO.getLocationCode())){
                throw new BusinessException("请选择对应的位置");
            }
            location = locationService.lambdaQuery().eq(ConfigPhysicalLocation::getCode, reqVO.getLocationCode()).last("limit 1")
                    .oneOpt().orElseThrow(() -> new BusinessException("未找到对应部位"));
        }
        DiseasePhysical result = diseasePhysicalService.lambdaQuery().eq(DiseasePhysical::getMedicalRecId, process.getMedicalRecId())
                .eq(DiseasePhysical::getToolId, tool.getId()).eq(StrUtil.isNotBlank(location.getId()), DiseasePhysical::getLocationId, location.getId()).last("limit 1")
                .oneOpt()
                .orElseGet(() -> {
                    DiseasePhysical diseasePhysical = new DiseasePhysical();
                    diseasePhysical.setResult("无相关资讯");
                    return diseasePhysical;
                });
        // 检查记录保存到数据库中
        DiagnosisPhysicalRecord diagnosisPhysicalRecord = new DiagnosisPhysicalRecord();
        diagnosisPhysicalRecord.setProcessId(process.getId());
        diagnosisPhysicalRecord.setPhysicalId(result.getId());
        diagnosisPhysicalRecord.setToolId(tool.getId());
        diagnosisPhysicalRecord.setLocationId(location.getId());
        diagnosisPhysicalRecord.setPrimaryId(reqVO.getPrimaryId());
        diagnosisPhysicalRecord.setResult(result.getResult());
        diagnosisPhysicalRecord.setCreateUserId(UserUtil.getUser().getCreateUserId());
        diagnosisPhysicalRecord.setUpdateUserId(UserUtil.getUser().getCreateUserId());
        diagnosisPhysicalRecord.insert();

        return initDiagnosisPhysicalRecordVo(reqVO.getPrimaryId(), process.getId(), result, tool, location);
    }


    @Override
    public List<AskPhysicalHistoryResVO> queryAskPhysicalHistory(String processId) {
        return diagnosisPhysicalRecordService.queryAskPhysicalHistory(processId);
    }


    private static DiagnosisPhysicalRecordVo initDiagnosisPhysicalRecordVo(String primaryId, String processId,
                                                                           DiseasePhysical result, ConfigPhysicalTool tool,
                                                                           ConfigPhysicalLocation location) {
        DiagnosisPhysicalRecordVo diagnosisPhysicalRecordVo = new DiagnosisPhysicalRecordVo();
        diagnosisPhysicalRecordVo.setProcessId(processId);
        diagnosisPhysicalRecordVo.setToolId(tool.getToolName());
        diagnosisPhysicalRecordVo.setToolName(tool.getToolName());
        diagnosisPhysicalRecordVo.setLocationId(location.getId());
        diagnosisPhysicalRecordVo.setLocationName(location.getLocationName());
        diagnosisPhysicalRecordVo.setPrimaryId(primaryId);
        diagnosisPhysicalRecordVo.setPhysicalId(result.getId());
        diagnosisPhysicalRecordVo.setResult(result.getResult());
        return diagnosisPhysicalRecordVo;
    }

}