代码修改

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

@@ -1,203 +0,0 @@
//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/hibernate/HibenateDemo.java

@@ -1,83 +0,0 @@
package com.yihu.jw.basic.hibernate;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.MixEnvelop;
import com.yihu.jw.rm.hospital.BaseHospitalRequestMapping;
import com.yihu.jw.util.date.DateUtil;
import org.apache.commons.collections.map.HashedMap;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
/**
 * Created by Trick on 2019/12/10.
 */
@Component
public class HibenateDemo {
    @Autowired
    private HibenateUtils hibenateUtils;
    /**
     * 特别注意，由于oracle 大小写不明感，表别名需要指定大小写（驼峰）的话需要加双引号
     * @param id
     * @param name
     * @param createTime
     * @param page
     * @param size
     * @return
     */
    public Envelop findDoctorInfo(String id, String name, String createTime, Integer page, Integer size){
        String sqlTotal ="SELECT " +
                " COUNT(1) AS \"total\" " +
                " FROM " +
                " base_doctor d " +
                " JOIN base_doctor_hospital h ON d.id = h.doctor_code " +
                " WHERE " +
                " 1 = 1";
        Map<String,Object> params = new HashedMap();
        if(StringUtils.isNotBlank(id)){
            sqlTotal+=" AND d.id =:id";
            params.put("id",id);
        }
        if(StringUtils.isNotBlank(name)){
            sqlTotal+=" AND d.name =:name";
            params.put("name",name);
        }
        if(StringUtils.isNotBlank(createTime)){
            sqlTotal+=" AND d.create_time >:createTime";
            params.put("createTime", DateUtil.stringToDate(createTime,"yyyy-MM-dd"));
        }
        Long count = 0L;
        List<Map<String,Object>> total = hibenateUtils.createSQLQuery(sqlTotal,params);
        if(total!=null){
            //mysql 与 Oracle 聚合函数返回类型不一致，需要判断装换
            count = hibenateUtils.objTransformLong(total.get(0).get("total"));
        }
        String sql ="SELECT " +
                " d.id AS \"id\", " +
                " d.NAME AS \"name\"," +
                " h.dept_name AS \"deptName\"" +
                " FROM " +
                " base_doctor d " +
                " JOIN base_doctor_hospital h ON d.id = h.doctor_code " +
                " WHERE " +
                " 1 = 1 ";
        if(StringUtils.isNotBlank(id)){
            sql+=" AND d.id =:id";
        }
        if(StringUtils.isNotBlank(name)){
            sql+=" AND d.name =:name";
        }
        if(StringUtils.isNotBlank(createTime)){
            sql+=" AND d.create_time >:createTime";
        }
        List<Map<String,Object>> list = hibenateUtils.createSQLQuery(sql,params,page,size);
       return MixEnvelop.getSuccessListWithPage(BaseHospitalRequestMapping.Prescription.api_success, list, page, size, count);
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/hibernate/HibenateUtils.java

@@ -1,264 +0,0 @@
package com.yihu.jw.basic.hibernate;
import com.yihu.jw.entity.hospital.prescription.HlwCf01DO;
import org.hibernate.Session;
import org.hibernate.query.NativeQuery;
import org.hibernate.query.internal.NativeQueryImpl;
import org.hibernate.transform.Transformers;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import javax.persistence.EntityManager;
import javax.persistence.ParameterMode;
import javax.persistence.PersistenceContext;
import javax.persistence.StoredProcedureQuery;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
 * 数据库查询工具，mysql与Oracle 通用复诊查询
 * 支持原生SQL。联表，动态传参。分页查询
 * 不支持数据库特有的函数
 * <p>
 * Created by Trick on 2019/12/10.
 */
@Component
@Transactional
public class HibenateUtils {
    /**
     * JPA 数据源
     */
    @PersistenceContext
    private EntityManager entityManager;
    /**
     * 创建SQL查询，根据配置，获取数据库方言
     * sql为原生sql语句，查询，Oracle不区分大小写，返回值需要驼峰命名，字段别名需要加 双引号
     * 目前只支持通用的聚合函数，特有的聚合函数不支持
     *
     * @param sql
     * @param page 第几页，1开始
     * @param size 每页记录数
     * @return
     */
    public List<Map<String, Object>> createSQLQuery(String sql, Integer page, Integer size) {
        Session session = (Session) entityManager.getDelegate();
        NativeQuery query = session.createNativeQuery(sql);
        query.unwrap(NativeQueryImpl.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        if(page!=null&&size!=null){
            query.setFirstResult((page - 1) * size);
            query.setMaxResults(size);
        }
        List<Map<String, Object>> list = query.list();
        return list;
    }
    /**
     * 创建SQL查询，根据配置，获取数据库方言
     * sql为原生sql语句，查询，Oracle不区分大小写，返回值需要驼峰命名，字段别名需要加 双引号
     * 目前只支持通用的聚合函数，特有的聚合函数不支持
     * 无分页
     * @param sql
     * @return
     */
    public List<Map<String, Object>> createSQLQuery(String sql) {
        Session session = (Session) entityManager.getDelegate();
        NativeQuery query = session.createNativeQuery(sql);
        query.unwrap(NativeQueryImpl.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        List<Map<String, Object>> list = query.list();
        return list;
    }
    /**
     * 创建SQL查询，根据配置，获取数据库方言
     * sql为原生sql语句，查询，Oracle不区分大小写，返回值需要驼峰命名，字段别名需要加 双引号
     * 目前只支持通用的聚合函数，特有的聚合函数不支持
     * @param sql
     * @param params 动态占位符入参，例如 like:name
     * @param page 第几页，1开始
     * @param size 每页记录数
     * @return
     */
    public List<Map<String, Object>> createSQLQuery(String sql, Map<String, Object> params, Integer page, Integer size) {
        Session session = (Session) entityManager.getDelegate();
        NativeQuery query = session.createNativeQuery(sql);
        query.unwrap(NativeQueryImpl.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        //设置查询参数
        setSqlQueryByMap(query, params);
        if(page!=null&&size!=null){
            query.setFirstResult((page-1) * size);
            query.setMaxResults(size);
        }
        List<Map<String, Object>> list = query.list();
        return list;
    }
    /**
     * 创建SQL查询，根据配置，获取数据库方言
     * sql为原生sql语句，查询，Oracle不区分大小写，返回值需要驼峰命名，字段别名需要加 双引号
     * 目前只支持通用的聚合函数，特有的聚合函数不支持
     * @param sql
     * @param params 动态占位符入参，例如 like:name
     * @return
     */
    public List<Map<String, Object>> createSQLQuery(String sql, Map<String, Object> params) {
        Session session = (Session) entityManager.getDelegate();
        NativeQuery query = session.createNativeQuery(sql);
        query.unwrap(NativeQueryImpl.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        //设置查询参数
        setSqlQueryByMap(query, params);
        List<Map<String, Object>> list = query.list();
        return list;
    }
    /**
     * 设置查询参数
     * @param sqlQuery
     * @param params
     * @return
     */
    private NativeQuery setSqlQueryByMap(NativeQuery sqlQuery, Map<String, Object> params) {
        if (params != null && !params.isEmpty()) {
            for (String key : params.keySet()) {
                Object obj = params.get(key);
                if (obj instanceof Collection<?>) {
                    sqlQuery.setParameterList(key, (Collection<?>) obj);
                } else if (obj instanceof Object[]) {
                    sqlQuery.setParameterList(key, (Object[]) obj);
                } else {
                    sqlQuery.setParameter(key, obj);
                }
            }
        }
        return sqlQuery;
    }
    /**
     * 聚合函数类型装换
     * @param obj
     * @return
     */
    public Long objTransformLong(Object obj){
        //Oracle count(1) 聚合函数类型装换
        if(obj instanceof BigDecimal){
            return ((BigDecimal) obj).longValue();
        //Mysql count(1) 聚合函数类型装换
        }else if(obj instanceof BigInteger){
            return ((BigInteger)obj).longValue();
        }else{
            return 0L;
        }
    }
    public void updateBySql(String sql){
        Session session = (Session) entityManager.getDelegate();
        session.createSQLQuery(sql).executeUpdate();
    }
    public void save(Object object) {
        entityManager.persist(object);
    }
    /**
     * 更新
     * @param entity
     */
    public void update(Object entity){
        entityManager.merge(entity);
        entityManager.flush();
    }
    public void update(String id,Integer status){
        HlwCf01DO hlwCf01DO = entityManager.find(HlwCf01DO.class,id);
        hlwCf01DO.setFKZT(status);
        update(hlwCf01DO);
    }
    public String saveJdxx(String brxm,Date csny,Float brxb,String czgh,String sfzh,String sjhm,String ybkh,String lxdz,Float zy) {
        StoredProcedureQuery query = entityManager
                .createStoredProcedureQuery(" ZKSG.sp_zksg_jdkh_2021@xec_link") // 被调用存储过程名称
                .registerStoredProcedureParameter("P_BRXM", String.class, ParameterMode.IN) // 注册参数
                .registerStoredProcedureParameter("P_CSNY", Date.class, ParameterMode.IN)
                .registerStoredProcedureParameter("P_BRXB", Float.class, ParameterMode.IN)
                .registerStoredProcedureParameter("P_CZGH", String.class, ParameterMode.IN)
                .registerStoredProcedureParameter("P_SFZH", String.class, ParameterMode.IN)
                .registerStoredProcedureParameter("P_SJHM", String.class, ParameterMode.IN)
                .registerStoredProcedureParameter("P_YBKH", String.class, ParameterMode.IN)
                .registerStoredProcedureParameter("P_LXDZ", String.class, ParameterMode.IN)
                .registerStoredProcedureParameter("P_ZY", Float.class, ParameterMode.IN)
                .registerStoredProcedureParameter("P_ERRMSG", String.class, ParameterMode.INOUT)
                .setParameter("P_BRXM", brxm)
                .setParameter("P_CSNY", csny)
                .setParameter("P_CZGH", czgh)
                .setParameter("P_BRXB", brxb)
                .setParameter("P_SFZH",sfzh)
                .setParameter("P_SJHM",sjhm)
                .setParameter("P_YBKH",ybkh)
                .setParameter("P_LXDZ",lxdz)
                .setParameter("P_ZY",zy);
        query.execute();
        String priceStr = (String) query.getOutputParameterValue("P_ERRMSG"); // 获取存储过程中的返回值
        return priceStr;
    }
    public String updateJdxx(Float brid,String sfzh,String lxdz,Float zy,String lxdh) {
        StoredProcedureQuery query = entityManager
                .createStoredProcedureQuery("ZKSG.SP_ZKSG_MZBRXXXG@xec_link") // 被调用存储过程名称
                .registerStoredProcedureParameter("P_BRID", Float.class, ParameterMode.IN) // 注册参数
                .registerStoredProcedureParameter("P_SFZH", String.class, ParameterMode.IN)
                .registerStoredProcedureParameter("P_LXDZ", String.class, ParameterMode.IN)
                .registerStoredProcedureParameter("P_LXDH", String.class, ParameterMode.IN)
                .registerStoredProcedureParameter("P_ZY", Float.class, ParameterMode.IN)
                .registerStoredProcedureParameter("P_ERRMSG", String.class, ParameterMode.INOUT)
                .setParameter("P_BRID", brid)
                .setParameter("P_SFZH", sfzh)
                .setParameter("P_LXDZ", lxdz)
                .setParameter("P_LXDH", lxdh)
                .setParameter("P_ZY",zy);
        query.execute();
        String priceStr = (String) query.getOutputParameterValue("P_ERRMSG"); // 获取存储过程中的返回值
        return priceStr;
    }
    public String updateJzkh(Float brid,String ybkh) {
        StoredProcedureQuery query = entityManager
                .createStoredProcedureQuery("zksg.sp_zksg_jzkhxg@xec_link") // 被调用存储过程名称
                .registerStoredProcedureParameter("P_BRID", Float.class, ParameterMode.IN) // 注册参数
                .registerStoredProcedureParameter("P_YBKH", String.class, ParameterMode.IN)
                .registerStoredProcedureParameter("P_ERRMSG", String.class, ParameterMode.INOUT)
                .setParameter("P_BRID", brid)
                .setParameter("P_YBKH", ybkh);
        query.execute();
        String priceStr = (String) query.getOutputParameterValue("P_ERRMSG"); // 获取存储过程中的返回值
        return priceStr;
    }
    public String updateSfzh(Float brid,String sfzh) {
        StoredProcedureQuery query = entityManager
                .createStoredProcedureQuery("zksg.SP_ZKSG_sfzhxg@xec_link") // 被调用存储过程名称
                .registerStoredProcedureParameter("P_BRID", Float.class, ParameterMode.IN) // 注册参数
                .registerStoredProcedureParameter("P_SFZH", String.class, ParameterMode.IN)
                .registerStoredProcedureParameter("P_ERRMSG", String.class, ParameterMode.INOUT)
                .setParameter("P_BRID", brid)
                .setParameter("P_SFZH", sfzh);
        query.execute();
        String priceStr = (String) query.getOutputParameterValue("P_ERRMSG"); // 获取存储过程中的返回值
        return priceStr;
    }
}

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

@@ -1,56 +0,0 @@
//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/quota/service/TjQuotaLogService.java

@@ -1,6 +1,5 @@
package com.yihu.jw.basic.quota.service;
import com.yihu.jw.basic.hibernate.HibenateUtils;
import com.yihu.jw.basic.quota.dao.XTjQuotaLogRepository;
import com.yihu.jw.entity.ehr.quota.TjQuotaLog;
import com.yihu.jw.mysql.query.BaseJpaService;
@@ -27,45 +26,7 @@ public class TjQuotaLogService extends BaseJpaService<TjQuotaLog, XTjQuotaLogRep
    @Autowired
    XTjQuotaLogRepository tjQuotaLogRepository;
    @Autowired
    HibenateUtils hibenateUtils;
   /* public List<TjQuotaLog> searchQuotaLogByParams(Map<String, Object> args) {
        Session session = entityManager.unwrap(Session.class);
        String quotaCode = (String) args.get("quotaCode");
        Integer page = (Integer) args.get("page");
        Integer pageSize = (Integer) args.get("pageSize");
        Date startTime = (Date) args.get("startDate");
        Date endTime = (Date) args.get("endDate");
        String hql = "from TjQuotaLog where 1=1";
        if (!StringUtils.isEmpty(quotaCode)) {
            hql += " and quotaCode = :quotaCode";
        }
        if (!StringUtils.isEmpty(startTime)) {
            hql += " and startTime >= :startTime";
        }
        if (!StringUtils.isEmpty(endTime)) {
            hql += " and endTime <= :endTime";
        }
        hql += " order by startTime desc";
        org.hibernate.query.Query query = session.createQuery(hql);
        if (!StringUtils.isEmpty(quotaCode)) {
            query.setString("quotaCode", quotaCode);
        }
        if (!StringUtils.isEmpty(startTime)) {
            query.setDate("startTime",startTime);
        }
        if (!StringUtils.isEmpty(endTime)) {
            query.setDate("endTime", endTime);
        }
        query.setMaxEnvelops(pageSize);
        query.setFirstEnvelop((page - 1) * pageSize);
        List<TjQuotaLog> tjQuotaLogs = query.list();
        return tjQuotaLogs;
    }*/
    public Integer searchQuotaLogByParamsTotalCount(Map<String, Object> args) {
        Session session = entityManager.unwrap(Session.class);

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

@@ -9,6 +9,7 @@ import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.io.IOException;
/**
 * Created by LLH on 2016/1/6.
@@ -104,4 +105,66 @@ public class AdapterDatasetController extends EnvelopRestEndpoint {
            @RequestParam(value = "metaDataIdStr") String metaDataIdStr){
        return datasetService.updateCustomize(schemeId, adapterVersion, stdVersion, datasetIdStr,metaDataIdStr);
    }
    @RequestMapping(value = "/cloneDataSet", method = RequestMethod.GET)
    @ApiOperation(value = "克隆一个数据集", response = Envelop.class,produces = "application/json")
    public Envelop cloneDataSet(@ApiParam(name = "adapterVersion", value = "适配版本号")
                                @RequestParam(value = "adapterVersion") String adapterVersion,
                                @ApiParam(name = "code", value = "adapter_dataset_* 的std_dataset_code")
                                @RequestParam(value = "code") String code){
        try {
            return datasetService.cloneDataSet(adapterVersion, code);
        } catch (IOException e) {
            e.printStackTrace();
            return Envelop.getError("克隆数据集失败");
        }
    }
    @RequestMapping(value = "/deleteCloneDataSet", method = RequestMethod.DELETE)
    @ApiOperation(value = "删除克隆的数据集", response = Envelop.class,produces = "application/json")
    public Envelop deleteCloneDataSet(@ApiParam(name = "adapterVersion", value = "适配版本号")
                                      @RequestParam(value = "adapterVersion") String adapterVersion,
                                      @ApiParam(name = "id", value = "adapter_dataset_* 的id")
                                      @RequestParam(value = "id") Long id){
        return datasetService.deleteCloneDataSet(adapterVersion, id);
    }
    @RequestMapping(value = "/isNeedRelation", method = RequestMethod.GET,produces="application/json;charset=UTF-8")
    @ApiOperation(value = "查询是否需要关联关系", response = Envelop.class,produces = "application/json", notes = "查询是否需要关联关系")
    public Envelop isNeedRelation(@ApiParam(name = "adapterVersion", value = "适配版本号")
                                  @RequestParam(value = "adapterVersion") String adapterVersion,
                                  @ApiParam(name = "id", value = "adapter_dataset_* 的id")
                                  @RequestParam(value = "id") Long id){
        return datasetService.isNeedRelation(adapterVersion, id);
    }
    @RequestMapping(value = "/getDataSets", method = RequestMethod.GET,produces="application/json;charset=UTF-8")
    @ApiOperation(value = "查询关联关系的dataset列表", response = Envelop.class,produces = "application/json", notes = "查询是否需要关联关系")
    public Envelop getDataSets(@ApiParam(name = "adapterVersion", value = "适配版本号")
                               @RequestParam(value = "adapterVersion") String adapterVersion,
                               @ApiParam(name = "id", value = "adapter_dataset_* 的id")
                               @RequestParam(value = "id") Long id,
                               @ApiParam(name = "sourceVersion", value = "源标准version")
                               @RequestParam(value = "sourceVersion") String sourceVersion,
                               @ApiParam(name = "page", value = "页码")
                               @RequestParam(value = "page",required = false) Integer page,
                               @ApiParam(name = "rows", value = "每页条数")
                               @RequestParam(value = "rows",required = false) Integer rows,
                               @ApiParam(name = "filterCodeOrName", value = "根据code或者name条件查询")
                               @RequestParam(value = "filterCodeOrName",required = false) String filterCodeOrName) throws IOException {
        return datasetService.getDataSets(adapterVersion, id,sourceVersion,page,rows,filterCodeOrName);
    }
    /**
     * 单个数据集智能匹配
     */
    @RequestMapping(value = "/smartMatchMedata", method = RequestMethod.GET,produces = "application/json")
    @ApiOperation(value = "单个字典智能匹配", response = Envelop.class, produces = "application/json", notes = "单个字典智能匹配")
    public Envelop smartMatchMedata(
            @ApiParam(value = "源version", required = true) @RequestParam("std_version") String std_version,
            @ApiParam(value = "适配方案版本号", required = true) @RequestParam("adapter_version") String adapter_version,
            @ApiParam(value = "适配表的id(目标的id)", required = true) @RequestParam("id") Long id,
            @ApiParam(value = "适配表的adapterDataSetId(源的stdDatasetId)", required = true) @RequestParam("adapterDataSetId") Long adapterDataSetId) throws Exception {
        return datasetService.smartMatchMedata(std_version,adapter_version,id,adapterDataSetId);
    }
}

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

@@ -7,6 +7,8 @@ import com.yihu.jw.basic.standard.service.bo.AdapterVersion;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
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;
@@ -79,8 +81,8 @@ public class AdapterMetadataController extends EnvelopRestEndpoint {
            @ApiParam(name = "adapterVersion", value = "标准版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "list", value = "数据元列表")
            @RequestParam(value = "list") String list) {
        return metadataService.updateMetadatas(adapterVersion, list);
            @RequestParam(value = "list") String list,String stdVersion) {
        return metadataService.updateMetadatas(adapterVersion,stdVersion, list);
    }
    @PostMapping("/delMetadata")
@@ -112,12 +114,12 @@ public class AdapterMetadataController extends EnvelopRestEndpoint {
    @RequestMapping(value = "/strategy", method = RequestMethod.POST)
    @ApiOperation(value = "智能匹配", produces = "application/json", notes = "智能匹配")
    @ApiOperation(value = "智能匹配", response = Object.class, produces = "application/json", notes = "智能匹配")
    public Envelop strategy(
            @ApiParam(value = "匹配version", required = true) @RequestParam("version") String version,
            @ApiParam(value = "平台标准version", required = true) @RequestParam("std_version") String std_version,
            @ApiParam(value = "适配方案版本号", required = true) @RequestParam("adapter_std_version") String adapter_std_version
    ) {
    ) throws Exception {
        try {
            //判断之前是否已经在匹配,有的话不进行匹配
            synchronized (MetadataStrategyExecute.class) {
@@ -128,7 +130,9 @@ public class AdapterMetadataController extends EnvelopRestEndpoint {
                    return Envelop.getSuccess("操作成功");
                }
            }
            adapterDatasetService.strategy(version,std_version,adapter_std_version);
            String schemaName = LocalContext.getContext().getAttachment(ContextAttributes.SCHEMA);
            adapterDatasetService.strategy(schemaName,version, std_version, adapter_std_version);
        } catch (Exception e) {
            e.printStackTrace();
            return Envelop.getError("操作失败",-1);

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

@@ -2,7 +2,6 @@ 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;
@@ -37,45 +36,39 @@ public class RuleController extends EnvelopRestEndpoint {
    @ApiOperation(value = "新增质控规则信息")
    @RequestMapping("addRule")
    public Result addRule(HttpServletRequest request) {
    public Envelop 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());
            return failed(ex.getMessage());
        }
    }
    /**
     * 删除质控规则信息
     *
     * @param request
     * @return
     */
    @RequestMapping("/deleteRule")
    public Result deleteRule(HttpServletRequest request) {
    public Envelop deleteRule(HttpServletRequest request) {
        try {
            String id = request.getParameter("id");
            ruleService.deleteRule(id);
            return Result.success("删除成功！");
            return success("删除成功！");
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("删除失败！");
            return failed("删除失败！");
        }
    }
    /**
     * 批量删除质控规则信息
     *
     * @param request
     * @return
     */
    @RequestMapping("/deleteRuleBatch")
    public Result deleteRuleBatch(HttpServletRequest request) {
    public Envelop deleteRuleBatch(HttpServletRequest request) {
        try {
            String idList = request.getParameter("idList");
            List<String> ids = Splitter.on(",").trimResults().splitToList(idList);
@@ -85,10 +78,10 @@ public class RuleController extends EnvelopRestEndpoint {
                    ruleService.deleteRule(id);
                }
            }
            return Result.success("删除成功！");
            return success("删除成功！");
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("删除失败！");
            return failed("删除失败！");
        }
    }
@@ -96,7 +89,7 @@ public class RuleController extends EnvelopRestEndpoint {
     * 修改质控规则信息
     */
    @RequestMapping("updateRule")
    public Result updateRule(HttpServletRequest request) {
    public Envelop updateRule(HttpServletRequest request) {
        try {
            RuleModel obj = new RuleModel();
            BeanUtils.populate(obj, request.getParameterMap());
@@ -104,7 +97,7 @@ public class RuleController extends EnvelopRestEndpoint {
            return ruleService.updateRule(obj);
        } catch (Exception ex) {
            ex.printStackTrace();
            return Result.error(ex.getMessage());
            return failed(ex.getMessage());
        }
    }

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

@@ -326,7 +326,6 @@ public class StdCdaController extends EnvelopRestEndpoint {
            BaseCDADocument cdaDocument = (BaseCDADocument) cdaDocumentService.get(BaseCDADocument.class, versionCode, StandardVersion.CDADocumentTable, cdaId);
            if (cdaDocument != null) {
                strFileGroup = cdaDocument.getFileGroup();
                strSchemePath = cdaDocument.getSchema();

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

@@ -8,5 +8,6 @@ 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 ,Long id);
    public StdDataSetModel getDatasetName(String schemaName, String version, Long id);
}

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

@@ -9,5 +9,6 @@ import java.util.List;
 * Created by Administrator on 2016/5/4.
 */
public interface IStdMetaDataModelDao extends XSQLGeneralDAO {
    List<StdMetaDataModel> getMetadata(String adapter_std_version, String orgMetadataName,String orgDatasetName);
    List<StdMetaDataModel> getMetadata(String schemaName, String adapter_std_version, String orgMetadataName, String orgDatasetName);
}

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

@@ -1,7 +1,7 @@
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 com.yihu.jw.restmodel.web.Envelop;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.Restrictions;
@@ -20,7 +20,7 @@ import java.util.Map;
public class RuleDao extends SQLGeneralDAO {
    public static final String BEAN_ID = "ruleDao";
    public Result getRuleList(Map<String, Object> params) throws Exception {
    public Envelop 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)) {

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

@@ -3,11 +3,10 @@ package com.yihu.jw.basic.standard.dao;
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.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.PageEnvelop;
import com.yihu.jw.util.common.NumberUtil;
import com.yihu.jw.util.common.StringUtil;
import com.yihu.jw.util.sql.SqlCreator;
@@ -27,7 +26,6 @@ import org.springframework.jdbc.core.RowMapper;
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;
@@ -67,41 +65,29 @@ public class SQLGeneralDAO implements XSQLGeneralDAO {
        return entityManager.unwrap(Session.class);
    }
    public DataGridResult getDataGridResult(String hql, Integer page, Integer rows) {
        DataGridResult dataGridResult = new DataGridResult();
    public Envelop getDataGridResult(String hql, Integer page, Integer rows) {
        Query query = currentSession().createQuery(hql);
        if (page != null && rows != null) {
            dataGridResult.setPageSize(rows);
            dataGridResult.setCurrPage(page);
            dataGridResult.setTotalCount(query.list().size());
            long count = query.list().size();
            query.setMaxResults(rows);
            query.setFirstResult((page - 1) * rows);
            dataGridResult.setDetailModelList(query.list());
            return PageEnvelop.getSuccessListWithPage("查询成功",query.list(),page,rows,count);
        } else {
            List list = query.list();
            dataGridResult.setDetailModelList(list);
            dataGridResult.setTotalCount(list.size());
            return PageEnvelop.getSuccessListWithPage("查询成功",list,page,rows,(long)list.size());
        }
        return dataGridResult;
    }
    public DataGridResult getDataGridResult(Query query, Integer page, Integer rows) {
        DataGridResult dataGridResult = new DataGridResult();
    public Envelop getDataGridResult(Query query, Integer page, Integer rows) {
        if (page != null && rows != null) {
            dataGridResult.setPageSize(rows);
            dataGridResult.setCurrPage(page);
            dataGridResult.setTotalCount(query.list().size());
            long count = query.list().size();
            query.setMaxResults(rows);
            query.setFirstResult((page - 1) * rows);
            dataGridResult.setDetailModelList(query.list());
            return PageEnvelop.getSuccessListWithPage("查询成功",query.list(),page,rows,count);
        } else {
            List list = query.list();
            dataGridResult.setDetailModelList(list);
            dataGridResult.setTotalCount(list.size());
            return PageEnvelop.getSuccessListWithPage("查询成功",list,page,rows,(long)list.size());
        }
        return dataGridResult;
    }
    public boolean delete(Class tclass, Object[] ids, String dataType, String version) {
@@ -427,7 +413,7 @@ public class SQLGeneralDAO implements XSQLGeneralDAO {
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Result.error("获取标准数据元失败");
        return Envelop.getError("获取标准数据元失败");
    }
    public Query getQuery(SqlCreator sqlCreator, String sql) {

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

@@ -15,12 +15,15 @@ import org.springframework.stereotype.Repository;
@CacheConfig(cacheNames = "StdDataSetModelCache")
public class StdDataSetModelDao extends SQLGeneralDAO implements IStdDataSetModelDao {
    @Override
    @Cacheable
    public StdDataSetModel getDatasetName(String version ,Long id){
    public StdDataSetModel getDatasetName(String schemaName,String version ,Long id){
        StringBuffer sql = new StringBuffer();
        sql.append("SELECT d.*").append(" FROM std_dataset_").append(version).append(" d where d.id ="+id);
        String myCatAnnotation = "/*#mycat:schema=" + schemaName + "*/ ";
        String completeSql = myCatAnnotation + sql;
        try {
            Query query = getCurrentSession().createSQLQuery(sql.toString());
            Query query = getCurrentSession().createSQLQuery(completeSql);
            query.setResultTransformer(new BeanTransformer(StdDataSetModel.class));
            StdDataSetModel stdDataSetModel =(StdDataSetModel) query.uniqueResult();
            return stdDataSetModel;

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

@@ -13,12 +13,16 @@ import java.util.List;
 */
@Repository("stdeMetadataDao")
public class StdMetaDataModelDao extends SQLGeneralDAO implements IStdMetaDataModelDao {
    public List<StdMetaDataModel> getMetadata(String adapter_std_version, String orgMetadataName,String orgDatasetName){
    public List<StdMetaDataModel> getMetadata(String schemaName,String adapter_std_version, String orgMetadataName,String orgDatasetName){
        StringBuffer sql = new StringBuffer();
        sql.append("SELECT m.*").append(" FROM std_metadata_"+adapter_std_version).append(" m inner join std_dataset_"+adapter_std_version )
                .append(" d on d.id= m.dataset_id where m.name like ? and d.name like ?");
        String myCatAnnotation = "/*#mycat:schema=" + schemaName + "*/ ";
        String completeSql = myCatAnnotation + sql;
        try {
            Query query = getCurrentSession().createSQLQuery(sql.toString());
            Query query = getCurrentSession().createSQLQuery(completeSql);
            query.setParameter(0,"%" + orgMetadataName + "%");
            query.setParameter(1,"%" + orgDatasetName + "%");
            query.setResultTransformer(new BeanTransformer(StdMetaDataModel.class));

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

@@ -1,6 +1,6 @@
package com.yihu.jw.basic.standard.dao;
import com.yihu.jw.basic.standard.model.DataGridResult;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.util.sql.SqlCreator;
import org.hibernate.Query;
import org.hibernate.Session;
@@ -34,7 +34,7 @@ public interface XSQLGeneralDAO {
    <T> T getEntity(Class<T> var1, Serializable var2) throws Exception;
    DataGridResult getDataGridResult(String var1, Integer var2, Integer var3) throws Exception;
    Envelop getDataGridResult(String var1, Integer var2, Integer var3) throws Exception;
    List<Map<String, Object>> queryListBySql(String var1) throws Exception;

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

@@ -18,8 +18,8 @@ import java.util.Map;
 */
public class MetadataStrategyExecute implements Runnable {
    private AdapterMetadataModel metadata;
    private MetadataMatchVO matchVO;
    private AdapterMetadataModel metadata;//待适配的数据元
    private MetadataMatchVO matchVO;//以往版本的适配缓存
    public static Map<String, List<Integer>> size = new HashMap<String, List<Integer>>();
    private String std_version;
    private String adapter_std_version;
@@ -28,8 +28,10 @@ public class MetadataStrategyExecute implements Runnable {
    private AdapterMetadataService adapterMetadataService;
    private MetatdataStandardNameStrategy standardNameStrategy;
    private IStdDataSetModelDao stdDataSetModelDao;
    private String schemaName;
    public MetadataStrategyExecute(
            String schemaName,
            AdapterMetadataModel metadata,
            MetadataMatchVO matchVO,
            String std_version,
@@ -45,15 +47,19 @@ public class MetadataStrategyExecute implements Runnable {
        this.version = version;
        this.adapterMetadataService = adapterMetadataService;
        this.stdDataSetModelDao = stdDataSetModelDao;
        this.schemaName = schemaName;
        //项目之间学习适配
        standardExistStrategy = new MetatdataStandardExistStrategy();
        standardExistStrategy.setStdMetaDataModelDao(stdMetaDataModelDao);
        standardExistStrategy.setAdapterMetadataService(adapterMetadataService);
        standardExistStrategy.setStdDataSetModelDao(stdDataSetModelDao);
        standardExistStrategy.setSchemaName(schemaName);
        standardNameStrategy = new MetatdataStandardNameStrategy();
        standardNameStrategy.setAdapterMetadataService(adapterMetadataService);
        standardNameStrategy.setStdDataSetModelDao(stdDataSetModelDao);
        standardNameStrategy.setSchemaName(schemaName);
    }
    @Override

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

@@ -1,20 +1,20 @@
package com.yihu.jw.basic.standard.match.metadata;
import com.yihu.jw.basic.standard.dao.IStdDataSetModelDao;
import com.yihu.jw.basic.standard.dao.IStdMetaDataModelDao;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.basic.standard.match.matchModel.MetadataMatchVO;
import com.yihu.jw.basic.standard.model.adapter.AdapterMetadataModel;
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.adapter.AdapterDatasetService;
import com.yihu.jw.basic.standard.service.adapter.AdapterMetadataService;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.basic.util.GetChineseFirst;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.List;
/**
@@ -28,6 +28,7 @@ public class MetatdataStandardExistStrategy extends SQLGeneralDAO {
    private AdapterMetadataService adapterMetadataService;
    private IStdDataSetModelDao stdDataSetModelDao;
    private AdapterDatasetService adapterDatasetService;
    private String schemaName;
    public AdapterDatasetService getAdapterDatasetService() {
        return adapterDatasetService;
@@ -65,6 +66,14 @@ public class MetatdataStandardExistStrategy extends SQLGeneralDAO {
        this.stdDataSetModelDao = stdDataSetModelDao;
    }
    public String getSchemaName() {
        return schemaName;
    }
    public void setSchemaName(String schemaName) {
        this.schemaName = schemaName;
    }
    public MetatdataStandardExistStrategy() {
    }
@@ -85,17 +94,17 @@ public class MetatdataStandardExistStrategy extends SQLGeneralDAO {
            if (adapterMetadatas != null && adapterMetadatas.size() > 0) {
                //获取待适配的数据集名
                Long unAdaptStdId = strategyMetadata.getStdDatasetId();
                StdDataSetModel stdDataset = stdDataSetModelDao.getDatasetName(std_version, unAdaptStdId);
                StdDataSetModel adapterDataset = stdDataSetModelDao.getDatasetName(adapter_std_version, unAdaptStdId);
                StdDataSetModel stdDataset = stdDataSetModelDao.getDatasetName(schemaName,std_version, unAdaptStdId);
                //StdDataSetModel adapterDataset = stdDataSetModelDao.getDatasetName(schemaName,adapter_std_version, unAdaptStdId);
                if(stdDataset!=null){
                    String stdDatasetName = stdDataset.getName();
                    List<String> sqlList = new ArrayList<String>();
                    //List<String> sqlList = new ArrayList<String>();
                    for (AdapterMetadataModel stdeMetadataTemp : adapterMetadatas) {
                        //利用名字來匹配
                        if (stdeMetadataTemp.getStdMetadataName().contains(strategyMetadata.getStdMetadataName())) {
                            String orgMetadataName = stdeMetadataTemp.getAdapterMetadataName();
                            //根据名字查找出 该项目下面的数据元名称
                            List<StdMetaDataModel> metadataTemps = stdMetaDataModelDao.getMetadata(adapter_std_version, orgMetadataName, stdDatasetName);
                            List<StdMetaDataModel> metadataTemps = stdMetaDataModelDao.getMetadata(schemaName,adapter_std_version, orgMetadataName, stdDatasetName);
                            if (metadataTemps != null && metadataTemps.size() > 0) {
                                String adapterInfo = "1";//找到默认为疑似适配
                                if (metadataTemps.size() == 1) {//找到条数为1,默认为完全适配
@@ -120,7 +129,7 @@ public class MetatdataStandardExistStrategy extends SQLGeneralDAO {
                }
//                if (adapterDataset != null) {
//                    adapterDatasetService = SpringBeanUtil.getService(AdapterDatasetService.BEAN_ID);
//                    AdapterDatasetModel entity = adapterDatasetService.getAdapterDatasetByCode(version, adapterDataset.getCode());
//                    AdapterDatasetModel entity = adapterDatasetService.getAdapterDatasetByCode(version, adapterDataset.getInnerCode());
//                    adapterDatasetService.saveAdaptDataset(entity,adapterDataset,version);
//                }
            }

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

@@ -1,5 +1,6 @@
package com.yihu.jw.basic.standard.match.metadata;
import com.yihu.jw.basic.standard.dao.IStdDataSetModelDao;
import com.yihu.jw.basic.standard.model.adapter.AdapterMetadataModel;
import com.yihu.jw.basic.standard.model.standard.StdDataSetModel;
@@ -20,23 +21,34 @@ import java.util.Map;
@Component("metatdataStandardNameStrategy")
public class MetatdataStandardNameStrategy {
    private static LikeHashMap<String, StdMetaDataModel> nameMap = new LikeHashMap<String, StdMetaDataModel>();//机构名称的map
    private static LikeHashMap<String, StdMetaDataModel> nameMap = new LikeHashMap<String, StdMetaDataModel>();//目标数据元缓存
    private static LikeHashMap<String, StdMetaDataModel> remarkMap = new LikeHashMap<String, StdMetaDataModel>();//机构remark的map
    private AdapterMetadataService adapterMetadataService;
    private IStdDataSetModelDao stdDataSetModelDao;
    public MetatdataStandardNameStrategy(AdapterMetadataService adapterMetadataService, IStdDataSetModelDao stdDataSetModelDao) {
    private String schemaName;
    public MetatdataStandardNameStrategy(AdapterMetadataService adapterMetadataService, IStdDataSetModelDao stdDataSetModelDao,String schemaName) {
        this.adapterMetadataService = adapterMetadataService;
        this.stdDataSetModelDao = stdDataSetModelDao;
        this.schemaName = schemaName;
    }
    public MetatdataStandardNameStrategy() {
    }
    public String getSchemaName() {
        return schemaName;
    }
    public void setSchemaName(String schemaName) {
        this.schemaName = schemaName;
    }
    public static Map<String, StdMetaDataModel> getRemarkMap() {
        return remarkMap;
    }
@@ -79,18 +91,19 @@ public class MetatdataStandardNameStrategy {
     */
    @Transactional
    public boolean match(AdapterMetadataModel metadata, String version, String std_version) throws Exception {
        StdDataSetModel stdDataset = stdDataSetModelDao.getDatasetName(std_version, metadata.getStdDatasetId());
        StdDataSetModel stdDataset = stdDataSetModelDao.getDatasetName(schemaName,std_version, metadata.getStdDatasetId());
        String name = metadata.getStdMetadataName();
        StdMetaDataModel orgStdeMetadata = nameMap.get(name + "_" + stdDataset.getCode(), true);
        StdMetaDataModel orgStdeMetadata = nameMap.get(name + "_" + stdDataset.getName(), true);
        if (orgStdeMetadata != null) {
            adapterMetadataService.saveAdapt(metadata, orgStdeMetadata, version, "2");
            adapterMetadataService.saveAdapt(schemaName,metadata, orgStdeMetadata, version, "1");
            return true;
        }
        orgStdeMetadata = remarkMap.get(name + "_" + stdDataset.getCode(), true);
        //根据数据元定义去匹配,匹配度低,浪费性能, 注释掉
        /*orgStdeMetadata = remarkMap.get(name + "_" + stdDataset.getName(), true);
        if (orgStdeMetadata != null) {
            adapterMetadataService.saveAdapt(metadata, orgStdeMetadata, version, "2");
            adapterMetadataService.saveAdapt(schemaName,metadata, orgStdeMetadata, version, "2");
            return true;
        }
        }*/
        return false;
    }
}

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

@@ -8,7 +8,7 @@ import java.io.Serializable;
 * @version 1.0
 * @created 01-9月-2015 17:08:41
 */
public class BaseCDADataSetRelationship extends Result implements Serializable {
public class BaseCDADataSetRelationship implements Serializable {
    @Id
    @Column(name = "id", unique = true, nullable = false)

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

@@ -1,11 +1,9 @@
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;
@@ -16,7 +14,7 @@ import java.util.Objects;
 * @version 1.0
 * @created 01-9月-2015 16:54:17
 */
public class BaseCDADocument extends Result implements Serializable {
public class BaseCDADocument implements Serializable {
    @Transient
//    @Value("${admin-region}")
    short adminRegion;

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

@@ -1,124 +0,0 @@
package com.yihu.jw.basic.standard.model;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.io.Serializable;
import java.util.List;
/**
 * 列表对象
 */
public class DataGridResult extends Result implements Serializable {
    private static final Logger logger = LoggerFactory.getLogger(DataGridResult.class);
    private int pageSize = 10;
    private int currPage = 1;
    private int totalPage;
    private int totalCount;
    private List detailModelList;
    public DataGridResult() {
    }
    public DataGridResult(int pageSize, int currPage) {
        this.pageSize = pageSize;
        this.currPage = currPage;
    }
    /**
     * Json�ַ���תʵ��
     *
     * @return
     */
    public static DataGridResult fromJson(String json) {
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            return objectMapper.readValue(json, DataGridResult.class);
        } catch (IOException e) {
            logger.error(e.getMessage());
        }
        return null;
    }
    public String toJson() {
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            return objectMapper.writeValueAsString(this);
        } catch (JsonProcessingException e) {
            logger.error(e.getMessage());
            return "";
        }
    }
    public int getPageSize() {
        return pageSize;
    }
    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }
    public int getCurrPage() {
        return currPage;
    }
    public void setCurrPage(int currPage) {
        this.currPage = currPage;
    }
    public int getTotalPage() {
        if (totalCount % pageSize == 0) {
            totalPage = totalCount / pageSize;
        } else {
            totalPage = totalCount / pageSize + 1;
        }
        return totalPage;
    }
    public void setTotalPage(int totalPage) {
        this.totalPage = totalPage;
    }
    public int getStart() {
        if (currPage != 0) {
            return (currPage - 1) * pageSize;
        }
        return 0;
    }
    public int getEnd() {
        if (currPage != 0) {
            return currPage * pageSize;
        }
        return 0;
    }
    public int getTotalCount() {
        if (totalCount == 0 && detailModelList != null) {
            totalCount = detailModelList.size();
        }
        return totalCount;
    }
    public void setTotalCount(int totalCount) {
        this.totalCount = totalCount;
    }
    public List getDetailModelList() {
        return detailModelList;
    }
    public void setDetailModelList(List detailModelList) {
        this.detailModelList = detailModelList;
    }
}

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

@@ -1,72 +0,0 @@
package com.yihu.jw.basic.standard.model;
import java.lang.reflect.Field;
/**
 * Created by chenweida on 2015/12/11.
 * 基础对象
 */
public class Result {
    protected boolean successFlg = true;
    protected String message;
    protected int errorCode;
    public boolean isSuccessFlg() {
        return successFlg;
    }
    public void setSuccessFlg(boolean successFlg) {
        this.successFlg = successFlg;
    }
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
    public int getErrorCode() {
        return errorCode;
    }
    public void setErrorCode(int errorCode) {
        this.errorCode = errorCode;
    }
    /**
     * 错误消息
     */
    public static Result error(String message) {
        Result re= new Result();
        re.successFlg = false;
        re.message = message;
        return re;
    }
    /**
     * 成功消息
     */
    public static Result success(String message) {
        Result re= new Result();
        re.successFlg = true;
        re.message = message;
        return re;
    }
    public void checkValue() {
        try {
            Field[] fields = this.getClass().getDeclaredFields();
            for (int j = 0; j < fields.length; j++) {
                fields[j].setAccessible(true);
                if (fields[j].getType().getName().equals(String.class.getTypeName())
                        && fields[j].get(this) == null){
                    fields[j].set(this, "");//设置为空字串
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

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

@@ -1,6 +1,5 @@
package com.yihu.jw.basic.standard.model.adapter;
import com.yihu.jw.basic.standard.model.Result;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
@@ -12,7 +11,7 @@ import java.io.Serializable;
/**
 * Created by lingfeng on 2015/9/16.
 */
public class AdapterDatasetModel extends Result implements Serializable {
public class AdapterDatasetModel  implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
@@ -40,13 +39,6 @@ public class AdapterDatasetModel extends Result implements Serializable {
    @Column(name="need_crawer")
    private Integer needCrawer;//0不需要采集   1需要采集(默认)
    public static AdapterDatasetModel error(String message) {
        AdapterDatasetModel re= new AdapterDatasetModel();
        re.successFlg = false;
        re.message = message;
        return re;
    }
    public Long getId() {
        return id;
    }

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

@@ -1,7 +1,5 @@
package com.yihu.jw.basic.standard.model.adapter;
import com.yihu.jw.basic.standard.model.Result;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
@@ -12,7 +10,7 @@ import java.io.Serializable;
/**
 * Created by lingfeng on 2015/9/16.
 */
public class AdapterDatasetRelationModel extends Result implements Serializable {
public class AdapterDatasetRelationModel implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")

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

@@ -1,7 +1,5 @@
package com.yihu.jw.basic.standard.model.adapter;
import com.yihu.jw.basic.standard.model.Result;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
@@ -12,7 +10,7 @@ import java.io.Serializable;
/**
 * Created by lingfeng on 2015/9/16.
 */
public class AdapterDictEntryModel extends Result implements Serializable {
public class AdapterDictEntryModel implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")

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

@@ -1,7 +1,5 @@
package com.yihu.jw.basic.standard.model.adapter;
import com.yihu.jw.basic.standard.model.Result;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
@@ -12,7 +10,7 @@ import java.io.Serializable;
/**
 * Created by lingfeng on 2015/9/16.
 */
public class AdapterDictModel extends Result implements Serializable {
public class AdapterDictModel implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")

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

@@ -1,7 +1,5 @@
package com.yihu.jw.basic.standard.model.adapter;
import com.yihu.jw.basic.standard.model.Result;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
@@ -12,7 +10,7 @@ import java.io.Serializable;
/**
 * Created by lingfeng on 2015/9/16.
 */
public class AdapterMetadataModel extends Result implements Serializable {
public class AdapterMetadataModel implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")

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

@@ -1,6 +1,5 @@
package com.yihu.jw.basic.standard.model.adapter;
import com.yihu.jw.basic.standard.model.Result;
import java.io.Serializable;
@@ -9,7 +8,7 @@ import java.io.Serializable;
 *
 * @Created by lingfeng 2015/12/23.
 */
public class AdapterSchemeDispatchModel extends Result implements Serializable {
public class AdapterSchemeDispatchModel implements Serializable {
    private Long id;
    private Long schemeId;

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

@@ -1,7 +1,5 @@
package com.yihu.jw.basic.standard.model.adapter;
import com.yihu.jw.basic.standard.model.Result;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.*;
import java.io.Serializable;
@@ -13,7 +11,7 @@ import java.io.Serializable;
 */
@Entity
@Table(name = "adapter_scheme")
public class AdapterSchemeModel extends Result implements Serializable {
public class AdapterSchemeModel implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)

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

@@ -1,6 +1,5 @@
package com.yihu.jw.basic.standard.model.adapter;
import com.yihu.jw.basic.standard.model.Result;
import javax.persistence.*;
import java.io.Serializable;
@@ -13,7 +12,7 @@ import java.util.Date;
 */
@Entity
@Table(name = "adapter_scheme_version")
public class AdapterSchemeVersionModel extends Result implements Serializable {
public class AdapterSchemeVersionModel implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

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

@@ -1,7 +1,6 @@
package com.yihu.jw.basic.standard.model.standard;
import com.yihu.jw.basic.standard.model.Result;
import javax.persistence.*;
import java.io.Serializable;
@@ -15,7 +14,7 @@ import java.util.Date;
@Entity
@Table(name = "std_version")
@Access(value = AccessType.PROPERTY)
public class STDVersion extends Result implements Serializable {
public class STDVersion implements Serializable {
    private Long id;
    private String version;

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

@@ -1,7 +1,5 @@
package com.yihu.jw.basic.standard.model.standard;
import com.yihu.jw.basic.standard.model.Result;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.*;
import java.io.Serializable;
@@ -11,9 +9,9 @@ import java.io.Serializable;
 *
 * @created Airhead 2015/12/23.
 */
public class StdCDACatalogModel extends Result implements Serializable {
public class StdCDACatalogModel implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;

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

@@ -1,9 +1,9 @@
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.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import java.io.Serializable;
@@ -12,9 +12,9 @@ import java.io.Serializable;
 *
 * @created Airhead 2015/12/23.
 */
public class StdCDADatasetModel extends Result implements Serializable {
public class StdCDADatasetModel implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;

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

@@ -1,18 +1,18 @@
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.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import java.io.Serializable;
/**
 * @created Airhead 2015/12/23.
 */
public class StdCDAModel extends Result implements Serializable {
public class StdCDAModel implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;

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

@@ -1,12 +1,7 @@
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.MappedSuperclass;
import javax.persistence.Transient;
import javax.persistence.*;
import java.io.Serializable;
import java.util.Objects;
@@ -15,9 +10,9 @@ import java.util.Objects;
 */
@MappedSuperclass
public class StdDataSetModel extends Result implements Serializable {
public class StdDataSetModel implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;

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

@@ -1,7 +1,5 @@
package com.yihu.jw.basic.standard.model.standard;
import com.yihu.jw.basic.standard.model.Result;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.*;
import java.io.Serializable;
@@ -11,11 +9,11 @@ import java.io.Serializable;
 *
 * @created Airhead 2015/12/23.
 */
public class StdDatasetCatalogModel extends Result implements Serializable {
public class StdDatasetCatalogModel implements Serializable {
    public static String TABLE_NAME = "STD_DATASET_CATALOG";
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;

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

@@ -1,6 +1,5 @@
package com.yihu.jw.basic.standard.model.standard;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.*;

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

@@ -1,18 +1,18 @@
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.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import java.io.Serializable;
/**
 * @created Airhead 2015/12/23.
 */
public class StdDictionaryEntryModel extends Result implements Serializable {
public class StdDictionaryEntryModel implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;

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

@@ -1,9 +1,9 @@
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.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import java.io.Serializable;
@@ -12,9 +12,9 @@ import java.io.Serializable;
 *
 * @created Airhead 2015/12/23.
 */
public class StdDictionaryModel extends Result implements Serializable {
public class StdDictionaryModel  implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;

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

@@ -1,15 +1,14 @@
package com.yihu.jw.basic.standard.model.standard;
import com.yihu.jw.basic.standard.model.Result;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.*;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.util.Objects;
/**
 * Created by wq on 2015/9/22.
 */
public class StdMetaDataModel extends Result implements Serializable {
public class StdMetaDataModel implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
@@ -258,4 +257,19 @@ public class StdMetaDataModel extends Result implements Serializable {
        this.dataSetId = dataSetId;
    }
    public void checkValue() {
        try {
            Field[] fields = this.getClass().getDeclaredFields();
            for (int j = 0; j < fields.length; j++) {
                fields[j].setAccessible(true);
                if (fields[j].getType().getName().equals(String.class.getTypeName())
                        && fields[j].get(this) == null){
                    fields[j].set(this, "");//设置为空字串
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

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

@@ -1,11 +1,10 @@
package com.yihu.jw.basic.standard.model.standard.resultModel;
import com.yihu.jw.basic.standard.model.Result;
/**
 * Created by lingfeng on 2016/4/22.
 */
public class PublisherResultModel extends Result {
public class PublisherResultModel {
    String name;
    String code;

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

@@ -1,11 +1,10 @@
package com.yihu.jw.basic.standard.model.standard.resultModel;
import com.yihu.jw.basic.standard.model.Result;
/**
 * Created by lingfeng on 2016/4/22.
 */
public class StandardParamResultModel extends Result {
public class StandardParamResultModel  {
    String code;
    String orgCode;

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

@@ -4,6 +4,8 @@ package com.yihu.jw.basic.standard.service.adapter;
import com.fasterxml.jackson.databind.JsonNode;
import com.yihu.jw.basic.standard.model.adapter.AdapterDatasetRelationModel;
import com.yihu.jw.basic.standard.service.bo.AdapterVersion;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.util.sql.ErrorCode;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.exception.ApiException;
@@ -26,7 +28,7 @@ public class AdapterDatasetRelationService extends SQLGeneralDAO {
        super.finalize();
    }
    public AdapterDatasetRelationModel add(String adapterVersion, String datasetRelation) {
    public Envelop add(String adapterVersion, String datasetRelation) {
        try {
            AdapterVersion version = new AdapterVersion(adapterVersion);
            AdapterDatasetRelationModel adapterDatasetRelationModel = objectMapper.readValue(datasetRelation, AdapterDatasetRelationModel.class);
@@ -41,10 +43,9 @@ public class AdapterDatasetRelationService extends SQLGeneralDAO {
            sql = sqlCreator.insertData(version.getMetaDataTableName(), jsonNode);
            query = getExeuteQuery(sqlCreator, sql);
            query.executeUpdate();
            adapterDatasetRelationModel.setSuccessFlg(true);
            adapterDatasetRelationModel.setMessage("保存数据集关联成功");
            return adapterDatasetRelationModel;
            return ObjEnvelop.getSuccess("保存数据集关联成功",adapterDatasetRelationModel);
        } catch (Exception e) {
            e.printStackTrace();
            throw new ApiException(ErrorCode.SaveDatasetRelationFailed.getErrorCode());
        }
    }

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

@@ -19,6 +19,7 @@ import com.yihu.jw.basic.standard.service.bo.AdapterVersion;
import com.yihu.jw.basic.standard.service.bo.StandardVersion;
import com.yihu.jw.basic.standard.service.standard.StdMetadataService;
import com.yihu.jw.basic.util.GetChineseFirst;
import com.yihu.jw.basic.util.LikeHashMap;
import com.yihu.jw.lang.SpringContext;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.ListEnvelop;
@@ -28,10 +29,11 @@ import com.yihu.jw.util.common.StringUtil;
import com.yihu.jw.util.sql.ErrorCode;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.exception.ApiException;
import com.yihu.jw.basic.standard.model.Result;
import com.yihu.jw.util.sql.BeanTransformer;
import com.yihu.jw.util.sql.SqlConstants;
import com.yihu.jw.util.sql.SqlCreator;
import com.yihu.jw.util.thread.ContextAttributes;
import com.yihu.jw.util.thread.LocalContext;
import org.apache.commons.collections.CollectionUtils;
import org.hibernate.Query;
import org.hibernate.Session;
@@ -79,6 +81,23 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        super.finalize();
    }
    public ObjEnvelop add(String adapterVersion, AdapterDatasetModel adapterDatasetModel) {
        try {
            AdapterVersion version = new AdapterVersion(adapterVersion);
            long maxId = getMaxId(version.getDataSetTableName());
            adapterDatasetModel.setId( Long.valueOf(maxId));
            JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterDatasetModel));
            SqlCreator sqlCreator = new SqlCreator(AdapterDatasetModel.class);
            String sql = sqlCreator.insertData(version.getDataSetTableName(), jsonNode);
            Query query = getExeuteQuery(sqlCreator, sql);
            query.executeUpdate();
            return ObjEnvelop.getSuccess("保存适配数据集成功",adapterDatasetModel);
        } catch (Exception e) {
            e.printStackTrace();
            return ObjEnvelop.getError("保存适配数据集失败",-1);
        }
    }
    public ObjEnvelop add(String adapterVersion, String dataset) {
        try {
            AdapterVersion version = new AdapterVersion(adapterVersion);
@@ -408,6 +427,93 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        }
    }
    public Envelop cloneDataSet(String adapterVersion,String code) throws IOException {
        Envelop envelop = new Envelop();
        AdapterDatasetModel adapterDataset = null;
        List<AdapterDatasetModel> adapterDatasets = getAdapterDatasetByCode(adapterVersion, code);
        if (adapterDatasets != null && adapterDatasets.size()>0) {
            adapterDataset = adapterDatasets.get(0);
        }else{
            envelop.setStatus(-1);
            envelop.setMessage("数据集不存在");
            return envelop;
        }
        if(adapterDataset==null){
            envelop.setStatus(-1);
            envelop.setMessage("数据集不存在");
            return envelop;
        }
        AdapterDatasetModel clone_adapter_dataset = new AdapterDatasetModel();
        clone_adapter_dataset.setSchemeId(adapterDataset.getSchemeId());
        clone_adapter_dataset.setStdDatasetId(adapterDataset.getStdDatasetId());
        clone_adapter_dataset.setStdDatasetCode(adapterDataset.getStdDatasetCode());
        clone_adapter_dataset.setStdDatasetName(adapterDataset.getStdDatasetName());
        clone_adapter_dataset.setIsClone(1);
        clone_adapter_dataset.setNeedCrawer(1);
        ObjEnvelop add = add(adapterVersion, clone_adapter_dataset);
        if(add.getStatus()!=200){
            envelop.setStatus(-1);
            envelop.setMessage("数据集克隆失败");
            return envelop;
        }
        List<AdapterMetadataModel> adapterMetadatas = adapterMetadataService.searchPage(AdapterMetadataModel.class,"adapter_metadata",adapterVersion,"belongAdapterId="+adapterDataset.getStdDatasetId(),null,1,9999,false);
        if(adapterMetadatas==null){
            envelop.setStatus(-1);
            envelop.setMessage("数据元不存在");
            return envelop;
        }
        AdapterDatasetModel clone_dataset = (AdapterDatasetModel)add.getObj();
        List<String> sqls = new ArrayList<>();
        AdapterVersion version = new AdapterVersion(adapterVersion);
        String dictIds = "";
        for(AdapterMetadataModel medata:adapterMetadatas){
            AdapterMetadataModel adapterMetadataModel = new AdapterMetadataModel();
            adapterMetadataModel.setSchemeId(medata.getSchemeId());
            adapterMetadataModel.setStdDatasetId(medata.getStdDatasetId());
            adapterMetadataModel.setStdMetadataId(medata.getStdMetadataId());
            adapterMetadataModel.setStdMetadataCode(medata.getStdMetadataCode());
            adapterMetadataModel.setStdMetadataName(medata.getStdMetadataName());
            Long stdDictId = medata.getStdDictId();
            adapterMetadataModel.setStdDictId(stdDictId);
            if(stdDictId != null && stdDictId!=0){
                dictIds+=","+stdDictId;
            }
            adapterMetadataModel.setBelongAdapterId(clone_dataset.getId());
            adapterMetadataModel.setNeedCrawer(1);
            String sql = getInsertSql(version, adapterMetadataModel);
            sqls.add(sql);
        }
        if (sqls.size() > 0) {
            adapterMetadataService.insertBatch(sqls);
        }
        if(!StringUtils.isEmpty(dictIds)){
            jdbcTemplate.execute("update "+new AdapterVersion(adapterVersion).getDictTableName() +" set need_crawer=1 where id in ("+dictIds.substring(1,dictIds.length())+")");
        }
        envelop.setStatus(200);
        return envelop;
    }
    public String getInsertSql(AdapterVersion version, AdapterMetadataModel medata) throws IOException {
        SqlCreator sqlCreator = new SqlCreator(AdapterMetadataModel.class);
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(medata));
        String sql = sqlCreator.insertDataToSQL(version.getMetaDataTableName(), jsonNode);
        return sql;
    }
    public Envelop isNeedRelation(String adapterVersion, Long id) {
        Envelop envelop = new Envelop();
        AdapterVersion version = new AdapterVersion(adapterVersion);
        String sql = "select DISTINCT adapter_dataset_id from "+ version.getMetaDataTableName() +" where adapter_metadata_code is not null and adapter_dataset_id is not null and belong_adapter_id = ?";
        List<Long> adapterIds = jdbcTemplate.queryForList(sql,Long.class, id);
        if(adapterIds!=null&&adapterIds.size()>=2){
            envelop.setStatus(200);
        }else{
            envelop.setStatus(-1);
        }
        return envelop;
    }
    public Envelop updateCustomize(Long schemeId, String adapterVersion, String stdVersion, String datasetIdStr, String metaDataIdStr) {
        AdapterVersion aVersion = new AdapterVersion(adapterVersion);
        StandardVersion sVersion = new StandardVersion(stdVersion);
@@ -603,7 +709,18 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        }
    }
    public AdapterDatasetModel getAdapterDatasetByCode(String version, String datasetCode) {
    public List<AdapterDatasetModel> getAdapterDatasetByCode(String version, String datasetCode) {
        if (StringUtil.isEmpty(datasetCode)) {
            return null;
        }
        SqlCreator sqlCreator = new SqlCreator(AdapterDatasetModel.class);
        sqlCreator.equalCondition("stdDatasetCode", datasetCode);
        String sql = sqlCreator.selectData("adapter_dataset_" + version);
        Query query = getQuery(sqlCreator, sql);
        return query.list();
    }
    public AdapterDatasetModel getAdapterDatasetByCode(String schemaName, String version, String datasetCode) {
        try {
            if (StringUtil.isEmpty(datasetCode)) {
                return null;
@@ -611,13 +728,19 @@ public class AdapterDatasetService extends SQLGeneralDAO {
            SqlCreator sqlCreator = new SqlCreator(AdapterDatasetModel.class);
            sqlCreator.equalCondition("stdDatasetCode", datasetCode);
            String sql = sqlCreator.selectData("adapter_dataset_" + version);
            return jdbcTemplate.query(sql,new BeanPropertyRowMapper<>(AdapterDatasetModel.class)).get(0);
            String myCatAnnotation = "/*#mycat:schema=" + schemaName + "*/ ";
            String completeSql = myCatAnnotation + sql;
            Query query = getQuery(sqlCreator, completeSql);
            return (AdapterDatasetModel) query.uniqueResult();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    public List<AdapterDatasetModel> getAdapterDatasetByAdapterIdList(AdapterVersion adapterVersion, List<Integer> datasetIdList) {
        try {
            if (CollectionUtils.isEmpty(datasetIdList)) {
@@ -633,17 +756,17 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        }
    }
    public void strategy(String version,String std_version,String adapter_std_version) throws Exception {
        List<AdapterMetadataModel> unAdapterMetadataModels =  adapterMetadataService.getAllUnAdaptMetadata(version);//等待适配的标准数据元
    public void strategy(String schemaName,String version,String std_version,String adapter_std_version) throws Exception {
        List<AdapterMetadataModel> unAdapterMetadataModels =  adapterMetadataService.getAllUnAdaptMetadata(schemaName,version);//等待适配的标准数据元
        List<AdapterMetadataModel> adapterMetadataModel = new ArrayList<AdapterMetadataModel>();//之前已经适配好的适配方案
        //获取所有未匹配的
        //查找出  之前已经适配好的适配方案
        List<AdapterSchemeVersionModel> all = adapterSchemeVersionService.getAll();
        List<AdapterSchemeVersionModel> all = adapterSchemeVersionService.getAll(schemaName);
        if(all!=null){
            for(AdapterSchemeVersionModel adapterSchemeVersionModel:all){
                String vers = adapterSchemeVersionModel.getVersion();
                if(org.apache.commons.lang3.StringUtils.isNotBlank(vers)){
                    List<AdapterMetadataModel> adaptMetadata = adapterMetadataService.getAllAdaptMetadata(adapterSchemeVersionModel.getVersion());
                    List<AdapterMetadataModel> adaptMetadata = adapterMetadataService.getAllAdaptMetadata(schemaName,adapterSchemeVersionModel.getVersion());
                    adapterMetadataModel.addAll(adaptMetadata);
                }
            }
@@ -652,12 +775,12 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        matchVO.setCodeAdapter(matchVO.geNameGroup(adapterMetadataModel));
        //設置匹配的机构数据緩存
        List<StdMetaDataModel> orgMetadatas = stdMetadataService.getList(adapter_std_version, null, null, null, null, null);//查找出机构所有的metadatas
        List<StdMetaDataModel> orgMetadatas = stdMetadataService.getList(schemaName,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(schemaName,adapter_std_version, stdMetadata.getDataSetId());
            if(null != stdDataset){
                MetatdataStandardNameStrategy.getNameMap().put(stdMetadata.getName() + "_" + stdDataset.getCode(),stdMetadata);
                MetatdataStandardNameStrategy.getRemarkMap().put(stdMetadata.getDefinition() + "_" + stdDataset.getCode(),stdMetadata);
                MetatdataStandardNameStrategy.getNameMap().put(stdMetadata.getName() + "_" + stdDataset.getName(),stdMetadata);
                //MetatdataStandardNameStrategy.getRemarkMap().put(stdMetadata.getDefinition() + "_" + stdDataset.getName(),stdMetadata);  //根据数据元定义去匹配,匹配度低,浪费性能, 注释掉
            }
        }
@@ -666,20 +789,20 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        Set<String> sqlList = new HashSet<String>();
        for (AdapterMetadataModel unAdapterMetadataModel : unAdapterMetadataModels) {
            threadPoolTaskExecutor.execute(new MetadataStrategyExecute(unAdapterMetadataModel, matchVO, std_version,adapter_std_version,version, stdMetaDataModelDao,stdDataSetModelDao,adapterMetadataService));
            threadPoolTaskExecutor.execute(new MetadataStrategyExecute(schemaName,unAdapterMetadataModel, matchVO, std_version,adapter_std_version,version, stdMetaDataModelDao,stdDataSetModelDao,adapterMetadataService));
            String metadataNameFirstCode = GetChineseFirst.cn2py(unAdapterMetadataModel.getStdMetadataName());//待匹配
            List<AdapterMetadataModel> adapterMetadatas = matchVO.getCodeAdapter().get(metadataNameFirstCode);//已存在
            if (adapterMetadatas != null && adapterMetadatas.size() > 0) {
                //获取待适配的数据集名
                Long unAdaptStdId = unAdapterMetadataModel.getStdDatasetId();
                StdDataSetModel adapterDataset = stdDataSetModelDao.getDatasetName(adapter_std_version, unAdaptStdId);
                StdDataSetModel adapterDataset = stdDataSetModelDao.getDatasetName(schemaName,adapter_std_version, unAdaptStdId);
                if (adapterDataset != null) {
                    adapterDatasetService = SpringContext.getService(AdapterDatasetService.BEAN_ID);
                    AdapterDatasetModel entity = adapterDatasetService.getAdapterDatasetByCode(version, adapterDataset.getCode());
                    AdapterDatasetModel entity = adapterDatasetService.getAdapterDatasetByCode(schemaName,version, adapterDataset.getCode());
                    String sqrSql = null;
                    if(null != entity){
                        sqrSql = adapterDatasetService.saveAdaptDatasetSql(entity, adapterDataset, version);
                        sqrSql = adapterDatasetService.saveAdaptDatasetSql(schemaName,entity, adapterDataset, version);
                    }
                    if(null != sqrSql && !"".equals(sqrSql)){
                        sqlList.add(sqrSql);
@@ -698,7 +821,6 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        }
    }
    public void saveAdaptDataset(AdapterDatasetModel strategyDataset,StdDataSetModel orgDataset,String version) throws Exception {
        if(null != strategyDataset){
            strategyDataset.setAdapterDatasetId(orgDataset.getId()+"");
@@ -712,13 +834,127 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        }
    }
    public String saveAdaptDatasetSql(AdapterDatasetModel strategyDataset,StdDataSetModel orgDataset,String version) throws Exception {
    @Transactional
    public String saveAdaptDatasetSql(String schemaName, AdapterDatasetModel strategyDataset, StdDataSetModel orgDataset, String version) throws Exception {
        StringBuilder sqlBuffer = new StringBuilder();
        sqlBuffer.append(SqlConstants.UPDATE + new AdapterVersion(version).getDataSetTableName() + SqlConstants.SET);
        sqlBuffer.append(" adapter_dataset_id = " + orgDataset.getId());
        sqlBuffer.append(",adapter_dataset_code = '" + orgDataset.getCode() + "'");
        sqlBuffer.append(",adapter_dataset_name = '" + orgDataset.getName() + "'");
        sqlBuffer.append(" where id=" + strategyDataset.getId());
        return sqlBuffer.toString();
        String myCatAnnotation = "/*#mycat:schema=" + schemaName + "*/ ";
        String completeSql = myCatAnnotation + sqlBuffer;
        return completeSql;
    }
    public Envelop deleteCloneDataSet(String adapterVersion, Long id) {
        Envelop envelop = new Envelop();
        AdapterVersion version = new AdapterVersion(adapterVersion);
        String dataSetTableName = version.getDataSetTableName();
        String metaDataTableName = version.getMetaDataTableName();
        String dictTableName = version.getDictTableName();
        //删除适配数据集
        jdbcTemplate.execute("delete from "+dataSetTableName +" where id="+id);
        //判断适配字典是否需要转成不需要采集状态
        List<Long> needCrawerIds = jdbcTemplate.queryForList("select DISTINCT  std_dict_id from " + metaDataTableName + " where std_dict_id is not null and std_dict_id!='' and need_crawer=1 and belong_adapter_id!="+id,Long.class);
        jdbcTemplate.execute("update "+ dictTableName +" set need_crawer=0");
        if(CollectionUtils.isNotEmpty(needCrawerIds)){
            String ids = "";
            for(Long _id:needCrawerIds){
                ids+=","+_id;
            }
            jdbcTemplate.execute("update "+dictTableName +" set need_crawer=1 where id in ("+ids.substring(1,ids.length())+")");
        }
        //删除适配的数据元
        jdbcTemplate.execute("delete from "+metaDataTableName +" where belong_adapter_id="+id);
        return Envelop.getSuccess("删除成功");
    }
    public Envelop getDataSets(String adapterVersion, Long id,String sourceVersion,Integer page,Integer rows ,String filterCodeOrName)throws IOException {
        AdapterVersion version = new AdapterVersion(adapterVersion);
        String sql = "select DISTINCT adapter_dataset_id from "+ version.getMetaDataTableName() +" where adapter_metadata_code is not null and adapter_dataset_id is not null and belong_adapter_id = ?";
        List<Long> adapterIds = jdbcTemplate.queryForList(sql,Long.class, id);
        String ids="";
        if(!CollectionUtils.isEmpty(adapterIds)){
            for(Long adapterId:adapterIds){
                ids+=","+adapterId;
            }
        }
        if(!StringUtil.isEmpty(ids)){
            ids=ids.substring(1,ids.length());
        }else{
            ListEnvelop.getSuccess("查询成功",null);
        }
        String condition = "id=" + ids+";";
        if(!StringUtils.isEmpty(filterCodeOrName)){
            condition+="code?"+filterCodeOrName+" g1;name?"+filterCodeOrName+" g1";
        }
        List std_datasets = searchPage(StdDataSetModel.class, "std_dataset", sourceVersion, condition, null, page, rows,true);
        return ListEnvelop.getSuccess("查询成功",std_datasets);
    }
    public Envelop smartMatchMedata(String std_version, String adapter_version, Long id, Long adapterDataSetId) throws Exception {
        //获取等待适配的数据元
        List<AdapterMetadataModel> unAdapterMedataModels= adapterMetadataService.getUnAdaptMetadataByid(adapter_version,id);
        //获取源数据元
        Map<String, String> order = new HashMap<>();
        Map<String, Object> query = new HashMap<>();
        query.put("dataSetId",adapterDataSetId);
        StandardVersion standardVersion = new StandardVersion(std_version);
        List<StdMetaDataModel> medataList = stdMetadataService.getList(standardVersion, null, query, order, null, null);
        if(medataList!=null && medataList.size()>0){
            LikeHashMap<String, StdMetaDataModel> nameMap = new LikeHashMap<String, StdMetaDataModel>();
            for(StdMetaDataModel medata:medataList){
                String code = medata.getCode();
                if(!StringUtil.isEmpty(code)){
                    code = code.trim();
                }
                String name = medata.getName();
                if(!StringUtil.isEmpty(name)){
                    name = name.trim();
                }
                nameMap.put(code+"@"+name,medata);
            }
            if(unAdapterMedataModels!=null && unAdapterMedataModels.size()>0){
                String schemaName = LocalContext.getContext().getAttachment(ContextAttributes.SCHEMA);
                //查询到的匹配字典项
                StdMetaDataModel stdMetadaModel = null;
                for(AdapterMetadataModel model:unAdapterMedataModels){
                    //查询到的匹配字典项
                    StdMetaDataModel stdMetaDataModel = null;
                    String code = model.getStdMetadataCode();
                    if(!StringUtil.isEmpty(code)){
                        code = code.trim();
                    }
                    String name = model.getStdMetadataName();
                    if(!StringUtil.isEmpty(name)){
                        name = name.trim();
                    }
                    //通过name做适配
                    stdMetadaModel = nameMap.get("@" + name, true);
                    if (stdMetadaModel != null) {
                        adapterMetadataService.saveAdapt(schemaName,model, stdMetadaModel, adapter_version,"1");//只匹配字典项code ,为疑似匹配
                    }else{ //通过code做匹配
                        stdMetadaModel = nameMap.get(code+"@", true);
                        if(stdMetadaModel!=null){
                            adapterMetadataService.saveAdapt(schemaName,model, stdMetadaModel, adapter_version,"1");//只匹配字典项code ,为疑似匹配
                        }
                    }
                }
            }
        }
        AdapterVersion adapterVersion = new AdapterVersion(adapter_version);
        adapterMetadataService.changeDatasetRelation(adapterVersion,id,std_version);
        return Envelop.getSuccess("匹配成功");
    }
}

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

@@ -58,7 +58,6 @@ public class AdapterDictEntryService extends SQLGeneralDAO {
            sql = sqlCreator.insertData(version.getDictEntryTableName(), jsonNode);
            query = getExeuteQuery(sqlCreator, sql);
            query.executeUpdate();
            adapterDictEntryModel.setSuccessFlg(true);
            return ObjEnvelop.getSuccess("保存适配字典项成功",adapterDictEntryModel);
        } catch (Exception e) {
            return ObjEnvelop.getError("保存适配字典项失败");

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

@@ -81,8 +81,6 @@ public class AdapterDictService extends SQLGeneralDAO {
            sql = sqlCreator.insertData(version.getMetaDataTableName(), jsonNode);
            query = getExeuteQuery(sqlCreator, sql);
            query.executeUpdate();
            adapterDictModel.setSuccessFlg(true);
            adapterDictModel.setMessage("保存适配字典成功");
            return ObjEnvelop.getSuccess("保存适配字典成功",adapterDictModel);
        } catch (Exception e) {
           return ObjEnvelop.getError("保存适配字典失败");

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

@@ -1,8 +1,9 @@
package com.yihu.jw.basic.standard.service.adapter;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.basic.standard.model.adapter.AdapterDatasetModel;
import com.yihu.jw.basic.standard.model.adapter.AdapterMetadataModel;
import com.yihu.jw.basic.standard.model.adapter.AdapterSchemeModel;
@@ -12,24 +13,22 @@ 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.AdapterVersion;
import com.yihu.jw.basic.standard.service.bo.StandardVersion;
import com.yihu.jw.exception.ApiException;
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.util.common.StringUtil;
import com.yihu.jw.util.sql.ErrorCode;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.exception.ApiException;
import com.yihu.jw.util.sql.BeanTransformer;
import com.yihu.jw.util.sql.ErrorCode;
import com.yihu.jw.util.sql.SqlConstants;
import com.yihu.jw.util.sql.SqlCreator;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import java.io.IOException;
import java.util.*;
@@ -46,7 +45,7 @@ public class AdapterMetadataService extends SQLGeneralDAO {
        super.finalize();
    }
    public ObjEnvelop add(String adapterVersion, String metadata) throws Exception {
    public Envelop add(String adapterVersion, String metadata) throws Exception {
        try {
            AdapterVersion version = new AdapterVersion(adapterVersion);
            AdapterMetadataModel adapterMetadataModel = objectMapper.readValue(metadata, AdapterMetadataModel.class);
@@ -54,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 ? 1L : Long.parseLong(object.toString()) + 1);
            adapterMetadataModel.setId(object == null ? 1 : Long.parseLong(object.toString()) + 1);
            JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterMetadataModel));
            SqlCreator sqlCreator = new SqlCreator(AdapterMetadataModel.class);
@@ -63,7 +62,8 @@ public class AdapterMetadataService extends SQLGeneralDAO {
            query.executeUpdate();
            return ObjEnvelop.getSuccess("保存适配数据元成功",adapterMetadataModel);
        } catch (Exception e) {
            return ObjEnvelop.getError("保存适配数据元失败");
            e.printStackTrace();
            return Envelop.getError("保存适配数据元失败");
        }
    }
@@ -83,7 +83,7 @@ public class AdapterMetadataService extends SQLGeneralDAO {
        }
    }
    public ObjEnvelop modify(String adapterVersion, String metadata) throws Exception {
    public Envelop modify(String adapterVersion, String metadata) throws Exception {
        try {
            AdapterVersion version = new AdapterVersion(adapterVersion);
            AdapterMetadataModel adapterMetadataModel = objectMapper.readValue(metadata, AdapterMetadataModel.class);
@@ -95,31 +95,30 @@ public class AdapterMetadataService extends SQLGeneralDAO {
            query.executeUpdate();
            return ObjEnvelop.getSuccess("修改适配数据元成功",adapterMetadataModel);
        } catch (Exception e) {
           return ObjEnvelop.getError("修改适配数据元失败");
            e.printStackTrace();
            return Envelop.getError("修改适配数据元失败");
        }
    }
    public ObjEnvelop get(String version, Integer dictEntryId) {
    public Envelop get(String version, Integer dictEntryId) {
        try {
            AdapterVersion adapterVersion = new AdapterVersion(version);
            AdapterMetadataModel adapterMetadataModel = (AdapterMetadataModel) get(AdapterMetadataModel.class, adapterVersion.getDictTableName(), dictEntryId);
            return ObjEnvelop.getSuccess("获取适配数据元成功",adapterMetadataModel);
        } catch (Exception e) {
            return ObjEnvelop.getError("获取适配数据元失败");
            e.printStackTrace();
            return Envelop.getError("获取适配数据元失败");
        }
    }
    public PageEnvelop getDetailResult(String adapterVersion, String condition, String order, Integer rows, Integer page) {
    public Envelop getDetailResult(String adapterVersion, String condition, String order, Integer rows, Integer page) {
        try {
            List dictEntryList = getMetadataList(AdapterMetadataModel.class, adapterVersion, condition, order, rows, page);
            Integer count = getMetadataCount(AdapterMetadataModel.class, adapterVersion, condition);
            PageEnvelop result = PageEnvelop.getSuccess("获取适配数据元列表成功");
            result.setDetailModelList(dictEntryList);
            result.setTotalCount(count);
            return result;
            long count = getMetadataCount(AdapterMetadataModel.class, adapterVersion, condition);
            return PageEnvelop.getSuccessListWithPage("",dictEntryList,page,rows,count);
        } catch (Exception e) {
            e.printStackTrace();
            return PageEnvelop.getError("获取适配数据元列表失败");
            return Envelop.getError("获取适配数据元列表失败");
        }
    }
@@ -132,7 +131,17 @@ public class AdapterMetadataService extends SQLGeneralDAO {
            try {
                JsonNode jsonNode = objectMapper.readTree(condition);
                String name = jsonNode.get("name").asText();
                sqlCreator.equalCondition("stdDatasetId", jsonNode.get("stdDatasetId").asInt());
                if(jsonNode.get("stdDatasetId") != null){
                    sqlCreator.equalCondition("stdDatasetId", jsonNode.get("stdDatasetId").asInt());
                }
                JsonNode belongAdapterId = jsonNode.get("belongAdapterId");
                if(belongAdapterId!=null){
                    sqlCreator.equalCondition("belongAdapterId",belongAdapterId.asLong());
                }
                JsonNode needCrawerNode = jsonNode.get("needCrawer");
                if(needCrawerNode!=null){
                    sqlCreator.equalCondition("needCrawer",needCrawerNode.asLong());
                }
                sqlCreator.likeOrCondition("stdMetadataCode", "stdMetadataName", name);
            } catch (IOException e) {
                e.printStackTrace();
@@ -153,34 +162,33 @@ public class AdapterMetadataService extends SQLGeneralDAO {
        }
        String sql = sqlCreator.selectData(tableName);
        Query query = getQuery(sqlCreator, sql);
        if (limit != null) {
            if (offset != null &&offset>0) {
                sql += " limit "+(offset - 1) * limit+","+limit;
            }else {
                sql += " limit "+limit;
            query.setMaxResults(limit);
            if (offset != null) {
                query.setFirstResult((offset - 1) * limit);
            }
        }
        List<AdapterMetadataModel> modelList = jdbcTemplate.query(sql,new BeanPropertyRowMapper<>(AdapterMetadataModel.class));
        List<Long> idList = new ArrayList<>();
        List<AdapterMetadataModel> modelList = query.list();
        String ids = "";
        Map<Long, StdDataSetModel> stdDatasetModelMap = new HashMap<>();
        Long schemeId = null;
        for (AdapterMetadataModel model : modelList) {
            if (model.getAdapterDatasetId() != null) {
                schemeId = model.getSchemeId();
                idList.add(model.getAdapterDatasetId());
                ids+=","+model.getAdapterDatasetId();
            }
        }
        if (!CollectionUtils.isEmpty(idList)) {
        if (!StringUtil.isEmpty(ids)) {
            AdapterSchemeModel scheme = getEntity(AdapterSchemeModel.class, schemeId);
            StandardVersion standardVersion = new StandardVersion(scheme.getAdapterStdVersion());
            tableName = standardVersion.getDataSetTableName();
            sqlCreator = new SqlCreator(StdDataSetModel.class);
            sqlCreator.inCondition("id", idList);
            sqlCreator.inCondition("id", ids.substring(1, ids.length()));
            sql = sqlCreator.selectData(tableName);
            List<StdDataSetModel> stdDatasetModelList = jdbcTemplate.query(sql,new BeanPropertyRowMapper<>(StdDataSetModel.class));
            query = getQuery(sqlCreator, sql);
            List<StdDataSetModel> stdDatasetModelList = query.list();
            for (StdDataSetModel model : stdDatasetModelList) {
                stdDatasetModelMap.put(model.getId(), model);
            }
@@ -208,6 +216,8 @@ public class AdapterMetadataService extends SQLGeneralDAO {
                detailModel.setAdapterDatasetCode(stdDatasetModelMap.get(model.getAdapterDatasetId()).getCode());
                detailModel.setAdapterDatasetName(stdDatasetModelMap.get(model.getAdapterDatasetId()).getName());
            }
            detailModel.setBelongAdapterId(model.getBelongAdapterId());
            detailModel.setAdapterDefault(model.getAdapterDefault());
            detailModelList.add(detailModel);
        }
        return detailModelList;
@@ -222,6 +232,14 @@ public class AdapterMetadataService extends SQLGeneralDAO {
                JsonNode jsonNode = objectMapper.readTree(condition);
                String name = jsonNode.get("name").asText();
                sqlCreator.equalCondition("stdDatasetId", jsonNode.get("stdDatasetId").asInt());
                JsonNode belongAdapterId = jsonNode.get("belongAdapterId");
                if(belongAdapterId!=null){
                    sqlCreator.equalCondition("belongAdapterId",belongAdapterId .asLong());
                }
                JsonNode needCrawerNode = jsonNode.get("needCrawer");
                if(needCrawerNode!=null){
                    sqlCreator.equalCondition("needCrawer",needCrawerNode.asLong());
                }
                sqlCreator.likeOrCondition("stdMetadataCode", "stdMetadataName", name);
            } catch (IOException e) {
                e.printStackTrace();
@@ -229,12 +247,17 @@ public class AdapterMetadataService extends SQLGeneralDAO {
        }
        String sql = sqlCreator.countData(tableName);
        Integer count = jdbcTemplate.queryForObject(sql,Integer.class);
        Query query = getCurrentSession().createSQLQuery(sql);
        for (String key : sqlCreator.getKeyValueMap().keySet()) {
            query.setParameter(key, sqlCreator.getKeyValueMap().get(key));
        }
        Integer count = Integer.parseInt(StringUtil.toString(query.list().get(0)));
        return count;
    }
    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);
        AdapterVersion version = new AdapterVersion(adapterVersion);
        List<AdapterMetadataModel> metadataModelList = getList(AdapterMetadataModel.class, version.getMetaDataTableName(), condition, order, limit, offset);
        List<Long> idList = new ArrayList<>();
        Map<Long, StdMetaDataModel> stdMetaDataModelMap = new HashMap<>();
        Long schemeId = null;
@@ -252,7 +275,8 @@ public class AdapterMetadataService extends SQLGeneralDAO {
            SqlCreator sqlCreator = new SqlCreator(StdMetaDataModel.class);
            sqlCreator.inCondition("id", idList);
            String sql = sqlCreator.selectData(tableName);
            List<StdMetaDataModel> stdMetadataModelList = jdbcTemplate.query(sql,new BeanPropertyRowMapper<>(StdMetaDataModel.class));
            Query query = getQuery(sqlCreator, sql);
            List<StdMetaDataModel> stdMetadataModelList = query.list();
            for (StdMetaDataModel model : stdMetadataModelList) {
                stdMetaDataModelMap.put(model.getId(), model);
            }
@@ -285,15 +309,16 @@ public class AdapterMetadataService extends SQLGeneralDAO {
        return detailModelList;
    }
    public ListEnvelop updateMetadatas(String adapterVersion, String list) {
    public Envelop updateMetadatas(String adapterVersion,String stdVersion, String list) {
        try {
            AdapterVersion version = new AdapterVersion(adapterVersion);
            List<ApiMetadataResultDetailModel> adapterMetadataList = Arrays.asList(objectMapper.readValue(list, ApiMetadataResultDetailModel[].class));
            List<String> sqlList = new ArrayList<>();
            List<Long> idList = new ArrayList<>();
            Map<Long, ApiMetadataResultDetailModel> metadataResultMap = new HashMap<>();
            AdapterMetadataModel adapterMetadataModel = null;
            for (ApiMetadataResultDetailModel metadataModel : adapterMetadataList) {
                AdapterMetadataModel adapterMetadataModel = new AdapterMetadataModel();
                adapterMetadataModel = new AdapterMetadataModel();
                adapterMetadataModel.setId(metadataModel.getId());
                adapterMetadataModel.setSchemeId(metadataModel.getSchemeId());
                adapterMetadataModel.setAdapterDatasetId(metadataModel.getAdapterDatasetId());
@@ -309,8 +334,13 @@ public class AdapterMetadataService extends SQLGeneralDAO {
                adapterMetadataModel.setStdMetadataCode(metadataModel.getStdMetadataCode());
                adapterMetadataModel.setStdMetadataName(metadataModel.getStdMetadataName());
                adapterMetadataModel.setAdapterInfo(metadataModel.getAdapterInfo());
                adapterMetadataModel.setBelongAdapterId(metadataModel.getBelongAdapterId());
                adapterMetadataModel.setAdapterDefault(metadataModel.getAdapterDefault());
                adapterMetadataModel.setNeedCrawer(1);
                idList.add(metadataModel.getStdDatasetId());
                metadataResultMap.put(metadataModel.getStdDatasetId(), metadataModel);
                if (!StringUtil.isEmpty(metadataModel.getAdapterDatasetCode())){
                    metadataResultMap.put(metadataModel.getStdDatasetId(), metadataModel);
                }
                JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterMetadataModel));
                SqlCreator sqlCreator = new SqlCreator(AdapterMetadataModel.class);
                String sql = sqlCreator.updateDataByTableKey(version.getMetaDataTableName(), jsonNode);
@@ -318,31 +348,69 @@ public class AdapterMetadataService extends SQLGeneralDAO {
                Query query = getExeuteQuery(sqlCreator, sql);
                query.executeUpdate();
            }
            if (!CollectionUtils.isEmpty(idList)) {
                String tableName = version.getDataSetTableName();
                SqlCreator sqlCreator = new SqlCreator(AdapterDatasetModel.class);
                sqlCreator.inCondition("stdDatasetId", idList);
                String sql = sqlCreator.selectData(tableName);
                List<AdapterDatasetModel> adapterDatasetModelList = jdbcTemplate.query(sql,new BeanPropertyRowMapper<>(AdapterDatasetModel.class));
                for (AdapterDatasetModel model : adapterDatasetModelList) {
                    ApiMetadataResultDetailModel metadataModel = metadataResultMap.get(model.getStdDatasetId());
                    model.setAdapterDatasetId(metadataModel.getAdapterDatasetId()+"");
                    model.setAdapterDatasetCode(metadataModel.getAdapterDatasetCode());
                    model.setAdapterDatasetName(metadataModel.getAdapterDatasetName());
                    JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(model));
                    sqlCreator = new SqlCreator(AdapterDatasetModel.class);
                    sql = sqlCreator.updateDataByTableKey(version.getDataSetTableName(), jsonNode);
                    sqlList.add(sql);
                    Query query = getExeuteQuery(sqlCreator, sql);
                    query.executeUpdate();
                }
            if(adapterMetadataModel!=null){
                //获取belongAdapterId
                Long belongAdapterId = adapterMetadataModel.getBelongAdapterId();
                changeDatasetRelation(version,belongAdapterId,stdVersion);
            }
            return ListEnvelop.getSuccess("修改适配数据元成功",adapterMetadataList);
        } catch (Exception e) {
            return ListEnvelop.getError("修改适配数据元失败");
            e.printStackTrace();
            return Envelop.getError("修改适配数据元失败");
        }
    }
    public void changeDatasetRelation(AdapterVersion version,Long belongAdapterId,String stdVersion){
        //获取匹配到的标准数据集id
        String sql = "select DISTINCT adapter_dataset_id from "+version.getMetaDataTableName() +" where belong_adapter_id=? and adapter_dataset_id is not null";
        List<Long> adapterDatasetIdList = jdbcTemplate.queryForList(sql,Long.class ,belongAdapterId);
        String adapterDatasetIds = "";
        String adapterDatasetCodes = "";
        String adapterDatasetNames = "";
        StandardVersion standardVersion = new StandardVersion(stdVersion);
        if(!CollectionUtils.isEmpty(adapterDatasetIdList)){
            String tableName = standardVersion.getDataSetTableName();
            SqlCreator sqlCreator = new SqlCreator(StdDataSetModel.class);
            String ids="";
            for(Long adapterDataset: adapterDatasetIdList){
                ids+=","+adapterDataset;
            }
            sqlCreator.inCondition("id", ids.substring(1,ids.length()));
            sql = sqlCreator.selectData(tableName);
            Query query = getQuery(sqlCreator, sql);
            List<StdDataSetModel> stdDataSetModelList = query.list();
            if(!CollectionUtils.isEmpty(stdDataSetModelList)){
                for(StdDataSetModel stdDataSetModel:stdDataSetModelList){
                    Long id = stdDataSetModel.getId();
                    String code = stdDataSetModel.getCode();
                    String name = stdDataSetModel.getName();
                    if(!"".equals(adapterDatasetIds)){
                        adapterDatasetIds+=","+id;
                    }else{
                        adapterDatasetIds=id+"";
                    }
                    if(!"".equals(adapterDatasetCodes)){
                        adapterDatasetCodes+=","+code;
                    }else{
                        adapterDatasetCodes=code;
                    }
                    if(!"".equals(adapterDatasetNames)){
                        adapterDatasetNames+=","+name;
                    }else{
                        adapterDatasetNames=name;
                    }
                }
            }
        }
        sql = SqlConstants.UPDATE + version.getDataSetTableName() + SqlConstants.SET+" " +
                "adapter_dataset_id='"+adapterDatasetIds+"',adapter_dataset_code='"+adapterDatasetCodes+"',adapter_dataset_name='"+adapterDatasetNames+
                "' where id="+belongAdapterId;
        jdbcTemplate.execute(sql);
    }
    public Envelop deleteMultiple(String adapterVersion, Integer metadataId, Integer stdDatasetId, Integer adapterDatasetId) {
        try {
            if (adapterVersion == null || adapterVersion.length() == 0) {
@@ -360,7 +428,8 @@ public class AdapterMetadataService extends SQLGeneralDAO {
            sqlCreator.equalCondition("stdDatasetId", stdDatasetId);
            sqlCreator.equalCondition("adapterDatasetId", adapterDatasetId);
            sql = sqlCreator.countData(version.getMetaDataTableName());
            Integer count = jdbcTemplate.queryForObject(sql,Integer.class);
            query = getExeuteQuery(sqlCreator, sql);
            Integer count = Integer.parseInt(StringUtil.toString(query.list().get(0)));
            if (count == 0) {
                sql = "delete from " + version.getDataSetTableName() + " where std_dataset_id = :stdDatasetId and adapter_dataset_id = :adapterDatasetId";
                query = session.createSQLQuery(sql);
@@ -374,7 +443,7 @@ public class AdapterMetadataService extends SQLGeneralDAO {
        }
    }
    public List getAdapterMetadataByDataset(String adapterVersion,Integer datasetId){
    public List getAdapterMetadataByDataset(String adapterVersion,Long datasetId){
        Map<String,Object> map = new HashMap<String,Object>();
        map.put("stdDatasetId", datasetId);
        String tableName="adapter_metadata_"+adapterVersion;
@@ -389,7 +458,7 @@ public class AdapterMetadataService extends SQLGeneralDAO {
    }
    public AdapterDatasetModel getAdapterDataset(String adapterVersion,Integer datasetId){
    public AdapterDatasetModel getAdapterDataset(String adapterVersion, Long datasetId){
        Map<String,Object> map = new HashMap<String,Object>();
        map.put("stdDatasetId", datasetId);
        String tableName="adapter_dataset_"+adapterVersion;
@@ -407,13 +476,14 @@ public class AdapterMetadataService extends SQLGeneralDAO {
            SqlCreator sqlCreator = new SqlCreator(AdapterMetadataModel.class);
            sqlCreator.equalCondition("id", adapterMetadataId);
            String sql = sqlCreator.selectData("adapter_metadata_"+version);
            return jdbcTemplate.query(sql,new BeanPropertyRowMapper<>(AdapterMetadataModel.class)).get(0);
            Query query = getQuery(sqlCreator, sql);
            return (AdapterMetadataModel)query.uniqueResult();
        } catch (Exception e) {
            return null;
        }
    }
    public List getAdapterMetadataNotNullList(AdapterVersion adapterVersion, Integer stdDatasetId, String condition) {
    public List getAdapterMetadataNotNullList(AdapterVersion adapterVersion, Long stdDatasetId, String condition) {
        try {
            StringBuffer sql = new StringBuffer();
            sql.append("SELECT * FROM ").append(adapterVersion.getMetaDataTableName());
@@ -442,6 +512,20 @@ public class AdapterMetadataService extends SQLGeneralDAO {
        return list;
    }
    public List<AdapterMetadataModel> getAllAdaptMetadata(String schemaName, String adapter_version){
        AdapterVersion adapterVersion = new AdapterVersion(adapter_version);
        StringBuffer sql = new StringBuffer();
        sql.append("SELECT m.*").append(" FROM "+adapterVersion.getMetaDataTableName()).append(" m where m.adapter_metadata_id is not null");
        String myCatAnnotation = "/*#mycat:schema=" + schemaName + "*/ ";
        String completeSql = myCatAnnotation + sql;
        Query query = getCurrentSession().createSQLQuery(completeSql);
        query.setResultTransformer(new BeanTransformer(AdapterMetadataModel.class));
        List<AdapterMetadataModel> list = query.list();
        return list;
    }
    public List<AdapterMetadataModel> getAllUnAdaptMetadata(String version){
        AdapterVersion adapterVersion = new AdapterVersion(version);
        StringBuffer sql = new StringBuffer();
@@ -452,10 +536,41 @@ public class AdapterMetadataService extends SQLGeneralDAO {
        return list;
    }
    public void saveAdapt(AdapterMetadataModel strategyMetadata,StdMetaDataModel orgMetadata,String version,String adapterInfo) throws Exception {
    public List<AdapterMetadataModel> getAllUnAdaptMetadata(String schemaName, String version){
        AdapterVersion adapterVersion = new AdapterVersion(version);
        StringBuffer sql = new StringBuffer();
        sql.append("SELECT m.*").append(" FROM "+adapterVersion.getMetaDataTableName()).append(" m where m.adapter_metadata_id is null");
        String myCatAnnotation = "/*#mycat:schema=" + schemaName + "*/ ";
        String completeSql = myCatAnnotation + sql;
        Query query1 = getCurrentSession().createSQLQuery(sql.toString());
        query1.setResultTransformer(new BeanTransformer(AdapterMetadataModel.class));
        List<AdapterMetadataModel> list1 = query1.list();
        Query query = getCurrentSession().createSQLQuery(completeSql);
        query.setResultTransformer(new BeanTransformer(AdapterMetadataModel.class));
        List<AdapterMetadataModel> list = query.list();
        return list;
    }
    public List<AdapterMetadataModel> getUnAdaptMetadataByid(String version, Long id){
        AdapterVersion adapterVersion = new AdapterVersion(version);
        StringBuffer sql = new StringBuffer();
        sql.append("SELECT m.*").append(" FROM "+adapterVersion.getMetaDataTableName()).append(" m where m.adapter_info =0 and m.belong_adapter_id="+id);
        Query query = getCurrentSession().createSQLQuery(sql.toString());
        query.setResultTransformer(new BeanTransformer(AdapterMetadataModel.class));
        List<AdapterMetadataModel> list = query.list();
        return list;
    }
    public void saveAdapt(AdapterMetadataModel strategyMetadata, StdMetaDataModel orgMetadata, String version, String adapterInfo) throws Exception {
        strategyMetadata.setAdapterDatasetId(orgMetadata.getDataSetId());
        strategyMetadata.setAdapterMetadataId(orgMetadata.getId());
        strategyMetadata.setAdapterMetadataCode(orgMetadata.getCode());
        strategyMetadata.setAdapterMetadataCode(orgMetadata.getInnerCode());
        strategyMetadata.setAdapterMetadataName(orgMetadata.getName());
        strategyMetadata.setAdapterInfo(adapterInfo);
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(strategyMetadata));
@@ -465,13 +580,30 @@ public class AdapterMetadataService extends SQLGeneralDAO {
        query.executeUpdate();
    }
    public String saveAdaptSql(AdapterMetadataModel strategyMetadata,StdMetaDataModel orgMetadata,String version,String adapterInfo) throws Exception {
    public void saveAdapt(String schemaName, AdapterMetadataModel strategyMetadata, StdMetaDataModel orgMetadata, String version, String adapterInfo) throws Exception {
        strategyMetadata.setAdapterDatasetId(orgMetadata.getDataSetId());
        strategyMetadata.setAdapterMetadataId(orgMetadata.getId());
        strategyMetadata.setAdapterMetadataCode(orgMetadata.getInnerCode());
        strategyMetadata.setAdapterMetadataName(orgMetadata.getName());
        strategyMetadata.setAdapterInfo(adapterInfo);
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(strategyMetadata));
        SqlCreator sqlCreator = new SqlCreator(AdapterMetadataModel.class);
        String sql = sqlCreator.updateDataByTableKey(new AdapterVersion(version).getMetaDataTableName(), jsonNode);
        String myCatAnnotation = "/*#mycat:schema=" + schemaName + "*/ ";
        String completeSql = myCatAnnotation + sql;
        Query query = getExeuteQuery(sqlCreator, completeSql);
        query.executeUpdate();
    }
    public String saveAdaptSql(AdapterMetadataModel strategyMetadata, StdMetaDataModel orgMetadata, String version, String adapterInfo) throws Exception {
        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_metadata_id = " + orgMetadata.getId());
            sqlBuffer.append(",adapter_metadata_code = '" + orgMetadata.getCode() + "'");
            sqlBuffer.append(",adapter_metadata_code = '" + orgMetadata.getInnerCode() + "'");
            sqlBuffer.append(",adapter_metadata_name = '" + orgMetadata.getName() + "'");
            if(null != adapterInfo){
                sqlBuffer.append(",adapter_info = " + adapterInfo);
@@ -484,4 +616,29 @@ public class AdapterMetadataService extends SQLGeneralDAO {
    public void insertBatch(final List<String> insertSqlList) {
        super.insertBatch(insertSqlList);
    }
    public Envelop clearAdapt(String adapterVersion, Long stdDatasetId, Long belongAdapterId) {
        Envelop envelop = new Envelop();
        //数据元可能数量比较多--->>使用原生sql提高清空数据元适配效率
        StringBuilder sqlBuffer = new StringBuilder();
        AdapterVersion version = new AdapterVersion(adapterVersion);
        String metaDataTableName = version.getMetaDataTableName();
        //清空数据元适配
        sqlBuffer.append(SqlConstants.UPDATE + metaDataTableName + SqlConstants.SET );
        sqlBuffer.append(" adapter_dataset_id = null , adapter_metadata_id = null , adapter_metadata_code = null ," +
                "adapter_metadata_name = null, adapter_data_type=0 ,adapter_dict_id=null ,adapter_info=0 ,adapter_default=null " +
                "where belong_adapter_id="+belongAdapterId+" and std_dataset_id="+stdDatasetId);
        jdbcTemplate.execute(sqlBuffer.toString());
        //清空数据集适配
        String dataSetTable = version.getDataSetTableName();
        String sql = SqlConstants.UPDATE + dataSetTable + SqlConstants.SET+" " +
                "adapter_dataset_id =null ,adapter_dataset_code =null,adapter_dataset_name=null " +
                "where id="+ belongAdapterId;
        jdbcTemplate.execute(sql);
        envelop.setStatus(200);
        return envelop;
    }
}

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

@@ -519,4 +519,16 @@ public class AdapterSchemeVersionService extends SQLGeneralDAO {
        List<AdapterSchemeVersionModel> list = query.list();
        return list;
    }
    public List<AdapterSchemeVersionModel> getAll(String schemaName){
        StringBuffer sql = new StringBuffer();
        sql.append("SELECT v.*").append(" FROM adapter_scheme_version v ");
        String myCatAnnotation = "/*#mycat:schema=" + schemaName + "*/ ";
        String completeSql = myCatAnnotation + sql;
        Query query = getCurrentSession().createSQLQuery(completeSql).addEntity(AdapterSchemeVersionModel.class);
        List<AdapterSchemeVersionModel> list = query.list();
        return list;
    }
}

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

@@ -14,6 +14,7 @@ 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.restmodel.web.Envelop;
import com.yihu.jw.util.sql.ErrorCode;
import org.hibernate.Query;
import org.hibernate.Session;
@@ -253,8 +254,8 @@ public class CDADataSetRelationshipManager extends SQLGeneralDAO {
        cdaDocument.setFileGroup(fileGroup);
        cdaDocument.setSchema(filePath);
        cdaDocument.setVersionCode(versionCode);
        Result result = cdaDocumentService.modify(versionCode, cdaDocument);
        return result.isSuccessFlg();
        Envelop result = cdaDocumentService.modify(versionCode, cdaDocument);
        return result.getStatus()==200;
    }
    public CDADocument saveCdaInfo(String cdaDocumentJsonData) throws Exception {

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

@@ -6,8 +6,9 @@ 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.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.util.sql.SqlCreator;
import com.yihu.jw.util.date.DateUtil;
import org.hibernate.Query;
@@ -39,7 +40,7 @@ public class CDADocumentService extends SQLGeneralDAO {
        }
    }
    public Result add(String adapterVersion, BaseCDADocument obj) throws IOException {
    public Envelop 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));
@@ -47,12 +48,10 @@ public class CDADocumentService extends SQLGeneralDAO {
        String sql = sqlCreator.insertData(version.getCDATableName(), jsonNode);
        Query query = getExeuteQuery(sqlCreator, sql);
        query.executeUpdate();
        obj.setSuccessFlg(true);
        obj.setMessage("保存成功");
        return obj;
        return ObjEnvelop.getSuccess("保存成功",obj);
    }
    public Result modify(String adapterVersion, BaseCDADocument obj) {
    public Envelop modify(String adapterVersion, BaseCDADocument obj) {
        try {
            StandardVersion version = new StandardVersion(adapterVersion);
            ObjectMapper mapper = new ObjectMapper();
@@ -62,11 +61,9 @@ public class CDADocumentService extends SQLGeneralDAO {
            String sql = sqlCreator.updateDataByTableKey(version.getCDATableName(), jsonNode);
            Query query = getExeuteQuery(sqlCreator, sql);
            query.executeUpdate();
            obj.setSuccessFlg(true);
            obj.setMessage("修改成功");
            return obj;
            return ObjEnvelop.getSuccess("修改成功",obj);
        } catch (Exception e) {
            return Result.error("修改失败");
            return Envelop.getError("修改失败");
        }
    }

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

@@ -6,7 +6,6 @@ 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;
@@ -15,12 +14,11 @@ 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 com.yihu.jw.restmodel.web.Envelop;
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;
@@ -53,7 +51,7 @@ public class RuleService {
    @Autowired
    private StdDatasetService stdDatasetService;
    public Result getRuleList(Map<String, Object> params) throws Exception {
    public Envelop getRuleList(Map<String, Object> params) throws Exception {
        return ruleDao.getRuleList(params);
    }
@@ -63,22 +61,22 @@ public class RuleService {
    }
    @Transactional
    public Result addRule(RuleModel obj) throws Exception {
    public Envelop addRule(RuleModel obj) throws Exception {
        ruleDao.saveEntity(obj);
        return Result.success("保存成功");
        return Envelop.getSuccess("保存成功");
    }
    @Transactional
    public Result updateRule(RuleModel obj) throws Exception {
    public Envelop updateRule(RuleModel obj) throws Exception {
        ruleDao.updateEntity(obj);
        return Result.success("更新成功");
        return Envelop.getSuccess("更新成功");
    }
    @Transactional
    public Result deleteRule(String id) throws Exception {
    public Envelop deleteRule(String id) throws Exception {
        RuleModel ruleModel = ruleDao.getEntity(RuleModel.class, id);
        ruleDao.deleteEntity(ruleModel);
        return Result.success("删除成功");
        return Envelop.getSuccess("删除成功");
    }

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

@@ -210,15 +210,15 @@ public class StandardService extends SQLGeneralDAO {
        if (systemParam != null) {
            StandardParamResultModel standardParamResultModel = new StandardParamResultModel();
            standardParamResultModel.setSuccessFlg(true);
            standardParamResultModel.setMessage("获取参数成功");
//            standardParamResultModel.setSuccessFlg(true);
//            standardParamResultModel.setMessage("获取参数成功");
            standardParamResultModel.setCode(systemParam.getParamValue());
            standardParamResultModel.setOrgCode(systemParam1.getParamValue());
            return standardParamResultModel;
        } else {
            StandardParamResultModel standardParamResultModel = new StandardParamResultModel();
            standardParamResultModel.setSuccessFlg(false);
            standardParamResultModel.setMessage("获取参数失败");
//            standardParamResultModel.setSuccessFlg(false);
//            standardParamResultModel.setMessage("获取参数失败");
            return standardParamResultModel;
        }
    }

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

@@ -45,6 +45,47 @@ public class StdMetadataService extends SQLGeneralDAO {
    public StdMetadataService() {
    }
    public List<StdMetaDataModel> getList(String schemaName, String stdVersion, Long datasetId, String condition, String order, Integer limit, Integer offset) {
        try {
            Map<String, Object> queryMap = RequestParamTransformer.parseJsonToMap(condition);
            Map<String, String> orderMap = RequestParamTransformer.parseJsonToMap(order);
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            return this.getList(schemaName,standardVersion, datasetId, queryMap, orderMap, limit, offset);
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardMetaDataGetListFailed.getErrorCode());
    }
    private List<StdMetaDataModel> getList(String schemaName,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);
        }
        for (String key : query.keySet()) {
            sqlCreator.equalCondition(key, query.get(key));
        }
        for (String key : order.keySet()) {
            sqlCreator.order(key, order.get(key));
        }
        String sql = sqlCreator.selectData(standardVersion.getMetaDataTableName());
        String myCatAnnotation = "/*#mycat:schema=" + schemaName + "*/ ";
        String completeSql = myCatAnnotation + sql;
        Query sessionQuery = getQuery(sqlCreator, completeSql);
        if (limit != null) {
            sessionQuery.setMaxResults(limit);
            if (offset != null) {
                sessionQuery.setFirstResult((offset - 1) * limit);
            }
        }
        return (List<StdMetaDataModel>) sessionQuery.list();
    }
    public List<StdMetaDataModel> getList(String stdVersion, Long datasetId, String condition, String order, Integer limit, Integer offset) {
        try {
@@ -190,7 +231,7 @@ public class StdMetadataService extends SQLGeneralDAO {
        query.executeUpdate();
    }
    private List<StdMetaDataModel> getList(StandardVersion standardVersion, Long datasetId, Map<String, Object> query, Map<String, String> order, Integer limit, Integer offset) {
    public 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);

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

@@ -98,8 +98,6 @@ public class StdPublisherService extends SQLGeneralDAO {
            PublisherResultModel publisherResultModel = new PublisherResultModel();
            publisherResultModel.setCode(systemOrganization.getCode());
            publisherResultModel.setName(systemOrganization.getFullName());
            publisherResultModel.setSuccessFlg(true);
            publisherResultModel.setMessage("获取机构信息成功");
            return ObjEnvelop.getSuccess("获取机构信息成功",publisherResultModel);
        } catch (Exception e) {
            e.printStackTrace();

svr/svr-basic/src/main/java/com/yihu/jw/basic/system/dao/DatasourceDao.java

@@ -1,9 +1,11 @@
package com.yihu.jw.basic.system.dao;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.basic.standard.model.DataGridResult;
import com.yihu.jw.basic.system.model.SystemDatasource;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.ListEnvelop;
import org.hibernate.Query;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.stereotype.Repository;
import org.springframework.util.StringUtils;
@@ -58,7 +60,7 @@ public class DatasourceDao extends SQLGeneralDAO {
     * @return
     */
    public DataGridResult getDatasource(Map<String, Object> conditionMap, Integer page, Integer pageSize) throws Exception
    public Envelop getDatasource(Map<String, Object> conditionMap, Integer page, Integer pageSize) throws Exception
    {
        StringBuilder sb = new StringBuilder();
        sb.append("from SystemDatasource t where 1=1 ");
@@ -86,18 +88,14 @@ public class DatasourceDao extends SQLGeneralDAO {
     * @return
     */
    public DataGridResult getDatasourceByOrg(String orgId) throws Exception
    public Envelop getDatasourceByOrg(String orgId) throws Exception
    {
        DataGridResult re = new DataGridResult();
        String sql = "select * from system_datasource";
        if(orgId!=null&&orgId.length()>0){
            sql += " where org_id ='"+orgId+"'";
        }
        List<SystemDatasource> list = super.queryListBySql(sql,SystemDatasource.class);
        re.setDetailModelList(list);
        return re;
        List<SystemDatasource> list = jdbcTemplate.query(sql,new BeanPropertyRowMapper<>(SystemDatasource.class));
        return ListEnvelop.getSuccess("查询成功",list);
    }
    /**

svr/svr-basic/src/main/java/com/yihu/jw/basic/system/dao/DictDao.java

@@ -1,8 +1,8 @@
package com.yihu.jw.basic.system.dao;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.basic.standard.model.Result;
import com.yihu.jw.basic.system.model.SystemDict;
import com.yihu.jw.restmodel.web.Envelop;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.stereotype.Repository;
import org.springframework.util.StringUtils;
@@ -19,7 +19,7 @@ public class DictDao extends SQLGeneralDAO {
    public static final String BEAN_ID = "dictDao";
   
    public Result getDictList(Map<String, Object> params) throws Exception {
    public Envelop getDictList(Map<String, Object> params) throws Exception {
        StringBuilder sb = new StringBuilder(" from SystemDict s where 1=1 ");
        if (!StringUtils.isEmpty(params.get("dictId"))) {
            sb.append(" and  (s.dictName = '" + params.get("dictId") +"')");

svr/svr-basic/src/main/java/com/yihu/jw/basic/system/dao/DictListDao.java

@@ -1,8 +1,8 @@
package com.yihu.jw.basic.system.dao;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.basic.standard.model.Result;
import com.yihu.jw.basic.system.model.SystemDictList;
import com.yihu.jw.restmodel.web.Envelop;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.stereotype.Repository;
import org.springframework.util.StringUtils;
@@ -18,7 +18,7 @@ public class DictListDao extends SQLGeneralDAO {
    public static final String BEAN_ID = "dictListDao";
    public Result getDictList(Map<String, Object> params) throws Exception {
    public Envelop getDictList(Map<String, Object> params) throws Exception {
        StringBuilder sb = new StringBuilder("from SystemDictList s where 1=1 ");
        if (!StringUtils.isEmpty(params.get("name"))) {
            sb.append(" and  s.chineseName like '%" + params.get("name") + "%' ");

svr/svr-basic/src/main/java/com/yihu/jw/basic/system/service/BaseDictManager.java

@@ -1,7 +1,6 @@
package com.yihu.jw.basic.system.service;
import com.yihu.jw.basic.standard.model.DataGridResult;
import com.yihu.jw.basic.system.dao.BaseDictDao;
import com.yihu.jw.basic.system.model.SystemDict;
import com.yihu.jw.basic.system.model.SystemDictList;