Merge branch 'master' of https://gitea.qinmian.online/first-dev/smart-cloud-server

# Conflicts:
#	zhilian-modules/zhilian-business/src/main/java/com/zhilian/business/service/impl/MarkersFenceServiceImpl.java
#	zhilian-modules/zhilian-business/src/main/java/com/zhilian/business/service/impl/VehicleMarkersServiceImpl.java

zhilian-common/zhilian-common-business/src/main/java/com/zhilian/business/domain/BreakLog.java

@@ -2,6 +2,8 @@ package com.zhilian.business.domain;
 
 import lombok.Data;
 
+import java.util.Date;
+
 /**
  * @ClassName BreakLog
  * @Description TODO
@@ -20,9 +22,11 @@ public class BreakLog {
     /** 故障类型 */
     private String breakType;
     /** 结束报警时间 */
-    private String breakTime;
+    private Date breakTime;
     /** 开始报警时间 */
-    private String breakDate;
+    private Date breakDate;
     /** 是否报警 */
     private String breakState;
+    /** 逻辑删除 */
+    private Integer breakDel;
 }

zhilian-common/zhilian-common-business/src/main/java/com/zhilian/business/remote/RemoteBreakService.java

@@ -1,12 +1,16 @@
 package com.zhilian.business.remote;
 
 import com.zhilian.business.domain.Break;
+import com.zhilian.business.domain.BreakLog;
 import com.zhilian.business.domain.BusinessBreak;
 import com.zhilian.business.remote.factory.RemoteBreakFallbackFactory;
 import com.zhilian.common.core.constant.ServiceNameConstants;
 import com.zhilian.common.core.domain.Result;
 import lombok.extern.java.Log;
 import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 
@@ -15,8 +19,9 @@ public interface RemoteBreakService {
     /**
      * 新增故障
      */
-    @PostMapping
+    @PostMapping("logAdd")
-    public Result add(@RequestBody BusinessBreak businessBreak);
+    public Result logAdd(@RequestBody BreakLog breakLog);
-
 
+    @GetMapping("/checkIfBreakLogExists/{breakCode}/{breakVin}")
+    public ResponseEntity<Boolean> checkIfBreakLogExists(@PathVariable("breakCode") String breakCode, @PathVariable("breakVin") String breakVin);
 }

zhilian-common/zhilian-common-business/src/main/java/com/zhilian/business/remote/factory/RemoteBreakFallbackFactory.java

@@ -1,10 +1,13 @@
 package com.zhilian.business.remote.factory;
 
+import com.zhilian.business.domain.BreakLog;
 import com.zhilian.business.domain.BusinessBreak;
 import com.zhilian.business.remote.RemoteBreakService;
 import com.zhilian.common.core.domain.Result;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.cloud.openfeign.FallbackFactory;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Component;
 @Slf4j
 @Component
@@ -13,10 +16,23 @@ public class RemoteBreakFallbackFactory implements FallbackFactory<RemoteBreakSe
     public RemoteBreakService create(Throwable cause) {
         return new RemoteBreakService() {
             @Override
-            public Result add(BusinessBreak businessBreak) {
+            public Result logAdd(BreakLog breakLog) {
-                log.error("故障日志服务调用失败");
+                 log.error("故障日志服务调用失败");
-                return Result.error("故障日志服务调用失败");
+                return Result.error(HttpStatus.INTERNAL_SERVER_ERROR);
+            }
+
+            @Override
+            public ResponseEntity<Boolean> checkIfBreakLogExists(String breakCode, String breakVin) {
+                log.error("根据VIN和故障码查询服务调用失败");
+                return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(false);
             }
         };
+//        return new RemoteBreakService() {
+//            @Override
+//            public Result add(BusinessBreak businessBreak) {
+//                log.error("故障日志服务调用失败");
+//                return Result.error("故障日志服务调用失败");
+//            }
+//        };
     }
 }

zhilian-common/zhilian-common-resolver/src/main/java/com/zhilian/common/resolver/ErrorCar.java

@@ -1,23 +0,0 @@
-package com.zhilian.common.resolver.domain;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-/**
- * @ClassName ErrorCar
- * @Description 描述
- * @Author Can.J
- * @Date  2024/4/8 12:50
- */
-@AllArgsConstructor
-@NoArgsConstructor
-@Data
-public class ErrorCar {
-
-    private Long id;
-    private String vin;
-    private String code;
-    private int level;
-
-}

zhilian-modules/zhilian-business/src/main/java/com/zhilian/business/controller/BreakLogController.java

@@ -3,10 +3,10 @@ package com.zhilian.business.controller;
 import com.zhilian.business.domain.BreakLog;
 import com.zhilian.business.service.BreakLogService;
 import com.zhilian.common.core.domain.Result;
+import io.swagger.models.auth.In;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.*;
-import org.springframework.web.bind.annotation.RestController;
 
 import java.util.List;
 
@@ -60,4 +60,23 @@ public class BreakLogController {
         return success;
     }
 
+    @PostMapping("logDel/{breakLogId}")
+    public Result logDel(@PathVariable Integer breakLogId){
+        int del = breakLogService.logDel(breakLogId);
+        Result<Integer> success = Result.success(del);
+        return success;
+    }
+
+    /**
+     *  根据故障码和vin判断数据库中是否有数据
+     * @param breakCode
+     * @param breakVin
+     * @return
+     */
+    @GetMapping("/checkIfBreakLogExists/{breakCode}/{breakVin}")
+    public ResponseEntity <Boolean> checkIfBreakLogExists(@PathVariable("breakCode") String breakCode,@PathVariable("breakVin") String breakVin){
+        boolean exists =breakLogService.checkIfBreakLogExists(breakCode,breakVin);
+        return ResponseEntity.ok(exists);
+    }
+
 }

zhilian-modules/zhilian-business/src/main/java/com/zhilian/business/domain/BreakLog.java

@@ -25,6 +25,8 @@ public class BreakLog {
     private String breakTime;
     /** 开始报警时间 */
     private String breakDate;
-    /** 是否报警 */
+    /** 故障状态 */
     private String breakState;
+    /** 逻辑删除 */
+    private Integer breakDel;
 }

zhilian-modules/zhilian-business/src/main/java/com/zhilian/business/mapper/BreakLogMapper.java

@@ -2,6 +2,7 @@ package com.zhilian.business.mapper;
 
 import com.zhilian.business.domain.BreakLog;
 import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
 
@@ -18,4 +19,14 @@ public interface BreakLogMapper {
     int logAdd(BreakLog breakLog);
 
     int updLog(BreakLog breakLog);
+
+    int logDel(Integer breakLogId);
+
+    /**
+     *  根据故障码和vin判断数据库中是否有数据
+     * @param breakCode
+     * @param breakVin
+     * @return
+     */
+    BreakLog findByBreakCodeAndBreakVin(@Param("breakCode") String breakCode, @Param("breakVin") String breakVin);
 }

zhilian-modules/zhilian-business/src/main/java/com/zhilian/business/service/BreakLogService.java

@@ -16,4 +16,14 @@ public interface BreakLogService {
     int logAdd(BreakLog breakLog);
 
     int updLog(BreakLog breakLog);
+
+    int logDel(Integer breakLogId);
+
+    /**
+     *  根据故障码和vin判断数据库中是否有数据
+     * @param breakCode
+     * @param breakVin
+     * @return
+     */
+    boolean checkIfBreakLogExists(String breakCode, String breakVin);
 }

zhilian-modules/zhilian-business/src/main/java/com/zhilian/business/service/impl/BreakLogServiceImpl.java

@@ -74,4 +74,23 @@ public class BreakLogServiceImpl implements BreakLogService {
     public int updLog(BreakLog breakLog) {
         return breakLogMapper.updLog(breakLog);
     }
+
+    @Override
+    public int logDel(Integer breakLogId) {
+        return breakLogMapper.logDel(breakLogId);
+    }
+
+
+    /**
+     *  根据故障码和vin判断数据库中是否有数据
+     * @param breakCode
+     * @param breakVin
+     * @return
+     */
+    @Override
+    public boolean checkIfBreakLogExists(String breakCode, String breakVin) {
+        BreakLog breakLog =breakLogMapper.findByBreakCodeAndBreakVin(breakCode,breakVin);
+        return breakLog!=null;
+    }
+
 }

zhilian-modules/zhilian-business/src/main/java/com/zhilian/business/service/impl/MarkersFenceServiceImpl.java

@@ -10,6 +10,7 @@ import com.zhilian.business.service.MarkersFenceService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
+import java.util.ArrayList;
 import java.util.List;
 
 @Service
@@ -17,7 +18,9 @@ public class MarkersFenceServiceImpl extends ServiceImpl<MarkersFenceMapper, Mar
     @Autowired
     private MarkersFenceMapper markersFenceMapper;
 
-    @Override    public boolean insert(Markers markers) {
+
+    @Override
+    public boolean insert(Markers markers) {
         ArrayList<MarkersFence> markersFences = new ArrayList<>();
         markers.getFenceIds().forEach(fenceId -> {
             MarkersFence markersFence = new MarkersFence();

zhilian-modules/zhilian-business/src/main/java/com/zhilian/business/service/impl/VehicleMarkersServiceImpl.java

@@ -38,12 +38,14 @@ public class VehicleMarkersServiceImpl extends ServiceImpl<VehicleMarkersMapper,
     @Transactional(rollbackFor=Exception.class)
     @Override
     public boolean insert(Vehicle vehicle) {
+        ArrayList<VehicleMarkers> list = new ArrayList<>();
         vehicle.getMarkersIds().forEach(markerId -> {
             VehicleMarkers vehicleMarkers = new VehicleMarkers();
             vehicleMarkers.setVehicleId(vehicle.getVehicleId());
             vehicleMarkers.setMarkersId(markerId);
             list.add(vehicleMarkers);
         });
+        return this.saveBatch(list);
 
 //        String vehicleVIN = vehicle.getVehicleVIN();
 //        //标识
@@ -62,14 +64,6 @@ public class VehicleMarkersServiceImpl extends ServiceImpl<VehicleMarkersMapper,
 //        });
 //
 //        redisService.set(vehicle.getVehicleId(), markersFences);
-
-
-
-
-
-
-
-        return this.saveBatch(list);
     }
 
     @Override

zhilian-modules/zhilian-business/src/main/resources/mapper/BreakLogMapper.xml

@@ -3,21 +3,45 @@
         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.zhilian.business.mapper.BreakLogMapper">
+
+    <!-- 查询-->
+    <resultMap type="com.zhilian.business.domain.BreakLog" id="BaseResultMap">
+        <result property="breakLogId"    column="break_log_id"/>
+        <result property="breakCode"    column="break_code"/>
+        <result property="breakVin"    column="break_vin"/>
+        <result property="breakType"    column="break_time"/>
+        <result property="breakTime"    column="break_type"/>
+        <result property="breakDate"    column="break_date"/>
+        <result property="breakState"    column="break_state"/>
+        <result property="breakDel"    column="break_del"/>
+    </resultMap>
+
     <insert id="logAdd">
 
         INSERT INTO `zhilian-business`.`business_break_log`
-        ( `break_code`, `break_vin`, `break_time`, `break_type`, `break_date`, `break_state`)
+        ( `break_code`, `break_vin`, `break_time`, `break_type`, `break_date`, `break_state`,`break_del`)
         VALUES
-            (#{breakCode}, #{breakVin}, NOW(), #{breakType}, NOW(), #{breakState});
+            (#{breakCode}, #{breakVin},#{breakTime}, #{breakType},DATE_ADD(NOW(),INTERVAL 8 HOUR), #{breakState},0);
     </insert>
     <update id="updLog">
         UPDATE `zhilian-business`.`business_break_log`
-        SET `break_code` = #{breakCode}, `break_vin` = #{breakVin}, `break_time` = NOW(), `break_type` = #{breakType}, `break_date` = NOW(), `break_state` = #{breakState}
+        SET `break_code` = #{breakCode}, `break_vin` = #{breakVin}, `break_time` = NOW(), `break_type` = #{breakType}, `break_date` = NOW(), `break_state` = #{breakState}, `break_del` = #{breakDel}
         WHERE `break_log_id` = #{breakLogId};
 
     </update>
+    <update id="logDel">
+        UPDATE `zhilian-business`.`business_break_log`
+        SET break_del = 1
+        WHERE break_log_id = #{breakLogId}
+    </update>
 
     <select id="breakLog" resultType="com.zhilian.business.domain.BreakLog">
-        select * from business_break_log
+        select * from business_break_log where break_del = 0
     </select>
+
+    <!-- 根据故障码和vin判断数据库中是否有数据-->
+    <select id="findByBreakCodeAndBreakVin" resultMap="BaseResultMap">
+        select * from business_break_log where break_code =#{breakCode} and break_vin =#{breakVin} and break_del =0
+    </select>
+
 </mapper>

zhilian-modules/zhilian-resolver/src/main/java/com/zhilian/resolver/ZhiLianResolverApplication.java

@@ -22,9 +22,6 @@ import org.springframework.scheduling.annotation.EnableScheduling;
 @EnableMyFeignClients(basePackages = {"com.zhilian.business.remote","com.zhilian.common.system.remote"})
 @MapperScan({"com.zhilian.resolver.mapper", "com.zhilian.resolver.resolverReport"})
 @SpringBootApplication
-//com.zhilian.business.remote.factory.RemoteBreakFallbackFactory
-//com.zhilian.business.remote.factory.RemoteFenceFallbackFactory
-//com.zhilian.business.remote.factory.RemoteVehicleFallbackFactory
 public class ZhiLianResolverApplication {
     public static void main(String[] args) {
         SpringApplication.run(ZhiLianResolverApplication.class,args);

zhilian-modules/zhilian-resolver/src/main/java/com/zhilian/resolver/resolverReport/ResolverMqttMsg.java

@@ -90,34 +90,11 @@ public class ResolverMqttMsg {
                             ResolverEventService resolverEventService =SpringUtils.getBean(stringEvent);
                             resolverEventService.execute(vehicleData);
 
-//                            if(isAnyFieldZero(vehicleData)){
-//                                malfunctionEventService.execute(vehicleData);
-//                            }
                         }
                     }
                     log.info("字符串：{}",str);
                 }
 
-//                private boolean isAnyFieldZero(ResolverReportData resolverReportData){
-//                    return resolverReportData.getChargingStatus() == 0 ||
-//                            resolverReportData.getOperatingStatus() == 0 ||
-//                            resolverReportData.getSocStatus() == 0 ||
-//                            resolverReportData.getVehicleStatus() == 0 ||
-//                            resolverReportData.getChargingEnergyStorageStatus() == 0 ||
-//                            resolverReportData.getDriveMotorStatus() == 0 ||
-//                            resolverReportData.getPositionStatus() == 0 ||
-//                            resolverReportData.getEasStatus() == 0 ||
-//                            resolverReportData.getPtcStatus() == 0 ||
-//                            resolverReportData.getEpsStatus() == 0 ||
-//                            resolverReportData.getAbsStatus() == 0 ||
-//                            resolverReportData.getMcuStatus() == 0 ||
-//                            resolverReportData.getHeatingStatus() == 0 ||
-//                            resolverReportData.getBatteryStatus() == 0 ||
-//                            resolverReportData.getBatteryInsulationStatus() == 0 ||
-//                            resolverReportData.getDcdcStatus() == 0 ||
-//                            resolverReportData.getChgStatus() == 0;
-//                }
-
                 @Override
                 public void deliveryComplete(IMqttDeliveryToken token) {
                     log.info("消息已成功投递：{}",token);
@@ -177,15 +154,11 @@ public class ResolverMqttMsg {
         String tim =str.substring(18,31);
         long timestamp = Long.parseLong(tim);
 
-        log.info("时间串=="+tim);
         Date date = new Date(timestamp);
-        System.out.println("时间"+date);
         vehicleData.setCreateTime(date);
-        log.info("shijian =="+vehicleData.getCreateTime());
 
         //经度
         String lt = str.substring(31,42);
-        log.info("经度串==：{}",lt);
         // 如果末尾是零，则舍去
         int endIndex = lt.length() - 1;
         while (lt.charAt(endIndex) == '0'){
@@ -194,11 +167,9 @@ public class ResolverMqttMsg {
 
         String longitude = lt.substring(0, endIndex + 1);
         vehicleData.setLongitude(longitude);
-        log.info("经度 =="+vehicleData.getLongitude());
 
         //维度
         String latitudeIndex =str.substring(42,52);
-        log.info("维度串==：{}",latitudeIndex);
         int endIndexT = latitudeIndex.length() - 1;
         while (latitudeIndex.charAt(endIndexT) == '0'){
             endIndexT--;
@@ -206,303 +177,231 @@ public class ResolverMqttMsg {
 
         String latitude = latitudeIndex.substring(0, endIndexT + 1);
         vehicleData.setLatitude(latitude);
-        log.info("维度==:{}",vehicleData.getLatitude());
 
         //速度speed
         String speed =str.substring(52,58);
-        log.info("速度==：{}",speed);
         vehicleData.setSpeed(speed);
-        log.info("速度==:{}",vehicleData.getSpeed());
 
         //里程
         BigDecimal mileage= new BigDecimal(str.substring(58,69));
-        log.info("里程==：{}",mileage);
         mileage=mileage.stripTrailingZeros();
         vehicleData.setMileage(mileage);
-        log.info("里程==:{}",vehicleData.getMileage());
 
         //总电压
         String voltage =str.substring(69,75);
-        log.info("总电压==：{}",voltage);
         while (voltage.endsWith("0")) {
             voltage = voltage.substring(0, voltage.length() - 1); // 去除末尾的零
         }
         vehicleData.setVoltage(voltage);
-        log.info("总电压==:{}",vehicleData.getVoltage());
 
         //总电流
         String current =str.substring(75,80);
-        log.info("总电流==：{}",current);
         while (current.endsWith("0")){
             current=current.substring(0,current.length()-1);
         }
         vehicleData.setCurrent(current);
-        log.info("总电流==：{}",vehicleData.getCurrent());
 
         //绝缘电阻 resistance
         String res =str.substring(80,89);
-        log.info("绝缘电阻==：{}",res);
         String resistance = res.substring(0, 5);
         vehicleData.setResistance(resistance);
-        log.info("绝缘电阻==：{}",vehicleData.getResistance());
 
         //档位
         String gear =str.substring(89,90);
-        log.info("档位==：{}",gear);
         vehicleData.setGear(gear);
-        log.info("档位==：{}",vehicleData.getGear());
 
         //accelerationPedal 加速踏板行程值
         String accelerationPedal =str.substring(90,91);
-        log.info("加速踏板行程值==：{}",accelerationPedal);
         vehicleData.setAccelerationPedal(accelerationPedal);
-        log.info("加速踏板行程值==：{}",vehicleData.getAccelerationPedal());
 
         //brakePedal 制动踏板行程值
         String brakePedal =str.substring(92,93);
-        log.info("制动踏板行程值==：{}",brakePedal);
         vehicleData.setBrakePedal(brakePedal);
-        log.info("制动踏板行程值==：{}",vehicleData.getBrakePedal());
 
         //fuelConsumptionRate  燃料消耗率
         String fuelConsumptionRate =str.substring(94,99);
-        log.info("燃料消耗率==：{}",fuelConsumptionRate);
         vehicleData.setFuelConsumptionRate(fuelConsumptionRate);
-        log.info("燃料消耗率==：{}",vehicleData.getFuelConsumptionRate());
 
         //motorControllerTemperature 电机控制器温度
         String motorControllerTemperature =str.substring(99,105);
         while (motorControllerTemperature.endsWith("0")){
             motorControllerTemperature=motorControllerTemperature.substring(0,motorControllerTemperature.length()-1);
         }
-        log.info("电机控制器温度==：{}",motorControllerTemperature);
         vehicleData.setMotorControllerTemperature(motorControllerTemperature);
-        log.info("电机控制器温度==：{}",vehicleData.getMotorControllerTemperature());
 
         //motorSpeed 电机转速
         String motorSpeed =str.substring(105,110);
-        log.info("电机转速==：{}",motorSpeed);
         vehicleData.setMotorSpeed(motorSpeed);
-        log.info("电机转速==：{}",vehicleData.getMotorSpeed());
 
         //motorTorque 电机转矩
         String motorTorque =str.substring(110,114);
-        log.info("电机转矩==：{}",motorTorque);
         while (motorTorque.endsWith("0")){
             motorTorque=motorTorque.substring(0,motorTorque.length()-1);
         }
         vehicleData.setMotorTorque(motorTorque);
-        log.info("电机转矩==：{}",vehicleData.getMotorTorque());
 
 
         //motorTemperature 电机温度
         String motorTemperature =str.substring(114,120);
-        log.info("电机温度==：{}",motorTemperature);
         while (motorTemperature.endsWith("0")){
             motorTemperature=motorTemperature.substring(0,motorTemperature.length()-1);
         }
         vehicleData.setMotorTemperature(motorTemperature);
-        log.info("电机温度==：{}",vehicleData.getMotorTemperature());
 
         //motorVoltage 电机电压
         String motorVoltage =str.substring(120,125);
-        log.info("电机电压==：{}",motorVoltage);
         while (motorVoltage.endsWith("0")){
             motorVoltage=motorVoltage.substring(0,motorVoltage.length()-1);
         }
         vehicleData.setMotorVoltage(motorVoltage);
-        log.info("电机电压==：{}",vehicleData.getMotorVoltage());
 
         //motorCurrent 电机电流
         String motorCurrent =str.substring(125,133);
-        log.info("电机电流==：{}",motorCurrent);
         while (motorCurrent.endsWith("0")){
             motorCurrent=motorCurrent.substring(0,motorCurrent.length()-1);
         }
         vehicleData.setMotorCurrent(motorCurrent);
-        log.info("电机电流==：{}",vehicleData.getMotorCurrent());
 
         //remainingBattery 动力电池剩余电量SOC
         BigDecimal remainingBattery = new BigDecimal(str.substring(133,138));
-        log.info("动力电池剩余电量SOC==：{}",remainingBattery);
         vehicleData.setRemainingBattery(remainingBattery);
-        log.info("动力电池剩余电量SOC==：{}",vehicleData.getRemainingBattery());
 
         //maximumFeedbackPower 当前状态允许的最大反馈功率
         String maximumFeedbackPower =str.substring(139,144);
-        log.info("当前状态允许的最大反馈功率==：{}",maximumFeedbackPower);
         while (maximumFeedbackPower.endsWith("0")){
             maximumFeedbackPower=maximumFeedbackPower.substring(0,maximumFeedbackPower.length()-1);
         }
         vehicleData.setMaximumFeedbackPower(maximumFeedbackPower);
-        log.info("当前状态允许的最大反馈功率==:{}",vehicleData.getMaximumFeedbackPower());
 
         //maximumDischargePower 当前状态允许最大放电功率
         String maximumDischargePower =str.substring(145,151);
-        log.info("当前状态允许最大放电功率:{}",maximumDischargePower);
         while (maximumDischargePower.endsWith("0")){
             maximumDischargePower=maximumDischargePower.substring(0,maximumDischargePower.length()-1);
         }
         vehicleData.setMaximumDischargePower(maximumDischargePower);
-        log.info("当前状态允许最大放电功率：{}",vehicleData.getMaximumDischargePower());
 
         //selfCheckCounter BMS自检计数器
         String selfCheckCounter =str.substring(151,153);
         String selfCheckCounterReplace = selfCheckCounter.replace("0", "");
-        log.info("BMS自检计数器==：{}",selfCheckCounter);
         vehicleData.setSelfCheckCounter(selfCheckCounterReplace);
-        log.info("BMS自检计数器==：{}",vehicleData.getSelfCheckCounter());
 
         //totalBatteryCurrent 动力电池充放电电流
         String totalBatteryCurrent =str.substring(153,158);
-        log.info("BMS自检计数器==：{}",totalBatteryCurrent);
         while (totalBatteryCurrent.endsWith("0")){
             totalBatteryCurrent=totalBatteryCurrent.substring(0,totalBatteryCurrent.length()-1);
         }
         vehicleData.setTotalBatteryCurrent(totalBatteryCurrent);
-        log.info("BMS自检计数器==：{}",vehicleData.getTotalBatteryCurrent());
 
         //totalBatteryVoltage 动力电池负载端总电压V3
         String totalBatteryVoltage =str.substring(158,164);
-        log.info("动力电池负载端总电压V3==：{}",totalBatteryVoltage);
         while (totalBatteryVoltage.endsWith("0")){
             totalBatteryVoltage=totalBatteryVoltage.substring(0,totalBatteryVoltage.length()-1);
         }
         vehicleData.setTotalBatteryVoltage(totalBatteryVoltage);
-        log.info("动力电池负载端总电压V3==：{}",vehicleData.getTotalBatteryVoltage());
 
         //singleBatteryMaxVoltage 单次最大电压
         String singleBatteryMaxVoltage =str.substring(164,168);
-        log.info("单次最大电压==：{}",singleBatteryMaxVoltage);
         while (singleBatteryMaxVoltage.endsWith("0")){
             singleBatteryMaxVoltage=singleBatteryMaxVoltage.substring(0,singleBatteryMaxVoltage.length()-1);
         }
         vehicleData.setSingleBatteryMaxVoltage(singleBatteryMaxVoltage);
-        log.info("单次最大电压==：{}",vehicleData.getSingleBatteryMaxVoltage());
 
         //singleBatteryMinVoltage 单体电池最低电压
         String singleBatteryMinVoltage =str.substring(168,172);
-        log.info("单体电池最低电压==：{}",singleBatteryMinVoltage);
         while (singleBatteryMinVoltage.endsWith("0")){
             singleBatteryMinVoltage=singleBatteryMinVoltage.substring(0,singleBatteryMinVoltage.length()-1);
         }
 
         vehicleData.setSingleBatteryMinVoltage(singleBatteryMinVoltage);
-        log.info("单体电池最低电压==：{}",vehicleData.getSingleBatteryMinVoltage());
 
         //singleBatteryMaxTemperature 单体电池最高温度
         String singleBatteryMaxTemperature =str.substring(172,178);
-        log.info("单体电池最高温度==：{}",singleBatteryMaxTemperature);
         while (singleBatteryMaxTemperature.endsWith("0")){
             singleBatteryMaxTemperature=singleBatteryMaxTemperature.substring(0,singleBatteryMaxTemperature.length()-1);
         }
         vehicleData.setSingleBatteryMaxTemperature(singleBatteryMaxTemperature);
-        log.info("单体电池最高温度==：{}",vehicleData.getSingleBatteryMaxTemperature());
 
         //singleBatteryMinTemperature 单体电池最低温度
         String singleBatteryMinTemperature =str.substring(178,184);
-        log.info("单体电池最低温度==：{}",singleBatteryMinTemperature);
         while (singleBatteryMinTemperature.endsWith("0")){
             singleBatteryMinTemperature=singleBatteryMinTemperature.substring(0,singleBatteryMinTemperature.length()-1);
         }
         vehicleData.setSingleBatteryMinTemperature(singleBatteryMinTemperature);
-        log.info("单体电池最低温度==：{}",vehicleData.getSingleBatteryMinTemperature());
 
         //availableBatteryCapacity 可用电池容量
         String availableBatteryCapacity =str.substring(184,190);
-        log.info("可用电池容量==：{}",availableBatteryCapacity);
         while (availableBatteryCapacity.endsWith("0")){
             availableBatteryCapacity=availableBatteryCapacity.substring(0,availableBatteryCapacity.length()-1);
         }
         vehicleData.setAvailableBatteryCapacity(availableBatteryCapacity);
-        log.info("可用电池容量==：{}",vehicleData.getAvailableBatteryCapacity());
 
         //vehicleStatus 车辆状态
         int vehicleStatus = Integer.parseInt(str.substring(190,191));
         vehicleData.setVehicleStatus(vehicleStatus);
-        log.info("车辆状态==：{}",vehicleData.getVehicleStatus());
 
         //chargingStatus 充电状态
         int chargingStatus = Integer.parseInt(str.substring(191,192));
         vehicleData.setChargingStatus(chargingStatus);
-        log.info("充电状态==：{}",vehicleData.getChargingStatus());
 
         //operatingStatus 运行状态
         int operatingStatus = Integer.parseInt(str.substring(192,193));
         vehicleData.setOperatingStatus(operatingStatus);
-        log.info("运行状态==：{}",vehicleData.getOperatingStatus());
 
         //socStatus SOC
         int socStatus = Integer.parseInt(str.substring(193,194));
         vehicleData.setSocStatus(socStatus);
-        log.info("SOC==：{}",vehicleData.getSocStatus());
 
         //chargingEnergyStorageStatus 可充电储能装置工作状态
         int chargingEnergyStorageStatus = Integer.parseInt(str.substring(194,195));
         vehicleData.setChargingEnergyStorageStatus(chargingEnergyStorageStatus);
-        log.info("可充电储能装置工作状态==：{}",vehicleData.getChargingEnergyStorageStatus());
 
         //driveMotorStatus 驱动电机状态
         int driveMotorStatus = Integer.parseInt(str.substring(195,196));
         vehicleData.setDriveMotorStatus(driveMotorStatus);
-        log.info("驱动电机状态==：{}",vehicleData.getDriveMotorStatus());
 
         //positionStatus 定位是否有效
         int positionStatus = Integer.parseInt(str.substring(196,197));
         vehicleData.setPositionStatus(positionStatus);
-        log.info("定位是否有效==：{}",vehicleData.getPositionStatus());
 
         //easStatus EAS(汽车防盗系统)状态
         int easStatus = Integer.parseInt(str.substring(197,198));
         vehicleData.setEasStatus(easStatus);
-        log.info("EAS(汽车防盗系统)状态==：{}",vehicleData.getEasStatus());
 
         //ptcStatus PTC(电动加热器)状态
         int ptcStatus = Integer.parseInt(str.substring(198,199));
         vehicleData.setPtcStatus(ptcStatus);
-        log.info("PTC(电动加热器)状态==：{}",vehicleData.getPtcStatus());
 
         //epsStatus
         int epsStatus = Integer.parseInt(str.substring(199,200));
         vehicleData.setEpsStatus(epsStatus);
-        log.info("车辆状态==：{}",vehicleData.getEpsStatus());
 
         //absStatus EPS(电动助力系统)状态
         int absStatus = Integer.parseInt(str.substring(200,201));
         vehicleData.setAbsStatus(absStatus);
-        log.info("EPS(电动助力系统)状态==：{}",vehicleData.getAbsStatus());
 
         //mcuStatus MCU(电机/逆变器)状态
         int mcuStatus = Integer.parseInt(str.substring(201,202));
         vehicleData.setMcuStatus(mcuStatus);
-        log.info("MCU(电机/逆变器)状态==：{}",vehicleData.getMcuStatus());
 
         //heatingStatus 动力电池加热状态
         int heatingStatus = Integer.parseInt(str.substring(202,203));
         vehicleData.setHeatingStatus(heatingStatus);
-        log.info("动力电池加热状态==：{}",vehicleData.getHeatingStatus());
 
         //batteryStatus 动力电池当前状态
         int batteryStatus = Integer.parseInt(str.substring(203,204));
         vehicleData.setBatteryStatus(batteryStatus);
-        log.info("动力电池当前状态==：{}",vehicleData.getBatteryStatus());
 
         //batteryInsulationStatus 动力电池保温状态
         int batteryInsulationStatus = Integer.parseInt(str.substring(204,205));
         vehicleData.setBatteryInsulationStatus(batteryInsulationStatus);
-        log.info("动力电池保温状态==：{}",vehicleData.getBatteryInsulationStatus());
 
         //dcdcStatus DCDC(电力交换系统)状态
         int dcdcStatus = Integer.parseInt(str.substring(205,206));
         vehicleData.setDcdcStatus(dcdcStatus);
-        log.info("DCDC(电力交换系统)状态==：{}",vehicleData.getDcdcStatus());
 
         //chgStatus CHG(充电机)状态
         int chgStatus = Integer.parseInt(str.substring(206,207));
         vehicleData.setChgStatus(chgStatus);
-        log.info("CHG(充电机)状态 ==：{}",vehicleData.getChgStatus());
-
-        log.info("车辆数据解析完成:{}",vehicleData);
 
         vehicleDataList.add(vehicleData);
 

zhilian-modules/zhilian-resolver/src/main/java/com/zhilian/resolver/service/impl/eventGeofence/GeofenceEventServiceImpl.java

@@ -1,4 +1,5 @@
 package com.zhilian.resolver.service.impl.eventGeofence;
+
 import com.zhilian.common.resolver.domain.ResolverReportData;
 import com.zhilian.resolver.GeoFence;
 import com.zhilian.resolver.service.ResolverEventService;
@@ -11,10 +12,10 @@ import java.util.List;
 import static java.lang.Double.parseDouble;
 
 /**
-  * @ClassName GeofenceEventServiceImpl
+ * @ClassName GeofenceEventServiceImpl
-  * @Description 电子围栏事件
+ * @Description 电子围栏事件
-  * @Author Can.J
+ * @Author Can.J
-  * @Date  2024/4/4 10:25
+ * @Date 2024/4/4 10:25
  */
 @Slf4j
 @Service("geofence")
@@ -24,26 +25,26 @@ public class GeofenceEventServiceImpl implements ResolverEventService {
     public void execute(ResolverReportData resolverReportData) {
         log.info("电子围挡执行");
         String vin = resolverReportData.getVin();
-        log.info("vin :"+vin);
+        log.info("vin :" + vin);
-        //经度
+        // 经度
         double pointLng = parseDouble(resolverReportData.getLongitude());
-        //维度
+        // 维度
         double pointLat = parseDouble(resolverReportData.getLatitude());
 
-//      调用电子围栏信息
+        // 调用电子围栏信息
-
         GeoFence geoFence = new GeoFence();
-        //39.958897,116.179075;    39.950476,116.330823;    39.865149,116.290311;     39.881485,116.083631
+        // 39.958897,116.179075;    39.950476,116.330823;    39.865149,116.290311;     39.881485,116.083631
-        // 廊坊经度:116.683752  维度:39.538047
+        // 廊坊经度：116.683752  维度：39.538047
-        geoFence.setLongitudeAndLatitude("39.538047,116.683752;39.538047,116.683752;39.538047,116.683752;39.538047,116.683752");
+        geoFence.setLongitudeAndLatitude("39.526907,116.695848;39.522727,116.686888;39.527536,116.708916;39.522847,116.684066");
 
         String[] split = geoFence.getLongitudeAndLatitude().split(";");
 
+        // 判断点是否在电子围栏内
         boolean withinFence = isWithinFence(pointLat, pointLng, Arrays.asList(split));
 
-        if(withinFence){
+        if (withinFence) {
             log.info("在围栏内");
-        }else {
+        } else {
             log.error("不在围栏内");
         }
 
@@ -55,8 +56,16 @@ public class GeofenceEventServiceImpl implements ResolverEventService {
         return "geofence";
     }
 
-        public boolean isWithinFence(double pointLat, double pointLng, List<String> split){
+    /**
-        if(split.size()<4){
+     * 判断点是否在矩形内（射线法）
+     *
+     * @param pointLat  纬度
+     * @param pointLng 经度
+     * @param coordinates 矩形顶点坐标数组，格式为：[纬度1,经度1,纬度2,经度2,纬度3,经度3]
+     * @return 如果点在矩形内，返回true；否则返回false
+     */
+    private boolean isWithinFence(double pointLat, double pointLng, List<String> coordinates) {
+        if (coordinates.size() < 4) {
             throw new IllegalArgumentException("不符合条件");
         }
 
@@ -64,14 +73,23 @@ public class GeofenceEventServiceImpl implements ResolverEventService {
         double[] latitudes = new double[4];
 
         for (int i = 0; i < 4; i++) {
-            String[] coordinates = split.get(i).split(",");
+            String[] coordinate = coordinates.get(i).split(",");
-            latitudes[i] = parseDouble(coordinates[0]);
+            latitudes[i] = parseDouble(coordinate[0]);
-            longitudes[i] = parseDouble(coordinates[1]);
+            longitudes[i] = parseDouble(coordinate[1]);
         }
 
-        return isPointInRectangle(pointLat,pointLat,latitudes,longitudes);
+        return isPointInRectangle(pointLat, pointLng, latitudes, longitudes);
     }
 
+    /**
+     * 判断点是否在矩形内（射线法）
+     *
+     * @param pointLat  纬度
+     * @param pointLng 经度
+     * @param latitudes 矩形顶点纬度数组
+     * @param longitudes 矩形顶点经度数组
+     * @return 如果点在矩形内，返回true；否则返回false
+     */
     private boolean isPointInRectangle(double pointLat, double pointLng, double[] latitudes, double[] longitudes) {
         // 根据矩形顶点顺序确定最小和最大纬度、经度
         double minLatitude = Arrays.stream(latitudes).min().orElseThrow();

zhilian-modules/zhilian-resolver/src/main/java/com/zhilian/resolver/service/impl/eventMalfunction/MalfunctionEventServiceImpl.java

@@ -1,7 +1,5 @@
 package com.zhilian.resolver.service.impl.eventMalfunction;
-
+import com.zhilian.business.domain.BreakLog;
-import com.alibaba.fastjson.JSON;
-import com.zhilian.business.domain.BusinessBreak;
 import com.zhilian.business.remote.RemoteBreakService;
 import com.zhilian.common.redis.service.RedisService;
 import com.zhilian.common.resolver.domain.ResolverReportData;
@@ -10,16 +8,20 @@ import com.zhilian.resolver.service.ResolverEventService;
 import com.zhilian.resolver.service.ResolverReportInfoService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Service;
 
 import java.util.Date;
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
 import java.util.concurrent.TimeUnit;
 
 /**
-  * @ClassName MalfunctionEventServiceImpl
+ * @ClassName MalfunctionEventServiceImpl
-  * @Description 故障事件服务
+ * @Description 故障事件服务
-  * @Author Can.J
+ * @Author Can.J
-  * @Date  2024/4/4 10:00
+ * @Date  2024/4/4 10:00
  */
 @Slf4j
 @Service("malfunction")
@@ -39,181 +41,163 @@ public class MalfunctionEventServiceImpl implements ResolverEventService {
     @Autowired
     private ResolverReportInfoService resolverReportInfoService;
 
+    /**
+     *  远程调用 BreakLog服务
+     */
     @Autowired
     private RemoteBreakService remoteBreakService;
 
     @Override
     public void execute(ResolverReportData vehicleData) {
         log.info("故障事件开始执行");
-                if(isAnyFieldZero(vehicleData)){
+        if(isAnyFieldZero(vehicleData)){
-                    resolverReportInfoService.saveDataToDatabaseByMalfunction(vehicleData);
+            resolverReportInfoService.saveDataToDatabaseByMalfunction(vehicleData);
 
-                    BusinessBreak businessBreak = new BusinessBreak();
+            BreakLog breakLog = new BreakLog();
-                    businessBreak.setBreakVin(vehicleData.getVin());
+            breakLog.setBreakVin(vehicleData.getVin());
-                    //     * 车辆状态 1：正常 0：故障
-                    if(vehicleData.getVehicleStatus()==0){
-                        businessBreak.setBreakCode("CL001");
-                        businessBreak.setBreakDate(new Date());
-                        businessBreak.setBreakType("车体故障");
-                        businessBreak.setBreakState("1");
-                        remoteBreakService.add(businessBreak);
-                    }
 
-                    //     * 充电状态 1：正常 0：故障
+            //     * 车辆状态 1：正常 0：故障
-                    //    private int chargingStatus;
+            if(vehicleData.getVehicleStatus()==0){
-                    if(vehicleData.getChargingStatus()==0){
+                breakLog.setBreakCode("CL001");
-                        businessBreak.setBreakCode("CD001");
+                breakLog.setBreakType("车体故障");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakType("电池故障");
+            }
-                        businessBreak.setBreakState("1");
-                        remoteBreakService.add(businessBreak);
-                    }
 
-                    //     * 运行状态 1：正常 0：故障
+            //     * 充电状态 1：正常 0：故障
-                    if(vehicleData.getOperatingStatus()==0){
+            //    private int chargingStatus;
-                        businessBreak.setBreakCode("DW001");
+            if(vehicleData.getChargingStatus()==0){
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakCode("CD001");
-                        businessBreak.setBreakType("行驶故障");
+                breakLog.setBreakType("电池故障");
-                        businessBreak.setBreakState("1");
+                breakLog.setBreakState("1");
-                        remoteBreakService.add(businessBreak);
+            }
-                    }
 
-                    //     * SOC 状态 1：正常 0：故障
+            //     * 运行状态 1：正常 0：故障
-                    if(vehicleData.getSocStatus()==0){
+            if(vehicleData.getOperatingStatus()==0){
-                        businessBreak.setBreakCode("SOC001");
+                breakLog.setBreakCode("DW001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("行驶故障");
-                        businessBreak.setBreakType("电池故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
+            }
-                        remoteBreakService.add(businessBreak);
-                    }
 
-                    //     可充电储能装置工作状态 1：正常 0：故障;
+            //     * SOC 状态 1：正常 0：故障
-                    if(vehicleData.getChargingEnergyStorageStatus()==0){
+            if(vehicleData.getSocStatus()==0){
-                        businessBreak.setBreakCode("CDC001");
+                breakLog.setBreakCode("SOC001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("电池故障");
-                        businessBreak.setBreakType("电池故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
+            }
-                        remoteBreakService.add(businessBreak);
-                    }
 
-                    //      驱动电机状态 1：正常 0：故障
+            //     可充电储能装置工作状态 1：正常 0：故障;
-                    if(vehicleData.getDriveMotorStatus()==0){
+            if(vehicleData.getChargingEnergyStorageStatus()==0){
-                        businessBreak.setBreakCode("DJ001");
+                breakLog.setBreakCode("CDC001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("电池故障");
-                        businessBreak.setBreakType("电机故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
+            }
-                        remoteBreakService.add(businessBreak);
-                    }
 
-                    //     定位是否有效 1：有效 0：无效
+            //      驱动电机状态 1：正常 0：故障
-                    if(vehicleData.getPositionStatus()==0){
+            if(vehicleData.getDriveMotorStatus()==0){
-                        businessBreak.setBreakCode("SOC001");
+                breakLog.setBreakCode("DJ001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("电机故障");
-                        businessBreak.setBreakType("定位故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
+            }
-                        remoteBreakService.add(businessBreak);
-                    }
 
-                    //     * EAS(汽车防盗系统)状态 1：正常 0：故障
+            //     定位是否有效 1：有效 0：无效
-                    if(vehicleData.getEasStatus()==0){
+            if(vehicleData.getPositionStatus()==0){
-                        businessBreak.setBreakCode("EAS001");
+                breakLog.setBreakCode("SOC001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("定位故障");
-                        businessBreak.setBreakType("EAS故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
+            }
-                        remoteBreakService.add(businessBreak);
-                    }
 
-                    //     * PTC(电动加热器)状态 1：正常 0：故障
+            //     * EAS(汽车防盗系统)状态 1：正常 0：故障
-                    if(vehicleData.getPtcStatus()==0){
+            if(vehicleData.getEasStatus()==0){
-                        businessBreak.setBreakCode("PTC001");
+                breakLog.setBreakCode("EAS001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("EAS故障");
-                        businessBreak.setBreakType("加热故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
+            }
-                        remoteBreakService.add(businessBreak);
-                    }
 
-                    //     * EPS(电动助力系统)状态 1：正常 0：故障
+            //     * PTC(电动加热器)状态 1：正常 0：故障
-                    if(vehicleData.getEpsStatus()==0){
+            if(vehicleData.getPtcStatus()==0){
-                        businessBreak.setBreakCode("EPS001");
+                breakLog.setBreakCode("PTC001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("加热故障");
-                        businessBreak.setBreakType("电动助力故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
+            }
-                        remoteBreakService.add(businessBreak);
-                    }
 
-                    //     * ABS(防抱死)状态 1：正常 0：故障
+            //     * EPS(电动助力系统)状态 1：正常 0：故障
-                    if(vehicleData.getAbsStatus()==0){
+            if(vehicleData.getEpsStatus()==0){
-                        businessBreak.setBreakCode("ABS001");
+                breakLog.setBreakCode("EPS001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("电动助力故障");
-                        businessBreak.setBreakType("ABS故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
+            }
-                        remoteBreakService.add(businessBreak);
-                    }
 
-                    //     *  MCU(电机/逆变器)状态 1：正常 0：故障
+            //     * ABS(防抱死)状态 1：正常 0：故障
-                    if(vehicleData.getMcuStatus()==0){
+            if(vehicleData.getAbsStatus()==0){
-                        businessBreak.setBreakCode("MCU001");
+                breakLog.setBreakCode("ABS001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("ABS故障");
-                        businessBreak.setBreakType("MCU故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
+            }
-                        remoteBreakService.add(businessBreak);
-                    }
 
-                    //     *  动力电池加热状态 1：正常 0：故障
+            //     *  MCU(电机/逆变器)状态 1：正常 0：故障
-                    if(vehicleData.getHeatingStatus()==0){
+            if(vehicleData.getMcuStatus()==0){
-                        businessBreak.setBreakCode("DC002");
+                breakLog.setBreakCode("MCU001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("MCU故障");
-                        businessBreak.setBreakType("电池故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
+            }
-                        remoteBreakService.add(businessBreak);
-                    }
 
-                    //     * 动力电池当前状态 1：正常 0：故障
+            //     *  动力电池加热状态 1：正常 0：故障
-                    if(vehicleData.getBatteryStatus()==0){
+            if(vehicleData.getHeatingStatus()==0){
-                        businessBreak.setBreakCode("DC003");
+                breakLog.setBreakCode("DC002");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("电池故障");
-                        businessBreak.setBreakType("电池故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
+            }
-                        remoteBreakService.add(businessBreak);
-                    }
 
-                    //     *  动力电池保温状态 1：正常 0：故障
+            //     * 动力电池当前状态 1：正常 0：故障
-                    if(vehicleData.getBatteryInsulationStatus()==0){
+            if(vehicleData.getBatteryStatus()==0){
-                        businessBreak.setBreakCode("DC004");
+                breakLog.setBreakCode("DC003");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("电池故障");
-                        businessBreak.setBreakType("电池故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
+            }
-                        remoteBreakService.add(businessBreak);
-                    }
 
-                    //     *  DCDC(电力交换系统) 状态 1：正常 0：故障
+            //     *  动力电池保温状态 1：正常 0：故障
-                    if(vehicleData.getDcdcStatus()==0){
+            if(vehicleData.getBatteryInsulationStatus()==0){
-                        businessBreak.setBreakCode("DCDC005");
+                breakLog.setBreakCode("DC004");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("电池故障");
-                        businessBreak.setBreakType("电力故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
+            }
-                        remoteBreakService.add(businessBreak);
-                    }
 
-                    //     * CHG(充电机)状态 1：正常 0：故障
+            //     *  DCDC(电力交换系统) 状态 1：正常 0：故障
-                    if(vehicleData.getChgStatus()==0){
+            if(vehicleData.getDcdcStatus()==0){
-                        businessBreak.setBreakCode("CDJ005");
+                breakLog.setBreakCode("DCDC005");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("电力故障");
-                        businessBreak.setBreakType("电力故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
+            }
-                        remoteBreakService.add(businessBreak);
+
-                    }
+            //     * CHG(充电机)状态 1：正常 0：故障
+            if(vehicleData.getChgStatus()==0){
+                breakLog.setBreakCode("CDJ005");
+                breakLog.setBreakType("电力故障");
+                breakLog.setBreakState("1");
+
+            }
+
+            HashSet<BreakLog> breakHash = new HashSet<>();
+            breakHash.add(breakLog);
 
 
+            redisService.setCacheSet("breakdown:gz:："+vehicleData.getVin(),breakHash);
 
-
+            Set<BreakLog> breakLogsFromRedis = redisService.getCacheSet("breakdown:gz:：" + vehicleData.getVin());
-//                    String key = "breakdown";
+            if(breakLogsFromRedis !=null && !breakLogsFromRedis.isEmpty()){
-                    String value = JSON.toJSONString(businessBreak);
+                // 检查第一条故障记录是否已存在于数据库中
-                    redisService.setCacheObject("breakdown:gz:"+vehicleData.getVin(),value);
+                BreakLog firstBreakLog = breakLogsFromRedis.iterator().next();
-                    long expireTime = 30;
+                if (!isInDatabase(firstBreakLog)) {
-                    redisService.expire("breakdown:gz:"+vehicleData.getVin(), expireTime, TimeUnit.MINUTES);
+                    remoteBreakService.logAdd(firstBreakLog);
-
                 }
+            }else {
+                log.info("没有找到对应VIN的故障记录在Redis中，无需同步到数据库");
+            }
+
+            long expireTime = 30;
+            redisService.expire("breakdown:gz:"+vehicleData.getVin(), expireTime, TimeUnit.MINUTES);
+
+        }
 
 
         log.info("故障事件结束");
@@ -243,4 +227,12 @@ public class MalfunctionEventServiceImpl implements ResolverEventService {
     public String getEventName() {
         return "malfunction";
     }
+
+    private boolean isInDatabase(BreakLog breakLog) {
+        // 查询数据库，判断是否已存在相同的故障记录
+        // 故障记录的唯一标识是breakCode和breakVin
+        ResponseEntity<Boolean> existingBreakLog = remoteBreakService.checkIfBreakLogExists(breakLog.getBreakCode(), breakLog.getBreakVin());
+        return existingBreakLog != null && existingBreakLog.getBody();
+
+    }
 }