瀏覽代碼

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

lijie 3 年之前
父節點
當前提交
a497832dc5

+ 9 - 1
src/main/java/com/persagy/proxy/migration/constant/MigrationConstant.java

@@ -8,13 +8,21 @@ package com.persagy.proxy.migration.constant;
  */
 public class MigrationConstant {
 
-    public final static int batchSubmitDataCount = 500;
+    public final static String ERROR = "目标地址错误不能正常访问!";
+
+    public final static int BATCH_SUBMIT_DATA_COUNT = 500;
+
     /** 数据拼接 用于list->map 时key和value拼接 **/
     public final static String SPLITER = "_";
 
     /** 数据拼接 用于map的key和value拼接成一个串 **/
     public final static String SPLITER_UNION = "@@";
 
+    /**   日志 接口 ***/
+    public final static String DT_LOG = "/dmp-rwd/rwd/log/migrate?";
+    public final static String DT_LOG_INSERT = "/dmp-rwd/rwd/log/migrate/create?";
+
+
     /**   对象类型定义 接口 ***/
     public final static String DEF_CLASS = "/dmp-rwd/rwd/def/class?";
     public final static String DEF_CLASS_INSERT = "/dmp-rwd/rwd/def/class/createBatch?";

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

@@ -8,25 +8,19 @@ package com.persagy.proxy.migration.constant;
  * @date 2021/12/3 19:54
  */
 public enum MigrationType {
-    INSERT("insert","新增"),UPDATE("update","更新"),DELETE("delete","删除"),QUERY("query","查询");
+    CREATE("create"),UPDATE("update"),DELETE("delete"),QUERY("query");
     private String code;
-    private String desc;
 
     public String getCode() {
         return code;
     }
 
-    public String getDesc() {
-        return desc;
-    }
-
-    MigrationType(String code, String desc) {
+    MigrationType(String code) {
         this.code = code;
-        this.desc = desc;
     }
 
     @Override
     public String toString() {
-        return this.code + "_" + this.desc;
+        return this.code;
     }
 }

+ 145 - 19
src/main/java/com/persagy/proxy/migration/controller/DataMigrationController.java

@@ -2,15 +2,29 @@ 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;
 import com.alibaba.excel.ExcelWriter;
 import com.alibaba.excel.write.metadata.WriteSheet;
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.persagy.dmp.basic.model.QueryCriteria;
 import com.persagy.dmp.common.constant.ResponseCode;
 import com.persagy.dmp.common.exception.BusinessException;
+import com.persagy.dmp.common.model.response.CommonResult;
+import com.persagy.dmp.common.utils.JsonHelper;
+import com.persagy.dmp.migrate.client.DigitalMigrateLogFacade;
+import com.persagy.dmp.rwd.migrate.entity.SyncData;
 import com.persagy.proxy.adm.request.AdmQueryCriteria;
 import com.persagy.proxy.adm.request.AdmResponse;
 import com.persagy.proxy.adm.utils.AdmContextUtil;
+import com.persagy.proxy.adm.utils.AdmQueryCriteriaHelper;
+import com.persagy.proxy.common.entity.DmpResult;
 import com.persagy.proxy.common.entity.InstanceUrlParam;
+import com.persagy.proxy.migration.constant.MigrationConstant;
+import com.persagy.proxy.migration.constant.MigrationObjType;
 import com.persagy.proxy.migration.handler.DataMigrationHandler;
 import com.persagy.proxy.migration.model.DataMigrationExcel;
 import com.persagy.proxy.migration.model.MigrationInfo;
@@ -18,14 +32,13 @@ 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.GetMapping;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
 
 import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
 import java.net.URLEncoder;
 import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
@@ -52,28 +65,25 @@ public class DataMigrationController {
      *  targetGroupCode 现场集团编码
      *  targetProjectId 现场项目id
      */
-    @GetMapping
-    public void migrate(HttpServletResponse response, @RequestBody MigrationInfo migrationInfo) {
+    @PostMapping("/excel")
+    public void migrateForExcel(HttpServletResponse response, @RequestBody MigrationInfo migrationInfo) {
         //调用服务迁移数据,返回处理结果excel
         try {
-            InstanceUrlParam context = AdmContextUtil.toDmpContext();
-            context.setGroupCode(migrationInfo.getTargetGroupCode());
-
             response.setContentType("application/vnd.ms-excel");
             String encode = StandardCharsets.UTF_8.name();
             response.setCharacterEncoding(encode);
-            if(migrationInfo == null || StrUtil.isBlank(migrationInfo.getTargetUrl())){
+            if (migrationInfo == null || StrUtil.isBlank(migrationInfo.getTargetUrl())) {
                 throw new BusinessException(ResponseCode.A0402.getCode(), ResponseCode.A0402.getDesc());
             }
-            if(StrUtil.isBlank(migrationInfo.getTargetGroupCode())){
-                migrationInfo.setTargetGroupCode(context.getGroupCode());
-            }
-            if(StrUtil.isBlank(migrationInfo.getTargetProjectId())){
-                migrationInfo.setTargetProjectId(context.getProjectId());
+            InstanceUrlParam context = AdmContextUtil.toDmpContext();
+            //确定集团编码 和 项目id
+            ensureParamValue(migrationInfo, context);
+            //验证目标项目地址是否正确
+            boolean valid = validTargetUrl(migrationInfo, context);
+            if (!valid) {
+                getErrorExcel(response);
             }
 
-            Map<String,List<DataMigrationExcel>> results = dataMigrationHandler.handle(context, migrationInfo);
-
             AdmQueryCriteria projectRequest = new AdmQueryCriteria();
             projectRequest.setName(AdmProject.OBJ_TYPE);
             projectRequest.setFilters("id = '" + context.getProjectId() + "';");
@@ -89,8 +99,9 @@ public class DataMigrationController {
                 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)){
+                if (CollUtil.isNotEmpty(results)) {
                     int sheetNo = 0;
                     ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream(), DataMigrationExcel.class).build();
                     try {
@@ -107,8 +118,123 @@ public class DataMigrationController {
                 }
             }
         } catch (Exception e) {
-            log.error("数据迁移失败",e);
+            getErrorExcel(response);
+        }
+    }
+
+    @PostMapping("/start")
+    public AdmResponse migrateForLog(@RequestBody MigrationInfo migrationInfo) {
+        InstanceUrlParam context = AdmContextUtil.toDmpContext();
+
+        if(migrationInfo == null || StrUtil.isBlank(migrationInfo.getTargetUrl())){
+            throw new BusinessException(ResponseCode.A0402.getCode(), ResponseCode.A0402.getDesc());
+        }
+        //确定集团编码 和 项目id
+        ensureParamValue(migrationInfo, context);
+        //验证目标项目地址是否正确
+        boolean valid = validTargetUrl(migrationInfo, context);
+        if(!valid){
+            return AdmResponse.failure(MigrationConstant.ERROR);
+        }
+        dataMigrationHandler.handleAndSaveLog(context, migrationInfo);
+        return AdmResponse.success();
+    }
+
+    @PostMapping("/log")
+    public AdmResponse queryMigrateForLog(@RequestBody AdmQueryCriteria request) {
+        QueryCriteria queryCriteria = AdmQueryCriteriaHelper.toDmpCriteria(request);
+        InstanceUrlParam context = AdmContextUtil.toDmpContext();
+        CommonResult<List<SyncData>> result = DigitalMigrateLogFacade.query(context.getGroupCode(),context.getProjectId(),context.getAppId(), context.getUserId(),queryCriteria);
+        if(result.getResult().equals(DmpResult.SUCCESS)){
+            if(CollUtil.isEmpty(result.getData())){
+                return AdmResponse.success();
+            }
+            // 设置返回值
+            AdmResponse response = AdmResponse.success(result.getData());
+            Long total = result.getCount() == null ? null : result.getCount().longValue();
+            if(request.isOnlyCount()){
+                response.setTotal(null);
+                response.setCount(total);
+            }else {
+                response.setTotal(total);
+            }
+            response.setPageNumber(request.getPageNumber());
+            response.setPageSize(request.getPageSize());
+            return response;
+        } else {
+            return AdmResponse.failure(result.getMessage());
+        }
+    }
+
+
+    private void ensureParamValue(MigrationInfo migrationInfo, InstanceUrlParam context){
+        if(migrationInfo.getTargetSign() == 0){
+            migrationInfo.setTargetGroupCode(context.getGroupCode());
+            migrationInfo.setTargetProjectId(context.getProjectId());
+        }
+        if(migrationInfo.getTargetSign() == 1){
+            if(StrUtil.isBlank(migrationInfo.getTargetGroupCode())){
+                migrationInfo.setTargetGroupCode(context.getGroupCode());
+            }
+            if(StrUtil.isBlank(migrationInfo.getTargetProjectId())){
+                migrationInfo.setTargetProjectId(context.getProjectId());
+            }
+        }
+
+    }
+
+    private boolean validTargetUrl(MigrationInfo migrationInfo, InstanceUrlParam context){
+
+        StringBuffer url = new StringBuffer(migrationInfo.getTargetUrl() + MigrationConstant.DT_OBJECT);
+        url.append("groupCode=").append(migrationInfo.getTargetGroupCode());
+        url.append("&projectId=").append(migrationInfo.getTargetProjectId());
+        if(StrUtil.isNotEmpty(context.getUserId())){
+            url.append("&userId=").append(context.getUserId());
+        }
+        if(StrUtil.isNotEmpty(context.getAppId())) {
+            url.append("&appId=").append(context.getAppId());
+        }
+        QueryCriteria queryCriteria = new QueryCriteria();
+        queryCriteria.setOnlyCount(true);
+        ObjectNode criteria = JsonNodeFactory.instance.objectNode();
+        criteria.put("valid", 1);
+        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);
+            return false;
         }
     }
 
+    private void getErrorExcel(HttpServletResponse response){
+        List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>(1);
+        DataMigrationExcel dataMigrationExcel = new DataMigrationExcel();
+        dataMigrationExcel.setId("error");
+        dataMigrationExcel.setMark(MigrationConstant.ERROR);
+        dataMigrationExcels.add(dataMigrationExcel);
+        response.setHeader("Content-disposition", "attachment;filename=error.xlsx");
+        try {
+            EasyExcel.write(response.getOutputStream(), DataMigrationExcel.class).sheet("sheet1").doWrite(dataMigrationExcels);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
 }

+ 13 - 2
src/main/java/com/persagy/proxy/migration/handler/DataMigrationHandler.java

@@ -23,19 +23,30 @@ public class DataMigrationHandler {
 
     private static Map<String, IDataMigration> migrationMap = new HashMap<>(16);
 
-    public Map<String, List<DataMigrationExcel>> handle(InstanceUrlParam context, MigrationInfo migrationInfo){
+    public Map<String, List<DataMigrationExcel>> handleAndGetExcelList(InstanceUrlParam context, MigrationInfo migrationInfo){
         Map<String,List<DataMigrationExcel>> results = new HashMap<>(16);
         if(CollUtil.isNotEmpty(migrationMap)){
             for (MigrationTable migrationTable : MigrationTable.values()){
                 if(!migrationMap.containsKey(migrationTable.getCode())){
                     continue;
                 }
-                results.put(migrationTable.getCode(), migrationMap.get(migrationTable.getCode()).migrate(context, migrationInfo));
+                results.put(migrationTable.getCode(), migrationMap.get(migrationTable.getCode()).migrateForExcel(context, migrationInfo));
             }
         }
         return results;
     }
 
+    public void handleAndSaveLog(InstanceUrlParam context, MigrationInfo migrationInfo){
+        if(CollUtil.isNotEmpty(migrationMap)){
+            for (MigrationTable migrationTable : MigrationTable.values()){
+                if(!migrationMap.containsKey(migrationTable.getCode())){
+                    continue;
+                }
+                migrationMap.get(migrationTable.getCode()).migrateForLog(context, migrationInfo);
+            }
+        }
+    }
+
     public void addMap(String tableName, IDataMigration iDataMigration){
         migrationMap.put(tableName, iDataMigration);
     }

+ 156 - 52
src/main/java/com/persagy/proxy/migration/handler/DefineInfoMigration.java

@@ -10,8 +10,11 @@ import com.persagy.dmp.common.constant.ResponseCode;
 import com.persagy.dmp.common.model.entity.BaseEntity;
 import com.persagy.dmp.define.client.DigitalObjectInfoFacade;
 import com.persagy.dmp.define.entity.ObjectInfoDefine;
+import com.persagy.dmp.rwd.migrate.entity.SyncData;
+import com.persagy.proxy.adm.request.AdmResponse;
 import com.persagy.proxy.common.entity.InstanceUrlParam;
 import com.persagy.proxy.migration.constant.MigrationConstant;
+import com.persagy.proxy.migration.constant.MigrationTable;
 import com.persagy.proxy.migration.constant.MigrationType;
 import com.persagy.proxy.migration.model.DataMigrationExcel;
 import com.persagy.proxy.migration.model.DataMigrationResponse;
@@ -19,10 +22,7 @@ import com.persagy.proxy.migration.model.MigrationInfo;
 import com.persagy.proxy.migration.service.Impl.MigrationAbstractServiceImpl;
 import lombok.extern.slf4j.Slf4j;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.stream.Collectors;
 
 /**
@@ -60,43 +60,92 @@ public class DefineInfoMigration extends MigrationAbstractServiceImpl<ObjectInfo
      * @return
      */
     @Override
-    public List<DataMigrationExcel> migrate(InstanceUrlParam context, MigrationInfo migrationInfo) {
-        log.info("######################### DefineInfo 同步开始 #########################");
+    public List<DataMigrationExcel> migrateForExcel(InstanceUrlParam context, MigrationInfo migrationInfo) {
+        log.info("######################### DefineInfo 数据迁移内容获取开始 #########################");
         long start = System.currentTimeMillis();
         List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
 
-        QueryCriteria queryCriteria = new QueryCriteria();
-        ObjectNode criteria = JsonNodeFactory.instance.objectNode();
-        criteria.put("valid", 1);
+        QueryCriteria queryCriteria = getQueryCriteria();
+        List<ObjectInfoDefine> admDefineList = getAdmData(context, queryCriteria);
+        String queryUrl = requestUrl(context, migrationInfo, MigrationType.QUERY.getCode());
+        List<ObjectInfoDefine> projectDefineList = getProjectData(queryCriteria, ObjectInfoDefine.class, queryUrl);
 
-        ObjectNode groupCode =  JsonNodeFactory.instance.objectNode();
-        groupCode.put("$ne", "0");
+        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);
 
-        ObjectNode projectId =  JsonNodeFactory.instance.objectNode();
-        projectId.put("$ne", "0");
 
-        ObjectNode andOr = JsonNodeFactory.instance.objectNode();
-        andOr.putPOJO("groupCode", projectId);
-        andOr.putPOJO("projectId", groupCode);
+        //差集 新增
+        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()));
+        }
 
-        criteria.putPOJO("$andOr", andOr);
+        //差集 删除
+        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)+" #########################");
+
+        return dataMigrationExcels;
+    }
+
+    @Override
+    public AdmResponse migrateForLog(InstanceUrlParam context, MigrationInfo migrationInfo) {
+        log.info("######################### DefineInfo 同步开始 #########################");
+        long start = System.currentTimeMillis();
+        List<SyncData> syncDataList = new ArrayList<>();
+
+        QueryCriteria queryCriteria = getQueryCriteria();
 
-        queryCriteria.setCriteria(criteria);
-        queryCriteria.setSize(-1L);
         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());
+        String insertUrl = requestUrl(context, migrationInfo, MigrationType.CREATE.getCode());
         if(CollUtil.isEmpty(projectDefineList)){
             log.info("######################### DefineInfo 批量插入数据 #########################");
             DataMigrationResponse response = insertBatch(admDefineList, ObjectInfoDefine.class, insertUrl);
-            dataMigrationExcels.addAll(processData(response, MigrationType.INSERT.getDesc()));
-            return dataMigrationExcels;
+            syncDataList.addAll(processDataForLog(response, MigrationType.CREATE.getCode()));
         }
         List<ObjectNode> objectNodeListPro = JsonNodeUtils.toListNode(projectDefineList, null, null);
         Map<String,Object> projectDefineMap = toEntityMap(objectNodeListPro, ObjectInfoDefine.class);
@@ -109,7 +158,7 @@ public class DefineInfoMigration extends MigrationAbstractServiceImpl<ObjectInfo
         Map<String,Object> subtractFromDel = doSubtractAdd(admDefineMap, projectDefineMap);
         if(!CollUtil.isEmpty(subtractFromDel)){
             List<ObjectInfoDefine> insertData = toList(subtractFromDel, admDefineList);
-            dataMigrationExcels.addAll(processData(insertBatch(insertData, ObjectInfoDefine.class, insertUrl), MigrationType.INSERT.getDesc()));
+            syncDataList.addAll(processDataForLog(insertBatch(insertData, ObjectInfoDefine.class, insertUrl), MigrationType.CREATE.getCode()));
         }
 
         //差集 删除
@@ -118,8 +167,12 @@ public class DefineInfoMigration extends MigrationAbstractServiceImpl<ObjectInfo
         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);
-            dataMigrationExcels.addAll(processData(response, MigrationType.DELETE.getDesc()));
+            //处理删除的数据
+            DataMigrationResponse dataMigrationResponse = deleteBatch(deleteIds, ObjectInfoDefine.class, delUrl);
+            List<String> successIds = (List<String>) dataMigrationResponse.getData();
+            List<ObjectInfoDefine> delObjs = toListByIds(successIds, admDefineList);
+            dataMigrationResponse.setData(delObjs);
+            syncDataList.addAll(processDataForLog(dataMigrationResponse, MigrationType.DELETE.getCode()));
         }
 
         //交集更新
@@ -132,13 +185,13 @@ public class DefineInfoMigration extends MigrationAbstractServiceImpl<ObjectInfo
             if(CollUtil.isNotEmpty(compareData) && compareData.size() > 0){
                 List<ObjectInfoDefine> updateData = toList(compareData, admDefineList);
                 String updateUrl = requestUrl(context, migrationInfo, MigrationType.UPDATE.getCode());
-                dataMigrationExcels.addAll(processData(updateBatch(updateData, ObjectInfoDefine.class, updateUrl), MigrationType.UPDATE.getCode()));
+                syncDataList.addAll(processDataForLog(updateBatch(updateData, ObjectInfoDefine.class, updateUrl), MigrationType.UPDATE.getCode()));
             }
         }
         long end = System.currentTimeMillis();
-        log.info("######################### DefineInfo 数据迁移已结束 时间:"+(end-start)+" #########################");
-
-        return dataMigrationExcels;
+        log.info("######################### DefineInfo 数据迁移已结束 时间:"+(end-start)+" 共计:"+syncDataList.size()+"条 #########################");
+        super.addSynLog(context, syncDataList);
+        return AdmResponse.success();
     }
 
     /**
@@ -164,16 +217,24 @@ public class DefineInfoMigration extends MigrationAbstractServiceImpl<ObjectInfo
 
     public List<ObjectInfoDefine> toList(Map<String, Object> fromMap, List<ObjectInfoDefine> fromList) {
         if(CollUtil.isEmpty(fromMap) || CollUtil.isEmpty(fromList)){
-            return null;
+            return Collections.emptyList();
+        }
+        return toListByIds(fromMap.keySet(), fromList);
+    }
+
+    public List<ObjectInfoDefine> toListByIds(Collection<String> ids, List<ObjectInfoDefine> fromList) {
+        if(CollUtil.isEmpty(ids) || CollUtil.isEmpty(fromList)){
+            return Collections.emptyList();
         }
-        List<ObjectInfoDefine> results = new ArrayList<>(fromMap.size());
+        List<ObjectInfoDefine> results = new ArrayList<>(ids.size());
         Map<String, ObjectInfoDefine> objectInfoDefineMap = CollUtil.fieldValueMap(fromList, BaseEntity.PROP_ID);
-        for(String key : fromMap.keySet()){
+        for(String key : ids){
             results.add(objectInfoDefineMap.get(key));
         }
         return results;
     }
 
+
     /**
      * 拼接访问链接
      *
@@ -190,7 +251,7 @@ public class DefineInfoMigration extends MigrationAbstractServiceImpl<ObjectInfo
         StringBuilder url = new StringBuilder(migrationInfo.getTargetUrl());
         if(type.equals(MigrationType.QUERY.getCode())) {
             url.append(MigrationConstant.DEF_FUNCID);
-        }else if(type.equals(MigrationType.INSERT.getCode())){
+        }else if(type.equals(MigrationType.CREATE.getCode())){
             url.append(MigrationConstant.DEF_FUNCID_INSERT);
         }else if(type.equals(MigrationType.UPDATE.getCode())){
             url.append(MigrationConstant.DEF_FUNCID_UPDATE);
@@ -203,36 +264,79 @@ public class DefineInfoMigration extends MigrationAbstractServiceImpl<ObjectInfo
     /**
      * 将目标集合处理成excel格式的集合  使用与insert/delete
      *
+     * @param list
+     * @return
+     */
+    @Override
+    public List<DataMigrationExcel> processDataForExcel(Collection list, String type) {
+        if(CollUtil.isEmpty(list)){
+            return Collections.emptyList();
+        }
+        List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
+        for(Object obj : list){
+            ObjectInfoDefine define = (ObjectInfoDefine) obj;
+            DataMigrationExcel excel = new DataMigrationExcel();
+            excel.setId(define.getId());
+            excel.setCode(define.getCode());
+            excel.setName(define.getName());
+            excel.setType(type);
+            dataMigrationExcels.add(excel);
+        }
+        return dataMigrationExcels;
+    }
+
+    /**
+     * 将目标集合处理成SyncData(日志)格式的集合  入库
+     *
      * @param dataMigrationResponse
+     * @param type                  insert/delete
      * @return
      */
     @Override
-    public List<DataMigrationExcel> processData(DataMigrationResponse dataMigrationResponse, String type) {
+    public List<SyncData> processDataForLog(DataMigrationResponse dataMigrationResponse, String type) {
         if(CollUtil.isEmpty(dataMigrationResponse.getData()) && CollUtil.isEmpty(dataMigrationResponse.getErrorMsg())){
             return Collections.emptyList();
         }
-        List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
+        List<SyncData> syncDataList = new ArrayList<>();
         if(CollUtil.isNotEmpty(dataMigrationResponse.getData())){
             for(Object obj : dataMigrationResponse.getData()){
-                if(!type.equals(MigrationType.DELETE.getCode())){
-                    ObjectInfoDefine define = (ObjectInfoDefine) obj;
-                    DataMigrationExcel excel = new DataMigrationExcel();
-                    excel.setId(define.getId());
-                    excel.setCode(define.getCode());
-                    excel.setName(define.getName());
-                    excel.setType(type);
-                    dataMigrationExcels.add(excel);
-                }else{
-                    DataMigrationExcel excel = new DataMigrationExcel();
-                    excel.setId(obj.toString());
-                    excel.setType(type);
-                    dataMigrationExcels.add(excel);
-                }
+                ObjectInfoDefine infoDefine = (ObjectInfoDefine) obj;
+                SyncData syncData = new SyncData();
+                syncData.setTableName(MigrationTable.DTDEFINEINFO.getCode());
+                syncData.setTargetId(infoDefine.getId());
+                syncData.setName(infoDefine.getName());
+                syncData.setCode(infoDefine.getCode());
+                syncData.setClassCode(infoDefine.getClassCode());
+                syncData.setType(type);//操作
+                syncDataList.add(syncData);
             }
         }
         if(CollUtil.isNotEmpty(dataMigrationResponse.getErrorMsg())){
-            dataMigrationExcels.addAll(addErrorInfo(dataMigrationResponse.getErrorMsg()));
+            syncDataList.addAll(addErrorInfoForLog(dataMigrationResponse.getErrorMsg(),MigrationTable.DTDEFINEINFO.getCode()));
         }
-        return dataMigrationExcels;
+        return syncDataList;
+    }
+
+
+    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;
     }
 }

+ 155 - 53
src/main/java/com/persagy/proxy/migration/handler/DefineTypeMigration.java

@@ -10,8 +10,11 @@ import com.persagy.dmp.common.constant.ResponseCode;
 import com.persagy.dmp.common.model.entity.BaseEntity;
 import com.persagy.dmp.define.client.DigitalDefineFacade;
 import com.persagy.dmp.define.entity.ObjectTypeDefine;
+import com.persagy.dmp.rwd.migrate.entity.SyncData;
+import com.persagy.proxy.adm.request.AdmResponse;
 import com.persagy.proxy.common.entity.InstanceUrlParam;
 import com.persagy.proxy.migration.constant.MigrationConstant;
+import com.persagy.proxy.migration.constant.MigrationTable;
 import com.persagy.proxy.migration.constant.MigrationType;
 import com.persagy.proxy.migration.model.DataMigrationExcel;
 import com.persagy.proxy.migration.model.DataMigrationResponse;
@@ -19,10 +22,7 @@ import com.persagy.proxy.migration.model.MigrationInfo;
 import com.persagy.proxy.migration.service.Impl.MigrationAbstractServiceImpl;
 import lombok.extern.slf4j.Slf4j;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.stream.Collectors;
 
 /**
@@ -59,28 +59,82 @@ public class DefineTypeMigration extends MigrationAbstractServiceImpl<ObjectType
      * @return
      */
     @Override
-    public List<DataMigrationExcel> migrate(InstanceUrlParam context, MigrationInfo migrationInfo) {
-        log.info("######################### DefineType 同步开始 #########################");
+    public List<DataMigrationExcel> migrateForExcel(InstanceUrlParam context, MigrationInfo migrationInfo) {
+        log.info("######################### DefineType 数据迁移内容获取开始 #########################");
         long start = System.currentTimeMillis();
         List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
 
-        QueryCriteria queryCriteria = new QueryCriteria();
-        ObjectNode criteria = JsonNodeFactory.instance.objectNode();
-        criteria.put("valid", 1);
-        ObjectNode groupCode =  JsonNodeFactory.instance.objectNode();
-        groupCode.put("$ne", "0");
+        QueryCriteria queryCriteria = getQueryCriteria();
 
-        ObjectNode projectId =  JsonNodeFactory.instance.objectNode();
-        projectId.put("$ne", "0");
+        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;
+        }
 
-        ObjectNode andOr = JsonNodeFactory.instance.objectNode();
-        andOr.putPOJO("groupCode", projectId);
-        andOr.putPOJO("projectId", groupCode);
+        //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()));
 
-        criteria.putPOJO("$andOr", andOr);
+            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);
 
-        queryCriteria.setCriteria(criteria);
-        queryCriteria.setSize(-1L);
+        //差集 新增
+        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;
+    }
+
+    @Override
+    public AdmResponse migrateForLog(InstanceUrlParam context, MigrationInfo migrationInfo) {
+        log.info("######################### DefineType 同步开始 #########################");
+        long start = System.currentTimeMillis();
+        List<SyncData> syncDataList = new ArrayList<>();
+
+        QueryCriteria queryCriteria = getQueryCriteria();
 
         List<ObjectTypeDefine> admDefineList = getAdmData(context, queryCriteria);
         String queryUrl = requestUrl(context, migrationInfo, MigrationType.QUERY.getCode());
@@ -88,16 +142,13 @@ public class DefineTypeMigration extends MigrationAbstractServiceImpl<ObjectType
         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());
+        String insertUrl = requestUrl(context, migrationInfo, MigrationType.CREATE.getCode());
         if(CollUtil.isEmpty(objectNodeList)){
             log.info("######################### DefineType 批量插入数据 #########################");
             DataMigrationResponse dataMigrationResponse = insertBatch(admDefineList, ObjectTypeDefine.class, insertUrl);
-            dataMigrationExcels.addAll(processData(dataMigrationResponse, MigrationType.INSERT.getDesc()));
-
-            return dataMigrationExcels;
+            syncDataList.addAll(processDataForLog(dataMigrationResponse, MigrationType.CREATE.getCode()));
         }
         List<ObjectNode> objectNodeListPro = JsonNodeUtils.toListNode(objectNodeList, null, null);
         Map<String,Object> projectDefineMap = toEntityMap(objectNodeListPro, ObjectTypeDefine.class);
@@ -110,7 +161,7 @@ public class DefineTypeMigration extends MigrationAbstractServiceImpl<ObjectType
         if(!CollUtil.isEmpty(doSubtractFromInsert)){
             List<ObjectTypeDefine> insertData = toList(doSubtractFromInsert, admDefineList);
             DataMigrationResponse dataMigrationResponse = insertBatch(insertData, ObjectTypeDefine.class, insertUrl);
-            dataMigrationExcels.addAll(processData(dataMigrationResponse, MigrationType.INSERT.getDesc()));
+            syncDataList.addAll(processDataForLog(dataMigrationResponse, MigrationType.CREATE.getCode()));
         }
 
         //差集 删除
@@ -118,11 +169,13 @@ public class DefineTypeMigration extends MigrationAbstractServiceImpl<ObjectType
         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 = toList(doSubtractFromDelete, projectDefineList);
 
             String delUrl = requestUrl(context, migrationInfo, MigrationType.DELETE.getCode());
             DataMigrationResponse dataMigrationResponse = deleteBatch(deleteIds, ObjectTypeDefine.class, delUrl);
-            dataMigrationExcels.addAll(processData(dataMigrationResponse, MigrationType.DELETE.getDesc()));
+            List<String> successIds = (List<String>) dataMigrationResponse.getData();
+            List<ObjectTypeDefine> delObjs = toListByIds(successIds, admDefineList);
+            dataMigrationResponse.setData(delObjs);
+            syncDataList.addAll(processDataForLog(dataMigrationResponse, MigrationType.DELETE.getCode()));
         }
 
         //交集更新
@@ -136,12 +189,13 @@ public class DefineTypeMigration extends MigrationAbstractServiceImpl<ObjectType
                 List<ObjectTypeDefine> updateData = toList(compareData, admDefineList);
                 String updateUrl = requestUrl(context, migrationInfo, MigrationType.UPDATE.getCode());
                 DataMigrationResponse dataMigrationResponse = updateBatch(updateData, ObjectTypeDefine.class, updateUrl);
-                dataMigrationExcels.addAll(processData(dataMigrationResponse, MigrationType.UPDATE.getDesc()));
+                syncDataList.addAll(processDataForLog(dataMigrationResponse, MigrationType.UPDATE.getCode()));
             }
         }
         long end = System.currentTimeMillis();
-        log.info("######################### DefineType 数据迁移已结束 时间:"+(end-start)+" #########################");
-        return dataMigrationExcels;
+        log.info("######################### DefineType 数据迁移已结束 时间:"+(end-start)+" 共计:"+syncDataList.size()+"条 #########################");
+        super.addSynLog(context, syncDataList);
+        return AdmResponse.success();
     }
 
     /**
@@ -157,6 +211,28 @@ 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 作为拼接符
@@ -164,14 +240,20 @@ public class DefineTypeMigration extends MigrationAbstractServiceImpl<ObjectType
      * @param fromList
      * @return
      */
-
     public List<ObjectTypeDefine> toList(Map<String, Object> fromMap, List<ObjectTypeDefine> fromList) {
         if(CollUtil.isEmpty(fromMap) || CollUtil.isEmpty(fromList)){
-            return null;
+            return Collections.emptyList();
         }
-        List<ObjectTypeDefine> results = new ArrayList<>(fromMap.size());
+        return toListByIds(fromMap.keySet(), fromList);
+    }
+
+    public List<ObjectTypeDefine> toListByIds(Collection<String> ids, List<ObjectTypeDefine> fromList) {
+        if(CollUtil.isEmpty(ids) || CollUtil.isEmpty(fromList)){
+            return Collections.emptyList();
+        }
+        List<ObjectTypeDefine> results = new ArrayList<>(ids.size());
         Map<String, ObjectTypeDefine> objectTypeDefineMap = CollUtil.fieldValueMap(fromList, BaseEntity.PROP_ID);
-        for(String key : fromMap.keySet()){
+        for(String key : ids){
             results.add(objectTypeDefineMap.get(StrUtil.trim(key)));
         }
         return results;
@@ -194,7 +276,7 @@ public class DefineTypeMigration extends MigrationAbstractServiceImpl<ObjectType
         StringBuilder url = new StringBuilder(migrationInfo.getTargetUrl());
         if(type.equals(MigrationType.QUERY.getCode())) {
             url.append(MigrationConstant.DEF_CLASS);
-        }else if(type.equals(MigrationType.INSERT.getCode())){
+        }else if(type.equals(MigrationType.CREATE.getCode())){
             url.append(MigrationConstant.DEF_CLASS_INSERT);
         }else if(type.equals(MigrationType.UPDATE.getCode())){
             url.append(MigrationConstant.DEF_CLASS_UPDATE);
@@ -207,37 +289,57 @@ public class DefineTypeMigration extends MigrationAbstractServiceImpl<ObjectType
     /**
      * 将目标集合处理成excel格式的集合  使用与insert/delete
      *
+     * @param list
+     * @return
+     */
+    @Override
+    public List<DataMigrationExcel> processDataForExcel(Collection list, String type) {
+        if(CollUtil.isEmpty(list) ){
+            return Collections.emptyList();
+        }
+        List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
+        for(Object obj : list){
+            ObjectTypeDefine objectTypeDefine = (ObjectTypeDefine) obj;
+            DataMigrationExcel excel = new DataMigrationExcel();
+            excel.setId(objectTypeDefine.getId());
+            excel.setCode(objectTypeDefine.getCode());
+            excel.setName(objectTypeDefine.getName());
+            excel.setType(type);
+            dataMigrationExcels.add(excel);
+        }
+        return dataMigrationExcels;
+    }
+
+    /**
+     * 将目标集合处理成SyncData(日志)格式的集合  入库
+     *
      * @param dataMigrationResponse
+     * @param type                  insert/delete
      * @return
      */
     @Override
-    public List<DataMigrationExcel> processData(DataMigrationResponse dataMigrationResponse, String type) {
+    public List<SyncData> processDataForLog(DataMigrationResponse dataMigrationResponse, String type) {
         if(CollUtil.isEmpty(dataMigrationResponse.getData()) && CollUtil.isEmpty(dataMigrationResponse.getErrorMsg())){
             return Collections.emptyList();
         }
-        List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
+        List<SyncData> syncDataList = new ArrayList<>();
         if(CollUtil.isNotEmpty(dataMigrationResponse.getData())){
             for(Object obj : dataMigrationResponse.getData()){
-                if(!type.equals(MigrationType.DELETE.getCode())){
-                    ObjectTypeDefine objectTypeDefine = (ObjectTypeDefine) obj;
-                    DataMigrationExcel excel = new DataMigrationExcel();
-                    excel.setId(objectTypeDefine.getId());
-                    excel.setCode(objectTypeDefine.getCode());
-                    excel.setName(objectTypeDefine.getName());
-                    excel.setType(type);
-                    dataMigrationExcels.add(excel);
-                }else{
-                    DataMigrationExcel excel = new DataMigrationExcel();
-                    excel.setId(obj.toString());
-                    excel.setType(type);
-                    dataMigrationExcels.add(excel);
-                }
+                ObjectTypeDefine objectTypeDefine = (ObjectTypeDefine) obj;
+                SyncData syncData = new SyncData();
+                syncData.setTableName(MigrationTable.DTDEFINETYPE.getCode());
+                syncData.setTargetId(objectTypeDefine.getId());
+                syncData.setName(objectTypeDefine.getName());
+                syncData.setCode(objectTypeDefine.getCode());
+                syncData.setObjectType(objectTypeDefine.getObjType());
+                syncData.setType(type);//操作
+                syncDataList.add(syncData);
             }
         }
         if(CollUtil.isNotEmpty(dataMigrationResponse.getErrorMsg())){
-            dataMigrationExcels.addAll(addErrorInfo(dataMigrationResponse.getErrorMsg()));
+            syncDataList.addAll(addErrorInfoForLog(dataMigrationResponse.getErrorMsg(), MigrationTable.DTDEFINETYPE.getCode()));
         }
-        return dataMigrationExcels;
+        return syncDataList;
     }
 
 }

+ 3 - 1
src/main/java/com/persagy/proxy/migration/handler/IDataMigration.java

@@ -1,5 +1,6 @@
 package com.persagy.proxy.migration.handler;
 
+import com.persagy.proxy.adm.request.AdmResponse;
 import com.persagy.proxy.common.entity.InstanceUrlParam;
 import com.persagy.proxy.migration.model.DataMigrationExcel;
 import com.persagy.proxy.migration.model.MigrationInfo;
@@ -20,6 +21,7 @@ public interface IDataMigration{
      * @param context
      * @return
      */
-    List<DataMigrationExcel> migrate(InstanceUrlParam context, MigrationInfo migrationInfo);
+    List<DataMigrationExcel> migrateForExcel(InstanceUrlParam context, MigrationInfo migrationInfo);
+    AdmResponse migrateForLog(InstanceUrlParam context, MigrationInfo migrationInfo);
 
 }

+ 12 - 1
src/main/java/com/persagy/proxy/migration/handler/IDataMigrationProcess.java

@@ -1,11 +1,13 @@
 package com.persagy.proxy.migration.handler;
 
 import com.persagy.dmp.basic.model.QueryCriteria;
+import com.persagy.dmp.rwd.migrate.entity.SyncData;
 import com.persagy.proxy.common.entity.InstanceUrlParam;
 import com.persagy.proxy.migration.model.DataMigrationExcel;
 import com.persagy.proxy.migration.model.DataMigrationResponse;
 import com.persagy.proxy.migration.model.MigrationInfo;
 
+import java.util.Collection;
 import java.util.List;
 
 /**
@@ -34,10 +36,19 @@ public interface IDataMigrationProcess<T> {
 
     /**
      * 将目标集合处理成excel格式的集合  使用与insert/delete
+     * @param list
+     * @param type insert/delete
+     * @return
+     */
+    List<DataMigrationExcel> processDataForExcel(Collection list, String type);
+
+    /**
+     * 将目标集合处理成SyncData(日志)格式的集合  入库
      * @param dataMigrationResponse
      * @param type insert/delete
      * @return
      */
-    List<DataMigrationExcel> processData(DataMigrationResponse dataMigrationResponse, String type);
+    List<SyncData> processDataForLog(DataMigrationResponse dataMigrationResponse, String type);
+
 
 }

+ 166 - 45
src/main/java/com/persagy/proxy/migration/handler/ObjectDigitalMigration.java

@@ -9,8 +9,12 @@ import com.persagy.dmp.basic.utils.JsonNodeUtils;
 import com.persagy.dmp.common.constant.ResponseCode;
 import com.persagy.dmp.digital.client.DigitalObjectFacade;
 import com.persagy.dmp.digital.entity.ObjectDigital;
+import com.persagy.dmp.rwd.migrate.entity.SyncData;
+import com.persagy.proxy.adm.request.AdmResponse;
 import com.persagy.proxy.common.entity.InstanceUrlParam;
 import com.persagy.proxy.migration.constant.MigrationConstant;
+import com.persagy.proxy.migration.constant.MigrationObjType;
+import com.persagy.proxy.migration.constant.MigrationTable;
 import com.persagy.proxy.migration.constant.MigrationType;
 import com.persagy.proxy.migration.model.DataMigrationExcel;
 import com.persagy.proxy.migration.model.DataMigrationResponse;
@@ -55,30 +59,54 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
      * @return
      */
     @Override
-    public List<DataMigrationExcel> migrate(InstanceUrlParam context, MigrationInfo migrationInfo) {
-        log.info("######################### dt_object 同步开始 #########################");
+    public List<DataMigrationExcel> migrateForExcel(InstanceUrlParam context, MigrationInfo migrationInfo) {
+        log.info("######################### dt_object 数据迁移内容获取开始 #########################");
         long start = System.currentTimeMillis();
         List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
 
-        //for(MigrationObjType objType : MigrationObjType.values()){
-            //log.info("######################### dt_object "+objType.getCode()+"同步开始 #########################");
-            QueryCriteria queryCriteria = new QueryCriteria();
-            queryCriteria.setSize(-1L);
-            ObjectNode criteria = JsonNodeFactory.instance.objectNode();
-            criteria.put("valid", 1);
-            criteria.put("objType", "equipment");
-            //criteria.put("objType", objType.getCode());
-            queryCriteria.setCriteria(criteria);
-            dataMigrationExcels.addAll(startMigrate(context,migrationInfo,queryCriteria));
-            //log.info("######################### dt_object "+objType.getCode()+"同步结束 #########################");
-        //}
+        for(MigrationObjType objType : MigrationObjType.values()){
+            log.info("######################### dt_object "+objType.getCode()+"数据迁移内容获取开始 #########################");
+
+            QueryCriteria queryCriteria = getQueryCriteria(objType.getCode());
+            dataMigrationExcels.addAll(startMigrateForExcel(context,migrationInfo,queryCriteria));
+
+            log.info("######################### dt_object "+objType.getCode()+"数据迁移内容获取结束 #########################");
+        }
+
         long end = System.currentTimeMillis();
-        log.info("######################### dt_object 数据迁移已结束 时间:"+(end-start)+" #########################");
+        log.info("######################### dt_object 数数据迁移内容获取已结束 时间:"+(end-start)+" #########################");
         return dataMigrationExcels;
     }
 
-    private List<DataMigrationExcel> startMigrate(InstanceUrlParam context, MigrationInfo migrationInfo, QueryCriteria queryCriteria) {
-        List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
+    @Override
+    public AdmResponse migrateForLog(InstanceUrlParam context, MigrationInfo migrationInfo) {
+        log.info("######################### dt_object 同步开始 #########################");
+        long start = System.currentTimeMillis();
+        for(MigrationObjType objType : MigrationObjType.values()){
+            log.info("######################### dt_object "+objType.getCode()+"同步开始 #########################");
+
+            QueryCriteria queryCriteria = getQueryCriteria(objType.getCode());
+            List<SyncData> syncDataList = startMigrateForLog(context,migrationInfo,queryCriteria);
+
+            log.info("######################### dt_object "+objType.getCode()+"同步结束 共计:"+syncDataList.size()+"条 #########################");
+        }
+        long end = System.currentTimeMillis();
+        log.info("######################### dt_object 数据迁移已结束 时间:"+(end-start)+" #########################");
+        return AdmResponse.success();
+    }
+
+    private QueryCriteria getQueryCriteria(String typeCode){
+        QueryCriteria queryCriteria = new QueryCriteria();
+        queryCriteria.setSize(-1L);
+        ObjectNode criteria = JsonNodeFactory.instance.objectNode();
+        criteria.put("valid", 1);
+        criteria.put("objType", typeCode);
+        queryCriteria.setCriteria(criteria);
+        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());
@@ -87,14 +115,12 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
 
         if(CollUtil.isEmpty(admData)){
             log.error(" ######################### dt_object adm已交付:"+ ResponseCode.C0320.getDesc() +" 同步结束 #########################");
-            return Collections.emptyList();
         }
 
-        String insertUrl = requestUrl(context, migrationInfo, MigrationType.INSERT.getCode());
+        String insertUrl = requestUrl(context, migrationInfo, MigrationType.CREATE.getCode());
         if(CollUtil.isEmpty(objectNodeList)){
             DataMigrationResponse dataMigrationResponse = insertBatch(admData, ObjectDigital.class, insertUrl);
-            dataMigrationExcels.addAll(processData(dataMigrationResponse, MigrationType.INSERT.getDesc()));
-            return dataMigrationExcels;
+            syncDataList = processDataForLog(dataMigrationResponse, MigrationType.CREATE.getCode());
         }
         Map<String,Object> projectMap = toEntityMap(objectNodeList, ObjectDigital.class);
         Map<String,Object> admMap = toEntityMap(admData, ObjectDigital.class);
@@ -103,7 +129,7 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
         if(!CollUtil.isEmpty(doSubtractFromInsert)){
             List<ObjectNode> insertData = toList(doSubtractFromInsert, admData);
             DataMigrationResponse dataMigrationResponse = insertBatch(insertData, ObjectDigital.class, insertUrl);
-            dataMigrationExcels.addAll(processData(dataMigrationResponse, MigrationType.INSERT.getDesc()));
+            syncDataList.addAll(processDataForLog(dataMigrationResponse, MigrationType.CREATE.getCode()));
         }
 
         //差集 删除
@@ -111,8 +137,12 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
         if(!CollUtil.isEmpty(doSubtractFromDelete)){
             List<String> deleteIds = doSubtractFromDelete.entrySet().stream().map(en -> en.getKey()).collect(Collectors.toList());
             String delUrl = requestUrl(context, migrationInfo, MigrationType.DELETE.getCode());
+            //处理删除的数据
             DataMigrationResponse dataMigrationResponse = deleteBatch(deleteIds, ObjectDigital.class, delUrl);
-            dataMigrationExcels.addAll(processData(dataMigrationResponse, MigrationType.DELETE.getDesc()));
+            List<String> successIds = (List<String>) dataMigrationResponse.getData();
+            List<ObjectNode> delObjs = toListByIds(successIds, admData);
+            dataMigrationResponse.setData(delObjs);
+            syncDataList.addAll(processDataForLog(dataMigrationResponse, MigrationType.DELETE.getCode()));
         }
 
         //交集更新
@@ -125,7 +155,65 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
                 List<ObjectNode> updateData = toList(compareData, admData);
                 String updateUrl = requestUrl(context, migrationInfo, MigrationType.UPDATE.getCode());
                 DataMigrationResponse dataMigrationResponse = updateBatch(updateData, ObjectDigital.class, updateUrl);
-                dataMigrationExcels.addAll(processData(dataMigrationResponse, MigrationType.UPDATE.getDesc()));
+                syncDataList.addAll(processDataForLog(dataMigrationResponse, MigrationType.UPDATE.getCode()));
+            }
+        }
+       return super.addSynLog(context, syncDataList);
+    }
+
+
+
+    private List<DataMigrationExcel> startMigrateForExcel(InstanceUrlParam context, MigrationInfo migrationInfo, QueryCriteria queryCriteria) {
+        List<DataMigrationExcel> dataMigrationExcels = 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);
+
+        if(CollUtil.isEmpty(admData)){
+            log.error(" ######################### dt_object adm已交付:"+ ResponseCode.C0320.getDesc() +" 同步结束 #########################");
+            return Collections.emptyList();
+        }
+
+        //String insertUrl = requestUrl(context, migrationInfo, MigrationType.INSERT.getCode());
+        if(CollUtil.isEmpty(objectNodeList)){
+            //DataMigrationResponse dataMigrationResponse = insertBatch(admData, ObjectDigital.class, insertUrl);
+            dataMigrationExcels.addAll(processDataForExcel(admData, MigrationType.CREATE.getCode()));
+            return dataMigrationExcels;
+        }
+        Map<String,Object> projectMap = toEntityMap(objectNodeList, ObjectDigital.class);
+        Map<String,Object> admMap = toEntityMap(admData, ObjectDigital.class);
+        //差集 新增
+        Map<String,Object> doSubtractFromInsert = doSubtractAdd(admMap, projectMap);
+        if(!CollUtil.isEmpty(doSubtractFromInsert)){
+            List<ObjectNode> insertData = toList(doSubtractFromInsert, admData);
+            //DataMigrationResponse dataMigrationResponse = insertBatch(insertData, ObjectDigital.class, insertUrl);
+            dataMigrationExcels.addAll(processDataForExcel(insertData, MigrationType.CREATE.getCode()));
+        }
+
+        //差集 删除
+        Map<String,Object> doSubtractFromDelete = doSubtractDel(admMap, projectMap);
+        if(!CollUtil.isEmpty(doSubtractFromDelete)){
+            List<String> deleteIds = doSubtractFromDelete.entrySet().stream().map(en -> en.getKey()).collect(Collectors.toList());
+
+            List<ObjectNode> deleteData = toListByIds(deleteIds, admData);
+            //String delUrl = requestUrl(context, migrationInfo, MigrationType.DELETE.getCode());
+            //DataMigrationResponse dataMigrationResponse = deleteBatch(deleteIds, ObjectDigital.class, delUrl);
+            dataMigrationExcels.addAll(processDataForExcel(deleteData, MigrationType.DELETE.getCode()));
+        }
+
+        //交集更新
+        Map<String,Object> intersectionUpdateFrom = doIntersectionGetFrom(admMap, projectMap);
+        Map<String,Object> intersectionUpdateTo = doIntersectionGetTo(admMap, projectMap);
+
+        if(!CollUtil.isEmpty(intersectionUpdateFrom) && !CollUtil.isEmpty(intersectionUpdateTo)){
+            Map<String, Object> compareData = compareData(intersectionUpdateFrom, intersectionUpdateTo);
+            if(CollUtil.isNotEmpty(compareData) && compareData.size() > 0){
+                List<ObjectNode> updateData = toList(compareData, admData);
+                //String updateUrl = requestUrl(context, migrationInfo, MigrationType.UPDATE.getCode());
+                //DataMigrationResponse dataMigrationResponse = updateBatch(updateData, ObjectDigital.class, updateUrl);
+                dataMigrationExcels.addAll(processDataForExcel(updateData, MigrationType.UPDATE.getCode()));
             }
         }
 
@@ -156,9 +244,17 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
      */
     public List<ObjectNode> toList(Map<String, Object> fromMap, List<ObjectNode> fromList) {
         if(CollUtil.isEmpty(fromMap) || CollUtil.isEmpty(fromList)){
-            return null;
+            return Collections.emptyList();
         }
-        List<ObjectNode> results = new ArrayList<>(fromMap.size());
+        return toListByIds(fromMap.keySet(), fromList);
+    }
+
+
+    public List<ObjectNode> toListByIds(Collection<String> ids, List<ObjectNode> fromList) {
+        if(CollUtil.isEmpty(ids) || CollUtil.isEmpty(fromList)){
+            return Collections.emptyList();
+        }
+        List<ObjectNode> results = new ArrayList<>(ids.size());
 
         Map<String, ObjectNode> objectDigitalMap =  new HashMap<>(fromList.size());
         for(ObjectNode node :  fromList){
@@ -168,12 +264,14 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
             objectDigitalMap.put(node.get("id").asText(), node);
         }
 
-        for(String key : fromMap.keySet()){
+        for(String key : ids){
             results.add(objectDigitalMap.get(key));
         }
         return results;
     }
 
+
+
     /**
      * 拼接访问链接
      *
@@ -190,7 +288,7 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
         StringBuilder url = new StringBuilder(migrationInfo.getTargetUrl());
         if(type.equals(MigrationType.QUERY.getCode())) {
             url.append(MigrationConstant.DT_OBJECT);
-        }else if(type.equals(MigrationType.INSERT.getCode())){
+        }else if(type.equals(MigrationType.CREATE.getCode())){
             url.append(MigrationConstant.DT_OBJECT_INSERT);
         }else if(type.equals(MigrationType.UPDATE.getCode())){
             url.append(MigrationConstant.DT_OBJECT_UPDATE);
@@ -203,35 +301,58 @@ public class ObjectDigitalMigration extends MigrationAbstractServiceImpl<ObjectD
     /**
      * 将目标集合处理成excel格式的集合  使用与insert/delete
      *
+     * @param list
+     * @return
+     */
+    @Override
+    public List<DataMigrationExcel> processDataForExcel(Collection list, String type) {
+        if(CollUtil.isEmpty(list)){
+            return Collections.emptyList();
+        }
+        List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
+        for(Object obj : list){
+            ObjectDigital digital = JsonNodeUtils.toEntity((ObjectNode) obj, ObjectDigital.class, null);
+            DataMigrationExcel excel = new DataMigrationExcel();
+            excel.setId(digital.getId());
+            excel.setName(digital.getName());
+            excel.setType(type);
+            dataMigrationExcels.add(excel);
+        }
+        return dataMigrationExcels;
+    }
+
+    /**
+     * 将目标集合处理成SyncData(日志)格式的集合  入库
+     *
      * @param dataMigrationResponse
+     * @param type    insert/delete
      * @return
      */
     @Override
-    public List<DataMigrationExcel> processData(DataMigrationResponse dataMigrationResponse, String type) {
+    public List<SyncData> processDataForLog(DataMigrationResponse dataMigrationResponse, String type) {
         if(CollUtil.isEmpty(dataMigrationResponse.getData()) && CollUtil.isEmpty(dataMigrationResponse.getErrorMsg())){
             return Collections.emptyList();
         }
-        List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
+        List<SyncData> syncDataList = new ArrayList<>();
         if(CollUtil.isNotEmpty(dataMigrationResponse.getData())){
             for(Object obj : dataMigrationResponse.getData()){
-                if(!type.equals(MigrationType.DELETE.getCode())){
-                    ObjectDigital digital = (ObjectDigital) obj;
-                    DataMigrationExcel excel = new DataMigrationExcel();
-                    excel.setId(digital.getId());
-                    excel.setName(digital.getName());
-                    excel.setType(type);
-                    dataMigrationExcels.add(excel);
-                }else{
-                    DataMigrationExcel excel = new DataMigrationExcel();
-                    excel.setId(obj.toString());
-                    excel.setType(type);
-                    dataMigrationExcels.add(excel);
-                }
+                ObjectDigital digital = (ObjectDigital) obj;
+                SyncData syncData = new SyncData();
+                syncData.setTableName(MigrationTable.DTOBJECT.getCode());
+                syncData.setName(digital.getName());
+                syncData.setObjectType(digital.getObjType());
+                syncData.setType(type);//操作
+                syncData.setClassCode(digital.getClassCode());
+                syncData.setTargetId(digital.getId());
+                syncData.setLocalId(digital.getLocalId());
+                syncData.setLocalName(digital.getLocalName());
+                syncDataList.add(syncData);
             }
         }
         if(CollUtil.isNotEmpty(dataMigrationResponse.getErrorMsg())){
-            dataMigrationExcels.addAll(addErrorInfo(dataMigrationResponse.getErrorMsg()));
+            syncDataList.addAll(addErrorInfoForLog(dataMigrationResponse.getErrorMsg(), MigrationTable.DTOBJECT.getCode()));
         }
-        return dataMigrationExcels;
+        return syncDataList;
     }
+
 }

+ 156 - 53
src/main/java/com/persagy/proxy/migration/handler/ObjectRelationMigration.java

@@ -10,9 +10,12 @@ import com.persagy.dmp.common.constant.ResponseCode;
 import com.persagy.dmp.common.model.entity.BaseEntity;
 import com.persagy.dmp.digital.client.DigitalRelationFacade;
 import com.persagy.dmp.digital.entity.ObjectRelation;
+import com.persagy.dmp.rwd.migrate.entity.SyncData;
+import com.persagy.proxy.adm.request.AdmResponse;
 import com.persagy.proxy.common.entity.InstanceUrlParam;
 import com.persagy.proxy.migration.constant.MiGrationRelCode;
 import com.persagy.proxy.migration.constant.MigrationConstant;
+import com.persagy.proxy.migration.constant.MigrationTable;
 import com.persagy.proxy.migration.constant.MigrationType;
 import com.persagy.proxy.migration.model.DataMigrationExcel;
 import com.persagy.proxy.migration.model.DataMigrationResponse;
@@ -20,10 +23,7 @@ import com.persagy.proxy.migration.model.MigrationInfo;
 import com.persagy.proxy.migration.service.Impl.MigrationAbstractServiceImpl;
 import lombok.extern.slf4j.Slf4j;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.stream.Collectors;
 
 /**
@@ -60,42 +60,62 @@ public class ObjectRelationMigration extends MigrationAbstractServiceImpl<Object
      * @return
      */
     @Override
-    public List<DataMigrationExcel> migrate(InstanceUrlParam context, MigrationInfo migrationInfo) {
-        log.info("######################### dt_relation 同步开始 #########################");
+    public List<DataMigrationExcel> migrateForExcel(InstanceUrlParam context, MigrationInfo migrationInfo) {
+        log.info("######################### dt_relation 数据迁移内容获取开始 #########################");
         long start = System.currentTimeMillis();
         List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
 
         for (MiGrationRelCode miGrationRelCode: MiGrationRelCode.values()){
-            log.info("######################### dt_relation "+miGrationRelCode.getCode()+"同步开始 #########################");
+            log.info("######################### dt_relation "+miGrationRelCode.getCode()+"数据迁移内容获取开始 #########################");
 
-            QueryCriteria queryCriteria = new QueryCriteria();
-            ObjectNode criteria = JsonNodeFactory.instance.objectNode();
-            criteria.put("valid", 1);
-            criteria.put("relCode", miGrationRelCode.getCode());
-            dataMigrationExcels.addAll(startMigrate(context, migrationInfo, queryCriteria));
+            QueryCriteria queryCriteria = getQueryCriteria(miGrationRelCode.getCode());
+            dataMigrationExcels.addAll(startMigrateForExcel(context, migrationInfo, queryCriteria));
 
-            log.info("######################### dt_relation "+miGrationRelCode.getCode()+"同步结束 #########################");
+            log.info("######################### dt_relation "+miGrationRelCode.getCode()+"数据迁移内容获取结束 #########################");
         }
         long end = System.currentTimeMillis();
-        log.info("######################### dt_relation 同步结束 "+(end-start)+"#########################");
+        log.info("######################### dt_relation 数据迁移内容获取结束 "+(end-start)+"#########################");
         return dataMigrationExcels;
     }
 
-    private List<DataMigrationExcel> startMigrate(InstanceUrlParam context, MigrationInfo migrationInfo, QueryCriteria queryCriteria){
+    @Override
+    public AdmResponse migrateForLog(InstanceUrlParam context, MigrationInfo migrationInfo) {
+        log.info("######################### dt_relation 同步开始 #########################");
+        long start = System.currentTimeMillis();
+        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()+"条 #########################");
+        }
+        long end = System.currentTimeMillis();
+        log.info("######################### dt_relation 同步结束 "+(end-start)+"#########################");
+        return AdmResponse.success();
+    }
+
+    private QueryCriteria getQueryCriteria(String typeCode){
+        QueryCriteria queryCriteria = new QueryCriteria();
+        ObjectNode criteria = JsonNodeFactory.instance.objectNode();
+        criteria.put("valid", 1);
+        criteria.put("relCode", typeCode);
+        return queryCriteria;
+    }
+
+    private List<DataMigrationExcel> startMigrateForExcel(InstanceUrlParam context, MigrationInfo migrationInfo, QueryCriteria queryCriteria){
         List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
         List<ObjectRelation> admRelations = getAdmData(context, queryCriteria);
 
         String queryUrl = requestUrl(context, migrationInfo, MigrationType.QUERY.getCode());
         List<ObjectRelation> projectRelations = getProjectData(queryCriteria, ObjectRelation.class, queryUrl);
         if(CollUtil.isEmpty(admRelations)){
-            log.error(" ######################### dt_relation adm已交付:"+ ResponseCode.C0320.getDesc() +" 同步结束 #########################");
+            log.error(" ######################### dt_relation adm已交付:"+ ResponseCode.C0320.getDesc() +" 数据迁移内容获取结束 #########################");
             return dataMigrationExcels;
         }
 
-        String insertUrl = requestUrl(context, migrationInfo, MigrationType.INSERT.getCode());
+        //String insertUrl = requestUrl(context, migrationInfo, MigrationType.INSERT.getCode());
         if(CollUtil.isEmpty(projectRelations)){
-            DataMigrationResponse dataMigrationResponse = insertBatch(admRelations, ObjectRelation.class, insertUrl);
-            dataMigrationExcels.addAll(processData(dataMigrationResponse, MigrationType.INSERT.getDesc()));
+            //DataMigrationResponse dataMigrationResponse = insertBatch(admRelations, ObjectRelation.class, insertUrl);
+            dataMigrationExcels.addAll(processDataForExcel(admRelations, MigrationType.CREATE.getCode()));
             return dataMigrationExcels;
         }
         List<ObjectNode> objectNodeListPro = JsonNodeUtils.toListNode(projectRelations, null, null);
@@ -107,8 +127,62 @@ public class ObjectRelationMigration extends MigrationAbstractServiceImpl<Object
         Map<String,Object> doSubtractFromInsert = doSubtractAdd(admDefineMap, projectDefineMap);
         if(!CollUtil.isEmpty(doSubtractFromInsert)){
             List<ObjectRelation> insertData = toList(doSubtractFromInsert, admRelations);
+            //DataMigrationResponse dataMigrationResponse = insertBatch(insertData, ObjectRelation.class, insertUrl);
+            dataMigrationExcels.addAll(processDataForExcel(insertData, MigrationType.CREATE.getCode()));
+        }
+
+        //差集 删除
+        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<ObjectRelation> deleteData = toListByIds(deleteIds, projectRelations);
+//            String delUrl = requestUrl(context, migrationInfo, MigrationType.DELETE.getCode());
+//            DataMigrationResponse dataMigrationResponse = deleteBatch(deleteIds, ObjectRelation.class, delUrl);
+            dataMigrationExcels.addAll(processDataForExcel(deleteData, MigrationType.DELETE.getCode()));
+        }
+
+        //交集更新
+        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<ObjectRelation> updateData = toList(compareData, admRelations);
+                //String updateUrl = requestUrl(context, migrationInfo, MigrationType.UPDATE.getCode());
+                //DataMigrationResponse dataMigrationResponse = updateBatch(updateData, ObjectRelation.class, updateUrl);
+                dataMigrationExcels.addAll(processDataForExcel(updateData, MigrationType.UPDATE.getCode()));
+            }
+        }
+        return dataMigrationExcels;
+    }
+
+    private List<SyncData> startMigrateForLog(InstanceUrlParam context, MigrationInfo migrationInfo, QueryCriteria queryCriteria){
+        List<SyncData> syncDataList = new ArrayList<>();
+        List<ObjectRelation> admRelations = getAdmData(context, queryCriteria);
+
+        String queryUrl = requestUrl(context, migrationInfo, MigrationType.QUERY.getCode());
+        List<ObjectRelation> projectRelations = getProjectData(queryCriteria, ObjectRelation.class, queryUrl);
+        if(CollUtil.isEmpty(admRelations)){
+            log.error(" ######################### dt_relation adm已交付:"+ ResponseCode.C0320.getDesc() +" 同步结束 #########################");
+        }
+
+        String insertUrl = requestUrl(context, migrationInfo, MigrationType.CREATE.getCode());
+        if(CollUtil.isEmpty(projectRelations)){
+            DataMigrationResponse dataMigrationResponse = insertBatch(admRelations, ObjectRelation.class, insertUrl);
+            syncDataList = processDataForLog(dataMigrationResponse, MigrationType.CREATE.getCode());
+        }
+        List<ObjectNode> objectNodeListPro = JsonNodeUtils.toListNode(projectRelations, null, null);
+        Map<String,Object> projectDefineMap = toEntityMap(objectNodeListPro, ObjectRelation.class);
+        List<ObjectNode> objectNodeListAdm = JsonNodeUtils.toListNode(admRelations, null, null);
+        Map<String,Object> admDefineMap = toEntityMap(objectNodeListAdm, ObjectRelation.class);
+
+        //差集 新增
+        Map<String,Object> doSubtractFromInsert = doSubtractAdd(admDefineMap, projectDefineMap);
+        if(!CollUtil.isEmpty(doSubtractFromInsert)){
+            List<ObjectRelation> insertData = toList(doSubtractFromInsert, admRelations);
             DataMigrationResponse dataMigrationResponse = insertBatch(insertData, ObjectRelation.class, insertUrl);
-            dataMigrationExcels.addAll(processData(dataMigrationResponse, MigrationType.INSERT.getDesc()));
+            syncDataList.addAll(processDataForLog(dataMigrationResponse, MigrationType.CREATE.getCode()));
         }
 
         //差集 删除
@@ -116,8 +190,13 @@ public class ObjectRelationMigration extends MigrationAbstractServiceImpl<Object
         if(!CollUtil.isEmpty(doSubtractFromDelete)){
             List<String> deleteIds = doSubtractFromDelete.entrySet().stream().map(en -> en.getKey()).collect(Collectors.toList());
             String delUrl = requestUrl(context, migrationInfo, MigrationType.DELETE.getCode());
+
+            //处理删除的数据
             DataMigrationResponse dataMigrationResponse = deleteBatch(deleteIds, ObjectRelation.class, delUrl);
-            dataMigrationExcels.addAll(processData(dataMigrationResponse, MigrationType.DELETE.getDesc()));
+            List<String> successIds = (List<String>) dataMigrationResponse.getData();
+            List<ObjectRelation> delObjs = toListByIds(successIds, admRelations);
+            dataMigrationResponse.setData(delObjs);
+            syncDataList.addAll(processDataForLog(dataMigrationResponse, MigrationType.DELETE.getCode()));
         }
 
         //交集更新
@@ -130,15 +209,13 @@ public class ObjectRelationMigration extends MigrationAbstractServiceImpl<Object
                 List<ObjectRelation> updateData = toList(compareData, admRelations);
                 String updateUrl = requestUrl(context, migrationInfo, MigrationType.UPDATE.getCode());
                 DataMigrationResponse dataMigrationResponse = updateBatch(updateData, ObjectRelation.class, updateUrl);
-                dataMigrationExcels.addAll(processData(dataMigrationResponse, MigrationType.UPDATE.getDesc()));
+                syncDataList.addAll(processDataForLog(dataMigrationResponse, MigrationType.UPDATE.getCode()));
             }
         }
-        return dataMigrationExcels;
+        return super.addSynLog(context, syncDataList);
     }
 
 
-
-
     /**
      * 获取adm交付的数据,默认获取有效数据
      *
@@ -160,11 +237,18 @@ public class ObjectRelationMigration extends MigrationAbstractServiceImpl<Object
      */
     public List<ObjectRelation> toList(Map<String, Object> fromMap, List<ObjectRelation> fromList) {
         if(CollUtil.isEmpty(fromMap) || CollUtil.isEmpty(fromList)){
-            return null;
+            return Collections.emptyList();
+        }
+        return toListByIds(fromMap.keySet(), fromList);
+    }
+
+    public List<ObjectRelation> toListByIds(Collection<String> ids, List<ObjectRelation> fromList) {
+        if(CollUtil.isEmpty(ids) || CollUtil.isEmpty(fromList)){
+            return Collections.emptyList();
         }
-        List<ObjectRelation> results = new ArrayList<>(fromMap.size());
+        List<ObjectRelation> results = new ArrayList<>(ids.size());
         Map<String, ObjectRelation> objectRelationMap = CollUtil.fieldValueMap(fromList, BaseEntity.PROP_ID);
-        for(String key : fromMap.keySet()){
+        for(String key : ids){
             results.add(objectRelationMap.get(key));
         }
         return results;
@@ -183,53 +267,72 @@ public class ObjectRelationMigration extends MigrationAbstractServiceImpl<Object
         if(StrUtil.isBlank(migrationInfo.getTargetUrl())){
             return null;
         }
-        StringBuilder uRL = new StringBuilder(migrationInfo.getTargetUrl());
+        StringBuilder url = new StringBuilder(migrationInfo.getTargetUrl());
         if(type.equals(MigrationType.QUERY.getCode())) {
-            uRL.append(MigrationConstant.DT_RELATION);
-        }else if(type.equals(MigrationType.INSERT.getCode())){
-            uRL.append(MigrationConstant.DT_RELATION_INSERT);
+            url.append(MigrationConstant.DT_RELATION);
+        }else if(type.equals(MigrationType.CREATE.getCode())){
+            url.append(MigrationConstant.DT_RELATION_INSERT);
         }else if(type.equals(MigrationType.UPDATE.getCode())){
-            uRL.append(MigrationConstant.DT_RELATION_UPDATE);
+            url.append(MigrationConstant.DT_RELATION_UPDATE);
         }else{
-            uRL.append(MigrationConstant.DT_RELATION_DELETE);
+            url.append(MigrationConstant.DT_RELATION_DELETE);
         }
-        return commonUrl(context, uRL.toString(), migrationInfo);
+        return commonUrl(context, url.toString(), migrationInfo);
     }
 
 
     /**
      * 将目标集合处理成excel格式的集合  使用与insert/delete
      *
+     * @param list
+     * @return
+     */
+    @Override
+    public List<DataMigrationExcel> processDataForExcel(Collection list, String type) {
+        if(CollUtil.isEmpty(list)){
+            return Collections.emptyList();
+        }
+        List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
+        for(Object obj : list){
+            ObjectRelation define = (ObjectRelation) obj;
+            DataMigrationExcel excel = new DataMigrationExcel();
+            excel.setId(define.getId());
+            excel.setCode(define.getRelCode());
+            excel.setCode1(define.getGraphCode());
+            excel.setType(type);
+            dataMigrationExcels.add(excel);
+        }
+        return dataMigrationExcels;
+    }
+
+    /**
+     * 将目标集合处理成SyncData(日志)格式的集合  入库
+     *
      * @param dataMigrationResponse
+     * @param type                  insert/delete
      * @return
      */
     @Override
-    public List<DataMigrationExcel> processData(DataMigrationResponse dataMigrationResponse, String type) {
+    public List<SyncData> processDataForLog(DataMigrationResponse dataMigrationResponse, String type) {
         if(CollUtil.isEmpty(dataMigrationResponse.getData()) && CollUtil.isEmpty(dataMigrationResponse.getErrorMsg())){
             return Collections.emptyList();
         }
-        List<DataMigrationExcel> dataMigrationExcels = new ArrayList<>();
+        List<SyncData> syncDataList = new ArrayList<>();
         if(CollUtil.isNotEmpty(dataMigrationResponse.getData())){
             for(Object obj : dataMigrationResponse.getData()){
-                if(!type.equals(MigrationType.DELETE.getCode())){
-                    ObjectRelation define = (ObjectRelation) obj;
-                    DataMigrationExcel excel = new DataMigrationExcel();
-                    excel.setId(define.getId());
-                    excel.setCode(define.getRelCode());
-                    excel.setCode1(define.getGraphCode());
-                    excel.setType(type);
-                    dataMigrationExcels.add(excel);
-                }else{
-                    DataMigrationExcel excel = new DataMigrationExcel();
-                    excel.setId(obj.toString());
-                    excel.setType(type);
-                    dataMigrationExcels.add(excel);
-                }
+                ObjectRelation relation = (ObjectRelation) obj;
+                SyncData syncData = new SyncData();
+                syncData.setTableName(MigrationTable.DTRALATION.getCode());
+                syncData.setType(type);//操作
+                syncData.setTargetId(relation.getId());
+                syncData.setFromId(relation.getObjFrom());
+                syncData.setToId(relation.getObjTo());
+                syncDataList.add(syncData);
             }
         }
         if(CollUtil.isNotEmpty(dataMigrationResponse.getErrorMsg())){
-            dataMigrationExcels.addAll(addErrorInfo(dataMigrationResponse.getErrorMsg()));
+            syncDataList.addAll(addErrorInfoForLog(dataMigrationResponse.getErrorMsg(),MigrationTable.DTRALATION.getCode()));
         }
-        return dataMigrationExcels;
+        return syncDataList;
     }
 }

+ 7 - 0
src/main/java/com/persagy/proxy/migration/model/MigrationInfo.java

@@ -12,7 +12,14 @@ import lombok.Data;
 @Data
 @Builder
 public class MigrationInfo {
+    /**
+     * 项目现场中台能访问的地址
+     */
     private String targetUrl;
     private String targetGroupCode;
     private String targetProjectId;
+    /**
+     * 目标标志,默认0,使用当前登录用的项目id和集团编码,等于1,项目id是集团编码从参数中获取
+     */
+    private int targetSign = 0;
 }

+ 72 - 9
src/main/java/com/persagy/proxy/migration/service/Impl/MigrationAbstractServiceImpl.java

@@ -15,6 +15,8 @@ import com.persagy.dmp.common.model.entity.AuditableEntity;
 import com.persagy.dmp.common.model.entity.BaseEntity;
 import com.persagy.dmp.common.model.response.CommonResult;
 import com.persagy.dmp.common.utils.JsonHelper;
+import com.persagy.dmp.migrate.client.DigitalMigrateLogFacade;
+import com.persagy.dmp.rwd.migrate.entity.SyncData;
 import com.persagy.proxy.common.entity.DmpResult;
 import com.persagy.proxy.common.entity.InstanceUrlParam;
 import com.persagy.proxy.migration.constant.MigrationConstant;
@@ -42,6 +44,8 @@ public class MigrationAbstractServiceImpl<T> implements MigrationAbstractService
     /**
      * adm交付数据(A) ∩ 现场数据(B)
      * (A∩B) A
+     * (null ∩ B) null
+     * (A ∩ null) null
      * 需要进一步对比的数据
      *
      * @param from
@@ -49,6 +53,9 @@ public class MigrationAbstractServiceImpl<T> implements MigrationAbstractService
      */
     @Override
     public Map<String, Object> doIntersectionGetFrom(Map<String, Object> from, Map<String, Object> to) {
+        if(CollUtil.isEmpty(from) || CollUtil.isEmpty(to)){
+            return null;
+        }
         Sets.SetView<String> intersection = Sets.intersection(from.keySet(), to.keySet());
         if(CollUtil.isEmpty(intersection)){
             return null;
@@ -58,7 +65,9 @@ public class MigrationAbstractServiceImpl<T> implements MigrationAbstractService
 
     /**
      * adm交付数据(A) ∩ 现场数据(B)
-     * (A∩B) B
+     * (A ∩ B) return B 子集
+     * (null ∩ B) return null
+     * (A ∩ null) return null
      * 需要进一步对比的数据
      *
      * @param from
@@ -66,6 +75,12 @@ public class MigrationAbstractServiceImpl<T> implements MigrationAbstractService
      */
     @Override
     public Map<String, Object> doIntersectionGetTo(Map<String, Object> from, Map<String, Object> to) {
+        if(CollUtil.isEmpty(from)){
+            return null;
+        }
+        if(CollUtil.isEmpty(to)){
+            return null;
+        }
         Sets.SetView<String> intersection = Sets.intersection(from.keySet(), to.keySet());
         if(CollUtil.isEmpty(intersection)){
             return null;
@@ -75,7 +90,10 @@ public class MigrationAbstractServiceImpl<T> implements MigrationAbstractService
 
     /**
      * adm交付数据(From) 与 现场数据(to) 差集  返回adm数据
-     * (From - to)
+     * (From - to) 返回 From 子集
+     * (null - to) 返回 null
+     * (From - null) 返回 From
+     *
      * 新增
      *
      * @param from
@@ -83,20 +101,35 @@ public class MigrationAbstractServiceImpl<T> implements MigrationAbstractService
      */
     @Override
     public Map<String, Object> doSubtractAdd(Map<String, Object> from, Map<String, Object> to) {
+        if(CollUtil.isEmpty(from)){
+            return null;
+        }
+        if(CollUtil.isEmpty(to)){
+            return from;
+        }
         Sets.SetView<String> diffA = Sets.difference(from.keySet(), to.keySet());
         return getValueForMapByKeys(diffA, from);
     }
 
     /**
-     * adm交付数据(From) 与 现场数据(to ) 差集  现场数据
-     * (to - From )
-     * 删除
+     * adm交付数据(From) 与 现场数据(to ) 差集
+     * (to - From )返回 to 子集
+     * (to - null )返回 to
+     * (null - From )返回 null
+     *
+     *  return 删除数据
      *
      * @param from
      * @param to
      */
     @Override
     public Map<String, Object> doSubtractDel(Map<String, Object> from, Map<String, Object> to) {
+        if(CollUtil.isEmpty(from)){
+            return to;
+        }
+        if(CollUtil.isEmpty(to)){
+            return null;
+        }
         Sets.SetView<String> diffB = Sets.difference(to.keySet(), from.keySet());
         return getValueForMapByKeys(diffB, to);
     }
@@ -207,19 +240,19 @@ public class MigrationAbstractServiceImpl<T> implements MigrationAbstractService
      */
     private DataMigrationResponse saveOrUpdateCommProcess(List vos,  Class<T> clazz, String url){
         DataMigrationResponse dataMigrationResponse = DataMigrationResponse.success();
-        if(vos.size() <= MigrationConstant.batchSubmitDataCount){
+        if(vos.size() <= MigrationConstant.BATCH_SUBMIT_DATA_COUNT){
             DataMigrationResponse temp = processProjectData(vos,null, clazz, url);
             if(CollUtil.isNotEmpty(temp.getData())){
                 dataMigrationResponse.addData(temp.getData());
             }
         }else{
-            int count= vos.size() / MigrationConstant.batchSubmitDataCount;
+            int count= vos.size() / MigrationConstant.BATCH_SUBMIT_DATA_COUNT;
             for(int k = 0; k< count + 1 ;k++){
-                int end = (k+1)  * MigrationConstant.batchSubmitDataCount - 1;
+                int end = (k+1)  * MigrationConstant.BATCH_SUBMIT_DATA_COUNT - 1;
                 if(end > vos.size()){
                     end = vos.size();
                 }
-                List admDataSub = vos.subList(k * MigrationConstant.batchSubmitDataCount, end);
+                List admDataSub = vos.subList(k * MigrationConstant.BATCH_SUBMIT_DATA_COUNT, end);
                 DataMigrationResponse responseTemp = processProjectData(admDataSub,null, clazz, url);
                 if(CollUtil.isNotEmpty(responseTemp.getData())){
                     dataMigrationResponse.addData(responseTemp.getData());
@@ -289,6 +322,36 @@ public class MigrationAbstractServiceImpl<T> implements MigrationAbstractService
         return dataMigrationExcels;
     }
 
+    @Override
+    public List<SyncData> addErrorInfoForLog(List<String> errorMsg, String tableName) {
+        if(CollUtil.isEmpty(errorMsg) || StrUtil.isEmpty(tableName)){
+            return Collections.emptyList();
+        }
+        List<SyncData> syncDataList = new ArrayList<>(errorMsg.size());
+        for(String msg : errorMsg){
+            SyncData syncData = new SyncData();
+            syncData.setTableName(tableName);
+            syncData.setTargetId("error");
+            syncData.setError(msg);
+            syncDataList.add(syncData);
+        }
+        return syncDataList;
+    }
+
+    @Override
+    public List<SyncData> addSynLog(InstanceUrlParam context, List<SyncData> syncDataList) {
+        if(CollUtil.isEmpty(syncDataList)){
+            return Collections.emptyList();
+        }
+        // 调用中台新增
+        List<SyncData> syncDatas = DigitalMigrateLogFacade.create(context.getGroupCode(),context.getProjectId(),context.getAppId(), context.getUserId(), syncDataList);
+
+        if(CollUtil.isEmpty(syncDatas)) {
+            throw new RuntimeException("调用中台更新迁移日志出错");
+        }
+        return syncDataList;
+    }
+
     private DataMigrationResponse processProjectData(List vos, QueryCriteria queryCriteria, Class<T> clazz, String url){
         //处理rwd 请求返回超时
         String body = null;

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

@@ -2,6 +2,7 @@ package com.persagy.proxy.migration.service;
 
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.persagy.dmp.basic.model.QueryCriteria;
+import com.persagy.dmp.rwd.migrate.entity.SyncData;
 import com.persagy.proxy.common.entity.InstanceUrlParam;
 import com.persagy.proxy.migration.model.DataMigrationExcel;
 import com.persagy.proxy.migration.model.DataMigrationResponse;
@@ -93,5 +94,7 @@ public interface MigrationAbstractService<T> {
     Map<String, Object> compareData(Map<String,Object> from, Map<String,Object> to);
 
     List<DataMigrationExcel> addErrorInfo(List<String> errorMsg);
+    List<SyncData> addErrorInfoForLog(List<String> errorMsg, String tableName);
+    List<SyncData> addSynLog(InstanceUrlParam context, List<SyncData> syncDataList);
 
 }

+ 1 - 1
src/main/java/com/persagy/proxy/object/controller/AdmSpaceController.java

@@ -143,7 +143,7 @@ public class AdmSpaceController {
             for (String mapKey : mapKeys) {
                 if ((AdmDictConstant.TABLE_INFOS.contains(mapKey)
                         && !AdmDictConstant.HEIGHT.equals(mapKey)
-                        && (objFieldMap.containsKey(mapKey)) || AdmDictConstant.SPECIAL_INFOS.contains(mapKey))
+                        && (fieldMap.containsKey(mapKey)) || AdmDictConstant.SPECIAL_INFOS.contains(mapKey))
                         || AdmDictConstant.PIC.equals(mapKey)){
                     // 这些信息就算在infos也不更新,
                     // 和com.persagy.proxy.dictionary.service.impl.AbstractAdmDictBaseServiceImpl.handleObjectInfoPath