feat

故障日志存储redis,mysql

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,9 @@ public class BreakLog {
     /** 故障类型 */
     private String breakType;
     /** 结束报警时间 */
-    private String breakTime;
+    private Date breakTime;
     /** 开始报警时间 */
-    private String breakDate;
+    private Date breakDate;
     /** 是否报警 */
     private String breakState;
     /** 逻辑删除 */

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

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

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

@@ -1,5 +1,6 @@
 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;
@@ -13,10 +14,17 @@ 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("故障日志服务调用失败");
                 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

@@ -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-common/zhilian-common-resolver/src/main/java/com/zhilian/common/resolver/domain/ResolverMalfunctionLog.java

@@ -1,47 +0,0 @@
-package com.zhilian.common.resolver.domain;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.util.Date;
-/**
-  * @ClassName ResolverMalfunctionLog
-  * @Description 解析故障日志
-  * @Author Can.J
-  * @Date  2024/4/10 11:10
- */
-@Data
-@AllArgsConstructor
-@NoArgsConstructor
-public class ResolverMalfunctionLog {
-    /**
-     *  故障主键id
-     */
-    private Long id;
-    /**
-     *  故障码
-     */
-    private String malfunctionCode;
-    /**
-     *  车辆VIN
-     */
-    private String malfunctionVin;
-    /**
-     *  开始报警时间
-     */
-    private Date startTime;
-    /**
-     *  故障类型
-     */
-    private String breakType;
-    /**
-     *  结束报警时间
-     */
-    private Date endTime;
-    /**
-     *  故障标签
-     */
-    private String malfunctionTag;
-
-}

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

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

zhilian-modules/zhilian-resolver/src/main/java/com/zhilian/resolver/controller/MalfunctionController.java

@@ -1,33 +0,0 @@
-package com.zhilian.resolver.controller;
-
-import com.zhilian.common.core.domain.Result;
-import com.zhilian.common.resolver.domain.ResolverMalfunctionLog;
-import com.zhilian.resolver.service.MalfunctionService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-/**
-  * @ClassName MalfunctionController
-  * @Description 解析故障日志控制层 测试
-  * @Author Can.J
-  * @Date  2024/4/10 11:13
- */
-@RestController
-@RequestMapping("/malfunction")
-public class MalfunctionController {
-    @Autowired
-    private MalfunctionService malfunctionService;
-
-    /**
-     *  解析故障日志添加 测试
-     * @param resolverMalfunctionLog
-     * @return
-     */
-    @PostMapping("/resolverMalfunctionInsert")
-    public Result resolverMalfunctionInsert(@RequestBody ResolverMalfunctionLog resolverMalfunctionLog){
-        Result resolverMalfunctionInsert =malfunctionService.resolverMalfunctionInsert(resolverMalfunctionLog);
-        return resolverMalfunctionInsert;
-    }
-}

zhilian-modules/zhilian-resolver/src/main/java/com/zhilian/resolver/mapper/MalfunctionMapper.java

@@ -1,11 +0,0 @@
-package com.zhilian.resolver.mapper;
-
-import com.zhilian.common.core.domain.Result;
-import com.zhilian.common.resolver.domain.ResolverMalfunctionLog;
-import org.apache.ibatis.annotations.Mapper;
-
-@Mapper
-public interface MalfunctionMapper {
-    Result resolverMalfunctionInsert(ResolverMalfunctionLog resolverMalfunctionLog);
-
-}

zhilian-modules/zhilian-resolver/src/main/java/com/zhilian/resolver/service/MalfunctionService.java

@@ -1,9 +0,0 @@
-package com.zhilian.resolver.service;
-
-import com.zhilian.common.core.domain.Result;
-import com.zhilian.common.resolver.domain.ResolverMalfunctionLog;
-
-public interface MalfunctionService {
-    Result resolverMalfunctionInsert(ResolverMalfunctionLog resolverMalfunctionLog);
-
-}

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

@@ -1,23 +0,0 @@
-package com.zhilian.resolver.service.impl;
-
-import com.zhilian.common.core.domain.Result;
-import com.zhilian.common.resolver.domain.ResolverMalfunctionLog;
-import com.zhilian.resolver.mapper.MalfunctionMapper;
-import com.zhilian.resolver.service.MalfunctionService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-/**
-  * @ClassName MalfunctionServiceImpl
-  * @Description 解析故障日志业务实现层 测试
-  * @Author Can.J
-  * @Date  2024/4/10 11:12
- */
-@Service
-public class MalfunctionServiceImpl implements MalfunctionService {
-    @Autowired
-    private MalfunctionMapper malfunctionMapper;
-    @Override
-    public Result resolverMalfunctionInsert(ResolverMalfunctionLog resolverMalfunctionLog) {
-        return malfunctionMapper.resolverMalfunctionInsert(resolverMalfunctionLog);
-    }
-}

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;
@@ -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,10 +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.ResolverMalfunctionLog;
 import com.zhilian.common.resolver.domain.ResolverReportData;
 import com.zhilian.resolver.mapper.UserMapper;
 import com.zhilian.resolver.service.ResolverEventService;
@@ -14,6 +11,8 @@ 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;
 
 /**
@@ -49,178 +48,146 @@ public class MalfunctionEventServiceImpl implements ResolverEventService {
         if(isAnyFieldZero(vehicleData)){
             resolverReportInfoService.saveDataToDatabaseByMalfunction(vehicleData);
 
-                    BusinessBreak businessBreak = new BusinessBreak();
+            BreakLog breakLog = new BreakLog();
-                    businessBreak.setBreakVin(vehicleData.getVin());
+            breakLog.setBreakVin(vehicleData.getVin());
-
-                    //测试故障日志添加
-                    ResolverMalfunctionLog resolverMalfunctionLog = new ResolverMalfunctionLog();
-                    resolverMalfunctionLog.setMalfunctionVin(vehicleData.getVin());
 
             //     * 车辆状态 1：正常 0：故障
             if(vehicleData.getVehicleStatus()==0){
-                        businessBreak.setBreakCode("CL001");
+                breakLog.setBreakCode("CL001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("车体故障");
-                        businessBreak.setBreakType("车体故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
-                        remoteBreakService.add(businessBreak);
-
-                        //测试故障日志添加
-                        resolverMalfunctionLog.setMalfunctionCode("CL001");
-
-
             }
 
             //     * 充电状态 1：正常 0：故障
             //    private int chargingStatus;
             if(vehicleData.getChargingStatus()==0){
-                        businessBreak.setBreakCode("CD001");
+                breakLog.setBreakCode("CD001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("电池故障");
-                        businessBreak.setBreakType("电池故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
-                        remoteBreakService.add(businessBreak);
             }
 
             //     * 运行状态 1：正常 0：故障
             if(vehicleData.getOperatingStatus()==0){
-                        businessBreak.setBreakCode("DW001");
+                breakLog.setBreakCode("DW001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("行驶故障");
-                        businessBreak.setBreakType("行驶故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
-                        remoteBreakService.add(businessBreak);
             }
 
             //     * SOC 状态 1：正常 0：故障
             if(vehicleData.getSocStatus()==0){
-                        businessBreak.setBreakCode("SOC001");
+                breakLog.setBreakCode("SOC001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("电池故障");
-                        businessBreak.setBreakType("电池故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
-                        remoteBreakService.add(businessBreak);
             }
 
             //     可充电储能装置工作状态 1：正常 0：故障;
             if(vehicleData.getChargingEnergyStorageStatus()==0){
-                        businessBreak.setBreakCode("CDC001");
+                breakLog.setBreakCode("CDC001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("电池故障");
-                        businessBreak.setBreakType("电池故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
-                        remoteBreakService.add(businessBreak);
             }
 
             //      驱动电机状态 1：正常 0：故障
             if(vehicleData.getDriveMotorStatus()==0){
-                        businessBreak.setBreakCode("DJ001");
+                breakLog.setBreakCode("DJ001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("电机故障");
-                        businessBreak.setBreakType("电机故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
-                        remoteBreakService.add(businessBreak);
             }
 
             //     定位是否有效 1：有效 0：无效
             if(vehicleData.getPositionStatus()==0){
-                        businessBreak.setBreakCode("SOC001");
+                breakLog.setBreakCode("SOC001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("定位故障");
-                        businessBreak.setBreakType("定位故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
-                        remoteBreakService.add(businessBreak);
             }
 
             //     * EAS(汽车防盗系统)状态 1：正常 0：故障
             if(vehicleData.getEasStatus()==0){
-                        businessBreak.setBreakCode("EAS001");
+                breakLog.setBreakCode("EAS001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("EAS故障");
-                        businessBreak.setBreakType("EAS故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
-                        remoteBreakService.add(businessBreak);
             }
 
             //     * PTC(电动加热器)状态 1：正常 0：故障
             if(vehicleData.getPtcStatus()==0){
-                        businessBreak.setBreakCode("PTC001");
+                breakLog.setBreakCode("PTC001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("加热故障");
-                        businessBreak.setBreakType("加热故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
-                        remoteBreakService.add(businessBreak);
             }
 
             //     * EPS(电动助力系统)状态 1：正常 0：故障
             if(vehicleData.getEpsStatus()==0){
-                        businessBreak.setBreakCode("EPS001");
+                breakLog.setBreakCode("EPS001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("电动助力故障");
-                        businessBreak.setBreakType("电动助力故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
-                        remoteBreakService.add(businessBreak);
             }
 
             //     * ABS(防抱死)状态 1：正常 0：故障
             if(vehicleData.getAbsStatus()==0){
-                        businessBreak.setBreakCode("ABS001");
+                breakLog.setBreakCode("ABS001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("ABS故障");
-                        businessBreak.setBreakType("ABS故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
-                        remoteBreakService.add(businessBreak);
             }
 
             //     *  MCU(电机/逆变器)状态 1：正常 0：故障
             if(vehicleData.getMcuStatus()==0){
-                        businessBreak.setBreakCode("MCU001");
+                breakLog.setBreakCode("MCU001");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("MCU故障");
-                        businessBreak.setBreakType("MCU故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
-                        remoteBreakService.add(businessBreak);
             }
 
             //     *  动力电池加热状态 1：正常 0：故障
             if(vehicleData.getHeatingStatus()==0){
-                        businessBreak.setBreakCode("DC002");
+                breakLog.setBreakCode("DC002");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("电池故障");
-                        businessBreak.setBreakType("电池故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
-                        remoteBreakService.add(businessBreak);
             }
 
             //     * 动力电池当前状态 1：正常 0：故障
             if(vehicleData.getBatteryStatus()==0){
-                        businessBreak.setBreakCode("DC003");
+                breakLog.setBreakCode("DC003");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("电池故障");
-                        businessBreak.setBreakType("电池故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
-                        remoteBreakService.add(businessBreak);
             }
 
             //     *  动力电池保温状态 1：正常 0：故障
             if(vehicleData.getBatteryInsulationStatus()==0){
-                        businessBreak.setBreakCode("DC004");
+                breakLog.setBreakCode("DC004");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("电池故障");
-                        businessBreak.setBreakType("电池故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
-                        remoteBreakService.add(businessBreak);
             }
 
             //     *  DCDC(电力交换系统) 状态 1：正常 0：故障
             if(vehicleData.getDcdcStatus()==0){
-                        businessBreak.setBreakCode("DCDC005");
+                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){
-                        businessBreak.setBreakCode("CDJ005");
+                breakLog.setBreakCode("CDJ005");
-                        businessBreak.setBreakDate(new Date());
+                breakLog.setBreakType("电力故障");
-                        businessBreak.setBreakType("电力故障");
+                breakLog.setBreakState("1");
-                        businessBreak.setBreakState("1");
+
-                        remoteBreakService.add(businessBreak);
             }
 
+            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()){
+                // 将Redis中的数据遍历，逐条插入数据库
+                for (BreakLog breakLogs : breakLogsFromRedis) {
+                    remoteBreakService.logAdd(breakLogs);
+                }
+            }else {
+                log.info("没有找到对应VIN的故障记录在Redis中，无需同步到数据库");
+            }
 
-//                    String key = "breakdown";
-                    String value = JSON.toJSONString(businessBreak);
-                    redisService.setCacheObject("breakdown:gz:"+vehicleData.getVin(),value);
             long expireTime = 30;
             redisService.expire("breakdown:gz:"+vehicleData.getVin(), expireTime, TimeUnit.MINUTES);
 

zhilian-modules/zhilian-resolver/src/main/resources/mapper/resolver/MalfunctionMapper.xml

@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-<!DOCTYPE mapper
-        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
-        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="com.zhilian.resolver.mapper.MalfunctionMapper">
-
-    <insert id="resolverMalfunctionInsert">
-        INSERT INTO `vehicle-resolver`.`resolver_malfunction_log` (`malfunction_code`, `malfunction_vin`, `start_time`, `break_type`, `end_time`, `malfunction_tag`)
-        VALUES (#{malfunctionCode}, #{malfunctionVin}, #{startTime}, #{breakType}, #{endTime}, #{malfunctionTag});
-    </insert>
-</mapper>