Jelajahi Sumber

Merge remote-tracking branch 'origin/develop' into develop

lijie 3 tahun lalu
induk
melakukan
1236667ca8

+ 1 - 1
src/main/java/com/persagy/proxy/dictionary/service/impl/AdmDictServiceImpl.java

@@ -587,7 +587,7 @@ public class AdmDictServiceImpl<T> extends AbstractAdmDictBaseServiceImpl<T> imp
         }else{
             criteria.setFilters("groupCode = '"+context.getGroupCode()+"' and projectId = '"+context.getProjectId()+"'");
         }
-        //criteria.setName(classCode);
+        criteria.setName(classCode);
         AdmResponse admResponse = doQueryObjectInfoCollect(context, criteria, "classCode", clazz);
         return (List<ObjectInfoCollect>) admResponse.getContent();
     }

+ 3 - 3
src/main/java/com/persagy/proxy/migration/constant/MigrationTable.java

@@ -7,10 +7,10 @@ package com.persagy.proxy.migration.constant;
  * @date 2021/12/2 12:24
  */
 public enum MigrationTable {
-    DTDEFINETYPE("dt_define_type","对象类型定义"),
+    DTDEFINETYPE("dt_define_type","对象类型定义"),
     DTDEFINEINFO("dt_define_info","信息点定义表"),
-    DTOBJECT("dt_object","对象实例"),
-    DTRALATION("dt_relation","关系实例表"),
+    DTOBJECT("dt_object","对象实例"),
+    DTRELATION("dt_relation","关系实例表"),
     //DTDEFINEGRAPH("dt_define_graph","图类型表"),
     //DTDEFINEREL("dt_define_rel","边类型表"),
     //DTDEFINEINFOCOLLECT("dt_define_info_collect","采集信息点配置表"),

+ 143 - 68
src/main/java/com/persagy/proxy/migration/controller/DataMigrationController.java

@@ -2,7 +2,6 @@ package com.persagy.proxy.migration.controller;
 
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.util.StrUtil;
-import cn.hutool.http.HttpException;
 import cn.hutool.http.HttpUtil;
 import cn.hutool.json.JSONUtil;
 import com.alibaba.excel.EasyExcel;
@@ -32,7 +31,10 @@ import com.persagy.proxy.object.model.AdmProject;
 import com.persagy.proxy.object.service.IAdmProjectService;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.web.bind.annotation.*;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
 
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
@@ -58,20 +60,21 @@ public class DataMigrationController {
     private final IAdmProjectService projectService;
 
     /**
+     * 导出待迁移的数据信息
      *
      * @param response
      * @migrationInfo :
      *  targetUrl  现场中台调用的url, eg:http://develop.persagy.com/dmp-rwd
      *  targetGroupCode 现场集团编码
      *  targetProjectId 现场项目id
+     *
+     *  return excel
      */
     @PostMapping("/excel")
     public void migrateForExcel(HttpServletResponse response, @RequestBody MigrationInfo migrationInfo) {
         //调用服务迁移数据,返回处理结果excel
         try {
-            response.setContentType("application/vnd.ms-excel");
-            String encode = StandardCharsets.UTF_8.name();
-            response.setCharacterEncoding(encode);
+
             if (migrationInfo == null || StrUtil.isBlank(migrationInfo.getTargetUrl())) {
                 throw new BusinessException(ResponseCode.A0402.getCode(), ResponseCode.A0402.getDesc());
             }
@@ -79,49 +82,38 @@ public class DataMigrationController {
             //确定集团编码 和 项目id
             ensureParamValue(migrationInfo, context);
             //验证目标项目地址是否正确
-            boolean valid = validTargetUrl(migrationInfo, context);
-            if (!valid) {
-                getErrorExcel(response);
-            }
-
-            AdmQueryCriteria projectRequest = new AdmQueryCriteria();
-            projectRequest.setName(AdmProject.OBJ_TYPE);
-            projectRequest.setFilters("id = '" + context.getProjectId() + "';");
-            AdmResponse responsePro = projectService.doQuery(AdmContextUtil.toDmpContext(), projectRequest, AdmProject.class);
-
-            if (CollUtil.isEmpty(responsePro.getContent())) {
-                throw new BusinessException(ResponseCode.A0402.getCode(), ResponseCode.A0402.getDesc());
-            } else {
-                AdmProject admProject = (AdmProject) responsePro.getContent().get(0);
-                // 防止中文乱码
-                String fileName = admProject.getLocalName() + "_数据迁移";
-
-                fileName = URLEncoder.encode(fileName, encode);
-
-                response.setHeader("Content-disposition", "attachment;filename=" + fileName + ".xlsx");
-                Map<String, List<DataMigrationExcel>> results = dataMigrationHandler.handleAndGetExcelList(context, migrationInfo);
-                //每个迁移的表写成一个sheet
-                if (CollUtil.isNotEmpty(results)) {
-                    int sheetNo = 0;
-                    ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream(), DataMigrationExcel.class).build();
-                    try {
-                        for (String sheet : results.keySet()) {
-                            WriteSheet writeSheet = EasyExcel.writerSheet(sheetNo, sheet).build();
-                            excelWriter.write(results.get(sheet), writeSheet);
-                            sheetNo++;
-                        }
-                    } finally {
-                        if (excelWriter != null) {
-                            excelWriter.finish();
-                        }
-                    }
+            try {
+                boolean valid = validTargetUrl(migrationInfo, context);
+                if (!valid) {
+                    getErrorExcel(response, MigrationConstant.ERROR);
+                } else {
+                    //导出数据
+                    processDataForExcel(response, migrationInfo, context);
                 }
+            }catch (cn.hutool.http.HttpException e)   {
+                getErrorExcel(response, e.getMessage());
+
+            } catch (Exception e) {
+                e.printStackTrace();
+                getErrorExcel(response, MigrationConstant.ERROR);
             }
+
         } catch (Exception e) {
-            getErrorExcel(response);
+            e.printStackTrace();
+            getErrorExcel(response, e.getMessage());
         }
     }
 
+    /**
+     * 迁移数据,结果入库
+     *
+     * @migrationInfo :
+     *  targetUrl  现场中台调用的url, eg:http://develop.persagy.com/dmp-rwd
+     *  targetGroupCode 现场集团编码
+     *  targetProjectId 现场项目id
+     *
+     *  return AdmResponse
+     */
     @PostMapping("/start")
     public AdmResponse migrateForLog(@RequestBody MigrationInfo migrationInfo) {
         InstanceUrlParam context = AdmContextUtil.toDmpContext();
@@ -132,14 +124,49 @@ public class DataMigrationController {
         //确定集团编码 和 项目id
         ensureParamValue(migrationInfo, context);
         //验证目标项目地址是否正确
-        boolean valid = validTargetUrl(migrationInfo, context);
-        if(!valid){
-            return AdmResponse.failure(MigrationConstant.ERROR);
+        try {
+            boolean valid = validTargetUrl(migrationInfo, context);
+            if(!valid){
+                return AdmResponse.failure(MigrationConstant.ERROR);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            return AdmResponse.failure(MigrationConstant.ERROR +":"+ e.getMessage());
         }
+
         dataMigrationHandler.handleAndSaveLog(context, migrationInfo);
+
+        AdmQueryCriteria admQueryCriteria = new AdmQueryCriteria();
+        admQueryCriteria.addFilters("targetId = 'error'");
+        admQueryCriteria.addFilters("projectId = '" + context.getProjectId() + "'");
+        admQueryCriteria.setOnlyCount(true);
+        AdmResponse response = queryMigrateForLog(admQueryCriteria);
+        if(response.getMessage().equals(DmpResult.SUCCESS) && response.getCount() > 5){
+            return AdmResponse.failure("出现错误次数:"+ response.getCount()+"次,请使用导出检查数据是否迁移成功");
+        }
         return AdmResponse.success();
     }
 
+    /**
+     * 迁移数据,执行脚本获取
+     */
+    public void getMigrateSqlFile(){
+
+    }
+
+    /**
+     * 获取迁移数据日志
+     *
+     * @AdmQueryCriteria
+     * {
+     *     "order": "lastUpdate asc, objId asc",
+     *     "pageNumber": 1,
+     *     "pageSize": 15,
+     *     "filters": "projectId='Pj9909990004';sign=2;type='create';objectType='building'"
+     * }
+     *
+     *  return AdmResponse
+     */
     @PostMapping("/log")
     public AdmResponse queryMigrateForLog(@RequestBody AdmQueryCriteria request) {
         QueryCriteria queryCriteria = AdmQueryCriteriaHelper.toDmpCriteria(request);
@@ -167,6 +194,8 @@ public class DataMigrationController {
     }
 
 
+
+
     private void ensureParamValue(MigrationInfo migrationInfo, InstanceUrlParam context){
         if(migrationInfo.getTargetSign() == 0){
             migrationInfo.setTargetGroupCode(context.getGroupCode());
@@ -183,8 +212,7 @@ public class DataMigrationController {
 
     }
 
-    private boolean validTargetUrl(MigrationInfo migrationInfo, InstanceUrlParam context){
-
+    private boolean validTargetUrl(MigrationInfo migrationInfo, InstanceUrlParam context) throws Exception{
         StringBuffer url = new StringBuffer(migrationInfo.getTargetUrl() + MigrationConstant.DT_OBJECT);
         url.append("groupCode=").append(migrationInfo.getTargetGroupCode());
         url.append("&projectId=").append(migrationInfo.getTargetProjectId());
@@ -201,34 +229,27 @@ public class DataMigrationController {
         criteria.put("objType", MigrationObjType.project.getCode());
         queryCriteria.setCriteria(criteria);
 
-        try{
-            String requestBody = null;
-            try {
-                requestBody = JsonHelper.toJsonStr(queryCriteria);
-            } catch (IOException e) {
-                log.error("参数转化失败(QueryCriteria -> jsonString)"+ e.getMessage());
-                return false;
-            }
-            String response = HttpUtil.post(url.toString(), requestBody, 3000);
-            CommonResult<List> commonResult = JSONUtil.toBean(response, CommonResult.class);
-            if(commonResult.getResult().equals(DmpResult.SUCCESS) && commonResult.getCount() == 1 ){
-                return true;
-            }else {
-                log.error(commonResult.getMessage());
-                return false;
-            }
-
-        }catch (HttpException e){
-            log.error(ResponseCode.C0001.getDesc()+",url:"+ url);
+        String requestBody = JsonHelper.toJsonStr(queryCriteria);
+        String response = HttpUtil.post(url.toString(), requestBody, 3000);
+        if(StrUtil.isNotEmpty(response) && response.contains("<!DOCTYPE html>")|| response.equals("Bad Gateway")){
             return false;
         }
+        CommonResult<List> commonResult = JSONUtil.toBean(response, CommonResult.class);
+        if(commonResult.getResult().equals(DmpResult.SUCCESS)){
+            return true;
+        }
+        return false;
     }
 
-    private void getErrorExcel(HttpServletResponse response){
+    private void getErrorExcel(HttpServletResponse response, String errorMsg){
+        response.setContentType("application/vnd.ms-excel");
+        String encode = StandardCharsets.UTF_8.name();
+        response.setCharacterEncoding(encode);
+
         List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>(1);
         DataMigrationExcel dataMigrationExcel = new DataMigrationExcel();
         dataMigrationExcel.setId("error");
-        dataMigrationExcel.setMark(MigrationConstant.ERROR);
+        dataMigrationExcel.setMark(errorMsg);
         dataMigrationExcels.add(dataMigrationExcel);
         response.setHeader("Content-disposition", "attachment;filename=error.xlsx");
         try {
@@ -237,4 +258,58 @@ public class DataMigrationController {
             e.printStackTrace();
         }
     }
+
+    private void processDataForExcel (HttpServletResponse response, MigrationInfo migrationInfo, InstanceUrlParam context) throws IOException{
+        response.setContentType("application/vnd.ms-excel");
+        String encode = StandardCharsets.UTF_8.name();
+        response.setCharacterEncoding(encode);
+        AdmQueryCriteria projectRequest = new AdmQueryCriteria();
+        projectRequest.setName(AdmProject.OBJ_TYPE);
+        projectRequest.setFilters("id = '" + context.getProjectId() + "';");
+        AdmResponse responsePro = projectService.doQuery(AdmContextUtil.toDmpContext(), projectRequest, AdmProject.class);
+
+        if (CollUtil.isEmpty(responsePro.getContent())) {
+            throw new BusinessException(ResponseCode.A0402.getCode(), ResponseCode.A0402.getDesc());
+        } else {
+            AdmProject admProject = (AdmProject) responsePro.getContent().get(0);
+            // 防止中文乱码
+            String fileName = admProject.getLocalName() + "_数据迁移";
+
+            fileName = URLEncoder.encode(fileName, encode);
+
+            response.setHeader("Content-disposition", "attachment;filename=" + fileName + ".xlsx");
+            //验证字典 defineType defineInfo
+            Map<String, List<DataMigrationExcel>> validRes = dataMigrationHandler.handleDicData(context, migrationInfo);
+            //字典验证失败
+            try {
+                if(CollUtil.isNotEmpty(validRes) && CollUtil.isNotEmpty(validRes.keySet())){
+                    returnExcel(response, validRes);
+                }else{
+                    Map<String, List<DataMigrationExcel>> results = dataMigrationHandler.handleAndGetExcelList(context, migrationInfo);
+                    //每个迁移的表写成一个sheet
+                    if (CollUtil.isNotEmpty(results)) {
+                        returnExcel(response, results);
+                    }
+                }
+            }catch (Exception e){
+                throw new BusinessException(e);
+            }
+        }
+    }
+
+    private void returnExcel(HttpServletResponse response, Map<String, List<DataMigrationExcel>> results) throws Exception{
+        int sheetNo = 0;
+        ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream(), DataMigrationExcel.class).build();
+        try {
+            for (String sheet : results.keySet()) {
+                WriteSheet writeSheet = EasyExcel.writerSheet(sheetNo, sheet).build();
+                excelWriter.write(results.get(sheet), writeSheet);
+                sheetNo++;
+            }
+        } finally {
+            if (excelWriter != null) {
+                excelWriter.finish();
+            }
+        }
+    }
 }

+ 39 - 4
src/main/java/com/persagy/proxy/migration/handler/DataMigrationHandler.java

@@ -1,6 +1,8 @@
 package com.persagy.proxy.migration.handler;
 
 import cn.hutool.core.collection.CollUtil;
+import com.persagy.proxy.adm.request.AdmResponse;
+import com.persagy.proxy.common.entity.DmpResult;
 import com.persagy.proxy.common.entity.InstanceUrlParam;
 import com.persagy.proxy.migration.constant.MigrationTable;
 import com.persagy.proxy.migration.model.DataMigrationExcel;
@@ -8,9 +10,7 @@ import com.persagy.proxy.migration.model.MigrationInfo;
 import org.springframework.stereotype.Component;
 
 import javax.annotation.PostConstruct;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 /**
  * @author lvxianyun
@@ -19,10 +19,40 @@ import java.util.Map;
  * @date 2021/12/3 11:14
  */
 @Component
+
 public class DataMigrationHandler {
 
     private static Map<String, IDataMigration> migrationMap = new HashMap<>(16);
 
+    /**
+     * 检查标准字典数据,据此判断是否需要提示用户升级字典
+     * @param context
+     * @param migrationInfo
+     */
+    public Map<String, List<DataMigrationExcel>> handleDicData(InstanceUrlParam context, MigrationInfo migrationInfo){
+        Map<String,List<DataMigrationExcel>> results = new HashMap<>(2);
+        AdmResponse admResponseType = DefineTypeMigration.getInstance().compareByCount(context, migrationInfo);
+
+        if(!admResponseType.getResult().equals(DmpResult.SUCCESS)){
+            List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
+            dataMigrationExcels.addAll((Collection<? extends DataMigrationExcel>) admResponseType.getContent());
+            results.put(MigrationTable.DTDEFINETYPE.getCode(), dataMigrationExcels);
+        }
+        AdmResponse admResponseInfo = DefineInfoMigration.getInstance().compareByCount(context, migrationInfo);
+        if(!admResponseInfo.getResult().equals(DmpResult.SUCCESS)){
+            List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
+            dataMigrationExcels.addAll((Collection<? extends DataMigrationExcel>) admResponseInfo.getContent());
+            results.put(MigrationTable.DTDEFINEINFO.getCode(), dataMigrationExcels);
+        }
+        return results;
+    }
+
+    /**
+     * 获取迁移数据信息
+     * @param context
+     * @param migrationInfo
+     * @return
+     */
     public Map<String, List<DataMigrationExcel>> handleAndGetExcelList(InstanceUrlParam context, MigrationInfo migrationInfo){
         Map<String,List<DataMigrationExcel>> results = new HashMap<>(16);
         if(CollUtil.isNotEmpty(migrationMap)){
@@ -36,6 +66,11 @@ public class DataMigrationHandler {
         return results;
     }
 
+    /**
+     * 迁移数据记录日志
+     * @param context
+     * @param migrationInfo
+     */
     public void handleAndSaveLog(InstanceUrlParam context, MigrationInfo migrationInfo){
         if(CollUtil.isNotEmpty(migrationMap)){
             for (MigrationTable migrationTable : MigrationTable.values()){
@@ -56,6 +91,6 @@ public class DataMigrationHandler {
         addMap(MigrationTable.DTDEFINETYPE.getCode(), DefineTypeMigration.getInstance());
         addMap(MigrationTable.DTDEFINEINFO.getCode(), DefineInfoMigration.getInstance());
         addMap(MigrationTable.DTOBJECT.getCode(), ObjectDigitalMigration.getInstance());
-        addMap(MigrationTable.DTRALATION.getCode(), ObjectRelationMigration.getInstance());
+        addMap(MigrationTable.DTRELATION.getCode(), ObjectRelationMigration.getInstance());
     }
 }

+ 189 - 66
src/main/java/com/persagy/proxy/migration/handler/DefineInfoMigration.java

@@ -33,7 +33,7 @@ import java.util.stream.Collectors;
  * @date 2021/12/8 17:28
  */
 @Slf4j
-public class DefineInfoMigration extends MigrationAbstractServiceImpl<ObjectInfoDefine> implements IDataMigration, IDataMigrationProcess<ObjectInfoDefine> {
+public class DefineInfoMigration extends MigrationAbstractServiceImpl<ObjectInfoDefine> implements IDataMigration, IDefineDataMigration<ObjectInfoDefine>, IDataMigrationProcess<ObjectInfoDefine> {
     
     private static DefineInfoMigration instance;
 
@@ -51,7 +51,6 @@ public class DefineInfoMigration extends MigrationAbstractServiceImpl<ObjectInfo
         return instance;
     }
 
-
     /**
      * 数据迁移
      *
@@ -61,68 +60,13 @@ public class DefineInfoMigration extends MigrationAbstractServiceImpl<ObjectInfo
      */
     @Override
     public List<DataMigrationExcel> migrateForExcel(InstanceUrlParam context, MigrationInfo migrationInfo) {
-        log.info("######################### DefineInfo 数据迁移内容获取开始 #########################");
-        long start = System.currentTimeMillis();
-        List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
-
-        QueryCriteria queryCriteria = getQueryCriteria();
+        log.info("######################### ObjectInfoDefine 数据迁移内容获取开始 #########################");
+        QueryCriteria queryCriteria = getCustomQueryCriteria();
         List<ObjectInfoDefine> admDefineList = getAdmData(context, queryCriteria);
         String queryUrl = requestUrl(context, migrationInfo, MigrationType.QUERY.getCode());
         List<ObjectInfoDefine> projectDefineList = getProjectData(queryCriteria, ObjectInfoDefine.class, queryUrl);
-
-        if(CollUtil.isEmpty(admDefineList)){
-            log.error(" ######################### DefineInfo adm已交付需要同步的数据:"+ ResponseCode.C0320.getDesc() +" 同步结束 #########################");
-            return dataMigrationExcels;
-        }
-        //String insertUrl = requestUrl(context, migrationInfo, MigrationType.INSERT.getCode());
-        if(CollUtil.isEmpty(projectDefineList)){
-            log.info("######################### DefineInfo 获取批量插入数据 #########################");
-            //DataMigrationResponse response = insertBatch(admDefineList, ObjectInfoDefine.class, insertUrl);
-            dataMigrationExcels.addAll(processDataForExcel(admDefineList, MigrationType.CREATE.getCode()));
-            return dataMigrationExcels;
-        }
-        List<ObjectNode> objectNodeListPro = JsonNodeUtils.toListNode(projectDefineList, null, null);
-        Map<String,Object> projectDefineMap = toEntityMap(objectNodeListPro, ObjectInfoDefine.class);
-        List<ObjectNode> objectNodeListAdm = JsonNodeUtils.toListNode(admDefineList, null, null);
-        Map<String,Object> admDefineMap = toEntityMap(objectNodeListAdm, ObjectInfoDefine.class);
-
-
-        //差集 新增
-        log.info("######################### DefineInfo 获取批量插入数据 #########################");
-        Map<String,Object> subtractFromDel = doSubtractAdd(admDefineMap, projectDefineMap);
-        if(!CollUtil.isEmpty(subtractFromDel)){
-            List<ObjectInfoDefine> insertData = toList(subtractFromDel, admDefineList);
-            dataMigrationExcels.addAll(processDataForExcel(insertData, MigrationType.CREATE.getCode()));
-        }
-
-        //差集 删除
-        log.info("######################### DefineInfo 获取批量处理删除数据 #########################");
-        Map<String,Object> subtractFromDelete = doSubtractDel(admDefineMap, projectDefineMap);
-        if(!CollUtil.isEmpty(subtractFromDelete)){
-            List<String> deleteIds = subtractFromDelete.entrySet().stream().map(en -> en.getKey()).collect(Collectors.toList());
-            //String delUrl = requestUrl(context, migrationInfo, MigrationType.DELETE.getCode());
-            //DataMigrationResponse response = deleteBatch(deleteIds, ObjectInfoDefine.class, delUrl);
-            List<ObjectInfoDefine> delData = toListByIds(deleteIds, admDefineList);
-            dataMigrationExcels.addAll(processDataForExcel(delData, MigrationType.DELETE.getCode()));
-        }
-
-        //交集更新
-        log.info("######################### DefineInfo 获取批量处理更新数据 #########################");
-        Map<String,Object> intersectionUpdateFrom = doIntersectionGetFrom(admDefineMap, projectDefineMap);
-        Map<String,Object> intersectionUpdateTo = doIntersectionGetTo(admDefineMap, projectDefineMap);
-
-        if(!CollUtil.isEmpty(intersectionUpdateFrom) && !CollUtil.isEmpty(intersectionUpdateTo)){
-            Map<String, Object> compareData = compareData(intersectionUpdateFrom, intersectionUpdateTo);
-            if(CollUtil.isNotEmpty(compareData) && compareData.size() > 0){
-                List<ObjectInfoDefine> updateData = toList(compareData, admDefineList);
-                //String updateUrl = requestUrl(context, migrationInfo, MigrationType.UPDATE.getCode());
-                //updateBatch(updateData, ObjectInfoDefine.class, updateUrl)
-                dataMigrationExcels.addAll(processDataForExcel(updateData, MigrationType.UPDATE.getCode()));
-            }
-        }
-        long end = System.currentTimeMillis();
-        log.info("######################### DefineInfo 数据迁移内容获取已结束 时间:"+(end-start)+" #########################");
-
+        List<DataMigrationExcel> dataMigrationExcels = compareByData(admDefineList, projectDefineList);
+        log.info("######################### ObjectInfoDefine 数据迁移内容获取结束 #########################");
         return dataMigrationExcels;
     }
 
@@ -132,7 +76,7 @@ public class DefineInfoMigration extends MigrationAbstractServiceImpl<ObjectInfo
         long start = System.currentTimeMillis();
         List<SyncData> syncDataList = new ArrayList<>();
 
-        QueryCriteria queryCriteria = getQueryCriteria();
+        QueryCriteria queryCriteria = getCustomQueryCriteria();
 
         List<ObjectInfoDefine> admDefineList = getAdmData(context, queryCriteria);
         String queryUrl = requestUrl(context, migrationInfo, MigrationType.QUERY.getCode());
@@ -170,7 +114,7 @@ public class DefineInfoMigration extends MigrationAbstractServiceImpl<ObjectInfo
             //处理删除的数据
             DataMigrationResponse dataMigrationResponse = deleteBatch(deleteIds, ObjectInfoDefine.class, delUrl);
             List<String> successIds = (List<String>) dataMigrationResponse.getData();
-            List<ObjectInfoDefine> delObjs = toListByIds(successIds, admDefineList);
+            List<ObjectInfoDefine> delObjs = toListByIds(successIds, projectDefineList);
             dataMigrationResponse.setData(delObjs);
             syncDataList.addAll(processDataForLog(dataMigrationResponse, MigrationType.DELETE.getCode()));
         }
@@ -229,7 +173,11 @@ public class DefineInfoMigration extends MigrationAbstractServiceImpl<ObjectInfo
         List<ObjectInfoDefine> results = new ArrayList<>(ids.size());
         Map<String, ObjectInfoDefine> objectInfoDefineMap = CollUtil.fieldValueMap(fromList, BaseEntity.PROP_ID);
         for(String key : ids){
-            results.add(objectInfoDefineMap.get(key));
+            ObjectInfoDefine define = objectInfoDefineMap.get(key);
+            if (define!= null) {
+                results.add(define);
+            }
+
         }
         return results;
     }
@@ -317,12 +265,170 @@ public class DefineInfoMigration extends MigrationAbstractServiceImpl<ObjectInfo
         return syncDataList;
     }
 
+    /**
+     * 获取标准字典数量,默认获取有效数据
+     *
+     * @param context
+     * @param queryCriteria
+     * @return count
+     */
+    @Override
+    public Long getAdmCountData(InstanceUrlParam context, QueryCriteria queryCriteria) {
+        Long count = DigitalObjectInfoFacade.queryForCount(context.getGroupCode(),context.getProjectId(),context.getUserId(),context.getUserId(),queryCriteria);
+        return count;
+    }
+
+    /**
+     * 标准字典 根据整体数量进行比较
+     *
+     * @param context
+     * @param migrationInfo
+     * @return AdmResponse
+     */
+    @Override
+    public AdmResponse compareByCount(InstanceUrlParam context, MigrationInfo migrationInfo) {
+        QueryCriteria queryCriteria = getCriterionQueryCriteria();
+        queryCriteria.setOnlyCount(true);
+        long admCont = getAdmCountData(context, queryCriteria);
+
+        String queryUrl = requestUrl(context, migrationInfo, MigrationType.QUERY.getCode());
+        long proCount = queryCountByHttp(queryUrl, queryCriteria);
+        //是否需要更新字典
+        boolean needUpdateDic = true;
+        List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
+        if(admCont - proCount == 0){
+            //TODO 对比标准字典数据
+           /* dataMigrationExcels = compareCriterionByData(context, migrationInfo, admCont);
+            if(CollUtil.isEmpty(dataMigrationExcels)){
+                needUpdateDic = false;
+            }*/
+            needUpdateDic = false;
+        }
+        //验证失败 需要更新字典
+        if(needUpdateDic){
+            String msg = "交付数据标准字典与项目现场标准字典不匹配(数量不一致),请联系管理者确认是否需要字典升级";
+            AdmResponse admResponse = AdmResponse.failure(msg);
+            DataMigrationExcel dataMigrationExcel = new DataMigrationExcel();
+            dataMigrationExcel.setId("error");
+            dataMigrationExcel.setName(msg);
+            dataMigrationExcels.add(dataMigrationExcel);
+            admResponse.setContent(dataMigrationExcels);
+             return admResponse;
+        }else{
+            return AdmResponse.success();
+        }
+    }
 
-    private QueryCriteria getQueryCriteria(){
+    /**
+     * 标准字典 根据整体数据进行逐条对比
+     *
+     * @param context
+     * @param migrationInfo
+     * @return AdmResponse
+     */
+    @Override
+    public List<DataMigrationExcel> compareCriterionByData(InstanceUrlParam context, MigrationInfo migrationInfo) {
+        log.info("######################### ObjectInfoDefine 数据迁移 标准字典验证 开始 #########################");
+        QueryCriteria queryCriteria = getCriterionQueryCriteria();
+        List<ObjectInfoDefine> admDefineList = getAdmData(context, queryCriteria);
+        String queryUrl = requestUrl(context, migrationInfo, MigrationType.QUERY.getCode());
+        List<ObjectInfoDefine> projectDefineList = getProjectData(queryCriteria, ObjectInfoDefine.class, queryUrl);
+        List<DataMigrationExcel> dataMigrationExcels = compareByData(admDefineList, projectDefineList);
+        log.info("######################### ObjectInfoDefine 数据迁移 标准字典验证 结束 #########################");
+        return dataMigrationExcels;
+    }
+
+    public List<DataMigrationExcel> compareCriterionByData(InstanceUrlParam context, MigrationInfo migrationInfo, long totalCount) {
+        log.info("######################### ObjectInfoDefine 数据迁移 标准字典验证 开始 #########################");
+        QueryCriteria queryCriteria = getCriterionQueryCriteria();
+        queryCriteria.setSize(10000l);
+        long pages = 1l;
+        if(totalCount > 10000){
+            pages = totalCount / 10000 + 1;
+        }
+        List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
+        for(long page = 1; page < pages; page++){
+            queryCriteria.setPage(page);
+            List<ObjectInfoDefine> admDefineList = getAdmData(context, queryCriteria);
+            String queryUrl = requestUrl(context, migrationInfo, MigrationType.QUERY.getCode());
+            List<ObjectInfoDefine> projectDefineList = getProjectData(queryCriteria, ObjectInfoDefine.class, queryUrl);
+            dataMigrationExcels.addAll(compareByData(admDefineList, projectDefineList));
+        }
+
+        log.info("######################### ObjectInfoDefine 数据迁移 标准字典验证 结束 #########################");
+        return dataMigrationExcels;
+    }
+
+    @Override
+    public List<DataMigrationExcel> compareByData(List<ObjectInfoDefine> admDefineList, List<ObjectInfoDefine> projectDefineList) {
+        log.info("######################### DefineInfo 数据迁移内容获取开始 #########################");
+        long start = System.currentTimeMillis();
+        List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
+
+        if(CollUtil.isEmpty(admDefineList)){
+            log.error(" ######################### DefineInfo adm已交付需要同步的数据:"+ ResponseCode.C0320.getDesc() +" 同步结束 #########################");
+            return dataMigrationExcels;
+        }
+        //String insertUrl = requestUrl(context, migrationInfo, MigrationType.INSERT.getCode());
+        if(CollUtil.isEmpty(projectDefineList)){
+            log.info("######################### DefineInfo 获取批量插入数据 #########################");
+            //DataMigrationResponse response = insertBatch(admDefineList, ObjectInfoDefine.class, insertUrl);
+            dataMigrationExcels.addAll(processDataForExcel(admDefineList, MigrationType.CREATE.getCode()));
+            return dataMigrationExcels;
+        }
+        List<ObjectNode> objectNodeListPro = JsonNodeUtils.toListNode(projectDefineList, null, null);
+        Map<String,Object> projectDefineMap = toEntityMap(objectNodeListPro, ObjectInfoDefine.class);
+        List<ObjectNode> objectNodeListAdm = JsonNodeUtils.toListNode(admDefineList, null, null);
+        Map<String,Object> admDefineMap = toEntityMap(objectNodeListAdm, ObjectInfoDefine.class);
+
+
+        //差集 新增
+        log.info("######################### DefineInfo 获取批量插入数据 #########################");
+        Map<String,Object> subtractFromDel = doSubtractAdd(admDefineMap, projectDefineMap);
+        if(!CollUtil.isEmpty(subtractFromDel)){
+            List<ObjectInfoDefine> insertData = toList(subtractFromDel, admDefineList);
+            dataMigrationExcels.addAll(processDataForExcel(insertData, MigrationType.CREATE.getCode()));
+        }
+
+        //差集 删除
+        log.info("######################### DefineInfo 获取批量处理删除数据 #########################");
+        Map<String,Object> subtractFromDelete = doSubtractDel(admDefineMap, projectDefineMap);
+        if(!CollUtil.isEmpty(subtractFromDelete)){
+            List<String> deleteIds = subtractFromDelete.entrySet().stream().map(en -> en.getKey()).collect(Collectors.toList());
+            //String delUrl = requestUrl(context, migrationInfo, MigrationType.DELETE.getCode());
+            //DataMigrationResponse response = deleteBatch(deleteIds, ObjectInfoDefine.class, delUrl);
+            List<ObjectInfoDefine> delData = toListByIds(deleteIds, projectDefineList);
+            dataMigrationExcels.addAll(processDataForExcel(delData, MigrationType.DELETE.getCode()));
+        }
+
+        //交集更新
+        log.info("######################### DefineInfo 获取批量处理更新数据 #########################");
+        Map<String,Object> intersectionUpdateFrom = doIntersectionGetFrom(admDefineMap, projectDefineMap);
+        Map<String,Object> intersectionUpdateTo = doIntersectionGetTo(admDefineMap, projectDefineMap);
+
+        if(!CollUtil.isEmpty(intersectionUpdateFrom) && !CollUtil.isEmpty(intersectionUpdateTo)){
+            //TODO 重写比较方法,dataSource 数据顺序不一致,导致对比失败,目前先跳过
+            Map<String, Object> compareData = compareData(intersectionUpdateFrom, intersectionUpdateTo);
+            if(CollUtil.isNotEmpty(compareData) && compareData.size() > 0){
+                List<ObjectInfoDefine> updateData = toList(compareData, admDefineList);
+                //String updateUrl = requestUrl(context, migrationInfo, MigrationType.UPDATE.getCode());
+                //updateBatch(updateData, ObjectInfoDefine.class, updateUrl)
+                dataMigrationExcels.addAll(processDataForExcel(updateData, MigrationType.UPDATE.getCode()));
+            }
+        }
+        long end = System.currentTimeMillis();
+        log.info("######################### DefineInfo 数据迁移内容获取已结束 时间:"+(end-start)+" #########################");
+        return dataMigrationExcels;
+    }
+
+    /**
+     * 项目级、集团级定义
+     * @return
+     */
+    private QueryCriteria getCustomQueryCriteria(){
         QueryCriteria queryCriteria = new QueryCriteria();
         ObjectNode criteria = JsonNodeFactory.instance.objectNode();
         criteria.put("valid", 1);
-
         ObjectNode groupCode =  JsonNodeFactory.instance.objectNode();
         groupCode.put("$ne", "0");
 
@@ -339,4 +445,21 @@ public class DefineInfoMigration extends MigrationAbstractServiceImpl<ObjectInfo
         queryCriteria.setSize(-1L);
         return queryCriteria;
     }
+
+
+    /**
+     * 标志字典数量获取
+     * @return
+     */
+    private QueryCriteria getCriterionQueryCriteria(){
+        QueryCriteria queryCriteria = new QueryCriteria();
+        ObjectNode criteria = JsonNodeFactory.instance.objectNode();
+        criteria.put("valid", 1);
+        criteria.put("groupCode", 0);
+        criteria.put("projectId", 0);
+        queryCriteria.setCriteria(criteria);
+        queryCriteria.setSize(-1L);
+        return queryCriteria;
+    }
+
 }

+ 194 - 89
src/main/java/com/persagy/proxy/migration/handler/DefineTypeMigration.java

@@ -32,7 +32,7 @@ import java.util.stream.Collectors;
  * @date 2021/12/1 19:38
  */
 @Slf4j
-public class DefineTypeMigration extends MigrationAbstractServiceImpl<ObjectTypeDefine> implements IDataMigration, IDataMigrationProcess<ObjectTypeDefine> {
+public class DefineTypeMigration extends MigrationAbstractServiceImpl<ObjectTypeDefine> implements IDataMigration, IDefineDataMigration<ObjectTypeDefine>, IDataMigrationProcess<ObjectTypeDefine> {
 
     private static DefineTypeMigration instance;
 
@@ -49,82 +49,23 @@ public class DefineTypeMigration extends MigrationAbstractServiceImpl<ObjectType
         }
         return instance;
     }
-
-
     /**
-     * 数据迁移
+     * 数据迁移 迁移项目级 集团级 字典信息
      *
      * @param context
      * @param migrationInfo
-     * @return
+     * @return excel
      */
     @Override
     public List<DataMigrationExcel> migrateForExcel(InstanceUrlParam context, MigrationInfo migrationInfo) {
         log.info("######################### DefineType 数据迁移内容获取开始 #########################");
-        long start = System.currentTimeMillis();
-        List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
-
-        QueryCriteria queryCriteria = getQueryCriteria();
+        QueryCriteria queryCriteria = getCustomQueryCriteria();
 
         List<ObjectTypeDefine> admDefineList = getAdmData(context, queryCriteria);
         String queryUrl = requestUrl(context, migrationInfo, MigrationType.QUERY.getCode());
         List<ObjectTypeDefine> projectDefineList = getProjectData(queryCriteria, ObjectTypeDefine.class, queryUrl);
-        List<ObjectNode> objectNodeList = JsonNodeUtils.toListNode(projectDefineList, null, null);
-        if(CollUtil.isEmpty(admDefineList)){
-            log.error(" ######################### DefineType adm已交付需要同步的数据:"+ ResponseCode.C0320.getDesc() +" 同步结束 #########################");
-            return dataMigrationExcels;
-        }
-
-        //String insertUrl = requestUrl(context, migrationInfo, MigrationType.INSERT.getCode());
-        if(CollUtil.isEmpty(objectNodeList)){
-            log.info("######################### DefineType 批量插入数据获取 #########################");
-            //DataMigrationResponse dataMigrationResponse = insertBatch(admDefineList, ObjectTypeDefine.class, insertUrl);
-            dataMigrationExcels.addAll(processDataForExcel(admDefineList, MigrationType.CREATE.getCode()));
-
-            return dataMigrationExcels;
-        }
-        List<ObjectNode> objectNodeListPro = JsonNodeUtils.toListNode(objectNodeList, null, null);
-        Map<String,Object> projectDefineMap = toEntityMap(objectNodeListPro, ObjectTypeDefine.class);
-        List<ObjectNode> objectNodeListAdm = JsonNodeUtils.toListNode(admDefineList, null, null);
-        Map<String,Object> admDefineMap = toEntityMap(objectNodeListAdm, ObjectTypeDefine.class);
-
-        //差集 新增
-        log.info("######################### DefineType 批量处理新增数据获取 #########################");
-        Map<String,Object> doSubtractFromInsert = doSubtractAdd(admDefineMap, projectDefineMap);
-        if(!CollUtil.isEmpty(doSubtractFromInsert)){
-            List<ObjectTypeDefine> insertData = toList(doSubtractFromInsert, admDefineList);
-            //DataMigrationResponse dataMigrationResponse = insertBatch(insertData, ObjectTypeDefine.class, insertUrl);
-            dataMigrationExcels.addAll(processDataForExcel(insertData, MigrationType.CREATE.getCode()));
-        }
-
-        //差集 删除
-        log.info("######################### DefineType 批量处理删除数据获取 #########################");
-        Map<String,Object> doSubtractFromDelete = doSubtractDel(admDefineMap, projectDefineMap);
-        if(!CollUtil.isEmpty(doSubtractFromDelete)){
-            List<String> deleteIds = doSubtractFromDelete.entrySet().stream().map(en -> en.getKey()).collect(Collectors.toList());
-            List<ObjectTypeDefine> deleteData = toListByIds(deleteIds, projectDefineList);
-
-            /*String delUrl = requestUrl(context, migrationInfo, MigrationType.DELETE.getCode());
-            DataMigrationResponse dataMigrationResponse = deleteBatch(deleteIds, ObjectTypeDefine.class, delUrl);*/
-            dataMigrationExcels.addAll(processDataForExcel(deleteData, MigrationType.DELETE.getCode()));
-        }
-
-        //交集更新
-        log.info("######################### DefineType 批量处理更新数据获取 #########################");
-        Map<String,Object> intersectionUpdateFrom = doIntersectionGetFrom(admDefineMap, projectDefineMap);
-        Map<String,Object> intersectionUpdateTo = doIntersectionGetTo(admDefineMap, projectDefineMap);
-
-        if(!CollUtil.isEmpty(intersectionUpdateFrom) && !CollUtil.isEmpty(intersectionUpdateTo)){
-            Map<String, Object> compareData = compareData(intersectionUpdateFrom, intersectionUpdateTo);
-            if(CollUtil.isNotEmpty(compareData) && compareData.size() > 0){
-                List<ObjectTypeDefine> updateData = toList(compareData, admDefineList);
-                //String updateUrl = requestUrl(context, migrationInfo, MigrationType.UPDATE.getCode());
-                //DataMigrationResponse dataMigrationResponse = updateBatch(updateData, ObjectTypeDefine.class, updateUrl);
-                dataMigrationExcels.addAll(processDataForExcel(updateData, MigrationType.UPDATE.getCode()));
-            }
-        }
-        long end = System.currentTimeMillis();
-        log.info("######################### DefineType 数据迁移获取已结束 时间:"+(end-start)+" #########################");
+        List<DataMigrationExcel> dataMigrationExcels = compareByData(admDefineList, projectDefineList);
+        log.info("######################### DefineType 数据迁移内容获取结束 #########################");
         return dataMigrationExcels;
     }
 
@@ -134,7 +75,7 @@ public class DefineTypeMigration extends MigrationAbstractServiceImpl<ObjectType
         long start = System.currentTimeMillis();
         List<SyncData> syncDataList = new ArrayList<>();
 
-        QueryCriteria queryCriteria = getQueryCriteria();
+        QueryCriteria queryCriteria = getCustomQueryCriteria();
 
         List<ObjectTypeDefine> admDefineList = getAdmData(context, queryCriteria);
         String queryUrl = requestUrl(context, migrationInfo, MigrationType.QUERY.getCode());
@@ -173,7 +114,7 @@ public class DefineTypeMigration extends MigrationAbstractServiceImpl<ObjectType
             String delUrl = requestUrl(context, migrationInfo, MigrationType.DELETE.getCode());
             DataMigrationResponse dataMigrationResponse = deleteBatch(deleteIds, ObjectTypeDefine.class, delUrl);
             List<String> successIds = (List<String>) dataMigrationResponse.getData();
-            List<ObjectTypeDefine> delObjs = toListByIds(successIds, admDefineList);
+            List<ObjectTypeDefine> delObjs = toListByIds(successIds, projectDefineList);
             dataMigrationResponse.setData(delObjs);
             syncDataList.addAll(processDataForLog(dataMigrationResponse, MigrationType.DELETE.getCode()));
         }
@@ -211,28 +152,6 @@ public class DefineTypeMigration extends MigrationAbstractServiceImpl<ObjectType
         return types;
     }
 
-
-    private QueryCriteria getQueryCriteria(){
-        QueryCriteria queryCriteria = new QueryCriteria();
-        ObjectNode criteria = JsonNodeFactory.instance.objectNode();
-        criteria.put("valid", 1);
-        ObjectNode groupCode =  JsonNodeFactory.instance.objectNode();
-        groupCode.put("$ne", "0");
-
-        ObjectNode projectId =  JsonNodeFactory.instance.objectNode();
-        projectId.put("$ne", "0");
-
-        ObjectNode andOr = JsonNodeFactory.instance.objectNode();
-        andOr.putPOJO("groupCode", projectId);
-        andOr.putPOJO("projectId", groupCode);
-
-        criteria.putPOJO("$andOr", andOr);
-
-        queryCriteria.setCriteria(criteria);
-        queryCriteria.setSize(-1L);
-        return queryCriteria;
-    }
-
     /**
      * 根据map转为需要处理的对象集合
      * 使用 MigrationConstant.spliter 作为拼接符
@@ -305,6 +224,11 @@ public class DefineTypeMigration extends MigrationAbstractServiceImpl<ObjectType
             excel.setCode(objectTypeDefine.getCode());
             excel.setName(objectTypeDefine.getName());
             excel.setType(type);
+            if(objectTypeDefine.getGroupCode().equals("0") && objectTypeDefine.getProjectId().equals("0")){
+                excel.setMark("标准字典");
+            }else{
+                excel.setMark("自定义字典");
+            }
             dataMigrationExcels.add(excel);
         }
         return dataMigrationExcels;
@@ -342,4 +266,185 @@ public class DefineTypeMigration extends MigrationAbstractServiceImpl<ObjectType
         return syncDataList;
     }
 
+    /**
+     * 获取标准字典数量,默认获取有效数据
+     *
+     * @param context
+     * @param queryCriteria
+     * @return count
+     */
+    @Override
+    public Long getAdmCountData(InstanceUrlParam context, QueryCriteria queryCriteria) {
+        Long typeCount = DigitalDefineFacade.queryObjectTypeForCount(context.getGroupCode(),context.getProjectId(),context.getUserId(),context.getUserId(),queryCriteria);
+        return typeCount;
+    }
+
+    /**
+     * 标准字典 根据整体数量进行比较
+     *
+     * @param context
+     * @param migrationInfo
+     * @return
+     */
+    @Override
+    public AdmResponse compareByCount(InstanceUrlParam context, MigrationInfo migrationInfo) {
+        QueryCriteria queryCriteria = getCriterionQueryCriteria();
+        queryCriteria.setOnlyCount(true);
+        long admCont = getAdmCountData(context, queryCriteria);
+
+        String queryUrl = requestUrl(context, migrationInfo, MigrationType.QUERY.getCode());
+        long proCount = queryCountByHttp(queryUrl, queryCriteria);
+        //是否需要更新字典
+        boolean needUpdateDic = true;
+        List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
+        if(admCont - proCount == 0){
+            dataMigrationExcels = compareCriterionByData(context, migrationInfo);
+            if(CollUtil.isEmpty(dataMigrationExcels)){
+                needUpdateDic = false;
+            }
+        }
+        //验证失败 需要更新字典
+        if(needUpdateDic){
+            String msg = "交付数据标准字典与项目现场标准字典不匹配,请联系管理者确认是否需要字典升级";
+            AdmResponse admResponse = AdmResponse.failure(msg);
+            DataMigrationExcel dataMigrationExcel = new DataMigrationExcel();
+            dataMigrationExcel.setId("error");
+            dataMigrationExcel.setName(msg);
+            dataMigrationExcels.add(dataMigrationExcel);
+            admResponse.setContent(dataMigrationExcels);
+            return admResponse;
+        }else{
+            return AdmResponse.success();
+        }
+    }
+
+    /**
+     * 标准字典 根据整体数据进行逐条对比
+     *
+     * @param context
+     * @param migrationInfo
+     * @return AdmResponse
+     */
+    @Override
+    public List<DataMigrationExcel> compareCriterionByData(InstanceUrlParam context, MigrationInfo migrationInfo) {
+        log.info("######################### DefineType 数据迁移 标准字典验证 开始 #########################");
+        QueryCriteria queryCriteria = getCriterionQueryCriteria();
+        List<ObjectTypeDefine> admDefineList = getAdmData(context, queryCriteria);
+        String queryUrl = requestUrl(context, migrationInfo, MigrationType.QUERY.getCode());
+        List<ObjectTypeDefine> projectDefineList = getProjectData(queryCriteria, ObjectTypeDefine.class, queryUrl);
+        List<DataMigrationExcel> dataMigrationExcels = compareByData(admDefineList, projectDefineList);
+        log.info("######################### DefineType 数据迁移 标准字典验证 结束 #########################");
+        return dataMigrationExcels;
+    }
+
+    /**
+     * 比较数据
+     *
+     * @param admDefineList
+     * @param projectDefineList
+     * @return
+     */
+    @Override
+    public List<DataMigrationExcel> compareByData(List<ObjectTypeDefine> admDefineList, List<ObjectTypeDefine> projectDefineList ) {
+        long start = System.currentTimeMillis();
+        List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
+        List<ObjectNode> objectNodeList = JsonNodeUtils.toListNode(projectDefineList, null, null);
+        if(CollUtil.isEmpty(admDefineList)){
+            log.error(" ######################### DefineType adm已交付需要同步的数据:"+ ResponseCode.C0320.getDesc() +" 同步结束 #########################");
+            return dataMigrationExcels;
+        }
+
+        //String insertUrl = requestUrl(context, migrationInfo, MigrationType.INSERT.getCode());
+        if(CollUtil.isEmpty(objectNodeList)){
+            log.info("######################### DefineType 批量插入数据获取 #########################");
+            //DataMigrationResponse dataMigrationResponse = insertBatch(admDefineList, ObjectTypeDefine.class, insertUrl);
+            dataMigrationExcels.addAll(processDataForExcel(admDefineList, MigrationType.CREATE.getCode()));
+
+            return dataMigrationExcels;
+        }
+        List<ObjectNode> objectNodeListPro = JsonNodeUtils.toListNode(objectNodeList, null, null);
+        Map<String,Object> projectDefineMap = toEntityMap(objectNodeListPro, ObjectTypeDefine.class);
+        List<ObjectNode> objectNodeListAdm = JsonNodeUtils.toListNode(admDefineList, null, null);
+        Map<String,Object> admDefineMap = toEntityMap(objectNodeListAdm, ObjectTypeDefine.class);
+
+        //差集 新增
+        log.info("######################### DefineType 批量处理新增数据获取 #########################");
+        Map<String,Object> doSubtractFromInsert = doSubtractAdd(admDefineMap, projectDefineMap);
+        if(!CollUtil.isEmpty(doSubtractFromInsert)){
+            List<ObjectTypeDefine> insertData = toList(doSubtractFromInsert, admDefineList);
+            //DataMigrationResponse dataMigrationResponse = insertBatch(insertData, ObjectTypeDefine.class, insertUrl);
+            dataMigrationExcels.addAll(processDataForExcel(insertData, MigrationType.CREATE.getCode()));
+        }
+
+        //差集 删除
+        log.info("######################### DefineType 批量处理删除数据获取 #########################");
+        Map<String,Object> doSubtractFromDelete = doSubtractDel(admDefineMap, projectDefineMap);
+        if(!CollUtil.isEmpty(doSubtractFromDelete)){
+            List<String> deleteIds = doSubtractFromDelete.entrySet().stream().map(en -> en.getKey()).collect(Collectors.toList());
+            List<ObjectTypeDefine> deleteData = toListByIds(deleteIds, projectDefineList);
+
+            /*String delUrl = requestUrl(context, migrationInfo, MigrationType.DELETE.getCode());
+            DataMigrationResponse dataMigrationResponse = deleteBatch(deleteIds, ObjectTypeDefine.class, delUrl);*/
+            dataMigrationExcels.addAll(processDataForExcel(deleteData, MigrationType.DELETE.getCode()));
+        }
+
+        //交集更新
+        log.info("######################### DefineType 批量处理更新数据获取 #########################");
+        Map<String,Object> intersectionUpdateFrom = doIntersectionGetFrom(admDefineMap, projectDefineMap);
+        Map<String,Object> intersectionUpdateTo = doIntersectionGetTo(admDefineMap, projectDefineMap);
+
+        if(!CollUtil.isEmpty(intersectionUpdateFrom) && !CollUtil.isEmpty(intersectionUpdateTo)){
+            Map<String, Object> compareData = compareData(intersectionUpdateFrom, intersectionUpdateTo);
+            if(CollUtil.isNotEmpty(compareData) && compareData.size() > 0){
+                List<ObjectTypeDefine> updateData = toList(compareData, admDefineList);
+                //String updateUrl = requestUrl(context, migrationInfo, MigrationType.UPDATE.getCode());
+                //DataMigrationResponse dataMigrationResponse = updateBatch(updateData, ObjectTypeDefine.class, updateUrl);
+                dataMigrationExcels.addAll(processDataForExcel(updateData, MigrationType.UPDATE.getCode()));
+            }
+        }
+        long end = System.currentTimeMillis();
+        log.info("######################### DefineType 数据迁移获取已结束 时间:"+(end-start)+" #########################");
+        return dataMigrationExcels;
+    }
+
+    /**
+     * 项目级、集团级定义
+     * @return
+     */
+    private QueryCriteria getCustomQueryCriteria(){
+        QueryCriteria queryCriteria = new QueryCriteria();
+        ObjectNode criteria = JsonNodeFactory.instance.objectNode();
+        criteria.put("valid", 1);
+        ObjectNode groupCode =  JsonNodeFactory.instance.objectNode();
+        groupCode.put("$ne", "0");
+
+        ObjectNode projectId =  JsonNodeFactory.instance.objectNode();
+        projectId.put("$ne", "0");
+
+        ObjectNode andOr = JsonNodeFactory.instance.objectNode();
+        andOr.putPOJO("groupCode", projectId);
+        andOr.putPOJO("projectId", groupCode);
+
+        criteria.putPOJO("$andOr", andOr);
+
+        queryCriteria.setCriteria(criteria);
+        queryCriteria.setSize(-1L);
+        return queryCriteria;
+    }
+
+
+    /**
+     * 标志字典数量获取
+     * @return
+     */
+    private QueryCriteria getCriterionQueryCriteria(){
+        QueryCriteria queryCriteria = new QueryCriteria();
+        ObjectNode criteria = JsonNodeFactory.instance.objectNode();
+        criteria.put("valid", 1);
+        criteria.put("groupCode", 0);
+        criteria.put("projectId", 0);
+        queryCriteria.setCriteria(criteria);
+        queryCriteria.setSize(-1L);
+        return queryCriteria;
+    }
 }

+ 46 - 0
src/main/java/com/persagy/proxy/migration/handler/IDefineDataMigration.java

@@ -0,0 +1,46 @@
+package com.persagy.proxy.migration.handler;
+
+import com.persagy.dmp.basic.model.QueryCriteria;
+import com.persagy.proxy.common.entity.InstanceUrlParam;
+import com.persagy.proxy.migration.model.DataMigrationExcel;
+import com.persagy.proxy.migration.model.MigrationInfo;
+
+import java.util.List;
+
+/**
+ * 标准字典比较
+ * @author lvxianyun
+ * @title: IDefineDataMigration
+ * @projectName adm-middleware
+ * @date 2021/12/24 14:25
+ */
+public interface IDefineDataMigration<T> {
+
+    /**
+     * 获取标准字典数量,默认获取有效数据
+     * @param context
+     * @return count
+     */
+    Long getAdmCountData(InstanceUrlParam context, QueryCriteria queryCriteria);
+
+
+    /**
+     * 标准字典 根据整体数量进行比较
+     * @param context
+     * @param migrationInfo
+     * @return AdmResponse
+     */
+    Object compareByCount(InstanceUrlParam context, MigrationInfo migrationInfo);
+
+    /**
+     * 标准字典 根据整体数据进行逐条对比
+     * @param context
+     * @param migrationInfo
+     * @return AdmResponse
+     */
+    List<DataMigrationExcel> compareCriterionByData(InstanceUrlParam context, MigrationInfo migrationInfo);
+
+    List<DataMigrationExcel> compareByData(List<T> admDefineList, List<T> projectDefineList);
+
+
+}

+ 44 - 14
src/main/java/com/persagy/proxy/migration/handler/ObjectDigitalMigration.java

@@ -52,11 +52,11 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
     }
 
     /**
-     * 数据迁移
+     * 数据迁移前,数据对比信息 汇总
      *
      * @param context
      * @param migrationInfo
-     * @return
+     * @return List<DataMigrationExcel>
      */
     @Override
     public List<DataMigrationExcel> migrateForExcel(InstanceUrlParam context, MigrationInfo migrationInfo) {
@@ -78,6 +78,12 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
         return dataMigrationExcels;
     }
 
+    /**
+     * 迁移数据,汇总记录日志
+     * @param context
+     * @param migrationInfo
+     * @return
+     */
     @Override
     public AdmResponse migrateForLog(InstanceUrlParam context, MigrationInfo migrationInfo) {
         log.info("######################### dt_object 同步开始 #########################");
@@ -105,24 +111,28 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
         return queryCriteria;
     }
 
+    /**
+     * 迁移数据,记录日志
+     *
+     */
     private List<SyncData> startMigrateForLog(InstanceUrlParam context, MigrationInfo migrationInfo, QueryCriteria queryCriteria) {
         List<SyncData> syncDataList = new ArrayList<>();
         List<ObjectNode> admData = getAdmData(context,queryCriteria);
 
         String queryUrl = requestUrl(context, migrationInfo, MigrationType.QUERY.getCode());
         List<ObjectDigital> projectData = getProjectData(queryCriteria, ObjectDigital.class, queryUrl);
-        List<ObjectNode> objectNodeList = JsonNodeUtils.toListNode(projectData, null, null);
+        List<ObjectNode> projObjectNodeList = JsonNodeUtils.toListNode(projectData, null, null);
 
         if(CollUtil.isEmpty(admData)){
             log.error(" ######################### dt_object adm已交付:"+ ResponseCode.C0320.getDesc() +" 同步结束 #########################");
         }
 
         String insertUrl = requestUrl(context, migrationInfo, MigrationType.CREATE.getCode());
-        if(CollUtil.isEmpty(objectNodeList)){
+        if(CollUtil.isEmpty(projObjectNodeList)){
             DataMigrationResponse dataMigrationResponse = insertBatch(admData, ObjectDigital.class, insertUrl);
             syncDataList = processDataForLog(dataMigrationResponse, MigrationType.CREATE.getCode());
         }
-        Map<String,Object> projectMap = toEntityMap(objectNodeList, ObjectDigital.class);
+        Map<String,Object> projectMap = toEntityMap(projObjectNodeList, ObjectDigital.class);
         Map<String,Object> admMap = toEntityMap(admData, ObjectDigital.class);
         //差集 新增
         Map<String,Object> doSubtractFromInsert = doSubtractAdd(admMap, projectMap);
@@ -140,7 +150,7 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
             //处理删除的数据
             DataMigrationResponse dataMigrationResponse = deleteBatch(deleteIds, ObjectDigital.class, delUrl);
             List<String> successIds = (List<String>) dataMigrationResponse.getData();
-            List<ObjectNode> delObjs = toListByIds(successIds, admData);
+            List<ObjectNode> delObjs = toListByIds(successIds, projObjectNodeList);
             dataMigrationResponse.setData(delObjs);
             syncDataList.addAll(processDataForLog(dataMigrationResponse, MigrationType.DELETE.getCode()));
         }
@@ -161,8 +171,10 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
        return super.addSynLog(context, syncDataList);
     }
 
-
-
+    /**
+     * 迁移数据,记录excel数据
+     *
+     */
     private List<DataMigrationExcel> startMigrateForExcel(InstanceUrlParam context, MigrationInfo migrationInfo, QueryCriteria queryCriteria) {
         List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
         List<ObjectNode> admData = getAdmData(context,queryCriteria);
@@ -197,7 +209,7 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
         if(!CollUtil.isEmpty(doSubtractFromDelete)){
             List<String> deleteIds = doSubtractFromDelete.entrySet().stream().map(en -> en.getKey()).collect(Collectors.toList());
 
-            List<ObjectNode> deleteData = toListByIds(deleteIds, admData);
+            List<ObjectNode> deleteData = toListByIds(deleteIds, objectNodeList);
             //String delUrl = requestUrl(context, migrationInfo, MigrationType.DELETE.getCode());
             //DataMigrationResponse dataMigrationResponse = deleteBatch(deleteIds, ObjectDigital.class, delUrl);
             dataMigrationExcels.addAll(processDataForExcel(deleteData, MigrationType.DELETE.getCode()));
@@ -237,7 +249,6 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
 
     /**
      * 根据map转为需要处理的对象集合
-     * 使用 MigrationConstant.spliter 作为拼接符
      * @param fromMap
      * @param fromList
      * @return
@@ -249,7 +260,12 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
         return toListByIds(fromMap.keySet(), fromList);
     }
 
-
+    /**
+     * 根据对象ids转为需要处理的对象集合
+     * @param ids
+     * @param fromList
+     * @return
+     */
     public List<ObjectNode> toListByIds(Collection<String> ids, List<ObjectNode> fromList) {
         if(CollUtil.isEmpty(ids) || CollUtil.isEmpty(fromList)){
             return Collections.emptyList();
@@ -265,7 +281,10 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
         }
 
         for(String key : ids){
-            results.add(objectDigitalMap.get(key));
+            if(objectDigitalMap.containsKey(key)){
+                results.add(objectDigitalMap.get(key));
+            }
+
         }
         return results;
     }
@@ -311,10 +330,13 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
         }
         List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
         for(Object obj : list){
+            if(obj ==  null){
+                continue;
+            }
             ObjectDigital digital = JsonNodeUtils.toEntity((ObjectNode) obj, ObjectDigital.class, null);
             DataMigrationExcel excel = new DataMigrationExcel();
             excel.setId(digital.getId());
-            excel.setName(digital.getName());
+            excel.setName(String.join(StrUtil.DASHED, digital.getLocalId() == null ? "" : digital.getLocalId(), digital.getLocalName() == null ? "" : digital.getLocalName()));
             excel.setType(type);
             dataMigrationExcels.add(excel);
         }
@@ -336,7 +358,15 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
         List<SyncData> syncDataList = new ArrayList<>();
         if(CollUtil.isNotEmpty(dataMigrationResponse.getData())){
             for(Object obj : dataMigrationResponse.getData()){
-                ObjectDigital digital = (ObjectDigital) obj;
+                if(null == obj){
+                    continue;
+                }
+                ObjectDigital digital = null;
+                if(obj instanceof ObjectDigital){
+                    digital = (ObjectDigital) obj;
+                }else{
+                    digital = JsonNodeUtils.toEntity((ObjectNode) obj, ObjectDigital.class, null);
+                }
                 SyncData syncData = new SyncData();
                 syncData.setTableName(MigrationTable.DTOBJECT.getCode());
                 syncData.setName(digital.getName());

+ 95 - 13
src/main/java/com/persagy/proxy/migration/handler/ObjectRelationMigration.java

@@ -24,6 +24,7 @@ import com.persagy.proxy.migration.service.Impl.MigrationAbstractServiceImpl;
 import lombok.extern.slf4j.Slf4j;
 
 import java.util.*;
+import java.util.concurrent.*;
 import java.util.stream.Collectors;
 
 /**
@@ -65,14 +66,43 @@ public class ObjectRelationMigration extends MigrationAbstractServiceImpl<Object
         long start = System.currentTimeMillis();
         List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
 
+        //TODO 之后考虑其他方式
+        ExecutorService service = getExcecutor();
+        List<Future<List<DataMigrationExcel>>> list = new ArrayList<>();
+
         for (MiGrationRelCode miGrationRelCode: MiGrationRelCode.values()){
             log.info("######################### dt_relation "+miGrationRelCode.getCode()+"数据迁移内容获取开始 #########################");
 
-            QueryCriteria queryCriteria = getQueryCriteria(miGrationRelCode.getCode());
-            dataMigrationExcels.addAll(startMigrateForExcel(context, migrationInfo, queryCriteria));
+            Future<List<DataMigrationExcel>> future = service.submit(new Callable<List<DataMigrationExcel>>(){
+                @Override
+                public List<DataMigrationExcel> call() throws Exception {
+                    return startMigrateForExcel(context, migrationInfo, miGrationRelCode.getCode());
+                }
+            });
+            list.add(future);
+        }
+        service.shutdown();
+        for (Future<List<DataMigrationExcel>> future : list) {
+            try {
+                List<DataMigrationExcel> excelList = future.get();
+                if(CollUtil.isNotEmpty(excelList)){
+                    dataMigrationExcels.addAll(excelList);
+                }
 
-            log.info("######################### dt_relation "+miGrationRelCode.getCode()+"数据迁移内容获取结束 #########################");
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+                log.error("######################### dt_relation 数据迁移内容获取失败"+e.getMessage());
+            } catch (ExecutionException e) {
+                e.printStackTrace();
+                log.error("######################### dt_relation 数据迁移内容获取失败"+e.getMessage());
+            }
         }
+        /*for (MiGrationRelCode miGrationRelCode: MiGrationRelCode.values()){
+            //log.info("######################### dt_relation "+miGrationRelCode.getCode()+"数据迁移内容获取开始 #########################");
+            QueryCriteria queryCriteria = getQueryCriteria(miGrationRelCode.getCode());
+            dataMigrationExcels.addAll(startMigrateForExcel(context, migrationInfo, queryCriteria));
+            //log.info("######################### dt_relation "+miGrationRelCode.getCode()+"数据迁移内容获取结束 #########################");
+        }*/
         long end = System.currentTimeMillis();
         log.info("######################### dt_relation 数据迁移内容获取结束 "+(end-start)+"#########################");
         return dataMigrationExcels;
@@ -82,26 +112,72 @@ public class ObjectRelationMigration extends MigrationAbstractServiceImpl<Object
     public AdmResponse migrateForLog(InstanceUrlParam context, MigrationInfo migrationInfo) {
         log.info("######################### dt_relation 同步开始 #########################");
         long start = System.currentTimeMillis();
-        for (MiGrationRelCode miGrationRelCode: MiGrationRelCode.values()){
+        /*for (MiGrationRelCode miGrationRelCode: MiGrationRelCode.values()){
             log.info("######################### dt_relation "+miGrationRelCode.getCode()+"同步开始 #########################");
             QueryCriteria queryCriteria = getQueryCriteria(miGrationRelCode.getCode());
             List<SyncData> syncDataList = startMigrateForLog(context, migrationInfo, queryCriteria);
             log.info("######################### dt_relation "+miGrationRelCode.getCode()+"同步结束 共计:"+syncDataList.size()+"条 #########################");
+        }*/
+        ExecutorService service = getExcecutor();
+        List<SyncData> syncDataList = new ArrayList<>();
+        List<Future<List<SyncData>>> list = new ArrayList<>();
+
+        for (MiGrationRelCode miGrationRelCode: MiGrationRelCode.values()){
+            log.info("######################### dt_relation "+miGrationRelCode.getCode()+"数据迁移开始 #########################");
+
+            Future<List<SyncData>> future = service.submit(new Callable<List<SyncData>>(){
+                @Override
+                public List<SyncData> call() throws Exception {
+                    return startMigrateForLog(context, migrationInfo, miGrationRelCode.getCode());
+                }
+            });
+            list.add(future);
+        }
+        service.shutdown();
+        for (Future<List<SyncData>> future : list) {
+            try {
+                List<SyncData> syncDatas = future.get();
+                if(CollUtil.isNotEmpty(syncDatas)){
+                    syncDataList.addAll(syncDatas);
+                }
+
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+                log.error("######################### dt_relation 数据迁移失败"+e.getMessage());
+            } catch (ExecutionException e) {
+                e.printStackTrace();
+                log.error("######################### dt_relation 数据迁移失败"+e.getMessage());
+            }
         }
         long end = System.currentTimeMillis();
         log.info("######################### dt_relation 同步结束 "+(end-start)+"#########################");
         return AdmResponse.success();
     }
 
+    private ExecutorService getExcecutor(){
+        ExecutorService service = new ThreadPoolExecutor(10, 15, 0L, TimeUnit.MILLISECONDS,
+                new LinkedBlockingQueue(), new ThreadFactory() {
+            @Override
+            public Thread newThread(Runnable r) {
+                Thread t = new Thread(r);
+                System.out.println("我是线程ObjectRelation:" + r);
+                return t;
+            }
+        }
+        );
+        return service;
+    }
     private QueryCriteria getQueryCriteria(String typeCode){
         QueryCriteria queryCriteria = new QueryCriteria();
         ObjectNode criteria = JsonNodeFactory.instance.objectNode();
         criteria.put("valid", 1);
         criteria.put("relCode", typeCode);
+        queryCriteria.setCriteria(criteria);
         return queryCriteria;
     }
 
-    private List<DataMigrationExcel> startMigrateForExcel(InstanceUrlParam context, MigrationInfo migrationInfo, QueryCriteria queryCriteria){
+    private List<DataMigrationExcel> startMigrateForExcel(InstanceUrlParam context, MigrationInfo migrationInfo, String code){
+        QueryCriteria queryCriteria = getQueryCriteria(code);
         List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
         List<ObjectRelation> admRelations = getAdmData(context, queryCriteria);
 
@@ -157,7 +233,8 @@ public class ObjectRelationMigration extends MigrationAbstractServiceImpl<Object
         return dataMigrationExcels;
     }
 
-    private List<SyncData> startMigrateForLog(InstanceUrlParam context, MigrationInfo migrationInfo, QueryCriteria queryCriteria){
+    private List<SyncData> startMigrateForLog(InstanceUrlParam context, MigrationInfo migrationInfo, String code){
+        QueryCriteria queryCriteria = getQueryCriteria(code);
         List<SyncData> syncDataList = new ArrayList<>();
         List<ObjectRelation> admRelations = getAdmData(context, queryCriteria);
 
@@ -194,7 +271,7 @@ public class ObjectRelationMigration extends MigrationAbstractServiceImpl<Object
             //处理删除的数据
             DataMigrationResponse dataMigrationResponse = deleteBatch(deleteIds, ObjectRelation.class, delUrl);
             List<String> successIds = (List<String>) dataMigrationResponse.getData();
-            List<ObjectRelation> delObjs = toListByIds(successIds, admRelations);
+            List<ObjectRelation> delObjs = toListByIds(successIds, projectRelations);
             dataMigrationResponse.setData(delObjs);
             syncDataList.addAll(processDataForLog(dataMigrationResponse, MigrationType.DELETE.getCode()));
         }
@@ -294,11 +371,15 @@ public class ObjectRelationMigration extends MigrationAbstractServiceImpl<Object
         }
         List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
         for(Object obj : list){
-            ObjectRelation define = (ObjectRelation) obj;
+            if(obj ==  null){
+                continue;
+            }
+            ObjectRelation objectRelation = (ObjectRelation) obj;
             DataMigrationExcel excel = new DataMigrationExcel();
-            excel.setId(define.getId());
-            excel.setCode(define.getRelCode());
-            excel.setCode1(define.getGraphCode());
+            excel.setId(objectRelation.getId());
+            excel.setCode(String.join(StrUtil.DASHED, objectRelation.getRelCode(), objectRelation.getGraphCode()));
+            excel.setObjFrom(objectRelation.getObjFrom());
+            excel.setObjTo(objectRelation.getObjTo());
             excel.setType(type);
             dataMigrationExcels.add(excel);
         }
@@ -322,16 +403,17 @@ public class ObjectRelationMigration extends MigrationAbstractServiceImpl<Object
             for(Object obj : dataMigrationResponse.getData()){
                 ObjectRelation relation = (ObjectRelation) obj;
                 SyncData syncData = new SyncData();
-                syncData.setTableName(MigrationTable.DTRALATION.getCode());
+                syncData.setTableName(MigrationTable.DTRELATION.getCode());
                 syncData.setType(type);//操作
                 syncData.setTargetId(relation.getId());
+                syncData.setName(String.join(StrUtil.DASHED, relation.getRelCode(), relation.getGraphCode()));
                 syncData.setFromId(relation.getObjFrom());
                 syncData.setToId(relation.getObjTo());
                 syncDataList.add(syncData);
             }
         }
         if(CollUtil.isNotEmpty(dataMigrationResponse.getErrorMsg())){
-            syncDataList.addAll(addErrorInfoForLog(dataMigrationResponse.getErrorMsg(),MigrationTable.DTRALATION.getCode()));
+            syncDataList.addAll(addErrorInfoForLog(dataMigrationResponse.getErrorMsg(),MigrationTable.DTRELATION.getCode()));
         }
         return syncDataList;
     }

+ 11 - 7
src/main/java/com/persagy/proxy/migration/model/DataMigrationExcel.java

@@ -32,26 +32,30 @@ public class DataMigrationExcel {
     private String code;
 
     @ColumnWidth(20)
-    @ExcelProperty(value = "code1", index=3)
-    private String code1;
+    @ExcelProperty(value = "objFrom", index=3)
+    private String objFrom;
 
     @ColumnWidth(20)
-    @ExcelProperty(value = "类型(增加/删除/修改)", index=4)
+    @ExcelProperty(value = "objTo", index=4)
+    private String objTo;
+
+    @ColumnWidth(20)
+    @ExcelProperty(value = "类型(增加/删除/修改)", index=5)
     private String type;
 
     @ColumnWidth(20)
-    @ExcelProperty(value = "源(云端/现场)", index=5)
+    @ExcelProperty(value = "源(云端/现场)", index=6)
     private String directional = "adm-to-project";
 
     @ColumnWidth(30)
-    @ExcelProperty(value = "from(adm)", index=6)
+    @ExcelProperty(value = "from(adm)", index=7)
     private String source;
 
     @ColumnWidth(30)
-    @ExcelProperty(value = "to(project)", index=7)
+    @ExcelProperty(value = "to(project)", index=8)
     private String targetProject;
 
     @ColumnWidth(50)
-    @ExcelProperty(value = "备注", index=8)
+    @ExcelProperty(value = "备注", index=9)
     private String mark;
 }

+ 63 - 14
src/main/java/com/persagy/proxy/migration/service/Impl/MigrationAbstractServiceImpl.java

@@ -171,7 +171,34 @@ public class MigrationAbstractServiceImpl<T> implements MigrationAbstractService
             return HttpUtil.post(url, requestBody, 5000);
         }catch (HttpException e){
            log.error(ResponseCode.C0001.getDesc()+",url:"+ url);
-           return null;
+           return "error:"+ResponseCode.C0001.getDesc()+",url:"+ url;
+        }
+    }
+
+    /**
+     * 向项目侧查询数据数量
+     *
+     * @param url
+     * @param queryCriteria
+     */
+    @Override
+    public Long queryCountByHttp(String url, QueryCriteria queryCriteria) {
+        String body = "";
+        try {
+            if(queryCriteria != null){
+                body = JsonHelper.toJsonStr(queryCriteria);
+            }
+            String count = HttpUtil.post(url, body, 3000);
+            CommonResult commonResult = JSONUtil.toBean(count, CommonResult.class);
+            if(commonResult.getResult().equals(DmpResult.SUCCESS)){
+                return commonResult.getCount();
+            }else{
+                log.error(commonResult.getMessage());
+                return -1L;
+            }
+        } catch (IOException e) {
+            log.error(ResponseCode.C0001.toString());
+            return -1L;
         }
     }
 
@@ -198,12 +225,19 @@ public class MigrationAbstractServiceImpl<T> implements MigrationAbstractService
                         || fieldKey.equals(AuditableEntity.PROP_CREATOR)
                         || fieldKey.equals(AuditableEntity.DO_PROP_MODIFIEDTIME)
                         || fieldKey.equals(AuditableEntity.PROP_MODIFIER)
-                        || fieldKey.equals(BaseEntity.PROP_TS)){
+                        || fieldKey.equals(BaseEntity.PROP_TS)
+                        || fieldKey.equals("dataSource")
+                ){
                     continue;
                 }
                 value.append(objectNode.get(fieldKey) == null ? "" : objectNode.get(fieldKey)).append(MigrationConstant.SPLITER);
             }
-            map.put(key.replaceAll("\"",""), value.toString().replaceAll("\"",""));
+            String valueTemp = value.toString().replaceAll("\"","");
+           /* valueTemp = StrUtil.removeAll(valueTemp,"[");
+            valueTemp = StrUtil.removeAll(valueTemp,"]");
+            valueTemp = StrUtil.removeAll(valueTemp,"},{");
+            valueTemp = StrUtil.removeAll(valueTemp,"{");*/
+            map.put(key.replaceAll("\"",""), valueTemp);
         }
         return map;
     }
@@ -299,9 +333,15 @@ public class MigrationAbstractServiceImpl<T> implements MigrationAbstractService
         Set<String> toSets = to.entrySet().stream().map(en -> String.join(MigrationConstant.SPLITER_UNION,en.getKey(),en.getValue().toString())).collect(Collectors.toSet());
 
         Sets.SetView<String> difference = Sets.difference(formSets, toSets);
+
         if(CollUtil.isEmpty(difference)){
             return null;
         }
+        /*difference.forEach(set1 -> System.out.println(set1));
+        System.out.println("-------------------------------------------------------------------------");
+        Sets.SetView<String> difference2 = Sets.difference(toSets, formSets);
+        difference2.forEach(set2 -> System.out.println(set2));*/
+
         Set<String> diff = difference.stream().map(entity -> StrUtil.subBefore(entity, MigrationConstant.SPLITER_UNION, true)).collect(Collectors.toSet());
         Map<String, Object> results = getValueForMapByKeys(diff, from);
         return results;
@@ -316,7 +356,7 @@ public class MigrationAbstractServiceImpl<T> implements MigrationAbstractService
         for(String msg : errorMsg){
             DataMigrationExcel dataMigrationExcelError = new DataMigrationExcel();
             dataMigrationExcelError.setId("error");
-            dataMigrationExcelError.setMark(msg);
+            dataMigrationExcelError.setName(msg);
             dataMigrationExcels.add(dataMigrationExcelError);
         }
         return dataMigrationExcels;
@@ -366,18 +406,27 @@ public class MigrationAbstractServiceImpl<T> implements MigrationAbstractService
             log.error(ResponseCode.C0001.toString());
             return DataMigrationResponse.error(ResponseCode.C0001.toString());
         }
-        String response = commitDataByHttp(url, body);
-        CommonResult<List> commonResult = JSONUtil.toBean(response, CommonResult.class);
-        if(commonResult.getResult().equals(DmpResult.SUCCESS)){
-            ArrayNode arrayNode = JsonNodeUtils.toArrayNode(commonResult.getData(), null, null);
-            if(arrayNode == null){
-                return DataMigrationResponse.success();
+        try{
+            String response = commitDataByHttp(url, body);
+            if(response.equals("Bad Gateway")){
+                return DataMigrationResponse.error("Bad Gateway");
             }
-            return DataMigrationResponse.success(JsonNodeUtils.toEntity(arrayNode, clazz, null));
-        }else {
-            log.error(commonResult.getMessage());
-            return DataMigrationResponse.error(commonResult.getMessage());
+            CommonResult<List> commonResult = JSONUtil.toBean(response, CommonResult.class);
+            if(commonResult.getResult().equals(DmpResult.SUCCESS)){
+                ArrayNode arrayNode = JsonNodeUtils.toArrayNode(commonResult.getData(), null, null);
+                if(arrayNode == null){
+                    return DataMigrationResponse.success();
+                }
+                return DataMigrationResponse.success(JsonNodeUtils.toEntity(arrayNode, clazz, null));
+            }else {
+                log.error(commonResult.getMessage());
+                return DataMigrationResponse.error(commonResult.getMessage());
+            }
+        }catch (Exception e){
+            log.error(e.getMessage());
+            return DataMigrationResponse.error(e.getMessage());
         }
+
     }
 
     @Override

+ 8 - 0
src/main/java/com/persagy/proxy/migration/service/MigrationAbstractService.java

@@ -71,6 +71,14 @@ public interface MigrationAbstractService<T> {
     String commitDataByHttp(String url, String requestBody);
 
     /**
+     * 向项目侧查询数据数量
+     * @param url
+     * @param queryCriteria
+     */
+    Long queryCountByHttp(String url , QueryCriteria queryCriteria);
+
+
+    /**
      * 将list根据自定义规则转为map  id为key的第一个串
      * 使用 MigrationConstant.spliter 作为拼接符
      * @param list