代码修改

svr/svr-basic/src/main/java/com/yihu/jw/basic/config/BeanConfig.java

@@ -0,0 +1,203 @@
//package com.yihu.jw.basic.config;
//
//import com.fasterxml.jackson.databind.ObjectMapper;
//
//import com.yihu.jw.basic.interceptor.AuditInterceptor;
//import com.yihu.jw.basic.standard.match.dictionary.DictitemStandardExistStrategy;
//import com.yihu.jw.basic.standard.match.metadata.MetatdataStandardExistStrategy;
//import org.apache.tomcat.util.threads.ThreadPoolExecutor;
//import org.hibernate.HibernateException;
//import org.hibernate.Session;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.beans.factory.annotation.Value;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.ComponentScan;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.context.support.ResourceBundleMessageSource;
//import org.springframework.core.io.DefaultResourceLoader;
//import org.springframework.core.io.Resource;
//import org.springframework.core.io.ResourceLoader;
//import org.springframework.jdbc.core.JdbcTemplate;
//import org.springframework.orm.hibernate5.HibernateTemplate;
//import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
//import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
//import org.springframework.transaction.annotation.EnableTransactionManagement;
//import org.springframework.web.multipart.MultipartResolver;
//import org.springframework.web.multipart.commons.CommonsMultipartResolver;
//import org.springframework.web.servlet.i18n.CookieLocaleResolver;
//import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
//
//import javax.sql.DataSource;
//import java.sql.SQLException;
//import java.util.HashMap;
//import java.util.Locale;
//import java.util.Map;
//import java.util.Properties;
//
///**
// * @author HZY
// * @vsrsion 1.0
// * Created at 2016/8/5.
// */
//@Configuration
//@EnableTransactionManagement
//@ComponentScan("com.yihu.jw")
//public class BeanConfig {
//
//    @Autowired
//    private DataSource dataSource;
//
//
//    @Value("${hos.filesystem.url}")
//    private String fsUrl;
//
//    public static Map<String, String> vesionedEntitys = new HashMap<>();
//    static{
//        vesionedEntitys.put("com.yihu.hos.standard.model.standard.StdDataSetModel", "std_dataset_");
//        vesionedEntitys.put("com.yihu.hos.standard.model.standard.StdMetaDataModel", "std_metadata_");
//        vesionedEntitys.put("com.yihu.hos.standard.model.standard.StdDictionaryModel", "std_dictionary_");
//        vesionedEntitys.put("com.yihu.hos.standard.model.standard.StdDictionaryModel", "std_dictionary_entry_");
//        vesionedEntitys.put("com.yihu.ehr.standard.document.service.CDADocument", "std_cda_document_");
//        vesionedEntitys.put("com.yihu.ehr.standard.document.service.CDADataSetRelationship", "std_cda_data_set_relationship_");
//    }
//
//
//    @Bean
//    public LocalSessionFactoryBean sessionFactory() {
//        LocalSessionFactoryBean localSessionFactoryBean = new LocalSessionFactoryBean();
//        localSessionFactoryBean.setDataSource(this.dataSource);
//        Properties properties1 = new Properties();
//        properties1.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL5Dialect");
//        properties1.setProperty("hibernate.show_sql", "false");
//        properties1.setProperty("hibernate.format_sql", "true");
//        localSessionFactoryBean.setHibernateProperties(properties1);
//        localSessionFactoryBean.setPackagesToScan("com.yihu.hos.*.entity", "com.yihu.hos.*.model");
//        ResourceLoader resourceLoader = new DefaultResourceLoader();
//        Resource resource = resourceLoader.getResource("resource/");
//        localSessionFactoryBean.setMappingDirectoryLocations(resource);
//        //设置拦截器
//        localSessionFactoryBean.setEntityInterceptor(this.auditInterceptor());
//
//        return localSessionFactoryBean;
//    }
//
//    //txManager事务开启
////    @Bean
////    public HibernateTransactionManager txManager() throws SQLException {
////        HibernateTransactionManager hibernateTransactionManager = new HibernateTransactionManager();
////        LocalSessionFactoryBean sessionFactoryBean = this.sessionFactory();
////        hibernateTransactionManager.setSessionFactory(sessionFactoryBean.getObject());
////        return hibernateTransactionManager;
////    }
//
//    @Bean
//    public MultipartResolver multipartResolver() {
//        CommonsMultipartResolver resolver = new CommonsMultipartResolver();
//        // resolver.setDefaultEncoding("UTF-8");
//        //resolver.setMaxUploadSize(50 * 1024 * 1024);// 上传文件大小 5M 5*1024*1024
//        return resolver;
//    }
//
//    //国际化配置
//    @Bean
//    public ResourceBundleMessageSource messageSource() {
//        ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
//        messageSource.setBasenames("text/message");
//        messageSource.setDefaultEncoding("UTF-8");
//        return messageSource;
//    }
//
//    @Bean
//    public CookieLocaleResolver localeResolver() {
//        CookieLocaleResolver localeResolver = new CookieLocaleResolver();
//        localeResolver.setCookieName("Language");
//        localeResolver.setCookieMaxAge(604800);
//        localeResolver.setDefaultLocale(new Locale("zh_cn"));
//        return localeResolver;
//    }
//
//    @Bean
//    public LocaleChangeInterceptor localeChangeInterceptor() {
//        return new LocaleChangeInterceptor();
//    }
//
//    @Bean
//    public JdbcTemplate jdbcTemplate() {
//        JdbcTemplate jdbcTemplate = new JdbcTemplate();
//        try {
//            jdbcTemplate.setDataSource(this.dataSource);
//            jdbcTemplate.setLazyInit(false);
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        return jdbcTemplate;
//    }
//
//    //Hibernate模版配置
//    @Bean
//    public HibernateTemplate hibernateTemplate() throws SQLException {
//        HibernateTemplate hibernateTemplate = new HibernateTemplate();
//        LocalSessionFactoryBean sessionFactory = this.sessionFactory();
//        hibernateTemplate.setSessionFactory(sessionFactory.getObject());
//        return hibernateTemplate;
//    }
//
//    @Bean
//    public Session getSession() throws HibernateException {
//        LocalSessionFactoryBean sessionFactory = this.sessionFactory();
//        return  sessionFactory.getObject().openSession();
//    }
//
//    @Bean
//    public AuditInterceptor auditInterceptor() {
//        return new AuditInterceptor();
//    }
//
//    @Override
//    protected void finalize() throws Throwable {
//        super.finalize();
//    }
//
//    public String getFsUrl() {
//        return fsUrl;
//    }
//
//    @Bean
//    public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
//        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
//        threadPoolTaskExecutor.setCorePoolSize(5);
//        threadPoolTaskExecutor.setMaxPoolSize(10);
//        threadPoolTaskExecutor.setQueueCapacity(25);
//        threadPoolTaskExecutor.setKeepAliveSeconds(300);
//        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
//        return threadPoolTaskExecutor;
//    }
//    @Bean
//    public MetatdataStandardExistStrategy metatdataStandardExistStrategy() {
//        return new MetatdataStandardExistStrategy();
//    }
//
//    @Bean
//    public DictitemStandardExistStrategy dictitemStandardExistStrategy() {
//        return new DictitemStandardExistStrategy();
//    }
//
//
////    @Bean
////    public HibernateFilter filterConfig() {
////        return new HibernateFilter();
////    }
////
////
////    @Bean
////    public ObjectMapper objectMapper() {
////        return new ObjectMapper();
////    }
////
////    @Bean
////    public ApplicationStart applicationStart() {
////        return new ApplicationStart();
////    }
//
//
//}

svr/svr-basic/src/main/java/com/yihu/jw/basic/config/TenantConfiguration.java

@@ -1,26 +1,26 @@
package com.yihu.ehr.config;
import feign.RequestInterceptor;
import feign.RequestTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 *   ehr使用 feginClient 调用eip(涉及到app应用,标准等) 时,需要此类,增加请求头信息
 */
@Configuration
public class TenantConfiguration {
    @Value("${eip.tenant}")
    private String tenant;
    @Bean
    public RequestInterceptor tenantInterceptor() {
        return new RequestInterceptor() {
            @Override
            public void apply(RequestTemplate requestTemplate) {
                requestTemplate.header("tenant_name", tenant);
            }
        };
    }
}
//package com.yihu.ehr.config;
//
//import feign.RequestInterceptor;
//import feign.RequestTemplate;
//import org.springframework.beans.factory.annotation.Value;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//
///**
// *   ehr使用 feginClient 调用eip(涉及到app应用,标准等) 时,需要此类,增加请求头信息
// */
//@Configuration
//public class TenantConfiguration {
//    @Value("${eip.tenant}")
//    private String tenant;
//
//    @Bean
//    public RequestInterceptor tenantInterceptor() {
//        return new RequestInterceptor() {
//            @Override
//            public void apply(RequestTemplate requestTemplate) {
//                requestTemplate.header("tenant_name", tenant);
//            }
//        };
//    }
//}

svr/svr-basic/src/main/java/com/yihu/jw/basic/interceptor/AuditInterceptor.java

@@ -0,0 +1,56 @@
//package com.yihu.jw.basic.interceptor;
//
//import com.yihu.jw.util.thread.ContextAttributes;
//import com.yihu.jw.util.thread.LocalContext;
//import org.apache.commons.lang3.StringUtils;
//import org.hibernate.EmptyInterceptor;
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//import org.springframework.stereotype.Component;
//
///**
// * @author HZY
// * @vsrsion 1.0
// * Created at 2016/11/30.
// */
//@Component
//public class AuditInterceptor extends EmptyInterceptor {
//
//    private static final long serialVersionUID = 1L;
//    private static Logger logger = LoggerFactory.getLogger(AuditInterceptor.class);
//
//    @Override
//    public String onPrepareStatement(String sql) {
//        String schemaName = getSchema();
//        String completeSql = sql;
//        if (StringUtils.isNotEmpty(schemaName)) {
//            String myCatAnnotation = "/*#mycat:schema=" + schemaName + "*/ ";
//            completeSql = myCatAnnotation + sql;
//        }
////        logger.info("prepare " + completeSql);
//        return super.onPrepareStatement(completeSql);
//    }
//
////    @Override
////    public void onDelete(
////            Object entity,
////            Serializable id,
////            Object[] state,
////            String[] propertyNames,
////            Type[] types) {
////        System.out.println("33333333333333");
////        super.onDelete(entity,id,state,propertyNames,types);
////    }
//
//
////    @Override
////    public void preFlush(Iterator entities) {
////        System.out.println("preflush..............");
////        super.preFlush(entities);
////    }
//
//    private String getSchema() {
//        return LocalContext.getContext().getAttachment(ContextAttributes.SCHEMA);
//    }
//
//}

svr/svr-basic/src/main/java/com/yihu/jw/basic/redis/schema/StdQcMetaDataKeySchema.java

@@ -0,0 +1,110 @@
package com.yihu.jw.basic.redis.schema;
import com.yihu.jw.redis.schema.KeySchema;
import com.yihu.jw.util.string.StringBuilderEx;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
 * 标准数据元质控规则 redis辅助类
 * @author HZY
 * @vsrsion 1.0
 * Created at 2018/5/24.
 */
@Component
public class StdQcMetaDataKeySchema extends KeySchema {
    private final static String QC = "qc_";
    @Autowired
    private RedisTemplate<String, Serializable> redisTemplate;
    /**
     * 获取key
     */
    public String getKey(String version,String dataSet,String metaData){
        return new StringBuilderEx(keySchema)
                .arg(QC+version)
                .arg(dataSet)
                .arg(metaData)
                .toString();
    }
    public void setQcMetaData(String version, String dataSetCode, String innerCode, String value) {
        redisClient.set(makeKey(QC + version, dataSetCode , innerCode),value);
    }
    public void multiSetQcMetaData(Map<String, Serializable> data) {
        redisClient.multiSetData(data);
    }
    public void setQcMetaDataList(String version, String dataSetCode, String innerCode, String value) {
        redisClient.set(makeKey(QC + version, dataSetCode, innerCode), value);
    }
    public void deleteQcMetaData(String version, String dataSetCode, String innerCode) {
        redisClient.delete(makeKey(QC + version, dataSetCode ,innerCode));
    }
    /**
     * 通过版本号，模糊删除
     * @param version
     */
    public void deleteQcMetaData(String version ) {
        String replacePattern = new StringBuilderEx("%1%2:%3")
                .arg(QC)
                .arg(version)
                .arg("*")
                .toString();
        redisClient.delete(replacePattern);
    }
    public String getQcMetaData(String version, String dataSetCode, String innerCode) {
        assert version != null && version.length() != 0 &&
                dataSetCode != null && dataSetCode.length() != 0 &&
                innerCode != null && innerCode.length() != 0;
        String key = makeKey(QC + version, dataSetCode, innerCode);
        return redisClient.get(key)== null ? null : this.redisClient.get(key).toString();
//        return this.redisTemplate.opsForValue().get(key) == null ? null : this.redisTemplate.opsForValue().get(key).toString();
    }
    public Boolean isQcMetaDataExist(String version, String dataSetCode, String innerCode) {
        assert StringUtils.isNotBlank(version) && StringUtils.isNotBlank(innerCode);
        return redisClient.hasKey(makeKey( version, dataSetCode ,innerCode));
    }
    /**
     * 模糊获取数据集下的有绑定规则的数据元
     */
    public  List<String>  getMetaDataByDataSet(String stdVersion,String stdDataSet){
       List<String> metaDatas = new ArrayList<>();
       String replacePattern = new StringBuilderEx("%1%2:%3:")
               .arg(QC)
               .arg(stdVersion)
               .arg(stdDataSet)
               .toString();
        Set<String> keys = redisClient.keys(makeKey(QC + stdVersion,stdDataSet,"*"));
        keys.stream().forEach(key ->{
            key = key.replace(replacePattern,"");
            metaDatas.add(key);
        });
        return metaDatas;
    }
    //测试redisTemplate 直取
    public Serializable getValue(String key){
        return  this.redisTemplate.opsForValue().get(key);
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/controller/AdapterDatasetController.java

@@ -106,7 +106,7 @@ public class AdapterDatasetController extends EnvelopRestEndpoint {
    @ApiOperation(value = "定制适配数据集",  responseContainer = "List",produces = "application/json", notes = "获取数据集列表")
    public Envelop adapterDataSet(
            @ApiParam(name = "schemeId", value = "适配方案ID")
            @RequestParam(value = "schemeId") Integer schemeId,
            @RequestParam(value = "schemeId") Long schemeId,
            @ApiParam(name = "adapterVersion", value = "适配版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "stdVersion", value = "标准版本号")

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/controller/RuleController.java

@@ -0,0 +1,337 @@
package com.yihu.jw.basic.standard.controller;
import com.google.common.base.Splitter;
import com.yihu.jw.basic.standard.model.Result;
import com.yihu.jw.basic.standard.model.qc.RuleModel;
import com.yihu.jw.basic.standard.service.qc.RuleService;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.ListEnvelop;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.apache.commons.beanutils.BeanUtils;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.List;
/**
 * 质控规则管理
 *
 * @author CD
 * @vsrsion 1.0
 * Created at 2017/05/05.
 */
@RequestMapping("/rule")
@RestController
@Api(description = "质控规则接口", tags = {"质控规则--质控规则接口"})
public class RuleController extends EnvelopRestEndpoint {
    @Resource(name = RuleService.BEAN_ID)
    private RuleService ruleService;
    /**
     * 新增质控规则s信息
     *
     * @param request
     * @return
     */
    @RequestMapping("addRule")
    @ResponseBody
    public Result addRule(HttpServletRequest request) {
        try {
            RuleModel obj = new RuleModel();
            BeanUtils.populate(obj, request.getParameterMap());
            return ruleService.addRule(obj);
        } catch (Exception ex) {
            ex.printStackTrace();
            return Result.error(ex.getMessage());
        }
    }
    /**
     * 删除质控规则信息
     *
     * @param request
     * @return
     */
    @RequestMapping("/deleteRule")
    @ResponseBody
    public Result deleteRule(HttpServletRequest request) {
        try {
            String id = request.getParameter("id");
            ruleService.deleteRule(id);
            return Result.success("删除成功！");
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("删除失败！");
        }
    }
    /**
     * 批量删除质控规则信息
     *
     * @param request
     * @return
     */
    @RequestMapping("/deleteRuleBatch")
    @ResponseBody
    public Result deleteRuleBatch(HttpServletRequest request) {
        try {
            String idList = request.getParameter("idList");
            List<String> ids = Splitter.on(",").trimResults().splitToList(idList);
            if (!CollectionUtils.isEmpty(ids)) {
                for (String id :
                        ids) {
                    ruleService.deleteRule(id);
                }
            }
            return Result.success("删除成功！");
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("删除失败！");
        }
    }
    /**
     * 修改质控规则信息
     */
    @RequestMapping("updateRule")
    @ResponseBody
    public Result updateRule(HttpServletRequest request) {
        try {
            RuleModel obj = new RuleModel();
            BeanUtils.populate(obj, request.getParameterMap());
            return ruleService.updateRule(obj);
        } catch (Exception ex) {
            ex.printStackTrace();
            return Result.error(ex.getMessage());
        }
    }
    /**
     * 绑定质控规则
     */
    @ApiOperation(" 根据数集ID&数据元编码绑定质控规则")
    @RequestMapping(value = "bindQcRule", method = RequestMethod.POST)
    @ResponseBody
    public Envelop bindQcRule(
            @RequestParam(name = "stdVersion") String stdVersion,
            @RequestParam(name = "stdDataSetId") Long stdDataSetId,
            @RequestParam(name = "dataElement") String dataElement,
            @RequestParam(name = "ruleList") String ruleList) {
        Envelop envelop = new Envelop();
        try {
            ruleService.bindQcRule(stdVersion,stdDataSetId,dataElement, ruleList);//绑定质控规则反射方法
            envelop.setStatus(200);
        } catch (Exception ex) {
            ex.printStackTrace();
            envelop.setStatus(-1);
            envelop.setMessage("失败");
        }
        return envelop;
    }
    /**
     * 绑定质控规则
     */
    @ApiOperation("根据数据元编码批量绑定质控规则")
    @RequestMapping(value = "bindQcRuleBatch", method = RequestMethod.POST)
    @ResponseBody
    public Envelop bindQcRuleBatch(
            @RequestParam(name = "stdVersion") String stdVersion,
            @RequestParam(name = "dataElement") String dataElement,
            @RequestParam(name = "ruleList") String ruleList) {
        Envelop envelop = new Envelop();
        try {
            ruleService.bindQcRuleBatch(stdVersion,dataElement, ruleList);//绑定质控规则反射方法
            envelop.setStatus(200);
        } catch (Exception ex) {
            ex.printStackTrace();
            envelop.setStatus(-1);
            envelop.setMessage("失败");
        }
        return envelop;
    }
    /**
     * 绑定质控规则
     */
    @ApiOperation(" 根据数集编码&数据元编码绑定质控规则")
    @RequestMapping(value = "bindQcRuleByCode", method = RequestMethod.POST)
    @ResponseBody
    public Envelop bindQcRule(
            @RequestParam(name = "stdVersion") String stdVersion,
            @RequestParam(name = "stdDataSetCode") String stdDataSetCode,
            @RequestParam(name = "dataElement") String dataElement,
            @RequestParam(name = "ruleList") String ruleList) {
        Envelop envelop = new Envelop();
        try {
            ruleService.bindQcRule(stdVersion,stdDataSetCode,dataElement, ruleList);
            envelop.setStatus(200);
        } catch (Exception ex) {
            ex.printStackTrace();
            envelop.setMessage("失败");
        }
        return envelop;
    }
    /**
     * 获取绑定质控规则
     */
    @RequestMapping(value = "bindQcRule", method = RequestMethod.GET)
    @ResponseBody
    public Envelop getBindQcRule(
            @RequestParam(name = "stdVersion") String stdVersion,
            @RequestParam(name = "stdDataSetId") Integer stdDataSetId,
            @RequestParam(name = "dataElement") String dataElement) {
        Envelop envelop = new Envelop();
        try {
            List<RuleModel> bindQcRule = ruleService.getBindQcRule(stdVersion,stdDataSetId,dataElement);
            return ListEnvelop.getSuccess("获取成功",bindQcRule);
        } catch (Exception ex) {
            ex.printStackTrace();
            envelop.setStatus(-1);
            envelop.setMessage("绑定制控规则");
        }
        return envelop;
    }
    /**
     * 获取绑定质控规则
     */
    @RequestMapping(value = "bindQcRuleByCode", method = RequestMethod.GET)
    @ResponseBody
    public Envelop bindQcRuleByCode(
            @RequestParam(name = "stdVersion") String stdVersion,
            @RequestParam(name = "stdDataSetCode") String stdDataSetCode,
            @RequestParam(name = "dataElement") String dataElement) {
        Envelop envelop = new Envelop();
        try {
            List<RuleModel> bindQcRule = ruleService.getBindQcRule(stdVersion,stdDataSetCode,dataElement);
            return ListEnvelop.getSuccess("获取成功",bindQcRule);
        } catch (Exception ex) {
            ex.printStackTrace();
            envelop.setStatus(-1);
            envelop.setMessage("绑定制控规则");
        }
        return envelop;
    }
    @ApiOperation("根据数据集，绑定其所有数据元的质控规则")
    @RequestMapping(value = "bindQcRuleByDataSet", method = RequestMethod.POST)
    @ResponseBody
    public Envelop bindQcRuleByDataSet(
            @ApiParam(name = "stdVersion", value = "标准版本号", required = true)
            @RequestParam(name = "stdVersion") String stdVersion,
            @ApiParam(name = "dataSetId", value = "数据集ID", required = true)
            @RequestParam(name = "dataSetId") Long dataSetId) {
        Envelop envelop = new Envelop();
        try {
            ruleService.bindQcRuleByDataSet(stdVersion, dataSetId);
            envelop.setStatus(200);
        } catch (Exception e) {
            e.printStackTrace();
            envelop.setStatus(-1);
            envelop.setMessage(e.getMessage());
        }
        return envelop;
    }
    @ApiOperation("根据标准版本，绑定其所有数据元的质控规则")
    @RequestMapping(value = "bindQcRuleByStdVersion", method = RequestMethod.POST)
    @ResponseBody
    public Envelop bindQcRuleByStdVersion(
            @ApiParam(name = "stdVersion", value = "标准版本", required = true)
            @RequestParam(name = "stdVersion") String stdVersion) {
        Envelop envelop = new Envelop();
        try {
            ruleService.batchBindRuleByStdVersion(stdVersion);
            envelop.setStatus(200);
            envelop.setMessage("标准版本："+stdVersion +"绑定规则成功");
        } catch (Exception e) {
            e.printStackTrace();
            envelop.setStatus(-1);
            envelop.setMessage(e.getMessage());
        }
        return envelop;
    }
    @ApiOperation("根据标准版本，删除其所有数据元的质控规则")
    @RequestMapping(value = "delQcRuleByStdVersion", method = RequestMethod.DELETE)
    @ResponseBody
    public Envelop delQcRuleByStdVersion(
            @ApiParam(name = "stdVersion", value = "标准版本", required = true)
            @RequestParam(name = "stdVersion") String stdVersion) {
        Envelop envelop = new Envelop();
        try {
            ruleService.deleteQcMetaData(stdVersion);
            envelop.setStatus(200);
        } catch (Exception e) {
            e.printStackTrace();
            envelop.setStatus(-1);
            envelop.setMessage("删除失败");
        }
        return envelop;
    }
    /**
     * 获取绑定质控规则
     */
    @ApiOperation("获取数据元绑定质控规则(返回单个数据元）")
    @RequestMapping(value = "metaDataRule", method = RequestMethod.GET)
    @ResponseBody
    public Envelop metaDataRule(
            @RequestParam(name = "stdVersion") String stdVersion,
            @RequestParam(name = "stdDataSetCode") String stdDataSetCode,
            @RequestParam(name = "metaDataCode") String metaDataCode) {
        Envelop envelop = new Envelop();
        try {
            String bindQcRule = ruleService.getQcRule(stdVersion,stdDataSetCode,metaDataCode);
            return ObjEnvelop.getSuccess("获取成功",bindQcRule);
        } catch (Exception ex) {
            ex.printStackTrace();
            envelop.setStatus(-1);
            envelop.setMessage("获取数据元质控绑定规则异常");
            return envelop;
        }
    }
    /**
     * 获取数据集下有绑定质控规则的数据元
     */
    @ApiOperation("获取数据集下有绑定质控规则的数据元")
    @RequestMapping(value = "metaDatas", method = RequestMethod.GET)
    @ResponseBody
    public Envelop getMetaDatasByDataSet(
            @RequestParam(name = "stdVersion") String stdVersion,
            @RequestParam(name = "stdDataSetCode") String stdDataSetCode) {
        Envelop envelop = new Envelop();
        try {
            List<String> metaDatas = ruleService.getMetaDataByDataSet(stdVersion,stdDataSetCode);
            return ListEnvelop.getSuccess("获取成功",metaDatas);
        } catch (Exception ex) {
            ex.printStackTrace();
            envelop.setStatus(-1);
            envelop.setMessage("获取数据元质控绑定规则异常");
            return envelop;
        }
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/controller/StandardVersionController.java

@@ -130,7 +130,7 @@ public class StandardVersionController extends EnvelopRestEndpoint {
    @ApiOperation(value = "根据type导入数据接口", response = Object.class, produces = "application/json", notes = "导入数据接口")
    public Envelop importFile(@ApiParam(value = "类型（1:数据集 2:字典 3:机构数据 4：机构字典）", required = true) @RequestParam("type") String type,
                             @ApiParam(value = "项目版本", required = true) @RequestParam("version") String version,
                             @ApiParam(value = "项目版本", required = true) @RequestParam("standardId") Integer standardId,
                             @ApiParam(value = "项目版本", required = true) @RequestParam("standardId") Long standardId,
                             @ApiParam(value = "文件", required = true, allowMultiple = true) @RequestParam("file") MultipartFile file){
        try {
            String id = "";

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/controller/StdCdaController.java

@@ -0,0 +1,386 @@
package com.yihu.jw.basic.standard.controller;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.cfg.ContextAttributes;
import com.yihu.fastdfs.FastDFSUtil;
import com.yihu.jw.basic.standard.model.BaseCDADataSetRelationship;
import com.yihu.jw.basic.standard.model.BaseCDADocument;
import com.yihu.jw.basic.standard.model.CDADocument;
import com.yihu.jw.basic.standard.service.bo.StandardVersion;
import com.yihu.jw.basic.standard.service.document.CDADataSetRelationshipManager;
import com.yihu.jw.basic.standard.service.document.CDADocumentService;
import com.yihu.jw.basic.standard.service.standard.StdCDAService;
import com.yihu.jw.entity.ehr.id.BizObject;
import com.yihu.jw.restmodel.ehr.standard.CDAModel;
import com.yihu.jw.restmodel.ehr.standard.CdaDataSetRelationshipModel;
import com.yihu.jw.restmodel.ehr.standard.MCDADocument;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.ListEnvelop;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.restmodel.web.PageEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import com.yihu.jw.util.common.LogService;
import com.yihu.jw.util.sql.ErrorCode;
import com.yihu.jw.util.date.DateUtil;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
@RequestMapping(value = "/cda", produces = "application/json;charset=utf-8")
@RestController
public class StdCdaController extends EnvelopRestEndpoint {
    @Autowired
    private StdCDAService stdCDAService;
    @Resource(name = CDADocumentService.BEAN_ID)
    private CDADocumentService cdaDocumentService;
    @Autowired
    private CDADataSetRelationshipManager cdaDatasetRelationshipManager;
    @Autowired
    private FastDFSUtil fastDFSUtil;
    @Autowired
    private ObjectMapper objectMapper;
    @RequestMapping("GetCdaListByKey")
    public Envelop getCdaListByKey(String strKey, String strVersion, String strType, Integer page, Integer rows) {
        String filters = "type="+strType;
        Envelop result = new Envelop();
        if (!StringUtils.isEmpty(strKey)){
            filters += " g1;code?"+strKey+" g2;name?"+strKey+" g2";
        }
        if (StringUtils.isEmpty(strVersion)) {
            result.setStatus(-1);
            result.setMessage(ErrorCode.VersionCodeIsNull.toString());
            return result;
        }
        try {
            List<BaseCDADocument> ls = cdaDocumentService.searchPage(BaseCDADocument.class, StandardVersion.CDADocumentTable, strVersion, filters, "", page, rows,true);
            Long totalCount = cdaDocumentService.searchCount(BaseCDADocument.class, strVersion, StandardVersion.CDADocumentTable, filters);
            Collection<MCDADocument> cdaDocumentList = convertToModels(ls, new ArrayList<>(ls.size()), MCDADocument.class, "");
            ResponseEntity<Collection<MCDADocument>> responseEntity = ResponseEntity.ok().body(cdaDocumentList);
            cdaDocumentList = responseEntity.getBody();
            List<CDAModel> cdaModelList = new ArrayList<>();
            for (MCDADocument mcdaDocument : cdaDocumentList) {
                mcdaDocument.setVersionCode(strVersion);
                cdaModelList.add(convertToCDAModel(mcdaDocument));
            }
            return PageEnvelop.getSuccessListWithPage("查询成功",cdaModelList,  page, rows, totalCount);
        } catch (Exception ex) {
            LogService.getLogger(StdCdaController.class).error(ex.getMessage());
            return Envelop.getError("查询失败");
        }
    }
    @RequestMapping("getCDAInfoById")
    public Envelop getCDAInfoById(String strId, String strVersion) {
        String strErrorMsg = "";
        Envelop result = new Envelop();
        if (StringUtils.isEmpty(strVersion)) {
            strErrorMsg += "请选择标准版本!";
        }
        if (StringUtils.isEmpty(strId)) {
            strErrorMsg += "请选择将要编辑的CDA!";
        }
        if (!StringUtils.isEmpty(strErrorMsg)) {
            result.setStatus(-1);
            result.setMessage(strErrorMsg);
            return result;
        }
        try {
            List<CDADocument> list = cdaDocumentService.searchPageData(BaseCDADocument.class, StandardVersion.CDADocumentTable, strVersion, "id=" + strId, null, null, null);
            Collection<MCDADocument> mcdaDocumentList = convertToModels(list, new ArrayList<>(list.size()), MCDADocument.class, "");
            if (mcdaDocumentList == null) {
                return failed("数据获取失败!");
            }
            List<CDAModel> cdaModelList = new ArrayList<>();
            for (MCDADocument mcdaDocument : mcdaDocumentList) {
                mcdaDocument.setVersionCode(strVersion);
                cdaModelList.add(convertToCDAModel(mcdaDocument));
            }
            return ListEnvelop.getSuccess("查询成功",cdaModelList);
        } catch (Exception ex) {
            LogService.getLogger(StdCdaController.class).error(ex.getMessage());
            return Envelop.getError("查询失败");
        }
    }
    @RequestMapping("getALLRelationByCdaId")
    public Envelop getALLRelationByCdaId(String cdaId, String strVersionCode) {
        try {
            Collection<BaseCDADataSetRelationship> mcdaDocumentList = cdaDatasetRelationshipManager.searchPageData
                    (BaseCDADataSetRelationship.class, StandardVersion.CDADatasetTable, strVersionCode, "cdaId=" + cdaId, null, null, null);
            List<CdaDataSetRelationshipModel> cdaDataSetRelationshipModels = new ArrayList<>();
            for (BaseCDADataSetRelationship mCdaDataSetRelationship : mcdaDocumentList) {
                CdaDataSetRelationshipModel cdaDataSetRelationshipModel = new CdaDataSetRelationshipModel();
                cdaDataSetRelationshipModel.setId(mCdaDataSetRelationship.getDataSetId());
                cdaDataSetRelationshipModel.setCdaId(mCdaDataSetRelationship.getCdaId());
                cdaDataSetRelationshipModel.setDataSetId(mCdaDataSetRelationship.getId());
                cdaDataSetRelationshipModels.add(cdaDataSetRelationshipModel);
            }
            if (cdaDataSetRelationshipModels != null) {
                return ListEnvelop.getSuccess("查询成功",cdaDataSetRelationshipModels);
            } else {
                return failed("查询失败");
            }
        } catch (Exception ex) {
            LogService.getLogger(StdCdaController.class).error(ex.getMessage());
            return failed("查询失败");
        }
    }
    @RequestMapping("SaveCdaInfo")
    public Envelop SaveCdaInfo(String cdaJson,String version,HttpServletRequest request) throws IOException {
        CDADocument cdaModel = objectMapper.readValue(cdaJson, CDADocument.class);
        try {
            if(StringUtils.isEmpty(cdaModel.getId())) {
                cdaModel.setStdVersion(version);
                BaseCDADocument model = (BaseCDADocument) cdaModel;
                model.setId(getObjectId(BizObject.STANDARD));
                model.setCreateDate(new Date());
                cdaDocumentService.add(version, model);
                model.setVersionCode(cdaModel.getVersionCode());
                return success(model);
            }
            else {
                List<CDADocument> list = cdaDocumentService.searchPageData(BaseCDADocument.class, StandardVersion.CDADocumentTable, cdaModel.getVersionCode(), "id=" + cdaModel.getId(), null, null, null);
                BaseCDADocument updateCdaModel = list.get(0);
                updateCdaModel.setCode(cdaModel.getCode());
                updateCdaModel.setName(cdaModel.getName());
                updateCdaModel.setSourceId(cdaModel.getSourceId());
                updateCdaModel.setType(cdaModel.getType());
                updateCdaModel.setDescription(cdaModel.getDescription());
                updateCdaModel.setUpdateDate(new Date());
                cdaDocumentService.modify(version, updateCdaModel);
                updateCdaModel.setVersionCode(cdaModel.getVersionCode());
                return success(updateCdaModel);
            }
        } catch (Exception ex) {
            LogService.getLogger(StdCdaController.class).error(ex.getMessage());
            return failed("修改失败");
        }
    }
    @RequestMapping("deleteCdaInfo")
    public Envelop deleteCdaInfo(String ids, String strVersionCode) {
        Envelop envelop = new Envelop();
        String strErrorMsg = "";
        if (StringUtils.isEmpty(strVersionCode)) {
            strErrorMsg += "标准版本不能为空!";
        }
        if (StringUtils.isEmpty(ids)) {
            strErrorMsg += "请先选择将要删除的CDA";
        }
        if (!StringUtils.isEmpty(strErrorMsg)) {
            envelop.setStatus(-1);
            envelop.setMessage(strErrorMsg);
            return envelop;
        }
        try {
            String[] cdaIds = ids.split(",");
            boolean bo = cdaDocumentService.deleteByField("id", cdaIds, StandardVersion.CDADocumentTable, strVersionCode);
            if(bo){
                return success("删除成功");
            }else {
                return failed("删除失败");
            }
        } catch (Exception ex) {
            LogService.getLogger(StdCdaController.class).error(ex.getMessage());
            return failed("删除失败");
        }
    }
    /**
     * 保存CDA信息
     * 1.先删除CDA数据集关联关系信息与cda文档XML文件，在新增信息
     * @param strDatasetIds 关联的数据集
     * @param strCdaId  cda文档 ID
     * @param strVersionCode 版本号
     * @param xmlInfo xml 文件内容
     * @return 操作结果
     */
    @RequestMapping("SaveRelationship")
    public Envelop SaveRelationship(String strDatasetIds, String strCdaId, String strVersionCode, String xmlInfo) {
        Envelop envelop = new Envelop();
        String strErrorMsg = "";
        if (StringUtils.isEmpty(strVersionCode)) {
            strErrorMsg += "标准版本不能为空!";
        }
        if (StringUtils.isEmpty(strCdaId)) {
            strErrorMsg += "请先选择CDA!";
        }
        if (!StringUtils.isEmpty(strErrorMsg)) {
            envelop.setStatus(-1);
            envelop.setMessage(strErrorMsg);
            return envelop;
        }
        try {
            boolean bo = cdaDatasetRelationshipManager.SaveDataSetRelationship(strDatasetIds, strCdaId, strVersionCode, xmlInfo);
            if(bo){
                return success("保存成功");
            }else {
                return failed("保存失败");
            }
        }catch(Exception ex){
            LogService.getLogger(StdCdaController.class).error(ex.getMessage());
            return failed("保存失败");
        }
    }
    /*
     * 根据CDA ID 获取数据集信息
     * @param strVersionCode 版本号
     * @param strCdaId CDAID
     * @return Result
     * */
    @RequestMapping("/getDatasetByCdaId")
    public Envelop getDatasetByCdaId(String strVersionCode, String strCdaId) {
        try {
            Collection<BaseCDADataSetRelationship> mcdaDocumentList = cdaDatasetRelationshipManager.searchPageData
                    (BaseCDADataSetRelationship.class, StandardVersion.CDADatasetTable, strVersionCode, "cdaId=" + strCdaId, null, null, null);
            List<CdaDataSetRelationshipModel> cdaDataSetRelationshipModels = new ArrayList<>();
            for (BaseCDADataSetRelationship mCdaDataSetRelationship : mcdaDocumentList) {
                CdaDataSetRelationshipModel cdaDataSetRelationshipModel = new CdaDataSetRelationshipModel();
                cdaDataSetRelationshipModel.setId(mCdaDataSetRelationship.getDataSetId());
                cdaDataSetRelationshipModel.setCdaId(mCdaDataSetRelationship.getCdaId());
                cdaDataSetRelationshipModel.setDataSetId(mCdaDataSetRelationship.getId());
                cdaDataSetRelationshipModels.add(cdaDataSetRelationshipModel);
            }
            if (cdaDataSetRelationshipModels != null) {
                return ListEnvelop.getSuccess("查询成功",cdaDataSetRelationshipModels);
            } else {
                return failed("查询失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return failed("查询失败");
        }
    }
    @RequestMapping("/validatorCda")
    public Object validatorCda(String code, String versionCode) {
        try {
            return success("查询失败");
        } catch (Exception ex) {
            LogService.getLogger(StdCdaController.class).error(ex.getMessage());
            return failed("查询失败");
        }
    }
    /**
     * 获取cda文档的XML文件信息。
     * <p>
     * 从服务器的临时文件路径中读取配置文件，并以XML形式返回。
     *
     * @param cdaId
     * @param versionCode
     * @return XML信息
     * @version 1.0.1 将临时目录转移至fastDFS。
     */
    @RequestMapping("/getCdaXmlFileInfo")
    public Envelop getCdaXmlFileInfo(String cdaId, String versionCode) {
        try {
            String strXmlInfo = "";
            String strFileGroup = "";
            String strSchemePath = "";
            String strPath = System.getProperty("java.io.tmpdir");
            strPath += "StandardFiles";
            String splitMark = System.getProperty("file.separator");
            String strXMLFilePath = strPath + splitMark + "xml" + splitMark + versionCode + splitMark + "downfile" + splitMark;
            List<String> listIds = new ArrayList<>();
            listIds.add(cdaId);
            BaseCDADocument cdaDocument = (BaseCDADocument) cdaDocumentService.get(BaseCDADocument.class, versionCode, StandardVersion.CDADocumentTable, cdaId);
            if (cdaDocument != null) {
                strFileGroup = cdaDocument.getFileGroup();
                strSchemePath = cdaDocument.getSchema();
            }
            File files = new File(strXMLFilePath);
            if (!files.exists()) {
                files.mkdirs();
            }
            String strLocalFileName = strXMLFilePath + "\\" + strSchemePath.replaceAll("/", "_");
            File localFile = new File(strLocalFileName);
            if (localFile.exists() && localFile.isFile()) {
                localFile.delete();
            }
            if (null != strFileGroup && !strFileGroup.equals("") && !strSchemePath.equals("")) {
                strLocalFileName = fastDFSUtil.download(strFileGroup, strSchemePath, strXMLFilePath);
                File file = new File(strLocalFileName);
                FileReader fr = new FileReader(file);
                BufferedReader bReader = new BufferedReader(fr);
                strXmlInfo = bReader.readLine();
            } else {
                strXmlInfo = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><root></root>";
            }
            if (strXmlInfo != null) {
                return ObjEnvelop.getSuccess("获取成功",strXmlInfo);
            } else {
                return Envelop.getError("获取cda文档XML文件信息失败");
            }
        }catch (Exception e){
            e.printStackTrace();
            return Envelop.getError("获取cda文档XML文件信息失败");
        }
    }
    public CDAModel convertToCDAModel(MCDADocument mcdaDocument) {
        CDAModel cdaModel = convertToModel(mcdaDocument, CDAModel.class);
        cdaModel.setCreateDate(DateUtil.dateToStr(mcdaDocument.getCreateDate(), DateUtil.YYYY_MM_DD_HH_MM));
        cdaModel.setUpdateDate(DateUtil.dateToStr(mcdaDocument.getUpdateDate(), DateUtil.YYYY_MM_DD_HH_MM));
//        MSTDVersion versionModel = versionClient.getVersion(mcdaDocument.getVersionCode());
//        cdaModel.setStaged(versionModel.isInStage() ? "1" : "0");
        return cdaModel;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/controller/StdCdaTmpController.java

@@ -0,0 +1,335 @@
//package com.yihu.jw.basic.standard.controller;
//
//
//import com.fasterxml.jackson.databind.ObjectMapper;
//import com.fasterxml.jackson.databind.cfg.ContextAttributes;
//import com.yihu.fastdfs.FastDFSUtil;
//import com.yihu.jw.basic.standard.model.BaseCDADataSetRelationship;
//import com.yihu.jw.basic.standard.model.BaseCDADocument;
//import com.yihu.jw.basic.standard.model.CDADocument;
//import com.yihu.jw.basic.standard.service.bo.StandardVersion;
//import com.yihu.jw.basic.standard.service.document.CDADataSetRelationshipManager;
//import com.yihu.jw.basic.standard.service.document.CDADocumentService;
//import com.yihu.jw.basic.standard.service.standard.StdCDAService;
//import com.yihu.jw.entity.ehr.id.BizObject;
//import com.yihu.jw.restmodel.ehr.standard.CDAModel;
//import com.yihu.jw.restmodel.ehr.standard.CdaDataSetRelationshipModel;
//import com.yihu.jw.restmodel.ehr.standard.MCDADocument;
//import com.yihu.jw.restmodel.web.Envelop;
//import com.yihu.jw.restmodel.web.ListEnvelop;
//import com.yihu.jw.restmodel.web.ObjEnvelop;
//import com.yihu.jw.restmodel.web.PageEnvelop;
//import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
//import com.yihu.jw.util.common.LogService;
//import com.yihu.jw.util.date.DateUtil;
//import com.yihu.jw.util.sql.ErrorCode;
//import io.swagger.annotations.ApiOperation;
//import io.swagger.annotations.ApiParam;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.http.ResponseEntity;
//import org.springframework.util.StringUtils;
//import org.springframework.web.bind.annotation.*;
//
//import javax.annotation.Resource;
//import javax.servlet.http.HttpServletRequest;
//import java.io.BufferedReader;
//import java.io.File;
//import java.io.FileReader;
//import java.io.IOException;
//import java.util.ArrayList;
//import java.util.Collection;
//import java.util.Date;
//import java.util.List;
//
//
//@RequestMapping(value = "/cdatmp", produces = "application/json;charset=utf-8")
//@RestController
//public class StdCdaTmpController extends EnvelopRestEndpoint {
//
//    @Resource(name = CDADocumentService.BEAN_ID)
//    private CDADocumentService cdaDocumentService;
//    @Autowired
//    private CDADataSetRelationshipManager cdaDatasetRelationshipManager;
//    @Autowired
//    private FastDFSUtil fastDFSUtil;
//    @Autowired
//    private ObjectMapper objectMapper;
//
//    @RequestMapping(value = "/cdas", method = RequestMethod.GET)
//    @ApiOperation(value = "根据条件获取cda列表")
//    public Envelop getCdaListByKey(
//            @ApiParam(name = "fields", value = "返回的字段，为空返回全部字段", defaultValue = "")
//            @RequestParam(value = "fields", required = false) String fields,
//            @ApiParam(name = "filters", value = "过滤器，为空检索所有条件", defaultValue = "")
//            @RequestParam(value = "filters", required = false) String filters,
//            @ApiParam(name = "sorts", value = "排序，规则参见说明文档", defaultValue = "")
//            @RequestParam(value = "sorts", required = false) String sorts,
//            @ApiParam(name = "size", value = "分页大小", defaultValue = "15")
//            @RequestParam(value = "size", required = false) int size,
//            @ApiParam(name = "page", value = "页码", defaultValue = "1")
//            @RequestParam(value = "page", required = false) int page,
//            @ApiParam(name = "version", value = "版本", defaultValue = "")
//            @RequestParam(value = "version") String version) throws IOException {
//        List<BaseCDADocument> ls = cdaDocumentService.searchPage(BaseCDADocument.class, StandardVersion.CDADocumentTable, version, filters, sorts, page, size,true);
//        Long totalCount = cdaDocumentService.searchCount(BaseCDADocument.class, version, StandardVersion.CDADocumentTable, filters);
//        Collection<MCDADocument> cdaDocumentList = convertToModels(ls, new ArrayList<>(ls.size()), MCDADocument.class, fields);
//
//        ResponseEntity<Collection<MCDADocument>> responseEntity = ResponseEntity.ok().body(cdaDocumentList);
//        cdaDocumentList = responseEntity.getBody();
//        List<CDAModel> cdaModelList = new ArrayList<>();
//        for (MCDADocument mcdaDocument : cdaDocumentList) {
//            mcdaDocument.setVersionCode(version);
//            cdaModelList.add(convertToCDAModel(mcdaDocument));
//        }
//        return PageEnvelop.getSuccessListWithPage("查询成功",cdaModelList,  page, size, totalCount);
//    }
//
//
//    @RequestMapping(value = "/cda", method = RequestMethod.GET)
//    @ApiOperation(value = "根据id获取cda")
//    public Envelop getCda(
//            @ApiParam(name = "cda_id", value = "cda_id")
//            @RequestParam(value = "cda_id") String cdaId,
//            @ApiParam(name = "version_code", value = "标准版本代码")
//            @RequestParam(value = "version_code") String versionCode) {
//        try {
//            List<CDADocument> list = cdaDocumentService.searchPageData(BaseCDADocument.class, StandardVersion.CDADocumentTable, versionCode, "id=" + cdaId, null, null, null);
//            Collection<MCDADocument> mcdaDocumentList = convertToModels(list, new ArrayList<>(list.size()), MCDADocument.class, "");
//
//            if (mcdaDocumentList == null) {
//                return failed("数据获取失败!");
//            }
//            List<CDAModel> cdaModelList = new ArrayList<>();
//            for (MCDADocument mcdaDocument : mcdaDocumentList) {
//                mcdaDocument.setVersionCode(versionCode);
//                cdaModelList.add(convertToCDAModel(mcdaDocument));
//            }
//            return ListEnvelop.getSuccess("",cdaModelList);
//        } catch (Exception e) {
//            e.printStackTrace();
//            return failed("获取失败");
//        }
//    }
//
//
//    @RequestMapping(value = "/cda", method = RequestMethod.POST)
//    @ApiOperation(value = "保存CDADocuments")
//    public Envelop saveCdaInfo(
//            @ApiParam(name = "version", value = "标准版本", defaultValue = "")
//            @RequestParam(value = "version") String version,
//            @ApiParam(name = "cdaInfoJson", value = "CDAJson")
//            @RequestParam(value = "cdaInfoJson") String cdaInfoJson) {
//        try {
//            CDADocument cdaModel = objectMapper.readValue(cdaInfoJson, CDADocument.class);
//            cdaModel.setStdVersion(version);
//            BaseCDADocument model = (BaseCDADocument) cdaModel;
//
//            model.setId(getObjectId(BizObject.STANDARD));
//            model.setCreateDate(new Date());
//            cdaDocumentService.add(version, model);
//            model.setVersionCode(cdaModel.getVersionCode());
//            return success(model);
//        } catch (Exception e) {
//            e.printStackTrace();
//            return failed("保存失败");
//        }
//    }
//
//
//    @RequestMapping(value = "/cda", method = RequestMethod.PUT)
//    @ApiOperation(value = "修改CDADocuments")
//    public Envelop updateCDADocuments(
//            @ApiParam(name = "version", value = "标准版本", defaultValue = "")
//            @RequestParam(value = "version") String version,
//            @ApiParam(name = "cdaInfoJson", value = "CDAJson")
//            @RequestParam(value = "cdaInfoJson") String cdaInfoJson) {
//        try {
//            CDADocument cdaModel = objectMapper.readValue(cdaInfoJson, CDADocument.class);
//            BaseCDADocument model = (BaseCDADocument) cdaModel;
//
//            model.setUpdateDate(new Date());
//            cdaDocumentService.modify(version, model);
//            model.setVersionCode(cdaModel.getVersionCode());
//            return success(model);
//        } catch (Exception e) {
//            e.printStackTrace();
//            return failed("修改失败");
//        }
//    }
//
//    @RequestMapping(value = "/cda", method = RequestMethod.DELETE)
//    @ApiOperation(value = "删除CDADocuments")
//    public Envelop deleteCda(
//            @ApiParam(name = "cdaId", value = "cdaID")
//            @RequestParam(value = "cdaId") String cdaId,
//            @ApiParam(name = "versionCode", value = "标准版本代码")
//            @RequestParam(value = "versionCode") String versionCode) {
//        String[] cdaIds = cdaId.split(",");
//        boolean bo = cdaDocumentService.deleteByField("id", cdaIds, StandardVersion.CDADocumentTable, versionCode);
//        if(bo){
//            return success("删除成功");
//        }else {
//            return failed("删除失败");
//        }
//    }
//
//
//    @RequestMapping(value = "/relationships", method = RequestMethod.GET)
//    @ApiOperation(value = "根据条件获取getCDADataSetRelationship")
//    public Envelop getRelationByCdaId(
//            @ApiParam(name = "cdaId", value = "cdaID")
//            @RequestParam(value = "cdaId") String cdaId,
//            @ApiParam(name = "versionCode", value = "标准版本代码")
//            @RequestParam(value = "versionCode") String versionCode) throws IOException {
//        Collection<BaseCDADataSetRelationship> mcdaDocumentList = cdaDatasetRelationshipManager.searchPageData(BaseCDADataSetRelationship.class, StandardVersion.CDADatasetTable, versionCode, "cdaId=" + cdaId, null, null, null);
//        List<CdaDataSetRelationshipModel> cdaDataSetRelationshipModels = new ArrayList<>();
//
//        for (BaseCDADataSetRelationship mCdaDataSetRelationship : mcdaDocumentList) {
//            CdaDataSetRelationshipModel cdaDataSetRelationshipModel = new CdaDataSetRelationshipModel();
//            cdaDataSetRelationshipModel.setId(mCdaDataSetRelationship.getDataSetId());
//            cdaDataSetRelationshipModel.setCdaId(mCdaDataSetRelationship.getCdaId());
//            cdaDataSetRelationshipModel.setDataSetId(mCdaDataSetRelationship.getId());
//            cdaDataSetRelationshipModels.add(cdaDataSetRelationshipModel);
//        }
//
//        if (cdaDataSetRelationshipModels != null) {
//            return ListEnvelop.getSuccess("查询成功",cdaDataSetRelationshipModels);
//        } else {
//            return failed("查询失败");
//        }
//    }
//
//    @RequestMapping(value = "saveRelationship", method = RequestMethod.POST)
//    @ApiOperation(value = "保存CDADataSetRelationship")
//    public Envelop saveRelationship(
//            @ApiParam(name = "dataSetIds", value = "数据集ID(多ID以逗号隔开)")
//            @RequestParam(value = "dataSetIds") String dataSetIds,
//            @ApiParam(name = "cdaId", value = "cdaID")
//            @RequestParam(value = "cdaId") String cdaId,
//            @ApiParam(name = "versionCode", value = "标准版本代码")
//            @RequestParam(value = "versionCode") String versionCode,
//            @ApiParam(name = "xmlInfo", value = "XML文件信息")
//            @RequestParam(value = "xmlInfo") String xmlInfo) throws Exception {
//        boolean bo = cdaDatasetRelationshipManager.SaveDataSetRelationship(dataSetIds, cdaId, versionCode, xmlInfo);
//        if(bo){
//            return success("保存成功");
//        }else {
//            return failed("保存失败");
//        }
//    }
//
//    @ApiOperation(value = "根基id删除CDADataSetRelationship")
//    @RequestMapping(value = "/cda_data_set_relationships", method = RequestMethod.DELETE)
//    public Envelop deleteCDADataSetRelationship(
//            @ApiParam(name = "versionCode", value = "versionCode")
//            @RequestParam(value = "versionCode") String versionCode,
//            @ApiParam(name = "ids", value = "ids")
//            @RequestParam(value = "ids") String[] ids) {
//        boolean bo = cdaDatasetRelationshipManager.deleteRelationshipById(versionCode, ids);
//        if(bo){
//            return success("删除成功");
//        }else {
//            return failed("删除失败");
//        }
//    }
//
//
//    @RequestMapping(value = "/file/existence/cda_id", method = RequestMethod.GET)
//    @ApiOperation(value = "根据cdaId和versionCode判断文件是否存在")
//    public Envelop FileExists(
//            @ApiParam(name = "versionCode", value = "versionCode")
//            @RequestParam(value = "versionCode") String versionCode,
//            @ApiParam(name = "cda_id", value = "cda_id")
//            @RequestParam(value = "cda_id") String cdaId) {
//        boolean bo = cdaDocumentService.isFileExists(cdaId, versionCode);
//        return ObjEnvelop.getSuccess("查询成功",bo);
//    }
//
//
//    @RequestMapping(value = "documentExist", method = RequestMethod.GET)
//    public Object documentExist(
//            @ApiParam(name = "code", value = "CDA代码")
//            @RequestParam(value = "code") String code,
//            @ApiParam(name = "versionCode", value = "标准版本代码")
//            @PathVariable(value = "versionCode") String versionCode) {
//        return null;
//    }
//
//    @RequestMapping(value = "/getCdaXmlFileInfo", method = RequestMethod.GET)
//    public Envelop getCdaXmlFileInfo1(
//            @ApiParam(name = "cdaId", value = "cdaID")
//            @RequestParam(value = "cdaId") String cdaId,
//            @ApiParam(name = "versionCode", value = "标准版本代码")
//            @RequestParam(value = "versionCode") String versionCode) throws Exception {
//        String strXmlInfo = "";
//        String strFileGroup = "";
//        String strSchemePath = "";
//
//        String strPath = System.getProperty("java.io.tmpdir");
//        strPath += "StandardFiles";
//
//        String splitMark = System.getProperty("file.separator");
//        String strXMLFilePath = strPath + splitMark + "xml" + splitMark + versionCode + splitMark + "downfile" + splitMark;
//
//        List<String> listIds = new ArrayList<>();
//        listIds.add(cdaId);
//
//        BaseCDADocument cdaDocument = (BaseCDADocument) cdaDocumentService.get(BaseCDADocument.class, versionCode, StandardVersion.CDADocumentTable, cdaId);
//
//
//        if (cdaDocument != null) {
//            strFileGroup = cdaDocument.getFileGroup();
//            strSchemePath = cdaDocument.getSchema();
//        }
//
//        File files = new File(strXMLFilePath);
//        if (!files.exists()) {
//            files.mkdirs();
//        }
//
//        String strLocalFileName = strXMLFilePath + "\\" + strSchemePath.replaceAll("/", "_");
//        File localFile = new File(strLocalFileName);
//        if (localFile.exists() && localFile.isFile()) {
//            localFile.delete();
//        }
//        if (null != strFileGroup && !strFileGroup.equals("") && !strSchemePath.equals("")) {
//            strLocalFileName = fastDFSUtil.download(strFileGroup, strSchemePath, strXMLFilePath);
//
//            File file = new File(strLocalFileName);
//            FileReader fr = new FileReader(file);
//            BufferedReader bReader = new BufferedReader(fr);
//            strXmlInfo = bReader.readLine();
//        } else {
//            strXmlInfo = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><root></root>";
//        }
//
//        if (strXmlInfo != null) {
//            return ObjEnvelop.getSuccess("获取成功",strXmlInfo);
//        } else {
//            return Envelop.getError("获取cda文档XML文件信息失败");
//        }
//    }
//
//    @RequestMapping(value = "createCDASchemaFile", method = RequestMethod.POST)
//    @ApiOperation(value = "生成CDA文件")
//    public Envelop createCDASchemaFile(
//            @ApiParam(name = "versionCode", value = "versionCode")
//            @RequestParam(value = "versionCode") String versionCode,
//            @ApiParam(name = "cda_id", value = "cda_id")
//            @RequestParam(value = "cda_id") String cdaId) throws Exception {
//        boolean bo = cdaDatasetRelationshipManager.createCDASchemaFile(cdaId, versionCode);
//        return ObjEnvelop.getSuccess("操作成功",bo);
//    }
//
//    public CDAModel convertToCDAModel(MCDADocument mcdaDocument) {
//        CDAModel cdaModel = convertToModel(mcdaDocument, CDAModel.class);
//        cdaModel.setCreateDate(DateUtil.dateToStr(mcdaDocument.getCreateDate(), DateUtil.YYYY_MM_DD_HH_MM));
//        cdaModel.setUpdateDate(DateUtil.dateToStr(mcdaDocument.getUpdateDate(), DateUtil.YYYY_MM_DD_HH_MM));
//
////        MSTDVersion versionModel = versionClient.getVersion(mcdaDocument.getVersionCode());
////        cdaModel.setStaged(versionModel.isInStage() ? "1" : "0");
//
//        return cdaModel;
//    }
//
//}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/controller/StdCdaTypeController.java

@@ -0,0 +1,260 @@
//package com.yihu.jw.basic.standard.controller;
//
//import com.fasterxml.jackson.databind.ObjectMapper;
//import com.yihu.hos.common.constants.ContextAttributes;
//import com.yihu.hos.core.log.LogService;
//import com.yihu.hos.model.standard.CdaTypeDetailModel;
//import com.yihu.hos.standard.service.CDATypeFeginClient;
//import com.yihu.hos.system.model.SystemUser;
//import com.yihu.hos.web.framework.constant.ErrorCode;
//import com.yihu.hos.web.framework.constant.SessionAttributeKeys;
//import com.yihu.hos.web.framework.model.Envelop;
//import com.yihu.hos.web.framework.util.controller.BaseUIController;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.stereotype.Controller;
//import org.springframework.ui.Model;
//import org.springframework.util.StringUtils;
//import org.springframework.web.bind.annotation.RequestMapping;
//import org.springframework.web.bind.annotation.ResponseBody;
//import org.springframework.web.bind.annotation.SessionAttributes;
//
//import javax.servlet.http.HttpServletRequest;
//import java.util.HashMap;
//import java.util.Map;
//
///**
// * Created by AndyCai on 2015/12/14.
// */
//@RequestMapping(value = "/cdatype", produces = "application/json;charset=utf-8")
//@Controller
//@SessionAttributes(SessionAttributeKeys.CurrentUser)
//public class StdCdaTypeController extends BaseUIController {
//
//    @Autowired
//    private CDATypeFeginClient cDATypeFeginClient;
//
//    @Autowired
//    ObjectMapper objectMapper;
//
//    @RequestMapping("index")
//    public String cdaTypeInitial(Model model) {
//        model.addAttribute("contentPage", "std/cdaType/index");
//        return "pageView";
//    }
//
//    @RequestMapping("typeupdate")
//    public String typeupdate(Model model, HttpServletRequest request) {
//        SystemUser user = (SystemUser)request.getSession().getAttribute(ContextAttributes.USER_INFO);
//        model.addAttribute("UserId", user.getId());
//        model.addAttribute("contentPage", "std/cdaType/CdaTypeDetail");
//        return "pageView";
//    }
//
//    @RequestMapping("getTreeGridData")
//    @ResponseBody
//    //获取TreeData 用于初始页面显示嵌套model
//    public Object getTreeGridData(String codeName) {
//        Envelop envelop = new Envelop();
//        String url = "/cda_types/cda_types_tree";
//        String strResult = "";
//        if (StringUtils.isEmpty(codeName)){
//            codeName = "";
//        }
//        try{
//            Envelop res = cDATypeFeginClient.getCdaTypeTreeModels(codeName);
//            return toJson(res);
//        }catch(Exception ex){
//            LogService.getLogger(StdCdaTypeController.class).error(ex.getMessage());
//            envelop.setSuccessFlg(false);
//            envelop.setErrorMsg(ErrorCode.SystemError.toString());
//            return envelop;
//        }
//    }
//
//    @RequestMapping("GetCdaTypeList")
//    @ResponseBody
//    public Object getCdaTypeList(String strKey, Integer page, Integer rows) {
//        Envelop envelop = new Envelop();
//        String filters = "";
//        if(!StringUtils.isEmpty(strKey)){
//            filters = "code?"+strKey+" g1;name?"+strKey+" g1;";
//        }
//        try{
//            Envelop res= cDATypeFeginClient.searchCDATypesWithoutPaging(filters);
//            return toJson(res);
//        }catch (Exception ex){
//            LogService.getLogger(StdCdaTypeController.class).error(ex.getMessage());
//            envelop.setSuccessFlg(false);
//            envelop.setErrorMsg(ErrorCode.SystemError.toString());
//        }
//        return envelop;
//    }
//
//    @RequestMapping("getCdaTypeById")
//    @ResponseBody
//    public Object getCdaTypeById(String strIds) {
//        Envelop envelop = new Envelop();
//        try{
//            Envelop res = cDATypeFeginClient.getCdaTypeById(strIds);
//            return toJson(res);
//        }catch (Exception ex){
//            LogService.getLogger(StdCdaTypeController.class).error(ex.getMessage());
//            envelop.setSuccessFlg(false);
//            envelop.setErrorMsg(ErrorCode.SystemError.toString());
//        }
//        return envelop;
//    }
//
//    @RequestMapping("delteCdaTypeInfo")
//    @ResponseBody
//    /**
//     * 删除CDA类别，若该类别存在子类别，将一并删除子类别
//     * 先根据当前的类别ID获取全部子类别ID，再进行删除
//     * @param  ids  cdaType Id
//     *  @return result 操作结果
//     */
//    public Object delteCdaTypeInfo(String ids) {
//        Envelop result = new Envelop();
//        if (StringUtils.isEmpty(ids)){
//            result.setErrorMsg("请选择要删除的数据");
//            result.setSuccessFlg(false);
//            return result;
//        }
//        try{
//            String[] idsArray = ids.split(",");
//            boolean b = cDATypeFeginClient.deleteCDATypeByPatientIds(idsArray);
//            if(b){
//                result.setSuccessFlg(true);
//            }else{
//                result.setSuccessFlg(false);
//                result.setErrorMsg("cda类别删除失败");
//            }
//        }catch (Exception ex){
//            LogService.getLogger(StdCdaTypeController.class).error(ex.getMessage());
//            result.setSuccessFlg(false);
//            result.setErrorMsg(ErrorCode.SystemError.toString());
//        }
//        return result;
//    }
//
//    @RequestMapping("SaveCdaType")
//    @ResponseBody
//    //新增、修改的保存合二为一
//    public Object SaveCdaType(String dataJson,HttpServletRequest request) {
//        Envelop envelop = new Envelop();
//        envelop.setSuccessFlg(false);
//        String url = "/cda_types";
//        SystemUser userDetailModel = (SystemUser)request.getSession().getAttribute(ContextAttributes.USER_INFO);
//        String createUserId = userDetailModel.getLoginCode();
//        try {
//            CdaTypeDetailModel detailModel = objectMapper.readValue(dataJson,CdaTypeDetailModel.class);
//            if(StringUtils.isEmpty(detailModel.getCode())){
//                envelop.setErrorMsg("cda类别编码不能为空！");
//                return envelop;
//            }
//            if(StringUtils.isEmpty(detailModel.getName())){
//                envelop.setErrorMsg("cda类别名称不能为空！");
//                return envelop;
//            }
//            Map<String,Object> params = new HashMap<>();
//            String cdaTypeId = detailModel.getId();
//            // 新增cda类别
//            if(StringUtils.isEmpty(cdaTypeId)){
//                detailModel.setCreateUser(createUserId);
//                String jsonData = objectMapper.writeValueAsString(detailModel);
//                Envelop res = cDATypeFeginClient.saveCDAType(jsonData);
//                return toJson(res);
//            }
//            // 修改cda类别（先获取，再赋值）
//            Envelop envelopGet = cDATypeFeginClient.getCdaTypeById(cdaTypeId);
//            if (!envelopGet.isSuccessFlg()){
//                return toJson(envelopGet);
//            }
//            CdaTypeDetailModel modelForUpdate = getEnvelopModel(envelopGet.getObj(),CdaTypeDetailModel.class);
//            modelForUpdate.setCode(detailModel.getCode());
//            modelForUpdate.setDescription(detailModel.getDescription());
//            modelForUpdate.setName(detailModel.getName());
//            modelForUpdate.setParentId(detailModel.getParentId());
//            modelForUpdate.setUpdateUser(createUserId);
//            String typeJson = objectMapper.writeValueAsString(modelForUpdate);
//            params.put("jsonData", typeJson);
//            Envelop res = cDATypeFeginClient.updateCDAType(typeJson);
//            return toJson(res);
//        } catch (Exception ex){
//            LogService.getLogger(StdCdaTypeController.class).error(ex.getMessage());
//            envelop.setSuccessFlg(false);
//            envelop.setErrorMsg(ErrorCode.SystemError.toString());
//        }
//        return envelop;
//    }
//
//    /**
//     * 获取可以作为父类别的cda类别列表
//     * @param strId
//     * @param codeName
//     * @return
//     */
//    @RequestMapping("getCdaTypeExcludeSelfAndChildren")
//    @ResponseBody
//    public Object getCdaTypeExcludeSelfAndChildren(String strId, String codeName) {
//        //页面新增修改访问的是同个接口
//        Envelop envelop = new Envelop();
//        try{
//            //新增cda类别是获取的是所有类别
//            if(StringUtils.isEmpty(strId)){
//                String filters = "";
//                if(!StringUtils.isEmpty(codeName)){
//                    filters = "code?"+codeName+" g1;name?"+codeName+" g1;";
//                }
//                Envelop res = cDATypeFeginClient.searchCDATypesWithoutPaging(filters);
//                return toJson(res);
//            }
//            //修改时获取自身及其子类。。以外的cda类别
//            Envelop res = cDATypeFeginClient.getCdaTypeExcludeSelfAndChildren(strId);
//            return toJson(res);
//        }catch (Exception ex){
//            LogService.getLogger(StdCdaTypeController.class).error(ex.getMessage());
//            envelop.setSuccessFlg(false);
//            envelop.setErrorMsg(ErrorCode.SystemError.toString());
//            return envelop;
//        }
//
//    }
//
//    @RequestMapping("getCDATypeListByParentId")
//    @ResponseBody
//    //根据父级ID获取下一级cda类别（不含子类的子类。。）
//    public Object getCDATypeListByParentId(String ids) {
//        Envelop envelop = new Envelop();
//        try {
//            envelop = cDATypeFeginClient.getChildrenByPatientId(ids);
//            return envelop.getDetailModelList();
//        } catch (Exception ex) {
//            LogService.getLogger(StdCdaTypeController.class).error(ex.getMessage());
//            envelop.setSuccessFlg(false);
//            envelop.setErrorMsg(ErrorCode.SystemError.toString());
//        }
//        return envelop;
//    }
//
//
//    /**
//     * 删除cda类别前先判断是否有关联的cda文档
//     * @param ids
//     * @return
//     */
//    @RequestMapping("isExitRelativeCDA")
//    @ResponseBody
//    public Object isExitRelativeCDA(String ids){
//        Envelop envelop = new Envelop();
//        try{
//            envelop = cDATypeFeginClient.isExitRelativeCDA(ids.split(","));
//            return toJson(envelop);
//        }catch (Exception ex){
//            LogService.getLogger(StdCdaTypeController.class).error(ex.getMessage());
//            envelop.setSuccessFlg(false);
//            envelop.setErrorMsg(ErrorCode.SystemError.toString());
//            return envelop;
//        }
//    }
//}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/controller/StdDatasetController.java

@@ -26,6 +26,7 @@ import java.util.Map;
public class StdDatasetController extends EnvelopRestEndpoint {
    @Resource(name = StdDatasetService.BEAN_ID)
    private StdDatasetService stdDatasetService;
    /**
     * 查询数据集列表信息（get）
     * @param stdVersion

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/controller/StdDictEntryController.java

@@ -42,7 +42,7 @@ public class StdDictEntryController extends EnvelopRestEndpoint {
            @ApiParam(name = "stdVersion", value = "标准版本号")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "dictId", value = "字典ID")
            @RequestParam(value = "dictId") Integer dictId,
            @RequestParam(value = "dictId") Long dictId,
            @ApiParam(name = "condition", value = "查询条件")
            @RequestParam(value = "condition", required = false) String condition,
            @ApiParam(name = "order", value = "Order param,Must be json.ascending:asc,descending:desc")
@@ -70,7 +70,7 @@ public class StdDictEntryController extends EnvelopRestEndpoint {
            @ApiParam(name = "stdVersion", value = "stdVersion")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "dictEntryId", value = "字典ID")
            @RequestParam(value = "dictEntryId") Integer dictEntryId) {
            @RequestParam(value = "dictEntryId") Long dictEntryId) {
        return stdDictEntryService.delete(stdVersion, dictEntryId);
    }
@@ -100,7 +100,7 @@ public class StdDictEntryController extends EnvelopRestEndpoint {
            @ApiParam(name = "stdVersion", value = "标准版本号")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "dictId", value = "数据集ID")
            @RequestParam(value = "dictId") Integer dictId,
            @RequestParam(value = "dictId") Long dictId,
            @ApiParam(name = "q", value = "字典名称或编码", required = false)
            @RequestParam(value = "q", required = false) String q,
            @ApiParam(name = "initDictValue", value = "初始化字典名称或编码", required = false)

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/controller/StdMetadataController.java

@@ -46,7 +46,7 @@ public class StdMetadataController extends EnvelopRestEndpoint {
            @ApiParam(name = "stdVersion", value = "标准版本号")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "datasetId", value = "数据集ID")
            @RequestParam(value = "datasetId") Integer datasetId,
            @RequestParam(value = "datasetId") Long datasetId,
            @ApiParam(name = "condition", value = "查询条件")
            @RequestParam(value = "condition", required = false) String condition,
            @ApiParam(name = "order", value = "Order param,Must be json.ascending:asc,descending:desc")
@@ -74,7 +74,7 @@ public class StdMetadataController extends EnvelopRestEndpoint {
            @ApiParam(name = "stdVersion", value = "stdVersion")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "metadataId", value = "数据元ID")
            @RequestParam(value = "metadataId") Integer metadataId) {
            @RequestParam(value = "metadataId") Long metadataId) {
        return stdMetadataService.delete(stdVersion, metadataId);
    }
@@ -105,7 +105,7 @@ public class StdMetadataController extends EnvelopRestEndpoint {
            @ApiParam(name = "stdVersion", value = "标准版本号")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "datasetId", value = "数据集ID")
            @RequestParam(value = "datasetId") Integer datasetId,
            @RequestParam(value = "datasetId") Long datasetId,
            @ApiParam(name = "q", value = "数据元名称或编码", required = false)
            @RequestParam(value = "q", required = false) String q,
            @ApiParam(name = "initMetadataNm", value = "初始化数据元名称或编码", required = false)

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/controller/StdRedisEndPoint.java

@@ -0,0 +1,176 @@
package com.yihu.jw.basic.standard.controller;
import com.yihu.jw.basic.standard.service.redis.StdRedisService;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import com.yihu.jw.rm.svrBasic.ServiceApi;
import com.yihu.jw.util.thread.ContextAttributes;
import com.yihu.jw.util.thread.LocalContext;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
/**
 * @author hzp add at 20170425
 */
@RestController
@Api(value = "Redis", description = "Redis数据缓存服务")
public class StdRedisEndPoint extends EnvelopRestEndpoint {
    @Autowired
    private StdRedisService stdRedisService;
    @ApiOperation("通过version值获取版本名")
    @RequestMapping(value = ServiceApi.Redis.StdVersion, method = RequestMethod.GET)
    public String getStdVersion(@ApiParam(value = "key", defaultValue = "59083976eebd")
                                    @RequestParam("key") String key) {
        return stdRedisService.getStdVersion(key);
    }
    @ApiOperation("通过StdDataSet版本和id获取标准数据集编码")
    @RequestMapping(value = ServiceApi.Redis.StdDataSetCode, method = RequestMethod.GET)
    public String getDataSetCode(@ApiParam(value = "version", defaultValue = "")
                                 @RequestParam("version") String version,
                                 @ApiParam(value = "id", defaultValue = "")
                                 @RequestParam("id") String id){
        return stdRedisService.getDataSetCode(version, id);
    }
    @ApiOperation("通过StdDataSet版本和id获取标准数据集名称")
    @RequestMapping(value = ServiceApi.Redis.StdDataSetName, method = RequestMethod.GET)
    public String getDataSetName(@ApiParam(value = "version", defaultValue = "")
                                     @RequestParam("version") String version,
                                 @ApiParam(value = "id", defaultValue = "")
                                 @RequestParam("id") String id){
        return stdRedisService.getDataSetName(version, id);
    }
    @ApiOperation("通过StdDataSet版本和编码获取标准数据集名称")
    @RequestMapping(value = ServiceApi.Redis.StdDataSetNameByCode, method = RequestMethod.GET)
    public String getDataSetNameByCode(@ApiParam(value = "version", defaultValue = "")
                                           @RequestParam("version") String version,
                                       @ApiParam(value = "code", defaultValue = "")
                                           @RequestParam("code") String code){
        return stdRedisService.getDataSetNameByCode(version, code);
    }
    @ApiOperation("通过StdDataSet版本和编码获取标准数据集主从表信息")
    @RequestMapping(value = ServiceApi.Redis.StdDataSetMultiRecord, method = RequestMethod.GET)
    public Boolean getDataSetMultiRecord(@ApiParam(value = "version", defaultValue = "")
                                            @RequestParam("version") String version,
                                        @ApiParam(value = "code", defaultValue = "")
                                            @RequestParam("code") String code){
        return stdRedisService.getDataSetMultiRecord(version, code);
    }
    @ApiOperation("通过StdDataSet版本、编码以及标准数据元的内部编码获取标准数据元对应类型")
    @RequestMapping(value = ServiceApi.Redis.StdMetadataType, method = RequestMethod.GET)
    public String getMetaDataType(@ApiParam(value = "version", defaultValue = "")
                                      @RequestParam("version") String version,
                                  @ApiParam(value = "dataSetCode", defaultValue = "")
                                  @RequestParam("dataSetCode") String dataSetCode,
                                  @ApiParam(value = "innerCode", defaultValue = "")
                                  @RequestParam("innerCode") String innerCode) {
        return stdRedisService.getMetaDataType( version, dataSetCode , innerCode);
    }
    @ApiOperation("通过StdDataSet版本、编码以及标准数据元的内部编码获取标准数据元字典ID")
    @RequestMapping(value = ServiceApi.Redis.StdMetadataDict, method = RequestMethod.GET)
    public String getMetaDataDict(@ApiParam(value = "version", defaultValue = "")
                                      @RequestParam("version") String version,
                                  @ApiParam(value = "dataSetCode", defaultValue = "")
                                      @RequestParam("dataSetCode") String dataSetCode,
                                  @ApiParam(value = "innerCode", defaultValue = "")
                                      @RequestParam("innerCode") String innerCode) {
        return stdRedisService.getMetaDataDict(version, dataSetCode, innerCode);
    }
    @ApiOperation("通过StdDataSet版本、标准数据元字典ID以及标准数据元字典项编码获取标准数据元字典项值")
    @RequestMapping(value = ServiceApi.Redis.StdDictEntryValue, method = RequestMethod.GET)
    public String getDictEntryValue(@ApiParam(value = "version", defaultValue = "")
                                        @RequestParam("version") String version,
                                    @ApiParam(value = "dictId", defaultValue = "")
                                    @RequestParam("dictId") String dictId,
                                    @ApiParam(value = "entryCode", defaultValue = "")
                                    @RequestParam("entryCode") String entryCode) {
        return stdRedisService.getDictEntryValue(version, dictId , entryCode);
    }
    @ApiOperation("通过版本号,数据集code查找数据元,返回通过,分隔的数据元字符串")
    @RequestMapping(value = ServiceApi.Redis.StdMetadataCodes, method = RequestMethod.GET)
    public String getMetadataCodes(@ApiParam(value = "version", defaultValue = "")
                                   @RequestParam("version") String version,
                                   @ApiParam(value = "datasetCode", defaultValue = "")
                                   @RequestParam("datasetCode") String datasetCode){
        return stdRedisService.getMetadataCodes(version, datasetCode);
    }
    @ApiOperation("通过版本号、标准数据集code和数据元code 获取标准数据元名称")
    @RequestMapping(value = ServiceApi.Redis.StdMetadataName, method = RequestMethod.GET)
    public String getMetadataName(@ApiParam(value = "version", defaultValue = "")
                                   @RequestParam("version") String version,
                                   @ApiParam(value = "datasetCode", defaultValue = "")
                                   @RequestParam("datasetCode") String datasetCode,
                                  @ApiParam(value = "metadataCode", defaultValue = "")
                                  @RequestParam("metadataCode") String metadataCode){
        return stdRedisService.getMetadataName(version, datasetCode,metadataCode);
    }
    @ApiOperation("通过版本号、标准数据集code和数据元code 获取标准数据元是否为空")
    @RequestMapping(value = ServiceApi.Redis.StdMetadataNullable, method = RequestMethod.GET)
    public boolean isMetaDataNullable(@ApiParam(value = "version", defaultValue = "")
                                  @RequestParam("version") String version,
                                  @ApiParam(value = "datasetCode", defaultValue = "")
                                  @RequestParam("datasetCode") String datasetCode,
                                  @ApiParam(value = "metadataCode", defaultValue = "")
                                  @RequestParam("metadataCode") String metadataCode){
        return stdRedisService.isMetaDataNullable(version, datasetCode,metadataCode);
    }
    @ApiOperation("通过版本号、标准数据集code和数据元code 获取标准数据元是否为空")
    @RequestMapping(value = ServiceApi.Redis.StdMetadataFormat, method = RequestMethod.GET)
    public String getMetadataFormat(@ApiParam(value = "version", defaultValue = "")
                                      @RequestParam("version") String version,
                                      @ApiParam(value = "datasetCode", defaultValue = "")
                                      @RequestParam("datasetCode") String datasetCode,
                                      @ApiParam(value = "metadataCode", defaultValue = "")
                                      @RequestParam("metadataCode") String metadataCode){
        return stdRedisService.getMetadataFormat(version, datasetCode,metadataCode);
    }
    @ApiOperation("Redis缓存标准版本")
    @RequestMapping(value = ServiceApi.Redis.InitVersions, method = RequestMethod.POST)
    public String cacheVersions(
            @ApiParam(name = "versions", value = "版本列表，使用逗号分隔", defaultValue = "59083976eebd")
            @RequestParam("versions") String versions,
            @ApiParam(name = "force", value = "强制清除再缓存", defaultValue = "true")
            @RequestParam("force") boolean force) throws Exception {
        String schema = LocalContext.getContext().getAttachment(ContextAttributes.SCHEMA);
        stdRedisService.cacheVersions(versions, force,schema);
        return "Redis缓存标准版本完成！";
    }
    @ApiOperation("通过StdDataSet版本、标准数据元字典ID以及标准数据元字典项编码判断编码是否存在")
    @RequestMapping(value = ServiceApi.Redis.StdDictEntryCodeExist, method = RequestMethod.GET)
    public Boolean isDictCodeExist(
            @ApiParam(value = "version", defaultValue = "")
            @RequestParam("version") String version,
            @ApiParam(value = "dictId", defaultValue = "")
            @RequestParam("dictId") String dictId,
            @ApiParam(value = "entryCode", defaultValue = "")
            @RequestParam("entryCode") String entryCode) {
        return stdRedisService.isDictCodeExist(version, dictId, entryCode);
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/dao/IStdDataSetModelDao.java

@@ -8,5 +8,5 @@ import com.yihu.jw.basic.standard.dao.XSQLGeneralDAO;
 * Created by Administrator on 2016/5/4.
 */
public interface IStdDataSetModelDao extends XSQLGeneralDAO {
    public StdDataSetModel getDatasetName(String version ,Integer id);
    public StdDataSetModel getDatasetName(String version ,Long id);
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/dao/IStdDictionaryModelDao.java

@@ -8,5 +8,5 @@ import com.yihu.jw.basic.standard.dao.XSQLGeneralDAO;
 * Created by Administrator on 2016/5/4.
 */
public interface IStdDictionaryModelDao extends XSQLGeneralDAO {
    public StdDictionaryModel getDictionaryName(String version, Integer id);
    public StdDictionaryModel getDictionaryName(String version, Long id);
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/dao/QcRuleMetadataDao.java

@@ -0,0 +1,27 @@
package com.yihu.jw.basic.standard.dao;
import com.yihu.jw.basic.standard.model.qc.QcRuleMetadata;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.Restrictions;
import org.springframework.stereotype.Repository;
/**
 * 数据元与质控规则关系表 DAO
 *
 * @author 张进军
 * @date 2018/3/2
 */
@Repository
public class QcRuleMetadataDao extends SQLGeneralDAO {
    public String findRuleCodeByType(String type) {
        Session session = getCurrentSession();
        Criteria criteria = session.createCriteria(QcRuleMetadata.class);
        criteria.add(Restrictions.eq("type", type));
        QcRuleMetadata qcRuleMetadata = (QcRuleMetadata) criteria.uniqueResult();
        return qcRuleMetadata.getQcRuleCode();
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/dao/RuleDao.java

@@ -0,0 +1,84 @@
package com.yihu.jw.basic.standard.dao;
import com.yihu.jw.basic.standard.model.Result;
import com.yihu.jw.basic.standard.model.qc.RuleModel;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.Restrictions;
import org.springframework.stereotype.Repository;
import org.springframework.util.StringUtils;
import java.util.List;
import java.util.Map;
/**
 * @author CD
 * @vsrsion 1.0
 * Created at 2017/05/05.
 */
@Repository("ruleDao")
public class RuleDao extends SQLGeneralDAO {
    public static final String BEAN_ID = "ruleDao";
    public Result getRuleList(Map<String, Object> params) throws Exception {
        StringBuilder sb = new StringBuilder("from RuleModel r where 1=1 ");
        Object name = params.get("name");
        if (!StringUtils.isEmpty(name)) {
            sb.append(" and r.name like '%" + name + "%'");
        }
        String page = (String)params.get("page");
        String rows = (String)params.get("rows");
        if(StringUtils.isEmpty(page) || StringUtils.isEmpty(rows)){
            return super.getDataGridResult(sb.toString(), null,null);
        }
        return super.getDataGridResult(sb.toString(), Integer.valueOf(page), Integer.valueOf(rows));
    }
    public List<RuleModel> getRuleList(String name) throws Exception {
        StringBuilder sb = new StringBuilder("from RuleModel r where 1=1 ");
        if (!StringUtils.isEmpty(name)) {
            sb.append(" and r.name like '%" + name + "%'");
        }
        return (List<RuleModel>) getCurrentSession().createQuery(sb.toString());
    }
    public List<RuleModel> getAllByIdList(List<String> idList) {
        Session session = getCurrentSession();
        Criteria criteria = session.createCriteria(RuleModel.class);
        criteria.add(Restrictions.in("id", idList));
        return criteria.list();
    }
    public RuleModel getByRule(String rule) {
        Session session = getCurrentSession();
        Criteria criteria = session.createCriteria(RuleModel.class);
        criteria.add(Restrictions.eq("rule", rule));
        List<RuleModel> ruleModels = criteria.list();
        if (ruleModels == null || ruleModels.size() == 0) {
            return null;
        }
        return ruleModels.get(0);
    }
    public RuleModel getByCode(String code) {
        RuleModel ruleModel = new RuleModel();
        if (!StringUtils.isEmpty(code)) {
            Session session = getCurrentSession();
            Criteria criteria = session.createCriteria(RuleModel.class);
            criteria.add(Restrictions.eq("code", code));
            ruleModel = (RuleModel) criteria.uniqueResult();
        }
        return ruleModel;
    }
    public List<RuleModel> getByRuleMethod(String ruleMethod) {
        Session session = getCurrentSession();
        Criteria criteria = session.createCriteria(RuleModel.class);
        criteria.add(Restrictions.eq("ruleMethod", ruleMethod));
        List<RuleModel> ruleModels = criteria.list();
        return ruleModels;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/dao/SQLGeneralDAO.java

@@ -4,9 +4,14 @@ import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.JsonNodeType;
import com.yihu.jw.basic.standard.model.DataGridResult;
import com.yihu.jw.basic.standard.model.Result;
import com.yihu.jw.basic.standard.model.standard.StdDataSetModel;
import com.yihu.jw.basic.standard.service.bo.AdapterVersion;
import com.yihu.jw.basic.standard.service.bo.StandardVersion;
import com.yihu.jw.util.common.NumberUtil;
import com.yihu.jw.util.common.StringUtil;
import com.yihu.jw.util.sql.SqlCreator;
import org.apache.commons.lang3.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
@@ -19,22 +24,19 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Table;
import java.io.IOException;
import java.io.Serializable;
import java.math.BigInteger;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.*;
/**
@@ -42,10 +44,13 @@ import java.util.Map;
 * @vsrsion 1.0
 * Created at 2016/8/8.
 */
@Transactional
@Repository("sqlGeneralDAO")
public class SQLGeneralDAO implements XSQLGeneralDAO {
    static private final Logger logger = LoggerFactory.getLogger(SQLGeneralDAO.class);
//    @Autowired
//    protected LocalSessionFactoryBean localSessionFactoryBean;
    @Autowired
    protected ObjectMapper objectMapper;
@@ -104,6 +109,23 @@ public class SQLGeneralDAO implements XSQLGeneralDAO {
        return dataGridResult;
    }
    public boolean delete(Class tclass, Object[] ids, String dataType, String version) {
        if (ids == null || ids.length == 0)
            return false;
        StandardVersion standardVersion = new StandardVersion(version);
        String tableName = standardVersion.getTableName(dataType);
        String hql =
                "DELETE FROM " + tableName +
                        " WHERE id in (:ids) ";
        Query query = this.getCurrentSession().createQuery(hql);
        query.setParameterList("ids", ids);
        return query.executeUpdate() > 0;
    }
    public void beginTransaction() throws Exception {
        currentSession().getTransaction().begin();
    }
@@ -151,6 +173,10 @@ public class SQLGeneralDAO implements XSQLGeneralDAO {
        return currentSession().get(cls, id);
    }
    public <T> T retrieve(Class<T> tclass,String tableName,Object id){
        return (T) get(tclass,tableName,id);
    }
    public List<Map<String, Object>> queryListBySql(String sql) throws Exception {
        List result = this.jdbcTemplate.queryForList(sql);
        return result;
@@ -237,7 +263,7 @@ public class SQLGeneralDAO implements XSQLGeneralDAO {
        if (limit != null) {
            criteria.setMaxResults(limit.intValue());
            if (offset != null) {
            if (offset != null &&offset>0) {
                criteria.setFirstResult((offset.intValue() - 1) * limit.intValue());
            }
        }
@@ -284,7 +310,7 @@ public class SQLGeneralDAO implements XSQLGeneralDAO {
        if (limit != null) {
            criteria.setMaxResults(limit.intValue());
            if (offset != null) {
            if (offset != null &&offset>0) {
                criteria.setFirstResult((offset.intValue() - 1) * limit.intValue());
            }
        }
@@ -334,7 +360,7 @@ public class SQLGeneralDAO implements XSQLGeneralDAO {
        Query query1 = this.getQuery(sqlCreator, sql1);
        if (limit != null) {
            query1.setMaxResults(limit.intValue());
            if (offset != null) {
            if (offset != null &&offset>0) {
                query1.setFirstResult(offset.intValue() * limit.intValue());
            }
        }
@@ -394,6 +420,23 @@ public class SQLGeneralDAO implements XSQLGeneralDAO {
        return query.uniqueResult();
    }
    public Object get(Class tClass, String stdVersion, String dataType, String id) {
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            if (id != null) {
                String tableName = standardVersion.getTableName(dataType);
                SqlCreator sqlCreator = new SqlCreator(tClass);
                sqlCreator.equalCondition("id", id);
                String sql = sqlCreator.selectData(tableName);
                Query query = getQuery(sqlCreator, sql);
                return query.uniqueResult();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Result.error("获取标准数据元失败");
    }
    public Query getQuery(SqlCreator sqlCreator, String sql) {
        SQLQuery query = this.getCurrentSession().createSQLQuery(sql);
        Iterator var4 = sqlCreator.getKeyValueMap().keySet().iterator();
@@ -428,11 +471,11 @@ public class SQLGeneralDAO implements XSQLGeneralDAO {
        return currentSession();
    }
    public Integer getMaxId(String tableName) {
    public Long getMaxId(String tableName) {
        String sql = "select max(id) from " + tableName;
        SQLQuery query = this.getCurrentSession().createSQLQuery(sql);
        Object object = query.uniqueResult();
        Integer maxId = Integer.valueOf(object == null ? 1 : Integer.parseInt(object.toString()) + 1);
        Long maxId = object == null ? 1L : (Long.parseLong(object.toString()) + 1);
        return maxId;
    }
@@ -483,6 +526,303 @@ public class SQLGeneralDAO implements XSQLGeneralDAO {
                var5.printStackTrace();
            }
        }
    }
    public String getTableName(Class<?> clazz) {
        Table table = (Table) clazz.getAnnotation(Table.class);
        return table.name();
    }
    public List searchVersionData(Class tClass, String stdVersion,String dataType, String condition) throws IOException {
        return searchVersionData(tClass,stdVersion,dataType,condition,null,null,null);
    }
    public List searchVersionData(Class tClass, String stdVersion,String dataType, String condition, String order, Integer page, Integer size) throws IOException {
        String tableName = null;
        if (!StringUtil.isEmpty(stdVersion)) {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            tableName = standardVersion.getTableName(dataType);
        } else {
            tableName = getTableName(tClass);
        }
        SqlCreator sqlCreator = new SqlCreator(tClass);
        //where
        if (!StringUtil.isEmpty(condition)) {
            String[] filterArray = condition.split(";");
            for (int i = 0; i < filterArray.length; ++i) {
                String[] tokens = filterArray[i].split("=");
                if (tokens.length > 2) {
                    for (int j = 1; j < tokens.length; j++) {
                        if (j == tokens.length - 1)
                            tokens[1] = tokens[j];
                        else
                            tokens[0] += " " + tokens[j];
                    }
                }
//            if (tokens.length > 2) throw new IllegalArgumentException("无效过滤参数");
                String group = null;
                if (tokens.length >= 2) group = tokens[1];
                if (group == null)
                    group = Integer.toString(i);
                sqlCreator.likeCondition(tokens[0], tokens[1]);
            }
        }
        //order
        if (StringUtils.isNotEmpty(order)) {
            String[] orderArray = order.split(",");
            for (String elem : orderArray) {
                String value = elem.startsWith("+") ? "ASC" : "DESC";
                sqlCreator.order(elem.substring(1), value);
            }
        }
        String sql = sqlCreator.selectData(tableName);
        Query query = getQuery(sqlCreator, sql);
        if (size != null) {
            query.setMaxResults(size);
            if (page != null) {
                query.setFirstResult((page - 1) * size);
            }
        }
        return query.list();
    }
    public Long searchVersionCount(Class tClass, String stdVersion, String dataType, String condition) throws IOException {
        String tableName = null;
        if (!StringUtil.isEmpty(stdVersion)) {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            tableName = standardVersion.getTableName(dataType);
        } else {
            tableName = getTableName(tClass);
        }
        SqlCreator sqlCreator = new SqlCreator(tClass);
        //where
        if (!StringUtil.isEmpty(condition)) {
            String[] filterArray = condition.split(";");
            for (int i = 0; i < filterArray.length; ++i) {
                String[] tokens = filterArray[i].split("=");
                if (tokens.length > 2) {
                    for (int j = 1; j < tokens.length; j++) {
                        if (j == tokens.length - 1)
                            tokens[1] = tokens[j];
                        else
                            tokens[0] += " " + tokens[j];
                    }
                }
//            if (tokens.length > 2) throw new IllegalArgumentException("无效过滤参数");
                String group = null;
                if (tokens.length >= 2) group = tokens[1];
                if (group == null)
                    group = Integer.toString(i);
                sqlCreator.likeCondition(tokens[0], tokens[1]);
            }
        }
        String sql = sqlCreator.countData(tableName);
        Query query = getCurrentSession().createSQLQuery(sql);
        for (String key : sqlCreator.getKeyValueMap().keySet()) {
            query.setParameter(key, sqlCreator.getKeyValueMap().get(key));
        }
        Long count = Long.valueOf(StringUtil.toString(query.list().get(0)));
        return count;
    }
    public Long searchCount(Class tClass, String stdVersion, String dataType, String condition) throws IOException {
        String tableName = null;
        if (!StringUtil.isEmpty(stdVersion)) {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            tableName = standardVersion.getTableName(dataType);
        } else {
            tableName = getTableName(tClass);
        }
        SqlCreator sqlCreator = new SqlCreator(tClass);
        //where
        if (!StringUtil.isEmpty(condition)) {
            Map<String, List<String>> whereMap = new HashMap<>();
            String[] filterArray = condition.split(";");
            for (int i = 0; i < filterArray.length; ++i) {
                String[] tokens = filterArray[i].split(" ");
                if (tokens.length > 2) {
                    for (int j = 1; j < tokens.length; j++) {
                        if (j == tokens.length - 1)
                            tokens[1] = tokens[j];
                        else
                            tokens[0] += " " + tokens[j];
                    }
                }
                String group = null;
                if (tokens.length >= 2)
                    group = tokens[1];
                if (group == null)
                    group = Integer.toString(i);
                List<String> list = whereMap.get(group);
                if(list==null || list.size()==0){
                    list = new ArrayList<String>();
                    list.add(tokens[0]);
                }else{
                    list.add(tokens[0]);
                }
                whereMap.put(group,list);
            }
            Collection<List<String>> lists = whereMap.values();
            for(List<String> whereCondition :lists){
                sqlCreator.makeWhere(whereCondition);
            }
        }
        String sql = sqlCreator.countData(tableName);
        Query query = getCurrentSession().createSQLQuery(sql);
        for (String key : sqlCreator.getKeyValueMap().keySet()) {
            query.setParameter(key, sqlCreator.getKeyValueMap().get(key));
        }
        Long count = Long.valueOf(StringUtil.toString(query.list().get(0)));
        return count;
    }
    //这边不支持分组条件查询,如需要分组查询
    //因为调用的地方太多,未做大改造,新增了  searchPage 方法
    public List searchPageData(Class tClass,String dataType, String stdVersion, String condition, String order, Integer offset, Integer limit) throws IOException {
        StandardVersion standardVersion = new StandardVersion(stdVersion);
        String tableName = standardVersion.getTableName(dataType);
        SqlCreator sqlCreator = new SqlCreator(tClass);
        //where
        if (!StringUtil.isEmpty(condition)) {
            String[] filterArray = condition.split(";");
            for (int i = 0; i < filterArray.length; ++i) {
                String[] tokens = filterArray[i].split("=");
                if (tokens.length > 2){
                    for(int j=1; j<tokens.length; j++){
                        if(j==tokens.length-1)
                            tokens[1] = tokens[j];
                        else
                            tokens[0] += " " + tokens[j] ;
                    }
                }
//            if (tokens.length > 2) throw new IllegalArgumentException("无效过滤参数");
                String group = null;
                if (tokens.length >= 2) group = tokens[1];
                if (group == null)
                    group = Integer.toString(i);
                if(tokens[1].contains(",")){
                    sqlCreator.inCondition(tokens[0],tokens[1]);
                }else{
                    sqlCreator.equalConditionQue(tokens[0],tokens[1]);
                }
            }
        }
        //order
        String sql = sqlCreator.selectData(tableName);
        if (StringUtils.isNotEmpty(order)) {
            sql += " order by "+order;
        }
        if(limit != null){
            if (offset != null &&offset>0) {
                sql += " limit "+ (offset - 1) * limit+","+limit;
            }else {
                sql += " limit " +limit;
            }
        }
        return jdbcTemplate.query(sql,new BeanPropertyRowMapper<>(tClass));
    }
    public List searchPage(Class tClass,String dataType, String version, String condition, String order, Integer offset, Integer limit,boolean isStandard) throws IOException {
        String tableName;
        if(isStandard){
            StandardVersion standardVersion = new StandardVersion(version);
            tableName = standardVersion.getTableName(dataType);
        }else{
            AdapterVersion adapterVersion = new AdapterVersion(version);
            tableName = adapterVersion.getTableName(dataType);
        }
        SqlCreator sqlCreator = new SqlCreator(tClass);
        //where
        if (!StringUtil.isEmpty(condition)) {
            Map<String, List<String>> whereMap = new HashMap<>();
            String[] filterArray = condition.split(";");
            for (int i = 0; i < filterArray.length; ++i) {
                String[] tokens = filterArray[i].split(" ");
                if (tokens.length > 2) {
                    for (int j = 1; j < tokens.length; j++) {
                        if (j == tokens.length - 1)
                            tokens[1] = tokens[j];
                        else
                            tokens[0] += " " + tokens[j];
                    }
                }
                String group = null;
                if (tokens.length >= 2)
                    group = tokens[1];
                if (group == null)
                    group = Integer.toString(i);
                List<String> list = whereMap.get(group);
                if(list==null || list.size()==0){
                    list = new ArrayList<String>();
                    list.add(tokens[0]);
                }else{
                    list.add(tokens[0]);
                }
                whereMap.put(group,list);
            }
            Collection<List<String>> lists = whereMap.values();
            for(List<String> whereCondition :lists){
                sqlCreator.makeWhere(whereCondition);
            }
        }
        //order
        if (StringUtils.isNotEmpty(order)) {
            String[] orderArray = order.split(",");
            for(String elem : orderArray){
                String value = elem.startsWith("-") ? "DESC" : "ASC";
                sqlCreator.order(elem.substring(1), value);
            }
        }
        String sql = sqlCreator.selectData(tableName);
        Query query = getQuery(sqlCreator, sql);
        if (limit != null) {
            query.setMaxResults(limit);
            if (offset != null &&offset>0) {
                query.setFirstResult((offset - 1) * limit);
            }
        }
        return query.list();
    }
    public boolean deleteByField(String field, Object[] ids, String dataType, String version) {
        if (ids == null || ids.length == 0)
            return false;
        StandardVersion standardVersion = new StandardVersion(version);
        String tableName = standardVersion.getTableName(dataType);
        String sql =
                "DELETE FROM " + tableName +
                        " WHERE " + field + " in (:ids) ";
        Query query = this.getCurrentSession().createSQLQuery(sql);
        query.setParameterList("ids", ids);
        return query.executeUpdate() > 0;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/dao/StdDataSetModelDao.java

@@ -16,7 +16,7 @@ import org.springframework.stereotype.Repository;
public class StdDataSetModelDao extends SQLGeneralDAO implements IStdDataSetModelDao {
    @Override
    @Cacheable
    public StdDataSetModel getDatasetName(String version ,Integer id){
    public StdDataSetModel getDatasetName(String version ,Long id){
        StringBuffer sql = new StringBuffer();
        sql.append("SELECT d.*").append(" FROM std_dataset_").append(version).append(" d where d.id ="+id);
        try {

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/dao/StdDictionaryModelDao.java

@@ -19,7 +19,7 @@ public class StdDictionaryModelDao extends SQLGeneralDAO implements IStdDictiona
    @Override
    @Cacheable
    public StdDictionaryModel getDictionaryName(String version, Integer id) {
    public StdDictionaryModel getDictionaryName(String version, Long id) {
        StringBuffer sql = new StringBuffer();
        sql.append("SELECT d.*").append(" FROM std_dictionary_").append(version).append(" d where d.id =" + id);
        try {

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/dao/XSQLGeneralDAO.java

@@ -72,7 +72,7 @@ public interface XSQLGeneralDAO {
    Query getExeuteQuery(SqlCreator var1, String var2);
    Integer getMaxId(String var1);
    Long getMaxId(String var1);
    void insertBatch(List<String> var1);

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/match/dictionary/DictitemStandardExistStrategy.java

@@ -70,7 +70,7 @@ public class DictitemStandardExistStrategy {
        String dictitemNameFirstCode = GetChineseFirst.cn2py(adapterDictEntryModel.getStdEntryValue());//待匹配
        List<AdapterDictEntryModel> matchList = matchVO.getCodeAdapter().get(dictitemNameFirstCode);//已存在
        if (matchList != null && matchList.size() > 0) {
            Integer unAdaptDicId = adapterDictEntryModel.getStdDictId();
            Long unAdaptDicId = adapterDictEntryModel.getStdDictId();
            StdDictionaryModel stdDictionaryModel = stdDictionaryDao.getDictionaryName(std_version,unAdaptDicId);
            StdDictionaryModel adapterDictionaryModel = stdDictionaryDao.getDictionaryName(adapter_std_version,unAdaptDicId);
            if(stdDictionaryModel!=null){

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/match/metadata/MetatdataStandardExistStrategy.java

@@ -84,7 +84,7 @@ public class MetatdataStandardExistStrategy extends SQLGeneralDAO {
            List<AdapterMetadataModel> adapterMetadatas = matchVO.getCodeAdapter().get(metadataNameFirstCode);//已存在
            if (adapterMetadatas != null && adapterMetadatas.size() > 0) {
                //获取待适配的数据集名
                Integer unAdaptStdId = strategyMetadata.getStdDatasetId();
                Long unAdaptStdId = strategyMetadata.getStdDatasetId();
                StdDataSetModel stdDataset = stdDataSetModelDao.getDatasetName(std_version, unAdaptStdId);
                StdDataSetModel adapterDataset = stdDataSetModelDao.getDatasetName(adapter_std_version, unAdaptStdId);
                if(stdDataset!=null){

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/BaseCDADataSetRelationship.java

@@ -0,0 +1,69 @@
package com.yihu.jw.basic.standard.model;
import javax.persistence.*;
import java.io.Serializable;
/**
 * @author AndyCai
 * @version 1.0
 * @created 01-9月-2015 17:08:41
 */
public class BaseCDADataSetRelationship extends Result implements Serializable {
    @Id
    @Column(name = "id", unique = true, nullable = false)
    private String id;
    @Column(name = "cda_id", unique = true, nullable = false)
    private String cdaId;
    @Column(name = "dataset_id", unique = true, nullable = false)
    private String dataSetId;
    @Column(name="std_id")
    private Long standardId;           //标准ID
    @Column(name="std_version")
    private String stdVersion;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getCdaId() {
        return cdaId;
    }
    public void setCdaId(String cdaId) {
        this.cdaId = cdaId;
    }
    public String getDataSetId() {
        return dataSetId;
    }
    public void setDataSetId(String dataSetId) {
        this.dataSetId = dataSetId;
    }
    public Long getStandardId() {
        return standardId;
    }
    public void setStandardId(Long standardId) {
        this.standardId = standardId;
    }
    public String getStdVersion() {
        return stdVersion;
    }
    public void setStdVersion(String stdVersion) {
        this.stdVersion = stdVersion;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/BaseCDADocument.java

@@ -0,0 +1,209 @@
package com.yihu.jw.basic.standard.model;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.beans.factory.annotation.Value;
import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;
import javax.persistence.Transient;
import java.io.Serializable;
import java.util.Date;
import java.util.Objects;
/**
 * @author AndyCai
 * @version 1.0
 * @created 01-9月-2015 16:54:17
 */
public class BaseCDADocument extends Result implements Serializable {
    @Transient
//    @Value("${admin-region}")
    short adminRegion;
    @Id
    @Column(name = "id", unique = true, nullable = false)
    private String id;
    @Column(name = "code", unique = false, nullable = false)
    private String code;
    @Column(name = "name", unique = false, nullable = false)
    private String name;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+08:00")
    @Column(name = "create_date", unique = false, nullable = false)
    private Date createDate;
    @Column(name = "create_user", unique = false, nullable = false)
    private String createUser;
    @Column(name = "description", unique = false, nullable = true)
    private String description;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+08:00")
    @Column(name = "update_date", unique = false, nullable = true)
    private Date updateDate;
    @Column(name = "update_user", unique = false, nullable = true)
    private String updateUser;
    @Transient
    private String versionCode;
    @Column(name = "type", unique = false, nullable = false)
    private String type;
    @Column(name = "print_out", unique = false, nullable = true)
    private String printOut;
    @Column(name = "schema_path", unique = false, nullable = true)
    private String schema;
    @Column(name = "source_id", unique = false, nullable = false)
    private String sourceId;
    @Column(name = "hash", unique = false, nullable = true)
    private int hashCode;
    @Column(name = "file_group", unique = false, nullable = true)
    private String fileGroup;
    @Transient
    private String staged;
    @Column(name="std_id")
    private Long standardId;           //标准ID
    @Column(name="std_version")
    private String stdVersion;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Date getCreateDate() {
        return createDate;
    }
    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }
    public String getCreateUser() {
        return createUser;
    }
    public void setCreateUser(String createUser) {
        this.createUser = createUser;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
    public Date getUpdateDate() {
        return updateDate;
    }
    public void setUpdateDate(Date updateDate) {
        this.updateDate = updateDate;
    }
    public String getUpdateUser() {
        return updateUser;
    }
    public void setUpdateUser(String updateUser) {
        this.updateUser = updateUser;
    }
    public String getVersionCode() {
        return versionCode;
    }
    public void setVersionCode(String versionCode) {
        this.versionCode = versionCode;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public String getPrintOut() {
        return printOut;
    }
    public void setPrintOut(String printOut) {
        this.printOut = printOut;
    }
    public String getSchema() {
        return schema;
    }
    public void setSchema(String schema) {
        this.schema = schema;
    }
    public String getSourceId() {
        return sourceId;
    }
    public void setSourceId(String sourceId) {
        this.sourceId = sourceId;
    }
    public int getHashCode() {
        hashCode = Objects.hash(id, code, createDate, createUser, name, printOut, schema, sourceId);
        return hashCode;
    }
    public void setHashCode(int hashCode) {
        this.hashCode = hashCode;
    }
    public String getFileGroup() {
        return fileGroup;
    }
    public void setFileGroup(String fileGroup) {
        this.fileGroup = fileGroup;
    }
    public String getStaged() {
        return staged;
    }
    public void setStaged(String staged) {
        this.staged = staged;
    }
    public Long getStandardId() {
        return standardId;
    }
    public void setStandardId(Long standardId) {
        this.standardId = standardId;
    }
    public String getStdVersion() {
        return stdVersion;
    }
    public void setStdVersion(String stdVersion) {
        this.stdVersion = stdVersion;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/CDADataSetRelationship.java

@@ -0,0 +1,10 @@
package com.yihu.jw.basic.standard.model;
/**
 * @author AndyCai
 * @version 1.0
 * @created 01-9月-2015 17:08:41
 */
public class CDADataSetRelationship extends BaseCDADataSetRelationship {
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/CDADocument.java

@@ -0,0 +1,12 @@
package com.yihu.jw.basic.standard.model;
/**
 * @author AndyCai
 * @version 1.0
 * @created 01-9月-2015 16:54:17
 */
public class CDADocument extends BaseCDADocument {
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/CDAType.java

@@ -0,0 +1,129 @@
package com.yihu.jw.basic.standard.model;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.*;
import java.util.Date;
/**
 * CDA类型
 *
 * @author AndyCai
 * @version 1.0
 * @created 11-12月-2015 15:52:22
 */
@Entity
@Table(name = "std_cda_type")
public class CDAType {
    @Id
    @GeneratedValue(generator = "Generator")
    @GenericGenerator(name = "Generator", strategy = "assigned")
    @Column(name = "id", unique = true, nullable = false)
    private String id;
    @Column(name = "code",  nullable = false)
    private String code;
    @Column(name = "name",  nullable = false)
    private String name;
    @Column(name = "parent_id",  nullable = true)
    private String parentId;
    @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+08:00")
    @Column(name = "create_date",  nullable = true)
    private Date createDate;
    @Column(name = "create_user",  nullable = true)
    private String createUser;
    @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+08:00")
    @Column(name = "update_date",  nullable = true)
    private Date updateDate;
    @Column(name = "update_user",  nullable = true)
    private String updateUser;
    @Column(name = "description",  nullable = true)
    private String description;
    public CDAType() {
    }
    public String getId() {
        return this.id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getCode() {
        return this.code;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
    public void setParentId(String parentId) {
        this.parentId = parentId;
    }
    public String getParentId() {
        return this.parentId;
    }
    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }
    public Date getCreateDate() {
        return this.createDate;
    }
    public void setCreateUser(String createUser) {
        this.createUser = createUser;
    }
    public String getCreateUser() {
        return this.createUser;
    }
    public void setUpdateDate(Date updateDate) {
        this.updateDate = updateDate;
    }
    public Date getUpdateDate() {
        return this.updateDate;
    }
    public void setUpdateUser(String updateUser) {
        this.updateUser = updateUser;
    }
    public String getUpdateUser() {
        return this.updateUser;
    }
//    public CDAType getParentCdaType() {
//
////        XCDATypeManager xcdaTypeManager = ServiceFactory.getService(Services.CDATypeManager);
////        List<XCDAType> listType = xcdaTypeManager.getCdatypeInfoByIds(this.parentId);
////        if (listType.size() > 0) {
////            return (CDAType) listType.get(0);
////        }
//        return null;
//    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/adapter/AdapterDatasetModel.java

@@ -5,6 +5,7 @@ import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import java.io.Serializable;
@@ -13,46 +14,45 @@ import java.io.Serializable;
 */
public class AdapterDatasetModel extends Result implements Serializable {
    @Id
    @GeneratedValue(generator = "generator")
    @GenericGenerator(name = "generator", strategy = "increment")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;
    private Long id;
    @Column(name = "scheme_id")
    private Integer schemeId;
    private Long schemeId;
    @Column(name = "std_dataset_id")
    private Integer stdDatasetId;
    private Long stdDatasetId;
    @Column(name = "std_dataset_code")
    private String stdDatasetCode;
    @Column(name = "std_dataset_name")
    private String stdDatasetName;
    @Column(name = "adapter_dataset_id")
    private Integer adapterDatasetId;
    private Long adapterDatasetId;
    @Column(name = "adapter_dataset_code")
    private String adapterDatasetCode;
    @Column(name = "adapter_dataset_name")
    private String adapterDatasetName;
    public Integer getId() {
    public Long getId() {
        return id;
    }
    public void setId(Integer id) {
    public void setId(Long id) {
        this.id = id;
    }
    public Integer getSchemeId() {
    public Long getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
    public void setSchemeId(Long schemeId) {
        this.schemeId = schemeId;
    }
    public Integer getStdDatasetId() {
    public Long getStdDatasetId() {
        return stdDatasetId;
    }
    public void setStdDatasetId(Integer stdDatasetId) {
    public void setStdDatasetId(Long stdDatasetId) {
        this.stdDatasetId = stdDatasetId;
    }
@@ -72,11 +72,11 @@ public class AdapterDatasetModel extends Result implements Serializable {
        this.stdDatasetName = stdDatasetName;
    }
    public Integer getAdapterDatasetId() {
    public Long getAdapterDatasetId() {
        return adapterDatasetId;
    }
    public void setAdapterDatasetId(Integer adapterDatasetId) {
    public void setAdapterDatasetId(Long adapterDatasetId) {
        this.adapterDatasetId = adapterDatasetId;
    }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/adapter/AdapterDatasetRelationModel.java

@@ -5,6 +5,7 @@ import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import java.io.Serializable;
@@ -13,56 +14,55 @@ import java.io.Serializable;
 */
public class AdapterDatasetRelationModel extends Result implements Serializable {
    @Id
    @GeneratedValue(generator = "generator")
    @GenericGenerator(name = "generator", strategy = "increment")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;
    private Long id;
    @Column(name = "scheme_id")
    private Integer schemeId;
    private Long schemeId;
    @Column(name = "master_dataset_id")
    private Integer masterdatasetId;
    private Long masterdatasetId;
    @Column(name = "master_metadata_id")
    private Integer masterMetadataId;
    private Long masterMetadataId;
    @Column(name = "foreign_metadata_id")
    private Integer foreignMetadataId;
    private Long foreignMetadataId;
    public Integer getId() {
    public Long getId() {
        return id;
    }
    public void setId(Integer id) {
    public void setId(Long id) {
        this.id = id;
    }
    public Integer getSchemeId() {
    public Long getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
    public void setSchemeId(Long schemeId) {
        this.schemeId = schemeId;
    }
    public Integer getMasterdatasetId() {
    public Long getMasterdatasetId() {
        return masterdatasetId;
    }
    public void setMasterdatasetId(Integer masterdatasetId) {
    public void setMasterdatasetId(Long masterdatasetId) {
        this.masterdatasetId = masterdatasetId;
    }
    public Integer getMasterMetadataId() {
    public Long getMasterMetadataId() {
        return masterMetadataId;
    }
    public void setMasterMetadataId(Integer masterMetadataId) {
    public void setMasterMetadataId(Long masterMetadataId) {
        this.masterMetadataId = masterMetadataId;
    }
    public Integer getForeignMetadataId() {
    public Long getForeignMetadataId() {
        return foreignMetadataId;
    }
    public void setForeignMetadataId(Integer foreignMetadataId) {
    public void setForeignMetadataId(Long foreignMetadataId) {
        this.foreignMetadataId = foreignMetadataId;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/adapter/AdapterDictEntryModel.java

@@ -5,6 +5,7 @@ import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import java.io.Serializable;
@@ -13,24 +14,23 @@ import java.io.Serializable;
 */
public class AdapterDictEntryModel extends Result implements Serializable {
    @Id
    @GeneratedValue(generator = "generator")
    @GenericGenerator(name = "generator", strategy = "increment")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;
    private Long id;
    @Column(name = "scheme_id")
    private Integer schemeId;
    private Long schemeId;
    @Column(name = "std_dict_id")
    private Integer stdDictId;
    private Long stdDictId;
    @Column(name = "std_entry_id")
    private Integer stdEntryId;
    private Long stdEntryId;
    @Column(name = "std_entry_code")
    private String stdEntryCode;
    @Column(name = "std_entry_value")
    private String stdEntryValue;
    @Column(name = "adapter_dict_id")
    private Integer adapterDictId;
    private Long adapterDictId;
    @Column(name = "adapter_entry_id")
    private Integer adapterEntryId;
    private Long adapterEntryId;
    @Column(name = "adapter_entry_code")
    private String adapterEntryCode;
    @Column(name = "adapter_entry_value")
@@ -46,35 +46,35 @@ public class AdapterDictEntryModel extends Result implements Serializable {
        this.adapterInfo = adapterInfo;
    }
    public Integer getId() {
    public Long getId() {
        return id;
    }
    public void setId(Integer id) {
    public void setId(Long id) {
        this.id = id;
    }
    public Integer getSchemeId() {
    public Long getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
    public void setSchemeId(Long schemeId) {
        this.schemeId = schemeId;
    }
    public Integer getStdDictId() {
    public Long getStdDictId() {
        return stdDictId;
    }
    public void setStdDictId(Integer stdDictId) {
    public void setStdDictId(Long stdDictId) {
        this.stdDictId = stdDictId;
    }
    public Integer getStdEntryId() {
    public Long getStdEntryId() {
        return stdEntryId;
    }
    public void setStdEntryId(Integer stdEntryId) {
    public void setStdEntryId(Long stdEntryId) {
        this.stdEntryId = stdEntryId;
    }
@@ -94,19 +94,19 @@ public class AdapterDictEntryModel extends Result implements Serializable {
        this.stdEntryValue = stdEntryValue;
    }
    public Integer getAdapterDictId() {
    public Long getAdapterDictId() {
        return adapterDictId;
    }
    public void setAdapterDictId(Integer adapterDictId) {
    public void setAdapterDictId(Long adapterDictId) {
        this.adapterDictId = adapterDictId;
    }
    public Integer getAdapterEntryId() {
    public Long getAdapterEntryId() {
        return adapterEntryId;
    }
    public void setAdapterEntryId(Integer adapterEntryId) {
    public void setAdapterEntryId(Long adapterEntryId) {
        this.adapterEntryId = adapterEntryId;
    }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/adapter/AdapterDictModel.java

@@ -5,6 +5,7 @@ import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import java.io.Serializable;
@@ -13,46 +14,45 @@ import java.io.Serializable;
 */
public class AdapterDictModel extends Result implements Serializable {
    @Id
    @GeneratedValue(generator = "generator")
    @GenericGenerator(name = "generator", strategy = "increment")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;
    private Long id;
    @Column(name = "scheme_id")
    private Integer schemeId;
    private Long schemeId;
    @Column(name = "std_dict_id")
    private Integer stdDictId;
    private Long stdDictId;
    @Column(name = "std_dict_code")
    private String stdDictCode;
    @Column(name = "std_dict_name")
    private String stdDictName;
    @Column(name = "adapter_dict_id")
    private Integer adapterDictId;
    private Long adapterDictId;
    @Column(name = "adapter_dict_code")
    private String adapterDictCode;
    @Column(name = "adapter_dict_name")
    private String adapterDictName;
    public Integer getId() {
    public Long getId() {
        return id;
    }
    public void setId(Integer id) {
    public void setId(Long id) {
        this.id = id;
    }
    public Integer getSchemeId() {
    public Long getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
    public void setSchemeId(Long schemeId) {
        this.schemeId = schemeId;
    }
    public Integer getStdDictId() {
    public Long getStdDictId() {
        return stdDictId;
    }
    public void setStdDictId(Integer stdDictId) {
    public void setStdDictId(Long stdDictId) {
        this.stdDictId = stdDictId;
    }
@@ -72,11 +72,11 @@ public class AdapterDictModel extends Result implements Serializable {
        this.stdDictName = stdDictName;
    }
    public Integer getAdapterDictId() {
    public Long getAdapterDictId() {
        return adapterDictId;
    }
    public void setAdapterDictId(Integer adapterDictId) {
    public void setAdapterDictId(Long adapterDictId) {
        this.adapterDictId = adapterDictId;
    }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/adapter/AdapterMetadataModel.java

@@ -5,6 +5,7 @@ import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import java.io.Serializable;
@@ -13,26 +14,25 @@ import java.io.Serializable;
 */
public class AdapterMetadataModel extends Result implements Serializable {
    @Id
    @GeneratedValue(generator = "generator")
    @GenericGenerator(name = "generator", strategy = "increment")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;
    private Long id;
    @Column(name = "scheme_id")
    private Integer schemeId;
    private Long schemeId;
    @Column(name = "std_dataset_id")
    private Integer stdDatasetId;
    private Long stdDatasetId;
    @Column(name = "std_metadata_id")
    private Integer stdMetadataId;
    private Long stdMetadataId;
    @Column(name = "std_metadata_code")
    private String stdMetadataCode;
    @Column(name = "std_metadata_name")
    private String stdMetadataName;
    @Column(name = "std_dict_id")
    private Integer stdDictId;
    private Long stdDictId;
    @Column(name = "adapter_dataset_id")
    private Integer adapterDatasetId;
    private Long adapterDatasetId;
    @Column(name = "adapter_metadata_id")
    private Integer adapterMetadataId;
    private Long adapterMetadataId;
    @Column(name = "adapter_metadata_code")
    private String adapterMetadataCode;
    @Column(name = "adapter_metadata_name")
@@ -40,7 +40,7 @@ public class AdapterMetadataModel extends Result implements Serializable {
    @Column(name = "adapter_data_type")
    private Integer adapterDataType;
    @Column(name = "adapter_dict_id")
    private Integer adapterDictId;
    private Long adapterDictId;
    @Column(name = "adapter_info")
    private String adapterInfo;
@@ -52,35 +52,35 @@ public class AdapterMetadataModel extends Result implements Serializable {
        this.adapterInfo = adapterInfo;
    }
    public Integer getId() {
    public Long getId() {
        return id;
    }
    public void setId(Integer id) {
    public void setId(Long id) {
        this.id = id;
    }
    public Integer getSchemeId() {
    public Long getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
    public void setSchemeId(Long schemeId) {
        this.schemeId = schemeId;
    }
    public Integer getStdDatasetId() {
    public Long getStdDatasetId() {
        return stdDatasetId;
    }
    public void setStdDatasetId(Integer stdDatasetId) {
    public void setStdDatasetId(Long stdDatasetId) {
        this.stdDatasetId = stdDatasetId;
    }
    public Integer getStdMetadataId() {
    public Long getStdMetadataId() {
        return stdMetadataId;
    }
    public void setStdMetadataId(Integer stdMetadataId) {
    public void setStdMetadataId(Long stdMetadataId) {
        this.stdMetadataId = stdMetadataId;
    }
@@ -100,27 +100,27 @@ public class AdapterMetadataModel extends Result implements Serializable {
        this.stdMetadataName = stdMetadataName;
    }
    public Integer getStdDictId() {
    public Long getStdDictId() {
        return stdDictId;
    }
    public void setStdDictId(Integer stdDictId) {
    public void setStdDictId(Long stdDictId) {
        this.stdDictId = stdDictId;
    }
    public Integer getAdapterDatasetId() {
    public Long getAdapterDatasetId() {
        return adapterDatasetId;
    }
    public void setAdapterDatasetId(Integer adapterDatasetId) {
    public void setAdapterDatasetId(Long adapterDatasetId) {
        this.adapterDatasetId = adapterDatasetId;
    }
    public Integer getAdapterMetadataId() {
    public Long getAdapterMetadataId() {
        return adapterMetadataId;
    }
    public void setAdapterMetadataId(Integer adapterMetadataId) {
    public void setAdapterMetadataId(Long adapterMetadataId) {
        this.adapterMetadataId = adapterMetadataId;
    }
@@ -148,11 +148,11 @@ public class AdapterMetadataModel extends Result implements Serializable {
        this.adapterDataType = adapterDataType;
    }
    public Integer getAdapterDictId() {
    public Long getAdapterDictId() {
        return adapterDictId;
    }
    public void setAdapterDictId(Integer adapterDictId) {
    public void setAdapterDictId(Long adapterDictId) {
        this.adapterDictId = adapterDictId;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/adapter/AdapterSchemeDispatchModel.java

@@ -10,27 +10,27 @@ import java.io.Serializable;
 * @Created by lingfeng 2015/12/23.
 */
public class AdapterSchemeDispatchModel extends Result implements Serializable {
    private Integer id;
    private Long id;
    private Integer schemeId;
    private Long schemeId;
    private String orgCode;
    private String orgName;
    public Integer getId() {
    public Long getId() {
        return id;
    }
    public void setId(Integer id) {
    public void setId(Long id) {
        this.id = id;
    }
    public Integer getSchemeId() {
    public Long getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
    public void setSchemeId(Long schemeId) {
        this.schemeId = schemeId;
    }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/adapter/AdapterSchemeModel.java

@@ -16,12 +16,11 @@ import java.io.Serializable;
public class AdapterSchemeModel extends Result implements Serializable {
    @Id
    @GeneratedValue(generator = "generator")
    @GenericGenerator(name = "generator", strategy = "increment")
    private Integer id;
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(name="parent_id")
    private Integer parentId;
    private Long parentId;
    @Column(name="name")
    private String name;
@@ -36,13 +35,13 @@ public class AdapterSchemeModel extends Result implements Serializable {
    private Integer status;
    @Column(name="std_id")
    private Integer stdId;
    private Long stdId;
    @Column(name="std_version")
    private String stdVersion;
    @Column(name="adapter_std_id")
    private Integer adapterStdId;
    private Long adapterStdId;
    @Column(name="adapter_std_version")
    private String adapterStdVersion;
@@ -50,19 +49,19 @@ public class AdapterSchemeModel extends Result implements Serializable {
    @Column(name="adapter_publisher_org_code")
    private String adapterPublisherOrgCode;
    public Integer getId() {
    public Long getId() {
        return id;
    }
    public void setId(Integer id) {
    public void setId(Long id) {
        this.id = id;
    }
    public Integer getParentId() {
    public Long getParentId() {
        return parentId;
    }
    public void setParentId(Integer parentId) {
    public void setParentId(Long parentId) {
        this.parentId = parentId;
    }
@@ -98,11 +97,11 @@ public class AdapterSchemeModel extends Result implements Serializable {
        this.status = status;
    }
    public Integer getStdId() {
    public Long getStdId() {
        return stdId;
    }
    public void setStdId(Integer stdId) {
    public void setStdId(Long stdId) {
        this.stdId = stdId;
    }
@@ -114,11 +113,11 @@ public class AdapterSchemeModel extends Result implements Serializable {
        this.stdVersion = stdVersion;
    }
    public Integer getAdapterStdId() {
    public Long getAdapterStdId() {
        return adapterStdId;
    }
    public void setAdapterStdId(Integer adapterStdId) {
    public void setAdapterStdId(Long adapterStdId) {
        this.adapterStdId = adapterStdId;
    }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/adapter/AdapterSchemeVersionModel.java

@@ -16,10 +16,10 @@ import java.util.Date;
public class AdapterSchemeVersionModel extends Result implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private Long id;
    @Column(name="scheme_id")
    private Integer schemeId;
    private Long schemeId;
    @Column(name="name")
    private String name;
@@ -46,19 +46,19 @@ public class AdapterSchemeVersionModel extends Result implements Serializable {
    }
    public Integer getId() {
    public Long getId() {
        return id;
    }
    public void setId(Integer id) {
    public void setId(Long id) {
        this.id = id;
    }
    public Integer getSchemeId() {
    public Long getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
    public void setSchemeId(Long schemeId) {
        this.schemeId = schemeId;
    }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/adapter/resultModel/AdapterDictEntryResultDetailModel.java

@@ -4,19 +4,20 @@ package com.yihu.jw.basic.standard.model.adapter.resultModel;
 * Created by lingfeng on 2015/9/16.
 */
public class AdapterDictEntryResultDetailModel {
    private Integer id;
    private Integer schemeId;
    private Integer stdDictId;
    private Integer stdEntryId;
    private Long id;
    private Long schemeId;
    private Long stdDictId;
    private Long stdEntryId;
    private String stdEntryCode;
    private String stdEntryValue;
    private Integer adapterDictId;
    private Integer adapterEntryId;
    private Long adapterDictId;
    private Long adapterEntryId;
    private String adapterEntryCode;
    private String adapterEntryValue;
    private String adapterDictCode;
    private String adapterDictName;
    private String adapterInfo;
    private Integer isClone;
    public String getAdapterInfo() {
        return adapterInfo;
@@ -26,35 +27,35 @@ public class AdapterDictEntryResultDetailModel {
        this.adapterInfo = adapterInfo;
    }
    public Integer getId() {
    public Long getId() {
        return id;
    }
    public void setId(Integer id) {
    public void setId(Long id) {
        this.id = id;
    }
    public Integer getSchemeId() {
    public Long getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
    public void setSchemeId(Long schemeId) {
        this.schemeId = schemeId;
    }
    public Integer getStdDictId() {
    public Long getStdDictId() {
        return stdDictId;
    }
    public void setStdDictId(Integer stdDictId) {
    public void setStdDictId(Long stdDictId) {
        this.stdDictId = stdDictId;
    }
    public Integer getStdEntryId() {
    public Long getStdEntryId() {
        return stdEntryId;
    }
    public void setStdEntryId(Integer stdEntryId) {
    public void setStdEntryId(Long stdEntryId) {
        this.stdEntryId = stdEntryId;
    }
@@ -74,19 +75,19 @@ public class AdapterDictEntryResultDetailModel {
        this.stdEntryValue = stdEntryValue;
    }
    public Integer getAdapterDictId() {
    public Long getAdapterDictId() {
        return adapterDictId;
    }
    public void setAdapterDictId(Integer adapterDictId) {
    public void setAdapterDictId(Long adapterDictId) {
        this.adapterDictId = adapterDictId;
    }
    public Integer getAdapterEntryId() {
    public Long getAdapterEntryId() {
        return adapterEntryId;
    }
    public void setAdapterEntryId(Integer adapterEntryId) {
    public void setAdapterEntryId(Long adapterEntryId) {
        this.adapterEntryId = adapterEntryId;
    }
@@ -121,4 +122,12 @@ public class AdapterDictEntryResultDetailModel {
    public void setAdapterDictName(String adapterDictName) {
        this.adapterDictName = adapterDictName;
    }
    public Integer getIsClone() {
        return isClone;
    }
    public void setIsClone(Integer isClone) {
        this.isClone = isClone;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/adapter/resultModel/AdapterMetadataResultDetailModel.java

@@ -4,50 +4,50 @@ package com.yihu.jw.basic.standard.model.adapter.resultModel;
 * Created by lingfeng on 2015/9/16.
 */
public class AdapterMetadataResultDetailModel {
    private Integer id;
    private Integer schemeId;
    private Integer stdDatasetId;
    private Integer stdMetadataId;
    private Long id;
    private Long schemeId;
    private Long stdDatasetId;
    private Long stdMetadataId;
    private String stdMetadataCode;
    private String stdMetadataName;
    private Integer stdDictId;
    private Integer adapterDatasetId;
    private Integer adapterMetadataId;
    private Long stdDictId;
    private Long adapterDatasetId;
    private Long adapterMetadataId;
    private String adapterMetadataCode;
    private String adapterMetadataName;
    private Integer adapterDataType;
    private String adapterMetadataType;
    private Integer adapterDictId;
    private Long adapterDictId;
    public Integer getId() {
    public Long getId() {
        return id;
    }
    public void setId(Integer id) {
    public void setId(Long id) {
        this.id = id;
    }
    public Integer getSchemeId() {
    public Long getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
    public void setSchemeId(Long schemeId) {
        this.schemeId = schemeId;
    }
    public Integer getStdDatasetId() {
    public Long getStdDatasetId() {
        return stdDatasetId;
    }
    public void setStdDatasetId(Integer stdDatasetId) {
    public void setStdDatasetId(Long stdDatasetId) {
        this.stdDatasetId = stdDatasetId;
    }
    public Integer getStdMetadataId() {
    public Long getStdMetadataId() {
        return stdMetadataId;
    }
    public void setStdMetadataId(Integer stdMetadataId) {
    public void setStdMetadataId(Long stdMetadataId) {
        this.stdMetadataId = stdMetadataId;
    }
@@ -67,27 +67,27 @@ public class AdapterMetadataResultDetailModel {
        this.stdMetadataName = stdMetadataName;
    }
    public Integer getStdDictId() {
    public Long getStdDictId() {
        return stdDictId;
    }
    public void setStdDictId(Integer stdDictId) {
    public void setStdDictId(Long stdDictId) {
        this.stdDictId = stdDictId;
    }
    public Integer getAdapterDatasetId() {
    public Long getAdapterDatasetId() {
        return adapterDatasetId;
    }
    public void setAdapterDatasetId(Integer adapterDatasetId) {
    public void setAdapterDatasetId(Long adapterDatasetId) {
        this.adapterDatasetId = adapterDatasetId;
    }
    public Integer getAdapterMetadataId() {
    public Long getAdapterMetadataId() {
        return adapterMetadataId;
    }
    public void setAdapterMetadataId(Integer adapterMetadataId) {
    public void setAdapterMetadataId(Long adapterMetadataId) {
        this.adapterMetadataId = adapterMetadataId;
    }
@@ -115,11 +115,11 @@ public class AdapterMetadataResultDetailModel {
        this.adapterDataType = adapterDataType;
    }
    public Integer getAdapterDictId() {
    public Long getAdapterDictId() {
        return adapterDictId;
    }
    public void setAdapterDictId(Integer adapterDictId) {
    public void setAdapterDictId(Long adapterDictId) {
        this.adapterDictId = adapterDictId;
    }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/adapter/resultModel/AdapterSchemeResultDetailModel.java

@@ -1,5 +1,6 @@
package com.yihu.jw.basic.standard.model.adapter.resultModel;
import com.yihu.jw.basic.standard.model.adapter.AdapterSchemeVersionModel;
import java.io.Serializable;
@@ -13,7 +14,8 @@ public class AdapterSchemeResultDetailModel implements Serializable {
    String stdName;
    String stdVersionName;
    String stdVersion;
    String publisher;
    String stdPublisher;
    String publisher; //源发布者
    String adapterName;
    String adapterVersionName;
    String adapterStdVersion;
@@ -141,4 +143,12 @@ public class AdapterSchemeResultDetailModel implements Serializable {
    public void setVersionList(List<AdapterSchemeVersionModel> versionList) {
        this.versionList = versionList;
    }
    public String getStdPublisher() {
        return stdPublisher;
    }
    public void setStdPublisher(String stdPublisher) {
        this.stdPublisher = stdPublisher;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/adapter/resultModel/AdapterSchemeResultModel.java

@@ -1,5 +1,6 @@
package com.yihu.jw.basic.standard.model.adapter.resultModel;
import com.yihu.jw.basic.standard.model.adapter.AdapterSchemeVersionModel;
import java.util.List;
@@ -11,15 +12,15 @@ import java.util.List;
 * Created at 2016/4/27.
 */
public class AdapterSchemeResultModel {
    private Integer schemeId;
    private Long schemeId;
    private String name;
    List<AdapterSchemeVersionModel> versionList;
    public Integer getSchemeId() {
    public Long getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
    public void setSchemeId(Long schemeId) {
        this.schemeId = schemeId;
    }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/adapter/resultModel/AdapterSchemeVersionResultDetailModel.java

@@ -8,8 +8,8 @@ import java.util.Date;
 * @created lingfeng 2015/12/23.
 */
public class AdapterSchemeVersionResultDetailModel {
    private Integer id;
    private Integer schemeId;
    private Long id;
    private Long schemeId;
    private String name;
    private String schemeName;
    private String version;
@@ -23,19 +23,19 @@ public class AdapterSchemeVersionResultDetailModel {
    }
    public Integer getId() {
    public Long getId() {
        return id;
    }
    public void setId(Integer id) {
    public void setId(Long id) {
        this.id = id;
    }
    public Integer getSchemeId() {
    public Long getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
    public void setSchemeId(Long schemeId) {
        this.schemeId = schemeId;
    }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/adapter/resultModel/ApiMetadataResultDetailModel.java

@@ -4,22 +4,24 @@ package com.yihu.jw.basic.standard.model.adapter.resultModel;
 * Created by lingfeng on 2015/9/18.
 */
public class ApiMetadataResultDetailModel {
    private Integer id;
    private Integer schemeId;
    private Integer stdDatasetId;
    private Integer stdMetadataId;
    private Long id;
    private Long schemeId;
    private Long stdDatasetId;
    private Long stdMetadataId;
    private String stdMetadataCode;
    private String stdMetadataName;
    private Integer stdDictId;
    private Integer adapterDatasetId;
    private Integer adapterMetadataId;
    private Long stdDictId;
    private Long adapterDatasetId;
    private Long adapterMetadataId;
    private String adapterMetadataCode;
    private String adapterMetadataName;
    private Integer adapterDataType;
    private String adapterDatasetCode;
    private String adapterDatasetName;
    private Integer adapterDictId;
    private Long adapterDictId;
    private String adapterInfo;
    private Long belongAdapterId;
    private String adapterDefault;
    public String getAdapterInfo() {
        return adapterInfo;
@@ -29,35 +31,35 @@ public class ApiMetadataResultDetailModel {
        this.adapterInfo = adapterInfo;
    }
    public Integer getId() {
    public Long getId() {
        return id;
    }
    public void setId(Integer id) {
    public void setId(Long id) {
        this.id = id;
    }
    public Integer getSchemeId() {
    public Long getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
    public void setSchemeId(Long schemeId) {
        this.schemeId = schemeId;
    }
    public Integer getStdDatasetId() {
    public Long getStdDatasetId() {
        return stdDatasetId;
    }
    public void setStdDatasetId(Integer stdDatasetId) {
    public void setStdDatasetId(Long stdDatasetId) {
        this.stdDatasetId = stdDatasetId;
    }
    public Integer getStdMetadataId() {
    public Long getStdMetadataId() {
        return stdMetadataId;
    }
    public void setStdMetadataId(Integer stdMetadataId) {
    public void setStdMetadataId(Long stdMetadataId) {
        this.stdMetadataId = stdMetadataId;
    }
@@ -77,27 +79,27 @@ public class ApiMetadataResultDetailModel {
        this.stdMetadataName = stdMetadataName;
    }
    public Integer getStdDictId() {
    public Long getStdDictId() {
        return stdDictId;
    }
    public void setStdDictId(Integer stdDictId) {
    public void setStdDictId(Long stdDictId) {
        this.stdDictId = stdDictId;
    }
    public Integer getAdapterDatasetId() {
    public Long getAdapterDatasetId() {
        return adapterDatasetId;
    }
    public void setAdapterDatasetId(Integer adapterDatasetId) {
    public void setAdapterDatasetId(Long adapterDatasetId) {
        this.adapterDatasetId = adapterDatasetId;
    }
    public Integer getAdapterMetadataId() {
    public Long getAdapterMetadataId() {
        return adapterMetadataId;
    }
    public void setAdapterMetadataId(Integer adapterMetadataId) {
    public void setAdapterMetadataId(Long adapterMetadataId) {
        this.adapterMetadataId = adapterMetadataId;
    }
@@ -125,11 +127,11 @@ public class ApiMetadataResultDetailModel {
        this.adapterDataType = adapterDataType;
    }
    public Integer getAdapterDictId() {
    public Long getAdapterDictId() {
        return adapterDictId;
    }
    public void setAdapterDictId(Integer adapterDictId) {
    public void setAdapterDictId(Long adapterDictId) {
        this.adapterDictId = adapterDictId;
    }
@@ -148,4 +150,20 @@ public class ApiMetadataResultDetailModel {
    public void setAdapterDatasetName(String adapterDatasetName) {
        this.adapterDatasetName = adapterDatasetName;
    }
    public Long getBelongAdapterId() {
        return belongAdapterId;
    }
    public void setBelongAdapterId(Long belongAdapterId) {
        this.belongAdapterId = belongAdapterId;
    }
    public String getAdapterDefault() {
        return adapterDefault;
    }
    public void setAdapterDefault(String adapterDefault) {
        this.adapterDefault = adapterDefault;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/qc/QcRuleMetadata.java

@@ -0,0 +1,60 @@
package com.yihu.jw.basic.standard.model.qc;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;
/**
 * 数据元与质控规则关系表 entity
 *
 * @author 张进军
 * @date 2018/3/2
 */
@Entity
@Table(name = "qc_rule_metadata")
public class QcRuleMetadata implements Serializable {
    private String id;
    private String type; // 校验类型
    private String qcRuleCode; // 质控规则编码
    private String remark; // 备注
    @Id
    @Column(name = "id")
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    @Column(name = "type", length = 20, nullable = true)
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    @Column(name = "qc_rule_code", length = 20, nullable = true)
    public String getQcRuleCode() {
        return qcRuleCode;
    }
    public void setQcRuleCode(String qcRuleCode) {
        this.qcRuleCode = qcRuleCode;
    }
    @Column(name = "remark", length = 255, nullable = false)
    public String getRemark() {
        return remark;
    }
    public void setRemark(String remark) {
        this.remark = remark;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/qc/RuleModel.java

@@ -0,0 +1,125 @@
package com.yihu.jw.basic.standard.model.qc;
import org.hibernate.annotations.Formula;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.*;
/**
 *
 * 质控表
 *
 * @author CD
 * @vsrsion 1.0
 * Created at 2017/05/05.
 */
@Entity
@Table(name = "qc_rule")
public class RuleModel implements java.io.Serializable {
    private String id;
    private String name; // 名称
    private String code; // 编码
    private String type; // 分类
    private String describe; // 描述
    private String rule; // 规则校验地址
    private String error_code; // 统一错误代码
    private String ruleMethod; // 质控规则反射方法
    // 临时属性
    private String typeName; // 分类名称
    private String errorCodeName; // 统一错误代码名称
    @Id
    @GeneratedValue(generator = "generator")
    @GenericGenerator(name = "generator", strategy = "uuid")
    @Column(name = "id")
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    @Column(name = "name", length = 255, nullable = true)
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Column(name = "code", length = 50, nullable = false)
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    @Column(name = "type", length = 20, nullable = false)
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    @Column(name = "description", length = 1000, nullable = false)
    public String getDescribe() {
        return describe;
    }
    public void setDescribe(String describe) {
        this.describe = describe;
    }
    @Column(name = "rule", length = 255, nullable = false)
    public String getRule() {
        return rule;
    }
    public void setRule(String rule) {
        this.rule = rule;
    }
    @Column(name = "error_code", length = 50, nullable = true)
    public String getError_code() {
        return error_code;
    }
    public void setError_code(String error_code) {
        this.error_code = error_code;
    }
    @Formula("( SELECT b.value FROM qc_rule a LEFT JOIN system_dict b ON b.code = a.type WHERE a.id = id )")
    public String getTypeName() {
        return typeName;
    }
    public void setTypeName(String typeName) {
        this.typeName = typeName;
    }
    @Formula("( SELECT b.value FROM qc_rule a LEFT JOIN system_dict b ON b.code = a.error_code WHERE a.id = id )")
    public String getErrorCodeName() {
        return errorCodeName;
    }
    public void setErrorCodeName(String errorCodeName) {
        this.errorCodeName = errorCodeName;
    }
    @Column(name = "rule_method", length = 255, nullable = false)
    public String getRuleMethod() {
        return ruleMethod;
    }
    public void setRuleMethod(String ruleMethod) {
        this.ruleMethod = ruleMethod;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/standard/STDVersion.java

@@ -0,0 +1,148 @@
package com.yihu.jw.basic.standard.model.standard;
import com.yihu.jw.basic.standard.model.Result;
import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;
/**
 * @author lincl
 * @version 1.0
 * @created 2016.2.3
 */
@Entity
@Table(name = "std_version")
@Access(value = AccessType.PROPERTY)
public class STDVersion extends Result implements Serializable {
    private Long id;
    private String version;
    private String versionName;
    private Long standardId;
    private Date commitTime;//发布时间
    private String publishUser;//发布者
    private String baseVersion;//基础版本
    private String primaryVersion;//主版本号
    private boolean inStage;
    private String path;
    private String author;
    public STDVersion(String baseVersion, String author, String versionName) {
        //this.baseVersion = baseVersion == null ? null : new ObjectVersion(baseVersion);
        this.author = author;
        this.commitTime = null;
        this.inStage = true;
        if (baseVersion == null) {
            this.versionName = versionName;
            this.baseVersion = null;
        } else {
            versionName = versionName.substring(1, versionName.length());
            double dVersion = Double.parseDouble(versionName) + 1.0;
            this.versionName = "V" + String.valueOf(dVersion);
        }
    }
    public STDVersion(){
    }
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id", unique = true, nullable = false)
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    @Column(name = "version", unique = true, nullable = false)
    public String getVersion() {
        return version;
    }
    public void setVersion(String version) {
        this.version = version;
    }
    @Column(name = "author", unique = false, nullable = false)
    public String getAuthor() {
        return author;
    }
    public void setAuthor(String author) {
        this.author = author;
    }
    @Column(name = "base_version", unique = false, nullable = true)
    @Access(value = AccessType.PROPERTY)
    public String getBaseVersion() {
        return baseVersion;
    }
    public void setBaseVersion(String baseVersion) {
        this.baseVersion = baseVersion;
    }
    @Column(name = "commit_time", unique = false, nullable = true)
    public Date getCommitTime() {
        return commitTime;
    }
    public void setCommitTime(Date commitTime) {
        this.commitTime = commitTime;
    }
    @Column(name = "version_name", unique = false, nullable = true)
    public String getVersionName() {
        return versionName;
    }
    public void setVersionName(String versionName) {
        this.versionName = versionName;
    }
    @Column(name = "staged", unique = false, nullable = true )
    public boolean isInStage() {
        return inStage;
    }
    public void setInStage(boolean inStage) {
        this.inStage = inStage;
    }
    @Column(name = "std_id" )
    public Long getStandardId() {
        return standardId;
    }
    public void setStandardId(Long standardId) {
        this.standardId = standardId;
    }
    @Column(name = "publish_user" )
    public String getPublishUser() {
        return publishUser;
    }
    public void setPublishUser(String publishUser) {
        this.publishUser = publishUser;
    }
    @Column(name = "primary_version", unique = false, nullable = true)
    @Access(value = AccessType.PROPERTY)
    public String getPrimaryVersion() {
        return primaryVersion;
    }
    public void setPrimaryVersion(String primaryVersion) {
        this.primaryVersion = primaryVersion;
    }
    @Column(name="path")
    public String getPath() {
        return path;
    }
    public void setPath(String path) {
        this.path = path;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/standard/StandardModel.java

@@ -1,6 +1,7 @@
package com.yihu.jw.basic.standard.model.standard;
import com.yihu.jw.entity.IntegerIdentityEntity;
import com.yihu.jw.entity.LongIdentityEntity;
import javax.persistence.Entity;
import javax.persistence.Table;
@@ -13,7 +14,7 @@ import java.io.Serializable;
 */
@Entity
@Table(name = "std_info")
public class StandardModel extends IntegerIdentityEntity implements Serializable {
public class StandardModel extends LongIdentityEntity implements Serializable {
    private String name;

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/standard/StandardVersionModel.java

@@ -21,7 +21,7 @@ public class StandardVersionModel extends IntegerIdentityEntity implements Seria
    private Integer standardId;
    private String name;
    private String versionName;
    private Date publishTime;
@@ -43,7 +43,7 @@ public class StandardVersionModel extends IntegerIdentityEntity implements Seria
        this.id = standardVersionModel.id;
        this.version = standardVersionModel.version;
        this.standardId = standardVersionModel.standardId;
        this.name = standardVersionModel.name;
        this.versionName = standardVersionModel.versionName;
        this.publishTime = standardVersionModel.publishTime;
        this.publishUser = standardVersionModel.publishUser;
        this.baseVersion = standardVersionModel.baseVersion;
@@ -71,12 +71,12 @@ public class StandardVersionModel extends IntegerIdentityEntity implements Seria
    }
    @Column(name = "version_name")
    public String getName() {
        return name;
    public String getVersionName() {
        return versionName;
    }
    public void setName(String name) {
        this.name = name;
    public void setVersionName(String versionName) {
        this.versionName = versionName;
    }
    @Column(name = "commit_time")

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/standard/StdCDACatalogModel.java

@@ -15,7 +15,7 @@ public class StdCDACatalogModel extends Result implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;
    private Long id;
    @Column(name = "code")
    private String code;
@@ -24,7 +24,7 @@ public class StdCDACatalogModel extends Result implements Serializable {
    private String name;
    @Column(name = "parent_id")
    private Integer parentID;
    private Long parentID;
    @Column(name = "sort")
    private String sort;
@@ -32,11 +32,11 @@ public class StdCDACatalogModel extends Result implements Serializable {
    @Column(name = "description")
    private String description;
    public Integer getId() {
    public Long getId() {
        return id;
    }
    public void setId(Integer id) {
    public void setId(Long id) {
        this.id = id;
    }
@@ -56,11 +56,11 @@ public class StdCDACatalogModel extends Result implements Serializable {
        this.name = name;
    }
    public Integer getParentID() {
    public Long getParentID() {
        return parentID;
    }
    public void setParentID(Integer parentID) {
    public void setParentID(Long parentID) {
        this.parentID = parentID;
    }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/standard/StdCDADatasetModel.java

@@ -16,35 +16,35 @@ public class StdCDADatasetModel extends Result implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;
    private Long id;
    @Column(name = "cda_id")
    private Integer cdaID;
    private Long cdaID;
    @Column(name = "dataset_id")
    private Integer datasetId;
    private Long datasetId;
    public Integer getId() {
    public Long getId() {
        return id;
    }
    public void setId(Integer id) {
    public void setId(Long id) {
        this.id = id;
    }
    public Integer getCdaID() {
    public Long getCdaID() {
        return cdaID;
    }
    public void setCdaID(Integer cdaID) {
    public void setCdaID(Long cdaID) {
        this.cdaID = cdaID;
    }
    public Integer getdatasetId() {
    public Long getdatasetId() {
        return datasetId;
    }
    public void setdatasetId(Integer datasetId) {
    public void setdatasetId(Long datasetId) {
        this.datasetId = datasetId;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/standard/StdCDAModel.java

@@ -14,10 +14,10 @@ public class StdCDAModel extends Result implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;
    private Long id;
    @Column(name = "std_id")
    private Integer standardId;
    private Long standardId;
    @Column(name = "code")
    private String code;
@@ -32,21 +32,21 @@ public class StdCDAModel extends Result implements Serializable {
    private String description;
    @Column(name = "catalog_id")
    private Integer catalogID;
    private Long catalogID;
    public Integer getId() {
    public Long getId() {
        return id;
    }
    public void setId(Integer id) {
    public void setId(Long id) {
        this.id = id;
    }
    public Integer getstandardId() {
    public Long getstandardId() {
        return standardId;
    }
    public void setstandardId(Integer standardId) {
    public void setstandardId(Long standardId) {
        this.standardId = standardId;
    }
@@ -82,11 +82,11 @@ public class StdCDAModel extends Result implements Serializable {
        this.description = description;
    }
    public Integer getCatalogID() {
    public Long getCatalogID() {
        return catalogID;
    }
    public void setCatalogID(Integer catalogID) {
    public void setCatalogID(Long catalogID) {
        this.catalogID = catalogID;
    }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/standard/StdDataSetModel.java

@@ -5,19 +5,24 @@ import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;
import javax.persistence.Transient;
import java.io.Serializable;
import java.util.Objects;
/**
 * Created by wq on 2015/9/16.
 */
@MappedSuperclass
public class StdDataSetModel extends Result implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;
    private Long id;
    @Column(name = "std_id")
    private Integer standardId;
    @Column(name="document_id")
    private Long documentId;
    @Column(name = "code")
    private String code;
@@ -37,20 +42,36 @@ public class StdDataSetModel extends Result implements Serializable {
    @Column(name = "class_model")
    private String classModel;
    public Integer getId() {
        return id;
    }
    @Column(name="ref_standard")
    private String reference;
    public void setId(Integer id) {
        this.id = id;
    }
    @Column(name = "lang", unique = false, nullable = true)
    private Integer lang;
    public Integer getstandardId() {
        return standardId;
    @Column(name = "publisher", unique = false, nullable = false)
    private Integer publisher;
    @Column(name = "multi_record", nullable = false)
    private boolean multiRecord;
    @Column(name = "std_version", unique = false, nullable = true)
    private String stdVersion;
    @Column(name = "hash", unique = false, nullable = true)
    private Integer hashCode;
    @Column(name="std_id")
    private Integer standardId;
    @Transient
    private String innerVersionId;
    public Long getId() {
        return id;
    }
    public void setstandardId(Integer standardId) {
        this.standardId = standardId;
    public void setId(Long id) {
        this.id = id;
    }
    public String getCode() {
@@ -102,4 +123,79 @@ public class StdDataSetModel extends Result implements Serializable {
    public void setClassModel(String classModel) {
        this.classModel = classModel;
    }
    public Integer getHashCode() {
        hashCode = Objects.hash( catalog, lang, standardId,
                publisher, stdVersion, code, name, summary);
        return hashCode;
    }
    public void setHashCode(Integer hashCode) {
        this.hashCode = hashCode;
    }
    public Integer getLang() {
        return lang;
    }
    public void setLang(Integer lang) {
        this.lang = lang;
    }
    public boolean isMultiRecord() {
        return multiRecord;
    }
    public void setMultiRecord(boolean multiRecord) {
        this.multiRecord = multiRecord;
    }
    public Integer getPublisher() {
        return publisher;
    }
    public void setPublisher(Integer publisher) {
        this.publisher = publisher;
    }
    public String getStdVersion() {
        return stdVersion;
    }
    public void setStdVersion(String stdVersion) {
        this.stdVersion = stdVersion;
    }
    public Long getDocumentId() {
        return documentId;
    }
    public void setDocumentId(Long documentId) {
        this.documentId = documentId;
    }
    public String getReference() {
        return reference;
    }
    public void setReference(String reference) {
        this.reference = reference;
    }
    public String getInnerVersionId() {
        return innerVersionId;
    }
    public void setInnerVersionId(String innerVersionId) {
        this.innerVersionId = innerVersionId;
    }
    public Integer getStandardId() {
        return standardId;
    }
    public void setStandardId(Integer standardId) {
        this.standardId = standardId;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/standard/StdDatasetCatalogModel.java

@@ -17,7 +17,7 @@ public class StdDatasetCatalogModel extends Result implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;
    private Long id;
    @Column(name = "name")
    private String name;
@@ -26,7 +26,7 @@ public class StdDatasetCatalogModel extends Result implements Serializable {
    private String code;
    @Column(name = "parent_id")
    private Integer parentID;
    private Long parentID;
    @Column(name = "sort")
    private String sort;
@@ -34,11 +34,11 @@ public class StdDatasetCatalogModel extends Result implements Serializable {
    @Column(name = "description")
    private String description;
    public Integer getId() {
    public Long getId() {
        return id;
    }
    public void setId(Integer id) {
    public void setId(Long id) {
        this.id = id;
    }
@@ -58,11 +58,11 @@ public class StdDatasetCatalogModel extends Result implements Serializable {
        this.code = code;
    }
    public Integer getParentID() {
    public Long getParentID() {
        return parentID;
    }
    public void setParentID(Integer parentID) {
    public void setParentID(Long parentID) {
        this.parentID = parentID;
    }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/standard/StdDictionaryEntryModel.java

@@ -14,13 +14,13 @@ public class StdDictionaryEntryModel extends Result implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;
    private Long id;
    @Column(name = "std_id")
    private Integer standardId;
    private Long standardId;
    @Column(name = "dict_id")
    private Integer dictId;
    private Long dictId;
    @Column(name = "code")
    private String code;
@@ -31,27 +31,27 @@ public class StdDictionaryEntryModel extends Result implements Serializable {
    @Column(name = "description")
    private String description;
    public Integer getId() {
    public Long getId() {
        return id;
    }
    public void setId(Integer id) {
    public void setId(Long id) {
        this.id = id;
    }
    public Integer getstandardId() {
    public Long getstandardId() {
        return standardId;
    }
    public void setstandardId(Integer standardId) {
    public void setstandardId(Long standardId) {
        this.standardId = standardId;
    }
    public Integer getDictId() {
    public Long getDictId() {
        return dictId;
    }
    public void setDictId(Integer dictId) {
    public void setDictId(Long dictId) {
        this.dictId = dictId;
    }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/standard/StdDictionaryModel.java

@@ -16,10 +16,10 @@ public class StdDictionaryModel extends Result implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;
    private Long id;
    @Column(name = "std_id")
    private Integer standardId;
    private Long standardId;
    @Column(name = "code")
    private String code;
@@ -34,21 +34,21 @@ public class StdDictionaryModel extends Result implements Serializable {
    private String description;
    @Column(name = "parent_id")
    private Integer parentId;
    private Long parentId;
    public Integer getId() {
    public Long getId() {
        return id;
    }
    public void setId(Integer id) {
    public void setId(Long id) {
        this.id = id;
    }
    public Integer getstandardId() {
    public Long getstandardId() {
        return standardId;
    }
    public void setstandardId(Integer standardId) {
    public void setstandardId(Long standardId) {
        this.standardId = standardId;
    }
@@ -84,11 +84,11 @@ public class StdDictionaryModel extends Result implements Serializable {
        this.description = description;
    }
    public Integer getParentId() {
    public Long getParentId() {
        return parentId;
    }
    public void setParentId(Integer parentId) {
    public void setParentId(Long parentId) {
        this.parentId = parentId;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/model/standard/StdMetaDataModel.java

@@ -1,32 +1,31 @@
package com.yihu.jw.basic.standard.model.standard;
import com.yihu.jw.basic.standard.model.Result;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.*;
import java.io.Serializable;
import java.util.Objects;
/**
 * Created by wq on 2015/9/22.
 */
public class StdMetaDataModel extends Result implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;                    // 数据元ID
    private Long id;                    // 数据元ID
    @Column(name = "std_id")
    private Integer standardId;           //标准ID
    private Long standardId;           //标准ID
    @Column(name = "dataset_id")
    private Integer datasetId;             //数据集ID
    private Long dataSetId;             //数据集ID
    @Column(name = "code")
    private String code;           // 内部代码
    @Column(name = "inner_code")
    private String innerCode;           // 内部代码
    @Column(name = "de_code")
    private String deCode;                 // 标准元编码
    @Column(name = "code")
    private String code;                 // 标准元编码
    @Column(name = "name")
    private String name;                // 名称
@@ -38,13 +37,13 @@ public class StdMetaDataModel extends Result implements Serializable {
    private String format;              // 表示格式
    @Column(name = "dict_id")
    private Integer dictId;                //字典ID
    private Long dictId;                //字典ID
    @Column(name = "definition")
    private String definition;          // 标准元定义, 即说明
    @Column(name = "nullable")
    private Integer nullable;           // 是否可为空
    private boolean nullable;           // 是否可为空
    @Column(name = "column_length")
    private String columnLength;         // 数据长度
@@ -56,46 +55,75 @@ public class StdMetaDataModel extends Result implements Serializable {
    private String columnName;          // 字段名
    @Column(name = "primary_key")
    private Integer primaryKey;         // 是否为主键
    private boolean primaryKey;         // 是否为主键
    @Column(name = "hash", unique = false, nullable = false)
    private Integer hashCode;
    @Column(name = "std_version")
    private String stdVersion;
    /************************/
    /**  Transient        ***/
    /************************/
    @Transient
    boolean isHbaseFullTextRetrieval;       // Hbase 全文检索字段
    @Transient
    boolean isHbasePrimaryKey;              // Hbase 主键字段
    @Transient
    private String dictName;
    @Transient
    private String dictCode;
    public Integer getHashCode() {
        hashCode = Objects.hash(dataSetId, dictId, code, definition, format, innerCode, name,
                type, columnLength, columnType, nullable, primaryKey);
        return hashCode;
    }
    public void setHashCode(Integer hashCode) {
        this.hashCode = hashCode;
    }
    public Integer getId() {
    public Long getId() {
        return id;
    }
    public void setId(Integer id) {
    public void setId(Long id) {
        this.id = id;
    }
    public Integer getStandardId() {
    public Long getStandardId() {
        return standardId;
    }
    public void setStandardId(Integer standardId) {
    public void setStandardId(Long standardId) {
        this.standardId = standardId;
    }
    public Integer getDatasetId() {
        return datasetId;
    public Long getDataSetId() {
        return dataSetId;
    }
    public void setDatasetId(Integer datasetId) {
        this.datasetId = datasetId;
    public void setDataSetId(long dataSetId) {
        this.dataSetId = dataSetId;
    }
    public String getCode() {
        return code;
    public String getInnerCode() {
        return innerCode;
    }
    public void setCode(String code) {
        this.code = code;
    public void setInnerCode(String innerCode) {
        this.innerCode = innerCode;
    }
    public String getDeCode() {
        return deCode;
    public String getCode() {
        return code;
    }
    public void setDeCode(String deCode) {
        this.deCode = deCode;
    public void setCode(String code) {
        this.code = code;
    }
    public String getName() {
@@ -122,11 +150,11 @@ public class StdMetaDataModel extends Result implements Serializable {
        this.format = format;
    }
    public Integer getDictId() {
    public Long getDictId() {
        return dictId;
    }
    public void setDictId(Integer dictId) {
    public void setDictId(Long dictId) {
        this.dictId = dictId;
    }
@@ -138,11 +166,11 @@ public class StdMetaDataModel extends Result implements Serializable {
        this.definition = definition;
    }
    public Integer getNullable() {
    public boolean getNullable() {
        return nullable;
    }
    public void setNullable(Integer nullable) {
    public void setNullable(boolean nullable) {
        this.nullable = nullable;
    }
@@ -170,11 +198,64 @@ public class StdMetaDataModel extends Result implements Serializable {
        this.columnName = columnName;
    }
    public Integer getPrimaryKey() {
    public boolean getPrimaryKey() {
        return primaryKey;
    }
    public void setPrimaryKey(Integer primaryKey) {
    public void setPrimaryKey(boolean primaryKey) {
        this.primaryKey = primaryKey;
    }
    public boolean isHbaseFullTextRetrieval() {
        return isHbaseFullTextRetrieval;
    }
    public void setHbaseFullTextRetrieval(boolean hbaseFullTextRetrieval) {
        isHbaseFullTextRetrieval = hbaseFullTextRetrieval;
    }
    public boolean isHbasePrimaryKey() {
        return isHbasePrimaryKey;
    }
    public void setHbasePrimaryKey(boolean hbasePrimaryKey) {
        isHbasePrimaryKey = hbasePrimaryKey;
    }
    public String getDictName() {
        return dictName;
    }
    public void setDictName(String dictName) {
        this.dictName = dictName;
    }
    public String getDictCode() {
        return dictCode;
    }
    public void setDictCode(String dictCode) {
        this.dictCode = dictCode;
    }
    public boolean isNullable() {
        return nullable;
    }
    public boolean isPrimaryKey() {
        return primaryKey;
    }
    public String getStdVersion() {
        return stdVersion;
    }
    public void setStdVersion(String stdVersion) {
        this.stdVersion = stdVersion;
    }
    public void setDataSetId(Long dataSetId) {
        this.dataSetId = dataSetId;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/adapter/AdapterDatasetRelationService.java

@@ -34,7 +34,7 @@ public class AdapterDatasetRelationService extends SQLGeneralDAO {
            String sql = "select max(id) from " + version.getMetaDataTableName();
            Query query = session.createSQLQuery(sql);
            Object object = query.uniqueResult();
            adapterDatasetRelationModel.setId(object == null ? 1 : Integer.parseInt(object.toString()) + 1);
            adapterDatasetRelationModel.setId(object == null ? 1L : Long.parseLong(object.toString()) + 1);
            JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterDatasetRelationModel));
            SqlCreator sqlCreator = new SqlCreator(AdapterDatasetRelationModel.class);

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/adapter/AdapterDatasetService.java

@@ -173,7 +173,7 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        Query query = getQuery(sqlCreator, sql);
        if (limit != null) {
            query.setMaxResults(limit);
            if (offset != null) {
            if (offset != null &&offset>0) {
                query.setFirstResult((offset - 1) * limit);
            }
        }
@@ -202,7 +202,7 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        }
    }
    public void getAdapterCustomize(String adapterVersion, List<TreeView> treeViewList, List<Integer> hasCheckDatasetIdList, List<Integer> hasCheckMetadataIdList) {
    public void getAdapterCustomize(String adapterVersion, List<TreeView> treeViewList, List<Long> hasCheckDatasetIdList, List<Long> hasCheckMetadataIdList) {
        boolean adapter = false;  //定制是否添加根节点
        //获取所有定制数据集
        AdapterVersion aVersion = new AdapterVersion(adapterVersion);
@@ -243,7 +243,7 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        treeViewList.addAll(adapterCustomizeList);
    }
    public void getStdCustomize(String stdVersion, List<TreeView> treeViewList, List<Integer> hasCheckDatasetIdList, List<Integer> hasCheckMetadataIdList) {
    public void getStdCustomize(String stdVersion, List<TreeView> treeViewList, List<Long> hasCheckDatasetIdList, List<Long> hasCheckMetadataIdList) {
        String id;
        boolean check;     //是否勾选
        boolean std = false;      //标准是否添加根节点
@@ -257,7 +257,7 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        for (StdDataSetModel dataSet : dataSetList) {
            idListStr += dataSet.getId() + SqlConstants.COMMA;
        }
        Map<Integer, List<StdMetaDataModel>> stdDataSetModelMap = new HashMap<>();
        Map<Long, List<StdMetaDataModel>> stdDataSetModelMap = new HashMap<>();
        if (!StringUtil.isEmpty(idListStr)) {
            String tableName = sVersion.getMetaDataTableName();
            SqlCreator sqlCreator = new SqlCreator(StdMetaDataModel.class);
@@ -265,12 +265,12 @@ public class AdapterDatasetService extends SQLGeneralDAO {
            Query query = getQuery(sqlCreator, sql);
            List<StdMetaDataModel> stdMetaDataModelList = query.list();
            for (StdMetaDataModel stdMetaDataModel : stdMetaDataModelList) {
                List<StdMetaDataModel> stdMetaDataModels = stdDataSetModelMap.get(stdMetaDataModel.getDatasetId());
                List<StdMetaDataModel> stdMetaDataModels = stdDataSetModelMap.get(stdMetaDataModel.getDataSetId());
                if (stdMetaDataModels == null) {
                    stdMetaDataModels = new ArrayList<>();
                }
                stdMetaDataModels.add(stdMetaDataModel);
                stdDataSetModelMap.put(stdMetaDataModel.getDatasetId(), stdMetaDataModels);
                stdDataSetModelMap.put(stdMetaDataModel.getDataSetId(), stdMetaDataModels);
            }
        }
@@ -332,8 +332,8 @@ public class AdapterDatasetService extends SQLGeneralDAO {
    public ListEnvelop getDatasetCustomize(String adapterVersion, String stdVersion) {
        try {
            List<TreeView> treeViewList = new ArrayList<>();
            List<Integer> hasCheckDatasetIdList = new ArrayList<>();
            List<Integer> hasCheckMetadataIdList = new ArrayList<>();
            List<Long> hasCheckDatasetIdList = new ArrayList<>();
            List<Long> hasCheckMetadataIdList = new ArrayList<>();
            getAdapterCustomize(adapterVersion, treeViewList, hasCheckDatasetIdList, hasCheckMetadataIdList);
            getStdCustomize(stdVersion, treeViewList, hasCheckDatasetIdList, hasCheckMetadataIdList);
            ListEnvelop detailModelResult = ListEnvelop.getSuccess("获取定制数据集列表成功",treeViewList);
@@ -344,25 +344,25 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        }
    }
    public Envelop updateCustomize(Integer schemeId, String adapterVersion, String stdVersion, String datasetIdStr, String metaDataIdStr) {
    public Envelop updateCustomize(Long schemeId, String adapterVersion, String stdVersion, String datasetIdStr, String metaDataIdStr) {
        AdapterVersion aVersion = new AdapterVersion(adapterVersion);
        StandardVersion sVersion = new StandardVersion(stdVersion);
        try {
            String[] datasetIdList = datasetIdStr.split(",");
            String[] metadataIdList = metaDataIdStr.split(",");
            List<Integer> newDatasetIdList = new ArrayList<>();
            List<Integer> newMetadataIdList = new ArrayList<>();
            List<Long> newDatasetIdList = new ArrayList<>();
            List<Long> newMetadataIdList = new ArrayList<>();
            for (String datasetId : datasetIdList) {
                if (!StringUtil.isStrEmpty(datasetId)) {
                    Integer newDatasetId = Integer.parseInt(datasetId);
                    Long newDatasetId = Long.parseLong(datasetId);
                    newDatasetIdList.add(newDatasetId);
                }
            }
            for (String metadataId : metadataIdList) {
                if (!StringUtil.isStrEmpty(metadataId)) {
                    Integer newMetadataId = Integer.parseInt(metadataId);
                    Long newMetadataId = Long.parseLong(metadataId);
                    newMetadataIdList.add(newMetadataId);
                }
            }
@@ -379,7 +379,7 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        }
    }
    public void updateDatasetCustomizeData(Integer schemeId, AdapterVersion aVersion, StandardVersion sVersion, List<Integer> newDatasetIdList, List<Integer> newMetadataIdList) throws Exception {
    public void updateDatasetCustomizeData(Long schemeId, AdapterVersion aVersion, StandardVersion sVersion, List<Long> newDatasetIdList, List<Long> newMetadataIdList) throws Exception {
        List<StdMetaDataModel> metadataList = new ArrayList<StdMetaDataModel>();
        if (newMetadataIdList.size() > 0) {
            SqlCreator sqlCreator = new SqlCreator(StdMetaDataModel.class);
@@ -389,7 +389,7 @@ public class AdapterDatasetService extends SQLGeneralDAO {
            metadataList = query.list();
        }
        List<Integer> newDictdList = new ArrayList<>();
        List<Long> newDictdList = new ArrayList<>();
        for (StdMetaDataModel stdMetaDataModel : metadataList) {
            if (stdMetaDataModel.getDictId() != null && !newDictdList.contains(stdMetaDataModel.getDictId())) {
                newDictdList.add(stdMetaDataModel.getDictId());
@@ -402,15 +402,15 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        List<AdapterMetadataModel> metadataModels = selectData(aVersion.getMetaDataTableName(), AdapterMetadataModel.class);
        List<AdapterDictModel> dictModels = selectData(aVersion.getDictTableName(), AdapterDictModel.class);
//        List<AdapterDictEntryModel> dictEntryModels = selectData(aVersion.getDictEntryTableName(), AdapterDictEntryModel.class);
        List<Integer> oldDatasetIdList = new ArrayList<>();
        List<Long> oldDatasetIdList = new ArrayList<>();
        for (AdapterDatasetModel datasetModel : datasetModels) {
            oldDatasetIdList.add(datasetModel.getId());
        }
        List<Integer> oldMetadataIdList = new ArrayList<>();
        List<Long> oldMetadataIdList = new ArrayList<>();
        for (AdapterMetadataModel metadataModel : metadataModels) {
            oldMetadataIdList.add(metadataModel.getId());
        }
        List<Integer> oldDictIdList = new ArrayList<>();
        List<Long> oldDictIdList = new ArrayList<>();
        for (AdapterDictModel dictModel : dictModels) {
            oldDictIdList.add(dictModel.getId());
        }
@@ -418,20 +418,20 @@ public class AdapterDatasetService extends SQLGeneralDAO {
//        for (AdapterDictEntryModel entryModel : dictEntryModels) {
//            oldDictEntryIdList.add(entryModel.getStdDictId());
//        }
        Map<String, List<Integer>> datasetMap = getDiffId(newDatasetIdList, oldDatasetIdList);
        Map<String, List<Integer>> metaMap = getDiffId(newMetadataIdList, oldMetadataIdList);
        Map<String, List<Integer>> dicMap = getDiffId(newDictdList, oldDictIdList);
        Map<String, List<Long>> datasetMap = getDiffId(newDatasetIdList, oldDatasetIdList);
        Map<String, List<Long>> metaMap = getDiffId(newMetadataIdList, oldMetadataIdList);
        Map<String, List<Long>> dicMap = getDiffId(newDictdList, oldDictIdList);
//        Map<String,List<Integer>> dicEntryMap = getDiffId(newDictdList,oldDictEntryIdList);
//        add del
        List<Integer> delDatasetList = datasetMap.get("del");
        List<Long> delDatasetList = datasetMap.get("del");
        if (delDatasetList.size() > 0) {
            insertSqlList.add(delData(aVersion.getDataSetTableName(), "id", delDatasetList));
        }
        List<Integer> delMetaList = metaMap.get("del");
        List<Long> delMetaList = metaMap.get("del");
        if (delMetaList.size() > 0) {
            insertSqlList.add(delData(aVersion.getMetaDataTableName(), "id", delMetaList));
        }
        List<Integer> delDicList = dicMap.get("del");
        List<Long> delDicList = dicMap.get("del");
        if (delDicList.size() > 0) {
            insertSqlList.add(delData(aVersion.getDictTableName(), "id", delDicList));
            insertSqlList.add(delData(aVersion.getDictEntryTableName(), "std_dict_id", delDicList));
@@ -441,7 +441,7 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        insertSqlList.add(SqlConstants.DELETE + SqlConstants.FROM + aVersion.getDictTableName());
        insertSqlList.add(SqlConstants.DELETE + SqlConstants.FROM + aVersion.getDictEntryTableName());*/
        List<Integer> addDataSetList = datasetMap.get("add");
        List<Long> addDataSetList = datasetMap.get("add");
        if (addDataSetList.size() > 0) {
            insertSqlList.add(insertData(aVersion.getDataSetTableName(), sVersion.getDataSetTableName(),
                    new String[]{"id,std_dataset_id,std_dataset_code,std_dataset_name"},
@@ -450,7 +450,7 @@ public class AdapterDatasetService extends SQLGeneralDAO {
                    "id",
                    addDataSetList));
        }
        List<Integer> addMetaList = metaMap.get("add");
        List<Long> addMetaList = metaMap.get("add");
        if (addMetaList.size() > 0) {
            insertSqlList.add(insertData(aVersion.getMetaDataTableName(), sVersion.getMetaDataTableName(),
                    new String[]{"id,std_metadata_id,std_metadata_code,std_metadata_name,std_dataset_id,std_dict_id"},
@@ -459,7 +459,7 @@ public class AdapterDatasetService extends SQLGeneralDAO {
                    "id",
                    addMetaList));
        }
        List<Integer> addDicList = dicMap.get("add");
        List<Long> addDicList = dicMap.get("add");
        if (addDicList.size() > 0) {
            insertSqlList.add(insertData(aVersion.getDictTableName(), sVersion.getDictTableName(),
                    new String[]{"id,std_dict_id,std_dict_code,std_dict_name"},
@@ -481,10 +481,10 @@ public class AdapterDatasetService extends SQLGeneralDAO {
    }
    private String delData(String adapterTableName, String item, List<Integer> idList) {
    private String delData(String adapterTableName, String item, List<Long> idList) {
        StringBuffer sql = new StringBuffer();
        String idStr = SqlConstants.EMPTY;
        for (Integer id : idList) {
        for (Long id : idList) {
            idStr += id + SqlConstants.COMMA;
        }
        if (!StringUtil.isEmpty(idStr)) {
@@ -500,13 +500,13 @@ public class AdapterDatasetService extends SQLGeneralDAO {
     * @param firtList   new
     * @param secondList old
     */
    private Map<String, List<Integer>> getDiffId(List<Integer> firtList, List<Integer> secondList) {
        Map<Integer, Integer> map = new HashMap<>();
        for (Integer id : firtList) {
    private Map<String, List<Long>> getDiffId(List<Long> firtList, List<Long> secondList) {
        Map<Long, Integer> map = new HashMap<>();
        for (Long id : firtList) {
            map.put(id, 1);
        }
        for (Integer id1 : secondList) {
        for (Long id1 : secondList) {
            Integer flag = map.get(id1);
            if (flag != null) {
                map.put(id1, ++flag);
@@ -516,32 +516,32 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        }
        List<Integer> diffLs = new ArrayList<>();
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
        List<Long> diffLs = new ArrayList<>();
        for (Map.Entry<Long, Integer> entry : map.entrySet()) {
            if (entry.getValue() == 1) {
                diffLs.add(entry.getKey());
            }
        }
        List<Integer> delIDLs = new ArrayList<>();
        List<Integer> addIDLs = new ArrayList<>();
        for (Integer diffL : diffLs) {
        List<Long> delIDLs = new ArrayList<>();
        List<Long> addIDLs = new ArrayList<>();
        for (Long diffL : diffLs) {
            if (firtList.contains(diffL)) {
                addIDLs.add(diffL);
            } else if (secondList.contains(diffL)) {
                delIDLs.add(diffL);
            }
        }
        Map<String, List<Integer>> listMap = new HashMap<>();
        Map<String, List<Long>> listMap = new HashMap<>();
        listMap.put("del", delIDLs);
        listMap.put("add", addIDLs);
        return listMap;
    }
    private String insertData(String adapterTableName, String stdTableName, String[] item1, String[] item2, Integer schemeId, String item, List<Integer> idList) {
    private String insertData(String adapterTableName, String stdTableName, String[] item1, String[] item2, Long schemeId, String item, List<Long> idList) {
        StringBuffer sql = new StringBuffer();
        String idStr = SqlConstants.EMPTY;
        for (Integer id : idList) {
        for (Long id : idList) {
            idStr += id + SqlConstants.COMMA;
        }
        if (!StringUtil.isEmpty(idStr)) {
@@ -653,7 +653,7 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        //設置匹配的机构数据緩存
        List<StdMetaDataModel> orgMetadatas = stdMetadataService.getList(adapter_std_version, null, null, null, null, null);//查找出机构所有的metadatas
        for (StdMetaDataModel stdMetadata:orgMetadatas){
            StdDataSetModel stdDataset = stdDataSetModelDao.getDatasetName(std_version, stdMetadata.getDatasetId());
            StdDataSetModel stdDataset = stdDataSetModelDao.getDatasetName(std_version, stdMetadata.getDataSetId());
            if(null != stdDataset){
                MetatdataStandardNameStrategy.getNameMap().put(stdMetadata.getName() + "_" + stdDataset.getCode(),stdMetadata);
                MetatdataStandardNameStrategy.getRemarkMap().put(stdMetadata.getDefinition() + "_" + stdDataset.getCode(),stdMetadata);
@@ -671,7 +671,7 @@ public class AdapterDatasetService extends SQLGeneralDAO {
            List<AdapterMetadataModel> adapterMetadatas = matchVO.getCodeAdapter().get(metadataNameFirstCode);//已存在
            if (adapterMetadatas != null && adapterMetadatas.size() > 0) {
                //获取待适配的数据集名
                Integer unAdaptStdId = unAdapterMetadataModel.getStdDatasetId();
                Long unAdaptStdId = unAdapterMetadataModel.getStdDatasetId();
                StdDataSetModel adapterDataset = stdDataSetModelDao.getDatasetName(adapter_std_version, unAdaptStdId);
                if (adapterDataset != null) {
                    adapterDatasetService = SpringContext.getService(AdapterDatasetService.BEAN_ID);

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/adapter/AdapterDictEntryService.java

@@ -50,7 +50,7 @@ public class AdapterDictEntryService extends SQLGeneralDAO {
            String sql = "select max(id) from " + version.getDictEntryTableName();
            Query query = session.createSQLQuery(sql);
            Object object = query.uniqueResult();
            adapterDictEntryModel.setId(object == null ? 1 : Integer.parseInt(object.toString()) + 1);
            adapterDictEntryModel.setId(object == null ? 1L : Long.parseLong(object.toString()) + 1);
            JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterDictEntryModel));
            SqlCreator sqlCreator = new SqlCreator(AdapterDictEntryModel.class);
@@ -148,14 +148,14 @@ public class AdapterDictEntryService extends SQLGeneralDAO {
        Query query = getQuery(sqlCreator, sql);
        if (limit != null) {
            query.setMaxResults(limit);
            if (offset != null) {
            if (offset != null &&offset>0) {
                query.setFirstResult((offset - 1) * limit);
            }
        }
        List<AdapterDictEntryModel> modelList = query.list();
        List<Integer> idList = new ArrayList<>();
        Map<Integer, StdDictionaryModel> stdDictModelMap = new HashMap<>();
        Integer schemeId = null;
        List<Long> idList = new ArrayList<>();
        Map<Long, StdDictionaryModel> stdDictModelMap = new HashMap<>();
        Long schemeId = null;
        for (AdapterDictEntryModel model : modelList) {
            if (model.getAdapterDictId() != null) {
                schemeId = model.getSchemeId();
@@ -227,9 +227,9 @@ public class AdapterDictEntryService extends SQLGeneralDAO {
        try {
            AdapterVersion version = new AdapterVersion(adapterVersion);
            List<AdapterDictEntryResultDetailModel> adapterDictEntryList = Arrays.asList(objectMapper.readValue(list, AdapterDictEntryResultDetailModel[].class));
            List<Integer> idList = new ArrayList<>();
            Map<Integer, AdapterDictEntryResultDetailModel> dictEntryResultMap = new HashMap<>();
            Integer maxId = null;
            List<Long> idList = new ArrayList<>();
            Map<Long, AdapterDictEntryResultDetailModel> dictEntryResultMap = new HashMap<>();
            Long maxId = null;
            for (AdapterDictEntryResultDetailModel dictEntryModel : adapterDictEntryList) {
                AdapterDictEntryModel adapterDictEntryModel = new AdapterDictEntryModel();
                adapterDictEntryModel.setId(dictEntryModel.getId());
@@ -252,7 +252,7 @@ public class AdapterDictEntryService extends SQLGeneralDAO {
                        sql = "select max(id) from " + version.getDictEntryTableName();
                        Query query = getCurrentSession().createSQLQuery(sql);
                        Object object = query.uniqueResult();
                        maxId = object == null ? 1 : Integer.parseInt(object.toString()) + 1;
                        maxId = object == null ? 1L : Long.parseLong(object.toString()) + 1;
                    }
                    adapterDictEntryModel.setId(maxId++);
                    JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterDictEntryModel));

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/adapter/AdapterDictService.java

@@ -73,7 +73,7 @@ public class AdapterDictService extends SQLGeneralDAO {
            String sql = "select max(id) from " + version.getMetaDataTableName();
            Query query = session.createSQLQuery(sql);
            Object object = query.uniqueResult();
            adapterDictModel.setId(object == null ? 1 : Integer.parseInt(object.toString()) + 1);
            adapterDictModel.setId(object == null ? 1L : Long.parseLong(object.toString()) + 1);
            JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterDictModel));
            SqlCreator sqlCreator = new SqlCreator(AdapterDictModel.class);
@@ -172,7 +172,7 @@ public class AdapterDictService extends SQLGeneralDAO {
        Query query = getQuery(sqlCreator, sql);
        if (limit != null) {
            query.setMaxResults(limit);
            if (offset != null) {
            if (offset != null &&offset>0) {
                query.setFirstResult((offset - 1) * limit);
            }
        }
@@ -237,7 +237,7 @@ public class AdapterDictService extends SQLGeneralDAO {
        for (AdapterDictEntryModel unAdapterDictEntryModel : unAdapterDictEntryModels) {
            threadPoolTaskExecutor.execute(new DictItemStrategyExecute(unAdapterDictEntryModel, matchVO,std_version,adapter_std_version,version, stdDictionaryDao, stdDictionaryEntryDao,adapterDictEntryService));
            Integer unAdaptDicId = unAdapterDictEntryModel.getStdDictId();
            Long unAdaptDicId = unAdapterDictEntryModel.getStdDictId();
            StdDictionaryModel adapterDictionaryModel = stdDictionaryDao.getDictionaryName(adapter_std_version, unAdaptDicId);
            if (adapterDictionaryModel != null) {
                adapterDictService = SpringContext.getService(AdapterDictService.BEAN_ID);

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/adapter/AdapterMetadataService.java

@@ -53,7 +53,7 @@ public class AdapterMetadataService extends SQLGeneralDAO {
            String sql = "select max(id) from " + version.getMetaDataTableName();
            Query query = session.createSQLQuery(sql);
            Object object = query.uniqueResult();
            adapterMetadataModel.setId(object == null ? 1 : Integer.parseInt(object.toString()) + 1);
            adapterMetadataModel.setId(object == null ? 1L : Long.parseLong(object.toString()) + 1);
            JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterMetadataModel));
            SqlCreator sqlCreator = new SqlCreator(AdapterMetadataModel.class);
@@ -155,15 +155,15 @@ public class AdapterMetadataService extends SQLGeneralDAO {
        Query query = getQuery(sqlCreator, sql);
        if (limit != null) {
            query.setMaxResults(limit);
            if (offset != null) {
            if (offset != null &&offset>0) {
                query.setFirstResult((offset - 1) * limit);
            }
        }
        List<AdapterMetadataModel> modelList = query.list();
        List<Integer> idList = new ArrayList<>();
        Map<Integer, StdDataSetModel> stdDatasetModelMap = new HashMap<>();
        Integer schemeId = null;
        List<Long> idList = new ArrayList<>();
        Map<Long, StdDataSetModel> stdDatasetModelMap = new HashMap<>();
        Long schemeId = null;
        for (AdapterMetadataModel model : modelList) {
            if (model.getAdapterDatasetId() != null) {
                schemeId = model.getSchemeId();
@@ -238,9 +238,9 @@ public class AdapterMetadataService extends SQLGeneralDAO {
    public List getInfoList(String adapterVersion, String condition, String order, Integer limit, Integer offset) throws Exception{
        AdapterVersion version = new AdapterVersion(adapterVersion);        List<AdapterMetadataModel> metadataModelList = getList(AdapterMetadataModel.class, version.getMetaDataTableName(), condition, order, limit, offset);
        List<Integer> idList = new ArrayList<>();
        Map<Integer, StdMetaDataModel> stdMetaDataModelMap = new HashMap<>();
        Integer schemeId = null;
        List<Long> idList = new ArrayList<>();
        Map<Long, StdMetaDataModel> stdMetaDataModelMap = new HashMap<>();
        Long schemeId = null;
        for (AdapterMetadataModel model : metadataModelList) {
            if (model.getAdapterMetadataId() != null) {
                idList.add(model.getAdapterMetadataId());
@@ -294,8 +294,8 @@ public class AdapterMetadataService extends SQLGeneralDAO {
            AdapterVersion version = new AdapterVersion(adapterVersion);
            List<ApiMetadataResultDetailModel> adapterMetadataList = Arrays.asList(objectMapper.readValue(list, ApiMetadataResultDetailModel[].class));
            List<String> sqlList = new ArrayList<>();
            List<Integer> idList = new ArrayList<>();
            Map<Integer, ApiMetadataResultDetailModel> metadataResultMap = new HashMap<>();
            List<Long> idList = new ArrayList<>();
            Map<Long, ApiMetadataResultDetailModel> metadataResultMap = new HashMap<>();
            for (ApiMetadataResultDetailModel metadataModel : adapterMetadataList) {
                AdapterMetadataModel adapterMetadataModel = new AdapterMetadataModel();
                adapterMetadataModel.setId(metadataModel.getId());
@@ -460,7 +460,7 @@ public class AdapterMetadataService extends SQLGeneralDAO {
    }
    public void saveAdapt(AdapterMetadataModel strategyMetadata,StdMetaDataModel orgMetadata,String version,String adapterInfo) throws Exception {
        strategyMetadata.setAdapterDatasetId(orgMetadata.getDatasetId());
        strategyMetadata.setAdapterDatasetId(orgMetadata.getDataSetId());
        strategyMetadata.setAdapterMetadataId(orgMetadata.getId());
        strategyMetadata.setAdapterMetadataCode(orgMetadata.getCode());
        strategyMetadata.setAdapterMetadataName(orgMetadata.getName());
@@ -476,7 +476,7 @@ public class AdapterMetadataService extends SQLGeneralDAO {
        StringBuilder sqlBuffer = new StringBuilder();
        if(null != orgMetadata){
            sqlBuffer.append(SqlConstants.UPDATE + new AdapterVersion(version).getMetaDataTableName() + SqlConstants.SET);
            sqlBuffer.append(" adapter_dataset_id = " + orgMetadata.getDatasetId());
            sqlBuffer.append(" adapter_dataset_id = " + orgMetadata.getDataSetId());
            sqlBuffer.append(",adapter_metadata_id = " + orgMetadata.getId());
            sqlBuffer.append(",adapter_metadata_code = '" + orgMetadata.getCode() + "'");
            sqlBuffer.append(",adapter_metadata_name = '" + orgMetadata.getName() + "'");

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/adapter/AdapterSchemeService.java

@@ -90,7 +90,7 @@ public class AdapterSchemeService extends SQLGeneralDAO {
        }
    }
    public Boolean schemeNameValidate(Integer schemeId, String name) {
    public Boolean schemeNameValidate(Long schemeId, String name) {
        String sql = "FROM AdapterSchemeModel WHERE name = :name and id != :schemeId";
        Query query = getCurrentSession().createQuery(sql);
        query.setParameter("name", name);
@@ -148,11 +148,11 @@ public class AdapterSchemeService extends SQLGeneralDAO {
            String schemeHql = "FROM AdapterSchemeModel";
            Query query = getCurrentSession().createQuery(schemeHql);
            List<AdapterSchemeModel> adapterSchemeModelList = query.list();
            List<Integer> schemeIdList = new ArrayList<>();
            List<Integer> stdIdList = new ArrayList<>();
            List<Long> schemeIdList = new ArrayList<>();
            List<Long> stdIdList = new ArrayList<>();
            List<String> versionList = new ArrayList<>();
            Map<Integer, AdapterSchemeVersionModel> schemeVersionMap = new HashMap<>();
            Map<Integer, StandardModel> stdMap = new HashMap<>();
            Map<Long, AdapterSchemeVersionModel> schemeVersionMap = new HashMap<>();
            Map<Long, StandardModel> stdMap = new HashMap<>();
            Map<String, StandardVersionModel> stdVersionMap = new HashMap<>();
            for (AdapterSchemeModel adapterSchemeModel : adapterSchemeModelList) {
@@ -211,11 +211,11 @@ public class AdapterSchemeService extends SQLGeneralDAO {
                resultDetailModel.setName(schemeModel.getName());
                resultDetailModel.setStdName(stdMap.get(schemeModel.getStdId()).getName());
                resultDetailModel.setStdVersion(stdVersionMap.get(schemeModel.getStdVersion()).getVersion());
                resultDetailModel.setStdVersionName(stdVersionMap.get(schemeModel.getStdVersion()).getName());
                resultDetailModel.setStdVersionName(stdVersionMap.get(schemeModel.getStdVersion()).getVersionName());
                resultDetailModel.setPublisher(stdMap.get(schemeModel.getAdapterStdId()) == null ? "" : stdMap.get(schemeModel.getAdapterStdId()).getPublisher());
                resultDetailModel.setAdapterName(stdMap.get(schemeModel.getAdapterStdId()) == null ? "" : stdMap.get(schemeModel.getAdapterStdId()).getName());
                if (stdVersionMap.get(schemeModel.getAdapterStdVersion()) != null) {
                    resultDetailModel.setAdapterVersionName(stdVersionMap.get(schemeModel.getAdapterStdVersion()).getName());
                    resultDetailModel.setAdapterVersionName(stdVersionMap.get(schemeModel.getAdapterStdVersion()).getVersionName());
                    resultDetailModel.setAdapterStdVersion(stdVersionMap.get(schemeModel.getAdapterStdVersion()).getVersion());
                }
                if (StringUtil.isEmpty(name) || schemeModel.getName().contains(name)) {

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/adapter/AdapterSchemeVersionService.java

@@ -98,7 +98,7 @@ public class AdapterSchemeVersionService extends SQLGeneralDAO {
        }
    }
    public Boolean schemeVersionNameValidate(Integer schemeId, String name) {
    public Boolean schemeVersionNameValidate(Long schemeId, String name) {
        String sql = "FROM AdapterSchemeVersionModel WHERE schemeId = :schemeId and name = :name";
        Query query = getCurrentSession().createQuery(sql);
        query.setParameter("schemeId", schemeId);
@@ -133,7 +133,7 @@ public class AdapterSchemeVersionService extends SQLGeneralDAO {
        }
    }
    public Boolean schemeVersionNameValidate(Integer schemeId, Integer versionId, String name) {
    public Boolean schemeVersionNameValidate(Long schemeId, Long versionId, String name) {
        String sql = "FROM AdapterSchemeVersionModel WHERE schemeId = :schemeId and name = :name and id != :versionId";
        Query query = getCurrentSession().createQuery(sql);
        query.setParameter("schemeId", schemeId);
@@ -231,8 +231,8 @@ public class AdapterSchemeVersionService extends SQLGeneralDAO {
            Criteria criteria = session.createCriteria(AdapterSchemeVersionModel.class);
            criteria.add(Restrictions.eq("publishStatus", 1));
            List<AdapterSchemeVersionModel> versionModelList = criteria.list();
            List<Integer> schemeIdList = new ArrayList<>();
            Map<Integer, String> schemeMap = new HashMap<>();
            List<Long> schemeIdList = new ArrayList<>();
            Map<Long, String> schemeMap = new HashMap<>();
            for (AdapterSchemeVersionModel model : versionModelList) {
                schemeIdList.add(model.getSchemeId());
            }
@@ -283,9 +283,9 @@ public class AdapterSchemeVersionService extends SQLGeneralDAO {
            Object[] object = (Object[]) adapterSchemeVersionQuery.uniqueResult();
            if (object != null) {
                AdapterSchemeVersionModel adapterSchemeVersionModel = new AdapterSchemeVersionModel();
                adapterSchemeVersionModel.setId((Integer) object[0]);
                adapterSchemeVersionModel.setId((Long) object[0]);
                adapterSchemeVersionModel.setVersion((String) object[1]);
                adapterSchemeVersionModel.setSchemeId((Integer) object[2]);
                adapterSchemeVersionModel.setSchemeId((Long) object[2]);
                adapterSchemeVersionModel.setName((String) object[3]);
                return adapterSchemeVersionModel;
            } else {
@@ -435,7 +435,7 @@ public class AdapterSchemeVersionService extends SQLGeneralDAO {
        String sql = sqlCreator.selectData(stdVersion.getMetaDataTableName());
        Query query = getQuery(sqlCreator, sql);
        List<StdMetaDataModel> metadataList = query.list();
        List<Integer> newDictdList = new ArrayList<>();
        List<Long> newDictdList = new ArrayList<>();
        for (StdMetaDataModel stdMetaDataModel : metadataList) {
            if (stdMetaDataModel.getDictId() != null && !newDictdList.contains(stdMetaDataModel.getDictId())) {
                newDictdList.add(stdMetaDataModel.getDictId());
@@ -485,11 +485,11 @@ public class AdapterSchemeVersionService extends SQLGeneralDAO {
        return sqlList;
    }
    private String insertData(String adapterTableName, String stdTableName, String[] item1, String[] item2, Integer schemeId, String item, List<Integer> idList) {
    private String insertData(String adapterTableName, String stdTableName, String[] item1, String[] item2, Long schemeId, String item, List<Long> idList) {
        StringBuffer sql = new StringBuffer();
        String idStr = SqlConstants.EMPTY;
        if (!CollectionUtils.isEmpty(idList)) {
            for (Integer id : idList) {
            for (Long id : idList) {
                idStr += id + SqlConstants.COMMA;
            }
            if (!StringUtil.isEmpty(idStr)) {

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/bo/AdapterVersion.java

@@ -47,6 +47,32 @@ public class AdapterVersion {
        return version.toString();
    }
    public String getTableName(String dataType) {
        String tableName = null;
        switch (dataType) {
            case DataSetTablePrefix:
                tableName = DataSetTablePrefix + "_" + version;
                break;
            case MetaDataTablePrefix:
                tableName =  MetaDataTablePrefix + "_" + version;
                break;
            case DictTablePrefix:
                tableName = DictTablePrefix + "_" + version;
                break;
            case DictEntryTablePrefix:
                tableName = DictEntryTablePrefix + "_" + version;
                break;
            case DatasetRelationTablePrefix:
                tableName = DatasetRelationTablePrefix + "_" + version;
                break;
            default:
                tableName = null;
                break;
        }
        return tableName;
    }
    public void finalize() throws Throwable {
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/bo/StandardVersion.java

@@ -54,6 +54,34 @@ public class StandardVersion {
        return version.toString();
    }
    public String getTableName(String dataType) {
        String tableName = null;
        switch (dataType) {
            case DataSetTable:
                tableName = DataSetTable + VersionBoundSymbol + version;
                break;
            case MetaDataTable:
                tableName =  MetaDataTable + VersionBoundSymbol + version;
                break;
            case DictTable:
                tableName = DictTable + VersionBoundSymbol + version;
                break;
            case DictEntryTable:
                tableName = DictEntryTable + VersionBoundSymbol + version;
                break;
            case CDADocumentTable:
                tableName = CDADocumentTable + VersionBoundSymbol + version;
                break;
            case CDADatasetTable:
                tableName = CDADatasetTable + VersionBoundSymbol + version;
                break;
            default:
                tableName = null;
                break;
        }
        return tableName;
    }
    public void finalize() throws Throwable {
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/document/CDADataSetRelationshipManager.java

@@ -0,0 +1,409 @@
package com.yihu.jw.basic.standard.service.document;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.yihu.fastdfs.FastDFSUtil;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.basic.standard.model.*;
import com.yihu.jw.basic.standard.model.standard.StdDataSetModel;
import com.yihu.jw.basic.standard.model.standard.StdMetaDataModel;
import com.yihu.jw.basic.standard.service.bo.StandardVersion;
import com.yihu.jw.basic.standard.service.standard.StdDatasetService;
import com.yihu.jw.basic.standard.service.standard.StdMetadataService;
import com.yihu.jw.basic.util.CDAVersionUtil;
import com.yihu.jw.exception.ApiException;
import com.yihu.jw.restmodel.ehr.standard.MCdaDataSet;
import com.yihu.jw.util.sql.ErrorCode;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
/**
 * @author AndyCai
 * @version 1.0
 * @created 02-9月-2015 14:00:55
 */
@Service
public class CDADataSetRelationshipManager extends SQLGeneralDAO {
    @Autowired
    private FastDFSUtil fastDFSUtil;
    @Autowired
    private CDADocumentService cdaDocumentService;
    @Autowired
    private StdMetadataService metaDataService;
    @Autowired
    private StdDatasetService dataSetService;
    /**
     * 根据关系ID删除关联关系
     *
     * @param ids
     */
    public boolean deleteRelationshipById(String version, String[] ids) {
        delete(BaseCDADataSetRelationship.class,ids, StandardVersion.CDADatasetTable, version);
        return true;
    }
    /**
     * 同时删除多个时 CDA ID用逗号隔开
     *
     * @param versionCode
     * @param ids
     */
    public boolean deleteDocument(String[] ids,String dataType,String versionCode) throws IOException {
        deleteRelationshipByCdaIds(versionCode,ids);
        delete(CDADocument.class,ids, dataType,versionCode);
        return true;
    }
    /**
     * 根据CDAID删除CDA数据集关联关系
     *
     * @param version
     * @param cdaIds
     */
    public void deleteRelationshipByCdaIds(String version, String[] cdaIds) throws IOException {
        List<BaseCDADataSetRelationship> ls = cdaDocumentService.searchPageData(BaseCDADataSetRelationship.class,StandardVersion.CDADatasetTable,version,"cdaId=" + String.join(",", cdaIds),null,null,null);
        String ids = "";
        for (int i = 0; i < ls.size(); i++) {
            BaseCDADataSetRelationship cdaDataSetRelationship = ls.get(i);
            if (i == 0) {
                ids += cdaDataSetRelationship.getId();
            } else {
                ids += "," + cdaDataSetRelationship.getId();
            }
            //ids += cdaDataSetRelationship.getId();
        }
        deleteByField("id",ids.split(","),StandardVersion.CDADatasetTable,version);
    }
    /**
     * 根据CDAID获取关联关系
     *
     * @param entityClass
     * @param filters
     * @param sorts
     * @param size
     * @param page
     * @return
     */
    public List getCDADataSetRelationships(Class entityClass,String version, String filters, String sorts, Integer size, Integer page) {
        List ls = null;
        try {
            ls = searchVersionData(entityClass,version,StandardVersion.CDADatasetTable, filters, sorts, page, size);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return ls;
    }
    public List getCDADataSetRelationshipByCDAId(Class entityClass,String version, String cdaId) {
        List ls = null;
        try {
            ls = searchVersionData(entityClass, version,StandardVersion.DataSetTable,"cdaId=" + cdaId);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return ls;
    }
    public List getCDADataSetRelationshipByCDAId( String version,String dataType, String cdaId) throws IOException {
        List ls = searchVersionData(CDADataSetRelationship.class,version,StandardVersion.CDADatasetTable, "cdaId=" + cdaId);
        return ls;
    }
    /**
     * 获取关联关系
     */
    public List<CDADataSetRelationship> getCDADataSetRelationship(String versionCode) {
        Session session = currentSession();
        String strTableName = CDAVersionUtil.getCDADatasetRelationshipTableName(versionCode);
        String strSql = "SELECT t.id," +
                "t.cda_id," +
                "t.dataSet_id" +
                " from " + strTableName + " t ";
        List<Object> records = session.createSQLQuery(strSql).list();
        List<CDADataSetRelationship> infos = new ArrayList<>();
        for (int i = 0; i < records.size(); ++i) {
            Object[] record = (Object[]) records.get(i);
            CDADataSetRelationship info = new CDADataSetRelationship();
            info.setId(record[0].toString());
            info.setCdaId(record[1].toString());
            info.setDataSetId(record[2].toString());
            infos.add(info);
        }
        return infos;
    }
    /**
     * 保存CDA信息
     * 1.先删除CDA数据集关联关系信息与cda文档XML文件，在新增信息
     *
     * @param strDataSetIds  关联的数据集
     * @param cdaId       cda文档 ID
     * @param versionCode 版本号
     * @param xmlInfo     xml 文件内容
     * @return 操作结果
     */
    public boolean SaveDataSetRelationship(String strDataSetIds, String cdaId, String versionCode, String xmlInfo) throws Exception {
        deleteRelationshipByCdaIds(versionCode, new String[]{cdaId});
        List<CDADocument> cdaDocuments = cdaDocumentService.searchPageData(BaseCDADocument.class,StandardVersion.CDADocumentTable,versionCode,"id="+cdaId,null,null,null);
        if (cdaDocuments.size() <= 0) return false;
        BaseCDADocument cdaDocument = cdaDocuments.get(0);
        if (cdaDocument.getFileGroup() != null
                && !cdaDocument.getFileGroup().equals("")
                && cdaDocument.getSchema() != null
                && !cdaDocument.getSchema().equals("")) {
            fastDFSUtil.delete(cdaDocument.getFileGroup(), cdaDocument.getSchema());
        }
        String[] dataSetIds = strDataSetIds.split(",");
        if (dataSetIds == null || dataSetIds.length == 0) return true;
        List<CDADataSetRelationship> infos = new ArrayList<>();
        for (int i = 0; i < dataSetIds.length; i++) {
            String dataSetId = dataSetIds[i];
            CDADataSetRelationship info = new CDADataSetRelationship();
            info.setCdaId(cdaId);
            info.setDataSetId(dataSetId);
            infos.add(info);
        }
        //cdaDataSetRelationshipManager.addRelationship(infos,versionCode);
        if (infos.size() > 0) {
            addRelationship(infos, versionCode);
        } else {
            throw new ApiException(ErrorCode.GetStdVersionFailed.getErrorCode());
        }
        String strFilePath = SaveCdaFile(xmlInfo, versionCode, cdaId);
        //将文件上传到服务器中
        ObjectNode msg = fastDFSUtil.upload(strFilePath, "");
        String strFileGroup = msg.get(FastDFSUtil.GROUP_NAME).asText();
        String strSchemePath = msg.get(FastDFSUtil.REMOTE_FILE_NAME).asText();
        File file = new File(strFilePath);
        // 路径为文件且不为空则进行删除
        if (file.isFile() && file.exists()) {
            file.delete();
        }
        boolean bRes = saveXmlFilePath(new String[]{cdaId}, versionCode, strFileGroup, strSchemePath);
        return bRes;
    }
    /**
     * 将String 保存为XML文件
     *
     * @param fileInfo 文件信息
     * @return 返回 文件路径
     */
    public String SaveCdaFile(String fileInfo, String versionCode, String cdaId) throws IOException {
        fileInfo = fileInfo.replaceAll("&lt;", "<").replaceAll("&gt;", ">");
        String strPath = System.getProperty("java.io.tmpdir");
        String splitMark = System.getProperty("file.separator");
        strPath += "StandardFiles";
        //文件路径
        String strXMLFilePath = strPath + splitMark + "xml" + splitMark + versionCode + splitMark + "createfile" + splitMark + cdaId + ".xml";
        File file = new File(strXMLFilePath);
        if (!file.getParentFile().exists()) {
            file.getParentFile().mkdirs();
        }
        file.createNewFile();
        FileWriter fw = new FileWriter(file, true);
        BufferedWriter bw = new BufferedWriter(fw);
        bw.write(fileInfo);
        bw.flush();
        bw.close();
        fw.close();
        return strXMLFilePath;
    }
    public boolean saveXmlFilePath(String[] cdaIds, String versionCode, String fileGroup, String filePath) throws IOException {
        List<CDADocument> cdaDocuments = cdaDocumentService.searchVersionData(BaseCDADocument.class,versionCode,StandardVersion.CDADocumentTable, "id=" + String.join(",", cdaIds));
        if (cdaDocuments.size() <= 0) {
            return false;
        }
        BaseCDADocument cdaDocument = cdaDocuments.get(0);
        cdaDocument.setFileGroup(fileGroup);
        cdaDocument.setSchema(filePath);
        cdaDocument.setVersionCode(versionCode);
        Result result = cdaDocumentService.modify(versionCode, cdaDocument);
        if(result.isSuccessFlg()){
            return true;
        }
        return false;
    }
    public CDADocument saveCdaInfo(String cdaDocumentJsonData) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        CDADocument cdaInfo = objectMapper.readValue(cdaDocumentJsonData, CDADocument.class);
        if (cdaDocumentService.isDocumentExist(cdaInfo.getVersionCode(), cdaInfo.getCode(), cdaInfo.getId())) {
            throw new Exception("已存在");
        }
        cdaDocumentService.saveEntity(cdaInfo);
        return cdaInfo;
    }
    /**
     * 新增关联关系
     *
     * @param cdaDatasetRelationships
     */
    public boolean addRelationship(List<CDADataSetRelationship> cdaDatasetRelationships, String versionCode) {
        Session session = currentSession();
        String strTableName = CDAVersionUtil.getCDADatasetRelationshipTableName(versionCode);
        String sql;
        Query query;
        String strValues = "";
        for (int i = 0; i < cdaDatasetRelationships.size(); i++) {
            CDADataSetRelationship info = (CDADataSetRelationship) cdaDatasetRelationships.get(i);
            if (StringUtils.isEmpty(info.getId())) {
                String strId = UUID.randomUUID().toString();
                info.setId(strId);
            }
            strValues += "('" + info.getId() + "','" + info.getCdaId() + "','" + info.getDataSetId() + "'),";
        }
        strValues = strValues.substring(0, strValues.length() - 1);
        sql = "insert into " + strTableName +
                " (id,cda_id,dataset_id) " +
                "values " + strValues;
        query = session.createSQLQuery(sql);
        query.executeUpdate();
        return true;
    }
    public List<MCdaDataSet> getCDADataSetByCDAId(String version, String cdaId) {
        String sql = "SELECT " +
                " scdsr.id id,scdsr.cda_id cdaId,scdsr.dataset_id dataSetId, sds.CODE dataSetCode,sds.multi_record multiRecord " +
                "FROM " +
                " std_cda_data_set_relationship_" + version + " scdsr, " +
                " std_data_set_" + version + " sds " +
                "WHERE " +
                " 1 = 1 " +
                "AND scdsr.cda_id = '" + cdaId + "' " +
                "AND scdsr.dataset_id = sds.id";
        RowMapper rowMapper = (RowMapper) BeanPropertyRowMapper.newInstance(MCdaDataSet.class);
        return this.jdbcTemplate.query(sql, rowMapper);
    }
    /**
     * 根据CDA Id 和 版本编码 生成CDA文档
     * @param cdaId
     * @param versionCode
     * @return
     * @throws TransformerException
     * @throws ParserConfigurationException
     * @throws FileNotFoundException
     * @throws UnsupportedEncodingException
     */
    public boolean createCDASchemaFile(String cdaId, String versionCode) throws Exception {
        List<CDADataSetRelationship> relationshipsList = getCDADataSetRelationshipByCDAId(CDADataSetRelationship.class,versionCode,cdaId);
        String strPath = System.getProperty("java.io.tmpdir");
        strPath += "StandardFiles";
        String splitMark = System.getProperty("file.separator");
        String strXMLFilePath = strPath + splitMark + "xml" + splitMark + versionCode + splitMark;
        File file = new File(strXMLFilePath);
        if (!file.exists()) {
            file.mkdirs();
        }
        String strFilepath = strXMLFilePath + cdaId + ".xml";
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document doc = builder.newDocument();
        Element root = doc.createElement("xs:schema");
        root.setAttribute("xmlns:xs", "http://www.w3.org/2001/XMLSchema");
        root.setAttribute("targetNamespace", "http://www.w3schools.com");
        root.setAttribute("xmlns", "http://www.w3schools.com");
        root.setAttribute("elementFormDefault", "qualified");
        doc.appendChild(root);
        for (int i = 0; i < relationshipsList.size(); i++) {
            //获取数据集
            BaseCDADataSetRelationship dataSetRelationship = relationshipsList.get(i);
            StandardVersion ver = new StandardVersion(versionCode);
            StdDataSetModel dataSet = dataSetService.retrieve(StdDataSetModel.class,ver.getDataSetTableName(),Long.parseLong(dataSetRelationship.getDataSetId()));
            Element rowSet = doc.createElement("xs:table");
            rowSet.setAttribute("code", dataSet.getCode());
            root.appendChild(rowSet);
            //获取数据元
            List<StdMetaDataModel> metaDatas = metaDataService.searchVersionData(StdMetaDataModel.class,StandardVersion.MetaDataTable,versionCode,"dataSetId="+dataSet.getId());
            for (int j = 0; j < metaDatas.size(); j++) {
                Element rowEle = doc.createElement("xs:element");
                rowEle.setAttribute("code", metaDatas.get(j).getCode());
                String strColumnType = StringUtils.isEmpty(metaDatas.get(j).getColumnType()) ? "VARCHAR" : metaDatas.get(j).getColumnType();
                rowEle.setAttribute("type", "xs:" + strColumnType);
                rowSet.appendChild(rowEle);
            }
        }
        //生成XML文件
        outputXml(doc, strFilepath);
        return true;
    }
    private void outputXml(Document doc, String fileName) throws TransformerException, FileNotFoundException, UnsupportedEncodingException {
        TransformerFactory tf = TransformerFactory.newInstance();
        Transformer transformer = tf.newTransformer();
        DOMSource source = new DOMSource(doc);
        transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
        transformer.setOutputProperty(OutputKeys.INDENT, "yes");//设置文档的换行与缩进
        OutputStreamWriter pw = new OutputStreamWriter(new FileOutputStream(fileName), "UTF-8");
        StreamResult result = new StreamResult(pw);
        transformer.transform(source, result);
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/document/CDADocumentService.java

@@ -0,0 +1,103 @@
package com.yihu.jw.basic.standard.service.document;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.basic.standard.model.BaseCDADocument;
import com.yihu.jw.basic.standard.model.CDADocument;
import com.yihu.jw.basic.standard.model.Result;
import com.yihu.jw.basic.standard.service.bo.StandardVersion;
import com.yihu.jw.util.sql.SqlCreator;
import com.yihu.utils.date.DateUtil;
import org.hibernate.Query;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.List;
import java.util.UUID;
/**
 * @author AndyCai
 * @version 1.0
 * @created 01-9月-2015 17:17:50
 */
@Service
public class CDADocumentService extends SQLGeneralDAO {
    public static final String BEAN_ID = "CDADocumentService";
    public void saveCdaDocument(BaseCDADocument cdaDocument) {
        try {
            saveEntity(cdaDocument);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public Result add(String adapterVersion, BaseCDADocument obj) throws IOException {
        StandardVersion version = new StandardVersion(adapterVersion);
        obj.setId(UUID.randomUUID().toString().replaceAll("-", ""));
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(obj));
        SqlCreator sqlCreator = new SqlCreator(BaseCDADocument.class);
        String sql = sqlCreator.insertData(version.getCDATableName(), jsonNode);
        Query query = getExeuteQuery(sqlCreator, sql);
        query.executeUpdate();
        obj.setSuccessFlg(true);
        obj.setMessage("保存成功");
        return obj;
    }
    public Result modify(String adapterVersion, BaseCDADocument obj) {
        try {
            StandardVersion version = new StandardVersion(adapterVersion);
            ObjectMapper mapper = new ObjectMapper();
            mapper.setDateFormat(new SimpleDateFormat(DateUtil.DEFAULT_YMDHMSDATE_FORMAT));
            JsonNode jsonNode = mapper.readTree(mapper.writeValueAsString(obj));
            SqlCreator sqlCreator = new SqlCreator(BaseCDADocument.class);
            String sql = sqlCreator.updateDataByTableKey(version.getCDATableName(), jsonNode);
            Query query = getExeuteQuery(sqlCreator, sql);
            query.executeUpdate();
            obj.setSuccessFlg(true);
            obj.setMessage("修改成功");
            return obj;
        } catch (Exception e) {
            return Result.error("修改失败");
        }
    }
    public boolean isDocumentExist(String version, String documentCode,String documentId) throws IOException {
        List list;
        if(StringUtils.isEmpty(documentId)){
            list = searchVersionData(CDADocument.class,version,StandardVersion.CDADocumentTable, "code="+documentCode);
        }else {
            list = searchVersionData(CDADocument.class,version, StandardVersion.CDADocumentTable, "code="+documentCode+",id="+documentId);
        }
        return list.size() > 0;
    }
    public boolean isFileExists(String cdaId, String strVersionCode) {
        String strFilePath = FilePath(strVersionCode) + cdaId + ".xml";
        File file = new File(strFilePath);
        return file.exists();
    }
    public String FilePath(String strVersionCode) {
        String strPath = System.getProperty("java.io.tmpdir");
        strPath += "StandardFiles";
        String splitMark = System.getProperty("file.separator");
        String strXMLFilePath = strPath + splitMark + "xml" + splitMark + strVersionCode + splitMark;
        return strXMLFilePath;
    }
    public CDADocument retrieve(String version,String id){
        return (CDADocument) get(CDADocument.class,version,id);
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/qc/RuleService.java

@@ -0,0 +1,412 @@
package com.yihu.jw.basic.standard.service.qc;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.jw.basic.redis.schema.StdQcMetaDataKeySchema;
import com.yihu.jw.basic.standard.dao.QcRuleMetadataDao;
import com.yihu.jw.basic.standard.dao.RuleDao;
import com.yihu.jw.basic.standard.model.Result;
import com.yihu.jw.basic.standard.model.qc.RuleModel;
import com.yihu.jw.basic.standard.model.standard.STDVersion;
import com.yihu.jw.basic.standard.model.standard.StdDataSetModel;
import com.yihu.jw.basic.standard.model.standard.StdMetaDataModel;
import com.yihu.jw.basic.standard.service.bo.StandardVersion;
import com.yihu.jw.basic.standard.service.standard.STDVersionService;
import com.yihu.jw.basic.standard.service.standard.StdDatasetService;
import com.yihu.jw.basic.standard.service.standard.StdMetadataService;
import org.apache.commons.collections.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.io.IOException;
import java.io.Serializable;
import java.util.*;
/**
 * @author CD
 * @vsrsion 1.0
 * Created at 2017/05/05.
 */
@Service("ruleService")
public class RuleService {
    public static final String BEAN_ID = "ruleService";
    static final Logger logger = LoggerFactory.getLogger(RuleService.class);
    @Resource(name = RuleDao.BEAN_ID)
    private RuleDao ruleDao;
    @Autowired
    private ObjectMapper objectMapper;
    @Autowired
    private StdMetadataService stdMetadataService;
    @Autowired
    private QcRuleMetadataDao qcRuleMetadataDao;
    @Autowired
    private STDVersionService stdVersionService;
    @Autowired
    private StdQcMetaDataKeySchema qcMetaDataKeySchema;
    @Autowired
    private StdDatasetService stdDatasetService;
    public Result getRuleList(Map<String, Object> params) throws Exception {
        return ruleDao.getRuleList(params);
    }
    public RuleModel getRuleById(String id) throws Exception {
        return ruleDao.getEntity(RuleModel.class, id);
    }
    @Transactional
    public Result addRule(RuleModel obj) throws Exception {
        ruleDao.saveEntity(obj);
        return Result.success("保存成功");
    }
    @Transactional
    public Result updateRule(RuleModel obj) throws Exception {
        ruleDao.updateEntity(obj);
        return Result.success("更新成功");
    }
    @Transactional
    public Result deleteRule(String id) throws Exception {
        RuleModel ruleModel = ruleDao.getEntity(RuleModel.class, id);
        ruleDao.deleteEntity(ruleModel);
        return Result.success("删除成功");
    }
    /**
     * 收集数据元需要绑定的质控规则
     *
     * @param metadata   数据元
     */
    private RuleModel collectQcRule(StdMetaDataModel metadata) {
        RuleModel ruleModel = null;
        String ruleCode = "";
        try {
            // 时间格式检验
            if (metadata.getFormat().contains("DT") || metadata.getColumnType().contains("DATE")) {
                ruleCode = qcRuleMetadataDao.findRuleCodeByType("type_rule");
            } else if (!metadata.getNullable()) {
                // 非空校验规则
                ruleCode = qcRuleMetadataDao.findRuleCodeByType("nullable");
            } else if (metadata.getDictId() != null && metadata.getDictId() != 0L) {
                // 值域校验规则
                ruleCode = qcRuleMetadataDao.findRuleCodeByType("dict_id");
            }
            if (!ruleCode.isEmpty()) {
                ruleModel = ruleDao.getByCode(ruleCode);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ruleModel;
    }
    /**
     * 收集数据元需要绑定的质控规则
     *
     * @param qcRuleList 质控规则容器
     * @param metadata   数据元
     */
    private void collectQcRule(List<RuleModel> qcRuleList, StdMetaDataModel metadata) {
        String ruleCode = "";
        try {
            // 时间格式检验
            if (metadata.getFormat().contains("DT") || metadata.getColumnType().contains("DATE")) {
                ruleCode = qcRuleMetadataDao.findRuleCodeByType("type_rule");
                qcRuleList.add(ruleDao.getByCode(ruleCode));
            }
            // 非空校验规则
            if (!metadata.getNullable()) {
                ruleCode = qcRuleMetadataDao.findRuleCodeByType("nullable");
                qcRuleList.add(ruleDao.getByCode(ruleCode));
            }
            // 值域校验规则
            if (metadata.getDictId() != null && metadata.getDictId() != 0L) {
                ruleCode = qcRuleMetadataDao.findRuleCodeByType("dict_id");
                qcRuleList.add(ruleDao.getByCode(ruleCode));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public List<RuleModel> getBindQcRule(String stdVersion,String stdDataSetCode,String dataElement) throws IOException {
        String qcRuleMethod = getQcRule(stdVersion, stdDataSetCode, dataElement);
        return ruleDao.getByRuleMethod(qcRuleMethod);
    }
    /* ******************************************   反射方式绑定质控规则 *************************************** */
    public List<RuleModel> getBindQcRule(String stdVersion,Integer stdDataSetId,String dataElement) throws IOException {
        StdDataSetModel stdDataSetModel = stdDatasetService.get(new StandardVersion(stdVersion), stdDataSetId);
        if (stdDataSetModel != null) {
            String qcRuleMethod = getQcRule(stdVersion, stdDataSetModel.getCode(), dataElement);
            return ruleDao.getByRuleMethod(qcRuleMethod);
        } else {
            throw new RuntimeException("绑定规则的数据集不存在，dataSetId：" + stdDataSetId);
        }
    }
    public void bindQcRule(String version, String dataSetCode, String metadataInnerCode, String ruleList) throws IOException {
        List<RuleModel> rules = objectMapper.readValue(ruleList,
                new TypeReference<List<RuleModel>>() {
                });
        bindQcRule(version, dataSetCode, metadataInnerCode, rules);
    }
    //绑定数据元质控规则方法
    public void bindQcRule(String version, String dataSetCode, String metadataInnerCode, List<RuleModel> ruleList) {
        String ruleMethod = null;
        if (ruleList !=null && ruleList.size()>0) {
            ruleMethod = ruleList.get(0).getRuleMethod();
        }
        if (ruleMethod == null) {
            return;
        }
        qcMetaDataKeySchema.setQcMetaDataList(version, dataSetCode, metadataInnerCode, ruleMethod);
    }
    /**
     * 绑定数据元质控规则方法  (反射）
     *
     * @param version           标准版本号
     * @param dataSetId         标准数据集ID
     * @param metadataInnerCode 标准数据元编码
     * @param ruleList          质控规则列表
     */
    public void bindQcRule(String version, Long dataSetId, String metadataInnerCode, String ruleList) throws IOException {
        List<RuleModel> rules = objectMapper.readValue(ruleList,
                new TypeReference<List<RuleModel>>() {
                });
        String ruleMethod = null;
        if (rules !=null && rules.size()>0) {
            ruleMethod = rules.get(0).getRuleMethod();
        }
        if (ruleMethod == null) {
            return;
        }
        StdDataSetModel stdDataSetModel = stdDatasetService.get(new StandardVersion(version), dataSetId.intValue());
        if (stdDataSetModel != null) {
            qcMetaDataKeySchema.setQcMetaDataList(version, stdDataSetModel.getCode(), metadataInnerCode, ruleMethod);
        } else {
            throw new RuntimeException("绑定规则的数据集不存在，dataSetId：" + dataSetId);
        }
    }
    /**
     * 绑定数据元质控规则方法  (反射）
     *
     * @param version           标准版本号
     * @param metadataInnerCode 标准数据元编码
     * @param ruleList          质控规则列表
     */
    public void bindQcRuleBatch(String version, String metadataInnerCode, String ruleList) throws IOException {
        List<RuleModel> rules = objectMapper.readValue(ruleList,
                new TypeReference<List<RuleModel>>() {
                });
        String ruleMethod = null;
        if (rules !=null && rules.size()>0) {
            ruleMethod = rules.get(0).getRuleMethod();
        }
        if (ruleMethod == null) {
            return;
        }
        //通过数据元内部编码获取所在的数据集,然后循环绑定值
        List<StdMetaDataModel> list = stdMetadataService.searchPage(StdMetaDataModel.class, StandardVersion.MetaDataTable,version, "innerCode="+metadataInnerCode, null, null, null,true);
        if(CollectionUtils.isNotEmpty(list)){
            for(StdMetaDataModel model:list){
                Long dataSetId = model.getDataSetId();
                StdDataSetModel stdDataSetModel = stdDatasetService.get(new StandardVersion(version), dataSetId.intValue());
                if (stdDataSetModel != null) {
                    qcMetaDataKeySchema.setQcMetaDataList(version, stdDataSetModel.getCode(), metadataInnerCode, ruleMethod);
                } else {
                    throw new RuntimeException("绑定规则的数据集不存在，dataSetId：" + dataSetId);
                }
            }
        }
    }
    /**
     * 根据数据集，绑定其所有数据元的质控规则
     *
     * @param stdVersion 标准版本号
     * @param dataSetId  数据集ID
     */
    public void bindQcRuleByDataSet(String stdVersion, Long dataSetId) {
        try {
            Map<String, Serializable> map = null;
            StdDataSetModel stdDataSetModel = stdDatasetService.get(new StandardVersion(stdVersion), dataSetId.intValue());
            List<StdMetaDataModel> metadataList = stdMetadataService.searchPageData(StdMetaDataModel.class, StandardVersion.MetaDataTable, stdVersion, "dataSetId=" + dataSetId, null, null, null);
            RuleModel ruleModel = null;
            if (stdDataSetModel == null) {
                throw new RuntimeException("获取数据集失败version: " + stdVersion + " ,datasetId : " + dataSetId);
            }
            map = new HashMap<>();
            for (StdMetaDataModel metadata : metadataList) {
                // 遍历标准版本的数据元集合
                if (metadata != null) {
                    ruleModel = this.collectQcRule(metadata);
                    if (ruleModel !=null) {
                        String key = qcMetaDataKeySchema.getKey(stdVersion, stdDataSetModel.getCode(), metadata.getInnerCode());
                        map.put(key, ruleModel.getRuleMethod());
                    }
                } else {
                    continue;
                }
            }
            qcMetaDataKeySchema.multiSetQcMetaData(map);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 根据标准版本，绑定其所有数据元的质控规则存储到redis
     *
     * @param stdVersion 标准版本
     */
    public void bindQcRuleByVersion(String stdVersion) {
        try {
            // 标准的版本信息
            STDVersion stdVersionInfo = stdVersionService.getVersion(stdVersion);
            List<StdDataSetModel> dataSetModelList = stdDatasetService.searchPageData(StdDataSetModel.class, StandardVersion.DataSetTable, stdVersion, null, null, null, null);
            for (StdDataSetModel dataSetModel : dataSetModelList) {
                List<StdMetaDataModel> metadataList = stdMetadataService.getMetadataList(StdMetaDataModel.class, stdVersion, dataSetModel.getId(), null, null, null, null);
                // 遍历标准版本的数据元集合
                List<RuleModel> qcRuleList = new ArrayList<>();
                for (StdMetaDataModel metadata : metadataList) {
                    qcRuleList.clear();
                    this.collectQcRule(qcRuleList, metadata);
                    this.bindQcRule(stdVersion, dataSetModel.getCode(), metadata.getInnerCode(), qcRuleList);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 根据标准版本，绑定其所有数据元的质控规则
     *
     * @param stdVersion 标准版本
     */
    public void batchBindRuleByStdVersion(String stdVersion) {
        try {
            Map<String, Serializable> map = null;
            // 标准的版本信息
//            STDVersion stdVersionInfo = stdVersionService.getVersion(stdVersion);
            List<StdDataSetModel> dataSetModelList = stdDatasetService.searchPageData(StdDataSetModel.class, StandardVersion.DataSetTable, stdVersion, null, null, null, null);
            for (StdDataSetModel dataSetModel : dataSetModelList) {
                List<StdMetaDataModel> metadataList = stdMetadataService.getMetadataList(StdMetaDataModel.class, stdVersion, dataSetModel.getId(), null, null, null, null);
                // 遍历标准版本的数据元集合
                RuleModel ruleModel;
                map = new HashMap<>();
                for (StdMetaDataModel metadata : metadataList) {
                    if (metadata != null) {
                        ruleModel = this.collectQcRule(metadata);
                        //有规则，添加到redis缓存
                        if (ruleModel!=null) {
                            String key = qcMetaDataKeySchema.getKey(stdVersion, dataSetModel.getCode(), metadata.getInnerCode());
                            map.put(key, ruleModel.getRuleMethod());
                        }
                    } else {
                        continue;
                    }
                }
                //保存到redis
                if (map !=null && !map.isEmpty()) {
                    qcMetaDataKeySchema.multiSetQcMetaData(map);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 根据标准版本，删除其所有数据元的质控规则
     *
     * @param stdVersion 标准版本
     */
    public void delQcRuleByStdVersion(String stdVersion) {
        try {
            // 标准的版本信息
            List<StdDataSetModel> dataSetModelList = stdDatasetService.searchPageData(StdDataSetModel.class, StandardVersion.DataSetTable, stdVersion, null, null, null, null);
            for (StdDataSetModel dataSetModel : dataSetModelList) {
                List<StdMetaDataModel> metadataList = stdMetadataService.getMetadataList(StdMetaDataModel.class, stdVersion, dataSetModel.getId(), null, null, null, null);
                // 遍历标准版本的数据元集合
                for (StdMetaDataModel metadata : metadataList) {
                    qcMetaDataKeySchema.deleteQcMetaData(stdVersion, dataSetModel.getCode(), metadata.getInnerCode());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 根据标准版本，删除其所有数据元的质控规则
     *
     * @param stdVersion 标准版本
     */
    public void deleteQcMetaData(String stdVersion) {
        try {
            // 根据版本号模糊删除
            qcMetaDataKeySchema.deleteQcMetaData(stdVersion);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 获取 数据元绑定质控规则方法（反射）
     *
     * @param version
     * @param dataSetCode
     * @param metadataInnerCode
     * @return
     * @throws IOException
     */
    public String getQcRule(String version, String dataSetCode, String metadataInnerCode) throws IOException {
        return qcMetaDataKeySchema.getQcMetaData(version, dataSetCode, metadataInnerCode);
    }
    /**
     * 模糊获取数据集下的有绑定规则的数据元
     */
    public List<String> getMetaDataByDataSet(String stdVersion, String stdDataSet) {
        return qcMetaDataKeySchema.getMetaDataByDataSet(stdVersion, stdDataSet);
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/redis/StdRedisService.java

@@ -0,0 +1,194 @@
package com.yihu.jw.basic.standard.service.redis;
import com.yihu.jw.basic.standard.task.StdRedisTask;
import com.yihu.jw.redis.schema.StdCdaVersionKeySchema;
import com.yihu.jw.redis.schema.StdDataSetKeySchema;
import com.yihu.jw.redis.schema.StdMetaDataKeySchema;
import com.yihu.jw.util.thread.ContextAttributes;
import com.yihu.jw.util.thread.LocalContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Future;
/**
 * Redis管理
 * @author hzp add at 20170425
 */
@Service
public class StdRedisService {
    @Autowired
    private StdCdaVersionKeySchema stdVersionKeySchema;
    @Autowired
    private StdDataSetKeySchema stdDataSetKeySchema;
    @Autowired
    private StdMetaDataKeySchema stdMetaDataKeySchema;
    @Resource(name = "jdbcTemplate")
    private JdbcTemplate jdbc;
    @Autowired
    private StdRedisTask stdRedisTask;
    /**
     *获取标准版本 redis
     */
    public String getStdVersion(String key)
    {
        return stdVersionKeySchema.get(key);
    }
    /**
     *获取标准数据集代码 redis
     */
    public String getDataSetCode(String version, String id){
        return stdDataSetKeySchema.dataSetCode(version, id);
    }
    /**
     *获取标准数据集名称 redis
     */
    public String getDataSetName(String version, String id){
        return stdDataSetKeySchema.dataSetName(version, id);
    }
    /**
     *获取标准数据集名称 redis
     */
    public String getDataSetNameByCode(String version, String code){
        return stdDataSetKeySchema.dataSetNameByCode(version, code);
    }
    /**
     *获取标准数据集--主从表 redis
     */
    public Boolean getDataSetMultiRecord(String version, String code){
        return stdDataSetKeySchema.dataSetMultiRecord(version, code);
    }
    /**
     * 获取标准数据元对应类型 redis
     */
    public String getMetaDataType(String version, String dataSetCode, String innerCode) {
        return stdMetaDataKeySchema.metaDataType(version, dataSetCode , innerCode);
    }
    /**
     * 获取标准数据元名称 redis
     */
    public String getMetadataName(String version, String datasetCode, String metadataCode) {
        return stdMetaDataKeySchema.metaName(version, datasetCode , metadataCode);
    }
    /**
     * 获取标准数据元是否为空 redis
     */
    public boolean isMetaDataNullable(String version, String datasetCode, String metadataCode) {
        return stdMetaDataKeySchema.metaDataNullable(version, datasetCode , metadataCode);
    }
    /**
     * 获取标准数据元格式 redis
     */
    public String getMetadataFormat(String version, String datasetCode, String metadataCode) {
        return stdMetaDataKeySchema.metaDataFormat(version, datasetCode , metadataCode);
    }
    /**
     * 获取标准数据元对应字典 redis
     */
    public String getMetaDataDict(String version, String dataSetCode, String innerCode) {
        return stdMetaDataKeySchema.metaDataDict(version, dataSetCode,innerCode);
    }
    /**
     * 获取标准数据字典对应值 redis
     */
    public String getDictEntryValue(String version, String dictId, String entryCode) {
        return stdMetaDataKeySchema.dictEntryValue(version, dictId , entryCode);
    }
    /**
     * 缓存版本
     * @param versions
     * @param force
     * @return
     */
    @Async
    public Future<Boolean> cacheVersions(String versions, boolean force,String schema) {
        String versionQuery = "SELECT version_name FROM std_version WHERE version = 'std.version.column'" ;
        String dataSetQuery = "SELECT id, code, name, multi_record FROM data.set.table";
        String metaDataQuery = "SELECT a.code AS data_set_code, b.inner_code, b.type, b.dict_id,b.name FROM data.set.table a, " +
                "meta.data.table b WHERE a.id = b.dataset_id";
        String dictEntryQuery = "SELECT t.dict_id, t.code, t.value FROM dict.entry.table t";
        LocalContext.getContext().setAttachment(ContextAttributes.SCHEMA,schema);
        for (String version : versions.split(",")) {
            if(force) {
                stdVersionKeySchema.delete(version);
                stdMetaDataKeySchema.deleteMetaDataDict(version, "*", "*");
                stdMetaDataKeySchema.deleteMetaDataType(version, "*", "*");
                stdMetaDataKeySchema.deleteDictEntryValue(version, "*", "*");
            }
            String dataSetTable = "std_dataset_" + version;
            String metaDataTable = "std_metadata_" + version;
            String dictEntryTable = "std_dictionary_entry_" + version;
            //数据集
            List<Map<String,Object>> dataSetList = jdbc.queryForList(dataSetQuery.replace("data.set.table", dataSetTable));
            Future<Boolean> cacheDataset = stdRedisTask.cacheDataset(version, dataSetList,schema);
            //数据元
            List<Map<String,Object>> metaDataList = jdbc.queryForList(metaDataQuery.replace("data.set.table", dataSetTable).replace("meta.data.table", metaDataTable));
            Future<Boolean> cacheMetadata = stdRedisTask.cacheMetadata(version, metaDataList,force,schema);
            //字典项
            List<Map<String,Object>> dictEntryList = jdbc.queryForList(dictEntryQuery.replace("dict.entry.table", dictEntryTable));
            Future<Boolean> cacheDict = stdRedisTask.cacheDict(version, dictEntryList);
            //该版本数据全部缓存好在进行下个版本的缓存
            for(;;){
                if(cacheDataset.isDone() && cacheMetadata.isDone() && cacheDict.isDone()){
                    break;
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //版本名
            Map<String, Object> versionMap = jdbc.queryForMap(versionQuery.replace("std.version.column", version));
            String versionName = (String) versionMap.get("version_name");
            stdVersionKeySchema.set(version, versionName);
        }
        return new AsyncResult<Boolean>(true);
    }
    public String getMetadataCodes(String version, String datasetCode) {
        return stdDataSetKeySchema.metadataCodes(version, datasetCode);
    }
    /**
     * 判断值域编码是否存在
     *
     * @param version
     * @param dictId
     * @param entryCode
     * @return
     */
    public Boolean isDictCodeExist(String version, String dictId, String entryCode) {
        return stdMetaDataKeySchema.isDictCodeExist(version, dictId, entryCode);
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/standard/STDVersionService.java

@@ -0,0 +1,288 @@
package com.yihu.jw.basic.standard.service.standard;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.basic.standard.model.standard.STDVersion;
import com.yihu.jw.basic.util.CDAVersionUtil;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Restrictions;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import java.text.ParseException;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
 * 版本管理实现类。
 * @author lincl
 * @version 1.0
 * @created 2016.2.3
 */
@Service
public class STDVersionService extends SQLGeneralDAO {
    public static final String FBVersion = "000000000000";
//    @Autowired
//    StdSessionFactoryBean sessionFactory;
    /**
     * 创建一个阶段性版本. 参数中的版本不能处于编辑状态.
     *
     * @param baseVersion
     * @param author
     */
    @Transactional(propagation = Propagation.REQUIRED)
    public STDVersion createStageVersion(STDVersion baseVersion, String author) throws Exception {
        if (author == null || author.length() == 0) throw new IllegalArgumentException("作者不能为空");
        STDVersion stagedVersion = null;
        if (baseVersion == null) {
            if (getVersionList().length != 0) {
                throw new IllegalArgumentException("基础版本不能为空");
            } else {
                // 空库的情况下，使用 XCDAVersionManager.FBVersion 作为初始版本
                stagedVersion = new STDVersion(null, author, "0.1");
                stagedVersion.setVersionName("0.1");
                stagedVersion.setVersion(STDVersionService.FBVersion);
            }
        } else {
            stagedVersion = new STDVersion(baseVersion.getVersion(), author, baseVersion.getVersionName());
        }
        buildVersionTables(stagedVersion);
        saveEntity(stagedVersion);
//        createVersionedClass(stagedVersion);
        return stagedVersion;
    }
//    private void createVersionedClass(STDVersion stagedVersion) throws Exception {
//        String version = stagedVersion.getVersion();
//        List<Class> tableClass = new ArrayList<>();
//        for (String vesionedEntity : BeanConfig.vesionedEntitys.keySet()){
//            tableClass.add(
//                    ClassPoolUtils.tableMapping(
//                            vesionedEntity,
//                            BeanConfig.vesionedEntitys.get(vesionedEntity) + version,
//                            vesionedEntity + version));
//        }
//        sessionFactory.addClassToBuildSessionFactory(tableClass.toArray(new Class[tableClass.size()]));
//    }
    /**
     * 根据版本号获取版本信息
     *
     * @param version
     * @return
     */
    public STDVersion getVersion(String version) throws ParseException {
        Query query = getCurrentSession().createQuery("from STDVersion where version='"+version+"'");
        List<STDVersion> list = query.list();
        if(list!=null && list.size()>0){
            return list.get(0);
        }
        return null;
    }
    /**
     * 获取最新的已发布版本
     *
     * @return
     */
    public STDVersion getLatestVersion() {
        Session session = currentSession();
        Query query = session.createQuery("from STDVersion a where a.inStage = false order by a.version desc");
        query.setFirstResult(0);
        query.setMaxResults(1);
        List<STDVersion> versions = query.list();
        STDVersion cdaVersion = versions.size() > 0 ? versions.get(0) : null;
        return cdaVersion;
    }
    /**
     * 获取所有版本
     *
     * @return
     */
    public STDVersion[] getVersionList() {
        Session session = currentSession();
        Query query = session.createQuery("from STDVersion order by commitTime");
        List<STDVersion> versionList = query.list();
        return versionList.toArray(new STDVersion[versionList.size()]);
    }
    /**
     * 发布版本
     *
     * @param version
     */
    @Transactional(propagation = Propagation.REQUIRED)
    public void commitVersion(STDVersion version) throws Exception {
        version.setInStage(false);
        version.setCommitTime(new Date());
        saveEntity(version);
    }
    @Transactional(propagation = Propagation.REQUIRED)
    public void revertVersion(STDVersion version) throws Exception {
        dropVersionTables(version);
        deleteEntity(version);
    }
    @Transactional(propagation = Propagation.REQUIRED)
    public void dropVersion(STDVersion version) throws Exception {
        Session session = currentSession();
        Query query = session.createQuery("from STDVersion where baseVersion = :version");
        query.setString("version", version.getVersion());
        STDVersion subVersion = (STDVersion) query.uniqueResult();
        if (subVersion != null) {
            subVersion.setBaseVersion(version.getBaseVersion());
            session.save(subVersion);
        }
        dropVersionTables(version);
        deleteEntity(version);
    }
    /**
     * 回滚到编辑状态
     *
     * @param version
     */
    @Transactional(propagation = Propagation.REQUIRED)
    public void rollbackToStage(STDVersion version) throws Exception {
        // 已经是编辑状态，直接返回
        if (version.isInStage()) {
            return;
        }
        // 非最新版本，无法回滚
        STDVersion latestVersion = getLatestVersion();
        if (latestVersion != null && !latestVersion.getVersion().equals(version.getVersion())) {
            throw new IllegalArgumentException("非最新版本,无法回滚");
        }
        // 回滚
        version.setInStage(true);
        version.setCommitTime(new Date());
        saveEntity(version);
    }
    @Transactional(propagation = Propagation.REQUIRED)
    public void dropVersionTables(STDVersion stdVersionVersion) {
        String version = stdVersionVersion.getVersion();
        String datasetTable = CDAVersionUtil.getDataSetTableName(version);
        String metadataTable = CDAVersionUtil.getMetaDataTableName(version);
        String dictTable = CDAVersionUtil.getDictTableName(version);
        String dictEntryTable = CDAVersionUtil.getDictEntryTableName(version);
        String cdaDocumentTable = CDAVersionUtil.getCDATableName(version);
        String relationshipTable = CDAVersionUtil.getCDADatasetRelationshipTableName(version);
        Session session = currentSession();
        String[] toDropTables = {datasetTable, metadataTable, dictTable, dictEntryTable, cdaDocumentTable, relationshipTable};
        for (String table : toDropTables) {
            Query query = session.createSQLQuery("DROP TABLE IF EXISTS " + table);
            query.executeUpdate();
        }
    }
    @Transactional(propagation = Propagation.REQUIRED)
    public void buildVersionTables(STDVersion cdaVersion) {
        //为空表示这是一个初始版本，不需要再创建表
        if (cdaVersion.getBaseVersion() == null) return;
        String version = cdaVersion.getVersion();
        String[] newTables = {CDAVersionUtil.getDataSetTableName(version),
                CDAVersionUtil.getMetaDataTableName(version),
                CDAVersionUtil.getDictTableName(version),
                CDAVersionUtil.getDictEntryTableName(version),
                CDAVersionUtil.getCDATableName(version),
                CDAVersionUtil.getCDADatasetRelationshipTableName(version)};
        version = cdaVersion.getBaseVersion();
        String[] baseTables = {CDAVersionUtil.getDataSetTableName(version),
                CDAVersionUtil.getMetaDataTableName(version),
                CDAVersionUtil.getDictTableName(version),
                CDAVersionUtil.getDictEntryTableName(version),
                CDAVersionUtil.getCDATableName(version),
                CDAVersionUtil.getCDADatasetRelationshipTableName(version)};
        Session session = currentSession();
        for (int i = 0; i < baseTables.length; ++i) {
            String baseTable = baseTables[i];
            String newTable = newTables[i];
            Query query = session.createSQLQuery("CREATE TABLE " + newTable + " like " + baseTable);
            query.executeUpdate();
            query = session.createSQLQuery("INSERT INTO " + newTable + " SELECT * FROM " + baseTable);
            query.executeUpdate();
        }
    }
    //1多条件查询
    public List<STDVersion> searchVersions(Map<String, Object> args) {
        Session session = currentSession();
        String version = (String) args.get("version");
        String versionName = (String) args.get("versionName");
        Integer page = (Integer) args.get("page");
        Integer pageSize = (Integer) args.get("rows");
        String hql = "from STDVersion where (version like :version or versionName like :versionName) order by commitTime";
        Query query = session.createQuery(hql);
        query.setString("version", "%" + version + "%");
        query.setString("versionName", "%" + versionName + "%");
        if (page != 0) {
            query.setMaxResults(pageSize);
            query.setFirstResult((page - 1) * pageSize);
        }
        return query.list();
    }
    //2查询符合条件记录数
    public Integer searchVersionInt(Map<String, Object> args) {
        Session session = currentSession();
        String version = (String) args.get("version");
        String versionName = (String) args.get("versionName");
        String hql = "SELECT count(*) FROM STDVersion WHERE (version like :version or versionName like :versionName)";
        Query query = session.createQuery(hql);
        query.setString("version", "%" + version + "%");
        query.setString("versionName", "%" + versionName + "%");
        return Integer.parseInt(query.list().get(0).toString());
    }
    /**
     * 根据标准ID，获取标准版本集合
     * @param standardId 标准ID
     * @return 标准版本集合
     */
    public List<STDVersion> findVersionsByStdId(Long standardId) {
        Criteria criteria = currentSession().createCriteria(STDVersion.class);
        criteria.add(Restrictions.eq("standardId", standardId));
        return criteria.list();
    }
    public Integer checkVersionName(String versionName) {
        Session session = currentSession();
        String hql = "SELECT count(*) FROM STDVersion WHERE versionName =:versionName";
        Query query = session.createQuery(hql);
        query.setString("versionName", versionName);
        return Integer.parseInt(query.list().get(0).toString());
    }
    public Integer searchInStage() {
        Session session = currentSession();
        Query query = session.createQuery("SELECT count(*) FROM STDVersion WHERE inStage = true");
        return Integer.parseInt(query.list().get(0).toString());
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/standard/StandardService.java

@@ -44,7 +44,7 @@ public class StandardService extends SQLGeneralDAO {
            List<StandardModel> standardModelList = getList(null, order, limit, offset);
            for (StandardModel standardModel : standardModelList) {
                DictItem items = new DictItem();
                Integer id = standardModel.getId();
                Long id = standardModel.getId();
                items.setCode(id.toString());
                items.setValue(standardModel.getName());
                detailModelList.add(items);
@@ -139,7 +139,7 @@ public class StandardService extends SQLGeneralDAO {
        }
    }
    public Boolean standardNameValidate(Integer standardId, String name) {
    public Boolean standardNameValidate(Long standardId, String name) {
        String sql = "FROM StandardModel WHERE name = :name and id != :standardId";
        Query query = getCurrentSession().createQuery(sql);
        query.setParameter("standardId", standardId);
@@ -151,7 +151,7 @@ public class StandardService extends SQLGeneralDAO {
        return false;
    }
    public Boolean standardCodeValidate(Integer standardId, String code) {
    public Boolean standardCodeValidate(Long standardId, String code) {
        String sql = "FROM StandardModel WHERE code = :code and id != :standardId";
        Query query = getCurrentSession().createQuery(sql);
        query.setParameter("standardId", standardId);
@@ -281,13 +281,13 @@ public class StandardService extends SQLGeneralDAO {
            resultDetailModel.setPid(pid);
            resultDetailModel.setPublisher(versionModel.getPublishUser());
            resultDetailModel.setStatus(versionModel.getPublishStatus());
            resultDetailModel.setName(versionModel.getName());
            resultDetailModel.setName(versionModel.getVersionName());
            resultDetailModel.setCode(versionModel.getVersion());
            resultDetailModel.setDate(StringUtil.toString(versionModel.getPublishTime()));
            resultDetailModel.setType(2);
            if (resultDetailModelCheckMap.containsKey(pid)) {
                resultDetailModelList.add(resultDetailModel);
            } else if (StringUtil.isEmpty(name) || versionModel.getName().contains(name)) {
            } else if (StringUtil.isEmpty(name) || versionModel.getVersionName().contains(name)) {
                resultDetailModelList.add(resultDetailModel);
                if (!resultDetailModelAddMap.containsKey(pid)) {
                    resultDetailModelAddMap.put(resultDetailModel.getPid(), resultDetailModelMap.get(resultDetailModel.getPid()));
@@ -350,7 +350,7 @@ public class StandardService extends SQLGeneralDAO {
        List<StandardModel> standardModelList = criteria.list();
        Map<String, String> codeToIdMap = new HashMap<>();
        List<Integer> idList = new ArrayList<>();
        List<Long> idList = new ArrayList<>();
        for (StandardModel standardModel : standardModelList) {
            idList.add(standardModel.getId());
        }
@@ -392,7 +392,7 @@ public class StandardService extends SQLGeneralDAO {
        throw new ApiException(ErrorCode.StandardForkFailed.getErrorCode());
    }
    public boolean existStandardVersionValid(Integer standardId) {
    public boolean existStandardVersionValid(Long standardId) {
        String hql = "FROM StandardVersionModel WHERE standardId = :standardId";
        Query query = getCurrentSession().createQuery(hql);
        query.setParameter("standardId", standardId);
@@ -432,8 +432,12 @@ public class StandardService extends SQLGeneralDAO {
        }
        if (limit != null) {
            criteria.setMaxResults(limit);
            if (offset != null) {
                criteria.setFirstResult((offset - 1) * limit);
            if (offset != null &&offset>0) {
                int tmp = 0;
                if((offset - 1) * limit>0){
                    tmp = (offset - 1) * limit;
                }
                criteria.setFirstResult(tmp);
            }
        }
        if (order != null) {

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/standard/StandardVersionService.java

@@ -35,6 +35,7 @@ import java.util.*;
/**
 * @created Airhead 2015/12/25.
 */
@Transactional
@Service("StandardVersionService")
public class StandardVersionService extends SQLGeneralDAO {
@@ -62,7 +63,7 @@ public class StandardVersionService extends SQLGeneralDAO {
            for(StandardVersionModel standardVersionModel : standardVersionModelList){
                DictItem items = new DictItem();
                String id = standardVersionModel.getVersion();
                String name = standardVersionModel.getName();
                String name = standardVersionModel.getVersionName();
                items.setCode(id.toString());
                items.setValue(name);
                detailModelList.add(items);
@@ -85,7 +86,7 @@ public class StandardVersionService extends SQLGeneralDAO {
            for (StandardVersionModel standardVersionModel : standardVersionModelList) {
                DictItem items = new DictItem();
                String  id = standardVersionModel.getVersion();
                String name = standardVersionModel.getName();
                String name = standardVersionModel.getVersionName();
                items.setCode(id.toString());
                items.setValue(name);
                detailModelList.add(items);
@@ -114,7 +115,7 @@ public class StandardVersionService extends SQLGeneralDAO {
        Boolean existFlg = false;
        try {
            StandardVersionModel versionModel = objectMapper.readValue(version, StandardVersionModel.class);
            existFlg = versionNameValidate(versionModel.getStandardId(), versionModel.getName());
            existFlg = versionNameValidate(versionModel.getStandardId(), versionModel.getVersionName());
            if (!existFlg) {
                this.add(versionModel);
                return ObjEnvelop.getSuccess("保存标准版本成功",versionModel);
@@ -132,7 +133,7 @@ public class StandardVersionService extends SQLGeneralDAO {
    public Boolean versionNameValidate(Integer standardId, String versionName) {
            Map<String, Object> query = new HashMap<>();
            Map<String, String> order = new HashMap<>();
            query.put("name", versionName);
            query.put("versionName", versionName);
            List<StandardVersionModel> list = getList(standardId, query, order, 1, 0);
            if (!CollectionUtils.isEmpty(list)) {
                return true;
@@ -141,10 +142,10 @@ public class StandardVersionService extends SQLGeneralDAO {
    }
    public Boolean versionNameValidate(Integer standardId, Integer versionId, String versionName) throws Exception {
        String sql = "FROM StandardVersionModel WHERE name = :name and standardId = :standardId and id != :versionId";
        String sql = "FROM StandardVersionModel WHERE versionName = :versionName and standardId = :standardId and id != :versionId";
        Query query = getCurrentSession().createQuery(sql);
        query.setParameter("standardId", standardId);
        query.setParameter("name", versionName);
        query.setParameter("versionName", versionName);
        query.setParameter("versionId", versionId);
        List<StandardVersionModel> list = query.list();
        if (!CollectionUtils.isEmpty(list)) {
@@ -193,7 +194,7 @@ public class StandardVersionService extends SQLGeneralDAO {
        Boolean existFlg = false;
        try {
            StandardVersionModel versionModel = objectMapper.readValue(version, StandardVersionModel.class);
            existFlg = versionNameValidate(versionModel.getStandardId(), versionModel.getId(), versionModel.getName());
            existFlg = versionNameValidate(versionModel.getStandardId(), versionModel.getId(), versionModel.getVersionName());
            if (!existFlg) {
                this.update(versionModel);
                return ObjEnvelop.getSuccess("修改标准版本成功",versionModel);
@@ -269,7 +270,7 @@ public class StandardVersionService extends SQLGeneralDAO {
        StandardVersionModel baseVersionModel = myGet(versionId);
        StandardVersionModel newVersionModel = new StandardVersionModel();
        newVersionModel.setBaseVersion(baseVersionModel.getVersion());
        newVersionModel.setName(baseVersionModel.getName() + " Copy");
        newVersionModel.setVersionName(baseVersionModel.getVersionName() + " Copy");
        newVersionModel.setPrimaryVersion(baseVersionModel.getPrimaryVersion());
        newVersionModel.setPublishTime(new Date());
        this.add(newVersionModel);
@@ -302,7 +303,7 @@ public class StandardVersionService extends SQLGeneralDAO {
        }
    }
    @Transactional
    private void  add(StandardVersionModel standardVersionModel) throws Exception {
        StandardVersion standardVersion = StandardVersion.generateVersion();
        standardVersionModel.setVersion(standardVersion.getVersion());
@@ -327,7 +328,7 @@ public class StandardVersionService extends SQLGeneralDAO {
        }
        if (limit != null) {
            criteria.setMaxResults(limit);
            if (offset != null) {
            if (offset != null &&offset>0) {
                criteria.setFirstResult((offset - 1) * limit);
            }
        }
@@ -411,7 +412,7 @@ public class StandardVersionService extends SQLGeneralDAO {
    }
    @Transactional
    public String saveDatasetExcel(MultipartFile file, String version,Integer standardId) throws Exception {
    public String saveDatasetExcel(MultipartFile file, String version,Long standardId) throws Exception {
        List<List<String[]>> list = ExcelUtilBigData.readerExcel(file.getInputStream(), 13, 0);//String[] 存放一行,List<String[]> 代表一个excel表格
        for (int i = 0; i < list.size(); i++) {
            List<String[]> l = list.get(i);
@@ -424,7 +425,7 @@ public class StandardVersionService extends SQLGeneralDAO {
            stdeDataset.setSummary(getNotNull(l.get(3)[1]));
            stdeDataset.setLanguage(getNotNull(l.get(4)[1]));
            stdeDataset.setClassModel(getNotNull(l.get(5)[1]));
            stdeDataset.setstandardId(standardId);
            stdeDataset.setStandardId(standardId.intValue());
            stdeDataset.setCatalog(0);
//            if(org.apache.commons.lang3.StringUtils.isNotBlank(getNotNull(l.get(2)[1]))){
//                stdeDataset.setCatalog(Integer.valueOf(getNotNull(l.get(2)[1])));
@@ -433,9 +434,9 @@ public class StandardVersionService extends SQLGeneralDAO {
            for (int row = 7; row < l.size(); row++) {
                //保存数据元
                StdMetaDataModel stdeMetadata = new StdMetaDataModel();
                stdeMetadata.setDatasetId(stdeDataset.getId());//肯定要设置
                stdeMetadata.setDataSetId(stdeDataset.getId());//肯定要设置
                stdeMetadata.setStandardId(standardId);
                stdeMetadata.setDeCode(getNotNull(l.get(row)[1]));
                stdeMetadata.setDictCode(getNotNull(l.get(row)[1]));
                stdeMetadata.setCode(getNotNull(l.get(row)[2]));
                stdeMetadata.setName(getNotNull(l.get(row)[3]));
                stdeMetadata.setDefinition(getNotNull(l.get(row)[4]));
@@ -443,18 +444,24 @@ public class StandardVersionService extends SQLGeneralDAO {
                stdeMetadata.setFormat(getNotNull(l.get(row)[6]));
                String dicId = getNotNull(l.get(row)[7]);
                if(org.apache.commons.lang3.StringUtils.isNotBlank(dicId)){
                    stdeMetadata.setDictId(Integer.valueOf(dicId));
                    stdeMetadata.setDictId(Long.valueOf(dicId));
                }
                stdeMetadata.setColumnName(getNotNull(l.get(row)[8]));
                stdeMetadata.setColumnType(getNotNull(l.get(row)[9]));
                stdeMetadata.setColumnLength(getNotNull(l.get(row)[10]));
                stdeMetadata.setPrimaryKey(false);
                String isPrimaryKey = getNotNull(l.get(row)[11]);
                if(org.apache.commons.lang3.StringUtils.isNotBlank(isPrimaryKey)){
                    stdeMetadata.setPrimaryKey(Integer.valueOf(isPrimaryKey));
                    if("1".equals(isPrimaryKey)){
                        stdeMetadata.setPrimaryKey(true);
                    }
                }
                String isNullable = getNotNull(l.get(row)[12]);
                stdeMetadata.setNullable(false);
                if(org.apache.commons.lang3.StringUtils.isNotBlank(isNullable)){
                    stdeMetadata.setNullable(Integer.valueOf(isNullable));
                    if("1".equals(isNullable)){
                        stdeMetadata.setNullable(true);
                    }
                }
                if(org.apache.commons.lang3.StringUtils.isBlank(stdeMetadata.getCode())){
                    continue;
@@ -466,7 +473,7 @@ public class StandardVersionService extends SQLGeneralDAO {
    }
    @Transactional
    public String saveDictExcel(MultipartFile file, String version,Integer standardId) throws Exception {
    public String saveDictExcel(MultipartFile file, String version,Long standardId) throws Exception {
        List<List<String[]>> list = ExcelUtilBigData.readerExcel(file.getInputStream(), 5, 3);
        list.stream().filter(medatas-> getNotNull(medatas.get(0)[1]).contains("ICD-10-CM")).forEach(medata->{

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/standard/StdCDACatalogService.java

@@ -113,7 +113,7 @@ public class StdCDACatalogService extends SQLGeneralDAO {
        }
        if (limit != null) {
            criteria.setMaxResults(limit);
            if (offset != null) {
            if (offset != null &&offset>0) {
                criteria.setFirstResult((offset - 1) * limit);
            }
        }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/standard/StdCDADatasetService.java

@@ -149,9 +149,9 @@ public class StdCDADatasetService extends SQLGeneralDAO {
                "where id = :id";
        Query query = session.createSQLQuery(sql);
        query.setInteger("id", stdCdaDatasetModel.getId());
        query.setInteger("cda_id", stdCdaDatasetModel.getCdaID());
        query.setInteger("dataset_id", stdCdaDatasetModel.getdatasetId());
        query.setLong("id", stdCdaDatasetModel.getId());
        query.setLong("cda_id", stdCdaDatasetModel.getCdaID());
        query.setLong("dataset_id", stdCdaDatasetModel.getdatasetId());
        query.executeUpdate();
    }
@@ -162,15 +162,15 @@ public class StdCDADatasetService extends SQLGeneralDAO {
        String sql = "select max(id) from " + cdaDatasetTableName;
        Query query = session.createSQLQuery(sql);
        Object object = query.uniqueResult();
        stdCdaDatasetModel.setId(object == null ? 1 : Integer.parseInt(object.toString()) + 1);
        stdCdaDatasetModel.setId(object == null ? 1L : Long.parseLong(object.toString()) + 1);
        sql = "insert into " + cdaDatasetTableName + "(id, cda_id, dataset_id)"
                + "VALUES (:id, :cda_id, :dataset_id)";
        query = session.createSQLQuery(sql);
        query.setInteger("id", stdCdaDatasetModel.getId());
        query.setInteger("cda_id", stdCdaDatasetModel.getCdaID());
        query.setInteger("dataset_id", stdCdaDatasetModel.getdatasetId());
        query.setLong("id", stdCdaDatasetModel.getId());
        query.setLong("cda_id", stdCdaDatasetModel.getCdaID());
        query.setLong("dataset_id", stdCdaDatasetModel.getdatasetId());
        query.executeUpdate();
    }
@@ -188,7 +188,7 @@ public class StdCDADatasetService extends SQLGeneralDAO {
        Query sessionQuery = getQuery(sqlCreator, sql);
        if (limit != null) {
            sessionQuery.setMaxResults(limit);
            if (offset != null) {
            if (offset != null &&offset>0) {
                sessionQuery.setFirstResult((offset - 1) * limit);
            }
        }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/standard/StdCDAService.java

@@ -140,7 +140,7 @@ public class StdCDAService extends SQLGeneralDAO {
        String sql = "select max(id) from " + cdaTableName;
        Query query = session.createSQLQuery(sql);
        Object object = query.uniqueResult();
        stdCdaModel.setId(object == null ? 1 : Integer.parseInt(object.toString()) + 1);
        stdCdaModel.setId(object == null ? 1L : Long.parseLong(object.toString()) + 1);
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(stdCdaModel));
        SqlCreator sqlCreator = new SqlCreator(StdCDAModel.class);
@@ -162,7 +162,7 @@ public class StdCDAService extends SQLGeneralDAO {
        Query sessionQuery = getQuery(sqlCreator, sql);
        if (limit != null) {
            sessionQuery.setMaxResults(limit);
            if (offset != null) {
            if (offset != null &&offset>0) {
                sessionQuery.setFirstResult((offset - 1) * limit);
            }
        }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/standard/StdDatasetCatalogService.java

@@ -113,7 +113,7 @@ public class StdDatasetCatalogService extends SQLGeneralDAO {
        String sql = "select max(id) from " + StdDatasetCatalogModel.TABLE_NAME;
        Query query = session.createSQLQuery(sql);
        Object object = query.uniqueResult();
        stdDatasetCatalogModel.setId(object == null ? 1 : Integer.parseInt(object.toString()) + 1);
        stdDatasetCatalogModel.setId(object == null ? 1L : Long.parseLong(object.toString()) + 1);
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(stdDatasetCatalogModel));
        SqlCreator sqlCreator = new SqlCreator(StdDatasetCatalogModel.class);
@@ -135,7 +135,7 @@ public class StdDatasetCatalogService extends SQLGeneralDAO {
        Query sessionQuery = getQuery(sqlCreator, sql);
        if (limit != null) {
            sessionQuery.setMaxResults(limit);
            if (offset != null) {
            if (offset != null &&offset>0) {
                sessionQuery.setFirstResult((offset - 1) * limit);
            }
        }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/standard/StdDatasetService.java

@@ -116,7 +116,7 @@ public class StdDatasetService extends SQLGeneralDAO {
        }
    }
    public Boolean datasetCodeValidate(StandardVersion standardVersion, Integer datasetId,  String code) {
    public Boolean datasetCodeValidate(StandardVersion standardVersion, Long datasetId,  String code) {
        SqlCreator sqlCreator = new SqlCreator(StdDataSetModel.class);
        sqlCreator.equalCondition("code", code);
        sqlCreator.neCondition("id", datasetId);
@@ -152,6 +152,7 @@ public class StdDatasetService extends SQLGeneralDAO {
        }
    }
    public ObjEnvelop get(String stdVersion, Integer datasetId) {
        if (StringUtil.isEmpty(stdVersion)) {
            return ObjEnvelop.getError("并无该数据集信息");
@@ -170,7 +171,17 @@ public class StdDatasetService extends SQLGeneralDAO {
        return ObjEnvelop.getError("获取标准数据集失败");
    }
    private StdDataSetModel get(StandardVersion standardVersion, Integer datasetId) {
//    public StdDataSetModel get(StandardVersion standardVersion, Long datasetId) {
//        String dataSetTable = standardVersion.getDataSetTableName();
//        SqlCreator sqlCreator = new SqlCreator(StdDataSetModel.class);
//        sqlCreator.equalCondition("id", datasetId);
//        String sql = sqlCreator.selectData(dataSetTable);
//        Query query = getQuery(sqlCreator, sql);
//        return (StdDataSetModel) query.uniqueResult();
//    }
    public StdDataSetModel get(StandardVersion standardVersion, Integer datasetId) {
        String dataSetTable = standardVersion.getDataSetTableName();
        SqlCreator sqlCreator = new SqlCreator(StdDataSetModel.class);
        sqlCreator.equalCondition("id", datasetId);
@@ -223,8 +234,12 @@ public class StdDatasetService extends SQLGeneralDAO {
        Query sessionQuery = getQuery(sqlCreator, sql);
        if (limit != null) {
            sessionQuery.setMaxResults(limit);
            if (offset != null) {
                sessionQuery.setFirstResult((offset - 1) * limit);
            if (offset != null &&offset>0) {
                int tmp = 0;
                if((offset - 1) * limit>0){
                    tmp = (offset - 1) * limit;
                }
                sessionQuery.setFirstResult(tmp);
            }
        }
        return (List<StdDataSetModel>) sessionQuery.list();
@@ -280,7 +295,7 @@ public class StdDatasetService extends SQLGeneralDAO {
        Query query = getQuery(sqlCreator, sql);
        if (limit != null) {
            query.setMaxResults(limit);
            if (offset != null) {
            if (offset != null &&offset>0) {
                query.setFirstResult((offset - 1) * limit);
            }
        }
@@ -338,7 +353,7 @@ public class StdDatasetService extends SQLGeneralDAO {
        criteria.add(Restrictions.eq("code", code));
        List<StandardModel> standardModelList = criteria.list();
        List<Integer> idList = standardModelList.stream().map(StandardModel::getId).collect(Collectors.toList());
        List<Long> idList = standardModelList.stream().map(StandardModel::getId).collect(Collectors.toList());
        try {
            List<StandardVersionModel> versionModelList = new ArrayList<>();
            if (!CollectionUtils.isEmpty(idList)) {
@@ -398,7 +413,7 @@ public class StdDatasetService extends SQLGeneralDAO {
        String sql = sqlCreator.selectData(dictTable);
        Query sessionQuery = getQuery(sqlCreator, sql);
        List<StdDictionaryModel> stdDictList = sessionQuery.list();
        Map<String, Integer> stdDictMap = new HashMap<>();
        Map<String, Long> stdDictMap = new HashMap<>();
        for (StdDictionaryModel dict : stdDictList) {
            stdDictMap.put(dict.getCode(), dict.getId());
        }
@@ -431,7 +446,7 @@ public class StdDatasetService extends SQLGeneralDAO {
                //插入数据集信息
                stdDataSetModel.setCode(dataSetCode);//code唯一
                stdDataSetModel.setName(dataSetNname);
                stdDataSetModel.setstandardId(2);
                stdDataSetModel.setStandardId(2);
                //获取数据元信息
                Set<String> set = new HashSet<String>();
@@ -452,13 +467,13 @@ public class StdDatasetService extends SQLGeneralDAO {
                    String columnLength = sheet.getCell(10, row).getContents();//列长度
                    String primaryKey = sheet.getCell(11, row).getContents();//主键
                    String nullable = sheet.getCell(12, row).getContents();//可为空
                    Integer pk = 0;
                    Integer isNull = 1;
                    Boolean pk = false;
                    Boolean isNull = true;
                    if (!StringUtil.isEmpty(primaryKey)) {
                        pk = Integer.parseInt(primaryKey);
                        pk = Integer.parseInt(primaryKey)>0?true:false;
                    }
                    if (!StringUtil.isEmpty(nullable)) {
                        isNull = Integer.parseInt(nullable);
                        isNull = Integer.parseInt(nullable)>0?true:false;
                    }
                    //todo：test--测试时备注做区别，方便删除测试，definition变量区别
@@ -484,7 +499,7 @@ public class StdDatasetService extends SQLGeneralDAO {
                    if (StringUtil.isEmpty(columnName)){
                        throw new Exception(sheetName+"第"+(row+1)+"行列名不能为空，请检查！");
                    }
                    if (pk == 1 && isNull == 1){
                    if (pk&&isNull){
                        throw new Exception(sheetName+"第"+(row+1)+"行主键不能为空，请检查！");
                    }
                    //数据类型与列类型一致 S、L、N、D、DT、T、BY
@@ -493,20 +508,20 @@ public class StdDatasetService extends SQLGeneralDAO {
                    }
                    //插入数据元信息
                    metaData.setId(0);//为0内部自增
                    metaData.setId(0L);//为0内部自增
                    metaData.setCode(innerCode);
                    metaData.setName(name);
                    metaData.setDeCode(code);
                    metaData.setDictCode(code);
                    metaData.setType(type);
                    if (!StringUtil.isEmpty(dictCode)) {
                        metaData.setDictId(stdDictMap.get(dictCode));
                        metaData.setDictId(stdDictMap.get(dictCode).longValue());
                    }
                    metaData.setFormat(format);
                    metaData.setDefinition(definition);
                    metaData.setColumnName(columnName);
                    metaData.setColumnLength(columnLength);
                    metaData.setColumnType(columnType);
                    metaData.setPrimaryKey(0);
                    metaData.setPrimaryKey(false);
                    metaData.setPrimaryKey(pk);
                    metaData.setNullable(isNull);
                    metaDataList.add(metaData);
@@ -514,15 +529,16 @@ public class StdDatasetService extends SQLGeneralDAO {
                }
                //数据集入库
                add(datasetTable, stdDataSetModel);//保存数据集信息
                Integer metaDataMaxId = getMaxId(metadataTable);
                Long metaDataMaxId = getMaxId(metadataTable);
                //数据元入库
                if (metaDataList.size()>0){
                    for (StdMetaDataModel metaData : metaDataList) {
                        sqlCreator = new SqlCreator(StdMetaDataModel.class);
                        metaData.setDatasetId(stdDataSetModel.getId());
                        metaData.setId(metaDataMaxId++);
                        metaData.setStandardId(2);
                        metaData.setDataSetId(stdDataSetModel.getId());
                        metaDataMaxId++;
                        metaData.setId(metaDataMaxId.longValue());
                        metaData.setStandardId(2L);
                        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(metaData));
                        sql = sqlCreator.insertData(metadataTable, jsonNode);
                        Query query = getExeuteQuery(sqlCreator, sql);

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/standard/StdDictEntryService.java

@@ -40,7 +40,7 @@ public class StdDictEntryService extends SQLGeneralDAO {
    public void finalize() throws Throwable {
    }
    public List<StdDictionaryEntryModel> getList(String stdVersion, Integer dictId, String condition, String order, Integer limit, Integer offset) {
    public List<StdDictionaryEntryModel> getList(String stdVersion, Long dictId, String condition, String order, Integer limit, Integer offset) {
        try {
            Map queryMap = RequestParamTransformer.parseJsonToMap(condition);
            Map orderMap = RequestParamTransformer.parseJsonToMap(order);
@@ -73,7 +73,7 @@ public class StdDictEntryService extends SQLGeneralDAO {
        }
    }
    public Boolean dictEntryCodeValidate(StandardVersion standardVersion, Integer dictId, String code) {
    public Boolean dictEntryCodeValidate(StandardVersion standardVersion, Long dictId, String code) {
        Map<String, Object> query = new HashMap<>();
        Map<String, String> order = new HashMap<>();
        query.put("code", code);
@@ -85,7 +85,7 @@ public class StdDictEntryService extends SQLGeneralDAO {
        return false;
    }
    public Envelop delete(String stdVersion, Integer dictEntryId) {
    public Envelop delete(String stdVersion, Long dictEntryId) {
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            if (dictEntryId != null) {
@@ -99,7 +99,7 @@ public class StdDictEntryService extends SQLGeneralDAO {
        return Envelop.getError("删除标准字典项失败");
    }
    public Boolean dictEntryCodeValidate(StandardVersion standardVersion, Integer dictId, Integer dictEntryId, String code) {
    public Boolean dictEntryCodeValidate(StandardVersion standardVersion, Long dictId, Long dictEntryId, String code) {
        SqlCreator sqlCreator = new SqlCreator(StdDictionaryEntryModel.class);
        sqlCreator.equalCondition("dictId", dictId);
        sqlCreator.equalCondition("code", code);
@@ -156,7 +156,7 @@ public class StdDictEntryService extends SQLGeneralDAO {
        Query query = session.createSQLQuery(sql);
        Object object = query.uniqueResult();
        Integer id = object == null ? 1 : Integer.parseInt(object.toString()) + 1;
        Long id = object == null ? 1L : Long.parseLong(object.toString()) + 1;
        stdDictionaryEntryModel.setId(id);
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(stdDictionaryEntryModel));
@@ -166,7 +166,7 @@ public class StdDictEntryService extends SQLGeneralDAO {
        query.executeUpdate();
    }
    public PageEnvelop getDetailModelList(String stdVersion, Integer dictId, String condition, String order, Integer rows, Integer page) {
    public PageEnvelop getDetailModelList(String stdVersion, Long dictId, String condition, String order, Integer rows, Integer page) {
        try {
            List<StdDictionaryEntryModel> detailModelList = getDictEntryList(StdDictionaryEntryModel.class, stdVersion, dictId, condition, order, rows, page);
            Integer count = getDictEntryInt(StdDictionaryEntryModel.class, stdVersion, dictId, condition);
@@ -180,7 +180,7 @@ public class StdDictEntryService extends SQLGeneralDAO {
        }
    }
    public List getDictEntryList(Class tClass, String stdVersion, Integer dictId, String condition, String order, Integer limit, Integer offset) {
    public List getDictEntryList(Class tClass, String stdVersion, Long dictId, String condition, String order, Integer limit, Integer offset) {
        StandardVersion standardVersion = new StandardVersion(stdVersion);
        String tableName = standardVersion.getDictEntryTableName();
        SqlCreator sqlCreator = new SqlCreator(tClass);
@@ -212,7 +212,7 @@ public class StdDictEntryService extends SQLGeneralDAO {
        Query query = getQuery(sqlCreator, sql);
        if (limit != null) {
            query.setMaxResults(limit);
            if (offset != null) {
            if (offset != null &&offset>0) {
                query.setFirstResult((offset - 1) * limit);
            }
        }
@@ -220,7 +220,7 @@ public class StdDictEntryService extends SQLGeneralDAO {
        return query.list();
    }
    public Integer getDictEntryInt(Class tClass, String stdVersion, Integer dictId, String condition) {
    public Integer getDictEntryInt(Class tClass, String stdVersion, Long dictId, String condition) {
        StandardVersion standardVersion = new StandardVersion(stdVersion);
        String tableName = standardVersion.getDictEntryTableName();
        SqlCreator sqlCreator = new SqlCreator(tClass);
@@ -243,7 +243,7 @@ public class StdDictEntryService extends SQLGeneralDAO {
        return count;
    }
    public PageEnvelop getDictEntrySelectList(String stdVersion, Integer dictId, String condition, String order, Integer rows, Integer page) {
    public PageEnvelop getDictEntrySelectList(String stdVersion, Long dictId, String condition, String order, Integer rows, Integer page) {
        try {
            List<StdDictionaryEntryModel> dictEntryModelList = getDictEntryList(StdDictionaryEntryModel.class, stdVersion, dictId, condition, order, rows, page);
            List<Select2> detailModelList = new ArrayList<>();
@@ -300,15 +300,15 @@ public class StdDictEntryService extends SQLGeneralDAO {
        query.executeUpdate();
    }
    private void delete(StandardVersion standardVersion, Integer dictEntryId) {
    private void delete(StandardVersion standardVersion, Long dictEntryId) {
        Session session = getCurrentSession();
        String sql = "delete from " + standardVersion.getDictEntryTableName() + " where id = :id";
        Query query = session.createSQLQuery(sql);
        query.setInteger("id", dictEntryId);
        query.setLong("id", dictEntryId);
        query.executeUpdate();
    }
    private List<StdDictionaryEntryModel> getList(StandardVersion standardVersion, Integer dictId, Map<String, Object> query, Map<String, String> order, Integer limit, Integer offset) {
    private List<StdDictionaryEntryModel> getList(StandardVersion standardVersion, Long dictId, Map<String, Object> query, Map<String, String> order, Integer limit, Integer offset) {
        SqlCreator sqlCreator = new SqlCreator(StdDictionaryEntryModel.class);
        sqlCreator.equalCondition("dictId", dictId);
        for (String key : query.keySet()) {
@@ -322,7 +322,7 @@ public class StdDictEntryService extends SQLGeneralDAO {
        Query sessionQuery = getQuery(sqlCreator, sql);
        if (limit != null) {
            sessionQuery.setMaxResults(limit);
            if (offset != null) {
            if (offset != null &&offset>0) {
                sessionQuery.setFirstResult((offset - 1) * limit);
            }
        }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/standard/StdDictService.java

@@ -74,8 +74,8 @@ public class StdDictService extends SQLGeneralDAO {
                query.put("code", stdDictionaryModel.getCode());
                List<StdDictionaryModel> list = this.getList(standardVersion, query, order, 1, 0);
                Integer id = list.get(0).getId();
                Integer parentId = list.get(0).getParentId();
                Long id = list.get(0).getId();
                Long parentId = list.get(0).getParentId();
                if (parentId != null) {
                    Map<String, Object> query1 = new HashMap<>();
                    Map<String, String> order1 = new HashMap<>();
@@ -129,7 +129,7 @@ public class StdDictService extends SQLGeneralDAO {
        return Envelop.getError("删除标准字典失败");
    }
    public Boolean dictCodeValidate(StandardVersion standardVersion, Integer dictId, String code) {
    public Boolean dictCodeValidate(StandardVersion standardVersion, Long dictId, String code) {
        SqlCreator sqlCreator = new SqlCreator(StdDictionaryModel.class);
        sqlCreator.equalCondition("code", code);
        sqlCreator.neCondition("id", dictId);
@@ -218,7 +218,7 @@ public class StdDictService extends SQLGeneralDAO {
        Query query = session.createSQLQuery(sql);
        Object object = query.uniqueResult();
        Integer id = object == null ? 1 : Integer.parseInt(object.toString()) + 1;
        Long id = object == null ? 1L : Long.parseLong(object.toString()) + 1;
        stdDictionaryModel.setId(id);
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(stdDictionaryModel));
@@ -241,7 +241,7 @@ public class StdDictService extends SQLGeneralDAO {
        Query sessionQuery = getQuery(sqlCreator, sql);
        if (limit != null) {
            sessionQuery.setMaxResults(limit);
            if (offset != null) {
            if (offset != null &&offset>0) {
                sessionQuery.setFirstResult((offset - 1) * limit);
            }
        }
@@ -265,7 +265,7 @@ public class StdDictService extends SQLGeneralDAO {
        Query sessionQuery = getQuery(sqlCreator, sql);
        if (limit != null) {
            sessionQuery.setMaxResults(limit);
            if (offset != null) {
            if (offset != null &&offset>0) {
                sessionQuery.setFirstResult((offset - 1) * limit);
            }
        }
@@ -282,7 +282,7 @@ public class StdDictService extends SQLGeneralDAO {
            detailModelList.add(item);
            for (StdDictionaryModel stdDictionaryModel : stdDictionaryModelList) {
                DictItem items = new DictItem();
                Integer  id = stdDictionaryModel.getId();
                Long  id = stdDictionaryModel.getId();
                String name = stdDictionaryModel.getName();
                items.setCode(id.toString());
                items.setValue(name);
@@ -341,7 +341,7 @@ public class StdDictService extends SQLGeneralDAO {
        Query query = getQuery(sqlCreator, sql);
        if (limit != null) {
            query.setMaxResults(limit);
            if (offset != null) {
            if (offset != null &&offset>0) {
                query.setFirstResult((offset - 1) * limit);
            }
        }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/standard/StdMetadataService.java

@@ -18,6 +18,7 @@ import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.criterion.Restrictions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
@@ -44,7 +45,7 @@ public class StdMetadataService extends SQLGeneralDAO {
    public StdMetadataService() {
    }
    public List<StdMetaDataModel> getList(String stdVersion, Integer datasetId, String condition, String order, Integer limit, Integer offset) {
    public List<StdMetaDataModel> getList(String stdVersion, Long datasetId, String condition, String order, Integer limit, Integer offset) {
        try {
            Map<String, Object> queryMap = RequestParamTransformer.parseJsonToMap(condition);
@@ -64,7 +65,7 @@ public class StdMetadataService extends SQLGeneralDAO {
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            StdMetaDataModel stdMetaDataModel = objectMapper.readValue(metadata, StdMetaDataModel.class);
            existFlg = metadataCodeValidate(standardVersion, stdMetaDataModel.getDatasetId(), stdMetaDataModel.getCode());
            existFlg = metadataCodeValidate(standardVersion, stdMetaDataModel.getDataSetId(), stdMetaDataModel.getCode());
            if (!existFlg) {
                this.add(standardVersion, stdMetaDataModel);
                return ObjEnvelop.getSuccess("保存数据元成功",stdMetaDataModel);
@@ -79,7 +80,7 @@ public class StdMetadataService extends SQLGeneralDAO {
        }
    }
    public Boolean metadataCodeValidate(StandardVersion standardVersion, Integer datasetId, String code) {
    public Boolean metadataCodeValidate(StandardVersion standardVersion, Long datasetId, String code) {
        Map<String, Object> query = new HashMap<>();
        Map<String, String> order = new HashMap<>();
        query.put("code", code);
@@ -91,7 +92,7 @@ public class StdMetadataService extends SQLGeneralDAO {
        return false;
    }
    public Envelop delete(String stdVersion, Integer metadataId) {
    public Envelop delete(String stdVersion, Long metadataId) {
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            if (metadataId != null) {
@@ -104,9 +105,9 @@ public class StdMetadataService extends SQLGeneralDAO {
        return Envelop.getError("删除数据元失败");
    }
    public Boolean metadataCodeValidate(StandardVersion standardVersion, Integer datasetId, Integer metadataId, String code) {
    public Boolean metadataCodeValidate(StandardVersion standardVersion, Long datasetId, Long metadataId, String code) {
        SqlCreator sqlCreator = new SqlCreator(StdMetaDataModel.class);
        sqlCreator.equalCondition("datasetId", datasetId);
        sqlCreator.equalCondition("dataSetId", datasetId);
        sqlCreator.equalCondition("code", code);
        sqlCreator.neCondition("id", metadataId);
        String sql = sqlCreator.selectData(standardVersion.getMetaDataTableName());
@@ -123,7 +124,7 @@ public class StdMetadataService extends SQLGeneralDAO {
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            StdMetaDataModel stdMetaDataModel = objectMapper.readValue(metadata, StdMetaDataModel.class);
            existFlg = metadataCodeValidate(standardVersion, stdMetaDataModel.getDatasetId(), stdMetaDataModel.getId(), stdMetaDataModel.getCode());
            existFlg = metadataCodeValidate(standardVersion, stdMetaDataModel.getDataSetId(), stdMetaDataModel.getId(), stdMetaDataModel.getCode());
            if (!existFlg) {
                this.modify(standardVersion, stdMetaDataModel);
                return ObjEnvelop.getSuccess("修改数据元成功",stdMetaDataModel);
@@ -167,11 +168,11 @@ public class StdMetadataService extends SQLGeneralDAO {
        query.executeUpdate();
    }
    private void delete(StandardVersion standardVersion, Integer metadataId) {
    private void delete(StandardVersion standardVersion, Long metadataId) {
        Session session = getCurrentSession();
        String sql = "delete from " + standardVersion.getMetaDataTableName() + " where id = :id";
        Query query = session.createSQLQuery(sql);
        query.setInteger("id", metadataId);
        query.setLong("id", metadataId);
        query.executeUpdate();
    }
@@ -182,7 +183,7 @@ public class StdMetadataService extends SQLGeneralDAO {
        String sql = "select max(id) from " + metaDataTableName;
        Query query = session.createSQLQuery(sql);
        Object object = query.uniqueResult();
        stdMetaDataModel.setId(object == null ? 1 : Integer.parseInt(object.toString()) + 1);
        stdMetaDataModel.setId(object == null ? 1L : Long.parseLong(object.toString()) + 1);
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(stdMetaDataModel));
        SqlCreator sqlCreator = new SqlCreator(StdMetaDataModel.class);
@@ -191,10 +192,10 @@ public class StdMetadataService extends SQLGeneralDAO {
        query.executeUpdate();
    }
    private List<StdMetaDataModel> getList(StandardVersion standardVersion, Integer datasetId, Map<String, Object> query, Map<String, String> order, Integer limit, Integer offset) {
    private List<StdMetaDataModel> getList(StandardVersion standardVersion, Long datasetId, Map<String, Object> query, Map<String, String> order, Integer limit, Integer offset) {
        SqlCreator sqlCreator = new SqlCreator(StdMetaDataModel.class);
        if(null!=datasetId){
            sqlCreator.equalCondition("datasetId", datasetId);
            sqlCreator.equalCondition("dataSetId", datasetId);
        }
        for (String key : query.keySet()) {
            sqlCreator.equalCondition(key, query.get(key));
@@ -207,14 +208,14 @@ public class StdMetadataService extends SQLGeneralDAO {
        Query sessionQuery = getQuery(sqlCreator, sql);
        if (limit != null) {
            sessionQuery.setMaxResults(limit);
            if (offset != null) {
            if (offset != null &&offset>0) {
                sessionQuery.setFirstResult((offset - 1) * limit);
            }
        }
        return (List<StdMetaDataModel>) sessionQuery.list();
    }
    public PageEnvelop getDetailModelList(String stdVersion, Integer dictId, String condition, String order, Integer rows, Integer page) {
    public PageEnvelop getDetailModelList(String stdVersion, Long dictId, String condition, String order, Integer rows, Integer page) {
        try {
            List<StdDictionaryEntryModel> detailModelList = getMetadataList(StdMetaDataModel.class, stdVersion, dictId, condition, order, rows, page);
            Integer count = getMetadataCount(StdMetaDataModel.class, stdVersion, dictId, condition);
@@ -228,51 +229,42 @@ public class StdMetadataService extends SQLGeneralDAO {
        }
    }
    public List getMetadataList(Class tClass, String stdVersion, Integer datasetId, String condition, String order, Integer limit, Integer offset) {
    public List getMetadataList(Class tClass, String stdVersion, Long datasetId, String condition, String order, Integer limit, Integer offset) {
        StandardVersion standardVersion = new StandardVersion(stdVersion);
        String tableName = standardVersion.getMetaDataTableName();
        SqlCreator sqlCreator = new SqlCreator(tClass);
        sqlCreator.equalCondition("datasetId", datasetId);
        String sql = "select * from "+tableName;
        sql += " where dataset_id = "+ datasetId;
        if (!StringUtil.isEmpty(condition)) {
            try {
                JsonNode jsonNode = objectMapper.readTree(condition);
                String name = jsonNode.get("name").asText();
                sqlCreator.likeOrCondition("code", "name", name);
                sql += " and (code like '%"+name+"%' or name like '%"+name+"%' )";
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            if (!StringUtil.isEmpty(order)) {
                JsonNode jsonNode = objectMapper.readTree(order);
                Iterator<String> fieldNames = jsonNode.fieldNames();
                while (fieldNames.hasNext()) {
                    String fieldName = fieldNames.next();
                    String value = jsonNode.get(fieldName).asText().toUpperCase();
                    sqlCreator.order(fieldName, value);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        if (!StringUtil.isEmpty(order)) {
            sql += " order by "+order;
        }
        String sql = sqlCreator.selectData(tableName);
        Query query = getQuery(sqlCreator, sql);
        if (limit != null) {
            query.setMaxResults(limit);
            if (offset != null) {
                query.setFirstResult((offset - 1) * limit);
        if(limit != null){
            if (offset != null &&offset>0) {
                sql += " limit "+ (offset - 1) * limit+","+limit;
            }else {
                sql += " limit " +limit;
            }
        }
        return query.list();
        return jdbcTemplate.query(sql,new BeanPropertyRowMapper<>(tClass));
    }
    public Integer getMetadataCount(Class tClass, String stdVersion, Integer datasetId, String condition) {
    public Integer getMetadataCount(Class tClass, String stdVersion, Long datasetId, String condition) {
        StandardVersion standardVersion = new StandardVersion(stdVersion);
        String tableName = standardVersion.getMetaDataTableName();
        SqlCreator sqlCreator = new SqlCreator(tClass);
        sqlCreator.equalCondition("datasetId", datasetId);
        sqlCreator.equalCondition("dataSetId", datasetId);
        if (!StringUtil.isEmpty(condition)) {
            try {
                JsonNode jsonNode = objectMapper.readTree(condition);
@@ -292,7 +284,7 @@ public class StdMetadataService extends SQLGeneralDAO {
        return count;
    }
    public PageEnvelop getMetadataSelectList(String stdVersion, Integer dictId, String condition, String order, Integer rows, Integer page) {
    public PageEnvelop getMetadataSelectList(String stdVersion, Long dictId, String condition, String order, Integer rows, Integer page) {
        try {
            List<StdMetaDataModel> metadataList = getMetadataList(StdMetaDataModel.class, stdVersion, dictId, condition, order, rows, page);
            List<Select2> detailModelList = new ArrayList<>();
@@ -332,7 +324,7 @@ public class StdMetadataService extends SQLGeneralDAO {
            String VersionCode = standardParam.getCode();
            criteria.add(Restrictions.eq("code", VersionCode));
            List<StandardModel> standardModelList = criteria.list();
            List<Integer> idList = standardModelList.stream().map(StandardModel::getId).collect(Collectors.toList());
            List<Long> idList = standardModelList.stream().map(StandardModel::getId).collect(Collectors.toList());
            List<StandardVersionModel> versionModelList;
            Session session = getCurrentSession();
            if (!CollectionUtils.isEmpty(idList)) {
@@ -368,7 +360,7 @@ public class StdMetadataService extends SQLGeneralDAO {
                    StandardVersion version = new StandardVersion((String) entry.getKey());
                    List<StdDataSetModel> dataList = (List<StdDataSetModel>) entry.getValue();
                    datasetIdMap.put(count++, StringUtil.toString(dataList.get(0).getId()));
                    sqlMetadataCreator.equalConditionQue("datasetId", dataList.get(0).getId());
                    sqlMetadataCreator.equalConditionQue("dataSetId", dataList.get(0).getId());
                    sql = sql + sqlMetadataCreator.selectData(version.getMetaDataTableName()) + SqlConstants.UNION;
                }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/service/standard/StdPublisherService.java

@@ -71,7 +71,7 @@ public class StdPublisherService extends SQLGeneralDAO {
        }
        if (limit != null) {
            criteria.setMaxResults(limit);
            if (offset != null) {
            if (offset != null &&offset>0) {
                criteria.setFirstResult((offset - 1) * limit);
            }
        }

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/task/StdRedisTask.java

@@ -0,0 +1,133 @@
package com.yihu.jw.basic.standard.task;
import com.yihu.jw.basic.standard.service.bo.StandardVersion;
import com.yihu.jw.redis.schema.StdDataSetKeySchema;
import com.yihu.jw.redis.schema.StdMetaDataKeySchema;
import com.yihu.jw.util.common.LogService;
import com.yihu.jw.util.thread.ContextAttributes;
import com.yihu.jw.util.thread.LocalContext;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Future;
@Component
public class StdRedisTask {
    @Autowired
    private StdDataSetKeySchema stdDataSetKeySchema;
    @Autowired
    private StdMetaDataKeySchema stdMetaDataKeySchema;
    @Resource(name = "jdbcTemplate")
    private JdbcTemplate jdbc;
    /**
     * 缓存标准的数据集
     * @param version
     * @param dataSetList
     * @return
     */
    @Async
    public Future<Boolean> cacheDataset(String version, List<Map<String,Object>> dataSetList,String scheme){
        System.out.println("开始缓存标准数据集");
        LocalContext.getContext().setAttachment(ContextAttributes.SCHEMA,scheme);
        StandardVersion standardVersion = new StandardVersion(version);
        for (Map<String, Object> tempMap: dataSetList) {
            String id = tempMap.get("id").toString();
            String code = (String) tempMap.get("code");
            String name = (String) tempMap.get("name");
            boolean multiRecord = (boolean) tempMap.get("multi_record");
            stdDataSetKeySchema.setDataSetCode(version, id, code);
            stdDataSetKeySchema.setDataSetName(version, id, name);
            stdDataSetKeySchema.setDataSetNameByCode(version, code, name);
            stdDataSetKeySchema.setDataSetMultiRecord(version, code, multiRecord);
            //通过该数据集id,查找所有的数据元codes,多个codes用,分隔
            String metaCodes = "";
            String sql = "select t.inner_code from "+standardVersion.getMetaDataTableName()+" t where t.dataset_id=?";
            List<String> metadataCodeList = jdbc.queryForList(sql,String.class, id);
            if(CollectionUtils.isNotEmpty(metadataCodeList)){
                for(String c:metadataCodeList){
                    metaCodes+=","+c;
                }
            }
            if(!StringUtils.isEmpty(metaCodes)){
                metaCodes = metaCodes.substring(1,metaCodes.length());
            }
            stdDataSetKeySchema.setMetadataCode(version, code, metaCodes);
        }
        System.out.println("缓存标准的数据集完成");
        return new AsyncResult<Boolean>(true);
    }
    /**
     * 缓存标准的数据元
     * @param version
     * @param metaDataList
     * @param force
     * @return
     */
    @Async
    public Future<Boolean> cacheMetadata(String version, List<Map<String,Object>> metaDataList, boolean force,String schema){
        System.out.println("开始缓存标准数据元");
        LocalContext.getContext().setAttachment(ContextAttributes.SCHEMA,schema);
        for(Map<String, Object> tempMap : metaDataList) {
            String dataSetCode = (String) tempMap.get("data_set_code");
            String innerCode = (String) tempMap.get("inner_code");
            String name = (String) tempMap.get("name");
            String type = (String) tempMap.get("type");
            Integer dictId = (Integer) tempMap.get("dict_id");
            String nullable = (String) tempMap.get("nullable");
            if(StringUtils.isEmpty(nullable)){
                nullable="1";//1为可以为空
            }
            String formate =(String) tempMap.get("formate");
            if(StringUtils.isEmpty(formate)){
                formate="";
            }
            String metaDataTypeKey = stdMetaDataKeySchema.makeKey(version, dataSetCode, innerCode);
            if (!force && stdMetaDataKeySchema.hasKey(metaDataTypeKey)) {
                LogService.getLogger().warn("Meta data duplicated: " + metaDataTypeKey);
            }
            stdMetaDataKeySchema.setMetaDataName(version, dataSetCode,innerCode, name);
            stdMetaDataKeySchema.setMetaDataType(version, dataSetCode, innerCode, type);
            if(dictId != null && dictId != 0 ){
                stdMetaDataKeySchema.setMetaDataDict(version, dataSetCode, innerCode, String.valueOf(dictId));
            }
            stdMetaDataKeySchema.setMetaDataNullable(version, dataSetCode, innerCode, nullable);
            stdMetaDataKeySchema.setMetaDataFormat(version, dataSetCode, innerCode, formate);
        }
        System.out.println("缓存标准数据元完成");
        return new AsyncResult<Boolean>(true);
    }
    /**
     * 缓存标准的字典
     * @param version
     * @param dictEntryList
     * @return
     */
    @Async
    public Future<Boolean> cacheDict(String version,List<Map<String,Object>> dictEntryList){
        System.out.println("开始缓存标准字典");
        for (Map<String, Object> tempMap: dictEntryList) {
            String dictId = tempMap.get("dict_id").toString();
            String code = (String) tempMap.get("code");
            String value = (String) tempMap.get("value");
            stdMetaDataKeySchema.setDictEntryValue(version, dictId, code, value);
        }
        System.out.println("缓存标准字典完成");
        return new AsyncResult<Boolean>(true);
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/util/CDAVersionUtil.java

@@ -0,0 +1,56 @@
package com.yihu.jw.basic.util;
import com.yihu.jw.basic.standard.service.bo.ObjectVersion;
/**
 * @author lincl
 * @version 1.0
 * @created 2016.2.3
 */
public class CDAVersionUtil {
    public final static String DataSetTablePrefix = "std_dataset_";
    public final static String MetaDataTablePrefix = "std_metadata_";
    public final static String DictTablePrefix = "std_dictionary_";
    public final static String DictEntryTablePrefix = "std_dictionary_entry_";
    public final static String CDADocumentTablePrefix = "std_cda_document_";
    public final static String CDADatasetRelationshipTablePrefix = "std_cda_data_set_relationship_";
    public static String getDataSetTableName(String version) {
        if (!ObjectVersion.isValid(version)) throw new IllegalArgumentException("无效版本号");
        return DataSetTablePrefix + version;
    }
    public static String getMetaDataTableName(String version) {
        if (!ObjectVersion.isValid(version)) throw new IllegalArgumentException("无效版本号");
        return MetaDataTablePrefix + version;
    }
    public static String getDictTableName(String version) {
        if (!ObjectVersion.isValid(version)) throw new IllegalArgumentException("无效版本号");
        return DictTablePrefix + version;
    }
    public static String getDictEntryTableName(String version) {
        if (!ObjectVersion.isValid(version)) throw new IllegalArgumentException("无效版本号");
        return DictEntryTablePrefix + version;
    }
    public static String getCDATableName(String version) {
        if (!ObjectVersion.isValid(version)) throw new IllegalArgumentException("无效版本号");
        return CDADocumentTablePrefix + version;
    }
    public static String getCDADatasetRelationshipTableName(String version) {
        if (!ObjectVersion.isValid(version)) throw new IllegalArgumentException("无效版本号");
        return CDADatasetRelationshipTablePrefix + version;
    }
}