From b6f3de8451867d85242b2bd706fcfa4a65df4ff7 Mon Sep 17 00:00:00 2001
From: puzhibing <393733352@qq.com>
Date: 星期六, 11 四月 2026 02:46:30 +0800
Subject: [PATCH] Merge branch 'master' of http://120.76.84.145:10101/gitblit/r/java/Robotaxi
---
xp-robotaxi-automatic-pilot-boot/src/main/java/com/xiaopeng/automaticPilot/service/KafkaConsumerService.java | 1108 ++++++++++++++++++++++++++++++++++++++++++----------------
1 files changed, 800 insertions(+), 308 deletions(-)
diff --git a/xp-robotaxi-automatic-pilot-boot/src/main/java/com/xiaopeng/automaticPilot/service/KafkaConsumerService.java b/xp-robotaxi-automatic-pilot-boot/src/main/java/com/xiaopeng/automaticPilot/service/KafkaConsumerService.java
index 275b682..468af59 100644
--- a/xp-robotaxi-automatic-pilot-boot/src/main/java/com/xiaopeng/automaticPilot/service/KafkaConsumerService.java
+++ b/xp-robotaxi-automatic-pilot-boot/src/main/java/com/xiaopeng/automaticPilot/service/KafkaConsumerService.java
@@ -1,69 +1,70 @@
package com.xiaopeng.automaticPilot.service;
-import cn.hutool.core.util.IdUtil;
+import cn.hutool.core.lang.Snowflake;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.util.JsonFormat;
+import com.xiaopeng.api.dto.automaticPilot.MqttPublishDto;
+import com.xiaopeng.api.dto.automaticPilot.PushOrderDto;
+import com.xiaopeng.api.dto.automaticPilot.VehicleEventDTO;
import com.xiaopeng.api.dto.map.OrderRouteAndFareDto;
import com.xiaopeng.api.dto.operation.CruisePointDto;
import com.xiaopeng.api.dto.operation.LonLatDto;
import com.xiaopeng.api.dto.operation.ReassignOrderDTO;
+import com.xiaopeng.api.dto.order.AddCruiseMissionDto;
import com.xiaopeng.api.dto.order.PopOrderDto;
import com.xiaopeng.api.dto.pushMessage.PushOrderRouteDTO;
import com.xiaopeng.api.dto.pushMessage.SendMessageDTO;
+import com.xiaopeng.api.dto.vehicleConvoy.UpdateVehicleStateDto;
+import com.xiaopeng.api.feignClient.automaticPilot.VehicleBuriedPointClient;
+import com.xiaopeng.api.feignClient.maintenance.XpTaskClient;
import com.xiaopeng.api.feignClient.map.XpMapClient;
import com.xiaopeng.api.feignClient.operation.ReassignOrderClient;
import com.xiaopeng.api.feignClient.operation.XpCruisePlanClient;
import com.xiaopeng.api.feignClient.order.XpCruiseOrderClient;
import com.xiaopeng.api.feignClient.order.XpOrderClient;
+import com.xiaopeng.api.feignClient.order.XpTestOrderClient;
import com.xiaopeng.api.feignClient.pushMessage.XpPushMessageClient;
import com.xiaopeng.api.feignClient.vehicleConvoy.UserVehicleClient;
import com.xiaopeng.api.feignClient.vehicleConvoy.XpVehicleClient;
import com.xiaopeng.api.model.order.XpCruiseOrder;
import com.xiaopeng.api.model.order.XpOrder;
+import com.xiaopeng.api.model.order.XpTestOrder;
import com.xiaopeng.api.model.vehicleConvoy.XpVehicle;
import com.xiaopeng.api.vo.OrderType;
-import com.xiaopeng.api.vo.SystemEventType;
import com.xiaopeng.api.vo.automaticPilot.VehiclePosition;
import com.xiaopeng.api.vo.automaticPilot.protobuf.*;
-import com.xiaopeng.api.vo.automaticPilot.protobuf.AbnormalReason;
-import com.xiaopeng.api.vo.automaticPilot.protobuf.GearLevel;
-import com.xiaopeng.api.vo.automaticPilot.protobuf.OrderPhase;
-import com.xiaopeng.api.vo.automaticPilot.protobuf.OrderStatusInfo;
-import com.xiaopeng.api.vo.automaticPilot.protobuf.RealtimePose;
-import com.xiaopeng.api.vo.automaticPilot.protobuf.ResponseMessage;
-import com.xiaopeng.api.vo.automaticPilot.protobuf.RtTripInfo;
-import com.xiaopeng.api.vo.automaticPilot.protobuf.StatusCode;
-import com.xiaopeng.api.vo.automaticPilot.protobuf.VehicleDynamicStatus;
-import com.xiaopeng.api.vo.automaticPilot.protobuf.VehicleStaticInfo;
-import com.xiaopeng.api.vo.automaticPilot.protobuf.VehicleStatus;
-import com.xiaopeng.api.vo.automaticPilot.protobuf.Wgs;
import com.xiaopeng.api.vo.operation.RouteVo;
+import com.xiaopeng.api.vo.order.OrderTrajectoryVo;
import com.xiaopeng.api.vo.vehicleConvoy.CancelTaxiPassengerVo;
import com.xiaopeng.automaticPilot.util.XPUUtil;
import com.xiaopeng.common.core.constant.CacheConstants;
+import com.xiaopeng.common.core.constant.Constants;
import com.xiaopeng.common.core.domain.R;
+import com.xiaopeng.common.core.enums.CancelOrderSceneEnum;
import com.xiaopeng.common.core.enums.OrderStatusEnum;
import com.xiaopeng.common.core.enums.PushMessageTypeEnum;
-import com.xiaopeng.common.core.utils.SnowFlake;
import com.xiaopeng.common.core.utils.StringUtils;
import com.xiaopeng.common.core.utils.uuid.UUID;
import com.xiaopeng.common.redis.service.RedisService;
import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.geo.Point;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.geo.GeoJsonPoint;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.core.query.Update;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.*;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
-;
/**
* Kafka 消费者服务
@@ -71,6 +72,8 @@
@Slf4j
@Service
public class KafkaConsumerService {
+ private static final String REASSIGN_CANCEL_CONTEXT_PREFIX = "REASSIGN_CANCEL_CONTEXT:";
+
@Resource
private XpMapClient xpMapClient;
@@ -108,6 +111,24 @@
@Resource
private XpCruisePlanClient xpCruisePlanClient;
+ @Resource(name = "hutoolSnowflake")
+ private Snowflake snowflake;
+
+ @Value("${robotaxi.appId:xp_robotaxi_api}")
+ private String appid;
+
+ @Resource
+ private XpTaskClient xpTaskClient;
+ @Resource
+ private VehicleBuriedPointClient vehicleBuriedPointClient;
+
+ @Resource
+ private XpTestOrderClient testOrderClient;
+
+ private static final JsonFormat.Printer jsonPrinter = JsonFormat.printer()
+ .printingEnumsAsInts()
+ .preservingProtoFieldNames();
+
/**
@@ -135,11 +156,24 @@
private MsgContent parseMsgContent(String message) {
try {
+ // 首先解析外层JSON，提取payload字段
+ JSONObject outerJson = JSON.parseObject(message);
+ String payload = outerJson.getString("payload");
+
+ if (StringUtils.isEmpty(payload)) {
+ log.error("Payload is empty in message: {}", message);
+ return null;
+ }
+
+ // 使用payload构建MsgContent
MsgContent.Builder builder = MsgContent.newBuilder();
- JsonFormat.parser().ignoringUnknownFields().merge(message, builder);
+ JsonFormat.parser().ignoringUnknownFields().merge(payload, builder);
return builder.build();
} catch (InvalidProtocolBufferException e) {
log.error("Failed to parse message: {}", message, e);
+ return null;
+ } catch (Exception e) {
+ log.error("Failed to extract payload from message: {}", message, e);
return null;
}
}
@@ -223,29 +257,44 @@
log.info("消息不在处理范围内，忽略：{}", message);
}
}
- //TODO 这里的逻辑要再确认下
//消息应答
- if(MessageType.MESSAGE_TYPE_RESPONSE == type){
- ResponseMessage response = msgContent.getResponse();
- StatusCode code = response.getCode();
- long requestSeq = response.getRequestSeq();
- if(code == StatusCode.OK){
- Object sequence = redisTemplate.opsForValue().get(requestSeq);
- if(sequence!=null){
- JSONObject jsonObject = JSON.parseObject(sequence.toString());
- String event = jsonObject.getString("event");
- //推送导航的响应消息
- if(SystemEventType.PUSH_NAVIGATION.equals(event)){
+ if(MessageType.MESSAGE_TYPE_RESPONSE == type) {
+ //区分业务类型
+ int cmdValue = header.getCmd();
+ RTCmdType cmd = RTCmdType.getByValue(cmdValue);
+ if (cmd == null) {
+ log.warn("Unknown cmd value: {}", cmdValue);
+ return;
+ }
+ //云端下发订单的响应报文
+ if (cmd == RTCmdType.CLOUD_SEND_RT_TASK) {
+ RtTaskListResponse response = msgContent.getRtTaskListResponse();
+ try {
+ log.info("云端下发订单操作的响应消息 (XPU→云端)：{}", jsonPrinter.print(response));
+ Object sequence = redisService.getCacheObject("CREATE_ORDER:" + response.getResults().getOrderId());
+ if(sequence!=null){
+ JSONObject jsonObject = JSON.parseObject(sequence.toString());
String orderId = jsonObject.getString("orderId");
String vin = jsonObject.getString("vin");
String orderType = jsonObject.getString("orderType");
PopOrderDto dto = new PopOrderDto();
- dto.setOrderId(Long.valueOf(orderId));
+ if(orderId.contains("XU")){
+ dto.setOrderId(Long.valueOf(orderId.substring(2)));
+ }else if(orderId.contains("TEST")){
+ dto.setOrderId(Long.valueOf(orderId.substring(4)));
+ }else{
+ dto.setOrderId(Long.valueOf(orderId));
+ }
dto.setXpVehicleVin(vin);
dto.setOrderType(orderType);
xpOrderClient.popOrder(dto);
+ log.info("订单状态更新：{}", response.getResults().getOrderId());
}
+ } catch (InvalidProtocolBufferException e) {
+ log.error("Failed to print RtTaskListResponse: {}", response, e);
}
+ } else {
+ log.info("响应消息不在处理范围内，忽略：{}", message);
}
}
}
@@ -278,52 +327,89 @@
long sequence = msgContent.getHeader().getSequence();
responseMessage(sequence, vin);
//保存车辆实时位置到redis
- redisTemplate.opsForGeo().add("vehiclePosition:" + vin, new Point(longitude, latitude), vin);
-
- //保存车辆实时信息到mongodb
- VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(vin)), VehiclePosition.class);
- if (null == vehiclePosition) {
- vehiclePosition = new VehiclePosition();
+ if(0 != longitude && 0 != latitude){
+ redisTemplate.opsForGeo().add("vehiclePosition:" + vin, new Point(longitude, latitude), vin);
}
- vehiclePosition.setVin(vin);
- vehiclePosition.setPoint(new GeoJsonPoint(longitude, latitude));
- vehiclePosition.setCourse(course);
- vehiclePosition.setAlt(alt);
+
VehicleStatus vehicleStatus = systemRuntimeStatus.getVehicleStatus();
+ OrderStatusInfo runningOrderStatusInfo = systemRuntimeStatus.getRunningOrderStatusInfo();
+ String order_id = runningOrderStatusInfo.getOrderId();
//车辆动态信息
VehicleDynamicStatus dynamicStatus = vehicleStatus.getDynamicStatus();
- vehiclePosition.setSpeed(dynamicStatus.getSpeed());
- vehiclePosition.setCurrentElectricity(dynamicStatus.getBmsSocDisp());
- vehiclePosition.setMileageRange(dynamicStatus.getDstBatDisp());
- //订单信息
- OrderStatusInfo runningOrderStatusInfo = systemRuntimeStatus.getRunningOrderStatusInfo();
Long orderId = null;
- String order_id = runningOrderStatusInfo.getOrderId();
- vehiclePosition.setHasOrder(0);
+ Integer hasOrder = 0;
if (StringUtils.isNotEmpty(order_id)) {
if (order_id.contains("XU")) {
- vehiclePosition.setHasOrder(1);
+ hasOrder = 1;
orderId = Long.parseLong(order_id.substring(2));
- } else {
+ } else if(order_id.contains("TEST")) {
+ orderId = Long.parseLong(order_id.substring(4));
+ }else{
orderId = Long.parseLong(order_id);
}
}
- vehiclePosition.setOrderId(orderId);
- mongoTemplate.save(vehiclePosition);
- //调用推送服务接口
- if (null != orderId) {
- RtTripInfo rtTripInfo = systemRuntimeStatus.getRtTripInfo();
- PushOrderRouteDTO dto = new PushOrderRouteDTO();
- dto.setOrderId(orderId);
- dto.setRouteType(order_id.contains("XU") ? 2 : 1);
- dto.setLongitude(longitude);
- dto.setLatitude(latitude);
- //TODO 这两个字段现在拿不到
+ //保存车辆实时信息到mongodb
+ if(0 != longitude && 0 != latitude){
+ VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(vin)), VehiclePosition.class);
+ if (null == vehiclePosition) {
+ vehiclePosition = new VehiclePosition();
+ vehiclePosition.setVin(vin);
+ vehiclePosition.setPoint(new GeoJsonPoint(longitude, latitude));
+ vehiclePosition.setCourse(course);
+ vehiclePosition.setAlt(alt);
+ vehiclePosition.setSpeed(dynamicStatus.getSpeed());
+ vehiclePosition.setCurrentElectricity(dynamicStatus.getBmsSocDisp());
+ vehiclePosition.setMileageRange(dynamicStatus.getDstBatDisp());
+ vehiclePosition.setOrderId(orderId);
+ vehiclePosition.setTotalOdometer(dynamicStatus.getTotalOdometer());
+ vehiclePosition.setAddTime(System.currentTimeMillis());
+ mongoTemplate.save(vehiclePosition);
+ }else{
+ vehiclePosition.setOrderId(orderId);
+ Update update = new Update()
+ .set("point", new GeoJsonPoint(longitude, latitude))
+ .set("course", course)
+ .set("alt", alt)
+ .set("speed", dynamicStatus.getSpeed())
+ .set("currentElectricity", dynamicStatus.getBmsSocDisp())
+ .set("mileageRange", dynamicStatus.getDstBatDisp())
+ .set("hasOrder", hasOrder)
+ .set("orderId", orderId)
+ .set("totalOdometer", dynamicStatus.getTotalOdometer()
+ .set("addTime", System.currentTimeMillis()));
+ mongoTemplate.updateFirst(new Query(Criteria.where("vin").is(vin)), update, VehiclePosition.class);
+ }
+ //调用推送服务接口，给乘客推送剩余轨迹和里程时长
+ if (null != orderId && !order_id.contains("XU")) {
+ RtTripInfo rtTripInfo = systemRuntimeStatus.getRtTripInfo();
+ PushOrderRouteDTO dto = new PushOrderRouteDTO();
+ dto.setOrderId(orderId);
+ dto.setRouteType(1);
+ dto.setLongitude(longitude);
+ dto.setLatitude(latitude);
+ //TODO 这两个字段现在拿不到
// dto.setDuration(rtTripInfo.getRemaining_time());
// dto.setDistance(rtTripInfo.getRemaining_distance().intValue());
- xpPushMessageClient.pushOrderRoute(dto);
+// dto.setDirection();
+ //只有乘客订单需要推送剩余导航数据
+ if(!order_id.contains("TEST")){
+ xpPushMessageClient.pushOrderRoute(dto);
+ }
+
+ //存储历史轨迹
+ OrderTrajectoryVo orderTrajectory = new OrderTrajectoryVo();
+ orderTrajectory.setOrderId(orderId);
+ orderTrajectory.setLocation(longitude + "," + latitude);
+ orderTrajectory.setDirection(dto.getDirection());
+ orderTrajectory.setSpeed(0D);
+ orderTrajectory.setLocatetime(System.currentTimeMillis());
+ orderTrajectory.setCreateTime(new Date());
+ xpOrderClient.saveVehicleLocation(orderTrajectory);
+ }
}
}
+
+
/**
@@ -338,37 +424,90 @@
// 存储车辆挡位
GearLevel gearLevel = systemRuntimeStatus.getVehicleStatus().getDynamicStatus().getGearLevel();
int value = gearLevel.getNumber();
- redisTemplate.opsForValue().set(CacheConstants.GEAR_LEVEL + systemRuntimeStatus.getVehicleStatus().getStaticInfo().getXpuId(), value);
+ redisService.setCacheObject(CacheConstants.GEAR_LEVEL + systemRuntimeStatus.getVehicleStatus().getStaticInfo().getXpuId(), value);
// 判断是否为故障状态
+ XpVehicle vehicle = null;
if (abnormalReason == AbnormalReason.FAULT) {
log.info("车辆故障，开始处理故障");
- // TODO 添加异常任务
- // 解绑用户与车辆关系
- CancelTaxiPassengerVo cancelTaxiPassengerVo = new CancelTaxiPassengerVo();
String orderId = systemRuntimeStatus.getRunningOrderStatusInfo().getOrderId();
- XpOrder xpOrder = xpOrderClient.queryOrderById(Long.parseLong(orderId)).getData();
- XpVehicle vehicle = xpVehicleClient.queryById(xpOrder.getVehicleId()).getData();
- if (vehicle != null) {
- // 修改车辆状态
- vehicle.setOperatingStatus(4);
- xpVehicleClient.updateVehicleById(vehicle);
- cancelTaxiPassengerVo.setVin(vehicle.getVehicleVin());
- cancelTaxiPassengerVo.setUid(xpOrder.getAppUserId().toString());
- cancelTaxiPassengerVo.setOrderNo(xpOrder.getOrderNumber());
- userVehicleClient.cancelTaxiPassenger(cancelTaxiPassengerVo);
+ if(orderId.contains("XU")){
+ //巡游订单，需要关闭订单
+ xpCruiseOrderClient.cancelCruiseOrderById(Long.parseLong(orderId.substring(2)));
+ XpCruiseOrder cruiseOrder = xpCruiseOrderClient.getCruiseOrder(Long.parseLong(orderId.substring(2))).getData();
+ vehicle = xpVehicleClient.queryById(cruiseOrder.getVehicleId()).getData();
+ if (vehicle != null) {
+ // 修改车辆状态
+ XpVehicle vehicle1 = new XpVehicle();
+ vehicle1.setOperatingStatus(4);
+ vehicle1.setId(vehicle.getId());
+ xpVehicleClient.updateVehicleById(vehicle1);
+ }
+ }else if(orderId.contains("TEST")){
+ //测试订单故障则取消订单
+ testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), 0);
+ XpTestOrder testOrder = testOrderClient.queryOrderById(Long.parseLong(orderId.substring(4))).getData();
+ vehicle = xpVehicleClient.queryById(testOrder.getVehicleId()).getData();
+ if (vehicle != null) {
+ // 修改车辆状态
+ XpVehicle vehicle1 = new XpVehicle();
+ vehicle1.setOperatingStatus(4);
+ vehicle1.setId(vehicle.getId());
+ xpVehicleClient.updateVehicleById(vehicle1);
+ log.info("车辆故障，车辆状态修改0 {}", vehicle.getPlateNumber());
+ }
+ }else {
+ //正常订单
+ XpOrder xpOrder = xpOrderClient.queryOrderById(Long.parseLong(orderId)).getData();
+ vehicle = xpVehicleClient.queryById(xpOrder.getVehicleId()).getData();
+ if (vehicle != null) {
+ // 修改车辆状态
+ XpVehicle vehicle1 = new XpVehicle();
+ vehicle1.setState(0);
+ vehicle1.setOperatingStatus(4);
+ vehicle1.setId(vehicle.getId());
+ xpVehicleClient.updateVehicleById(vehicle1);
+ log.info("车辆故障，车辆状态修改0 {}", vehicle.getPlateNumber());
+ // 解绑用户与车辆关系
+ CancelTaxiPassengerVo cancelTaxiPassengerVo = new CancelTaxiPassengerVo();
+ cancelTaxiPassengerVo.setVin(vehicle.getVehicleVin());
+ cancelTaxiPassengerVo.setUid(xpOrder.getAppUserId().toString());
+ cancelTaxiPassengerVo.setOrderNo(xpOrder.getOrderNumber());
+ cancelTaxiPassengerVo.setAppId(appid);
+ userVehicleClient.cancelTaxiPassenger(cancelTaxiPassengerVo);
+ }
+ // TODO 重新派单
+ ReassignOrderDTO reassignOrderDTO = new ReassignOrderDTO();
+ reassignOrderDTO.setUid(xpOrder.getAppUserId().toString());
+ reassignOrderDTO.setOrderNo(xpOrder.getOrderNumber());
+ reassignOrderDTO.setCount(10);
+ RealtimePose pose = systemRuntimeStatus.getPose();
+ Wgs naviPose = pose.getNaviPose();
+ Double latitude = naviPose.getLatitude();
+ Double longitude = naviPose.getLongitude();
+ reassignOrderDTO.setLongitude(longitude);
+ reassignOrderDTO.setLatitude(latitude);
+ reassignOrderClient.reassignOrder(reassignOrderDTO);
}
- // TODO 重新派单
- ReassignOrderDTO reassignOrderDTO = new ReassignOrderDTO();
- reassignOrderDTO.setUid(xpOrder.getAppUserId().toString());
- reassignOrderDTO.setOrderNo(xpOrder.getOrderNumber());
- reassignOrderDTO.setCount(10);
- RealtimePose pose = systemRuntimeStatus.getPose();
- Wgs naviPose = pose.getNaviPose();
- Double latitude = naviPose.getLatitude();
- Double longitude = naviPose.getLongitude();
- reassignOrderDTO.setLongitude(longitude);
- reassignOrderDTO.setLatitude(latitude);
- reassignOrderClient.reassignOrder(reassignOrderDTO);
+ //添加车辆异常任务和发送消息
+ xpTaskClient.saveVehicleAccidentError(vehicle.getId());
+
+ // 封装埋点消息实体
+ VehicleEventDTO vehicleEventDTO = new VehicleEventDTO();
+ vehicleEventDTO.setVin(vehicle.getVehicleVin());
+ vehicleEventDTO.setXpuId("");
+ vehicleEventDTO.setOrderId("");
+ vehicleEventDTO.setEventKey("RT_web_vehicle_status_changed");
+ vehicleEventDTO.setEventTime(System.currentTimeMillis());
+ Map<String,Object> attributes = new HashMap<>();
+ attributes.put("vin",vehicle.getVehicleVin());
+ attributes.put("order_id","");
+ attributes.put("timestamp",vehicleEventDTO.getEventTime());
+ attributes.put("main_status","OFFLINE");
+ // TODO 预留位置 目前无状态
+ attributes.put("sub_status","");
+ attributes.put("prev_sub_status","");
+ vehicleEventDTO.setAttributes(attributes);
+ vehicleBuriedPointClient.sendVehicleEvent(vehicleEventDTO);
}
}
@@ -391,15 +530,15 @@
log.info("订单的任务未开始执行");
break;
case ROUTE_TO_PICKUP:
- log.info("驶往上车点的行程");
+ log.info("驶往上车点的行程 {}", orderId);
buildNaviRequest(requestId, orderId, orderPhase, msgContent.getHeader().getSequence());
break;
case ROUTE_TO_DESTINATION:
- log.info("驶往下车点的行程");
+ log.info("驶往下车点的行程 {}", orderId);
buildNaviRequest(requestId, orderId, orderPhase, msgContent.getHeader().getSequence());
break;
case ROUTE_TO_CRUISE:
- log.info("巡游阶段路线");
+ log.info("巡游阶段路线 {}", orderId);
buildNaviRequest(requestId, orderId, orderPhase, msgContent.getHeader().getSequence());
break;
}
@@ -412,79 +551,69 @@
* @param msgContent
*/
public void navigationDeviationEvent(MsgContent msgContent) {
- //先响应消息
- long sequence = msgContent.getHeader().getSequence();
//开始处理消息对应的业务逻辑
NavigationDeviationEvent deviationEvent = msgContent.getNaviDeviationEvent();
- // todo 请求id确认是否有这个参数
-// String requestId = deviationEvent.getRequestId();
- String requestId = "";
+ String requestId = deviationEvent.getNavigationDeviationMessage().getNaviRecalcRequestSeq() + "";
//导航id
String routeID = "";
Long vehicleId = null;
String orderType = "";
//偏航事件类型 1：请求导航，2：取消导航
-// if (deviationEvent.getEvent_type().equals(RtEventType.RT_EVENT_TYPE_REQUEST)) {
- NavigationDeviationMessage navigationDeviationMessage = deviationEvent.getNavigationDeviationMessage();
- String orderId = navigationDeviationMessage.getOrderId();
- String taskId = navigationDeviationMessage.getTaskId();
- Wgs wgs = navigationDeviationMessage.getPoint();
- Double longitude = wgs.getLongitude();
- Double latitude = wgs.getLatitude();
- //订单类型 1：乘客订单，2=巡游订单
- LonLatDto destination = new LonLatDto();
- LonLatDto origin = new LonLatDto();
+ NavigationDeviationMessage navigationDeviationMessage = deviationEvent.getNavigationDeviationMessage();
+ String orderId = navigationDeviationMessage.getOrderId();
+ String taskId = navigationDeviationMessage.getTaskId();
+ Wgs wgs = navigationDeviationMessage.getPoint();
+ Double longitude = wgs.getLongitude();
+ Double latitude = wgs.getLatitude();
+ //订单类型 1：乘客订单，2=巡游订单
+ LonLatDto destination = new LonLatDto();
+ LonLatDto origin = new LonLatDto();
- if (orderId.contains("XU")) {
- orderType = OrderType.CRUISE_ORDER;
+ if (orderId.contains("XU")) {
+ orderType = OrderType.CRUISE_ORDER;
- R<XpCruiseOrder> cruiseOrder = xpCruiseOrderClient.getCruiseOrder(orderId);
- XpCruiseOrder xpCruiseOrder = cruiseOrder.getData();
+ R<XpCruiseOrder> cruiseOrder = xpCruiseOrderClient.getCruiseOrder(Long.parseLong(orderId.substring(2)));
+ XpCruiseOrder xpCruiseOrder = cruiseOrder.getData();
- //先响应消息
- responseMessage(sequence, "");
- //构建导航数据给到车端
- origin.setLongitude(longitude);
- origin.setLatitude(latitude);
- destination.setLongitude(xpCruiseOrder.getEndLon());
- destination.setLatitude(xpCruiseOrder.getEndLat());
+ //构建导航数据给到车端
+ origin.setLongitude(longitude);
+ origin.setLatitude(latitude);
+ destination.setLongitude(xpCruiseOrder.getEndLon());
+ destination.setLatitude(xpCruiseOrder.getEndLat());
- OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
- dto.setOrderId(Long.parseLong(orderId));
- dto.setOrigin(origin);
- dto.setDestination(destination);
- R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
- if (200 != routeVoR.getCode()) {
- throw new RuntimeException("获取订单线路和运费失败");
- }
- RouteVo routeVo = routeVoR.getData();
- routeID = routeVo.getRouteID();
+ OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
+ dto.setOrderId(Long.parseLong(orderId.substring(2)));
+ dto.setOrigin(origin);
+ dto.setDestination(destination);
+ dto.setRouteType(3);
+ R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
+ if (200 != routeVoR.getCode()) {
+ throw new RuntimeException("获取订单线路和运费失败");
+ }
+ RouteVo routeVo = routeVoR.getData();
+ routeID = routeVo.getRouteID();
- vehicleId = xpCruiseOrder.getVehicleId();
- } else {
- orderType = OrderType.USER_ORDER;
- //正常单
- R<XpOrder> xpOrderR = xpOrderClient.queryOrderById(Long.parseLong(orderId));
- if (200 != xpOrderR.getCode()) {
- throw new RuntimeException("订单不存在");
- }
- XpOrder xpOrder = xpOrderR.getData();
- XpVehicle xpVehicle = xpVehicleClient.queryById(xpOrder.getVehicleId()).getData();
- //响应消息
- responseMessage(sequence, xpVehicle.getVehicleVin());
+ vehicleId = xpCruiseOrder.getVehicleId();
+ } else if(orderId.contains("TEST")){
+ R<XpTestOrder> cruiseOrder = testOrderClient.queryOrderById(Long.parseLong(orderId.substring(4)));
+ XpTestOrder testOrder = cruiseOrder.getData();
+ //区分测试单和测试巡游单
+ if(1 == testOrder.getOrderType()){
+ orderType = OrderType.TEST_ORDER;
//驶往上车点的行程
- if (Arrays.asList(3).contains(xpOrder.getStatus())) {
+ if (3 == testOrder.getStatus()) {
//查询司机当前位置到起点的线路
origin.setLongitude(longitude);
origin.setLatitude(latitude);
- destination.setLongitude(xpOrder.getStartLon());
- destination.setLatitude(xpOrder.getStartLat());
+ destination.setLongitude(testOrder.getStartLon());
+ destination.setLatitude(testOrder.getStartLat());
OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
- dto.setOrderId(Long.parseLong(orderId));
+ dto.setOrderId(Long.parseLong(orderId.substring(4)));
dto.setOrigin(origin);
dto.setDestination(destination);
+ dto.setRouteType(1);
R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
if (200 != routeVoR.getCode()) {
throw new RuntimeException("获取订单线路和运费失败");
@@ -492,19 +621,20 @@
RouteVo routeVo = routeVoR.getData();
routeID = routeVo.getRouteID();
//缓存数据，用于后续推给乘客导航线路
- redisService.setCacheObject("ORDER_NAVIGATION_START_DATA:" + xpOrder.getAppUserId(), JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
+ redisService.setCacheObject("TEST_ORDER_NAVIGATION_START_DATA:" + testOrder.getVehicleId(), JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
}
//驶往下车点的行程
- if (Arrays.asList(6).contains(xpOrder.getStatus())) {
+ if (6 == testOrder.getStatus()) {
origin.setLongitude(longitude);
origin.setLatitude(latitude);
- destination.setLongitude(xpOrder.getEndLon());
- destination.setLatitude(xpOrder.getEndLat());
+ destination.setLongitude(testOrder.getEndLon());
+ destination.setLatitude(testOrder.getEndLat());
OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
- dto.setOrderId(Long.parseLong(orderId));
+ dto.setOrderId(Long.parseLong(orderId.substring(4)));
dto.setOrigin(origin);
dto.setDestination(destination);
+ dto.setRouteType(2);
R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
if (200 != routeVoR.getCode()) {
throw new RuntimeException("获取订单线路和运费失败");
@@ -512,22 +642,96 @@
RouteVo routeVo = routeVoR.getData();
routeID = routeVo.getRouteID();
//缓存导航数据，用于后面的逻辑中给乘客端推送导航数据
- redisService.setCacheObject("ORDER_NAVIGATION_END_DATA:" + xpOrder.getAppUserId(), com.alibaba.fastjson.JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
+ redisService.setCacheObject("TEST_ORDER_NAVIGATION_END_DATA:" + testOrder.getVehicleId(), JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
}
- vehicleId = xpOrder.getVehicleId();
- }
- if(StringUtils.isNotEmpty(routeID)){
- XpVehicle xpVehicle = xpVehicleClient.queryById(vehicleId).getData();
- R<String> stringR = xpMapClient.queryRouted(routeID);
- if (200 != stringR.getCode()) {
- throw new RuntimeException("根据导航ID获取车端需要的导航数据失败");
+ }else{
+ orderType = OrderType.TEST_CRUISE_ORDER;
+
+ //构建导航数据给到车端
+ origin.setLongitude(longitude);
+ origin.setLatitude(latitude);
+ destination.setLongitude(testOrder.getEndLon());
+ destination.setLatitude(testOrder.getEndLat());
+
+ OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
+ dto.setOrderId(Long.parseLong(orderId.substring(4)));
+ dto.setOrigin(origin);
+ dto.setDestination(destination);
+ dto.setRouteType(3);
+ R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
+ if (200 != routeVoR.getCode()) {
+ throw new RuntimeException("获取订单线路和运费失败");
}
- //TODO 这里的逻辑不太对，收到导航偏航事件之后
- //构建导航下发请求对象
- cloudPushNavigationInfo(requestId, routeID, stringR.getData(), orderType, orderId, xpVehicle.getVehicleVin(), xpVehicle.getXpuId());
+ RouteVo routeVo = routeVoR.getData();
+ routeID = routeVo.getRouteID();
+
+ vehicleId = testOrder.getVehicleId();
}
-// }
+ } else {
+ orderType = OrderType.USER_ORDER;
+ //正常单
+ R<XpOrder> xpOrderR = xpOrderClient.queryOrderById(Long.parseLong(orderId));
+ if (200 != xpOrderR.getCode()) {
+ throw new RuntimeException("订单不存在");
+ }
+ XpOrder xpOrder = xpOrderR.getData();
+ XpVehicle xpVehicle = xpVehicleClient.queryById(xpOrder.getVehicleId()).getData();
+ //驶往上车点的行程
+ if (3 == xpOrder.getStatus()) {
+ //查询司机当前位置到起点的线路
+ origin.setLongitude(longitude);
+ origin.setLatitude(latitude);
+ destination.setLongitude(xpOrder.getStartLon());
+ destination.setLatitude(xpOrder.getStartLat());
+
+ OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
+ dto.setOrderId(Long.parseLong(orderId));
+ dto.setOrigin(origin);
+ dto.setDestination(destination);
+ dto.setRouteType(1);
+ R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
+ if (200 != routeVoR.getCode()) {
+ throw new RuntimeException("获取订单线路和运费失败");
+ }
+ RouteVo routeVo = routeVoR.getData();
+ routeID = routeVo.getRouteID();
+ //缓存数据，用于后续推给乘客导航线路
+ redisService.setCacheObject("ORDER_NAVIGATION_START_DATA:" + xpOrder.getAppUserId(), JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
+ }
+ //驶往下车点的行程
+ if (6 == xpOrder.getStatus()) {
+ origin.setLongitude(longitude);
+ origin.setLatitude(latitude);
+ destination.setLongitude(xpOrder.getEndLon());
+ destination.setLatitude(xpOrder.getEndLat());
+
+ OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
+ dto.setOrderId(Long.parseLong(orderId));
+ dto.setOrigin(origin);
+ dto.setDestination(destination);
+ dto.setRouteType(2);
+ R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
+ if (200 != routeVoR.getCode()) {
+ throw new RuntimeException("获取订单线路和运费失败");
+ }
+ RouteVo routeVo = routeVoR.getData();
+ routeID = routeVo.getRouteID();
+ //缓存导航数据，用于后面的逻辑中给乘客端推送导航数据
+ redisService.setCacheObject("ORDER_NAVIGATION_END_DATA:" + xpOrder.getAppUserId(), JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
+ }
+ vehicleId = xpOrder.getVehicleId();
+ }
+ //直接响应回最新导航数据
+ if(StringUtils.isNotEmpty(routeID)){
+ XpVehicle xpVehicle = xpVehicleClient.queryById(vehicleId).getData();
+ R<String> stringR = xpMapClient.queryRouted(routeID);
+ if (200 != stringR.getCode()) {
+ throw new RuntimeException("根据导航ID获取车端需要的导航数据失败");
+ }
+ //构建响应导航数据给车端
+ cloudPushNavigationInfo(requestId, routeID, stringR.getData(), orderType, orderId, xpVehicle.getVehicleVin(), xpVehicle.getXpuId());
+ }
}
@@ -546,14 +750,11 @@
Long vehicleId = null;
String orderType = "";
if (orderId.contains("XU")) {
-
orderType = OrderType.CRUISE_ORDER;
//巡游单
if (orderPhase.equals(OrderPhase.ROUTE_TO_CRUISE)) {
- //先响应消息
- responseMessage(sequence, "");
/* 构建导航数据给到车端 */
- R<XpCruiseOrder> cruiseOrder = xpCruiseOrderClient.getCruiseOrder(orderId);
+ R<XpCruiseOrder> cruiseOrder = xpCruiseOrderClient.getCruiseOrder(Long.parseLong(orderId.substring(2)));
XpCruiseOrder xpCruiseOrder = cruiseOrder.getData();
origin.setLongitude(xpCruiseOrder.getStartLon());
@@ -562,9 +763,10 @@
destination.setLatitude(xpCruiseOrder.getEndLat());
OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
- dto.setOrderId(Long.parseLong(orderId));
+ dto.setOrderId(Long.parseLong(orderId.substring(2)));
dto.setOrigin(origin);
dto.setDestination(destination);
+ dto.setRouteType(3);
R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
if (200 != routeVoR.getCode()) {
throw new RuntimeException("获取订单线路和运费失败");
@@ -575,42 +777,142 @@
vehicleId = xpCruiseOrder.getVehicleId();
}
- } else {
+ } else if(orderId.contains("TEST")){
+ R<XpTestOrder> cruiseOrder = testOrderClient.queryOrderById(Long.parseLong(orderId.substring(4)));
+ XpTestOrder testOrder = cruiseOrder.getData();
+ XpVehicle xpVehicle = xpVehicleClient.queryById(testOrder.getVehicleId()).getData();
+ //区分测试单和测试巡游单
+ if(1 == testOrder.getOrderType()){
+ orderType = OrderType.TEST_ORDER;
+ //驶往上车点的行程
+ if (orderPhase.equals(OrderPhase.ROUTE_TO_PICKUP)) {
+ //直接取缓存中的导航数据推送给车端和乘客
+ Object cacheObject = redisService.getCacheObject("TEST_ORDER_NAVIGATION_START_DATA:" + testOrder.getVehicleId());
+ if(null == cacheObject){
+ //没有缓存数据，重新规划线路
+ //查询车辆位置
+ VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(xpVehicle.getVehicleVin())), VehiclePosition.class);
+ if (Objects.isNull(vehiclePosition)) {
+ throw new RuntimeException("车辆位置信息不存在");
+ }
+ origin.setLongitude(vehiclePosition.getPoint().getX());
+ origin.setLatitude(vehiclePosition.getPoint().getY());
+ destination.setLongitude(testOrder.getStartLon());
+ destination.setLatitude(testOrder.getStartLat());
+ OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
+ dto.setOrderId(Long.parseLong(orderId.substring(4)));
+ dto.setOrigin(origin);
+ dto.setDestination(destination);
+ dto.setRouteType(2);
+ R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
+ if (200 != routeVoR.getCode()) {
+ throw new RuntimeException("获取订单线路和运费失败");
+ }
+ RouteVo routeVo = routeVoR.getData();
+ routeID = routeVo.getRouteID();
+ //缓存导航数据，用于后面的逻辑中给乘客端推送导航数据
+ redisService.setCacheObject("TEST_ORDER_NAVIGATION_START_DATA:" + testOrder.getVehicleId(), JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
+ }else{
+ RouteVo routeVo = JSON.parseObject(cacheObject.toString(), RouteVo.class);
+ routeID = routeVo.getRouteID();
+ }
+ }
+ //驶往下车点的行程
+ if (orderPhase.equals(OrderPhase.ROUTE_TO_DESTINATION)) {
+ //直接取缓存中的导航数据推送给车端和乘客
+ Object cacheObject = redisService.getCacheObject("TEST_ORDER_NAVIGATION_END_DATA:" + testOrder.getVehicleId());
+ if(null == cacheObject){
+ //没有缓存数据，重新规划线路
+ //查询起点到终点的线路
+ origin.setLongitude(testOrder.getStartLon());
+ origin.setLatitude(testOrder.getStartLat());
+ destination.setLongitude(testOrder.getEndLon());
+ destination.setLatitude(testOrder.getEndLat());
+ OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
+ dto.setOrderId(Long.parseLong(orderId.substring(4)));
+ dto.setOrigin(origin);
+ dto.setDestination(destination);
+ dto.setRouteType(2);
+ R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
+ if (200 != routeVoR.getCode()) {
+ throw new RuntimeException("获取订单线路和运费失败");
+ }
+ RouteVo routeVo = routeVoR.getData();
+ routeID = routeVo.getRouteID();
+ //缓存导航数据，用于后面的逻辑中给乘客端推送导航数据
+ redisService.setCacheObject("TEST_ORDER_NAVIGATION_END_DATA:" + testOrder.getVehicleId(), JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
+ }else{
+ RouteVo routeVo = JSON.parseObject(cacheObject.toString(), RouteVo.class);
+ routeID = routeVo.getRouteID();
+ }
+ }
+
+ }else{
+ orderType = OrderType.TEST_CRUISE_ORDER;
+
+ //巡游单
+ if (orderPhase.equals(OrderPhase.ROUTE_TO_CRUISE)) {
+ /* 构建导航数据给到车端 */
+ origin.setLongitude(testOrder.getStartLon());
+ origin.setLatitude(testOrder.getStartLat());
+ destination.setLongitude(testOrder.getEndLon());
+ destination.setLatitude(testOrder.getEndLat());
+
+ OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
+ dto.setOrderId(Long.parseLong(orderId.substring(4)));
+ dto.setOrigin(origin);
+ dto.setDestination(destination);
+ dto.setRouteType(3);
+ R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
+ if (200 != routeVoR.getCode()) {
+ throw new RuntimeException("获取订单线路和运费失败");
+ }
+ RouteVo routeVo = routeVoR.getData();
+ routeID = routeVo.getRouteID();
+ }
+ }
+ vehicleId = testOrder.getVehicleId();
+ }else{
orderType = OrderType.USER_ORDER;
//正常单
R<XpOrder> xpOrderR = xpOrderClient.queryOrderById(Long.parseLong(orderId));
if (200 != xpOrderR.getCode()) {
- throw new RuntimeException("订单不存在");
+ throw new RuntimeException("订单不存在 " + orderId);
}
XpOrder xpOrder = xpOrderR.getData();
XpVehicle xpVehicle = xpVehicleClient.queryById(xpOrder.getVehicleId()).getData();
- //先响应消息
- responseMessage(sequence, xpVehicle.getVehicleVin());
//驶往上车点的行程
if (orderPhase.equals(OrderPhase.ROUTE_TO_PICKUP)) {
- //查询车辆位置
- VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(xpVehicle.getVehicleVin())), VehiclePosition.class);
- if (Objects.isNull(vehiclePosition)) {
- throw new RuntimeException("车辆位置信息不存在");
- }
- //查询司机当前位置到起点的线路
- origin.setLongitude(vehiclePosition.getPoint().getX());
- origin.setLatitude(vehiclePosition.getPoint().getY());
- destination.setLongitude(xpOrder.getStartLon());
- destination.setLatitude(xpOrder.getStartLat());
+ Object cacheObject = redisService.getCacheObject("ORDER_NAVIGATION_START_DATA:" + xpOrder.getAppUserId());
+ if(null == cacheObject){
+ //查询车辆位置
+ VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(xpVehicle.getVehicleVin())), VehiclePosition.class);
+ if (Objects.isNull(vehiclePosition)) {
+ throw new RuntimeException("车辆位置信息不存在");
+ }
+ //查询司机当前位置到起点的线路
+ origin.setLongitude(vehiclePosition.getPoint().getX());
+ origin.setLatitude(vehiclePosition.getPoint().getY());
+ destination.setLongitude(xpOrder.getStartLon());
+ destination.setLatitude(xpOrder.getStartLat());
- OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
- dto.setOrderId(Long.parseLong(orderId));
- dto.setOrigin(origin);
- dto.setDestination(destination);
- R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
- if (200 != routeVoR.getCode()) {
- throw new RuntimeException("获取订单线路和运费失败");
- }
- RouteVo routeVo = routeVoR.getData();
- routeID = routeVo.getRouteID();
- //缓存数据，用于后续推给乘客导航线路
- redisService.setCacheObject("ORDER_NAVIGATION_START_DATA:" + xpOrder.getAppUserId(), JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
+ OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
+ dto.setOrderId(Long.parseLong(orderId));
+ dto.setOrigin(origin);
+ dto.setDestination(destination);
+ dto.setRouteType(1);
+ R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
+ if (200 != routeVoR.getCode()) {
+ throw new RuntimeException("获取订单线路和运费失败");
+ }
+ RouteVo routeVo = routeVoR.getData();
+ routeID = routeVo.getRouteID();
+ //缓存数据，用于后续推给乘客导航线路
+ redisService.setCacheObject("ORDER_NAVIGATION_START_DATA:" + xpOrder.getAppUserId(), JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
+ }else{
+ RouteVo routeVo = JSON.parseObject(cacheObject.toString(), RouteVo.class);
+ routeID = routeVo.getRouteID();
+ };
}
//驶往下车点的行程
if (orderPhase.equals(OrderPhase.ROUTE_TO_DESTINATION)) {
@@ -627,6 +929,7 @@
dto.setOrderId(Long.parseLong(orderId));
dto.setOrigin(origin);
dto.setDestination(destination);
+ dto.setRouteType(2);
R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
if (200 != routeVoR.getCode()) {
throw new RuntimeException("获取订单线路和运费失败");
@@ -634,7 +937,7 @@
RouteVo routeVo = routeVoR.getData();
routeID = routeVo.getRouteID();
//缓存导航数据，用于后面的逻辑中给乘客端推送导航数据
- redisService.setCacheObject("ORDER_NAVIGATION_END_DATA:" + xpOrder.getAppUserId(), com.alibaba.fastjson.JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
+ redisService.setCacheObject("ORDER_NAVIGATION_END_DATA:" + xpOrder.getAppUserId(), JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
}else{
RouteVo routeVo = JSON.parseObject(cacheObject.toString(), RouteVo.class);
routeID = routeVo.getRouteID();
@@ -644,11 +947,13 @@
}
if(StringUtils.isNotEmpty(routeID)){
+ log.info("开始推送导航信息 {}", orderId);
XpVehicle xpVehicle = xpVehicleClient.queryById(vehicleId).getData();
R<String> stringR = xpMapClient.queryRouted(routeID);
if (200 != stringR.getCode()) {
throw new RuntimeException("根据导航ID获取车端需要的导航数据失败");
}
+ log.info("根据导航ID获取车端需要的导航数据 订单 {} 导航数据 {}", orderId, stringR.getData());
//构建导航下发请求对象
cloudPushNavigationInfo(requestId, routeID, stringR.getData(), orderType, orderId, xpVehicle.getVehicleVin(), xpVehicle.getXpuId());
}
@@ -697,11 +1002,9 @@
}
orderOperationBuilder.addAllWaypoints(waypoints);
- SnowFlake snowFlake = new SnowFlake(0, 0);
- snowFlake.withStartTimestamp(1420041600000L);
- long sequence = snowFlake.nextId();
+ long sequence = snowflake.nextId();
// 处理数据
- redisTemplate.opsForValue().set(sequence,"pushOrder_"+orderId+"_"+vin,30, TimeUnit.MINUTES);
+ redisService.setCacheObject(sequence + "","pushOrder_"+orderId+"_"+vin,30L, TimeUnit.MINUTES);
//开发发送请求到XPU
xpuUtil.cloudOrderOperation(orderOperationBuilder.build(), vin,sequence);
}
@@ -742,8 +1045,14 @@
break;
case ORDER_RECEIVED:
//收到订单
- buildPushOrderStatus(orderId, OrderStatusEnum.READY_DEPART, sequence);
- xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.READY_DEPART.getCode());
+ if(!orderId.contains("XU")){
+ if(orderId.contains("TEST")){
+ testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.READY_DEPART.getCode());
+ }else{
+ buildPushOrderStatus(orderId, OrderStatusEnum.READY_DEPART, sequence);
+ xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.READY_DEPART.getCode());
+ }
+ }
break;
case ORDER_STARTED:
//开始执行订单
@@ -751,8 +1060,14 @@
break;
case ORDER_EN_ROUTE_TO_PICKUP:
//前往上车点
- buildPushOrderStatus(orderId, OrderStatusEnum.PICK_UP, sequence);
- xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.PICK_UP.getCode());
+ if(!orderId.contains("XU")){
+ if(orderId.contains("TEST")){
+ testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.PICK_UP.getCode());
+ }else{
+ buildPushOrderStatus(orderId, OrderStatusEnum.PICK_UP, sequence);
+ xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.PICK_UP.getCode());
+ }
+ }
break;
case ORDER_ARRIVED_AT_PICKUP:
//到达上车点
@@ -760,45 +1075,206 @@
break;
case ORDER_WAITING_FOR_PICKUP:
//等待乘客上车
- buildPushOrderStatus(orderId, OrderStatusEnum.PICK_UP_GUESTS, sequence);
- xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.PICK_UP_GUESTS.getCode());
+ if(!orderId.contains("XU")){
+ if(orderId.contains("TEST")){
+ testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.PICK_UP_GUESTS.getCode());
+ }else{
+ buildPushOrderStatus(orderId, OrderStatusEnum.PICK_UP_GUESTS, sequence);
+ xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.PICK_UP_GUESTS.getCode());
+ }
+ }
break;
case ORDER_PASSENGER_ONBOARD:
//乘客已上车
- buildPushOrderStatus(orderId, OrderStatusEnum.PASSENGER_BOARDED, sequence);
- xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.PASSENGER_BOARDED.getCode());
+ if(!orderId.contains("XU")){
+ if(orderId.contains("TEST")){
+ testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.PASSENGER_BOARDED.getCode());
+ }else{
+ buildPushOrderStatus(orderId, OrderStatusEnum.PASSENGER_BOARDED, sequence);
+ xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.PASSENGER_BOARDED.getCode());
+ }
+ }
break;
case ORDER_EN_ROUTE_TO_DESTINATION:
//前往目的地
- buildPushOrderStatus(orderId, OrderStatusEnum.IN_SERVICE, sequence);
- xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.IN_SERVICE.getCode());
+ if(!orderId.contains("XU")){
+ if(orderId.contains("TEST")){
+ testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.IN_SERVICE.getCode());
+ }else{
+ buildPushOrderStatus(orderId, OrderStatusEnum.IN_SERVICE, sequence);
+ xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.IN_SERVICE.getCode());
+ }
+ }
break;
case ORDER_ARRIVED_AT_DESTINATION:
//到达目的地
log.info("到达目的地，不做任何处理：{}", orderId);
break;
case ORDER_WAITING_FOR_DROPOFF:
- //等待乘客下车
- buildPushOrderStatus(orderId, OrderStatusEnum.SEE_OFF_GUESTS, sequence);
- xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.SEE_OFF_GUESTS.getCode());
+ //等待乘客下车，开始倒计时发下巡游单
+ if(!orderId.contains("XU")){
+ if(orderId.contains("TEST")){
+ testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.SEE_OFF_GUESTS.getCode());
+ }else{
+ buildPushOrderStatus(orderId, OrderStatusEnum.SEE_OFF_GUESTS, sequence);
+ xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.SEE_OFF_GUESTS.getCode());
+ }
+ }
break;
case ORDER_DROPOFF_COMPLETED:
- //下车完成
- buildPushOrderStatus(orderId, OrderStatusEnum.APPROVAL_REJECTION, sequence);
- xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.APPROVAL_REJECTION.getCode());
+ //下车完成，不需要处理状态，由后续的乘客主动触发或者定时任务触发
+ log.info("乘客已下车，不做任何处理：{}", orderId);
break;
case ORDER_COMPLETED:
//已完成
log.info("已完成，不做任何处理：{}", orderId);
+ if(!orderId.contains("XU")){
+ XpOrder xpOrder = xpOrderClient.queryOrderById(Long.valueOf(orderId)).getData();
+ if (Objects.nonNull(xpOrder)){
+ // 查询车辆
+ XpVehicle xpVehicle = xpVehicleClient.queryById(xpOrder.getVehicleId()).getData();
+ if (Objects.nonNull(xpVehicle)){
+ String vin = xpVehicle.getVehicleVin();
+ // 封装埋点消息实体
+ VehicleEventDTO vehicleEventDTO = new VehicleEventDTO();
+ vehicleEventDTO.setVin(vin);
+ vehicleEventDTO.setXpuId("");
+ vehicleEventDTO.setOrderId(orderId);
+ vehicleEventDTO.setEventKey("RT_xpu_vehicle_trace_upload");
+ vehicleEventDTO.setEventTime(System.currentTimeMillis());
+ Map<String,Object> attributes = new HashMap<>();
+ attributes.put("vin",vin);
+ attributes.put("order_id",vehicleEventDTO.getOrderId());
+ attributes.put("order_type","user_order");
+ attributes.put("timestamp",vehicleEventDTO.getEventTime());
+ attributes.put("current_main_status",OrderStatus.ORDER_COMPLETED);
+ attributes.put("current_sub_status","");
+ VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(vin)), VehiclePosition.class);
+ if(Objects.nonNull(vehiclePosition)){
+ attributes.put("odometer_km",vehiclePosition.getTotalOdometer());
+ }else {
+ attributes.put("odometer_km","");
+ }
+ vehicleEventDTO.setAttributes(attributes);
+ vehicleBuriedPointClient.sendVehicleEvent(vehicleEventDTO);
+ log.info("已完成，推送埋点：{}", orderId);
+ }
+ }
+ }
break;
case ORDER_CANCELLED:
//已取消
- buildPushOrderStatus(orderId, OrderStatusEnum.CANCELED, sequence);
- xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.CANCELED.getCode());
+ if(!orderId.contains("XU")){
+ String taskId = orderStatusInfo.getTaskId();
+ JSONObject reassignCancelContext = resolveReassignCancelContext(orderId, orderStatusInfo);
+ if (Objects.nonNull(reassignCancelContext)) {
+ log.info("改派旧车取消回调，跳过订单取消处理，orderId: {}, taskId: {}, cancelScene: {}, context: {}",
+ orderId, taskId, reassignCancelContext.getString("cancelScene"), reassignCancelContext);
+ //响应消息
+ String responseVin = resolveReassignCancelResponseVin(reassignCancelContext);
+ if (StringUtils.isNotEmpty(responseVin)) {
+ responseMessage(sequence, responseVin);
+ } else {
+ log.warn("改派旧车取消回调未找到响应VIN，orderId: {}, taskId: {}, context: {}",
+ orderId, taskId, reassignCancelContext);
+ }
+ return;
+ }
+ if(orderId.contains("TEST")){
+ //判断订单状态，已经取消的不作处理
+ Object cacheObject = redisService.getCacheObject("TEST_ORDER_STATUS:" + orderId.substring(4));
+ if(null != cacheObject){
+ int order_status = Integer.parseInt(cacheObject.toString());
+ if(0 == order_status){
+ return;
+ }
+ }
+ XpTestOrder testOrder = testOrderClient.queryOrderById(Long.valueOf(orderId.substring(4))).getData();
+ if(testOrder.getStatus() == 0 || testOrder.getStatus() >= 8){
+ return;
+ }
+ //行程中取消订单，按照行程结束处理
+ if(testOrder.getStatus() > 5 && testOrder.getStatus() < 8){
+ testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.SEE_OFF_GUESTS.getCode());
+ redisService.setCacheObject("TEST_ORDER_STATUS:" + orderId.substring(4), OrderStatusEnum.SEE_OFF_GUESTS.getCode(), 24L, TimeUnit.HOURS);
+ }else{
+ testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.CANCELED.getCode());
+ redisService.setCacheObject("TEST_ORDER_STATUS:" + orderId.substring(4), OrderStatusEnum.CANCELED.getCode(), 24L, TimeUnit.HOURS);
+ }
+ }else{
+ //判断订单状态，已经取消的不作处理
+ Object cacheObject = redisService.getCacheObject("ORDER_STATUS:" + orderId);
+ if(null != cacheObject){
+ int order_status = Integer.parseInt(cacheObject.toString());
+ if(0 == order_status){
+ return;
+ }
+ }
+ XpOrder xpOrder = xpOrderClient.queryOrderById(Long.parseLong(orderId)).getData();
+ if(xpOrder.getStatus() == 0 || xpOrder.getStatus() >= 8){
+ return;
+ }
+ if(xpOrder.getStatus() > 5 && xpOrder.getStatus() < 8){
+ //行程中取消订单，按照行程结束处理
+ buildPushOrderStatus(orderId, OrderStatusEnum.SEE_OFF_GUESTS, sequence);
+ xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.SEE_OFF_GUESTS.getCode());
+ redisService.setCacheObject("ORDER_STATUS:" + orderId, OrderStatusEnum.SEE_OFF_GUESTS.getCode(), 24L, TimeUnit.HOURS);
+ }else{
+ buildPushOrderStatus(orderId, OrderStatusEnum.CANCELED, sequence);
+ xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.CANCELED.getCode());
+ redisService.setCacheObject("ORDER_STATUS:" + orderId, OrderStatusEnum.CANCELED.getCode(), 24L, TimeUnit.HOURS);
+ }
+ }
+ }
break;
case ORDER_ARRIVED_AT_CRUISE_DESTINATION:
//到达巡游终点
- buildPushOrderStatus(orderId, OrderStatusEnum.COMPLETED, sequence);
+ if(orderId.contains("XU")){
+ buildPushOrderStatus(orderId, OrderStatusEnum.COMPLETED, sequence);
+ String cruiseOrderId = orderId.substring(2);
+ XpCruiseOrder xpCruiseOrder = xpCruiseOrderClient.getCruiseOrder(Long.parseLong(cruiseOrderId)).getData();
+ if (Objects.nonNull(xpCruiseOrder)){
+ // 查询车辆
+ XpVehicle xpVehicle = xpVehicleClient.queryById(xpCruiseOrder.getVehicleId()).getData();
+ if (Objects.nonNull(xpVehicle)){
+ String vin = xpVehicle.getVehicleVin();
+ // 封装埋点消息实体
+ VehicleEventDTO vehicleEventDTO = new VehicleEventDTO();
+ vehicleEventDTO.setVin(vin);
+ vehicleEventDTO.setXpuId("");
+ vehicleEventDTO.setOrderId(cruiseOrderId);
+ vehicleEventDTO.setEventKey("RT_xpu_vehicle_trace_upload");
+ vehicleEventDTO.setEventTime(System.currentTimeMillis());
+ Map<String,Object> attributes = new HashMap<>();
+ attributes.put("vin",vin);
+ attributes.put("order_id",vehicleEventDTO.getOrderId());
+ attributes.put("order_type","cruise_order");
+ attributes.put("timestamp",vehicleEventDTO.getEventTime());
+ attributes.put("current_main_status",OrderStatus.ORDER_ARRIVED_AT_CRUISE_DESTINATION);
+ attributes.put("current_sub_status","");
+ VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(vin)), VehiclePosition.class);
+ if(Objects.nonNull(vehiclePosition)){
+ attributes.put("odometer_km",vehiclePosition.getTotalOdometer());
+ }else {
+ attributes.put("odometer_km","");
+ }
+ vehicleEventDTO.setAttributes(attributes);
+ vehicleBuriedPointClient.sendVehicleEvent(vehicleEventDTO);
+ log.info("到达巡游终点，推送埋点：{}", orderId);
+ }
+ }
+ }else if(orderId.contains("TEST")){
+ //测试巡游单完成状态
+ XpTestOrder testOrder = testOrderClient.queryOrderById(Long.parseLong(orderId.substring(4))).getData();
+ if(testOrder.getOrderType() == 2){
+ XpVehicle xpVehicle = xpVehicleClient.queryById(testOrder.getVehicleId()).getData();
+ //响应消息
+ responseMessage(sequence, xpVehicle.getVehicleVin());
+ //测试巡游单处理逻辑
+ testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.COMPLETED.getCode());
+ redisService.setCacheObject("TEST_ORDER_STATUS:" + orderId.substring(4), OrderStatusEnum.COMPLETED.getCode(), 24L, TimeUnit.HOURS);
+ }
+ }
break;
case ORDER_PAUSED:
//订单暂停
@@ -819,101 +1295,49 @@
public void buildPushOrderStatus(String orderId, OrderStatusEnum status, Long sequence){
if(orderId.contains("XU")){
//巡游单
- //响应消息
- responseMessage(sequence, "");
- //前往目的地
- if(OrderStatusEnum.IN_SERVICE.equals(status)){
-
- }
//到达目的地
if(OrderStatusEnum.COMPLETED.equals(status)){
-
// 返程找到目前的订单 -》之前的订单 查询生成一个 正常巡游 找到下一个点位 若到达最后点位 则反向找点位 每次判断是否收车状态 是则不进行处理了
// 找到这个订单
- R<XpCruiseOrder> cruiseOrder = xpCruiseOrderClient.getCruiseOrder(orderId);
+ R<XpCruiseOrder> cruiseOrder = xpCruiseOrderClient.getCruiseOrder(Long.parseLong(orderId.substring(2)));
if(cruiseOrder!=null){
XpCruiseOrder xpCruiseOrder = cruiseOrder.getData();
Long vehicleId = xpCruiseOrder.getVehicleId();
-
// 完成当前巡游单子 已完成
- xpCruiseOrderClient.closeCruiseOrder(xpCruiseOrder.getVehicleVin());
+ xpCruiseOrderClient.completeCruiseOrder(Long.parseLong(orderId.substring(2)));
R<XpVehicle> xpVehicleR = xpVehicleClient.queryById(vehicleId);
XpVehicle xpVehicle = xpVehicleR.getData();
+ //响应消息
+ responseMessage(sequence, xpVehicle.getVehicleVin());
// 运营中 继续执行
if(xpVehicle.getOperatingStatus()==1 && xpVehicle.getState()==0){
+ log.info("巡游单到达终点，继续执行下一笔巡游单");
// 创建新的巡游单子 判断是否为返程单子
- if(xpCruiseOrder.getOrderType()==2){
- R<XpCruiseOrder> lastOrder = xpCruiseOrderClient.getCruiseOrder(xpCruiseOrder.getLastOrderId());
- XpCruiseOrder lastXpCruiseOrder = lastOrder.getData();
+ // 正常巡游 找到下一个点位 若到达最后点位 则反向找点位
+ // 起点
+ Double endLon = xpCruiseOrder.getEndLon();
+ Double endLat = xpCruiseOrder.getEndLat();
+ XpCruiseOrder newXpCruiseOrder = new XpCruiseOrder();
+ newXpCruiseOrder.setVehicleId(xpCruiseOrder.getVehicleId());
+ newXpCruiseOrder.setVehicleVin(xpCruiseOrder.getVehicleVin());
+ newXpCruiseOrder.setFleetId(xpCruiseOrder.getFleetId());
+ newXpCruiseOrder.setOrderType(1);
+ newXpCruiseOrder.setStartLat(endLat);
+ newXpCruiseOrder.setStartLon(endLon);
+ newXpCruiseOrder.setStartPointId(xpCruiseOrder.getEndPointId());
+ newXpCruiseOrder.setStartPointName(xpCruiseOrder.getEndPointName());
+ newXpCruiseOrder.setStatus(1);
+ newXpCruiseOrder.setLastOrderId(xpCruiseOrder.getId());
- // 修改一下id 加一个一样的巡游单子
- lastXpCruiseOrder.setId("XU"+ IdUtil.fastUUID());
- lastXpCruiseOrder.setStatus(1);
- xpCruiseOrderClient.addCruiseOrder(lastXpCruiseOrder);
-
-
-
- // 获取点位id
- Long endPointId = xpCruiseOrder.getEndPointId();
- // 获取点位信息 获取点位是否需要停车
-// xpCruisePlanClient.getPlanPointInfo(endPointId);
-
-
-
- RtTask.Builder taskBuilder = RtTask.newBuilder();
- taskBuilder.setOrderId(lastXpCruiseOrder.getId());
- taskBuilder.setTaskId("MISSION_"+ IdUtil.fastUUID());
- taskBuilder.setTaskType(com.xiaopeng.api.vo.automaticPilot.protobuf.OrderType.ORDER_TYPE_CRUISE);
-
- RtTask task = taskBuilder.build();
- RtTaskList taskList = RtTaskList.newBuilder().addTasks(task).build();
-
-
- SnowFlake snowFlake = new SnowFlake(0, 0);
- snowFlake.withStartTimestamp(1420041600000L);
- long sequence1 = snowFlake.nextId();
- xpuUtil.cloudCreateOrder(taskList, xpVehicle.getVehicleVin(),sequence1);
- }else if(xpCruiseOrder.getOrderType()==1){
- // 正常巡游 找到下一个点位 若到达最后点位 则反向找点位
- // 起点
- Double endLon = xpCruiseOrder.getEndLon();
- Double endLat = xpCruiseOrder.getEndLat();
- XpCruiseOrder newXpCruiseOrder = new XpCruiseOrder();
- newXpCruiseOrder.setId("XU"+ IdUtil.fastUUID());
- newXpCruiseOrder.setVehicleId(xpCruiseOrder.getVehicleId());
- newXpCruiseOrder.setVehicleVin(xpCruiseOrder.getVehicleVin());
- newXpCruiseOrder.setFleetId(xpCruiseOrder.getFleetId());
- newXpCruiseOrder.setOrderType(1);
- newXpCruiseOrder.setStartLat(endLat);
- newXpCruiseOrder.setStartLon(endLon);
- newXpCruiseOrder.setStartPointId(xpCruiseOrder.getEndPointId());
- newXpCruiseOrder.setStartPointName(xpCruiseOrder.getEndPointName());
- newXpCruiseOrder.setStatus(1);
- newXpCruiseOrder.setLastOrderId(xpCruiseOrder.getId());
-
-
- // 通过车找终点id
- CruisePointDto cruisePointDto = new CruisePointDto();
- cruisePointDto.setNewXpCruiseOrder(newXpCruiseOrder);
- cruisePointDto.setVehicleId(xpCruiseOrder.getVehicleId());
- cruisePointDto.setPointId(newXpCruiseOrder.getStartPointId());
- cruisePointDto.setOrderReverse(xpCruiseOrder.getOrderReverse());
- R<XpCruiseOrder> cruisePoint = xpCruisePlanClient.getCruisePoint(cruisePointDto);
- if(cruisePoint!=null){
- xpCruiseOrderClient.addCruiseOrder(cruisePoint.getData());
- RtTask.Builder taskBuilder = RtTask.newBuilder();
- //TODO 设置目标地点信息
- taskBuilder.setOrderId(newXpCruiseOrder.getId());
- taskBuilder.setTaskId("MISSION_"+ IdUtil.fastUUID());
- taskBuilder.setTaskType(com.xiaopeng.api.vo.automaticPilot.protobuf.OrderType.ORDER_TYPE_CRUISE);
- RtTaskList.Builder taskListBuilder = RtTaskList.newBuilder();
- taskListBuilder.addTasks(taskBuilder.build());
-
- SnowFlake snowFlake = new SnowFlake(0, 0);
- snowFlake.withStartTimestamp(1420041600000L);
- long sequence1 = snowFlake.nextId();
- xpuUtil.cloudCreateOrder(taskListBuilder.build(), xpVehicle.getVehicleVin(),sequence1);
- }
+ // 通过车找终点id
+ CruisePointDto cruisePointDto = new CruisePointDto();
+ cruisePointDto.setNewXpCruiseOrder(newXpCruiseOrder);
+ cruisePointDto.setVehicleId(xpCruiseOrder.getVehicleId());
+ cruisePointDto.setPointId(newXpCruiseOrder.getStartPointId());
+ cruisePointDto.setOrderReverse(xpCruiseOrder.getOrderReverse());
+ R<XpCruiseOrder> cruisePoint = xpCruisePlanClient.getCruisePoint(cruisePointDto);
+ if(cruisePoint!=null){
+ xpCruiseOrderClient.addCruiseOrder(cruisePoint.getData());
}
}
}
@@ -940,10 +1364,85 @@
dto.setAppUserId(appUserId + "");
dto.setMessage(message);
R<String> stringR = xpPushMessageClient.sendStatus(dto);
- if (R.isError(stringR)) {
- log.error("推送消息失败：{}", stringR.getMsg());
+
+ //推送失败，重试3次
+ if(stringR.getCode() != Constants.SUCCESS){
+ ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>());
+ executor.execute(() -> {
+ for (int i = 0; i < 3; i++) {
+ R<String> stringR1 = xpPushMessageClient.sendStatus(dto);
+ if(stringR1.getCode() == Constants.SUCCESS){
+ break;
+ }
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ throw new RuntimeException(e);
+ }
+ log.info("推送订单状态消息失败：{} {} {}", stringR1.getMsg(), JSON.toJSONString(dto), xpOrder.getOrderNumber());
+ }
+ });
}
+
}
+ }
+
+ private JSONObject getReassignCancelContext(String orderId) {
+ if (StringUtils.isEmpty(orderId)) {
+ return null;
+ }
+ Object cacheObject = redisService.getCacheObject(REASSIGN_CANCEL_CONTEXT_PREFIX + orderId);
+ if (cacheObject == null) {
+ return null;
+ }
+ return JSON.parseObject(cacheObject.toString());
+ }
+
+ private JSONObject resolveReassignCancelContext(String orderId, OrderStatusInfo orderStatusInfo) {
+ if (OrderStateChangeSource.ORDER_STATE_CHANGE_SOURCE_VEHICLE != orderStatusInfo.getChangeSource()) {
+ return null;
+ }
+ JSONObject cancelContext = getReassignCancelContext(orderId);
+ if (cancelContext == null) {
+ return null;
+ }
+ if (CancelOrderSceneEnum.REASSIGN_OLD_VEHICLE != CancelOrderSceneEnum.fromCode(
+ cancelContext.getString("cancelScene"))) {
+ return null;
+ }
+ R<XpOrder> orderResult = xpOrderClient.queryOrderById(Long.parseLong(orderId));
+ XpOrder xpOrder = orderResult == null ? null : orderResult.getData();
+ if (xpOrder == null) {
+ log.warn("改派取消回调识别失败，订单不存在，orderId: {}, context: {}", orderId, cancelContext);
+ return null;
+ }
+ Long newVehicleId = cancelContext.getLong("newVehicleId");
+ Integer currentStatus = xpOrder.getStatus();
+ boolean vehicleMatched = Objects.nonNull(newVehicleId) && Objects.equals(newVehicleId, xpOrder.getVehicleId());
+ boolean statusMatched = Objects.nonNull(currentStatus) && currentStatus > 0 && currentStatus < 8;
+ if (vehicleMatched && statusMatched) {
+ return cancelContext;
+ }
+ log.info("改派取消回调未命中专用上下文，orderId: {}, currentVehicleId: {}, newVehicleId: {}, currentStatus: {}",
+ orderId, xpOrder.getVehicleId(), newVehicleId, currentStatus);
+ return null;
+ }
+
+ private String resolveReassignCancelResponseVin(JSONObject cancelContext) {
+ if (cancelContext == null) {
+ return null;
+ }
+ String oldVehicleVin = cancelContext.getString("oldVehicleVin");
+ if (StringUtils.isNotEmpty(oldVehicleVin)) {
+ return oldVehicleVin;
+ }
+ Long oldVehicleId = cancelContext.getLong("oldVehicleId");
+ if (Objects.isNull(oldVehicleId)) {
+ return null;
+ }
+ R<XpVehicle> vehicleResult = xpVehicleClient.queryById(oldVehicleId);
+ XpVehicle xpVehicle = vehicleResult == null ? null : vehicleResult.getData();
+ return xpVehicle == null ? null : xpVehicle.getVehicleVin();
}
/**
@@ -962,17 +1461,10 @@
navigationDataBuilder.setRequestId(requestId);
navigationDataBuilder.setContent(routeDataContent);
navigationDataBuilder.setTimestamp(System.currentTimeMillis());
- SnowFlake snowFlake = new SnowFlake(0, 0);
- snowFlake.withStartTimestamp(1420041600000L);
- long sequence = snowFlake.nextId();
- // 处理数据
- JSONObject jsonObject = new JSONObject();
- jsonObject.put("event", SystemEventType.PUSH_NAVIGATION);
- jsonObject.put("orderType", orderType);
- jsonObject.put("orderId", orderId);
- jsonObject.put("vin", vin);
- redisTemplate.opsForValue().set(sequence, jsonObject.toJSONString(),30, TimeUnit.MINUTES);
- xpuUtil.cloudPushNavigation(navigationDataBuilder.build(), xpuId, sequence);
+ long sequence = snowflake.nextId();
+ log.info("开始推送导航数据 {}", orderId);
+ MqttPublishDto mqttPublishDto = xpuUtil.cloudPushNavigation(navigationDataBuilder.build(), xpuId, sequence);
+ log.info("推送导航的响应消息，{}", JSON.toJSONString(mqttPublishDto));
}
}
--
Gitblit v1.7.1