修改bug::数据元和字典自动适配时,退出登录后报错

src/main/java/com/yihu/hos/interceptor/AuditInterceptor.java

@@ -20,6 +20,11 @@ public class AuditInterceptor extends EmptyInterceptor {
    @Override
    public String onPrepareStatement(String sql) {
        if(null!=sql && sql.contains("mycat:schema=")){
            return super.onPrepareStatement(sql);
        }
        String schemaName = getSchema();
        String completeSql = sql;
        if (StringUtils.isNotEmpty(schemaName)) {

src/main/java/com/yihu/hos/standard/controller/AdapterDictController.java

@@ -1,5 +1,7 @@
package com.yihu.hos.standard.controller;
import com.yihu.hos.common.constants.ContextAttributes;
import com.yihu.hos.interceptor.LocalContext;
import com.yihu.hos.standard.match.dictionary.DictItemStrategyExecute;
import com.yihu.hos.standard.service.adapter.AdapterDictService;
import com.yihu.hos.web.framework.model.ActionResult;
@@ -87,6 +89,7 @@ public class AdapterDictController extends BaseController {
            @RequestParam(value = "dict") String dict) {
        return dictService.add(adapterVersion, dict);
    }
    @RequestMapping(value = "/isStrategyDic", method = RequestMethod.POST , produces = "application/json")
    @ResponseBody
    @ApiOperation(value = "是否智能匹配", response = Object.class, produces = "application/json", notes = "是否智能匹配")
@@ -128,7 +131,10 @@ public class AdapterDictController extends BaseController {
                    return actionResult;
                }
            }
            dictService.strategy(version,std_version,adapter_std_version);
            String schemaName = LocalContext.getContext().getAttachment(ContextAttributes.SCHEMA);
            dictService.strategy(schemaName,version,std_version,adapter_std_version);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error(e.getMessage());

src/main/java/com/yihu/hos/standard/controller/AdapterMetadataController.java

@@ -1,5 +1,7 @@
package com.yihu.hos.standard.controller;
import com.yihu.hos.common.constants.ContextAttributes;
import com.yihu.hos.interceptor.LocalContext;
import com.yihu.hos.standard.match.metadata.MetadataStrategyExecute;
import com.yihu.hos.standard.service.adapter.AdapterDatasetService;
import com.yihu.hos.standard.service.adapter.AdapterMetadataService;
@@ -148,7 +150,9 @@ public class AdapterMetadataController extends BaseController {
                    return actionResult;
                }
            }
            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 Result.error(e.getMessage());

src/main/java/com/yihu/hos/standard/dao/IStdDataSetModelDao.java

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

src/main/java/com/yihu/hos/standard/dao/IStdDictionaryEntryModelDao.java

@@ -10,5 +10,5 @@ import java.util.List;
 */
public interface IStdDictionaryEntryModelDao extends XSQLGeneralDAO {
    List<StdDictionaryEntryModel> getDictionaryEntry(String adapter_std_version, String orgDicEntryValue,String orgDicValue);
    List<StdDictionaryEntryModel> getDictionaryEntry(String schemaName,String adapter_std_version, String orgDicEntryValue,String orgDicValue);
}

src/main/java/com/yihu/hos/standard/dao/IStdDictionaryModelDao.java

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

src/main/java/com/yihu/hos/standard/dao/IStdMetaDataModelDao.java

@@ -9,5 +9,5 @@ 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);
}

src/main/java/com/yihu/hos/standard/dao/StdDataSetModelDao.java

@@ -16,11 +16,15 @@ import org.springframework.stereotype.Repository;
public class StdDataSetModelDao extends SQLGeneralDAO implements IStdDataSetModelDao {
    @Override
    @Cacheable
    public StdDataSetModel getDatasetName(String version ,Integer id){
    public StdDataSetModel getDatasetName(String schemaName,String version ,Integer 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;

src/main/java/com/yihu/hos/standard/dao/StdDictionaryEntryModelDao.java

@@ -18,12 +18,16 @@ import java.util.List;
public class StdDictionaryEntryModelDao extends SQLGeneralDAO implements IStdDictionaryEntryModelDao {
    @Override
    @Cacheable
    public List<StdDictionaryEntryModel> getDictionaryEntry(String adapter_std_version, String orgDicEntryValue, String dictName) {
    public List<StdDictionaryEntryModel> getDictionaryEntry(String schemaName,String adapter_std_version, String orgDicEntryValue, String dictName) {
        StringBuffer sql = new StringBuffer();
        sql.append("SELECT m.*").append(" FROM std_dictionary_entry_" + adapter_std_version).append(" m inner join std_dictionary_" + adapter_std_version)
                .append(" d on d.id= m.dict_id where m.value 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.setCacheable(true);
            query.setParameter(0, "%" + orgDicEntryValue + "%");
            query.setParameter(1, "%" + dictName + "%");

src/main/java/com/yihu/hos/standard/dao/StdDictionaryModelDao.java

@@ -19,11 +19,15 @@ public class StdDictionaryModelDao extends SQLGeneralDAO implements IStdDictiona
    @Override
    @Cacheable
    public StdDictionaryModel getDictionaryName(String version, Integer id) {
    public StdDictionaryModel getDictionaryName(String schemaName,String version, Integer id) {
        StringBuffer sql = new StringBuffer();
        sql.append("SELECT d.*").append(" FROM std_dictionary_").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(StdDictionaryModel.class));
            StdDictionaryModel stdDictionaryModel = (StdDictionaryModel) query.uniqueResult();
            return stdDictionaryModel;

src/main/java/com/yihu/hos/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));

src/main/java/com/yihu/hos/standard/match/dictionary/DictItemStrategyExecute.java

@@ -29,10 +29,14 @@ public class DictItemStrategyExecute implements Runnable {
    private IStdDictionaryModelDao stdDictionaryDao;
    private StdDictionaryEntryModelDao stdDictionaryEntryDao;
    private AdapterDictEntryService adapterDictEntryService;
    private String schemaName;
    private DictitemStandardNameStrategy dictitemStandardNameStrategy;
    public DictItemStrategyExecute(
            String schemaName,
            AdapterDictEntryModel adapterDictEntryModel,
            DictItemMatchVO matchVO,
            String std_version,
@@ -41,6 +45,7 @@ public class DictItemStrategyExecute implements Runnable {
            IStdDictionaryModelDao stdDictionaryDao,
                    StdDictionaryEntryModelDao stdDictionaryEntryDao,
                    AdapterDictEntryService adapterDictEntryService) {
        this.schemaName = schemaName;
        this.adapterDictEntryModel = adapterDictEntryModel;
        this.matchVO = matchVO;
        this.std_version = std_version;
@@ -51,9 +56,11 @@ public class DictItemStrategyExecute implements Runnable {
        standardExistStrategy.setStdDictionaryDao(stdDictionaryDao);
        standardExistStrategy.setStdDictionaryEntryDao(stdDictionaryEntryDao);
        standardExistStrategy.setAdapterDictEntryService(adapterDictEntryService);
        standardExistStrategy.setSchemaName(schemaName);
        dictitemStandardNameStrategy = new DictitemStandardNameStrategy();
        dictitemStandardNameStrategy.setAdapterDictEntryService(adapterDictEntryService);
        dictitemStandardNameStrategy.setStdDictionaryDao(stdDictionaryDao);
        dictitemStandardNameStrategy.setSchemaName(schemaName);
    }
    public static void setVersionYes(String version) {

src/main/java/com/yihu/hos/standard/match/dictionary/DictitemStandardExistStrategy.java

@@ -27,8 +27,10 @@ public class DictitemStandardExistStrategy {
    private AdapterDictEntryService adapterDictEntryService;
    private AdapterDictService adapterDictService;
    private String schemaName;
    public DictitemStandardExistStrategy(IStdDictionaryModelDao stdDictionaryDao, StdDictionaryEntryModelDao stdDictionaryEntryDao, AdapterDictEntryService adapterDictEntryService) {
    public DictitemStandardExistStrategy(String schemaName,IStdDictionaryModelDao stdDictionaryDao, StdDictionaryEntryModelDao stdDictionaryEntryDao, AdapterDictEntryService adapterDictEntryService) {
        this.schemaName = schemaName;
        this.stdDictionaryDao = stdDictionaryDao;
        this.stdDictionaryEntryDao = stdDictionaryEntryDao;
        this.adapterDictEntryService = adapterDictEntryService;
@@ -58,6 +60,22 @@ public class DictitemStandardExistStrategy {
        this.adapterDictEntryService = adapterDictEntryService;
    }
    public AdapterDictService getAdapterDictService() {
        return adapterDictService;
    }
    public void setAdapterDictService(AdapterDictService adapterDictService) {
        this.adapterDictService = adapterDictService;
    }
    public String getSchemaName() {
        return schemaName;
    }
    public void setSchemaName(String schemaName) {
        this.schemaName = schemaName;
    }
    public DictitemStandardExistStrategy() {
    }
@@ -71,15 +89,14 @@ public class DictitemStandardExistStrategy {
        List<AdapterDictEntryModel> matchList = matchVO.getCodeAdapter().get(dictitemNameFirstCode);//已存在
        if (matchList != null && matchList.size() > 0) {
            Integer unAdaptDicId = adapterDictEntryModel.getStdDictId();
            StdDictionaryModel stdDictionaryModel = stdDictionaryDao.getDictionaryName(std_version,unAdaptDicId);
            StdDictionaryModel adapterDictionaryModel = stdDictionaryDao.getDictionaryName(adapter_std_version,unAdaptDicId);
            StdDictionaryModel stdDictionaryModel = stdDictionaryDao.getDictionaryName(schemaName,std_version,unAdaptDicId);
            if(stdDictionaryModel!=null){
                String dictName = stdDictionaryModel.getName();
                for (AdapterDictEntryModel adapterDictEntry : matchList) {
                    if(adapterDictEntry.getStdEntryValue().contains(adapterDictEntryModel.getStdEntryValue())){
                        String orgDicEntryValue= adapterDictEntry.getAdapterEntryValue();
                        //根据值查找出 该项目下面的字典项
                        List<StdDictionaryEntryModel> dictionaryEntryTemps = stdDictionaryEntryDao.getDictionaryEntry(adapter_std_version,orgDicEntryValue,dictName);
                        List<StdDictionaryEntryModel> dictionaryEntryTemps = stdDictionaryEntryDao.getDictionaryEntry(schemaName,adapter_std_version,orgDicEntryValue,dictName);
                        if(dictionaryEntryTemps!=null&&dictionaryEntryTemps.size()>0){
                            String adapterInfo = "1";//查找到就默认疑似适配
                            if(dictionaryEntryTemps.size()==1){//查找到的条数为1,则为完全适配
@@ -87,18 +104,13 @@ public class DictitemStandardExistStrategy {
                            }
                            StdDictionaryEntryModel stdDictionaryEntryModel = dictionaryEntryTemps.get(0);
                            //保存适配
                            adapterDictEntryService.saveAdapt(adapterDictEntryModel, stdDictionaryEntryModel, version,adapterInfo);
                            adapterDictEntryService.saveAdapt(schemaName,adapterDictEntryModel, stdDictionaryEntryModel, version,adapterInfo);
                            flag=true;
                            break;
                        }
                    }
                }
            }
//            if (adapterDictionaryModel != null) {
//                adapterDictService = SpringBeanUtil.getService(AdapterDictService.BEAN_ID);
//                AdapterDictModel entity = adapterDictService.getAdapterDictByCode(version, adapterDictionaryModel.getCode());
//                adapterDictService.saveAdaptDict(entity, adapterDictionaryModel,version);
//            }
        }
        } catch (Exception e) {
            e.printStackTrace();

src/main/java/com/yihu/hos/standard/match/dictionary/DictitemStandardNameStrategy.java

@@ -28,6 +28,8 @@ public class DictitemStandardNameStrategy {
        return stdDictionaryDao;
    }
    private String schemaName;
    public void setStdDictionaryDao(IStdDictionaryModelDao stdDictionaryDao) {
        this.stdDictionaryDao = stdDictionaryDao;
    }
@@ -45,6 +47,14 @@ public class DictitemStandardNameStrategy {
        this.adapterDictEntryService = adapterDictEntryService;
    }
    public String getSchemaName() {
        return schemaName;
    }
    public void setSchemaName(String schemaName) {
        this.schemaName = schemaName;
    }
    private static LikeHashMap<String,StdDictionaryEntryModel> nameMap=new LikeHashMap<String,StdDictionaryEntryModel>();//机构字典项值的map
@@ -55,14 +65,11 @@ public class DictitemStandardNameStrategy {
    @Transactional
    public boolean match(AdapterDictEntryModel adapterDictEntryModel, String version,String std_version) throws Exception {
        if (adapterDictEntryModel==null){
            System.out.println(adapterDictEntryModel);
        }
        StdDictionaryModel dictionary = stdDictionaryDao.getDictionaryName(std_version, adapterDictEntryModel.getStdDictId());
        StdDictionaryModel dictionary = stdDictionaryDao.getDictionaryName(schemaName,std_version, adapterDictEntryModel.getStdDictId());
        StdDictionaryEntryModel orgDictItem = nameMap.get(adapterDictEntryModel.getStdEntryValue()+ "_" + dictionary.getCode(), true);
        if (orgDictItem != null ) {
            adapterDictEntryService.saveAdapt(adapterDictEntryModel, orgDictItem, version,"2");
            adapterDictEntryService.saveAdapt(schemaName,adapterDictEntryModel, orgDictItem, version,"2");
            return true;
        }
        return false;

src/main/java/com/yihu/hos/standard/match/metadata/MetadataStrategyExecute.java

@@ -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

src/main/java/com/yihu/hos/standard/match/metadata/MetatdataStandardExistStrategy.java

@@ -1,10 +1,8 @@
package com.yihu.hos.standard.match.metadata;
import com.yihu.hos.core.datatype.CollectionUtil;
import com.yihu.hos.standard.dao.IStdDataSetModelDao;
import com.yihu.hos.standard.dao.IStdMetaDataModelDao;
import com.yihu.hos.standard.match.matchModel.MetadataMatchVO;
import com.yihu.hos.standard.model.adapter.AdapterDatasetModel;
import com.yihu.hos.standard.model.adapter.AdapterMetadataModel;
import com.yihu.hos.standard.model.standard.StdDataSetModel;
import com.yihu.hos.standard.model.standard.StdMetaDataModel;
@@ -12,13 +10,10 @@ import com.yihu.hos.standard.service.adapter.AdapterDatasetService;
import com.yihu.hos.standard.service.adapter.AdapterMetadataService;
import com.yihu.hos.standard.util.GetChineseFirst;
import com.yihu.hos.web.framework.dao.SQLGeneralDAO;
import com.yihu.hos.web.framework.util.springutil.SpringBeanUtil;
import org.apache.commons.collections4.CollectionUtils;
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;
/**
@@ -32,6 +27,7 @@ public class MetatdataStandardExistStrategy extends SQLGeneralDAO {
    private AdapterMetadataService adapterMetadataService;
    private IStdDataSetModelDao stdDataSetModelDao;
    private AdapterDatasetService adapterDatasetService;
    private String schemaName;
    public AdapterDatasetService getAdapterDatasetService() {
        return adapterDatasetService;
@@ -69,6 +65,14 @@ public class MetatdataStandardExistStrategy extends SQLGeneralDAO {
        this.stdDataSetModelDao = stdDataSetModelDao;
    }
    public String getSchemaName() {
        return schemaName;
    }
    public void setSchemaName(String schemaName) {
        this.schemaName = schemaName;
    }
    public MetatdataStandardExistStrategy() {
    }
@@ -89,17 +93,17 @@ public class MetatdataStandardExistStrategy extends SQLGeneralDAO {
            if (adapterMetadatas != null && adapterMetadatas.size() > 0) {
                //获取待适配的数据集名
                Integer 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,默认为完全适配

src/main/java/com/yihu/hos/standard/match/metadata/MetatdataStandardNameStrategy.java

@@ -6,12 +6,10 @@ import com.yihu.hos.standard.model.standard.StdDataSetModel;
import com.yihu.hos.standard.model.standard.StdMetaDataModel;
import com.yihu.hos.standard.service.adapter.AdapterMetadataService;
import com.yihu.hos.standard.util.LikeHashMap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import java.util.Map;
/**
@@ -29,16 +27,27 @@ public class MetatdataStandardNameStrategy {
    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;
    }
@@ -81,16 +90,16 @@ 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);
        if (orgStdeMetadata != null) {
            adapterMetadataService.saveAdapt(metadata, orgStdeMetadata, version, "2");
            adapterMetadataService.saveAdapt(schemaName,metadata, orgStdeMetadata, version, "2");
            return true;
        }
        orgStdeMetadata = remarkMap.get(name + "_" + stdDataset.getCode(), true);
        if (orgStdeMetadata != null) {
            adapterMetadataService.saveAdapt(metadata, orgStdeMetadata, version, "2");
            adapterMetadataService.saveAdapt(schemaName,metadata, orgStdeMetadata, version, "2");
            return true;
        }
        return false;

src/main/java/com/yihu/hos/standard/service/adapter/AdapterDatasetService.java

@@ -616,6 +616,26 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        }
    }
    public AdapterDatasetModel getAdapterDatasetByCode(String schemaName,String version, String datasetCode) {
        try {
            if (StringUtil.isEmpty(datasetCode)) {
                return null;
            }
            SqlCreator sqlCreator = new SqlCreator(AdapterDatasetModel.class);
            sqlCreator.equalCondition("stdDatasetCode", datasetCode);
            String sql = sqlCreator.selectData("adapter_dataset_" + version);
            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 (CollectionUtil.isEmpty(datasetIdList)) {
@@ -632,17 +652,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);
                }
            }
@@ -651,9 +671,9 @@ 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,std_version, stdMetadata.getDatasetId());
            if(null != stdDataset){
                MetatdataStandardNameStrategy.getNameMap().put(stdMetadata.getName() + "_" + stdDataset.getCode(),stdMetadata);
                MetatdataStandardNameStrategy.getRemarkMap().put(stdMetadata.getDefinition() + "_" + stdDataset.getCode(),stdMetadata);
@@ -665,20 +685,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) {
                //获取待适配的数据集名
                Integer unAdaptStdId = unAdapterMetadataModel.getStdDatasetId();
                StdDataSetModel adapterDataset = stdDataSetModelDao.getDatasetName(adapter_std_version, unAdaptStdId);
                StdDataSetModel adapterDataset = stdDataSetModelDao.getDatasetName(schemaName,adapter_std_version, unAdaptStdId);
                if (adapterDataset != null) {
                    adapterDatasetService = SpringBeanUtil.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);
@@ -720,4 +740,18 @@ public class AdapterDatasetService extends SQLGeneralDAO {
        sqlBuffer.append(" where id=" + strategyDataset.getId());
        return sqlBuffer.toString();
    }
    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());
        String myCatAnnotation = "/*#mycat\\:schema=" + schemaName + "*/ ";
        String completeSql = myCatAnnotation + sqlBuffer;
        return completeSql;
    }
}

src/main/java/com/yihu/hos/standard/service/adapter/AdapterDictEntryService.java

@@ -362,6 +362,20 @@ public class AdapterDictEntryService extends SQLGeneralDAO {
        return list;
    }
    public List<AdapterDictEntryModel> getAllUnAdaptDictEntry(String schemaName, String version){
        AdapterVersion adapterVersion = new AdapterVersion(version);
        StringBuffer sql = new StringBuffer();
        sql.append("SELECT m.*").append(" FROM "+adapterVersion.getDictEntryTableName()).append(" m where m.adapter_entry_id is null");
        String myCatAnnotation = "/*#mycat\\:schema=" + schemaName + "*/ ";
        String completeSql = myCatAnnotation + sql;
        Query query = getCurrentSession().createSQLQuery(completeSql);
        query.setResultTransformer(new BeanTransformer(AdapterDictEntryModel.class));
        List<AdapterDictEntryModel> list = query.list();
        return list;
    }
    public List<AdapterDictEntryModel> getAllAdaptDictEntry(String version) {
        AdapterVersion adapterVersion = new AdapterVersion(version);
        StringBuffer sql = new StringBuffer();
@@ -372,6 +386,20 @@ public class AdapterDictEntryService extends SQLGeneralDAO {
        return list;
    }
    public List<AdapterDictEntryModel> getAllAdaptDictEntry(String schemaName,String version) {
        AdapterVersion adapterVersion = new AdapterVersion(version);
        StringBuffer sql = new StringBuffer();
        sql.append("SELECT m.*").append(" FROM "+adapterVersion.getDictEntryTableName()).append(" m where m.adapter_entry_id is not null");
        String myCatAnnotation = "/*#mycat\\:schema=" + schemaName + "*/ ";
        String completeSql = myCatAnnotation + sql;
        Query query = getCurrentSession().createSQLQuery(completeSql);
        query.setResultTransformer(new BeanTransformer(AdapterDictEntryModel.class));
        List<AdapterDictEntryModel> list = query.list();
        return list;
    }
    public void saveAdapt(AdapterDictEntryModel adapterDictEntryModel, StdDictionaryEntryModel stdDictionaryEntryModel, String version,String adapterInfo) throws  Exception{
        adapterDictEntryModel.setAdapterDictId(stdDictionaryEntryModel.getDictId());
        adapterDictEntryModel.setAdapterEntryId(stdDictionaryEntryModel.getId());
@@ -384,4 +412,21 @@ public class AdapterDictEntryService extends SQLGeneralDAO {
        Query query = getExeuteQuery(sqlCreator, sql);
        query.executeUpdate();
    }
    public void saveAdapt(String schemaName,AdapterDictEntryModel adapterDictEntryModel, StdDictionaryEntryModel stdDictionaryEntryModel, String version,String adapterInfo) throws  Exception{
        adapterDictEntryModel.setAdapterDictId(stdDictionaryEntryModel.getDictId());
        adapterDictEntryModel.setAdapterEntryId(stdDictionaryEntryModel.getId());
        adapterDictEntryModel.setAdapterEntryCode(stdDictionaryEntryModel.getCode());
        adapterDictEntryModel.setAdapterEntryValue(stdDictionaryEntryModel.getValue());
        adapterDictEntryModel.setAdapterInfo(adapterInfo);
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterDictEntryModel));
        SqlCreator sqlCreator = new SqlCreator(AdapterDictEntryModel.class);
        String sql = sqlCreator.updateDataByTableKey(new AdapterVersion(version).getDictEntryTableName(), jsonNode);
        String myCatAnnotation = "/*#mycat\\:schema=" + schemaName + "*/ ";
        String completeSql = myCatAnnotation + sql;
        Query query = getExeuteQuery(sqlCreator, completeSql);
        query.executeUpdate();
    }
}

src/main/java/com/yihu/hos/standard/service/adapter/AdapterDictService.java

@@ -204,16 +204,16 @@ public class AdapterDictService extends SQLGeneralDAO {
        Integer count = Integer.parseInt(StringUtil.toString(query.list().get(0)));
        return count;
    }
    public void strategy(String version,String std_version, String adapter_std_version) throws Exception {
        List<AdapterDictEntryModel> unAdapterDictEntryModels= adapterDictEntryService.getAllUnAdaptDictEntry(version);//等待适配的标准字典项
    public void strategy(String schemaName, String version,String std_version, String adapter_std_version) throws Exception {
        List<AdapterDictEntryModel> unAdapterDictEntryModels= adapterDictEntryService.getAllUnAdaptDictEntry(schemaName,version);//等待适配的标准字典项
        List<AdapterDictEntryModel> adapterDictEntryModels = new ArrayList<AdapterDictEntryModel>();//之前已经适配好的适配方案
        //查找出  之前已经适配好的适配方案
        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<AdapterDictEntryModel> adaptMetadata = adapterDictEntryService.getAllAdaptDictEntry(adapterSchemeVersionModel.getVersion());
                    List<AdapterDictEntryModel> adaptMetadata = adapterDictEntryService.getAllAdaptDictEntry(schemaName,adapterSchemeVersionModel.getVersion());
                    adapterDictEntryModels.addAll(adaptMetadata);
                }
            }
@@ -223,10 +223,10 @@ public class AdapterDictService extends SQLGeneralDAO {
        //設置匹配的机构数据緩存
        StandardVersion standardVersion = new StandardVersion(adapter_std_version);
        List<StdDictionaryEntryModel> dictItems = stdDictService.getDicEntryList(standardVersion, null, null, null, null);
        List<StdDictionaryEntryModel> dictItems = stdDictService.getDicEntryList(schemaName,standardVersion, null, null, null, null);
        for (StdDictionaryEntryModel stdDictItem:dictItems){
            StdDictionaryModel dictionary = stdDictionaryDao.getDictionaryName(adapter_std_version, stdDictItem.getDictId());
            StdDictionaryModel dictionary = stdDictionaryDao.getDictionaryName(schemaName,adapter_std_version, stdDictItem.getDictId());
            if(dictionary != null){
                DictitemStandardNameStrategy.getNameMap().put(stdDictItem.getValue() + "_" + dictionary.getCode(),stdDictItem);
            }
@@ -238,16 +238,16 @@ public class AdapterDictService extends SQLGeneralDAO {
        Set<String> sqlList = new HashSet<String>();
        for (AdapterDictEntryModel unAdapterDictEntryModel : unAdapterDictEntryModels) {
            threadPoolTaskExecutor.execute(new DictItemStrategyExecute(unAdapterDictEntryModel, matchVO,std_version,adapter_std_version,version, stdDictionaryDao, stdDictionaryEntryDao,adapterDictEntryService));
            threadPoolTaskExecutor.execute(new DictItemStrategyExecute(schemaName,unAdapterDictEntryModel, matchVO,std_version,adapter_std_version,version, stdDictionaryDao, stdDictionaryEntryDao,adapterDictEntryService));
            Integer unAdaptDicId = unAdapterDictEntryModel.getStdDictId();
            StdDictionaryModel adapterDictionaryModel = stdDictionaryDao.getDictionaryName(adapter_std_version, unAdaptDicId);
            StdDictionaryModel adapterDictionaryModel = stdDictionaryDao.getDictionaryName(schemaName,adapter_std_version, unAdaptDicId);
            if (adapterDictionaryModel != null) {
                adapterDictService = SpringBeanUtil.getService(AdapterDictService.BEAN_ID);
                AdapterDictModel entity = adapterDictService.getAdapterDictByCode(version, adapterDictionaryModel.getCode());
                AdapterDictModel entity = adapterDictService.getAdapterDictByCode(schemaName,version, adapterDictionaryModel.getCode());
                String sqrSql = null;
                if (null != entity) {
                    sqrSql = adapterDictService.saveAdaptDictSql(entity, adapterDictionaryModel, version);
                    sqrSql = adapterDictService.saveAdaptDictSql(schemaName,entity, adapterDictionaryModel, version);
                }
                if (null != sqrSql && !"".equals(sqrSql)) {
                    sqlList.add(sqrSql);
@@ -277,6 +277,20 @@ public class AdapterDictService extends SQLGeneralDAO {
        return sqlBuffer.toString();
    }
    public String saveAdaptDictSql(String schemaName,AdapterDictModel strategyDict, StdDictionaryModel orgDict, String version) throws Exception {
        StringBuilder sqlBuffer = new StringBuilder();
        sqlBuffer.append(SqlConstants.UPDATE + new AdapterVersion(version).getDictTableName() + SqlConstants.SET);
        sqlBuffer.append(" adapter_dict_id = " + orgDict.getId());
        sqlBuffer.append(",adapter_dict_code = '" + orgDict.getCode() + "'");
        sqlBuffer.append(",adapter_dict_name = '" + orgDict.getName() + "'");
        sqlBuffer.append(" where id=" + strategyDict.getId());
        String myCatAnnotation = "/*#mycat\\:schema=" + schemaName + "*/ ";
        String completeSql = myCatAnnotation + sqlBuffer.toString();
        return completeSql;
    }
    public AdapterDictModel getAdapterDictByCode(String version, String dictCode) {
        try {
            if (StringUtil.isEmpty(dictCode)) {
@@ -293,4 +307,24 @@ public class AdapterDictService extends SQLGeneralDAO {
        }
    }
    public AdapterDictModel getAdapterDictByCode(String schemaName,String version, String dictCode) {
        try {
            if (StringUtil.isEmpty(dictCode)) {
                return null;
            }
            SqlCreator sqlCreator = new SqlCreator(AdapterDictModel.class);
            sqlCreator.equalCondition("stdDictCode", dictCode);
            String sql = sqlCreator.selectData("adapter_dict_" + version);
            String myCatAnnotation = "/*#mycat\\:schema=" + schemaName + "*/ ";
            String completeSql = myCatAnnotation + sql;
            Query query = getQuery(sqlCreator, completeSql);
            return (AdapterDictModel) query.uniqueResult();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

src/main/java/com/yihu/hos/standard/service/adapter/AdapterMetadataService.java

@@ -95,7 +95,7 @@ public class AdapterMetadataService extends SQLGeneralDAO {
            adapterMetadataModel.setMessage("修改适配数据元成功");
            return adapterMetadataModel;
        } catch (Exception e) {
           return Result.error("修改适配数据元失败");
            return Result.error("修改适配数据元失败");
        }
    }
@@ -454,6 +454,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();
@@ -464,6 +478,27 @@ public class AdapterMetadataService extends SQLGeneralDAO {
        return list;
    }
    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 void saveAdapt(AdapterMetadataModel strategyMetadata,StdMetaDataModel orgMetadata,String version,String adapterInfo) throws Exception {
        strategyMetadata.setAdapterDatasetId(orgMetadata.getDatasetId());
        strategyMetadata.setAdapterMetadataId(orgMetadata.getId());
@@ -477,6 +512,23 @@ public class AdapterMetadataService extends SQLGeneralDAO {
        query.executeUpdate();
    }
    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.getCode());
        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){

src/main/java/com/yihu/hos/standard/service/adapter/AdapterSchemeVersionService.java

@@ -517,4 +517,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;
    }
}

src/main/java/com/yihu/hos/standard/service/standard/StdDictService.java

@@ -282,6 +282,34 @@ public class StdDictService extends SQLGeneralDAO {
        return (List<StdDictionaryEntryModel>) sessionQuery.list();
    }
    public List<StdDictionaryEntryModel> getDicEntryList(String schemaName,StandardVersion standardVersion, Map<String, Object> query, Map<String, String> order, Integer limit, Integer offset) {
        SqlCreator sqlCreator = new SqlCreator(StdDictionaryEntryModel.class);
        if(null!=query){
            for (String key : query.keySet()) {
                sqlCreator.equalCondition(key, query.get(key));
            }
        }
        if(order!=null){
            for (String key : order.keySet()) {
                sqlCreator.order(key, order.get(key));
            }
        }
        String sql = sqlCreator.selectData(standardVersion.getDictEntryTableName());
        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<StdDictionaryEntryModel>) sessionQuery.list();
    }
    public DictionaryResult getDictionaryList(String stdVersion, String query, String order, Integer rows, Integer page) {
        try {
            List<StdDictionaryModel> stdDictionaryModelList = getList(stdVersion, query, order, rows, page);

src/main/java/com/yihu/hos/standard/service/standard/StdMetadataService.java

@@ -61,6 +61,20 @@ public class StdMetadataService extends SQLGeneralDAO {
        throw new ApiException(ErrorCode.StandardMetaDataGetListFailed);
    }
    public List<StdMetaDataModel> getList(String schemaName, String stdVersion, Integer 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);
    }
    public Result add(String stdVersion, String metadata) {
        Boolean existFlg = false;
@@ -222,6 +236,33 @@ public class StdMetadataService extends SQLGeneralDAO {
        return (List<StdMetaDataModel>) sessionQuery.list();
    }
    private List<StdMetaDataModel> getList(String schemaName,StandardVersion standardVersion, Integer 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 DetailModelResult getDetailModelList(String stdVersion, Integer dictId, String condition, String order, Integer rows, Integer page) {
        try {
            List<StdDictionaryEntryModel> detailModelList = getMetadataList(StdMetaDataModel.class, stdVersion, dictId, condition, order, rows, page);

src/main/webapp/WEB-INF/ehr/jsp/standard/adapterplan/configuration.jsp

@@ -65,9 +65,9 @@
  .back{
    border-right: 1px solid #d3d3d3;
  }
  .unadapt .l-grid-row-cell {background-color:#F5F5F5}
  .ysadapt .l-grid-row-cell {background-color:#1eaaff}
  .alladapt .l-grid-row-cell {background-color: #ff9600;}
  .unadapt .l-grid-row-cell:nth-child(1) {background-color:#F5F5F5}
  .ysadapt .l-grid-row-cell:nth-child(1) {background-color:#ff9b00}
  .alladapt .l-grid-row-cell:nth-child(1) {background-color: #1eaaff;}
  .js-example-data-array{width: 90% !important;height:30px;margin-top:5px;}
</style>