采集流程逻辑新增

Hos-resource/src/main/java/com/yihu/ehr/crawler/model/flow/CrawlerFlow.java

@@ -0,0 +1,35 @@
package com.yihu.ehr.crawler.model.flow;
import com.yihu.ehr.framework.model.Result;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
/**
 * 标准基本信息
 *
 * @created Airhead 2015/12/23.
 */
public class CrawlerFlow extends Result implements Serializable {
    private String datasetCode;
    private List<String> metadataCodeList = new ArrayList<>();
    public String getDatasetCode() {
        return datasetCode;
    }
    public void setDatasetCode(String datasetCode) {
        this.datasetCode = datasetCode;
    }
    public List<String> getMetadataCodeList() {
        return metadataCodeList;
    }
    public void setMetadataCodeList(List<String> metadataCodeList) {
        this.metadataCodeList = metadataCodeList;
    }
}

Hos-resource/src/main/java/com/yihu/ehr/crawler/model/flow/CrawlerFlowHeadModel.java

@@ -15,8 +15,6 @@ public class CrawlerFlowHeadModel extends Result implements Serializable {
    private String datasetCode;
    private String datasetName;
    private String metadataCode;
    private String identityCode;
@@ -37,14 +35,6 @@ public class CrawlerFlowHeadModel extends Result implements Serializable {
        this.datasetCode = datasetCode;
    }
    public String getDatasetName() {
        return datasetName;
    }
    public void setDatasetName(String datasetName) {
        this.datasetName = datasetName;
    }
    public String getMetadataCode() {
        return metadataCode;
    }

Hos-resource/src/main/java/com/yihu/ehr/crawler/service/CrawlerFlowManager.java

@@ -0,0 +1,255 @@
package com.yihu.ehr.crawler.service;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.ehr.crawler.model.adapter.AdapterDataSet;
import com.yihu.ehr.crawler.model.config.SysConfig;
import com.yihu.ehr.crawler.model.flow.CrawlerFlowHeadModel;
import com.yihu.ehr.crawler.model.flow.CrawlerFlowModel;
import com.yihu.ehr.crawler.model.patient.Patient;
import com.yihu.ehr.framework.constrant.Constants;
import com.yihu.ehr.framework.util.log.LogService;
import com.yihu.ehr.framework.util.operator.CollectionUtil;
import com.yihu.ehr.framework.util.operator.StringUtil;
import com.yihu.ehr.framework.util.springutil.SpringBeanUtil;
import com.yihu.ehr.standard.model.adapter.AdapterDatasetModel;
import com.yihu.ehr.standard.model.adapter.AdapterSchemeVersionModel;
import com.yihu.ehr.standard.service.adapter.AdapterDatasetService;
import com.yihu.ehr.standard.service.adapter.AdapterSchemeVersionService;
import com.yihu.ehr.standard.service.bo.AdapterVersion;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class CrawlerFlowManager {
    private static volatile CrawlerFlowManager instance;
    private static DataCollectDispatcher dispatch;
    private Map<String, AdapterDataSet> adapterDataSetMap;
    private List<CrawlerFlowHeadModel> crawlerFlowHeadModelList;
    private Map<String, List<CrawlerFlowModel>> crawlerFlowDatasetMap;
    private Map<String, List<CrawlerFlowModel>> crawlerFlowMetadataMap;
    private Boolean adapterFlg;
    private List<Patient> patientList;
    public CrawlerFlowManager() {
        dispatch = DataCollectDispatcher.getInstance();
    }
    public void finalize() throws Throwable {
    }
    public static CrawlerFlowManager getInstance() {
        if (instance == null) {
            synchronized (CrawlerFlowManager.class) {
                if (instance == null) {
                    try {
                        instance = new CrawlerFlowManager();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        return instance;
    }
    public String dataCrawler() {
        Integer count = 0;
        Integer totalCount = 0;
        Map<String, Object> condition = new HashMap<>();
        condition.put("orgCode", SysConfig.getInstance().orgCode);
        patientList = dispatch.getPatientList(condition, adapterDataSetMap);
        if (!CollectionUtil.isEmpty(patientList)) {
            totalCount = patientList.size();
            for (Patient patient : patientList) {
                collectProcess(patient);
            }
        }
        String message = "本次采集病人共" + totalCount + "条,成功采集信息"+ count + "条";
        LogService.getLogger().info(message);
        return message;
    }
    public String collectProcess(Patient patient) {
        SysConfig.getInstance().setOrgCode(patient.getOrgCode());
        String message;
        if (!getDataForPrepare()) {
            message = "适配数据尚未准备";
            LogService.getLogger().error(message);
            return message;
        }
        patient.setReUploadFlg(StringUtil.toString(false));
        LogService.getLogger().trace("采集->注册->打包上传,任务ID：,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
        try {
            /**
             * 获取token
             */
            if (!dispatch.getToken()) {
                message = "token获取失败";
                LogService.getLogger().error(message);
                return message;
            }
            Map<String, JsonNode> dataMap = new HashMap<>();
            for (CrawlerFlowHeadModel crawlerFlowHeadModel : crawlerFlowHeadModelList) {
                /**
                 * 采集信息
                 */
                String datasetCode = crawlerFlowHeadModel.getDatasetCode();
                AdapterDataSet adapterDataSet = adapterDataSetMap.get(datasetCode);
                String data = dispatch.fecthData(patient, adapterDataSet);
                if (StringUtil.isEmpty(data)) {
                    continue;
                }
                ObjectMapper objectMapper = new ObjectMapper();
                JsonNode jsonObject = objectMapper.readTree(data);
                dataMap.put(datasetCode, jsonObject);
                /**
                 * 根据采集流程递归查询
                 */
                getDataByCrawlerFlow(datasetCode, patient, dataMap);
                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()))) {
                            //register
                            dispatch.register(patient, data);
                        }
                    }
                }
            }
            LogService.getLogger().info("采集病人成功,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
            /**
             * 上传档案
             */
            try {
                if (!CollectionUtil.isEmpty(dataMap.keySet())) {
                    if (!dispatch.upload(dataMap, patient, adapterDataSetMap)) {
                        message = "上传档案失败";
                        LogService.getLogger().error(message);
                        return message;
                    }
                }
            } catch (Exception e) {
                message = "上传档案失败";
                LogService.getLogger().error("档案上传失败,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
                return message;
            }
        } catch (Exception e) {
            message = "采集病人失败";
            LogService.getLogger().error("采集病人失败,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo(), e);
            return message;
        }
        return Constants.EMPTY;
    }
    public Boolean getDataByCrawlerFlow(String preDatasetCode, Patient patient, Map<String, JsonNode> dataMap) {
        try {
            JsonNode preData = dataMap.get(preDatasetCode);
            Map<String, String> relationValueMap = new HashMap<>();
            List<CrawlerFlowModel> crawlerFlowDatasetList = crawlerFlowDatasetMap.get(preDatasetCode);
            for (CrawlerFlowModel crawlerFlowDataset : crawlerFlowDatasetList) {
                List<CrawlerFlowModel> crawlerFlowMetadataList = crawlerFlowMetadataMap.get(crawlerFlowDataset.getDatasetCode());
                for (CrawlerFlowModel crawlerFlowMetadata : crawlerFlowMetadataList) {
                    String metadataCode = crawlerFlowMetadata.getMetadataCode();
                    String inputMetadataCode = crawlerFlowMetadata.getInputMetadataCode();
                    relationValueMap.put(metadataCode, preData.get(inputMetadataCode).asText());
                }
                String datasetCode = crawlerFlowDataset.getDatasetCode();
                AdapterDataSet adapterDataSet = adapterDataSetMap.get(datasetCode);
                String data = dispatch.fecthData(patient, adapterDataSet, relationValueMap);
                if (StringUtil.isEmpty(data)) {
                    continue;
                } else {
                    ObjectMapper objectMapper = new ObjectMapper();
                    JsonNode jsonObject = objectMapper.readTree(data);
                    dataMap.put(datasetCode, jsonObject);
                }
                getDataByCrawlerFlow(datasetCode, patient, dataMap);
            }
            return true;
        } catch (Exception e) {
            return false;
        }
    }
    public Boolean getDataForPrepare() {
        if (!adapterFlg) {
            /**
             * 获取适配数据集
             */
            adapterDataSetMap = new HashMap<>();
            AdapterSchemeVersionService adapterSchemeVersionService = SpringBeanUtil.getService(AdapterSchemeVersionService.BEAN_ID);
            AdapterSchemeVersionModel adapterSchemeVersionModel = adapterSchemeVersionService.getEhrAdapterVersionLasted();
            if (adapterSchemeVersionModel == null) {
                return false;
            }
            List<CrawlerDataSetModel> crawlerDataSetModelList = new ArrayList<>();
            List<Integer> datasetIdList = new ArrayList<>();
            for (CrawlerDataSetModel crawlerDataSetModel : crawlerDataSetModelList) {
                datasetIdList.add(crawlerDataSetModel.getDatasetId());
            }
            String version = adapterSchemeVersionModel.getVersion();
            AdapterVersion adapterVersion = new AdapterVersion(version);
            AdapterDatasetService adapterDatasetService = SpringBeanUtil.getService(AdapterDatasetService.BEAN_ID);
            List<AdapterDatasetModel> adapterDataSetModelList = adapterDatasetService.getListByAdapterDatasetIdList(adapterVersion, datasetIdList);
            for (AdapterDatasetModel adapterDatasetModel : adapterDataSetModelList) {
                adapterDataSetMap.put(adapterDatasetModel.getStdDatasetCode(), new AdapterDataSet(adapterDatasetModel, adapterVersion));
            }
            /**
             * 获取采集流程表头
             */
            crawlerFlowHeadModelList = new ArrayList<>();
            List<CrawlerFlowModel> crawlerFlowModelList = new ArrayList<>();
            crawlerFlowDatasetMap = new HashMap<>();
            crawlerFlowMetadataMap = new HashMap<>();
            for (CrawlerFlowModel crawlerFlowModel : crawlerFlowModelList) {
                List<CrawlerFlowModel> datasetList = new ArrayList<>();
                List<CrawlerFlowModel> metadataList = new ArrayList<>();
                String inputDatasetCode = crawlerFlowModel.getInputDatasetCode();
                String datasetCode = crawlerFlowModel.getDatasetCode();
                if (StringUtil.isEmpty(inputDatasetCode)) {
                    continue;
                }
                if (crawlerFlowDatasetMap.containsKey(inputDatasetCode)) {
                    datasetList = crawlerFlowDatasetMap.get(inputDatasetCode);
                }
                datasetList.add(crawlerFlowModel);
                crawlerFlowMetadataMap.put(datasetCode, datasetList);
                if (crawlerFlowDatasetMap.containsKey(datasetCode)) {
                    metadataList = crawlerFlowDatasetMap.get(datasetCode);
                }
                metadataList.add(crawlerFlowModel);
                crawlerFlowDatasetMap.put(datasetCode, metadataList);
            }
        }
        return true;
    }
    /**
     * 解析病人索引信息
     *
     * @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) {
            LogService.getLogger().error("patient参数错误：" + patientInfo, e);
            return null;
        }
    }
    public void setAdapterFlg(Boolean adapterFlg) {
        this.adapterFlg = adapterFlg;
    }
}

Hos-resource/src/main/java/com/yihu/ehr/crawler/service/CrawlerManager.java

@@ -26,9 +26,8 @@ public class CrawlerManager {
    private static volatile CrawlerManager instance;
    private static DataCollectDispatcher dispatch;
    private List<AdapterDataSet> adapterDataSetList;
    private Map<String, AdapterDataSet> adapterDataSetMap;
    private Boolean adapterFlg = false;
    private List<Patient> patientList;
    public CrawlerManager() {
        dispatch = DataCollectDispatcher.getInstance();
    }
@@ -59,7 +58,7 @@ public class CrawlerManager {
        Integer totalCount = 0;
        Map<String, Object> condition = new HashMap<>();
        condition.put("orgCode", SysConfig.getInstance().orgCode);
        patientList = dispatch.getPatientList(condition, adapterDataSetList);
        List<Patient> patientList = dispatch.getPatientList(condition, adapterDataSetMap);
        if (!CollectionUtil.isEmpty(patientList)) {
            totalCount = patientList.size();
            for (Patient patient : patientList) {
@@ -71,10 +70,11 @@ public class CrawlerManager {
        return message;
    }
    //单个病人采集上传
    public String collectProcess(Patient patient) {
        SysConfig.getInstance().setOrgCode(patient.getOrgCode());
        String message;
        if (!getAdapterDataSetList()) {
        if (!getDataForPrepare()) {
            message = "适配数据尚未准备";
            LogService.getLogger().error(message);
            return message;
@@ -82,16 +82,17 @@ public class CrawlerManager {
        patient.setReUploadFlg(StringUtil.toString(false));
        LogService.getLogger().trace("采集->注册->打包上传,任务ID：,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
        try {
            Map<String, AdapterDataSet> dataSetMap = new HashMap<>();
            List<JsonNode> dataList = new ArrayList<>();
            //getToken
            if (!dispatch.getToken()) {
                message = "token获取失败";
                LogService.getLogger().error(message);
                return message;
            }
            for (AdapterDataSet adapterDataSet : adapterDataSetList) {
            Map<String, AdapterDataSet> dataSetMap = new HashMap<>();
            Map<String, JsonNode> dataMap = new HashMap<>();
            for (String key : adapterDataSetMap.keySet()) {
                //collectData
                AdapterDataSet adapterDataSet = adapterDataSetMap.get(key);
                String data = dispatch.fecthData(patient, adapterDataSet);
                if (StringUtil.isEmpty(data)) {
                    continue;
@@ -99,7 +100,7 @@ public class CrawlerManager {
                ObjectMapper objectMapper = new ObjectMapper();
                JsonNode jsonObject = objectMapper.readTree(data);
                dataSetMap.put(adapterDataSet.getAdapterDataSetT().getStdDatasetCode(), adapterDataSet);
                dataList.add(jsonObject);
                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()))) {
@@ -112,8 +113,8 @@ public class CrawlerManager {
            LogService.getLogger().info("采集病人成功,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
            //上传档案
            try {
                if (!CollectionUtil.isEmpty(dataList)) {
                    if (!dispatch.upload(dataList, patient, dataSetMap)) {
                if (!CollectionUtil.isEmpty(dataMap.keySet())) {
                    if (!dispatch.upload(dataMap, patient, dataSetMap)) {
                        message = "上传档案失败";
                        LogService.getLogger().error(message);
                        return message;
@@ -132,9 +133,9 @@ public class CrawlerManager {
        return Constants.EMPTY;
    }
    public Boolean getAdapterDataSetList() {
    public Boolean getDataForPrepare() {
        if (!adapterFlg) {
            adapterDataSetList = new ArrayList<>();
            adapterDataSetMap = new HashMap<>();
            AdapterSchemeVersionService adapterSchemeVersionService = SpringBeanUtil.getService(AdapterSchemeVersionService.BEAN_ID);
            AdapterSchemeVersionModel adapterSchemeVersionModel = adapterSchemeVersionService.getEhrAdapterVersionLasted();
            if (adapterSchemeVersionModel == null) {
@@ -146,9 +147,9 @@ public class CrawlerManager {
            Map<String, String> condition = new HashMap<>();
            condition.put("column", "adapter_dataset_code");
            JSONObject jsonpObject = JSONObject.fromObject(condition);
            List<AdapterDatasetModel> adapterDataSetModelList = adapterDatasetService.getAdapterDatasetNotNullList(AdapterDatasetModel.class, adapterVersion.getDataSetTableName(), jsonpObject.toString());
            List<AdapterDatasetModel> adapterDataSetModelList = adapterDatasetService.getAdapterDatasetNotNullList(adapterVersion, jsonpObject.toString());
            for (AdapterDatasetModel adapterDatasetModel : adapterDataSetModelList) {
                adapterDataSetList.add(new AdapterDataSet(adapterDatasetModel, adapterVersion));
                adapterDataSetMap.put(adapterDatasetModel.getStdDatasetCode(), new AdapterDataSet(adapterDatasetModel, adapterVersion));
            }
            adapterFlg = true;
        }

Hos-resource/src/main/java/com/yihu/ehr/crawler/service/DataCollectDispatcher.java

@@ -58,18 +58,18 @@ public class DataCollectDispatcher {
     * @param condition
     * @return List<PatientT>
     */
    public List<Patient> getPatientList(Map<String, Object> condition, List<AdapterDataSet> adapterDataSetList) {
    public List<Patient> getPatientList(Map<String, Object> condition, Map<String, AdapterDataSet> adapterDataSetMap) {
        ArrayList<Patient> patientList = new ArrayList<>();
        SimpleDateFormat df = new SimpleDateFormat(DateUtil.DEFAULT_YMDHMSDATE_FORMAT);
        for (AdapterDataSet adapterDataSet : adapterDataSetList) {
            PatientIdentity patientIdentity = SysConfig.getInstance().getPatientIdentity(adapterDataSet.getAdapterDataSetT().getStdDatasetCode());
        for (String key : adapterDataSetMap.keySet()) {
            PatientIdentity patientIdentity = SysConfig.getInstance().getPatientIdentity(key);
            if (patientIdentity == null) {
                continue;
            }
            try {
                //获取病人列表字段检验
                Map<String, String> propertyMap = getItemList(adapterDataSet);
                Map<String, String> propertyMap = getItemList(adapterDataSetMap.get(key));
                if (propertyMap == null) {
                    return patientList;
                }
@@ -83,7 +83,7 @@ public class DataCollectDispatcher {
                queryParams.add(new EhrCondition(" < ", patientIdentity.getRefTimeCode(), endTime));
                //Rest 接口请求
                String rootStr = EsbHttp.getPatientList(adapterDataSet, queryParams);
                String rootStr = EsbHttp.getPatientList(adapterDataSetMap.get(key), queryParams);
                if (StringUtil.isEmpty(rootStr)) {
                    return null;
                }
@@ -145,7 +145,89 @@ public class DataCollectDispatcher {
        return propertyMap;
    }
    public String fecthData(Patient patient, AdapterDataSet adapterDataSet, List<EhrCondition> queryParams ) {
        try {
            ObjectMapper mapper = new ObjectMapper();
            ObjectNode paramsNode = mapper.createObjectNode();
            paramsNode.put("tableCode", adapterDataSet.getAdapterDataSetT().getStdDatasetCode());
            paramsNode.put("condition", mapper.writeValueAsString(queryParams));
            List<NameValuePair> formParams = new ArrayList<>();
//            formParams.add(new BasicNameValuePair("secret", secret));
            formParams.add(new BasicNameValuePair("api", "collectionData"));
            formParams.add(new BasicNameValuePair("param", mapper.writeValueAsString(paramsNode)));
            //调用资源服务网关
            String rootStr = EsbHttp.getFecthData(formParams);
            JsonNode resultNode = mapper.readValue(rootStr, JsonNode.class);
            JsonNode result = resultNode.path("detailModelList");
            JsonNode data = matchAdapterData(result, adapterDataSet);
            ObjectNode jsonObject = mapper.createObjectNode();
            if (data != null && data.size() > 0) {
                jsonObject.set("data", data);
                jsonObject.put("code", adapterDataSet.getAdapterDataSetT().getStdDatasetCode());
                jsonObject.put("patient_id", patient.getPatientId());
                jsonObject.put("event_no", patient.getEventNo());
                String agencyCode = patient.getOrgCode();
                jsonObject.put("org_code", agencyCode);
                jsonObject.put("inner_version", "123456");
                jsonObject.put("create_date", DateUtil.toString(new Date(), DateUtil.DEFAULT_YMDHMSDATE_FORMAT));
                jsonObject.put("event_time", patient.getReferenceTime());//DateUtil.toString(patient.getReferenceTime(), DateUtil.DEFAULT_YMDHMSDATE_FORMAT)
                if (StringUtil.isEmpty(patient.getReUploadFlg())) {
                    jsonObject.put("reUploadFlg", LogicValues.LOGIC_FALSE);
                } else {
                    jsonObject.put("reUploadFlg", patient.getReUploadFlg());
                }
                return jsonObject.toString();
            } else {
                return Constants.EMPTY;
            }
        } catch (Exception e) {
            return Constants.EMPTY;
        }
    }
    public String fecthData(Patient patient, AdapterDataSet adapterDataSet, Map<String, String> relationValueMap) {
        List<EhrCondition> queryParams = new ArrayList<>();
        for (String key : relationValueMap.keySet()) {
            queryParams.add(new EhrCondition(" = ", key, relationValueMap.get(key)));
        }
        return fecthData(patient, adapterDataSet, queryParams);
    }
    public String fecthData(Patient patient, AdapterDataSet adapterDataSet) {
        List<EhrCondition> queryParams = new ArrayList<>();
        boolean patientId = true;
        if (adapterDataSet.isHavePatientID()) {
            AdapterMetaData adapterMetaData = adapterDataSet.getAdapterMetaDataMap().get(PatientIdentity.getPatientIDCode());
            queryParams.add(new EhrCondition(" = ", adapterMetaData.getAdapterMetadataModel().getStdMetadataCode(), patient.getPatientId()));
        } else {
            patientId = false;
        }
        boolean eventNo = true;
        if (adapterDataSet.isHaveEventNo()) {
            AdapterMetaData adapterMetaData = adapterDataSet.getAdapterMetaDataMap().get(adapterDataSet.getEventNoCode());
            queryParams.add(new EhrCondition(" = ", adapterMetaData.getAdapterMetadataModel().getStdMetadataCode(), patient.getEventNo()));
        } else {
            eventNo = false;
        }
        if (!patientId && !eventNo) {
            LogService.getLogger().error("采集病人数据集至少需要一项病人标识.数据集名:" + adapterDataSet.getAdapterDataSetT().getStdDatasetCode());
            return Constants.EMPTY;
        }
        return fecthData(patient, adapterDataSet, queryParams);
    }
    /**
     * 根据编排任务进行采集
     * @param patient
     * @param adapterDataSet
     * @return
     */
    public String fecthData1(Patient patient, AdapterDataSet adapterDataSet) {
        try {
            ObjectMapper mapper = new ObjectMapper();
            List<EhrCondition> queryParams = new ArrayList<>();
@@ -236,12 +318,12 @@ public class DataCollectDispatcher {
        return EsbHttp.register(patient, data, token);
    }
    public Boolean upload(List<JsonNode> dataList, Patient patient, Map<String, AdapterDataSet> dataSetMap) {
    public Boolean upload(Map<String, JsonNode> dataMap, Patient patient, Map<String, AdapterDataSet> dataSetMap) {
        Boolean result = true;
        try {
            DataSetTransformer dataTransformer = new DataSetTransformer();
            for (JsonNode data : dataList) {
                dataTransformer.setData(data);
            for (String key : dataMap.keySet()) {
                dataTransformer.setData(dataMap.get(key));
                if (!toFile(dataTransformer, patient, "origin")) {
                    LogService.getLogger().info("存储原始文件失败:patient_id=" + patient.getPatientId()
                            + "event_no=" + patient.getEventNo());

Hos-resource/src/main/java/com/yihu/ehr/standard/controller/StandardController.java

@@ -30,7 +30,7 @@ public class StandardController extends BaseController {
     * @throws Exception
     */
    @RequestMapping("/searchStandard")
    @ApiOperation(value = "获取标准列表", response = DetailModelResult.class, responseContainer = "List", notes = "获取标准列表")
    @ApiOperation(value = "获取标准树列表", response = DetailModelResult.class, responseContainer = "List", notes = "获取标准列表")
    public DetailModelResult searchStandard(
            @ApiParam(name = "condition", value = "查询条件name：厂商、标准、标准版本名称，标准类别type：0为集成标准，1为应用标准")
            @RequestParam(value = "condition", required = false) String condition) {

Hos-resource/src/main/java/com/yihu/ehr/standard/service/adapter/AdapterDatasetService.java

@@ -428,10 +428,10 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        return sql.toString();
    }
    public List getAdapterDatasetNotNullList(Class tClass, String tableName, String condition) {
    public List getAdapterDatasetNotNullList(AdapterVersion adapterVersion, String condition) {
        try {
            StringBuffer sql = new StringBuffer();
            sql.append("SELECT * FROM ").append(tableName);
            sql.append("SELECT * FROM ").append(adapterVersion.getDataSetTableName());
            ObjectMapper objectMapper = new ObjectMapper();
            if (!StringUtil.isEmpty(condition)) {
                JsonNode jsonNode = objectMapper.readTree(condition);
@@ -439,7 +439,23 @@ public class AdapterDatasetService extends SQLGeneralDAO {
                sql.append(" WHERE ").append(column).append(" IS NOT NULL");
            }
            Query query = getCurrentSession().createSQLQuery(sql.toString());
            query.setResultTransformer(new BeanTransformer(tClass));
            query.setResultTransformer(new BeanTransformer(AdapterDatasetModel.class));
            return query.list();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    public List getListByAdapterDatasetIdList(AdapterVersion adapterVersion, List<Integer> datasetIdList) {
        try {
            if (CollectionUtil.isEmpty(datasetIdList)) {
                return null;
            }
            SqlCreator sqlCreator = new SqlCreator(AdapterDatasetModel.class);
            sqlCreator.inCondition("adapterDatasetId", datasetIdList);
            String sql = sqlCreator.selectData(adapterVersion.getDataSetTableName());
            Query query = getQuery(sqlCreator, sql);
            return query.list();
        } catch (Exception e) {
            e.printStackTrace();

Hos-resource/src/main/java/com/yihu/ehr/standard/service/standard/StandardService.java

@@ -362,15 +362,14 @@ public class StandardService extends SQLGeneralDAO {
        for (StandardModel standardModel : standardModelList) {
            idList.add(standardModel.getId());
        }
        if (CollectionUtil.isEmpty(idList)) {
            idList.add(null);
        List<StandardVersionModel> versionModelList = new ArrayList<>();
        if (!CollectionUtil.isEmpty(idList)) {
            String versionHql = "FROM StandardVersionModel WHERE standardId IN :idList";
            Query query = getCurrentSession().createQuery(versionHql);
            query.setParameterList("idList", idList);
            versionModelList = query.list();
        }
        String versionHql = "FROM StandardVersionModel WHERE standardId IN :idList";
        Query query = getCurrentSession().createQuery(versionHql);
        query.setParameterList("idList", idList);
        List<StandardVersionModel> versionModelList = query.list();
        List<StandardResultDetailModel> resultDetailModelList = getStandardListFormat(publisherModelList,
                                                                                        standardModelList,
                                                                                        versionModelList,

Hos-resource/src/main/resources/hbm/resource/CrawlerFlowHead.hbm.xml

@@ -6,13 +6,8 @@
        <composite-id>
            <key-property name="schemeVersionId" column="scheme_version_id"/>
            <key-property name="datasetCode" column="dataset_code"/>
            <key-property name="metadataCode" column="metadata_code"/>
        </composite-id>
        <property name="datasetName">
            <column name="dataset_name"/>
        </property>
        <property name="metadataCode">
            <column name="metadata_code"/>
        </property>
        <property name="identityCode">
            <column name="identity_code"/>
        </property>