相对方批量同步

src/main/java/com/nbport/zgwl/partner/controller/PartnerManageController.java

@@ -71,4 +71,11 @@ public class PartnerManageController {
     public R<PartnerManageDto> mockSync(@PathVariable("customerSysid") Long customerSysid) {
         return R.success(partnerManageService.mockSyncPartner(customerSysid));
     }
+
+    /** 批量模拟同步到法务系统（法务接口支持一次传多个，最多500条） */
+    @PostMapping("/batch-sync")
+    public R<Integer> batchSync(@RequestBody List<Long> customerSysids) {
+        int count = partnerManageService.batchSyncPartner(customerSysids);
+        return R.success(Integer.valueOf(count));
+    }
 }

src/main/java/com/nbport/zgwl/partner/mapper/PartnerManageMapper.java

@@ -27,6 +27,9 @@ public interface PartnerManageMapper {
     /** 根据主键查询单条相对方详情 */
     PartnerManageDto selectPartnerById(@Param("customerSysid") Long customerSysid);
 
+    /** 根据主键列表批量查询相对方（用于批量同步） */
+    List<PartnerManageDto> selectPartnerByIds(@Param("customerSysids") List<Long> customerSysids);
+
     /** 新增相对方 */
     int insertPartner(PartnerManageDto partner);
 

src/main/java/com/nbport/zgwl/partner/service/PartnerManageService.java

@@ -28,4 +28,14 @@ public interface PartnerManageService {
 
     /** 模拟同步到法务系统 */
     PartnerManageDto mockSyncPartner(Long customerSysid);
+
+    /**
+     * 批量同步相对方到法务系统。
+     * 模拟实现：逐条构造法务 oppositeId 并回写同步状态，打印批量报文日志。
+     * 后续联调时替换为调用 collectOpposites 批量接口（一次最多500条）。
+     *
+     * @param customerSysids 待同步的相对方ID列表
+     * @return 成功同步的条数
+     */
+    int batchSyncPartner(List<Long> customerSysids);
 }

src/main/java/com/nbport/zgwl/partner/service/PartnerManageServiceImpl.java

@@ -149,7 +149,6 @@ public class PartnerManageServiceImpl implements PartnerManageService {
                 PartnerManageConstants.PARTNER_IS_DELETED_DELETED);
     }
 
-    /** 同步相对方到法务系统 */
     @Override
     @Transactional(rollbackFor = Exception.class)
     public PartnerManageDto mockSyncPartner(Long customerSysid) {
@@ -224,6 +223,74 @@ public class PartnerManageServiceImpl implements PartnerManageService {
         return selectPartnerById(customerSysid);
     }
 
+    /**
+     * 批量模拟同步相对方到法务系统。
+     *
+     * 法务 collectOpposites 接口支持一次传多个（最多500条），这里构造数组报文。
+     * 当前法务接口不可用，逐条模拟回写 oppositeId 和同步状态。
+     * 真实联调时打开注释的 collectOpposites 调用，用法务返回的 jtId 回写。
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int batchSyncPartner(List<Long> customerSysids) {
+        if (customerSysids == null || customerSysids.isEmpty()) {
+            return 0;
+        }
+
+        List<PartnerManageDto> partners = partnerManageMapper.selectPartnerByIds(customerSysids);
+        if (partners.isEmpty()) {
+            return 0;
+        }
+
+        attachContacts(partners);
+
+        LocalDateTime now = LocalDateTime.now();
+
+        // 构造批量报文（法务接口要求 JSON 数组 [{...},{...}]）
+        List<Map<String, Object>> batchPayload = PartnerSyncPayloadBuilder.buildCollectOppositesBatchPayload(partners);
+        log.info("法务系统批量同步参数，共 {} 条: {}", partners.size(), JsonUtils.toJson(batchPayload));
+
+        // TODO: 真实联调时打开以下调用
+        // PushPayloadDTO requestDTO = new PushPayloadDTO();
+        // requestDTO.setPayload(Map.of("opposites", batchPayload));  // 或直接传 List，取决于 collectOpposites 签名
+        // Map<String, Object> response = dataCollectionPushService.collectOpposites(requestDTO);
+        // 解析法务返回结果（响应格式: { "code": "200", "data": [{ "o_id": "4083", "jtId": "10256" }, ...], "msg": "接收成功" }）
+        // Object codeObj = response.get("code");
+        // if (codeObj != null && ("200".equals(String.valueOf(codeObj)) || Integer.valueOf(200).equals(codeObj))) {
+        //     List<?> dataList = (List<?>) response.get("data");
+        //     if (dataList != null) {
+        //         for (Object item : dataList) {
+        //             if (item instanceof Map) {
+        //                 Map<?, ?> map = (Map<?, ?>) item;
+        //                 Long oId = Long.valueOf(String.valueOf(map.get("o_id")));
+        //                 String jtId = map.get("jtId") != null ? String.valueOf(map.get("jtId")) : null;
+        //                 partnerManageMapper.updatePartnerSyncInfo(oId, jtId, SYNC_STATUS_SYNCED, now, "批量同步成功", operator, now);
+        //             }
+        //         }
+        //     }
+        // }
+
+        // 模拟同步：逐条回写
+        String syncMessage = "批量模拟同步成功。TODO：后续调用 collectOpposites 批量接口。";
+        int successCount = 0;
+        for (PartnerManageDto partner : partners) {
+            String finalOppositeId = StrUtilHelper.hasText(partner.getOppositeId())
+                    ? partner.getOppositeId()
+                    : PartnerIdUtils.buildGroupPartnerId();
+            partnerManageMapper.updatePartnerSyncInfo(
+                    partner.getCustomerSysid(),
+                    finalOppositeId,
+                    PartnerManageConstants.SYNC_STATUS_SYNCED,
+                    now,
+                    syncMessage,
+                    PartnerManageConstants.DEFAULT_OPERATOR,
+                    now);
+            successCount++;
+        }
+
+        return successCount;
+    }
+
     /** 批量查询并填充联系人（避免 N+1，一次查完再分组赋值） */
     private void attachContacts(List<PartnerManageDto> partnerList) {
         if (partnerList == null || partnerList.isEmpty()) {

src/main/java/com/nbport/zgwl/partner/utils/PartnerSyncPayloadBuilder.java

@@ -19,8 +19,25 @@ public final class PartnerSyncPayloadBuilder {
     private PartnerSyncPayloadBuilder() {
     }
 
-    /** 构建相对方信息采集报文（数据采集接口规范 V3.0 格式） */
+    /** 构建相对方信息采集报文（数据采集接口规范 V3.0 格式，单条） */
     public static PushPayloadDTO buildCollectOppositesPayload(PartnerManageDto partner) {
+        PushPayloadDTO requestDTO = new PushPayloadDTO();
+        requestDTO.setPayload(buildSingleOppositePayload(partner));
+        return requestDTO;
+    }
+
+    /**
+     * 构建相对方信息采集批量报文（数据采集接口规范 V3.0 格式，支持一次传多个，每次最多500条）。
+     * 文档要求请求体为 JSON 数组 [{...},{...}]，直接返回 List 供调用方自行序列化。
+     */
+    public static List<Map<String, Object>> buildCollectOppositesBatchPayload(List<PartnerManageDto> partners) {
+        return partners.stream()
+                .map(PartnerSyncPayloadBuilder::buildSingleOppositePayload)
+                .collect(Collectors.toList());
+    }
+
+    /** 构建单个相对方的报文体（复用于单条和批量） */
+    private static Map<String, Object> buildSingleOppositePayload(PartnerManageDto partner) {
         Map<String, Object> payload = new LinkedHashMap<>();
         payload.put("o_id", partner.getCustomerSysid() == null ? null : String.valueOf(partner.getCustomerSysid()));
         payload.put("o_name", partner.getCustomerNameC());
@@ -49,10 +66,7 @@ public final class PartnerSyncPayloadBuilder {
                         partner.getCreateTime().format(DATE_TIME_FORMATTER)
         );
         payload.put("o_contacts", buildContactList(partner.getContacts()));
-
-        PushPayloadDTO requestDTO = new PushPayloadDTO();
-        requestDTO.setPayload(payload);
-        return requestDTO;
+        return payload;
     }
 
     /** 构建联系人列表报文 */

src/main/resources/mapper/partner/PartnerManageMapper.xml

@@ -114,6 +114,15 @@
           and IS_DELETED = 'N'
     </select>
 
+    <select id="selectPartnerByIds" resultMap="PartnerManageResult">
+        <include refid="selectPartnerColumns"/>
+        where IS_DELETED = 'N'
+          and CUSTOMER_SYSID in
+        <foreach collection="customerSysids" item="customerSysid" open="(" separator="," close=")">
+            #{customerSysid}
+        </foreach>
+    </select>
+
     <insert id="insertPartner" parameterType="com.nbport.zgwl.partner.dto.PartnerManageDto">
         insert into ILDM_FEE_CUSTOMER_INFO
         (