src/main/java/com/zsElectric/boot/business/service/impl/ChargeOrderInfoServiceImpl.java

@@ -718,7 +718,8 @@ public class ChargeOrderInfoServiceImpl extends ServiceImpl<ChargeOrderInfoMappe
             if (pricePolicy != null) {
                 List<ThirdPartyPolicyInfo> policyInfos = thirdPartyPolicyInfoMapper.selectList(
                         Wrappers.<ThirdPartyPolicyInfo>lambdaQuery()
-                                .eq(ThirdPartyPolicyInfo::getPricePolicyId, pricePolicy.getId()));
+                                .eq(ThirdPartyPolicyInfo::getPricePolicyId, pricePolicy.getId())
+                                .eq(ThirdPartyPolicyInfo::getIsDeleted, 0));
                 PolicyFee maxPolicyFee = null;
                 for (ThirdPartyPolicyInfo policyInfo : policyInfos) {
                     PolicyFee policyFee = policyFeeMapper.selectOne(Wrappers.<PolicyFee>lambdaQuery()
@@ -772,6 +773,7 @@ public class ChargeOrderInfoServiceImpl extends ServiceImpl<ChargeOrderInfoMappe
         List<ThirdPartyPolicyInfo> allPolicyInfos = thirdPartyPolicyInfoMapper.selectList(
                 Wrappers.<ThirdPartyPolicyInfo>lambdaQuery()
                         .eq(ThirdPartyPolicyInfo::getPricePolicyId, pricePolicy.getId())
+                        .eq(ThirdPartyPolicyInfo::getIsDeleted, 0)
                         .orderByAsc(ThirdPartyPolicyInfo::getStartTime));
         
         if (allPolicyInfos.isEmpty()) {

src/main/java/com/zsElectric/boot/business/service/impl/ThirdPartyChargingServiceImpl.java

@@ -43,6 +43,7 @@ import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 /**
@@ -559,6 +560,7 @@ public class ThirdPartyChargingServiceImpl implements ThirdPartyChargingService
         List<ThirdPartyPolicyInfo> existingDetails = policyInfoMapper.selectList(
                 Wrappers.<ThirdPartyPolicyInfo>lambdaQuery()
                         .eq(ThirdPartyPolicyInfo::getPricePolicyId, latestPolicy.getId())
+                        .eq(ThirdPartyPolicyInfo::getIsDeleted, 0)
                         .orderBy(true, true, ThirdPartyPolicyInfo::getStartTime)
         );
 
@@ -653,13 +655,19 @@ public class ThirdPartyChargingServiceImpl implements ThirdPartyChargingService
      * 保存价格策略明细（对比后更新或新增）
      */
     private void savePolicyInfoDetails(List<ChargingPricePolicyVO.PolicyInfo> policyInfos, Long policyId) {
-        // 查询已存在的明细记录，以 startTime 为 key
+        // 查询已存在的明细记录，以 startTime 为 key（只查询未删除的）
         Map<String, ThirdPartyPolicyInfo> existingMap = policyInfoMapper.selectList(
                 Wrappers.<ThirdPartyPolicyInfo>lambdaQuery()
-                        .eq(ThirdPartyPolicyInfo::getPricePolicyId, policyId))
+                        .eq(ThirdPartyPolicyInfo::getPricePolicyId, policyId)
+                        .eq(ThirdPartyPolicyInfo::getIsDeleted, 0))
                 .stream()
                 .collect(Collectors.toMap(ThirdPartyPolicyInfo::getStartTime, info -> info, (v1, v2) -> v1));
 
+        // 收集新数据中的所有 startTime，用于后续判断哪些需要删除
+        Set<String> newStartTimes = policyInfos.stream()
+                .map(ChargingPricePolicyVO.PolicyInfo::getStartTime)
+                .collect(Collectors.toSet());
+
         for (ChargingPricePolicyVO.PolicyInfo policyInfo : policyInfos) {
             ThirdPartyPolicyInfo existing = existingMap.get(policyInfo.getStartTime());
             
@@ -668,17 +676,7 @@ public class ThirdPartyChargingServiceImpl implements ThirdPartyChargingService
                 savePolicyInfoDetail(policyInfo, policyId);
                 log.debug("价格策略明细新增成功 - policyId: {}, startTime: {}", policyId, policyInfo.getStartTime());
             } else if (!isPolicyInfoSame(existing, policyInfo)) {
-                // 检查上次更新时间，如果低于1小时，跳过本次更新
-                if (existing.getUpdateTime() != null) {
-                    LocalDateTime oneHourAgo = LocalDateTime.now().minusHours(1);
-                    if (existing.getUpdateTime().isAfter(oneHourAgo)) {
-                        log.info("价格策略明细上次更新时间不足1小时，跳过更新 - policyId: {}, startTime: {}, lastUpdateTime: {}",
-                                policyId, policyInfo.getStartTime(), existing.getUpdateTime());
-                        continue; // 跳过本次更新
-                    }
-                }
-                
-                // 存在且数据变化，且距离上次更新超过1小时，执行更新
+                // 存在且数据变化，执行更新
                 updatePolicyInfoDetail(existing, policyInfo);
                 log.debug("价格策略明细更新成功 - policyId: {}, startTime: {}", policyId, policyInfo.getStartTime());
                 
@@ -690,6 +688,16 @@ public class ThirdPartyChargingServiceImpl implements ThirdPartyChargingService
                 log.debug("价格策略明细未变化，更新同步时间 - policyId: {}, startTime: {}", policyId, policyInfo.getStartTime());
             }
         }
+
+        // 逻辑删除：数据库中存在但第三方返回数据中没有的明细
+        for (Map.Entry<String, ThirdPartyPolicyInfo> entry : existingMap.entrySet()) {
+            if (!newStartTimes.contains(entry.getKey())) {
+                ThirdPartyPolicyInfo toDelete = entry.getValue();
+                policyInfoMapper.deleteById(toDelete.getId());
+                log.info("价格策略明细逻辑删除 - policyId: {}, startTime: {}, id: {}", 
+                        policyId, entry.getKey(), toDelete.getId());
+            }
+        }
     }
     
     /**

src/main/java/com/zsElectric/boot/charging/quartz/ChargingJob.java

@@ -2,17 +2,12 @@ package com.zsElectric.boot.charging.quartz;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.zsElectric.boot.charging.entity.ThirdPartyConnectorInfo;
-import com.zsElectric.boot.charging.entity.ThirdPartyEquipmentPricePolicy;
-import com.zsElectric.boot.charging.entity.ThirdPartyPolicyInfo;
 import com.zsElectric.boot.charging.mapper.ThirdPartyConnectorInfoMapper;
-import com.zsElectric.boot.charging.mapper.ThirdPartyEquipmentPricePolicyMapper;
-import com.zsElectric.boot.charging.mapper.ThirdPartyPolicyInfoMapper;
 import com.zsElectric.boot.charging.service.ChargingBusinessService;
 import com.zsElectric.boot.charging.vo.ChargingPricePolicyVO;
 import com.zsElectric.boot.charging.vo.QueryStationsInfoVO;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Component;
 import org.springframework.util.CollectionUtils;
 
@@ -33,8 +28,6 @@ public class ChargingJob {
 
     private final ChargingBusinessService chargingBusinessService;
     private final ThirdPartyConnectorInfoMapper connectorInfoMapper;
-    private final ThirdPartyEquipmentPricePolicyMapper pricePolicyMapper;
-    private final ThirdPartyPolicyInfoMapper policyInfoMapper;
 
     // 任务执行标记，防止并发执行
     private volatile boolean isPricePolicySyncRunning = false;
@@ -113,13 +106,6 @@ public class ChargingJob {
                     String connectorId = connector.getConnectorId();
                     String equipmentId = connector.getEquipmentId();
 
-                    // 检查该充电桩的价格策略上次更新时间，如果不足1小时则跳过
-                    if (shouldSkipUpdate(connectorId)) {
-                        log.info("充电桩价格策略上次更新时间不足1小时，跳过本次同步 - connectorId: {}, equipmentId: {}",
-                                connectorId, equipmentId);
-                        continue; // 跳过本次充电桩，不调用第三方接口
-                    }
-
                     log.info("查询价格策略 - connectorId: {}, equipmentId: {}", connectorId, equipmentId);
 
                     // 调用业务服务查询价格策略（会自动保存到数据库）
@@ -160,64 +146,4 @@ public class ChargingJob {
             log.info("设备价格策略同步定时任务执行结束");
         }
     }
-
-    /**
-     * 检查是否应该跳过更新
-     * 如果该充电桩的价格策略上次更新时间不足1小时，则跳过
-     *
-     * @param connectorId 充电接口ID
-     * @return true-跳过更新, false-需要更新
-     */
-    private boolean shouldSkipUpdate(String connectorId) {
-        try {
-            // 1. 查询该充电桩的最新价格策略记录
-            ThirdPartyEquipmentPricePolicy latestPolicy = pricePolicyMapper.selectList(
-                    new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<ThirdPartyEquipmentPricePolicy>()
-                            .eq(ThirdPartyEquipmentPricePolicy::getConnectorId, connectorId)
-                            .orderByDesc(ThirdPartyEquipmentPricePolicy::getCreateTime)
-                            .last("LIMIT 1")
-            ).stream().findFirst().orElse(null);
-
-            if (latestPolicy == null) {
-                // 没有记录，需要更新
-                return false;
-            }
-
-            // 2. 查询该价格策略的明细记录，获取最近的更新时间
-            List<ThirdPartyPolicyInfo> policyInfoList = policyInfoMapper.selectList(
-                    new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<ThirdPartyPolicyInfo>()
-                            .eq(ThirdPartyPolicyInfo::getPricePolicyId, latestPolicy.getId())
-                            .orderByDesc(ThirdPartyPolicyInfo::getUpdateTime)
-                            .last("LIMIT 1")
-            );
-
-            if (policyInfoList.isEmpty()) {
-                // 没有明细记录，需要更新
-                return false;
-            }
-
-            LocalDateTime lastUpdateTime = policyInfoList.get(0).getUpdateTime();
-            if (lastUpdateTime == null) {
-                // 没有更新时间，需要更新
-                return false;
-            }
-
-            // 3. 判断是否距离上次更新不足1小时
-            LocalDateTime oneHourAgo = LocalDateTime.now().minusHours(1);
-            if (lastUpdateTime.isAfter(oneHourAgo)) {
-                // 上次更新时间在1小时内，跳过更新
-                log.debug("充电桩价格策略距离上次更新不足1小时 - connectorId: {}, lastUpdateTime: {}",
-                        connectorId, lastUpdateTime);
-                return true;
-            }
-
-            // 距离上次更新超过1小时，需要更新
-            return false;
-
-        } catch (Exception e) {
-            log.error("检查更新时间失败，默认需要更新 - connectorId: {}", connectorId, e);
-            // 发生异常时，默认需要更新
-            return false;
-        }
-    }
 }

src/main/java/com/zsElectric/boot/charging/service/impl/ChargingReceptionServiceImpl.java

@@ -296,6 +296,7 @@ public class ChargingReceptionServiceImpl implements ChargingReceptionService {
                                 // 查询该价格策略下的所有时段信息，按startTime升序排列
                                 List<ThirdPartyPolicyInfo> allPolicyInfos = thirdPartyPolicyInfoMapper.selectList(Wrappers.<ThirdPartyPolicyInfo>lambdaQuery()
                                         .eq(ThirdPartyPolicyInfo::getPricePolicyId, thirdPartyEquipmentPricePolicy.getId())
+                                        .eq(ThirdPartyPolicyInfo::getIsDeleted, 0)
                                         .orderByAsc(ThirdPartyPolicyInfo::getStartTime));
                                 
                                 // 将充电开始时间和结束时间转换为HHmmss格式字符串进行匹配