wxservice-server/src/main/java/thyyxxk/wxservice_server/service/InspectionsService.java

package thyyxxk.wxservice_server.service;

import lombok.extern.slf4j.Slf4j;
import org.apache.cxf.endpoint.Client;
import org.apache.cxf.endpoint.Endpoint;
import org.apache.cxf.jaxws.endpoint.dynamic.JaxWsDynamicClientFactory;
import org.apache.cxf.service.model.BindingInfo;
import org.apache.cxf.service.model.BindingOperationInfo;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import thyyxxk.wxservice_server.config.exception.ExceptionEnum;
import thyyxxk.wxservice_server.dao.InspectionsDao;
import thyyxxk.wxservice_server.pojo.ResultVo;
import thyyxxk.wxservice_server.pojo.inspections.CheckExamParam;
import thyyxxk.wxservice_server.pojo.inspections.ExamIndexResult;
import thyyxxk.wxservice_server.pojo.inspections.detail.*;
import thyyxxk.wxservice_server.utils.ResultVoUtil;
import thyyxxk.wxservice_server.utils.StringUtil;

import javax.xml.namespace.QName;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.CompletableFuture;

@Slf4j
@Service
public class InspectionsService {
    private static final String SOAP_URL = "http://172.16.32.178:622/pushservice.asmx?wsdl";
    private final InspectionsDao dao;

    @Autowired
    public InspectionsService(InspectionsDao dao) {
        this.dao = dao;
    }

    @Async("asyncTask")
    public CompletableFuture<ResultVo<List<ExamIndexResult>>> getExamIndex(CheckExamParam param) {
        final String tjNo = dao.selectTjNo(param.getPatientId());
        final String inpatientNo = dao.selectInpatientNo(param.getPatientId());
        String sendHead1 = "<message><PATIENT_TYPE>0</PATIENT_TYPE><PTNT_NO>" + param.getPatientId() + "</PTNT_NO>";
        String sendHead2 = null;
        String sendHead3 = null;
        if (StringUtil.notBlank(tjNo)) {
            sendHead2 = "<message><PTNT_NO>" + tjNo + "</PTNT_NO>";
        }
        if (StringUtil.notBlank(inpatientNo)) {
            sendHead3 = "<message><PATIENT_TYPE>1</PATIENT_TYPE><PTNT_NO>" + inpatientNo + "</PTNT_NO>";
        }
        String sendEnd = "<START_TIME>" + param.getStart() + "</START_TIME><END_TIME>" + param.getEnd() + "</END_TIME></message>";
        String send1 = sendHead1 + sendEnd;
        String xml1 = invokeRemoteMethod("GetLabReportIndex", new Object[]{send1});
        List<ExamIndexResult> list1 = analyzeExamIndex(xml1.substring(1, xml1.length() - 1));
        if (null != sendHead2) {
            String send2 = sendHead2 + sendEnd;
            String xml2 = invokeRemoteMethod("GetLabReportIndex", new Object[]{send2});
            List<ExamIndexResult> list2 = analyzeExamIndex(xml2.substring(1, xml2.length() - 1));
            list1.addAll(list2);
        }
        if (null != sendHead3) {
            String send3 = sendHead3 + sendEnd;
            String xml3 = invokeRemoteMethod("GetLabReportIndex", new Object[]{send3});
            List<ExamIndexResult> list3 = analyzeExamIndex(xml3.substring(1, xml3.length() - 1));
            list1.addAll(list3);
        }
        return CompletableFuture.completedFuture(ResultVoUtil.success(list1));
    }

    @Async("asyncTask")
    public CompletableFuture<ResultVo<List<ExamIndexResult>>> checkAllIndexBySocialNo(String socialNo) {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        Date date = new Date();
        String start = df.format(date.getTime() - 15L * 24 * 60 * 60 * 1000);
        String end = df.format(date);
        String xmlEnd = "<START_TIME>" + start + "</START_TIME><END_TIME>" + end + "</END_TIME></message>";
        List<String> tjNos = dao.selectTjNos(socialNo);
        List<String> mzNos = dao.selectMzNos(socialNo);
        List<String> zyNos = dao.selectZyNos(socialNo);
        List<ExamIndexResult> results = new ArrayList<>();
        if (null != tjNos && tjNos.size() > 0) {
            for (String tjNo : tjNos) {
                String tjHead = "<message><PTNT_NO>" + tjNo + "</PTNT_NO>";
                String xml = invokeRemoteMethod("GetLabReportIndex", new Object[]{tjHead+xmlEnd});
                List<ExamIndexResult> list = analyzeExamIndex(xml.substring(1, xml.length() - 1));
                recognitionCovidExam(results, list);
            }
        }
        if (null != mzNos && mzNos.size() > 0) {
            for (String mzNo : mzNos) {
                String mzHead = "<message><PATIENT_TYPE>0</PATIENT_TYPE><PTNT_NO>" + mzNo + "</PTNT_NO>";
                String xml = invokeRemoteMethod("GetLabReportIndex", new Object[]{mzHead+xmlEnd});
                List<ExamIndexResult> list = analyzeExamIndex(xml.substring(1, xml.length() - 1));
                recognitionCovidExam(results, list);
            }
        }
        if (null != zyNos && zyNos.size() > 0) {
            for (String zyNo : zyNos) {
                String zyHead = "<message><PATIENT_TYPE>1</PATIENT_TYPE><PTNT_NO>" + zyNo + "</PTNT_NO>";
                String xml = invokeRemoteMethod("GetLabReportIndex", new Object[]{zyHead+xmlEnd});
                List<ExamIndexResult> list = analyzeExamIndex(xml.substring(1, xml.length() - 1));
                recognitionCovidExam(results, list);
            }
        }
        return CompletableFuture.completedFuture(ResultVoUtil.success(results));
    }

    private void recognitionCovidExam(List<ExamIndexResult> results, List<ExamIndexResult> list) {
        if (null != list) {
            for (ExamIndexResult index : list) {
                if (isCovidExam(index.getAPLY_CTNT())) {
                    results.add(index);
                }
            }
        }
    }

    private boolean isCovidExam(String name) {
        return name.startsWith("新") && name.contains("冠") && name.endsWith("核酸检测");
    }

    @Async("asyncTask")
    public CompletableFuture<ResultVo<ExamDetailResult>> getExamDetail(String orderId) {
        if (StringUtil.isBlank(orderId) || "undefined".equals(orderId.trim())) {
            return CompletableFuture.completedFuture(ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "报告ID不能为空！"));
        }
        String send = "<message><ORDR_ID>" + orderId + "</ORDR_ID></message>";
        String xml = invokeRemoteMethod("GetLabReport", new Object[]{send});
        return CompletableFuture.completedFuture(analyzeExamDetail(xml.substring(1, xml.length() - 1)));
    }

    private String invokeRemoteMethod(String operation, Object[] parameters) {
        log.info("查询检验报告：方法：{}，参数：{}", operation, parameters[0]);
        JaxWsDynamicClientFactory dcf = JaxWsDynamicClientFactory.newInstance();
        Client client = dcf.createClient(SOAP_URL);
        //处理webService接口和实现类namespace不同的情况，CXF动态客户端在处理此问题时，会报No operation was found with the name的异常
        Endpoint endpoint = client.getEndpoint();
        QName opName = new QName(endpoint.getService().getName().getNamespaceURI(), operation);
        BindingInfo bindingInfo = endpoint.getEndpointInfo().getBinding();
        if (bindingInfo.getOperation(opName) == null) {
            for (BindingOperationInfo operationInfo : bindingInfo.getOperations()) {
                if (operation.equals(operationInfo.getName().getLocalPart())) {
                    opName = operationInfo.getName();
                    break;
                }
            }
        }
        Object[] res = null;
        try {
            res = client.invoke(opName, parameters);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Arrays.toString(res);
    }

    private Element getReturnElement(String xml) {
        try {
            Document document = DocumentHelper.parseText(xml);
            Element root = document.getRootElement();
            return root.element("return");
        } catch (DocumentException e) {
            e.printStackTrace();
        }
        return null;
    }

    private List<ExamIndexResult> analyzeExamIndex(String xml) {
        Element retEle = getReturnElement(xml);
        if (retEle == null) {
            return new ArrayList<>();
        }
        Element codeEl = retEle.element("Code");
        String code = codeEl.getStringValue();
        if ("1".equals(code)) {
            List<ExamIndexResult> examList = new ArrayList<>();
            Element resEl = retEle.element("Result");
            List<Element> reports = resEl.elements("ReportList");
            reports.forEach(item -> {
                ExamIndexResult pojo = new ExamIndexResult();
                Field[] fields = pojo.getClass().getDeclaredFields();
                for (Field field : fields) {
                    try {
                        field.setAccessible(true);
                        String name = field.getName();
                        Method m = pojo.getClass().getMethod("set" + name, String.class);
                        m.invoke(pojo, item.elementTextTrim(name));
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                examList.add(pojo);
            });
            return examList;
        } else {
            Element errorMsgEl = retEle.element("ErrorMsg");
            log.info("查询检验报告列表出错，{}", errorMsgEl.getStringValue());
            return new ArrayList<>();
        }
    }

    private ResultVo<ExamDetailResult> analyzeExamDetail(String xml) {
        Element retEle = getReturnElement(xml);
        ExamDetailResult detail = new ExamDetailResult();
        if (retEle == null) {
            return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "结果集为空！");
        }
        String code = retEle.elementTextTrim("Code");
        if ("0".equals(code)) {
            return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, retEle.elementTextTrim("ErrorMsg"));
        }
        Element reportListEle = retEle.element("Result").element("ReportList");
        ReportHeader header = new ReportHeader();
        detail.setReportHeader((ReportHeader) reflect(header, reportListEle.element("ReportHeader")));
        List<ReportItem> reportItems = new ArrayList<>();
        List<Element> reportItemElements = reportListEle.elements("ReportItem");
        reportItemElements.forEach(reportItemElement -> {
            ReportItem reportItem = new ReportItem();
            reflect(reportItem, reportItemElement);
            List<Element> bacteriaResultElements = reportItemElement.elements("BacteriaResult");
            if (bacteriaResultElements.size() > 0) {
                List<BacteriaResult> bacteriaResults = new ArrayList<>();
                bacteriaResultElements.forEach(bacterialResultElement -> {
                    BacteriaResult bacteriaResult = new BacteriaResult();
                    reflect(bacteriaResult, bacterialResultElement);
                    List<Element> antibioticResultElements = bacterialResultElement.elements("AntibioticResult");
                    if (antibioticResultElements.size() > 0) {
                        List<AntibioticResult> antibioticResults = new ArrayList<>();
                        antibioticResultElements.forEach(antibioticResultElement -> {
                            AntibioticResult antibioticResult = new AntibioticResult();
                            antibioticResults.add((AntibioticResult) reflect(antibioticResult, antibioticResultElement));
                        });
                        bacteriaResult.setAntibioticResults(antibioticResults);
                    }
                    if (StringUtil.notBlank(bacteriaResult.getBAC_ID())) {
                        bacteriaResults.add(bacteriaResult);
                    }
                });
                reportItem.setBacteriaResults(bacteriaResults);
            }
            if (StringUtil.notBlank(reportItem.getITM_VALUE()) || StringUtil.notBlank(reportItem.getITM_STR_VALUE())
                    || reportItem.getBacteriaResults().size() > 0) {
                reportItems.add(reportItem);
            }
        });
        detail.setReportItems(reportItems);
        return ResultVoUtil.success(detail);
    }

    private Object reflect(Object pojo, Element element) {
        Field[] fields = pojo.getClass().getDeclaredFields();
        for (Field field : fields) {
            try {
                String name = field.getName();
                if ("bacteriaResults".equals(name) || "antibioticResults".equals(name)) {
                    continue;
                }
                Method m = pojo.getClass().getMethod("set" + name, String.class);
                m.invoke(pojo, element.elementTextTrim(name));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return pojo;
    }
}