Merge branch 'master' of zlf/esb into master

Hos-Framework/src/main/java/com/yihu/ehr/framework/common/dao/SQLGeneralDAO.java

@@ -373,6 +373,19 @@ public class SQLGeneralDAO implements XSQLGeneralDAO {
        return query.list();
    }
    public List getListByIdList(Class tClass, String tableName, String fieldName, List<Integer> idList) {
        SqlCreator sqlCreator = new SqlCreator(tClass);
        try {
            sqlCreator.inCondition(fieldName, idList);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        String sql = sqlCreator.selectData(tableName);
        Query query = getQuery(sqlCreator, sql);
        return query.list();
    }
    public Integer getDataSetInt(Class tClass, String tableName, String condition) {
        SqlCreator sqlCreator = new SqlCreator(tClass);
        ObjectMapper objectMapper = new ObjectMapper();

Hos-Framework/src/main/java/com/yihu/ehr/framework/common/dao/XSQLGeneralDAO.java

@@ -17,6 +17,7 @@ import java.util.Map;
 */
public interface XSQLGeneralDAO {
    public void beginTransaction() throws Exception;
    public void commitTransaction() throws Exception;
    public void saveEntity(Object entity) throws Exception;
@@ -109,10 +110,11 @@ public interface XSQLGeneralDAO {
    /**
     * 获取单列值
     */
    public <T> T scalarBySql(String sql,Class cls) throws Exception;
    public <T> T scalarBySql(String sql, Class cls) throws Exception;
    /**
     * 执行SQL语句
     *
     * @return
     */
    void execute(String sql) throws Exception;
@@ -140,4 +142,6 @@ public interface XSQLGeneralDAO {
    public Integer getMaxId(String tableName);
    public void insertBatch(final List<String> insertSqlList);
}
    public List getListByIdList(Class tClass, String tableName, String fieldName, List<Integer> idList);
}

Hos-resource/pom.xml

@@ -103,7 +103,7 @@
        <dependency>
            <groupId>com.yihu.core</groupId>
            <artifactId>ehr-dbhelper</artifactId>
            <version>1.1.8</version>
            <version>1.1.9</version>
        </dependency>
        <!-- =============WEBSERVICE调用====================-->

Hos-resource/src/main/java/com/yihu/ehr/crawler/controller/CrawlerController.java

@@ -7,7 +7,9 @@ import com.yihu.ehr.framework.model.ActionResult;
import com.yihu.ehr.framework.model.DetailModelResult;
import com.yihu.ehr.framework.model.Result;
import com.yihu.ehr.framework.util.operator.StringUtil;
import com.yihu.ehr.standard.model.adapter.AdapterSchemeVersionModel;
import com.yihu.ehr.standard.service.adapter.AdapterSchemeService;
import com.yihu.ehr.standard.service.adapter.AdapterSchemeVersionService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
@@ -38,8 +40,8 @@ public class CrawlerController {
    @Resource(name = AdapterSchemeService.BEAN_ID)
    private AdapterSchemeService adapterSchemeService;
    /*
       任务编排
    /**
    任务编排
    */
    @RequestMapping("jobLayout")
    public String jobLayout(Model model) {
@@ -79,13 +81,14 @@ public class CrawlerController {
            @ApiParam(name = "patient", value = "病人索引信息", required = true)
            @RequestParam(value = "patient") String patientInfo) {
        Patient patient = CrawlerManager.getInstance().parsePatient(patientInfo);
        CrawlerManager crawlerManager = new CrawlerManager();
        Patient patient = crawlerManager.parsePatient(patientInfo);
        if (patient != null) {
            String message = CrawlerManager.getInstance().collectProcess(patient);
            if (StringUtil.isEmpty(message)) {
            Boolean result = crawlerManager.collectProcess(patient);
            if (result) {
                return Result.success("采集上传成功");
            } else {
                return Result.error(message);
                return Result.error("采集上传失败");
            }
        } else {
            return Result.error("参数转换病人实体失败");

Hos-resource/src/main/java/com/yihu/ehr/crawler/format/AdapterScheme.java

@@ -62,25 +62,4 @@ public class AdapterScheme  extends AdapterBase{
        return getAdapterMetaDataMap().get(dataSetCode);
    }
    public AdapterMetadataModel getAdapterMetaData(AdapterDatasetModel adapterDataSet, String stdMetadataCode) {
        List<AdapterMetadataModel> adapterMetaDataList = getAdapterMetaDatas(adapterDataSet.getStdDatasetCode());
        for (AdapterMetadataModel adapterMetaData : adapterMetaDataList) {
            if (adapterMetaData.getAdapterMetadataCode().equals(stdMetadataCode)) {
                return adapterMetaData;
            }
        }
        return null;
    }
    public AdapterMetaData getAdapterMetaData(String dataSetCode, String metaDataCode) {
        AdapterDatasetModel adapterDataSetT = getAdapterDatasetService().getAdapterDatasetByCode(adapterVersion.getVersion(),dataSetCode);
        AdapterMetadataModel adapterMetaDataT = adapterMetaDataT = getAdapterMetaData(adapterDataSetT, metaDataCode);
        if (adapterMetaDataT == null) {
            return null;
        }
        AdapterMetaData adapterMetaData = new AdapterMetaData(adapterMetaDataT,adapterVersion);
        return adapterMetaData;
    }
}

Hos-resource/src/main/java/com/yihu/ehr/crawler/format/DataSetTransformer.java

@@ -1,23 +1,18 @@
package com.yihu.ehr.crawler.format;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.yihu.ehr.crawler.model.adapter.AdapterDataSet;
import com.yihu.ehr.crawler.model.adapter.AdapterDict;
import com.yihu.ehr.crawler.model.adapter.AdapterMetaData;
import com.yihu.ehr.crawler.model.config.SysConfig;
import com.yihu.ehr.crawler.model.patient.Patient;
import com.yihu.ehr.crawler.model.transform.DictDataType;
import com.yihu.ehr.crawler.model.transform.MetaDataVerify;
import com.yihu.ehr.crawler.model.transform.TransformType;
import com.yihu.ehr.crawler.service.EsbHttp;
import com.yihu.ehr.crawler.service.standard.StdMetaData;
import com.yihu.ehr.dbhelper.jdbc.DBHelper;
import com.yihu.ehr.framework.constrant.Constants;
import com.yihu.ehr.standard.model.adapter.AdapterSchemeVersionModel;
import com.yihu.ehr.standard.model.standard.StdMetaDataModel;
import com.yihu.ehr.framework.util.operator.StringUtil;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
@@ -37,57 +32,48 @@ import java.util.Map;
 * <p>
 * Created by Air on 2015/6/4.
 */
public class DataSetTransformer implements IDataTransformer {
    private ObjectNode jsonObject;
    protected AdapterScheme adapterScheme;
    protected Patient patient;
    public DataSetTransformer(AdapterScheme adapterScheme) {
        this.adapterScheme = adapterScheme;
    }
    @Override
    public Patient getPatient() {
        return patient;
public class DataSetTransformer implements IDataTransformer{
    private JsonNode jsonObject;
    private Patient patient;
    private static DBHelper db;
    public JsonNode getJsonObject() {
        return jsonObject;
    }
    public ObjectNode getJsonObject() {
        return jsonObject;
    public DataSetTransformer() {
        if (db == null) {
            db = new DBHelper();
        }
    }
    @Override
    public boolean transfer() {
    public boolean transfer(Map<String, AdapterDataSet> dataSetMap) {
        if (jsonObject != null) {
            String dataSetCode = jsonObject.get("code").asText();
            ArrayNode jsonArray = (ArrayNode) jsonObject.get("data");
            boolean transfer = transferJson(jsonArray, dataSetCode);
            AdapterDataSet adapterDataSet = dataSetMap.get(dataSetCode);
            boolean transfer = transferJson(jsonArray, adapterDataSet);
            return transfer;
        }
        return false;
    }
    @Override
    public String getData(String orgCode) {
    public String getData() {
        //确保文档有版本信息
        String version = EsbHttp.getRemoteVersion(orgCode);
        jsonObject.put("inner_version", version);//TODO 获取远程版本号
        return jsonObject.asText();
    }
    @Override
    public void setData(String data) {
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            jsonObject = objectMapper.readValue(data, ObjectNode.class);
        } catch (IOException e) {
            //DebugLogger.fatal("", e);
        }
    public void setData(JsonNode data) {
        jsonObject = data;
        setPatient();
    }
    @Override
    public Patient getPatient() {
        return patient;
    }
    public TransformType getTransformType() {
        return TransformType.DATA_SET_JSON;
    }
@@ -104,89 +90,68 @@ public class DataSetTransformer implements IDataTransformer {
     * [{"metadata_code1":"1","metadata_code2":"2"}]}
     *
     * @param jsonArray
     * @param dataSetCode
     * @param adapterDataSet
     * @return
     */
    public boolean transferJson(ArrayNode jsonArray, String dataSetCode) {
    public boolean transferJson(ArrayNode jsonArray, AdapterDataSet adapterDataSet) {
        for (Object objectRow : jsonArray) {
            if (objectRow instanceof JsonNode) {
                transferJsonRow((ObjectNode) objectRow, dataSetCode);
                transferJsonRow((ObjectNode) objectRow, adapterDataSet);
            }
        }
        return false;
    }
    public void transferJsonRow(ObjectNode jsonObject, String dataSetCode) {
    public void transferJsonRow(ObjectNode jsonObject, AdapterDataSet adapterDataSet) {
        Iterator<Map.Entry<String, JsonNode>> fields = jsonObject.fields();
        while (fields.hasNext()) {
            Map.Entry<String, JsonNode> next = fields.next();
            String key = next.getKey();
            JsonNode jsonNode = next.getValue();
            String value = jsonNode.asText();
            String stdValue = transferElem(dataSetCode, key, value);
            String stdValue = transferElem(adapterDataSet, key, value);
            if (jsonNode instanceof JsonNode) {
//                ObjectNode objectNode = (ObjectNode) next;
                jsonObject.put(key, stdValue);
            if (jsonNode instanceof ObjectNode) {
                ObjectNode objectNode = (ObjectNode) next;
                objectNode.put(key, stdValue);
            }
        }
    }
    /**
     * @param dataSetCode 数据集编码
     * @param adapterDataSet 数据集编码
     * @param code        数据元编码
     * @param data        数据
     * @param esbData        数据
     * @return String 标准值
     * @modify 2015.09.16 airhead 增加值与编码转换
     */
    public String transferElem(String dataSetCode, String code, String data) {
        AdapterMetaData adapterMetaData = adapterScheme.getAdapterMetaData(dataSetCode, code);
        if (adapterMetaData == null) {
            //BusinessLogger.fatal("获取数据元适配错误，数据集编码：" + dataSetCode + "数据元编码：" + code);
            return Constants.EMPTY;
        }
    public String transferElem(AdapterDataSet adapterDataSet, String code, String esbData) {
        Map<String, AdapterMetaData> adapterMetaDataMap = adapterDataSet.getAdapterMetaDataMap();
        AdapterMetaData adapterMetaData = adapterMetaDataMap.get(code);
        AdapterDict adapterDict = adapterMetaData.getAdapterDict();
        StdMetaData metaData = adapterMetaData.getStdMetaData();
        if (!adapterDict.isValidAdapterDict()) {
            MetaDataVerify metaDataVerify = new MetaDataVerify(metaData, data);
            boolean check = metaDataVerify.check();
            if (!check) {
                //BusinessLogger.fatal("保存:数据元校验错误." + metaDataVerify.getErrorInfo());
                return Constants.EMPTY;    //未校验成功数据,清空
            }
            return data;
        if (adapterDict == null) {
            return esbData;
        }
        String stdData = Constants.EMPTY;
        DictDataType stdDictDataType = metaData.getDictDataType();
        DictDataType orgDictDataType = adapterMetaData.getAdapterDictDataType();
        if (stdDictDataType == DictDataType.VALUE) {
            if (orgDictDataType == DictDataType.VALUE) {
                stdData = adapterDict.getEhrDictEntryValueByCode(data);
            } else if (orgDictDataType == DictDataType.CODE) {
                String stdDictItemCode = adapterDict.getEhrDictEntryCodeByValue(data);
                stdData = adapterDict.getStdDict().toValue(stdDictItemCode);
            }
        } else if (stdDictDataType == DictDataType.CODE) {
            if (orgDictDataType == DictDataType.VALUE) {
                String stdDictItemValue = adapterDict.getEhrDictEntryValueByCode(data);
                stdData = adapterDict.getStdDict().toCode(stdDictItemValue);
            } else if (orgDictDataType == DictDataType.CODE) {
                stdData = adapterDict.getEhrDictEntryCodeByValue(data);
            }
        String ehrData = null;
        DictDataType adapterDictDataType = adapterMetaData.getAdapterDictDataType();
        if (adapterDictDataType == DictDataType.VALUE) {
            ehrData = adapterDict.getAdapterValueToCodeMap().get(esbData);
        } else if (adapterDictDataType == DictDataType.CODE) {
            ehrData = adapterDict.getAdapterCodeToValueMap().get(esbData);
        }
        return stdData;
        if (StringUtil.isEmpty(ehrData)) {
            return Constants.EMPTY;
        }
        return ehrData;
    }
    /**
     * 根据DataSet信息构造Patient
     */
    private void setPatient() {
        patient=new Patient();
        patient = new Patient();
        patient.setPatientId(jsonObject.get("patient_id").asText());
        patient.setEventNo(jsonObject.get("event_no").asText());
        patient.setOrgCode(jsonObject.get("org_code").asText());

Hos-resource/src/main/java/com/yihu/ehr/crawler/format/DocumentTransformer.java

@@ -1,17 +1,20 @@
package com.yihu.ehr.crawler.format;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.yihu.ehr.crawler.model.adapter.AdapterDataSet;
import com.yihu.ehr.crawler.model.patient.Patient;
import com.yihu.ehr.crawler.model.transform.TransformType;
import java.io.IOException;
import java.util.Map;
/**
 * Created by Administrator on 2015/10/15.
 */
public class DocumentTransformer implements IDataTransformer  {
    private ObjectNode jsonObject;
    private JsonNode jsonObject;
    protected AdapterScheme adapterScheme;
    protected Patient patient;
@@ -29,31 +32,22 @@ public class DocumentTransformer implements IDataTransformer  {
     *
     * @return
     */
    @Override
    public boolean transfer() {
    public boolean transfer(Map<String, AdapterDataSet> dataSetMap) {
        return true;
    }
    public ObjectNode getJsonObject() {
    public JsonNode getJsonObject() {
        return jsonObject;
    }
    @Override
    public String getData(String orgCode) {
    public String getData() {
        return jsonObject.asText();
    }
    @Override
    public void setData(String data) {
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            jsonObject = objectMapper.readValue(data, ObjectNode.class);
        } catch (IOException e) {
            //DebugLogger.fatal("", e);
        }
    public void setData(JsonNode data) {
        jsonObject = data;
    }
    @Override
    public TransformType getTransformType() {
        return TransformType.DOCUMENT;
    }

Hos-resource/src/main/java/com/yihu/ehr/crawler/format/IDataTransformer.java

@@ -1,9 +1,13 @@
package com.yihu.ehr.crawler.format;
import com.fasterxml.jackson.databind.JsonNode;
import com.yihu.ehr.crawler.model.adapter.AdapterDataSet;
import com.yihu.ehr.crawler.model.patient.Patient;
import com.yihu.ehr.crawler.model.transform.TransformType;
import java.util.Map;
/**
 * @author Airhead
 * @version 1.0
@@ -11,11 +15,11 @@ import com.yihu.ehr.crawler.model.transform.TransformType;
 */
public interface IDataTransformer {
    boolean transfer();
    boolean transfer(Map<String, AdapterDataSet> dataSetMap);
    String getData(String orgCode);
    String getData();
    void setData(String data);
    void setData(JsonNode data);
    Patient getPatient();

Hos-resource/src/main/java/com/yihu/ehr/crawler/model/adapter/AdapterDataSet.java

@@ -2,13 +2,19 @@ package com.yihu.ehr.crawler.model.adapter;
import com.yihu.ehr.crawler.model.patient.PatientIdentity;
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.AdapterDictEntryModel;
import com.yihu.ehr.standard.model.adapter.AdapterMetadataModel;
import com.yihu.ehr.standard.model.adapter.AdapterSchemeModel;
import com.yihu.ehr.standard.model.standard.StdMetaDataModel;
import com.yihu.ehr.standard.service.adapter.AdapterMetadataService;
import com.yihu.ehr.standard.service.adapter.AdapterSchemeService;
import com.yihu.ehr.standard.service.bo.AdapterVersion;
import com.yihu.ehr.standard.service.bo.StandardVersion;
import com.yihu.ehr.standard.service.standard.StdMetadataService;
import net.sf.json.JSONObject;
import org.hibernate.criterion.Restrictions;
import java.util.*;
@@ -25,49 +31,58 @@ public class AdapterDataSet {
    private String eventNoCode;
    private AdapterVersion adapterVersion;
    public AdapterDataSet(AdapterDatasetModel adapterDatasetModel, AdapterVersion adapterVersion) {
    public AdapterDataSet(AdapterDatasetModel adapterDatasetModel, AdapterVersion adapterVersion, Map<Integer, List<AdapterDictEntryModel>> entryMap) {
        this.adapterDatasetModel = adapterDatasetModel;
        this.adapterVersion = adapterVersion;
        getAdapterMetaDataList();
        getAdapterMetaDataMap();
        prepareData(entryMap);
    }
    public AdapterDatasetModel getAdapterDataSetT() {
        return adapterDatasetModel;
    }
    public List<AdapterMetaData> getAdapterMetaDataList() {
        if (CollectionUtil.isEmpty(adapterMetaDataList)) {
    public void prepareData(Map<Integer, List<AdapterDictEntryModel>> entryMap) {
        try {
            adapterMetaDataList = new ArrayList<>();
            adapterMetaDataMap = new HashMap<>();
            Map<String, Object> condition = new HashMap<>();
            condition.put("stdDatasetId", adapterDatasetModel.getStdDatasetId());
            condition.put("column", "adapter_metadata_code");
            JSONObject jsonpObject = JSONObject.fromObject(condition);
            AdapterMetadataService metadataService = SpringBeanUtil.getService(AdapterMetadataService.BEAN_ID);
            List<AdapterMetadataModel> adapterMetaDataModelList = metadataService.getList(AdapterMetadataModel.class, adapterVersion.getMetaDataTableName(), jsonpObject.toString(), null, null, null);
            AdapterSchemeService schemeService = SpringBeanUtil.getService(AdapterSchemeService.BEAN_ID);
            List<AdapterMetadataModel> adapterMetaDataModelList = metadataService.getAdapterMetadataNotNullList(adapterVersion, adapterDatasetModel.getStdDatasetId(), jsonpObject.toString());
            String stdVersion = schemeService.getEntity(AdapterSchemeModel.class, adapterDatasetModel.getSchemeId()).getStdVersion();
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            List<Integer> stdMetaDataIdList = new ArrayList<>();
            if (!CollectionUtil.isEmpty(adapterMetaDataModelList)) {
                for (AdapterMetadataModel adapterMetadataModel : adapterMetaDataModelList) {
                    adapterMetaDataList.add(new AdapterMetaData(adapterMetadataModel, adapterVersion));
                    stdMetaDataIdList.add(adapterMetadataModel.getStdMetadataId());
                }
                List<StdMetaDataModel> stdMetaDataModelList = metadataService.getListByIdList(StdMetaDataModel.class, standardVersion.getMetaDataTableName(), "id", stdMetaDataIdList);
                Map<Integer, StdMetaDataModel> stdMetaDataModelMap = new HashMap<>();
                for (StdMetaDataModel stdMetaDataModel : stdMetaDataModelList) {
                    stdMetaDataModelMap.put(stdMetaDataModel.getId(), stdMetaDataModel);
                }
                for (AdapterMetadataModel adapterMetadataModel : adapterMetaDataModelList) {
                    StdMetaDataModel stdMetaDataModel = stdMetaDataModelMap.get(adapterMetadataModel.getStdMetadataId());
                    AdapterMetaData adapterMetaData = new AdapterMetaData(adapterMetadataModel, adapterVersion, entryMap, stdMetaDataModel);
                    adapterMetaDataList.add(adapterMetaData);
                    adapterMetaDataMap.put(adapterMetadataModel.getStdMetadataCode().toUpperCase(), adapterMetaData);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return adapterMetaDataList;
    }
    public Map<String, AdapterMetaData> getAdapterMetaDataMap() {
        if (adapterMetaDataMap == null) {
            adapterMetaDataMap = new HashMap<>();
            if (!CollectionUtil.isEmpty(adapterMetaDataList)) {
                for (AdapterMetaData adapterMetaData : adapterMetaDataList) {
                    adapterMetaDataMap.put(adapterMetaData.getAdapterMetadataModel().getStdMetadataCode().toUpperCase(), adapterMetaData);
                }
            }
        }
        return adapterMetaDataMap;
    }
    public List<AdapterMetaData> getAdapterMetaDataList() {
        return adapterMetaDataList;
    }
    public boolean isHavePatientID() {
        return findPatientIdentity(PatientIdentity.getPatientIDCode());
    }

Hos-resource/src/main/java/com/yihu/ehr/crawler/model/adapter/AdapterDict.java

@@ -2,6 +2,7 @@ package com.yihu.ehr.crawler.model.adapter;
import com.yihu.ehr.crawler.format.AdapterBase;
import com.yihu.ehr.crawler.service.standard.StdDict;
import com.yihu.ehr.framework.constrant.Constants;
import com.yihu.ehr.framework.util.operator.CollectionUtil;
import com.yihu.ehr.framework.util.operator.StringUtil;
import com.yihu.ehr.framework.util.springutil.SpringBeanUtil;
@@ -23,58 +24,55 @@ import java.util.Map;
 */
public class AdapterDict extends AdapterBase {
    public static final String INVALID_ADAPTER_DICT = "";   //"Invalid Adapter";
    private AdapterDictModel adapterDictModel;
    private AdapterVersion adapterVersion;
    private AdapterDictModel adapterDictT;
    public AdapterDict(AdapterDictModel adapterDictModel, AdapterVersion adapterVersion) {
    private Map<String, String> adapterValueToCodeMap;
    private Map<String, String> adapterCodeToValueMap;
    private Map<String, String> stdCodeToValueMap;
    private Map<String, String> stdValueToCodeMap;
    public AdapterDict(AdapterDictModel adapterDictModel, AdapterVersion adapterVersion, Map<Integer, List<AdapterDictEntryModel>> entryMap) {
        this.adapterDictModel = adapterDictModel;
        this.adapterVersion = adapterVersion;
    }
    public AdapterDict(AdapterDictModel adapterDictT) {
        this.adapterDictT = adapterDictT;
        this.adapterDictT = adapterDictModel;
        prepareData(entryMap);
    }
    public Boolean isValidAdapterDict() {
        return adapterDictT != null;
    }
    public String getEhrDictEntryCodeByValue(String esbDictEntryValue) {
        Map<String, Object> condition = new HashMap<>();
        condition.put("stdDictId", adapterDictModel.getStdDictId());
        condition.put("stdEntryValue", esbDictEntryValue);
        JSONObject jsonpObject = JSONObject.fromObject(condition);
        AdapterDictEntryService adapterDictEntryService = SpringBeanUtil.getService(AdapterDictEntryService.BEAN_ID);
        List<AdapterDictEntryModel> adapterDictEntryModelList = adapterDictEntryService.getList(AdapterDictEntryModel.class, adapterVersion.getDictEntryTableName(), jsonpObject.toString(), null, null, null);
        if (!CollectionUtil.isEmpty(adapterDictEntryModelList)) {
            String ehrDictEntryCode = adapterDictEntryModelList.get(0).getAdapterEntryCode();
            if (!StringUtil.isEmpty(ehrDictEntryCode)) {
                return ehrDictEntryCode;
            }
    public void prepareData(Map<Integer, List<AdapterDictEntryModel>> entryMap) {
        adapterValueToCodeMap = new HashMap<>();
        adapterCodeToValueMap = new HashMap<>();
        stdCodeToValueMap = new HashMap<>();
        stdValueToCodeMap = new HashMap<>();
        List<AdapterDictEntryModel> adapterDictEntryModelList = entryMap.get(adapterDictModel.getStdDictId());
        for (AdapterDictEntryModel adapterDictEntryModel : adapterDictEntryModelList) {
            adapterValueToCodeMap.put(adapterDictEntryModel.getStdEntryValue(), adapterDictEntryModel.getAdapterEntryCode());
            adapterCodeToValueMap.put(adapterDictEntryModel.getStdEntryCode(), adapterDictEntryModel.getAdapterEntryValue());
            stdCodeToValueMap.put(adapterDictEntryModel.getStdEntryCode(), adapterDictEntryModel.getStdEntryValue());
            stdValueToCodeMap.put(adapterDictEntryModel.getStdEntryValue(), adapterDictEntryModel.getStdEntryCode());
        }
        return new String(INVALID_ADAPTER_DICT);
    }
    public String getEhrDictEntryValueByCode(String esbDictEntryCode) {
        Map<String, Object> condition = new HashMap<>();
        condition.put("stdDictId", adapterDictModel.getStdDictId());
        condition.put("stdEntryCode", esbDictEntryCode);
        JSONObject jsonpObject = JSONObject.fromObject(condition);
        AdapterDictEntryService adapterDictEntryService = SpringBeanUtil.getService(AdapterDictEntryService.BEAN_ID);
        List<AdapterDictEntryModel> adapterDictEntryModelList = adapterDictEntryService.getList(AdapterDictEntryModel.class, adapterVersion.getDictEntryTableName(), jsonpObject.toString(), null, null, null);
        if (!CollectionUtil.isEmpty(adapterDictEntryModelList)) {
            String ehrDictEntryCode = adapterDictEntryModelList.get(0).getAdapterEntryCode();
            if (!StringUtil.isEmpty(ehrDictEntryCode)) {
                return ehrDictEntryCode;
            }
        }
        return new String(INVALID_ADAPTER_DICT);
    public Map<String, String> getAdapterValueToCodeMap() {
        return adapterValueToCodeMap;
    }
    public StdDict getStdDict(){
        StdDictionaryModel stdDictT = getStdDictService().getAdapterDictByCode(adapterVersion.getVersion(), adapterDictT.getStdDictCode());
        return new StdDict(stdDictT);
    public Map<String, String> getAdapterCodeToValueMap() {
        return adapterCodeToValueMap;
    }
    public Map<String, String> getStdCodeToValueMap() {
        return stdCodeToValueMap;
    }
    public Map<String, String> getStdValueToCodeMap() {
        return stdValueToCodeMap;
    }
//    public StdDict getStdDict(){
//        StdDictionaryModel stdDictT = getStdDictService().getAdapterDictByCode(adapterVersion.getVersion(), adapterDictT.getStdDictCode());
//        return new StdDict(stdDictT);
//    }
}

Hos-resource/src/main/java/com/yihu/ehr/crawler/model/adapter/AdapterMetaData.java

@@ -5,6 +5,7 @@ import com.yihu.ehr.crawler.service.standard.StdMetaData;
import com.yihu.ehr.framework.constrant.ErrorCode;
import com.yihu.ehr.framework.util.operator.NumberUtil;
import com.yihu.ehr.framework.util.springutil.SpringBeanUtil;
import com.yihu.ehr.standard.model.adapter.AdapterDictEntryModel;
import com.yihu.ehr.standard.model.adapter.AdapterDictModel;
import com.yihu.ehr.standard.model.adapter.AdapterMetadataModel;
import com.yihu.ehr.standard.model.standard.StdMetaDataModel;
@@ -14,6 +15,8 @@ import com.yihu.ehr.standard.service.bo.AdapterVersion;
import com.yihu.ehr.standard.service.standard.StdMetadataService;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
/**
 * @author Air
@@ -27,40 +30,32 @@ public class AdapterMetaData {
    private AdapterVersion adapterVersion;
    private StdMetaData stdMetaData;
    @Resource(name=AdapterMetadataService.BEAN_ID)
    private AdapterMetadataService adapterMetadataService;
    @Resource(name=StdMetadataService.BEAN_ID)
    private StdMetadataService stdMetadataService;
    public AdapterMetaData(AdapterMetadataModel adapterMetadataModel, AdapterVersion adapterVersion) {
    public AdapterMetaData(AdapterMetadataModel adapterMetadataModel, AdapterVersion adapterVersion, Map<Integer, List<AdapterDictEntryModel>> entryMap, StdMetaDataModel stdMetaDataModel) {
        this.adapterMetadataModel = adapterMetadataModel;
        this.adapterVersion = adapterVersion;
        this.stdMetaData = new StdMetaData(stdMetaDataModel);
        prepareData(entryMap);
    }
    public AdapterMetadataModel getAdapterMetadataModel() {
        return adapterMetadataModel;
    }
    public AdapterDict getAdapterDict() {
        if (adapterDict == null) {
            if (!NumberUtil.isZero(adapterMetadataModel.getStdDictId())) {
                AdapterDictService adapterDictService = SpringBeanUtil.getService(AdapterDictService.BEAN_ID);
                AdapterDictModel adapterDictModel = (AdapterDictModel) adapterDictService.get(AdapterDictModel.class, adapterVersion.getDictTableName(), adapterMetadataModel.getStdDictId());
                if (adapterDictModel != null) {
                    adapterDict = new AdapterDict(adapterDictModel, adapterVersion);
                }
    public void prepareData(Map<Integer, List<AdapterDictEntryModel>> entryMap) {
        if (!NumberUtil.isZero(adapterMetadataModel.getStdDictId())) {
            AdapterDictService adapterDictService = SpringBeanUtil.getService(AdapterDictService.BEAN_ID);
            AdapterDictModel adapterDictModel = (AdapterDictModel) adapterDictService.get(AdapterDictModel.class, adapterVersion.getDictTableName(), adapterMetadataModel.getStdDictId());
            if (adapterDictModel != null) {
                adapterDict = new AdapterDict(adapterDictModel, adapterVersion, entryMap);
            }
        }
    }
    public AdapterDict getAdapterDict() {
        return adapterDict;
    }
    public StdMetaData getStdMetaData() {
        if (stdMetaData == null) {
            StdMetaDataModel stdMetaDataT = stdMetadataService.getStdMetadata(adapterVersion.getVersion(), adapterMetadataModel.getStdMetadataId());
            stdMetaData = new StdMetaData(stdMetaDataT);
        }
        return stdMetaData;
    }

Hos-resource/src/main/java/com/yihu/ehr/crawler/model/config/SysConfig.java

@@ -32,6 +32,7 @@ public class SysConfig {
        patientIdentityHashMap = new HashMap<>();
        patientIndexMap = new HashMap<>();
        publicKeyMap = new HashMap<>();
        versionMap = new HashMap<>();
        init();
    }
@@ -166,30 +167,4 @@ public class SysConfig {
            }
        }
    }
    private void initPatientIndex(Element rootElement) {
        List queueDataSets = rootElement.element("patient_index").elements("dataset");
        PatientIndex patientIndex = null;
        for (Object obj : queueDataSets) {
            patientIndex = new PatientIndex();
            if (obj instanceof Element) {
                Element element = (Element) obj;
                String dataSetCode = element.attributeValue("code");
                patientIndex.setEventNoCode(element.elementTextTrim("event_no"));
                patientIndex.setRefTimeCode(element.elementTextTrim("ref_time"));
                patientIndex.setOfficeCode(element.elementTextTrim("office_code"));
                patientIndex.setOfficeName(element.elementTextTrim("office_name"));
                if ("HDSC02_09".equals(dataSetCode)) {
                    patientIndex.setLeaveTime(element.elementTextTrim("leave_time"));
                }
                Element diagnostic = element.element("diagnostic");
                patientIndex.setDiagDataSet(diagnostic.attributeValue("dataset"));
                patientIndex.setDiagType(diagnostic.elementTextTrim("type"));
                patientIndex.setDiagCode(diagnostic.elementTextTrim("code"));
                patientIndex.setDiagName(diagnostic.elementTextTrim("name"));
                patientIndexMap.put(dataSetCode, patientIndex);
            }
        }
    }
}//end SysConfig

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

@@ -16,6 +16,7 @@ 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.AdapterDictEntryModel;
import com.yihu.ehr.standard.model.adapter.AdapterSchemeVersionModel;
import com.yihu.ehr.standard.service.adapter.AdapterDatasetService;
import com.yihu.ehr.standard.service.adapter.AdapterSchemeVersionService;
@@ -225,9 +226,26 @@ public class CrawlerFlowManager {
                String version = adapterSchemeVersionModel.getVersion();
                AdapterVersion adapterVersion = new AdapterVersion(version);
                AdapterDatasetService adapterDatasetService = SpringBeanUtil.getService(AdapterDatasetService.BEAN_ID);
                /**
                 * 字典项初始化
                 */
                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);
                }
                /**
                 * 数据集初始化
                 */
                List<AdapterDatasetModel> adapterDataSetModelList = adapterDatasetService.getListByAdapterDatasetIdList(adapterVersion, datasetIdList);
                for (AdapterDatasetModel adapterDatasetModel : adapterDataSetModelList) {
                    adapterDataSetMap.put(adapterDatasetModel.getStdDatasetCode(), new AdapterDataSet(adapterDatasetModel, adapterVersion));
                    adapterDataSetMap.put(adapterDatasetModel.getStdDatasetCode(), new AdapterDataSet(adapterDatasetModel, adapterVersion, adapterDictEntryModelMap));
                }
                /**

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

@@ -3,19 +3,21 @@ 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.adapter.AdapterDictEntry;
import com.yihu.ehr.crawler.model.config.SysConfig;
import com.yihu.ehr.crawler.model.patient.Patient;
import com.yihu.ehr.framework.constrant.Constants;
import com.yihu.ehr.framework.model.DictItem;
import com.yihu.ehr.framework.model.Result;
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.AdapterDictEntryModel;
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 net.sf.json.JSONObject;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
@@ -28,51 +30,44 @@ public class CrawlerManager {
    private static Logger logger = LogManager.getLogger(CrawlerManager.class);
    private static volatile CrawlerManager instance;
    private static DataCollectDispatcher dispatch;
    private static DataCollectDispatcher dispatch = DataCollectDispatcher.getInstance();
    private static Map<String, Map<String, AdapterDataSet>> adapterDataSetVersionMap = new HashMap<>();
    private Map<String, AdapterDataSet> adapterDataSetMap;
    private Boolean adapterFlg = false;
    private String schemeVersion;
    private List<DictItem> datasetList;
    public CrawlerManager(List datasetList, String schemeVersion) {
        this.datasetList = datasetList;
        this.schemeVersion = schemeVersion;
    }
    public CrawlerManager() {
        dispatch = DataCollectDispatcher.getInstance();
    }
    public void finalize() throws Throwable {
    }
    public static CrawlerManager getInstance() {
        if (instance == null) {
            synchronized (CrawlerManager.class) {
                if (instance == null) {
                    try {
                        instance = new CrawlerManager();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        return instance;
    }
    public String dataCrawler(Map<String, Object> condition) {
        Integer count = 0;
        Integer totalCount = 0;
        String message;
        datasetList = (List<DictItem>) condition.get("datasetList");
        /**
         * 适配基本数据准备
         */
        if (!getDataForPrepare()) {
            message = "适配数据尚未准备";
            logger.error(message);
            return message;
        }
        List<Patient> patientList = dispatch.getPatientList(condition, adapterDataSetMap);
        if (!CollectionUtil.isEmpty(patientList)) {
            totalCount = patientList.size();
            for (Patient patient : patientList) {
                collectProcess(patient);
                Boolean result = collectProcess(patient);
                if (result) {
                    count++;
                }
            }
        }
        message = "本次采集病人共" + totalCount + "条,成功采集信息"+ count + "条";
@@ -81,28 +76,24 @@ public class CrawlerManager {
    }
    //单个病人采集上传
    public String collectProcess(Patient patient) {
        String message;
    public Boolean collectProcess(Patient patient) {
        if (!getDataForPrepare()) {
            message = "适配数据尚未准备";
            logger.error(message);
            return message;
            logger.error("适配数据尚未准备");
            return false;
        }
        patient.setReUploadFlg(StringUtil.toString(false));
        logger.trace("采集->注册->打包上传,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
        try {
            //getToken
            if (!dispatch.getToken()) {
                message = "token获取失败";
                logger.error(message);
                return message;
                logger.error("token获取失败");
                return false;
            }
            //getRemoteVersion
            if (!dispatch.getRemoteVersion(patient.getOrgCode())) {
                message = "远程版本获取失败";
                logger.error(message);
                return message;
                logger.error("远程版本获取失败");
                return false;
            }
            Map<String, AdapterDataSet> dataSetMap = new HashMap<>();
@@ -111,6 +102,7 @@ public class CrawlerManager {
                /**
                 * 获取数据
                 */
                logger.info("获取病人档案数据");
                AdapterDataSet adapterDataSet = adapterDataSetMap.get(key);
                String data = dispatch.fecthData(patient, adapterDataSet);
                if (StringUtil.isEmpty(data)) {
@@ -120,10 +112,13 @@ public class CrawlerManager {
                JsonNode jsonObject = objectMapper.readTree(data);
                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()))) {
                            //register
                            logger.info("注册病人");
                            dispatch.register(patient, data);
                        }
                    }
@@ -131,62 +126,90 @@ public class CrawlerManager {
            }
            logger.info("采集病人成功,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
            //上传档案
            logger.info("上传病人档案");
            try {
                if (!CollectionUtil.isEmpty(dataMap.keySet())) {
                    if (!dispatch.upload(dataMap, patient, dataSetMap)) {
                        message = "上传档案失败";
                        logger.error(message);
                        return message;
                        logger.error("上传档案失败");
                        return false;
                    }
                }
            } catch (Exception e) {
                message = "上传档案失败";
                logger.error("档案上传失败,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo());
                return message;
                return false;
            }
        } catch (Exception e) {
            message = "采集病人失败";
            logger.error("采集病人失败,patient_id:" + patient.getPatientId() + ", event_no:" + patient.getEventNo(), e);
            return message;
            return false;
        }
        return Constants.EMPTY;
        return true;
    }
    public Boolean getDataForPrepare() {
        if (!adapterFlg) {
            try {
                adapterDataSetMap = new HashMap<>();
        logger.info("适配基本相关数据准备");
        if (adapterFlg) {
            return true;
        }
        try {
            adapterDataSetMap = new HashMap<>();
            AdapterVersion adapterVersion = null;
            AdapterDatasetService adapterDatasetService = SpringBeanUtil.getService(AdapterDatasetService.BEAN_ID);
            List<AdapterDatasetModel> adapterDataSetModelList = new ArrayList<>();
            if (!CollectionUtil.isEmpty(datasetList)) {
                /**
                 * 拉模式接口调用，由任务配置决定适配版本
                 */
                adapterVersion = new AdapterVersion(schemeVersion);
                List<Integer> datasetIdList = new ArrayList<>();
                for (DictItem dictItem : datasetList) {
                    datasetIdList.add(Integer.parseInt(dictItem.getCode()));
                }
                adapterDataSetModelList = adapterDatasetService.getAdapterDatasetByAdapterIdList(adapterVersion, datasetIdList);
            } else {
                /**
                 * 推模式接口调用，默认只使用最新版本的适配
                 */
                AdapterSchemeVersionService adapterSchemeVersionService = SpringBeanUtil.getService(AdapterSchemeVersionService.BEAN_ID);
                AdapterSchemeVersionModel adapterSchemeVersionModel = adapterSchemeVersionService.getEhrAdapterVersionLasted();
                if (adapterSchemeVersionModel == null) {
                    logger.error("获取最新ehr适配版本错误");
                    return false;
                } else {
                    this.schemeVersion = adapterSchemeVersionModel.getVersion();
                    adapterVersion = new AdapterVersion(schemeVersion);
                }
                String version = adapterSchemeVersionModel.getVersion();
                AdapterVersion adapterVersion = new AdapterVersion(version);
                AdapterDatasetService adapterDatasetService = SpringBeanUtil.getService(AdapterDatasetService.BEAN_ID);
                Map<String, String> condition = new HashMap<>();
                condition.put("column", "adapter_dataset_code");
                JSONObject jsonpObject = JSONObject.fromObject(condition);
                List<AdapterDatasetModel> adapterDataSetModelList = adapterDatasetService.getAdapterDatasetNotNullList(adapterVersion, jsonpObject.toString());
                List<Integer> datasetIdList = new ArrayList<>();
                if (!CollectionUtil.isEmpty(datasetList)) {
                    for (DictItem dictItem : datasetList) {
                        datasetIdList.add(Integer.parseInt(dictItem.getCode()));
                    }
                if (adapterDataSetVersionMap.get(schemeVersion) != null) {
                    adapterDataSetMap = adapterDataSetVersionMap.get(schemeVersion);
                    adapterFlg = true;
                    return true;
                }
            }
                for (AdapterDatasetModel adapterDatasetModel : adapterDataSetModelList) {
                    if (CollectionUtil.isEmpty(datasetIdList) || datasetIdList.contains(adapterDatasetModel.getAdapterDatasetId())) {
                        adapterDataSetMap.put(adapterDatasetModel.getStdDatasetCode(), new AdapterDataSet(adapterDatasetModel, adapterVersion));
                    }
            /**
             * 字典项初始化
             */
            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<>();
                }
                SysConfig.getInstance().setVersionMap(new HashMap<>());
                adapterFlg = true;
            } catch (Exception e) {
                adapterFlg = false;
                entryModelList.add(adapterDictEntryModel);
                adapterDictEntryModelMap.put(adapterDictEntryModel.getStdDictId(), entryModelList);
            }
            /**
             * 数据集初始化
             */
            for (AdapterDatasetModel adapterDatasetModel : adapterDataSetModelList) {
                adapterDataSetMap.put(adapterDatasetModel.getStdDatasetCode(), new AdapterDataSet(adapterDatasetModel, adapterVersion, adapterDictEntryModelMap));
            }
            adapterDataSetVersionMap.put(schemeVersion, adapterDataSetMap);
            adapterFlg = true;
            return true;
        } catch (Exception e) {
            return false;
        }
        return adapterFlg;
    }
    /**
@@ -206,7 +229,11 @@ public class CrawlerManager {
        }
    }
    public void setAdapterFlg(Boolean adapterFlg) {
        this.adapterFlg = adapterFlg;
    public void setSchemeVersion(String schemeVersion) {
        this.schemeVersion = schemeVersion;
    }
    public void setDatasetList(List<DictItem> datasetList) {
        this.datasetList = datasetList;
    }
}

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

@@ -4,6 +4,7 @@ import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.yihu.ehr.crawler.format.DataSetTransformer;
import com.yihu.ehr.crawler.model.adapter.AdapterDataSet;
import com.yihu.ehr.crawler.model.adapter.AdapterMetaData;
import com.yihu.ehr.crawler.model.config.SysConfig;
@@ -292,16 +293,17 @@ public class DataCollectDispatcher {
    public JsonNode matchAdapterData(JsonNode data, AdapterDataSet adapterDataSet) {
        ObjectMapper mapper = new ObjectMapper();
        ArrayNode result = mapper.createArrayNode();
        List<AdapterMetaData> metaDatas = adapterDataSet.getAdapterMetaDataList();
        Iterator<JsonNode> array = data.iterator();
        while (array.hasNext()) {
            JsonNode dataNode = array.next();
            ObjectNode jsonNode = mapper.createObjectNode();
            for (AdapterMetaData adapterMetaData : metaDatas) {
            for (AdapterMetaData adapterMetaData : adapterDataSet.getAdapterMetaDataList()) {
                AdapterMetadataModel adapterMetadataModel = adapterMetaData.getAdapterMetadataModel();
                String orgMetaDataCode = adapterMetadataModel.getAdapterMetadataCode();
                String stdMetaDataCode = adapterMetadataModel.getStdMetadataCode();
                jsonNode.put(orgMetaDataCode, dataNode.path(stdMetaDataCode).asText());
                if (!StringUtil.isEmpty(orgMetaDataCode)) {
                    jsonNode.put(orgMetaDataCode, dataNode.path(stdMetaDataCode).asText());
                }
            }
            result.add(jsonNode);
        }

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

@@ -1,149 +0,0 @@
package com.yihu.ehr.crawler.service;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.yihu.ehr.crawler.model.adapter.AdapterDataSet;
import com.yihu.ehr.crawler.model.adapter.AdapterDict;
import com.yihu.ehr.crawler.model.adapter.AdapterMetaData;
import com.yihu.ehr.crawler.model.patient.Patient;
import com.yihu.ehr.crawler.model.transform.DictDataType;
import com.yihu.ehr.crawler.model.transform.TransformType;
import com.yihu.ehr.dbhelper.jdbc.DBHelper;
import java.util.Iterator;
import java.util.Map;
/**
 * 目前只处理json格式
 * <p>
 * json 格式
 * {
 * "inner_version":"xxxxx",
 * "patient_id":"xxxx",
 * "event_no":"xxxx",
 * "code":"dataset_code",
 * "org_code":"xxxx"
 * "data":
 * [{"metadata_code1":"5","metadata_code2":"6"},
 * [{"metadata_code1":"1","metadata_code2":"2"}]}
 * <p>
 * Created by Air on 2015/6/4.
 */
public class DataSetTransformer {
    private JsonNode jsonObject;
    private Patient patient;
    private static DBHelper db;
    public JsonNode getJsonObject() {
        return jsonObject;
    }
    public DataSetTransformer() {
        if (db == null) {
            db = new DBHelper();
        }
    }
    public boolean transfer(Map<String, AdapterDataSet> dataSetMap) {
        if (jsonObject != null) {
            String dataSetCode = jsonObject.get("code").asText();
            ArrayNode jsonArray = (ArrayNode) jsonObject.get("data");
            AdapterDataSet adapterDataSet = dataSetMap.get(dataSetCode);
            boolean transfer = transferJson(jsonArray, adapterDataSet);
            return transfer;
        }
        return false;
    }
    public String getData() {
        //确保文档有版本信息
        return jsonObject.asText();
    }
    public void setData(JsonNode data) {
        jsonObject = data;
        setPatient();
    }
    public TransformType getTransformType() {
        return TransformType.DATA_SET_JSON;
    }
    /**
     * json 格式
     * {
     * "inner_version":"xxxxx",
     * "patient_id":"xxxx",
     * "event_no":"xxxx",
     * "code":"dataset_code",
     * "data":
     * [{"metadata_code1":"5","metadata_code2":"6"},
     * [{"metadata_code1":"1","metadata_code2":"2"}]}
     *
     * @param jsonArray
     * @param adapterDataSet
     * @return
     */
    public boolean transferJson(ArrayNode jsonArray, AdapterDataSet adapterDataSet) {
        for (Object objectRow : jsonArray) {
            if (objectRow instanceof JsonNode) {
                transferJsonRow((ObjectNode) objectRow, adapterDataSet);
            }
        }
        return false;
    }
    public void transferJsonRow(ObjectNode jsonObject, AdapterDataSet adapterDataSet) {
        Iterator<Map.Entry<String, JsonNode>> fields = jsonObject.fields();
        while (fields.hasNext()) {
            Map.Entry<String, JsonNode> next = fields.next();
            String key = next.getKey();
            JsonNode jsonNode = next.getValue();
            String value = jsonNode.asText();
            String stdValue = transferElem(adapterDataSet, key, value);
            if (jsonNode instanceof ObjectNode) {
                ObjectNode objectNode = (ObjectNode) next;
                objectNode.put(key, stdValue);
            }
        }
    }
    /**
     * @param adapterDataSet 数据集编码
     * @param code        数据元编码
     * @param esbData        数据
     * @return String 标准值
     * @modify 2015.09.16 airhead 增加值与编码转换
     */
    public String transferElem(AdapterDataSet adapterDataSet, String code, String esbData) {
        Map<String, AdapterMetaData> adapterMetaDataMap = adapterDataSet.getAdapterMetaDataMap();
        AdapterMetaData adapterMetaData = adapterMetaDataMap.get(code);
        AdapterDict adapterDict = adapterMetaData.getAdapterDict();
        if (adapterDict == null) {
            return esbData;
        }
        String ehrData = null;
        DictDataType adapterDictDataType = adapterMetaData.getAdapterDictDataType();
        if (adapterDictDataType == DictDataType.VALUE) {
            ehrData = adapterDict.getEhrDictEntryCodeByValue(esbData);
        } else if (adapterDictDataType == DictDataType.CODE) {
            ehrData = adapterDict.getEhrDictEntryValueByCode(esbData);
        }
        return ehrData;
    }
    /**
     * 根据DataSet信息构造Patient
     */
    private void setPatient() {
        patient = new Patient();
        patient.setPatientId(jsonObject.get("patient_id").asText());
        patient.setEventNo(jsonObject.get("event_no").asText());
        patient.setOrgCode(jsonObject.get("org_code").asText());
    }
}

Hos-resource/src/main/java/com/yihu/ehr/crawler/storage/DocumentStorage.java

@@ -45,7 +45,7 @@ public class DocumentStorage extends MongodbStorage {
    @Override
    public boolean save(IDataTransformer dataTransformer) {
        DocumentTransformer documentTransformer = (DocumentTransformer) dataTransformer;
        ObjectNode jsonObject = documentTransformer.getJsonObject();
        JsonNode jsonObject = documentTransformer.getJsonObject();
        if (jsonObject != null) {
            String dataSetCode = jsonObject.get(getKey()).asText();

Hos-resource/src/main/java/com/yihu/ehr/crawler/storage/MongodbStorage.java

@@ -65,7 +65,7 @@ public class MongodbStorage implements IDataStorage {
    @Override
    public boolean save(IDataTransformer dataTransformer) {
        DataSetTransformer dataSetTransformer = (DataSetTransformer) dataTransformer;
        ObjectNode jsonObject = dataSetTransformer.getJsonObject();
        ObjectNode jsonObject = (ObjectNode) dataSetTransformer.getJsonObject();
        if (jsonObject != null) {
            String dataSetCode = jsonObject.get(getKey()).asText();

Hos-resource/src/main/java/com/yihu/ehr/datacollect/service/DatacollectService.java

@@ -3,7 +3,10 @@ package com.yihu.ehr.datacollect.service;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.mongodb.client.MongoCollection;
import com.yihu.ehr.common.Services;
import com.yihu.ehr.crawler.model.config.SysConfig;
import com.yihu.ehr.crawler.model.patient.PatientIdentity;
import com.yihu.ehr.datacollect.dao.intf.IDatacollectDao;
import com.yihu.ehr.datacollect.dao.intf.IDatacollectLogDao;
import com.yihu.ehr.datacollect.model.*;
@@ -13,12 +16,15 @@ import com.yihu.ehr.dbhelper.common.QueryCondition;
import com.yihu.ehr.dbhelper.common.enums.DBType;
import com.yihu.ehr.dbhelper.common.sqlparser.*;
import com.yihu.ehr.dbhelper.jdbc.DBHelper;
import com.yihu.ehr.dbhelper.mongodb.MongodbFactory;
import com.yihu.ehr.dbhelper.mongodb.MongodbHelper;
import com.yihu.ehr.framework.constrant.Constants;
import com.yihu.ehr.framework.constrant.DateConvert;
import com.yihu.ehr.framework.model.ActionResult;
import com.yihu.ehr.framework.util.httpclient.HttpHelper;
import com.yihu.ehr.framework.util.httpclient.HttpResponse;
import com.yihu.ehr.framework.util.log.LogService;
import com.yihu.ehr.framework.util.operator.CollectionUtil;
import com.yihu.ehr.framework.util.webservice.WebserviceUtil;
import com.yihu.ehr.resource.service.IStdService;
import org.apache.axis.client.Call;
@@ -254,7 +260,17 @@ public class DatacollectService implements IDatacollectService {
     */
    private String intoMongodb(List<JSONObject> list,String schemeVersion,String stdDatasetCode,JSONArray colList)
    {
        String patientIdCode = Constants.PATIENT_ID.toUpperCase();
        String eventNoCode = Constants.EVENT_NO.toUpperCase();
        PatientIdentity patientIdentity = SysConfig.getInstance().getPatientIdentity(stdDatasetCode);
        if (patientIdentity != null) {
            patientIdCode = patientIdentity.getPatientIDCode();
            eventNoCode = patientIdentity.getEventNoCode();
        }
        try{
            if(!mongo.createIndex(stdDatasetCode, "patientIndex", patientIdCode, eventNoCode)) {
                return "Mongodb索引创建失败！（表："+stdDatasetCode+"）";
            }
            if(list!=null && list.size()>0)
            {
                //字典转换

Hos-resource/src/main/java/com/yihu/ehr/job/service/ArchiveUploadJob.java

@@ -25,8 +25,7 @@ public class ArchiveUploadJob implements IBaseJob {
    @Override
    public void execute(String jobId) throws Exception{
        System.out.println("档案上传quartz:"+DateConvert.toString(new Date()) + ",jobId:"+jobId);
        logger.info("档案上传quartz:"+DateConvert.toString(new Date()) + ":"+jobId);
        logger.info("档案采集上传开始:"+DateConvert.toString(new Date()) + ":"+jobId);
        IDatacollectManager datacollect = SpringBeanUtil.getService(Services.Datacollect);
        RsJobConfig job = datacollect.getJobById(jobId);
        Map<String, Object> condition = new HashMap<>();
@@ -46,14 +45,14 @@ public class ArchiveUploadJob implements IBaseJob {
        condition.put("endDate", end);
        DataGridResult result = datacollect.getJobDatasetByJobId(jobId);
        condition.put("datasetList", result.getDetailModelList());
        CrawlerManager.getInstance().dataCrawler(condition);
        CrawlerManager crawlerManager = new CrawlerManager(result.getDetailModelList(), job.getSchemeVersion());
        crawlerManager.dataCrawler(condition);
        if (!job.getJobType().equals("0")) {
            job.setRepeatStartTime(end);
            job.setRepeatEndTime(DateUtil.formatYMDToYMDHMS(DateUtil.getSysDateTime().toString()));
        }
        datacollect.updateJob(job);
        logger.info("档案采集上传结束:"+DateConvert.toString(new Date()) + ":"+jobId);
        return;
    }
}

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

@@ -479,4 +479,20 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        }
    }
    public List<AdapterDatasetModel> getAdapterDatasetByAdapterIdList(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();
            return null;
        }
    }
}

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

@@ -4,12 +4,14 @@ package com.yihu.ehr.standard.service.adapter;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.ehr.framework.common.dao.SQLGeneralDAO;
import com.yihu.ehr.framework.constrant.Constants;
import com.yihu.ehr.framework.constrant.ErrorCode;
import com.yihu.ehr.framework.exception.ApiException;
import com.yihu.ehr.framework.model.DetailModelResult;
import com.yihu.ehr.framework.model.Result;
import com.yihu.ehr.framework.util.operator.CollectionUtil;
import com.yihu.ehr.framework.util.operator.StringUtil;
import com.yihu.ehr.framework.util.sql.BeanTransformer;
import com.yihu.ehr.framework.util.sql.SqlCreator;
import com.yihu.ehr.standard.model.adapter.AdapterDatasetModel;
import com.yihu.ehr.standard.model.adapter.AdapterMetadataModel;
@@ -409,4 +411,23 @@ public class AdapterMetadataService extends SQLGeneralDAO {
        }
    }
    public List getAdapterMetadataNotNullList(AdapterVersion adapterVersion, Integer stdDatasetId, String condition) {
        try {
            StringBuffer sql = new StringBuffer();
            sql.append("SELECT * FROM ").append(adapterVersion.getMetaDataTableName());
            ObjectMapper objectMapper = new ObjectMapper();
            if (!StringUtil.isEmpty(condition)) {
                JsonNode jsonNode = objectMapper.readTree(condition);
                String column = jsonNode.get("column").asText();
                sql.append(" WHERE std_dataset_id = " + stdDatasetId + Constants.AND);
                sql.append(column).append(" IS NOT NULL");
            }
            Query query = getCurrentSession().createSQLQuery(sql.toString());
            query.setResultTransformer(new BeanTransformer(AdapterMetadataModel.class));
            return query.list();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

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

@@ -108,22 +108,6 @@ public class AdapterSchemeVersionService extends SQLGeneralDAO {
    }
    public Result publish(String version) {
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            AdapterSchemeVersionModel versionModel = objectMapper.readValue(version, AdapterSchemeVersionModel.class);
            List<AdapterSchemeModel> adapterSchemeModelList = getEhrAdapterSchemeList();
            if (!CollectionUtil.isEmpty(adapterSchemeModelList)) {
                List<Integer> schemeIdList = new ArrayList<>();
                for (AdapterSchemeModel adapterSchemeModel : adapterSchemeModelList) {
                    schemeIdList.add(adapterSchemeModel.getId());
                }
                if (schemeIdList.contains(versionModel.getSchemeId())) {
                    CrawlerManager.getInstance().setAdapterFlg(false);
                }
            }
        } catch (Exception e) {
            return Result.error("修改适配方案版本失败");
        }
        return update(version);
    }
@@ -231,16 +215,6 @@ public class AdapterSchemeVersionService extends SQLGeneralDAO {
        try {
            AdapterSchemeVersionModel adapterSchemeVersionModel = getEntity(AdapterSchemeVersionModel.class, versionId);
            //TODO:generate standard version file;
            List<AdapterSchemeModel> adapterSchemeModelList = getEhrAdapterSchemeList();
            if (!CollectionUtil.isEmpty(adapterSchemeModelList)) {
                List<Integer> schemeIdList = new ArrayList<>();
                for (AdapterSchemeModel adapterSchemeModel : adapterSchemeModelList) {
                    schemeIdList.add(adapterSchemeModel.getId());
                }
                if (schemeIdList.contains(adapterSchemeVersionModel.getSchemeId())) {
                    CrawlerManager.getInstance().setAdapterFlg(false);
                }
            }
            adapterSchemeVersionModel.setPublishTime(new Date());
            adapterSchemeVersionModel.setPublishUser(publisher);
            adapterSchemeVersionModel.setPublishStatus(1);

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

@@ -410,15 +410,5 @@ public class StdMetadataService extends SQLGeneralDAO {
        }
    }
    public StdMetaDataModel getStdMetadata(String version, Integer stdMetadataId) {
        try {
            SqlCreator sqlCreator = new SqlCreator(AdapterMetadataModel.class);
            sqlCreator.equalCondition("id", stdMetadataId);
            String sql = sqlCreator.selectData("std_metadata_" + version);
            Query query = getQuery(sqlCreator, sql);
            return (StdMetaDataModel) query.uniqueResult();
        } catch (Exception e) {
            return null;
        }
    }
}