first-dev
/
smart-cloud-server
5
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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
master_suzejing
xiaoSu 2024-04-11 15:27:43 +08:00
parent 3c1b9cef33 08acad4531
commit b8de8285b7
16 changed files with 317 additions and 327 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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;
}

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

@ -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
public Result add(@RequestBody BusinessBreak businessBreak);
@PostMapping("logAdd")
public Result logAdd(@RequestBody BreakLog breakLog);
@GetMapping("/checkIfBreakLogExists/{breakCode}/{breakVin}")
public ResponseEntity<Boolean> checkIfBreakLogExists(@PathVariable("breakCode") String breakCode, @PathVariable("breakVin") String breakVin);
}

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

@ -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("故障日志服务调用失败");
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("故障日志服务调用失败");
// }
// };
}
}

23
zhilian-common/zhilian-common-resolver/src/main/java/com/zhilian/common/resolver/ErrorCar.java
View File

@ -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;
}

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

@ -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.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
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);
}
}

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

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

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

@ -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);
}

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

@ -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);
}

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

@ -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;
}
}

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

@ -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();

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

@ -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

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

@ -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>

3
zhilian-modules/zhilian-resolver/src/main/java/com/zhilian/resolver/ZhiLianResolverApplication.java
View File

@ -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);

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

@ -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);

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

@ -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
// 廊坊经度:116.683752 维度:39.538047
geoFence.setLongitudeAndLatitude("39.538047,116.683752;39.538047,116.683752;39.538047,116.683752;39.538047,116.683752");
// 39.958897,116.179075; 39.950476,116.330823; 39.865149,116.290311; 39.881485,116.083631
// 廊坊经度：116.683752 维度：39.538047
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(",");
latitudes[i] = parseDouble(coordinates[0]);
longitudes[i] = parseDouble(coordinates[1]);
String[] coordinate = coordinates.get(i).split(",");
latitudes[i] = parseDouble(coordinate[0]);
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();

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

@ -1,7 +1,5 @@
package com.zhilian.resolver.service.impl.eventMalfunction;
import com.alibaba.fastjson.JSON;
import com.zhilian.business.domain.BusinessBreak;
import com.zhilian.business.domain.BreakLog;
import com.zhilian.business.remote.RemoteBreakService;
import com.zhilian.common.redis.service.RedisService;
import com.zhilian.common.resolver.domain.ResolverReportData;
@ -10,9 +8,13 @@ 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;
/**
@ -39,6 +41,9 @@ public class MalfunctionEventServiceImpl implements ResolverEventService {
@Autowired
private ResolverReportInfoService resolverReportInfoService;
/**
* 远程调用 BreakLog服务
*/
@Autowired
private RemoteBreakService remoteBreakService;
@ -48,168 +53,147 @@ public class MalfunctionEventServiceImpl implements ResolverEventService {
if(isAnyFieldZero(vehicleData)){
resolverReportInfoService.saveDataToDatabaseByMalfunction(vehicleData);
BusinessBreak businessBreak = new BusinessBreak();
businessBreak.setBreakVin(vehicleData.getVin());
BreakLog breakLog = new BreakLog();
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);
breakLog.setBreakCode("CL001");
breakLog.setBreakType("车体故障");
breakLog.setBreakState("1");
}
// * 充电状态 1：正常 0：故障
// private int chargingStatus;
if(vehicleData.getChargingStatus()==0){
businessBreak.setBreakCode("CD001");
businessBreak.setBreakDate(new Date());
businessBreak.setBreakType("电池故障");
businessBreak.setBreakState("1");
remoteBreakService.add(businessBreak);
breakLog.setBreakCode("CD001");
breakLog.setBreakType("电池故障");
breakLog.setBreakState("1");
}
// * 运行状态 1：正常 0：故障
if(vehicleData.getOperatingStatus()==0){
businessBreak.setBreakCode("DW001");
businessBreak.setBreakDate(new Date());
businessBreak.setBreakType("行驶故障");
businessBreak.setBreakState("1");
remoteBreakService.add(businessBreak);
breakLog.setBreakCode("DW001");
breakLog.setBreakType("行驶故障");
breakLog.setBreakState("1");
}
// * SOC 状态 1：正常 0：故障
if(vehicleData.getSocStatus()==0){
businessBreak.setBreakCode("SOC001");
businessBreak.setBreakDate(new Date());
businessBreak.setBreakType("电池故障");
businessBreak.setBreakState("1");
remoteBreakService.add(businessBreak);
breakLog.setBreakCode("SOC001");
breakLog.setBreakType("电池故障");
breakLog.setBreakState("1");
}
// 可充电储能装置工作状态 1：正常 0：故障;
if(vehicleData.getChargingEnergyStorageStatus()==0){
businessBreak.setBreakCode("CDC001");
businessBreak.setBreakDate(new Date());
businessBreak.setBreakType("电池故障");
businessBreak.setBreakState("1");
remoteBreakService.add(businessBreak);
breakLog.setBreakCode("CDC001");
breakLog.setBreakType("电池故障");
breakLog.setBreakState("1");
}
// 驱动电机状态 1：正常 0：故障
if(vehicleData.getDriveMotorStatus()==0){
businessBreak.setBreakCode("DJ001");
businessBreak.setBreakDate(new Date());
businessBreak.setBreakType("电机故障");
businessBreak.setBreakState("1");
remoteBreakService.add(businessBreak);
breakLog.setBreakCode("DJ001");
breakLog.setBreakType("电机故障");
breakLog.setBreakState("1");
}
// 定位是否有效 1：有效 0：无效
if(vehicleData.getPositionStatus()==0){
businessBreak.setBreakCode("SOC001");
businessBreak.setBreakDate(new Date());
businessBreak.setBreakType("定位故障");
businessBreak.setBreakState("1");
remoteBreakService.add(businessBreak);
breakLog.setBreakCode("SOC001");
breakLog.setBreakType("定位故障");
breakLog.setBreakState("1");
}
// * EAS(汽车防盗系统)状态 1：正常 0：故障
if(vehicleData.getEasStatus()==0){
businessBreak.setBreakCode("EAS001");
businessBreak.setBreakDate(new Date());
businessBreak.setBreakType("EAS故障");
businessBreak.setBreakState("1");
remoteBreakService.add(businessBreak);
breakLog.setBreakCode("EAS001");
breakLog.setBreakType("EAS故障");
breakLog.setBreakState("1");
}
// * PTC(电动加热器)状态 1：正常 0：故障
if(vehicleData.getPtcStatus()==0){
businessBreak.setBreakCode("PTC001");
businessBreak.setBreakDate(new Date());
businessBreak.setBreakType("加热故障");
businessBreak.setBreakState("1");
remoteBreakService.add(businessBreak);
breakLog.setBreakCode("PTC001");
breakLog.setBreakType("加热故障");
breakLog.setBreakState("1");
}
// * EPS(电动助力系统)状态 1：正常 0：故障
if(vehicleData.getEpsStatus()==0){
businessBreak.setBreakCode("EPS001");
businessBreak.setBreakDate(new Date());
businessBreak.setBreakType("电动助力故障");
businessBreak.setBreakState("1");
remoteBreakService.add(businessBreak);
breakLog.setBreakCode("EPS001");
breakLog.setBreakType("电动助力故障");
breakLog.setBreakState("1");
}
// * ABS(防抱死)状态 1：正常 0：故障
if(vehicleData.getAbsStatus()==0){
businessBreak.setBreakCode("ABS001");
businessBreak.setBreakDate(new Date());
businessBreak.setBreakType("ABS故障");
businessBreak.setBreakState("1");
remoteBreakService.add(businessBreak);
breakLog.setBreakCode("ABS001");
breakLog.setBreakType("ABS故障");
breakLog.setBreakState("1");
}
// * MCU(电机/逆变器)状态 1：正常 0：故障
if(vehicleData.getMcuStatus()==0){
businessBreak.setBreakCode("MCU001");
businessBreak.setBreakDate(new Date());
businessBreak.setBreakType("MCU故障");
businessBreak.setBreakState("1");
remoteBreakService.add(businessBreak);
breakLog.setBreakCode("MCU001");
breakLog.setBreakType("MCU故障");
breakLog.setBreakState("1");
}
// * 动力电池加热状态 1：正常 0：故障
if(vehicleData.getHeatingStatus()==0){
businessBreak.setBreakCode("DC002");
businessBreak.setBreakDate(new Date());
businessBreak.setBreakType("电池故障");
businessBreak.setBreakState("1");
remoteBreakService.add(businessBreak);
breakLog.setBreakCode("DC002");
breakLog.setBreakType("电池故障");
breakLog.setBreakState("1");
}
// * 动力电池当前状态 1：正常 0：故障
if(vehicleData.getBatteryStatus()==0){
businessBreak.setBreakCode("DC003");
businessBreak.setBreakDate(new Date());
businessBreak.setBreakType("电池故障");
businessBreak.setBreakState("1");
remoteBreakService.add(businessBreak);
breakLog.setBreakCode("DC003");
breakLog.setBreakType("电池故障");
breakLog.setBreakState("1");
}
// * 动力电池保温状态 1：正常 0：故障
if(vehicleData.getBatteryInsulationStatus()==0){
businessBreak.setBreakCode("DC004");
businessBreak.setBreakDate(new Date());
businessBreak.setBreakType("电池故障");
businessBreak.setBreakState("1");
remoteBreakService.add(businessBreak);
breakLog.setBreakCode("DC004");
breakLog.setBreakType("电池故障");
breakLog.setBreakState("1");
}
// * DCDC(电力交换系统) 状态 1：正常 0：故障
if(vehicleData.getDcdcStatus()==0){
businessBreak.setBreakCode("DCDC005");
businessBreak.setBreakDate(new Date());
businessBreak.setBreakType("电力故障");
businessBreak.setBreakState("1");
remoteBreakService.add(businessBreak);
breakLog.setBreakCode("DCDC005");
breakLog.setBreakType("电力故障");
breakLog.setBreakState("1");
}
// * CHG(充电机)状态 1：正常 0：故障
if(vehicleData.getChgStatus()==0){
businessBreak.setBreakCode("CDJ005");
businessBreak.setBreakDate(new Date());
businessBreak.setBreakType("电力故障");
businessBreak.setBreakState("1");
remoteBreakService.add(businessBreak);
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()){
// 检查第一条故障记录是否已存在于数据库中
BreakLog firstBreakLog = breakLogsFromRedis.iterator().next();
if (!isInDatabase(firstBreakLog)) {
remoteBreakService.logAdd(firstBreakLog);
}
}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);
@ -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();
}
}