临时逻辑文件删除

hos-rest/src/main/java/com/yihu/hos/rest/controllers/CrawlerController.java

@@ -31,11 +31,10 @@ public class CrawlerController {
    @Resource
    CrawlerService crawlerService;
    @Resource
    CrawlerManager crawlerManager;
    @Resource
    QCCrawlerManager qcCrawlerManager;
    @Resource
    CrawlerFlowManager crawlerFlowManager;
@@ -94,20 +93,17 @@ public class CrawlerController {
            @ApiParam(name = "patient", value = "病人索引信息", required = true)
            @RequestParam(value = "patient") String patientInfo) {
        System.out.println("采集上传接口调用："+patientInfo);
        return Result.success("采集上传成功");
//        Patient patient = crawlerManager.parsePatient(patientInfo);
//        if (patient != null) {
//            Boolean result = crawlerManager.collectProcess(patient);
//            if (result) {
//                return Result.success("采集上传成功");
//            } else {
//                return Result.error("采集上传失败");
//            }
//        } else {
//            return Result.error("参数转换病人实体失败");
//        }
        Patient patient = crawlerManager.parsePatient(patientInfo);
        if (patient != null) {
            Boolean result = crawlerManager.collectProcess(patient,null);
            if (result) {
                return Result.success("采集上传成功");
            } else {
                return Result.error("采集上传失败");
            }
        } else {
            return Result.error("参数转换病人实体失败");
        }
    }
    @RequestMapping(value = "patient/flow", method = RequestMethod.POST)
@@ -137,7 +133,7 @@ public class CrawlerController {
            @ApiParam(name = "jobId", value = "任务jobId", required = true)
            @RequestParam(value = "jobId") String jobId) {
        try {
            return crawlerManager.dataCrawlerByJobId(jobId);
            return crawlerManager.dataCrawlerByJobId(jobId,null);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("采集上传失败");
@@ -333,7 +329,7 @@ public class CrawlerController {
            @ApiParam(name = "jobId", value = "任务jobId", required = true)
            @RequestParam(value = "jobId") String jobId) {
        try {
            return qcCrawlerManager.PatientListByJobId(jobId);
            return crawlerManager.PatientListByJobId(jobId);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
@@ -350,7 +346,7 @@ public class CrawlerController {
            @ApiParam(name = "checkType", value = "质控规则类型集合，以“，”分割", required = false)
            @RequestParam(value = "checkType", required = false) String checkType) {
        try {
            return qcCrawlerManager.dataCrawlerByJobId(jobId,checkType);
            return crawlerManager.dataCrawlerByJobId(jobId,checkType);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("采集上传失败");
@@ -365,10 +361,10 @@ public class CrawlerController {
            @ApiParam(name = "checkType", value = "质控规则类型集合，以“，”分割", required = false)
            @RequestParam(value = "checkType") String checkType) {
        Patient patient = qcCrawlerManager.parsePatient(patientInfo);
        Patient patient = crawlerManager.parsePatient(patientInfo);
        //TODO 通过获取规则，获取规则类型，进行校验
        if (patient != null) {
            Boolean result = qcCrawlerManager.collectProcess(patient, checkType);
            Boolean result = crawlerManager.collectProcess(patient, checkType);
            if (result) {
                return Result.success("上传档案质控数据成功");
            } else {

hos-rest/src/main/java/com/yihu/hos/rest/services/crawler/CrawlerManager.java

@@ -2,6 +2,7 @@ package com.yihu.hos.rest.services.crawler;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.yihu.hos.core.datatype.CollectionUtil;
import com.yihu.hos.core.datatype.DateUtil;
import com.yihu.hos.core.datatype.StringUtil;
@@ -13,6 +14,8 @@ import com.yihu.hos.rest.models.crawler.adapter.AdapterDataSet;
import com.yihu.hos.rest.models.crawler.adapter.StdDataSet;
import com.yihu.hos.rest.models.crawler.config.SysConfig;
import com.yihu.hos.rest.models.crawler.patient.Patient;
import com.yihu.hos.rest.models.crawler.qc.QcDaily;
import com.yihu.hos.rest.models.crawler.qc.QcPatientIndex;
import com.yihu.hos.rest.models.rs.RsJobConfig;
import com.yihu.hos.rest.models.standard.adapter.AdapterDatasetModel;
import com.yihu.hos.rest.models.standard.adapter.AdapterDictEntryModel;
@@ -31,9 +34,9 @@ import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.*;
@Service("CrawlerManager")
@Service("qCCrawlerManager")
public class CrawlerManager {
    public static final String BEAN_ID = "CrawlerManager";
    public static final String BEAN_ID = "qCCrawlerManager";
    private static String unstructured = "unstructured";
    private static Logger logger = LoggerFactory.getLogger(CrawlerManager.class);
    @Resource
@@ -50,6 +53,8 @@ public class CrawlerManager {
    private StdMetadataService StdMetadataService;
    @Resource(name = AdapterSchemeService.BEAN_ID)
    private AdapterSchemeService adapterSchemeService;
    @Resource
    private ObjectMapper objectMapper;
    private static DataCollectDispatcher dispatch = DataCollectDispatcher.getInstance();
    private static SysConfig sysConfig = SysConfig.getInstance();
@@ -70,11 +75,88 @@ public class CrawlerManager {
    }
    public Result dataCrawlerByJobId(String jobId) throws Exception {
    /**
     * 病人事件列表
     *
     * @param jobId
     * @return
     * @throws Exception
     */
    public List<Patient> PatientListByJobId(String jobId) throws Exception {
        RsJobConfig rsJobConfig = datacollect.getJobById(jobId);
        logger.info("质控服务-病人列表获取jobId:" + jobId);
        Date begin = rsJobConfig.getRepeatStartTime();
        Date end = rsJobConfig.getRepeatEndTime();
        if (end == null) {
            int totalOffset = rsJobConfig.getDelayTime();
            Calendar instance = Calendar.getInstance();
            instance.setTime(new Date(DateUtil.getSysDateTime().getTime()));
            instance.add(Calendar.SECOND, -totalOffset);    //调整截止时间，当前时间-偏移量
            end = instance.getTime();
        }
        if ((end.getTime() - begin.getTime()) <= 0) {
            System.out.println("质控服务-错误：采集结束时间小于开始时间！"); //结束时间小于开始时间时，不获取
            return null;
        }
        end = DateUtil.fromatDateToTimestamp(end);
        if (!rsJobConfig.getJobType().equals("0")) {
            //调整截止时间，当前时间-偏移量
            end = DateUtil.addDate(-rsJobConfig.getDelayTime(), DateUtil.getSysDateTime());
            if ((end.getTime() - begin.getTime()) <= 0) {
                System.out.println("质控服务-错误：采集结束时间小于开始时间！"); //结束时间小于开始时间时，不获取
                return null;
            }
        }
        if (DateUtil.getDifferenceOfDays(begin, end) > 1) {
            end = DateUtil.addDate(1, begin);
            end = DateUtil.fromatDateToTimestamp(end);
        }
        DataGridResult dataGridResult = datacollect.getJobDatasetByJobId(jobId);
        this.datasetList = dataGridResult.getDetailModelList();
        this.schemeVersion = rsJobConfig.getSchemeVersion();
        List<Patient> patientList = getPatientList(begin, end);
        return patientList;
    }
    public List<Patient> getPatientList(Date beginDate, Date endDate) {
        Map<String, Object> condition = new HashMap<>();
        condition.put("beginDate", beginDate);
        condition.put("endDate", endDate);
        Integer count = 0;
        Integer totalCount = 0;
        String message;
        /**
         * 适配基本数据准备
         */
        if (!getDataForPrepare()) {
            message = "适配数据尚未准备";
            logger.error(message);
            return null;
        }
        List<Patient> patientList = dispatch.getPatientList(condition, adapterDataSetMap);
            return patientList;
    }
    /**
     * 上传档案/质控上传
     * @param jobId
     * @param checkType
     * @return
     * @throws Exception
     */
    public Result dataCrawlerByJobId(String jobId,String checkType) throws Exception {
        RsJobConfig rsJobConfig = datacollect.getJobById(jobId);
        String random = UUID.randomUUID().toString();
        logger.info("档案采集上传开始,流水号:" + random + ",jobId:" + jobId);
        logger.info("质控数据采集上传开始,流水号:" + random + ",jobId:"+jobId);
        Date begin = rsJobConfig.getRepeatStartTime();
        Date end = rsJobConfig.getRepeatEndTime();
@@ -82,12 +164,12 @@ public class CrawlerManager {
            int totalOffset = rsJobConfig.getDelayTime();
            Calendar instance = Calendar.getInstance();
            instance.setTime(new Date(DateUtil.getSysDateTime().getTime()));
            instance.add(Calendar.SECOND, -totalOffset);    //调整截止时间，当前时间-偏移量
            instance.add(Calendar.SECOND, - totalOffset);    //调整截止时间，当前时间-偏移量
            end = instance.getTime();
        }
        if ((end.getTime() - begin.getTime()) <= 0) {
            return Result.error("错误：采集上传结束时间小于开始时间！jobId: "+jobId +",start:"+begin.toString()+" end: "+end.toString()); //结束时间小于开始时间时，不获取
            return Result.error("错误：采集结束时间小于开始时间！"); //结束时间小于开始时间时，不获取
        }
        end = DateUtil.fromatDateToTimestamp(end);
@@ -96,7 +178,7 @@ public class CrawlerManager {
            //调整截止时间，当前时间-偏移量
            end = DateUtil.addDate(-rsJobConfig.getDelayTime(), DateUtil.getSysDateTime());
            if ((end.getTime() - begin.getTime()) <= 0) {
                return Result.error("调整截止时间偏移量错误：采集上传结束时间小于开始时间！jobId: " + jobId + ",start:" + begin.toString() + " end: " + end.toString()); //结束时间小于开始时间时，不获取
                return Result.success("错误：采集结束时间小于开始时间！"); //结束时间小于开始时间时，不获取
            }
        }
@@ -108,17 +190,17 @@ public class CrawlerManager {
        DataGridResult dataGridResult = datacollect.getJobDatasetByJobId(jobId);
        this.datasetList = dataGridResult.getDetailModelList();
        this.schemeVersion = rsJobConfig.getSchemeVersion();
        Result result = dataCrawler(begin, end);
        Result result = dataCrawler(begin, end,checkType);
        if (!rsJobConfig.getJobType().equals("0")) {
            rsJobConfig.setRepeatStartTime(end);
//            rsJobConfig.setRepeatEndTime(DateUtil.formatYMDToYMDHMS(DateUtil.getSysDateTime().toString()));
        }
        datacollect.updateJob(rsJobConfig);
        logger.info("档案采集上传结束,上传结果：" + result.isSuccessFlg() + "流水号:" + random + ",jobId:" + jobId + ",message:" + result.getMessage());
        logger.info("质控采集上传结束,流水号:" + random + ",jobId:" + jobId + ",message:" + result.getMessage());
        return result;
    }
    public Result dataCrawler(Date beginDate, Date endDate) {
    public Result dataCrawler(Date beginDate, Date endDate,String checkType) {
        Map<String, Object> condition = new HashMap<>();
        condition.put("beginDate", beginDate);
        condition.put("endDate", endDate);
@@ -137,38 +219,45 @@ public class CrawlerManager {
        List<Patient> patientList = dispatch.getPatientList(condition, adapterDataSetMap);
        if (!CollectionUtil.isEmpty(patientList)) {
            totalCount = patientList.size();
            QcDaily qcDaily = genQcDaily(patientList);
            QcPatientIndex qcPatientIndex =null;
            for (Patient patient : patientList) {
                Boolean result = collectProcess(patient);
                if (result) {
                    count++;
                Boolean result = collectProcess(patient,checkType);
                qcPatientIndex = new QcPatientIndex(patient.getPatientId(),patient.getEventNo(),patient.getReferenceTime());
                    qcDaily.addTotal(qcPatientIndex,patient.getDataSet());
                    if (result) {
                        count++;
                        qcDaily.addReal(qcPatientIndex,patient.getDataSet());
                    }
                }
            if (qcDaily!=null){
                qcDaily.setOrg_code(patientList.get(0).getOrgCode());
                qcDaily.setInner_version(this.schemeVersion);
                qcDaily.setCreate_date(DateUtil.getCurrentString(DateUtil.DATE_WORLD_FORMAT));
                qcDaily.setTotal_outpatient_num(qcDaily.getTotal_outpatient().size());
                qcDaily.setTotal_hospital_num(qcDaily.getTotal_hospital().size());
                qcDaily.setReal_outpatient_num(qcDaily.getReal_outpatient().size());
                qcDaily.setReal_hospital_num(qcDaily.getReal_hospital().size());
                boolean b = dispatch.uploadQcDaily(objectMapper.convertValue(qcDaily, JsonNode.class),patientList.get(0));
                if (!b){
                    logger.debug("质控服务-日报包上传失败！！！");
                }
            }
        }
        message = "本次采集上传病人共" + totalCount + "条,成功采集上传信息" + count + "条";
        message = "本次上传病人共" + totalCount + "条,成功上传信息"+ count + "条";
        return Result.success(message);
    }
    //单个病人采集上传
    public Boolean collectProcess(Patient patient) {
    //单个病人质控数据采集上传
    public Boolean collectProcess(Patient patient, String collectType) {
        if (!getDataForPrepare()) {
            logger.error("适配数据尚未准备");
            return false;
        }
        patient.setReUploadFlg(StringUtil.toString(false));
        logger.trace("采集->注册->打包上传,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
        logger.trace("采集->质控分析->打包上传,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
        try {
            //getToken
//            if (!dispatch.getToken()) {
//                logger.error("token获取失败");
//                return false;
//            }
            //getRemoteVersion
//            if (!dispatch.getRemoteVersion(patient.getOrgCode())) {
//                logger.error("远程版本获取失败");
//                return false;
//            }
            if (StringUtil.isEmpty(sysConfig.getVersionMap().get(patient.getOrgCode()))) {
                Map.Entry<String, AdapterDataSet> next = adapterDataSetMap.entrySet().iterator().next();
@@ -182,28 +271,26 @@ public class CrawlerManager {
                }
            }
            if (StringUtil.isEmpty(sysConfig.getVersionMap().get(patient.getOrgCode()))) {
                logger.error("版本获取失败");
                return false;
            }
            Map<String, AdapterDataSet> dataSetMap = new HashMap<>();
            Map<String, JsonNode> dataMap = new HashMap<>();
            int realCount = 0;
            List<String> realList = new ArrayList<>();
            ObjectNode qcDataSet = dispatch.genQcDataSet(patient);//获取质控数据结构
            qcDataSet.put("total_num",adapterDataSetMap.size());
            for (String key : adapterDataSetMap.keySet()) {
                /**
                 * 获取数据
                 */
                AdapterDataSet adapterDataSet = adapterDataSetMap.get(key);
                String stdVersion = adapterDatasetService.getStdVersionByAdapterDataSet(this.schemeVersion);
                JsonNode jsonObject = null;
                if (!StringUtil.isEmpty(stdVersion)){
                    jsonObject = dispatch.fecthData(patient, adapterDataSet,stdVersion);
                }
                JsonNode jsonObject = dispatch.fecthData(patient, adapterDataSet,stdVersion);
                if (StringUtil.isEmpty(jsonObject)) {
                    continue;
                }
                dataSetMap.put(adapterDataSet.getAdapterDataSetT().getStdDatasetCode(), adapterDataSet);
                dataMap.put(key, jsonObject);
                realCount++;
                realList.add(key);
                /**
                 * 注册病人
                 */
@@ -216,106 +303,42 @@ public class CrawlerManager {
//                    }
//                }
            }
            logger.info("上传档案流程-获取病人信息成功,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
            ObjectMapper objectMapper = new ObjectMapper();
            qcDataSet.put("real_num",realCount);
            qcDataSet.set("total", objectMapper.convertValue(adapterDataSetMap.keySet().toArray(), JsonNode.class));
            qcDataSet.set("real", objectMapper.convertValue(realList, JsonNode.class));
            boolean b = dispatch.toQcDataSetFile(qcDataSet, patient);//生成数据集质控文件
            logger.info("采集病人数据成功,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
            //上传档案
            logger.info("上传病人档案");
            logger.info("上传病人档案及质控数据");
            try {
                if (!CollectionUtil.isEmpty(dataMap.keySet())) {
                    if (!dispatch.upload(dataMap, patient, dataSetMap, stdDataSetMap)) {
                        logger.error("上传档案失败");
                        return false;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
                logger.error("档案上传失败,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
                return false;
            }
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("采集病人失败,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo(), e);
            return false;
        }
        return true;
    }
    //TOADD 单个病人采集上传（包含blob)
    public Boolean collectProcess2(Patient patient) {
        if (!getDataForPrepare()) {
            logger.error("适配数据尚未准备");
            return false;
        }
        patient.setReUploadFlg(StringUtil.toString(false));
        logger.trace("采集->注册->打包上传,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
        try {
            //getToken
            if (!dispatch.getToken()) {
                logger.error("token获取失败");
                return false;
            }
            //getRemoteVersion
//            if (!dispatch.getRemoteVersion(patient.getOrgCode())) {
//                logger.error("远程版本获取失败");
//                return false;
//            }
            if (StringUtil.isEmpty(sysConfig.getVersionMap().get(patient.getOrgCode()))) {
                logger.error("版本获取失败");
                return false;
            }
            Map<String, AdapterDataSet> dataSetMap = new HashMap<>();
            Map<String, JsonNode> dataMap = new HashMap<>();
                    if (StringUtil.isEmpty(collectType)) {
                        //采集档案
                        if (!dispatch.upload(dataMap, patient, dataSetMap, stdDataSetMap)) {
                            logger.error("上传档案失败");
                            return false;
                        }
                    } else {
                        //TODO 规则检验
                        if (!dispatch.uploadQcData(dataMap, patient, dataSetMap, stdDataSetMap,collectType)) {
                            logger.error("上传质控包失败");
                            return false;
                        }
            if (adapterDataSetMap.containsKey(unstructured)) {
                //TODO 非结构化档处理
            } else {
                //TODO 结构化档案处理
            }
            for (String key : adapterDataSetMap.keySet()) {
                /**
                 * 获取数据
                 */
                AdapterDataSet adapterDataSet = adapterDataSetMap.get(key);
                String stdVersion = adapterDatasetService.getStdVersionByAdapterDataSet(this.schemeVersion);
                JsonNode jsonObject = null;
                if (!StringUtil.isEmpty(stdVersion)){
                    jsonObject = dispatch.fecthData(patient, adapterDataSet,stdVersion);
                }
                if (StringUtil.isEmpty(jsonObject)) {
                    continue;
                }
                dataSetMap.put(adapterDataSet.getAdapterDataSetT().getStdDatasetCode(), adapterDataSet);
                dataMap.put(key, jsonObject);
                /**
                 * 注册病人
                 */
                if (SysConfig.getInstance().getRegisterDataSet().equals(adapterDataSet.getAdapterDataSetT().getStdDatasetCode())) {
                    if (!StringUtil.isEmpty(jsonObject.get("data")) && !StringUtil.isEmpty(jsonObject.get("data").get(0))) {
                        if (!StringUtil.isEmpty(jsonObject.get("data").get(0).get(SysConfig.getInstance().getRegisterIdCardNo()))) {
                            logger.info("注册病人");
                            dispatch.register(patient, jsonObject.toString());
                        if (!dispatch.upload(dataMap, patient, dataSetMap, stdDataSetMap)) {
                            logger.error("上传档案失败");
                            return false;
                        }
                    }
                }
            }
            logger.info("上传-采集病人信息成功,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
            //上传档案
            logger.info("上传病人档案");
            try {
                if (!CollectionUtil.isEmpty(dataMap.keySet())) {
                    if (!dispatch.upload(dataMap, patient, dataSetMap, stdDataSetMap)) {
                        logger.error("上传档案失败");
                        return false;
                    }
                }
            } catch (Exception e) {
                logger.error("档案上传失败,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
                logger.error("质控数据上传失败,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
                return false;
            }
        } catch (Exception e) {
            logger.error("采集病人失败,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo(), e);
            logger.error("采集质控数据失败,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo(), e);
            return false;
        }
        return true;
@@ -364,6 +387,7 @@ public class CrawlerManager {
                 * 推模式接口调用，默认只使用最新版本的适配
                 */
                AdapterSchemeVersionModel adapterSchemeVersionModel = adapterSchemeVersionService.getEhrAdapterVersionLasted();
                if (adapterSchemeVersionModel == null) {
                    logger.error("获取最新ehr适配版本错误");
                    return false;
@@ -418,7 +442,6 @@ public class CrawlerManager {
            stdFlg = true;
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
@@ -447,4 +470,18 @@ public class CrawlerManager {
    public void setDatasetList(List<DictItem> datasetList) {
        this.datasetList = datasetList;
    }
    public QcDaily genQcDaily(List<Patient> patients){
        QcDaily qcDaily = new QcDaily();
        if (patients!=null && patients.isEmpty()){
            qcDaily.setOrg_code(patients.get(0).getOrgCode());
            qcDaily.setInner_version(SysConfig.getInstance().getVersionMap().get(patients.get(0).getOrgCode()));
            qcDaily.setCreate_date(DateUtil.getUtcDate(new Date()));
        }
        return qcDaily;
    }
}

hos-rest/src/main/java/com/yihu/hos/rest/services/crawler/QCCrawlerManager.java

@@ -1,487 +0,0 @@
package com.yihu.hos.rest.services.crawler;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.yihu.hos.core.datatype.CollectionUtil;
import com.yihu.hos.core.datatype.DateUtil;
import com.yihu.hos.core.datatype.StringUtil;
import com.yihu.hos.core.log.Logger;
import com.yihu.hos.core.log.LoggerFactory;
import com.yihu.hos.rest.common.format.AdapterBase;
import com.yihu.hos.rest.common.format.StdBase;
import com.yihu.hos.rest.models.crawler.adapter.AdapterDataSet;
import com.yihu.hos.rest.models.crawler.adapter.StdDataSet;
import com.yihu.hos.rest.models.crawler.config.SysConfig;
import com.yihu.hos.rest.models.crawler.patient.Patient;
import com.yihu.hos.rest.models.crawler.qc.QcDaily;
import com.yihu.hos.rest.models.crawler.qc.QcPatientIndex;
import com.yihu.hos.rest.models.rs.RsJobConfig;
import com.yihu.hos.rest.models.standard.adapter.AdapterDatasetModel;
import com.yihu.hos.rest.models.standard.adapter.AdapterDictEntryModel;
import com.yihu.hos.rest.models.standard.adapter.AdapterSchemeModel;
import com.yihu.hos.rest.models.standard.adapter.AdapterSchemeVersionModel;
import com.yihu.hos.rest.models.standard.bo.AdapterVersion;
import com.yihu.hos.rest.models.standard.bo.StandardVersion;
import com.yihu.hos.rest.models.standard.standard.StdMetaDataModel;
import com.yihu.hos.rest.services.standard.adapter.*;
import com.yihu.hos.rest.services.standard.standard.StdMetadataService;
import com.yihu.hos.web.framework.model.DataGridResult;
import com.yihu.hos.web.framework.model.DictItem;
import com.yihu.hos.web.framework.model.Result;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.*;
@Service("qCCrawlerManager")
public class QCCrawlerManager {
    public static final String BEAN_ID = "qCCrawlerManager";
    private static String unstructured = "unstructured";
    private static Logger logger = LoggerFactory.getLogger(QCCrawlerManager.class);
    @Resource
    private AdapterDatasetService adapterDatasetService;
    @Resource
    private AdapterMetadataService adapterMetadataService;
    @Resource
    private AdapterDictService adapterDictService;
    @Resource
    private AdapterSchemeVersionService adapterSchemeVersionService;
    @Resource
    private DatacollectManager datacollect;
    @Resource
    private StdMetadataService StdMetadataService;
    @Resource(name = AdapterSchemeService.BEAN_ID)
    private AdapterSchemeService adapterSchemeService;
    @Resource
    private ObjectMapper objectMapper;
    private static DataCollectDispatcher dispatch = DataCollectDispatcher.getInstance();
    private static SysConfig sysConfig = SysConfig.getInstance();
    private static Map<String, Map<String, AdapterDataSet>> adapterDataSetVersionMap = new HashMap<>();
    private static Map<String, Map<String, StdDataSet>> stdDataSetVersionMap = new HashMap<>();
    private static Map<Integer, List<StdMetaDataModel>> stdMetaDataMap = new HashMap<>();
    private Map<String, AdapterDataSet> adapterDataSetMap;
    private Map<String, StdDataSet> stdDataSetMap;
    private Boolean adapterFlg = false;
    private Boolean stdFlg = false;
    private String schemeVersion;
    private List<DictItem> datasetList;
    public void finalize() throws Throwable {
    }
    /**
     * 病人事件列表
     *
     * @param jobId
     * @return
     * @throws Exception
     */
    public List<Patient> PatientListByJobId(String jobId) throws Exception {
        RsJobConfig rsJobConfig = datacollect.getJobById(jobId);
        logger.info("质控服务-病人列表获取jobId:" + jobId);
        Date begin = rsJobConfig.getRepeatStartTime();
        Date end = rsJobConfig.getRepeatEndTime();
        if (end == null) {
            int totalOffset = rsJobConfig.getDelayTime();
            Calendar instance = Calendar.getInstance();
            instance.setTime(new Date(DateUtil.getSysDateTime().getTime()));
            instance.add(Calendar.SECOND, -totalOffset);    //调整截止时间，当前时间-偏移量
            end = instance.getTime();
        }
        if ((end.getTime() - begin.getTime()) <= 0) {
            System.out.println("质控服务-错误：采集结束时间小于开始时间！"); //结束时间小于开始时间时，不获取
            return null;
        }
        end = DateUtil.fromatDateToTimestamp(end);
        if (!rsJobConfig.getJobType().equals("0")) {
            //调整截止时间，当前时间-偏移量
            end = DateUtil.addDate(-rsJobConfig.getDelayTime(), DateUtil.getSysDateTime());
            if ((end.getTime() - begin.getTime()) <= 0) {
                System.out.println("质控服务-错误：采集结束时间小于开始时间！"); //结束时间小于开始时间时，不获取
                return null;
            }
        }
        if (DateUtil.getDifferenceOfDays(begin, end) > 1) {
            end = DateUtil.addDate(1, begin);
            end = DateUtil.fromatDateToTimestamp(end);
        }
        DataGridResult dataGridResult = datacollect.getJobDatasetByJobId(jobId);
        this.datasetList = dataGridResult.getDetailModelList();
        this.schemeVersion = rsJobConfig.getSchemeVersion();
        List<Patient> patientList = getPatientList(begin, end);
        return patientList;
    }
    public List<Patient> getPatientList(Date beginDate, Date endDate) {
        Map<String, Object> condition = new HashMap<>();
        condition.put("beginDate", beginDate);
        condition.put("endDate", endDate);
        Integer count = 0;
        Integer totalCount = 0;
        String message;
        /**
         * 适配基本数据准备
         */
        if (!getDataForPrepare()) {
            message = "适配数据尚未准备";
            logger.error(message);
            return null;
        }
        List<Patient> patientList = dispatch.getPatientList(condition, adapterDataSetMap);
            return patientList;
    }
    /**
     * 上传档案/质控上传
     * @param jobId
     * @param checkType
     * @return
     * @throws Exception
     */
    public Result dataCrawlerByJobId(String jobId,String checkType) throws Exception {
        RsJobConfig rsJobConfig = datacollect.getJobById(jobId);
        String random = UUID.randomUUID().toString();
        logger.info("质控数据采集上传开始,流水号:" + random + ",jobId:"+jobId);
        Date begin = rsJobConfig.getRepeatStartTime();
        Date end = rsJobConfig.getRepeatEndTime();
        if (end == null) {
            int totalOffset = rsJobConfig.getDelayTime();
            Calendar instance = Calendar.getInstance();
            instance.setTime(new Date(DateUtil.getSysDateTime().getTime()));
            instance.add(Calendar.SECOND, - totalOffset);    //调整截止时间，当前时间-偏移量
            end = instance.getTime();
        }
        if ((end.getTime() - begin.getTime()) <= 0) {
            return Result.error("错误：采集结束时间小于开始时间！"); //结束时间小于开始时间时，不获取
        }
        end = DateUtil.fromatDateToTimestamp(end);
        if (!rsJobConfig.getJobType().equals("0")) {
            //调整截止时间，当前时间-偏移量
            end = DateUtil.addDate(-rsJobConfig.getDelayTime(), DateUtil.getSysDateTime());
            if ((end.getTime() - begin.getTime()) <= 0) {
                return Result.success("错误：采集结束时间小于开始时间！"); //结束时间小于开始时间时，不获取
            }
        }
        if (DateUtil.getDifferenceOfDays(begin, end) > 1) {
            end = DateUtil.addDate(1, begin);
            end = DateUtil.fromatDateToTimestamp(end);
        }
        DataGridResult dataGridResult = datacollect.getJobDatasetByJobId(jobId);
        this.datasetList = dataGridResult.getDetailModelList();
        this.schemeVersion = rsJobConfig.getSchemeVersion();
        Result result = dataCrawler(begin, end,checkType);
        if (!rsJobConfig.getJobType().equals("0")) {
            rsJobConfig.setRepeatStartTime(end);
//            rsJobConfig.setRepeatEndTime(DateUtil.formatYMDToYMDHMS(DateUtil.getSysDateTime().toString()));
        }
        datacollect.updateJob(rsJobConfig);
        logger.info("质控采集上传结束,流水号:" + random + ",jobId:" + jobId + ",message:" + result.getMessage());
        return result;
    }
    public Result dataCrawler(Date beginDate, Date endDate,String checkType) {
        Map<String, Object> condition = new HashMap<>();
        condition.put("beginDate", beginDate);
        condition.put("endDate", endDate);
        Integer count = 0;
        Integer totalCount = 0;
        String message;
        /**
         * 适配基本数据准备
         */
        if (!getDataForPrepare()) {
            message = "适配数据尚未准备";
            logger.error(message);
            return Result.error(message);
        }
        List<Patient> patientList = dispatch.getPatientList(condition, adapterDataSetMap);
        if (!CollectionUtil.isEmpty(patientList)) {
            totalCount = patientList.size();
            QcDaily qcDaily = genQcDaily(patientList);
            QcPatientIndex qcPatientIndex =null;
            for (Patient patient : patientList) {
                Boolean result = collectProcess(patient,checkType);
                qcPatientIndex = new QcPatientIndex(patient.getPatientId(),patient.getEventNo(),patient.getReferenceTime());
                    qcDaily.addTotal(qcPatientIndex,patient.getDataSet());
                    if (result) {
                        count++;
                        qcDaily.addReal(qcPatientIndex,patient.getDataSet());
                    }
                }
            if (qcDaily!=null){
                qcDaily.setOrg_code(patientList.get(0).getOrgCode());
                qcDaily.setInner_version(this.schemeVersion);
                qcDaily.setCreate_date(DateUtil.getCurrentString(DateUtil.DATE_WORLD_FORMAT));
                qcDaily.setTotal_outpatient_num(qcDaily.getTotal_outpatient().size());
                qcDaily.setTotal_hospital_num(qcDaily.getTotal_hospital().size());
                qcDaily.setReal_outpatient_num(qcDaily.getReal_outpatient().size());
                qcDaily.setReal_hospital_num(qcDaily.getReal_hospital().size());
                boolean b = dispatch.uploadQcDaily(objectMapper.convertValue(qcDaily, JsonNode.class),patientList.get(0));
                if (!b){
                    logger.debug("质控服务-日报包上传失败！！！");
                }
            }
        }
        message = "本次上传病人共" + totalCount + "条,成功上传信息"+ count + "条";
        return Result.success(message);
    }
    //单个病人质控数据采集上传
    public Boolean collectProcess(Patient patient, String collectType) {
        if (!getDataForPrepare()) {
            logger.error("适配数据尚未准备");
            return false;
        }
        patient.setReUploadFlg(StringUtil.toString(false));
        logger.trace("采集->质控分析->打包上传,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
        try {
            if (StringUtil.isEmpty(sysConfig.getVersionMap().get(patient.getOrgCode()))) {
                Map.Entry<String, AdapterDataSet> next = adapterDataSetMap.entrySet().iterator().next();
                Integer schemeId = next.getValue().getAdapterDataSetT().getSchemeId();
                AdapterSchemeModel schemeModel = adapterSchemeService.getEntity(AdapterSchemeModel.class, schemeId);
                if (schemeModel.getStdVersion() != null) {
                    SysConfig.getInstance().getVersionMap().put(patient.getOrgCode(), schemeModel.getStdVersion());
                } else {
                    logger.error("版本获取失败");
                    return false;
                }
            }
            Map<String, AdapterDataSet> dataSetMap = new HashMap<>();
            Map<String, JsonNode> dataMap = new HashMap<>();
            int realCount = 0;
            List<String> realList = new ArrayList<>();
            ObjectNode qcDataSet = dispatch.genQcDataSet(patient);//获取质控数据结构
            qcDataSet.put("total_num",adapterDataSetMap.size());
            for (String key : adapterDataSetMap.keySet()) {
                /**
                 * 获取数据
                 */
                AdapterDataSet adapterDataSet = adapterDataSetMap.get(key);
                String stdVersion = adapterDatasetService.getStdVersionByAdapterDataSet(this.schemeVersion);
                JsonNode jsonObject = dispatch.fecthData(patient, adapterDataSet,stdVersion);
                if (StringUtil.isEmpty(jsonObject)) {
                    continue;
                }
                dataSetMap.put(adapterDataSet.getAdapterDataSetT().getStdDatasetCode(), adapterDataSet);
                dataMap.put(key, jsonObject);
                realCount++;
                realList.add(key);
                /**
                 * 注册病人
                 */
//                if (SysConfig.getInstance().getRegisterDataSet().equals(adapterDataSet.getAdapterDataSetT().getStdDatasetCode())) {
//                    if (!StringUtil.isEmpty(jsonObject.get("data")) && !StringUtil.isEmpty(jsonObject.get("data").get(0))) {
//                        if (!StringUtil.isEmpty(jsonObject.get("data").get(0).get(SysConfig.getInstance().getRegisterIdCardNo()))) {
//                            logger.info("注册病人");
//                            dispatch.register(patient, jsonObject.toString());
//                        }
//                    }
//                }
            }
            ObjectMapper objectMapper = new ObjectMapper();
            qcDataSet.put("real_num",realCount);
            qcDataSet.set("total", objectMapper.convertValue(adapterDataSetMap.keySet().toArray(), JsonNode.class));
            qcDataSet.set("real", objectMapper.convertValue(realList, JsonNode.class));
            boolean b = dispatch.toQcDataSetFile(qcDataSet, patient);//生成数据集质控文件
            logger.info("采集病人数据成功,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
            //上传档案
            logger.info("上传病人档案及质控数据");
            try {
                if (!CollectionUtil.isEmpty(dataMap.keySet())) {
                    if (StringUtil.isEmpty(collectType)) {
                        //采集档案
                        if (!dispatch.upload(dataMap, patient, dataSetMap, stdDataSetMap)) {
                            logger.error("上传档案失败");
                            return false;
                        }
                    } else {
                        //TODO 规则检验
                        if (!dispatch.uploadQcData(dataMap, patient, dataSetMap, stdDataSetMap,collectType)) {
                            logger.error("上传质控包失败");
                            return false;
                        }
                        if (!dispatch.upload(dataMap, patient, dataSetMap, stdDataSetMap)) {
                            logger.error("上传档案失败");
                            return false;
                        }
                    }
                }
            } catch (Exception e) {
                logger.error("质控数据上传失败,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
                return false;
            }
        } catch (Exception e) {
            logger.error("采集质控数据失败,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo(), e);
            return false;
        }
        return true;
    }
    public Boolean getDataForPrepare() {
        if (adapterFlg && stdFlg) {
            return true;
        }
        AdapterBase.setAdapterMetadataService(adapterMetadataService);
        AdapterBase.setAdapterDictService(adapterDictService);
        AdapterBase.setAdapterSchemeVersionService(adapterSchemeVersionService);
        StdBase.setStdMetadataService(StdMetadataService);
        logger.info("适配基本相关数据准备");
        try {
            adapterDataSetMap = new HashMap<>();
            stdDataSetMap = new HashMap<>();
            AdapterVersion adapterVersion;
            StandardVersion standardVersion = null;
            List<AdapterDatasetModel> adapterDataSetModelList;
            if (!CollectionUtil.isEmpty(datasetList)) {
                /**
                 * 拉模式接口调用，由任务配置决定适配版本
                 */
                adapterVersion = new AdapterVersion(schemeVersion);
                List<Integer> datasetIdList = new ArrayList<>();
                for (DictItem dictItem : datasetList) {
                    Integer dataSetId = Integer.parseInt(dictItem.getCode());
                    datasetIdList.add(dataSetId);
                }
                adapterDataSetModelList = adapterDatasetService.getAdapterDatasetByAdapterIdList(adapterVersion, datasetIdList);
                if (adapterDataSetModelList != null && !adapterDataSetModelList.isEmpty()) {
                    AdapterSchemeModel adapterScheme = adapterSchemeService.getEntity(AdapterSchemeModel.class, adapterDataSetModelList.get(0).getSchemeId());
                    standardVersion = new StandardVersion(adapterScheme.getStdVersion());
                    for (DictItem dictItem : datasetList) {
                        Integer dataSetId = Integer.parseInt(dictItem.getCode());
                        if (!stdMetaDataMap.containsKey(dataSetId)) {
                            stdMetaDataMap.put(dataSetId, new StdDataSet(dataSetId, standardVersion).getStdMetaDataModelList());
                        }
                    }
                }
            } else {
                /**
                 * 推模式接口调用，默认只使用最新版本的适配
                 */
                AdapterSchemeVersionModel adapterSchemeVersionModel = adapterSchemeVersionService.getEhrAdapterVersionLasted();
                if (adapterSchemeVersionModel == null) {
                    logger.error("获取最新ehr适配版本错误");
                    return false;
                } else {
                    this.schemeVersion = adapterSchemeVersionModel.getVersion();
                    adapterVersion = new AdapterVersion(schemeVersion);
                }
                if (adapterDataSetVersionMap.get(schemeVersion) != null) {
                    adapterDataSetMap = adapterDataSetVersionMap.get(schemeVersion);
                    adapterFlg = true;
                }
                if (stdDataSetVersionMap.get(schemeVersion) != null) {
                    stdDataSetMap = stdDataSetVersionMap.get(schemeVersion);
                    stdFlg = true;
                }
                if (adapterFlg && stdFlg) {
                    return true;
                }
                Map<String, String> condition = new HashMap<>();
                condition.put("column", "adapter_dataset_code");
                ObjectMapper mapper = new ObjectMapper();
                String conditionStr = mapper.writeValueAsString(condition);
                adapterDataSetModelList = adapterDatasetService.getAdapterDatasetNotNullList(adapterVersion, conditionStr);
            }
            /**
             * 字典项初始化
             */
            List<AdapterDictEntryModel> adapterDictEntryModelList = adapterDatasetService.getList(AdapterDictEntryModel.class, adapterVersion.getDictEntryTableName(), null, null, null, null);
            Map<Integer, List<AdapterDictEntryModel>> adapterDictEntryModelMap = new HashMap<>();
            for (AdapterDictEntryModel adapterDictEntryModel : adapterDictEntryModelList) {
                List<AdapterDictEntryModel> entryModelList = adapterDictEntryModelMap.get(adapterDictEntryModel.getStdDictId());
                if (CollectionUtil.isEmpty(entryModelList)) {
                    entryModelList = new ArrayList<>();
                }
                entryModelList.add(adapterDictEntryModel);
                adapterDictEntryModelMap.put(adapterDictEntryModel.getStdDictId(), entryModelList);
            }
            /**
             * 数据集初始化
             */
            for (AdapterDatasetModel adapterDatasetModel : adapterDataSetModelList) {
                adapterDataSetMap.put(adapterDatasetModel.getStdDatasetCode(), new AdapterDataSet(adapterDatasetModel, adapterVersion, adapterDictEntryModelMap));
                stdDataSetMap.put(adapterDatasetModel.getStdDatasetCode(), new StdDataSet(adapterDatasetModel.getStdDatasetId(), standardVersion));
            }
            adapterDataSetVersionMap.put(schemeVersion, adapterDataSetMap);
            stdDataSetVersionMap.put(schemeVersion, stdDataSetMap);
            adapterFlg = true;
            stdFlg = true;
            return true;
        } catch (Exception e) {
            return false;
        }
    }
    /**
     * 解析病人索引信息
     *
     * @param patientInfo 病人索引信息
     * @return
     */
    public Patient parsePatient(String patientInfo) {
        try {
            ObjectMapper mapper = new ObjectMapper();
            Patient patient = mapper.readValue(patientInfo, Patient.class);
            return patient;
        } catch (Exception e) {
            logger.error("patient参数错误：" + patientInfo, e);
            return null;
        }
    }
    public void setSchemeVersion(String schemeVersion) {
        this.schemeVersion = schemeVersion;
    }
    public void setDatasetList(List<DictItem> datasetList) {
        this.datasetList = datasetList;
    }
    public QcDaily genQcDaily(List<Patient> patients){
        QcDaily qcDaily = new QcDaily();
        if (patients!=null && patients.isEmpty()){
            qcDaily.setOrg_code(patients.get(0).getOrgCode());
            qcDaily.setInner_version(SysConfig.getInstance().getVersionMap().get(patients.get(0).getOrgCode()));
            qcDaily.setCreate_date(DateUtil.getUtcDate(new Date()));
        }
        return qcDaily;
    }
}