Merge remote-tracking branch 'origin/feature/REQ-3094' into release/20241030

pom.xml

@@ -47,6 +47,16 @@
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
+            <dependency>
+                <groupId>cn.axzo.platform</groupId>
+                <artifactId>axzo-log-api</artifactId>
+                <version>1.0.0-SNAPSHOT</version>
+            </dependency>
+            <dependency>
+                <groupId>cn.axzo.framework.logging</groupId>
+                <artifactId>axzo-common-trace</artifactId>
+                <version>1.0.0-SNAPSHOT</version>
+            </dependency>
             <dependency>
                 <groupId>io.github.openfeign</groupId>
                 <artifactId>feign-httpclient</artifactId>

riven-server/src/main/java/cn/axzo/riven/Application.java

@@ -9,7 +9,7 @@ import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.core.env.Environment;
 
 @Slf4j
-@SpringBootApplication(scanBasePackages = "cn.axzo")
+@SpringBootApplication(scanBasePackages = {"cn.axzo", "com.axzo.framework"})
 @EnableFeignClients(basePackages = {"cn.axzo"})
 public class Application {
 	public static void main(String[] args) {

riven-server/src/main/java/cn/axzo/riven/controller/PrivateController.java

@@ -1,49 +1,61 @@
 package cn.axzo.riven.controller;
 
-import cn.axzo.framework.rocketmq.Event;
+import cn.axzo.framework.domain.web.result.ApiResult;
-import cn.axzo.framework.rocketmq.EventConsumer;
+import cn.axzo.framework.jackson.utility.JSON;
-import cn.axzo.framework.web.http.ApiResponse;
+import cn.axzo.riven.third.job.TaiZhouProjectPersonIncJob;
+import cn.axzo.riven.third.job.TaiZhouProjectPersonJob;
+import com.alibaba.fastjson.JSONObject;
 import com.google.common.collect.ImmutableMap;
+import com.xxl.job.core.biz.model.ReturnT;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
-import org.springframework.beans.factory.annotation.Autowired;
+import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
-import javax.validation.Valid;
+import java.util.Optional;
+import java.util.function.Function;
 
 @RestController
-@RequestMapping("/private")
+@RequestMapping("/api/private")
+@RequiredArgsConstructor
 public class PrivateController {
 
-    @Autowired
+    private final TaiZhouProjectPersonJob taiZhouProjectPersonJob;
-    private EventConsumer eventConsumer;
+    private final TaiZhouProjectPersonIncJob taiZhouProjectPersonIncJob;
 
-    /**
+    @PostMapping("/job/run")
-     * 探活
+    public ApiResult reconsumeMessage(@RequestBody RunJobParam param) throws Exception {
-     */
+        ImmutableMap<String, Function<RunJobParam, ReturnT<String>>> jobRunners = ImmutableMap.<String, Function<RunJobParam, ReturnT<String>>>builder()
-    @PostMapping("/event/consume")
+                .put("taiZhouProjectPersonJob", p -> {
-    public ApiResponse<Void> consumeEvent(@RequestBody @Valid ConsumeEventParam param) {
+                    try {
-        EventConsumer.Context context = EventConsumer.Context.builder()
+                        return taiZhouProjectPersonJob.execute(p.getParam() == null ? null : p.getParam().toString());
-                .msgId("privateEventConsumer-" + System.currentTimeMillis())
+                    } catch (Exception e) {
-                .ext(ImmutableMap.of("topic", "topic-private-dummy"))
+                        throw new RuntimeException(e);
-                .headers(ImmutableMap.of())
+                    }
-                .lagSupplier(() -> 1L)
+                })
+                .put("taiZhouProjectPersonIncJob", p -> {
+                    try {
+                        return taiZhouProjectPersonIncJob.execute(p.getParam() == null ? null : p.getParam().toString());
+                    } catch (Exception e) {
+                        throw new RuntimeException(e);
+                    }
+                })
                 .build();
-        eventConsumer.onEvent(param.event.toJsonString(), context);
+        Optional.ofNullable(jobRunners.get(param.getJobName())).ifPresent(c -> c.apply(param));
-        return ApiResponse.ok();
+        return ApiResult.ok("job ran. -> " + JSON.toJSONString(param));
     }
 
     @NoArgsConstructor
     @AllArgsConstructor
     @Data
     @Builder
-    public static class ConsumeEventParam {
+    public static class RunJobParam {
-        private String topic;
+        private String jobName;
-        private Event event;
+        private JSONObject param;
     }
 }

riven-server/src/main/java/cn/axzo/riven/controller/PrivateMQReconsumeController.java

@@ -0,0 +1,106 @@
+package cn.axzo.riven.controller;
+
+import cn.axzo.framework.domain.web.result.ApiResult;
+import cn.axzo.framework.rocketmq.Event;
+import cn.axzo.framework.rocketmq.EventConsumer;
+import com.google.common.collect.ImmutableMap;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContext;
+import org.springframework.util.ReflectionUtils;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.lang.reflect.Method;
+
+@RestController
+public class PrivateMQReconsumeController {
+
+    @Autowired
+    private ApplicationContext appCtx;
+
+    /**
+     * <pre>
+     * {
+     *     "bean": "nodeUserEventHandler",
+     *     "method": "onEvent",
+     *     "event": {
+     *         "eventId": "maokai_a753b5b34cf54a019e11a7846ed19779",
+     *         "eventModule": "node-user",
+     *         "eventName": "node-user-delete",
+     *         "eventTime": 1729064347240,
+     *         "operatorId": "system",
+     *         "operatorType": "system",
+     *         "schemaHash": "505167ebaddc9c832ac862447780c617",
+     *         "shardingKey": "262970",
+     *         "targetId": "262970",
+     *         "targetType": "node-user",
+     *         "data": {
+     *             "createAt": 1729064238000,
+     *             "extra": {
+     *                 "directManager": "",
+     *                 "directManagerId": null,
+     *                 "directManagerPersonId": 0,
+     *                 "directManagerType": null,
+     *                 "oldOrgJobId": null,
+     *                 "title": "",
+     *                 "workspaceId": null
+     *             },
+     *             "groupIdentityIds": "",
+     *             "groupJobIds": "",
+     *             "groupNodeIds": "",
+     *             "id": 262970,
+     *             "idNumber": "532127197608120055",
+     *             "identityId": 85608,
+     *             "identityType": 1,
+     *             "isAllowed": 2,
+     *             "isDelete": 0,
+     *             "jobNumber": null,
+     *             "joinAt": 1729064238000,
+     *             "leaveAt": null,
+     *             "manager": false,
+     *             "organizationalJobId": 369,
+     *             "organizationalNodeId": 16994,
+     *             "organizationalUnitId": 5314,
+     *             "personId": 81819,
+     *             "phone": "14787057685",
+     *             "primaryJob": 1,
+     *             "realName": "王宗平",
+     *             "syncDataId": 0,
+     *             "tempSourceId": 0,
+     *             "topNodeId": 6178,
+     *             "updateAt": 1729064238000,
+     *             "workspaceId": 0
+     *         }
+     *     }
+     * }
+     * </pre>
+     * @param param
+     * @return
+     * @throws Exception
+     */
+    @PostMapping("/api/private/message/re-consume")
+    public ApiResult reconsumeMessage(@RequestBody ReconsumeMessage param) throws Exception {
+        Object bean = appCtx.getBean(param.getBean());
+        Method method = ReflectionUtils.findMethod(bean.getClass(), param.getMethod(), Event.class, EventConsumer.Context.class);
+        if (method == null) {
+            return ApiResult.err("bean not found -> " + param.getBean() + "." + param.getMethod());
+        }
+        ReflectionUtils.invokeMethod(method, bean, param.getEvent(), EventConsumer.Context.builder().logEnabled(true).headers(ImmutableMap.of()).build());
+        return ApiResult.ok("success");
+    }
+
+    @NoArgsConstructor
+    @AllArgsConstructor
+    @Data
+    @Builder
+    public static class ReconsumeMessage {
+        Event event;
+        private String bean;
+        private String method;
+    }
+}

riven-third/pom.xml

@@ -85,10 +85,13 @@
             <version>2.0.0-SNAPSHOT</version>
         </dependency>
         <dependency>
-            <groupId>cn.axzo.tyr</groupId>
+            <groupId>cn.axzo.platform</groupId>
-            <artifactId>tyr-api</artifactId>
+            <artifactId>axzo-log-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>cn.axzo.framework.logging</groupId>
+            <artifactId>axzo-common-trace</artifactId>
         </dependency>
-
         <dependency>
             <groupId>com.aliyun</groupId>
             <artifactId>alibaba-dingtalk-service-sdk</artifactId>

riven-third/src/main/java/cn/axzo/riven/third/common/MdcLogConstant.java

@@ -0,0 +1,8 @@
+package cn.axzo.riven.third.common;
+
+public class MdcLogConstant {
+    /**
+     * MDC 日志 KEY
+     */
+    public static final String CTX_LOG_ID_MDC = "ctxLogId";
+}

riven-third/src/main/java/cn/axzo/riven/third/entity/ThirdProjectPerson.java

@@ -60,6 +60,11 @@ public class ThirdProjectPerson extends BaseEntity<ThirdProjectPerson>{
      */
     private String thirdPostName;
 
+    /**
+     * 最后一次同步时间
+     */
+    private Date lastSyncAt;
+
     /**
      * 三方ext,扩展域等等,工种信息等等
      */

riven-third/src/main/java/cn/axzo/riven/third/job/TaiZhouProjectPersonIncJob.java

@@ -0,0 +1,127 @@
+package cn.axzo.riven.third.job;
+
+import cn.axzo.riven.third.common.MdcLogConstant;
+import cn.axzo.riven.third.entity.ThirdPerson;
+import cn.axzo.riven.third.entity.ThirdProjectPerson;
+import cn.axzo.riven.third.service.ThirdPersonService;
+import cn.axzo.riven.third.service.ThirdProjectPersonService;
+import cn.axzo.riven.third.service.ThirdProjectService;
+import cn.axzo.riven.third.taizhou.entity.TaiZhouProject;
+import cn.axzo.riven.third.taizhou.service.TaiZhouService;
+import cn.azxo.framework.common.logger.JobLoggerTemplate;
+import cn.hutool.core.collection.CollUtil;
+import com.alibaba.fastjson.JSON;
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.core.handler.IJobHandler;
+import com.xxl.job.core.handler.annotation.XxlJob;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.util.CollectionUtils;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 增量新增job
+ */
+@Slf4j
+@Component
+public class TaiZhouProjectPersonIncJob extends IJobHandler {
+
+    @Autowired
+    ThirdProjectPersonService thirdProjectPersonService;
+
+    @Autowired
+    ThirdProjectService thirdProjectService;
+
+    @Autowired
+    ThirdPersonService thirdPersonService;
+
+    @Autowired
+    TaiZhouService taiZhouService;
+
+    @Autowired
+    JobLoggerTemplate jobLoggerTemplate;
+
+    @XxlJob("taiZhouProjectPersonIncJob")
+    @Override
+    public ReturnT<String> execute(String s) throws Exception {
+        return jobLoggerTemplate.execute(MdcLogConstant.CTX_LOG_ID_MDC, () -> {
+
+            log.info("taiZhouProjectPersonJob-inc start");
+
+            //获取泰州所有的项目信息
+            List<TaiZhouProject> taiZhouProjectList = taiZhouService.queryThirdProjectForTaiZhou();
+
+            if (CollectionUtils.isEmpty(taiZhouProjectList)) {
+                log.info("DB中泰州项目为空，同步结束");
+                return ReturnT.SUCCESS;
+            }
+            log.info("taiZhouProjectPersonJob-inc--项目list：{}", JSON.toJSONString(taiZhouProjectList));
+
+
+            log.info("taiZhouProjectPersonJob-inc 同步项目用工信息--开始");
+            Map<String, List<ThirdProjectPerson>> incThirdProjectPeople = new HashMap<>();
+            taiZhouProjectList.forEach(x -> {
+                log.info("taiZhouProjectPersonJob-inc 同步项目用工信息--项目ID：{} 远程获取开始", x.getThirdProjectId());
+                //基于项目维度进行获取项目下的员工信息
+                List<ThirdProjectPerson> thirdProjectPersonList = taiZhouService.remoteQueryProjectPersonInc(x);
+
+                //更新入库
+                if (!CollectionUtils.isEmpty(thirdProjectPersonList)) {
+                    log.info("taiZhouProjectPersonJob-inc 同步项目用工信息--项目ID：{}，size:{}", x.getThirdProjectId(), thirdProjectPersonList.size());
+                    thirdProjectPersonList.forEach(thirdProjectPerson -> {
+                        thirdProjectPersonService.addOrUpdateThirdProjectPerson(thirdProjectPerson, true);
+                    });
+                    incThirdProjectPeople.put(x.getThirdProjectId(), thirdProjectPersonList);
+                } else {
+                    log.info("taiZhouProjectPersonJob-inc 同步项目用工信息--项目ID：{}，size:0", x.getThirdProjectId());
+                }
+            });
+            log.info("taiZhouProjectPersonJob-inc 同步项目用工信息--结束");
+
+            if (incThirdProjectPeople.isEmpty()) {
+                log.info("taiZhouProjectPersonJob-inc 泰州job同步项目人员信息--本次无新增数据，无需处理");
+                return ReturnT.SUCCESS;
+            }
+
+            log.info("泰州job同步项目人员信息--开始");
+
+            //根据项目信息获取调用泰州的项目人员接口
+            taiZhouProjectList.forEach(x -> {
+                log.info("taiZhouProjectPersonJob-inc 同步项目人员信息--项目ID：{} 开始", x.getThirdProjectId());
+
+                List<ThirdProjectPerson> thirdProjectPeople = incThirdProjectPeople.get(x.getThirdProjectId());
+                if (CollUtil.isEmpty(thirdProjectPeople)) {
+                    log.info("taiZhouProjectPersonJob-inc 同步项目人员信息--项目ID：{} 结束 - 当前项目没有新增的项目用工信息", x.getThirdProjectId());
+                    return;
+                }
+
+                List<ThirdPerson> thirdPersonList = taiZhouService.remoteQueryPerson(x, thirdProjectPeople);
+
+                //更新入库
+                if (!CollectionUtils.isEmpty(thirdPersonList)) {
+                    log.info("taiZhouProjectPersonJob-inc 同步项目人员信息--项目ID：{}，size:{}", x.getThirdProjectId(), thirdPersonList.size());
+
+                    thirdPersonList.forEach(thirdPerson -> {
+                        try {
+                            taiZhouService.handlePerson(thirdPerson, x, TaiZhouService.HandlerPersonType.ADD);
+                        } catch (Exception e) {
+                            log.error("泰州人员：{} 处理异常，对应泰州ID：{}", thirdPerson.getThirdPersonName(), thirdPerson.getThirdUniquePersonId(), e);
+                        }
+
+                    });
+                } else {
+                    log.info("taiZhouProjectPersonJob-inc 同步项目人员信息--项目ID：{}，size:0", x.getThirdProjectId());
+                }
+            });
+            log.info("taiZhouProjectPersonIncJob 泰州job同步项目用工信息--结束");
+
+            log.info("taiZhouProjectPersonIncJob end");
+
+            return ReturnT.SUCCESS;
+        });
+    }
+}

riven-third/src/main/java/cn/axzo/riven/third/job/TaiZhouProjectPersonJob.java

@@ -1,5 +1,6 @@
 package cn.axzo.riven.third.job;
 
+import cn.axzo.riven.third.common.MdcLogConstant;
 import cn.axzo.riven.third.entity.ThirdPerson;
 import cn.axzo.riven.third.entity.ThirdProjectPerson;
 import cn.axzo.riven.third.service.ThirdPersonService;
@@ -7,7 +8,9 @@ import cn.axzo.riven.third.service.ThirdProjectPersonService;
 import cn.axzo.riven.third.service.ThirdProjectService;
 import cn.axzo.riven.third.taizhou.entity.TaiZhouProject;
 import cn.axzo.riven.third.taizhou.service.TaiZhouService;
+import cn.azxo.framework.common.logger.JobLoggerTemplate;
 import com.alibaba.fastjson.JSON;
+import com.google.common.collect.ImmutableList;
 import com.xxl.job.core.biz.model.ReturnT;
 import com.xxl.job.core.handler.IJobHandler;
 import com.xxl.job.core.handler.annotation.XxlJob;
@@ -16,11 +19,11 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 import org.springframework.util.CollectionUtils;
 
+import java.util.ArrayList;
 import java.util.List;
 
 /**
- * Author:  zhongpeng
+ * 全量更新
- * Date:  2024/6/25 14:12
  */
 @Slf4j
 @Component
@@ -39,69 +42,74 @@ public class TaiZhouProjectPersonJob extends IJobHandler {
     @Autowired
     TaiZhouService taiZhouService;
 
+    @Autowired
+    JobLoggerTemplate jobLoggerTemplate;
     @XxlJob("taiZhouProjectPersonJob")
     @Override
     public ReturnT<String> execute(String s) throws Exception {
+        return jobLoggerTemplate.execute(MdcLogConstant.CTX_LOG_ID_MDC, () -> {
+            log.info("taiZhouProjectPersonJob start");
 
-        log.info("taiZhouProjectPersonJob start");
+            //获取泰州所有的项目信息
+            List<TaiZhouProject> taiZhouProjectList = taiZhouService.queryThirdProjectForTaiZhou();
 
-        //获取泰州所有的项目信息
+            if (CollectionUtils.isEmpty(taiZhouProjectList)) {
-        List<TaiZhouProject> taiZhouProjectList = taiZhouService.queryThirdProjectForTaiZhou();
+                log.info("DB中泰州项目为空，同步结束");
+                return ReturnT.SUCCESS;
+            }
+            log.info("taiZhouProjectPersonJob--项目list：{}", JSON.toJSONString(taiZhouProjectList));
+
+
+            log.info("taiZhouProjectPersonJob 同步项目用工信息--开始");
+            taiZhouProjectList.forEach(x -> {
+                log.info("taiZhouProjectPersonJob 同步项目用工信息--项目ID：{} 远程获取开始", x.getThirdProjectId());
+                //基于项目维度进行获取项目下的员工信息
+                List<ThirdProjectPerson> thirdProjectPersonList = taiZhouService.remoteQueryProjectPerson(x);
+
+                //更新入库
+                if (!CollectionUtils.isEmpty(thirdProjectPersonList)) {
+                    log.info("taiZhouProjectPersonJob 同步项目用工信息--项目ID：{}，size:{}", x.getThirdProjectId(), thirdProjectPersonList.size());
+                    thirdProjectPersonList.forEach(thirdProjectPerson -> {
+                        // 全量更新不插入thirdProjectPerson数据。只做更新操作。新增由增量更新处理
+                        thirdProjectPersonService.addOrUpdateThirdProjectPerson(thirdProjectPerson, false);
+                    });
+                } else {
+                    log.info("taiZhouProjectPersonJob 同步项目用工信息--项目ID：{}，size:0", x.getThirdProjectId());
+                }
+            });
+            log.info("taiZhouProjectPersonJob 同步项目用工信息--结束");
+
+            log.info("taiZhouProjectPersonJob 泰州job同步项目人员信息--开始");
+
+            //根据项目信息获取调用泰州的项目人员接口
+            taiZhouProjectList.forEach(x -> {
+
+                log.info("taiZhouProjectPersonJob 同步项目人员信息--项目ID：{} 开始", x.getThirdProjectId());
+
+                // 全量更新接口，直接返回全量的用户数据，主要处理人员信息变更的情况
+                List<ThirdPerson> thirdPersonList = taiZhouService.remoteQueryPerson(x, ImmutableList.of());
+
+                //更新入库
+                if (!CollectionUtils.isEmpty(thirdPersonList)) {
+                    log.info("taiZhouProjectPersonJob 同步项目人员信息--项目ID：{}，size:{}", x.getThirdProjectId(), thirdPersonList.size());
+
+                    thirdPersonList.forEach(thirdPerson -> {
+                        try {
+                            taiZhouService.handlePerson(thirdPerson, x, TaiZhouService.HandlerPersonType.UPDATE);
+                        } catch (Exception e) {
+                            log.error("泰州人员：{} 处理异常，对应泰州ID：{}", thirdPerson.getThirdPersonName(), thirdPerson.getThirdUniquePersonId(), e);
+                        }
+
+                    });
+                } else {
+                    log.info("taiZhouProjectPersonJob 同步项目人员信息--项目ID：{}，size:0", x.getThirdProjectId());
+                }
+            });
+            log.info("taiZhouProjectPersonJob 泰州job同步项目人员信息--结束");
+
+            log.info("taiZhouProjectPersonJob end");
 
-        if (CollectionUtils.isEmpty(taiZhouProjectList)) {
-            log.info("DB中泰州项目为空，同步结束");
             return ReturnT.SUCCESS;
-        }
-        log.info("taiZhouProjectPersonJob--项目list：{}", JSON.toJSONString(taiZhouProjectList));
-
-
-        log.info("taiZhouProjectPersonJob 同步项目用工信息--开始");
-        taiZhouProjectList.forEach(x -> {
-            log.info("taiZhouProjectPersonJob 同步项目用工信息--项目ID：{} 远程获取开始", x.getThirdProjectId());
-            //基于项目维度进行获取项目下的员工信息
-            List<ThirdProjectPerson> thirdProjectPersonList = taiZhouService.remoteQueryProjectPerson(x);
-
-            //更新入库
-            if (!CollectionUtils.isEmpty(thirdProjectPersonList)) {
-                log.info("taiZhouProjectPersonJob 同步项目用工信息--项目ID：{}，size:{}", x.getThirdProjectId(), thirdProjectPersonList.size());
-                thirdProjectPersonList.forEach(thirdProjectPerson -> {
-                    thirdProjectPersonService.addOrUpdateThirdProjectPerson(thirdProjectPerson);
-                });
-            } else {
-                log.info("taiZhouProjectPersonJob 同步项目用工信息--项目ID：{}，size:0", x.getThirdProjectId());
-            }
         });
-        log.info("taiZhouProjectPersonJob 同步项目用工信息--结束");
-
-        log.info("泰州job同步项目人员信息--开始");
-
-        //根据项目信息获取调用泰州的项目人员接口
-        taiZhouProjectList.forEach(x -> {
-
-            log.info("taiZhouProjectPersonJob 同步项目人员信息--项目ID：{} 开始", x.getThirdProjectId());
-
-            List<ThirdPerson> thirdPersonList = taiZhouService.remoteQueryPerson(x);
-
-            //更新入库
-            if (!CollectionUtils.isEmpty(thirdPersonList)) {
-                log.info("taiZhouProjectPersonJob 同步项目人员信息--项目ID：{}，size:{}", x.getThirdProjectId(), thirdPersonList.size());
-
-                thirdPersonList.forEach(thirdPerson -> {
-                    try {
-                        taiZhouService.handlePerson(thirdPerson, x);
-                    } catch (Exception e) {
-                        log.error("泰州人员：{} 处理异常，对应泰州ID：{}", thirdPerson.getThirdPersonName(), thirdPerson.getThirdUniquePersonId(), e);
-                    }
-
-                });
-            } else {
-                log.info("taiZhouProjectPersonJob 同步项目人员信息--项目ID：{}，size:0", x.getThirdProjectId());
-            }
-        });
-        log.info("泰州job同步项目用工信息--结束");
-
-        log.info("taiZhouProjectPersonJob end");
-
-        return ReturnT.SUCCESS;
     }
 }

riven-third/src/main/java/cn/axzo/riven/third/service/ThirdProjectPersonService.java

@@ -10,8 +10,8 @@ import java.util.List;
  */
 public interface ThirdProjectPersonService {
 
-    public void addOrUpdateThirdProjectPerson(ThirdProjectPerson thirdProjectPerson);
+    void addOrUpdateThirdProjectPerson(ThirdProjectPerson thirdProjectPerson, boolean add);
 
-    public ThirdProjectPerson queryThirdProjectPerson(String thirdCode,String thirdProjectId,String thirdUniquePersonId);
+    ThirdProjectPerson queryThirdProjectPerson(String thirdCode,String thirdProjectId,String thirdUniquePersonId);
 
 }

riven-third/src/main/java/cn/axzo/riven/third/service/impl/ThirdProjectPersonServiceImpl.java

@@ -1,6 +1,7 @@
 package cn.axzo.riven.third.service.impl;
 
 import cn.axzo.riven.third.dao.ThirdProjectPersonDao;
+import cn.axzo.riven.third.entity.ThirdPerson;
 import cn.axzo.riven.third.entity.ThirdProjectPerson;
 import cn.axzo.riven.third.service.ThirdProjectPersonService;
 import com.alibaba.fastjson.JSON;
@@ -8,6 +9,7 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
+import java.util.Date;
 import java.util.List;
 import java.util.Objects;
 
@@ -23,7 +25,7 @@ public class ThirdProjectPersonServiceImpl implements ThirdProjectPersonService
     private ThirdProjectPersonDao thirdProjectPersonDao;
 
     @Override
-    public void addOrUpdateThirdProjectPerson(ThirdProjectPerson thirdProjectPerson) {
+    public void addOrUpdateThirdProjectPerson(ThirdProjectPerson thirdProjectPerson, boolean add) {
 
         ThirdProjectPerson db = thirdProjectPersonDao.lambdaQuery()
                 .eq(ThirdProjectPerson::getThirdCode, thirdProjectPerson.getThirdCode())
@@ -32,8 +34,8 @@ public class ThirdProjectPersonServiceImpl implements ThirdProjectPersonService
                 .one();
 
         log.info("thirdProjectPerson:{}",JSON.toJSON(thirdProjectPerson));
-        //如果数据库为空，则插入
+        //如果数据库为空，并且是新增的时候，才新增，避免竞争
-        if (Objects.isNull(db)) {
+        if (Objects.isNull(db) && add) {
             thirdProjectPersonDao.save(thirdProjectPerson);
         }
         //反之则更新
@@ -49,10 +51,10 @@ public class ThirdProjectPersonServiceImpl implements ThirdProjectPersonService
                     .set(!Objects.isNull(thirdProjectPerson.getThirdDepartmentId()),ThirdProjectPerson::getThirdDepartmentId, thirdProjectPerson.getThirdDepartmentId())
                     .set(!Objects.isNull(thirdProjectPerson.getThirdPostName()),ThirdProjectPerson::getThirdPostName, thirdProjectPerson.getThirdPostName())
                     .set(!Objects.isNull(thirdProjectPerson.getThirdExt()),ThirdProjectPerson::getThirdExt, thirdProjectPerson.getThirdExt())
+                    .set(thirdProjectPerson.getLastSyncAt() != null, ThirdProjectPerson::getLastSyncAt, thirdProjectPerson.getLastSyncAt())
                     .update();
         }
 
-
     }
 
     @Override

riven-third/src/main/java/cn/axzo/riven/third/taizhou/rpc/TaiZhouClient.java

@@ -119,9 +119,10 @@ public class TaiZhouClient {
         RestTemplateUtils restTemplateUtils = new RestTemplateUtils(taiZhouConfig.getHttpConnectTimeout(), taiZhouConfig.getHttpReadTimeout());
         if (StringUtils.hasText(requestBody)) {
             String body = AesUtil.encryptPkcs5(requestBody, taiZhouConfig.getKey());
-            log.info("请求泰州住建局body：{}", body);
+            log.info("请求泰州住建局，apiFullUrl = {}, paramReq = {}, originBody = {} ,encodedBody = {}", apiFullUrl, JSON.toJSONString(paramReq), requestBody, body);
             responseEntity = restTemplateUtils.post(apiFullUrl, headers, body, String.class);
         } else {
+            log.info("请求泰州住建局，apiFullUrl = {}, paramReq = {}", apiFullUrl, JSON.toJSONString(paramReq));
             responseEntity = restTemplateUtils.post(apiFullUrl, headers, String.class);
         }
 

riven-third/src/main/java/cn/axzo/riven/third/taizhou/rpc/TaiZhouRpc.java

@@ -3,6 +3,7 @@ package cn.axzo.riven.third.taizhou.rpc;
 import cn.axzo.riven.third.taizhou.constant.enums.TaiZhouApiEnum;
 import cn.axzo.riven.third.taizhou.rpc.req.TaiZhouParamReq;
 import cn.axzo.riven.third.taizhou.rpc.req.TaiZhouPhoneReq;
+import cn.axzo.riven.third.taizhou.rpc.req.TaiZhouWorkerHmcIncReq;
 import cn.axzo.riven.third.taizhou.rpc.res.*;
 import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.TypeReference;
@@ -57,6 +58,30 @@ public class TaiZhouRpc {
     }
 
 
+    /**
+     * 调用泰州平台查询：项目用工信息(增量)(GetWorkerHmc_Inc)
+     */
+    public List<TaiZhouPrjWorkerRes> getWorkerHmcInc(TaiZhouWorkerHmcIncReq req) {
+        List<TaiZhouPrjWorkerRes> resList = new ArrayList<>();
+        try {
+            ResponseEntity<String> response = client.post(TaiZhouApiEnum.GET_WORKER_HMC_INC.getPath(), req, EMPTY_JSON_STR);
+            TaiZhouRes<String> taiZhouRes = client.parseResult(response, String.class);
+            if (!taiZhouRes.getResultSuccess()) {
+                log.info("taizhou: GetWorkerHmc_Inc failed, res={}", JSON.toJSONString(taiZhouRes));
+                return resList;
+            }
+            List<TaiZhouPrjWorkerRes> list = JSON.parseObject(taiZhouRes.getResultData(), new TypeReference<List<TaiZhouPrjWorkerRes>>() {
+            });
+            if (CollectionUtils.isNotEmpty(list)) {
+                resList = list;
+            }
+        } catch (Exception e) {
+            log.error("泰州获取调用项目人员接口GetWorkerHmcInc异常",e);
+        }
+        return resList;
+    }
+
+
     /**
      * 调用泰州平台查询：人员基本信息(GB_Worker)
      *

riven-third/src/main/java/cn/axzo/riven/third/taizhou/rpc/req/TaiZhouWorkerHmcIncReq.java

@@ -0,0 +1,26 @@
+package cn.axzo.riven.third.taizhou.rpc.req;
+
+import com.alibaba.fastjson.annotation.JSONField;
+import lombok.Getter;
+import lombok.Setter;
+
+@Setter
+@Getter
+public class TaiZhouWorkerHmcIncReq extends TaiZhouParamReq {
+    /**
+     * 人员状态（0在场，1离场,空所有）
+     */
+    private String ryzt;
+
+    /**
+     * 开始时间（yyyy-mm-dd）
+     */
+    @JSONField(name = "BeginDate")
+    private String beginDate;
+
+    /**
+     * 结束时间（yyyy-mm-dd）
+     */
+    @JSONField(name = "EndDate")
+    private String endDate;
+}

riven-third/src/main/java/cn/axzo/riven/third/taizhou/service/TaiZhouService.java

@@ -14,16 +14,21 @@ import java.util.List;
 public interface TaiZhouService {
 
 
-    public void updateProjectIdForRemote(TaiZhouProject taiZhouProject);
+    void updateProjectIdForRemote(TaiZhouProject taiZhouProject);
 
-    public List<TaiZhouProject> queryThirdProjectForTaiZhou();
+    List<TaiZhouProject> queryThirdProjectForTaiZhou();
 
 
-    public List<ThirdProjectPerson> remoteQueryProjectPerson(TaiZhouProject taiZhouProject);
+    List<ThirdProjectPerson> remoteQueryProjectPerson(TaiZhouProject taiZhouProject);
 
+    List<ThirdProjectPerson> remoteQueryProjectPersonInc(TaiZhouProject taiZhouProject);
 
-    public List<ThirdPerson> remoteQueryPerson(TaiZhouProject taiZhouProject);
+    List<ThirdPerson> remoteQueryPerson(TaiZhouProject taiZhouProject, List<ThirdProjectPerson> needReturnPeople);
 
-    public void handlePerson(ThirdPerson thirdPerson, TaiZhouProject taiZhouProject);
+    void handlePerson(ThirdPerson thirdPerson, TaiZhouProject taiZhouProject, HandlerPersonType handlerPersonType);
+
+    enum HandlerPersonType{
+        ADD,UPDATE;
+    }
 
 }

riven-third/src/main/java/cn/axzo/riven/third/taizhou/service/impl/OperateLogServiceImpl.java

@@ -1,20 +1,16 @@
 package cn.axzo.riven.third.taizhou.service.impl;
 
 import cn.axzo.framework.jackson.utility.JSON;
+import cn.axzo.log.platform.client.feign.LogApi;
+import cn.axzo.log.platform.client.model.req.LogAddReq;
 import cn.axzo.riven.third.taizhou.service.OperateLogService;
-import cn.axzo.tyr.client.feign.PermissionOperateLogApi;
+import com.google.common.collect.ImmutableList;
-import cn.axzo.tyr.client.model.req.PermissionOperateLogReq;
-import com.alibaba.fastjson.JSONObject;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.BooleanUtils;
-import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.cloud.context.config.annotation.RefreshScope;
 import org.springframework.stereotype.Service;
 
-import java.util.Optional;
 import java.util.concurrent.ExecutorService;
 
 @Service
@@ -22,14 +18,14 @@ import java.util.concurrent.ExecutorService;
 @RefreshScope
 public class OperateLogServiceImpl implements OperateLogService {
 
+    private static final String OPERATE_LOG_SCENE = "riven_taizhou_sync";
+
     @Qualifier("operateLogSyncExecutor")
     @Autowired
     private ExecutorService executorService;
 
     @Autowired
-    private PermissionOperateLogApi permissionOperateLogApi;
+    private LogApi logApi;
-    @Value("${operateLog.saveToTyr:true}")
-    private Boolean saveToTyr;
 
     @Override
     public void save(SaveParam param) {
@@ -47,21 +43,14 @@ public class OperateLogServiceImpl implements OperateLogService {
     public void doSave(SaveParam param) {
         try {
             param.check();
-            log.info("OperateLogServiceImpl doSave, saveToTyr = {}, saveParam = {}", saveToTyr, JSON.toJSONString(param));
+            log.info("OperateLogServiceImpl doSave, saveParam = {}", JSON.toJSONString(param));
-            if (BooleanUtils.isTrue(saveToTyr)) {
+            LogAddReq logAddReq = LogAddReq.builder()
-                // 暂时存在tyr的日志。后续如果需要切换，再调整
+                    .scene(OPERATE_LOG_SCENE)
-                permissionOperateLogApi.save(PermissionOperateLogReq.builder()
+                    .level("INFO")
-                        .operatorId(param.getOperatorId() == null || param.getOperatorId() < 1 ? null : param.getOperatorId())
+                    .tags(ImmutableList.of(param.getResourceId() + ""))
-                        .operatorName(StringUtils.firstNonBlank(param.getOperatorName(), "unknown"))
+                    .message(JSON.toJSONString(param))
-                        .requestData(param.getOldValue())
+                    .build();
-                        .operateData(param.getNewValue())
+            logApi.addLog(logAddReq);
-                        .scene(String.format("%s_%s", param.getResourceType().name(), param.getOperateType().name()))
-                        .sceneId(param.getResourceId() + "")
-                        .tableName(param.getResourceType().getTableName())
-                        .ext(Optional.ofNullable(param.getExt()).orElseGet(JSONObject::new)
-                                .fluentPut("summary", param.getSummary()))
-                        .build());
-            }
         } catch (Throwable e) {
             log.warn("OperateLogServiceImpl doSave caught exception, msg = {}, param = {}",
                     e.getMessage(), JSON.toJSONString(param), e);

riven-third/src/main/java/cn/axzo/riven/third/taizhou/service/impl/TaiZhouServiceImpl.java

@@ -24,13 +24,21 @@ import cn.axzo.riven.third.taizhou.entity.TaiZhouThirdProjectExt;
 import cn.axzo.riven.third.taizhou.rpc.TaiZhouRpc;
 import cn.axzo.riven.third.taizhou.rpc.req.TaiZhouParamReq;
 import cn.axzo.riven.third.taizhou.rpc.req.TaiZhouPhoneReq;
+import cn.axzo.riven.third.taizhou.rpc.req.TaiZhouWorkerHmcIncReq;
 import cn.axzo.riven.third.taizhou.rpc.req.TaiZhouWorkerHmcReq;
 import cn.axzo.riven.third.taizhou.rpc.res.TaiZhouPhoneRes;
 import cn.axzo.riven.third.taizhou.rpc.res.TaiZhouPrjWorkerRes;
 import cn.axzo.riven.third.taizhou.rpc.res.TaiZhouWorkerRes;
 import cn.axzo.riven.third.taizhou.rpc.res.TazZhouProjectRes;
+import cn.axzo.riven.third.taizhou.service.OperateLogService;
 import cn.axzo.riven.third.taizhou.service.TaiZhouService;
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.date.DateUtil;
 import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.BeanUtils;
@@ -41,8 +49,10 @@ import org.springframework.util.CollectionUtils;
 import java.net.URLDecoder;
 import java.util.ArrayList;
 import java.util.Date;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Objects;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 /**
@@ -80,6 +90,9 @@ public class TaiZhouServiceImpl implements TaiZhouService {
     @Autowired
     private DingDingRobotService dingDingRobotService;
 
+    @Autowired
+    private OperateLogService operateLogService;
+
     @Override
     public void updateProjectIdForRemote(TaiZhouProject taiZhouProject) {
 
@@ -158,13 +171,59 @@ public class TaiZhouServiceImpl implements TaiZhouService {
         req.setBagsBH(ext.getBagsBH());
         req.setDataNumber(ext.getDataNumber());
         req.setRyzt("");
+        Date now = new Date();
+
         List<TaiZhouPrjWorkerRes> resList = rpc.GetWorkerHmc(req);
 
 
         if (CollectionUtils.isEmpty(resList)) {
+            // 暂不收敛告警，遇到后做告警抑制处理。
+            log.error("三方项目用工信息获取失败，taiZhouProjectId = {}, dataNumber = {}，resList.size = 0，如连续多次出现，可能是项目数据指纹发生变更，请和群耀进行确认。"
+                    , taiZhouProject.getThirdProjectId(), ext.getDataNumber());
             return projectPersonList;
         }
         //转化对象
+        return buildThirdProjectPeople(resList, now);
+
+    }
+
+
+    @Override
+    public List<ThirdProjectPerson> remoteQueryProjectPersonInc(TaiZhouProject taiZhouProject) {
+        ThirdProjectPerson latestSyncProjectPerson = thirdProjectPersonDao.lambdaQuery()
+                .eq(ThirdProjectPerson::getThirdProjectId, taiZhouProject.getThirdProjectId())
+                .eq(ThirdProjectPerson::getThirdCode, ThirdCodeEnum.TAI_ZHOU.getCode())
+                .orderByDesc(ThirdProjectPerson::getLastSyncAt)
+                .last(" limit 1")
+                .one();
+        // 没有取到最晚同步时间，走全量同步
+        if (latestSyncProjectPerson == null || latestSyncProjectPerson.getLastSyncAt() == null) {
+            log.info("增加查询项目用工信息, 没有找到最后一次同步时间，走全量同步");
+            return remoteQueryProjectPerson(taiZhouProject);
+        }
+
+        TaiZhouThirdProjectExt ext = taiZhouProject.getTaiZhouThirdProjectExt();
+        String beginDate = DateUtil.formatDate(latestSyncProjectPerson.getLastSyncAt());
+        Date endTime = new Date();
+        String endDate = DateUtil.formatDate(endTime);
+        TaiZhouWorkerHmcIncReq req = new TaiZhouWorkerHmcIncReq();
+        req.setDataNumber(ext.getDataNumber());
+        req.setBagsBH(ext.getBagsBH());
+        req.setRyzt("");
+        req.setBeginDate(beginDate);
+        req.setEndDate(endDate);
+        List<TaiZhouPrjWorkerRes> resList = rpc.getWorkerHmcInc(req);
+
+        // 没有查询到人
+        if (CollectionUtils.isEmpty(resList)) {
+            return ImmutableList.of();
+        }
+        //转化对象
+        return buildThirdProjectPeople(resList, endTime);
+
+    }
+
+    private List<ThirdProjectPerson> buildThirdProjectPeople(List<TaiZhouPrjWorkerRes> resList, Date syncTime) {
         return resList.stream().map(x -> {
             ThirdProjectPerson projectPerson = new ThirdProjectPerson();
             projectPerson.setThirdCode(ThirdCodeEnum.TAI_ZHOU.getCode());
@@ -179,16 +238,16 @@ public class TaiZhouServiceImpl implements TaiZhouService {
             projectPerson.setThirdDepartmentId("");
             projectPerson.setThirdPostName("");
             projectPerson.setCreateAt(new Date());
+            projectPerson.setLastSyncAt(syncTime);
             //填充扩展域
             projectPerson.setThirdExt(buildThirdExt(x));
             return projectPerson;
         }).collect(Collectors.toList());
-
     }
 
 
     @Override
-    public List<ThirdPerson> remoteQueryPerson(TaiZhouProject taiZhouProject) {
+    public List<ThirdPerson> remoteQueryPerson(TaiZhouProject taiZhouProject, List<ThirdProjectPerson> needReturnPeople) {
 
         List<ThirdPerson> personList = new ArrayList<>();
 
@@ -203,14 +262,26 @@ public class TaiZhouServiceImpl implements TaiZhouService {
         req.setDataNumber(ext.getDataNumber());
         List<TaiZhouWorkerRes> resList = rpc.gBWorker(req);
         if (CollectionUtils.isEmpty(resList)) {
+            log.info("获取泰州人员信息(gBWorker) - projectTotalPersonCount = {}, returnCount = {}, needReturnCount = {}", 0, 0, CollUtil.size(needReturnPeople));
+            // 暂不收敛告警，遇到后做告警抑制处理。
+            log.error("三方工人基本信息获取失败，taiZhouProjectId = {}, dataNumber = {}，resList.size = 0，如连续多次出现，可能是项目数据指纹发生变更，请和群耀进行确认。"
+                    , taiZhouProject.getThirdProjectId(), ext.getDataNumber());
             return personList;
         }
 
-        resList.forEach(x -> {
+        Set<String> needReturnWorkerIds = needReturnPeople == null ? ImmutableSet.of() :
+                needReturnPeople.stream().map(ThirdProjectPerson::getThirdUniquePersonId).collect(Collectors.toSet());
+        List<TaiZhouWorkerRes> needReturns = resList.stream()
+                // 如果指定了需要返回的people，只需要返回这些即可（主要是为了节约换取手机号接口调用的时间，这里耗时最严重）
+                .filter(r -> needReturnWorkerIds.isEmpty() || needReturnWorkerIds.contains(r.getWorkerId()))
+                .collect(Collectors.toList());
+
+        needReturns.forEach(x -> {
             ThirdPerson person = buildPerson(taiZhouProject, x);
             personList.add(person);
         });
-
+        log.info("获取泰州人员信息(gBWorker) - projectTotalPersonCount = {}, returnCount = {}, needReturnCount = {}"
+                , resList.size(), needReturns.size(), CollUtil.size(needReturnPeople));
         return personList;
     }
 
@@ -284,7 +355,7 @@ public class TaiZhouServiceImpl implements TaiZhouService {
     }
 
     @Override
-    public void handlePerson(ThirdPerson thirdPerson, TaiZhouProject taiZhouProject) {
+    public void handlePerson(ThirdPerson thirdPerson, TaiZhouProject taiZhouProject, HandlerPersonType handlerPersonType) {
         // 如果手机号解密失败了，本次不处理，待下次同步
         if (StringUtils.contains(thirdPerson.getThirdPersonPhone(), "*")) {
             log.warn("泰州人员：{}，{}，{} 手机号解密失败，本次忽略处理",
@@ -293,41 +364,58 @@ public class TaiZhouServiceImpl implements TaiZhouService {
         }
         log.info("泰州人员：{} 开始处理", thirdPerson.getThirdPersonName());
         ThirdPerson oldThirdPerson = queryThirdPerson(thirdPerson);
-        //如果数据库为空，则插入
+        Set<String> updateIgnoredWorkerNames = new HashSet<>();
-        if (Objects.isNull(oldThirdPerson)) {
+
-            //数据入库
+        if (handlerPersonType == HandlerPersonType.ADD){
-            thirdPersonDao.save(thirdPerson);
+            if (oldThirdPerson == null) {
-            //业务操作
+                //数据入库
-            newDataHandle(thirdPerson, taiZhouProject);
+                thirdPersonDao.save(thirdPerson);
+                operateLogService.save(buildOperateParam(null, null,
+                        OperateLogService.OperateType.ADD, thirdPerson, "新增泰州用户", (JSONObject) JSON.toJSON(thirdPerson)));
+                //业务操作
+                newDataHandle(thirdPerson, taiZhouProject);
+            } else {
+                // 如果用户已经存在，则走全量刷新的接口，进行刷新操作。
+                log.info("泰州人员：{} 本次不处理，ADD 已经存在的ThirdPerson. db.id = {}", oldThirdPerson.getThirdPersonName(), oldThirdPerson.getId());
+            }
+        }else if (handlerPersonType == HandlerPersonType.UPDATE) {
+            if (oldThirdPerson != null) {
+                //先更新数据，保持和泰州一致
+                updateThirdPerson(oldThirdPerson, thirdPerson);
+
+                //业务前置检查，泰州同步关键信息不能变化，身份证，姓名不能有变化
+                taiZhouSyncBasicPersonCheck(thirdPerson, oldThirdPerson);
+
+                //如果没有绑定，直接使用新手机号绑定
+                if (oldThirdPerson.getPersonId() == 0L) {
+                    log.info("泰州人员：{}，历史数据未绑定安心筑账号，重新执行绑定业务（根据业务条件尝试绑定，不一定会绑定）", thirdPerson.getThirdPersonName());
+                    newDataHandle(thirdPerson, taiZhouProject);
+                    return;
+                }
+
+                //查询当前绑定的安心筑信息
+                PersonProfileDto currentBindPerson = userCenterRpc.queryPersonByPersonId(oldThirdPerson.getPersonId());
+                //如果数据不为空，且状态是删除状态，清除绑定关系后，重新走绑定流程
+                if (Objects.isNull(currentBindPerson)) {
+                    log.info("泰州人员：{}，历史绑定数据personID:{} 被删除，清除绑定关系后，重新执行绑定业务（根据业务条件尝试绑定，不一定会绑定）", thirdPerson.getThirdPersonName(), oldThirdPerson.getPersonId());
+                    clearBindPerson(oldThirdPerson);
+                    newDataHandle(thirdPerson, taiZhouProject);
+                    return;
+                }
+
+                //业务操作
+                updateDataHandle(thirdPerson, oldThirdPerson, currentBindPerson);
+            } else {
+                // 全量更新的时候，该数据还没有被增量接口写入，无需处理。下次增量同步会更新进来。
+                updateIgnoredWorkerNames.add(thirdPerson.getThirdPersonName());
+            }
         }
-        //反之则更新
+        // 存在本次未处理的数据（）
-        else {
+        if (!updateIgnoredWorkerNames.isEmpty()) {
-            //先更新数据，保持和泰州一致
+            String errorLog = String.format("泰州人员：%s 处理中 - 发现用户尚未增量新增（如连续多次告警，请确认），workerNames = %s"
-            updateThirdPerson(thirdPerson);
+                    , thirdPerson.getThirdPersonName(), JSON.toJSONString(updateIgnoredWorkerNames));
-
+            log.info(errorLog);
-            //业务前置检查，泰州同步关键信息不能变化，身份证，姓名不能有变化
+            dingDingRobotService.send(errorLog);
-            taiZhouSyncBasicPersonCheck(thirdPerson, oldThirdPerson);
-
-            //如果没有绑定，直接使用新手机号绑定
-            if (oldThirdPerson.getPersonId() == 0L) {
-                log.info("泰州人员：{}，历史数据未绑定安心筑账号，重新执行绑定业务（根据业务条件尝试绑定，不一定会绑定）", thirdPerson.getThirdPersonName());
-                newDataHandle(thirdPerson, taiZhouProject);
-                return;
-            }
-
-            //查询当前绑定的安心筑信息
-            PersonProfileDto currentBindPerson = userCenterRpc.queryPersonByPersonId(oldThirdPerson.getPersonId());
-            //如果数据不为空，且状态是删除状态，清除绑定关系后，重新走绑定流程
-            if (Objects.isNull(currentBindPerson)) {
-                log.info("泰州人员：{}，历史绑定数据personID:{} 被删除，清除绑定关系后，重新执行绑定业务（根据业务条件尝试绑定，不一定会绑定）", thirdPerson.getThirdPersonName(), oldThirdPerson.getPersonId());
-                clearBindPerson(oldThirdPerson);
-                newDataHandle(thirdPerson, taiZhouProject);
-                return;
-            }
-
-            //业务操作
-            updateDataHandle(thirdPerson, oldThirdPerson, currentBindPerson);
-
         }
         log.info("泰州人员：{} 处理结束", thirdPerson.getThirdPersonName());
     }
@@ -343,7 +431,7 @@ public class TaiZhouServiceImpl implements TaiZhouService {
                 .eq(ThirdPerson::getThirdUniquePersonId, oldThirdPerson.getThirdUniquePersonId())
                 .set(ThirdPerson::getPersonId, 0)
                 .update();
-
+        operateLogService.save(buildOperateParam(oldThirdPerson.getPersonId(), 0L, OperateLogService.OperateType.UPDATE, oldThirdPerson, "清除personId", null));
     }
 
     private void updateDataHandle(ThirdPerson thirdPerson, ThirdPerson oldThirdPerson, PersonProfileDto currentBindPerson) {
@@ -452,6 +540,8 @@ public class TaiZhouServiceImpl implements TaiZhouService {
         if (personProfileDto.getRealName().contains("工友") || personProfileDto.getRealName().contains("工人")) {
             log.info("泰州人员：{} 关联的安心筑人员姓名是默认姓名，需要修改，修改前：{}，修改后：{}", thirdPerson.getThirdPersonName(), personProfileDto.getRealName(), thirdPerson.getThirdPersonName());
             userCenterRpc.updateUserName(thirdPerson);
+            operateLogService.save(buildOperateParam(thirdPerson.getPersonId(), thirdPerson.getPersonId(), OperateLogService.OperateType.UPDATE,
+                    thirdPerson, String.format("更新安心筑工人姓名 %s -> %s", personProfileDto.getRealName(), thirdPerson.getThirdPersonName()), null));
         }
         thirdPersonDao.lambdaUpdate()
                 .eq(ThirdPerson::getThirdCode, thirdPerson.getThirdCode())
@@ -481,6 +571,9 @@ public class TaiZhouServiceImpl implements TaiZhouService {
         if (!(VerifyStatus.VERIFY_SUCCESS == currentBindPerson.getVerification().getVerifyStatus())) {
             log.info("泰州人员：{} 同步数据，新手机号在安心筑账号为空，且历史绑定数据未实名，需要覆盖安心筑手机号，安心筑personId：{}：originPhone:{},newPhone:{}", thirdPerson.getThirdPersonName(), currentBindPerson.getId(), currentBindPerson.getPhone(), thirdPerson.getThirdPersonPhone());
             userCenterRpc.updateUserPhone(oldThirdPerson.getPersonId(), thirdPerson.getThirdPersonPhone());
+            operateLogService.save(buildOperateParam(oldThirdPerson.getPersonId(), oldThirdPerson.getPersonId(), OperateLogService.OperateType.UPDATE,
+                    oldThirdPerson, String.format("更新安心筑用户手机号(泰州老手机号对应安心筑手机号未实名，且新手机号未注册) - " +
+                            "oldPhone=%s,newPhone=%s,personId=%s", oldThirdPerson.getThirdPersonPhone(), thirdPerson.getThirdPersonPhone(), oldThirdPerson.getPersonId()), new JSONObject()));
             return;
         }
 
@@ -489,6 +582,9 @@ public class TaiZhouServiceImpl implements TaiZhouService {
         if (comparePersonInfo(currentBindPerson, thirdPerson)) {
             log.info("泰州人员：{} 同步数据，新手机号在安心筑账号为空，且历史绑定数据实名，且与泰州信息一致，需要覆盖安心筑手机号，安心筑personId：{}：originPhone:{},newPhone:{}", thirdPerson.getThirdPersonName(), currentBindPerson.getId(), currentBindPerson.getPhone(), thirdPerson.getThirdPersonPhone());
             userCenterRpc.updateUserPhone(oldThirdPerson.getPersonId(), thirdPerson.getThirdPersonPhone());
+            operateLogService.save(buildOperateParam(oldThirdPerson.getPersonId(), oldThirdPerson.getPersonId(), OperateLogService.OperateType.UPDATE,
+                    oldThirdPerson, String.format("更新安心筑用户手机号(泰州老手机号对应安心筑手机号未实名，且新手机号未注册) - " +
+                            "oldPhone=%s,newPhone=%s,personId=%s", oldThirdPerson.getThirdPersonPhone(), thirdPerson.getThirdPersonPhone(), oldThirdPerson.getPersonId()), new JSONObject()));
         } else {
             String errorLog = String.format("泰州人员：%s 基本信息和安心筑信息不一致（姓名或者脱敏身份证不一致），不修改安心筑手机号 ", thirdPerson.getThirdPersonName());
             dingDingRobotService.send(errorLog);
@@ -608,11 +704,14 @@ public class TaiZhouServiceImpl implements TaiZhouService {
         if (Objects.isNull(personProfileDto)) {
             throw new ServiceException("泰州人员：" + thirdPerson.getThirdPersonName() + " 创建安心筑用户失败，程序跳过处理，请人工处理，或者等待后续重试，失败手机号：" + thirdPerson.getThirdPersonPhone());
         }
+        Long originPersonId = thirdPerson.getPersonId();
         thirdPerson.setPersonId(personProfileDto.getId());
         //先更新安心筑表中的姓名，在更新三方表的记录，顺序不能变
         if (personProfileDto.getRealName().contains("工友") || personProfileDto.getRealName().contains("工人")) {
             log.info("泰州人员：{} 关联的安心筑人员姓名是默认姓名，需要修改：修改前：{}，修改后：{}", thirdPerson.getThirdPersonName(), personProfileDto.getRealName(), thirdPerson.getThirdPersonName());
             userCenterRpc.updateUserName(thirdPerson);
+            operateLogService.save(buildOperateParam(originPersonId, originPersonId, OperateLogService.OperateType.UPDATE,
+                    thirdPerson, String.format("更新安心筑工人姓名 %s -> %s", personProfileDto.getRealName(), thirdPerson.getThirdPersonName()), null));
         }
 
         log.info("泰州人员：{} 开始绑定安心筑personID：{}", thirdPerson.getThirdPersonName(), personProfileDto.getId());
@@ -624,13 +723,24 @@ public class TaiZhouServiceImpl implements TaiZhouService {
                 .eq(ThirdPerson::getThirdUniquePersonId, thirdPerson.getThirdUniquePersonId())
                 .set(ThirdPerson::getPersonId, thirdPerson.getPersonId())
                 .update();
+        operateLogService.save(buildOperateParam(originPersonId, thirdPerson.getPersonId(),
+                OperateLogService.OperateType.UPDATE, thirdPerson, String.format("三方用户表绑定personId %s -> %s", originPersonId, thirdPerson.getPersonId()), null));
         log.info("泰州人员：{} 绑定安心筑账号结束", thirdPerson.getThirdPersonName());
 
     }
 
-
+    private void updateThirdPerson(ThirdPerson oldThirdPerson, ThirdPerson thirdPerson) {
-    private void updateThirdPerson(ThirdPerson thirdPerson) {
+        if (isNotChanged(thirdPerson.getThirdPersonName(), oldThirdPerson.getThirdPersonName())
-        thirdPersonDao.lambdaUpdate()
+                && isNotChanged(thirdPerson.getThirdPersonPhone(), oldThirdPerson.getThirdPersonPhone())
+                && isNotChanged(thirdPerson.getThirdPersonPhoto(), oldThirdPerson.getThirdPersonPhoto())
+                && isNotChanged(thirdPerson.getThirdAuthority(), oldThirdPerson.getThirdAuthority())
+                && isNotChanged(thirdPerson.getThirdIdNumber(), oldThirdPerson.getThirdIdNumber())
+                && isNotChanged(thirdPerson.getThirdPersonFaceUrl(), oldThirdPerson.getThirdPersonFaceUrl())
+                && isNotChanged(thirdPerson.getThirdSex(), oldThirdPerson.getThirdSex())) {
+            log.info("泰州人员：{} thirdPerson 泰州侧关键信息未变更，不更新ThirdPerson表泰州侧信息", thirdPerson.getThirdPersonName());
+            return;
+        }
+        boolean updated = thirdPersonDao.lambdaUpdate()
                 .eq(ThirdPerson::getThirdCode, thirdPerson.getThirdCode())
                 .eq(ThirdPerson::getThirdUniquePersonId, thirdPerson.getThirdUniquePersonId())
                 .set(!Objects.isNull(thirdPerson.getThirdPersonName()), ThirdPerson::getThirdPersonName, thirdPerson.getThirdPersonName())
@@ -641,8 +751,23 @@ public class TaiZhouServiceImpl implements TaiZhouService {
                 .set(!Objects.isNull(thirdPerson.getThirdPersonFaceUrl()), ThirdPerson::getThirdPersonFaceUrl, thirdPerson.getThirdPersonFaceUrl())
                 .set(!Objects.isNull(thirdPerson.getThirdSex()), ThirdPerson::getThirdSex, thirdPerson.getThirdSex())
                 .update();
+
+        // compare and log
+        if (updated) {
+            ThirdPerson toUpdate = BeanUtil.toBean(thirdPerson, ThirdPerson.class);
+            toUpdate.setId(oldThirdPerson.getId());
+            operateLogService.save(buildOperateParam(oldThirdPerson.getPersonId(), oldThirdPerson.getPersonId(), OperateLogService.OperateType.UPDATE, toUpdate,
+                    String.format("泰州用户 %s：信息变更", thirdPerson.getThirdPersonName()),
+                    new JSONObject().fluentPut("oldValue", oldThirdPerson).fluentPut("newValue", toUpdate)));
+        }
     }
 
+    private boolean isNotChanged(Object oldValue, Object newValue) {
+        if (newValue == null) {
+            return true;
+        }
+        return Objects.equals(oldValue, newValue);
+    }
 
     private void convertPhone(ThirdPerson thirdPerson, TaiZhouProject taiZhouProject) {
 
@@ -689,4 +814,17 @@ public class TaiZhouServiceImpl implements TaiZhouService {
         }
     }
 
+    private OperateLogService.SaveParam buildOperateParam(Long oldPersonId, Long newPersonId, OperateLogService.OperateType operateType, ThirdPerson toUpdate, String summary, JSONObject ext) {
+        return OperateLogService.SaveParam.builder()
+                .operateType(operateType)
+                .operatorName("系统")
+                .summary(summary)
+                .resourceType(OperateLogService.ResourceType.THIRD_PERSON)
+                .resourceId(toUpdate.getId() == null ? 0L : toUpdate.getId())
+                .oldValue(new JSONObject().fluentPut("personId", oldPersonId))
+                .newValue(new JSONObject().fluentPut("personId", newPersonId))
+                .ext(ext)
+                .build();
+    }
+
 }