diagbotcloud/prec-service/src/main/java/com/diagbot/facade/InquiryInfoFacade.java

package com.diagbot.facade;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.diagbot.client.TranServiceClient;
import com.diagbot.dto.GetInquiryDetailDTO;
import com.diagbot.dto.GetInquiryDetailImgDTO;
import com.diagbot.dto.HisInquiryDTO;
import com.diagbot.dto.RecordCheckDTO;
import com.diagbot.dto.RespDTO;
import com.diagbot.dto.SaveInquiryDTO;
import com.diagbot.entity.InquiryDetail;
import com.diagbot.entity.InquiryEvaluator;
import com.diagbot.entity.InquiryInfo;
import com.diagbot.entity.InquiryQuote;
import com.diagbot.entity.InquiryReport;
import com.diagbot.enums.InquiryQuotedTypeEnum;
import com.diagbot.enums.IsDeleteEnum;
import com.diagbot.enums.SexEnum;
import com.diagbot.exception.CommonErrorCode;
import com.diagbot.exception.CommonException;
import com.diagbot.service.impl.InquiryDetailServiceImpl;
import com.diagbot.service.impl.InquiryInfoServiceImpl;
import com.diagbot.service.impl.InquiryReportServiceImpl;
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.vo.GetInquiryDetailVO;
import com.diagbot.vo.HisInquirysVO;
import com.diagbot.vo.InquiryQuoteVO;
import com.diagbot.vo.RecordCheckVO;
import com.diagbot.vo.SaveInquiryVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @author: zhoutg
 * @time: 2018/8/6 9:11
 */
@Component
public class InquiryInfoFacade extends InquiryInfoServiceImpl {

    @Value("${imageUrl.prefix}")
    private String imageUrlPrefix;

    @Autowired
    private InquiryDetailFacade inquiryDetailFacade;
    @Autowired
    private InquiryReportFacade inquiryReportFacade;
    @Autowired
    private InquiryEvaluatorFacade inquiryEvaluatorFacade;
    @Autowired
    @Qualifier("inquiryDetailServiceImpl")
    private InquiryDetailServiceImpl inquiryDetailServiceImpl;
    @Autowired
    @Qualifier("inquiryReportServiceImpl")
    private InquiryReportServiceImpl inquiryReportServiceImpl;
    @Autowired
    private TranServiceClient tranServiceClient;
    @Autowired
    private InquiryQuoteFacade inquiryQuoteFacade;

    /**
     * 问诊记录保存
     *
     * @param saveInquiryVO
     * @return
     */
    public SaveInquiryDTO saveInquiry(SaveInquiryVO saveInquiryVO) {
        SaveInquiryDTO saveInquiryDTO = new SaveInquiryDTO();
        Date now = DateUtil.now();

        QueryWrapper<InquiryInfo> inquiryInfoQe = new QueryWrapper<>();
        inquiryInfoQe.eq("is_deleted", IsDeleteEnum.N.getKey());
        inquiryInfoQe.eq("hospital_id", saveInquiryVO.getHospitalId());
        inquiryInfoQe.eq(saveInquiryVO.getSonHospitalId() != null,
                "son_hospital_id", saveInquiryVO.getSonHospitalId());
        inquiryInfoQe.eq("hospital_dept_id", saveInquiryVO.getHospitalDeptId());
        inquiryInfoQe.eq(saveInquiryVO.getDoctorId() != null,
                "doctor_id", saveInquiryVO.getDoctorId());
        inquiryInfoQe.eq("patient_id", saveInquiryVO.getPatientId());
        inquiryInfoQe.eq(StringUtil.isNotBlank(saveInquiryVO.getInquiryCode()),
                "inquiry_code", saveInquiryVO.getInquiryCode());
        inquiryInfoQe.eq("is_quoted", 0);
        inquiryInfoQe.orderByDesc("gmt_modified");
        InquiryInfo inquiryInfo = this.getOne(inquiryInfoQe, false);

        if (inquiryInfo == null) {
            inquiryInfo = new InquiryInfo();
            inquiryInfo.setGmtCreate(now);
        } else {
            QueryWrapper<InquiryDetail> inquiryDetailQe = new QueryWrapper<>();
            inquiryDetailQe.eq("inquiry_id", inquiryInfo.getId());
            inquiryDetailFacade.remove(inquiryDetailQe);

            QueryWrapper<InquiryReport> inquiryReportQe = new QueryWrapper<>();
            inquiryReportQe.eq("inquiry_id", inquiryInfo.getId());
            inquiryReportFacade.remove(inquiryReportQe);
        }

        BeanUtil.copyProperties(saveInquiryVO, inquiryInfo);
        inquiryInfo.setGmtModified(now);
        saveOrUpdate(inquiryInfo);

        Long inquiryId = inquiryInfo.getId();

        List<InquiryDetail> inquiryDetailList = BeanUtil.listCopyTo(saveInquiryVO.getDetailList(), InquiryDetail.class);
        inquiryDetailList.forEach(i -> {
            i.setInquiryId(inquiryId);
            i.setGmtCreate(now);
            i.setGmtModified(now);
        });
        inquiryDetailServiceImpl.saveBatch(inquiryDetailList);

        List<InquiryReport> inquiryReportList = BeanUtil.listCopyTo(saveInquiryVO.getReportList(), InquiryReport.class);
        inquiryReportList.forEach(i -> {
            i.setInquiryId(inquiryId);
            i.setNarrowImage("0");
            i.setGmtCreate(now);
            i.setGmtModified(now);
        });
        inquiryReportServiceImpl.saveBatch(inquiryReportList);

        saveInquiryDTO.setInquiryId(inquiryId);

        return saveInquiryDTO;
    }

    /**
     * 问诊记录检查确认
     *
     * @param recordCheckVO
     * @return
     */
    public RecordCheckDTO recordCheck(RecordCheckVO recordCheckVO) {
        RecordCheckDTO recordCheckDTO = new RecordCheckDTO();
        int type = 1;

        QueryWrapper<InquiryInfo> inquiryInfoQe = new QueryWrapper<>();
        inquiryInfoQe.eq("is_deleted", IsDeleteEnum.N.getKey());
        inquiryInfoQe.eq("hospital_id", recordCheckVO.getHospitalId());
        inquiryInfoQe.eq("hospital_dept_id", recordCheckVO.getHospitalDeptId());
        inquiryInfoQe.eq("doctor_id", recordCheckVO.getDoctorId());
        inquiryInfoQe.eq("patient_id", recordCheckVO.getPatientId());
        inquiryInfoQe.eq("inquiry_code", recordCheckVO.getInquiryCode());
        InquiryInfo inquiryInfo = this.getOne(inquiryInfoQe, false);

        if (inquiryInfo != null) {
            QueryWrapper<InquiryDetail> inquiryDetailQe = new QueryWrapper<>();
            inquiryDetailQe.eq("inquiry_id", inquiryInfo.getId());
            if (inquiryDetailFacade.count(inquiryDetailQe) > 0) {
                type = type + 2;
            }

            QueryWrapper<InquiryEvaluator> inquiryEvaluatorQe = new QueryWrapper<>();
            inquiryEvaluatorQe.eq("inquiry_id", inquiryInfo.getId());
            if (inquiryEvaluatorFacade.count(inquiryEvaluatorQe) > 0) {
                type = type + 3;
            }
        }

        recordCheckDTO.setType(type);
        return recordCheckDTO;
    }

    /**
     * 历史病历列表
     *
     * @param hisInquirysVO
     * @return
     */
    public List<HisInquiryDTO> hisInquirys(HisInquirysVO hisInquirysVO) {
        if (hisInquirysVO.getHospitalId() == null && StringUtil.isBlank(hisInquirysVO.getHospitalCode())) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "医院信息(医院id或者医院编码)必传！");
        }

        QueryWrapper<InquiryInfo> inquiryInfoQe = new QueryWrapper<InquiryInfo>();
        inquiryInfoQe.eq("is_deleted", IsDeleteEnum.N.getKey());
        inquiryInfoQe.eq("is_quoted", InquiryQuotedTypeEnum.Disable.getKey());
        inquiryInfoQe.eq(hisInquirysVO.getHospitalId() != null,
                "hospital_id", hisInquirysVO.getHospitalId());
        inquiryInfoQe.eq(StringUtil.isNotBlank(hisInquirysVO.getHospitalCode()),
                "hospital_code", hisInquirysVO.getHospitalCode());
        inquiryInfoQe.eq(hisInquirysVO.getHospitalDeptId() != null,
                "hospital_dept_id", hisInquirysVO.getHospitalDeptId());
        inquiryInfoQe.eq(StringUtil.isNotBlank(hisInquirysVO.getHospitalDeptCode()),
                "hospital_dept_code", hisInquirysVO.getHospitalDeptCode());
        inquiryInfoQe.eq(hisInquirysVO.getDoctorId() != null,
                "doctor_id", hisInquirysVO.getDoctorId());
        inquiryInfoQe.eq(StringUtil.isNotBlank(hisInquirysVO.getDoctorCode()),
                "doctor_code", hisInquirysVO.getDoctorCode());
        inquiryInfoQe.eq(hisInquirysVO.getPatientId() != null,
                "patient_id", hisInquirysVO.getPatientId());
        inquiryInfoQe.eq(StringUtil.isNotBlank(hisInquirysVO.getPatientCode()),
                "patient_code", hisInquirysVO.getPatientCode());
        inquiryInfoQe.eq(StringUtil.isNotBlank(hisInquirysVO.getPatientIdNo()),
                "patient_id_no", hisInquirysVO.getPatientIdNo());
        inquiryInfoQe.eq(StringUtil.isNotBlank(hisInquirysVO.getPatientName()),
                "patient_name", hisInquirysVO.getPatientName());
        inquiryInfoQe.eq(hisInquirysVO.getType() != null,
                "type", hisInquirysVO.getType());
        String day = DateUtil.formatDateTime(DateUtil.getFirstTimeOfDay(DateUtil.addDay(DateUtil.now(),
                -hisInquirysVO.getDayLimit())));
        inquiryInfoQe.ge("gmt_modified", day);

        inquiryInfoQe.ge(hisInquirysVO.getStartDate() != null,
                "gmt_create", hisInquirysVO.getStartDate());
        inquiryInfoQe.le(hisInquirysVO.getEndDate() != null,
                "gmt_create", hisInquirysVO.getEndDate());

        if (hisInquirysVO.getOrderType() == null || hisInquirysVO.getOrderType() == 1) {
            inquiryInfoQe.orderByDesc("gmt_modified");
        } else if (hisInquirysVO.getOrderType() == 2) {
            inquiryInfoQe.orderByAsc("gmt_modified");
        } else if (hisInquirysVO.getOrderType() == 3) {
            inquiryInfoQe.orderByDesc("inquiry_code");
        } else if (hisInquirysVO.getOrderType() == 4) {
            inquiryInfoQe.orderByAsc("inquiry_code");
        } else {
            inquiryInfoQe.orderByDesc("gmt_modified");
        }

        List<HisInquiryDTO> hisInquiryDTOList = BeanUtil.listCopyTo(list(inquiryInfoQe), HisInquiryDTO.class);
        hisInquiryDTOList.forEach(i -> {
            i.setPatientSexMsg(SexEnum.getName(i.getPatientSex()));
            i.setInquiryDate(i.getGmtModified());
            i.setInquiryTime(i.getGmtModified());
            i.setPatientAge(DateUtil.yearCompare(i.getPatientBirthday(), DateUtil.now()));
        });

        return hisInquiryDTOList;
    }

    /**
     * 病历详情
     *
     * @param getInquiryDetailVO
     * @return
     */
    public GetInquiryDetailDTO getInquiryDetail(GetInquiryDetailVO getInquiryDetailVO) {
        if (getInquiryDetailVO.getHospitalId() == null
                && StringUtil.isBlank(getInquiryDetailVO.getHospitalCode())) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "医院信息(医院id或者医院编码)必传！");
        }
        /*if (getInquiryDetailVO.getHospitalDeptId() == null && StringUtil.isBlank(getInquiryDetailVO.getHospitalDeptCode())) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "科室信息(科室id或者科室编码)必传！");
        }
        if (getInquiryDetailVO.getDoctorId() == null && StringUtil.isBlank(getInquiryDetailVO.getDoctorCode())) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "医生信息(医生id或者医生编码)必传！");
        }*/
        if (getInquiryDetailVO.getPatientId() == null
                && StringUtil.isBlank(getInquiryDetailVO.getPatientCode())
                && (StringUtil.isBlank(getInquiryDetailVO.getPatientIdNo())
                || StringUtil.isBlank(getInquiryDetailVO.getPatientName()))) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "患者信息(患者id或者患者编码或者患者病历号)必传！");
        }

        QueryWrapper<InquiryInfo> inquiryInfoQe = new QueryWrapper<InquiryInfo>();
        inquiryInfoQe.eq(getInquiryDetailVO.getInquiryId() != null,
                "id", getInquiryDetailVO.getInquiryId());
        inquiryInfoQe.eq("is_deleted", IsDeleteEnum.N.getKey());
        inquiryInfoQe.eq("is_quoted", InquiryQuotedTypeEnum.Disable.getKey());
        inquiryInfoQe.eq(getInquiryDetailVO.getHospitalId() != null,
                "hospital_id", getInquiryDetailVO.getHospitalId());
        inquiryInfoQe.eq(StringUtil.isNotBlank(getInquiryDetailVO.getHospitalCode()),
                "hospital_code", getInquiryDetailVO.getHospitalCode());
        inquiryInfoQe.eq(getInquiryDetailVO.getHospitalDeptId() != null,
                "hospital_dept_id", getInquiryDetailVO.getHospitalDeptId());
        inquiryInfoQe.eq(StringUtil.isNotBlank(getInquiryDetailVO.getHospitalDeptCode()),
                "hospital_dept_code", getInquiryDetailVO.getHospitalDeptCode());
        inquiryInfoQe.eq(getInquiryDetailVO.getDoctorId() != null,
                "doctor_id", getInquiryDetailVO.getDoctorId());
        inquiryInfoQe.eq(StringUtil.isNotBlank(getInquiryDetailVO.getDoctorCode()),
                "doctor_code", getInquiryDetailVO.getDoctorCode());
        inquiryInfoQe.eq(getInquiryDetailVO.getPatientId() != null,
                "patient_id", getInquiryDetailVO.getPatientId());
        inquiryInfoQe.eq(StringUtil.isNotBlank(getInquiryDetailVO.getPatientCode()),
                "patient_code", getInquiryDetailVO.getPatientCode());
        inquiryInfoQe.eq(StringUtil.isNotBlank(getInquiryDetailVO.getPatientIdNo()),
                "patient_id_no", getInquiryDetailVO.getPatientIdNo());
        inquiryInfoQe.eq(StringUtil.isNotBlank(getInquiryDetailVO.getPatientName()),
                "patient_name", getInquiryDetailVO.getPatientName());
        inquiryInfoQe.eq(StringUtil.isNotBlank(getInquiryDetailVO.getInquiryCode()),
                "inquiry_code", getInquiryDetailVO.getInquiryCode());
        String day = DateUtil.formatDateTime(DateUtil.getFirstTimeOfDay(DateUtil.addDay(DateUtil.now(),
                -getInquiryDetailVO.getDayLimit())));
        inquiryInfoQe.ge("gmt_modified", day);
        inquiryInfoQe.orderByDesc("gmt_modified");

        InquiryInfo inquiryInfo = this.getOne(inquiryInfoQe, false);
        if (inquiryInfo == null) {
            throw new CommonException(CommonErrorCode.NOT_EXISTS, "该病历不存在！");
        }

        QueryWrapper<InquiryDetail> inquiryDetailQe = new QueryWrapper<>();
        inquiryDetailQe.eq("inquiry_id", inquiryInfo.getId());
        inquiryDetailQe.orderByAsc("type");
        List<InquiryDetail> inquiryDetailList = inquiryDetailFacade.list(inquiryDetailQe);

        QueryWrapper<InquiryReport> inquiryReportQe = new QueryWrapper<>();
        inquiryReportQe.eq("inquiry_id", inquiryInfo.getId());
        inquiryReportQe.orderByAsc("order_num");
        List<InquiryReport> inquiryReportList = inquiryReportFacade.list(inquiryReportQe);

        QueryWrapper<InquiryEvaluator> inquiryEvaluatorQe = new QueryWrapper<>();
        inquiryEvaluatorQe.eq("inquiry_id", inquiryInfo.getId());
        inquiryEvaluatorQe.orderByDesc("gmt_modified");
        inquiryEvaluatorQe.last("limit 0,1");
        List<InquiryEvaluator> inquiryEvaluatorList = inquiryEvaluatorFacade.list(inquiryEvaluatorQe);

        GetInquiryDetailDTO getInquiryDetailDTO = new GetInquiryDetailDTO();
        BeanUtil.copyProperties(inquiryInfo, getInquiryDetailDTO);
        getInquiryDetailDTO.setPatientSexMsg(SexEnum.getName(inquiryInfo.getPatientSex()));
        getInquiryDetailDTO.setInquiryDate(inquiryInfo.getGmtModified());
        getInquiryDetailDTO.setInquiryTime(inquiryInfo.getGmtModified());
        getInquiryDetailDTO.setPatientAge(DateUtil.yearCompare(inquiryInfo.getPatientBirthday(), DateUtil.now()));

        if (ListUtil.isNotEmpty(inquiryDetailList)) {
            Map<Integer, InquiryDetail> inquiryDetailMap
                    = EntityUtil.makeEntityMap(inquiryDetailList, "type");
            if (null != inquiryDetailMap.get(1)) {
                getInquiryDetailDTO.setChiefComplaint(inquiryDetailMap.get(1).getContentValue());
            }
            if (null != inquiryDetailMap.get(2)) {
                getInquiryDetailDTO.setXbs(inquiryDetailMap.get(2).getContentValue());
            }
            if (null != inquiryDetailMap.get(3)) {
                getInquiryDetailDTO.setQts(inquiryDetailMap.get(3).getContentValue());
            }
            if (null != inquiryDetailMap.get(4)) {
                getInquiryDetailDTO.setSupplement(inquiryDetailMap.get(4).getContentValue());
            }
        }
        getInquiryDetailDTO.setPhysicalRes(
                ListUtil.isNotEmpty(inquiryEvaluatorList) ? inquiryEvaluatorList.get(0).getPhysicalRes() : null);
        if (ListUtil.isNotEmpty(inquiryReportList)) {
            for (InquiryReport inquiryReport : inquiryReportList) {
                if (StringUtil.isNotBlank(inquiryReport.getOriginalImage())) {
                    inquiryReport.setOriginalImage(imageUrlPrefix + inquiryReport.getOriginalImage());
                }
            }
            getInquiryDetailDTO.setImageList(BeanUtil.listCopyTo(inquiryReportList, GetInquiryDetailImgDTO.class));
        }

        return getInquiryDetailDTO;
    }

    /**
     * 病历引用
     *
     * @param inquiryQuoteVO
     * @return
     */
    public Boolean inquiryQuote(InquiryQuoteVO inquiryQuoteVO) {
        InquiryInfo inquiryInfo = getById(inquiryQuoteVO.getInquiryId());
        if (inquiryInfo == null) {
            throw new CommonException(CommonErrorCode.RPC_ERROR, "病历不存在");
        }
        if (!inquiryInfo.getHospitalCode().equals(inquiryQuoteVO.getHospitalCode())) {
            throw new CommonException(CommonErrorCode.RPC_ERROR, "医院不一致");
        }
        if (inquiryInfo.getIsQuoted() == 1) {
            return true;
        }

        RespDTO<InquiryQuoteVO> respDTO = tranServiceClient.inquiryQuote(inquiryQuoteVO);
        RespDTOUtil.respNGDealCover(respDTO, "病历引用失败");
        inquiryQuoteVO = respDTO.data;

        Date now = DateUtil.now();
        inquiryInfo.setGmtModified(now);
        inquiryInfo.setIsQuoted(1);
        inquiryInfo.setInquiryCode(inquiryQuoteVO.getInquiryCode());
        inquiryInfo.setPatientId(inquiryQuoteVO.getPatientInfo().getId());
        inquiryInfo.setPatientCode(inquiryQuoteVO.getPatientInfo().getCode());
        inquiryInfo.setPatientName(inquiryQuoteVO.getPatientInfo().getName());
        inquiryInfo.setPatientIdNo(inquiryQuoteVO.getPatientInfo().getIdNo());
        inquiryInfo.setPatientBirthday(inquiryQuoteVO.getPatientInfo().getBirthday());
        inquiryInfo.setPatientPhone(inquiryQuoteVO.getPatientInfo().getPhone());
        inquiryInfo.setPatientSex(inquiryQuoteVO.getPatientInfo().getSex());
        updateById(inquiryInfo);

        //插入引用表信息
        InquiryQuote inquiryQuote = new InquiryQuote();
        BeanUtil.copyProperties(inquiryQuoteVO, inquiryQuote);
        inquiryQuote.setGmtCreate(now);
        inquiryQuote.setGmtModified(now);
        inquiryQuote.setHospitalDeptId(inquiryQuoteVO.getDeptInfo().getId());
        inquiryQuote.setHospitalDeptCode(inquiryQuoteVO.getDeptInfo().getCode());
        inquiryQuote.setHospitalDeptName(inquiryQuoteVO.getDeptInfo().getName());
        inquiryQuote.setDoctorId(inquiryQuoteVO.getDoctorInfo().getId());
        inquiryQuote.setDoctorCode(inquiryQuoteVO.getDoctorInfo().getCode());
        inquiryQuote.setDoctorName(inquiryQuoteVO.getDoctorInfo().getName());
        inquiryQuote.setPatientId(inquiryQuoteVO.getPatientInfo().getId());
        inquiryQuote.setPatientCode(inquiryQuoteVO.getPatientInfo().getCode());
        inquiryQuote.setPatientName(inquiryQuoteVO.getPatientInfo().getName());
        inquiryQuote.setPatientIdNo(inquiryQuoteVO.getPatientInfo().getIdNo());
        inquiryQuote.setPatientBirthday(inquiryQuoteVO.getPatientInfo().getBirthday());
        inquiryQuote.setPatientPhone(inquiryQuoteVO.getPatientInfo().getPhone());
        inquiryQuote.setPatientSex(inquiryQuoteVO.getPatientInfo().getSex());
        inquiryQuote.setRegVisitedState(inquiryInfo.getRegVisitedState());
        inquiryQuote.setType(inquiryInfo.getType());
        inquiryQuote.setDataJson(inquiryInfo.getDataJson());

        inquiryQuoteFacade.save(inquiryQuote);

        return true;
    }

}