svr-pack-resolve/src/main/java/com/yihu/ehr/resolve/SimplePackageResolver.java

package com.yihu.ehr.resolve;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.yihu.ehr.profile.exception.IllegalJsonDataException;
import com.yihu.ehr.profile.exception.IllegalJsonFileException;
import com.yihu.ehr.profile.exception.LegacyPackageException;
import com.yihu.ehr.profile.model.MetaDataRecord;
import com.yihu.ehr.profile.model.PackageDataSet;
import com.yihu.ehr.resolve.config.EventIndexConfig;
import com.yihu.ehr.resolve.dao.DataSetPackageDao;
import com.yihu.ehr.resolve.log.PackResolveLogger;
import com.yihu.ehr.resolve.model.stage1.OriginalPackage;
import com.yihu.ehr.resolve.model.stage1.SimplePackage;
import com.yihu.ehr.util.datetime.DateTimeUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

import java.io.File;
import java.io.IOException;
import java.text.ParseException;
import java.util.*;

/**
 * 数据集（非档案类型）档案包解析器.
 *
 * @author 张进军
 * @created 2017.06.27 11:28
 */
@Component
public class SimplePackageResolver extends PackageResolver {

    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Autowired
    private EventIndexConfig eventIndex;
    @Autowired
    private DataSetPackageDao dataSetPackageDao;

    @Override
    public void resolve(OriginalPackage originalPackage, File root) throws Exception {
        File originFolder = new File(root.getAbsolutePath());
        this.parseFiles((SimplePackage) originalPackage, originFolder.listFiles());
    }

    /**
     * 解析 .json 文件中的 JSON 数据，拼接成SQL语句
     * @param simplePackage
     * @param files
     * @throws IOException
     * @throws ParseException
     */
    private void parseFiles(SimplePackage simplePackage, File[] files) throws IOException, ParseException {
        List<String> sqlList = new ArrayList<>();
        for (File file : files) {
            // head 节点
            JsonNode headNode = objectMapper.readTree(file).get("head");
            String transactionId = headNode.get("id").asText();
            String orgCode = headNode.get("orgCode").asText();
            String version = headNode.get("version").asText();
            String sourceTable = headNode.get("source").asText();
            String targetTable = headNode.get("target").asText();
            String createTime = headNode.get("createTime").asText();
            // data 节点
            JsonNode dataNode = objectMapper.readTree(file).get("data");
            String tableName = dataNode.get("table").get("name").asText();
            String[] pkArr = dataNode.get("table").get("pk").asText().split(",");
            // columns 节点
            JsonNode columnsNode = dataNode.get("columns");
            // rows 节点
            JsonNode rowsNode = dataNode.get("rows");

            // 判断标准版本是否存在。
            String isExistVersionSql = "SELECT 1 FROM std_cda_versions WHERE version = '" + version + "'";
            if (jdbcTemplate.queryForList(isExistVersionSql).size() == 0) {
                throw new IllegalJsonDataException("标准版本号不存在，version: " + version);
            }
            // 判断表是否存在。
            String isExistTableSql = "SELECT 1 FROM std_data_set_" + version + " WHERE code = '" + tableName + "'";
            if (jdbcTemplate.queryForList(isExistTableSql).size() == 0) {
                throw new IllegalJsonDataException("标准中不存在该表，version: " + version + ", table: " + tableName);
            }

            // 拼接 insert/update 语句，后续批量执行保存数据。
            for (int i = 0, length = rowsNode.size(); i < length; i++) {
                JsonNode rowNode = rowsNode.get(i);

                // 用于记录日志：日志JSON结构中的data子节点。
                ObjectNode logDataNode = objectMapper.createObjectNode();
                ObjectNode logDataTargetIdNode = objectMapper.createObjectNode();
                logDataNode.put("transactionId", transactionId);
                logDataNode.put("target", targetTable);
                logDataNode.set("source_id", rowNode.get("_id"));

                // 判断是 insert，还是 update。
                StringBuffer hasRecordSql = new StringBuffer(" SELECT 1 FROM " + tableName + " WHERE ");
                for (String pk : pkArr) {
                    String pkValue = rowNode.get(pk).asText();
                    hasRecordSql.append(pk + " = '" + pkValue + "' AND ");
                    logDataTargetIdNode.put(pk, pkValue);
                }

                logDataNode.set("target_id", logDataTargetIdNode);
                PackResolveLogger.info(logDataNode.toString());

                int hasRecordSqlLen = hasRecordSql.length();
                hasRecordSql.delete(hasRecordSqlLen - 4, hasRecordSqlLen);
                boolean isInsert = jdbcTemplate.queryForList(hasRecordSql.toString()).size() == 0 ? true : false;

                StringBuffer sql = new StringBuffer();
                if (isInsert) {
                    sql.append(" INSERT INTO " + tableName + " SET ");
                } else {
                    sql.append(" UPDATE " + tableName + " SET ");
                }
                for (JsonNode column : columnsNode) {
                    if (rowNode == null){
                        System.out.println("/////////");
                    }
                    String fieldName = column.get("column")== null ? "": column.get("column").asText();
                    String fieldValue = rowNode.get(fieldName)== null ? "" : rowNode.get(fieldName).asText();

                    // 判断表字段是否存在。
                    String fieldSql = "SELECT f.column_type AS column_type FROM std_meta_data_" + version + " f  " +
                            "LEFT JOIN std_data_set_" + version + " t ON t.id = f.dataset_id " +
                            "WHERE t.code = '" + tableName + "' AND f.column_name = '" + fieldName + "'";
                    if (jdbcTemplate.queryForList(fieldSql).size() == 0) {
                        throw new IllegalJsonDataException("标准中不存在该表字段的字段类型，version: " + version + ", table: " + tableName + ", field: " + fieldName);
                    }

                    // 判断字段类型
                    String columnType = jdbcTemplate.queryForMap(fieldSql).get("column_type").toString().toUpperCase();
                    if (columnType.contains("VARCHAR")) {
                        sql.append(fieldName + " = '" + fieldValue + "', ");
                    } else if (columnType.equals("TINYINT") || columnType.contains("NUMBER")) {
                        sql.append(fieldName + " = " + fieldValue + ", ");
                    } else if (columnType.equals("DATE")) {
                        sql.append(fieldName + " = '" + DateTimeUtil.simpleDateFormat(DateTimeUtil.simpleDateParse(fieldValue)) + "', ");
                    } else if (columnType.equals("DATETIME")) {
                        sql.append(fieldName + " = '" + DateTimeUtil.simpleDateTimeFormat(DateTimeUtil.utcDateTimeParse(fieldValue)) + "', ");
                    }
                }
                sql.deleteCharAt(sql.lastIndexOf(","));
                if (!isInsert) {
                    sql.append(" WHERE ");
                    for (String pk : pkArr) {
                        sql.append(pk + " = '" + rowNode.get(pk).asText() + "' AND ");
                    }
                    int sqlLen = sql.length();
                    sql.delete(sqlLen - 4, sqlLen);
                }
                sql.append(";");

                sqlList.add(sql.toString());
            }

            simplePackage.setOrgCode(orgCode);
            simplePackage.setCreateDate(DateTimeUtil.utcDateTimeParse(createTime));
        }
        simplePackage.setSqlList(sqlList);
        dataSetPackageDao.saveDataset(simplePackage);//执行sql操作
    }

    /**
     * 生产数据集
     *
     * @param jsonFile
     * @param isOrigin
     * @return
     * @throws IOException
     */
    private List<PackageDataSet> generateDataSet(File jsonFile, boolean isOrigin) throws IOException {
        JsonNode jsonNode = objectMapper.readTree(jsonFile);
        if (jsonNode.isNull()) {
            throw new IllegalJsonFileException("Invalid json file when generate data set");
        }
        List<PackageDataSet> dataSets = parseNonArchiveJsonDataSet(jsonNode);
        return dataSets;
    }

    /**
     *  TODO 未完整逻辑,返回列表
     *  add by HZY at 2017/07/03
     * （非档案类型）结构化档案包数据集处理
     *
     * @param root
     * @return
     */
    public List<PackageDataSet> parseNonArchiveJsonDataSet(JsonNode root) {
        List<PackageDataSet> packageDataSetList = new ArrayList<>();
        PackageDataSet dataSet;
        JsonNode head = root.get("head");//文件内容头信息
        JsonNode data = root.get("data");//文件内容主体信息

        String version = head.get("version").asText();
        if (version.equals("000000000000")) {
            throw new LegacyPackageException("Package is collected via cda version 00000000000, ignored.");
        }

        String dataSetCode = head.get("target").asText();
        String createTime = head.get("createTime").isNull() ? "" : head.get("createTime").asText();
        String orgCode = head.get("orgCode").asText();

        final String[] eventNo = {""};
        final String[] patientId = {""};
        final String[] eventTime = {""};    // 旧数据集结构可能不存在这个属性
        JsonNode table =  data.get("table");//表
        List<String> pkList = Arrays.asList(table.path("pk").asText().split(","));//主键字段
        ArrayNode columns = (ArrayNode) data.get("columns");//列名
        ArrayNode rows = (ArrayNode) data.get("rows");//列值

        //获取索引字段
        columns.forEach(item -> {
            //事件号字段获取
            if (eventIndex.getEventNo().contains(item.get("column").asText())){
                eventNo[0] = item.get("column").asText();
            }
            //病人ID字段获取
            if (eventIndex.getPatientId().contains(item.get("column").asText())){
                patientId[0] = item.get("column").asText();
            }
            //时间时间获取
            if (eventIndex.getEventTime().contains(item.get("column").asText())){
                eventTime[0] = item.path("column").isNull() ? "" : item.path("column").asText();    // 旧数据集结构可能不存在这个属性
            }
        });

        StringBuffer pkBuffer = new StringBuffer();
        for (int i = 0; i < rows.size(); ++i) {
            JsonNode recordNode = rows.get(i);
            try {
                dataSet  = new PackageDataSet();
                dataSet.setPatientId(recordNode.path(patientId[0]).asText());
                dataSet.setEventNo(recordNode.path(eventNo[0]).asText());
                dataSet.setCdaVersion(version);
                dataSet.setCode(dataSetCode);
                dataSet.setOrgCode(orgCode);
                dataSet.setEventTime(DateTimeUtil.simpleDateParse(recordNode.path(eventTime[0]).asText()));
                dataSet.setCreateTime(DateTimeUtil.simpleDateParse(createTime));
                MetaDataRecord record = new MetaDataRecord();
                Iterator<Map.Entry<String, JsonNode>> iterator = recordNode.fields();
                while (iterator.hasNext()) {
                    Map.Entry<String, JsonNode> item = iterator.next();
                    String metaData = item.getKey();
                    if (metaData.equals("EVENT_NO")) continue; //metaData.equals("PATIENT_ID") ||
                    if (metaData.equals("_id")) continue;//源表主键字段名
                    String value = item.getValue().asText().equals("null") ? "" : item.getValue().asText();
                    record.putMetaData(metaData, value);
                    if (pkList != null && pkList.contains(metaData)){
                        pkBuffer.append(value).append("_");
                    }
                }
                dataSet.setPk(pkBuffer.toString());
                dataSet.addRecord(Integer.toString(i), record);
                packageDataSetList.add(dataSet);
            } catch (NullPointerException e) {
                throw new IllegalJsonDataException("Null pointer occurs while generate data set, package cda version: " + version);
            } catch (ParseException e) {
                throw new IllegalJsonDataException("Invalid date time format, do not deal with fail-tolerant.");
            }
        }
        return packageDataSetList;
    }
}