代码修改

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

@@ -0,0 +1,120 @@
package com.yihu.jw.basic.standard.controller;
import com.yihu.jw.basic.standard.service.adapter.AdapterDatasetService;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.ListEnvelop;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.restmodel.web.PageEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.io.UnsupportedEncodingException;
/**
 * Created by LLH on 2016/1/6.
 */
@RestController("AdapterDatasetController")
@RequestMapping("/adapterCenter")
@Api(protocols = "https", value = "AdapterDatasetController", description = "适配数据集管理", tags = {"适配数据集"})
public class AdapterDatasetController extends EnvelopRestEndpoint {
    @Resource(name = AdapterDatasetService.BEAN_ID)
    private AdapterDatasetService datasetService;
    /**
     * 查询数据集列表信息（get）
     * @param adapterVersion
     * @param condition
     * @param order
     * @param rows
     * @param page
     * @return
     * @throws Exception
     */
    @GetMapping(value = "/searchDatasetList")
    @ApiOperation(value = "获取数据集列表", produces = "application/json", notes = "获取数据集列表")
    public PageEnvelop getDatasetList(
            @ApiParam(name = "adapterVersion", value = "适配方案版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "condition", value = "查询条件：编码或名称")
            @RequestParam(value = "condition", required = false) String condition,
            @ApiParam(name = "order", value = "Order param,Must be json.ascending:asc,descending:desc")
            @RequestParam(value = "order", required = false) String order,
            @ApiParam(name = "rows", value = "Limit the size of result set. Must be an integer")
            @RequestParam(value = "rows", required = false) Integer rows,
            @ApiParam(name = "page", value = "Start position of result set. Must be an integer")
            @RequestParam(value = "page", required = false) Integer page) {
        return datasetService.getDetailModelResult(adapterVersion, condition, order, rows, page);
    }
    @GetMapping("/getForDatasetId")
    @ApiOperation(value = "获取适配数据集", produces = "application/json", notes = "获取适配数据集")
    public ObjEnvelop getForDatasetId(
            @ApiParam(name = "adapterVersion", value = "适配版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "datasetId", value = "适配数据集ID")
            @RequestParam(value = "datasetId") Integer datasetId) {
        return datasetService.get(adapterVersion, datasetId);
    }
    @PostMapping(value = "/delDataset")
    @ApiOperation(value = "删除数据集",  produces = "application/json", notes = "删除适配数据集")
    public Envelop delDataset(
            @ApiParam(name = "adapterVersion", value = "适配版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "datasetId", value = "适配数据集ID")
            @RequestParam(value = "datasetId") Integer datasetId) {
       return datasetService.delete(adapterVersion, datasetId);
    }
    @PostMapping(value = "/updateDataset")
    @ApiOperation(value = "修改适配数据集", produces = "application/json", notes = "修改适配数据集")
    public ObjEnvelop modify(
            @ApiParam(name = "adapterVersion", value = "适配版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "dataset", value = "数据集,JSON")
            @RequestParam(value = "dataset") String dataset) {
        return datasetService.modify(adapterVersion, dataset);
    }
    @PostMapping(value = "/addDataset")
    @ApiOperation(value = "保存适配数据集", produces = "application/json", notes = "保存数据集")
    public ObjEnvelop add(
            @ApiParam(name = "adapterVersion", value = "适配版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "dataset", value = "数据集信息")
            @RequestParam(value = "dataset") String dataset) {
        return datasetService.add(adapterVersion, dataset);
    }
    @GetMapping(value = "/getAdapterDataset")
    @ApiOperation(value = "获取定制数据集列表",  responseContainer = "List",produces = "application/json", notes = "获取数据集列表")
    public ListEnvelop getDatasetCustomize(
            @ApiParam(name = "adapterVersion", value = "适配版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "stdVersion", value = "标准版本号")
            @RequestParam(value = "stdVersion") String stdVersion) {
        return datasetService.getDatasetCustomize(adapterVersion, stdVersion);
    }
    @RequestMapping(value = "/saveAdapterDataset", method = RequestMethod.POST)
    @ApiOperation(value = "定制适配数据集",  responseContainer = "List",produces = "application/json", notes = "获取数据集列表")
    public Envelop adapterDataSet(
            @ApiParam(name = "schemeId", value = "适配方案ID")
            @RequestParam(value = "schemeId") Integer schemeId,
            @ApiParam(name = "adapterVersion", value = "适配版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "stdVersion", value = "标准版本号")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "datasetIdStr", value = "适配数据集信息")
            @RequestParam(value = "datasetIdStr") String datasetIdStr,
            @ApiParam(name = "metaDataIdStr", value = "适配数据元信息")
            @RequestParam(value = "metaDataIdStr") String metaDataIdStr) throws UnsupportedEncodingException {
        return datasetService.updateCustomize(schemeId, adapterVersion, stdVersion, datasetIdStr,metaDataIdStr);
    }
}

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

@@ -0,0 +1,162 @@
package com.yihu.jw.basic.standard.controller;
import com.yihu.jw.basic.standard.match.dictionary.DictItemStrategyExecute;
import com.yihu.jw.basic.standard.service.adapter.AdapterDictService;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.restmodel.web.PageEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
/**
 * Created by LLH on 2016/1/6.
 */
@RestController("AdapterDictController")
@RequestMapping("/adapterCenter")
@Api(protocols = "https", value = "AdapterDictController", description = "适配字典管理", tags = {"适配字典"})
public class AdapterDictController extends EnvelopRestEndpoint {
    @Resource(name = AdapterDictService.BEAN_ID)
    private AdapterDictService dictService;
    /**
     * 查询字典列表信息（get）
     * @param adapterVersion
     * @param condition
     * @param order
     * @param rows
     * @param page
     * @return
     * @throws Exception
     */
    @GetMapping(value = "/searchDictList")
    @ApiOperation(value = "获取字典列表", produces = "application/json", notes = "获取字典列表")
    public PageEnvelop searchDictList(
            @ApiParam(name = "adapterVersion", value = "适配标准版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "condition", value = "查询条件：编码或名称")
            @RequestParam(value = "condition", required = false) String condition,
            @ApiParam(name = "order", value = "Order param,Must be json.ascending:asc,descending:desc")
            @RequestParam(value = "order", required = false) String order,
            @ApiParam(name = "rows", value = "Limit the size of result set. Must be an integer")
            @RequestParam(value = "rows", required = false) Integer rows,
            @ApiParam(name = "page", value = "Start position of result set. Must be an integer")
            @RequestParam(value = "page", required = false) Integer page) {
        return dictService.getDetailResult(adapterVersion, condition, order, rows, page);
    }
    @GetMapping(value = "/getForDictId")
    @ApiOperation(value = "获取字典", produces = "application/json", notes = "获取字典")
    public ObjEnvelop get(
            @ApiParam(name = "adapterVersion", value = "标准版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "dictId", value = "字典ID")
            @RequestParam(value = "dictId") Integer dictId) {
        return dictService.get(adapterVersion, dictId);
    }
    @PostMapping(value = "/delDict")
    @ApiOperation(value = "删除字典", produces = "application/json", notes = "删除字典")
    public Envelop delDict(
            @ApiParam(name = "adapterVersion", value = "标准版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "dictId", value = "字典ID")
            @RequestParam(value = "dictId") Integer dictId) {
        return dictService.delete(adapterVersion, dictId);
    }
    
    @PostMapping(value = "/updateDict")
    @ApiOperation(value = "修改字典", produces = "application/json", notes = "修改字典")
    public ObjEnvelop updateDict(
            @ApiParam(name = "adapterVersion", value = "标准版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "dict", value = "字典")
            @RequestParam(value = "dict") String dict) {
        return dictService.modify(adapterVersion, dict);
    }
    @PostMapping(value = "/addDict")
    @ApiOperation(value = "保存字典", produces = "application/json", notes = "保存字典")
    public ObjEnvelop addDict(
            @ApiParam(name = "adapterVersion", value = "标准版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "dict", value = "字典")
            @RequestParam(value = "dict") String dict) {
        return dictService.add(adapterVersion, dict);
    }
    @RequestMapping(value = "/isStrategyDic", method = RequestMethod.POST , produces = "application/json")
    @ApiOperation(value = "是否智能匹配",  produces = "application/json", notes = "是否智能匹配")
    public Envelop isStrategy(
            @ApiParam(value = "匹配version", required = true) @RequestParam("version") String version
    ) {
        try {
            return ObjEnvelop.getSuccess("查询成功","{\"isAdapt\":\"" + DictItemStrategyExecute.isAdapt(version) + "\"}");
        } catch (Exception e) {
            e.printStackTrace();
            return ObjEnvelop.getError("查询失败",-1);
        }
    }
    /**
     * 智能匹配
     *
     * @param version
     * @return
     * @throws Exception
     */
    @RequestMapping(value = "/strategyDic", method = RequestMethod.POST)
    @ApiOperation(value = "智能匹配", produces = "application/json", notes = "智能匹配")
    public Envelop strategyDic(
            @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
    ) {
        try {
            synchronized (DictItemStrategyExecute.class){
                if (!DictItemStrategyExecute.isAdapt(version)) {
                    //判断之前是否已经有匹配有的话不进行匹配
                    DictItemStrategyExecute.setVersionYes(version);
                }else{
                    return Envelop.getSuccess("操作成功");
                }
            }
            dictService.strategy(version,std_version,adapter_std_version);
        } catch (Exception e) {
            e.printStackTrace();
            return Envelop.getError("操作失败",-1);
        }
        return Envelop.getSuccess("操作成功");
    }
    @RequestMapping(value = "/getStrategyDicSize", method = RequestMethod.POST)
    @ApiOperation(value = "智能匹配进行",  produces = "application/json", notes = "智能匹配进行")
    public Envelop getStrategyDicSize(
            @ApiParam(value = "匹配version", required = true) @RequestParam("version") String version
    ){
        try {
            return ObjEnvelop.getSuccess("操作成功",DictItemStrategyExecute.getAllNumAndAdaptNum(version));
        } catch (Exception e) {
            e.printStackTrace();
            return Envelop.getError("操作失败",-1);
        }
    }
    @RequestMapping(value = "/endStrategyDic", method = RequestMethod.POST)
    @ApiOperation(value = "智能匹配結束", produces = "application/json", notes = "智能匹配結束")
    public Envelop endStrategyDic(
            @ApiParam(value = "匹配version", required = true) @RequestParam("version") String version
    ){
        try {
            DictItemStrategyExecute.removeAdapt(version);
            return Envelop.getSuccess("操作成功");
        } catch (Exception e) {
            e.printStackTrace();
            return Envelop.getError("操作失败",-1);
        }
    }
}

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

@@ -0,0 +1,105 @@
package com.yihu.jw.basic.standard.controller;
import com.yihu.jw.basic.standard.service.adapter.AdapterDictEntryService;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.ListEnvelop;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.restmodel.web.PageEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
/**
 * Created by LLH on 2016/1/6.
 */
@RestController("AdapterDictEntryController")
@RequestMapping("/adapterCenter")
@Api(protocols = "https", value = "AdapterDictEntryController", description = "适配字典项管理", tags = {"适配字典项"})
public class AdapterDictEntryController extends EnvelopRestEndpoint {
    @Resource(name = AdapterDictEntryService.BEAN_ID)
    private AdapterDictEntryService dictentryService;
    /**
     * 查询字典项列表信息（get）
     * @param adapterVersion
     * @param condition
     * @param order
     * @param rows
     * @param page
     * @return
     * @throws Exception
     */
    @GetMapping(value = "/searchDictEntryList")
    @ApiOperation(value = "获取字典项列表",  produces = "application/json", notes = "获取字典项列表")
    public PageEnvelop getDictEntryList(
            @ApiParam(name = "adapterVersion", value = "适配版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "condition", value = "查询条件")
            @RequestParam(value = "condition", required = false) String condition,
            @ApiParam(name = "order", value = "Order param,Must be json.ascending:asc,descending:desc")
            @RequestParam(value = "order", required = false) String order,
            @ApiParam(name = "rows", value = "Limit the size of result set. Must be an integer")
            @RequestParam(value = "rows", required = false) Integer rows,
            @ApiParam(name = "page", value = "Start position of result set. Must be an integer")
            @RequestParam(value = "page", required = false) Integer page) throws Exception{
        return dictentryService.getDetailResult(adapterVersion, condition, order, rows, page);
    }
    @GetMapping(value = "/getForDictEntryId")
    @ApiOperation(value = "获取字典项",  produces = "application/json", notes = "获取字典项")
    public ObjEnvelop get(
            @ApiParam(name = "adapterVersion", value = "标准版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "dictEntryId", value = "字典项ID")
            @RequestParam(value = "dictEntryId") Integer dictentryId) {
        return dictentryService.get(adapterVersion, dictentryId);
    }
    @PostMapping(value = "/updateDictEntry")
    @ApiOperation(value = "修改字典项", produces = "application/json", notes = "修改字典项")
    public ObjEnvelop updateDictEntry(
            @ApiParam(name = "adapterVersion", value = "标准版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "dictEntry", value = "字典项")
            @RequestParam(value = "dictEntry") String dictEntry) {
        return dictentryService.modify(adapterVersion, dictEntry);
    }
    @PostMapping(value = "/addDictEntry")
    @ApiOperation(value = "保存字典项", produces = "application/json", notes = "保存字典项")
    public ObjEnvelop add(
            @ApiParam(name = "adapterVersion", value = "标准版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "dictEntry", value = "字典项")
            @RequestParam(value = "dictEntry") String dictEntry) {
        return dictentryService.add(adapterVersion, dictEntry);
    }
    @PostMapping("/updateDictEntrys")
    @ApiOperation(value = "保存字典项",  produces = "application/json", notes = "保存数据元")
    public ListEnvelop updateDictEntrys(
            @ApiParam(name = "adapterVersion", value = "标准版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "list", value = "字典项列表")
            @RequestParam(value = "list") String list) {
        return dictentryService.updateDictEntrys(adapterVersion, list);
    }
    @PostMapping("/delDictEntry")
    @ApiOperation(value = "删除字典项",  produces = "application/json", notes = "删除字典项,若字典项表为空管理字典清掉")
    public Envelop delete(
            @ApiParam(name = "adapterVersion", value = "标准版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "dictEntryId", value = "字典项ID")
            @RequestParam(value = "dictEntryId") Integer dictEntryId,
            @ApiParam(name = "stdDictId", value = "标准字典ID")
            @RequestParam(value = "stdDictId") Integer stdDictId,
            @ApiParam(name = "adapterDictId", value = "适配字典ID")
            @RequestParam(value = "adapterDictId") Integer adapterDictId) {
        return dictentryService.deleteMultiple(adapterVersion, dictEntryId, stdDictId, adapterDictId);
    }
}

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

@@ -0,0 +1,174 @@
package com.yihu.jw.basic.standard.controller;
import com.yihu.jw.basic.standard.match.metadata.MetadataStrategyExecute;
import com.yihu.jw.basic.standard.service.adapter.AdapterDatasetService;
import com.yihu.jw.basic.standard.service.adapter.AdapterMetadataService;
import com.yihu.jw.basic.standard.service.bo.AdapterVersion;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.ListEnvelop;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.restmodel.web.PageEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
/**
 * Created by LLH on 2016/1/6.
 */
@RestController("AdapterMetadataController")
@RequestMapping("/adapterCenter")
@Api(protocols = "https", value = "AdapterMetadataController", description = "适配字典管理", tags = {"适配字典"})
public class AdapterMetadataController extends EnvelopRestEndpoint {
    @Resource(name = AdapterMetadataService.BEAN_ID)
    private AdapterMetadataService metadataService;
    @Resource(name = AdapterDatasetService.BEAN_ID)
    private AdapterDatasetService adapterDatasetService;
    @GetMapping("/searchMetadataList")
    @ApiOperation(value = "查询数据元列表信息",  produces = "application/json", notes = "获取数据元列表")
    public PageEnvelop getMetadataList(
            @ApiParam(name = "adapterVersion", value = "标准版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "condition", value = "查询条件")
            @RequestParam(value = "condition", required = false) String condition,
            @ApiParam(name = "order", value = "Order param,Must be json.ascending:asc,descending:desc")
            @RequestParam(value = "order", required = false) String order,
            @ApiParam(name = "rows", value = "Limit the size of result set. Must be an integer")
            @RequestParam(value = "rows", required = false) Integer rows,
            @ApiParam(name = "page", value = "Start position of result set. Must be an integer")
            @RequestParam(value = "page", required = false) Integer page)  throws Exception{
        return  metadataService.getDetailResult(adapterVersion, condition, order, rows, page);
    }
    @GetMapping("/getForMetadataId")
    @ApiOperation(value = "获取数据元", produces = "application/json", notes = "获取数据元")
    public ObjEnvelop get(
            @ApiParam(name = "adapterVersion", value = "标准版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "metadataId", value = "数据元ID")
            @RequestParam(value = "metadataId") Integer metadataId) {
        AdapterVersion version = new AdapterVersion(adapterVersion);
        return metadataService.get(version.getMetaDataTableName(), metadataId);
    }
    @PostMapping("/updateMetadata")
    @ApiOperation(value = "修改数据元",  produces = "application/json", notes = "修改数据元")
    public ObjEnvelop updateMetadata(
            @ApiParam(name = "adapterVersion", value = "标准版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "metadata", value = "数据元")
            @RequestParam(value = "metadata") String metadata) throws Exception {
        return metadataService.modify(adapterVersion, metadata);
    }
    @PostMapping("/addMetadata")
    @ApiOperation(value = "保存数据元",  produces = "application/json", notes = "保存数据元")
    public ObjEnvelop addMetadata(
            @ApiParam(name = "adapterVersion", value = "标准版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "metadata", value = "数据元")
            @RequestParam(value = "metadata") String metadata) throws Exception {
        return metadataService.add(adapterVersion, metadata);
    }
    @PostMapping("/updateMetadatas")
    @ApiOperation(value = "修改数据元",  produces = "application/json", notes = "保存数据元")
    public ListEnvelop updateMetadatas(
            @ApiParam(name = "adapterVersion", value = "标准版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "list", value = "数据元列表")
            @RequestParam(value = "list") String list) {
        return metadataService.updateMetadatas(adapterVersion, list);
    }
    @PostMapping("/delMetadata")
    @ApiOperation(value = "删除数据元",  produces = "application/json", notes = "删除数据元")
    public Envelop delete(
            @ApiParam(name = "adapterVersion", value = "标准版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "metadataId", value = "数据元ID")
            @RequestParam(value = "metadataId") Integer metadataId,
            @ApiParam(name = "stdDatasetId", value = "标准数据集ID")
            @RequestParam(value = "stdDatasetId") Integer stdDatasetId,
            @ApiParam(name = "adapterDatasetId", value = "适配数据集ID")
            @RequestParam(value = "adapterDatasetId") Integer adapterDatasetId) {
        return metadataService.deleteMultiple(adapterVersion, metadataId, stdDatasetId, adapterDatasetId);
    }
    @RequestMapping(value = "/isStrategy", method = RequestMethod.POST , produces = "application/json")
    @ApiOperation(value = "是否智能匹配", produces = "application/json", notes = "是否智能匹配")
    public Envelop isStrategy(
            @ApiParam(value = "匹配version", required = true) @RequestParam("version") String version
    ){
        try {
            return  ObjEnvelop.getSuccess("操作成功","{\"isAdapt\":\"" + MetadataStrategyExecute.isAdapt(version) + "\"}");
        } catch (Exception e) {
            e.printStackTrace();
            return Envelop.getError("操作失败",-1);
        }
    }
    /**
     * 智能匹配
     *
     * @param version
     * @return
     * @throws Exception
     */
    @RequestMapping(value = "/strategy", method = RequestMethod.POST)
    @ApiOperation(value = "智能匹配", 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
    ) {
        try {
            //判断之前是否已经在匹配,有的话不进行匹配
            synchronized (MetadataStrategyExecute.class) {
                if (!MetadataStrategyExecute.isAdapt(version)) {
                    //判断之前是否已经有匹配有的话不进行匹配
                    MetadataStrategyExecute.setVersionYes(version);
                } else {
                    return Envelop.getSuccess("操作成功");
                }
            }
            adapterDatasetService.strategy(version,std_version,adapter_std_version);
        } catch (Exception e) {
            e.printStackTrace();
            return Envelop.getError("操作失败",-1);
        }
        return Envelop.getSuccess("操作成功");
    }
    @RequestMapping(value = "/getStrategySize", method = RequestMethod.POST)
    @ApiOperation(value = "智能匹配进行", produces = "application/json", notes = "智能匹配进行")
    public Envelop getStrategySize(
            @ApiParam(value = "匹配version", required = true) @RequestParam("version") String version
    ) {
        try {
            return  ObjEnvelop.getSuccess("操作成功",MetadataStrategyExecute.getAllNumAndAdaptNum(version));
        } catch (Exception e) {
            e.printStackTrace();
            return Envelop.getError("操作失败",-1);
        }
    }
    @RequestMapping(value = "/endStrategy", method = RequestMethod.POST)
    @ApiOperation(value = "智能匹配結束",  produces = "application/json", notes = "智能匹配結束")
    public Envelop endStrategy(
            @ApiParam(value = "匹配version", required = true) @RequestParam("version") String version
    ) {
        try {
            MetadataStrategyExecute.removeAdapt(version);
        } catch (Exception e) {
            e.printStackTrace();
            return Envelop.getError("操作失败",-1);
        }
        return Envelop.getSuccess("操作成功");
    }
}

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

@@ -0,0 +1,42 @@
package com.yihu.jw.basic.standard.controller;
import com.yihu.jw.basic.standard.service.adapter.AdapterDictService;
import com.yihu.jw.restmodel.web.PageEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
 * Created by LLH on 2016/1/6.
 */
@RestController("InitController")
@RequestMapping("/init")
@Api(protocols = "https", value = "AdapterDictController", description = "适配字典管理", tags = {"适配字典"})
public class InitController extends EnvelopRestEndpoint {
    @Resource(name = AdapterDictService.BEAN_ID)
    private AdapterDictService dictService;
    @GetMapping(value = "/searchDictList")
    @ApiOperation(value = "获取字典列表",  produces = "application/json", notes = "获取字典列表")
    public PageEnvelop searchDictList(
            @ApiParam(name = "adapterVersion", value = "适配标准版本号")
            @RequestParam(value = "adapterVersion") String adapterVersion,
            @ApiParam(name = "condition", value = "查询条件：编码或名称")
            @RequestParam(value = "condition", required = false) String condition,
            @ApiParam(name = "order", value = "Order param,Must be json.ascending:asc,descending:desc")
            @RequestParam(value = "order", required = false) String order,
            @ApiParam(name = "rows", value = "Limit the size of result set. Must be an integer")
            @RequestParam(value = "rows", required = false) Integer rows,
            @ApiParam(name = "page", value = "Start position of result set. Must be an integer")
            @RequestParam(value = "page", required = false) Integer page) {
        return dictService.getDetailResult(adapterVersion, condition, order, rows, page);
    }
}

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

@@ -0,0 +1,65 @@
package com.yihu.jw.basic.standard.controller;
import com.yihu.jw.basic.standard.service.standard.StdPublisherService;
import com.yihu.jw.restmodel.web.ListEnvelop;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
 * Created by LLH on 2016/1/6.
 */
@RestController("PublisherController")
@RequestMapping("/standardCenter")
@Api(protocols = "https", value = "PublisherController", description = "发布者管理", tags = {"发布者"})
public class PublisherController extends EnvelopRestEndpoint {
    @Resource(name = StdPublisherService.BEAN_ID)
    private StdPublisherService stdPublisherService;
    /**
     * 根据标准ID获取发布机构（get）
     * @param publisherId
     * @return
     * @throws Exception
     */
    @GetMapping(value = "/getForPublisherId")
    @ApiOperation(value = "获取发布机构",  produces = "application/json", notes = "获取发布机构")
    public ObjEnvelop get(
            @ApiParam(name = "publisherId", value = "机构ID")
            @RequestParam(value = "publisherId") String publisherId) {
        return stdPublisherService.get(publisherId);
    }
    @GetMapping(value = "/getStandardPublisher")
    @ApiOperation(value = "获取发布机构",  produces = "application/json", notes = "获取发布机构")
    public ObjEnvelop getStandardPublisher(){
        return stdPublisherService.getStandardPublisher();
    }
    /**
     * 获取发布机构名称列表
     * @return
     * @throws Exception
     */
    @GetMapping(value = "/getPublishers")
    @ApiOperation(value = "获取发布机构列表",  produces = "application/json", notes = "获取发布机构列表")
    public ListEnvelop getPublishers(
            @ApiParam(name = "condition", value = "Must be Json")
            @RequestParam(value = "condition", required = false) String condition,
            @ApiParam(name = "order", value = "Must be Json")
            @RequestParam(value = "order", required = false) String order,
            @ApiParam(name = "rows", value = "Limit the size of result set. Must be an integer")
            @RequestParam(value = "rows", required = false) Integer rows,
            @ApiParam(name = "page", value = "Start position of result set. Must be an integer")
            @RequestParam(value = "page", required = false) Integer page) {
        return stdPublisherService.getDictionaryResult(condition, order, rows, page);
    }
}

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

@@ -0,0 +1,90 @@
package com.yihu.jw.basic.standard.controller;
import com.yihu.jw.basic.standard.service.adapter.AdapterSchemeService;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.ListEnvelop;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
@RestController("SchemeController")
@RequestMapping("/adapterCenter")
@Api(protocols = "https", value = "SchemeController", description = "适配方案管理", tags = {"适配方案"})
public class SchemeController extends EnvelopRestEndpoint {
    @Resource(name = AdapterSchemeService.BEAN_ID)
    private AdapterSchemeService adapterSchemeService;
    /**
     * 查询适配方案首页信息（get）
     * @param condition
     * @return
     * @throws Exception
     */
    @GetMapping(value = "/searchScheme")
    @ApiOperation(value = "获取方案列表",  responseContainer = "List", notes = "获取方案列表")
    public ListEnvelop searchScheme(
            @ApiParam(name = "condition", value = "查询条件：适配方案名称、适配方案版本名称")
            @RequestParam(value = "condition", required = false) String condition) {
        return adapterSchemeService.getSchemeList(condition);
    }
    /**
     * 根据适配ID获取适配方案信息（get）
     * @param schemeId
     * @return
     * @throws Exception
     */
    @GetMapping(value = "/getForSchemeId")
    @ApiOperation(value = "获取适配方案", produces = "application/json", notes = "获取适配方案")
    public ObjEnvelop get(
            @ApiParam(name = "schemeId", value = "标准版本ID")
            @RequestParam(value = "schemeId") Integer schemeId) {
        return adapterSchemeService.get(schemeId);
    }
    /**
     * 修改适配（PUT）
     * @param scheme
     * @return
     * @throws Exception
     */
    @PostMapping("/updateScheme")
    @ApiOperation(value = "修改适配方案",  produces = "application/json", notes = "修改适配方案")
    public ObjEnvelop modify(
            @ApiParam(name = "scheme", value = "适配方案")
            @RequestParam(value = "scheme") String scheme) {
        return adapterSchemeService.update(scheme);
    }
    /**
     * 新增适配（POST）
     * @param scheme
     * @return
     * @throws Exception
     */
    @PostMapping(value = "/addScheme")
    @ApiOperation(value = "保存适配方案",  produces = "application/json", notes = "保存适配方案")
    public ObjEnvelop add(
            @ApiParam(name = "scheme", value = "适配方案信息")
            @RequestParam(value = "scheme") String scheme) {
        return adapterSchemeService.add(scheme);
    }
    /**
     * 删除适配（DELETE）
     * @param  schemeId
     * @return
     * @throws Exception
     */
    @PostMapping(value = "/deleteScheme")
    @ApiOperation(value = "删除适配方案",  produces = "application/json", notes = "删除适配方案")
    public Envelop delete(
            @ApiParam(name = "schemeId", value = "适配方案ID")
            @RequestParam(value = "schemeId") Integer schemeId) {
        return adapterSchemeService.delete(schemeId);
    }
}

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

@@ -0,0 +1,135 @@
package com.yihu.jw.basic.standard.controller;
import com.yihu.jw.basic.standard.service.adapter.AdapterSchemeVersionService;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.ListEnvelop;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.restmodel.web.PageEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
@RestController("SchemeVersionController")
@RequestMapping("/adapterCenter")
@Api(protocols = "https", value = "SchemeVersionController", description = "适配版本管理", tags = {"适配版本"})
public class SchemeVersionController extends EnvelopRestEndpoint {
    @Resource(name = AdapterSchemeVersionService.BEAN_ID)
    private AdapterSchemeVersionService adapterSchemeVersion;
    /**
     * 根据版本id获取适配方案信息（get）
     * @param versionId
     * @return
     * @throws Exception
     */
    @GetMapping("/getForVersionId")
    @ApiOperation(value = "获取适配版本",  produces = "application/json", notes = "获取适配版本")
    public ObjEnvelop get(
            @ApiParam(name = "versionId", value = "适配版本ID")
            @RequestParam(value = "versionId") Integer versionId) {
        return adapterSchemeVersion.get(versionId);
    }
    /**
     * 新增版本（post）
     * @param version
     * @return
     * @throws Exception
     */
    @PostMapping("/addVersion")
    @ApiOperation(value = "保存适配版本", produces = "application/json", notes = "保存适配版本")
    public ObjEnvelop add(
            @ApiParam(name = "version", value = "适配版本信息")
            @RequestParam(value = "version") String version) {
        return adapterSchemeVersion.add(version);
    }
    /**
     * 修改版本（put）
     * @param version
     * @return
     * @throws Exception
     */
    @PostMapping("/updateVersion")
    @ApiOperation(value = "修改适配版本",  produces = "application/json", notes = "修改适配版本")
    public ObjEnvelop modify(
            @ApiParam(name = "version", value = "标准版本")
            @RequestParam(value = "version") String version) {
        return adapterSchemeVersion.update(version);
    }
    /**
     * 发布版本（put）
     * @param versionId
     * @return
     * @throws Exception
     */
    @PostMapping("/publishVersion")
    @ApiOperation(value = "发布适配版本",  produces = "application/json", notes = "发布适配版本")
    public ObjEnvelop publish(
            @ApiParam(name = "versionId", value = "适配版本ID")
            @RequestParam(value = "versionId") Integer versionId,
            @ApiParam(name = "publisher", value = "发布者")
            @RequestParam(value = "publisher", required = false) String publisher) {
        return adapterSchemeVersion.publish(versionId, publisher);
    }
    /**
     * 删除版本（put）
     * @param versionId
     * @return
     * @throws Exception
     */
    @PostMapping("/deleteVersion")
    @ApiOperation(value = "删除版本",  produces = "application/json", notes = "删除版本")
    public Envelop delete(
            @ApiParam(name = "versionId", value = "标准版本ID")
            @RequestParam(value = "versionId") Integer versionId) {
        return adapterSchemeVersion.delete(versionId);
    }
    @GetMapping("getVersion")
    public PageEnvelop getVersion() {
        try {
            return adapterSchemeVersion.getVersion();
        } catch (Exception e) {
            e.printStackTrace();
            return PageEnvelop.getError("获取失败");
        }
    }
    @GetMapping("getVersionTree")
    public ListEnvelop getVersionTree() {
        try {
            return ListEnvelop.getSuccess("获取成功",adapterSchemeVersion.getVersionTree());
        } catch (Exception e) {
            e.printStackTrace();
            return ListEnvelop.getError("获取失败");
        }
    }
    /**
     * 获取基础版本列表
     * @param schemeId
     * @return
     * @throws Exception
     */
    @GetMapping(value = "/getVersions")
    @ApiOperation(value = "获取适配方案版本列表", produces = "application/json", notes = "获取标准版本列表")
    public ListEnvelop getList(
            @ApiParam(name = "schemeId", value = "适配方案ID")
            @RequestParam(value = "schemeId") Integer schemeId,
            @ApiParam(name = "condition", value = "Search param,Must be json")
            @RequestParam(value = "condition", required = false) String condition,
            @ApiParam(name = "order", value = "Order param,Must be json.ascending:asc,descending:desc")
            @RequestParam(value = "order", required = false) String order,
            @ApiParam(name = "rows", value = "Limit the size of result set. Must be an integer")
            @RequestParam(value = "rows", required = false) Integer rows,
            @ApiParam(name = "page", value = "Start position of result set. Must be an integer")
            @RequestParam(value = "page", required = false) Integer page) {
        return adapterSchemeVersion.getDictionaryResult(schemeId, condition, order, rows, page);
    }
}

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

@@ -0,0 +1,121 @@
package com.yihu.jw.basic.standard.controller;
import com.yihu.jw.basic.standard.model.standard.resultModel.StandardParamResultModel;
import com.yihu.jw.basic.standard.service.standard.StandardService;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.ListEnvelop;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import com.yihu.jw.util.sql.SqlConstants;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
@RestController("StandardController")
@RequestMapping("/standardCenter")
@Api(protocols = "https", value = "StandardController", description = "标准管理", tags = {"标准"})
public class StandardController extends EnvelopRestEndpoint {
    @Resource(name = StandardService.BEAN_ID)
    private StandardService standardService;
    /**
     * 查询集成标准首页信息（get）
     * @param condition
     * @return
     * @throws Exception
     */
    @GetMapping("/searchStandard")
    @ApiOperation(value = "获取标准树列表", responseContainer = "List", notes = "获取标准列表")
    public ListEnvelop searchStandard(
            @ApiParam(name = "condition", value = "查询条件name：厂商、标准、标准版本名称，标准类别type：0为集成标准，1为应用标准")
            @RequestParam(value = "condition", required = false) String condition) {
        return standardService.getDetailModelResult(condition);
    }
    @GetMapping("/getSysParamList")
    @ApiOperation(value = "获取集成标准系统参数", notes = "获取集成标准系统参数")
    public ObjEnvelop getSysParamList() {
        StandardParamResultModel standardParamResultModel = standardService.getStandardParam(SqlConstants.STANDARD);
        return ObjEnvelop.getSuccess("获取成功",standardParamResultModel);
    }
    /**
     * 根据标准ID获取集成标准信息（get）
     * @param standardId
     * @return
     * @throws Exception
     */
    @GetMapping("/getForStandardId")
    @ApiOperation(value = "获取标准",  produces = "application/json", notes = "获取标准")
    public ObjEnvelop getForStandardId(
            @ApiParam(name = "standardId", value = "标准ID")
            @RequestParam(value = "standardId") Integer standardId){
        return standardService.get(standardId);
    }
    /**
     * 修改标准信息（PUT）
     * @param standard
     * @return
     * @throws Exception
     */
    @PostMapping("/updateStandard")
    @ApiOperation(value = "修改标准",  produces = "application/json", notes = "修改标准")
    public ObjEnvelop modify(
            @ApiParam(name = "standard", value = "标准基本信息")
            @RequestParam(value = "standard") String standard) {
        return standardService.update(standard);
    }
    /**
     * 新增标准信息（POST）
     * @param standard
     * @return
     * @throws Exception
     */
    @PostMapping("/addStandard")
    @ApiOperation(value = "保存标准",  produces = "application/json", notes = "保存标准")
    public ObjEnvelop add(
            @ApiParam(name = "standard", value = "标准基本信息")
            @RequestParam(value = "standard") String standard) {
        return standardService.add(standard);
    }
    /**
     * 删除标准信息（DELETE）
     * @param  standardId
     * @return
     * @throws Exception
     */
    @PostMapping("/deleteStandard")
    @ApiOperation(value = "删除标准",  produces = "application/json", notes = "删除标准")
    public Envelop delete(
            @ApiParam(name = "standardId", value = "标准ID")
            @RequestParam(value = "standardId") Integer standardId) {
        return standardService.delete(standardId);
    }
    /**
     * 获取平台标准名称/应用标准名称列表
     * @param condition
     * @return
     * @throws Exception
     */
    @GetMapping(value = "/getStandards")
    @ApiOperation(value = "获取标准列表",  produces = "application/json", notes = "获取标准列表")
    public ListEnvelop getStandardList(
            @ApiParam(name = "condition", value = "Must be Json,其中type为区分集成与应用标准")
            @RequestParam(value = "condition", required = false) String condition,
            @ApiParam(name = "order", value = "Must be Json")
            @RequestParam(value = "order", required = false) String order,
            @ApiParam(name = "rows", value = "Limit the size of result set. Must be an integer")
            @RequestParam(value = "rows", required = false) Integer rows,
            @ApiParam(name = "page", value = "Start position of result set. Must be an integer")
            @RequestParam(value = "page", required = false) Integer page) {
        return standardService.getDictionaryResult( order, rows, page);
    }
}

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

@@ -0,0 +1,194 @@
package com.yihu.jw.basic.standard.controller;
import com.yihu.jw.basic.standard.service.standard.StandardVersionService;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.ListEnvelop;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
/**
 * Created by LLH on 2016/1/6.
 */
@RestController("StandardVersionController")
@RequestMapping("/standardCenter")
@Api(protocols = "https", value = "StandardVersionController", description = "标准版本管理", tags = {"标准版本"})
public class StandardVersionController extends EnvelopRestEndpoint {
    @Resource(name = StandardVersionService.BEAN_ID)
    private StandardVersionService standardVersionService;
    /**
     * 根据版本id获取标准版本信息（get）
     * @param versionId
     * @return
     * @throws Exception
     */
    @GetMapping("/getForVersionId")
    @ApiOperation(value = "获取标准版本", produces = "application/json", notes = "获取标准版本")
    public ObjEnvelop getForVersionId(
            @ApiParam(name = "versionId", value = "标准版本ID")
            @RequestParam(value = "versionId") Integer versionId) {
        return standardVersionService.get(versionId);
    }
    /**
     * 新增版本（post）
     * @param version
     * @return
     * @throws Exception
     */
    @PostMapping("/addVersion")
    @ApiOperation(value = "保存标准版本",  produces = "application/json", notes = "保存标准版本")
    public ObjEnvelop addVersion(
            @ApiParam(name = "version", value = "标准版本信息")
            @RequestParam(value = "version") String version) throws Exception {
        return standardVersionService.add(version);
    }
    /**
     * 修改版本（put）
     * @param version
     * @return
     * @throws Exception
     */
    @PostMapping("/updateVersion")
    @ApiOperation(value = "修改版本", produces = "application/json", notes = "修改版本")
    public ObjEnvelop updateVersion(
            @ApiParam(name = "version", value = "标准版本")
            @RequestParam(value = "version") String version) throws Exception {
        return standardVersionService.update(version);
    }
    /**
     * 发布版本（post）
     * @param versionId
     * @param publisher
     * @return
     * @throws Exception
     */
    @PostMapping("/publishVersion")
    @ApiOperation(value = "发布版本", produces = "application/json", notes = "发布版本")
    public ObjEnvelop publish(
            @ApiParam(name = "versionId", value = "标准版本ID")
            @RequestParam(value = "versionId") Integer versionId,
            @ApiParam(name = "publisher", value = "发布者")
            @RequestParam(value = "publisher") String publisher) throws Exception {
        return standardVersionService.publish(versionId, publisher);
    }
    /**
     * 删除版本（put）
     * @param versionId
     * @return
     * @throws Exception
     */
    @PostMapping("/deleteVersion")
    @ApiOperation(value = "删除版本", produces = "application/json", notes = "删除版本")
    public Envelop delete(
            @ApiParam(name = "versionId", value = "标准版本ID")
            @RequestParam(value = "versionId") Integer versionId,
            @ApiParam(name = "version", value = "标准版本值")
            @RequestParam(value = "version") String version) throws Exception {
        return standardVersionService.delete(versionId,version);
    }
    /**
     * 获取基础版本名称列表
     * @param standardId
     * @return
     * @throws Exception
     */
    @GetMapping("/getVersions")
    @ApiOperation(value = "获取标准版本列表",  produces = "application/json", notes = "获取标准版本列表")
    public ListEnvelop getVersions(
            @ApiParam(name = "standardId", value = "标准ID")
            @RequestParam(value = "standardId") Integer standardId,
            @ApiParam(name = "condition", value = "Must be Json")
            @RequestParam(value = "condition", required = false) String condition,
            @ApiParam(name = "order", value = "Must be Json")
            @RequestParam(value = "order", required = false) String order,
            @ApiParam(name = "rows", value = "Limit the size of result set. Must be an integer")
            @RequestParam(value = "rows", required = false) Integer rows,
            @ApiParam(name = "page", value = "Start position of result set. Must be an integer")
            @RequestParam(value = "page", required = false) Integer page) {
        return standardVersionService.getDetailResultModelList(standardId, condition, order, rows, page);
    }
    /**
     * 根据类型文件上传保存对应的数据
     *
     * @param type
     * @param file
     * @return
     * @throws Exception
     */
    @RequestMapping(value = "/importFile", method = RequestMethod.POST)
    @ApiOperation(value = "根据type导入数据接口", response = Object.class, produces = "application/json", notes = "导入数据接口")
    public Envelop importFile(@ApiParam(value = "类型（1:数据集 2:字典 3:机构数据 4：机构字典）", required = true) @RequestParam("type") String type,
                             @ApiParam(value = "项目版本", required = true) @RequestParam("version") String version,
                             @ApiParam(value = "项目版本", required = true) @RequestParam("standardId") Integer standardId,
                             @ApiParam(value = "文件", required = true, allowMultiple = true) @RequestParam("file") MultipartFile file){
        try {
            String id = "";
            //根據类别判断上传的文件1:数据集 2:字典
            if("1".equals(type)){
                version = standardVersionService.saveDatasetExcel(file, version,standardId);
            }else {
                version = standardVersionService.saveDictExcel(file, version,standardId);
            }
            //解析excel文件 保存
            return ObjEnvelop.getSuccess("操作成功","{\"version\":\"" + version + "\"}");
        } catch (Exception e) {
            e.printStackTrace();
            return Envelop.getError("操作失败",-1);
        }
    }
    @RequestMapping(value = "/isUpdateDatasetAndDict", method = RequestMethod.POST)
    @ApiOperation(value = "项目列表",  produces = "application/json", notes = "项目列表")
    public Envelop isUpdateDatasetAndDict(
            @RequestParam(required = true) String version) {
        try {
            return ObjEnvelop.getSuccess("操作成功",standardVersionService.isUpdateDatasetAndDict(version));
        } catch (Exception e) {
            e.printStackTrace();
            return Envelop.getError("操作失败",-1);
        }
    }
    /**
     * 根据类型和主键删除数据
     *
     * @param type
     * @return
     * @throws Exception
     */
    @RequestMapping(value = "/deleteByType", method = RequestMethod.POST)
    @ApiOperation(value = "文件上传成功后的删除",  produces = "application/json", notes = "文件上传成功后的删除")
    public Envelop deleteByType(
            @ApiParam(value = "类型（1:数据集 2:字典 ）", required = true) @RequestParam("type") String type,
            @ApiParam(value = "主键(上传成功后返回的ID)", required = true) @RequestParam("version") String version) {
        try {
            //根據类别判断上传的文件1:数据集 2:字典 删除数据
            switch (type) {
                case "1": {
                    standardVersionService.deleteDataset(version);
                    break;
                }
                case "2": {
                    standardVersionService.deleteDict(version);
                    break;
                }
            }
        } catch (Exception e) {
            return Envelop.getError("操作失败",-1);
        }
        return Envelop.getSuccess("操作成功");
    }
}

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

@@ -0,0 +1,127 @@
package com.yihu.jw.basic.standard.controller;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.jw.basic.standard.service.standard.StdDatasetService;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.restmodel.web.PageEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import com.yihu.jw.util.common.StringUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;
/**
 * Created by LLH on 2016/1/6.
 */
@RestController("StdDatasetController")
@RequestMapping("/standardCenter")
@Api(protocols = "https", value = "StdDatasetController", description = "标准数据集管理", tags = {"标准数据集"})
public class StdDatasetController extends EnvelopRestEndpoint {
    @Resource(name = StdDatasetService.BEAN_ID)
    private StdDatasetService stdDatasetService;
    /**
     * 查询数据集列表信息（get）
     * @param stdVersion
     * @param condition
     * @param order
     * @param rows
     * @param page
     * @return
     * @throws Exception
     */
    @GetMapping("/searchDatasetList")
    @ApiOperation(value = "获取数据集列表",  produces = "application/json", notes = "获取数据集列表")
    public PageEnvelop searchDatasetList(
            @ApiParam(name = "stdVersion", value = "标准版本号")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "condition", value = "查询条件：编码或名称")
            @RequestParam(value = "condition", required = false) String condition,
            @ApiParam(name = "order", value = "Order param,Must be json.ascending:asc,descending:desc")
            @RequestParam(value = "order", required = false) String order,
            @ApiParam(name = "rows", value = "Limit the size of result set. Must be an integer")
            @RequestParam(value = "rows", required = false) Integer rows,
            @ApiParam(name = "page", value = "Start position of result set. Must be an integer")
            @RequestParam(value = "page", required = false) Integer page) {
        return stdDatasetService.getDetailModelList(stdVersion, condition, order, rows, page);
    }
    @GetMapping("/getForDatasetId")
    @ApiOperation(value = "获取数据集",  produces = "application/json", notes = "获取数据集")
    public ObjEnvelop getForDatasetId(
            @ApiParam(name = "stdVersion", value = "标准版本号")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "datasetId", value = "数据集ID")
            @RequestParam(value = "datasetId") Integer datasetId) {
        return stdDatasetService.get(stdVersion, datasetId);
    }
    @PostMapping("/delDataset")
    @ApiOperation(value = "删除数据集",  produces = "application/json", notes = "删除数据集")
    public Envelop delDataset(
            @ApiParam(name = "stdVersion", value = "标准版本号")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "datasetId", value = "数据集ID")
            @RequestParam(value = "datasetId") Integer datasetId) {
        return stdDatasetService.delete(stdVersion, datasetId);
    }
    @PostMapping("/updateDataset")
    @ApiOperation(value = "修改数据集",  produces = "application/json", notes = "修改数据集")
    public ObjEnvelop updateDataset(
            @ApiParam(name = "stdVersion", value = "标准版本号")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "dataset", value = "数据集")
            @RequestParam(value = "dataset") String dataset) {
        return stdDatasetService.update(stdVersion, dataset);
    }
    @PostMapping("/addDataset")
    @ApiOperation(value = "保存数据集",  produces = "application/json", notes = "保存数据集")
    public ObjEnvelop add(
            @ApiParam(name = "stdVersion", value = "标准版本号")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "dataset", value = "数据集")
            @RequestParam(value = "dataset") String dataset) {
        return stdDatasetService.add(stdVersion, dataset);
    }
    @GetMapping(value="/getDatasetCodeValues")
    @ApiOperation(value = "获取数据集下拉框信息",  produces = "application/json", notes = "获取机构数据元下拉框信息")
    public PageEnvelop getSelectList(
            @ApiParam(name = "stdVersion", value = "标准版本号")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "q", value = "数据集名称或编码", required = false)
            @RequestParam(value = "q", required = false) String q,
            @ApiParam(name = "initVal", value = "初始化数据集名称或编码", required = false)
            @RequestParam(value = "initVal", required = false) String initVal,
            @ApiParam(name = "order", value = "Order param,Must be json.ascending:asc,descending:desc")
            @RequestParam(value = "order", required = false) String order,
            @ApiParam(name = "rows", value = "Limit the size of result set. Must be an integer")
            @RequestParam(value = "rows", required = false) Integer rows,
            @ApiParam(name = "page", value = "Start position of result set. Must be an integer")
            @RequestParam(value = "page", required = false) Integer page) {
        Map<String,String> condition = new HashMap<String,String>();
        ObjectMapper mapper = new ObjectMapper();
        if(!StringUtil.isEmpty(q)){
            condition.put("name", q);
            rows = 10;
        }
        else if(!StringUtil.isEmpty(initVal)){
            condition.put("initVal", initVal);//默认值
        }
        String conditionStr = null;
        try {
             conditionStr = mapper.writeValueAsString(condition);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return stdDatasetService.getDatasetSelectList(stdVersion, conditionStr, order, rows, 0);
    }
}

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

@@ -0,0 +1,153 @@
package com.yihu.jw.basic.standard.controller;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.jw.basic.standard.model.standard.StdDictionaryModel;
import com.yihu.jw.basic.standard.service.standard.StdDictService;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.ListEnvelop;
import com.yihu.jw.restmodel.web.PageEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import com.yihu.jw.util.common.StringUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * Created by LLH on 2016/1/6.
 */
@RestController("StdDictController")
@RequestMapping("/standardCenter")
@Api(protocols = "https", value = "StdDictController", description = "标准字典管理", tags = {"标准字典"})
public class StdDictController extends EnvelopRestEndpoint {
    @Resource(name = StdDictService.BEAN_ID)
    StdDictService stdDictService;
    /**
     * 查询字典列表信息（get）
     * @param stdVersion
     * @param condition
     * @param order
     * @param rows
     * @param page
     * @return
     * @throws Exception
     */
    @GetMapping("/searchDictList")
    @ApiOperation(value = "获取字典列表",produces = "application/json", notes = "获取字典列表")
    public PageEnvelop getDictList(
            @ApiParam(name = "stdVersion", value = "标准版本号")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "condition", value = "查询条件：编码或名称")
            @RequestParam(value = "condition", required = false) String condition,
            @ApiParam(name = "order", value = "Order param,Must be json.ascending:asc,descending:desc")
            @RequestParam(value = "order", required = false) String order,
            @ApiParam(name = "rows", value = "Limit the size of result set. Must be an integer")
            @RequestParam(value = "rows", required = false) Integer rows,
            @ApiParam(name = "page", value = "Start position of result set. Must be an integer")
            @RequestParam(value = "page", required = false) Integer page) {
        return stdDictService.getDetailModelList(stdVersion, condition, order, rows, page);
    }
    @GetMapping("/getForDictId")
    @ApiOperation(value = "获取字典",  produces = "application/json", notes = "获取字典")
    public Envelop get(
            @ApiParam(name = "stdVersion", value = "stdVersion")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "dictId", value = "字典ID")
            @RequestParam(value = "dictId") Integer dictId) {
        return stdDictService.get(stdVersion, dictId);
    }
    @PostMapping("/delDict")
    @ApiOperation(value = "删除字典",  produces = "application/json", notes = "删除字典")
    public Envelop delete(
            @ApiParam(name = "stdVersion", value = "stdVersion")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "dictId", value = "字典ID")
            @RequestParam(value = "dictId") Integer dictId) {
        return stdDictService.delete(stdVersion, dictId);
    }
    
    @PostMapping("/updateDict")
    @ApiOperation(value = "修改字典",  produces = "application/json", notes = "修改字典")
    public Envelop modify(
            @ApiParam(name = "stdVersion", value = "stdVersion")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "dict", value = "字典")
            @RequestParam(value = "dict") String dict) {
        return stdDictService.update(stdVersion, dict);
    }
    @PostMapping("/addDict")
    @ApiOperation(value = "保存字典",  produces = "application/json", notes = "保存字典")
    public Envelop addDict(
            @ApiParam(name = "stdVersion", value = "stdVersion")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "dict", value = "字典")
            @RequestParam(value = "dict") String dict) {
        return stdDictService.add(stdVersion, dict);
    }
    @GetMapping(value="/getDictCodeValues")
    @ApiOperation(value = "获取字典下拉框信息",  produces = "application/json", notes = "获取字典下拉框信息")
    public PageEnvelop getSelectList(
            @ApiParam(name = "stdVersion", value = "标准版本号")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "q", value = "数据集名称或编码", required = false)
            @RequestParam(value = "q", required = false) String q,
            @ApiParam(name = "initVal", value = "初始化数据集名称或编码", required = false)
            @RequestParam(value = "initVal", required = false) String initVal,
            @ApiParam(name = "order", value = "Order param,Must be json.ascending:asc,descending:desc")
            @RequestParam(value = "order", required = false) String order,
            @ApiParam(name = "rows", value = "Limit the size of result set. Must be an integer")
            @RequestParam(value = "rows", required = false) Integer rows,
            @ApiParam(name = "page", value = "Start position of result set. Must be an integer")
            @RequestParam(value = "page", required = false) Integer page) {
        Map<String,String> condition = new HashMap<String,String>();
        if(!StringUtil.isEmpty(q)){
            condition.put("name", q);
        }
        else if(!StringUtil.isEmpty(initVal)){
            condition.put("initVal", initVal);//默认值
        }
        ObjectMapper mapper = new ObjectMapper();
        String conditionStr = null;
        try {
            conditionStr = mapper.writeValueAsString(condition);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        List<StdDictionaryModel> dictList = stdDictService.getDictList(StdDictionaryModel.class, stdVersion, conditionStr, order, rows, 0);
        return stdDictService.getDictSelectList(dictList);
    }
    /**
     * 获取对应字典/参考字典列表
     * @param stdVersion
     * @return
     * @throws Exception
     */
    @GetMapping("/getDicts")
    @ApiOperation(value = "获取字典列表",  produces = "application/json", notes = "获取字典列表")
    public ListEnvelop getList(
            @ApiParam(name = "stdVersion", value = "stdVersion")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "condition", value = "Must be Json")
            @RequestParam(value = "condition", required = false) String condition,
            @ApiParam(name = "order", value = "Must be Json")
            @RequestParam(value = "order", required = false) String order,
            @ApiParam(name = "rows", value = "Limit the size of result set. Must be an integer")
            @RequestParam(value = "rows", required = false) Integer rows,
            @ApiParam(name = "page", value = "Start position of result set. Must be an integer")
            @RequestParam(value = "page", required = false) Integer page) {
        return stdDictService.getDictionaryList(stdVersion, condition, order, rows, page);
    }
}

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

@@ -0,0 +1,134 @@
package com.yihu.jw.basic.standard.controller;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.jw.basic.standard.service.standard.StdDictEntryService;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.PageEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import com.yihu.jw.util.common.StringUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;
/**
 * Created by LLH on 2016/1/6.
 */
@RestController("StdDictEntryController")
@RequestMapping("/standardCenter")
@Api(protocols = "https", value = "StdDictEntryController", description = "标准字典项管理", tags = {"标准字典项"})
public class StdDictEntryController extends EnvelopRestEndpoint {
    @Resource(name = StdDictEntryService.BEAN_ID)
    StdDictEntryService stdDictEntryService;
    /**
     * 查询字典项列表信息（get）
     * @param stdVersion
     * @param dictId
     * @param condition
     * @param order
     * @param rows
     * @param page
     * @return
     * @throws Exception
     */
    @GetMapping("/searchDictEntryList")
    @ApiOperation(value = "获取字典项列表",  responseContainer = "List",produces = "application/json", notes = "获取字典项列表")
    public PageEnvelop getDictEntryList(
            @ApiParam(name = "stdVersion", value = "标准版本号")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "dictId", value = "字典ID")
            @RequestParam(value = "dictId") Integer dictId,
            @ApiParam(name = "condition", value = "查询条件")
            @RequestParam(value = "condition", required = false) String condition,
            @ApiParam(name = "order", value = "Order param,Must be json.ascending:asc,descending:desc")
            @RequestParam(value = "order", required = false) String order,
            @ApiParam(name = "rows", value = "Limit the size of result set. Must be an integer")
            @RequestParam(value = "rows", required = false) Integer rows,
            @ApiParam(name = "page", value = "Start position of result set. Must be an integer")
            @RequestParam(value = "page", required = false) Integer page) {
        return stdDictEntryService.getDetailModelList(stdVersion, dictId, condition, order, rows, page);
    }
    @GetMapping("/getForDictEntryId")
    @ApiOperation(value = "获取字典", produces = "application/json", notes = "获取字典")
    public Envelop get(
            @ApiParam(name = "stdVersion", value = "stdVersion")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "dictEntryId", value = "字典ID")
            @RequestParam(value = "dictEntryId") Integer dictEntryId) {
        return stdDictEntryService.get(stdVersion, dictEntryId);
    }
    @PostMapping("/delDictEntry")
    @ApiOperation(value = "删除字典", produces = "application/json", notes = "删除字典")
    public Envelop delete(
            @ApiParam(name = "stdVersion", value = "stdVersion")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "dictEntryId", value = "字典ID")
            @RequestParam(value = "dictEntryId") Integer dictEntryId) {
        return stdDictEntryService.delete(stdVersion, dictEntryId);
    }
    @PostMapping("/updateDictEntry")
    @ApiOperation(value = "修改字典", produces = "application/json", notes = "修改字典")
    public Envelop modify(
            @ApiParam(name = "stdVersion", value = "stdVersion")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "dictEntry", value = "字典")
            @RequestParam(value = "dictEntry") String dictEntry) {
        return stdDictEntryService.update(stdVersion, dictEntry);
    }
    @PostMapping("/addDictEntry")
    @ApiOperation(value = "保存字典",  produces = "application/json", notes = "保存字典")
    public Envelop add(
            @ApiParam(name = "stdVersion", value = "stdVersion")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "dictEntry", value = "字典")
            @RequestParam(value = "dictEntry") String dictEntry) {
        return stdDictEntryService.add(stdVersion, dictEntry);
    }
    @GetMapping(value="/getDictEntryCodeValues")
    @ApiOperation(value = "获取字典下拉框信息",  produces = "application/json", notes = "获取适配字典下拉框信息")
    public PageEnvelop searchOrgDictItem(
            @ApiParam(name = "stdVersion", value = "标准版本号")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "dictId", value = "数据集ID")
            @RequestParam(value = "dictId") Integer dictId,
            @ApiParam(name = "q", value = "字典名称或编码", required = false)
            @RequestParam(value = "q", required = false) String q,
            @ApiParam(name = "initDictValue", value = "初始化字典名称或编码", required = false)
            @RequestParam(value = "initDictValue", required = false) String initDictValue,
            @ApiParam(name = "order", value = "Order param,Must be json.ascending:asc,descending:desc")
            @RequestParam(value = "order", required = false) String order,
            @ApiParam(name = "rows", value = "Limit the size of result set. Must be an integer")
            @RequestParam(value = "rows", required = false) Integer rows,
            @ApiParam(name = "page", value = "Start position of result set. Must be an integer")
            @RequestParam(value = "page", required = false) Integer page) {
        Map<String,String> condition = new HashMap<String,String>();
        if (StringUtil.isEmpty(initDictValue)) {
            initDictValue = "";
        }
        if(StringUtil.isEmpty(q)){
            condition.put("name", initDictValue);
        }else{
            condition.put("name", q);
        }
        ObjectMapper mapper = new ObjectMapper();
        String conditionStr = null;
        try {
            conditionStr = mapper.writeValueAsString(condition);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return stdDictEntryService.getDictEntrySelectList(stdVersion, dictId, conditionStr, order, rows, 0);
    }
}

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

@@ -0,0 +1,137 @@
package com.yihu.jw.basic.standard.controller;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.jw.basic.standard.service.standard.StdDictService;
import com.yihu.jw.basic.standard.service.standard.StdMetadataService;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.restmodel.web.PageEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import com.yihu.jw.util.common.StringUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;
/**
 * Created by LLH on 2016/1/6.
 */
@RestController("StdMetadataController")
@RequestMapping("/standardCenter")
@Api(protocols = "https", value = "StdMetadataController", description = "标准数据元管理", tags = {"标准数据元"})
public class StdMetadataController extends EnvelopRestEndpoint {
    @Resource(name = StdMetadataService.BEAN_ID)
    StdMetadataService stdMetadataService;
    @Resource(name = StdDictService.BEAN_ID)
    StdDictService stdDictService;
    /**
     * 查询数据元列表信息（get）
     * @param stdVersion
     * @param datasetId
     * @param condition
     * @param order
     * @param rows
     * @param page
     * @return
     * @throws Exception
     */
    @GetMapping("/searchMetadataList")
    @ApiOperation(value = "获取数据元列表",  produces = "application/json", notes = "获取数据元列表")
    public PageEnvelop getMetadataList(
            @ApiParam(name = "stdVersion", value = "标准版本号")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "datasetId", value = "数据集ID")
            @RequestParam(value = "datasetId") Integer datasetId,
            @ApiParam(name = "condition", value = "查询条件")
            @RequestParam(value = "condition", required = false) String condition,
            @ApiParam(name = "order", value = "Order param,Must be json.ascending:asc,descending:desc")
            @RequestParam(value = "order", required = false) String order,
            @ApiParam(name = "rows", value = "Limit the size of result set. Must be an integer")
            @RequestParam(value = "rows", required = false) Integer rows,
            @ApiParam(name = "page", value = "Start position of result set. Must be an integer")
            @RequestParam(value = "page", required = false) Integer page) {
        return stdMetadataService.getDetailModelList(stdVersion, datasetId, condition, order, rows, page);
    }
    @GetMapping("/getForMetadataId")
    @ApiOperation(value = "获取数据元",  produces = "application/json", notes = "获取数据元")
    public ObjEnvelop getForMetadataId(
            @ApiParam(name = "stdVersion", value = "stdVersion")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "metadataId", value = "数据元ID")
            @RequestParam(value = "metadataId") Integer metadataId) {
        return stdMetadataService.get(stdVersion, metadataId);
    }
    @PostMapping("/delMetaData")
    @ApiOperation(value = "删除数据元",  produces = "application/json", notes = "删除数据元")
    public Envelop delMetaData(
            @ApiParam(name = "stdVersion", value = "stdVersion")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "metadataId", value = "数据元ID")
            @RequestParam(value = "metadataId") Integer metadataId) {
        return stdMetadataService.delete(stdVersion, metadataId);
    }
    @PostMapping("/updateMetadata")
    @ApiOperation(value = "修改数据元",  produces = "application/json", notes = "修改数据元")
    public ObjEnvelop updateMetadata(
            @ApiParam(name = "stdVersion", value = "stdVersion")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "metadata", value = "数据元")
            @RequestParam(value = "metadata") String metadata) {
        return stdMetadataService.update(stdVersion, metadata);
    }
    @PostMapping("/addMetadata")
    @ApiOperation(value = "保存数据元",  produces = "application/json", notes = "保存数据元")
    public ObjEnvelop addMetadata(
            @ApiParam(name = "stdVersion", value = "stdVersion")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "metadata", value = "数据元")
            @RequestParam(value = "metadata") String metadata) {
        return stdMetadataService.add(stdVersion, metadata);
    }
    @GetMapping(value="/getMetadataCodeValues")
    @ApiOperation(value = "获取数据元下拉框信息",  produces = "application/json", notes = "获取机构数据元下拉框信息")
    public PageEnvelop getSelectList(
            @ApiParam(name = "stdVersion", value = "标准版本号")
            @RequestParam(value = "stdVersion") String stdVersion,
            @ApiParam(name = "datasetId", value = "数据集ID")
            @RequestParam(value = "datasetId") Integer datasetId,
            @ApiParam(name = "q", value = "数据元名称或编码", required = false)
            @RequestParam(value = "q", required = false) String q,
            @ApiParam(name = "initMetadataNm", value = "初始化数据元名称或编码", required = false)
            @RequestParam(value = "initMetadataNm", required = false) String initMetadataNm,
            @ApiParam(name = "order", value = "Order param,Must be json.ascending:asc,descending:desc")
            @RequestParam(value = "order", required = false) String order,
            @ApiParam(name = "rows", value = "Limit the size of result set. Must be an integer")
            @RequestParam(value = "rows", required = false) Integer rows,
            @ApiParam(name = "page", value = "Start position of result set. Must be an integer")
            @RequestParam(value = "page", required = false) Integer page) {
        Map<String,String> condition = new HashMap<String,String>();
        if (StringUtil.isEmpty(initMetadataNm)) {
            initMetadataNm = "";
        }
        if(StringUtil.isEmpty(q)){
            condition.put("name", initMetadataNm);
        }else{
            condition.put("name", q);
        }
        ObjectMapper mapper = new ObjectMapper();
        String conditionStr = null;
        try {
            conditionStr = mapper.writeValueAsString(condition);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return stdMetadataService.getMetadataSelectList(stdVersion, datasetId, conditionStr, order, rows, 0);
    }
}

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

@@ -0,0 +1,29 @@
package com.yihu.jw.basic.standard.dao;
import com.yihu.jw.basic.standard.model.adapter.AdapterMetadataModel;
import com.yihu.jw.basic.standard.dao.XSQLGeneralDAO;
import java.util.List;
/**
 * Created by Administrator on 2016/5/4.
 */
public interface IStdAdapterMetadataDao extends XSQLGeneralDAO {
    List<AdapterMetadataModel> getAdapterMetadataByMetadateId(String metedataId) throws Exception;
    List<AdapterMetadataModel> getAdapterMetadataByDatasetIdAndStatus(String id, String s) throws Exception;
    void updateAdapterMetadataStatus(String id, String s) throws Exception;
    List<AdapterMetadataModel> getAdapterMetadataByAdaptMetadateId(String AdaptMetadateId)throws Exception;
    List<AdapterMetadataModel> getAdapterMetadataByMetadateIdAndStatus(String id, String type)throws Exception;
    List<AdapterMetadataModel> getAdapterMetadataByAdaptMetadateIdAndStdDataSetId(String AdaptMetadateId, String stdDataSetId)throws Exception;
    List<AdapterMetadataModel> getAdapterMetadataByProjectId(String id)throws Exception;
    List<AdapterMetadataModel> getAdapterMetadataByDatasetId(String dataSetId)throws Exception;
}

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

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

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

@@ -0,0 +1,14 @@
package com.yihu.jw.basic.standard.dao;
import com.yihu.jw.basic.standard.model.standard.StdDictionaryEntryModel;
import com.yihu.jw.basic.standard.dao.XSQLGeneralDAO;
import java.util.List;
/**
 * Created by Administrator on 2017/4/19 0019.
 */
public interface IStdDictionaryEntryModelDao extends XSQLGeneralDAO {
    List<StdDictionaryEntryModel> getDictionaryEntry(String adapter_std_version, String orgDicEntryValue,String orgDicValue);
}

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

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

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

@@ -0,0 +1,13 @@
package com.yihu.jw.basic.standard.dao;
import com.yihu.jw.basic.standard.model.standard.StdMetaDataModel;
import com.yihu.jw.basic.standard.dao.XSQLGeneralDAO;
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);
}

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

@@ -0,0 +1,488 @@
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.util.common.NumberUtil;
import com.yihu.jw.util.common.StringUtil;
import com.yihu.jw.util.sql.SqlCreator;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
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.jdbc.core.RowMapper;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.io.IOException;
import java.io.Serializable;
import java.math.BigInteger;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
 * @author HZY
 * @vsrsion 1.0
 * Created at 2016/8/8.
 */
@Repository("sqlGeneralDAO")
public class SQLGeneralDAO implements XSQLGeneralDAO {
    static private final Logger logger = LoggerFactory.getLogger(SQLGeneralDAO.class);
    @Autowired
    protected ObjectMapper objectMapper;
    @Resource(
            name = "jdbcTemplate"
    )
    protected JdbcTemplate jdbcTemplate;
    @PersistenceContext
    protected EntityManager entityManager;
    public SQLGeneralDAO() {
    }
    public JdbcTemplate getJdbcTemplate() {
        return this.jdbcTemplate;
    }
    public Session currentSession() {
        return entityManager.unwrap(Session.class);
    }
    public DataGridResult getDataGridResult(String hql, Integer page, Integer rows) {
        DataGridResult dataGridResult = new DataGridResult();
        Query query = currentSession().createQuery(hql);
        if (page != null && rows != null) {
            dataGridResult.setPageSize(rows.intValue());
            dataGridResult.setCurrPage(page.intValue());
            dataGridResult.setTotalCount(query.list().size());
            query.setMaxResults(rows.intValue());
            query.setFirstResult((page.intValue() - 1) * rows.intValue());
            dataGridResult.setDetailModelList(query.list());
        } else {
            List list = query.list();
            dataGridResult.setDetailModelList(list);
            dataGridResult.setTotalCount(list.size());
        }
        return dataGridResult;
    }
    public DataGridResult getDataGridResult(Query query, Integer page, Integer rows) {
        DataGridResult dataGridResult = new DataGridResult();
        if (page != null && rows != null) {
            dataGridResult.setPageSize(rows.intValue());
            dataGridResult.setCurrPage(page.intValue());
            dataGridResult.setTotalCount(query.list().size());
            query.setMaxResults(rows.intValue());
            query.setFirstResult((page.intValue() - 1) * rows.intValue());
            dataGridResult.setDetailModelList(query.list());
        } else {
            List list = query.list();
            dataGridResult.setDetailModelList(list);
            dataGridResult.setTotalCount(list.size());
        }
        return dataGridResult;
    }
    public void beginTransaction() throws Exception {
        currentSession().getTransaction().begin();
    }
    public void commitTransaction() throws Exception {
        currentSession().getTransaction().commit();
    }
    public void saveEntity(Object entity) throws Exception {
        if (entity != null) {
            currentSession().save(entity);
        }
    }
    public void updateEntity(Object entity) throws Exception {
        if (entity != null) {
            currentSession().update(entity);
        }
    }
    public void saveOrUpdateEntity(Object entity) throws Exception {
        if (entity != null) {
            currentSession().saveOrUpdate(entity);
        }
    }
    public void mergeEntity(Object entity) throws Exception {
        if (entity != null) {
            currentSession().merge(entity);
        }
    }
    public void deleteEntity(Object entity) throws Exception {
        if (entity != null) {
            currentSession().delete(entity);
        }
    }
    public <T> void deleteEntity(Class<T> cls, Serializable id) throws Exception {
        Object obj = currentSession().load(cls, id);
        currentSession().delete(obj);
    }
    public <T> T getEntity(Class<T> cls, Serializable id) throws Exception {
        return currentSession().get(cls, id);
    }
    public List<Map<String, Object>> queryListBySql(String sql) throws Exception {
        List result = this.jdbcTemplate.queryForList(sql);
        return result;
    }
    public List<Map<String, Object>> queryListBySql(String sql, List params) throws Exception {
        List result = this.jdbcTemplate.queryForList(sql, params.toArray());
        return result;
    }
    public <T> List<T> queryListBySql(String sql, Class obj) throws Exception {
        RowMapper<T> rowMapper = BeanPropertyRowMapper.newInstance(obj);
        List result = this.jdbcTemplate.query(sql, rowMapper);
        return result;
    }
    public <T> List<T> queryListBySql(String sql, List params, Class obj) throws Exception {
        RowMapper<T> rowMapper = BeanPropertyRowMapper.newInstance(obj);
        List result = this.jdbcTemplate.query(sql, params.toArray(), rowMapper);
        return result;
    }
    public <T> T queryObjBySql(String sql, List params, Class obj) throws Exception {
        RowMapper<T> rowMapper = BeanPropertyRowMapper.newInstance(obj);
        T result = this.jdbcTemplate.queryForObject(sql, params.toArray(), rowMapper);
        return result;
    }
    public <T> T queryObjBySql(String sql, Class obj) throws Exception {
        RowMapper<T> rowMapper = BeanPropertyRowMapper.newInstance(obj);
        T result = this.jdbcTemplate.queryForObject(sql, rowMapper);
        return result;
    }
    public <T> T scalarBySql(String sql, Class cls) throws Exception {
        T result = (T) this.jdbcTemplate.queryForObject(sql, cls);
        return result;
    }
    public void execute(String sql) throws Exception {
        this.jdbcTemplate.execute(sql);
    }
    public <T> List getEntityList(Class<T> cls, String hql) {
        Query query = this.getCurrentSession().createQuery(hql);
        return query.list();
    }
    public <T> List getEntityList(Class<T> cls, String condition, String order, Integer limit, Integer offset) throws IOException {
        Session session = this.getCurrentSession();
        Criteria criteria = session.createCriteria(cls);
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode jsonNode;
        Iterator fieldNames;
        String fieldName;
        if (!StringUtil.isEmpty(condition)) {
            jsonNode = objectMapper.readTree(condition);
            fieldNames = jsonNode.fieldNames();
            while (fieldNames.hasNext()) {
                fieldName = (String) fieldNames.next();
                if (jsonNode.get(fieldName).isInt()) {
                    criteria.add(Restrictions.eq(fieldName, Integer.valueOf(jsonNode.get(fieldName).asInt())));
                } else {
                    criteria.add(Restrictions.eq(fieldName, jsonNode.get(fieldName).asText()));
                }
            }
        }
        if (!StringUtil.isEmpty(order)) {
            jsonNode = objectMapper.readTree(order);
            fieldNames = jsonNode.fieldNames();
            while (fieldNames.hasNext()) {
                fieldName = (String) fieldNames.next();
                String value = jsonNode.get(fieldName).asText().toUpperCase();
                if (value.equals("ASC")) {
                    criteria.addOrder(Order.asc(fieldName));
                } else if (value.equals("DESC")) {
                    criteria.addOrder(Order.desc(fieldName));
                }
            }
        }
        if (limit != null) {
            criteria.setMaxResults(limit.intValue());
            if (offset != null) {
                criteria.setFirstResult((offset.intValue() - 1) * limit.intValue());
            }
        }
        return criteria.list();
    }
    public <T> List getEntityListByParentId(Class<T> cls, String parentFiledName, Integer patentId, String condition, String order, Integer limit, Integer offset) throws IOException {
        Session session = this.getCurrentSession();
        Criteria criteria = session.createCriteria(cls);
        criteria.add(Restrictions.eq(parentFiledName, patentId));
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode jsonNode;
        Iterator fieldNames;
        String fieldName;
        if (!StringUtil.isEmpty(condition)) {
            jsonNode = objectMapper.readTree(condition);
            fieldNames = jsonNode.fieldNames();
            while (fieldNames.hasNext()) {
                fieldName = (String) fieldNames.next();
                if (jsonNode.get(fieldName).isInt()) {
                    criteria.add(Restrictions.eq(fieldName, Integer.valueOf(jsonNode.get(fieldName).asInt())));
                } else {
                    criteria.add(Restrictions.eq(fieldName, jsonNode.get(fieldName).asText()));
                }
            }
        }
        if (!StringUtil.isEmpty(order)) {
            jsonNode = objectMapper.readTree(order);
            fieldNames = jsonNode.fieldNames();
            while (fieldNames.hasNext()) {
                fieldName = (String) fieldNames.next();
                String value = jsonNode.get(fieldName).asText().toUpperCase();
                if (value.equals("ASC")) {
                    criteria.addOrder(Order.asc(fieldName));
                } else if (value.equals("DESC")) {
                    criteria.addOrder(Order.desc(fieldName));
                }
            }
        }
        if (limit != null) {
            criteria.setMaxResults(limit.intValue());
            if (offset != null) {
                criteria.setFirstResult((offset.intValue() - 1) * limit.intValue());
            }
        }
        return criteria.list();
    }
    public List getList(Class tClass, String tableName, String condition, String order, Integer limit, Integer offset) {
        SqlCreator sqlCreator = new SqlCreator(tClass);
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            JsonNode sql;
            Iterator query;
            String fieldName;
            String value;
            if (!StringUtil.isEmpty(condition)) {
                sql = objectMapper.readTree(condition);
                query = sql.fieldNames();
                while (query.hasNext()) {
                    fieldName = (String) query.next();
                    value = sql.get(fieldName).asText();
                    if (sql.get(fieldName).getNodeType().equals(JsonNodeType.NUMBER)) {
                        sqlCreator.equalCondition(fieldName, Integer.valueOf(Integer.parseInt(value)));
                    } else {
                        sqlCreator.equalCondition(fieldName, value);
                    }
                }
            }
            if (!StringUtil.isEmpty(order)) {
                sql = objectMapper.readTree(order);
                query = sql.fieldNames();
                while (query.hasNext()) {
                    fieldName = (String) query.next();
                    value = sql.get(fieldName).asText().toUpperCase();
                    sqlCreator.order(fieldName, value);
                }
            }
        } catch (Exception var13) {
            var13.printStackTrace();
        }
        String sql1 = sqlCreator.selectData(tableName);
        Query query1 = this.getQuery(sqlCreator, sql1);
        if (limit != null) {
            query1.setMaxResults(limit.intValue());
            if (offset != null) {
                query1.setFirstResult(offset.intValue() * limit.intValue());
            }
        }
        return query1.list();
    }
    public List getListByIdList(Class tClass, String tableName, String fieldName, List<Integer> idList) {
        SqlCreator sqlCreator = new SqlCreator(tClass);
        try {
            sqlCreator.inCondition(fieldName, idList);
        } catch (Exception var8) {
            var8.printStackTrace();
            return null;
        }
        String sql = sqlCreator.selectData(tableName);
        Query query = this.getQuery(sqlCreator, sql);
        return query.list();
    }
    public Integer getDataSetInt(Class tClass, String tableName, String condition) {
        SqlCreator sqlCreator = new SqlCreator(tClass);
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            if (!StringUtil.isEmpty(condition)) {
                JsonNode sql = objectMapper.readTree(condition);
                Iterator query = sql.fieldNames();
                while (query.hasNext()) {
                    String count = (String) query.next();
                    String value = sql.get(count).asText();
                    if (NumberUtil.isInteger(value)) {
                        sqlCreator.equalCondition(count, Integer.valueOf(Integer.parseInt(value)));
                    } else {
                        sqlCreator.equalCondition(count, value);
                    }
                }
            }
        } catch (Exception var10) {
            var10.printStackTrace();
        }
        String sql1 = sqlCreator.countData(tableName);
        Query query1 = this.getQuery(sqlCreator, sql1);
        Integer count1 = Integer.valueOf(Integer.parseInt(StringUtil.toString(query1.list().get(0))));
        return count1;
    }
    public Object get(Class tClass, String tableName, Object id) {
        SqlCreator sqlCreator = new SqlCreator(tClass);
        sqlCreator.equalCondition("id", id);
        String sql = sqlCreator.selectData(tableName);
        Query query = this.getQuery(sqlCreator, sql);
        return query.uniqueResult();
    }
    public Query getQuery(SqlCreator sqlCreator, String sql) {
        SQLQuery query = this.getCurrentSession().createSQLQuery(sql);
        Iterator var4 = sqlCreator.getKeyValueMap().keySet().iterator();
        while (var4.hasNext()) {
            String key = (String) var4.next();
            Object value = sqlCreator.getKeyValueMap().get(key);
            if (value instanceof Collection) {
                query.setParameterList(key, (Collection) value);
            } else {
                query.setParameter(key, value);
            }
        }
        query.setResultTransformer(sqlCreator.getTransformer());
        return query;
    }
    public void insertBatch(final List<String> insertSqlList) {
//        Session session = this.getHibernateTemplate().getSessionFactory().getCurrentSession();
        String[] sqlStr = new String[insertSqlList.size()];
        String[] sqlArr = insertSqlList.toArray(sqlStr);
        this.jdbcTemplate.batchUpdate(sqlArr);
    }
    public Session openSession() {
        return null;
    }
    public Session getCurrentSession() {
        return currentSession();
    }
    public Integer getMaxId(String tableName) {
        String sql = "select max(id) from " + tableName;
        SQLQuery query = this.getCurrentSession().createSQLQuery(sql);
        Object object = query.uniqueResult();
        Integer maxId = Integer.valueOf(object == null ? 1 : Integer.parseInt(object.toString()) + 1);
        return maxId;
    }
    public Query getExeuteQuery(SqlCreator sqlCreator, String sql) {
        SQLQuery query = this.getCurrentSession().createSQLQuery(sql);
        Iterator var4 = sqlCreator.getKeyValueMap().keySet().iterator();
        while (var4.hasNext()) {
            String key = (String) var4.next();
            Object value = sqlCreator.getKeyValueMap().get(key);
            if (value instanceof Collection) {
                query.setParameterList(key, (Collection) value);
            } else {
                query.setParameter(key, value);
            }
        }
        return query;
    }
    public Boolean tableIsExist(String sql) {
        BigInteger tableNum = (BigInteger) this.getCurrentSession().createSQLQuery(sql).uniqueResult();
        if (tableNum.intValue() > 0) {
            return true;
        }
        return false;
    }
    protected void doClose(Session session, Statement stmt, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
                rs = null;
            } catch (Exception var6) {
                rs = null;
                logger.error("close-ResultSet ", var6);
                var6.printStackTrace();
            }
        }
        if (stmt != null) {
            try {
                stmt.close();
                stmt = null;
            } catch (Exception var5) {
                stmt = null;
                logger.error("close-ResultSet ", var5);
                var5.printStackTrace();
            }
        }
    }
}

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

@@ -0,0 +1,88 @@
package com.yihu.jw.basic.standard.dao;
import com.yihu.jw.basic.standard.model.adapter.AdapterMetadataModel;
import com.yihu.jw.basic.standard.model.standard.StdDataSetModel;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import org.springframework.stereotype.Repository;
import org.springframework.util.StringUtils;
import java.util.List;
/**
 * Created by Administrator on 2016/5/4.
 */
@Repository("stdeAdapterMetadataDao")
public class StdAdapterMetadataDao extends SQLGeneralDAO implements IStdAdapterMetadataDao {
    @Override
    public List<AdapterMetadataModel> getAdapterMetadataByMetadateId(String metedataId) throws Exception {
        String hql = " from StdeAdapterMetadata s where 1=1 ";
        if (!StringUtils.isEmpty(metedataId)) {
            hql += " and s.stdMatadataId='" + metedataId+ "'";
        }
        return super.getEntityList(StdDataSetModel.class, hql);
    }
    @Override
    public List<AdapterMetadataModel> getAdapterMetadataByDatasetIdAndStatus(String id, String s) throws Exception {
        String hql = " from StdeAdapterMetadata s where 1=1 ";
        if (!StringUtils.isEmpty(id)) {
            hql += " and s.stdDatasetId='" + id+ "'";
        }
        if (!StringUtils.isEmpty(s)) {
            hql += " and s.status='" + s+ "'";
        }
        return super.getEntityList(StdDataSetModel.class, hql);
    }
    @Override
    public void updateAdapterMetadataStatus(String id, String s) throws Exception {
//        super.getEntity(AdapterMetadataModel.class,id).setStatus(s);
    }
    @Override
    public List<AdapterMetadataModel> getAdapterMetadataByAdaptMetadateId(String AdaptMetadateId) throws Exception {
        String hql = " from StdeAdapterMetadata s where 1=1 ";
        if (!StringUtils.isEmpty(AdaptMetadateId)) {
            hql += " and s.adapterMatadataId='" + AdaptMetadateId+ "'";
        }
        return super.getEntityList(StdDataSetModel.class, hql);
    }
    @Override
    public List<AdapterMetadataModel> getAdapterMetadataByMetadateIdAndStatus(String id, String type) throws Exception {
        String hql = " from StdeAdapterMetadata s where 1=1 ";
        if (!StringUtils.isEmpty(id)) {
            hql += " and s.stdMatadataId='" + id+ "'";
        }
        if (!StringUtils.isEmpty(type)) {
            hql += " and s.status='" + type+ "'";
        }
        return super.getEntityList(StdDataSetModel.class, hql);
    }
    @Override
    public List<AdapterMetadataModel> getAdapterMetadataByAdaptMetadateIdAndStdDataSetId(String AdaptMetadateId, String stdDataSetId) throws Exception {
        String hql = " from StdeAdapterMetadata s where 1=1 ";
        if (!StringUtils.isEmpty(AdaptMetadateId)) {
            hql += " and s.adapterMatadataId='" + AdaptMetadateId+ "'";
        }
        if (!StringUtils.isEmpty(stdDataSetId)) {
            hql += " and s.stdDatasetId='" + stdDataSetId+ "'";
        }
        return super.getEntityList(StdDataSetModel.class, hql);
    }
    @Override
    public List<AdapterMetadataModel> getAdapterMetadataByProjectId(String id) throws Exception {
        String hql = " from StdeAdapterMetadata s where 1=1 and projectId='"+id+"' ";
        return super.getEntityList(StdDataSetModel.class, hql);
    }
    @Override
    public List<AdapterMetadataModel> getAdapterMetadataByDatasetId(String dataSetId) throws Exception {
        String hql = " from StdeAdapterMetadata s where 1=1 and stdDatasetId='"+dataSetId+"' ";
        return super.getEntityList(StdDataSetModel.class, hql);
    }
}

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

@@ -0,0 +1,34 @@
package com.yihu.jw.basic.standard.dao;
import com.yihu.jw.basic.standard.model.standard.StdDataSetModel;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.util.sql.BeanTransformer;
import org.hibernate.Query;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Repository;
/**
 * Created by Administrator on 2016/5/4.
 */
@Repository("stdeDatasetDao")
@CacheConfig(cacheNames = "StdDataSetModelCache")
public class StdDataSetModelDao extends SQLGeneralDAO implements IStdDataSetModelDao {
    @Override
    @Cacheable
    public StdDataSetModel getDatasetName(String version ,Integer id){
        StringBuffer sql = new StringBuffer();
        sql.append("SELECT d.*").append(" FROM std_dataset_").append(version).append(" d where d.id ="+id);
        try {
            Query query = getCurrentSession().createSQLQuery(sql.toString());
            query.setResultTransformer(new BeanTransformer(StdDataSetModel.class));
            StdDataSetModel stdDataSetModel =(StdDataSetModel) query.uniqueResult();
            return stdDataSetModel;
        }catch (Exception e){
            System.out.println("错误SQL："+sql.toString());
            e.printStackTrace();
            return null;
        }
    }
}

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

@@ -0,0 +1,39 @@
package com.yihu.jw.basic.standard.dao;
import com.yihu.jw.basic.standard.model.standard.StdDictionaryEntryModel;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.util.sql.BeanTransformer;
import org.hibernate.Query;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
 * Created by Administrator on 2017/4/19 0019.
 */
@Repository("stdDictionaryEntryDao")
@CacheConfig(cacheNames = "StdDictionaryEntryModelCache")
public class StdDictionaryEntryModelDao extends SQLGeneralDAO implements IStdDictionaryEntryModelDao {
    @Override
    @Cacheable
    public List<StdDictionaryEntryModel> getDictionaryEntry(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 ?");
        try {
            Query query = getCurrentSession().createSQLQuery(sql.toString());
            query.setCacheable(true);
            query.setParameter(0, "%" + orgDicEntryValue + "%");
            query.setParameter(1, "%" + dictName + "%");
            query.setResultTransformer(new BeanTransformer(StdDictionaryEntryModel.class));
            List<StdDictionaryEntryModel> list = query.list();
            return list;
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("错误Dict Like SQL：" + sql.toString());
            return null;
        }
    }
}

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

@@ -0,0 +1,36 @@
package com.yihu.jw.basic.standard.dao;
import com.yihu.jw.basic.standard.model.standard.StdDictionaryModel;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.util.sql.BeanTransformer;
import org.hibernate.Query;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Repository;
/**
 * Created by Administrator on 2017/4/19 0019.
 */
@Repository("stdDictionaryDao")
@CacheConfig(cacheNames = "StdDictionaryModelCache")
public class StdDictionaryModelDao extends SQLGeneralDAO implements IStdDictionaryModelDao {
    public final static String BEAN_ID = "stdDictionaryDao";
    @Override
    @Cacheable
    public StdDictionaryModel getDictionaryName(String version, Integer id) {
        StringBuffer sql = new StringBuffer();
        sql.append("SELECT d.*").append(" FROM std_dictionary_").append(version).append(" d where d.id =" + id);
        try {
            Query query = getCurrentSession().createSQLQuery(sql.toString());
            query.setResultTransformer(new BeanTransformer(StdDictionaryModel.class));
            StdDictionaryModel stdDictionaryModel = (StdDictionaryModel) query.uniqueResult();
            return stdDictionaryModel;
        } catch (Exception e) {
            System.out.println("错误Dict SQL：" + sql.toString());
            e.printStackTrace();
            return null;
        }
    }
}

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

@@ -0,0 +1,34 @@
package com.yihu.jw.basic.standard.dao;
import com.yihu.jw.basic.standard.model.standard.StdMetaDataModel;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.util.sql.BeanTransformer;
import org.hibernate.Query;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
 * Created by Administrator on 2016/5/4.
 */
@Repository("stdeMetadataDao")
public class StdMetaDataModelDao extends SQLGeneralDAO implements IStdMetaDataModelDao {
    public List<StdMetaDataModel> getMetadata(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 ?");
        try {
            Query query = getCurrentSession().createSQLQuery(sql.toString());
            query.setParameter(0,"%" + orgMetadataName + "%");
            query.setParameter(1,"%" + orgDatasetName + "%");
            query.setResultTransformer(new BeanTransformer(StdMetaDataModel.class));
            List<StdMetaDataModel> list = query.list();
            return list;
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("错误Like SQL："+sql.toString());
            return null;
        }
    }
}

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

@@ -0,0 +1,80 @@
package com.yihu.jw.basic.standard.dao;
import com.yihu.jw.basic.standard.model.DataGridResult;
import com.yihu.jw.util.sql.SqlCreator;
import org.hibernate.Query;
import org.hibernate.Session;
import java.io.IOException;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
/**
 * @author HZY
 * @vsrsion 1.0
 * Created at 2016/8/8.
 */
public interface XSQLGeneralDAO {
    void beginTransaction() throws Exception;
    void commitTransaction() throws Exception;
    void saveEntity(Object var1) throws Exception;
    void updateEntity(Object var1) throws Exception;
    void mergeEntity(Object var1) throws Exception;
    void deleteEntity(Object var1) throws Exception;
    <T> void deleteEntity(Class<T> var1, Serializable var2) throws Exception;
    void saveOrUpdateEntity(Object var1) throws Exception;
    <T> T getEntity(Class<T> var1, Serializable var2) throws Exception;
    DataGridResult getDataGridResult(String var1, Integer var2, Integer var3) throws Exception;
    List<Map<String, Object>> queryListBySql(String var1) throws Exception;
    List<Map<String, Object>> queryListBySql(String var1, List var2) throws Exception;
    <T> List<T> queryListBySql(String var1, Class var2) throws Exception;
    <T> List<T> queryListBySql(String var1, List var2, Class var3) throws Exception;
    <T> T queryObjBySql(String var1, List var2, Class var3) throws Exception;
    <T> T queryObjBySql(String var1, Class var2) throws Exception;
    <T> T scalarBySql(String var1, Class var2) throws Exception;
    void execute(String var1) throws Exception;
    <T> List getEntityList(Class<T> var1, String var2);
    <T> List getEntityList(Class<T> var1, String var2, String var3, Integer var4, Integer var5) throws IOException;
    <T> List getEntityListByParentId(Class<T> var1, String var2, Integer var3, String var4, String var5, Integer var6, Integer var7) throws IOException;
    <T> List getList(Class<T> var1, String var2, String var3, String var4, Integer var5, Integer var6);
    <T> Integer getDataSetInt(Class<T> var1, String var2, String var3);
    <T> Object get(Class<T> var1, String var2, Object var3);
    Session getCurrentSession();
    Session openSession();
    Query getQuery(SqlCreator var1, String var2);
    Query getExeuteQuery(SqlCreator var1, String var2);
    Integer getMaxId(String var1);
    void insertBatch(List<String> var1);
    List getListByIdList(Class var1, String var2, String var3, List<Integer> var4);
}

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

@@ -0,0 +1,122 @@
package com.yihu.jw.basic.standard.match.dictionary;
import com.yihu.jw.basic.standard.dao.IStdDictionaryModelDao;
import com.yihu.jw.basic.standard.dao.StdDictionaryEntryModelDao;
import com.yihu.jw.basic.standard.match.matchModel.DictItemMatchVO;
import com.yihu.jw.basic.standard.model.adapter.AdapterDictEntryModel;
import com.yihu.jw.basic.standard.service.adapter.AdapterDictEntryService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * Created by Administrator on 2016/6/24.
 * 字典项匹配器
 */
public class DictItemStrategyExecute implements Runnable {
    private static final Logger logger = LoggerFactory.getLogger(DictItemStrategyExecute.class);
    public static Map<String, List<Integer>> size = new HashMap<String, List<Integer>>();
    private DictItemMatchVO matchVO;
    private DictitemStandardExistStrategy standardExistStrategy;
    private AdapterDictEntryModel adapterDictEntryModel;
    private String std_version;
    private String adapter_std_version;
    private String version;
    private IStdDictionaryModelDao stdDictionaryDao;
    private StdDictionaryEntryModelDao stdDictionaryEntryDao;
    private AdapterDictEntryService adapterDictEntryService;
    private DictitemStandardNameStrategy dictitemStandardNameStrategy;
    public DictItemStrategyExecute(
            AdapterDictEntryModel adapterDictEntryModel,
            DictItemMatchVO matchVO,
            String std_version,
            String adapter_std_version,
            String version,
            IStdDictionaryModelDao stdDictionaryDao,
                    StdDictionaryEntryModelDao stdDictionaryEntryDao,
                    AdapterDictEntryService adapterDictEntryService) {
        this.adapterDictEntryModel = adapterDictEntryModel;
        this.matchVO = matchVO;
        this.std_version = std_version;
        this.adapter_std_version = adapter_std_version;
        this.version = version;
        standardExistStrategy = new DictitemStandardExistStrategy();
        standardExistStrategy.setStdDictionaryDao(stdDictionaryDao);
        standardExistStrategy.setStdDictionaryEntryDao(stdDictionaryEntryDao);
        standardExistStrategy.setAdapterDictEntryService(adapterDictEntryService);
        dictitemStandardNameStrategy = new DictitemStandardNameStrategy();
        dictitemStandardNameStrategy.setAdapterDictEntryService(adapterDictEntryService);
        dictitemStandardNameStrategy.setStdDictionaryDao(stdDictionaryDao);
    }
    public static void setVersionYes(String version) {
        List<Integer> sizeList = new ArrayList<Integer>();
        size.put(version, sizeList);
    }
    @Override
    public void run() {
        try {
            if (dictitemStandardNameStrategy.match(adapterDictEntryModel, version,std_version)) {
                updateAdapt(version);
                return;
            }
            if (matchVO != null) {
                if (standardExistStrategy.match(adapterDictEntryModel, matchVO,std_version,adapter_std_version, version)) {
                    updateAdapt(version);
                    return;
                }
            }
            updateAdapt(version);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static Map<String, List<Integer>> getSize() {
        return size;
    }
    public synchronized static void updateAdapt(String version) {
        List<Integer> sizeList = size.get(version);
        sizeList.add(1, sizeList.get(1) + 1);
        logger.debug("更新匹配数目:" + sizeList.get(0) + "/" + (sizeList.get(1)));
    }
    public synchronized static void setFirst(String version, Integer allCount) {
        List<Integer> sizeList = new ArrayList<Integer>();
        sizeList.add(0, allCount);
        sizeList.add(1, 0);
        size.put(version, sizeList);
    }
    public synchronized static void removeAdapt(String version) {
        size.remove(version);
    }
    public synchronized static boolean isAdapt(String version) {
        if (size.get(version) == null) {
            return false;
        } else {
            return true;
        }
    }
    public synchronized static Map getAllNumAndAdaptNum(String version) {
        Map<String, Integer> adapt = new HashMap<String, Integer>();
        List<Integer> list = size.get(version);
        if(list!=null && !list.isEmpty()){
            adapt.put("all", list.get(0));
            adapt.put("adapt", list.get(1));
        }
        return adapt;
    }
}

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

@@ -0,0 +1,108 @@
package com.yihu.jw.basic.standard.match.dictionary;
import com.yihu.jw.basic.standard.dao.IStdDictionaryModelDao;
import com.yihu.jw.basic.standard.dao.StdDictionaryEntryModelDao;
import com.yihu.jw.basic.standard.match.matchModel.DictItemMatchVO;
import com.yihu.jw.basic.standard.model.adapter.AdapterDictEntryModel;
import com.yihu.jw.basic.standard.model.standard.StdDictionaryEntryModel;
import com.yihu.jw.basic.standard.model.standard.StdDictionaryModel;
import com.yihu.jw.basic.standard.service.adapter.AdapterDictEntryService;
import com.yihu.jw.basic.standard.service.adapter.AdapterDictService;
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.List;
/**
 * Created by Administrator on 2016/6/24.
 */
@Scope("prototype")
@Component("dictitemStandardExistStrategy")
public class DictitemStandardExistStrategy {
    private IStdDictionaryModelDao stdDictionaryDao;
    private StdDictionaryEntryModelDao stdDictionaryEntryDao;
    private AdapterDictEntryService adapterDictEntryService;
    private AdapterDictService adapterDictService;
    public DictitemStandardExistStrategy(IStdDictionaryModelDao stdDictionaryDao, StdDictionaryEntryModelDao stdDictionaryEntryDao, AdapterDictEntryService adapterDictEntryService) {
        this.stdDictionaryDao = stdDictionaryDao;
        this.stdDictionaryEntryDao = stdDictionaryEntryDao;
        this.adapterDictEntryService = adapterDictEntryService;
    }
    public IStdDictionaryModelDao getStdDictionaryDao() {
        return stdDictionaryDao;
    }
    public void setStdDictionaryDao(IStdDictionaryModelDao stdDictionaryDao) {
        this.stdDictionaryDao = stdDictionaryDao;
    }
    public StdDictionaryEntryModelDao getStdDictionaryEntryDao() {
        return stdDictionaryEntryDao;
    }
    public void setStdDictionaryEntryDao(StdDictionaryEntryModelDao stdDictionaryEntryDao) {
        this.stdDictionaryEntryDao = stdDictionaryEntryDao;
    }
    public AdapterDictEntryService getAdapterDictEntryService() {
        return adapterDictEntryService;
    }
    public void setAdapterDictEntryService(AdapterDictEntryService adapterDictEntryService) {
        this.adapterDictEntryService = adapterDictEntryService;
    }
    public DictitemStandardExistStrategy() {
    }
    @Transactional
    public boolean match(AdapterDictEntryModel adapterDictEntryModel, DictItemMatchVO matchVO, String std_version, String adapter_std_version, String version) throws Exception {
        boolean flag = false;
        try {
        String dictitemNameFirstCode = GetChineseFirst.cn2py(adapterDictEntryModel.getStdEntryValue());//待匹配
        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);
            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);
                        if(dictionaryEntryTemps!=null&&dictionaryEntryTemps.size()>0){
                            String adapterInfo = "1";//查找到就默认疑似适配
                            if(dictionaryEntryTemps.size()==1){//查找到的条数为1,则为完全适配
                                adapterInfo = "2";
                            }
                            StdDictionaryEntryModel stdDictionaryEntryModel = dictionaryEntryTemps.get(0);
                            //保存适配
                            adapterDictEntryService.saveAdapt(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();
        }
        return flag;
    }
}

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

@@ -0,0 +1,79 @@
package com.yihu.jw.basic.standard.match.dictionary;
import com.yihu.jw.basic.standard.dao.IStdDictionaryModelDao;
import com.yihu.jw.basic.standard.model.adapter.AdapterDictEntryModel;
import com.yihu.jw.basic.standard.model.standard.StdDictionaryEntryModel;
import com.yihu.jw.basic.standard.model.standard.StdDictionaryModel;
import com.yihu.jw.basic.standard.service.adapter.AdapterDictEntryService;
import com.yihu.jw.basic.util.LikeHashMap;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.util.Map;
/**
 * Created by Administrator on 2016/7/4.
 */
@Scope("prototype")
@Component("dictitemStandardNameStrategy")
public class DictitemStandardNameStrategy {
    private AdapterDictEntryService adapterDictEntryService;
    private IStdDictionaryModelDao stdDictionaryDao;
    public IStdDictionaryModelDao getStdDictionaryDao() {
        return stdDictionaryDao;
    }
    public void setStdDictionaryDao(IStdDictionaryModelDao stdDictionaryDao) {
        this.stdDictionaryDao = stdDictionaryDao;
    }
    public AdapterDictEntryService getAdapterDictEntryService() {
        return adapterDictEntryService;
    }
    public void setAdapterDictEntryService(AdapterDictEntryService adapterDictEntryService) {
        this.adapterDictEntryService = adapterDictEntryService;
    }
    public DictitemStandardNameStrategy(AdapterDictEntryService adapterDictEntryService) {
        this.adapterDictEntryService = adapterDictEntryService;
    }
    private static LikeHashMap<String,StdDictionaryEntryModel> nameMap=new LikeHashMap<String,StdDictionaryEntryModel>();//机构字典项值的map
    public 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());
        StdDictionaryEntryModel orgDictItem = nameMap.get(adapterDictEntryModel.getStdEntryValue()+ "_" + dictionary.getCode(), true);
        if (orgDictItem != null ) {
            adapterDictEntryService.saveAdapt(adapterDictEntryModel, orgDictItem, version,"2");
            return true;
        }
        return false;
    }
    public static Map<String, StdDictionaryEntryModel> getNameMap() {
        return nameMap;
    }
    public static void setNameMap(LikeHashMap<String, StdDictionaryEntryModel> nameMap) {
        DictitemStandardNameStrategy.nameMap = nameMap;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/match/matchModel/DictItemMatchVO.java

@@ -0,0 +1,46 @@
package com.yihu.jw.basic.standard.match.matchModel;
import com.yihu.jw.basic.standard.model.adapter.AdapterDictEntryModel;
import com.yihu.jw.basic.util.GetChineseFirst;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * Created by Administrator on 2016/6/29.
 */
public class DictItemMatchVO {
   private Map<String, List<AdapterDictEntryModel>> codeAdapter = new HashMap<String, List<AdapterDictEntryModel>>();
    public Map<String, List<AdapterDictEntryModel>> getCodeAdapter() {
        return codeAdapter;
    }
    public void setCodeAdapter(Map<String, List<AdapterDictEntryModel>> codeAdapter) {
        this.codeAdapter = codeAdapter;
    }
    /**
     * 根据name的首字母分组
     * @param stdeAdapterDictitems
     * @return
     */
    public Map<String, List<AdapterDictEntryModel>> geNameGroup(List<AdapterDictEntryModel> stdeAdapterDictitems) {
        Map<String, List<AdapterDictEntryModel>> returnMap = new HashMap<String, List<AdapterDictEntryModel>>();
        for (AdapterDictEntryModel stdeAdapterDictitem : stdeAdapterDictitems) {
            String firstCode= GetChineseFirst.cn2py(stdeAdapterDictitem.getStdEntryValue());
            List<AdapterDictEntryModel> temp=returnMap.get(firstCode);
            if(temp!=null){
                temp.add(stdeAdapterDictitem);
            }else{
                temp=new ArrayList<AdapterDictEntryModel>();
                temp.add(stdeAdapterDictitem);
            }
            returnMap.put(firstCode,temp);
        }
        return returnMap;
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/standard/match/matchModel/MetadataMatchVO.java

@@ -0,0 +1,57 @@
package com.yihu.jw.basic.standard.match.matchModel;
import com.yihu.jw.basic.standard.model.adapter.AdapterMetadataModel;
import com.yihu.jw.basic.standard.model.standard.StdMetaDataModel;
import com.yihu.jw.basic.util.GetChineseFirst;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * Created by Administrator on 2016/6/29.
 */
public class MetadataMatchVO {
    private Map<String, List<AdapterMetadataModel>> codeAdapter = new HashMap<String, List<AdapterMetadataModel>>();
    private Map<String, StdMetaDataModel> orgMetadata = new HashMap<String, StdMetaDataModel>();
    public Map<String, List<AdapterMetadataModel>> getCodeAdapter() {
        return codeAdapter;
    }
    public void setCodeAdapter(Map<String, List<AdapterMetadataModel>> codeAdapter) {
        this.codeAdapter = codeAdapter;
    }
    /**
     * 根据name的首字母分组
     *
     * @param stdeAdapterMetadatas
     * @return
     */
    public Map<String, List<AdapterMetadataModel>> geNameGroup(List<AdapterMetadataModel> stdeAdapterMetadatas) {
        Map<String, List<AdapterMetadataModel>> returnMap = new HashMap<String, List<AdapterMetadataModel>>();
        for (AdapterMetadataModel stdeAdapterMetadata : stdeAdapterMetadatas) {
            String firstCode = GetChineseFirst.cn2py(stdeAdapterMetadata.getStdMetadataName());
            List<AdapterMetadataModel> temp = returnMap.get(firstCode);
            if (temp != null) {
                temp.add(stdeAdapterMetadata);
            } else {
                temp = new ArrayList<AdapterMetadataModel>();
                temp.add(stdeAdapterMetadata);
            }
            returnMap.put(firstCode, temp);
        }
        return returnMap;
    }
    public Map<String, StdMetaDataModel> getOrgMetadata() {
        return orgMetadata;
    }
    public void setOrgMetadata(Map<String, StdMetaDataModel> orgMetadata) {
        this.orgMetadata = orgMetadata;
    }
}

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

@@ -0,0 +1,125 @@
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.match.matchModel.MetadataMatchVO;
import com.yihu.jw.basic.standard.model.adapter.AdapterMetadataModel;
import com.yihu.jw.basic.standard.service.adapter.AdapterMetadataService;
import org.apache.commons.collections4.CollectionUtils;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * Created by Administrator on 2016/5/18.
 * 数据元匹配执行器
 */
public class MetadataStrategyExecute implements Runnable {
    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;
    private String version;
    private MetatdataStandardExistStrategy standardExistStrategy;
    private AdapterMetadataService adapterMetadataService;
    private MetatdataStandardNameStrategy standardNameStrategy;
    private IStdDataSetModelDao stdDataSetModelDao;
    public MetadataStrategyExecute(
            AdapterMetadataModel metadata,
            MetadataMatchVO matchVO,
            String std_version,
            String adapter_std_version,
            String version,
            IStdMetaDataModelDao stdMetaDataModelDao,
            IStdDataSetModelDao stdDataSetModelDao,
            AdapterMetadataService adapterMetadataService) {
        this.metadata = metadata;
        this.matchVO = matchVO;
        this.std_version = std_version;
        this.adapter_std_version = adapter_std_version;
        this.version = version;
        this.adapterMetadataService = adapterMetadataService;
        this.stdDataSetModelDao = stdDataSetModelDao;
        //项目之间学习适配
        standardExistStrategy = new MetatdataStandardExistStrategy();
        standardExistStrategy.setStdMetaDataModelDao(stdMetaDataModelDao);
        standardExistStrategy.setAdapterMetadataService(adapterMetadataService);
        standardExistStrategy.setStdDataSetModelDao(stdDataSetModelDao);
        standardNameStrategy = new MetatdataStandardNameStrategy();
        standardNameStrategy.setAdapterMetadataService(adapterMetadataService);
        standardNameStrategy.setStdDataSetModelDao(stdDataSetModelDao);
    }
    @Override
    public void run() {
        try {
            //按名字相似度来适配
            if (standardNameStrategy.match(metadata, version, std_version)) {
                updateAdapt(version);
                return;
            }
            if (matchVO != null) {
                //项目间学习
                if (standardExistStrategy.match(metadata, matchVO,std_version,adapter_std_version, version)) {
                    updateAdapt(version);
                    return;
                }
            }
            updateAdapt(version);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static Map<String, List<Integer>> getSize() {
        return size;
    }
    public synchronized static void updateAdapt(String version) {
        List<Integer> sizeList = size.get(version);
        sizeList.add(1, sizeList.get(1) + 1);
    }
    public synchronized static void setFirst(String version, Integer allCount) {
        List<Integer> sizeList = new ArrayList<Integer>();
        sizeList.add(0, allCount);
        sizeList.add(1, 0);
        size.put(version, sizeList);
    }
    public synchronized static void setVersionYes(String version) {
        List<Integer> sizeList = new ArrayList<Integer>();
        size.put(version, sizeList);
    }
    public synchronized static void removeAdapt(String version) {
        size.remove(version);
    }
    public synchronized static boolean isAdapt(String version) {
        if (size.get(version) == null) {
            return false;
        } else {
            return true;
        }
    }
    public synchronized static Map getAllNumAndAdaptNum(String version) {
        Map<String, Integer> adapt = new HashMap<String, Integer>();
        List<Integer> list = size.get(version);
        if(CollectionUtils.isNotEmpty(list)){
            adapt.put("all", list.get(0));
            adapt.put("adapt", list.get(1));
        }
        return adapt;
    }
}

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

@@ -0,0 +1,133 @@
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.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;
/**
 * Created by Administrator on 2016/5/16.
 * 对已经存在的匹配
 */
@Scope("prototype")
@Component("metatdataStandardExistStrategy")
public class MetatdataStandardExistStrategy extends SQLGeneralDAO {
    private IStdMetaDataModelDao stdMetaDataModelDao;
    private AdapterMetadataService adapterMetadataService;
    private IStdDataSetModelDao stdDataSetModelDao;
    private AdapterDatasetService adapterDatasetService;
    public AdapterDatasetService getAdapterDatasetService() {
        return adapterDatasetService;
    }
    public void setAdapterDatasetService(AdapterDatasetService adapterDatasetService) {
        this.adapterDatasetService = adapterDatasetService;
    }
    public MetatdataStandardExistStrategy(IStdMetaDataModelDao stdMetaDataModelDao) {
        this.stdMetaDataModelDao = stdMetaDataModelDao;
    }
    public IStdMetaDataModelDao getStdMetaDataModelDao() {
        return stdMetaDataModelDao;
    }
    public void setStdMetaDataModelDao(IStdMetaDataModelDao stdMetaDataModelDao) {
        this.stdMetaDataModelDao = stdMetaDataModelDao;
    }
    public AdapterMetadataService getAdapterMetadataService() {
        return adapterMetadataService;
    }
    public void setAdapterMetadataService(AdapterMetadataService adapterMetadataService) {
        this.adapterMetadataService = adapterMetadataService;
    }
    public IStdDataSetModelDao getStdDataSetModelDao() {
        return stdDataSetModelDao;
    }
    public void setStdDataSetModelDao(IStdDataSetModelDao stdDataSetModelDao) {
        this.stdDataSetModelDao = stdDataSetModelDao;
    }
    public MetatdataStandardExistStrategy() {
    }
    /**
     * 对传进来的StdeMetadata进行匹配
     *
     * @param strategyMetadata
     * @param matchVO
     * @return
     * @throws Exception
     */
    @Transactional
    public boolean match(AdapterMetadataModel strategyMetadata, MetadataMatchVO matchVO, String std_version, String adapter_std_version, String version) {
        boolean flag = false;
        try {
            String metadataNameFirstCode = GetChineseFirst.cn2py(strategyMetadata.getStdMetadataName());//待匹配
            List<AdapterMetadataModel> adapterMetadatas = matchVO.getCodeAdapter().get(metadataNameFirstCode);//已存在
            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);
                if(stdDataset!=null){
                    String stdDatasetName = stdDataset.getName();
                    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);
                            if (metadataTemps != null && metadataTemps.size() > 0) {
                                String adapterInfo = "1";//找到默认为疑似适配
                                if (metadataTemps.size() == 1) {//找到条数为1,默认为完全适配
                                    adapterInfo = "2";
                                }
                                StdMetaDataModel orgMetadata = metadataTemps.get(0);
                                //保存适配
                                adapterMetadataService.saveAdapt(strategyMetadata, orgMetadata, version, adapterInfo);
//                                String strSql = adapterMetadataService.saveAdaptSql(strategyMetadata, orgMetadata, version, adapterInfo);
//                                if(null != strSql && !"".equals(strSql)){
//                                    sqlList.add(strSql);
//                                }
                                flag = true;
                                break;
                            }
                        }
                    }
//                    if(CollectionUtils.isNotEmpty(sqlList)){
//                        adapterMetadataService.insertBatch(sqlList);
//                    }
                }
//                if (adapterDataset != null) {
//                    adapterDatasetService = SpringBeanUtil.getService(AdapterDatasetService.BEAN_ID);
//                    AdapterDatasetModel entity = adapterDatasetService.getAdapterDatasetByCode(version, adapterDataset.getCode());
//                    adapterDatasetService.saveAdaptDataset(entity,adapterDataset,version);
//                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }
}

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

@@ -0,0 +1,96 @@
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;
import com.yihu.jw.basic.standard.model.standard.StdMetaDataModel;
import com.yihu.jw.basic.standard.service.adapter.AdapterMetadataService;
import com.yihu.jw.basic.util.LikeHashMap;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.util.Map;
/**
 * Created by Administrator on 2016/7/4.
 */
@Scope("prototype")
@Component("metatdataStandardNameStrategy")
public class MetatdataStandardNameStrategy {
    private static LikeHashMap<String, StdMetaDataModel> nameMap = new LikeHashMap<String, StdMetaDataModel>();//机构名称的map
    private static LikeHashMap<String, StdMetaDataModel> remarkMap = new LikeHashMap<String, StdMetaDataModel>();//机构remark的map
    private AdapterMetadataService adapterMetadataService;
    private IStdDataSetModelDao stdDataSetModelDao;
    public MetatdataStandardNameStrategy(AdapterMetadataService adapterMetadataService, IStdDataSetModelDao stdDataSetModelDao) {
        this.adapterMetadataService = adapterMetadataService;
        this.stdDataSetModelDao = stdDataSetModelDao;
    }
    public MetatdataStandardNameStrategy() {
    }
    public static Map<String, StdMetaDataModel> getRemarkMap() {
        return remarkMap;
    }
    public static void setRemarkMap(LikeHashMap<String, StdMetaDataModel> remarkMap) {
        MetatdataStandardNameStrategy.remarkMap = remarkMap;
    }
    public static Map<String, StdMetaDataModel> getNameMap() {
        return nameMap;
    }
    public static void setNameMap(LikeHashMap<String, StdMetaDataModel> nameMap) {
        MetatdataStandardNameStrategy.nameMap = nameMap;
    }
    public AdapterMetadataService getAdapterMetadataService() {
        return adapterMetadataService;
    }
    public void setAdapterMetadataService(AdapterMetadataService adapterMetadataService) {
        this.adapterMetadataService = adapterMetadataService;
    }
    public IStdDataSetModelDao getStdDataSetModelDao() {
        return stdDataSetModelDao;
    }
    public void setStdDataSetModelDao(IStdDataSetModelDao stdDataSetModelDao) {
        this.stdDataSetModelDao = stdDataSetModelDao;
    }
    /**
     * 对传进来的metadata进行匹配
     *
     * @param metadata
     * @param version
     * @return
     * @throws Exception
     */
    @Transactional
    public boolean match(AdapterMetadataModel metadata, String version, String std_version) throws Exception {
        StdDataSetModel stdDataset = stdDataSetModelDao.getDatasetName(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");
            return true;
        }
        orgStdeMetadata = remarkMap.get(name + "_" + stdDataset.getCode(), true);
        if (orgStdeMetadata != null) {
            adapterMetadataService.saveAdapt(metadata, orgStdeMetadata, version, "2");
            return true;
        }
        return false;
    }
}

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

@@ -0,0 +1,124 @@
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/DictItem.java

@@ -0,0 +1,37 @@
package com.yihu.jw.basic.standard.model;
/**
 * 字典项
 * Created by hzp on 2016/1/15
 */
public class DictItem {
    private String value;
    private String code;
    private String extend;
    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getExtend() {
        return extend;
    }
    public void setExtend(String extend) {
        this.extend = extend;
    }
}

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

@@ -0,0 +1,72 @@
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/Select2.java

@@ -0,0 +1,24 @@
package com.yihu.jw.basic.standard.model;
public class Select2 {
    private String id;
    private String text;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getText() {
        return text;
    }
    public void setText(String text) {
        this.text = text;
    }
}

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

@@ -0,0 +1,193 @@
package com.yihu.jw.basic.standard.model;
import com.yihu.jw.entity.UuidIdentityEntity;
import javax.persistence.Entity;
import javax.persistence.Table;
/**
 * SystemOrganization entity. @author MyEclipse Persistence Tools
 */
@Entity
@Table(name = "system_organization")
public class SystemOrganization extends UuidIdentityEntity implements java.io.Serializable {
	// Fields
	private String fullName;
	private String pid;
	private String activityFlag;
	private String code;
	private String shortName;
	private String pyCode;
	private String area;
	private String address;
	private String orgType;
	private String settled;
	private String settledWay;
	private String tel;
	private String tags;
	private String qlcOrgCode;
	private String qlcAdapterVersion;
	// Constructors
	/** default constructor */
	public SystemOrganization() {
	}
	/** minimal constructor */
	public SystemOrganization(String fullName, String pid, String activityFlag) {
		this.fullName = fullName;
		this.pid = pid;
		this.activityFlag = activityFlag;
	}
	/** full constructor */
	public SystemOrganization(String fullName, String pid, String activityFlag, String code, String shortName, String pyCode, String area, String address, String orgType, String settled, String settledWay, String tel, String tags) {
		this.fullName = fullName;
		this.pid = pid;
		this.activityFlag = activityFlag;
		this.code = code;
		this.shortName = shortName;
		this.pyCode = pyCode;
		this.area = area;
		this.address = address;
		this.orgType = orgType;
		this.settled = settled;
		this.settledWay = settledWay;
		this.tel = tel;
		this.tags = tags;
	}
	// Property accessors
	public String getFullName() {
		return this.fullName;
	}
	public void setFullName(String fullName) {
		this.fullName = fullName;
	}
	public String getPid() {
		return this.pid;
	}
	public void setPid(String pid) {
		this.pid = pid;
	}
	public String getActivityFlag() {
		return this.activityFlag;
	}
	public void setActivityFlag(String activityFlag) {
		this.activityFlag = activityFlag;
	}
	public String getCode() {
		return this.code;
	}
	public void setCode(String code) {
		this.code = code;
	}
	public String getShortName() {
		return this.shortName;
	}
	public void setShortName(String shortName) {
		this.shortName = shortName;
	}
	public String getPyCode() {
		return this.pyCode;
	}
	public void setPyCode(String pyCode) {
		this.pyCode = pyCode;
	}
	public String getArea() {
		return this.area;
	}
	public void setArea(String area) {
		this.area = area;
	}
	public String getAddress() {
		return this.address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public String getOrgType() {
		return this.orgType;
	}
	public void setOrgType(String orgType) {
		this.orgType = orgType;
	}
	public String getSettled() {
		return this.settled;
	}
	public void setSettled(String settled) {
		this.settled = settled;
	}
	public String getSettledWay() {
		return this.settledWay;
	}
	public void setSettledWay(String settledWay) {
		this.settledWay = settledWay;
	}
	public String getTel() {
		return this.tel;
	}
	public void setTel(String tel) {
		this.tel = tel;
	}
	public String getTags() {
		return this.tags;
	}
	public void setTags(String tags) {
		this.tags = tags;
	}
	public String getQlcOrgCode() {
		return qlcOrgCode;
	}
	public void setQlcOrgCode(String qlcOrgCode) {
		this.qlcOrgCode = qlcOrgCode;
	}
	public String getQlcAdapterVersion() {
		return qlcAdapterVersion;
	}
	public void setQlcAdapterVersion(String qlcAdapterVersion) {
		this.qlcAdapterVersion = qlcAdapterVersion;
	}
}

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

@@ -0,0 +1,62 @@
package com.yihu.jw.basic.standard.model;
import com.yihu.jw.entity.UuidIdentityEntity;
import javax.persistence.Entity;
import javax.persistence.Table;
/**
 * SystemParam entity. @author MyEclipse Persistence Tools
 */
@Entity
@Table(name = "system_param")
public class SystemParam extends UuidIdentityEntity implements java.io.Serializable {
    // Fields
    private String paramKey;
    private String paramValue;
    private String remark;
    private String orgId;
    // Constructors
    /**
     * default constructor
     */
    public SystemParam() {
    }
    public String getParamKey() {
        return paramKey;
    }
    public void setParamKey(String paramKey) {
        this.paramKey = paramKey;
    }
    public String getParamValue() {
        return paramValue;
    }
    public void setParamValue(String paramValue) {
        this.paramValue = paramValue;
    }
    public String getRemark() {
        return this.remark;
    }
    public void setRemark(String remark) {
        this.remark = remark;
    }
    public String getOrgId() {
        return this.orgId;
    }
    public void setOrgId(String orgId) {
        this.orgId = orgId;
    }
}

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

@@ -0,0 +1,65 @@
package com.yihu.jw.basic.standard.model;
import java.io.Serializable;
/**
 * Created by chenweida on 2015/12/17.
 */
public class TreeResult implements Serializable {
    String id;//节点IP
    String pid;//父节点IP
    String text;//显示的名字
    String code;//1是类别 2是接口
    String type;//类别
    String icon;//图标类
    public String getId() {
        return id;
    }
    public String getPid() {
        return pid;
    }
    public void setPid(String pid) {
        this.pid = pid;
    }
    public String getText() {
        return text;
    }
    public void setText(String text) {
        this.text = text;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getType() {
        return type;
    }
    public String getIcon() {
        return icon;
    }
    public void setIcon(String icon) {
        this.icon = icon;
    }
    public void setType(String type) {
        this.type = type;
    }
}

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

@@ -0,0 +1,46 @@
package com.yihu.jw.basic.standard.model;
/**
 * select2类
 *
 * @author llh
 */
public class TreeView {
    private String id;
    private String pid;
    private String text;
    private Boolean ischecked;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getPid() {
        return pid;
    }
    public void setPid(String pid) {
        this.pid = pid;
    }
    public String getText() {
        return text;
    }
    public void setText(String text) {
        this.text = text;
    }
    public Boolean getIschecked() {
        return ischecked;
    }
    public void setIschecked(Boolean ischecked) {
        this.ischecked = ischecked;
    }
}

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

@@ -0,0 +1,98 @@
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;
import javax.persistence.Id;
import java.io.Serializable;
/**
 * Created by lingfeng on 2015/9/16.
 */
public class AdapterDatasetModel extends Result implements Serializable {
    @Id
    @GeneratedValue(generator = "generator")
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;
    @Column(name = "scheme_id")
    private Integer schemeId;
    @Column(name = "std_dataset_id")
    private Integer stdDatasetId;
    @Column(name = "std_dataset_code")
    private String stdDatasetCode;
    @Column(name = "std_dataset_name")
    private String stdDatasetName;
    @Column(name = "adapter_dataset_id")
    private Integer adapterDatasetId;
    @Column(name = "adapter_dataset_code")
    private String adapterDatasetCode;
    @Column(name = "adapter_dataset_name")
    private String adapterDatasetName;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
        this.schemeId = schemeId;
    }
    public Integer getStdDatasetId() {
        return stdDatasetId;
    }
    public void setStdDatasetId(Integer stdDatasetId) {
        this.stdDatasetId = stdDatasetId;
    }
    public String getStdDatasetCode() {
        return stdDatasetCode;
    }
    public void setStdDatasetCode(String stdDatasetCode) {
        this.stdDatasetCode = stdDatasetCode;
    }
    public String getStdDatasetName() {
        return stdDatasetName;
    }
    public void setStdDatasetName(String stdDatasetName) {
        this.stdDatasetName = stdDatasetName;
    }
    public Integer getAdapterDatasetId() {
        return adapterDatasetId;
    }
    public void setAdapterDatasetId(Integer adapterDatasetId) {
        this.adapterDatasetId = adapterDatasetId;
    }
    public String getAdapterDatasetCode() {
        return adapterDatasetCode;
    }
    public void setAdapterDatasetCode(String adapterDatasetCode) {
        this.adapterDatasetCode = adapterDatasetCode;
    }
    public String getAdapterDatasetName() {
        return adapterDatasetName;
    }
    public void setAdapterDatasetName(String adapterDatasetName) {
        this.adapterDatasetName = adapterDatasetName;
    }
}

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

@@ -0,0 +1,68 @@
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;
import javax.persistence.Id;
import java.io.Serializable;
/**
 * Created by lingfeng on 2015/9/16.
 */
public class AdapterDatasetRelationModel extends Result implements Serializable {
    @Id
    @GeneratedValue(generator = "generator")
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;
    @Column(name = "scheme_id")
    private Integer schemeId;
    @Column(name = "master_dataset_id")
    private Integer masterdatasetId;
    @Column(name = "master_metadata_id")
    private Integer masterMetadataId;
    @Column(name = "foreign_metadata_id")
    private Integer foreignMetadataId;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
        this.schemeId = schemeId;
    }
    public Integer getMasterdatasetId() {
        return masterdatasetId;
    }
    public void setMasterdatasetId(Integer masterdatasetId) {
        this.masterdatasetId = masterdatasetId;
    }
    public Integer getMasterMetadataId() {
        return masterMetadataId;
    }
    public void setMasterMetadataId(Integer masterMetadataId) {
        this.masterMetadataId = masterMetadataId;
    }
    public Integer getForeignMetadataId() {
        return foreignMetadataId;
    }
    public void setForeignMetadataId(Integer foreignMetadataId) {
        this.foreignMetadataId = foreignMetadataId;
    }
}

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

@@ -0,0 +1,128 @@
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;
import javax.persistence.Id;
import java.io.Serializable;
/**
 * Created by lingfeng on 2015/9/16.
 */
public class AdapterDictEntryModel extends Result implements Serializable {
    @Id
    @GeneratedValue(generator = "generator")
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;
    @Column(name = "scheme_id")
    private Integer schemeId;
    @Column(name = "std_dict_id")
    private Integer stdDictId;
    @Column(name = "std_entry_id")
    private Integer stdEntryId;
    @Column(name = "std_entry_code")
    private String stdEntryCode;
    @Column(name = "std_entry_value")
    private String stdEntryValue;
    @Column(name = "adapter_dict_id")
    private Integer adapterDictId;
    @Column(name = "adapter_entry_id")
    private Integer adapterEntryId;
    @Column(name = "adapter_entry_code")
    private String adapterEntryCode;
    @Column(name = "adapter_entry_value")
    private String adapterEntryValue;
    @Column(name = "adapter_info")
    private String adapterInfo;
    public String getAdapterInfo() {
        return adapterInfo;
    }
    public void setAdapterInfo(String adapterInfo) {
        this.adapterInfo = adapterInfo;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
        this.schemeId = schemeId;
    }
    public Integer getStdDictId() {
        return stdDictId;
    }
    public void setStdDictId(Integer stdDictId) {
        this.stdDictId = stdDictId;
    }
    public Integer getStdEntryId() {
        return stdEntryId;
    }
    public void setStdEntryId(Integer stdEntryId) {
        this.stdEntryId = stdEntryId;
    }
    public String getStdEntryCode() {
        return stdEntryCode;
    }
    public void setStdEntryCode(String stdEntryCode) {
        this.stdEntryCode = stdEntryCode;
    }
    public String getStdEntryValue() {
        return stdEntryValue;
    }
    public void setStdEntryValue(String stdEntryValue) {
        this.stdEntryValue = stdEntryValue;
    }
    public Integer getAdapterDictId() {
        return adapterDictId;
    }
    public void setAdapterDictId(Integer adapterDictId) {
        this.adapterDictId = adapterDictId;
    }
    public Integer getAdapterEntryId() {
        return adapterEntryId;
    }
    public void setAdapterEntryId(Integer adapterEntryId) {
        this.adapterEntryId = adapterEntryId;
    }
    public String getAdapterEntryCode() {
        return adapterEntryCode;
    }
    public void setAdapterEntryCode(String adapterEntryCode) {
        this.adapterEntryCode = adapterEntryCode;
    }
    public String getAdapterEntryValue() {
        return adapterEntryValue;
    }
    public void setAdapterEntryValue(String adapterEntryValue) {
        this.adapterEntryValue = adapterEntryValue;
    }
}

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

@@ -0,0 +1,98 @@
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;
import javax.persistence.Id;
import java.io.Serializable;
/**
 * Created by lingfeng on 2015/9/16.
 */
public class AdapterDictModel extends Result implements Serializable {
    @Id
    @GeneratedValue(generator = "generator")
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;
    @Column(name = "scheme_id")
    private Integer schemeId;
    @Column(name = "std_dict_id")
    private Integer stdDictId;
    @Column(name = "std_dict_code")
    private String stdDictCode;
    @Column(name = "std_dict_name")
    private String stdDictName;
    @Column(name = "adapter_dict_id")
    private Integer adapterDictId;
    @Column(name = "adapter_dict_code")
    private String adapterDictCode;
    @Column(name = "adapter_dict_name")
    private String adapterDictName;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
        this.schemeId = schemeId;
    }
    public Integer getStdDictId() {
        return stdDictId;
    }
    public void setStdDictId(Integer stdDictId) {
        this.stdDictId = stdDictId;
    }
    public String getStdDictCode() {
        return stdDictCode;
    }
    public void setStdDictCode(String stdDictCode) {
        this.stdDictCode = stdDictCode;
    }
    public String getStdDictName() {
        return stdDictName;
    }
    public void setStdDictName(String stdDictName) {
        this.stdDictName = stdDictName;
    }
    public Integer getAdapterDictId() {
        return adapterDictId;
    }
    public void setAdapterDictId(Integer adapterDictId) {
        this.adapterDictId = adapterDictId;
    }
    public String getAdapterDictCode() {
        return adapterDictCode;
    }
    public void setAdapterDictCode(String adapterDictCode) {
        this.adapterDictCode = adapterDictCode;
    }
    public String getAdapterDictName() {
        return adapterDictName;
    }
    public void setAdapterDictName(String adapterDictName) {
        this.adapterDictName = adapterDictName;
    }
}

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

@@ -0,0 +1,158 @@
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;
import javax.persistence.Id;
import java.io.Serializable;
/**
 * Created by lingfeng on 2015/9/16.
 */
public class AdapterMetadataModel extends Result implements Serializable {
    @Id
    @GeneratedValue(generator = "generator")
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;
    @Column(name = "scheme_id")
    private Integer schemeId;
    @Column(name = "std_dataset_id")
    private Integer stdDatasetId;
    @Column(name = "std_metadata_id")
    private Integer stdMetadataId;
    @Column(name = "std_metadata_code")
    private String stdMetadataCode;
    @Column(name = "std_metadata_name")
    private String stdMetadataName;
    @Column(name = "std_dict_id")
    private Integer stdDictId;
    @Column(name = "adapter_dataset_id")
    private Integer adapterDatasetId;
    @Column(name = "adapter_metadata_id")
    private Integer adapterMetadataId;
    @Column(name = "adapter_metadata_code")
    private String adapterMetadataCode;
    @Column(name = "adapter_metadata_name")
    private String adapterMetadataName;
    @Column(name = "adapter_data_type")
    private Integer adapterDataType;
    @Column(name = "adapter_dict_id")
    private Integer adapterDictId;
    @Column(name = "adapter_info")
    private String adapterInfo;
    public String getAdapterInfo() {
        return adapterInfo;
    }
    public void setAdapterInfo(String adapterInfo) {
        this.adapterInfo = adapterInfo;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
        this.schemeId = schemeId;
    }
    public Integer getStdDatasetId() {
        return stdDatasetId;
    }
    public void setStdDatasetId(Integer stdDatasetId) {
        this.stdDatasetId = stdDatasetId;
    }
    public Integer getStdMetadataId() {
        return stdMetadataId;
    }
    public void setStdMetadataId(Integer stdMetadataId) {
        this.stdMetadataId = stdMetadataId;
    }
    public String getStdMetadataCode() {
        return stdMetadataCode;
    }
    public void setStdMetadataCode(String stdMetadataCode) {
        this.stdMetadataCode = stdMetadataCode;
    }
    public String getStdMetadataName() {
        return stdMetadataName;
    }
    public void setStdMetadataName(String stdMetadataName) {
        this.stdMetadataName = stdMetadataName;
    }
    public Integer getStdDictId() {
        return stdDictId;
    }
    public void setStdDictId(Integer stdDictId) {
        this.stdDictId = stdDictId;
    }
    public Integer getAdapterDatasetId() {
        return adapterDatasetId;
    }
    public void setAdapterDatasetId(Integer adapterDatasetId) {
        this.adapterDatasetId = adapterDatasetId;
    }
    public Integer getAdapterMetadataId() {
        return adapterMetadataId;
    }
    public void setAdapterMetadataId(Integer adapterMetadataId) {
        this.adapterMetadataId = adapterMetadataId;
    }
    public String getAdapterMetadataCode() {
        return adapterMetadataCode;
    }
    public void setAdapterMetadataCode(String adapterMetadataCode) {
        this.adapterMetadataCode = adapterMetadataCode;
    }
    public String getAdapterMetadataName() {
        return adapterMetadataName;
    }
    public void setAdapterMetadataName(String adapterMetadataName) {
        this.adapterMetadataName = adapterMetadataName;
    }
    public Integer getAdapterDataType() {
        return adapterDataType;
    }
    public void setAdapterDataType(Integer adapterDataType) {
        this.adapterDataType = adapterDataType;
    }
    public Integer getAdapterDictId() {
        return adapterDictId;
    }
    public void setAdapterDictId(Integer adapterDictId) {
        this.adapterDictId = adapterDictId;
    }
}

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

@@ -0,0 +1,52 @@
package com.yihu.jw.basic.standard.model.adapter;
import com.yihu.jw.basic.standard.model.Result;
import java.io.Serializable;
/**
 * 标准版本模型
 *
 * @Created by lingfeng 2015/12/23.
 */
public class AdapterSchemeDispatchModel extends Result implements Serializable {
    private Integer id;
    private Integer schemeId;
    private String orgCode;
    private String orgName;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
        this.schemeId = schemeId;
    }
    public String getOrgCode() {
        return orgCode;
    }
    public void setOrgCode(String orgCode) {
        this.orgCode = orgCode;
    }
    public String getOrgName() {
        return orgName;
    }
    public void setOrgName(String orgName) {
        this.orgName = orgName;
    }
}

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

@@ -0,0 +1,140 @@
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;
/**
 * 标准版本模型
 *
 * @Created by lingfeng 2015/12/23.
 */
@Entity
@Table(name = "adapter_scheme")
public class AdapterSchemeModel extends Result implements Serializable {
    @Id
    @GeneratedValue(generator = "generator")
    @GenericGenerator(name = "generator", strategy = "increment")
    private Integer id;
    @Column(name="parent_id")
    private Integer parentId;
    @Column(name="name")
    private String name;
    @Column(name="type")
    private String type;
    @Column(name="description")
    private String description;
    @Column(name="status")
    private Integer status;
    @Column(name="std_id")
    private Integer stdId;
    @Column(name="std_version")
    private String stdVersion;
    @Column(name="adapter_std_id")
    private Integer adapterStdId;
    @Column(name="adapter_std_version")
    private String adapterStdVersion;
    @Column(name="adapter_publisher_org_code")
    private String adapterPublisherOrgCode;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getParentId() {
        return parentId;
    }
    public void setParentId(Integer parentId) {
        this.parentId = parentId;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
    public Integer getStatus() {
        return status;
    }
    public void setStatus(Integer status) {
        this.status = status;
    }
    public Integer getStdId() {
        return stdId;
    }
    public void setStdId(Integer stdId) {
        this.stdId = stdId;
    }
    public String getStdVersion() {
        return stdVersion;
    }
    public void setStdVersion(String stdVersion) {
        this.stdVersion = stdVersion;
    }
    public Integer getAdapterStdId() {
        return adapterStdId;
    }
    public void setAdapterStdId(Integer adapterStdId) {
        this.adapterStdId = adapterStdId;
    }
    public String getAdapterStdVersion() {
        return adapterStdVersion;
    }
    public void setAdapterStdVersion(String adapterStdVersion) {
        this.adapterStdVersion = adapterStdVersion;
    }
    public String getAdapterPublisherOrgCode() {
        return adapterPublisherOrgCode;
    }
    public void setAdapterPublisherOrgCode(String adapterPublisherOrgCode) {
        this.adapterPublisherOrgCode = adapterPublisherOrgCode;
    }
}

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

@@ -0,0 +1,120 @@
package com.yihu.jw.basic.standard.model.adapter;
import com.yihu.jw.basic.standard.model.Result;
import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;
/**
 * 标准版本模型
 *
 * @created lingfeng 2015/12/23.
 */
@Entity
@Table(name = "adapter_scheme_version")
public class AdapterSchemeVersionModel extends Result implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    @Column(name="scheme_id")
    private Integer schemeId;
    @Column(name="name")
    private String name;
    @Column(name="version")
    private String version;
    @Column(name="publish_time")
    private Date publishTime;
    @Column(name="publish_user")
    private String publishUser;
    @Column(name="base_version")
    private String baseVersion;
    @Column(name="publish_status")
    private Integer publishStatus;
    @Column(name="path")
    private String path;
    public AdapterSchemeVersionModel(){
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
        this.schemeId = schemeId;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getVersion() {
        return version;
    }
    public void setVersion(String version) {
        this.version = version;
    }
    public Date getPublishTime() {
        return publishTime;
    }
    public void setPublishTime(Date publishTime) {
        this.publishTime = publishTime;
    }
    public String getBaseVersion() {
        return baseVersion;
    }
    public void setBaseVersion(String baseVersion) {
        this.baseVersion = baseVersion;
    }
    public Integer getPublishStatus() {
        return publishStatus;
    }
    public void setPublishStatus(Integer publishStatus) {
        this.publishStatus = publishStatus;
    }
    public String getPath() {
        return path;
    }
    public void setPath(String path) {
        this.path = path;
    }
    public String getPublishUser() {
        return publishUser;
    }
    public void setPublishUser(String publishUser) {
        this.publishUser = publishUser;
    }
}

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

@@ -0,0 +1,124 @@
package com.yihu.jw.basic.standard.model.adapter.resultModel;
/**
 * Created by lingfeng on 2015/9/16.
 */
public class AdapterDictEntryResultDetailModel {
    private Integer id;
    private Integer schemeId;
    private Integer stdDictId;
    private Integer stdEntryId;
    private String stdEntryCode;
    private String stdEntryValue;
    private Integer adapterDictId;
    private Integer adapterEntryId;
    private String adapterEntryCode;
    private String adapterEntryValue;
    private String adapterDictCode;
    private String adapterDictName;
    private String adapterInfo;
    public String getAdapterInfo() {
        return adapterInfo;
    }
    public void setAdapterInfo(String adapterInfo) {
        this.adapterInfo = adapterInfo;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
        this.schemeId = schemeId;
    }
    public Integer getStdDictId() {
        return stdDictId;
    }
    public void setStdDictId(Integer stdDictId) {
        this.stdDictId = stdDictId;
    }
    public Integer getStdEntryId() {
        return stdEntryId;
    }
    public void setStdEntryId(Integer stdEntryId) {
        this.stdEntryId = stdEntryId;
    }
    public String getStdEntryCode() {
        return stdEntryCode;
    }
    public void setStdEntryCode(String stdEntryCode) {
        this.stdEntryCode = stdEntryCode;
    }
    public String getStdEntryValue() {
        return stdEntryValue;
    }
    public void setStdEntryValue(String stdEntryValue) {
        this.stdEntryValue = stdEntryValue;
    }
    public Integer getAdapterDictId() {
        return adapterDictId;
    }
    public void setAdapterDictId(Integer adapterDictId) {
        this.adapterDictId = adapterDictId;
    }
    public Integer getAdapterEntryId() {
        return adapterEntryId;
    }
    public void setAdapterEntryId(Integer adapterEntryId) {
        this.adapterEntryId = adapterEntryId;
    }
    public String getAdapterEntryCode() {
        return adapterEntryCode;
    }
    public void setAdapterEntryCode(String adapterEntryCode) {
        this.adapterEntryCode = adapterEntryCode;
    }
    public String getAdapterEntryValue() {
        return adapterEntryValue;
    }
    public void setAdapterEntryValue(String adapterEntryValue) {
        this.adapterEntryValue = adapterEntryValue;
    }
    public String getAdapterDictCode() {
        return adapterDictCode;
    }
    public void setAdapterDictCode(String adapterDictCode) {
        this.adapterDictCode = adapterDictCode;
    }
    public String getAdapterDictName() {
        return adapterDictName;
    }
    public void setAdapterDictName(String adapterDictName) {
        this.adapterDictName = adapterDictName;
    }
}

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

@@ -0,0 +1,133 @@
package com.yihu.jw.basic.standard.model.adapter.resultModel;
/**
 * Created by lingfeng on 2015/9/16.
 */
public class AdapterMetadataResultDetailModel {
    private Integer id;
    private Integer schemeId;
    private Integer stdDatasetId;
    private Integer stdMetadataId;
    private String stdMetadataCode;
    private String stdMetadataName;
    private Integer stdDictId;
    private Integer adapterDatasetId;
    private Integer adapterMetadataId;
    private String adapterMetadataCode;
    private String adapterMetadataName;
    private Integer adapterDataType;
    private String adapterMetadataType;
    private Integer adapterDictId;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
        this.schemeId = schemeId;
    }
    public Integer getStdDatasetId() {
        return stdDatasetId;
    }
    public void setStdDatasetId(Integer stdDatasetId) {
        this.stdDatasetId = stdDatasetId;
    }
    public Integer getStdMetadataId() {
        return stdMetadataId;
    }
    public void setStdMetadataId(Integer stdMetadataId) {
        this.stdMetadataId = stdMetadataId;
    }
    public String getStdMetadataCode() {
        return stdMetadataCode;
    }
    public void setStdMetadataCode(String stdMetadataCode) {
        this.stdMetadataCode = stdMetadataCode;
    }
    public String getStdMetadataName() {
        return stdMetadataName;
    }
    public void setStdMetadataName(String stdMetadataName) {
        this.stdMetadataName = stdMetadataName;
    }
    public Integer getStdDictId() {
        return stdDictId;
    }
    public void setStdDictId(Integer stdDictId) {
        this.stdDictId = stdDictId;
    }
    public Integer getAdapterDatasetId() {
        return adapterDatasetId;
    }
    public void setAdapterDatasetId(Integer adapterDatasetId) {
        this.adapterDatasetId = adapterDatasetId;
    }
    public Integer getAdapterMetadataId() {
        return adapterMetadataId;
    }
    public void setAdapterMetadataId(Integer adapterMetadataId) {
        this.adapterMetadataId = adapterMetadataId;
    }
    public String getAdapterMetadataCode() {
        return adapterMetadataCode;
    }
    public void setAdapterMetadataCode(String adapterMetadataCode) {
        this.adapterMetadataCode = adapterMetadataCode;
    }
    public String getAdapterMetadataName() {
        return adapterMetadataName;
    }
    public void setAdapterMetadataName(String adapterMetadataName) {
        this.adapterMetadataName = adapterMetadataName;
    }
    public Integer getAdapterDataType() {
        return adapterDataType;
    }
    public void setAdapterDataType(Integer adapterDataType) {
        this.adapterDataType = adapterDataType;
    }
    public Integer getAdapterDictId() {
        return adapterDictId;
    }
    public void setAdapterDictId(Integer adapterDictId) {
        this.adapterDictId = adapterDictId;
    }
    public String getAdapterMetadataType() {
        return adapterMetadataType;
    }
    public void setAdapterMetadataType(String adapterMetadataType) {
        this.adapterMetadataType = adapterMetadataType;
    }
}

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

@@ -0,0 +1,144 @@
package com.yihu.jw.basic.standard.model.adapter.resultModel;
import com.yihu.jw.basic.standard.model.adapter.AdapterSchemeVersionModel;
import java.io.Serializable;
import java.util.List;
public class AdapterSchemeResultDetailModel implements Serializable {
    String id;
    String pid;
    String name;
    Integer status;
    String stdName;
    String stdVersionName;
    String stdVersion;
    String publisher;
    String adapterName;
    String adapterVersionName;
    String adapterStdVersion;
    String version;
    Integer type;
    String date;
    List<AdapterSchemeVersionModel> versionList;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getPid() {
        return pid;
    }
    public void setPid(String pid) {
        this.pid = pid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getStatus() {
        return status;
    }
    public void setStatus(Integer status) {
        this.status = status;
    }
    public String getStdName() {
        return stdName;
    }
    public void setStdName(String stdName) {
        this.stdName = stdName;
    }
    public String getStdVersionName() {
        return stdVersionName;
    }
    public void setStdVersionName(String stdVersionName) {
        this.stdVersionName = stdVersionName;
    }
    public String getPublisher() {
        return publisher;
    }
    public void setPublisher(String publisher) {
        this.publisher = publisher;
    }
    public String getAdapterName() {
        return adapterName;
    }
    public void setAdapterName(String adapterName) {
        this.adapterName = adapterName;
    }
    public String getAdapterVersionName() {
        return adapterVersionName;
    }
    public void setAdapterVersionName(String adapterVersionName) {
        this.adapterVersionName = adapterVersionName;
    }
    public Integer getType() {
        return type;
    }
    public void setType(Integer type) {
        this.type = type;
    }
    public String getDate() {
        return date;
    }
    public void setDate(String date) {
        this.date = date;
    }
    public String getVersion() {
        return version;
    }
    public void setVersion(String version) {
        this.version = version;
    }
    public String getStdVersion() {
        return stdVersion;
    }
    public void setStdVersion(String stdVersion) {
        this.stdVersion = stdVersion;
    }
    public String getAdapterStdVersion() {
        return adapterStdVersion;
    }
    public void setAdapterStdVersion(String adapterStdVersion) {
        this.adapterStdVersion = adapterStdVersion;
    }
    public List<AdapterSchemeVersionModel> getVersionList() {
        return versionList;
    }
    public void setVersionList(List<AdapterSchemeVersionModel> versionList) {
        this.versionList = versionList;
    }
}

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

@@ -0,0 +1,41 @@
package com.yihu.jw.basic.standard.model.adapter.resultModel;
import com.yihu.jw.basic.standard.model.adapter.AdapterSchemeVersionModel;
import java.util.List;
/**
 * 任务编排列表
 * @author HZY
 * @vsrsion 1.0
 * Created at 2016/4/27.
 */
public class AdapterSchemeResultModel {
    private Integer schemeId;
    private String name;
    List<AdapterSchemeVersionModel> versionList;
    public Integer getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
        this.schemeId = schemeId;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public List<AdapterSchemeVersionModel> getVersionList() {
        return versionList;
    }
    public void setVersionList(List<AdapterSchemeVersionModel> versionList) {
        this.versionList = versionList;
    }
}

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

@@ -0,0 +1,105 @@
package com.yihu.jw.basic.standard.model.adapter.resultModel;
import java.util.Date;
/**
 * 标准版本模型
 *
 * @created lingfeng 2015/12/23.
 */
public class AdapterSchemeVersionResultDetailModel {
    private Integer id;
    private Integer schemeId;
    private String name;
    private String schemeName;
    private String version;
    private Date publishTime;
    private String publishUser;
    private String baseVersion;
    private Integer publishStatus;
    private String path;
    public AdapterSchemeVersionResultDetailModel(){
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
        this.schemeId = schemeId;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSchemeName() {
        return schemeName;
    }
    public void setSchemeName(String schemeName) {
        this.schemeName = schemeName;
    }
    public String getVersion() {
        return version;
    }
    public void setVersion(String version) {
        this.version = version;
    }
    public Date getPublishTime() {
        return publishTime;
    }
    public void setPublishTime(Date publishTime) {
        this.publishTime = publishTime;
    }
    public String getPublishUser() {
        return publishUser;
    }
    public void setPublishUser(String publishUser) {
        this.publishUser = publishUser;
    }
    public String getBaseVersion() {
        return baseVersion;
    }
    public void setBaseVersion(String baseVersion) {
        this.baseVersion = baseVersion;
    }
    public Integer getPublishStatus() {
        return publishStatus;
    }
    public void setPublishStatus(Integer publishStatus) {
        this.publishStatus = publishStatus;
    }
    public String getPath() {
        return path;
    }
    public void setPath(String path) {
        this.path = path;
    }
}

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

@@ -0,0 +1,151 @@
package com.yihu.jw.basic.standard.model.adapter.resultModel;
/**
 * Created by lingfeng on 2015/9/18.
 */
public class ApiMetadataResultDetailModel {
    private Integer id;
    private Integer schemeId;
    private Integer stdDatasetId;
    private Integer stdMetadataId;
    private String stdMetadataCode;
    private String stdMetadataName;
    private Integer stdDictId;
    private Integer adapterDatasetId;
    private Integer adapterMetadataId;
    private String adapterMetadataCode;
    private String adapterMetadataName;
    private Integer adapterDataType;
    private String adapterDatasetCode;
    private String adapterDatasetName;
    private Integer adapterDictId;
    private String adapterInfo;
    public String getAdapterInfo() {
        return adapterInfo;
    }
    public void setAdapterInfo(String adapterInfo) {
        this.adapterInfo = adapterInfo;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getSchemeId() {
        return schemeId;
    }
    public void setSchemeId(Integer schemeId) {
        this.schemeId = schemeId;
    }
    public Integer getStdDatasetId() {
        return stdDatasetId;
    }
    public void setStdDatasetId(Integer stdDatasetId) {
        this.stdDatasetId = stdDatasetId;
    }
    public Integer getStdMetadataId() {
        return stdMetadataId;
    }
    public void setStdMetadataId(Integer stdMetadataId) {
        this.stdMetadataId = stdMetadataId;
    }
    public String getStdMetadataCode() {
        return stdMetadataCode;
    }
    public void setStdMetadataCode(String stdMetadataCode) {
        this.stdMetadataCode = stdMetadataCode;
    }
    public String getStdMetadataName() {
        return stdMetadataName;
    }
    public void setStdMetadataName(String stdMetadataName) {
        this.stdMetadataName = stdMetadataName;
    }
    public Integer getStdDictId() {
        return stdDictId;
    }
    public void setStdDictId(Integer stdDictId) {
        this.stdDictId = stdDictId;
    }
    public Integer getAdapterDatasetId() {
        return adapterDatasetId;
    }
    public void setAdapterDatasetId(Integer adapterDatasetId) {
        this.adapterDatasetId = adapterDatasetId;
    }
    public Integer getAdapterMetadataId() {
        return adapterMetadataId;
    }
    public void setAdapterMetadataId(Integer adapterMetadataId) {
        this.adapterMetadataId = adapterMetadataId;
    }
    public String getAdapterMetadataCode() {
        return adapterMetadataCode;
    }
    public void setAdapterMetadataCode(String adapterMetadataCode) {
        this.adapterMetadataCode = adapterMetadataCode;
    }
    public String getAdapterMetadataName() {
        return adapterMetadataName;
    }
    public void setAdapterMetadataName(String adapterMetadataName) {
        this.adapterMetadataName = adapterMetadataName;
    }
    public Integer getAdapterDataType() {
        return adapterDataType;
    }
    public void setAdapterDataType(Integer adapterDataType) {
        this.adapterDataType = adapterDataType;
    }
    public Integer getAdapterDictId() {
        return adapterDictId;
    }
    public void setAdapterDictId(Integer adapterDictId) {
        this.adapterDictId = adapterDictId;
    }
    public String getAdapterDatasetCode() {
        return adapterDatasetCode;
    }
    public void setAdapterDatasetCode(String adapterDatasetCode) {
        this.adapterDatasetCode = adapterDatasetCode;
    }
    public String getAdapterDatasetName() {
        return adapterDatasetName;
    }
    public void setAdapterDatasetName(String adapterDatasetName) {
        this.adapterDatasetName = adapterDatasetName;
    }
}

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

@@ -0,0 +1,114 @@
package com.yihu.jw.basic.standard.model.standard;
import com.yihu.jw.entity.IntegerIdentityEntity;
import javax.persistence.Entity;
import javax.persistence.Table;
import java.io.Serializable;
/**
 * 标准基本信息
 *
 * @created Airhead 2015/12/23.
 */
@Entity
@Table(name = "std_info")
public class StandardModel extends IntegerIdentityEntity implements Serializable {
    private String name;
    private String code;
    private String publisher;
    private String publisherOrgCode;
    private String summary;
    private String refStandard;
    private String refStandardVersion;
    private Integer versionStatus;
    public StandardModel(){
    }
    public StandardModel(StandardModel standardModel){
        this.id = standardModel.id;
        this.name = standardModel.name;
        this.code = standardModel.code;
        this.publisher = standardModel.publisher;
        this.publisherOrgCode = standardModel.publisherOrgCode;
        this.summary = standardModel.summary;
        this.refStandard = standardModel.refStandard;
        this.refStandardVersion = standardModel.refStandardVersion;
        this.versionStatus = standardModel.versionStatus;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getPublisher() {
        return publisher;
    }
    public void setPublisher(String publisher) {
        this.publisher = publisher;
    }
    public String getPublisherOrgCode() {
        return publisherOrgCode;
    }
    public void setPublisherOrgCode(String publisherOrgCode) {
        this.publisherOrgCode = publisherOrgCode;
    }
    public String getSummary() {
        return summary;
    }
    public void setSummary(String summary) {
        this.summary = summary;
    }
    public String getRefStandard() {
        return refStandard;
    }
    public void setRefStandard(String refStandard) {
        this.refStandard = refStandard;
    }
    public String getRefStandardVersion() {
        return refStandardVersion;
    }
    public void setRefStandardVersion(String refStandardVersion) {
        this.refStandardVersion = refStandardVersion;
    }
    public Integer getVersionStatus() {
        return versionStatus;
    }
    public void setVersionStatus(Integer versionStatus) {
        this.versionStatus = versionStatus;
    }
}

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

@@ -0,0 +1,135 @@
package com.yihu.jw.basic.standard.model.standard;
import com.yihu.jw.entity.IntegerIdentityEntity;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;
import java.io.Serializable;
import java.util.Date;
/**
 * 标准版本模型
 *
 * @created Airhead 2015/12/23.
 */
@Entity
@Table(name = "std_version")
public class StandardVersionModel extends IntegerIdentityEntity implements Serializable {
    private String version;
    private Integer standardId;
    private String name;
    private Date publishTime;
    private String publishUser;
    private String baseVersion;
    private String primaryVersion;
    private Integer publishStatus;
    private String path;
    public StandardVersionModel(){
    }
    public StandardVersionModel(StandardVersionModel standardVersionModel){
        this.id = standardVersionModel.id;
        this.version = standardVersionModel.version;
        this.standardId = standardVersionModel.standardId;
        this.name = standardVersionModel.name;
        this.publishTime = standardVersionModel.publishTime;
        this.publishUser = standardVersionModel.publishUser;
        this.baseVersion = standardVersionModel.baseVersion;
        this.primaryVersion = standardVersionModel.primaryVersion;
        this.publishStatus = standardVersionModel.publishStatus;
        this.path = standardVersionModel.path;
    }
    public String getVersion() {
        return version;
    }
    public void setVersion(String version) {
        this.version = version;
    }
    @Column(name = "std_id")
    public Integer getStandardId() {
        return standardId;
    }
    public void setStandardId(Integer standardId) {
        this.standardId = standardId;
    }
    @Column(name = "version_name")
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Column(name = "commit_time")
    public Date getPublishTime() {
        return publishTime;
    }
    public void setPublishTime(Date publishTime) {
        this.publishTime = publishTime;
    }
    @Column(name = "publish_user")
    public String getPublishUser() {
        return publishUser;
    }
    public void setPublishUser(String publishUser) {
        this.publishUser = publishUser;
    }
    @Column(name = "base_version")
    public String getBaseVersion() {
        return baseVersion;
    }
    public void setBaseVersion(String baseVersion) {
        this.baseVersion = baseVersion;
    }
    @Column(name = "primary_version")
    public String getPrimaryVersion() {
        return primaryVersion;
    }
    public void setPrimaryVersion(String primaryVersion) {
        this.primaryVersion = primaryVersion;
    }
    @Column(name = "staged")
    public Integer getPublishStatus() {
        return publishStatus;
    }
    public void setPublishStatus(Integer publishStatus) {
        this.publishStatus = publishStatus;
    }
    public String getPath() {
        return path;
    }
    public void setPath(String path) {
        this.path = path;
    }
}

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

@@ -0,0 +1,82 @@
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;
/**
 * CDA类型模型
 *
 * @created Airhead 2015/12/23.
 */
public class StdCDACatalogModel extends Result implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;
    @Column(name = "code")
    private String code;
    @Column(name = "name")
    private String name;
    @Column(name = "parent_id")
    private Integer parentID;
    @Column(name = "sort")
    private String sort;
    @Column(name = "description")
    private String description;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getParentID() {
        return parentID;
    }
    public void setParentID(Integer parentID) {
        this.parentID = parentID;
    }
    public String getSort() {
        return sort;
    }
    public void setSort(String sort) {
        this.sort = sort;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
}

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

@@ -0,0 +1,50 @@
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 java.io.Serializable;
/**
 * CDA与数据集关系模型
 *
 * @created Airhead 2015/12/23.
 */
public class StdCDADatasetModel extends Result implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;
    @Column(name = "cda_id")
    private Integer cdaID;
    @Column(name = "dataset_id")
    private Integer datasetId;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getCdaID() {
        return cdaID;
    }
    public void setCdaID(Integer cdaID) {
        this.cdaID = cdaID;
    }
    public Integer getdatasetId() {
        return datasetId;
    }
    public void setdatasetId(Integer datasetId) {
        this.datasetId = datasetId;
    }
}

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

@@ -0,0 +1,94 @@
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 java.io.Serializable;
/**
 * @created Airhead 2015/12/23.
 */
public class StdCDAModel extends Result implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;
    @Column(name = "std_id")
    private Integer standardId;
    @Column(name = "code")
    private String code;
    @Column(name = "name")
    private String name;
    @Column(name = "path")
    private String path;
    @Column(name = "description")
    private String description;
    @Column(name = "catalog_id")
    private Integer catalogID;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getstandardId() {
        return standardId;
    }
    public void setstandardId(Integer standardId) {
        this.standardId = standardId;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPath() {
        return path;
    }
    public void setPath(String path) {
        this.path = path;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
    public Integer getCatalogID() {
        return catalogID;
    }
    public void setCatalogID(Integer catalogID) {
        this.catalogID = catalogID;
    }
}

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

@@ -0,0 +1,105 @@
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 java.io.Serializable;
/**
 * Created by wq on 2015/9/16.
 */
public class StdDataSetModel extends Result implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;
    @Column(name = "std_id")
    private Integer standardId;
    @Column(name = "code")
    private String code;
    @Column(name = "name")
    private String name;
    @Column(name = "language")
    private String language;
    @Column(name = "catalog")
    private Integer catalog;
    @Column(name = "summary")
    private String summary;
    @Column(name = "class_model")
    private String classModel;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getstandardId() {
        return standardId;
    }
    public void setstandardId(Integer standardId) {
        this.standardId = standardId;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getLanguage() {
        return language;
    }
    public void setLanguage(String language) {
        this.language = language;
    }
    public Integer getCatalog() {
        return catalog;
    }
    public void setCatalog(Integer catalog) {
        this.catalog = catalog;
    }
    public String getSummary() {
        return summary;
    }
    public void setSummary(String summary) {
        this.summary = summary;
    }
    public String getClassModel() {
        return classModel;
    }
    public void setClassModel(String classModel) {
        this.classModel = classModel;
    }
}

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

@@ -0,0 +1,84 @@
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;
/**
 * 数据集模型
 *
 * @created Airhead 2015/12/23.
 */
public class StdDatasetCatalogModel extends Result implements Serializable {
    public static String TABLE_NAME = "STD_DATASET_CATALOG";
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;
    @Column(name = "name")
    private String name;
    @Column(name = "code")
    private String code;
    @Column(name = "parent_id")
    private Integer parentID;
    @Column(name = "sort")
    private String sort;
    @Column(name = "description")
    private String description;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public Integer getParentID() {
        return parentID;
    }
    public void setParentID(Integer parentID) {
        this.parentID = parentID;
    }
    public String getSort() {
        return sort;
    }
    public void setSort(String sort) {
        this.sort = sort;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
}

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

@@ -0,0 +1,81 @@
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 java.io.Serializable;
/**
 * @created Airhead 2015/12/23.
 */
public class StdDictionaryEntryModel extends Result implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;
    @Column(name = "std_id")
    private Integer standardId;
    @Column(name = "dict_id")
    private Integer dictId;
    @Column(name = "code")
    private String code;
    @Column(name = "value")
    private String value;
    @Column(name = "description")
    private String description;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getstandardId() {
        return standardId;
    }
    public void setstandardId(Integer standardId) {
        this.standardId = standardId;
    }
    public Integer getDictId() {
        return dictId;
    }
    public void setDictId(Integer dictId) {
        this.dictId = dictId;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
}

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

@@ -0,0 +1,94 @@
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 java.io.Serializable;
/**
 * 标准数据字典模型
 *
 * @created Airhead 2015/12/23.
 */
public class StdDictionaryModel extends Result implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;
    @Column(name = "std_id")
    private Integer standardId;
    @Column(name = "code")
    private String code;
    @Column(name = "name")
    private String name;
    @Column(name = "define")
    private String define;
    @Column(name = "description")
    private String description;
    @Column(name = "parent_id")
    private Integer parentId;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getstandardId() {
        return standardId;
    }
    public void setstandardId(Integer standardId) {
        this.standardId = standardId;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getDefine() {
        return define;
    }
    public void setDefine(String define) {
        this.define = define;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
    public Integer getParentId() {
        return parentId;
    }
    public void setParentId(Integer parentId) {
        this.parentId = parentId;
    }
}

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

@@ -0,0 +1,180 @@
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 java.io.Serializable;
/**
 * Created by wq on 2015/9/22.
 */
public class StdMetaDataModel extends Result implements Serializable {
    @Id
    @GenericGenerator(name = "generator", strategy = "increment")
    @Column(name = "id")
    private Integer id;                    // 数据元ID
    @Column(name = "std_id")
    private Integer standardId;           //标准ID
    @Column(name = "dataset_id")
    private Integer datasetId;             //数据集ID
    @Column(name = "code")
    private String code;           // 内部代码
    @Column(name = "de_code")
    private String deCode;                 // 标准元编码
    @Column(name = "name")
    private String name;                // 名称
    @Column(name = "type")
    private String type;                // 数据元数据类型
    @Column(name = "format")
    private String format;              // 表示格式
    @Column(name = "dict_id")
    private Integer dictId;                //字典ID
    @Column(name = "definition")
    private String definition;          // 标准元定义, 即说明
    @Column(name = "nullable")
    private Integer nullable;           // 是否可为空
    @Column(name = "column_length")
    private String columnLength;         // 数据长度
    @Column(name = "column_type")
    private String columnType;          // 数据类型
    @Column(name = "column_name")
    private String columnName;          // 字段名
    @Column(name = "primary_key")
    private Integer primaryKey;         // 是否为主键
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getStandardId() {
        return standardId;
    }
    public void setStandardId(Integer standardId) {
        this.standardId = standardId;
    }
    public Integer getDatasetId() {
        return datasetId;
    }
    public void setDatasetId(Integer datasetId) {
        this.datasetId = datasetId;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getDeCode() {
        return deCode;
    }
    public void setDeCode(String deCode) {
        this.deCode = deCode;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public String getFormat() {
        return format;
    }
    public void setFormat(String format) {
        this.format = format;
    }
    public Integer getDictId() {
        return dictId;
    }
    public void setDictId(Integer dictId) {
        this.dictId = dictId;
    }
    public String getDefinition() {
        return definition;
    }
    public void setDefinition(String definition) {
        this.definition = definition;
    }
    public Integer getNullable() {
        return nullable;
    }
    public void setNullable(Integer nullable) {
        this.nullable = nullable;
    }
    public String getColumnLength() {
        return columnLength;
    }
    public void setColumnLength(String columnLength) {
        this.columnLength = columnLength;
    }
    public String getColumnType() {
        return columnType;
    }
    public void setColumnType(String columnType) {
        this.columnType = columnType;
    }
    public String getColumnName() {
        return columnName;
    }
    public void setColumnName(String columnName) {
        this.columnName = columnName;
    }
    public Integer getPrimaryKey() {
        return primaryKey;
    }
    public void setPrimaryKey(Integer primaryKey) {
        this.primaryKey = primaryKey;
    }
}

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

@@ -0,0 +1,27 @@
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 {
    String name;
    String code;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
}

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

@@ -0,0 +1,27 @@
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 {
    String code;
    String orgCode;
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getOrgCode() {
        return orgCode;
    }
    public void setOrgCode(String orgCode) {
        this.orgCode = orgCode;
    }
}

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

@@ -0,0 +1,78 @@
package com.yihu.jw.basic.standard.model.standard.resultModel;
import java.io.Serializable;
public class StandardResultDetailModel implements Serializable {
    String id;
    String pid;
    String name;
    String code;
    Integer status;
    String publisher;
    Integer type;
    String date;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getPid() {
        return pid;
    }
    public void setPid(String pid) {
        this.pid = pid;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPublisher() {
        return publisher;
    }
    public void setPublisher(String publisher) {
        this.publisher = publisher;
    }
    public Integer getStatus() {
        return status;
    }
    public void setStatus(Integer status) {
        this.status = status;
    }
    public Integer getType() {
        return type;
    }
    public void setType(Integer type) {
        this.type = type;
    }
    public String getDate() {
        return date;
    }
    public void setDate(String date) {
        this.date = date;
    }
}

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

@@ -0,0 +1,82 @@
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.util.sql.ErrorCode;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.exception.ApiException;
import com.yihu.jw.util.sql.SqlCreator;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Transactional
@Service("AdapterDatasetRelationService")
public class AdapterDatasetRelationService extends SQLGeneralDAO {
    public static final String BEAN_ID = "AdapterDatasetRelationService";
    public AdapterDatasetRelationService() {
    }
    public void finalize() throws Throwable {
        super.finalize();
    }
    public AdapterDatasetRelationModel add(String adapterVersion, String datasetRelation) {
        try {
            AdapterVersion version = new AdapterVersion(adapterVersion);
            AdapterDatasetRelationModel adapterDatasetRelationModel = objectMapper.readValue(datasetRelation, AdapterDatasetRelationModel.class);
            Session session = getCurrentSession();
            String sql = "select max(id) from " + version.getMetaDataTableName();
            Query query = session.createSQLQuery(sql);
            Object object = query.uniqueResult();
            adapterDatasetRelationModel.setId(object == null ? 1 : Integer.parseInt(object.toString()) + 1);
            JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterDatasetRelationModel));
            SqlCreator sqlCreator = new SqlCreator(AdapterDatasetRelationModel.class);
            sql = sqlCreator.insertData(version.getMetaDataTableName(), jsonNode);
            query = getExeuteQuery(sqlCreator, sql);
            query.executeUpdate();
            adapterDatasetRelationModel.setSuccessFlg(true);
            adapterDatasetRelationModel.setMessage("保存数据集关联成功");
            return adapterDatasetRelationModel;
        } catch (Exception e) {
            throw new ApiException(ErrorCode.SaveDatasetRelationFailed.getErrorCode());
        }
    }
    public void delete(String adapterVersion, Integer datasetRelationId) {
        try {
            if (adapterVersion == null || adapterVersion.length() == 0) {
                throw new ApiException(ErrorCode.InvalidStdVersion.getErrorCode());
            }
            AdapterVersion version = new AdapterVersion(adapterVersion);
            Session session = getCurrentSession();
            String sql = "delete from " + version.getMetaDataTableName() + " where id = :id";
            Query query = session.createSQLQuery(sql);
            query.setInteger("id", datasetRelationId);
            query.executeUpdate();
        } catch (Exception e) {
            throw new ApiException(ErrorCode.DeleteDataSetRelationFailed.getErrorCode());
        }
    }
    public AdapterDatasetRelationModel modify(String adapterVersion, String datasetRelation) {
        try {
            AdapterVersion version = new AdapterVersion(adapterVersion);
            AdapterDatasetRelationModel adapterDatasetRelationModel = objectMapper.readValue(datasetRelation, AdapterDatasetRelationModel.class);
            JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterDatasetRelationModel));
            SqlCreator sqlCreator = new SqlCreator(AdapterDatasetRelationModel.class);
            String sql = sqlCreator.updateDataByTableKey(version.getMetaDataTableName(), jsonNode);
            Query query = getExeuteQuery(sqlCreator, sql);
            query.executeUpdate();
            return adapterDatasetRelationModel;
        } catch (Exception e) {
            throw new ApiException(ErrorCode.UpdateatasetRelationFailed.getErrorCode());
        }
    }
}

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

@@ -0,0 +1,723 @@
package com.yihu.jw.basic.standard.service.adapter;
import com.fasterxml.jackson.databind.JsonNode;
import com.yihu.jw.basic.standard.dao.IStdDataSetModelDao;
import com.yihu.jw.basic.standard.dao.IStdMetaDataModelDao;
import com.yihu.jw.basic.standard.match.matchModel.MetadataMatchVO;
import com.yihu.jw.basic.standard.match.metadata.MetadataStrategyExecute;
import com.yihu.jw.basic.standard.match.metadata.MetatdataStandardNameStrategy;
import com.yihu.jw.basic.standard.model.TreeView;
import com.yihu.jw.basic.standard.model.adapter.AdapterDatasetModel;
import com.yihu.jw.basic.standard.model.adapter.AdapterDictModel;
import com.yihu.jw.basic.standard.model.adapter.AdapterMetadataModel;
import com.yihu.jw.basic.standard.model.adapter.AdapterSchemeVersionModel;
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.basic.standard.service.standard.StdMetadataService;
import com.yihu.jw.basic.util.GetChineseFirst;
import com.yihu.jw.lang.SpringContext;
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.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 org.apache.commons.collections.CollectionUtils;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
@Transactional
@Service("AdapterDatasetService")
public class AdapterDatasetService extends SQLGeneralDAO {
    public static final String BEAN_ID = "AdapterDatasetService";
    @Autowired
    private AdapterMetadataService adapterMetadataService;
    @Autowired
    private AdapterSchemeVersionService adapterSchemeVersionService;
    @Autowired
    private ThreadPoolTaskExecutor threadPoolTaskExecutor;
    @Autowired
    private IStdMetaDataModelDao stdMetaDataModelDao;
    @Autowired
    private IStdDataSetModelDao stdDataSetModelDao;
    @Autowired
    private StdMetadataService stdMetadataService;
    private AdapterDatasetService adapterDatasetService;
    public AdapterDatasetService() {
    }
    public void finalize() throws Throwable {
        super.finalize();
    }
    public ObjEnvelop add(String adapterVersion, String dataset) {
        try {
            AdapterVersion version = new AdapterVersion(adapterVersion);
            AdapterDatasetModel adapterDatasetModel = objectMapper.readValue(dataset, AdapterDatasetModel.class);
            adapterDatasetModel.setId(getMaxId(version.getDataSetTableName()));
            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 Envelop delete(String adapterVersion, Integer datasetId) {
        try {
            if (adapterVersion == null || adapterVersion.length() == 0) {
                return Envelop.getSuccess("无效适配版本");
            }
            AdapterVersion version = new AdapterVersion(adapterVersion);
            Session session = getCurrentSession();
            String sql = "delete from " + version.getDataSetTableName() + " where id = :id";
            Query query = session.createSQLQuery(sql);
            query.setInteger("id", datasetId);
            query.executeUpdate();
            return Envelop.getSuccess("删除适配数据集成功");
        } catch (Exception e) {
            e.printStackTrace();
            return Envelop.getError("删除适配数据集失败",-1);
        }
    }
    public ObjEnvelop modify(String adapterVersion, String dataset) {
        try {
            AdapterVersion version = new AdapterVersion(adapterVersion);
            AdapterDatasetModel adapterDatasetModel = objectMapper.readValue(dataset, AdapterDatasetModel.class);
            JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterDatasetModel));
            SqlCreator sqlCreator = new SqlCreator(AdapterDatasetModel.class);
            String sql = sqlCreator.updateDataByTableKey(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 get(String version, Integer datasetId) {
        try {
            AdapterVersion adapterVersion = new AdapterVersion(version);
            AdapterDatasetModel adapterDatasetModel = (AdapterDatasetModel) get(AdapterDatasetModel.class, adapterVersion.getDataSetTableName(), datasetId);
            return ObjEnvelop.getSuccess("获取适配数据集成功",adapterDatasetModel);
        } catch (Exception e) {
            e.printStackTrace();
            return ObjEnvelop.getError("获取适配数据集失败",-1);
        }
    }
    public PageEnvelop getDetailModelResult(String version, String condition, String order, Integer rows, Integer page) {
        try {
            AdapterVersion adapterVersion = new AdapterVersion(version);
            List<AdapterDatasetModel> dataSetModelList = getDatasetList(AdapterDatasetModel.class, version, condition, order, rows, page);
            Integer count = getDatasetInt(AdapterDatasetModel.class, adapterVersion, condition);
            PageEnvelop detailModelResult = PageEnvelop.getSuccess("获取适配数据集成功");
            detailModelResult.setDetailModelList(dataSetModelList);
            detailModelResult.setTotalCount(count);
            return detailModelResult;
        } catch (Exception e) {
            e.printStackTrace();
            return PageEnvelop.getError("获取适配数据集失败",-1);
        }
    }
    public List getDatasetList(Class tClass, String version, String condition, String order, Integer limit, Integer offset) throws Exception {
        AdapterVersion adapterVersion = new AdapterVersion(version);
        String tableName = adapterVersion.getDataSetTableName();
        SqlCreator sqlCreator = new SqlCreator(tClass);
        if (!StringUtil.isEmpty(condition)) {
            JsonNode jsonNode = objectMapper.readTree(condition);
            String name = jsonNode.get("name").asText();
            sqlCreator.likeOrCondition("stdDatasetName", "stdDatasetCode", name);
        }
        if (!StringUtil.isEmpty(order)) {
            JsonNode jsonNode = objectMapper.readTree(order);
            Iterator<String> fieldNames = jsonNode.fieldNames();
            while (fieldNames.hasNext()) {
                String fieldName = fieldNames.next();
                String value = jsonNode.get(fieldName).asText().toUpperCase();
                sqlCreator.order(fieldName, value);
            }
        }
        String sql = sqlCreator.selectData(tableName);
        Query query = getQuery(sqlCreator, sql);
        if (limit != null) {
            query.setMaxResults(limit);
            if (offset != null) {
                query.setFirstResult((offset - 1) * limit);
            }
        }
        return query.list();
    }
    public Integer getDatasetInt(Class tClass, AdapterVersion adapterVersion, String condition) {
        try {
            String tableName = adapterVersion.getDataSetTableName();
            SqlCreator sqlCreator = new SqlCreator(tClass);
            if (!StringUtil.isEmpty(condition)) {
                JsonNode jsonNode = objectMapper.readTree(condition);
                String name = jsonNode.get("name").asText();
                sqlCreator.likeOrCondition("stdDatasetName", "stdDatasetCode", name);
            }
            String sql = sqlCreator.countData(tableName);
            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;
        } catch (Exception e) {
            e.printStackTrace();
            throw new ApiException(ErrorCode.GetDataSetListFailed.getErrorCode());
        }
    }
    public void getAdapterCustomize(String adapterVersion, List<TreeView> treeViewList, List<Integer> hasCheckDatasetIdList, List<Integer> hasCheckMetadataIdList) {
        boolean adapter = false;  //定制是否添加根节点
        //获取所有定制数据集
        AdapterVersion aVersion = new AdapterVersion(adapterVersion);
        List<AdapterDatasetModel> adapterDataSetList = getList(AdapterDatasetModel.class, aVersion.getDataSetTableName(), "", "", null, null);
        List<AdapterMetadataModel> adapterMetaDataList = getList(AdapterMetadataModel.class, aVersion.getMetaDataTableName(), "", "", null, null);
        List<TreeView> adapterCustomizeList = new ArrayList<>();
        //数据集
        for (AdapterDatasetModel adapterDataset : adapterDataSetList) {
            TreeView parent = new TreeView();
            parent.setId("AD" + adapterDataset.getStdDatasetId());
            parent.setPid("A0");
            parent.setText(adapterDataset.getStdDatasetName());
            parent.setIschecked(true);
            adapterCustomizeList.add(parent);
            adapter = true;
            hasCheckDatasetIdList.add(adapterDataset.getStdDatasetId());
        }
        //数据元
        for (AdapterMetadataModel adapterMetadat : adapterMetaDataList) {
            TreeView child = new TreeView();
            child.setId("AM" + adapterMetadat.getStdMetadataId());
            child.setPid("AD" + adapterMetadat.getStdDatasetId());
            child.setText(adapterMetadat.getStdMetadataName());
            child.setIschecked(true);
            adapterCustomizeList.add(child);
            adapter = true;
            hasCheckMetadataIdList.add(adapterMetadat.getStdMetadataId());
        }
        //根节点
        if (adapter) {
            TreeView adapterRoot = new TreeView();
            adapterRoot.setId("A0");
            adapterRoot.setPid("-1");
            adapterRoot.setText("数据集");
            adapterRoot.setIschecked(true);
            adapterCustomizeList.add(adapterRoot);
        }
        treeViewList.addAll(adapterCustomizeList);
    }
    public void getStdCustomize(String stdVersion, List<TreeView> treeViewList, List<Integer> hasCheckDatasetIdList, List<Integer> hasCheckMetadataIdList) {
        String id;
        boolean check;     //是否勾选
        boolean std = false;      //标准是否添加根节点
        long childCheckCount;
        long datasetCount = 0;
        //获取所有标准数据集
        StandardVersion sVersion = new StandardVersion(stdVersion);
        List<StdDataSetModel> dataSetList = getList(StdDataSetModel.class, sVersion.getDataSetTableName(), "", "", null, null);
        String idListStr = SqlConstants.EMPTY;
        for (StdDataSetModel dataSet : dataSetList) {
            idListStr += dataSet.getId() + SqlConstants.COMMA;
        }
        Map<Integer, List<StdMetaDataModel>> stdDataSetModelMap = new HashMap<>();
        if (!StringUtil.isEmpty(idListStr)) {
            String tableName = sVersion.getMetaDataTableName();
            SqlCreator sqlCreator = new SqlCreator(StdMetaDataModel.class);
            String sql = sqlCreator.selectData(tableName);
            Query query = getQuery(sqlCreator, sql);
            List<StdMetaDataModel> stdMetaDataModelList = query.list();
            for (StdMetaDataModel stdMetaDataModel : stdMetaDataModelList) {
                List<StdMetaDataModel> stdMetaDataModels = stdDataSetModelMap.get(stdMetaDataModel.getDatasetId());
                if (stdMetaDataModels == null) {
                    stdMetaDataModels = new ArrayList<>();
                }
                stdMetaDataModels.add(stdMetaDataModel);
                stdDataSetModelMap.put(stdMetaDataModel.getDatasetId(), stdMetaDataModels);
            }
        }
        List<TreeView> stdCustomizeList = new ArrayList<>();
        for (StdDataSetModel dataSet : dataSetList) {
            TreeView parent = new TreeView();
            parent.setId("SD" + dataSet.getId());
            parent.setPid("S0");
            parent.setText(dataSet.getName());
            parent.setIschecked(false);
            std = true;
            childCheckCount = 0;
            List<StdMetaDataModel> metaDataList = stdDataSetModelMap.get(dataSet.getId());
            if (!CollectionUtils.isEmpty(metaDataList)) {
                for (StdMetaDataModel metaData : metaDataList) {
                    id = String.valueOf(metaData.getId());
                    if (hasCheckMetadataIdList.contains(metaData.getId())) {
                        check = true;
                        childCheckCount++;
                    } else {
                        check = false;
                    }
                    TreeView child = new TreeView();
                    child.setId("SM" + id);
                    child.setPid("SD" + dataSet.getId());
                    child.setText(metaData.getName());
                    child.setIschecked(check);
                    stdCustomizeList.add(child);
                }
                std = true;
            }
            if (!CollectionUtils.isEmpty(metaDataList) && metaDataList.size() == childCheckCount && childCheckCount > 0) {
                parent.setIschecked(true);//子节点全选
                datasetCount++;
            } else if (CollectionUtils.isEmpty(metaDataList) && hasCheckDatasetIdList.contains(dataSet.getId())) {
                parent.setIschecked(true);
                datasetCount++;
            }
            stdCustomizeList.add(parent);
        }
        //根节点
        if (std) {
            TreeView stdRoot = new TreeView();
            stdRoot.setId("S0");
            stdRoot.setPid("-1");
            stdRoot.setText("数据集");
            if (datasetCount == dataSetList.size()) {
                stdRoot.setIschecked(true);
            } else {
                stdRoot.setIschecked(false);
            }
            stdCustomizeList.add(stdRoot);
        }
        treeViewList.addAll(stdCustomizeList);
    }
    public ListEnvelop getDatasetCustomize(String adapterVersion, String stdVersion) {
        try {
            List<TreeView> treeViewList = new ArrayList<>();
            List<Integer> hasCheckDatasetIdList = new ArrayList<>();
            List<Integer> hasCheckMetadataIdList = new ArrayList<>();
            getAdapterCustomize(adapterVersion, treeViewList, hasCheckDatasetIdList, hasCheckMetadataIdList);
            getStdCustomize(stdVersion, treeViewList, hasCheckDatasetIdList, hasCheckMetadataIdList);
            ListEnvelop detailModelResult = ListEnvelop.getSuccess("获取定制数据集列表成功",treeViewList);
            return detailModelResult;
        } catch (Exception e) {
            e.printStackTrace();
            return ListEnvelop.getError("获取定制数据集列表失败");
        }
    }
    public Envelop updateCustomize(Integer schemeId, String adapterVersion, String stdVersion, String datasetIdStr, String metaDataIdStr) {
        AdapterVersion aVersion = new AdapterVersion(adapterVersion);
        StandardVersion sVersion = new StandardVersion(stdVersion);
        try {
            String[] datasetIdList = datasetIdStr.split(",");
            String[] metadataIdList = metaDataIdStr.split(",");
            List<Integer> newDatasetIdList = new ArrayList<>();
            List<Integer> newMetadataIdList = new ArrayList<>();
            for (String datasetId : datasetIdList) {
                if (!StringUtil.isStrEmpty(datasetId)) {
                    Integer newDatasetId = Integer.parseInt(datasetId);
                    newDatasetIdList.add(newDatasetId);
                }
            }
            for (String metadataId : metadataIdList) {
                if (!StringUtil.isStrEmpty(metadataId)) {
                    Integer newMetadataId = Integer.parseInt(metadataId);
                    newMetadataIdList.add(newMetadataId);
                }
            }
            if (newDatasetIdList.size() == 0) {
                return Envelop.getError("定制内容为空");
            }
            updateDatasetCustomizeData(schemeId, aVersion, sVersion, newDatasetIdList, newMetadataIdList);
            return Envelop.getSuccess("定制数据集成功");
        } catch (Exception e) {
            e.printStackTrace();
            return Envelop.getError("定制数据集失败");
        }
    }
    public void updateDatasetCustomizeData(Integer schemeId, AdapterVersion aVersion, StandardVersion sVersion, List<Integer> newDatasetIdList, List<Integer> newMetadataIdList) throws Exception {
        List<StdMetaDataModel> metadataList = new ArrayList<StdMetaDataModel>();
        if (newMetadataIdList.size() > 0) {
            SqlCreator sqlCreator = new SqlCreator(StdMetaDataModel.class);
            sqlCreator.inCondition("id", newMetadataIdList);
            String sql = sqlCreator.selectData(sVersion.getMetaDataTableName());
            Query query = getQuery(sqlCreator, sql);
            metadataList = query.list();
        }
        List<Integer> newDictdList = new ArrayList<>();
        for (StdMetaDataModel stdMetaDataModel : metadataList) {
            if (stdMetaDataModel.getDictId() != null && !newDictdList.contains(stdMetaDataModel.getDictId())) {
                newDictdList.add(stdMetaDataModel.getDictId());
            }
        }
        List<String> insertSqlList = new ArrayList<>();
        // 找出新增 删除  modify by cyj
        List<AdapterDatasetModel> datasetModels = selectData(aVersion.getDataSetTableName(), AdapterDatasetModel.class);
        List<AdapterMetadataModel> metadataModels = selectData(aVersion.getMetaDataTableName(), AdapterMetadataModel.class);
        List<AdapterDictModel> dictModels = selectData(aVersion.getDictTableName(), AdapterDictModel.class);
//        List<AdapterDictEntryModel> dictEntryModels = selectData(aVersion.getDictEntryTableName(), AdapterDictEntryModel.class);
        List<Integer> oldDatasetIdList = new ArrayList<>();
        for (AdapterDatasetModel datasetModel : datasetModels) {
            oldDatasetIdList.add(datasetModel.getId());
        }
        List<Integer> oldMetadataIdList = new ArrayList<>();
        for (AdapterMetadataModel metadataModel : metadataModels) {
            oldMetadataIdList.add(metadataModel.getId());
        }
        List<Integer> oldDictIdList = new ArrayList<>();
        for (AdapterDictModel dictModel : dictModels) {
            oldDictIdList.add(dictModel.getId());
        }
//        List<Integer> oldDictEntryIdList = new ArrayList<>();
//        for (AdapterDictEntryModel entryModel : dictEntryModels) {
//            oldDictEntryIdList.add(entryModel.getStdDictId());
//        }
        Map<String, List<Integer>> datasetMap = getDiffId(newDatasetIdList, oldDatasetIdList);
        Map<String, List<Integer>> metaMap = getDiffId(newMetadataIdList, oldMetadataIdList);
        Map<String, List<Integer>> dicMap = getDiffId(newDictdList, oldDictIdList);
//        Map<String,List<Integer>> dicEntryMap = getDiffId(newDictdList,oldDictEntryIdList);
//        add del
        List<Integer> delDatasetList = datasetMap.get("del");
        if (delDatasetList.size() > 0) {
            insertSqlList.add(delData(aVersion.getDataSetTableName(), "id", delDatasetList));
        }
        List<Integer> delMetaList = metaMap.get("del");
        if (delMetaList.size() > 0) {
            insertSqlList.add(delData(aVersion.getMetaDataTableName(), "id", delMetaList));
        }
        List<Integer> delDicList = dicMap.get("del");
        if (delDicList.size() > 0) {
            insertSqlList.add(delData(aVersion.getDictTableName(), "id", delDicList));
            insertSqlList.add(delData(aVersion.getDictEntryTableName(), "std_dict_id", delDicList));
        }
/*        insertSqlList.add(SqlConstants.DELETE + SqlConstants.FROM + aVersion.getDataSetTableName());
        insertSqlList.add(SqlConstants.DELETE + SqlConstants.FROM + aVersion.getMetaDataTableName());
        insertSqlList.add(SqlConstants.DELETE + SqlConstants.FROM + aVersion.getDictTableName());
        insertSqlList.add(SqlConstants.DELETE + SqlConstants.FROM + aVersion.getDictEntryTableName());*/
        List<Integer> addDataSetList = datasetMap.get("add");
        if (addDataSetList.size() > 0) {
            insertSqlList.add(insertData(aVersion.getDataSetTableName(), sVersion.getDataSetTableName(),
                    new String[]{"id,std_dataset_id,std_dataset_code,std_dataset_name"},
                    new String[]{"id,id,code,name"},
                    schemeId,
                    "id",
                    addDataSetList));
        }
        List<Integer> addMetaList = metaMap.get("add");
        if (addMetaList.size() > 0) {
            insertSqlList.add(insertData(aVersion.getMetaDataTableName(), sVersion.getMetaDataTableName(),
                    new String[]{"id,std_metadata_id,std_metadata_code,std_metadata_name,std_dataset_id,std_dict_id"},
                    new String[]{"id,id,code,name,dataset_id,dict_id"},
                    schemeId,
                    "id",
                    addMetaList));
        }
        List<Integer> addDicList = dicMap.get("add");
        if (addDicList.size() > 0) {
            insertSqlList.add(insertData(aVersion.getDictTableName(), sVersion.getDictTableName(),
                    new String[]{"id,std_dict_id,std_dict_code,std_dict_name"},
                    new String[]{"id,id,code,name"},
                    schemeId,
                    "id",
                    addDicList));
            insertSqlList.add(insertData(aVersion.getDictEntryTableName(), sVersion.getDictEntryTableName(),
                    new String[]{"id,std_entry_id,std_entry_code,std_entry_value,std_dict_id"},
                    new String[]{"id,id,code,value,dict_id"},
                    schemeId,
                    "dict_id",
                    addDicList));
        }
        if (insertSqlList.size() > 0) {
            insertBatch(insertSqlList);
        }
    }
    private String delData(String adapterTableName, String item, List<Integer> idList) {
        StringBuffer sql = new StringBuffer();
        String idStr = SqlConstants.EMPTY;
        for (Integer id : idList) {
            idStr += id + SqlConstants.COMMA;
        }
        if (!StringUtil.isEmpty(idStr)) {
            idStr = SqlConstants.LEFT_BRACKET + idStr.substring(0, idStr.length() - 1) + SqlConstants.RIGHT_BRACKET;
        }
        sql.append(SqlConstants.DELETE + SqlConstants.FROM).append(adapterTableName).append(SqlConstants.WHERE).append(item).append(SqlConstants.IN).append(idStr);
        return sql.toString();
    }
    /**
     * 将第一个数组放入map(id,1) 然后循环第二个数组，如果map中找到对应键值就+1  不存在设置 1
     *
     * @param firtList   new
     * @param secondList old
     */
    private Map<String, List<Integer>> getDiffId(List<Integer> firtList, List<Integer> secondList) {
        Map<Integer, Integer> map = new HashMap<>();
        for (Integer id : firtList) {
            map.put(id, 1);
        }
        for (Integer id1 : secondList) {
            Integer flag = map.get(id1);
            if (flag != null) {
                map.put(id1, ++flag);
            } else {
                map.put(id1, 1);
            }
        }
        List<Integer> diffLs = new ArrayList<>();
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            if (entry.getValue() == 1) {
                diffLs.add(entry.getKey());
            }
        }
        List<Integer> delIDLs = new ArrayList<>();
        List<Integer> addIDLs = new ArrayList<>();
        for (Integer diffL : diffLs) {
            if (firtList.contains(diffL)) {
                addIDLs.add(diffL);
            } else if (secondList.contains(diffL)) {
                delIDLs.add(diffL);
            }
        }
        Map<String, List<Integer>> listMap = new HashMap<>();
        listMap.put("del", delIDLs);
        listMap.put("add", addIDLs);
        return listMap;
    }
    private String insertData(String adapterTableName, String stdTableName, String[] item1, String[] item2, Integer schemeId, String item, List<Integer> idList) {
        StringBuffer sql = new StringBuffer();
        String idStr = SqlConstants.EMPTY;
        for (Integer id : idList) {
            idStr += id + SqlConstants.COMMA;
        }
        if (!StringUtil.isEmpty(idStr)) {
            idStr = SqlConstants.LEFT_BRACKET + idStr.substring(0, idStr.length() - 1) + SqlConstants.RIGHT_BRACKET;
        }
        sql.append(SqlConstants.INSERT_INTO + adapterTableName + SqlConstants.LEFT_BRACKET);
        for (String it : item1) {
            sql.append(it + SqlConstants.COMMA);
        }
        sql.append("scheme_id" + SqlConstants.RIGHT_BRACKET + SqlConstants.LEFT_BRACKET + SqlConstants.SELECT);
        for (String it : item2) {
            sql.append(it + SqlConstants.COMMA);
        }
        sql.append(schemeId + SqlConstants.FROM + stdTableName + SqlConstants.WHERE + item + SqlConstants.IN + idStr + SqlConstants.RIGHT_BRACKET);
        return sql.toString();
    }
    public List selectData(String adapterTableName, Class clazz) throws Exception {
        StringBuffer sql = new StringBuffer();
        sql.append("SELECT * FROM ").append(adapterTableName);
        return queryListBySql(sql.toString(), clazz);
    }
    public List getAdapterDatasetNotNullList(AdapterVersion adapterVersion, String condition) {
        try {
            StringBuffer sql = new StringBuffer();
            sql.append("SELECT * FROM ").append(adapterVersion.getDataSetTableName());
            if (!StringUtil.isEmpty(condition)) {
                JsonNode jsonNode = objectMapper.readTree(condition);
                String column = jsonNode.get("column").asText();
                sql.append(" WHERE ").append(column).append(" IS NOT NULL");
            }
            Query query = getCurrentSession().createSQLQuery(sql.toString());
            query.setResultTransformer(new BeanTransformer(AdapterDatasetModel.class));
            return query.list();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    public List getListByAdapterDatasetIdList(AdapterVersion adapterVersion, List<Integer> datasetIdList) {
        try {
            if (CollectionUtils.isEmpty(datasetIdList)) {
                return null;
            }
            SqlCreator sqlCreator = new SqlCreator(AdapterDatasetModel.class);
            sqlCreator.inCondition("stdDatasetId", datasetIdList);
            String sql = sqlCreator.selectData(adapterVersion.getDataSetTableName());
            Query query = getQuery(sqlCreator, sql);
            return query.list();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    public AdapterDatasetModel getAdapterDatasetByCode(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);
            Query query = getQuery(sqlCreator, sql);
            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)) {
                return null;
            }
            SqlCreator sqlCreator = new SqlCreator(AdapterDatasetModel.class);
            sqlCreator.inCondition("adapterDatasetId", datasetIdList);
            String sql = sqlCreator.selectData(adapterVersion.getDataSetTableName());
            Query query = getQuery(sqlCreator, sql);
            return query.list();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    public void strategy(String version,String std_version,String adapter_std_version) throws Exception {
        List<AdapterMetadataModel> unAdapterMetadataModels =  adapterMetadataService.getAllUnAdaptMetadata(version);//等待适配的标准数据元
        List<AdapterMetadataModel> adapterMetadataModel = new ArrayList<AdapterMetadataModel>();//之前已经适配好的适配方案
        //获取所有未匹配的
        //查找出  之前已经适配好的适配方案
        List<AdapterSchemeVersionModel> all = adapterSchemeVersionService.getAll();
        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());
                    adapterMetadataModel.addAll(adaptMetadata);
                }
            }
        }
        MetadataMatchVO matchVO = new MetadataMatchVO();
        matchVO.setCodeAdapter(matchVO.geNameGroup(adapterMetadataModel));
        //設置匹配的机构数据緩存
        List<StdMetaDataModel> orgMetadatas = stdMetadataService.getList(adapter_std_version, null, null, null, null, null);//查找出机构所有的metadatas
        for (StdMetaDataModel stdMetadata:orgMetadatas){
            StdDataSetModel stdDataset = stdDataSetModelDao.getDatasetName(std_version, stdMetadata.getDatasetId());
            if(null != stdDataset){
                MetatdataStandardNameStrategy.getNameMap().put(stdMetadata.getName() + "_" + stdDataset.getCode(),stdMetadata);
                MetatdataStandardNameStrategy.getRemarkMap().put(stdMetadata.getDefinition() + "_" + stdDataset.getCode(),stdMetadata);
            }
        }
        //执行匹配
        MetadataStrategyExecute.setFirst(version, unAdapterMetadataModels.size());//设置第一次匹配
        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));
            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);
                if (adapterDataset != null) {
                    adapterDatasetService = SpringContext.getService(AdapterDatasetService.BEAN_ID);
                    AdapterDatasetModel entity = adapterDatasetService.getAdapterDatasetByCode(version, adapterDataset.getCode());
                    String sqrSql = null;
                    if(null != entity){
                        sqrSql = adapterDatasetService.saveAdaptDatasetSql(entity, adapterDataset, version);
                    }
                    if(null != sqrSql && !"".equals(sqrSql)){
                        sqlList.add(sqrSql);
                    }
                }
            }
        }
        if(CollectionUtils.isNotEmpty(sqlList)){
            List list=new ArrayList();
            Iterator it=sqlList.iterator();
            while(it.hasNext()){
                list.add((String) it.next());
            }
            super.insertBatch(list);
        }
    }
    public void saveAdaptDataset(AdapterDatasetModel strategyDataset,StdDataSetModel orgDataset,String version) throws Exception {
        if(null != strategyDataset){
            strategyDataset.setAdapterDatasetId(orgDataset.getId());
            strategyDataset.setAdapterDatasetCode(orgDataset.getCode());
            strategyDataset.setAdapterDatasetName(orgDataset.getName());
            JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(strategyDataset));
            SqlCreator sqlCreator = new SqlCreator(AdapterDatasetModel.class);
            String sql = sqlCreator.updateDataByTableKey(new AdapterVersion(version).getDataSetTableName(), jsonNode);
            Query query = getExeuteQuery(sqlCreator, sql);
            query.executeUpdate();
        }
    }
    public String saveAdaptDatasetSql(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();
    }
}

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

@@ -0,0 +1,382 @@
package com.yihu.jw.basic.standard.service.adapter;
import com.fasterxml.jackson.databind.JsonNode;
import com.yihu.jw.basic.standard.model.adapter.AdapterDictEntryModel;
import com.yihu.jw.basic.standard.model.adapter.AdapterDictModel;
import com.yihu.jw.basic.standard.model.adapter.AdapterSchemeModel;
import com.yihu.jw.basic.standard.model.adapter.resultModel.AdapterDictEntryResultDetailModel;
import com.yihu.jw.basic.standard.model.standard.StdDictionaryEntryModel;
import com.yihu.jw.basic.standard.model.standard.StdDictionaryModel;
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.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.SqlCreator;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import java.io.IOException;
import java.util.*;
@Transactional
@Service("AdapterDictEntryService")
public class AdapterDictEntryService extends SQLGeneralDAO {
    public static final String BEAN_ID = "AdapterDictEntryService";
    public AdapterDictEntryService() {
    }
    public void finalize() throws Throwable {
        super.finalize();
    }
    public ObjEnvelop add(String adapterVersion, String dictentry) {
        try {
            AdapterVersion version = new AdapterVersion(adapterVersion);
            AdapterDictEntryModel adapterDictEntryModel = objectMapper.readValue(dictentry, AdapterDictEntryModel.class);
            Session session = getCurrentSession();
            String sql = "select max(id) from " + version.getDictEntryTableName();
            Query query = session.createSQLQuery(sql);
            Object object = query.uniqueResult();
            adapterDictEntryModel.setId(object == null ? 1 : Integer.parseInt(object.toString()) + 1);
            JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterDictEntryModel));
            SqlCreator sqlCreator = new SqlCreator(AdapterDictEntryModel.class);
            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("保存适配字典项失败");
        }
    }
    public void delete(String adapterVersion, Integer dictentryId) {
        try {
            if (adapterVersion == null || adapterVersion.length() == 0) throw new IllegalArgumentException("无效版本");
            AdapterVersion version = new AdapterVersion(adapterVersion);
            Session session = getCurrentSession();
            String sql = "delete from " + version.getDictEntryTableName() + " where id = :id";
            Query query = session.createSQLQuery(sql);
            query.setInteger("id", dictentryId);
            query.executeUpdate();
        } catch (Exception e) {
            throw new ApiException(ErrorCode.DeleteDictEntryFailed.getErrorCode());
        }
    }
    public ObjEnvelop modify(String adapterVersion, String dictentry) {
        try {
            AdapterVersion version = new AdapterVersion(adapterVersion);
            AdapterDictEntryModel adapterDictEntryModel = objectMapper.readValue(dictentry, AdapterDictEntryModel.class);
            JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterDictEntryModel));
            SqlCreator sqlCreator = new SqlCreator(AdapterDictEntryModel.class);
            String sql = sqlCreator.updateDataByTableKey(version.getDictEntryTableName(), jsonNode);
            Query query = getExeuteQuery(sqlCreator, sql);
            query.executeUpdate();
            return ObjEnvelop.getSuccess("获取适配字典项成功",adapterDictEntryModel);
        } catch (Exception e) {
            return ObjEnvelop.getError("获取适配字典项失败");
        }
    }
    public ObjEnvelop get(String version, Integer dictEntryId) {
        try {
            AdapterVersion adapterVersion = new AdapterVersion(version);
            AdapterDictEntryModel adapterDictEntryModel = (AdapterDictEntryModel) get(AdapterDictEntryModel.class, adapterVersion.getDictTableName(), dictEntryId);
            return ObjEnvelop.getSuccess("获取适配字典项成功",adapterDictEntryModel);
        } catch (Exception e) {
            return ObjEnvelop.getError("获取适配字典项失败");
        }
    }
    public PageEnvelop getDetailResult(String adapterVersion, String condition, String order, Integer rows, Integer page) {
       try {
           List dictEntryList = getDictEntryList(AdapterDictEntryModel.class, adapterVersion, condition, order, rows, page);
           Integer count = getDictEntryInt(AdapterDictModel.class, adapterVersion, condition);
           PageEnvelop result = PageEnvelop.getSuccess("获取适配字典项列表成功");
           result.setDetailModelList(dictEntryList);
           result.setTotalCount(count);
           return result;
       } catch (Exception e) {
           return PageEnvelop.getError("获取适配字典项列表失败");
       }
    }
    public List getDictEntryList(Class tClass, String adapterVersion, String condition, String order, Integer limit, Integer offset) throws Exception{
        AdapterVersion version = new AdapterVersion(adapterVersion);
        String tableName = version.getDictEntryTableName();
        SqlCreator sqlCreator = new SqlCreator(tClass);
        if (!StringUtil.isEmpty(condition)) {
            try {
                JsonNode jsonNode = objectMapper.readTree(condition);
                String name = jsonNode.get("name").asText();
                sqlCreator.equalCondition("stdDictId", jsonNode.get("stdDictId").asInt());
                sqlCreator.likeOrCondition("stdEntryCode", "stdEntryValue", name);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            if (!StringUtil.isEmpty(order)) {
                JsonNode jsonNode = objectMapper.readTree(order);
                Iterator<String> fieldNames = jsonNode.fieldNames();
                while (fieldNames.hasNext()) {
                    String fieldName = fieldNames.next();
                    String value = jsonNode.get(fieldName).asText().toUpperCase();
                    sqlCreator.order(fieldName, value);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        String sql = sqlCreator.selectData(tableName);
        Query query = getQuery(sqlCreator, sql);
        if (limit != null) {
            query.setMaxResults(limit);
            if (offset != null) {
                query.setFirstResult((offset - 1) * limit);
            }
        }
        List<AdapterDictEntryModel> modelList = query.list();
        List<Integer> idList = new ArrayList<>();
        Map<Integer, StdDictionaryModel> stdDictModelMap = new HashMap<>();
        Integer schemeId = null;
        for (AdapterDictEntryModel model : modelList) {
            if (model.getAdapterDictId() != null) {
                schemeId = model.getSchemeId();
                idList.add(model.getAdapterDictId());
            }
        }
        if (!CollectionUtils.isEmpty(idList)) {
            AdapterSchemeModel scheme = getEntity(AdapterSchemeModel.class, schemeId);
            StandardVersion standardVersion = new StandardVersion(scheme.getAdapterStdVersion());
            tableName = standardVersion.getDictTableName();
            sqlCreator = new SqlCreator(StdDictionaryModel.class);
            sqlCreator.inCondition("id", idList);
            sql = sqlCreator.selectData(tableName);
            query = getQuery(sqlCreator, sql);
            List<StdDictionaryModel> stdDictModelList = query.list();
            for (StdDictionaryModel model : stdDictModelList) {
                stdDictModelMap.put(model.getId(), model);
            }
        }
        List<AdapterDictEntryResultDetailModel> detailModelList = new ArrayList<>();
        for (AdapterDictEntryModel model : modelList) {
            AdapterDictEntryResultDetailModel detailModel = new AdapterDictEntryResultDetailModel();
            detailModel.setId(model.getId());
            detailModel.setSchemeId(model.getSchemeId());
            detailModel.setAdapterDictId(model.getAdapterDictId());
            detailModel.setAdapterEntryId(model.getAdapterEntryId());
            detailModel.setAdapterEntryCode(model.getAdapterEntryCode());
            detailModel.setAdapterEntryValue(model.getAdapterEntryValue());
            detailModel.setStdDictId(model.getStdDictId());
            detailModel.setStdEntryId(model.getStdEntryId());
            detailModel.setStdEntryCode(model.getStdEntryCode());
            detailModel.setStdEntryValue(model.getStdEntryValue());
            detailModel.setAdapterInfo(model.getAdapterInfo());
            if (stdDictModelMap.get(model.getAdapterDictId()) != null) {
                detailModel.setAdapterDictCode(stdDictModelMap.get(model.getAdapterDictId()).getCode());
                detailModel.setAdapterDictName(stdDictModelMap.get(model.getAdapterDictId()).getName());
            }
            detailModelList.add(detailModel);
        }
        return detailModelList;
    }
    public Integer getDictEntryInt(Class tClass, String adapterVersion, String condition) {
        AdapterVersion version = new AdapterVersion(adapterVersion);
        String tableName = version.getDictEntryTableName();
        SqlCreator sqlCreator = new SqlCreator(tClass);
        if (!StringUtil.isEmpty(condition)) {
            try {
                JsonNode jsonNode = objectMapper.readTree(condition);
                String name = jsonNode.get("name").asText();
                sqlCreator.equalCondition("stdDictId", jsonNode.get("stdDictId").asInt());
                sqlCreator.likeOrCondition("stdEntryCode", "stdEntryValue", name);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        String sql = sqlCreator.countData(tableName);
        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 ListEnvelop updateDictEntrys(String adapterVersion, String list) {
        try {
            AdapterVersion version = new AdapterVersion(adapterVersion);
            List<AdapterDictEntryResultDetailModel> adapterDictEntryList = Arrays.asList(objectMapper.readValue(list, AdapterDictEntryResultDetailModel[].class));
            List<Integer> idList = new ArrayList<>();
            Map<Integer, AdapterDictEntryResultDetailModel> dictEntryResultMap = new HashMap<>();
            Integer maxId = null;
            for (AdapterDictEntryResultDetailModel dictEntryModel : adapterDictEntryList) {
                AdapterDictEntryModel adapterDictEntryModel = new AdapterDictEntryModel();
                adapterDictEntryModel.setId(dictEntryModel.getId());
                adapterDictEntryModel.setSchemeId(dictEntryModel.getSchemeId());
                adapterDictEntryModel.setAdapterDictId(dictEntryModel.getAdapterDictId());
                adapterDictEntryModel.setAdapterEntryId(dictEntryModel.getAdapterEntryId());
                adapterDictEntryModel.setAdapterEntryCode(dictEntryModel.getAdapterEntryCode());
                adapterDictEntryModel.setAdapterEntryValue(dictEntryModel.getAdapterEntryValue());
                adapterDictEntryModel.setStdDictId(dictEntryModel.getStdDictId());
                adapterDictEntryModel.setStdEntryId(dictEntryModel.getStdEntryId());
                adapterDictEntryModel.setStdEntryCode(dictEntryModel.getStdEntryCode());
                adapterDictEntryModel.setStdEntryValue(dictEntryModel.getStdEntryValue());
                adapterDictEntryModel.setAdapterInfo(dictEntryModel.getAdapterInfo());
                idList.add(dictEntryModel.getStdDictId());
                dictEntryResultMap.put(dictEntryModel.getStdDictId(), dictEntryModel);
                SqlCreator sqlCreator = new SqlCreator(AdapterDictEntryModel.class);
                String sql;
                if (dictEntryModel.getId() == null) {
                    if (maxId == null) {
                        sql = "select max(id) from " + version.getDictEntryTableName();
                        Query query = getCurrentSession().createSQLQuery(sql);
                        Object object = query.uniqueResult();
                        maxId = object == null ? 1 : Integer.parseInt(object.toString()) + 1;
                    }
                    adapterDictEntryModel.setId(maxId++);
                    JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterDictEntryModel));
                    sql = sqlCreator.insertData(version.getDictEntryTableName(), jsonNode);
                } else {
                    JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterDictEntryModel));
                    sql = sqlCreator.updateDataByTableKey(version.getDictEntryTableName(), jsonNode);
                }
                Query query = getExeuteQuery(sqlCreator, sql);
                query.executeUpdate();
            }
            if (!CollectionUtils.isEmpty(idList)) {
                String tableName = version.getDictTableName();
                SqlCreator sqlCreator = new SqlCreator(AdapterDictModel.class);
                sqlCreator.inCondition("stdDictId", idList);
                String sql = sqlCreator.selectData(tableName);
                Query query = getQuery(sqlCreator, sql);
                List<AdapterDictModel> adapterDictModelList = query.list();
                for (AdapterDictModel model : adapterDictModelList) {
                    AdapterDictEntryResultDetailModel dictentryModel = dictEntryResultMap.get(model.getStdDictId());
                    model.setAdapterDictId(dictentryModel.getAdapterDictId());
                    model.setAdapterDictCode(dictentryModel.getAdapterDictCode());
                    model.setAdapterDictName(dictentryModel.getAdapterDictName());
                    JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(model));
                    sqlCreator = new SqlCreator(AdapterDictModel.class);
                    sql = sqlCreator.updateDataByTableKey(version.getDictTableName(), jsonNode);
                    query = getExeuteQuery(sqlCreator, sql);
                    query.executeUpdate();
                }
            }
            return ListEnvelop.getSuccess("保存适配字典项成功",adapterDictEntryList);
        } catch (Exception e) {
            return ListEnvelop.getError("保存适配字典项失败");
        }
    }
    public Envelop deleteMultiple(String adapterVersion, Integer dictEntryId, Integer stdDictId, Integer adapterDictId) {
        try {
            if (adapterVersion == null || adapterVersion.length() == 0) {
                return Envelop.getError("无效适配版本");
            }
            AdapterVersion version = new AdapterVersion(adapterVersion);
            Session session = getCurrentSession();
            String sql = "delete from " + version.getDictEntryTableName() + " where id = :id";
            Query query = session.createSQLQuery(sql);
            query.setInteger("id", dictEntryId);
            query.executeUpdate();
            SqlCreator sqlCreator = new SqlCreator(AdapterDictEntryModel.class);
            sqlCreator.equalCondition("stdDictId", stdDictId);
            sqlCreator.equalCondition("adapterDictId", adapterDictId);
            sql = sqlCreator.countData(version.getDictEntryTableName());
            query = getExeuteQuery(sqlCreator, sql);
            Integer count = Integer.parseInt(StringUtil.toString(query.list().get(0)));
            if (count == 0) {
                sql = "delete from " + version.getDictTableName() + " where std_dict_id = :stdDictId and adapter_dict_id = :adapterDictId";
                query = session.createSQLQuery(sql);
                query.setInteger("stdDictId", stdDictId);
                query.setInteger("adapterDictId", adapterDictId);
                query.executeUpdate();
            }
            return Envelop.getSuccess("删除适配字典项成功");
        } catch (Exception e) {
            return Envelop.getError("删除适配字典项失败");
        }
    }
    public AdapterDictEntryModel getAdapterDictItemBydictCode(String version,AdapterDictModel adapterDictT, String dictCode) {
        try {
            SqlCreator sqlCreator = new SqlCreator(AdapterDictEntryModel.class);
            sqlCreator.equalCondition("stdDictId", adapterDictT.getStdDictId());
            sqlCreator.equalCondition("stdEntryCode", dictCode);
            String sql = sqlCreator.selectData("std_dictionary_entry_"+version);
            Query query = getQuery(sqlCreator, sql);
            return (AdapterDictEntryModel)query.uniqueResult();
        } catch (Exception e) {
            return null;
        }
    }
    public AdapterDictEntryModel getAdapterDictItemBydictValue(String version,AdapterDictModel adapterDictT, String dictValue) {
        try {
            SqlCreator sqlCreator = new SqlCreator(AdapterDictEntryModel.class);
            sqlCreator.equalCondition("stdDictId", adapterDictT.getStdDictId());
            sqlCreator.equalCondition("stdEntryValue", dictValue);
            String sql = sqlCreator.selectData("std_dictionary_entry_"+version);
            Query query = getQuery(sqlCreator, sql);
            return (AdapterDictEntryModel)query.uniqueResult();
        } catch (Exception e) {
            return null;
        }
    }
    public List<AdapterDictEntryModel> getAllUnAdaptDictEntry(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");
        Query query = getCurrentSession().createSQLQuery(sql.toString());
        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();
        sql.append("SELECT m.*").append(" FROM "+adapterVersion.getDictEntryTableName()).append(" m where m.adapter_entry_id is not null");
        Query query = getCurrentSession().createSQLQuery(sql.toString());
        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());
        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);
        Query query = getExeuteQuery(sqlCreator, sql);
        query.executeUpdate();
    }
}

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

@@ -0,0 +1,293 @@
package com.yihu.jw.basic.standard.service.adapter;
import com.fasterxml.jackson.databind.JsonNode;
import com.yihu.jw.basic.standard.dao.IStdDictionaryModelDao;
import com.yihu.jw.basic.standard.dao.StdDictionaryEntryModelDao;
import com.yihu.jw.basic.standard.match.dictionary.DictItemStrategyExecute;
import com.yihu.jw.basic.standard.match.dictionary.DictitemStandardNameStrategy;
import com.yihu.jw.basic.standard.match.matchModel.DictItemMatchVO;
import com.yihu.jw.basic.standard.model.adapter.AdapterDictEntryModel;
import com.yihu.jw.basic.standard.model.adapter.AdapterDictModel;
import com.yihu.jw.basic.standard.model.adapter.AdapterSchemeVersionModel;
import com.yihu.jw.basic.standard.model.standard.StdDictionaryEntryModel;
import com.yihu.jw.basic.standard.model.standard.StdDictionaryModel;
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.StdDictService;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.lang.SpringContext;
import com.yihu.jw.restmodel.web.Envelop;
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.SqlConstants;
import com.yihu.jw.util.sql.SqlCreator;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
@Transactional
@Service("AdapterDictService")
public class AdapterDictService extends SQLGeneralDAO {
    public static final String BEAN_ID = "AdapterDictService";
    @Autowired
    private AdapterDictEntryService adapterDictEntryService;
    @Autowired
    private AdapterSchemeVersionService adapterSchemeVersionService;
    @Autowired
    private ThreadPoolTaskExecutor threadPoolTaskExecutor;
    @Autowired
    private IStdDictionaryModelDao stdDictionaryDao;
    @Autowired
    private StdDictionaryEntryModelDao stdDictionaryEntryDao;
    @Autowired
    private StdDictService stdDictService;
    private AdapterDictService adapterDictService;
    public AdapterDictService() {
    }
    public void finalize() throws Throwable {
        super.finalize();
    }
    public ObjEnvelop add(String adapterVersion, String dict) {
        try {
            AdapterVersion version = new AdapterVersion(adapterVersion);
            AdapterDictModel adapterDictModel = objectMapper.readValue(dict, AdapterDictModel.class);
            Session session = getCurrentSession();
            String sql = "select max(id) from " + version.getMetaDataTableName();
            Query query = session.createSQLQuery(sql);
            Object object = query.uniqueResult();
            adapterDictModel.setId(object == null ? 1 : Integer.parseInt(object.toString()) + 1);
            JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterDictModel));
            SqlCreator sqlCreator = new SqlCreator(AdapterDictModel.class);
            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("保存适配字典失败");
        }
    }
    public Envelop delete(String adapterVersion, Integer dictId) {
        try {
            if (adapterVersion == null || adapterVersion.length() == 0) {
                return Envelop.getError("无效适配版本");
            }
            AdapterVersion version = new AdapterVersion(adapterVersion);
            Session session = getCurrentSession();
            String sql = "delete from " + version.getMetaDataTableName() + " where id = :id";
            Query query = session.createSQLQuery(sql);
            query.setInteger("id", dictId);
            query.executeUpdate();
            return Envelop.getSuccess("删除适配字典成功");
        } catch (Exception e) {
            return Envelop.getError("删除适配字典失败");
        }
    }
    public ObjEnvelop modify(String adapterVersion, String dict) {
        try {
            AdapterVersion version = new AdapterVersion(adapterVersion);
            AdapterDictModel adapterDictModel = objectMapper.readValue(dict, AdapterDictModel.class);
            JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterDictModel));
            SqlCreator sqlCreator = new SqlCreator(AdapterDictModel.class);
            String sql = sqlCreator.updateDataByTableKey(version.getMetaDataTableName(), jsonNode);
            Query query = getExeuteQuery(sqlCreator, sql);
            query.executeUpdate();
            return ObjEnvelop.getSuccess("修改适配字典成功",adapterDictModel);
        } catch (Exception e) {
            return ObjEnvelop.getError("修改适配字典失败");
        }
    }
    public PageEnvelop getDetailResult(String adapterVersion, String condition, String order, Integer rows, Integer page) {
        try {
            List dictList = getDictList(AdapterDictModel.class, adapterVersion, condition, order, rows, page);
            Integer count = getDictInt(AdapterDictModel.class, adapterVersion, condition);
            PageEnvelop result = PageEnvelop.getSuccess("获取适配字典列表成功");
            result.setDetailModelList(dictList);
            result.setTotalCount(count);
            return result;
        } catch (Exception e) {
            return PageEnvelop.getError("获取适配字典列表成功");
        }
    }
    public ObjEnvelop get(String version, Integer dictId) {
        try {
            AdapterVersion adapterVersion = new AdapterVersion(version);
            AdapterDictModel adapterDictModel = (AdapterDictModel) get(AdapterDictModel.class, adapterVersion.getDictTableName(), dictId);
            return ObjEnvelop.getSuccess("获取适配字典成功",adapterDictModel);
        } catch (Exception e) {
            return ObjEnvelop.getError("获取适配字典失败");
        }
    }
    public List getDictList(Class tClass, String adapterVersion, String condition, String order, Integer limit, Integer offset) {
        AdapterVersion version = new AdapterVersion(adapterVersion);
        String tableName = version.getDictTableName();
        SqlCreator sqlCreator = new SqlCreator(tClass);
        try {
            if (!StringUtil.isEmpty(condition)) {
                JsonNode jsonNode = objectMapper.readTree(condition);
                String name = jsonNode.get("name").asText();
                sqlCreator.likeOrCondition("stdDictCode", "stdDictName", name);
            }
            if (!StringUtil.isEmpty(order)) {
                JsonNode jsonNode = objectMapper.readTree(order);
                Iterator<String> fieldNames = jsonNode.fieldNames();
                while (fieldNames.hasNext()) {
                    String fieldName = fieldNames.next();
                    String value = jsonNode.get(fieldName).asText().toUpperCase();
                    sqlCreator.order(fieldName, value);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        String sql = sqlCreator.selectData(tableName);
        Query query = getQuery(sqlCreator, sql);
        if (limit != null) {
            query.setMaxResults(limit);
            if (offset != null) {
                query.setFirstResult((offset - 1) * limit);
            }
        }
        return query.list();
    }
    public Integer getDictInt(Class tClass, String adapterVersion, String condition) {
        AdapterVersion version = new AdapterVersion(adapterVersion);
        String tableName = version.getDictTableName();
        SqlCreator sqlCreator = new SqlCreator(tClass);
        try {
            if (!StringUtil.isEmpty(condition)) {
                JsonNode jsonNode = objectMapper.readTree(condition);
                String name = jsonNode.get("name").asText();
                sqlCreator.likeOrCondition("stdDictCode", "stdDictName", name);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        String sql = sqlCreator.countData(tableName);
        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 void strategy(String version,String std_version, String adapter_std_version) throws Exception {
        List<AdapterDictEntryModel> unAdapterDictEntryModels= adapterDictEntryService.getAllUnAdaptDictEntry(version);//等待适配的标准字典项
        List<AdapterDictEntryModel> adapterDictEntryModels = new ArrayList<AdapterDictEntryModel>();//之前已经适配好的适配方案
        //查找出  之前已经适配好的适配方案
        List<AdapterSchemeVersionModel> all = adapterSchemeVersionService.getAll();//
        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());
                    adapterDictEntryModels.addAll(adaptMetadata);
                }
            }
        }
        DictItemMatchVO matchVO= new DictItemMatchVO();
        matchVO.setCodeAdapter(matchVO.geNameGroup(adapterDictEntryModels));
        //設置匹配的机构数据緩存
        StandardVersion standardVersion = new StandardVersion(adapter_std_version);
        List<StdDictionaryEntryModel> dictItems = stdDictService.getDicEntryList(standardVersion, null, null, null, null);
        for (StdDictionaryEntryModel stdDictItem:dictItems){
            StdDictionaryModel dictionary = stdDictionaryDao.getDictionaryName(adapter_std_version, stdDictItem.getDictId());
            if(dictionary != null){
                DictitemStandardNameStrategy.getNameMap().put(stdDictItem.getValue() + "_" + dictionary.getCode(),stdDictItem);
            }
        }
        //执行匹配
        DictItemStrategyExecute.setFirst(version, unAdapterDictEntryModels.size());//设置第一次匹配
        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));
            Integer unAdaptDicId = unAdapterDictEntryModel.getStdDictId();
            StdDictionaryModel adapterDictionaryModel = stdDictionaryDao.getDictionaryName(adapter_std_version, unAdaptDicId);
            if (adapterDictionaryModel != null) {
                adapterDictService = SpringContext.getService(AdapterDictService.BEAN_ID);
                AdapterDictModel entity = adapterDictService.getAdapterDictByCode(version, adapterDictionaryModel.getCode());
                String sqrSql = null;
                if (null != entity) {
                    sqrSql = adapterDictService.saveAdaptDictSql(entity, adapterDictionaryModel, version);
                }
                if (null != sqrSql && !"".equals(sqrSql)) {
                    sqlList.add(sqrSql);
                }
            }
        }
    }
    public void saveAdaptDict(AdapterDictModel strategyDict,StdDictionaryModel orgDict,String version) throws Exception {
        strategyDict.setAdapterDictId(orgDict.getId());
        strategyDict.setAdapterDictCode(orgDict.getCode());
        strategyDict.setAdapterDictName(orgDict.getName());
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(strategyDict));
        SqlCreator sqlCreator = new SqlCreator(AdapterDictModel.class);
        String sql = sqlCreator.updateDataByTableKey(new AdapterVersion(version).getDictTableName(), jsonNode);
        Query query = getExeuteQuery(sqlCreator, sql);
        query.executeUpdate();
    }
    public String saveAdaptDictSql(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());
        return sqlBuffer.toString();
    }
    public AdapterDictModel getAdapterDictByCode(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);
            Query query = getQuery(sqlCreator, sql);
            return (AdapterDictModel) query.uniqueResult();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

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

@@ -0,0 +1,494 @@
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.model.adapter.AdapterDatasetModel;
import com.yihu.jw.basic.standard.model.adapter.AdapterMetadataModel;
import com.yihu.jw.basic.standard.model.adapter.AdapterSchemeModel;
import com.yihu.jw.basic.standard.model.adapter.resultModel.AdapterMetadataResultDetailModel;
import com.yihu.jw.basic.standard.model.adapter.resultModel.ApiMetadataResultDetailModel;
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.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.SqlConstants;
import com.yihu.jw.util.sql.SqlCreator;
import org.apache.commons.lang3.StringUtils;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import java.io.IOException;
import java.util.*;
@Transactional
@Service("AdapterMetadataService")
public class AdapterMetadataService extends SQLGeneralDAO {
    public static final String BEAN_ID = "AdapterMetadataService";
    public AdapterMetadataService() {
    }
    public void finalize() throws Throwable {
        super.finalize();
    }
    public ObjEnvelop add(String adapterVersion, String metadata) throws Exception {
        try {
            AdapterVersion version = new AdapterVersion(adapterVersion);
            AdapterMetadataModel adapterMetadataModel = objectMapper.readValue(metadata, AdapterMetadataModel.class);
            Session session = getCurrentSession();
            String sql = "select max(id) from " + version.getMetaDataTableName();
            Query query = session.createSQLQuery(sql);
            Object object = query.uniqueResult();
            adapterMetadataModel.setId(object == null ? 1 : Integer.parseInt(object.toString()) + 1);
            JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterMetadataModel));
            SqlCreator sqlCreator = new SqlCreator(AdapterMetadataModel.class);
            sql = sqlCreator.insertData(version.getMetaDataTableName(), jsonNode);
            query = getExeuteQuery(sqlCreator, sql);
            query.executeUpdate();
            return ObjEnvelop.getSuccess("保存适配数据元成功",adapterMetadataModel);
        } catch (Exception e) {
            return ObjEnvelop.getError("保存适配数据元失败");
        }
    }
    public void delete(String adapterVersion, Integer metadataId) throws Exception {
        try {
            if (adapterVersion == null || adapterVersion.length() == 0) {
                throw new ApiException(ErrorCode.InvalidStdVersion.getErrorCode());
            }
            AdapterVersion version = new AdapterVersion(adapterVersion);
            Session session = getCurrentSession();
            String sql = "delete from " + version.getMetaDataTableName() + " where id = :id";
            Query query = session.createSQLQuery(sql);
            query.setInteger("id", metadataId);
            query.executeUpdate();
        } catch (Exception e) {
            throw new ApiException(ErrorCode.SaveMetaDataFailed.getErrorCode());
        }
    }
    public ObjEnvelop modify(String adapterVersion, String metadata) throws Exception {
        try {
            AdapterVersion version = new AdapterVersion(adapterVersion);
            AdapterMetadataModel adapterMetadataModel = objectMapper.readValue(metadata, AdapterMetadataModel.class);
            JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(adapterMetadataModel));
            SqlCreator sqlCreator = new SqlCreator(AdapterMetadataModel.class);
            String sql = sqlCreator.updateDataByTableKey(version.getMetaDataTableName(), jsonNode);
            Query query = getExeuteQuery(sqlCreator, sql);
            query.executeUpdate();
            return ObjEnvelop.getSuccess("修改适配数据元成功",adapterMetadataModel);
        } catch (Exception e) {
           return ObjEnvelop.getError("修改适配数据元失败");
        }
    }
    public ObjEnvelop 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("获取适配数据元失败");
        }
    }
    public PageEnvelop 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;
        } catch (Exception e) {
            e.printStackTrace();
            return PageEnvelop.getError("获取适配数据元列表失败");
        }
    }
    public List getMetadataList(Class tClass, String adapterVersion, String condition, String order, Integer limit, Integer offset) throws Exception {
        AdapterVersion version = new AdapterVersion(adapterVersion);
        String tableName = version.getMetaDataTableName();
        SqlCreator sqlCreator = new SqlCreator(tClass);
        if (!StringUtil.isEmpty(condition)) {
            try {
                JsonNode jsonNode = objectMapper.readTree(condition);
                String name = jsonNode.get("name").asText();
                sqlCreator.equalCondition("stdDatasetId", jsonNode.get("stdDatasetId").asInt());
                sqlCreator.likeOrCondition("stdMetadataCode", "stdMetadataName", name);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            if (!StringUtil.isEmpty(order)) {
                JsonNode jsonNode = objectMapper.readTree(order);
                Iterator<String> fieldNames = jsonNode.fieldNames();
                while (fieldNames.hasNext()) {
                    String fieldName = fieldNames.next();
                    String value = jsonNode.get(fieldName).asText().toUpperCase();
                    sqlCreator.order(fieldName, value);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        String sql = sqlCreator.selectData(tableName);
        Query query = getQuery(sqlCreator, sql);
        if (limit != null) {
            query.setMaxResults(limit);
            if (offset != null) {
                query.setFirstResult((offset - 1) * limit);
            }
        }
        List<AdapterMetadataModel> modelList = query.list();
        List<Integer> idList = new ArrayList<>();
        Map<Integer, StdDataSetModel> stdDatasetModelMap = new HashMap<>();
        Integer schemeId = null;
        for (AdapterMetadataModel model : modelList) {
            if (model.getAdapterDatasetId() != null) {
                schemeId = model.getSchemeId();
                idList.add(model.getAdapterDatasetId());
            }
        }
        if (!CollectionUtils.isEmpty(idList)) {
            AdapterSchemeModel scheme = getEntity(AdapterSchemeModel.class, schemeId);
            StandardVersion standardVersion = new StandardVersion(scheme.getAdapterStdVersion());
            tableName = standardVersion.getDataSetTableName();
            sqlCreator = new SqlCreator(StdDataSetModel.class);
            sqlCreator.inCondition("id", idList);
            sql = sqlCreator.selectData(tableName);
            query = getQuery(sqlCreator, sql);
            List<StdDataSetModel> stdDatasetModelList = query.list();
            for (StdDataSetModel model : stdDatasetModelList) {
                stdDatasetModelMap.put(model.getId(), model);
            }
        }
        List<ApiMetadataResultDetailModel> detailModelList = new ArrayList<>();
        for (AdapterMetadataModel model : modelList) {
            ApiMetadataResultDetailModel detailModel = new ApiMetadataResultDetailModel();
            detailModel.setId(model.getId());
            detailModel.setSchemeId(model.getSchemeId());
            detailModel.setAdapterDatasetId(model.getAdapterDatasetId());
            detailModel.setAdapterDictId(model.getAdapterDictId());
            detailModel.setAdapterDataType(model.getAdapterDataType());
            detailModel.setAdapterMetadataId(model.getAdapterMetadataId());
            detailModel.setAdapterMetadataCode(model.getAdapterMetadataCode());
            detailModel.setAdapterMetadataName(model.getAdapterMetadataName());
            detailModel.setAdapterDictId(model.getAdapterDictId());
            detailModel.setStdDictId(model.getStdDictId());
            detailModel.setStdDatasetId(model.getStdDatasetId());
            detailModel.setStdMetadataId(model.getStdMetadataId());
            detailModel.setStdMetadataCode(model.getStdMetadataCode());
            detailModel.setStdMetadataName(model.getStdMetadataName());
            detailModel.setAdapterInfo(model.getAdapterInfo());
            if (stdDatasetModelMap.get(model.getAdapterDatasetId()) != null) {
                detailModel.setAdapterDatasetCode(stdDatasetModelMap.get(model.getAdapterDatasetId()).getCode());
                detailModel.setAdapterDatasetName(stdDatasetModelMap.get(model.getAdapterDatasetId()).getName());
            }
            detailModelList.add(detailModel);
        }
        return detailModelList;
    }
    public Integer getMetadataCount(Class tClass, String adapterVersion, String condition) throws Exception {
        AdapterVersion version = new AdapterVersion(adapterVersion);
        String tableName = version.getMetaDataTableName();
        SqlCreator sqlCreator = new SqlCreator(tClass);
        if (!StringUtil.isEmpty(condition)) {
            try {
                JsonNode jsonNode = objectMapper.readTree(condition);
                String name = jsonNode.get("name").asText();
                sqlCreator.equalCondition("stdDatasetId", jsonNode.get("stdDatasetId").asInt());
                sqlCreator.likeOrCondition("stdMetadataCode", "stdMetadataName", name);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        String sql = sqlCreator.countData(tableName);
        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);
        List<Integer> idList = new ArrayList<>();
        Map<Integer, StdMetaDataModel> stdMetaDataModelMap = new HashMap<>();
        Integer schemeId = null;
        for (AdapterMetadataModel model : metadataModelList) {
            if (model.getAdapterMetadataId() != null) {
                idList.add(model.getAdapterMetadataId());
                schemeId = model.getSchemeId();
            }
        }
        if (!CollectionUtils.isEmpty(idList)) {
            AdapterSchemeModel scheme = getEntity(AdapterSchemeModel.class, schemeId);
            StandardVersion standardVersion = new StandardVersion(scheme.getAdapterStdVersion());
            String tableName = standardVersion.getMetaDataTableName();
            SqlCreator sqlCreator = new SqlCreator(StdMetaDataModel.class);
            sqlCreator.inCondition("id", idList);
            String sql = sqlCreator.selectData(tableName);
            Query query = getQuery(sqlCreator, sql);
            List<StdMetaDataModel> stdMetadataModelList = query.list();
            for (StdMetaDataModel model : stdMetadataModelList) {
                stdMetaDataModelMap.put(model.getId(), model);
            }
        }
        List<AdapterMetadataResultDetailModel> detailModelList = new ArrayList<>();
        for (AdapterMetadataModel model : metadataModelList) {
            if (StringUtils.isBlank(model.getAdapterMetadataCode()) || StringUtils.isBlank(model.getAdapterMetadataName())) {
                continue;
            }
            AdapterMetadataResultDetailModel detailModel = new AdapterMetadataResultDetailModel();
            detailModel.setId(model.getId());
            detailModel.setSchemeId(model.getSchemeId());
            detailModel.setAdapterDatasetId(model.getAdapterDatasetId());
            detailModel.setAdapterDictId(model.getAdapterDictId());
            detailModel.setAdapterDataType(model.getAdapterDataType());
            detailModel.setAdapterMetadataId(model.getAdapterMetadataId());
            detailModel.setAdapterMetadataCode(model.getAdapterMetadataCode());
            detailModel.setAdapterMetadataName(model.getAdapterMetadataName());
            detailModel.setAdapterDictId(model.getAdapterDictId());
            detailModel.setStdDictId(model.getStdDictId());
            detailModel.setStdDatasetId(model.getStdDatasetId());
            detailModel.setStdMetadataCode(model.getStdMetadataCode());
            detailModel.setStdMetadataName(model.getStdMetadataName());
            if (stdMetaDataModelMap.get(model.getAdapterMetadataId()) != null) {
                detailModel.setAdapterMetadataType(stdMetaDataModelMap.get(model.getAdapterMetadataId()).getColumnType());
            }
            detailModelList.add(detailModel);
        }
        return detailModelList;
    }
    public ListEnvelop updateMetadatas(String adapterVersion, String list) {
        try {
            AdapterVersion version = new AdapterVersion(adapterVersion);
            List<ApiMetadataResultDetailModel> adapterMetadataList = Arrays.asList(objectMapper.readValue(list, ApiMetadataResultDetailModel[].class));
            List<String> sqlList = new ArrayList<>();
            List<Integer> idList = new ArrayList<>();
            Map<Integer, ApiMetadataResultDetailModel> metadataResultMap = new HashMap<>();
            for (ApiMetadataResultDetailModel metadataModel : adapterMetadataList) {
                AdapterMetadataModel adapterMetadataModel = new AdapterMetadataModel();
                adapterMetadataModel.setId(metadataModel.getId());
                adapterMetadataModel.setSchemeId(metadataModel.getSchemeId());
                adapterMetadataModel.setAdapterDatasetId(metadataModel.getAdapterDatasetId());
                adapterMetadataModel.setAdapterDictId(metadataModel.getAdapterDictId());
                adapterMetadataModel.setAdapterDataType(metadataModel.getAdapterDataType());
                adapterMetadataModel.setAdapterMetadataId(metadataModel.getAdapterMetadataId());
                adapterMetadataModel.setAdapterMetadataCode(metadataModel.getAdapterMetadataCode());
                adapterMetadataModel.setAdapterMetadataName(metadataModel.getAdapterMetadataName());
                adapterMetadataModel.setAdapterDictId(metadataModel.getAdapterDictId());
                adapterMetadataModel.setStdDictId(metadataModel.getStdDictId());
                adapterMetadataModel.setStdMetadataId(metadataModel.getStdMetadataId());
                adapterMetadataModel.setStdDatasetId(metadataModel.getStdDatasetId());
                adapterMetadataModel.setStdMetadataCode(metadataModel.getStdMetadataCode());
                adapterMetadataModel.setStdMetadataName(metadataModel.getStdMetadataName());
                adapterMetadataModel.setAdapterInfo(metadataModel.getAdapterInfo());
                idList.add(metadataModel.getStdDatasetId());
                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);
                sqlList.add(sql);
                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);
                Query query = getQuery(sqlCreator, sql);
                List<AdapterDatasetModel> adapterDatasetModelList = query.list();
                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 = getExeuteQuery(sqlCreator, sql);
                    query.executeUpdate();
                }
            }
            return ListEnvelop.getSuccess("修改适配数据元成功",adapterMetadataList);
        } catch (Exception e) {
            return ListEnvelop.getError("修改适配数据元失败");
        }
    }
    public Envelop deleteMultiple(String adapterVersion, Integer metadataId, Integer stdDatasetId, Integer adapterDatasetId) {
        try {
            if (adapterVersion == null || adapterVersion.length() == 0) {
                return Envelop.getError("无效适配版本");
            }
            AdapterVersion version = new AdapterVersion(adapterVersion);
            Session session = getCurrentSession();
            String sql = "delete from " + version.getMetaDataTableName() + " where id = :id";
            Query query = session.createSQLQuery(sql);
            query.setInteger("id", metadataId);
            query.executeUpdate();
            SqlCreator sqlCreator = new SqlCreator(AdapterMetadataModel.class);
            sqlCreator.equalCondition("stdDatasetId", stdDatasetId);
            sqlCreator.equalCondition("adapterDatasetId", adapterDatasetId);
            sql = sqlCreator.countData(version.getMetaDataTableName());
            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);
                query.setInteger("stdDatasetId", stdDatasetId);
                query.setInteger("adapterDatasetId", adapterDatasetId);
                query.executeUpdate();
            }
            return Envelop.getSuccess("删除适配数据元成功");
        } catch (Exception e) {
            return Envelop.getError("删除适配数据元失败");
        }
    }
    public List getAdapterMetadataByDataset(String adapterVersion,Integer datasetId){
        Map<String,Object> map = new HashMap<String,Object>();
        map.put("stdDatasetId", datasetId);
        String tableName="adapter_metadata_"+adapterVersion;
        try {
            String condition =objectMapper.writeValueAsString(map);
            List<AdapterMetadataModel> metadataModelList = getList(AdapterMetadataModel.class,tableName, condition, null, null, null);
            return metadataModelList;
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
    public AdapterDatasetModel getAdapterDataset(String adapterVersion,Integer datasetId){
        Map<String,Object> map = new HashMap<String,Object>();
        map.put("stdDatasetId", datasetId);
        String tableName="adapter_dataset_"+adapterVersion;
        String condition = null;
        try {
            condition = objectMapper.writeValueAsString(map);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        List<AdapterDatasetModel> datasetModel = getList(AdapterDatasetModel.class,tableName, condition, null, null, null);
        return datasetModel.get(0);
    }
    public AdapterMetadataModel getAdapterMetadata(String version, Integer adapterMetadataId) {
        try {
            SqlCreator sqlCreator = new SqlCreator(AdapterMetadataModel.class);
            sqlCreator.equalCondition("id", adapterMetadataId);
            String sql = sqlCreator.selectData("adapter_metadata_"+version);
            Query query = getQuery(sqlCreator, sql);
            return (AdapterMetadataModel)query.uniqueResult();
        } catch (Exception e) {
            return null;
        }
    }
    public List getAdapterMetadataNotNullList(AdapterVersion adapterVersion, Integer stdDatasetId, String condition) {
        try {
            StringBuffer sql = new StringBuffer();
            sql.append("SELECT * FROM ").append(adapterVersion.getMetaDataTableName());
            if (!StringUtil.isEmpty(condition)) {
                JsonNode jsonNode = objectMapper.readTree(condition);
                String column = jsonNode.get("column").asText();
                sql.append(" WHERE std_dataset_id = " + stdDatasetId + SqlConstants.AND);
                sql.append(column).append(" IS NOT NULL");
            }
            Query query = getCurrentSession().createSQLQuery(sql.toString());
            query.setResultTransformer(new BeanTransformer(AdapterMetadataModel.class));
            return query.list();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    public List<AdapterMetadataModel> getAllAdaptMetadata(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");
        Query query = getCurrentSession().createSQLQuery(sql.toString());
        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();
        sql.append("SELECT m.*").append(" FROM "+adapterVersion.getMetaDataTableName()).append(" m where m.adapter_metadata_id is null");
        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.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);
        Query query = getExeuteQuery(sqlCreator, sql);
        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_name = '" + orgMetadata.getName() + "'");
            if(null != adapterInfo){
                sqlBuffer.append(",adapter_info = " + adapterInfo);
            }
            sqlBuffer.append(" where id=" + strategyMetadata.getId());
        }
        return sqlBuffer.toString();
    }
    public void insertBatch(final List<String> insertSqlList) {
        super.insertBatch(insertSqlList);
    }
}

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

@@ -0,0 +1,56 @@
package com.yihu.jw.basic.standard.service.adapter;
import com.yihu.jw.basic.standard.model.adapter.AdapterSchemeDispatchModel;
import com.yihu.jw.util.sql.ErrorCode;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.exception.ApiException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
 * @created lingfeng 2015/12/25.
 */
@Transactional
@Service("AdapterSchemeDispatchService")
public class AdapterSchemeDispatchService extends SQLGeneralDAO {
    public static final String BEAN_ID = "AdapterSchemeDispatchService";
    public AdapterSchemeDispatchModel add(String dispatcher) {
        try {
            AdapterSchemeDispatchModel model = objectMapper.readValue(dispatcher, AdapterSchemeDispatchModel.class);
            saveEntity(model);
            return model;
        } catch (Exception e) {
            throw new ApiException(ErrorCode.SaveSchemeFailed.getErrorCode());
        }
    }
    public void delete(Integer dispatchId) {
        try {
            AdapterSchemeDispatchModel model = getEntity(AdapterSchemeDispatchModel.class, dispatchId);
            deleteEntity(model);
        } catch (Exception e) {
            throw new ApiException(ErrorCode.DeleteSchemeFailed.getErrorCode());
        }
    }
    public AdapterSchemeDispatchModel update(String dispatcher) {
        try {
            AdapterSchemeDispatchModel model = objectMapper.readValue(dispatcher, AdapterSchemeDispatchModel.class);
            updateEntity(model);
            return model;
        } catch (Exception e) {
            throw new ApiException(ErrorCode.UpdateSchemeFailed.getErrorCode());
        }
    }
    public AdapterSchemeDispatchModel get(Integer dispatchId) {
        try {
            AdapterSchemeDispatchModel model = getEntity(AdapterSchemeDispatchModel.class, dispatchId);
            return model;
        } catch (Exception e) {
            throw new ApiException(ErrorCode.GetSchemeFailed.getErrorCode());
        }
    }
}

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

@@ -0,0 +1,307 @@
package com.yihu.jw.basic.standard.service.adapter;
import com.fasterxml.jackson.databind.JsonNode;
import com.yihu.jw.basic.standard.model.adapter.AdapterSchemeModel;
import com.yihu.jw.basic.standard.model.adapter.AdapterSchemeVersionModel;
import com.yihu.jw.basic.standard.model.adapter.resultModel.AdapterSchemeResultDetailModel;
import com.yihu.jw.basic.standard.model.adapter.resultModel.AdapterSchemeResultModel;
import com.yihu.jw.basic.standard.model.standard.StandardModel;
import com.yihu.jw.basic.standard.model.standard.StandardVersionModel;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
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.util.common.StringUtil;
import com.yihu.jw.util.sql.SqlConstants;
import org.hibernate.Query;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import java.io.IOException;
import java.util.*;
/**
 * @created lingfeng 2015/12/25.
 */
@Transactional
@Service("AdapterSchemeService")
public class AdapterSchemeService extends SQLGeneralDAO {
    public static final String BEAN_ID = "AdapterSchemeService";
    public ListEnvelop getEntityList(String query, String order, Integer limit, Integer offset) {
        try {
            List list = getEntityList(AdapterSchemeModel.class, query, order, limit, offset);
            return ListEnvelop.getSuccess("获取适配列表成功",list);
        } catch (Exception e) {
            e.printStackTrace();
            return ListEnvelop.getError("获取适配列表失败");
        }
    }
    public ObjEnvelop add(String scheme) {
        Boolean existFlg = false;
        try {
            AdapterSchemeModel model = objectMapper.readValue(scheme, AdapterSchemeModel.class);
            existFlg = schemeNameValidate(model.getName());
            if (!existFlg) {
                model.setStatus(0);
                saveEntity(model);
            }
            return ObjEnvelop.getSuccess("保存适配方案成功",model);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (existFlg) {
            return ObjEnvelop.getError("已存在相同适配方案名");
        } else {
            return ObjEnvelop.getError("保存适配方案失败");
        }
    }
    public Boolean schemeNameValidate(String name) {
        String sql = "FROM AdapterSchemeModel WHERE name = :name";
        Query query = getCurrentSession().createQuery(sql);
        query.setParameter("name", name);
        List<AdapterSchemeModel> list = query.list();
        if (!CollectionUtils.isEmpty(list)) {
            return true;
        }
        return false;
    }
    public Envelop delete(Integer schemeId) {
        Boolean existFlg = false;
        try {
            AdapterSchemeModel model = getEntity(AdapterSchemeModel.class, schemeId);
            existFlg = existSchemeVersionValid(schemeId);
            if (!existFlg) {
                deleteEntity(model);
                return Envelop.getSuccess("删除适配方案成功");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (existFlg) {
            return Envelop.getError("已存在适配方案版本");
        } else {
            return Envelop.getError("删除适配方案成功失败");
        }
    }
    public Boolean schemeNameValidate(Integer schemeId, String name) {
        String sql = "FROM AdapterSchemeModel WHERE name = :name and id != :schemeId";
        Query query = getCurrentSession().createQuery(sql);
        query.setParameter("name", name);
        query.setParameter("schemeId", schemeId);
        List<AdapterSchemeModel> list = query.list();
        if (!CollectionUtils.isEmpty(list)) {
            return true;
        }
        return false;
    }
    public ObjEnvelop update(String scheme) {
        Boolean existFlg = false;
        try {
            AdapterSchemeModel model = objectMapper.readValue(scheme, AdapterSchemeModel.class);
            existFlg = schemeNameValidate(model.getId(), model.getName());
            if (!existFlg) {
                updateEntity(model);
                return ObjEnvelop.getSuccess("修改适配方案成功",model);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (existFlg) {
            return ObjEnvelop.getError("已存在适配方案名称");
        } else {
            return ObjEnvelop.getError("修改适配方案失败");
        }
    }
    public ObjEnvelop get(Integer schemeId) {
        try {
            AdapterSchemeModel model = getEntity(AdapterSchemeModel.class, schemeId);
            return ObjEnvelop.getSuccess("获取适配成功",model);
        } catch (Exception e) {
            e.printStackTrace();
            return ObjEnvelop.getError("获取适配失败");
        }
    }
    public ListEnvelop getSchemeList(String condition) {
        try {
            String name = SqlConstants.EMPTY;
            if (!StringUtil.isEmpty(condition)) {
                try {
                    JsonNode jsonNode = objectMapper.readTree(condition);
                    if (jsonNode.get("name") != null) {
                        name = jsonNode.get("name").asText();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            String schemeHql = "FROM AdapterSchemeModel";
            Query query = getCurrentSession().createQuery(schemeHql);
            List<AdapterSchemeModel> adapterSchemeModelList = query.list();
            List<Integer> schemeIdList = new ArrayList<>();
            List<Integer> stdIdList = new ArrayList<>();
            List<String> versionList = new ArrayList<>();
            Map<Integer, AdapterSchemeVersionModel> schemeVersionMap = new HashMap<>();
            Map<Integer, StandardModel> stdMap = new HashMap<>();
            Map<String, StandardVersionModel> stdVersionMap = new HashMap<>();
            for (AdapterSchemeModel adapterSchemeModel : adapterSchemeModelList) {
                schemeIdList.add(adapterSchemeModel.getId());
                stdIdList.add(adapterSchemeModel.getStdId());
                stdIdList.add(adapterSchemeModel.getAdapterStdId());
                versionList.add(adapterSchemeModel.getStdVersion());
                versionList.add(adapterSchemeModel.getAdapterStdVersion());
            }
//            versionList = delDuplicateArr(versionList);
            if (CollectionUtils.isEmpty(schemeIdList)) {
                schemeIdList.add(null);
            }
            if (CollectionUtils.isEmpty(stdIdList)) {
                stdIdList.add(null);
            }
            if (CollectionUtils.isEmpty(versionList)) {
                versionList.add(SqlConstants.EMPTY);
            }
            String adapterVersionHql = "FROM AdapterSchemeVersionModel WHERE schemeId IN :schemeIdList";
            query = getCurrentSession().createQuery(adapterVersionHql);
            query.setParameterList("schemeIdList", schemeIdList);
            List<AdapterSchemeVersionModel> versionModelList = query.list();
            for (AdapterSchemeVersionModel model : versionModelList) {
                schemeVersionMap.put(model.getId(), model);
            }
            String standardHql = "FROM StandardModel WHERE id IN :stdIdList";
            query = getCurrentSession().createQuery(standardHql);
            query.setParameterList("stdIdList", stdIdList);
            List<StandardModel> stdModelList = query.list();
            for (StandardModel model : stdModelList) {
                stdMap.put(model.getId(), model);
            }
            String stdVersionHql = "FROM StandardVersionModel WHERE version IN :versionList";
            query = getCurrentSession().createQuery(stdVersionHql);
            query.setParameterList("versionList", versionList);
            List<StandardVersionModel> stdVersionList = query.list();
            for (StandardVersionModel model : stdVersionList) {
                stdVersionMap.put(model.getVersion(), model);
            }
            List<AdapterSchemeResultDetailModel> resultDetailModelList = new ArrayList<>();
            Map<String, AdapterSchemeResultDetailModel> resultDetailModelMap = new HashMap<>();
            Map<String, AdapterSchemeResultDetailModel> resultDetailModelCheckMap = new HashMap<>();
            Map<String, AdapterSchemeResultDetailModel> resultDetailModelAddMap = new HashMap<>();
            for (AdapterSchemeModel schemeModel : adapterSchemeModelList) {
                String id = "scheme" + schemeModel.getId();
                AdapterSchemeResultDetailModel resultDetailModel = new AdapterSchemeResultDetailModel();
                resultDetailModel.setId(id);
                resultDetailModel.setPid("");
                resultDetailModel.setType(0);
                resultDetailModel.setName(schemeModel.getName());
                resultDetailModel.setStdName(stdMap.get(schemeModel.getStdId()).getName());
                resultDetailModel.setStdVersion(stdVersionMap.get(schemeModel.getStdVersion()).getVersion());
                resultDetailModel.setStdVersionName(stdVersionMap.get(schemeModel.getStdVersion()).getName());
                resultDetailModel.setPublisher(stdMap.get(schemeModel.getAdapterStdId()) == null ? "" : stdMap.get(schemeModel.getAdapterStdId()).getPublisher());
                resultDetailModel.setAdapterName(stdMap.get(schemeModel.getAdapterStdId()) == null ? "" : stdMap.get(schemeModel.getAdapterStdId()).getName());
                if (stdVersionMap.get(schemeModel.getAdapterStdVersion()) != null) {
                    resultDetailModel.setAdapterVersionName(stdVersionMap.get(schemeModel.getAdapterStdVersion()).getName());
                    resultDetailModel.setAdapterStdVersion(stdVersionMap.get(schemeModel.getAdapterStdVersion()).getVersion());
                }
                if (StringUtil.isEmpty(name) || schemeModel.getName().contains(name)) {
                    resultDetailModelCheckMap.put(id, resultDetailModel);
                    resultDetailModelAddMap.put(id, resultDetailModel);
                    resultDetailModelList.add(resultDetailModel);
                }
                resultDetailModelMap.put(id, resultDetailModel);
            }
            for (AdapterSchemeVersionModel versionModel : versionModelList) {
                String pid = "scheme" + versionModel.getSchemeId();
                String id = "version" + versionModel.getId();
                AdapterSchemeResultDetailModel resultDetailModel = new AdapterSchemeResultDetailModel();
                resultDetailModel.setId(id);
                resultDetailModel.setPid(pid);
                resultDetailModel.setName(versionModel.getName());
                resultDetailModel.setStatus(versionModel.getPublishStatus());
                resultDetailModel.setDate(StringUtil.toString(versionModel.getPublishTime()));
                resultDetailModel.setVersion(versionModel.getVersion());
                resultDetailModel.setType(1);
                if (resultDetailModelCheckMap.containsKey(pid)) {
                    resultDetailModel.setAdapterStdVersion(resultDetailModelCheckMap.get(resultDetailModel.getPid()).getAdapterStdVersion());
                    resultDetailModelList.add(resultDetailModel);
                } else if (StringUtil.isEmpty(name) || versionModel.getName().contains(name)) {
                    resultDetailModelList.add(resultDetailModel);
                    if (!resultDetailModelAddMap.containsKey(pid)) {
                        resultDetailModelAddMap.put(pid, resultDetailModelMap.get(resultDetailModel.getPid()));
                        resultDetailModelList.add(resultDetailModelMap.get(resultDetailModel.getPid()));
                    }
                }
            }
            return ListEnvelop.getSuccess("获取适配方案成功",resultDetailModelList);
        } catch (Exception e) {
            e.printStackTrace();
            return ListEnvelop.getError("获取适配方案失败");
        }
    }
    public boolean existSchemeVersionValid(Integer schemeId) {
        String hql = "FROM AdapterSchemeVersionModel WHERE schemeId = :schemeId";
        Query query = getCurrentSession().createQuery(hql);
        query.setParameter("schemeId", schemeId);
        List<AdapterSchemeVersionModel> schemeVersionModelList = query.list();
        if (!CollectionUtils.isEmpty(schemeVersionModelList)) {
            return true;
        }
        return false;
    }
    public ListEnvelop getAdapterSchemeResultModelList() {
        String schemeHql = "FROM AdapterSchemeModel";
        Query query = getCurrentSession().createQuery(schemeHql);
        List<AdapterSchemeModel> adapterSchemeModelList = query.list();
        List<AdapterSchemeResultModel> schemeList = new ArrayList<>();
        for (AdapterSchemeModel schemeModel : adapterSchemeModelList) {
            String adapterVersionHql = "FROM AdapterSchemeVersionModel WHERE schemeId = :schemeId and publishStatus = 1";
            query = getCurrentSession().createQuery(adapterVersionHql);
            query.setParameter("schemeId", schemeModel.getId());
            List<AdapterSchemeVersionModel> versionModelList = query.list();
            if(versionModelList.size()>0){
                AdapterSchemeResultModel resultDetailModel = new AdapterSchemeResultModel();
                resultDetailModel.setSchemeId(schemeModel.getId());
                resultDetailModel.setName(schemeModel.getName());
                resultDetailModel.setVersionList(versionModelList);
                schemeList.add(resultDetailModel);
            }
        }
        return ListEnvelop.getSuccess("获取成功",schemeList);
    }
    public List delDuplicateArr(List<?> list){
        // 利用 Set 的特性，将所有项目放入 Set
        //中即可移除重复的项目
        Set<Object> set = new HashSet<>();
        for (Object element : list) {
            set.add(element);
        }
        // Set.size() 为不重复项目的个数
        List nonDuplicateArra = new ArrayList();
        // 将 Set 中的项目取出放到 nonDuplicateArray 中
        Object[] tempArray = set.toArray();
        for (int i = 0; i < tempArray.length; i++) {
           nonDuplicateArra.add ( tempArray[i]);
        }
        return nonDuplicateArra;
    }
}

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

@@ -0,0 +1,522 @@
package com.yihu.jw.basic.standard.service.adapter;
import com.yihu.jw.basic.standard.model.adapter.AdapterSchemeModel;
import com.yihu.jw.basic.standard.model.adapter.AdapterSchemeVersionModel;
import com.yihu.jw.basic.standard.model.adapter.resultModel.AdapterSchemeVersionResultDetailModel;
import com.yihu.jw.basic.standard.model.standard.StandardModel;
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.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.basic.standard.model.*;
import com.yihu.jw.util.sql.SqlConstants;
import com.yihu.jw.util.sql.SqlCreator;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Restrictions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import java.beans.Beans;
import java.util.*;
/**
 * @Created by lingfeng 2015/12/25.
 */
@Transactional
@Service("AdapterSchemeVersionService")
public class AdapterSchemeVersionService extends SQLGeneralDAO {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    public static final String BEAN_ID = "AdapterSchemeVersionService";
    public ListEnvelop getDictionaryResult(Integer schemeId, String condition, String order, Integer rows, Integer page) {
        try {
            List<AdapterSchemeVersionModel> adapterSchemeVersionModelList = getEntityListByParentId(
                    AdapterSchemeVersionModel.class, "schemeId", schemeId, condition, order, rows, page);
            List<DictItem> detailModelList = new ArrayList<DictItem>();
            DictItem item = new DictItem();
            item.setCode("");
            item.setValue("-无-");
            detailModelList.add(item);
            for (AdapterSchemeVersionModel adapterSchemeVersionModel : adapterSchemeVersionModelList) {
                DictItem items = new DictItem();
                String id = adapterSchemeVersionModel.getVersion();
                String name = adapterSchemeVersionModel.getName();
                items.setCode(id.toString());
                items.setValue(name);
                detailModelList.add(items);
            }
            return ListEnvelop.getSuccess("获取适配方案版本成功",detailModelList);
        } catch (Exception e) {
            e.printStackTrace();
            return ListEnvelop.getError("获取适配方案版本失败");
        }
    }
    public ObjEnvelop add(String version) {
        Boolean existFlg = false;
        try {
            AdapterSchemeVersionModel versionModel = objectMapper.readValue(version, AdapterSchemeVersionModel.class);
            existFlg = schemeVersionNameValidate(versionModel.getSchemeId(), versionModel.getName());
            if (!existFlg) {
                AdapterVersion adapterVersion = AdapterVersion.generateVersion();
                versionModel.setVersion(adapterVersion.getVersion());
                versionModel.setPublishStatus(0);
                saveEntity(versionModel);
                if (!StringUtil.isEmpty(versionModel.getBaseVersion())) {
                    AdapterSchemeVersionModel baseVersionModel = getByVersion(versionModel.getBaseVersion());
                    AdapterVersion baseVersion = new AdapterVersion(baseVersionModel.getVersion());
                    AdapterVersion newVersion = new AdapterVersion(versionModel.getVersion());
                    buildVersionTables(baseVersion, newVersion);
                } else {
                    buildVersionTables(versionModel);
                }
                return ObjEnvelop.getSuccess("保存适配版本成功",versionModel);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (existFlg) {
            return ObjEnvelop.getError("已存在适配方案版本名称");
        } else {
            return ObjEnvelop.getError("保存适配方案失败");
        }
    }
    public Boolean schemeVersionNameValidate(Integer schemeId, String name) {
        String sql = "FROM AdapterSchemeVersionModel WHERE schemeId = :schemeId and name = :name";
        Query query = getCurrentSession().createQuery(sql);
        query.setParameter("schemeId", schemeId);
        query.setParameter("name", name);
        List<AdapterSchemeVersionModel> list = query.list();
        if (!CollectionUtils.isEmpty(list)) {
            return true;
        }
        return false;
    }
    public ObjEnvelop publish(String version) {
        return update(version);
    }
    public ObjEnvelop update(String version) {
        Boolean existFlg = false;
        try {
            AdapterSchemeVersionModel versionModel = objectMapper.readValue(version, AdapterSchemeVersionModel.class);
            existFlg = schemeVersionNameValidate(versionModel.getSchemeId(), versionModel.getId(), versionModel.getName());
            if (!existFlg) {
                updateEntity(versionModel);
                return ObjEnvelop.getSuccess("修改适配方案成功",versionModel);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (existFlg) {
            return ObjEnvelop.getError("已存在适配方案版本名称");
        } else {
            return ObjEnvelop.getError("修改适配方案版本失败");
        }
    }
    public Boolean schemeVersionNameValidate(Integer schemeId, Integer versionId, String name) {
        String sql = "FROM AdapterSchemeVersionModel WHERE schemeId = :schemeId and name = :name and id != :versionId";
        Query query = getCurrentSession().createQuery(sql);
        query.setParameter("schemeId", schemeId);
        query.setParameter("name", name);
        query.setParameter("versionId", versionId);
        List<AdapterSchemeVersionModel> list = query.list();
        if (!CollectionUtils.isEmpty(list)) {
            return true;
        }
        return false;
    }
    public Envelop delete(Integer versionId) {
        Boolean publishedFlg = false;
        try {
            AdapterSchemeVersionModel versionModel = getEntity(AdapterSchemeVersionModel.class, versionId);
            if (versionModel.getPublishStatus() != null && versionModel.getPublishStatus() == 1) {
                publishedFlg = true;
            } else {
                this.deleteEntity(versionModel);
                deleteVersionTables(new AdapterVersion(versionModel.getVersion()));
                return Envelop.getSuccess("删除适配版本成功");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (publishedFlg) {
            return Envelop.getError("该适配版本已发布");
        } else {
            return Envelop.getError("删除适配版本失败");
        }
    }
    public ObjEnvelop get(Integer versionId) {
        try {
            AdapterSchemeVersionModel versionModel = getEntity(AdapterSchemeVersionModel.class, versionId);
            return ObjEnvelop.getSuccess("获取适配版本方成功",versionModel);
        } catch (Exception e) {
            e.printStackTrace();
            return ObjEnvelop.getError("获取适配方案失败");
        }
    }
    public AdapterSchemeVersionModel getByVersion(String version) {
        try {
            String sql = "FROM AdapterSchemeVersionModel WHERE version = :version";
            Query query = getCurrentSession().createQuery(sql);
            query.setParameter("version", version);
            List<AdapterSchemeVersionModel> list = query.list();
            if (CollectionUtils.isEmpty(list)) {
                return null;
            }
            AdapterSchemeVersionModel versionModel = list.get(0);
            return versionModel;
        } catch (Exception e) {
            throw new ApiException(ErrorCode.GetSchemeVersionFailed.getErrorCode());
        }
    }
    public AdapterSchemeVersionModel fork(Integer versionId) {
        try {
            AdapterSchemeVersionModel baseVersionModel = getEntity(AdapterSchemeVersionModel.class, versionId);
            AdapterSchemeVersionModel newVersionModel = new AdapterSchemeVersionModel();
            newVersionModel.setBaseVersion(baseVersionModel.getVersion());
            newVersionModel.setSchemeId(baseVersionModel.getSchemeId());
            newVersionModel.setPublishTime(new Date());
            this.saveEntity(newVersionModel);
            AdapterVersion baseVersion = new AdapterVersion(baseVersionModel.getVersion());
            AdapterVersion newVersion = new AdapterVersion(newVersionModel.getVersion());
            buildVersionTables(baseVersion, newVersion);
            return newVersionModel;
        } catch (Exception e) {
            throw new ApiException(ErrorCode.SaveSchemeVersionFailed.getErrorCode());
        }
    }
    public ObjEnvelop publish(Integer versionId, String publisher) {
        try {
            AdapterSchemeVersionModel adapterSchemeVersionModel = getEntity(AdapterSchemeVersionModel.class, versionId);
            //TODO:generate standard version file;
            adapterSchemeVersionModel.setPublishTime(new Date());
            adapterSchemeVersionModel.setPublishUser(publisher);
            adapterSchemeVersionModel.setPublishStatus(1);
            this.updateEntity(adapterSchemeVersionModel);
            return ObjEnvelop.getSuccess("发布适配版本成功",adapterSchemeVersionModel);
        } catch (Exception e) {
            e.printStackTrace();
            return ObjEnvelop.getError("发布适配版本失败");
        }
    }
    public List<AdapterSchemeVersionResultDetailModel> getPublishedList() {
        try {
            Session session = getCurrentSession();
            Criteria criteria = session.createCriteria(AdapterSchemeVersionModel.class);
            criteria.add(Restrictions.eq("publishStatus", 1));
            List<AdapterSchemeVersionModel> versionModelList = criteria.list();
            List<Integer> schemeIdList = new ArrayList<>();
            Map<Integer, String> schemeMap = new HashMap<>();
            for (AdapterSchemeVersionModel model : versionModelList) {
                schemeIdList.add(model.getSchemeId());
            }
            if (CollectionUtils.isEmpty(schemeIdList)) {
                schemeIdList.add(null);
            }
            criteria = session.createCriteria(AdapterSchemeModel.class);
            criteria.add(Restrictions.in("id", schemeIdList));
            List<AdapterSchemeModel> schemeList = criteria.list();
            for (AdapterSchemeModel schemeModel : schemeList) {
                schemeMap.put(schemeModel.getId(), schemeModel.getName());
            }
            List<AdapterSchemeVersionResultDetailModel> detailModelList = new ArrayList<>();
            for (AdapterSchemeVersionModel model : versionModelList) {
                AdapterSchemeVersionResultDetailModel detailModel = new AdapterSchemeVersionResultDetailModel();
                detailModel.setId(model.getId());
                detailModel.setName(model.getName());
                detailModel.setSchemeId(model.getSchemeId());
                detailModel.setSchemeName(schemeMap.get(model.getSchemeId()));
                detailModel.setVersion(model.getVersion());
                detailModel.setBaseVersion(model.getBaseVersion());
                detailModel.setPublishStatus(model.getPublishStatus());
                detailModel.setPublishUser(model.getPublishUser());
                detailModel.setPublishTime(model.getPublishTime());
                detailModelList.add(detailModel);
            }
            return detailModelList;
        } catch (Exception e) {
            throw new ApiException(ErrorCode.GetSchemeVersionListFailed.getErrorCode());
        }
    }
    public AdapterSchemeVersionModel getEhrAdapterVersionLasted() {
        try {
            List<AdapterSchemeModel> adapterSchemeModelList = getEhrAdapterSchemeList();
            if (CollectionUtils.isEmpty(adapterSchemeModelList)) {
                return null;
            }
            String schemeIdListStr = SqlConstants.EMPTY;
            for (AdapterSchemeModel adapterSchemeModel : adapterSchemeModelList) {
                schemeIdListStr = schemeIdListStr + adapterSchemeModel.getId() + SqlConstants.COMMA;
            }
            schemeIdListStr = SqlConstants.LEFT_BRACKET + schemeIdListStr.substring(0, schemeIdListStr.length() - 1) + SqlConstants.RIGHT_BRACKET;
            String adapterSchemeVersionHql = "SELECT ID AS id,VERSION AS version,SCHEME_ID AS schemeId,NAME AS name FROM ADAPTER_SCHEME_VERSION WHERE PUBLISH_TIME=(select max(PUBLISH_TIME) from ADAPTER_SCHEME_VERSION WHERE SCHEME_ID in " + schemeIdListStr + ")";
            Query adapterSchemeVersionQuery = getCurrentSession().createSQLQuery(adapterSchemeVersionHql);
            Object[] object = (Object[]) adapterSchemeVersionQuery.uniqueResult();
            if (object != null) {
                AdapterSchemeVersionModel adapterSchemeVersionModel = new AdapterSchemeVersionModel();
                adapterSchemeVersionModel.setId((Integer) object[0]);
                adapterSchemeVersionModel.setVersion((String) object[1]);
                adapterSchemeVersionModel.setSchemeId((Integer) object[2]);
                adapterSchemeVersionModel.setName((String) object[3]);
                return adapterSchemeVersionModel;
            } else {
                return null;
            }
        } catch (Exception e) {
            return null;
        }
    }
    public List<AdapterSchemeModel> getEhrAdapterSchemeList() {
        String paramSql = "select s.param_value from system_param s where s.param_key = '" + SqlConstants.STANDARD_EHR + "'";
        Query paramQuery = getCurrentSession().createSQLQuery(paramSql);
        String code = (String) paramQuery.uniqueResult();
        if (StringUtil.isEmpty(code)) {
            return null;
        }
        String standardHql = "FROM StandardModel WHERE code = :code";
        Query standardQuery = getCurrentSession().createQuery(standardHql);
        standardQuery.setParameter("code", code);
        StandardModel standardModel = (StandardModel) standardQuery.uniqueResult();
        if (standardModel == null) {
            return null;
        }
        String adapterSchemeHql = "FROM AdapterSchemeModel WHERE adapterStdId = :adapterStdId";
        Query adapterSchemeQuery = getCurrentSession().createQuery(adapterSchemeHql);
        adapterSchemeQuery.setParameter("adapterStdId", standardModel.getId());
        List<AdapterSchemeModel> adapterSchemeModelList = adapterSchemeQuery.list();
        return adapterSchemeModelList;
    }
    public PageEnvelop getVersion() throws Exception {
        String schemeSql = "select * from adapter_scheme";
        List<AdapterSchemeModel> std = jdbcTemplate.query(schemeSql,new BeanPropertyRowMapper<>(AdapterSchemeModel.class));
        PageEnvelop data = new PageEnvelop();
        List<TreeResult> results = new ArrayList<>();
        for (int i = 0; i < std.size(); i++) {
            TreeResult re = new TreeResult();
            //re.setPid("0");
            re.setText(std.get(i).getName());
            re.setId(String.valueOf(std.get(i).getId()));
            results.add(re);
            String sql = "select * from adapter_scheme_version ";
            sql += "where scheme_id=" + std.get(i).getId();
            List<AdapterSchemeVersionModel> stdModel = jdbcTemplate.query(sql,new BeanPropertyRowMapper<>(AdapterSchemeVersionModel.class));
            for (int j = 0; j < stdModel.size(); j++) {
                TreeResult tmpTree = new TreeResult();
                tmpTree.setId(String.valueOf(stdModel.get(j).getId()));
                tmpTree.setText(stdModel.get(j).getName());
                tmpTree.setPid(String.valueOf(std.get(i).getId()));
                results.add(tmpTree);
            }
        }
        data.setTotalCount(results.size());
        data.setDetailModelList(results);
        return data;
    }
    /**
     * 树型数据
     *
     * @return
     * @throws Exception
     */
    public List<TreeResult> getVersionTree() throws Exception {
        String schemeSql = "select * from from adapter_scheme";
        List<AdapterSchemeModel> std = jdbcTemplate.query(schemeSql,new BeanPropertyRowMapper<>(AdapterSchemeModel.class));
        List<TreeResult> results = new ArrayList<>();
        for (int i = 0; i < std.size(); i++) {
            TreeResult re = new TreeResult();
            //re.setPid("0");
            re.setText(std.get(i).getName());
            re.setId(String.valueOf(std.get(i).getId()));
            results.add(re);
            String sql = "select * from from adapter_scheme_version ";
            sql += "where scheme_id=" + std.get(i).getId();
            List<AdapterSchemeVersionModel> stdModel = jdbcTemplate.query(sql,new BeanPropertyRowMapper<>(AdapterSchemeVersionModel.class));
            for (int j = 0; j < stdModel.size(); j++) {
                TreeResult tmpTree = new TreeResult();
                tmpTree.setId(String.valueOf(stdModel.get(j).getId()));
                tmpTree.setText(stdModel.get(j).getName());
                tmpTree.setPid(String.valueOf(std.get(i).getId()));
                results.add(tmpTree);
            }
        }
        return results;
    }
    private void deleteVersionTables(AdapterVersion version) {
        String[] tables = {version.getDataSetTableName(),
                version.getMetaDataTableName(),
                version.getDictTableName(),
                version.getDictEntryTableName(),
                version.getDatasetRelationTableName()};
        List<String> deleteSqlList = new ArrayList<>();
        boolean temp = false;
        for (int i = 0; i < tables.length; ++i) {
            String table = tables[i];
            temp = tableIsExist("SELECT COUNT(*) FROM information_schema.TABLES WHERE table_name ='"+table+"'");
            if(temp){
                deleteSqlList.add(SqlConstants.DROP_TABLE + table);
            }
        }
        insertBatch(deleteSqlList);
    }
    private void buildVersionTables(AdapterVersion baseVersion, AdapterVersion newVersion) {
        String[] newTables = {newVersion.getDataSetTableName(),
                newVersion.getMetaDataTableName(),
                newVersion.getDictTableName(),
                newVersion.getDictEntryTableName()};
        String[] baseTables = {baseVersion.getDataSetTableName(),
                baseVersion.getMetaDataTableName(),
                baseVersion.getDictTableName(),
                baseVersion.getDictEntryTableName()};
        Session session = getCurrentSession();
        for (int i = 0; i < baseTables.length; ++i) {
            String baseTable = baseTables[i];
            String newTable = newTables[i];
            Query query = session.createSQLQuery(SqlConstants.CREATE_TABLE + newTable + SqlConstants.LIKE + baseTable);
            query.executeUpdate();
            query = session.createSQLQuery(SqlConstants.INSERT_INTO + newTable + SqlConstants.SELECT + "*" + SqlConstants.FROM + baseTable);
            query.executeUpdate();
        }
    }
    private void buildVersionTables(AdapterSchemeVersionModel versionModel) throws Exception {
        AdapterVersion adapterVersion = new AdapterVersion(versionModel.getVersion());
        AdapterSchemeModel scheme = getEntity(AdapterSchemeModel.class, versionModel.getSchemeId());
        StandardVersion stdVersion = new StandardVersion(scheme.getStdVersion());
        insertBatch(createTable(adapterVersion));
        List<String> sqlList = new ArrayList<>();
        SqlCreator sqlCreator = new SqlCreator(StdMetaDataModel.class);
        String sql = sqlCreator.selectData(stdVersion.getMetaDataTableName());
        Query query = getQuery(sqlCreator, sql);
        List<StdMetaDataModel> metadataList = query.list();
        List<Integer> newDictdList = new ArrayList<>();
        for (StdMetaDataModel stdMetaDataModel : metadataList) {
            if (stdMetaDataModel.getDictId() != null && !newDictdList.contains(stdMetaDataModel.getDictId())) {
                newDictdList.add(stdMetaDataModel.getDictId());
            }
        }
        sqlList.add(insertData(adapterVersion.getDataSetTableName(), stdVersion.getDataSetTableName(),
                new String[]{"id,std_dataset_id,std_dataset_code,std_dataset_name"},
                new String[]{"id,id,code,name"},
                scheme.getId(),
                "",
                null));
        sqlList.add(insertData(adapterVersion.getMetaDataTableName(), stdVersion.getMetaDataTableName(),
                new String[]{"id,std_metadata_id,std_metadata_code,std_metadata_name,std_dataset_id,std_dict_id"},
                new String[]{"id,id,code,name,dataset_id,dict_id"},
                scheme.getId(),
                "",
                null));
        if(newDictdList.size()!=0){
            sqlList.add(insertData(adapterVersion.getDictTableName(), stdVersion.getDictTableName(),
                    new String[]{"id,std_dict_id,std_dict_code,std_dict_name"},
                    new String[]{"id,id,code,name"},
                    scheme.getId(),
                    "id",
                    newDictdList));
            sqlList.add(insertData(adapterVersion.getDictEntryTableName(), stdVersion.getDictEntryTableName(),
                    new String[]{"id,std_entry_id,std_entry_code,std_entry_value,std_dict_id"},
                    new String[]{"id,id,code,value,dict_id"},
                    scheme.getId(),
                    "dict_id",
                    newDictdList));
        }
        insertBatch(sqlList);
    }
    private List<String> createTable(AdapterVersion adapterVersion) {
        List<String> sqlList = new ArrayList<>();
        List<String> adapterTableList = new ArrayList<>();
        adapterTableList.add(adapterVersion.DataSetTablePrefix);
        adapterTableList.add(adapterVersion.MetaDataTablePrefix);
        adapterTableList.add(adapterVersion.DictTablePrefix);
        adapterTableList.add(adapterVersion.DictEntryTablePrefix);
        adapterTableList.add(adapterVersion.DatasetRelationTablePrefix);
        for (String table : adapterTableList) {
            String sql = SqlConstants.CREATE_TABLE + table + SqlConstants.UNDERLINE + adapterVersion.getVersion() + SqlConstants.LIKE + table;
            sqlList.add(sql);
        }
        return sqlList;
    }
    private String insertData(String adapterTableName, String stdTableName, String[] item1, String[] item2, Integer schemeId, String item, List<Integer> idList) {
        StringBuffer sql = new StringBuffer();
        String idStr = SqlConstants.EMPTY;
        if (!CollectionUtils.isEmpty(idList)) {
            for (Integer id : idList) {
                idStr += id + SqlConstants.COMMA;
            }
            if (!StringUtil.isEmpty(idStr)) {
                idStr = SqlConstants.LEFT_BRACKET + idStr.substring(0, idStr.length() - 1) + SqlConstants.RIGHT_BRACKET;
            }
        }
        sql.append(SqlConstants.INSERT_INTO + adapterTableName + SqlConstants.LEFT_BRACKET);
        for (String it : item1) {
            sql.append(it + SqlConstants.COMMA);
        }
        sql.append("scheme_id" + SqlConstants.RIGHT_BRACKET + SqlConstants.LEFT_BRACKET + SqlConstants.SELECT);
        for (String it : item2) {
            sql.append(it + SqlConstants.COMMA);
        }
        sql.append(schemeId + SqlConstants.FROM + stdTableName);
        if (!StringUtil.isEmpty(item)) {
            sql.append(SqlConstants.WHERE + item + SqlConstants.IN + idStr);
        }
        sql.append(SqlConstants.RIGHT_BRACKET);
        return sql.toString();
    }
    public List<AdapterSchemeVersionModel> getAll(){
        StringBuffer sql = new StringBuffer();
        sql.append("SELECT v.*").append(" FROM adapter_scheme_version v ");
        Query query = getCurrentSession().createSQLQuery(sql.toString()).addEntity(AdapterSchemeVersionModel.class);
        List<AdapterSchemeVersionModel> list = query.list();
        return list;
    }
}

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

@@ -0,0 +1,52 @@
package com.yihu.jw.basic.standard.service.bo;
import com.yihu.jw.util.sql.SqlConstants;
public class AdapterVersion {
    public static final String FBVersion = "000000000000";
    public final static String DataSetTablePrefix = "adapter_dataset";
    public final static String MetaDataTablePrefix = "adapter_metadata";
    public final static String DictTablePrefix = "adapter_dict";
    public final static String DictEntryTablePrefix = "adapter_dictentry";
    public final static String DatasetRelationTablePrefix = "adapter_dataset_relation";
    private ObjectVersion version;
    public AdapterVersion(String version) {
        this.version = new ObjectVersion(version);
    }
    public static AdapterVersion generateVersion() {
        ObjectVersion objectVersion = new ObjectVersion();
        return new AdapterVersion(objectVersion.toString());
    }
    public String getDataSetTableName() {
        return DataSetTablePrefix + SqlConstants.UNDERLINE + version;
    }
    public String getMetaDataTableName() {
        return MetaDataTablePrefix + SqlConstants.UNDERLINE + version;
    }
    public String getDictTableName() {
        return DictTablePrefix + SqlConstants.UNDERLINE + version;
    }
    public String getDictEntryTableName() {
        return DictEntryTablePrefix + SqlConstants.UNDERLINE + version;
    }
    public String getDatasetRelationTableName() {
        return DatasetRelationTablePrefix + SqlConstants.UNDERLINE + version;
    }
    public String getVersion() {
        return version.toString();
    }
    public void finalize() throws Throwable {
    }
}

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

@@ -0,0 +1,184 @@
package com.yihu.jw.basic.standard.service.bo;
import java.io.Serializable;
import java.security.SecureRandom;
import java.util.Date;
import java.util.concurrent.atomic.AtomicInteger;
/**
 * @author HZY
 * @vsrsion 1.0
 * Created at 2016/8/8.
 */
public final class ObjectVersion implements Comparable<ObjectVersion>, Serializable {
    private static final long serialVersionUID = 789056789654456072L;
    private static final int BYTE_ARRAY_LENGTH = 6;
    private static final AtomicInteger NEXT_COUNTER = new AtomicInteger((new SecureRandom()).nextInt());
    private static final char[] HEX_CHARS = new char[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
    private final int timestamp;
    private final short counter;
    public static boolean isValid(String hexString) {
        if(hexString == null) {
            throw new IllegalArgumentException();
        } else {
            int len = hexString.length();
            if(len != 12) {
                return false;
            } else {
                for(int i = 0; i < len; ++i) {
                    char c = hexString.charAt(i);
                    if((c < 48 || c > 57) && (c < 97 || c > 102) && (c < 65 || c > 70)) {
                        return false;
                    }
                }
                return true;
            }
        }
    }
    public static int getCurrentCounter() {
        return NEXT_COUNTER.get();
    }
    public ObjectVersion() {
        this(new Date());
    }
    public ObjectVersion(Date date) {
        this(dateToTimestampSeconds(date), (short)NEXT_COUNTER.getAndIncrement());
    }
    public ObjectVersion(Date date, short counter) {
        this(dateToTimestampSeconds(date), counter);
    }
    public ObjectVersion(int timestamp, short counter) {
        this.timestamp = timestamp;
        this.counter = counter;
    }
    public ObjectVersion(String hexString) {
        this(parseHexString(hexString));
    }
    public ObjectVersion(byte[] bytes) {
        if(bytes == null) {
            throw new IllegalArgumentException();
        } else if(bytes.length != 6) {
            throw new IllegalArgumentException("need 6 bytes");
        } else {
            this.timestamp = makeInt(bytes[0], bytes[1], bytes[2], bytes[3]);
            this.counter = (short)makeInt((byte)0, (byte)0, bytes[4], bytes[5]);
        }
    }
    public byte[] toByteArray() {
        byte[] bytes = new byte[]{int3(this.timestamp), int2(this.timestamp), int1(this.timestamp), int0(this.timestamp), int1(this.counter), int0(this.counter)};
        return bytes;
    }
    public Date getDate() {
        return new Date((long)this.timestamp * 1000L);
    }
    public int getTimestamp() {
        return this.timestamp;
    }
    public short getCounter() {
        return this.counter;
    }
    public String toHexString() {
        char[] chars = new char[12];
        int i = 0;
        byte[] var3 = this.toByteArray();
        int var4 = var3.length;
        for(int var5 = 0; var5 < var4; ++var5) {
            byte b = var3[var5];
            chars[i++] = HEX_CHARS[b >> 4 & 15];
            chars[i++] = HEX_CHARS[b & 15];
        }
        return new String(chars);
    }
    public boolean equals(Object o) {
        if(this == o) {
            return true;
        } else if(o != null && this.getClass() == o.getClass()) {
            ObjectVersion objectId = (ObjectVersion)o;
            return this.counter != objectId.counter?false:this.timestamp == objectId.timestamp;
        } else {
            return false;
        }
    }
    public int hashCode() {
        int result = this.timestamp;
        result = 31 * result + this.counter;
        return result;
    }
    public int compareTo(ObjectVersion other) {
        if(other == null) {
            throw new NullPointerException();
        } else {
            byte[] byteArray = this.toByteArray();
            byte[] otherByteArray = other.toByteArray();
            for(int i = 0; i < 6; ++i) {
                if(byteArray[i] != otherByteArray[i]) {
                    return (byteArray[i] & 255) < (otherByteArray[i] & 255)?-1:1;
                }
            }
            return 0;
        }
    }
    public String toString() {
        return this.toHexString();
    }
    private static byte[] parseHexString(String s) {
        if(!isValid(s)) {
            throw new IllegalArgumentException("invalid hexadecimal representation of an ObjectId: [" + s + "]");
        } else {
            byte[] b = new byte[6];
            for(int i = 0; i < b.length; ++i) {
                b[i] = (byte)Integer.parseInt(s.substring(i * 2, i * 2 + 2), 16);
            }
            return b;
        }
    }
    private static int dateToTimestampSeconds(Date time) {
        return (int)(time.getTime() / 1000L);
    }
    private static int makeInt(byte b3, byte b2, byte b1, byte b0) {
        return b3 << 24 | (b2 & 255) << 16 | (b1 & 255) << 8 | b0 & 255;
    }
    private static byte int3(int x) {
        return (byte)(x >> 24);
    }
    private static byte int2(int x) {
        return (byte)(x >> 16);
    }
    private static byte int1(int x) {
        return (byte)(x >> 8);
    }
    private static byte int0(int x) {
        return (byte)x;
    }
}

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

@@ -0,0 +1,59 @@
package com.yihu.jw.basic.standard.service.bo;
public class StandardVersion {
    public final static String VersionBoundSymbol = "_";
    public final static String DataSetTable = "std_dataset";
    public final static String MetaDataTable = "std_metadata";
    public final static String DictTable = "std_dictionary";
    public final static String DictEntryTable = "std_dictionary_entry";
    public final static String CDADocumentTable = "std_cda_document";
    public final static String CDADatasetTable = "std_cda_dataset";
    private ObjectVersion version;
    public StandardVersion(String version) {
        this.version = new ObjectVersion(version);
    }
    public StandardVersion() {
    }
    public static StandardVersion generateVersion() {
        ObjectVersion objectVersion = new ObjectVersion();
        return new StandardVersion(objectVersion.toString());
    }
    public String getDataSetTableName() {
        return DataSetTable + VersionBoundSymbol + version;
    }
    public String getMetaDataTableName() {
        return MetaDataTable + VersionBoundSymbol + version;
    }
    public String getDictTableName() {
        return DictTable + VersionBoundSymbol + version;
    }
    public String getDictEntryTableName() {
        return DictEntryTable + VersionBoundSymbol + version;
    }
    public String getCDATableName() {
        return CDADocumentTable + VersionBoundSymbol + version;
    }
    public String getCDADatasetTableName() {
        return CDADatasetTable + VersionBoundSymbol + version;
    }
    public String getVersion() {
        return version.toString();
    }
    public void finalize() throws Throwable {
    }
}

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

@@ -0,0 +1,450 @@
package com.yihu.jw.basic.standard.service.standard;
import com.fasterxml.jackson.databind.JsonNode;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.basic.standard.model.*;
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.util.common.StringUtil;
import com.yihu.jw.util.sql.ErrorCode;
import com.yihu.jw.exception.ApiException;
import com.yihu.jw.util.sql.RequestParamTransformer;
import com.yihu.jw.basic.standard.model.standard.StandardModel;
import com.yihu.jw.basic.standard.model.standard.StandardVersionModel;
import com.yihu.jw.basic.standard.model.standard.resultModel.StandardParamResultModel;
import com.yihu.jw.basic.standard.model.standard.resultModel.StandardResultDetailModel;
import com.yihu.jw.util.sql.SqlConstants;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * @created Airhead 2015/12/23.
 */
@Service("StandardService")
public class StandardService extends SQLGeneralDAO {
    public static final String BEAN_ID = "StandardService";
    public ListEnvelop getDictionaryResult(String order, Integer limit, Integer offset) {
        try {
            List<DictItem> detailModelList = new ArrayList<DictItem>();
            List<StandardModel> standardModelList = getList(null, order, limit, offset);
            for (StandardModel standardModel : standardModelList) {
                DictItem items = new DictItem();
                Integer id = standardModel.getId();
                items.setCode(id.toString());
                items.setValue(standardModel.getName());
                detailModelList.add(items);
            }
            return ListEnvelop.getSuccess("获取标准列表成功",detailModelList);
        } catch (Exception e) {
            return ListEnvelop.getError("获取适配列表失败");
        }
    }
    public List<StandardModel> getList(String condition, String order, Integer limit, Integer offset) {
        Map queryMap = RequestParamTransformer.parseJsonToMap(condition);
        Map orderMap = RequestParamTransformer.parseJsonToMap(order);
        return this.getList(queryMap, orderMap, limit, offset);
    }
    public ObjEnvelop add(String standard) {
        Boolean existCodeFlg = false;
        Boolean existNameFlg = false;
        try {
            StandardModel standardModel = objectMapper.readValue(standard, StandardModel.class);
            existCodeFlg = standardCodeValidate(standardModel.getCode());
            existNameFlg = standardNameValidate(standardModel.getName());
            if (!existCodeFlg && !existNameFlg) {
                this.add(standardModel);
                return ObjEnvelop.getSuccess("保存标准成功",standardModel);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (existCodeFlg) {
            return ObjEnvelop.getError("已存在标准编码");
        } else if (existNameFlg) {
            return ObjEnvelop.getError("已存在标准名称");
        } else {
            return ObjEnvelop.getError("保存标准失败");
        }
    }
    public Boolean standardCodeValidate(String code) {
        Map<String, Object> query = new HashMap<>();
        Map<String, String> order = new HashMap<>();
        query.put("code", code);
        List<StandardModel> list = getList(query, order, 1, 0);
        if (!CollectionUtils.isEmpty(list)) {
            return true;
        }
        return false;
    }
    public Boolean standardNameValidate(String name) {
        Map<String, Object> query = new HashMap<>();
        Map<String, String> order = new HashMap<>();
        query.put("name", name);
        List<StandardModel> list = getList(query, order, 1, 0);
        if (!CollectionUtils.isEmpty(list)) {
            return true;
        }
        return false;
    }
    @Transactional
    public Envelop delete(Integer standardId) {
        Boolean publishedFlg = false;
        Boolean existFlg = false;
        try {
            ObjEnvelop objEnvelop = get(standardId);
            if (objEnvelop.getStatus()!=200) {
                return Envelop.getError("删除标准失败");
            }
            StandardModel standardModel = (StandardModel) objEnvelop.getObj();
            if (standardModel.getVersionStatus().equals(1)) {
                publishedFlg = true;
            }
            existFlg = existStandardVersionValid(standardModel.getId());
            if (!publishedFlg && !existFlg) {
                deleteEntity(StandardModel.class, standardId);
                return Envelop.getSuccess("删除标准成功");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (publishedFlg) {
            return Envelop.getError("该标准下已有标准版本");
        } else if (existFlg) {
            return Envelop.getError("已存在标准版本");
        } else {
            return Envelop.getError("删除标准失败");
        }
    }
    public Boolean standardNameValidate(Integer standardId, String name) {
        String sql = "FROM StandardModel WHERE name = :name and id != :standardId";
        Query query = getCurrentSession().createQuery(sql);
        query.setParameter("standardId", standardId);
        query.setParameter("name", name);
        List<StandardModel> list = query.list();
        if (!CollectionUtils.isEmpty(list)) {
            return true;
        }
        return false;
    }
    public Boolean standardCodeValidate(Integer standardId, String code) {
        String sql = "FROM StandardModel WHERE code = :code and id != :standardId";
        Query query = getCurrentSession().createQuery(sql);
        query.setParameter("standardId", standardId);
        query.setParameter("code", code);
        List<StandardModel> list = query.list();
        if (!CollectionUtils.isEmpty(list)) {
            return true;
        }
        return false;
    }
    @Transactional
    public ObjEnvelop update(String standard) {
        Boolean existCodeFlg = false;
        Boolean existNameFlg = false;
        try {
            StandardModel standardModel = objectMapper.readValue(standard, StandardModel.class);
            existCodeFlg = standardCodeValidate(standardModel.getId(), standardModel.getCode());
            existNameFlg = standardNameValidate(standardModel.getId(), standardModel.getName());
            if (!existCodeFlg && !existNameFlg) {
                this.update(standardModel);
                return ObjEnvelop.getSuccess("修改标准成功",standardModel);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (existCodeFlg) {
            return ObjEnvelop.getError("已存在标准编码");
        } else if (existNameFlg) {
            return ObjEnvelop.getError("已存在标准名称");
        } else {
            return ObjEnvelop.getError("修改标准失败");
        }
    }
    public ObjEnvelop get(Integer standardId) {
        try {
            StandardModel standardModel = getEntity(StandardModel.class, standardId);
            return ObjEnvelop.getSuccess("获取标准成功",standardModel);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ObjEnvelop.getError("获取标准失败");
    }
    public StandardParamResultModel getStandardParam(String paramKey) {
        Criteria criteria = getCurrentSession().createCriteria(SystemParam.class);
        criteria.add(Restrictions.eq("paramKey", paramKey));
        SystemParam systemParam = (SystemParam) criteria.uniqueResult();
        Criteria criteria1 = getCurrentSession().createCriteria(SystemParam.class);
        criteria1.add(Restrictions.eq("paramKey", SqlConstants.STANDARD_ORG));
        SystemParam systemParam1 = (SystemParam) criteria1.uniqueResult();
        if (systemParam != null) {
            StandardParamResultModel standardParamResultModel = new StandardParamResultModel();
            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("获取参数失败");
            return standardParamResultModel;
        }
    }
    public List<StandardResultDetailModel> getStandardListFormat(List<SystemOrganization> publisherModelList,
                                                                 List<StandardModel> standardModelList,
                                                                 List<StandardVersionModel> versionModelList,
                                                                 Map<String, String> codeToIdMap,
                                                                 String name) {
        List<StandardResultDetailModel> resultDetailModelList = new ArrayList<>();
        Map<String, StandardResultDetailModel> resultDetailModelMap = new HashMap<>();
        Map<String, StandardResultDetailModel> resultDetailModelCheckMap = new HashMap<>();
        Map<String, StandardResultDetailModel> resultDetailModelAddMap = new HashMap<>();
        for (SystemOrganization publisherModel : publisherModelList) {
            StandardResultDetailModel resultDetailModel = new StandardResultDetailModel();
            String id = "publisher" + publisherModel.getId();
            resultDetailModel.setId(id);
            resultDetailModel.setName(publisherModel.getFullName());
            resultDetailModel.setType(0);
            resultDetailModel.setCode(publisherModel.getCode());
            codeToIdMap.put(publisherModel.getCode(), id);
            if (StringUtil.isEmpty(name) || publisherModel.getFullName().contains(name)) {
                resultDetailModelCheckMap.put(id, resultDetailModel);
                resultDetailModelAddMap.put(id, resultDetailModel);
                resultDetailModelList.add(resultDetailModel);
            }
            resultDetailModelMap.put(id, resultDetailModel);
        }
        for (StandardModel standardModel : standardModelList) {
            String pid = codeToIdMap.get(standardModel.getPublisherOrgCode());
            if (StringUtil.isEmpty(pid)) {
                continue;
            }
            String id = "standard" + standardModel.getId();
            StandardResultDetailModel resultDetailModel = new StandardResultDetailModel();
            resultDetailModel.setId(id);
            resultDetailModel.setPid(codeToIdMap.get(standardModel.getPublisherOrgCode()));
            resultDetailModel.setType(1);
            resultDetailModel.setName(standardModel.getName());
            resultDetailModel.setCode(standardModel.getCode());
            if (resultDetailModelCheckMap.containsKey(pid)) {
                resultDetailModelCheckMap.put(id, resultDetailModel);
                resultDetailModelList.add(resultDetailModel);
                resultDetailModelAddMap.put(id, resultDetailModel);
            } else if (StringUtil.isEmpty(name) || standardModel.getName().contains(name)) {
                resultDetailModelCheckMap.put(id, resultDetailModel);
                resultDetailModelList.add(resultDetailModel);
                if (!resultDetailModelAddMap.containsKey(pid)) {
                    resultDetailModelAddMap.put(pid, resultDetailModel);
                    resultDetailModelList.add(resultDetailModelMap.get(pid));
                }
            }
            resultDetailModelMap.put(id, resultDetailModel);
        }
        for (StandardVersionModel versionModel : versionModelList) {
            String pid = "standard" + versionModel.getStandardId();
            String id = "version" + versionModel.getId();
            StandardResultDetailModel resultDetailModel = new StandardResultDetailModel();
            resultDetailModel.setId(id);
            resultDetailModel.setPid(pid);
            resultDetailModel.setPublisher(versionModel.getPublishUser());
            resultDetailModel.setStatus(versionModel.getPublishStatus());
            resultDetailModel.setName(versionModel.getName());
            resultDetailModel.setCode(versionModel.getVersion());
            resultDetailModel.setDate(StringUtil.toString(versionModel.getPublishTime()));
            resultDetailModel.setType(2);
            if (resultDetailModelCheckMap.containsKey(pid)) {
                resultDetailModelList.add(resultDetailModel);
            } else if (StringUtil.isEmpty(name) || versionModel.getName().contains(name)) {
                resultDetailModelList.add(resultDetailModel);
                if (!resultDetailModelAddMap.containsKey(pid)) {
                    resultDetailModelAddMap.put(resultDetailModel.getPid(), resultDetailModelMap.get(resultDetailModel.getPid()));
                    if (resultDetailModelMap.get(pid) != null && resultDetailModelMap.get(resultDetailModel.getPid()) != null) {
                        resultDetailModelAddMap.put(resultDetailModelMap.get(pid).getPid(), resultDetailModelMap.get(resultDetailModelMap.get(resultDetailModel.getPid()).getPid()));
                        resultDetailModelList.add(resultDetailModelMap.get(resultDetailModel.getPid()));
                        resultDetailModelList.add(resultDetailModelMap.get(resultDetailModelMap.get(resultDetailModel.getPid()).getPid()));
                    }
                }
            }
        }
        return resultDetailModelList;
    }
    public ListEnvelop getDetailModelResult(String condition) {
        try {
            List<StandardResultDetailModel> standardResultDetailModelList = getStandardList(condition);
            return ListEnvelop.getSuccess("获取标准列表成功",standardResultDetailModelList);
        } catch (Exception e) {
            e.printStackTrace();
            return ListEnvelop.getError("获取标准列表失败");
        }
    }
    public List<StandardResultDetailModel> getStandardList(String condition) {
        String name = SqlConstants.EMPTY;
        Integer type = null;
        if (!StringUtil.isEmpty(condition)) {
            try {
                JsonNode jsonNode = objectMapper.readTree(condition);
                if (jsonNode.get("type") != null) {
                    type = jsonNode.get("type").asInt();
                }
                if (jsonNode.get("name") != null) {
                    name = jsonNode.get("name").asText();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        StandardParamResultModel standardParam = getStandardParam(SqlConstants.STANDARD);
        StandardParamResultModel standardParam1 = getStandardParam(SqlConstants.STANDARD_ORG);
        String code = standardParam.getCode();
        String orgCode = standardParam1.getCode();
        List<SystemOrganization> publisherModelList = new ArrayList<>();
        Criteria criteria = getCurrentSession().createCriteria(StandardModel.class);
        if (type == 0) {
            criteria.add(Restrictions.eq("code", code));
            String publisherHql = "FROM SystemOrganization WHERE code =:orgCode";
            Query query = getCurrentSession().createQuery(publisherHql);
            query.setParameter("orgCode", orgCode);
            publisherModelList = query.list();
        } else if (type == 1) {
            criteria.add(Restrictions.ne("code", code));
            String publisherHql = "FROM SystemOrganization";
            Query query = getCurrentSession().createQuery(publisherHql);
            publisherModelList = query.list();
        }
        List<StandardModel> standardModelList = criteria.list();
        Map<String, String> codeToIdMap = new HashMap<>();
        List<Integer> idList = new ArrayList<>();
        for (StandardModel standardModel : standardModelList) {
            idList.add(standardModel.getId());
        }
        List<StandardVersionModel> versionModelList = new ArrayList<>();
        if (!CollectionUtils.isEmpty(idList)) {
            String versionHql = "FROM StandardVersionModel WHERE standardId IN :idList";
            Query query = getCurrentSession().createQuery(versionHql);
            query.setParameterList("idList", idList);
            versionModelList = query.list();
        }
        List<StandardResultDetailModel> resultDetailModelList = getStandardListFormat(publisherModelList,
                standardModelList,
                versionModelList,
                codeToIdMap,
                name);
        return resultDetailModelList;
    }
    //TODO:TEST
    public StandardModel fork(Integer standardId) {
        try {
            ObjEnvelop objEnvelop = get(standardId);
            StandardModel baseStandard = (StandardModel) objEnvelop.getObj();
            StandardModel newStandard = new StandardModel(baseStandard);
            newStandard.setId(null);
            newStandard.setName(baseStandard.getName() + "-副本");
            newStandard.setCode(baseStandard.getCode() + "-副本");
            newStandard.setVersionStatus(0);
            saveEntity(newStandard);
            return newStandard;
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardForkFailed.getErrorCode());
    }
    public boolean existStandardVersionValid(Integer standardId) {
        String hql = "FROM StandardVersionModel WHERE standardId = :standardId";
        Query query = getCurrentSession().createQuery(hql);
        query.setParameter("standardId", standardId);
        List<StandardVersionModel> standardModelList = query.list();
        if (!CollectionUtils.isEmpty(standardModelList)) {
            return true;
        }
        return false;
    }
    private void update(StandardModel standardModel) throws Exception {
        updateEntity(standardModel);
    }
    private void add(StandardModel standardModel) throws Exception {
        saveEntity(standardModel);
    }
    private List<StandardModel> getList(Map<String, Object> query, Map<String, String> order, Integer limit, Integer offset) {
        Session session = getCurrentSession();
        Criteria criteria = session.createCriteria(StandardModel.class);
        if (query!=null) {
            for (String key : query.keySet()) {
                if (key.equals("type")) {
                    Integer type = (Integer) query.get(key);
                    String code = getStandardParam(SqlConstants.STANDARD).getCode();
                    if (type == 0) {
                        criteria.add(Restrictions.eq("code", code));
                    } else if (type == 1) {
                        criteria.add(Restrictions.ne("code", code));
                    }
                } else {
                    criteria.add(Restrictions.eq(key, query.get(key)));
                }
            }
        }
        if (limit != null) {
            criteria.setMaxResults(limit);
            if (offset != null) {
                criteria.setFirstResult((offset - 1) * limit);
            }
        }
        if (order != null) {
            for (String key : order.keySet()) {
                if (order.get(key).equals(SqlConstants.ASC)) {
                    criteria.addOrder(Order.asc(key));
                } else if (order.get(key).equals(SqlConstants.DESC)) {
                    criteria.addOrder(Order.desc(key));
                }
            }
        }
        return (List<StandardModel>) criteria.list();
    }
}

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

@@ -0,0 +1,551 @@
package com.yihu.jw.basic.standard.service.standard;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.jw.basic.standard.model.standard.*;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.basic.util.ExcelUtilBigData;
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.util.common.StringUtil;
import com.yihu.jw.util.sql.ErrorCode;
import com.yihu.jw.exception.ApiException;
import com.yihu.jw.basic.standard.model.DictItem;
import com.yihu.jw.util.sql.RequestParamTransformer;
import com.yihu.jw.basic.standard.model.adapter.AdapterSchemeModel;
import com.yihu.jw.basic.standard.service.bo.StandardVersion;
import com.yihu.jw.util.sql.SqlConstants;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
import java.util.*;
/**
 * @created Airhead 2015/12/25.
 */
@Service("StandardVersionService")
public class StandardVersionService extends SQLGeneralDAO {
    public static final String BEAN_ID = "StandardVersionService";
    @Autowired
    private ObjectMapper objectMapper;
    @Autowired
    private StdDatasetService stdDatasetService;
    @Autowired
    private StdMetadataService stdMetadataService;
    @Autowired
    private StdDictService stdDictService;
    @Autowired
    private StdDictEntryService stdDictEntryService;
    public ListEnvelop getDictionaryResult(Integer standardId, String condition, String order, Integer rows, Integer page) {
        try {
            List<DictItem> detailModelList = new ArrayList<>();
            List<StandardVersionModel> standardVersionModelList = getVersionList(standardId, condition, order, rows, page);
            for(StandardVersionModel standardVersionModel : standardVersionModelList){
                DictItem items = new DictItem();
                String id = standardVersionModel.getVersion();
                String name = standardVersionModel.getName();
                items.setCode(id.toString());
                items.setValue(name);
                detailModelList.add(items);
            }
            return ListEnvelop.getSuccess("获取标准版本成功",detailModelList);
        } catch (Exception e) {
            e.printStackTrace();
            return ListEnvelop.getError("获取标准版本失败");
        }
    }
    public ListEnvelop getDetailResultModelList(Integer standardId, String condition, String order, Integer rows, Integer page) {
        try {
            List<StandardVersionModel> standardVersionModelList = getVersionList(standardId, condition, order, rows, page);
            List<DictItem> detailModelList = new ArrayList<DictItem>();
            DictItem item = new DictItem();
            item.setCode("");
            item.setValue("-无-");
            detailModelList.add(item);
            for (StandardVersionModel standardVersionModel : standardVersionModelList) {
                DictItem items = new DictItem();
                String  id = standardVersionModel.getVersion();
                String name = standardVersionModel.getName();
                items.setCode(id.toString());
                items.setValue(name);
                detailModelList.add(items);
            }
            return ListEnvelop.getSuccess("获取标准版本列表成功",detailModelList);
        } catch (Exception e) {
            e.printStackTrace();
            return ListEnvelop.getError("获取标准版本列表失败");
        }
    }
    public List<StandardVersionModel> getVersionList(Integer standardId, String condition, String order, Integer limit, Integer offset) {
        try {
            Map queryMap = RequestParamTransformer.parseJsonToMap(condition);
            Map orderMap = RequestParamTransformer.parseJsonToMap(order);
            return this.getList(standardId, queryMap, orderMap, limit, offset);
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardVersionGetListFailed.getErrorCode());
    }
    @Transactional
    public ObjEnvelop add(String version) throws Exception {
        Boolean existFlg = false;
        try {
            StandardVersionModel versionModel = objectMapper.readValue(version, StandardVersionModel.class);
            existFlg = versionNameValidate(versionModel.getStandardId(), versionModel.getName());
            if (!existFlg) {
                this.add(versionModel);
                return ObjEnvelop.getSuccess("保存标准版本成功",versionModel);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (existFlg) {
            return ObjEnvelop.getError("已存在标准版本名称");
        } else {
            return ObjEnvelop.getError("保存标准版本失败");
        }
    }
    public Boolean versionNameValidate(Integer standardId, String versionName) {
            Map<String, Object> query = new HashMap<>();
            Map<String, String> order = new HashMap<>();
            query.put("name", versionName);
            List<StandardVersionModel> list = getList(standardId, query, order, 1, 0);
            if (!CollectionUtils.isEmpty(list)) {
                return true;
            }
            return false;
    }
    public Boolean versionNameValidate(Integer standardId, Integer versionId, String versionName) throws Exception {
        String sql = "FROM StandardVersionModel WHERE name = :name and standardId = :standardId and id != :versionId";
        Query query = getCurrentSession().createQuery(sql);
        query.setParameter("standardId", standardId);
        query.setParameter("name", versionName);
        query.setParameter("versionId", versionId);
        List<StandardVersionModel> list = query.list();
        if (!CollectionUtils.isEmpty(list)) {
            return true;
        }
        return false;
    }
    @Transactional
    public Envelop delete(Integer versionId, String version) throws Exception {
        Boolean existFlg = false;
        Boolean useredFlg = false;
        try {
            ObjEnvelop objEnvelop = get(versionId);
            StandardVersionModel versionModel = (StandardVersionModel) objEnvelop.getObj();
            if (versionModel.getPublishStatus() == 1) {
                existFlg = true;
            } else {
                String sql = "FROM AdapterSchemeModel WHERE stdVersion = :stdVersion or adapterStdVersion =  :adapterStdVersion";
                Query query = getCurrentSession().createQuery(sql);
                query.setParameter("stdVersion", version);
                query.setParameter("adapterStdVersion", version);
                List<AdapterSchemeModel> list = query.list();
                if (!CollectionUtils.isEmpty(list)) {
                    useredFlg = true;
                }else{
                    this.delete(versionModel);
                    deleteVersionTables(new StandardVersion(versionModel.getVersion()));
                    return Envelop.getSuccess("删除标准版本成功");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (existFlg) {
            return Envelop.getError("该标准版本已发布");
        } else if(useredFlg){
            return Envelop.getError("该标准版本已被适配使用");
        } else {
            return Envelop.getError("删除标准版本失败");
        }
    }
    @Transactional
    public ObjEnvelop update(String version) throws Exception {
        Boolean existFlg = false;
        try {
            StandardVersionModel versionModel = objectMapper.readValue(version, StandardVersionModel.class);
            existFlg = versionNameValidate(versionModel.getStandardId(), versionModel.getId(), versionModel.getName());
            if (!existFlg) {
                this.update(versionModel);
                return ObjEnvelop.getSuccess("修改标准版本成功",versionModel);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (existFlg) {
            return ObjEnvelop.getError("已存在标准版本名称");
        } else {
            return ObjEnvelop.getError("修改标准版本失败");
        }
    }
    public ObjEnvelop get(Integer versionId) {
        try {
            StandardVersionModel versionModel = this.myGet(versionId);
            return ObjEnvelop.getSuccess("获取标准版本信息成功",versionModel);
        } catch (DataAccessException e) {
            e.printStackTrace();
            return ObjEnvelop.getError("获取标准版本信息失败");
        }
    }
    public StandardVersionModel fork(Integer versionId) throws Exception {
        try {
            return this.myFork(versionId);
        } catch (DataAccessException | IOException e) {
            throw new ApiException(ErrorCode.StandardVersionForkFailed.getErrorCode());
        }
    }
    @Transactional
    public ObjEnvelop publish(Integer versionId, String publisher) throws Exception {
        try {
            StandardVersionModel standardVersionModel = this.myPublish(versionId, publisher);
            return ObjEnvelop.getSuccess("发布标准版本成功",standardVersionModel);
        } catch (DataAccessException e) {
            e.printStackTrace();
            return ObjEnvelop.getError("发布标准版本失败");
        }
    }
    public StandardVersionModel getLastestVersion(Integer standardId) {
        Map<String, Object> query = new HashMap<>();
        Map<String, String> order = new HashMap<>();
        order.put("publisher", SqlConstants.DESC);
        List<StandardVersionModel> list = getList(standardId, query, order, 1, 0);
        if (list != null && list.size() != 0) {
            return list.get(0);
        }
        return null;
    }
    public StandardVersionModel myPublish(Integer versionId, String publisher) throws Exception {
        StandardVersionModel standardVersionModel = myGet(versionId);
        //TODO:generate standard version file;
        String path = "";
        standardVersionModel.setPath(path);
        standardVersionModel.setPublishTime(new Date());
        standardVersionModel.setPublishUser(publisher);
        standardVersionModel.setPublishStatus(1);
        this.update(standardVersionModel);
        return standardVersionModel;
    }
    private StandardVersionModel myFork(Integer versionId) throws Exception {
        StandardVersionModel baseVersionModel = myGet(versionId);
        StandardVersionModel newVersionModel = new StandardVersionModel();
        newVersionModel.setBaseVersion(baseVersionModel.getVersion());
        newVersionModel.setName(baseVersionModel.getName() + " Copy");
        newVersionModel.setPrimaryVersion(baseVersionModel.getPrimaryVersion());
        newVersionModel.setPublishTime(new Date());
        this.add(newVersionModel);
        StandardVersion baseVersion = new StandardVersion(baseVersionModel.getVersion());
        StandardVersion newVersion = new StandardVersion(newVersionModel.getVersion());
        buildVersionTables(baseVersion, newVersion, baseVersionModel.getStandardId());
        return newVersionModel;
    }
    private StandardVersionModel myGet(Integer versionId) {
        try {
            return (StandardVersionModel) getEntity(StandardVersionModel.class, versionId);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    private void delete(StandardVersionModel standardVersionModel) throws Exception {
        deleteEntity(standardVersionModel);
    }
    private void update(StandardVersionModel standardVersionModel) throws Exception {
        try {
            updateEntity(standardVersionModel);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    @Transactional
    private void  add(StandardVersionModel standardVersionModel) throws Exception {
        StandardVersion standardVersion = StandardVersion.generateVersion();
        standardVersionModel.setVersion(standardVersion.getVersion());
        standardVersionModel.setPublishTime(null);
        standardVersionModel.setPublishStatus(0);
        saveEntity(standardVersionModel);
        String baseVer = standardVersionModel.getBaseVersion();
        StandardVersion baseVersion = StringUtil.isEmpty(baseVer) ? null : new StandardVersion(baseVer);
        StandardVersion newVersion = new StandardVersion(standardVersionModel.getVersion());
        buildVersionTables(baseVersion, newVersion, standardVersionModel.getStandardId());
    }
    private List<StandardVersionModel> getList(Integer standardId, Map<String, Object> query, Map<String, String> order, Integer limit, Integer offset) {
        Session session = getCurrentSession();
        Criteria criteria = session.createCriteria(StandardVersionModel.class);
        criteria.add(Restrictions.eq("standardId", standardId));
        if (query != null) {
            for (String key : query.keySet()) {
                criteria.add(Restrictions.eq(key, query.get(key)));
            }
        }
        if (limit != null) {
            criteria.setMaxResults(limit);
            if (offset != null) {
                criteria.setFirstResult((offset - 1) * limit);
            }
        }
        if (order != null) {
            for (String key : order.keySet()) {
                if (order.get(key).equals(SqlConstants.ASC)) {
                    criteria.addOrder(Order.asc(key));
                } else if (order.get(key).equals(SqlConstants.DESC)) {
                    criteria.addOrder(Order.desc(key));
                }
            }
        }
        return (List<StandardVersionModel>) criteria.list();
    }
    private void deleteVersionTables(StandardVersion version) {
        String[] tables = {version.getDataSetTableName(),
                version.getMetaDataTableName(),
                version.getDictTableName(),
                version.getDictEntryTableName()
                /*version.getCDATableName(),
               /* version.getCDADatasetTableName()*/};
        List<String> deleteSql = new ArrayList<>();
        for (int i = 0; i < tables.length; ++i) {
            String table = tables[i];
            deleteSql.add(SqlConstants.DROP_TABLE + table);
        }
        insertBatch(deleteSql);
    }
    private void buildVersionTables(StandardVersion baseVersion, StandardVersion newVersion, Integer standardId) {
        String[] newTables = {newVersion.getDataSetTableName(),
                newVersion.getMetaDataTableName(),
                newVersion.getDictTableName(),
                newVersion.getDictEntryTableName()
               /* newVersion.getCDATableName(),
                newVersion.getCDADatasetTableName()*/};
        String[] baseTables;
        if (baseVersion == null) {
            String[] templateTables = {StandardVersion.DataSetTable,
                    StandardVersion.MetaDataTable,
                    StandardVersion.DictTable,
                    StandardVersion.DictEntryTable
                   /* StandardVersion.CDADocumentTable,
                    StandardVersion.CDADatasetTable*/};
            baseTables = templateTables;
        } else {
            String[] templateTables = {baseVersion.getDataSetTableName(),
                    baseVersion.getMetaDataTableName(),
                    baseVersion.getDictTableName(),
                    baseVersion.getDictEntryTableName()
                    /*baseVersion.getCDATableName(),
                    baseVersion.getCDADatasetTableName()*/};
            baseTables = templateTables;
        }
        List<String> createSql = new ArrayList<>();
        List<String> insertSql = new ArrayList<>();
        List<String> updateSql = new ArrayList<>();
        for (int i = 0; i < baseTables.length; ++i) {
            String baseTable = baseTables[i];
            String newTable = newTables[i];
            createSql.add(SqlConstants.CREATE_TABLE + newTable + SqlConstants.LIKE + baseTable);
        }
        for (int i = 0; i < baseTables.length; ++i) {
            String baseTable = baseTables[i];
            String newTable = newTables[i];
            insertSql.add(SqlConstants.INSERT_INTO + newTable + SqlConstants.SELECT + SqlConstants.ASTERISK + SqlConstants.FROM + baseTable);
        }
        for (int i = 0; i < baseTables.length; ++i) {
            String newTable = newTables[i];
            updateSql.add(SqlConstants.UPDATE + newTable + SqlConstants.SET + " STD_ID = " + standardId);
        }
        insertBatch(createSql);
        insertBatch(insertSql);
        insertBatch(updateSql);
    }
    @Transactional
    public String saveDatasetExcel(MultipartFile file, String version,Integer standardId) throws Exception {
        List<List<String[]>> list = ExcelUtilBigData.readerExcel(file.getInputStream(), 13, 0);//String[] 存放一行,List<String[]> 代表一个excel表格
        for (int i = 0; i < list.size(); i++) {
            List<String[]> l = list.get(i);
            //遍历sheet
            //新增数据集
            StandardVersion standardVersion = new StandardVersion(version);
            StdDataSetModel stdeDataset = new StdDataSetModel();
            stdeDataset.setName(getNotNull(l.get(0)[1]));
            stdeDataset.setCode(getNotNull(l.get(1)[1]));
            stdeDataset.setSummary(getNotNull(l.get(3)[1]));
            stdeDataset.setLanguage(getNotNull(l.get(4)[1]));
            stdeDataset.setClassModel(getNotNull(l.get(5)[1]));
            stdeDataset.setstandardId(standardId);
            stdeDataset.setCatalog(0);
//            if(org.apache.commons.lang3.StringUtils.isNotBlank(getNotNull(l.get(2)[1]))){
//                stdeDataset.setCatalog(Integer.valueOf(getNotNull(l.get(2)[1])));
//            }
            stdDatasetService.add(standardVersion.getDataSetTableName(), stdeDataset);
            for (int row = 7; row < l.size(); row++) {
                //保存数据元
                StdMetaDataModel stdeMetadata = new StdMetaDataModel();
                stdeMetadata.setDatasetId(stdeDataset.getId());//肯定要设置
                stdeMetadata.setStandardId(standardId);
                stdeMetadata.setDeCode(getNotNull(l.get(row)[1]));
                stdeMetadata.setCode(getNotNull(l.get(row)[2]));
                stdeMetadata.setName(getNotNull(l.get(row)[3]));
                stdeMetadata.setDefinition(getNotNull(l.get(row)[4]));
                stdeMetadata.setType(getNotNull(l.get(row)[5]));
                stdeMetadata.setFormat(getNotNull(l.get(row)[6]));
                String dicId = getNotNull(l.get(row)[7]);
                if(org.apache.commons.lang3.StringUtils.isNotBlank(dicId)){
                    stdeMetadata.setDictId(Integer.valueOf(dicId));
                }
                stdeMetadata.setColumnName(getNotNull(l.get(row)[8]));
                stdeMetadata.setColumnType(getNotNull(l.get(row)[9]));
                stdeMetadata.setColumnLength(getNotNull(l.get(row)[10]));
                String isPrimaryKey = getNotNull(l.get(row)[11]);
                if(org.apache.commons.lang3.StringUtils.isNotBlank(isPrimaryKey)){
                    stdeMetadata.setPrimaryKey(Integer.valueOf(isPrimaryKey));
                }
                String isNullable = getNotNull(l.get(row)[12]);
                if(org.apache.commons.lang3.StringUtils.isNotBlank(isNullable)){
                    stdeMetadata.setNullable(Integer.valueOf(isNullable));
                }
                if(org.apache.commons.lang3.StringUtils.isBlank(stdeMetadata.getCode())){
                    continue;
                }
                stdMetadataService.add(standardVersion, stdeMetadata);
            }
        }
        return version;
    }
    @Transactional
    public String saveDictExcel(MultipartFile file, String version,Integer standardId) throws Exception {
        List<List<String[]>> list = ExcelUtilBigData.readerExcel(file.getInputStream(), 5, 3);
        list.stream().filter(medatas-> getNotNull(medatas.get(0)[1]).contains("ICD-10-CM")).forEach(medata->{
            System.out.println(list.indexOf(medata));
        });
        StandardVersion standardVersion = new StandardVersion(version);
        for (int i = 0; i < list.size(); i++) {
            List<String[]> l = list.get(i);
            //遍历sheet
            StdDictionaryModel stdeDict = new StdDictionaryModel();
            stdeDict.setstandardId(standardId);
            stdeDict.setCode(getNotNull(l.get(0)[1]));
            stdeDict.setName(getNotNull(l.get(1)[1]));
//            stdeDict.setDefine(getNotNull(l.get(2)[1]));
//            stdeDict.setDescription(getNotNull(l.get(3)[1]));
//            String parentId = getNotNull(l.get(4)[1]);
//            if(!StringUtils.isEmpty(parentId)){
//                stdeDict.setParentId(Integer.valueOf(parentId));
//            }
            stdDictService.add(standardVersion,stdeDict);
            for (int row = 0; row < l.size(); row++) {
                if (StringUtils.isEmpty(l.get(row)[4])) {
                    continue;
                }
                StdDictionaryEntryModel stdeDictItem = new StdDictionaryEntryModel();
                stdeDictItem.setstandardId(standardId);
                stdeDictItem.setDictId(stdeDict.getId());
                stdeDictItem.setValue(getNotNull(l.get(row)[4]));
                stdeDictItem.setCode(getNotNull(l.get(row)[3]));
                System.out.println("第"+(i+1)+"个表格;第"+(row+1)+"行数据");
                stdDictEntryService.add(standardVersion,stdeDictItem);
            }
        }
        return version;
    }
    private String getNotNull(Object obj) {
        if (!StringUtils.isEmpty(obj)) {
            return obj.toString().replace("\"", "");
        }
        return "";
    }
    public String isUpdateDatasetAndDict(String version) {
        JSONObject jo=new JSONObject();
        List<StdDataSetModel> stdDataSetModels = stdDatasetService.getList(version, null, null, null, null);
        if(stdDataSetModels!=null&&stdDataSetModels.size()>0){
            jo.put("datasetUpdate","true");
        }else{
            jo.put("datasetUpdate","false");
        }
        List<StdDictionaryModel> stdDictionaryModels = stdDictService.getList(version, null, null, null, null);
        if(stdDictionaryModels!=null&&stdDictionaryModels.size()>0){
            jo.put("dictUpdate","true");
        }else{
            jo.put("dictUpdate","false");
        }
        return jo.toString();
    }
    @Transactional
    public void deleteDataset(String version) throws Exception {
        Session session = getCurrentSession();
        //删除数据集
        String sql1 = "truncate table std_dataset_" + version;
        session.createSQLQuery(sql1).executeUpdate();
        //删除数据元
        String sql = "truncate table std_metadata_" + version;
        session.createSQLQuery(sql).executeUpdate();
    }
    public void deleteDict(String version) {
        Session session = getCurrentSession();
        //删除字典
        String sql1 = "truncate table std_dictionary_" + version;
        session.createSQLQuery(sql1).executeUpdate();
        //删除字典项
        String sql = "truncate table std_dictionary_entry_" + version;
        session.createSQLQuery(sql).executeUpdate();
    }
}

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

@@ -0,0 +1,131 @@
package com.yihu.jw.basic.standard.service.standard;
import com.yihu.jw.basic.standard.model.standard.StandardModel;
import com.yihu.jw.basic.standard.model.standard.StdCDACatalogModel;
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.RequestParamTransformer;
import com.yihu.jw.util.sql.SqlConstants;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import java.util.Map;
/**
 * @author AndyCai
 * @version 1.0
 * @created 11-12月-2015 15:53:02
 */
@Transactional
@Service("StdCDACatalogService")
public class StdCDACatalogService extends SQLGeneralDAO {
    public static final String BEAN_ID = "StdCDACatalogService";
    public StdCDACatalogService() {
    }
    public void finalize() throws Throwable {
    }
    public List<StdCDACatalogModel> getList(String condition, String order, Integer limit, Integer offset) {
        try {
            Map queryMap = RequestParamTransformer.parseJsonToMap(condition);
            Map orderMap = RequestParamTransformer.parseJsonToMap(order);
            return this.getList(queryMap, orderMap, limit, offset);
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardCDACatalogGetListFailed.getErrorCode());
    }
    public Object add(String catalog) {
        try {
            StdCDACatalogModel standardModel = objectMapper.readValue(catalog, StdCDACatalogModel.class);
            this.add(standardModel);
            return standardModel.getId();
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardCDACatalogSaveFailed.getErrorCode());
    }
    public void delete(Integer catalogId) throws Exception {
        try {
            if (catalogId != null) {
                StdCDACatalogModel stdCdaCatalogModel = get(catalogId);
                deleteEntity(stdCdaCatalogModel);
            }
        } catch (Exception e) {
            throw new ApiException(ErrorCode.StandardCDACatalogDeleteFailed.getErrorCode());
        }
    }
    public Object update(String catalog) {
        try {
            StdCDACatalogModel standardModel = objectMapper.readValue(catalog, StdCDACatalogModel.class);
            this.update(standardModel);
            return standardModel;
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardCDACatalogUpdateFailed.getErrorCode());
    }
    public StdCDACatalogModel get(Integer catalogId) {
        try {
            return getEntity(StdCDACatalogModel.class, catalogId);
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardCDACatalogGetFailed.getErrorCode());
    }
    private void update(StdCDACatalogModel stdCDACatalogModel) throws Exception {
        updateEntity(stdCDACatalogModel);
    }
    private void add(StdCDACatalogModel stdCDACatalogModel) throws Exception {
        saveEntity(stdCDACatalogModel);
    }
    private List<StdCDACatalogModel> getList(Map<String, Object> query, Map<String, String> order, Integer limit, Integer offset) {
        Session session = getCurrentSession();
        Criteria criteria = session.createCriteria(StandardModel.class);
        for (String key : query.keySet()) {
            criteria.add(Restrictions.eq(key, query.get(key)));
        }
        if (limit != null) {
            criteria.setMaxResults(limit);
            if (offset != null) {
                criteria.setFirstResult((offset - 1) * limit);
            }
        }
        if (order != null) {
            for (String key : order.keySet()) {
                if (order.get(key).equals(SqlConstants.ASC)) {
                    criteria.addOrder(Order.asc(key));
                } else if (order.get(key).equals(SqlConstants.DESC)) {
                    criteria.addOrder(Order.desc(key));
                }
            }
        }
        return (List<StdCDACatalogModel>) criteria.list();
    }
}

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

@@ -0,0 +1,199 @@
package com.yihu.jw.basic.standard.service.standard;
import com.yihu.jw.basic.standard.model.standard.StdCDADatasetModel;
import com.yihu.jw.basic.standard.service.bo.StandardVersion;
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.RequestParamTransformer;
import com.yihu.jw.util.sql.SqlCreator;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.io.IOException;
import java.util.List;
import java.util.Map;
/**
 * @author AndyCai
 * @version 1.0
 * @created 02-9月-2015 14:00:55
 */
@Transactional
@Service("StdCDADatasetService")
public class StdCDADatasetService extends SQLGeneralDAO {
    public static final String BEAN_ID = "StdCDADatasetService";
    public StdCDADatasetService() {
    }
    public void finalize() throws Throwable {
    }
    public List<StdCDADatasetModel> getList(String stdVersion, String condition, String order, Integer limit, Integer offset) {
        try {
            Map queryMap = RequestParamTransformer.parseJsonToMap(condition);
            Map orderMap = RequestParamTransformer.parseJsonToMap(order);
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            return this.getList(standardVersion, queryMap, orderMap, limit, offset);
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardCDADatasetGetListFailed.getErrorCode());
    }
    public StdCDADatasetModel add(String stdVersion, String cdaDataset) {
        if (stdVersion.equals("{stdVersion}")) {
            throw new ApiException(ErrorCode.StandardCDADatasetMissVersion.getErrorCode());
        }
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            StdCDADatasetModel stdCdaDatasetModel = objectMapper.readValue(cdaDataset, StdCDADatasetModel.class);
            this.add(standardVersion, stdCdaDatasetModel);
            return stdCdaDatasetModel;
        } catch (IOException e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardCDADatasetSaveFailed.getErrorCode());
    }
    public void delete(String stdVersion, Integer cdadatasetId) {
        if (StringUtil.isEmpty(stdVersion)) {
            throw new ApiException(ErrorCode.StandardCDADatasetMissVersion.getErrorCode());
        }
        if (cdadatasetId == null) {
            throw new ApiException(ErrorCode.StandardCDADatasetMissID.getErrorCode());
        }
        try {
            if (cdadatasetId != null) {
                StandardVersion standardVersion = new StandardVersion(stdVersion);
                Session session = getCurrentSession();
                String sql = "delete from " + standardVersion.getCDADatasetTableName() + " where id = :id";
                Query query = session.createSQLQuery(sql);
                query.setInteger("id", cdadatasetId);
                query.executeUpdate();
            }
        } catch (Exception e) {
            throw new ApiException(ErrorCode.StandardCDADatasetDeleteFailed.getErrorCode());
        }
    }
    public StdCDADatasetModel update(String stdVersion, String cdaDataset) {
        if (stdVersion.equals("{stdVersion}")) {
            throw new ApiException(ErrorCode.StandardCDADatasetMissVersion.getErrorCode());
        }
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            StdCDADatasetModel stdCdaDatasetModel = objectMapper.readValue(cdaDataset, StdCDADatasetModel.class);
            this.modify(standardVersion, stdCdaDatasetModel);
            return stdCdaDatasetModel;
        } catch (IOException e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardCDADatasetUpdateFailed.getErrorCode());
    }
    public StdCDADatasetModel get(String stdVersion, Integer cdadatasetId) {
        if (StringUtil.isEmpty(stdVersion)) {
            throw new ApiException(ErrorCode.StandardCDADatasetMissVersion.getErrorCode());
        }
        if (cdadatasetId == null) {
            throw new ApiException(ErrorCode.StandardCDADatasetMissID.getErrorCode());
        }
        try {
            if (cdadatasetId != null) {
                StandardVersion standardVersion = new StandardVersion(stdVersion);
                Session session = getCurrentSession();
                String cdaDatasetTableName = standardVersion.getCDADatasetTableName();
                String sql = "select id, cda_id, dataset_id from " + cdaDatasetTableName + " where id = :id";
                Query query = session.createSQLQuery(sql);
                query.setInteger("id", cdadatasetId);
                query.setResultTransformer(new BeanTransformer<>(StdCDADatasetModel.class));
                return (StdCDADatasetModel) query.uniqueResult();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardCDADatasetGetFailed.getErrorCode());
    }
    private void modify(StandardVersion standardVersion, StdCDADatasetModel stdCdaDatasetModel) {
        Session session = getCurrentSession();
        String cdaDatasetTableName = standardVersion.getCDADatasetTableName();
        String sql = "update " + cdaDatasetTableName +
                "set " +
                "id = :id, " +
                "cda_id = :cda_id, " +
                "dataset_id = :dataset_id " +
                "where id = :id";
        Query query = session.createSQLQuery(sql);
        query.setInteger("id", stdCdaDatasetModel.getId());
        query.setInteger("cda_id", stdCdaDatasetModel.getCdaID());
        query.setInteger("dataset_id", stdCdaDatasetModel.getdatasetId());
        query.executeUpdate();
    }
    private void add(StandardVersion standardVersion, StdCDADatasetModel stdCdaDatasetModel) {
        Session session = getCurrentSession();
        String cdaDatasetTableName = standardVersion.getCDADatasetTableName();
        String sql = "select max(id) from " + cdaDatasetTableName;
        Query query = session.createSQLQuery(sql);
        Object object = query.uniqueResult();
        stdCdaDatasetModel.setId(object == null ? 1 : Integer.parseInt(object.toString()) + 1);
        sql = "insert into " + cdaDatasetTableName + "(id, cda_id, dataset_id)"
                + "VALUES (:id, :cda_id, :dataset_id)";
        query = session.createSQLQuery(sql);
        query.setInteger("id", stdCdaDatasetModel.getId());
        query.setInteger("cda_id", stdCdaDatasetModel.getCdaID());
        query.setInteger("dataset_id", stdCdaDatasetModel.getdatasetId());
        query.executeUpdate();
    }
    private List<StdCDADatasetModel> getList(StandardVersion standardVersion, Map<String, Object> query, Map<String, String> order, Integer limit, Integer offset) {
        SqlCreator sqlCreator = new SqlCreator(StdCDADatasetModel.class);
        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.getCDADatasetTableName());
        Query sessionQuery = getQuery(sqlCreator, sql);
        if (limit != null) {
            sessionQuery.setMaxResults(limit);
            if (offset != null) {
                sessionQuery.setFirstResult((offset - 1) * limit);
            }
        }
        return (List<StdCDADatasetModel>) sessionQuery.list();
    }
}//end CDADatasetRelationshipManager

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

@@ -0,0 +1,173 @@
package com.yihu.jw.basic.standard.service.standard;
import com.fasterxml.jackson.databind.JsonNode;
import com.yihu.jw.basic.standard.model.standard.StdCDAModel;
import com.yihu.jw.basic.standard.service.bo.StandardVersion;
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.RequestParamTransformer;
import com.yihu.jw.util.sql.SqlCreator;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.io.IOException;
import java.util.List;
import java.util.Map;
/**
 * @author AndyCai
 * @version 1.0
 * @created 01-9月-2015 17:17:50
 */
@Transactional
@Service("StdCDAService")
public class StdCDAService extends SQLGeneralDAO {
    public static final String BEAN_ID = "StdCDAService";
    public StdCDAService() {
    }
    public List<StdCDAModel> getList(String stdVersion, String condition, String order, Integer limit, Integer offset) {
        try {
            Map queryMap = RequestParamTransformer.parseJsonToMap(condition);
            Map orderMap = RequestParamTransformer.parseJsonToMap(order);
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            return this.getList(standardVersion, queryMap, orderMap, limit, offset);
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardCDAGetListFailed.getErrorCode());
    }
    public Object add(String stdVersion, String cda) {
        if (stdVersion.equals("{stdVersion}")) {
            throw new ApiException(ErrorCode.StandardCDAMissVersion.getErrorCode());
        }
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            StdCDAModel stdCdaModel = objectMapper.readValue(cda, StdCDAModel.class);
            this.add(standardVersion, stdCdaModel);
            return stdCdaModel.getId();
        } catch (IOException e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardCDASaveFailed.getErrorCode());
    }
    public void delete(String stdVersion, Integer cdaId) {
        if (StringUtil.isEmpty(stdVersion)) {
            throw new ApiException(ErrorCode.StandardCDAMissVersion.getErrorCode());
        }
        try {
            if (cdaId != null) {
                StandardVersion standardVersion = new StandardVersion(stdVersion);
                Session session = getCurrentSession();
                String sql = "delete from " + standardVersion.getCDATableName() + " where id = :id";
                Query query = session.createSQLQuery(sql);
                query.setInteger("id", cdaId);
                query.executeUpdate();
            }
        } catch (Exception e) {
            throw new ApiException(ErrorCode.StandardCDADeleteFailed.getErrorCode());
        }
    }
    public Object update(String stdVersion, String cda) {
        if (stdVersion.equals("{stdVersion}")) {
            throw new ApiException(ErrorCode.StandardCDAMissVersion.getErrorCode());
        }
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            StdCDAModel stdCdaModel = objectMapper.readValue(cda, StdCDAModel.class);
            this.modify(standardVersion, stdCdaModel);
            return stdCdaModel;
        } catch (IOException e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardCDAUpdateFailed.getErrorCode());
    }
    public StdCDAModel get(String stdVersion, Integer cdaId) {
        if (stdVersion.equals("{stdVersion}")) {
            throw new ApiException(ErrorCode.StandardCDAMissVersion.getErrorCode());
        }
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            return this.get(standardVersion, cdaId);
        } catch (Exception e) {
        }
        throw new ApiException(ErrorCode.StandardCDAGetFailed.getErrorCode());
    }
    private StdCDAModel get(StandardVersion standardVersion, Integer cdaId) {
        Session session = getCurrentSession();
        String cdaTableName = standardVersion.getCDATableName();
        String sql = "select id, std_id, code, name, path, description, catalog_id from " + cdaTableName + " where id = :id";
        Query query = session.createSQLQuery(sql);
        query.setInteger("id", cdaId);
        query.setResultTransformer(new BeanTransformer<>(StdCDAModel.class));
        return (StdCDAModel) query.uniqueResult();
    }
    private void modify(StandardVersion standardVersion, StdCDAModel stdCdaModel) throws IOException {
        String cdaTableName = standardVersion.getCDATableName();
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(stdCdaModel));
        SqlCreator sqlCreator = new SqlCreator(StdCDAModel.class);
        String sql = sqlCreator.updateDataByTableKey(cdaTableName, jsonNode);
        Query query = getExeuteQuery(sqlCreator, sql);
        query.executeUpdate();
    }
    private void add(StandardVersion standardVersion, StdCDAModel stdCdaModel) throws IOException {
        String cdaTableName = standardVersion.getCDATableName();
        Session session = getCurrentSession();
        String sql = "select max(id) from " + cdaTableName;
        Query query = session.createSQLQuery(sql);
        Object object = query.uniqueResult();
        stdCdaModel.setId(object == null ? 1 : Integer.parseInt(object.toString()) + 1);
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(stdCdaModel));
        SqlCreator sqlCreator = new SqlCreator(StdCDAModel.class);
        sql = sqlCreator.insertData(cdaTableName, jsonNode);
        query = getExeuteQuery(sqlCreator, sql);
        query.executeUpdate();
    }
    private List<StdCDAModel> getList(StandardVersion standardVersion, Map<String, Object> query,  Map<String, String> order, Integer limit, Integer offset) {
        SqlCreator sqlCreator = new SqlCreator(StdCDAModel.class);
        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.getCDATableName());
        Query sessionQuery = getQuery(sqlCreator, sql);
        if (limit != null) {
            sessionQuery.setMaxResults(limit);
            if (offset != null) {
                sessionQuery.setFirstResult((offset - 1) * limit);
            }
        }
        return (List<StdCDAModel>) sessionQuery.list();
    }
}//end CDADocumentManager

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

@@ -0,0 +1,144 @@
package com.yihu.jw.basic.standard.service.standard;
import com.fasterxml.jackson.databind.JsonNode;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.util.sql.ErrorCode;
import com.yihu.jw.exception.ApiException;
import com.yihu.jw.util.sql.RequestParamTransformer;
import com.yihu.jw.util.sql.SqlCreator;
import com.yihu.jw.basic.standard.model.standard.StdDatasetCatalogModel;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.io.IOException;
import java.util.List;
import java.util.Map;
/**
 * @created Airhead 2015/12/28.
 */
@Transactional
@Service("StdDatasetCatalogService")
public class StdDatasetCatalogService extends SQLGeneralDAO {
    public static final String BEAN_ID = "StdDatasetCatalogService";
    public StdDatasetCatalogService() {
    }
    public void finalize() throws Throwable {
    }
    public List<StdDatasetCatalogModel> getList(String condition, String order, Integer limit, Integer offset) {
        try {
            Map queryMap = RequestParamTransformer.parseJsonToMap(condition);
            Map orderMap = RequestParamTransformer.parseJsonToMap(order);
            return this.getList(queryMap, orderMap, limit, offset);
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardDatasetCatalogGetListFailed.getErrorCode());
    }
    public Object add(String catalog) throws Exception {
        try {
            StdDatasetCatalogModel stdDatasetCatalogModel = objectMapper.readValue(catalog, StdDatasetCatalogModel.class);
            this.add(stdDatasetCatalogModel);
            return stdDatasetCatalogModel.getId();
        } catch (IOException e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardDatasetCatalogSaveFailed.getErrorCode());
    }
    public void delete(Integer catalogId) throws Exception {
        try {
            if (catalogId != null) {
                StdDatasetCatalogModel cdaCatalogModel = get(catalogId);
                deleteEntity(cdaCatalogModel);
            }
        } catch (DataAccessException e) {
            throw new ApiException(ErrorCode.StandardDatasetCatalogDeleteFailed.getErrorCode());
        }
    }
    public Object update(String catalog) throws Exception {
        try {
            StdDatasetCatalogModel stdDatasetCatalogModel = objectMapper.readValue(catalog, StdDatasetCatalogModel.class);
            this.modify(stdDatasetCatalogModel);
            return stdDatasetCatalogModel;
        } catch (IOException e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardDatasetCatalogUpdateFailed.getErrorCode());
    }
    public StdDatasetCatalogModel get(Integer catalogId) {
        if (catalogId == null) {
            throw new ApiException(ErrorCode.StandardDatasetCatalogMissID.getErrorCode());
        }
        
        try {
            if (catalogId != null) {
                Session session = getCurrentSession();
                String hql = "FROM StdDatasetCatalogModel where id = ?";
                Query query = session.createQuery(hql);
                query.setParameter(0, catalogId);
                return (StdDatasetCatalogModel) query.uniqueResult();
            }
        } catch (DataAccessException e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardDatasetCatalogGetFailed.getErrorCode());
    }
    private void modify(StdDatasetCatalogModel stdDatasetCatalogModel)  throws Exception {
        updateEntity(stdDatasetCatalogModel);
    }
    private void add(StdDatasetCatalogModel stdDatasetCatalogModel)  throws Exception {
        Session session = getCurrentSession();
        String sql = "select max(id) from " + StdDatasetCatalogModel.TABLE_NAME;
        Query query = session.createSQLQuery(sql);
        Object object = query.uniqueResult();
        stdDatasetCatalogModel.setId(object == null ? 1 : Integer.parseInt(object.toString()) + 1);
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(stdDatasetCatalogModel));
        SqlCreator sqlCreator = new SqlCreator(StdDatasetCatalogModel.class);
        sql = sqlCreator.insertData(StdDatasetCatalogModel.TABLE_NAME, jsonNode);
        query = getExeuteQuery(sqlCreator, sql);
        query.executeUpdate();
    }
    private List<StdDatasetCatalogModel> getList(Map<String, Object> query, Map<String, String> order, Integer limit, Integer offset) {
        SqlCreator sqlCreator = new SqlCreator(StdDatasetCatalogModel.class);
        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(StdDatasetCatalogModel.TABLE_NAME);
        Query sessionQuery = getQuery(sqlCreator, sql);
        if (limit != null) {
            sessionQuery.setMaxResults(limit);
            if (offset != null) {
                sessionQuery.setFirstResult((offset - 1) * limit);
            }
        }
        return (List<StdDatasetCatalogModel>) sessionQuery.list();
    }
}

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

@@ -0,0 +1,584 @@
package com.yihu.jw.basic.standard.service.standard;
import com.fasterxml.jackson.databind.JsonNode;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.restmodel.web.Envelop;
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.*;
import com.yihu.jw.exception.ApiException;
import com.yihu.jw.basic.standard.model.Select2;
import com.yihu.jw.basic.standard.model.standard.*;
import com.yihu.jw.basic.standard.model.standard.resultModel.StandardParamResultModel;
import com.yihu.jw.basic.standard.service.bo.StandardVersion;
import jxl.Sheet;
import jxl.Workbook;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.criterion.Restrictions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;
import java.util.stream.Collectors;
/**
 * 数据集管理器.
 *
 * @author Sand
 * @version 1.0
 * @created 30-6月-2015 16:19:05
 */
@Transactional
@Service("StdDatasetService")
public class StdDatasetService extends SQLGeneralDAO {
    public static final String BEAN_ID = "StdDatasetService";
    @Autowired
    StandardService standardService;
    public StdDatasetService() {
    }
    public void finalize() throws Throwable {
        super.finalize();
    }
    public List<StdDataSetModel> getList(String stdVersion, String condition, String order, Integer limit, Integer offset) {
        try {
            Map queryMap = RequestParamTransformer.parseJsonToMap(condition);
            Map orderMap = RequestParamTransformer.parseJsonToMap(order);
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            return this.getList(standardVersion, queryMap, orderMap, limit, offset);
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardDatasetGetListFailed.getErrorCode());
    }
    public ObjEnvelop add(String stdVersion, String dataset) {
        if (StringUtil.isEmpty(stdVersion)) {
            return ObjEnvelop.getError("并无该标准版本");
        }
        Boolean existFlg = false;
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            StdDataSetModel stdDataSetModel = objectMapper.readValue(dataset, StdDataSetModel.class);
            existFlg = datasetCodeValidate(standardVersion, stdDataSetModel.getCode());
            if (!existFlg) {
                this.add(standardVersion.getDataSetTableName(), stdDataSetModel);
                return ObjEnvelop.getSuccess("保存数据集成功",stdDataSetModel);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (existFlg) {
            return ObjEnvelop.getError("已存在标准数据集编码");
        } else {
            return ObjEnvelop.getError("保存数据集失败");
        }
    }
    public Boolean datasetCodeValidate(StandardVersion standardVersion, String code) {
        Map<String, Object> query = new HashMap<>();
        Map<String, String> order = new HashMap<>();
        query.put("code", code);
        List<StdDataSetModel> list = this.getList(standardVersion, query, order, 1, 1);
        if (!CollectionUtils.isEmpty(list)) {
            return true;
        }
        return false;
    }
    public Envelop delete(String stdVersion, Integer datasetId) {
        if (StringUtil.isEmpty(stdVersion)) {
            return Envelop.getError("并无该标准版本");
        }
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            if (datasetId != null) {
                this.delete(standardVersion, datasetId);
            }
            return Envelop.getSuccess("删除数据集成功");
        } catch (Exception e) {
            e.printStackTrace();
            return Envelop.getError("删除数据集失败");
        }
    }
    public Boolean datasetCodeValidate(StandardVersion standardVersion, Integer datasetId,  String code) {
        SqlCreator sqlCreator = new SqlCreator(StdDataSetModel.class);
        sqlCreator.equalCondition("code", code);
        sqlCreator.neCondition("id", datasetId);
        String sql = sqlCreator.selectData(standardVersion.getDataSetTableName());
        Query sessionQuery = getQuery(sqlCreator, sql);
        List<StdDataSetModel> list = sessionQuery.list();
        if (!CollectionUtils.isEmpty(list)) {
            return true;
        }
        return false;
    }
    public ObjEnvelop update(String stdVersion, String dataset) {
        if (StringUtil.isEmpty(stdVersion)) {
            return ObjEnvelop.getError("并无该标准版本");
        }
        Boolean existFlg = false;
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            StdDataSetModel stdDataSetModel = objectMapper.readValue(dataset, StdDataSetModel.class);
            existFlg = datasetCodeValidate(standardVersion, stdDataSetModel.getId(), stdDataSetModel.getCode());
            if (!existFlg) {
                this.update(standardVersion, stdDataSetModel);
                return ObjEnvelop.getSuccess("修改数据集成功",stdDataSetModel);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (existFlg) {
            return ObjEnvelop.getError("已存在标准数据集编码");
        } else {
            return ObjEnvelop.getError("修改数据集失败");
        }
    }
    public ObjEnvelop get(String stdVersion, Integer datasetId) {
        if (StringUtil.isEmpty(stdVersion)) {
            return ObjEnvelop.getError("并无该数据集信息");
        }
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            if (datasetId != null) {
                StdDataSetModel stdDataSetModel = this.get(standardVersion, datasetId);
                return ObjEnvelop.getSuccess("获取标准数据集成功",stdDataSetModel);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ObjEnvelop.getError("获取标准数据集失败");
    }
    private StdDataSetModel get(StandardVersion standardVersion, Integer datasetId) {
        String dataSetTable = standardVersion.getDataSetTableName();
        SqlCreator sqlCreator = new SqlCreator(StdDataSetModel.class);
        sqlCreator.equalCondition("id", datasetId);
        String sql = sqlCreator.selectData(dataSetTable);
        Query query = getQuery(sqlCreator, sql);
        return (StdDataSetModel) query.uniqueResult();
    }
    private void update(StandardVersion standardVersion, StdDataSetModel stdDataSetModel) throws IOException {
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(stdDataSetModel));
        SqlCreator sqlCreator = new SqlCreator(StdDataSetModel.class);
        String dataSetTable = standardVersion.getDataSetTableName();
        String sql = sqlCreator.updateDataByTableKey(dataSetTable, jsonNode);
        Query query = getExeuteQuery(sqlCreator, sql);
        query.executeUpdate();
    }
    private void delete(StandardVersion standardVersion, Integer datasetId) {
        Session session = getCurrentSession();
        String sql = "delete from " + standardVersion.getDataSetTableName() + " where id = :id";
        Query query = session.createSQLQuery(sql);
        query.setInteger("id", datasetId);
        query.executeUpdate();
        sql = "delete from " + standardVersion.getMetaDataTableName() + " where dataset_id = :datasetId";
        query = session.createSQLQuery(sql);
        query.setInteger("datasetId", datasetId);
        query.executeUpdate();
    }
    public void add(String dataSetTable, StdDataSetModel stdDataSetModel) throws IOException {
        stdDataSetModel.setId(getMaxId(dataSetTable));
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(stdDataSetModel));
        SqlCreator sqlCreator = new SqlCreator(StdDataSetModel.class);
        String sql = sqlCreator.insertData(dataSetTable, jsonNode);
        Query query = getExeuteQuery(sqlCreator, sql);
        query.executeUpdate();
    }
    private List<StdDataSetModel> getList(StandardVersion standardVersion, Map<String, Object> query, Map<String, String> order, Integer limit, Integer offset) {
        SqlCreator sqlCreator = new SqlCreator(StdDataSetModel.class);
        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.getDataSetTableName());
        Query sessionQuery = getQuery(sqlCreator, sql);
        if (limit != null) {
            sessionQuery.setMaxResults(limit);
            if (offset != null) {
                sessionQuery.setFirstResult((offset - 1) * limit);
            }
        }
        return (List<StdDataSetModel>) sessionQuery.list();
    }
    public PageEnvelop getDetailModelList(String stdVersion, String condition, String order, Integer rows, Integer page) {
        try {
            List<StdDataSetModel> dataSetModelList = getDatasetList(StdDataSetModel.class, stdVersion, condition, order, rows, page);
            List<StdDataSetModel> totalList = getDatasetList(StdDataSetModel.class, stdVersion, condition, order, null, null);
            Integer count = totalList.size();
//            Integer count = getDatasetInt(StdDataSetModel.class, stdVersion, condition);
            PageEnvelop result = PageEnvelop.getSuccess("获取标准数据集列表成功");
            result.setDetailModelList(dataSetModelList);
            result.setTotalCount(count);
            return result;
        } catch (Exception e) {
            e.printStackTrace();
            return PageEnvelop.getError("获取标准数据集列表失败");
        }
    }
    public List getDatasetList(Class tClass, String stdVersion, String condition, String order, Integer limit, Integer offset) throws IOException {
        StandardVersion standardVersion = new StandardVersion(stdVersion);
        String tableName = standardVersion.getDataSetTableName();
        SqlCreator sqlCreator = new SqlCreator(tClass);
        if (!StringUtil.isEmpty(condition)) {
            JsonNode jsonNode = objectMapper.readTree(condition);
            if(jsonNode.get("initVal")!=null && !jsonNode.get("initVal").asText().isEmpty()){
                String initName = jsonNode.get("initVal").asText();
                sqlCreator.neCondition("code",initName);
            }else if(jsonNode.get("name")!=null && !jsonNode.get("name").asText().isEmpty()){
                String name = jsonNode.get("name").asText();
                sqlCreator.likeOrCondition("code", "name", name);
            } else if (jsonNode.get("stdId") != null && !jsonNode.get("stdId").asText().isEmpty()) {
                String[] stdLs = jsonNode.get("stdId").asText().split(",");
                List<Integer> stdIdLs = new ArrayList<>();
                for (String s : stdLs) {
                    stdIdLs.add(Integer.valueOf(s));
                }
                sqlCreator.inCondition("id", stdIdLs);
            }
        }
        if (!StringUtil.isEmpty(order)) {
            JsonNode jsonNode = objectMapper.readTree(order);
            Iterator<String> fieldNames = jsonNode.fieldNames();
            while (fieldNames.hasNext()) {
                String fieldName = fieldNames.next();
                String value = jsonNode.get(fieldName).asText().toUpperCase();
                sqlCreator.order(fieldName, value);
            }
        }
        String sql = sqlCreator.selectData(tableName);
        Query query = getQuery(sqlCreator, sql);
        if (limit != null) {
            query.setMaxResults(limit);
            if (offset != null) {
                query.setFirstResult((offset - 1) * limit);
            }
        }
        return query.list();
    }
    public Integer getDatasetInt(Class tClass, String stdVersion, String condition) {
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            String tableName = standardVersion.getDataSetTableName();
            SqlCreator sqlCreator = new SqlCreator(tClass);
            if (!StringUtil.isEmpty(condition)) {
                JsonNode jsonNode = objectMapper.readTree(condition);
                String name = jsonNode.get("name").asText();
                sqlCreator.likeOrCondition("code", "name", name);
            }
            String sql = sqlCreator.countData(tableName);
            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;
        } catch (Exception e) {
            e.printStackTrace();
            throw new ApiException(ErrorCode.GetDataSetListFailed.getErrorCode());
        }
    }
    public PageEnvelop getDatasetSelectList(String stdVersion, String condition, String order, Integer limit, Integer offset) {
        try {
            List<StdDataSetModel> datasetList = getDatasetList(StdDataSetModel.class, stdVersion, condition, order, limit, offset);
            List<Select2> detailModelList = new ArrayList<>();
            for (StdDataSetModel stdDataSetModel : datasetList) {
                Select2 select2 = new Select2();
                select2.setId(stdDataSetModel.getId() + SqlConstants.COMMA + stdDataSetModel.getCode());
                select2.setText(stdDataSetModel.getName());
                detailModelList.add(select2);
            }
            PageEnvelop detailModelResult = PageEnvelop.getSuccess("获取数据集下拉列表成功");
            detailModelResult.setDetailModelList(detailModelList);
            detailModelResult.setTotalCount(detailModelList.size());
            return detailModelResult;
        } catch (Exception e) {
            e.printStackTrace();
            return PageEnvelop.getError("获取数据集下拉列表失败");
        }
    }
    public List getAllVersionDatasetList() {
        // 导入的数据集列表应该只取集成标准已发布各版本的并集去重 @modify by yingjie chen
        Criteria criteria = getCurrentSession().createCriteria(StandardModel.class);
        StandardParamResultModel standardParam = standardService.getStandardParam(SqlConstants.STANDARD);
        String code = standardParam.getCode();
        criteria.add(Restrictions.eq("code", code));
        List<StandardModel> standardModelList = criteria.list();
        List<Integer> idList = standardModelList.stream().map(StandardModel::getId).collect(Collectors.toList());
        try {
            List<StandardVersionModel> versionModelList = new ArrayList<>();
            if (!CollectionUtils.isEmpty(idList)) {
                String hql = "FROM StandardVersionModel WHERE publishTime is not null AND standardId IN :idList order by publishTime";
                Query query = getCurrentSession().createQuery(hql);
                query.setParameterList("idList", idList);
                versionModelList = query.list();
            }
            String sql = SqlConstants.EMPTY;
            BeanTransformer transformer = new BeanTransformer(StdDataSetModel.class);
            for (StandardVersionModel versionModel : versionModelList) {
                SqlCreator sqlCreator = new SqlCreator(StdDataSetModel.class);
                StandardVersion version = new StandardVersion(versionModel.getVersion());
                sql = sql + sqlCreator.selectData(version.getDataSetTableName()) + SqlConstants.UNION;
            }
            if (!StringUtil.isEmpty(sql)) {
                sql = sql.substring(0, sql.length() - SqlConstants.UNION.length());
                SQLQuery sqlQuery = getCurrentSession().createSQLQuery(sql);
                sqlQuery.setResultTransformer(transformer);
                List<StdDataSetModel> modelList = sqlQuery.list();
                List<StdDataSetModel> distinctModelList = new ArrayList<>();
                Map<String, StdDataSetModel> datasetModelMap = new HashMap<>();
                for (StdDataSetModel model : modelList) {
                    datasetModelMap.put(model.getCode(), model);
                }
                for (String key : datasetModelMap.keySet()) {
                    distinctModelList.add(datasetModelMap.get(key));
                }
                return distinctModelList;
            } else {
                return new ArrayList<>();
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new ApiException(ErrorCode.GetDataSetListFailed.getErrorCode());
        }
    }
    //从excel导入数据集、数据元
    public void importFromExcel(String filePath, String stdVersion){
        String datasetTable;
        String metadataTable;
        String dictTable;
        if (StringUtil.isEmpty(stdVersion)) {
            datasetTable = "std_dataset";
            metadataTable = "std_metadata";
            dictTable = "std_dictionary";
        } else {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            datasetTable = standardVersion.getDataSetTableName();
            metadataTable = standardVersion.getMetaDataTableName();
            dictTable = standardVersion.getDictTableName();
        }
        SqlCreator sqlCreator = new SqlCreator(StdDictionaryModel.class);
        String sql = sqlCreator.selectData(dictTable);
        Query sessionQuery = getQuery(sqlCreator, sql);
        List<StdDictionaryModel> stdDictList = sessionQuery.list();
        Map<String, Integer> stdDictMap = new HashMap<>();
        for (StdDictionaryModel dict : stdDictList) {
            stdDictMap.put(dict.getCode(), dict.getId());
        }
        try {
            InputStream is = new FileInputStream(filePath);
            Workbook rwb = Workbook.getWorkbook(is);
            Sheet[] sheets = rwb.getSheets();
            for (Sheet sheet : sheets) {
                StdDataSetModel stdDataSetModel = new StdDataSetModel();
                //获取数据集信息
                String sheetName = sheet.getName(); //sheet名字
                String dataSetNname = sheet.getCell(1, 0).getContents();//名称
                String dataSetCode = sheet.getCell(1, 1).getContents();//标识
                String reference = sheet.getCell(1, 2).getContents();//参考
                String summary = sheet.getCell(1, 3).getContents();//备注
                //todo：test--测试时备注做区别，方便删除测试，summary变量区别
                //summary="测试excel导入";
                //todo：test--测试时code区别，否则测试不成功，因为code唯一
                //dataSetCode = dataSetCode+"excel";
                if (dataSetNname==null || dataSetNname.equals("")){
                    throw new Exception(sheetName+"数据集名称不能为空，请检查！");
                }
                if (dataSetCode==null || dataSetCode.equals("")){
                    throw new Exception(sheetName +"数据集标识不能为空，请检查！");
                }
                //插入数据集信息
                stdDataSetModel.setCode(dataSetCode);//code唯一
                stdDataSetModel.setName(dataSetNname);
                stdDataSetModel.setstandardId(2);
                //获取数据元信息
                Set<String> set = new HashSet<String>();
                List<StdMetaDataModel> metaDataList = new ArrayList<>();
                int rows = sheet.getRows();
                for (int j = 0; j < rows - 5; j++) {
                    StdMetaDataModel metaData = new StdMetaDataModel();
                    int row = j + 5;
                    String innerCode = sheet.getCell(1, row).getContents();//内部标识
                    String code = sheet.getCell(2, row).getContents();//数据元编码
                    String name = sheet.getCell(3, row).getContents();//数据元名称
                    String definition = sheet.getCell(4, row).getContents();//数据元定义
                    String type = sheet.getCell(5, row).getContents();//数据类型
                    String format = sheet.getCell(6, row).getContents();//表示形式
                    String dictCode = sheet.getCell(7, row).getContents();//术语范围值
                    String columnName = sheet.getCell(8, row).getContents();//列名
                    String columnType = sheet.getCell(9, row).getContents();//列类型
                    String columnLength = sheet.getCell(10, row).getContents();//列长度
                    String primaryKey = sheet.getCell(11, row).getContents();//主键
                    String nullable = sheet.getCell(12, row).getContents();//可为空
                    Integer pk = 0;
                    Integer isNull = 1;
                    if (!StringUtil.isEmpty(primaryKey)) {
                        pk = Integer.parseInt(primaryKey);
                    }
                    if (!StringUtil.isEmpty(nullable)) {
                        isNull = Integer.parseInt(nullable);
                    }
                    //todo：test--测试时备注做区别，方便删除测试，definition变量区别
                    //definition="测试excel导入";
                    //数据元的校验，一个不通过则全部不保存
                    if (innerCode==null || innerCode.equals("")){
                        throw new Exception(sheetName+"第"+(row+1)+"行内部标识不能为空，请检查！");
                    }else{
                        //innerCode要唯一
                        set.add(innerCode);
                        if (set.toArray(new String[set.size()]).length != j+1){
                            //innerCode重复
                            throw new Exception(sheetName+"第"+(row+1)+"行内部标识已存在，请检查！");
                        }
                    }
                    if (StringUtil.isEmpty(code)){
                        throw new Exception(sheetName+"第"+(row+1)+"行数据元编码不能为空，请检查！");
                    }
                    if (StringUtil.isEmpty(name)){
                        throw new Exception(sheetName+"第"+(row+1)+"行数据元名称不能为空，请检查！");
                    }
                    if (StringUtil.isEmpty(columnName)){
                        throw new Exception(sheetName+"第"+(row+1)+"行列名不能为空，请检查！");
                    }
                    if (pk == 1 && isNull == 1){
                        throw new Exception(sheetName+"第"+(row+1)+"行主键不能为空，请检查！");
                    }
                    //数据类型与列类型一致 S、L、N、D、DT、T、BY
                    if ((type.contains("S") && !columnType.contains("VARCHAR")) || (type.equals("D") && !columnType.equals("DATE"))  || (type.equals("DT") && !columnType.equals("DATETIME"))) {
                        throw new Exception(sheetName+"第"+(row+1)+"行数据类型与列类型不匹配，请检查！");
                    }
                    //插入数据元信息
                    metaData.setId(0);//为0内部自增
                    metaData.setCode(innerCode);
                    metaData.setName(name);
                    metaData.setDeCode(code);
                    metaData.setType(type);
                    if (!StringUtil.isEmpty(dictCode)) {
                        metaData.setDictId(stdDictMap.get(dictCode));
                    }
                    metaData.setFormat(format);
                    metaData.setDefinition(definition);
                    metaData.setColumnName(columnName);
                    metaData.setColumnLength(columnLength);
                    metaData.setColumnType(columnType);
                    metaData.setPrimaryKey(0);
                    metaData.setPrimaryKey(pk);
                    metaData.setNullable(isNull);
                    metaDataList.add(metaData);
                    //metaDataManager.saveMetaData(dataSet, metaData);//保存数据元
                }
                //数据集入库
                add(datasetTable, stdDataSetModel);//保存数据集信息
                Integer metaDataMaxId = getMaxId(metadataTable);
                //数据元入库
                if (metaDataList.size()>0){
                    for (StdMetaDataModel metaData : metaDataList) {
                        sqlCreator = new SqlCreator(StdMetaDataModel.class);
                        metaData.setDatasetId(stdDataSetModel.getId());
                        metaData.setId(metaDataMaxId++);
                        metaData.setStandardId(2);
                        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(metaData));
                        sql = sqlCreator.insertData(metadataTable, jsonNode);
                        Query query = getExeuteQuery(sqlCreator, sql);
                        query.executeUpdate();
                    }
                }
            }
            //关闭
            rwb.close();
            is.close();
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    public List datasetVersionListByName(String rsResourceImportDatasetDialogName) {
        try {
            String hql = "FROM StandardVersionModel WHERE publishTime is not null order by publishTime";
            Query query = getCurrentSession().createQuery(hql);
            List<StandardVersionModel> versionModelList = query.list();
            String sql = SqlConstants.EMPTY;
            BeanTransformer transformer = new BeanTransformer(StdDataSetModel.class);
            for (StandardVersionModel versionModel : versionModelList) {
                SqlCreator sqlCreator = new SqlCreator(StdDataSetModel.class);
                StandardVersion version = new StandardVersion(versionModel.getVersion());
                sql = sql + sqlCreator.selectData(version.getDataSetTableName())  + SqlConstants.UNION;
            }
            if (!StringUtil.isEmpty(sql)) {
                sql = sql.substring(0, sql.length() - SqlConstants.UNION.length());
                SQLQuery sqlQuery = getCurrentSession().createSQLQuery(sql);
                sqlQuery.setResultTransformer(transformer);
                List<StdDataSetModel> modelList = sqlQuery.list();
                List<StdDataSetModel> distinctModelList = new ArrayList<>();
                Map<String, StdDataSetModel> datasetModelMap = new HashMap<>();
                for (StdDataSetModel model : modelList) {
                    datasetModelMap.put(model.getCode(), model);
                }
                for (String key : datasetModelMap.keySet()) {
                    StdDataSetModel s=datasetModelMap.get(key);
                    if(s.getName().contains(rsResourceImportDatasetDialogName)){
                        distinctModelList.add(datasetModelMap.get(key));
                    }
                }
                return distinctModelList;
            } else {
                return new ArrayList<>();
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new ApiException(ErrorCode.GetDataSetListFailed.getErrorCode());
        }
    }
}

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

@@ -0,0 +1,332 @@
package com.yihu.jw.basic.standard.service.standard;
import com.fasterxml.jackson.databind.JsonNode;
import com.yihu.jw.basic.standard.model.Select2;
import com.yihu.jw.basic.standard.model.standard.StdDictionaryEntryModel;
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.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.RequestParamTransformer;
import com.yihu.jw.util.sql.SqlConstants;
import com.yihu.jw.util.sql.SqlCreator;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import java.io.IOException;
import java.util.*;
/**
 * @author Sand
 * @version 1.0
 * @created 16-7月-2015 20:57:06
 */
@Transactional
@Service("StdDictEntryService")
public class StdDictEntryService extends SQLGeneralDAO {
    public static final String BEAN_ID = "StdDictEntryService";
    public StdDictEntryService() {
    }
    public void finalize() throws Throwable {
    }
    public List<StdDictionaryEntryModel> getList(String stdVersion, Integer dictId, String condition, String order, Integer limit, Integer offset) {
        try {
            Map queryMap = RequestParamTransformer.parseJsonToMap(condition);
            Map orderMap = RequestParamTransformer.parseJsonToMap(order);
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            return this.getList(standardVersion, dictId, queryMap, orderMap, limit, offset);
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardDictEntryGetListFailed.getErrorCode());
    }
    public ObjEnvelop add(String stdVersion, String dictEntry) {
        Boolean existFlg = false;
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            StdDictionaryEntryModel stdDictionaryEntryModel = objectMapper.readValue(dictEntry, StdDictionaryEntryModel.class);
            existFlg = dictEntryCodeValidate(standardVersion, stdDictionaryEntryModel.getDictId(), stdDictionaryEntryModel.getCode());
            if (!existFlg) {
                this.add(standardVersion, stdDictionaryEntryModel);
                return ObjEnvelop.getSuccess("保存标准字典项成功",stdDictionaryEntryModel);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (existFlg) {
            return ObjEnvelop.getError("已存在标准字典项编码");
        } else {
            return ObjEnvelop.getError("保存标准字典项失败");
        }
    }
    public Boolean dictEntryCodeValidate(StandardVersion standardVersion, Integer dictId, String code) {
        Map<String, Object> query = new HashMap<>();
        Map<String, String> order = new HashMap<>();
        query.put("code", code);
        List<StdDictionaryEntryModel> list = this.getList(standardVersion, dictId, query, order, 1, 1);
        if (!CollectionUtils.isEmpty(list)) {
            return true;
        }
        return false;
    }
    public Envelop delete(String stdVersion, Integer dictEntryId) {
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            if (dictEntryId != null) {
                this.delete(standardVersion, dictEntryId);
                return Envelop.getSuccess("删除标准字典项成功");
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new ApiException(ErrorCode.StandardDictEntryDeleteFailed.getErrorCode());
        }
        return Envelop.getError("删除标准字典项失败");
    }
    public Boolean dictEntryCodeValidate(StandardVersion standardVersion, Integer dictId, Integer dictEntryId, String code) {
        SqlCreator sqlCreator = new SqlCreator(StdDictionaryEntryModel.class);
        sqlCreator.equalCondition("dictId", dictId);
        sqlCreator.equalCondition("code", code);
        sqlCreator.neCondition("id", dictEntryId);
        String sql = sqlCreator.selectData(standardVersion.getDictEntryTableName());
        Query sessionQuery = getQuery(sqlCreator, sql);
        List<StdDictionaryEntryModel> list = sessionQuery.list();
        if (!CollectionUtils.isEmpty(list)) {
            return true;
        }
        return false;
    }
    public ObjEnvelop update(String stdVersion, String dictEntry) {
        Boolean existFlg = false;
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            StdDictionaryEntryModel stdDictionaryEntryModel = objectMapper.readValue(dictEntry, StdDictionaryEntryModel.class);
            existFlg = dictEntryCodeValidate(standardVersion, stdDictionaryEntryModel.getDictId(), stdDictionaryEntryModel.getId(), stdDictionaryEntryModel.getCode());
            if (!existFlg) {
                this.modify(standardVersion, stdDictionaryEntryModel);
                return ObjEnvelop.getSuccess("修改标准字典项成功",stdDictionaryEntryModel);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (existFlg) {
            return ObjEnvelop.getError("已存在标准字典项编码");
        } else {
            return ObjEnvelop.getError("修改标准字典项失败");
        }
    }
    public ObjEnvelop get(String stdVersion, Integer dictEntryId) {
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            if (dictEntryId != null) {
                StdDictionaryEntryModel stdDictionaryEntryModel = this.get(standardVersion, dictEntryId);
                return ObjEnvelop.getSuccess("获取标准字典项成功",stdDictionaryEntryModel);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ObjEnvelop.getError("获取标准字典项失败");
    }
    public void add(StandardVersion standardVersion, StdDictionaryEntryModel stdDictionaryEntryModel) throws IOException {
        Session session = getCurrentSession();
        String dictEntryTableName = standardVersion.getDictEntryTableName();
        String sql = "select max(id) from " + dictEntryTableName;
        Query query = session.createSQLQuery(sql);
        Object object = query.uniqueResult();
        Integer id = object == null ? 1 : Integer.parseInt(object.toString()) + 1;
        stdDictionaryEntryModel.setId(id);
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(stdDictionaryEntryModel));
        SqlCreator sqlCreator = new SqlCreator(StdDictionaryEntryModel.class);
        sql = sqlCreator.insertData(dictEntryTableName, jsonNode);
        query = getExeuteQuery(sqlCreator, sql);
        query.executeUpdate();
    }
    public PageEnvelop getDetailModelList(String stdVersion, Integer dictId, String condition, String order, Integer rows, Integer page) {
        try {
            List<StdDictionaryEntryModel> detailModelList = getDictEntryList(StdDictionaryEntryModel.class, stdVersion, dictId, condition, order, rows, page);
            Integer count = getDictEntryInt(StdDictionaryEntryModel.class, stdVersion, dictId, condition);
            PageEnvelop result = PageEnvelop.getSuccess("获取标准字典项列表成功");
            result.setDetailModelList(detailModelList);
            result.setTotalCount(count);
            return result;
        } catch (Exception e) {
            e.printStackTrace();
            return PageEnvelop.getError("获取标准字典项列表失败");
        }
    }
    public List getDictEntryList(Class tClass, String stdVersion, Integer dictId, String condition, String order, Integer limit, Integer offset) {
        StandardVersion standardVersion = new StandardVersion(stdVersion);
        String tableName = standardVersion.getDictEntryTableName();
        SqlCreator sqlCreator = new SqlCreator(tClass);
        sqlCreator.equalCondition("dictId", dictId);
        if (!StringUtil.isEmpty(condition)) {
            try {
                JsonNode jsonNode = objectMapper.readTree(condition);
                String name = jsonNode.get("name").asText();
                sqlCreator.likeOrCondition("code", "value", name);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            if (!StringUtil.isEmpty(order)) {
                JsonNode jsonNode = objectMapper.readTree(order);
                Iterator<String> fieldNames = jsonNode.fieldNames();
                while (fieldNames.hasNext()) {
                    String fieldName = fieldNames.next();
                    String value = jsonNode.get(fieldName).asText().toUpperCase();
                    sqlCreator.order(fieldName, value);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        String sql = sqlCreator.selectData(tableName);
        Query query = getQuery(sqlCreator, sql);
        if (limit != null) {
            query.setMaxResults(limit);
            if (offset != null) {
                query.setFirstResult((offset - 1) * limit);
            }
        }
        return query.list();
    }
    public Integer getDictEntryInt(Class tClass, String stdVersion, Integer dictId, String condition) {
        StandardVersion standardVersion = new StandardVersion(stdVersion);
        String tableName = standardVersion.getDictEntryTableName();
        SqlCreator sqlCreator = new SqlCreator(tClass);
        sqlCreator.equalCondition("dictId", dictId);
        if (!StringUtil.isEmpty(condition)) {
            try {
                JsonNode jsonNode = objectMapper.readTree(condition);
                String name = jsonNode.get("name").asText();
                sqlCreator.likeOrCondition("code", "value", name);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        String sql = sqlCreator.countData(tableName);
        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 PageEnvelop getDictEntrySelectList(String stdVersion, Integer dictId, String condition, String order, Integer rows, Integer page) {
        try {
            List<StdDictionaryEntryModel> dictEntryModelList = getDictEntryList(StdDictionaryEntryModel.class, stdVersion, dictId, condition, order, rows, page);
            List<Select2> detailModelList = new ArrayList<>();
            for (StdDictionaryEntryModel dictEntry : dictEntryModelList) {
                Select2 select2 = new Select2();
                select2.setId(dictEntry.getId() + SqlConstants.COMMA + dictEntry.getCode());
                select2.setText(dictEntry.getValue());
                detailModelList.add(select2);
            }
            PageEnvelop result = PageEnvelop.getSuccess("获取标准字典项下拉列表成功");
            result.setDetailModelList(detailModelList);
            result.setTotalCount(detailModelList.size());
            return result;
        } catch (Exception e) {
            e.printStackTrace();
            return PageEnvelop.getError("获取标准字典项下拉列表失败");
        }
    }
    public StdDictionaryEntryModel getStEntryValueByCode(String version, Integer dictId, String entryCode) {
        try {
            SqlCreator sqlCreator = new SqlCreator(StdDictionaryEntryModel.class);
            sqlCreator.equalCondition("dictId", dictId);
            sqlCreator.equalCondition("code", entryCode);
            String sql = sqlCreator.selectData("std_dictionary_entry_" + version);
            Query query = getQuery(sqlCreator, sql);
            List<StdDictionaryEntryModel> list = query.list();
            if (list == null || list.size() == 0) {
                return null;
            } else {
                return list.get(0);
            }
        } catch (Exception e) {
            return null;
        }
    }
    private StdDictionaryEntryModel get(StandardVersion standardVersion, Integer dictEntryId) {
        String dictEntryTableName = standardVersion.getDictEntryTableName();
        SqlCreator sqlCreator = new SqlCreator(StdDictionaryEntryModel.class);
        sqlCreator.equalCondition("id", dictEntryId);
        String sql = sqlCreator.selectData(dictEntryTableName);
        Query query = getQuery(sqlCreator, sql);
        return (StdDictionaryEntryModel) query.uniqueResult();
    }
    private void modify(StandardVersion standardVersion, StdDictionaryEntryModel stdDictionaryEntryModel) throws IOException {
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(stdDictionaryEntryModel));
        SqlCreator sqlCreator = new SqlCreator(StdDictionaryEntryModel.class);
        String dictEntryTableName = standardVersion.getDictEntryTableName();
        String sql = sqlCreator.updateDataByTableKey(dictEntryTableName, jsonNode);
        Query query = getExeuteQuery(sqlCreator, sql);
        query.executeUpdate();
    }
    private void delete(StandardVersion standardVersion, Integer dictEntryId) {
        Session session = getCurrentSession();
        String sql = "delete from " + standardVersion.getDictEntryTableName() + " where id = :id";
        Query query = session.createSQLQuery(sql);
        query.setInteger("id", dictEntryId);
        query.executeUpdate();
    }
    private List<StdDictionaryEntryModel> getList(StandardVersion standardVersion, Integer dictId, Map<String, Object> query, Map<String, String> order, Integer limit, Integer offset) {
        SqlCreator sqlCreator = new SqlCreator(StdDictionaryEntryModel.class);
        sqlCreator.equalCondition("dictId", dictId);
        for (String key : query.keySet()) {
            sqlCreator.equalCondition(key, query.get(key));
        }
        for (String key : order.keySet()) {
            sqlCreator.order(key, order.get(key));
        }
        String sql = sqlCreator.selectData(standardVersion.getDictEntryTableName());
        Query sessionQuery = getQuery(sqlCreator, sql);
        if (limit != null) {
            sessionQuery.setMaxResults(limit);
            if (offset != null) {
                sessionQuery.setFirstResult((offset - 1) * limit);
            }
        }
        return (List<StdDictionaryEntryModel>) sessionQuery.list();
    }
}//end DictEntryManager

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

@@ -0,0 +1,406 @@
package com.yihu.jw.basic.standard.service.standard;
import com.fasterxml.jackson.databind.JsonNode;
import com.yihu.jw.basic.standard.model.Select2;
import com.yihu.jw.basic.standard.model.standard.StdDictionaryEntryModel;
import com.yihu.jw.basic.standard.model.standard.StdDictionaryModel;
import com.yihu.jw.basic.standard.service.bo.StandardVersion;
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.*;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.exception.ApiException;
import com.yihu.jw.basic.standard.model.DictItem;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import java.io.IOException;
import java.util.*;
/**
 * @author Sand
 * @version 1.0
 * @created 14-7月-2015 15:44:21
 */
@Transactional
@Service("StdDictService")
public class StdDictService extends SQLGeneralDAO {
    public static final String BEAN_ID = "StdDictService";
    @Autowired
    StdDictEntryService stdDictEntryService;
    public StdDictService() {
    }
    public void finalize() throws Throwable {
    }
    public List<StdDictionaryModel> getList(String stdVersion, 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(standardVersion, queryMap, orderMap, limit, offset);
        }catch (Exception e){
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardDictGetListFailed.getErrorCode());
    }
    public ObjEnvelop add(String stdVersion, String dict) {
        Boolean existFlg = false;
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            StdDictionaryModel stdDictionaryModel = objectMapper.readValue(dict, StdDictionaryModel.class);
            existFlg = dictCodeValidate(standardVersion, stdDictionaryModel.getCode());
            if (!existFlg) {
                this.add(standardVersion, stdDictionaryModel);
                //取得新增字典表记录
                Map<String, Object> query = new HashMap<>();
                Map<String, String> order = new HashMap<>();
                query.put("code", stdDictionaryModel.getCode());
                List<StdDictionaryModel> list = this.getList(standardVersion, query, order, 1, 0);
                Integer id = list.get(0).getId();
                Integer parentId = list.get(0).getParentId();
                if (parentId != null) {
                    Map<String, Object> query1 = new HashMap<>();
                    Map<String, String> order1 = new HashMap<>();
                    query1.put("dictId", parentId);
                    List<StdDictionaryEntryModel> dicEntryList = this.getDicEntryList(standardVersion,query1,order,null,null);
                    for (StdDictionaryEntryModel entryModel : dicEntryList) {
                        StdDictionaryEntryModel model =  new StdDictionaryEntryModel();
                        model.setDictId(id);
                        model.setstandardId(entryModel.getstandardId());
                        model.setCode(entryModel.getCode());
                        model.setValue(entryModel.getValue());
                        model.setDescription(entryModel.getDescription());
                        stdDictEntryService.add(standardVersion,model);
                    }
                }
                return ObjEnvelop.getSuccess("保存标准字典成功",stdDictionaryModel);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (existFlg) {
            return ObjEnvelop.getError("已存在标准字典编码");
        } else {
            return ObjEnvelop.getError("保存标准字典失败");
        }
    }
    public Boolean dictCodeValidate(StandardVersion standardVersion, String code) {
        Map<String, Object> query = new HashMap<>();
        Map<String, String> order = new HashMap<>();
        query.put("code", code);
        List<StdDictionaryModel> list = this.getList(standardVersion, query, order, 1, 0);
        if (!CollectionUtils.isEmpty(list)) {
            return true;
        }
        return false;
    }
    public Envelop delete(String stdVersion, Integer dictId) {
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            if (dictId != null) {
                this.delete(standardVersion, dictId);
                return Envelop.getSuccess("删除标准字典成功");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Envelop.getError("删除标准字典失败");
    }
    public Boolean dictCodeValidate(StandardVersion standardVersion, Integer dictId, String code) {
        SqlCreator sqlCreator = new SqlCreator(StdDictionaryModel.class);
        sqlCreator.equalCondition("code", code);
        sqlCreator.neCondition("id", dictId);
        String sql = sqlCreator.selectData(standardVersion.getDictTableName());
        Query sessionQuery = getQuery(sqlCreator, sql);
        List<StdDictionaryModel> list = sessionQuery.list();
        if (!CollectionUtils.isEmpty(list)) {
            return true;
        }
        return false;
    }
    public ObjEnvelop update(String stdVersion, String dict) {
        Boolean existFlg = false;
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            StdDictionaryModel stdDictionaryModel = objectMapper.readValue(dict, StdDictionaryModel.class);
            existFlg = dictCodeValidate(standardVersion, stdDictionaryModel.getId(), stdDictionaryModel.getCode());
            if (!existFlg) {
                this.modify(standardVersion, stdDictionaryModel);
                return ObjEnvelop.getSuccess("修改标准字典成功",stdDictionaryModel);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (existFlg) {
            return ObjEnvelop.getError("已存在标准字典编码");
        } else {
            return ObjEnvelop.getError("修改标准字典失败");
        }
    }
    public ObjEnvelop get(String stdVersion, Integer dictId) {
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            if (dictId != null) {
                StdDictionaryModel stdDictionaryModel = this.get(standardVersion, dictId);
                return ObjEnvelop.getSuccess("获取标准字典成功",stdDictionaryModel);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ObjEnvelop.getError("获取标准字典失败");
    }
    private StdDictionaryModel get(StandardVersion standardVersion, Integer dictId) {
        Session session = getCurrentSession();
        String dictTableName = standardVersion.getDictTableName();
        String sql = "select id, std_id, code, name, define, description, parent_id from " + dictTableName + " where id = :id";
        Query query = session.createSQLQuery(sql);
        query.setInteger("id", dictId);
        query.setResultTransformer(new BeanTransformer<>(StdDictionaryModel.class));
        return (StdDictionaryModel) query.uniqueResult();
    }
    private void modify(StandardVersion standardVersion, StdDictionaryModel stdDictionaryModel) throws IOException {
        String strTableName = standardVersion.getDictTableName();
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(stdDictionaryModel));
        SqlCreator sqlCreator = new SqlCreator(StdDictionaryModel.class);
        String sql = sqlCreator.updateDataByTableKey(strTableName, jsonNode);
        Query query = getExeuteQuery(sqlCreator, sql);
        query.executeUpdate();
    }
    private void delete(StandardVersion standardVersion, Integer dictId) {
        Session session = getCurrentSession();
        String sql = "delete from " + standardVersion.getDictTableName() + " where id = :id";
        Query query = session.createSQLQuery(sql);
        query.setInteger("id", dictId);
        query.executeUpdate();
        sql = "delete from " + standardVersion.getDictEntryTableName() + " where dict_id = :dictId";
        query = session.createSQLQuery(sql);
        query.setInteger("dictId", dictId);
        query.executeUpdate();
    }
    public void add(StandardVersion standardVersion, StdDictionaryModel stdDictionaryModel) throws IOException {
        Session session = getCurrentSession();
        String strTableName = standardVersion.getDictTableName();
        String sql = null;
        sql = "select max(id) from " + strTableName;
        Query query = session.createSQLQuery(sql);
        Object object = query.uniqueResult();
        Integer id = object == null ? 1 : Integer.parseInt(object.toString()) + 1;
        stdDictionaryModel.setId(id);
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(stdDictionaryModel));
        SqlCreator sqlCreator = new SqlCreator(StdDictionaryModel.class);
        sql = sqlCreator.insertData(strTableName, jsonNode);
        query = getExeuteQuery(sqlCreator, sql);
        query.executeUpdate();
    }
    private List<StdDictionaryModel> getList(StandardVersion standardVersion, Map<String, Object> query, Map<String, String> order, Integer limit, Integer offset) {
        SqlCreator sqlCreator = new SqlCreator(StdDictionaryModel.class);
        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.getDictTableName());
        Query sessionQuery = getQuery(sqlCreator, sql);
        if (limit != null) {
            sessionQuery.setMaxResults(limit);
            if (offset != null) {
                sessionQuery.setFirstResult((offset - 1) * limit);
            }
        }
        return (List<StdDictionaryModel>) sessionQuery.list();
    }
    public List<StdDictionaryEntryModel> getDicEntryList(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());
        Query sessionQuery = getQuery(sqlCreator, sql);
        if (limit != null) {
            sessionQuery.setMaxResults(limit);
            if (offset != null) {
                sessionQuery.setFirstResult((offset - 1) * limit);
            }
        }
        return (List<StdDictionaryEntryModel>) sessionQuery.list();
    }
    public ListEnvelop getDictionaryList(String stdVersion, String query, String order, Integer rows, Integer page) {
        try {
            List<StdDictionaryModel> stdDictionaryModelList = getList(stdVersion, query, order, rows, page);
            List<DictItem> detailModelList = new ArrayList<DictItem>();
            DictItem item = new DictItem();
            item.setCode("");
            item.setValue("-无-");
            detailModelList.add(item);
            for (StdDictionaryModel stdDictionaryModel : stdDictionaryModelList) {
                DictItem items = new DictItem();
                Integer  id = stdDictionaryModel.getId();
                String name = stdDictionaryModel.getName();
                items.setCode(id.toString());
                items.setValue(name);
                detailModelList.add(items);
            }
            return ListEnvelop.getSuccess("获取字典列表成功",detailModelList);
        } catch (Exception e) {
            e.printStackTrace();
            return ListEnvelop.getError("获取字典列表失败");
        }
    }
    public PageEnvelop getDetailModelList(String stdVersion, String condition, String order, Integer rows, Integer page) {
        try {
            List<StdDictionaryModel> dictModelList = getDictList(StdDictionaryModel.class, stdVersion, condition, order, rows, page);
            Integer count = getDictInt(StdDictionaryModel.class, stdVersion, condition);
            PageEnvelop result = PageEnvelop.getSuccess("获取标准数据字典列表成功");
            result.setDetailModelList(dictModelList);
            result.setTotalCount(count);
            return result;
        } catch (Exception e) {
            e.printStackTrace();
            return PageEnvelop.getError("获取标准字典列表失败");
        }
    }
    public List getDictList(Class tClass, String stdVersion, String condition, String order, Integer limit, Integer offset) {
        StandardVersion standardVersion = new StandardVersion(stdVersion);
        String tableName = standardVersion.getDictTableName();
        SqlCreator sqlCreator = new SqlCreator(tClass);
        try {
            if (!StringUtil.isEmpty(condition)) {
                JsonNode jsonNode = objectMapper.readTree(condition);
                if(jsonNode.get("initVal")!=null && !jsonNode.get("initVal").asText().isEmpty()){
                    String initName = jsonNode.get("initVal").asText();
                    sqlCreator.equalCondition("name",initName);
                }else if(jsonNode.get("name")!=null && !jsonNode.get("name").asText().isEmpty()){
                    String name = jsonNode.get("name").asText();
                    sqlCreator.likeOrCondition("code", "name", name);
                }
            }
            if (!StringUtil.isEmpty(order)) {
                JsonNode jsonNode = objectMapper.readTree(order);
                Iterator<String> fieldNames = jsonNode.fieldNames();
                while (fieldNames.hasNext()) {
                    String fieldName = fieldNames.next();
                    String value = jsonNode.get(fieldName).asText().toUpperCase();
                    sqlCreator.order(fieldName, value);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        String sql = sqlCreator.selectData(tableName);
        Query query = getQuery(sqlCreator, sql);
        if (limit != null) {
            query.setMaxResults(limit);
            if (offset != null) {
                query.setFirstResult((offset - 1) * limit);
            }
        }
        return query.list();
    }
    public Integer getDictInt(Class tClass, String stdVersion, String condition) {
        StandardVersion standardVersion = new StandardVersion(stdVersion);
        String tableName = standardVersion.getDictTableName();
        SqlCreator sqlCreator = new SqlCreator(tClass);
        try {
            if (!StringUtil.isEmpty(condition)) {
                JsonNode jsonNode = objectMapper.readTree(condition);
                String name = jsonNode.get("name").asText();
                sqlCreator.likeOrCondition("code", "name", name);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        String sql = sqlCreator.countData(tableName);
        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 PageEnvelop getDictSelectList(List<StdDictionaryModel> dictList) {
        try {
            List<Select2> detailModelList = new ArrayList<>();
            for (StdDictionaryModel dictModel : dictList) {
                Select2 select2 = new Select2();
                select2.setId(dictModel.getId() + SqlConstants.COMMA + dictModel.getCode());
                select2.setText(dictModel.getName());
                detailModelList.add(select2);
            }
            PageEnvelop detailModelResult = PageEnvelop.getSuccess("获取字典下来列表成功");
            detailModelResult.setDetailModelList(detailModelList);
            detailModelResult.setTotalCount(detailModelList.size());
            return detailModelResult;
        } catch (Exception e) {
            e.printStackTrace();
            return PageEnvelop.getError("获取字典下来列表失败");
        }
    }
    public StdDictionaryModel getAdapterDictByCode(String version, String dictCode) {
        try {
            SqlCreator sqlCreator = new SqlCreator(StdDictionaryModel.class);
            sqlCreator.equalCondition("code", dictCode);
            String sql = sqlCreator.selectData("std_dictentry_"+version);
            Query query = getQuery(sqlCreator, sql);
            return (StdDictionaryModel)query.uniqueResult();
        } catch (Exception e) {
            return null;
        }
    }
}

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

@@ -0,0 +1,405 @@
package com.yihu.jw.basic.standard.service.standard;
import com.fasterxml.jackson.databind.JsonNode;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.restmodel.web.Envelop;
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.*;
import com.yihu.jw.exception.ApiException;
import com.yihu.jw.basic.standard.model.Select2;
import com.yihu.jw.basic.standard.model.standard.*;
import com.yihu.jw.basic.standard.model.standard.resultModel.StandardParamResultModel;
import com.yihu.jw.basic.standard.service.bo.StandardVersion;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.criterion.Restrictions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;
/**
 * 数据元管理接口实现。
 *
 * @author Sand
 * @version 1.0
 * @created 2015.07.10 15:22
 */
@Transactional
@Service("StdMetadataService")
public class StdMetadataService extends SQLGeneralDAO {
    public static final String BEAN_ID = "StdMetadataService";
    @Autowired
    StandardService standardService;
    public StdMetadataService() {
    }
    public List<StdMetaDataModel> getList(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(standardVersion, datasetId, queryMap, orderMap, limit, offset);
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.StandardMetaDataGetListFailed.getErrorCode());
    }
    public ObjEnvelop add(String stdVersion, String metadata) {
        Boolean existFlg = false;
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            StdMetaDataModel stdMetaDataModel = objectMapper.readValue(metadata, StdMetaDataModel.class);
            existFlg = metadataCodeValidate(standardVersion, stdMetaDataModel.getDatasetId(), stdMetaDataModel.getCode());
            if (!existFlg) {
                this.add(standardVersion, stdMetaDataModel);
                return ObjEnvelop.getSuccess("保存数据元成功",stdMetaDataModel);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (existFlg) {
            return ObjEnvelop.getError("已存在标准数据元编码");
        } else {
            return ObjEnvelop.getError("保存数据元失败");
        }
    }
    public Boolean metadataCodeValidate(StandardVersion standardVersion, Integer datasetId, String code) {
        Map<String, Object> query = new HashMap<>();
        Map<String, String> order = new HashMap<>();
        query.put("code", code);
        List<StdMetaDataModel> list = this.getList(standardVersion, datasetId, query, order, 1, 1);
        if (!CollectionUtils.isEmpty(list)) {
            return true;
        }
        return false;
    }
    public Envelop delete(String stdVersion, Integer metadataId) {
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            if (metadataId != null) {
                this.delete(standardVersion, metadataId);
                return Envelop.getSuccess("删除数据元成功");
            }
        } catch (Exception e) {
            throw new ApiException(ErrorCode.StandardMetaDataDeleteFailed.getErrorCode());
        }
        return Envelop.getError("删除数据元失败");
    }
    public Boolean metadataCodeValidate(StandardVersion standardVersion, Integer datasetId, Integer metadataId, String code) {
        SqlCreator sqlCreator = new SqlCreator(StdMetaDataModel.class);
        sqlCreator.equalCondition("datasetId", datasetId);
        sqlCreator.equalCondition("code", code);
        sqlCreator.neCondition("id", metadataId);
        String sql = sqlCreator.selectData(standardVersion.getMetaDataTableName());
        Query sessionQuery = getQuery(sqlCreator, sql);
        List<StdMetaDataModel> list = sessionQuery.list();
        if (!CollectionUtils.isEmpty(list)) {
            return true;
        }
        return false;
    }
    public ObjEnvelop update(String stdVersion, String metadata) {
        Boolean existFlg = false;
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            StdMetaDataModel stdMetaDataModel = objectMapper.readValue(metadata, StdMetaDataModel.class);
            existFlg = metadataCodeValidate(standardVersion, stdMetaDataModel.getDatasetId(), stdMetaDataModel.getId(), stdMetaDataModel.getCode());
            if (!existFlg) {
                this.modify(standardVersion, stdMetaDataModel);
                return ObjEnvelop.getSuccess("修改数据元成功",stdMetaDataModel);
            } else {
                return ObjEnvelop.getError("已存在标准数据元编码");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ObjEnvelop.getError("修改数据元失败");
    }
    public ObjEnvelop get(String stdVersion, Integer metadataId) {
        try {
            StandardVersion standardVersion = new StandardVersion(stdVersion);
            if (metadataId != null) {
                String metaDataTableName = standardVersion.getMetaDataTableName();
                SqlCreator sqlCreator = new SqlCreator(StdMetaDataModel.class);
                sqlCreator.equalCondition("id", metadataId);
                String sql = sqlCreator.selectData(metaDataTableName);
                Query query = getQuery(sqlCreator, sql);
                StdMetaDataModel stdMetaDataModel = (StdMetaDataModel) query.uniqueResult();
                if (stdMetaDataModel != null) {
                    stdMetaDataModel.checkValue();
                }
                return ObjEnvelop.getSuccess("获取标准数据元成功",stdMetaDataModel);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ObjEnvelop.getError("获取标准数据元失败");
    }
    private void modify(StandardVersion standardVersion, StdMetaDataModel stdMetaDataModel) throws IOException {
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(stdMetaDataModel));
        SqlCreator sqlCreator = new SqlCreator(StdMetaDataModel.class);
        String metaDataTableName = standardVersion.getMetaDataTableName();
        String sql = sqlCreator.updateDataByTableKey(metaDataTableName, jsonNode);
        Query query = getExeuteQuery(sqlCreator, sql);
        query.executeUpdate();
    }
    private void delete(StandardVersion standardVersion, Integer metadataId) {
        Session session = getCurrentSession();
        String sql = "delete from " + standardVersion.getMetaDataTableName() + " where id = :id";
        Query query = session.createSQLQuery(sql);
        query.setInteger("id", metadataId);
        query.executeUpdate();
    }
    public void add(StandardVersion standardVersion, StdMetaDataModel stdMetaDataModel) throws IOException {
        Session session = getCurrentSession();
        String metaDataTableName = standardVersion.getMetaDataTableName();
        String sql = "select max(id) from " + metaDataTableName;
        Query query = session.createSQLQuery(sql);
        Object object = query.uniqueResult();
        stdMetaDataModel.setId(object == null ? 1 : Integer.parseInt(object.toString()) + 1);
        JsonNode jsonNode = objectMapper.readTree(objectMapper.writeValueAsString(stdMetaDataModel));
        SqlCreator sqlCreator = new SqlCreator(StdMetaDataModel.class);
        sql = sqlCreator.insertData(metaDataTableName, jsonNode);
        query = getExeuteQuery(sqlCreator, sql);
        query.executeUpdate();
    }
    private List<StdMetaDataModel> getList(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());
        Query sessionQuery = getQuery(sqlCreator, sql);
        if (limit != null) {
            sessionQuery.setMaxResults(limit);
            if (offset != null) {
                sessionQuery.setFirstResult((offset - 1) * limit);
            }
        }
        return (List<StdMetaDataModel>) sessionQuery.list();
    }
    public PageEnvelop getDetailModelList(String stdVersion, Integer dictId, String condition, String order, Integer rows, Integer page) {
        try {
            List<StdDictionaryEntryModel> detailModelList = getMetadataList(StdMetaDataModel.class, stdVersion, dictId, condition, order, rows, page);
            Integer count = getMetadataCount(StdMetaDataModel.class, stdVersion, dictId, condition);
            PageEnvelop result = PageEnvelop.getSuccess("获取标准字数据元列表成功");
            result.setDetailModelList(detailModelList);
            result.setTotalCount(count);
            return result;
        } catch (Exception e) {
            e.printStackTrace();
            return PageEnvelop.getError("获取标准数据元列表失败");
        }
    }
    public List getMetadataList(Class tClass, String stdVersion, Integer datasetId, String condition, String order, Integer limit, Integer offset) {
        StandardVersion standardVersion = new StandardVersion(stdVersion);
        String tableName = standardVersion.getMetaDataTableName();
        SqlCreator sqlCreator = new SqlCreator(tClass);
        sqlCreator.equalCondition("datasetId", datasetId);
        if (!StringUtil.isEmpty(condition)) {
            try {
                JsonNode jsonNode = objectMapper.readTree(condition);
                String name = jsonNode.get("name").asText();
                sqlCreator.likeOrCondition("code", "name", name);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            if (!StringUtil.isEmpty(order)) {
                JsonNode jsonNode = objectMapper.readTree(order);
                Iterator<String> fieldNames = jsonNode.fieldNames();
                while (fieldNames.hasNext()) {
                    String fieldName = fieldNames.next();
                    String value = jsonNode.get(fieldName).asText().toUpperCase();
                    sqlCreator.order(fieldName, value);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        String sql = sqlCreator.selectData(tableName);
        Query query = getQuery(sqlCreator, sql);
        if (limit != null) {
            query.setMaxResults(limit);
            if (offset != null) {
                query.setFirstResult((offset - 1) * limit);
            }
        }
        return query.list();
    }
    public Integer getMetadataCount(Class tClass, String stdVersion, Integer datasetId, String condition) {
        StandardVersion standardVersion = new StandardVersion(stdVersion);
        String tableName = standardVersion.getMetaDataTableName();
        SqlCreator sqlCreator = new SqlCreator(tClass);
        sqlCreator.equalCondition("datasetId", datasetId);
        if (!StringUtil.isEmpty(condition)) {
            try {
                JsonNode jsonNode = objectMapper.readTree(condition);
                String name = jsonNode.get("name").asText();
                sqlCreator.likeOrCondition("code", "name", name);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        String sql = sqlCreator.countData(tableName);
        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 PageEnvelop getMetadataSelectList(String stdVersion, Integer dictId, String condition, String order, Integer rows, Integer page) {
        try {
            List<StdMetaDataModel> metadataList = getMetadataList(StdMetaDataModel.class, stdVersion, dictId, condition, order, rows, page);
            List<Select2> detailModelList = new ArrayList<>();
            for (StdMetaDataModel metaDataModel : metadataList) {
                Select2 select2 = new Select2();
                if (metaDataModel.getDictId() != null) {
                    select2.setId(metaDataModel.getId() + SqlConstants.COMMA + metaDataModel.getCode() + SqlConstants.COMMA + metaDataModel.getDictId());
                } else {
                    select2.setId(metaDataModel.getId() + SqlConstants.COMMA + metaDataModel.getCode());
                }
                select2.setText(metaDataModel.getName());
                detailModelList.add(select2);
            }
            PageEnvelop detailModelResult = PageEnvelop.getSuccess("获取标准数据元下拉列表成功");
            detailModelResult.setDetailModelList(detailModelList);
            detailModelResult.setTotalCount(detailModelList.size());
            return detailModelResult;
        } catch (Exception e) {
            e.printStackTrace();
            return PageEnvelop.getError("获取标准数据元下拉列表失败");
        }
    }
    public List getAllVersionMetadataList(String condition) {
        //数据元列表应该是所选择的数据集列表的数据元并集去重 @modify by Yingjie Chen
        try {
            Map<String,List<StdDataSetModel>> version2DataSetMap = new HashMap<>();
            String sql;
            String code = SqlConstants.EMPTY;
            if (!StringUtil.isEmpty(condition)) {
                JsonNode jsonNode = objectMapper.readTree(condition);
                code = jsonNode.get("code").asText();
            }
            Criteria criteria = getCurrentSession().createCriteria(StandardModel.class);
            StandardParamResultModel standardParam = standardService.getStandardParam(SqlConstants.STANDARD);
            String VersionCode = standardParam.getCode();
            criteria.add(Restrictions.eq("code", VersionCode));
            List<StandardModel> standardModelList = criteria.list();
            List<Integer> idList = standardModelList.stream().map(StandardModel::getId).collect(Collectors.toList());
            List<StandardVersionModel> versionModelList;
            Session session = getCurrentSession();
            if (!CollectionUtils.isEmpty(idList)) {
                String hql = "FROM StandardVersionModel WHERE publishTime is not null AND standardId IN :idList order by publishTime";
                Query query = getCurrentSession().createQuery(hql);
                query.setParameterList("idList", idList);
                versionModelList = query.list();
                for (StandardVersionModel versionModel : versionModelList) {
                    SqlCreator sqlDatasetCreator = new SqlCreator(StdDataSetModel.class);
                    StandardVersion version = new StandardVersion(versionModel.getVersion());
                    sqlDatasetCreator.equalCondition("code", code);
                    sql = sqlDatasetCreator.selectData(version.getDataSetTableName());
                    SQLQuery sqlQuery = session.createSQLQuery(sql);
                    BeanTransformer datasetTransformer = new BeanTransformer(StdDataSetModel.class);
                    sqlQuery.setResultTransformer(datasetTransformer);
                    sqlQuery.setParameter("code", code);
                    List<StdDataSetModel> dataList = sqlQuery.list();
                    if (dataList.size() > 0) {
                        version2DataSetMap.put(versionModel.getVersion(),dataList);
                    }
                }
            }
            if (!version2DataSetMap.isEmpty()) {
                sql = SqlConstants.EMPTY;
                Integer count = 1;
                Map<Integer, String> datasetIdMap = new HashMap<>();
                Iterator iter = version2DataSetMap.entrySet().iterator();
                while (iter.hasNext()) {
                    Map.Entry entry = (Map.Entry) iter.next();
                    SqlCreator sqlMetadataCreator = new SqlCreator(StdMetaDataModel.class);
                    StandardVersion version = new StandardVersion((String) entry.getKey());
                    List<StdDataSetModel> dataList = (List<StdDataSetModel>) entry.getValue();
                    datasetIdMap.put(count++, StringUtil.toString(dataList.get(0).getId()));
                    sqlMetadataCreator.equalConditionQue("datasetId", dataList.get(0).getId());
                    sql = sql + sqlMetadataCreator.selectData(version.getMetaDataTableName()) + SqlConstants.UNION;
                }
                BeanTransformer metadataTransformer = new BeanTransformer(StdMetaDataModel.class);
                List<StdMetaDataModel> distinctModelList = new ArrayList<>();
                if (!StringUtil.isEmpty(sql)) {
                    sql = sql.substring(0, sql.length() - SqlConstants.UNION.length());
                    SQLQuery sqlQuery;
                    sqlQuery = getCurrentSession().createSQLQuery(sql);
                    sqlQuery.setResultTransformer(metadataTransformer);
                    for (int i = 1; i < count; i++) {
                        sqlQuery.setParameter(i - 1, datasetIdMap.get(i));
                    }
                    List<StdMetaDataModel> metadataList = sqlQuery.list();
                    Map<String, StdMetaDataModel> meatadataModelMap = new HashMap<>();
                    for (StdMetaDataModel model : metadataList) {
                        meatadataModelMap.put(model.getCode(), model);
                    }
                    distinctModelList.addAll(meatadataModelMap.keySet().stream().map(meatadataModelMap::get).collect(Collectors.toList()));
                }
                return distinctModelList;
            } else {
                return new ArrayList<>();
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new ApiException(ErrorCode.GetDataSetListFailed.getErrorCode());
        }
    }
}

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

@@ -0,0 +1,127 @@
package com.yihu.jw.basic.standard.service.standard;
import com.yihu.jw.basic.standard.dao.SQLGeneralDAO;
import com.yihu.jw.basic.standard.model.SystemOrganization;
import com.yihu.jw.restmodel.web.ListEnvelop;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.util.sql.ErrorCode;
import com.yihu.jw.exception.ApiException;
import com.yihu.jw.basic.standard.model.DictItem;
import com.yihu.jw.util.sql.RequestParamTransformer;
import com.yihu.jw.basic.standard.model.standard.resultModel.PublisherResultModel;
import com.yihu.jw.util.sql.SqlConstants;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
 * @created Airhead 2015/12/23.
 */
@Transactional
@Service("StdPublisherService")
public class StdPublisherService extends SQLGeneralDAO {
    public static final String BEAN_ID = "StdPublisherService";
    public ListEnvelop getDictionaryResult(String condition, String order, Integer limit, Integer offset) {
        try {
            List<DictItem> detailModelList = new ArrayList<DictItem>();
            List<SystemOrganization> stdPublisherModelList = getList(condition, order, limit, offset);
            for(SystemOrganization systemOrganization : stdPublisherModelList){
                DictItem items = new DictItem();
                String id = systemOrganization.getCode();
                String name = systemOrganization.getFullName();
                items.setCode(id.toString());
                items.setValue(name);
                detailModelList.add(items);
            }
            return ListEnvelop.getSuccess("获取发布机构列表成功",detailModelList);
        } catch (Exception e) {
            return ListEnvelop.getError("获取发布机构列表失败");
        }
    }
    public List<SystemOrganization> getList(String condition, String order, Integer limit, Integer offset) {
        try{
            Map<String, Object> queryMap = RequestParamTransformer.parseJsonToMap(condition);
            Map<String, String> orderMap = RequestParamTransformer.parseJsonToMap(order);
            return this.getList(queryMap, orderMap, limit, offset);
        } catch (Exception e) {
            e.printStackTrace();
        }
        throw new ApiException(ErrorCode.GetPublisherListFaield.getErrorCode());
    }
    private List<SystemOrganization> getList(Map<String, Object> query, Map<String, String> order, Integer limit, Integer offset) {
        Session session = getCurrentSession();
        Criteria criteria = session.createCriteria(SystemOrganization.class);
        if (query != null) {
            for (String key : query.keySet()) {
                criteria.add(Restrictions.eq(key, query.get(key)));
            }
        }
        if (limit != null) {
            criteria.setMaxResults(limit);
            if (offset != null) {
                criteria.setFirstResult((offset - 1) * limit);
            }
        }
        if (order != null) {
            for (String key : order.keySet()) {
                if (order.get(key).equals(SqlConstants.ASC)) {
                    criteria.addOrder(Order.asc(key));
                } else if (order.get(key).equals(SqlConstants.DESC)) {
                    criteria.addOrder(Order.desc(key));
                }
            }
        }
        List<SystemOrganization> systemOrganizationList = criteria.list();
        return systemOrganizationList;
    }
    public ObjEnvelop get(String stdPublisherId) {
        try {
            Session session = getCurrentSession();
            Criteria criteria = session.createCriteria(SystemOrganization.class);
            criteria.add(Restrictions.eq("id", stdPublisherId));
            SystemOrganization systemOrganization = (SystemOrganization) criteria.uniqueResult();
            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();
            return ObjEnvelop.getError("获取机构信息失败");
        }
    }
    public ObjEnvelop getStandardPublisher() {
        try {
            String paramSql = "select s.param_value from system_param s where s.param_key = '"+ SqlConstants.STANDARD_ORG+"'";
            Query paramQuery = getCurrentSession().createSQLQuery(paramSql);
            String publisherCode = (String) paramQuery.uniqueResult();
            Criteria criteria = getCurrentSession().createCriteria(SystemOrganization.class);
            criteria.add(Restrictions.eq("code", publisherCode));
            SystemOrganization systemOrganization = (SystemOrganization) criteria.uniqueResult();
            PublisherResultModel publisherResultModel = new PublisherResultModel();
            publisherResultModel.setCode(systemOrganization.getCode());
            publisherResultModel.setName(systemOrganization.getFullName());
            return ObjEnvelop.getSuccess("获取机构信息成功",publisherResultModel);
        } catch (Exception e) {
            e.printStackTrace();
            return ObjEnvelop.getError(ErrorCode.GetPublisherFailed.getErrorCode());
        }
    }
}

svr/svr-basic/src/main/java/com/yihu/jw/basic/user/controller/GetInfoEndPoint.java

@@ -51,7 +51,7 @@ public class GetInfoEndPoint extends EnvelopRestEndpoint {
        return orgCodeList;
    }
    @RequestMapping(value = "/getOrgByUserId", method = RequestMethod.GET)
    @RequestMapping(value = "/userInfo/getOrgByUserId", method = RequestMethod.GET)
    @ApiOperation(value = "获取当前用户可查询的机构名称")
    List<String> getOrgByUserId(
            @ApiParam(name = "userId", value = "userId", defaultValue = "")
@@ -67,7 +67,7 @@ public class GetInfoEndPoint extends EnvelopRestEndpoint {
        return getSaasCodeList(userId);
    }
    @RequestMapping(value = "/getDistrictByUserId", method = RequestMethod.GET)
    @RequestMapping(value = "/userInfo/getDistrictByUserId", method = RequestMethod.GET)
    @ApiOperation(value = "获取当前用户可查询的地区名称列表")
    List<String> getDistrictByUserId(
            @ApiParam(name = "userId", value = "userId", defaultValue = "")

svr/svr-basic/src/main/java/com/yihu/jw/basic/user/controller/UserEndPoint.java

@@ -1163,7 +1163,7 @@ public class UserEndPoint extends EnvelopRestEndpoint {
            if (systemDictList.size()==0) {
                return ListEnvelop.getError("获取系统设置信息失败");
            }
            Integer systemSettingId = systemDictList.get(0).getId().intValue();
            Long systemSettingId = systemDictList.get(0).getId();
            List<SystemDictEntry> systemDictEntryList = systemDictEntryService.search(null,"dictId=" + systemSettingId + ";code=CITY",null,1,1);
            if(systemDictEntryList.size()>0) {
                String cityId = systemDictEntryList.get(0).getValue();
@@ -1183,7 +1183,7 @@ public class UserEndPoint extends EnvelopRestEndpoint {
            if (systemDictList.size()==0) {
                return ListEnvelop.getError("获取系统设置信息失败");
            }
            Integer systemSettingId = systemDictList.get(0).getId().intValue();
            Long systemSettingId = systemDictList.get(0).getId();
            List<SystemDictEntry> systemDictEntryList = systemDictEntryService.search(null,"dictId=" + systemSettingId + ";code=CITY",null,1,1);
            if(systemDictEntryList.size()>0) {
                String cityId = systemDictEntryList.get(0).getValue();

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

@@ -0,0 +1,39 @@
package com.yihu.jw.basic.util;
import java.util.ArrayList;
import java.util.List;
/**
 * Created by Administrator on 2016/6/24.
 */
public class ExcelModel {
    public static String[] dataset={"平台数据集编码","平台数据集名称","数据元编码","数据元名称","机构数据集编码","机构数据集名称","机构数据元编码","机构数据元名称","说明"};
    public static String[] dict={"平台字典编码","平台字典名称","字典項编码","字典項名称","机构字典编码","机构字典名称","机构字典項编码","机构字典項名称","说明"};
    private String sheetName;//sheet名字
    private List<String> head =new ArrayList<String>();//表头名字
    private List<List<String>> context=new ArrayList<List<String>>();//内容
    public String getSheetName() {
        return sheetName;
    }
    public void setSheetName(String sheetName) {
        this.sheetName = sheetName;
    }
    public List<String> getHead() {
        return head;
    }
    public void setHead(List<String> head) {
        this.head = head;
    }
    public List<List<String>> getContext() {
        return context;
    }
    public void setContext(List<List<String>> context) {
        this.context = context;
    }
}

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

@@ -0,0 +1,117 @@
package com.yihu.jw.basic.util;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.ss.usermodel.HorizontalAlignment;
import org.apache.poi.ss.usermodel.IndexedColors;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.List;
import java.util.UUID;
/**
 * Created by Administrator on 2016/6/24.
 */
public class ExcelUtil {
    public static void downFileByHttpResponse(HttpServletResponse response, List<ExcelModel> excelModels) throws Exception {
        response.setHeader("Content-disposition", "attachment; filename= adapt.xlsx");// 设定输出文件头
        response.setContentType("application/x-msdownload");// 定义输出类型
        OutputStream os = response.getOutputStream();// 取得输出流
        HSSFWorkbook xssfWorkbook = new HSSFWorkbook();
        HSSFCellStyle style=xssfWorkbook.createCellStyle();
        for (ExcelModel excelModel : excelModels) {
            HSSFSheet sheet = xssfWorkbook.createSheet(excelModel.getSheetName());
            //设置表头
            HSSFRow row = sheet.createRow(0);
            for (int i = 0; i < excelModel.getHead().size(); i++) {
                sheet.setColumnWidth(i, 5000);
                HSSFCell cell= row.createCell(i);
                style.setFillForegroundColor(IndexedColors.BLUE_GREY.getIndex());//設置背景色
//                style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
                style.setAlignment(HorizontalAlignment.CENTER); // 居中
                HSSFFont font = xssfWorkbook.createFont();
                font.setFontName("黑体");
                font.setFontHeightInPoints((short) 12);
                style.setFont(font);
                cell.setCellStyle(style);
                cell.setCellValue(excelModel.getHead().get(i));
            }
            for (int i = 0; i <excelModel.getContext().size(); i++) {
                List<String> rowData = excelModel.getContext().get(i);
                row = sheet.createRow(i + 1);
                for (int j = 0; j < rowData.size(); j++) {
                    HSSFCell cell= row.createCell(j);
                    cell.setCellValue(rowData.get(j));
                }
            }
        }
        //主体内容生成结束
        xssfWorkbook.write(os); // 写入文件
        xssfWorkbook.close();
        os.flush();
        os.close();
    }
    public static File saveAsFile(List<ExcelModel> excelModels,String path) throws Exception {
        File newPath=new File(path);
        newPath.mkdir();
        File file=new File(path+ UUID.randomUUID().toString().replaceAll("-", "")+".xls");
        OutputStream outputStream=new FileOutputStream(file);
        HSSFWorkbook xssfWorkbook = new HSSFWorkbook();
        HSSFCellStyle style=xssfWorkbook.createCellStyle();
        for (ExcelModel excelModel : excelModels) {
            HSSFSheet sheet = xssfWorkbook.createSheet(excelModel.getSheetName());
            //设置表头
            HSSFRow row = sheet.createRow(0);
            for (int i = 0; i < excelModel.getHead().size(); i++) {
                sheet.setColumnWidth(i, 5000);
                HSSFCell cell= row.createCell(i);
                style.setFillForegroundColor(IndexedColors.BLUE_GREY.getIndex());//設置背景色
//                style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
                style.setAlignment(HorizontalAlignment.CENTER); // 居中
                HSSFFont font = xssfWorkbook.createFont();
                font.setFontName("黑体");
                font.setFontHeightInPoints((short) 12);
                style.setFont(font);
                cell.setCellStyle(style);
                cell.setCellValue(excelModel.getHead().get(i));
            }
            for (int i = 0; i <excelModel.getContext().size(); i++) {
                List<String> rowData = excelModel.getContext().get(i);
                row = sheet.createRow(i + 1);
                for (int j = 0; j < rowData.size(); j++) {
                    HSSFCell cell= row.createCell(j);
                    cell.setCellValue(rowData.get(j));
                }
            }
        }
        //主体内容生成结束
         xssfWorkbook.write(outputStream); // 写入文件
         xssfWorkbook.close();
         outputStream.flush();
         outputStream.close();
        return file;
    }
}

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

@@ -0,0 +1,452 @@
package com.yihu.jw.basic.util;
import org.apache.poi.hssf.usermodel.HSSFDateUtil;
import org.apache.poi.openxml4j.exceptions.OpenXML4JException;
import org.apache.poi.openxml4j.opc.OPCPackage;
import org.apache.poi.ss.usermodel.BuiltinFormats;
import org.apache.poi.ss.usermodel.DataFormatter;
import org.apache.poi.xssf.eventusermodel.ReadOnlySharedStringsTable;
import org.apache.poi.xssf.eventusermodel.XSSFReader;
import org.apache.poi.xssf.model.StylesTable;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFRichTextString;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.DefaultHandler;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
 * Created by Administrator on 2016/7/4.
 */
public class ExcelUtilBigData {
    /**
     * The type of the data value is indicated by an attribute on the cell. The
     * value is usually in a "v" element within the cell.
     */
    enum xssfDataType {
        BOOL, ERROR, FORMULA, INLINESTR, SSTINDEX, NUMBER,
    }
    /**
     * 使用xssf_sax_API处理Excel,请参考： http://poi.apache.org/spreadsheet/how-to.html#xssf_sax_api
     * <p/>
     * Also see Standard ECMA-376, 1st edition, part 4, pages 1928ff, at
     * http://www.ecma-international.org/publications/standards/Ecma-376.htm
     * <p/>
     * A web-friendly version is http://openiso.org/Ecma/376/Part4
     */
    class MyXSSFSheetHandler extends DefaultHandler {
        /**
         * Table with styles
         */
        private StylesTable stylesTable;
        /**
         * Table with unique strings
         */
        private ReadOnlySharedStringsTable sharedStringsTable;
        /**
         * Destination for data
         */
        private final PrintStream output;
        /**
         * Number of columns to read starting with leftmost
         */
        private final int minColumnCount;
        // Set when V start element is seen
        private boolean vIsOpen;
        // Set when cell start element is seen;
        // used when cell close element is seen.
        private xssfDataType nextDataType;
        // Used to format numeric cell values.
        private short formatIndex;
        private String formatString;
        private final DataFormatter formatter;
        private int thisColumn = -1;
        // The last column printed to the output stream
        private int lastColumnNumber = -1;
        // Gathers characters as they are seen.
        private StringBuffer value;
        private String[] record;
        private List<String[]> rows = new ArrayList<String[]>();
        private boolean isCellNull = false;
        private int start;
        /**
         * Accepts objects needed while parsing.
         *
         * @param styles  Table of styles
         * @param strings Table of shared strings
         * @param cols    Minimum number of columns to show
         * @param target  Sink for output
         */
        public MyXSSFSheetHandler(StylesTable styles,
                                  ReadOnlySharedStringsTable strings, int cols, PrintStream target,int start) {
            this.stylesTable = styles;
            this.sharedStringsTable = strings;
            this.minColumnCount = cols;
            this.output = target;
            this.value = new StringBuffer();
            this.nextDataType = xssfDataType.NUMBER;
            this.formatter = new DataFormatter();
            record = new String[this.minColumnCount];
            this.start=start;
            rows.clear();// 每次读取都清空行集合
        }
        /*
         * (non-Javadoc)
         *
         * @see
         * org.xml.sax.helpers.DefaultHandler#startElement(java.lang.String,
         * java.lang.String, java.lang.String, org.xml.sax.Attributes)
         */
        public void startElement(String uri, String localName, String name,
                                 Attributes attributes) throws SAXException {
            if ("inlineStr".equals(name) || "v".equals(name)) {
                vIsOpen = true;
                // Clear contents cache
                value.setLength(0);
            }
            // c => cell
            else if ("c".equals(name)) {
                // Get the cell reference
                String r = attributes.getValue("r");
                int firstDigit = -1;
                for (int c = 0; c < r.length(); ++c) {
                    if (Character.isDigit(r.charAt(c))) {
                        firstDigit = c;
                        break;
                    }
                }
                thisColumn = nameToColumn(r.substring(0, firstDigit));
                // Set up defaults.
                this.nextDataType = xssfDataType.NUMBER;
                this.formatIndex = -1;
                this.formatString = null;
                String cellType = attributes.getValue("t");
                String cellStyleStr = attributes.getValue("s");
                if ("b".equals(cellType))
                    nextDataType = xssfDataType.BOOL;
                else if ("e".equals(cellType))
                    nextDataType = xssfDataType.ERROR;
                else if ("inlineStr".equals(cellType))
                    nextDataType = xssfDataType.INLINESTR;
                else if ("s".equals(cellType))
                    nextDataType = xssfDataType.SSTINDEX;
                else if ("str".equals(cellType))
                    nextDataType = xssfDataType.FORMULA;
                else if (cellStyleStr != null) {
                    // It's a number, but almost certainly one
                    // with a special style or format
                    int styleIndex = Integer.parseInt(cellStyleStr);
                    XSSFCellStyle style = stylesTable.getStyleAt(styleIndex);
                    this.formatIndex = style.getDataFormat();
                    this.formatString = style.getDataFormatString();
                    if (this.formatString == null)
                        this.formatString = BuiltinFormats
                                .getBuiltinFormat(this.formatIndex);
                }
            }
        }
        /*
         * (non-Javadoc)
         *
         * @see org.xml.sax.helpers.DefaultHandler#endElement(java.lang.String,
         * java.lang.String, java.lang.String)
         */
        public void endElement(String uri, String localName, String name)
                throws SAXException {
            String thisStr = null;
            // v => contents of a cell
            if ("v".equals(name)) {
                // Process the value contents as required.
                // Do now, as characters() may be called more than once
                switch (nextDataType) {
                    case BOOL:
                        char first = value.charAt(0);
                        thisStr = first == '0' ? "FALSE" : "TRUE";
                        break;
                    case ERROR:
                        thisStr = "\"ERROR:" + value.toString() + '"';
                        break;
                    case FORMULA:
                        // A formula could result in a string value,
                        // so always add double-quote characters.
                        thisStr = '"' + value.toString() + '"';
                        break;
                    case INLINESTR:
                        // TODO: have seen an example of this, so it's untested.
                        XSSFRichTextString rtsi = new XSSFRichTextString(
                                value.toString());
                        thisStr = '"' + rtsi.toString() + '"';
                        break;
                    case SSTINDEX:
                        String sstIndex = value.toString();
                        try {
                            int idx = Integer.parseInt(sstIndex);
                            XSSFRichTextString rtss = new XSSFRichTextString(
                                    sharedStringsTable.getEntryAt(idx));
                            thisStr = '"' + rtss.toString() + '"';
                        } catch (NumberFormatException ex) {
                            output.println("Failed to parse SST index '" + sstIndex
                                    + "': " + ex.toString());
                        }
                        break;
                    case NUMBER:
                        String n = value.toString();
                        // 判断是否是日期格式
                        if (HSSFDateUtil.isADateFormat(this.formatIndex, n)) {
                            Double d = Double.parseDouble(n);
                            Date date = HSSFDateUtil.getJavaDate(d);
                            thisStr = formateDateToString(date);
                        } else if (this.formatString != null)
                            thisStr = formatter.formatRawCellContents(
                                    Double.parseDouble(n), this.formatIndex,
                                    this.formatString);
                        else
                            thisStr = n;
                        break;
                    default:
                        thisStr = "(TODO: Unexpected type: " + nextDataType + ")";
                        break;
                }
                // Output after we've seen the string contents
                // Emit commas for any fields that were missing on this row
                if (lastColumnNumber == -1) {
                    lastColumnNumber = 0;
                }
                //判断单元格的值是否为空
                if (thisStr == null || "".equals(thisStr)) {
                   // if(start==0){
                        isCellNull = true;// 设置单元格是否为空值
                    //}else{
                    //    if(thisColumn>3){
                    //        isCellNull = true;// 设置单元格是否为空值
                    //    }
                    // }
                }
                record[thisColumn] = thisStr;
                // Update column
                if (thisColumn > -1)
                    lastColumnNumber = thisColumn;
            } else if ("row".equals(name)) {
                // Print out any missing commas if needed
                if (minColumns > 0) {
                    // Columns are 0 based
                    if (lastColumnNumber == -1) {
                        lastColumnNumber = 0;
                    }
                    //if(start==0){
                        if (isCellNull == false )// 判断是否空行
                        {
                            rows.add(record.clone());
                            isCellNull = false;
                            for (int i = 0; i < record.length; i++) {
                                record[i] = null;
                            }
                        }
                   // }else{
//                        if (isCellNull == false && record[4] != null
//                                && record[3] != null)// 判断是否空行
//                        {
//                            rows.add(record.clone());
//                            isCellNull = false;
//                            for (int i = 0; i < record.length; i++) {
//                                record[i] = null;
//                            }
//                        }
//                    }
                }
                lastColumnNumber = -1;
            }
        }
        public List<String[]> getRows() {
            return rows;
        }
        public void setRows(List<String[]> rows) {
            this.rows = rows;
        }
        /**
         * Captures characters only if a suitable element is open. Originally
         * was just "v"; extended for inlineStr also.
         */
        public void characters(char[] ch, int start, int length)
                throws SAXException {
            if (vIsOpen)
                value.append(ch, start, length);
        }
        /**
         * Converts an Excel column name like "C" to a zero-based index.
         *
         * @param name
         * @return Index corresponding to the specified name
         */
        private int nameToColumn(String name) {
            int column = -1;
            for (int i = 0; i < name.length(); ++i) {
                int c = name.charAt(i);
                column = (column + 1) * 26 + c - 'A';
            }
            return column;
        }
        private String formateDateToString(Date date) {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//格式化日期
            return sdf.format(date);
        }
    }
    // /////////////////////////////////////
    private OPCPackage xlsxPackage;
    private int minColumns;
    private PrintStream output;
    private int start;
    /**
     * Creates a new XLSX -> CSV converter
     *
     * @param pkg        The XLSX package to process
     * @param output     The PrintStream to output the CSV to
     * @param minColumns The minimum number of columns to output, or -1 for no minimum
     */
    public ExcelUtilBigData(OPCPackage pkg, PrintStream output,
                            int minColumns, int start) {
        this.xlsxPackage = pkg;
        this.output = output;
        this.minColumns = minColumns;
        this.start=start;
    }
    /**
     * Parses and shows the content of one sheet using the specified styles and
     * shared-strings tables.
     *
     * @param styles
     * @param strings
     * @param sheetInputStream
     */
    public List<String[]> processSheet(StylesTable styles,
                                       ReadOnlySharedStringsTable strings, InputStream sheetInputStream)
            throws IOException, ParserConfigurationException, SAXException {
        InputSource sheetSource = new InputSource(sheetInputStream);
        SAXParserFactory saxFactory = SAXParserFactory.newInstance();
        SAXParser saxParser = saxFactory.newSAXParser();
        XMLReader sheetParser = saxParser.getXMLReader();
        MyXSSFSheetHandler handler = new MyXSSFSheetHandler(styles, strings,
                    this.minColumns, this.output,this.start);
        sheetParser.setContentHandler(handler);
        sheetParser.parse(sheetSource);
        return handler.getRows();
    }
    /**
     * 初始化这个处理程序 将
     *
     * @throws IOException
     * @throws OpenXML4JException
     * @throws ParserConfigurationException
     * @throws SAXException
     */
    public List<List<String[]>> process() throws IOException, OpenXML4JException,
            ParserConfigurationException, SAXException {
        ReadOnlySharedStringsTable strings = new ReadOnlySharedStringsTable(
                this.xlsxPackage);
        XSSFReader xssfReader = new XSSFReader(this.xlsxPackage);
        List<List<String[]>> returnlist = new ArrayList<List<String[]>>();
        List<String[]> list=null;
        StylesTable styles = xssfReader.getStylesTable();
        XSSFReader.SheetIterator iter = (XSSFReader.SheetIterator) xssfReader
                .getSheetsData();
        int index = 0;
        while (iter.hasNext()) {
            InputStream stream = iter.next();
            list = processSheet(styles, strings, stream);
            returnlist.add(list);
            stream.close();
            ++index;
        }
        return returnlist;
    }
    /**
     * 读取Excel
     *
     * @param in       文件路径
     * @param minColumns 列总数
     * @param start 判断起始行
     * @return
     * @throws SAXException
     * @throws ParserConfigurationException
     * @throws OpenXML4JException
     * @throws IOException
     */
    public static List<List<String[]>> readerExcel(InputStream
                                                           in, int minColumns,int start) throws IOException, OpenXML4JException,
            ParserConfigurationException, SAXException {
        OPCPackage p = OPCPackage.open(in);
        ExcelUtilBigData xlsx2csv = new ExcelUtilBigData(p, System.out,
                minColumns,start);
        List<List<String[]>> returnList = xlsx2csv.process();
        p.close();
        return returnList;
    }
//    public static void main(String[] args) throws Exception {
//        List<List<String[]>> list = ExcelUtilBigData
//                .readerExcel("F:\\公司\\健康之路\\工作文档\\标准编辑器\\机构数据字典.xlsx", 3);
//        for (List<String[]> l:list){
//            for (String[] record : l) {
//                for (String cell : record) {
//                    System.out.print(cell + "  ");
//                }
//                System.out.println();
//            }
//        }
  //  }
}

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

@@ -0,0 +1,100 @@
package com.yihu.jw.basic.util;
/**
 * Created by Administrator on 2016/6/28.
 */
public class GetChineseFirst {
    // 简体中文的编码范围从B0A1（45217）一直到F7FE（63486）
    private static int BEGIN = 45217;
    private static int END = 63486;
    // 按照声 母表示，这个表是在GB2312中的出现的第一个汉字，也就是说“啊”是代表首字母a的第一个汉字。
    // i, u, v都不做声母, 自定规则跟随前面的字母
    private static char[] chartable = { '啊', '芭', '擦', '搭', '蛾', '发', '噶', '哈', '哈', '击', '喀', '垃', '妈', '拿', '哦', '啪', '期', '然', '撒', '塌', '塌', '塌', '挖', '昔', '压', '匝', };
    // 二十六个字母区间对应二十七个端点
    // GB2312码汉字区间十进制表示
    private static int[] table = new int[27];
    // 对应首字母区间表
    private static char[] initialtable = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'h', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 't', 't', 'w', 'x', 'y', 'z', };
    // 初始化
    static {
        for (int i = 0; i < 26; i++) {
            table[i] = gbValue(chartable[i]);// 得到GB2312码的首字母区间端点表，十进制。
        }
        table[26] = END;// 区间表结尾
    }
    // ------------------------public方法区------------------------
    // 根据一个包含汉字的字符串返回一个汉字拼音首字母的字符串 最重要的一个方法，思路如下：一个个字符读入、判断、输出
    public static String cn2py(String SourceStr) {
        String Result = "";
        int StrLength = SourceStr.length();
        int i;
        try {
            for (i = 0; i < StrLength; i++) {
                Result += Char2Initial(SourceStr.charAt(i));
            }
        } catch (Exception e) {
            Result = "";
            e.printStackTrace();
        }
        return Result;
    }
    // ------------------------private方法区------------------------
    /**
     * 输入字符,得到他的声母,英文字母返回对应的大写字母,其他非简体汉字返回 '0' 　　* 　　
     */
    private static char Char2Initial(char ch) {
        // 对英文字母的处理：小写字母转换为大写，大写的直接返回
        if (ch >= 'a' && ch <= 'z') {
            return (char) (ch - 'a' + 'A');
        }
        if (ch >= 'A' && ch <= 'Z') {
            return ch;
        }
        // 对非英文字母的处理：转化为首字母，然后判断是否在码表范围内，
        // 若不是，则直接返回。
        // 若是，则在码表内的进行判断。
        int gb = gbValue(ch);// 汉字转换首字母
        if ((gb < BEGIN) || (gb > END))// 在码表区间之前，直接返回
        {
            return ch;
        }
        int i;
        for (i = 0; i < 26; i++) {// 判断匹配码表区间，匹配到就break,判断区间形如“[,)”
            if ((gb >= table[i]) && (gb < table[i + 1])) {
                break;
            }
        }
        if (gb == END) {// 补上GB2312区间最右端
            i = 25;
        }
        return initialtable[i]; // 在码表区间中，返回首字母
    }
    /**
     * 取出汉字的编码 cn 汉字 　　
     */
    private static int gbValue(char ch) {// 将一个汉字（GB2312）转换为十进制表示。
        String str = new String();
        str += ch;
        try {
            byte[] bytes = str.getBytes("GB2312");
            if (bytes.length < 2) {
                return 0;
            }
            return (bytes[0] << 8 & 0xff00) + (bytes[1] & 0xff);
        } catch (Exception e) {
            return 0;
        }
    }
    public static void main(String[] args) throws Exception {
       // System.out.println(cn2py("陈伟达"));
    }
}

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

@@ -0,0 +1,28 @@
package com.yihu.jw.basic.util;
import java.util.*;
/**
 * Created by Administrator on 2016/7/13.
 */
public class LikeHashMap<K, V> extends HashMap<K, V> {
    public V get(String key, boolean like) {
        List<V> list = null;
        if (like) {
            list = new ArrayList<V>();
            K[] a = null;
            Set<K> set = this.keySet();
            a = (K[])set.toArray();
            Arrays.sort(a, null);
            for (int i = 0; i < a.length; i++) {
                if (a[i].toString().indexOf(key) == -1) {
                    continue;
                } else {
                   return this.get(a[i]);
                }
            }
        }
        return null;
    }
}

svr/svr-basic/src/main/resources/bootstrap.yml

@@ -1,6 +1,6 @@
spring:
  application:
    name: svr-basic
    name: svr-basic-ysj
  cloud:
    config:
      failFast: true