政务云数据上传bug修改

无关风月

4 天以前 19653375fdbfd0b4ce017d53be112f7af97b56cc

 ruoyi-service/ruoyi-jianguan/src/main/java/com/ruoyi/jianguan/util/GovernmentCloudTask.java

@@ -44,6 +44,9 @@
import com.ruoyi.chargingPile.api.model.TChargingGun;
import com.ruoyi.account.api.model.TAppUserSign;

import java.time.LocalDate;
import java.time.ZoneId;
import java.util.Date;
import java.util.List;

import com.ruoyi.account.api.model.TAppUserVipDetail;
@@ -74,6 +77,7 @@

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.stream.Collectors;


/**
@@ -262,10 +266,29 @@
    @Resource
    private JianGuanSystemClient  jianGuanSystemClient;

    public static void main(String[] args) {
        LocalDate yesterday = LocalDate.now().minusDays(1);

        LocalDateTime startOfDay = yesterday.atTime(0, 0, 0);
        LocalDateTime endOfDay = yesterday.atTime(23, 59, 59);
        // 转化为Date类型
        Date startDate = Date.from(startOfDay.atZone(ZoneId.systemDefault()).toInstant());
        Date endDate = Date.from(endOfDay.atZone(ZoneId.systemDefault()).toInstant());

        System.err.println(startOfDay);
        System.err.println(endOfDay);
    }
    // 每天下午3点执行的定时任务
    @Scheduled(fixedRate = 86400000)
    public void taskMonth() {
        log.info("市政云传数据");
        LocalDate yesterday = LocalDate.now().minusDays(1);

        LocalDateTime startOfDay = yesterday.atTime(0, 0, 0);
        LocalDateTime endOfDay = yesterday.atTime(23, 59, 59);
        // 转化为Date类型
        Date startDate = Date.from(startOfDay.atZone(ZoneId.systemDefault()).toInstant());
        Date endDate = Date.from(endOfDay.atZone(ZoneId.systemDefault()).toInstant());
        // account服务
        GovernmentCloudAccountVO data = jianGuanAccountClient.listAll().getData();
        if (data != null) {
@@ -391,6 +414,11 @@
            List<TAccountingStrategy> accountingStrategies = data1.getAccountingStrategies();
            if (!accountingStrategies.isEmpty()) {
                log.info("策略"+accountingStrategies.size());
                // 筛选出昨天凌晨00:00:00到昨天晚上23:59:59的数据
                accountingStrategies = accountingStrategies.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                // 分批插入数据 每次最多700条
                for (int i = 0; i < accountingStrategies.size(); i += 700) {
                    accountingStrategyService.saveOrUpdateBatch(accountingStrategies.subList(i, Math.min(i + 700, accountingStrategies.size())));
@@ -399,6 +427,10 @@
            List<TAccountingStrategyDetail> accountingStrategyDetails = data1.getAccountingStrategyDetails();
            if (!accountingStrategyDetails.isEmpty()) {
                log.info("策略明细"+accountingStrategyDetails.size());
                accountingStrategyDetails = accountingStrategyDetails.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < accountingStrategies.size(); i += 700) {
                    accountingStrategyDetailService.saveOrUpdateBatch(accountingStrategyDetails.subList(i, Math.min(i + 700, accountingStrategyDetails.size())));
                }
@@ -406,15 +438,24 @@
            List<TApplyChargingPile> applyChargingPiles = data1.getApplyChargingPiles();
            if (!applyChargingPiles.isEmpty()) {
                log.info("申请充电桩"+applyChargingPiles.size());
                applyChargingPiles = applyChargingPiles.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                // 分批插入数据 每次最多700条

                for (int i = 0; i < applyChargingPiles.size(); i += 700) {
                    applyChargingPileService.saveOrUpdateBatch(applyChargingPiles.subList(i, Math.min(i + 700, applyChargingPiles.size())));
                }
            }
            List<TCarport> carports = data1.getCarports();
            if (!carports.isEmpty()) {
                log.info("停车场"+carports.size());
                log.info("车库"+carports.size());
                // 分批插入数据 每次最多700条
                carports = carports.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < carports.size(); i += 700) {
                    carportService.saveOrUpdateBatch(carports.subList(i, Math.min(i + 700, carports.size())));
                }
@@ -423,6 +464,10 @@
            if (!chargingGuns.isEmpty()) {
                log.info("充电枪"+chargingGuns.size());
                // 分批插入数据 每次最多700条
                chargingGuns = chargingGuns.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < chargingGuns.size(); i += 700) {
                    chargingGunService.saveOrUpdateBatch(chargingGuns.subList(i, Math.min(i + 700, chargingGuns.size())));
                }
@@ -433,6 +478,10 @@
            if (!chargingPiles.isEmpty()) {
                log.info("充电桩"+chargingPiles.size());
                // 分批插入数据 每次最多700条
                chargingPiles = chargingPiles.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < chargingPiles.size(); i += 700) {
                    chargingPileService.saveOrUpdateBatch(chargingPiles.subList(i, Math.min(i + 700, chargingPiles.size())));
                }
@@ -442,6 +491,10 @@
            if (!chargingPileNotifications.isEmpty()) {
                log.info("充电桩通知"+chargingPileNotifications.size());
                // 分批插入数据 每次最多700条
                chargingPileNotifications = chargingPileNotifications.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < chargingPileNotifications.size(); i += 700) {
                    chargingPileNotificationService.saveOrUpdateBatch(chargingPileNotifications.subList(i, Math.min(i + 700, chargingPileNotifications.size())));
                }
@@ -450,6 +503,10 @@
            if (!faultMessages.isEmpty()) {
                log.info("故障"+faultMessages.size());
                // 分批插入数据 每次最多700条
                faultMessages = faultMessages.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < faultMessages.size(); i += 700) {
                    faultMessageService.saveOrUpdateBatch(faultMessages.subList(i, Math.min(i + 700, faultMessages.size())));
                }
@@ -458,6 +515,10 @@
            if (!monitoringEquipments.isEmpty()) {
                log.info("监控设备"+monitoringEquipments.size());
                // 分批插入数据 每次最多700条
                monitoringEquipments = monitoringEquipments.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < monitoringEquipments.size(); i += 700) {
                    monitoringEquipmentService.saveOrUpdateBatch(monitoringEquipments.subList(i, Math.min(i + 700, monitoringEquipments.size())));

@@ -467,6 +528,10 @@
            if (!parkingLots.isEmpty()) {
                log.info("停车场"+parkingLots.size());
                // 分批插入数据 每次最多700条
                parkingLots = parkingLots.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < parkingLots.size(); i += 700) {
                    parkingLotService.saveOrUpdateBatch(parkingLots.subList(i, Math.min(i + 700, parkingLots.size())));
                }
@@ -475,6 +540,10 @@
            if (!parkingRecords.isEmpty()) {
                log.info("停车记录"+parkingRecords.size());
                // 分批插入数据 每次最多700条
                parkingRecords = parkingRecords.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < parkingRecords.size(); i += 700) {
                    parkingRecordService.saveOrUpdateBatch(parkingRecords.subList(i, Math.min(i + 700, parkingRecords.size())));
                }
@@ -483,6 +552,7 @@
            if (partnerSites!=null&&!partnerSites.isEmpty()) {
                log.info("合作商站点"+parkingRecords.size());
                // 分批插入数据 每次最多700条

                for (int i = 0; i < partnerSites.size(); i += 700) {
                    partnerSiteService.saveOrUpdateBatch(partnerSites.subList(i, Math.min(i + 700, partnerSites.size())));
                }
@@ -491,6 +561,10 @@
            if (!repairs.isEmpty()) {
                log.info("报修"+repairs.size());
                // 分批插入数据 每次最多700条
                repairs = repairs.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < repairs.size(); i += 700) {
                    repairService.saveOrUpdateBatch(repairs.subList(i, Math.min(i + 700, repairs.size())));
                }
@@ -499,6 +573,10 @@
            if (siteMenus!=null&&!siteMenus.isEmpty()) {
                log.info("站点菜单"+repairs.size());
                // 分批插入数据 每次最多700条
                siteMenus = siteMenus.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < siteMenus.size(); i += 700) {
                    siteMenuService.saveOrUpdateBatch(siteMenus.subList(i, Math.min(i + 700, siteMenus.size())));
                }
@@ -507,174 +585,301 @@
            if (!vehicleRamps.isEmpty()) {
                log.info("车道"+vehicleRamps.size());
                // 分批插入数据 每次最多700条
                vehicleRamps = vehicleRamps.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < vehicleRamps.size(); i += 700) {
                    vehicleRampService.saveOrUpdateBatch(vehicleRamps.subList(i, Math.min(i + 700, vehicleRamps.size())));
                }
            }
        }
        //order服务
        GovernmentCloudOrderVO data2 = jianGuanOrderClient.listAll().getData();
        if (data2 != null) {
            log.info("Order服务");
            List<AccountingStrategyDetailOrder> accountingStrategyDetailOrders = data2.getAccountingStrategyDetailOrders();
//        GovernmentCloudOrderVO data2 = jianGuanOrderClient.listAll().getData();
        GovernmentCloudOrderVO dataOrder1 = jianGuanOrderClient.listAll1().getData();
        GovernmentCloudOrderVO dataOrder2 = jianGuanOrderClient.listAll2().getData();
        GovernmentCloudOrderVO dataOrder3 = jianGuanOrderClient.listAll3().getData();
        GovernmentCloudOrderVO dataOrder4 = jianGuanOrderClient.listAll4().getData();
        GovernmentCloudOrderVO dataOrder5 = jianGuanOrderClient.listAll5().getData();
        GovernmentCloudOrderVO dataOrder6 = jianGuanOrderClient.listAll6().getData();
        GovernmentCloudOrderVO dataOrder7 = jianGuanOrderClient.listAll7().getData();
        GovernmentCloudOrderVO dataOrder8 = jianGuanOrderClient.listAll8().getData();
        GovernmentCloudOrderVO dataOrder9 = jianGuanOrderClient.listAll9().getData();
        GovernmentCloudOrderVO dataOrder10 = jianGuanOrderClient.listAll10().getData();
        GovernmentCloudOrderVO dataOrder11 = jianGuanOrderClient.listAll11().getData();
        GovernmentCloudOrderVO dataOrder12 = jianGuanOrderClient.listAll12().getData();
        GovernmentCloudOrderVO dataOrder13 = jianGuanOrderClient.listAll13().getData();
        GovernmentCloudOrderVO dataOrder14 = jianGuanOrderClient.listAll14().getData();
        GovernmentCloudOrderVO dataOrder15 = jianGuanOrderClient.listAll15().getData();
        GovernmentCloudOrderVO dataOrder16 = jianGuanOrderClient.listAll16().getData();
        GovernmentCloudOrderVO dataOrder17 = jianGuanOrderClient.listAll17().getData();
        GovernmentCloudOrderVO dataOrder18 = jianGuanOrderClient.listAll18().getData();
        log.info("Order服务");
        if (dataOrder1 != null) {
            List<AccountingStrategyDetailOrder> accountingStrategyDetailOrders = dataOrder1.getAccountingStrategyDetailOrders();
            if (!accountingStrategyDetailOrders.isEmpty()) {
                log.info("订单明细策略"+accountingStrategyDetailOrders.size());
                log.info("订单明细策略" + accountingStrategyDetailOrders.size());
                // 分批插入数据 每次最多700条
                accountingStrategyDetailOrders = accountingStrategyDetailOrders.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < accountingStrategyDetailOrders.size(); i += 700) {
                    accountingStrategyDetailOrderService.saveOrUpdateBatch(accountingStrategyDetailOrders.subList(i, Math.min(i + 700, accountingStrategyDetailOrders.size())));
                }
            }
            List<AccountingStrategyOrder> accountingStrategyOrders = data2.getAccountingStrategyOrders();
        }
        if (dataOrder2 != null) {
            List<AccountingStrategyOrder> accountingStrategyOrders = dataOrder2.getAccountingStrategyOrders();
            if (!accountingStrategyOrders.isEmpty()) {
                log.info("订单策略"+accountingStrategyOrders.size());
                log.info("订单策略" + accountingStrategyOrders.size());
                // 分批插入数据 每次最多700条
                int size = 700;
                accountingStrategyOrders = accountingStrategyOrders.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < accountingStrategyOrders.size(); i += size) {
                    List<AccountingStrategyOrder> subList = accountingStrategyOrders.subList(i, Math.min(i + size, accountingStrategyOrders.size()));
                    accountingStrategyOrderService.saveOrUpdateBatch(subList);
                }
            }
            List<TChargingBill> chargingBills = data2.getChargingBills();
        }
        if (dataOrder3 != null) {
            List<TChargingBill> chargingBills = dataOrder3.getChargingBills();
            if (!chargingBills.isEmpty()) {
                log.info("账单"+chargingBills.size());
                log.info("账单" + chargingBills.size());
                // 分批插入数据 每次最多700条
                // 分批插入数据 每次最多700条
                chargingBills = chargingBills.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < chargingBills.size(); i += 700) {
                    chargingBillService.saveOrUpdateBatch(chargingBills.subList(i, Math.min(i + 700, chargingBills.size())));
                }

            }
            List<TChargingOrder> chargingOrders = data2.getChargingOrders();
            if (!chargingOrders.isEmpty()) {
                log.info("充电订单"+chargingOrders.size());
                // 分批插入数据 每次最多700条
                for (int i = 0; i < chargingOrders.size(); i += 700) {
                    chargingOrderService.saveOrUpdateBatch(chargingOrders.subList(i, Math.min(i + 700, chargingOrders.size())));
                }
            }
            List<TChargingOrderAccountingStrategy> chargingOrderAccountingStrategies = data2.getChargingOrderAccountingStrategies();
        }
        if (dataOrder4 != null) {
            List<TChargingOrderAccountingStrategy> chargingOrderAccountingStrategies = dataOrder4.getChargingOrderAccountingStrategies();
            if (!chargingOrderAccountingStrategies.isEmpty()) {
                log.info("充电订单策略"+chargingOrderAccountingStrategies.size());
                log.info("充电订单策略" + chargingOrderAccountingStrategies.size());
                // 分批插入数据 每次最多700条
                chargingOrderAccountingStrategies = chargingOrderAccountingStrategies.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < chargingOrderAccountingStrategies.size(); i += 700) {
                    chargingOrderAccountingStrategyService.saveOrUpdateBatch(chargingOrderAccountingStrategies.subList(i, Math.min(i + 700, chargingOrderAccountingStrategies.size())));
                }
            }
            List<TChargingOrderRefund> chargingOrderRefunds = data2.getChargingOrderRefunds();
        }
        if (dataOrder5 != null) {
            List<TChargingOrderRefund> chargingOrderRefunds = dataOrder5.getChargingOrderRefunds();
            if (!chargingOrderRefunds.isEmpty()) {
                log.info("充电订单退款"+chargingOrderRefunds.size());
                log.info("充电订单退款" + chargingOrderRefunds.size());

                // 分批插入数据 每次最多700条
                chargingOrderRefunds = chargingOrderRefunds.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < chargingOrderRefunds.size(); i += 700) {
                    chargingOrderRefundService.saveOrUpdateBatch(chargingOrderRefunds.subList(i, Math.min(i + 700, chargingOrderRefunds.size())));
                }
            }
            List<TExchangeOrder> exchangeOrders = data2.getExchangeOrders();
            if (!exchangeOrders.isEmpty()) {
                log.info("兑换订单"+exchangeOrders.size());
        }
        if (dataOrder6 != null) {
            List<TChargingOrder> chargingOrders = dataOrder6.getChargingOrders();
            if (!chargingOrders.isEmpty()) {
                log.info("充电订单" + chargingOrders.size());
                // 分批插入数据 每次最多700条
                chargingOrders = chargingOrders.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < chargingOrders.size(); i += 700) {
                    chargingOrderService.saveOrUpdateBatch(chargingOrders.subList(i, Math.min(i + 700, chargingOrders.size())));
                }
            }
        }


        if (dataOrder7 != null) {
            List<TExchangeOrder> exchangeOrders = dataOrder7.getExchangeOrders();
            if (!exchangeOrders.isEmpty()) {
                log.info("兑换订单" + exchangeOrders.size());
                exchangeOrders = exchangeOrders.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                // 分批插入数据 每次最多700条
                for (int i = 0; i < exchangeOrders.size(); i += 700) {
                    exchangeOrderService.saveOrUpdateBatch(exchangeOrders.subList(i, Math.min(i + 700, exchangeOrders.size())));
                }
            }
            List<TGrantVip> grantVips = data2.getGrantVips();
        }
        if (dataOrder8 != null) {
            List<TGrantVip> grantVips = dataOrder8.getGrantVips();
            if (!grantVips.isEmpty()) {
                log.info("赠送vip"+grantVips.size());
                log.info("赠送vip" + grantVips.size());

                // 分批插入数据 每次最多700条
                grantVips = grantVips.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < grantVips.size(); i += 700) {
                    grantVipService.saveOrUpdateBatch(grantVips.subList(i, Math.min(i + 700, grantVips.size())));
                }
            }
            List<TOrderAppeal> orderAppeals = data2.getOrderAppeals();
        }
        if (dataOrder9 != null) {
            List<TOrderAppeal> orderAppeals = dataOrder9.getOrderAppeals();
            if (!orderAppeals.isEmpty()) {
                log.info("订单申诉"+orderAppeals.size());

                log.info("订单申诉" + orderAppeals.size());
                orderAppeals = orderAppeals.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                // 分批插入数据 每次最多700条
                for (int i = 0; i < orderAppeals.size(); i += 700) {
                    orderAppealService.saveOrUpdateBatch(orderAppeals.subList(i, Math.min(i + 700, orderAppeals.size())));
                }
            }
            List<TOrderEvaluate> orderEvaluates = data2.getOrderEvaluates();
        }
        if (dataOrder10 != null) {
            List<TOrderEvaluate> orderEvaluates = dataOrder10.getOrderEvaluates();
            if (!orderEvaluates.isEmpty()) {
                log.info("订单评价"+orderEvaluates.size());

                orderEvaluates = orderEvaluates.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                // 分批插入数据 每次最多700条
                for (int i = 0; i < orderEvaluates.size(); i += 700) {
                    orderEvaluateService.saveOrUpdateBatch(orderEvaluates.subList(i, Math.min(i + 700, orderEvaluates.size())));
                }
            }
            List<TOrderEvaluateTag> orderEvaluateTags = data2.getOrderEvaluateTags();
            }
        if (dataOrder11 != null) {
            List<TOrderEvaluateTag> orderEvaluateTags = dataOrder11.getOrderEvaluateTags();
            if (!orderEvaluateTags.isEmpty()) {
                log.info("订单评价标签"+orderEvaluateTags.size());
                log.info("订单评价标签" + orderEvaluateTags.size());
                // 分批插入数据 每次最多700条
                orderEvaluateTags = orderEvaluateTags.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < orderEvaluateTags.size(); i += 700) {
                    orderEvaluateTagService.saveOrUpdateBatch(orderEvaluateTags.subList(i, Math.min(i + 700, orderEvaluateTags.size())));
                }
            }
            List<TOrderInvoice> orderInvoices = data2.getOrderInvoices();
        }
        if (dataOrder12 != null) {
            List<TOrderInvoiceDetail> orderInvoiceDetails = dataOrder12.getOrderInvoiceDetails();
            if (!orderInvoiceDetails.isEmpty()) {
                log.info("订单开票明细" + orderInvoiceDetails.size());
                // 分批插入数据 每次最多700条
                orderInvoiceDetails = orderInvoiceDetails.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < orderInvoiceDetails.size(); i += 700) {
                    orderInvoiceDetailService.saveOrUpdateBatch(orderInvoiceDetails.subList(i, Math.min(i + 700, orderInvoiceDetails.size())));
                }
            }
        }
        if (dataOrder13 != null) {
            List<TOrderInvoice> orderInvoices = dataOrder13.getOrderInvoices();
            if (!orderInvoices.isEmpty()) {
                log.info("订单开票"+orderInvoices.size());

                log.info("订单开票" + orderInvoices.size());
                orderInvoices = orderInvoices.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                // 分批插入数据 每次最多700条
                for (int i = 0; i < orderInvoices.size(); i += 700) {
                    orderInvoiceService.saveOrUpdateBatch(orderInvoices.subList(i, Math.min(i + 700, orderInvoices.size())));
                }
            }
            List<TOrderInvoiceDetail> orderInvoiceDetails = data2.getOrderInvoiceDetails();
            if (!orderInvoiceDetails.isEmpty()) {
                log.info("订单开票明细"+orderInvoiceDetails.size());
                // 分批插入数据 每次最多700条
                for (int i = 0; i < orderInvoiceDetails.size(); i += 700) {
                    orderInvoiceDetailService.saveOrUpdateBatch(orderInvoiceDetails.subList(i, Math.min(i + 700, orderInvoiceDetails.size())));
                }
            }
            List<TSettlementConfirm> settlementConfirms = data2.getSettlementConfirms();
            if (!settlementConfirms.isEmpty()) {
                log.info("账单结算"+settlementConfirms.size());
        }

        if (dataOrder14 != null) {
            List<TSettlementConfirm> settlementConfirms = dataOrder14.getSettlementConfirms();
            if (!settlementConfirms.isEmpty()) {
                log.info("账单结算" + settlementConfirms.size());
                settlementConfirms = settlementConfirms.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                // 分批插入数据 每次最多700条
                for (int i = 0; i < settlementConfirms.size(); i += 700) {
                    settlementConfirmService.saveOrUpdateBatch(settlementConfirms.subList(i, Math.min(i + 700, settlementConfirms.size())));
                }
            }
            List<TShoppingOrder> shoppingOrders = data2.getShoppingOrders();
            if (!shoppingOrders.isEmpty()) {
                log.info("购物订单"+shoppingOrders.size());

                // 分批插入数据 每次最多700条
                for (int i = 0; i < shoppingOrders.size(); i += 700) {
                    shoppingOrderService.saveOrUpdateBatch(shoppingOrders.subList(i, Math.min(i + 700, shoppingOrders.size())));
                }
            }
            List<TShoppingOrderRefund> shoppingOrderRefunds = data2.getShoppingOrderRefunds();
        }
        if (dataOrder15 != null) {
            List<TShoppingOrderRefund> shoppingOrderRefunds = dataOrder15.getShoppingOrderRefunds();
            if (!shoppingOrderRefunds.isEmpty()) {
                log.info("购物订单退款"+shoppingOrderRefunds.size());
                log.info("购物订单退款" + shoppingOrderRefunds.size());
                // 分批插入数据 每次最多700条
                shoppingOrderRefunds = shoppingOrderRefunds.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                for (int i = 0; i < shoppingOrderRefunds.size(); i += 700) {
                    shoppingOrderRefundService.saveOrUpdateBatch(shoppingOrderRefunds.subList(i, Math.min(i + 700, shoppingOrderRefunds.size())));
                }
            }
            List<TVipOrder> vipOrders = data2.getVipOrders();
            if (!vipOrders.isEmpty()) {
                log.info("会员订单"+vipOrders.size());

                // 分批插入数据 每次最多700条
                for (int i = 0; i < vipOrders.size(); i += 700) {
                    vipOrderService.saveOrUpdateBatch(vipOrders.subList(i, Math.min(i + 700, vipOrders.size())));
                }
            }
            List<TVipOrderRefund> vipOrderRefunds = data2.getVipOrderRefunds();
        }
        if (dataOrder16 != null) {
            List<TVipOrderRefund> vipOrderRefunds = dataOrder16.getVipOrderRefunds();
            if (!vipOrderRefunds.isEmpty()) {
                log.info("会员订单退款"+vipOrderRefunds);

                log.info("会员订单退款" + vipOrderRefunds);
                vipOrderRefunds = vipOrderRefunds.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                // 分批插入数据 每次最多700条
                for (int i = 0; i < vipOrderRefunds.size(); i += 700) {
                    vipOrderRefundService.saveOrUpdateBatch(vipOrderRefunds.subList(i, Math.min(i + 700, vipOrderRefunds.size())));
                }
            }
        }
        if (dataOrder17 != null) {
            List<TVipOrder> vipOrders = dataOrder17.getVipOrders();
            if (!vipOrders.isEmpty()) {
                log.info("会员订单" + vipOrders.size());
                vipOrders = vipOrders.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                // 分批插入数据 每次最多700条
                for (int i = 0; i < vipOrders.size(); i += 700) {
                    vipOrderService.saveOrUpdateBatch(vipOrders.subList(i, Math.min(i + 700, vipOrders.size())));
                }
            }
        }
        if (dataOrder18 != null) {
            List<TShoppingOrder> shoppingOrders = dataOrder18.getShoppingOrders();
            if (!shoppingOrders.isEmpty()) {
                log.info("购物订单" + shoppingOrders.size());
                shoppingOrders = shoppingOrders.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                // 分批插入数据 每次最多700条
                for (int i = 0; i < shoppingOrders.size(); i += 700) {
                    shoppingOrderService.saveOrUpdateBatch(shoppingOrders.subList(i, Math.min(i + 700, shoppingOrders.size())));
                }
            }
        }




        // other服务
        GovernmentCloudOtherVO data3 = jianGuanOtherClient.listAll().getData();
        if (data3 != null) {
@@ -800,7 +1005,10 @@
            List<SysLoginLog> loginLogs = data4.getLoginLogs();
            if (!loginLogs.isEmpty()) {
                log.info("登录日志"+loginLogs.size());

                loginLogs = loginLogs.stream()
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isAfter(startOfDay))
                        .filter(accountingStrategy -> accountingStrategy.getCreateTime().isBefore(endOfDay))
                        .collect(Collectors.toList());
                // 分批插入数据 每次最多700条
                for (int i = 0; i < loginLogs.size(); i += 700) {
                    sysLoginLogService.saveOrUpdateBatch(loginLogs.subList(i, Math.min(i + 700, loginLogs.size())));
@@ -809,7 +1017,10 @@
            List<SysOperLog> sysOperLogs = data4.getSysOperLogs();
            if (!sysOperLogs.isEmpty()) {
                log.info("操作日志"+sysOperLogs.size());

                sysOperLogs = sysOperLogs.stream()
                        .filter(accountingStrategy -> accountingStrategy.getOperTime().after(startDate))
                        .filter(accountingStrategy -> accountingStrategy.getOperTime().before(endDate))
                        .collect(Collectors.toList());
                // 分批插入数据 每次最多700条
                for (int i = 0; i < sysOperLogs.size(); i += 700) {
                    sysOperLogService.saveOrUpdateBatch(sysOperLogs.subList(i, Math.min(i + 700, sysOperLogs.size())));