From 726cdb0da6b8930b89bf098ac9e375bddefc6f66 Mon Sep 17 00:00:00 2001 From: Gjm <你的邮箱> Date: Fri, 8 May 2026 17:25:43 +0800 Subject: [PATCH] =?UTF-8?q?refactor(job):=20=E4=BC=98=E5=8C=96ERP=E5=9F=BA?= =?UTF-8?q?=E7=A1=80=E6=95=B0=E6=8D=AE=E5=90=8C=E6=AD=A5=E4=BB=BB=E5=8A=A1?= =?UTF-8?q?=E5=A4=84=E7=90=86=E9=80=BB=E8=BE=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 修改ErpBasicDataInformationJob中syncDCPartnerByTimestamp方法参数传递 - 修改SalesBasicDataInformationJob中物料信息同步的数据处理方式 - 修复多个Mapper中查询条件的字段匹配问题 - 在ErpBfPartnerServiceImpl中实现完整的合作伙伴数据处理功能 - 添加对合作伙伴股东、关联关系、控制人、高管等数据的同步处理 - 实现重试机制以提高ERP接口调用的稳定性 - 完善数据同步过程中的错误处理和日志记录 --- .../job/ErpBasicDataInformationJob.java | 6 +- .../job/SalesBasicDataInformationJob.java | 10 +- .../mapper/erp/ErpBfPartnerVersionMapper.java | 2 +- .../erp/ErpMaterialConversionMapper.java | 2 +- .../mapper/erp/ErpMaterialExtendMapper.java | 2 +- .../erp/ErpMaterialMeasureunitMapper.java | 2 +- .../service/erp/ErpBfPartnerService.java | 3 +- .../service/erp/ErpMaterialService.java | 3 +- .../service/erp/SalesMaterialService.java | 3 +- .../erp/impl/BomMaterialServiceImpl.java | 2 +- .../erp/impl/ErpBfPartnerServiceImpl.java | 1558 ++++++++++++++++- .../erp/impl/ErpMaterialServiceImpl.java | 1521 +++++++++++++++- .../erp/impl/SalesBfPartnerServiceImpl.java | 6 +- .../erp/impl/SalesMaterialServiceImpl.java | 1434 ++++++++++++++- 14 files changed, 4512 insertions(+), 42 deletions(-) diff --git a/lidee-core/src/main/java/com/lideeyunji/core/framework/config/job/ErpBasicDataInformationJob.java b/lidee-core/src/main/java/com/lideeyunji/core/framework/config/job/ErpBasicDataInformationJob.java index fe5b36d..7596fc4 100644 --- a/lidee-core/src/main/java/com/lideeyunji/core/framework/config/job/ErpBasicDataInformationJob.java +++ b/lidee-core/src/main/java/com/lideeyunji/core/framework/config/job/ErpBasicDataInformationJob.java @@ -113,7 +113,7 @@ public class ErpBasicDataInformationJob implements JobHandler { if (partner.getOfRegion() != null && codeItemsMapping.containsKey(partner.getOfRegion())) { partner.setOfRegion(codeItemsMapping.get(partner.getOfRegion())); } - return erpBfPartnerService.syncDCPartnerByTimestamp(partner, time); + return erpBfPartnerService.syncDCPartnerByTimestamp(partner, time,codeItemsMapping); } ); @@ -148,12 +148,12 @@ public class ErpBasicDataInformationJob implements JobHandler { if (materialEntity.getOutboundStrategy() != null && codeItemsMapping.containsKey(materialEntity.getOutboundStrategy())) { materialEntity.setOutboundStrategy(codeItemsMapping.get(materialEntity.getOutboundStrategy())); } - return erpMaterialService.syncDCPartnerByTimestamp(data); + return erpMaterialService.syncDCPartnerByTimestamp(data,unitMap,time); } ); - this.handleMarerialChild(lastSyncTime, unitMap); +// this.handleMarerialChild(lastSyncTime, unitMap); // // syncDataWithHandling("计量单位信息(DC->ERP)", lastSyncTime, diff --git a/lidee-core/src/main/java/com/lideeyunji/core/framework/config/job/SalesBasicDataInformationJob.java b/lidee-core/src/main/java/com/lideeyunji/core/framework/config/job/SalesBasicDataInformationJob.java index 05789c4..fd29a07 100644 --- a/lidee-core/src/main/java/com/lideeyunji/core/framework/config/job/SalesBasicDataInformationJob.java +++ b/lidee-core/src/main/java/com/lideeyunji/core/framework/config/job/SalesBasicDataInformationJob.java @@ -124,12 +124,6 @@ public class SalesBasicDataInformationJob implements JobHandler { // Map itemsMap = itemsMapping(); Map unitMap = materialUnitMapping(); - syncDataWithHandling("物料信息主数据字段信息(DC->ERP)", lastSyncTime, - time -> salesMaterialService.selectPartnerFromDC(time), - - (data, time) -> salesMaterialService.syncDCPartnerByTimestamp(data)); - - syncDataWithHandling("物料信息主数据字段信息(DC->ERP)", lastSyncTime, time -> salesMaterialService.selectPartnerFromDC(time), (data, time) -> { @@ -152,11 +146,11 @@ public class SalesBasicDataInformationJob implements JobHandler { if (materialEntity.getOutboundStrategy() != null && codeItemsMapping.containsKey(materialEntity.getOutboundStrategy())) { materialEntity.setOutboundStrategy(codeItemsMapping.get(materialEntity.getOutboundStrategy())); } - return salesMaterialService.syncDCPartnerByTimestamp(data); + return salesMaterialService.syncDCPartnerByTimestamp(data,unitMap); } ); - this.handleMarerialChild(lastSyncTime,unitMap); +// this.handleMarerialChild(lastSyncTime,unitMap); // syncDataWithHandling("计量单位信息(DC->ERP)", lastSyncTime, diff --git a/lidee-core/src/main/java/com/lideeyunji/core/framework/mapper/erp/ErpBfPartnerVersionMapper.java b/lidee-core/src/main/java/com/lideeyunji/core/framework/mapper/erp/ErpBfPartnerVersionMapper.java index 0841144..0fbd336 100644 --- a/lidee-core/src/main/java/com/lideeyunji/core/framework/mapper/erp/ErpBfPartnerVersionMapper.java +++ b/lidee-core/src/main/java/com/lideeyunji/core/framework/mapper/erp/ErpBfPartnerVersionMapper.java @@ -28,7 +28,7 @@ public interface ErpBfPartnerVersionMapper extends BaseMapper() .eq(ErpBfPartnerVersionEntity::getParentId, versions.getParentId()) - .eq(ErpBfPartnerVersionEntity::getStateIsEnabled, "0") + .eq(ErpBfPartnerVersionEntity::getStateIsEnabled, "1") ); } diff --git a/lidee-core/src/main/java/com/lideeyunji/core/framework/mapper/erp/ErpMaterialConversionMapper.java b/lidee-core/src/main/java/com/lideeyunji/core/framework/mapper/erp/ErpMaterialConversionMapper.java index 2176bf6..f5b62d1 100644 --- a/lidee-core/src/main/java/com/lideeyunji/core/framework/mapper/erp/ErpMaterialConversionMapper.java +++ b/lidee-core/src/main/java/com/lideeyunji/core/framework/mapper/erp/ErpMaterialConversionMapper.java @@ -17,7 +17,7 @@ public interface ErpMaterialConversionMapper extends BaseMapper(); } - return this.selectList(new LambdaQueryWrapper().eq(ErpMaterialConversionEntity::getId, data.getId()) + return this.selectList(new LambdaQueryWrapper() .eq(ErpMaterialConversionEntity::getParentId, data.getParentId()) ); } diff --git a/lidee-core/src/main/java/com/lideeyunji/core/framework/mapper/erp/ErpMaterialExtendMapper.java b/lidee-core/src/main/java/com/lideeyunji/core/framework/mapper/erp/ErpMaterialExtendMapper.java index afa307a..8ed4746 100644 --- a/lidee-core/src/main/java/com/lideeyunji/core/framework/mapper/erp/ErpMaterialExtendMapper.java +++ b/lidee-core/src/main/java/com/lideeyunji/core/framework/mapper/erp/ErpMaterialExtendMapper.java @@ -17,7 +17,7 @@ public interface ErpMaterialExtendMapper extends BaseMapper(); } - return this.selectList(new LambdaQueryWrapper().eq(ErpMaterialExtendEntity::getId, data.getId()) + return this.selectList(new LambdaQueryWrapper() .eq(ErpMaterialExtendEntity::getMaterialId, data.getMaterialId())); } diff --git a/lidee-core/src/main/java/com/lideeyunji/core/framework/mapper/erp/ErpMaterialMeasureunitMapper.java b/lidee-core/src/main/java/com/lideeyunji/core/framework/mapper/erp/ErpMaterialMeasureunitMapper.java index b6a162b..04b84e6 100644 --- a/lidee-core/src/main/java/com/lideeyunji/core/framework/mapper/erp/ErpMaterialMeasureunitMapper.java +++ b/lidee-core/src/main/java/com/lideeyunji/core/framework/mapper/erp/ErpMaterialMeasureunitMapper.java @@ -18,7 +18,7 @@ public interface ErpMaterialMeasureunitMapper extends BaseMapper(); } - return this.selectList(new LambdaQueryWrapper().eq(ErpMaterialMeasureunitEntity::getMaterialMeasureUnit, data.getMaterialMeasureUnit()) + return this.selectList(new LambdaQueryWrapper() .eq(ErpMaterialMeasureunitEntity::getParentId, data.getParentId()) ); } diff --git a/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/ErpBfPartnerService.java b/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/ErpBfPartnerService.java index dcd6a9b..f550ba8 100644 --- a/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/ErpBfPartnerService.java +++ b/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/ErpBfPartnerService.java @@ -6,12 +6,13 @@ import com.lideeyunji.core.framework.entity.erp.*; import java.io.IOException; import java.util.Date; import java.util.List; +import java.util.Map; public interface ErpBfPartnerService { List selectPartnerFromDC(Date time) ; - Integer syncDCPartnerByTimestamp(ErpBfPartner data,Date time); + Integer syncDCPartnerByTimestamp(ErpBfPartner data,Date time, Map codeItemsMapping); List selectPartnerContactFromDC(Date time); diff --git a/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/ErpMaterialService.java b/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/ErpMaterialService.java index bcd15e7..2cda27d 100644 --- a/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/ErpMaterialService.java +++ b/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/ErpMaterialService.java @@ -4,11 +4,12 @@ import com.lideeyunji.core.framework.entity.erp.*; import java.util.Date; import java.util.List; +import java.util.Map; public interface ErpMaterialService { List selectPartnerFromDC(Date time); - Integer syncDCPartnerByTimestamp(ErpMaterialEntity data); + Integer syncDCPartnerByTimestamp(ErpMaterialEntity data, MapunitMap, Date time); List selectUnitAreaFromDC(Date time); diff --git a/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/SalesMaterialService.java b/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/SalesMaterialService.java index 29a1f36..4b40c74 100644 --- a/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/SalesMaterialService.java +++ b/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/SalesMaterialService.java @@ -4,11 +4,12 @@ import com.lideeyunji.core.framework.entity.erp.*; import java.util.Date; import java.util.List; +import java.util.Map; public interface SalesMaterialService { List selectPartnerFromDC(Date time); - Integer syncDCPartnerByTimestamp(ErpMaterialEntity data); + Integer syncDCPartnerByTimestamp(ErpMaterialEntity data, Map unitMap); List selectUnitAreaFromDC(Date time); diff --git a/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/impl/BomMaterialServiceImpl.java b/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/impl/BomMaterialServiceImpl.java index acee056..50a2766 100644 --- a/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/impl/BomMaterialServiceImpl.java +++ b/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/impl/BomMaterialServiceImpl.java @@ -303,7 +303,7 @@ public class BomMaterialServiceImpl extends ServiceImpl() .eq(ErpMaterialEntity::getCode, data.getCcode()) - .eq(ErpMaterialEntity::getStateIsEnabled, "0") + .eq(ErpMaterialEntity::getStateIsEnabled, "1") ); JsbomEntity jsbom = baseMapper.selectOne( new LambdaQueryWrapper() diff --git a/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/impl/ErpBfPartnerServiceImpl.java b/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/impl/ErpBfPartnerServiceImpl.java index eae996c..5fd3ac7 100644 --- a/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/impl/ErpBfPartnerServiceImpl.java +++ b/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/impl/ErpBfPartnerServiceImpl.java @@ -227,7 +227,1556 @@ public class ErpBfPartnerServiceImpl extends ServiceImpl codeItemsMapping) { + this.handlePartnerData(data, time); + String parentId = this.handlePartnerId(data.getId()); + if (parentId == null) + return 0; +// this.handleAttachment(data, time,parentId);//附件 +// this.handleCertificate(data, time, parentId);//证件 +// this.handleLinks(data, time, parentId);//链接 +// this.handleIban(data, time, parentId);//iban +// this.handleVersion(data, time, parentId);//版本 +// this.handleHeadExt(data, time, parentId);// 扩展 +// this.handleBranch(data, time, parentId);//分支机构 +// this.handleCXOS(data, time, parentId);//企业高管 +// this.handleEquity(data, time, parentId);//控制人信息 +// this.hadleRelation(data, time, parentId);//企业关联关系 +// this.handleShareholder(data, time, parentId);//股东 + return 1; + } + + private void handleShareholder(ErpBfPartner data, Date time, String parentId) { + StringBuilder urlBuilder = new StringBuilder(partnerShareholder); + + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取股东数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + String dataJson = jsonObject.getStr("data"); + if (dataJson != null && !dataJson.isEmpty()) { + contactList = JSON.parseArray(dataJson, ErpBfPartnerShareholderEntity.class); + if (contactList == null) { + contactList = new ArrayList<>(); + } + log.info("成功从ERP获取往来单位股东数据，数量: {}", contactList.size()); + } else { + log.info("成功从ERP获取往来单位股东数据，数量: 0"); + } + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个股东 + for (ErpBfPartnerShareholderEntity shareholder : contactList) { + shareholder.setParentId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在（假设按 parentId + shareholderName 作为唯一标识） + ErpBfPartnerShareholderEntity queryParam = new ErpBfPartnerShareholderEntity(); + queryParam.setParentId(parentId); + queryParam.setCode(shareholder.getCode()); + + List existingList = erpBfPartnerShareholderMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + shareholder.setId(UUID.randomUUID().toString()); + toInsert.add(shareholder); + } else { + // 存在则加入更新列表 + ErpBfPartnerShareholderEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(shareholder, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpBfPartnerShareholderMapper.insertBatchErpPartnerShareHolder(toInsert); + copyBfPartnerShareholderMapper.insertBatchErpPartnerShareHolder(toInsert); + log.info("批量新增往来单位股东数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpBfPartnerShareholderEntity entity : toUpdate) { + erpBfPartnerShareholderMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpBfPartnerShareholderEntity entity : toUpdate) { + CopyBfPartnerShareholderEntity copyEntity = new CopyBfPartnerShareholderEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyBfPartnerShareholderEntity copyEntity : copyList) { + copyBfPartnerShareholderMapper.updateById(copyEntity); + } + + log.info("批量更新往来单位股东数据，数量: {}", toUpdate.size()); + } + + log.info("往来单位股东数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void hadleRelation(ErpBfPartner data, Date time, String parentId) { + StringBuilder urlBuilder = new StringBuilder(partnerRelation); + + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取企业关联数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + String dataJson = jsonObject.getStr("data"); + if (dataJson != null && !dataJson.isEmpty()) { + contactList = JSON.parseArray(dataJson, ErpBfPartnerRelationEntity.class); + if (contactList == null) { + contactList = new ArrayList<>(); + } + log.info("成功从ERP获取往来单位企业关联数据，数量: {}", contactList.size()); + } else { + log.info("成功从ERP获取往来单位企业关联数据，数量: 0"); + } + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个企业关联 + for (ErpBfPartnerRelationEntity relation : contactList) { + relation.setParentId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在（假设按 parentId + relatedPartnerCode 作为唯一标识） + ErpBfPartnerRelationEntity queryParam = new ErpBfPartnerRelationEntity(); + queryParam.setParentId(parentId); + queryParam.setCode(relation.getCode()); + + List existingList = erpBfPartnerRelationMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + relation.setId(UUID.randomUUID().toString()); + toInsert.add(relation); + } else { + // 存在则加入更新列表 + ErpBfPartnerRelationEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(relation, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpBfPartnerRelationMapper.insertERPBatchPartnerRelation(toInsert); + copyBfPartnerRelationMapper.insertERPBatchPartnerRelation(toInsert); + log.info("批量新增往来单位企业关联数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpBfPartnerRelationEntity entity : toUpdate) { + erpBfPartnerRelationMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpBfPartnerRelationEntity entity : toUpdate) { + CopyBfPartnerRelationEntity copyEntity = new CopyBfPartnerRelationEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyBfPartnerRelationEntity copyEntity : copyList) { + copyBfPartnerRelationMapper.updateById(copyEntity); + } + + log.info("批量更新往来单位企业关联数据，数量: {}", toUpdate.size()); + } + + log.info("往来单位企业关联数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handleEquity(ErpBfPartner data, Date time, String parentId) { + StringBuilder urlBuilder = new StringBuilder(partnerEquity); + + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取控制人数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + String dataJson = jsonObject.getStr("data"); + if (dataJson != null && !dataJson.isEmpty()) { + contactList = JSON.parseArray(dataJson, ErpBfPartnerEquityEntity.class); + if (contactList == null) { + contactList = new ArrayList<>(); + } + log.info("成功从ERP获取往来单位控制人数据，数量: {}", contactList.size()); + } else { + log.info("成功从ERP获取往来单位控制人数据，数量: 0"); + } + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个控制人 + for (ErpBfPartnerEquityEntity equity : contactList) { + equity.setParentId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在（假设按 parentId + shareholderName 作为唯一标识） + ErpBfPartnerEquityEntity queryParam = new ErpBfPartnerEquityEntity(); + queryParam.setParentId(parentId); + queryParam.setCode(equity.getCode()); + + List existingList = erpBfPartnerEquityMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + equity.setId(UUID.randomUUID().toString()); + toInsert.add(equity); + } else { + // 存在则加入更新列表 + ErpBfPartnerEquityEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(equity, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpBfPartnerEquityMapper.insertERPBatchPartnerEquity(toInsert); + copyBfPartnerEquityMapper.insertERPBatchPartnerEquity(toInsert); + log.info("批量新增往来单位控制人数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpBfPartnerEquityEntity entity : toUpdate) { + erpBfPartnerEquityMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpBfPartnerEquityEntity entity : toUpdate) { + CopyBfPartnerEquityEntity copyEntity = new CopyBfPartnerEquityEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyBfPartnerEquityEntity copyEntity : copyList) { + copyBfPartnerEquityMapper.updateById(copyEntity); + } + + log.info("批量更新往来单位控制人数据，数量: {}", toUpdate.size()); + } + + log.info("往来单位控制人数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handleCXOS(ErpBfPartner data, Date time, String parentId) { + StringBuilder urlBuilder = new StringBuilder(partnerCXOs); + + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取企业高管数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + String dataJson = jsonObject.getStr("data"); + if (dataJson != null && !dataJson.isEmpty()) { + contactList = JSON.parseArray(dataJson, ErpBfPartnerCXOsEntity.class); + if (contactList == null) { + contactList = new ArrayList<>(); + } + log.info("成功从ERP获取往来单位企业高管数据，数量: {}", contactList.size()); + } else { + log.info("成功从ERP获取往来单位企业高管数据，数量: 0"); + } + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个企业高管 + for (ErpBfPartnerCXOsEntity cxo : contactList) { + cxo.setParentId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在（假设按 parentId + name 作为唯一标识） + ErpBfPartnerCXOsEntity queryParam = new ErpBfPartnerCXOsEntity(); + queryParam.setParentId(parentId); + queryParam.setCode(cxo.getCode()); + + List existingList = erpBfPartnerCXOsMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + cxo.setId(UUID.randomUUID().toString()); + toInsert.add(cxo); + } else { + // 存在则加入更新列表 + ErpBfPartnerCXOsEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(cxo, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpBfPartnerCXOsMapper.insertBatchERPPartnerCXOs(toInsert); + copyBfPartnerCXOsMapper.insertBatchERPPartnerCXOs(toInsert); + log.info("批量新增往来单位企业高管数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpBfPartnerCXOsEntity entity : toUpdate) { + erpBfPartnerCXOsMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpBfPartnerCXOsEntity entity : toUpdate) { + CopyBfPartnerCXOsEntity copyEntity = new CopyBfPartnerCXOsEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyBfPartnerCXOsEntity copyEntity : copyList) { + copyBfPartnerCXOsMapper.updateById(copyEntity); + } + + log.info("批量更新往来单位企业高管数据，数量: {}", toUpdate.size()); + } + + log.info("往来单位企业高管数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handleBranch(ErpBfPartner data, Date time, String parentId) { + StringBuilder urlBuilder = new StringBuilder(partnerBranch); + + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取分支机构数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + String dataJson = jsonObject.getStr("data"); + if (dataJson != null && !dataJson.isEmpty()) { + contactList = JSON.parseArray(dataJson, ErpBfPartnerBranchEntity.class); + if (contactList == null) { + contactList = new ArrayList<>(); + } + log.info("成功从ERP获取往来单位分支机构数据，数量: {}", contactList.size()); + } else { + log.info("成功从ERP获取往来单位分支机构数据，数量: 0"); + } + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个分支机构 + for (ErpBfPartnerBranchEntity branch : contactList) { + branch.setParentId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在（假设按 parentId + code 作为唯一标识） + ErpBfPartnerBranchEntity queryParam = new ErpBfPartnerBranchEntity(); + queryParam.setParentId(parentId); + queryParam.setCode(branch.getCode()); + + List existingList = erpBfPartnerBranchMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + branch.setId(UUID.randomUUID().toString()); + toInsert.add(branch); + } else { + // 存在则加入更新列表 + ErpBfPartnerBranchEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(branch, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpBfPartnerBranchMapper.insertBatchERPPartnerBranch(toInsert); + copyBfPartnerBranchMapper.insertBatchERPPartnerBranch(toInsert); + log.info("批量新增往来单位分支机构数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpBfPartnerBranchEntity entity : toUpdate) { + erpBfPartnerBranchMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpBfPartnerBranchEntity entity : toUpdate) { + CopyBfPartnerBranchEntity copyEntity = new CopyBfPartnerBranchEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyBfPartnerBranchEntity copyEntity : copyList) { + copyBfPartnerBranchMapper.updateById(copyEntity); + } + + log.info("批量更新往来单位分支机构数据，数量: {}", toUpdate.size()); + } + + log.info("往来单位分支机构数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handleHeadExt(ErpBfPartner data, Date time, String parentId) { + StringBuilder urlBuilder = new StringBuilder(partnerHeadExt); + + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取拓展数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + String dataJson = jsonObject.getStr("data"); + if (dataJson != null && !dataJson.isEmpty()) { + contactList = JSON.parseArray(dataJson, ErpBfPartnerHeadExtEntity.class); + if (contactList == null) { + contactList = new ArrayList<>(); + } + log.info("成功从ERP获取往来单位拓展数据，数量: {}", contactList.size()); + } else { + log.info("成功从ERP获取往来单位拓展数据，数量: 0"); + } + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个自定义拓展 + for (ErpBfPartnerHeadExtEntity headExt : contactList) { + headExt.setPartnerId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在 + ErpBfPartnerHeadExtEntity queryParam = new ErpBfPartnerHeadExtEntity(); + queryParam.setPartnerId(parentId); + queryParam.setVersion(headExt.getVersion()); + + List existingList = erpBfPartnerHeadExtMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + headExt.setId(UUID.randomUUID().toString()); + toInsert.add(headExt); + } else { + // 存在则加入更新列表 + ErpBfPartnerHeadExtEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(headExt, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpBfPartnerHeadExtMapper.insertBatchERPHeadExt(toInsert); + copyBfPartnerHeadExtMapper.insertBatchERPHeadExt(toInsert); + log.info("批量新增往来单位自定义拓展数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpBfPartnerHeadExtEntity entity : toUpdate) { + erpBfPartnerHeadExtMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpBfPartnerHeadExtEntity entity : toUpdate) { + CopyBfPartnerHeadExtEntity copyEntity = new CopyBfPartnerHeadExtEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyBfPartnerHeadExtEntity copyEntity : copyList) { + copyBfPartnerHeadExtMapper.updateById(copyEntity); + } + + log.info("批量更新往来单位自定义拓展数据，数量: {}", toUpdate.size()); + } + + log.info("往来单位自定义拓展数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handleVersion(ErpBfPartner data, Date time, String parentId) { + StringBuilder urlBuilder = new StringBuilder(partnerVersion); +// urlBuilder.append("&TIMESTAMP_LASTCHANGEDON=").append(lastChangeTime); + + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取历史版本数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + String dataJson = jsonObject.getStr("data"); + if (dataJson != null && !dataJson.isEmpty()) { + contactList = JSON.parseArray(dataJson, ErpBfPartnerVersionEntity.class); + if (contactList == null) { + contactList = new ArrayList<>(); + } + log.info("成功从ERP获取往来单位历史版本数据，数量: {}", contactList.size()); + } else { + log.info("成功从ERP获取往来单位历史版本数据，数量: 0"); + } + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个历史版本 + for (ErpBfPartnerVersionEntity version : contactList) { + version.setParentId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在（假设按 parentId + version 作为唯一标识） + ErpBfPartnerVersionEntity queryParam = new ErpBfPartnerVersionEntity(); + queryParam.setParentId(parentId); + queryParam.setVersion(version.getVersion()); + + List existingList = erpBfPartnerVersionMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + version.setId(UUID.randomUUID().toString()); + version.setTimeStampCreatedOn(now); + version.setTimeStampLastChangedOn(now); + toInsert.add(version); + } else { + // 存在则加入更新列表 + ErpBfPartnerVersionEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(version, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + existing.setTimeStampLastChangedOn(now); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpBfPartnerVersionMapper.insertBatchERPBfPartnerVersion(toInsert); + copyBfPartnerVersionMapper.insertBatchERPBfPartnerVersion(toInsert); + log.info("批量新增往来单位历史版本数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpBfPartnerVersionEntity entity : toUpdate) { + erpBfPartnerVersionMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpBfPartnerVersionEntity entity : toUpdate) { + CopyBfPartnerVersionEntity copyEntity = new CopyBfPartnerVersionEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyBfPartnerVersionEntity copyEntity : copyList) { + copyBfPartnerVersionMapper.updateById(copyEntity); + } + + log.info("批量更新往来单位历史版本数据，数量: {}", toUpdate.size()); + } + + log.info("往来单位历史版本数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handleIban(ErpBfPartner data, Date time, String parentId) { + StringBuilder urlBuilder = new StringBuilder(partnerIBAN); +// urlBuilder.append("&TIMESTAMP_LASTCHANGEDON=").append(lastChangeTime); + + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取IBAN数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + String dataJson = jsonObject.getStr("data"); + if (dataJson != null && !dataJson.isEmpty()) { + contactList = JSON.parseArray(dataJson, ErpBfPartnerIbanEntity.class); + if (contactList == null) { + contactList = new ArrayList<>(); + } + log.info("成功从ERP获取往来单位IBAN数据，数量: {}", contactList.size()); + } else { + log.info("成功从ERP获取往来单位IBAN数据，数量: 0"); + } + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个IBAN + for (ErpBfPartnerIbanEntity iban : contactList) { + iban.setParentId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在（假设按 parentId + iban 作为唯一标识） + ErpBfPartnerIbanEntity queryParam = new ErpBfPartnerIbanEntity(); + queryParam.setParentId(parentId); + queryParam.setIban(iban.getIban()); + + List existingList = erpBfPartnerIbanMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + iban.setId(UUID.randomUUID().toString()); + iban.setTimeStampCreatedOn(now); + iban.setTimeStampLastChangedOn(now); + toInsert.add(iban); + } else { + // 存在则加入更新列表 + ErpBfPartnerIbanEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(iban, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + existing.setTimeStampLastChangedOn(now); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpBfPartnerIbanMapper.insertBatchERPBfPartnerIban(toInsert); + copyBfPartnerIbanMapper.insertBatchERPBfPartnerIban(toInsert); + log.info("批量新增往来单位IBAN数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpBfPartnerIbanEntity entity : toUpdate) { + erpBfPartnerIbanMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpBfPartnerIbanEntity entity : toUpdate) { + CopyBfPartnerIbanEntity copyEntity = new CopyBfPartnerIbanEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyBfPartnerIbanEntity copyEntity : copyList) { + copyBfPartnerIbanMapper.updateById(copyEntity); + } + + log.info("批量更新往来单位IBAN数据，数量: {}", toUpdate.size()); + } + + log.info("往来单位IBAN数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handleLinks(ErpBfPartner data, Date time, String parentId) { + StringBuilder urlBuilder = new StringBuilder(partnerDomainLinks); +// urlBuilder.append("&TIMESTAMP_LASTCHANGEDON=").append(lastChangeTime); + + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取作用域数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + String dataJson = jsonObject.getStr("data"); + if (dataJson != null && !dataJson.isEmpty()) { + contactList = JSON.parseArray(dataJson, ErpBfPartnerDomainLinksEntity.class); + if (contactList == null) { + contactList = new ArrayList<>(); + } + log.info("成功从ERP获取往来单位作用域数据，数量: {}", contactList.size()); + } else { + log.info("成功从ERP获取往来单位作用域数据，数量: 0"); + } + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个作用域关联 + for (ErpBfPartnerDomainLinksEntity domainLink : contactList) { + domainLink.setPartnerId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在（假设按 partnerId + domainCode 作为唯一标识） + ErpBfPartnerDomainLinksEntity queryParam = new ErpBfPartnerDomainLinksEntity(); + queryParam.setPartnerId(parentId); + queryParam.setVersion(domainLink.getVersion()); + + List existingList = erpBfPartnerDomainLinksMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + domainLink.setId(UUID.randomUUID().toString()); + domainLink.setTimeStampLastChangedOn(now); + toInsert.add(domainLink); + } else { + // 存在则加入更新列表 + ErpBfPartnerDomainLinksEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(domainLink, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + existing.setTimeStampLastChangedOn(now); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpBfPartnerDomainLinksMapper.insertBatchERPBfPartnerDomain(toInsert); + copyBfPartnerDomainLinksMapper.insertBatchERPBfPartnerDomain(toInsert); + log.info("批量新增往来单位作用域关联数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpBfPartnerDomainLinksEntity entity : toUpdate) { + erpBfPartnerDomainLinksMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpBfPartnerDomainLinksEntity entity : toUpdate) { + CopyBfPartnerDomainLinksEntity copyEntity = new CopyBfPartnerDomainLinksEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyBfPartnerDomainLinksEntity copyEntity : copyList) { + copyBfPartnerDomainLinksMapper.updateById(copyEntity); + } + + log.info("批量更新往来单位作用域关联数据，数量: {}", toUpdate.size()); + } + + log.info("往来单位作用域关联数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handleCertificate(ErpBfPartner data, Date time, String parentId) { + StringBuilder urlBuilder = new StringBuilder(partnerCertificateUrl); +// urlBuilder.append("&TIMESTAMP_LASTCHANGEDON=").append(lastChangeTime); + + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取证照数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + String dataJson = jsonObject.getStr("data"); + if (dataJson != null && !dataJson.isEmpty()) { + contactList = JSON.parseArray(dataJson, ErpBfPartnerCertificateEntity.class); + if (contactList == null) { + contactList = new ArrayList<>(); + } + log.info("成功从ERP获取往来单位证照数据，数量: {}", contactList.size()); + } else { + log.info("成功从ERP获取往来单位证照数据，数量: 0"); + } + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个证照 + for (ErpBfPartnerCertificateEntity certificate : contactList) { + certificate.setParentId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在（假设按 parentId + certificateCode 作为唯一标识） + ErpBfPartnerCertificateEntity queryParam = new ErpBfPartnerCertificateEntity(); + queryParam.setParentId(parentId); + queryParam.setCode(certificate.getCode()); + + List existingList = erpBfPartnerCertificateMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + certificate.setId(UUID.randomUUID().toString()); + certificate.setTimeStampLastChangedOn(now); + toInsert.add(certificate); + } else { + // 存在则加入更新列表 + ErpBfPartnerCertificateEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(certificate, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + existing.setTimeStampLastChangedOn(now); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpBfPartnerCertificateMapper.insertBatchERPBfPartnerAttachment(toInsert); + copyBfPartnerCertificateMapper.insertBatchERPBfPartnerAttachment(toInsert); + log.info("批量新增往来单位证照数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpBfPartnerCertificateEntity entity : toUpdate) { + erpBfPartnerCertificateMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpBfPartnerCertificateEntity entity : toUpdate) { + CopyBfPartnerCertificateEntity copyEntity = new CopyBfPartnerCertificateEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyBfPartnerCertificateEntity copyEntity : copyList) { + copyBfPartnerCertificateMapper.updateById(copyEntity); + } + + log.info("批量更新往来单位证照数据，数量: {}", toUpdate.size()); + } + + log.info("往来单位证照数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handleAttachment(ErpBfPartner data, Date time, String parentId) { + StringBuilder urlBuilder = new StringBuilder(attachmentsUrl); + urlBuilder.append("&PARENTID=").append(data.getId()); + + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取附件数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + String dataJson = jsonObject.getStr("data"); + if (dataJson != null && !dataJson.isEmpty()) { + contactList = JSON.parseArray(dataJson, ErpBfPartnerAttachmentEntity.class); + if (contactList == null) { + contactList = new ArrayList<>(); + } + log.info("成功从ERP获取往来单位附件数据，数量: {}", contactList.size()); + } else { + log.info("成功从ERP获取往来单位附件数据，数量: 0"); + } + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个附件 + for (ErpBfPartnerAttachmentEntity attachment : contactList) { + attachment.setParentId(parentId); + + // 按 fileName 查询 ERP 系统中是否已存在 + ErpBfPartnerAttachmentEntity queryParam = new ErpBfPartnerAttachmentEntity(); + queryParam.setFileName(attachment.getFileName()); + queryParam.setParentId(parentId); + + List existingList = erpBfPartnerAttachmentMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + attachment.setId(UUID.randomUUID().toString()); + toInsert.add(attachment); + } else { + // 存在则加入更新列表 + ErpBfPartnerAttachmentEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(attachment, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpBfPartnerAttachmentMapper.insertBatchERPBfPartnerAttachment(toInsert); + copyBfPartnerAttachmentMapper.insertBatchERPBfPartnerAttachment(toInsert); + log.info("批量新增往来单位附件数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpBfPartnerAttachmentEntity entity : toUpdate) { + erpBfPartnerAttachmentMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpBfPartnerAttachmentEntity entity : toUpdate) { + CopyBfPartnerAttachmentEntity copyEntity = new CopyBfPartnerAttachmentEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyBfPartnerAttachmentEntity copyEntity : copyList) { + copyBfPartnerAttachmentMapper.updateById(copyEntity); + } + + log.info("批量更新往来单位附件数据，数量: {}", toUpdate.size()); + } + + log.info("往来单位附件数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private Integer handlePartnerData(ErpBfPartner data, Date time) { if (data == null || data.getCode() == null) { log.warn("往来单位数据为空或缺少编码"); return 0; @@ -238,9 +1787,8 @@ public class ErpBfPartnerServiceImpl extends ServiceImpl() .eq(ErpBfPartner::getCode, data.getCode()) - .eq(ErpBfPartner::getStateIsEnabled, "0") + .eq(ErpBfPartner::getStateIsEnabled, "1") ); - if (targetData == null) { data.setId(UUID.randomUUID().toString()); data.setTimeStampLastChangedOn(new Date()); @@ -288,7 +1836,7 @@ public class ErpBfPartnerServiceImpl extends ServiceImpl existingBackups = erpBfPartnerBackUpMapper.selectList( new LambdaQueryWrapper() .eq(ErpBfPartnerBackupEntity::getCode, targetData.getCode()) - .eq(ErpBfPartnerBackupEntity::getStateIsEnabled, "0") + .eq(ErpBfPartnerBackupEntity::getStateIsEnabled, "1") ); if (CollectionUtils.isEmpty(existingBackups)) { @@ -604,7 +2152,7 @@ public class ErpBfPartnerServiceImpl extends ServiceImpl() .eq(ErpBfPartner::getCode, dcEntity.getCode()) - .eq(ErpBfPartner::getStateIsEnabled, "0") + .eq(ErpBfPartner::getStateIsEnabled, "1") .last("LIMIT 1") ); diff --git a/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/impl/ErpMaterialServiceImpl.java b/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/impl/ErpMaterialServiceImpl.java index af29815..ce44e6a 100644 --- a/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/impl/ErpMaterialServiceImpl.java +++ b/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/impl/ErpMaterialServiceImpl.java @@ -90,7 +90,7 @@ public class ErpMaterialServiceImpl extends ServiceImpl unitMap,Date time) { + log.info("开始处理物料信息数据,data {}", sourceData); + this.handleMaterials(sourceData); + String parentId = this.hanldeMaterialsParentId(sourceData.getId()); + if (parentId == null) + return 0; + this.hanldeUnitArea(sourceData, parentId, unitMap); + this.hanldeMainAux(sourceData, parentId, unitMap); + this.handleConversion(sourceData, parentId, unitMap,time); + this.handleLabel(sourceData, parentId, time); + this.hanldeMeasureUnit(sourceData, parentId, unitMap,time); + this.handlePropsetRel(sourceData, parentId); + this.hadlePropsetValue(sourceData, parentId,time); + this.handleDomainRel(sourceData, parentId,time); + this.handleCategory(sourceData, parentId,time); + this.handleExtend(sourceData, parentId); + this.handleAttachment(sourceData, parentId); + log.info("物料信息同步完成"); + return 1; + } + + private void handleAttachment(ErpMaterialEntity sourceData, String parentId) { + StringBuilder urlBuilder = new StringBuilder(materialAttachment); + urlBuilder.append("&PARENTID=").append(sourceData.getId()); + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料附件数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialAttachmentEntity.class); + log.info("成功从ERP获取物料附件数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个附件 + for (ErpMaterialAttachmentEntity attachment : contactList) { + log.info("开始处理物料附件数据,data {}", attachment); + attachment.setParentId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在（假设按 materialId + fileName 作为唯一标识） + ErpMaterialAttachmentEntity queryParam = new ErpMaterialAttachmentEntity(); + queryParam.setParentId(parentId); + queryParam.setFileName(attachment.getFileName()); + + List existingList = erpMaterialAttachmentMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + attachment.setId(UUID.randomUUID().toString()); + toInsert.add(attachment); + } else { + // 存在则加入更新列表 + ErpMaterialAttachmentEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(attachment, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpMaterialAttachmentMapper.insertBatchERPData(toInsert); + erpMaterialAttachmentMapper.insertBatchERPDataCopy(toInsert); + log.info("批量新增物料附件数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpMaterialAttachmentEntity entity : toUpdate) { + erpMaterialAttachmentMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpMaterialAttachmentEntity entity : toUpdate) { + CopyMaterialAttachmentEntity copyEntity = new CopyMaterialAttachmentEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyMaterialAttachmentEntity copyEntity : copyList) { + copyMaterialAttachmentMapper.updateById(copyEntity); + } + + log.info("批量更新物料附件数据，数量: {}", toUpdate.size()); + } + + log.info("物料附件数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handleExtend(ErpMaterialEntity sourceData, String parentId) { + log.info("开始处理物料自定义拓展数据"); + StringBuilder urlBuilder = new StringBuilder(materialHeadExt); + urlBuilder.append("&MATERIALID=").append(sourceData.getId()); + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料自定义拓展数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialExtendEntity.class); + log.info("成功从ERP获取物料自定义拓展数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个自定义拓展 + for (ErpMaterialExtendEntity extend : contactList) { + log.info("开始处理物料自定义拓展数据,data {}", extend); + extend.setMaterialId(parentId); + +// // 按唯一标识查询 ERP 系统中是否已存在（假设按 materialId 作为唯一标识） +// ErpMaterialExtendEntity queryParam = new ErpMaterialExtendEntity(); +// queryParam.setMaterialId(parentId); +// +// List existingList = erpMaterialExtendMapper.selectERPDataList(queryParam); + +// if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + extend.setId(UUID.randomUUID().toString()); + toInsert.add(extend); +// } else { +// // 存在则加入更新列表 +// ErpMaterialExtendEntity existing = existingList.get(0); +// +// // 复制非空字段到现有记录（忽略 id） +// cn.hutool.core.bean.BeanUtil.copyProperties(extend, existing, +// CopyOptions.create() +// .setIgnoreNullValue(true) +// .setIgnoreError(true) +// .setIgnoreProperties("id") +// ); +// existing.setUpdateTime(now); +// toUpdate.add(existing); +// } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpMaterialExtendMapper.insertBatchERPData(toInsert); + erpMaterialExtendMapper.insertBatchERPDataCopy(toInsert); + log.info("批量新增物料自定义拓展数据，数量: {}", toInsert.size()); + } + +// // 批量更新 +// if (!toUpdate.isEmpty()) { +// // 更新主表 +// for (ErpMaterialExtendEntity entity : toUpdate) { +// erpMaterialExtendMapper.updateById(entity); +// } +// +// // 同步到备份表 +// List copyList = new ArrayList<>(); +// for (ErpMaterialExtendEntity entity : toUpdate) { +// CopyMaterialExtendEntity copyEntity = new CopyMaterialExtendEntity(); +// cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, +// CopyOptions.create() +// .setIgnoreNullValue(true) +// .setIgnoreError(true) +// ); +// copyList.add(copyEntity); +// } +// +// for (CopyMaterialExtendEntity copyEntity : copyList) { +// copyMaterialExtendMapper.updateById(copyEntity); +// } +// +// log.info("批量更新物料自定义拓展数据，数量: {}", toUpdate.size()); +// } +// +// log.info("物料自定义拓展数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handleCategory(ErpMaterialEntity sourceData, String parentId,Date time ) { + + StringBuilder urlBuilder = new StringBuilder(materialCustomizedType); + urlBuilder.append("&MATERIALID=").append(sourceData.getId()); + if (time != null) { + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + String lastChangeTime = sdf.format(time); + try { + String encodeTime = java.net.URLEncoder.encode(lastChangeTime, "UTF-8"); + urlBuilder.append("&TIMESTAMP_LASTCHANGEDON=").append(encodeTime); + } catch (UnsupportedEncodingException e) { + log.error("时间编码失败", e); + } + } + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料自定义分类数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialDefineCategoryEntity.class); + log.info("成功从ERP获取物料自定义分类数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个自定义分类 + for (ErpMaterialDefineCategoryEntity category : contactList) { + log.info("开始处理物料自定义分类数据,data {}", category); + category.setMaterialId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在（假设按 materialId + categoryId 作为唯一标识） + ErpMaterialDefineCategoryEntity queryParam = new ErpMaterialDefineCategoryEntity(); + queryParam.setMaterialId(parentId); + queryParam.setCode(category.getCode()); + + List existingList = erpMaterialDefineCategoryMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + category.setId(UUID.randomUUID().toString()); + toInsert.add(category); + } else { + // 存在则加入更新列表 + ErpMaterialDefineCategoryEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(category, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpMaterialDefineCategoryMapper.insertBatchERPData(toInsert); + erpMaterialDefineCategoryMapper.insertBatchERPDataCopy(toInsert); + log.info("批量新增物料自定义分类数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpMaterialDefineCategoryEntity entity : toUpdate) { + erpMaterialDefineCategoryMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpMaterialDefineCategoryEntity entity : toUpdate) { + CopyMaterialDefineCategoryEntity copyEntity = new CopyMaterialDefineCategoryEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyMaterialDefineCategoryEntity copyEntity : copyList) { + copyMaterialDefineCategoryMapper.updateById(copyEntity); + } + + log.info("批量更新物料自定义分类数据，数量: {}", toUpdate.size()); + } + + log.info("物料自定义分类数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handleDomainRel(ErpMaterialEntity sourceData, String parentId,Date time) { + + StringBuilder urlBuilder = new StringBuilder(materialDomainLinks); + urlBuilder.append("&MATERIALID=").append(sourceData.getId()); + if (time != null) { + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + String lastChangeTime = sdf.format(time); + try { + String encodeTime = java.net.URLEncoder.encode(lastChangeTime, "UTF-8"); + urlBuilder.append("&TIMASTAMP_LASTCHANGEDON=").append(encodeTime); + } catch (UnsupportedEncodingException e) { + log.error("时间编码失败", e); + } + } + String finalUrl = urlBuilder.toString(); + + Map headers = new HashMap<>(); + String getResult = null; + try { + getResult = HttpUtils.doGet(finalUrl, headers); + } catch (IOException e) { + log.error("调用ERP接口失败，URL: {}", finalUrl, e); + throw new RuntimeException("调用ERP接口失败: " + e.getMessage(), e); + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialDomainRelEntity.class); + log.info("成功从ERP获取物料信息作用域关联数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个作用域关联 + for (ErpMaterialDomainRelEntity domainRel : contactList) { + log.info("开始处理物料信息作用域关联数据,data {}", domainRel); + domainRel.setMaterialId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在（假设按 materialId + domainId 作为唯一标识） + ErpMaterialDomainRelEntity queryParam = new ErpMaterialDomainRelEntity(); + queryParam.setMaterialId(domainRel.getMaterialId()); + queryParam.setDomainId(domainRel.getDomainId()); + + List existingList = erpMaterialDomainRelMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + domainRel.setId(UUID.randomUUID().toString()); + toInsert.add(domainRel); + } else { + // 存在则加入更新列表 + ErpMaterialDomainRelEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(domainRel, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpMaterialDomainRelMapper.insertBatchERPData(toInsert); + erpMaterialDomainRelMapper.insertBatchERPDataCopy(toInsert); + log.info("批量新增物料作用域关联数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpMaterialDomainRelEntity entity : toUpdate) { + erpMaterialDomainRelMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpMaterialDomainRelEntity entity : toUpdate) { + CopyMaterialDomainRelEntity copyEntity = new CopyMaterialDomainRelEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyMaterialDomainRelEntity copyEntity : copyList) { + copyMaterialDomainRelMapper.updateById(copyEntity); + } + + log.info("批量更新物料作用域关联数据，数量: {}", toUpdate.size()); + } + + log.info("物料作用域关联数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void hadlePropsetValue(ErpMaterialEntity sourceData, String parentId,Date time) { + log.info("开始处理物料征集结果数据"); + StringBuilder urlBuilder = new StringBuilder(materialPropValue); + urlBuilder.append("&PARENTID=").append(sourceData.getId()); + if (time != null) { + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + String lastChangeTime = sdf.format(time); + try { + String encodeTime = java.net.URLEncoder.encode(lastChangeTime, "UTF-8"); + urlBuilder.append("&TIMESTAMP_LASTCHANGEDON=").append(encodeTime); + } catch (UnsupportedEncodingException e) { + log.error("时间编码失败", e); + } + } + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料征集结果数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialPropValueEntity.class); + log.info("成功从ERP获取物料征集结果数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个征集结果 + for (ErpMaterialPropValueEntity propValue : contactList) { + propValue.setParentId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在（假设按 materialId + propValueId 作为唯一标识） + ErpMaterialPropValueEntity queryParam = new ErpMaterialPropValueEntity(); + queryParam.setParentId(parentId); + queryParam.setPropId(propValue.getPropId()); + + List existingList = erpMaterialPropValueMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + propValue.setId(UUID.randomUUID().toString()); + toInsert.add(propValue); + } else { + // 存在则加入更新列表 + ErpMaterialPropValueEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(propValue, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpMaterialPropValueMapper.insertBatchERPData(toInsert); + erpMaterialPropValueMapper.insertBatchERPDataCopy(toInsert); + log.info("批量新增物料征集结果数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpMaterialPropValueEntity entity : toUpdate) { + erpMaterialPropValueMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpMaterialPropValueEntity entity : toUpdate) { + CopyMaterialPropValueEntity copyEntity = new CopyMaterialPropValueEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyMaterialPropValueEntity copyEntity : copyList) { + copyMaterialPropValueMapper.updateById(copyEntity); + } + + log.info("批量更新物料征集结果数据，数量: {}", toUpdate.size()); + } + + log.info("物料征集结果数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handlePropsetRel(ErpMaterialEntity sourceData, String parentId) { + + StringBuilder urlBuilder = new StringBuilder(materialPropSetLink); + urlBuilder.append("&PARENTID=").append(sourceData.getId()); + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料征集关联数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialPropsetRelEntity.class); + log.info("成功从ERP获取物料征集关联数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个征集关联 + for (ErpMaterialPropsetRelEntity propsetRel : contactList) { + log.info("开始同步物料征集关联数据,data {}", propsetRel); + propsetRel.setParentId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在 + ErpMaterialPropsetRelEntity queryParam = new ErpMaterialPropsetRelEntity(); + queryParam.setParentId(parentId); + queryParam.setPropSetId(propsetRel.getPropSetId()); + + List existingList = erpMaterialPropsetRelMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + propsetRel.setId(UUID.randomUUID().toString()); + toInsert.add(propsetRel); + } else { + // 存在则加入更新列表 + ErpMaterialPropsetRelEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(propsetRel, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpMaterialPropsetRelMapper.insertBatchERPData(toInsert); + erpMaterialPropsetRelMapper.insertBatchERPDataCopy(toInsert); + log.info("批量新增物料征集关联数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpMaterialPropsetRelEntity entity : toUpdate) { + erpMaterialPropsetRelMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpMaterialPropsetRelEntity entity : toUpdate) { + CopyMaterialPropsetRelEntity copyEntity = new CopyMaterialPropsetRelEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyMaterialPropsetRelEntity copyEntity : copyList) { + copyMaterialPropsetRelMapper.updateById(copyEntity); + } + + log.info("批量更新物料征集关联数据，数量: {}", toUpdate.size()); + } + + log.info("物料征集关联数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void hanldeMeasureUnit(ErpMaterialEntity sourceData, String parentId, Map unitMap,Date time) { + StringBuilder urlBuilder = new StringBuilder(bfMaterialMeasureUnit); + urlBuilder.append("&PARENTID=").append(sourceData.getId()); + if (time != null) { + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + String lastChangeTime = sdf.format(time); + try { + String encodeTime = java.net.URLEncoder.encode(lastChangeTime, "UTF-8"); + urlBuilder.append("&TIMESTAMP_LASTCHANGEDON=").append(encodeTime); + } catch (UnsupportedEncodingException e) { + log.error("时间编码失败", e); + } + } + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料计量单位数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialMeasureunitEntity.class); + log.info("成功从ERP获取物料计量单位数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个计量单位 + for (ErpMaterialMeasureunitEntity measureunit : contactList) { + log.info("开始处理物料计量单位数据,data {}", measureunit); + measureunit.setParentId(parentId); + if (measureunit.getMaterialMeasureUnit() != null && unitMap.containsKey(measureunit.getMaterialMeasureUnit())) { + measureunit.setMaterialMeasureUnit(unitMap.get(measureunit.getMaterialMeasureUnit())); + } +// +// // 按唯一标识查询 ERP 系统中是否已存在（假设按 materialId + unitId 作为唯一标识） +// ErpMaterialMeasureunitEntity queryParam = new ErpMaterialMeasureunitEntity(); +// queryParam.setParentId(parentId); +// queryParam.setUnitId(measureunit.getUnitId()); +// +// List existingList = erpMaterialMeasureunitMapper.selectERPDataList(queryParam); + +// if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + measureunit.setId(UUID.randomUUID().toString()); + toInsert.add(measureunit); +// } else { +// // 存在则加入更新列表 +// ErpMaterialMeasureunitEntity existing = existingList.get(0); +// +// // 复制非空字段到现有记录（忽略 id） +// cn.hutool.core.bean.BeanUtil.copyProperties(measureunit, existing, +// CopyOptions.create() +// .setIgnoreNullValue(true) +// .setIgnoreError(true) +// .setIgnoreProperties("id") +// ); +// existing.setUpdateTime(now); +// toUpdate.add(existing); +// } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpMaterialMeasureunitMapper.insertBatchERPData(toInsert); + erpMaterialMeasureunitMapper.insertBatchERPBDataCopy(toInsert); + log.info("批量新增物料计量单位数据，数量: {}", toInsert.size()); + } + +// // 批量更新 +// if (!toUpdate.isEmpty()) { +// // 更新主表 +// for (ErpMaterialMeasureunitEntity entity : toUpdate) { +// erpMaterialMeasureunitMapper.updateById(entity); +// } +// +// // 同步到备份表 +// List copyList = new ArrayList<>(); +// for (ErpMaterialMeasureunitEntity entity : toUpdate) { +// CopyMaterialMeasureunitEntity copyEntity = new CopyMaterialMeasureunitEntity(); +// cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, +// CopyOptions.create() +// .setIgnoreNullValue(true) +// .setIgnoreError(true) +// ); +// copyList.add(copyEntity); +// } +// +// for (CopyMaterialMeasureunitEntity copyEntity : copyList) { +// copyMaterialMeasureunitMapper.updateById(copyEntity); +// } +// +// log.info("批量更新物料计量单位数据，数量: {}", toUpdate.size()); +// } +// +// log.info("物料计量单位数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handleLabel(ErpMaterialEntity sourceData, String parentId,Date time) { + StringBuilder urlBuilder = new StringBuilder(materialLabel); + urlBuilder.append("&PARENTID=").append(sourceData.getId()); + if (time != null) { + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + String lastChangeTime = sdf.format(time); + try { + String encodeTime = java.net.URLEncoder.encode(lastChangeTime, "UTF-8"); + urlBuilder.append("&TIMESTAMP_LASTCHANGEDON=").append(encodeTime); + } catch (UnsupportedEncodingException e) { + log.error("时间编码失败", e); + } + } + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料标签数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialLabelEntity.class); + log.info("成功从ERP获取物料标签数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + // 处理每个标签 + for (ErpMaterialLabelEntity label : contactList) { + log.info("开始处理物料标签数据,data {}", label); + label.setParentId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在（假设按 materialId + labelId 作为唯一标识） + ErpMaterialLabelEntity queryParam = new ErpMaterialLabelEntity(); + queryParam.setParentId(parentId); + queryParam.setMaterialLabel(label.getMaterialLabel()); + + List existingList = erpMaterialLabelMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + label.setId(UUID.randomUUID().toString()); + toInsert.add(label); + } else { + // 存在则加入更新列表 + ErpMaterialLabelEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(label, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpMaterialLabelMapper.insertBatchERPBData(toInsert); + erpMaterialLabelMapper.insertBatchERPBDataCopy(toInsert); + log.info("批量新增物料标签数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpMaterialLabelEntity entity : toUpdate) { + erpMaterialLabelMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpMaterialLabelEntity entity : toUpdate) { + CopyMaterialLabelEntity copyEntity = new CopyMaterialLabelEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyMaterialLabelEntity copyEntity : copyList) { + copyMaterialLabelMapper.updateById(copyEntity); + } + + log.info("批量更新物料标签数据，数量: {}", toUpdate.size()); + } + + log.info("物料标签数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handleConversion(ErpMaterialEntity sourceData, String parentId, Map unitMap,Date time) { + log.info("开始处理物料换算率数据"); + StringBuilder urlBuilder = new StringBuilder(materialConvRatio); + urlBuilder.append("&PARENTID=").append(sourceData.getId()); + if (time != null) { + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + String lastChangeTime = sdf.format(time); + try { + String encodeTime = java.net.URLEncoder.encode(lastChangeTime, "UTF-8"); + urlBuilder.append("&TIMESTAMP_LASTCHANGEDON=").append(encodeTime); + } catch (UnsupportedEncodingException e) { + log.error("时间编码失败", e); + } + } + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料换算率数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialConversionEntity.class); + log.info("成功从ERP获取物料换算率数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + List insertList = new ArrayList<>(); + // 处理每个换算率 + for (ErpMaterialConversionEntity conversion : contactList) { + conversion.setParentId(parentId); + if (conversion.getMeasureUnit1() != null && unitMap.containsKey(conversion.getMeasureUnit1())) { + conversion.setMeasureUnit1(unitMap.get(conversion.getMeasureUnit1())); + } + if (conversion.getMeasureUnit2() != null && unitMap.containsKey(conversion.getMeasureUnit2())) { + conversion.setMeasureUnit2(unitMap.get(conversion.getMeasureUnit2())); + } + // 不存在则新增 + conversion.setId(UUID.randomUUID().toString()); + + insertList.add(conversion); + } + if (CollectionUtils.isEmpty(insertList)) + return; + erpMaterialConversionMapper.insertBatchERPBData(insertList); + copyMaterialConversionMapper.insertBatchERPBData(insertList); + + log.info("新增换算率数据，数量: {}", + insertList.size()); + + } + + private void hanldeMainAux(ErpMaterialEntity data, String parentId, Map unitMap) { + log.info("开始同步物料主辅计量"); + StringBuilder urlBuilder = new StringBuilder(mainAux); + urlBuilder.append("&MATERIALID=").append(data.getId()); + + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料主辅计量数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialUnitAreaMainAuxEntity.class); + log.info("成功从ERP获取物料主辅计量数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个主辅计量单位 + for (ErpMaterialUnitAreaMainAuxEntity mainAux : contactList) { + mainAux.setMaterialId(parentId); + + // 转换单位ID + if (mainAux.getAuxUnitId() != null && unitMap.containsKey(mainAux.getAuxUnitId())) { + mainAux.setAuxUnitId(unitMap.get(mainAux.getAuxUnitId())); + } + if (mainAux.getMainUnitId() != null && unitMap.containsKey(mainAux.getMainUnitId())) { + mainAux.setMainUnitId(unitMap.get(mainAux.getMainUnitId())); + } + + // 按唯一标识查询 ERP 系统中是否已存在 + ErpMaterialUnitAreaMainAuxEntity queryParam = new ErpMaterialUnitAreaMainAuxEntity(); + queryParam.setMaterialId(mainAux.getMaterialId()); + queryParam.setVersion(mainAux.getVersion()); + + List existingList = erpMaterialUnitAreaMainAuxMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + mainAux.setId(UUID.randomUUID().toString()); + toInsert.add(mainAux); + } else { + // 存在则加入更新列表 + ErpMaterialUnitAreaMainAuxEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(mainAux, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpMaterialUnitAreaMainAuxMapper.insertBatchERPData(toInsert); + copyMaterialUnitAreaMainAuxMapper.insertBatchERPData(toInsert); + log.info("批量新增物料主辅计量单位数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpMaterialUnitAreaMainAuxEntity entity : toUpdate) { + erpMaterialUnitAreaMainAuxMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpMaterialUnitAreaMainAuxEntity entity : toUpdate) { + CopyMaterialUnitAreaMainAuxEntity copyEntity = new CopyMaterialUnitAreaMainAuxEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyMaterialUnitAreaMainAuxEntity copyEntity : copyList) { + copyMaterialUnitAreaMainAuxMapper.updateById(copyEntity); + } + + log.info("批量更新物料主辅计量单位数据，数量: {}", toUpdate.size()); + } + + log.info("物料主辅计量单位数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void hanldeUnitArea(ErpMaterialEntity data, String parentId, Map unitMap) { + log.info("开始同步物料范围计量单位"); + StringBuilder urlBuilder = new StringBuilder(materialUnitByArea); + urlBuilder.append("&MATERIALID=").append(data.getId()); + + + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料范围计量单位数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialUnitAreaEntity.class); + log.info("成功从ERP获取物料范围计量单位数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个范围计量单位 + for (ErpMaterialUnitAreaEntity unitArea : contactList) { + // 转换单位ID + if (unitArea.getUnitId() != null && unitMap.containsKey(unitArea.getUnitId())) { + unitArea.setUnitId(unitMap.get(unitArea.getUnitId())); + } + + unitArea.setMaterialId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在 + ErpMaterialUnitAreaEntity queryParam = new ErpMaterialUnitAreaEntity(); + queryParam.setMaterialId(parentId); + queryParam.setUnitId(unitArea.getUnitId()); + + List existingList = erpMaterialUnitAreaMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + unitArea.setId(UUID.randomUUID().toString()); + toInsert.add(unitArea); + } else { + // 存在则加入更新列表 + ErpMaterialUnitAreaEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(unitArea, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + erpMaterialUnitAreaMapper.insertBatchERPBfPartnerAdress(toInsert); + copyMaterialUnitAreaMapper.insertBatchERPBfPartnerAdress(toInsert); + log.info("批量新增物料范围计量单位数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpMaterialUnitAreaEntity entity : toUpdate) { + erpMaterialUnitAreaMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpMaterialUnitAreaEntity entity : toUpdate) { + CopyMaterialUnitAreaEntity copyEntity = new CopyMaterialUnitAreaEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyMaterialUnitAreaEntity copyEntity : copyList) { + copyMaterialUnitAreaMapper.updateById(copyEntity); + } + + log.info("批量更新物料范围计量单位数据，数量: {}", toUpdate.size()); + } + + log.info("物料范围计量单位数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private Integer handleMaterials(ErpMaterialEntity sourceData) { if (sourceData == null || sourceData.getCode() == null) { log.warn("物料数据为空或缺少编码"); return 0; @@ -215,12 +1706,13 @@ public class ErpMaterialServiceImpl extends ServiceImpl() .eq(ErpMaterialEntity::getCode, sourceData.getCode()) - .eq(ErpMaterialEntity::getStateIsEnabled, "0") + .eq(ErpMaterialEntity::getStateIsEnabled, "1") ); CopyMaterialEntity copyMaterialEntity = new CopyMaterialEntity(); if (targetData == null) { + String dcId = sourceData.getId(); sourceData.setId(String.valueOf(UUID.randomUUID())); sourceData.setTimeStampLastChangedOn(new Date()); @@ -234,7 +1726,14 @@ public class ErpMaterialServiceImpl extends ServiceImpl existingBackups = erpMaterialBackUpMapper.selectList( new LambdaQueryWrapper() .eq(ErpMaterialBackUpEntity::getCode, sourceData.getCode()) - .eq(ErpMaterialBackUpEntity::getStateIsEnabled, "0") + .eq(ErpMaterialBackUpEntity::getStateIsEnabled, "1") ); if (CollectionUtils.isEmpty(existingBackups)) { @@ -422,7 +1921,7 @@ public class ErpMaterialServiceImpl extends ServiceImpl() .eq(ErpMaterialEntity::getCode, dcEntity.getCode()) - .eq(ErpMaterialEntity::getStateIsEnabled, "0") + .eq(ErpMaterialEntity::getStateIsEnabled, "1") .last("LIMIT 1") ); @@ -839,7 +2338,7 @@ public class ErpMaterialServiceImpl extends ServiceImpl DCContactList = erpMaterialMeasureunitMapper.selectERPDataList(data); if (CollectionUtils.isEmpty(DCContactList)) { @@ -848,7 +2347,7 @@ public class ErpMaterialServiceImpl extends ServiceImpl DCContactList = erpMaterialExtendMapper.selectERPDataList(data); if (CollectionUtils.isEmpty(DCContactList)) { @@ -1351,7 +2850,7 @@ public class ErpMaterialServiceImpl extends ServiceImpl() .eq(ErpBfPartner::getCode, data.getCode()) - .eq(ErpBfPartner::getStateIsEnabled, "0") + .eq(ErpBfPartner::getStateIsEnabled, "1") ); if (targetData == null) { @@ -921,7 +921,7 @@ public class SalesBfPartnerServiceImpl extends ServiceImpl existingBackups = salesBfPartnerBackUpMapper.selectList( new LambdaQueryWrapper() .eq(ErpBfPartnerBackupEntity::getCode, targetData.getCode()) - .eq(ErpBfPartnerBackupEntity::getStateIsEnabled, "0") + .eq(ErpBfPartnerBackupEntity::getStateIsEnabled, "1") ); if (CollectionUtils.isEmpty(existingBackups)) { @@ -1213,7 +1213,7 @@ public class SalesBfPartnerServiceImpl extends ServiceImpl() .eq(ErpBfPartner::getCode, dcEntity.getCode()) - .eq(ErpBfPartner::getStateIsEnabled, "0") + .eq(ErpBfPartner::getStateIsEnabled, "1") .last("LIMIT 1") ); diff --git a/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/impl/SalesMaterialServiceImpl.java b/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/impl/SalesMaterialServiceImpl.java index d63f366..6bf1674 100644 --- a/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/impl/SalesMaterialServiceImpl.java +++ b/lidee-core/src/main/java/com/lideeyunji/core/framework/service/erp/impl/SalesMaterialServiceImpl.java @@ -350,7 +350,1433 @@ public class SalesMaterialServiceImpl extends ServiceImpl unitMap) { + log.info("开始处理物料信息数据,data {}", sourceData); + this.handleMaterials(sourceData); + String parentId = this.hanldeMaterialsParentId(sourceData.getId()); + if (parentId == null) + return 0; + this.hanldeUnitArea(sourceData, parentId, unitMap); + this.hanldeMainAux(sourceData, parentId, unitMap); + this.handleConversion(sourceData, parentId, unitMap); + this.handleLabel(sourceData, parentId); + this.hanldeMeasureUnit(sourceData, parentId, unitMap); + this.handlePropsetRel(sourceData, parentId); + this.hadlePropsetValue(sourceData, parentId); + this.handleDomainRel(sourceData, parentId); + this.handleCategory(sourceData, parentId); + this.handleExtend(sourceData, parentId); + this.handleAttachment(sourceData, parentId); + log.info("物料信息同步完成"); + return 1; + } + + private void handleAttachment(ErpMaterialEntity sourceData, String parentId) { + StringBuilder urlBuilder = new StringBuilder(materialAttachment); + urlBuilder.append("&PARENTID=").append(sourceData.getId()); + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料附件数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialAttachmentEntity.class); + log.info("成功从ERP获取物料附件数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个附件 + for (ErpMaterialAttachmentEntity attachment : contactList) { + log.info("开始处理物料附件数据,data {}", attachment); + attachment.setParentId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在（假设按 materialId + fileName 作为唯一标识） + ErpMaterialAttachmentEntity queryParam = new ErpMaterialAttachmentEntity(); + queryParam.setParentId(parentId); + queryParam.setFileName(attachment.getFileName()); + + List existingList = salesMaterialAttachmentMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + attachment.setId(UUID.randomUUID().toString()); + toInsert.add(attachment); + } else { + // 存在则加入更新列表 + ErpMaterialAttachmentEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(attachment, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + salesMaterialAttachmentMapper.insertBatchERPData(toInsert); + salesMaterialAttachmentMapper.insertBatchERPDataCopy(toInsert); + log.info("批量新增物料附件数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpMaterialAttachmentEntity entity : toUpdate) { + salesMaterialAttachmentMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpMaterialAttachmentEntity entity : toUpdate) { + CopyMaterialAttachmentEntity copyEntity = new CopyMaterialAttachmentEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyMaterialAttachmentEntity copyEntity : copyList) { + copySalesMaterialAttachmentMapper.updateById(copyEntity); + } + + log.info("批量更新物料附件数据，数量: {}", toUpdate.size()); + } + + log.info("物料附件数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handleExtend(ErpMaterialEntity sourceData, String parentId) { + log.info("开始处理物料自定义拓展数据"); + StringBuilder urlBuilder = new StringBuilder(materialHeadExt); + urlBuilder.append("&MATERIALID=").append(sourceData.getId()); + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料自定义拓展数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialExtendEntity.class); + log.info("成功从ERP获取物料自定义拓展数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个自定义拓展 + for (ErpMaterialExtendEntity extend : contactList) { + log.info("开始处理物料自定义拓展数据,data {}", extend); + extend.setMaterialId(parentId); + +// // 按唯一标识查询 ERP 系统中是否已存在（假设按 materialId 作为唯一标识） +// ErpMaterialExtendEntity queryParam = new ErpMaterialExtendEntity(); +// queryParam.setMaterialId(parentId); +// +// List existingList = erpMaterialExtendMapper.selectERPDataList(queryParam); + +// if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + extend.setId(UUID.randomUUID().toString()); + toInsert.add(extend); +// } else { +// // 存在则加入更新列表 +// ErpMaterialExtendEntity existing = existingList.get(0); +// +// // 复制非空字段到现有记录（忽略 id） +// cn.hutool.core.bean.BeanUtil.copyProperties(extend, existing, +// CopyOptions.create() +// .setIgnoreNullValue(true) +// .setIgnoreError(true) +// .setIgnoreProperties("id") +// ); +// existing.setUpdateTime(now); +// toUpdate.add(existing); +// } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + salesMaterialExtendMapper.insertBatchERPData(toInsert); + salesMaterialExtendMapper.insertBatchERPDataCopy(toInsert); + log.info("批量新增物料自定义拓展数据，数量: {}", toInsert.size()); + } + +// // 批量更新 +// if (!toUpdate.isEmpty()) { +// // 更新主表 +// for (ErpMaterialExtendEntity entity : toUpdate) { +// erpMaterialExtendMapper.updateById(entity); +// } +// +// // 同步到备份表 +// List copyList = new ArrayList<>(); +// for (ErpMaterialExtendEntity entity : toUpdate) { +// CopyMaterialExtendEntity copyEntity = new CopyMaterialExtendEntity(); +// cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, +// CopyOptions.create() +// .setIgnoreNullValue(true) +// .setIgnoreError(true) +// ); +// copyList.add(copyEntity); +// } +// +// for (CopyMaterialExtendEntity copyEntity : copyList) { +// copyMaterialExtendMapper.updateById(copyEntity); +// } +// +// log.info("批量更新物料自定义拓展数据，数量: {}", toUpdate.size()); +// } +// +// log.info("物料自定义拓展数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handleCategory(ErpMaterialEntity sourceData, String parentId) { + + StringBuilder urlBuilder = new StringBuilder(materialCustomizedType); + urlBuilder.append("&MATERIALID=").append(sourceData.getId()); + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料自定义分类数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialDefineCategoryEntity.class); + log.info("成功从ERP获取物料自定义分类数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个自定义分类 + for (ErpMaterialDefineCategoryEntity category : contactList) { + log.info("开始处理物料自定义分类数据,data {}", category); + category.setMaterialId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在（假设按 materialId + categoryId 作为唯一标识） + ErpMaterialDefineCategoryEntity queryParam = new ErpMaterialDefineCategoryEntity(); + queryParam.setMaterialId(parentId); + queryParam.setCode(category.getCode()); + + List existingList = salesMaterialDefineCategoryMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + category.setId(UUID.randomUUID().toString()); + toInsert.add(category); + } else { + // 存在则加入更新列表 + ErpMaterialDefineCategoryEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(category, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + salesMaterialDefineCategoryMapper.insertBatchERPData(toInsert); + salesMaterialDefineCategoryMapper.insertBatchERPDataCopy(toInsert); + log.info("批量新增物料自定义分类数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpMaterialDefineCategoryEntity entity : toUpdate) { + salesMaterialDefineCategoryMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpMaterialDefineCategoryEntity entity : toUpdate) { + CopyMaterialDefineCategoryEntity copyEntity = new CopyMaterialDefineCategoryEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyMaterialDefineCategoryEntity copyEntity : copyList) { + copySalesMaterialDefineCategoryMapper.updateById(copyEntity); + } + + log.info("批量更新物料自定义分类数据，数量: {}", toUpdate.size()); + } + + log.info("物料自定义分类数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handleDomainRel(ErpMaterialEntity sourceData, String parentId) { + + StringBuilder urlBuilder = new StringBuilder(materialDomainLinks); + urlBuilder.append("&MATERIALID=").append(sourceData.getId()); + String finalUrl = urlBuilder.toString(); + + Map headers = new HashMap<>(); + String getResult = null; + try { + getResult = HttpUtils.doGet(finalUrl, headers); + } catch (IOException e) { + log.error("调用ERP接口失败，URL: {}", finalUrl, e); + throw new RuntimeException("调用ERP接口失败: " + e.getMessage(), e); + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialDomainRelEntity.class); + log.info("成功从ERP获取物料信息作用域关联数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个作用域关联 + for (ErpMaterialDomainRelEntity domainRel : contactList) { + log.info("开始处理物料信息作用域关联数据,data {}", domainRel); + domainRel.setMaterialId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在（假设按 materialId + domainId 作为唯一标识） + ErpMaterialDomainRelEntity queryParam = new ErpMaterialDomainRelEntity(); + queryParam.setMaterialId(domainRel.getMaterialId()); + queryParam.setDomainId(domainRel.getDomainId()); + + List existingList = salesMaterialDomainRelMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + domainRel.setId(UUID.randomUUID().toString()); + toInsert.add(domainRel); + } else { + // 存在则加入更新列表 + ErpMaterialDomainRelEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(domainRel, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + salesMaterialDomainRelMapper.insertBatchERPData(toInsert); + salesMaterialDomainRelMapper.insertBatchERPDataCopy(toInsert); + log.info("批量新增物料作用域关联数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpMaterialDomainRelEntity entity : toUpdate) { + salesMaterialDomainRelMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpMaterialDomainRelEntity entity : toUpdate) { + CopyMaterialDomainRelEntity copyEntity = new CopyMaterialDomainRelEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyMaterialDomainRelEntity copyEntity : copyList) { + copySalesMaterialDomainRelMapper.updateById(copyEntity); + } + + log.info("批量更新物料作用域关联数据，数量: {}", toUpdate.size()); + } + + log.info("物料作用域关联数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void hadlePropsetValue(ErpMaterialEntity sourceData, String parentId) { + log.info("开始处理物料征集结果数据"); + StringBuilder urlBuilder = new StringBuilder(materialPropValue); + urlBuilder.append("&PARENTID=").append(sourceData.getId()); + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料征集结果数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialPropValueEntity.class); + log.info("成功从ERP获取物料征集结果数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个征集结果 + for (ErpMaterialPropValueEntity propValue : contactList) { + propValue.setParentId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在（假设按 materialId + propValueId 作为唯一标识） + ErpMaterialPropValueEntity queryParam = new ErpMaterialPropValueEntity(); + queryParam.setParentId(parentId); + queryParam.setPropId(propValue.getPropId()); + + List existingList = salesMaterialPropValueMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + propValue.setId(UUID.randomUUID().toString()); + toInsert.add(propValue); + } else { + // 存在则加入更新列表 + ErpMaterialPropValueEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(propValue, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + salesMaterialPropValueMapper.insertBatchERPData(toInsert); + salesMaterialPropValueMapper.insertBatchERPDataCopy(toInsert); + log.info("批量新增物料征集结果数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpMaterialPropValueEntity entity : toUpdate) { + salesMaterialPropValueMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpMaterialPropValueEntity entity : toUpdate) { + CopyMaterialPropValueEntity copyEntity = new CopyMaterialPropValueEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyMaterialPropValueEntity copyEntity : copyList) { + copySalesMaterialPropValueMapper.updateById(copyEntity); + } + + log.info("批量更新物料征集结果数据，数量: {}", toUpdate.size()); + } + + log.info("物料征集结果数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handlePropsetRel(ErpMaterialEntity sourceData, String parentId) { + + StringBuilder urlBuilder = new StringBuilder(materialPropSetLink); + urlBuilder.append("&PARENTID=").append(sourceData.getId()); + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料征集关联数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialPropsetRelEntity.class); + log.info("成功从ERP获取物料征集关联数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个征集关联 + for (ErpMaterialPropsetRelEntity propsetRel : contactList) { + log.info("开始同步物料征集关联数据,data {}", propsetRel); + propsetRel.setParentId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在 + ErpMaterialPropsetRelEntity queryParam = new ErpMaterialPropsetRelEntity(); + queryParam.setParentId(parentId); + queryParam.setPropSetId(propsetRel.getPropSetId()); + + List existingList = salesMaterialPropsetRelMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + propsetRel.setId(UUID.randomUUID().toString()); + toInsert.add(propsetRel); + } else { + // 存在则加入更新列表 + ErpMaterialPropsetRelEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(propsetRel, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + salesMaterialPropsetRelMapper.insertBatchERPData(toInsert); + salesMaterialPropsetRelMapper.insertBatchERPDataCopy(toInsert); + log.info("批量新增物料征集关联数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpMaterialPropsetRelEntity entity : toUpdate) { + salesMaterialPropsetRelMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpMaterialPropsetRelEntity entity : toUpdate) { + CopyMaterialPropsetRelEntity copyEntity = new CopyMaterialPropsetRelEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyMaterialPropsetRelEntity copyEntity : copyList) { + copySalesMaterialPropsetRelMapper.updateById(copyEntity); + } + + log.info("批量更新物料征集关联数据，数量: {}", toUpdate.size()); + } + + log.info("物料征集关联数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void hanldeMeasureUnit(ErpMaterialEntity sourceData, String parentId, Map unitMap) { + StringBuilder urlBuilder = new StringBuilder(bfMaterialMeasureUnit); + urlBuilder.append("&PARENTID=").append(sourceData.getId()); + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料计量单位数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialMeasureunitEntity.class); + log.info("成功从ERP获取物料计量单位数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个计量单位 + for (ErpMaterialMeasureunitEntity measureunit : contactList) { + log.info("开始处理物料计量单位数据,data {}", measureunit); + measureunit.setParentId(parentId); + if (measureunit.getMaterialMeasureUnit() != null && unitMap.containsKey(measureunit.getMaterialMeasureUnit())) { + measureunit.setMaterialMeasureUnit(unitMap.get(measureunit.getMaterialMeasureUnit())); + } +// +// // 按唯一标识查询 ERP 系统中是否已存在（假设按 materialId + unitId 作为唯一标识） +// ErpMaterialMeasureunitEntity queryParam = new ErpMaterialMeasureunitEntity(); +// queryParam.setParentId(parentId); +// queryParam.setUnitId(measureunit.getUnitId()); +// +// List existingList = erpMaterialMeasureunitMapper.selectERPDataList(queryParam); + +// if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + measureunit.setId(UUID.randomUUID().toString()); + toInsert.add(measureunit); +// } else { +// // 存在则加入更新列表 +// ErpMaterialMeasureunitEntity existing = existingList.get(0); +// +// // 复制非空字段到现有记录（忽略 id） +// cn.hutool.core.bean.BeanUtil.copyProperties(measureunit, existing, +// CopyOptions.create() +// .setIgnoreNullValue(true) +// .setIgnoreError(true) +// .setIgnoreProperties("id") +// ); +// existing.setUpdateTime(now); +// toUpdate.add(existing); +// } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + salesMaterialMeasureunitMapper.insertBatchERPData(toInsert); + salesMaterialMeasureunitMapper.insertBatchERPDataCopy(toInsert); + log.info("批量新增物料计量单位数据，数量: {}", toInsert.size()); + } + +// // 批量更新 +// if (!toUpdate.isEmpty()) { +// // 更新主表 +// for (ErpMaterialMeasureunitEntity entity : toUpdate) { +// erpMaterialMeasureunitMapper.updateById(entity); +// } +// +// // 同步到备份表 +// List copyList = new ArrayList<>(); +// for (ErpMaterialMeasureunitEntity entity : toUpdate) { +// CopyMaterialMeasureunitEntity copyEntity = new CopyMaterialMeasureunitEntity(); +// cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, +// CopyOptions.create() +// .setIgnoreNullValue(true) +// .setIgnoreError(true) +// ); +// copyList.add(copyEntity); +// } +// +// for (CopyMaterialMeasureunitEntity copyEntity : copyList) { +// copyMaterialMeasureunitMapper.updateById(copyEntity); +// } +// +// log.info("批量更新物料计量单位数据，数量: {}", toUpdate.size()); +// } +// +// log.info("物料计量单位数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handleLabel(ErpMaterialEntity sourceData, String parentId) { + StringBuilder urlBuilder = new StringBuilder(materialLabel); + urlBuilder.append("&PARENTID=").append(sourceData.getId()); + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料标签数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialLabelEntity.class); + log.info("成功从ERP获取物料标签数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + // 处理每个标签 + for (ErpMaterialLabelEntity label : contactList) { + log.info("开始处理物料标签数据,data {}", label); + label.setParentId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在（假设按 materialId + labelId 作为唯一标识） + ErpMaterialLabelEntity queryParam = new ErpMaterialLabelEntity(); + queryParam.setParentId(parentId); + queryParam.setMaterialLabel(label.getMaterialLabel()); + + List existingList = salesMaterialLabelMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + label.setId(UUID.randomUUID().toString()); + toInsert.add(label); + } else { + // 存在则加入更新列表 + ErpMaterialLabelEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(label, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + salesMaterialLabelMapper.insertBatchERPBData(toInsert); + salesMaterialLabelMapper.insertBatchERPBDataCopy(toInsert); + log.info("批量新增物料标签数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpMaterialLabelEntity entity : toUpdate) { + salesMaterialLabelMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpMaterialLabelEntity entity : toUpdate) { + CopyMaterialLabelEntity copyEntity = new CopyMaterialLabelEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyMaterialLabelEntity copyEntity : copyList) { + copySalesMaterialLabelMapper.updateById(copyEntity); + } + + log.info("批量更新物料标签数据，数量: {}", toUpdate.size()); + } + + log.info("物料标签数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void handleConversion(ErpMaterialEntity sourceData, String parentId, Map unitMap) { + log.info("开始处理物料换算率数据"); + StringBuilder urlBuilder = new StringBuilder(materialConvRatio); + urlBuilder.append("&PARENTID=").append(sourceData.getId()); + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料换算率数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialConversionEntity.class); + log.info("成功从ERP获取物料换算率数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + List insertList = new ArrayList<>(); + // 处理每个换算率 + for (ErpMaterialConversionEntity conversion : contactList) { + conversion.setParentId(parentId); + if (conversion.getMeasureUnit1() != null && unitMap.containsKey(conversion.getMeasureUnit1())) { + conversion.setMeasureUnit1(unitMap.get(conversion.getMeasureUnit1())); + } + if (conversion.getMeasureUnit2() != null && unitMap.containsKey(conversion.getMeasureUnit2())) { + conversion.setMeasureUnit2(unitMap.get(conversion.getMeasureUnit2())); + } + conversion.setId(UUID.randomUUID().toString()); + + insertList.add(conversion); + } + if (CollectionUtils.isEmpty(insertList)) + return; + salesMaterialConversionMapper.insertBatchERPBData(insertList); + salesMaterialConversionMapper.insertBatchERPBDataCopy(insertList); + + log.info("新增换算率数据，数量: {}", + insertList.size()); + } + + private void hanldeMainAux(ErpMaterialEntity data, String parentId, Map unitMap) { + log.info("开始同步物料主辅计量"); + StringBuilder urlBuilder = new StringBuilder(mainAux); + urlBuilder.append("&MATERIALID=").append(data.getId()); + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料主辅计量数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialUnitAreaMainAuxEntity.class); + log.info("成功从ERP获取物料主辅计量数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个主辅计量单位 + for (ErpMaterialUnitAreaMainAuxEntity mainAux : contactList) { + mainAux.setMaterialId(parentId); + + // 转换单位ID + if (mainAux.getAuxUnitId() != null && unitMap.containsKey(mainAux.getAuxUnitId())) { + mainAux.setAuxUnitId(unitMap.get(mainAux.getAuxUnitId())); + } + if (mainAux.getMainUnitId() != null && unitMap.containsKey(mainAux.getMainUnitId())) { + mainAux.setMainUnitId(unitMap.get(mainAux.getMainUnitId())); + } + + // 按唯一标识查询 ERP 系统中是否已存在 + ErpMaterialUnitAreaMainAuxEntity queryParam = new ErpMaterialUnitAreaMainAuxEntity(); + queryParam.setMaterialId(mainAux.getMaterialId()); + queryParam.setVersion(mainAux.getVersion()); + + List existingList = salesMaterialUnitAreaMainAuxMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + mainAux.setId(UUID.randomUUID().toString()); + toInsert.add(mainAux); + } else { + // 存在则加入更新列表 + ErpMaterialUnitAreaMainAuxEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(mainAux, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + salesMaterialUnitAreaMainAuxMapper.insertBatchERPData(toInsert); + salesMaterialUnitAreaMainAuxMapper.insertBatchERPDataCopy(toInsert); + log.info("批量新增物料主辅计量单位数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpMaterialUnitAreaMainAuxEntity entity : toUpdate) { + salesMaterialUnitAreaMainAuxMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpMaterialUnitAreaMainAuxEntity entity : toUpdate) { + CopyMaterialUnitAreaMainAuxEntity copyEntity = new CopyMaterialUnitAreaMainAuxEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyMaterialUnitAreaMainAuxEntity copyEntity : copyList) { + copySalesMaterialUnitAreaMainAuxMapper.updateById(copyEntity); + } + + log.info("批量更新物料主辅计量单位数据，数量: {}", toUpdate.size()); + } + + log.info("物料主辅计量单位数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private void hanldeUnitArea(ErpMaterialEntity data, String parentId, Map unitMap) { + log.info("开始同步物料范围计量单位"); + StringBuilder urlBuilder = new StringBuilder(materialUnitByArea); + urlBuilder.append("&MATERIALID=").append(data.getId()); + String finalUrl = urlBuilder.toString(); + + // 重试配置 + int maxRetries = 3; + int retryDelay = 1000; // 1秒 + String getResult = null; + + for (int attempt = 1; attempt <= maxRetries; attempt++) { + try { + log.info("第 {} 次调用ERP接口获取物料范围计量单位数据，URL: {}", attempt, finalUrl); + getResult = HttpUtils.doGet(finalUrl, new HashMap<>()); + + // 成功获取数据，跳出重试循环 + if (getResult != null && !getResult.isEmpty()) { + log.info("第 {} 次调用成功", attempt); + break; + } + } catch (IOException e) { + log.warn("第 {} 次调用ERP接口失败，URL: {}", attempt, finalUrl, e); + + if (attempt < maxRetries) { + try { + log.info("等待 {}ms 后重试...", retryDelay * attempt); + Thread.sleep(retryDelay * attempt); // 递增延迟：1s, 2s, 3s + } catch (InterruptedException ie) { + Thread.currentThread().interrupt(); + log.error("重试等待被中断", ie); + throw new RuntimeException("调用ERP接口被中断", ie); + } + } else { + log.error("调用ERP接口失败，已重试 {} 次，URL: {}", maxRetries, finalUrl, e); + throw new RuntimeException("调用ERP接口失败，已重试" + maxRetries + "次: " + e.getMessage(), e); + } + } + } + + if (getResult == null || getResult.isEmpty()) { + log.warn("ERP接口返回数据为空，URL: {}", finalUrl); + return; + } + + JSONObject jsonObject = new JSONObject(getResult); + int status = jsonObject.getInt("status"); + String msg = jsonObject.getStr("msg"); + List contactList = new ArrayList<>(); + + if (status == 200) { + contactList = JSON.parseObject(getResult) + .getJSONArray("data") + .toJavaList(ErpMaterialUnitAreaEntity.class); + log.info("成功从ERP获取物料范围计量单位数据，数量: {}", contactList != null ? contactList.size() : 0); + } else { + log.error("ERP接口请求失败，状态码: {}, 消息: {}", status, msg); + } + if (CollectionUtils.isEmpty(contactList)) { + return; + } + + // 收集需要新增和更新的记录 + List toInsert = new ArrayList<>(); + List toUpdate = new ArrayList<>(); + Date now = new Date(); + + // 处理每个范围计量单位 + for (ErpMaterialUnitAreaEntity unitArea : contactList) { + // 转换单位ID + if (unitArea.getUnitId() != null && unitMap.containsKey(unitArea.getUnitId())) { + unitArea.setUnitId(unitMap.get(unitArea.getUnitId())); + } + + unitArea.setMaterialId(parentId); + + // 按唯一标识查询 ERP 系统中是否已存在 + ErpMaterialUnitAreaEntity queryParam = new ErpMaterialUnitAreaEntity(); + queryParam.setMaterialId(parentId); + queryParam.setUnitId(unitArea.getUnitId()); + + List existingList = salesMaterialUnitAreaMapper.selectERPDataList(queryParam); + + if (CollectionUtils.isEmpty(existingList)) { + // 不存在则加入新增列表 + unitArea.setId(UUID.randomUUID().toString()); + toInsert.add(unitArea); + } else { + // 存在则加入更新列表 + ErpMaterialUnitAreaEntity existing = existingList.get(0); + + // 复制非空字段到现有记录（忽略 id） + cn.hutool.core.bean.BeanUtil.copyProperties(unitArea, existing, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + .setIgnoreProperties("id") + ); + toUpdate.add(existing); + } + } + + // 批量新增 + if (!toInsert.isEmpty()) { + salesMaterialUnitAreaMapper.insertBatchERPBfPartnerAdress(toInsert); + salesMaterialUnitAreaMapper.insertBatchERPBfPartnerAdressCopy(toInsert); + log.info("批量新增物料范围计量单位数据，数量: {}", toInsert.size()); + } + + // 批量更新 + if (!toUpdate.isEmpty()) { + // 更新主表 + for (ErpMaterialUnitAreaEntity entity : toUpdate) { + salesMaterialUnitAreaMapper.updateById(entity); + } + + // 同步到备份表 + List copyList = new ArrayList<>(); + for (ErpMaterialUnitAreaEntity entity : toUpdate) { + CopyMaterialUnitAreaEntity copyEntity = new CopyMaterialUnitAreaEntity(); + cn.hutool.core.bean.BeanUtil.copyProperties(entity, copyEntity, + CopyOptions.create() + .setIgnoreNullValue(true) + .setIgnoreError(true) + ); + copyList.add(copyEntity); + } + + for (CopyMaterialUnitAreaEntity copyEntity : copyList) { + copySalesMaterialUnitAreaMapper.updateById(copyEntity); + } + + log.info("批量更新物料范围计量单位数据，数量: {}", toUpdate.size()); + } + + log.info("物料范围计量单位数据处理完成，新增: {}, 更新: {}", toInsert.size(), toUpdate.size()); + } + + private Integer handleMaterials(ErpMaterialEntity sourceData) { if (sourceData == null || sourceData.getCode() == null) { log.warn("物料数据为空或缺少编码"); return 0; @@ -361,7 +1787,7 @@ public class SalesMaterialServiceImpl extends ServiceImpl() .eq(ErpMaterialEntity::getCode, sourceData.getCode()) - .eq(ErpMaterialEntity::getStateIsEnabled, "0") + .eq(ErpMaterialEntity::getStateIsEnabled, "1") ); CopyMaterialEntity copyMaterialEntity = new CopyMaterialEntity(); @@ -390,7 +1816,7 @@ public class SalesMaterialServiceImpl extends ServiceImpl existingBackups = salesMaterialBackUpMapper.selectList( new LambdaQueryWrapper() .eq(ErpMaterialBackUpEntity::getCode, sourceData.getCode()) - .eq(ErpMaterialBackUpEntity::getStateIsEnabled, "0") + .eq(ErpMaterialBackUpEntity::getStateIsEnabled, "1") ); if (CollectionUtils.isEmpty(existingBackups)) { @@ -514,7 +1940,7 @@ public class SalesMaterialServiceImpl extends ServiceImpl() .eq(ErpMaterialEntity::getCode, dcEntity.getCode()) - .eq(ErpMaterialEntity::getStateIsEnabled, "0") + .eq(ErpMaterialEntity::getStateIsEnabled, "1") .last("LIMIT 1") );