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

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

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

@@ -1,7 +1,6 @@
 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;
@@ -16,8 +15,8 @@ public interface RemoteBreakService {
     /**
      * 新增故障
      */
-    @PostMapping("logAdd")
+    @PostMapping
-    public Result logAdd(@RequestBody BreakLog breakLog);
+    public Result add(@RequestBody BusinessBreak businessBreak);
 
 
 }

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

@@ -1,6 +1,5 @@
 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;
@@ -14,17 +13,10 @@ public class RemoteBreakFallbackFactory implements FallbackFactory<RemoteBreakSe
     public RemoteBreakService create(Throwable cause) {
         return new RemoteBreakService() {
             @Override
-            public Result logAdd(BreakLog breakLog) {
+            public Result add(BusinessBreak businessBreak) {
-                                log.error("故障日志服务调用失败");
+                log.error("故障日志服务调用失败");
                 return Result.error("故障日志服务调用失败");
             }
         };
-//        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

@@ -0,0 +1,23 @@
+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/service/impl/BreakLogServiceImpl.java

@@ -79,5 +79,4 @@ public class BreakLogServiceImpl implements BreakLogService {
     public int logDel(Integer breakLogId) {
         return breakLogMapper.logDel(breakLogId);
     }
-
 }

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

@@ -1,5 +1,4 @@
 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;
@@ -12,10 +11,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")
@@ -25,26 +24,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.526907,116.695848;39.522727,116.686888;39.527536,116.708916;39.522847,116.684066");
+        geoFence.setLongitudeAndLatitude("39.538047,116.683752;39.538047,116.683752;39.538047,116.683752;39.538047,116.683752");
 
         String[] split = geoFence.getLongitudeAndLatitude().split(";");
 
-        // 判断点是否在电子围栏内
         boolean withinFence = isWithinFence(pointLat, pointLng, Arrays.asList(split));
 
-        if (withinFence) {
+        if(withinFence){
             log.info("在围栏内");
-        } else {
+        }else {
             log.error("不在围栏内");
         }
 
@@ -56,16 +55,8 @@ 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("不符合条件");
         }
 
@@ -73,23 +64,14 @@ public class GeofenceEventServiceImpl implements ResolverEventService {
         double[] latitudes = new double[4];
 
         for (int i = 0; i < 4; i++) {
-            String[] coordinate = coordinates.get(i).split(",");
+            String[] coordinates = split.get(i).split(",");
-            latitudes[i] = parseDouble(coordinate[0]);
+            latitudes[i] = parseDouble(coordinates[0]);
-            longitudes[i] = parseDouble(coordinate[1]);
+            longitudes[i] = parseDouble(coordinates[1]);
         }
 
-        return isPointInRectangle(pointLat, pointLng, latitudes, longitudes);
+        return isPointInRectangle(pointLat,pointLat,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,5 +1,7 @@
 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;
@@ -11,15 +13,13 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import java.util.Date;
-import java.util.HashSet;
-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")
@@ -45,153 +45,175 @@ public class MalfunctionEventServiceImpl implements ResolverEventService {
     @Override
     public void execute(ResolverReportData vehicleData) {
         log.info("故障事件开始执行");
-        if(isAnyFieldZero(vehicleData)){
+                if(isAnyFieldZero(vehicleData)){
-            resolverReportInfoService.saveDataToDatabaseByMalfunction(vehicleData);
+                    resolverReportInfoService.saveDataToDatabaseByMalfunction(vehicleData);
 
-            BreakLog breakLog = new BreakLog();
+                    BusinessBreak businessBreak = new BusinessBreak();
-            breakLog.setBreakVin(vehicleData.getVin());
+                    businessBreak.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：故障
-            if(vehicleData.getVehicleStatus()==0){
+                    //    private int chargingStatus;
-                breakLog.setBreakCode("CL001");
+                    if(vehicleData.getChargingStatus()==0){
-                breakLog.setBreakType("车体故障");
+                        businessBreak.setBreakCode("CD001");
-                breakLog.setBreakState("1");
+                        businessBreak.setBreakDate(new Date());
-            }
+                        businessBreak.setBreakType("电池故障");
+                        businessBreak.setBreakState("1");
+                        remoteBreakService.add(businessBreak);
+                    }
 
-            //     * 充电状态 1：正常 0：故障
+                    //     * 运行状态 1：正常 0：故障
-            //    private int chargingStatus;
+                    if(vehicleData.getOperatingStatus()==0){
-            if(vehicleData.getChargingStatus()==0){
+                        businessBreak.setBreakCode("DW001");
-                breakLog.setBreakCode("CD001");
+                        businessBreak.setBreakDate(new Date());
-                breakLog.setBreakType("电池故障");
+                        businessBreak.setBreakType("行驶故障");
-                breakLog.setBreakState("1");
+                        businessBreak.setBreakState("1");
-            }
+                        remoteBreakService.add(businessBreak);
+                    }
 
-            //     * 运行状态 1：正常 0：故障
+                    //     * SOC 状态 1：正常 0：故障
-            if(vehicleData.getOperatingStatus()==0){
+                    if(vehicleData.getSocStatus()==0){
-                breakLog.setBreakCode("DW001");
+                        businessBreak.setBreakCode("SOC001");
-                breakLog.setBreakType("行驶故障");
+                        businessBreak.setBreakDate(new Date());
-                breakLog.setBreakState("1");
+                        businessBreak.setBreakType("电池故障");
-            }
+                        businessBreak.setBreakState("1");
+                        remoteBreakService.add(businessBreak);
+                    }
 
-            //     * SOC 状态 1：正常 0：故障
+                    //     可充电储能装置工作状态 1：正常 0：故障;
-            if(vehicleData.getSocStatus()==0){
+                    if(vehicleData.getChargingEnergyStorageStatus()==0){
-                breakLog.setBreakCode("SOC001");
+                        businessBreak.setBreakCode("CDC001");
-                breakLog.setBreakType("电池故障");
+                        businessBreak.setBreakDate(new Date());
-                breakLog.setBreakState("1");
+                        businessBreak.setBreakType("电池故障");
-            }
+                        businessBreak.setBreakState("1");
+                        remoteBreakService.add(businessBreak);
+                    }
 
-            //     可充电储能装置工作状态 1：正常 0：故障;
+                    //      驱动电机状态 1：正常 0：故障
-            if(vehicleData.getChargingEnergyStorageStatus()==0){
+                    if(vehicleData.getDriveMotorStatus()==0){
-                breakLog.setBreakCode("CDC001");
+                        businessBreak.setBreakCode("DJ001");
-                breakLog.setBreakType("电池故障");
+                        businessBreak.setBreakDate(new Date());
-                breakLog.setBreakState("1");
+                        businessBreak.setBreakType("电机故障");
-            }
+                        businessBreak.setBreakState("1");
+                        remoteBreakService.add(businessBreak);
+                    }
 
-            //      驱动电机状态 1：正常 0：故障
+                    //     定位是否有效 1：有效 0：无效
-            if(vehicleData.getDriveMotorStatus()==0){
+                    if(vehicleData.getPositionStatus()==0){
-                breakLog.setBreakCode("DJ001");
+                        businessBreak.setBreakCode("SOC001");
-                breakLog.setBreakType("电机故障");
+                        businessBreak.setBreakDate(new Date());
-                breakLog.setBreakState("1");
+                        businessBreak.setBreakType("定位故障");
-            }
+                        businessBreak.setBreakState("1");
+                        remoteBreakService.add(businessBreak);
+                    }
 
-            //     定位是否有效 1：有效 0：无效
+                    //     * EAS(汽车防盗系统)状态 1：正常 0：故障
-            if(vehicleData.getPositionStatus()==0){
+                    if(vehicleData.getEasStatus()==0){
-                breakLog.setBreakCode("SOC001");
+                        businessBreak.setBreakCode("EAS001");
-                breakLog.setBreakType("定位故障");
+                        businessBreak.setBreakDate(new Date());
-                breakLog.setBreakState("1");
+                        businessBreak.setBreakType("EAS故障");
-            }
+                        businessBreak.setBreakState("1");
+                        remoteBreakService.add(businessBreak);
+                    }
 
-            //     * EAS(汽车防盗系统)状态 1：正常 0：故障
+                    //     * PTC(电动加热器)状态 1：正常 0：故障
-            if(vehicleData.getEasStatus()==0){
+                    if(vehicleData.getPtcStatus()==0){
-                breakLog.setBreakCode("EAS001");
+                        businessBreak.setBreakCode("PTC001");
-                breakLog.setBreakType("EAS故障");
+                        businessBreak.setBreakDate(new Date());
-                breakLog.setBreakState("1");
+                        businessBreak.setBreakType("加热故障");
-            }
+                        businessBreak.setBreakState("1");
+                        remoteBreakService.add(businessBreak);
+                    }
 
-            //     * PTC(电动加热器)状态 1：正常 0：故障
+                    //     * EPS(电动助力系统)状态 1：正常 0：故障
-            if(vehicleData.getPtcStatus()==0){
+                    if(vehicleData.getEpsStatus()==0){
-                breakLog.setBreakCode("PTC001");
+                        businessBreak.setBreakCode("EPS001");
-                breakLog.setBreakType("加热故障");
+                        businessBreak.setBreakDate(new Date());
-                breakLog.setBreakState("1");
+                        businessBreak.setBreakType("电动助力故障");
-            }
+                        businessBreak.setBreakState("1");
+                        remoteBreakService.add(businessBreak);
+                    }
 
-            //     * EPS(电动助力系统)状态 1：正常 0：故障
+                    //     * ABS(防抱死)状态 1：正常 0：故障
-            if(vehicleData.getEpsStatus()==0){
+                    if(vehicleData.getAbsStatus()==0){
-                breakLog.setBreakCode("EPS001");
+                        businessBreak.setBreakCode("ABS001");
-                breakLog.setBreakType("电动助力故障");
+                        businessBreak.setBreakDate(new Date());
-                breakLog.setBreakState("1");
+                        businessBreak.setBreakType("ABS故障");
-            }
+                        businessBreak.setBreakState("1");
+                        remoteBreakService.add(businessBreak);
+                    }
 
-            //     * ABS(防抱死)状态 1：正常 0：故障
+                    //     *  MCU(电机/逆变器)状态 1：正常 0：故障
-            if(vehicleData.getAbsStatus()==0){
+                    if(vehicleData.getMcuStatus()==0){
-                breakLog.setBreakCode("ABS001");
+                        businessBreak.setBreakCode("MCU001");
-                breakLog.setBreakType("ABS故障");
+                        businessBreak.setBreakDate(new Date());
-                breakLog.setBreakState("1");
+                        businessBreak.setBreakType("MCU故障");
-            }
+                        businessBreak.setBreakState("1");
+                        remoteBreakService.add(businessBreak);
+                    }
 
-            //     *  MCU(电机/逆变器)状态 1：正常 0：故障
+                    //     *  动力电池加热状态 1：正常 0：故障
-            if(vehicleData.getMcuStatus()==0){
+                    if(vehicleData.getHeatingStatus()==0){
-                breakLog.setBreakCode("MCU001");
+                        businessBreak.setBreakCode("DC002");
-                breakLog.setBreakType("MCU故障");
+                        businessBreak.setBreakDate(new Date());
-                breakLog.setBreakState("1");
+                        businessBreak.setBreakType("电池故障");
-            }
+                        businessBreak.setBreakState("1");
+                        remoteBreakService.add(businessBreak);
+                    }
 
-            //     *  动力电池加热状态 1：正常 0：故障
+                    //     * 动力电池当前状态 1：正常 0：故障
-            if(vehicleData.getHeatingStatus()==0){
+                    if(vehicleData.getBatteryStatus()==0){
-                breakLog.setBreakCode("DC002");
+                        businessBreak.setBreakCode("DC003");
-                breakLog.setBreakType("电池故障");
+                        businessBreak.setBreakDate(new Date());
-                breakLog.setBreakState("1");
+                        businessBreak.setBreakType("电池故障");
-            }
+                        businessBreak.setBreakState("1");
+                        remoteBreakService.add(businessBreak);
+                    }
 
-            //     * 动力电池当前状态 1：正常 0：故障
+                    //     *  动力电池保温状态 1：正常 0：故障
-            if(vehicleData.getBatteryStatus()==0){
+                    if(vehicleData.getBatteryInsulationStatus()==0){
-                breakLog.setBreakCode("DC003");
+                        businessBreak.setBreakCode("DC004");
-                breakLog.setBreakType("电池故障");
+                        businessBreak.setBreakDate(new Date());
-                breakLog.setBreakState("1");
+                        businessBreak.setBreakType("电池故障");
-            }
+                        businessBreak.setBreakState("1");
+                        remoteBreakService.add(businessBreak);
+                    }
 
-            //     *  动力电池保温状态 1：正常 0：故障
+                    //     *  DCDC(电力交换系统) 状态 1：正常 0：故障
-            if(vehicleData.getBatteryInsulationStatus()==0){
+                    if(vehicleData.getDcdcStatus()==0){
-                breakLog.setBreakCode("DC004");
+                        businessBreak.setBreakCode("DCDC005");
-                breakLog.setBreakType("电池故障");
+                        businessBreak.setBreakDate(new Date());
-                breakLog.setBreakState("1");
+                        businessBreak.setBreakType("电力故障");
-            }
+                        businessBreak.setBreakState("1");
+                        remoteBreakService.add(businessBreak);
+                    }
 
-            //     *  DCDC(电力交换系统) 状态 1：正常 0：故障
+                    //     * CHG(充电机)状态 1：正常 0：故障
-            if(vehicleData.getDcdcStatus()==0){
+                    if(vehicleData.getChgStatus()==0){
-                breakLog.setBreakCode("DCDC005");
+                        businessBreak.setBreakCode("CDJ005");
-                breakLog.setBreakType("电力故障");
+                        businessBreak.setBreakDate(new Date());
-                breakLog.setBreakState("1");
+                        businessBreak.setBreakType("电力故障");
-            }
+                        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());
+
-            if(breakLogsFromRedis !=null && !breakLogsFromRedis.isEmpty()){
+//                    String key = "breakdown";
-                // 将Redis中的数据遍历，逐条插入数据库
+                    String value = JSON.toJSONString(businessBreak);
-                for (BreakLog breakLogs : breakLogsFromRedis) {
+                    redisService.setCacheObject("breakdown:gz:"+vehicleData.getVin(),value);
-                    remoteBreakService.logAdd(breakLogs);
+                    long expireTime = 30;
+                    redisService.expire("breakdown:gz:"+vehicleData.getVin(), expireTime, TimeUnit.MINUTES);
+
                 }
-            }else {
-                log.info("没有找到对应VIN的故障记录在Redis中，无需同步到数据库");
-            }
-
-            long expireTime = 30;
-            redisService.expire("breakdown:gz:"+vehicleData.getVin(), expireTime, TimeUnit.MINUTES);
-
-        }
 
 
         log.info("故障事件结束");