From 08cc6d5cf7e93b75cfabe7dcc2aeaa9afa1117eb Mon Sep 17 00:00:00 2001
From: puzhibing <393733352@qq.com>
Date: 星期二, 12 五月 2026 15:01:47 +0800
Subject: [PATCH] Merge branch '1.0' of http://120.76.84.145:10101/gitblit/r/java/Robotaxi into 1.1
---
xp-robotaxi-automatic-pilot-boot/src/main/java/com/xiaopeng/automaticPilot/controller/OrderMissionController.java | 930 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
1 files changed, 896 insertions(+), 34 deletions(-)
diff --git a/xp-robotaxi-automatic-pilot-boot/src/main/java/com/xiaopeng/automaticPilot/controller/OrderMissionController.java b/xp-robotaxi-automatic-pilot-boot/src/main/java/com/xiaopeng/automaticPilot/controller/OrderMissionController.java
index ae3fb3d..ddeff3c 100644
--- a/xp-robotaxi-automatic-pilot-boot/src/main/java/com/xiaopeng/automaticPilot/controller/OrderMissionController.java
+++ b/xp-robotaxi-automatic-pilot-boot/src/main/java/com/xiaopeng/automaticPilot/controller/OrderMissionController.java
@@ -1,25 +1,52 @@
package com.xiaopeng.automaticPilot.controller;
import cn.hutool.core.lang.Snowflake;
-import cn.hutool.core.util.IdUtil;
+import com.alibaba.fastjson2.JSON;
+import com.alibaba.fastjson2.JSONObject;
import com.xiaopeng.api.dto.automaticPilot.MqttPublishDto;
import com.xiaopeng.api.dto.automaticPilot.PushOrderDto;
+import com.xiaopeng.api.dto.map.OrderRouteAndFareDto;
+import com.xiaopeng.api.dto.operation.LonLatDto;
+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.map.XpMapClient;
+import com.xiaopeng.api.feignClient.order.XpOrderClient;
+import com.xiaopeng.api.feignClient.pushMessage.XpPushMessageClient;
import com.xiaopeng.api.feignClient.vehicleConvoy.XpVehicleClient;
-import com.xiaopeng.api.vo.automaticPilot.proto.down.cloudCreateOrder.RTTask;
-import com.xiaopeng.api.vo.automaticPilot.proto.down.cloudCreateOrder.TaskStatus;
-import com.xiaopeng.api.vo.automaticPilot.proto.down.cloudCreateOrder.TaskType;
+import com.xiaopeng.api.model.order.XpOrder;
+import com.xiaopeng.api.model.vehicleConvoy.XpVehicle;
+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.operation.RouteVo;
+import com.xiaopeng.api.vo.order.OrderTrajectoryVo;
import com.xiaopeng.automaticPilot.util.XPUUtil;
import com.xiaopeng.common.core.domain.R;
-import com.xiaopeng.common.core.utils.SnowFlake;
+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.StringUtils;
import com.xiaopeng.common.redis.service.RedisService;
import io.swagger.annotations.Api;
import lombok.extern.slf4j.Slf4j;
+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.web.bind.annotation.*;
import javax.annotation.Resource;
+import java.util.*;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
@Slf4j
@RestController
@@ -27,60 +54,895 @@
@Api(tags = "订单任务Api")
public class OrderMissionController {
+ /**
+ * 共享线程池，用于推送司机位置轨迹，避免每次请求创建新线程池导致资源泄漏
+ */
+ private static final ThreadPoolExecutor DRIVER_LOCATION_EXECUTOR = new ThreadPoolExecutor(
+ 2, 4, 60L, TimeUnit.SECONDS,
+ new LinkedBlockingQueue<>(500),
+ r -> {
+ Thread t = new Thread(r, "driver-location-push");
+ t.setDaemon(true);
+ return t;
+ },
+ new ThreadPoolExecutor.CallerRunsPolicy()
+ );
+
@Resource
private XPUUtil xpuUtil;
@Resource
private RedisService redisService;
@Resource
private XpVehicleClient xpVehicleClient;
+ @Resource
+ private VehicleBuriedPointClient vehicleBuriedPointClient;
+ @Resource(name = "hutoolSnowflake")
+ private Snowflake snowflake;
-
- @PostMapping("/inner/pushOrder")
+ @PostMapping("/logan/inner/pushOrder")
public R<Boolean> pushOrder(@RequestBody PushOrderDto dto) {
- RtTask.Builder taskBuilder = RtTask.newBuilder();
- //TODO 设置目标地点信息
- taskBuilder.setOrderId(dto.getOrderId().toString());
- taskBuilder.setTaskId("MISSION_"+ IdUtil.fastUUID());
-
- if(dto.getOrderId().contains("XU")){
- taskBuilder.setTaskType(OrderType.ORDER_TYPE_CRUISE);
- }else {
- taskBuilder.setTaskType(OrderType.ORDER_TYPE_ROBOTAXI);
- }
+ log.info("创建订单，推送XPU报文：{}", JSON.toJSONString(dto));
+ //构建点位信息
+ Waypoint.Builder pointBuilderStart = Waypoint.newBuilder();
+ Waypoint.Builder pointBuilderEnd = Waypoint.newBuilder();
RtTaskList.Builder taskListBuilder = RtTaskList.newBuilder();
- taskListBuilder.addTasks(taskBuilder.build());
+ //巡游订单
+ if(dto.getOrderType().equals(com.xiaopeng.api.vo.OrderType.CRUISE_ORDER)){
+ RtTask.Builder taskBuilder = RtTask.newBuilder();
+ taskBuilder.setOrderId(dto.getOrderId().toString());
+ taskBuilder.setTaskId(StringUtils.isNotEmpty(dto.getEndTaskId()) ? dto.getEndTaskId() : snowflake.nextId() + "");
+ taskBuilder.setTaskType(OrderType.ORDER_TYPE_CRUISE);
+ //构建起点坐标数据
+ pointBuilderStart.setWaypointId(dto.getStartWaypointId() + "");
+ pointBuilderStart.setPointType(PointType.START_POINT);
+ pointBuilderStart.setSequence(1);
+ pointBuilderStart.setActionType(ActionType.ACTION_UNSPECIFIED);
+ GeoPoint.Builder geoPointBuilder = GeoPoint.newBuilder();
+ geoPointBuilder.setLatitude(dto.getStartLatitude());
+ geoPointBuilder.setLongitude(dto.getStartLongitude());
+ pointBuilderStart.setPoint(geoPointBuilder.build());
+ taskBuilder.addPoints(pointBuilderStart);
- SnowFlake snowFlake = new SnowFlake(0, 0);
- snowFlake.withStartTimestamp(1420041600000L);
- long sequence = snowFlake.nextId();
+ //构建终点数据
+ pointBuilderEnd.setWaypointId(dto.getEndWaypointId() + "");
+ pointBuilderEnd.setPointType(PointType.CRUISE_END_POINT);
+ pointBuilderEnd.setSequence(2);
+ pointBuilderEnd.setActionType(ActionType.DRIVE_THROUGH);
+ geoPointBuilder = GeoPoint.newBuilder();
+ geoPointBuilder.setLatitude(dto.getEndLatitude());
+ geoPointBuilder.setLongitude(dto.getEndLongitude());
+ pointBuilderEnd.setPoint(geoPointBuilder.build());
+ taskBuilder.addPoints(pointBuilderEnd);
+ taskBuilder.setSequence(1);
+ taskBuilder.setOrderPhase(OrderPhase.ROUTE_TO_CRUISE);
+
+ //不停车替换原有任务
+ if(null != dto.getLastOrderId()){
+ TaskAction.Builder taskActionBuilder = TaskAction.newBuilder();
+ taskActionBuilder.setOrderId(dto.getLastOrderId());
+ taskActionBuilder.setTaskId(dto.getLastXpuTaskId());
+ taskActionBuilder.setActionType(dto.getTaskActionType());
+ taskBuilder.addPreActions(taskActionBuilder.build());
+ }
+ taskListBuilder.addTasks(taskBuilder.build());
+ }else if(dto.getOrderType().equals(com.xiaopeng.api.vo.OrderType.USER_ORDER)){
+ //乘客单
+ for (int i = 1; i < 3; i++) {
+ if(i == 1){
+ RtTask.Builder taskBuilder = RtTask.newBuilder();
+ taskBuilder.setOrderId(dto.getOrderId().toString());
+ taskBuilder.setTaskId(StringUtils.isNotEmpty(dto.getStartTaskId()) ? dto.getStartTaskId() : snowflake.nextId() + "");
+ taskBuilder.setTaskType(OrderType.ORDER_TYPE_ROBOTAXI);
+ VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(dto.getVin())), VehiclePosition.class);
+ //构建车辆当前位置数据
+ pointBuilderStart.setPointType(PointType.START_POINT);
+ pointBuilderStart.setActionType(ActionType.ACTION_UNSPECIFIED);
+ pointBuilderStart.setSequence(1);
+ GeoPoint.Builder geoPointBuilder = GeoPoint.newBuilder();
+ geoPointBuilder.setLatitude(vehiclePosition.getPoint().getY());
+ geoPointBuilder.setLongitude(vehiclePosition.getPoint().getX());
+ pointBuilderStart.setPoint(geoPointBuilder.build());
+ taskBuilder.addPoints(pointBuilderStart);
+
+ //构建上车点位置信息
+ pointBuilderEnd.setWaypointId(dto.getStartWaypointId() + "");
+ pointBuilderEnd.setPointType(PointType.PICK_UP_POINT);
+ pointBuilderEnd.setActionType(ActionType.PICK_UP);
+ pointBuilderEnd.setSequence(2);
+ geoPointBuilder = GeoPoint.newBuilder();
+ geoPointBuilder.setLatitude(dto.getStartLatitude());
+ geoPointBuilder.setLongitude(dto.getStartLongitude());
+ pointBuilderEnd.setPoint(geoPointBuilder.build());
+ taskBuilder.addPoints(pointBuilderEnd);
+ taskBuilder.setSequence(i);
+ taskBuilder.setOrderPhase(OrderPhase.ROUTE_TO_PICKUP);
+
+ //不停车替换原有任务
+ if(null != dto.getLastOrderId()){
+ TaskAction.Builder taskActionBuilder = TaskAction.newBuilder();
+ taskActionBuilder.setOrderId(dto.getLastOrderId());
+ taskActionBuilder.setTaskId(dto.getLastXpuTaskId());
+ taskActionBuilder.setActionType(dto.getTaskActionType());
+ taskBuilder.addPreActions(taskActionBuilder.build());
+ }
+ taskListBuilder.addTasks(taskBuilder.build());
+ }else{
+ RtTask.Builder taskBuilder = RtTask.newBuilder();
+ taskBuilder.setOrderId(dto.getOrderId().toString());
+ taskBuilder.setTaskId(StringUtils.isNotEmpty(dto.getEndTaskId()) ? dto.getEndTaskId() : snowflake.nextId() + "");
+ taskBuilder.setTaskType(OrderType.ORDER_TYPE_ROBOTAXI);
+ //构建上车点位置信息
+ pointBuilderStart.setWaypointId(dto.getStartWaypointId() + "");
+ pointBuilderStart.setPointType(PointType.PICK_UP_POINT);
+ pointBuilderStart.setActionType(ActionType.PICK_UP);
+ pointBuilderStart.setSequence(1);
+ GeoPoint.Builder geoPointBuilder = GeoPoint.newBuilder();
+ geoPointBuilder.setLatitude(dto.getStartLatitude());
+ geoPointBuilder.setLongitude(dto.getStartLongitude());
+ pointBuilderStart.setPoint(geoPointBuilder.build());
+ taskBuilder.addPoints(pointBuilderStart);
+
+ //构建下车点位置信息
+ pointBuilderEnd.setWaypointId(dto.getEndWaypointId() + "");
+ pointBuilderEnd.setPointType(PointType.END_POINT);
+ pointBuilderEnd.setActionType(ActionType.DROP_OFF);
+ pointBuilderEnd.setSequence(2);
+ pointBuilderEnd.setPoiName(dto.getEndPoiName());
+ geoPointBuilder = GeoPoint.newBuilder();
+ geoPointBuilder.setLatitude(dto.getEndLatitude());
+ geoPointBuilder.setLongitude(dto.getEndLongitude());
+ pointBuilderEnd.setPoint(geoPointBuilder.build());
+ taskBuilder.addPoints(pointBuilderEnd);
+ taskBuilder.setSequence(i);
+ taskBuilder.setOrderPhase(OrderPhase.ROUTE_TO_DESTINATION);
+
+ //不停车替换原有任务
+ if(null != dto.getLastOrderId()){
+ TaskAction.Builder taskActionBuilder = TaskAction.newBuilder();
+ taskActionBuilder.setOrderId(dto.getLastOrderId());
+ taskActionBuilder.setTaskId(dto.getLastXpuTaskId());
+ taskActionBuilder.setActionType(dto.getTaskActionType());
+ taskBuilder.addPreActions(taskActionBuilder.build());
+ }
+ taskListBuilder.addTasks(taskBuilder.build());
+ }
+ }
+ }else if(dto.getOrderType().equals(com.xiaopeng.api.vo.OrderType.TEST_ORDER)){
+ //测试单
+ for (int i = 1; i < 3; i++) {
+ if(i == 1){
+ RtTask.Builder taskBuilder = RtTask.newBuilder();
+ taskBuilder.setOrderId(dto.getOrderId().toString());
+ taskBuilder.setTaskId(StringUtils.isNotEmpty(dto.getStartTaskId()) ? dto.getStartTaskId() : snowflake.nextId() + "");
+ taskBuilder.setTaskType(OrderType.ORDER_TYPE_ROBOTAXI);
+ VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(dto.getVin())), VehiclePosition.class);
+ //构建车辆当前位置数据
+ pointBuilderStart.setPointType(PointType.START_POINT);
+ pointBuilderStart.setActionType(ActionType.ACTION_UNSPECIFIED);
+ pointBuilderStart.setSequence(1);
+ GeoPoint.Builder geoPointBuilder = GeoPoint.newBuilder();
+ geoPointBuilder.setLatitude(vehiclePosition.getPoint().getY());
+ geoPointBuilder.setLongitude(vehiclePosition.getPoint().getX());
+ pointBuilderStart.setPoint(geoPointBuilder.build());
+ taskBuilder.addPoints(pointBuilderStart);
+
+ //构建上车点位置信息
+ pointBuilderEnd.setWaypointId(dto.getStartWaypointId() + "");
+ pointBuilderEnd.setPointType(PointType.PICK_UP_POINT);
+ pointBuilderEnd.setActionType(ActionType.PICK_UP);
+ pointBuilderEnd.setSequence(2);
+ geoPointBuilder = GeoPoint.newBuilder();
+ geoPointBuilder.setLatitude(dto.getStartLatitude());
+ geoPointBuilder.setLongitude(dto.getStartLongitude());
+ pointBuilderEnd.setPoint(geoPointBuilder.build());
+ pointBuilderEnd.setPoiName(dto.getEndPoiName());
+ taskBuilder.addPoints(pointBuilderEnd);
+ taskBuilder.setSequence(i);
+ taskBuilder.setOrderPhase(OrderPhase.ROUTE_TO_PICKUP);
+
+ //不停车替换原有任务
+ if(null != dto.getLastOrderId()){
+ TaskAction.Builder taskActionBuilder = TaskAction.newBuilder();
+ taskActionBuilder.setOrderId(dto.getLastOrderId());
+ taskActionBuilder.setTaskId(dto.getLastXpuTaskId());
+ taskActionBuilder.setActionType(dto.getTaskActionType());
+ taskBuilder.addPreActions(taskActionBuilder.build());
+ }
+ taskListBuilder.addTasks(taskBuilder.build());
+ }else{
+ RtTask.Builder taskBuilder = RtTask.newBuilder();
+ taskBuilder.setOrderId(dto.getOrderId().toString());
+ taskBuilder.setTaskId(StringUtils.isNotEmpty(dto.getEndTaskId()) ? dto.getEndTaskId() : snowflake.nextId() + "");
+ taskBuilder.setTaskType(OrderType.ORDER_TYPE_ROBOTAXI);
+ //构建上车点位置信息
+ pointBuilderStart.setWaypointId(dto.getStartWaypointId() + "");
+ pointBuilderStart.setPointType(PointType.PICK_UP_POINT);
+ pointBuilderStart.setActionType(ActionType.PICK_UP);
+ pointBuilderStart.setSequence(1);
+ GeoPoint.Builder geoPointBuilder = GeoPoint.newBuilder();
+ geoPointBuilder.setLatitude(dto.getStartLatitude());
+ geoPointBuilder.setLongitude(dto.getStartLongitude());
+ pointBuilderStart.setPoint(geoPointBuilder.build());
+ taskBuilder.addPoints(pointBuilderStart);
+
+ //构建下车点位置信息
+ pointBuilderEnd.setWaypointId(dto.getEndWaypointId() + "");
+ pointBuilderEnd.setPointType(PointType.END_POINT);
+ pointBuilderEnd.setActionType(ActionType.DROP_OFF);
+ pointBuilderEnd.setSequence(2);
+ geoPointBuilder = GeoPoint.newBuilder();
+ geoPointBuilder.setLatitude(dto.getEndLatitude());
+ geoPointBuilder.setLongitude(dto.getEndLongitude());
+ pointBuilderEnd.setPoint(geoPointBuilder.build());
+ taskBuilder.addPoints(pointBuilderEnd);
+ taskBuilder.setSequence(i);
+ taskBuilder.setOrderPhase(OrderPhase.ROUTE_TO_DESTINATION);
+
+ //不停车替换原有任务
+ if(null != dto.getLastOrderId()){
+ TaskAction.Builder taskActionBuilder = TaskAction.newBuilder();
+ taskActionBuilder.setOrderId(dto.getLastOrderId());
+ taskActionBuilder.setTaskId(dto.getLastXpuTaskId());
+ taskActionBuilder.setActionType(dto.getTaskActionType());
+ taskBuilder.addPreActions(taskActionBuilder.build());
+ }
+ taskListBuilder.addTasks(taskBuilder.build());
+ }
+ }
+ }else if(dto.getOrderType().equals(com.xiaopeng.api.vo.OrderType.TEST_CRUISE_ORDER)){
+ //测试单巡游单
+ RtTask.Builder taskBuilder = RtTask.newBuilder();
+ taskBuilder.setOrderId(dto.getOrderId().toString());
+ taskBuilder.setTaskId(StringUtils.isNotEmpty(dto.getEndTaskId()) ? dto.getEndTaskId() : snowflake.nextId() + "");
+ taskBuilder.setTaskType(OrderType.ORDER_TYPE_CRUISE);
+ //构建起点坐标数据
+ pointBuilderStart.setWaypointId(dto.getStartWaypointId() + "");
+ pointBuilderStart.setPointType(PointType.START_POINT);
+ pointBuilderStart.setSequence(1);
+ pointBuilderStart.setActionType(ActionType.ACTION_UNSPECIFIED);
+ GeoPoint.Builder geoPointBuilder = GeoPoint.newBuilder();
+ geoPointBuilder.setLatitude(dto.getStartLatitude());
+ geoPointBuilder.setLongitude(dto.getStartLongitude());
+ pointBuilderStart.setPoint(geoPointBuilder.build());
+ taskBuilder.addPoints(pointBuilderStart);
+
+ //构建终点数据
+ pointBuilderEnd.setWaypointId(dto.getEndWaypointId() + "");
+ pointBuilderEnd.setPointType(PointType.CRUISE_END_POINT);
+ pointBuilderEnd.setSequence(2);
+ pointBuilderEnd.setActionType(ActionType.DRIVE_THROUGH);
+ geoPointBuilder = GeoPoint.newBuilder();
+ geoPointBuilder.setLatitude(dto.getEndLatitude());
+ geoPointBuilder.setLongitude(dto.getEndLongitude());
+ pointBuilderEnd.setPoint(geoPointBuilder.build());
+ taskBuilder.addPoints(pointBuilderEnd);
+ taskBuilder.setSequence(1);
+ taskBuilder.setOrderPhase(OrderPhase.ROUTE_TO_CRUISE);
+
+ //不停车替换原有任务
+ if(null != dto.getLastOrderId()){
+ TaskAction.Builder taskActionBuilder = TaskAction.newBuilder();
+ taskActionBuilder.setOrderId(dto.getLastOrderId());
+ taskActionBuilder.setTaskId(dto.getLastXpuTaskId());
+ taskActionBuilder.setActionType(dto.getTaskActionType());
+ taskBuilder.addPreActions(taskActionBuilder.build());
+ }
+ taskListBuilder.addTasks(taskBuilder.build());
+ }
+
+ long sequence = snowflake.nextId();
MqttPublishDto mqttPublishDto = xpuUtil.cloudCreateOrder(taskListBuilder.build(), dto.getVin(),sequence);
- // 正常单子才修改 巡游单子不修改状态
- if (!dto.getOrderId().contains("XU") && mqttPublishDto.getCode()== 200) {
+ //先将车辆修改状态，防止在异步通知之前被其他订单选中
+ if(!dto.getOrderType().equals(com.xiaopeng.api.vo.OrderType.CRUISE_ORDER) &&
+ !dto.getOrderType().equals(com.xiaopeng.api.vo.OrderType.TEST_CRUISE_ORDER)
+ && mqttPublishDto.getCode()== 200){
// 修改车子为接单状态
- xpVehicleClient.updateVehicleStatus(new UpdateVehicleStateDto(dto.getVin(),1));
+ xpVehicleClient.updateVehicleStatus(new UpdateVehicleStateDto(dto.getVin(), 1));
+ }
+ if(null != mqttPublishDto && mqttPublishDto.getCode() == 200){
+ JSONObject jsonObject = new JSONObject();
+ jsonObject.put("event", SystemEventType.CREATE_ORDER);
+ jsonObject.put("orderType", dto.getOrderType());
+ jsonObject.put("orderId", dto.getOrderId());
+ jsonObject.put("vin", dto.getVin());
+ redisService.setCacheObject("CREATE_ORDER:" + dto.getOrderId().toString(), jsonObject.toJSONString(),30L, TimeUnit.MINUTES);
return R.ok(true);
}
return R.ok(false);
}
- @PostMapping("/inner/cancelOrder")
- R<Boolean> cancelOrder(@RequestBody PushOrderDto dto) {
+ @PostMapping("/logan/inner/cancelOrder")
+ public R<Boolean> cancelOrder(@RequestBody PushOrderDto dto) {
+ log.info("取消订单，推送XPU报文：{}", JSON.toJSONString(dto));
+ String taskId = StringUtils.isNotEmpty(dto.getEndTaskId()) ? dto.getEndTaskId() : snowflake.nextId() + "";
OrderOperation.Builder operationBuilder = OrderOperation.newBuilder();
operationBuilder.setOrderId(dto.getOrderId().toString());
- operationBuilder.setTaskId("CANCEL_MISSION_" + IdUtil.fastUUID());
+ operationBuilder.setTaskId(taskId);
if (dto.getOperation_type() != null) {
- operationBuilder.setOperationType(OrderOperationType.forNumber(dto.getOperation_type().getValue()));
+ operationBuilder.setOperationType(OrderOperationType.forNumber(dto.getOperation_type().getNumber()));
}
- SnowFlake snowFlake = new SnowFlake(0, 0);
- snowFlake.withStartTimestamp(1420041600000L);
- long sequence = snowFlake.nextId();
- xpuUtil.cloudOrderOperation(operationBuilder.build(), dto.getVin(), sequence);
- redisService.setCacheObject(String.valueOf(sequence), "cancelOrder_" + dto.getOrderId() + "_" + dto.getVin(), 30l, TimeUnit.MINUTES);
- return R.ok(true);
+ long sequence = snowflake.nextId();
+ MqttPublishDto mqttPublishDto = xpuUtil.cloudOrderOperation(operationBuilder.build(), dto.getVin(), sequence);
+
+ if (mqttPublishDto.getCode() == 200) {
+ if(!dto.getOrderId().contains("XU")){
+ Map<String, Object> cancelContext = new HashMap<>();
+ cancelContext.put("orderId", dto.getOrderId());
+ cancelContext.put("vin", dto.getVin());
+ cancelContext.put("cancelScene", StringUtils.isNotEmpty(dto.getCancelScene())
+ ? dto.getCancelScene()
+ : CancelOrderSceneEnum.NORMAL_CANCEL.getCode());
+ redisService.setCacheObject("CANCEL_ORDER_CONTEXT:" + taskId,
+ JSONObject.toJSONString(cancelContext), 30L, TimeUnit.MINUTES);
+ log.info("记录取消订单上下文成功，orderId: {}, vin: {}, taskId: {}, cancelScene: {}",
+ dto.getOrderId(), dto.getVin(), taskId, cancelContext.get("cancelScene"));
+ }
+ return R.ok(true);
+ }
+
+ return R.ok(false);
}
+
+
+
+ @PostMapping("/logan/inner/updateEndAddress")
+ public R<Boolean> updateEndAddress(@RequestBody PushOrderDto dto){
+ log.info("修改目的地，推送XPU报文：{}", JSON.toJSONString(dto));
+ String taskId = StringUtils.isNotEmpty(dto.getEndTaskId()) ? dto.getEndTaskId() : snowflake.nextId() + "";
+ OrderOperation.Builder operationBuilder = OrderOperation.newBuilder();
+ operationBuilder.setOrderId(dto.getOrderId().toString());
+ operationBuilder.setTaskId(taskId);
+ if (dto.getOperation_type() != null) {
+ operationBuilder.setOperationType(OrderOperationType.forNumber(dto.getOperation_type().getNumber()));
+ }
+ Waypoint.Builder waypointBuilder = Waypoint.newBuilder();
+ waypointBuilder.setWaypointId(dto.getOrderId() + "-002");
+ waypointBuilder.setPointType(PointType.END_POINT);
+ waypointBuilder.setActionType(ActionType.DROP_OFF);
+ waypointBuilder.setSequence(2);
+ GeoPoint.Builder geoPointBuilder = GeoPoint.newBuilder();
+ geoPointBuilder.setLatitude(dto.getEndLatitude());
+ geoPointBuilder.setLongitude(dto.getEndLongitude());
+ waypointBuilder.setPoint(geoPointBuilder.build());
+ waypointBuilder.setPoiName(dto.getEndPoiName());
+ operationBuilder.setTargetPoint(waypointBuilder);
+ long sequence = snowflake.nextId();
+ MqttPublishDto mqttPublishDto = xpuUtil.cloudOrderOperation(operationBuilder.build(), dto.getVin(), sequence);
+
+ if (mqttPublishDto.getCode() == 200) {
+ if(!dto.getOrderId().contains("XU")){
+ Map<String, Object> cancelContext = new HashMap<>();
+ cancelContext.put("orderId", dto.getOrderId());
+ cancelContext.put("vin", dto.getVin());
+ cancelContext.put("cancelScene", StringUtils.isNotEmpty(dto.getCancelScene())
+ ? dto.getCancelScene()
+ : CancelOrderSceneEnum.NORMAL_CANCEL.getCode());
+ redisService.setCacheObject("CANCEL_ORDER_CONTEXT:" + taskId,
+ JSONObject.toJSONString(cancelContext), 30L, TimeUnit.MINUTES);
+ log.info("记录修改目的地订单上下文成功，orderId: {}, vin: {}, taskId: {}, cancelScene: {}",
+ dto.getOrderId(), dto.getVin(), taskId, cancelContext.get("cancelScene"));
+ }
+ return R.ok(true);
+ }
+
+ return R.ok(false);
+ }
+
+
+
+
+
+
+
+
+
+
+ //-----------------------------------------------用户测试阶段模拟车机报文调用流程接口实现业务闭环--------------------------------------//
+
+
+ @Resource
+ private XpOrderClient xpOrderClient;
+
+ @Resource
+ private XpMapClient xpMapClient;
+
+ @Resource
+ private MongoTemplate mongoTemplate;
+
+ @Resource
+ public RedisTemplate redisTemplate;
+
+ @Resource
+ private XpPushMessageClient xpPushMessageClient;
+
+
+ /**
+ * 模拟接单
+ * @param orderId 订单id
+ * @param vehicleId 车辆id
+ * @param startLon 车子当前位置经度
+ * @param startLat 车子当前位置维度
+ * @return
+ */
+ @GetMapping("/base/v1/order/acceptingOrder")
+ public R acceptingOrder(Long orderId, String code, Long vehicleId, Double startLon, Double startLat){
+ log.info("【模拟接单】开始，orderId={}, code={}, vehicleId={}, startLon={}, startLat={}", orderId, code, vehicleId, startLon, startLat);
+ if(null == vehicleId){
+ vehicleId = 11L;//默认使用造的测试车辆
+ log.info("【模拟接单】vehicleId为空，使用默认测试车辆 vehicleId={}", vehicleId);
+ }
+ if(null == startLat || null == startLon){
+ startLat = 23.146815D;
+ startLon = 113.459765D;
+ log.info("【模拟接单】起点坐标为空，使用默认坐标 startLon={}, startLat={}", startLon, startLat);
+ }
+ XpVehicle xpVehicle = xpVehicleClient.queryById(vehicleId).getData();
+ log.info("【模拟接单】查询车辆信息，vehicleId={}, vin={}", vehicleId, xpVehicle != null ? xpVehicle.getVehicleVin() : "null");
+ XpOrder xpOrder = null;
+ if(null != orderId){
+ xpOrder = xpOrderClient.queryOrderById(orderId).getData();
+ log.info("【模拟接单】按orderId查询订单，orderId={}, orderNo={}", orderId, xpOrder != null ? xpOrder.getOrderNumber() : "null");
+ }
+ if(StringUtils.isNotEmpty(code)){
+ xpOrder = xpOrderClient.queryOrderByOrderNo(code).getData();
+ log.info("【模拟接单】按orderNo查询订单，code={}, orderId={}", code, xpOrder != null ? xpOrder.getId() : "null");
+ }
+
+ orderId = xpOrder.getId();
+ log.info("【模拟接单】订单信息，orderId={}, appUserId={}, startLon={}, startLat={}", orderId, xpOrder.getAppUserId(), xpOrder.getStartLon(), xpOrder.getStartLat());
+ OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
+ dto.setOrderId(orderId);
+ LonLatDto origin = new LonLatDto();
+ origin.setLongitude(startLon);
+ origin.setLatitude(startLat);
+ dto.setOrigin(origin);
+
+ //保存车辆实时位置到redis
+ redisTemplate.opsForGeo().add("vehiclePosition:" + xpVehicle.getVehicleVin(), new Point(startLon, startLat), xpVehicle.getVehicleVin());
+ log.info("【模拟接单】保存车辆位置到Redis，vin={}, lon={}, lat={}", xpVehicle.getVehicleVin(), startLon, startLat);
+
+ //保存车辆实时信息到mongodb
+ VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(xpVehicle.getVehicleVin())), VehiclePosition.class);
+ if (null == vehiclePosition) {
+ log.info("【模拟接单】MongoDB无车辆位置记录，新建，vin={}", xpVehicle.getVehicleVin());
+ vehiclePosition = new VehiclePosition();
+ vehiclePosition.setVin(xpVehicle.getVehicleVin());
+ vehiclePosition.setPoint(new GeoJsonPoint(startLon, startLat));
+ vehiclePosition.setCourse(60D);
+ vehiclePosition.setAlt(100F);
+ vehiclePosition.setSpeed(50F);
+ vehiclePosition.setCurrentElectricity(80);
+ vehiclePosition.setMileageRange(300f);
+ vehiclePosition.setHasOrder(0);
+ vehiclePosition.setOrderId(orderId);
+ vehiclePosition.setTotalOdometer(10000L);
+ vehiclePosition.setAddTime(System.currentTimeMillis());
+ mongoTemplate.save(vehiclePosition);
+ }else{
+ log.info("【模拟接单】更新MongoDB车辆位置记录，vin={}", xpVehicle.getVehicleVin());
+ vehiclePosition.setOrderId(orderId);
+ Update update = new Update()
+ .set("point", new GeoJsonPoint(startLon, startLat))
+ .set("course", 60D)
+ .set("alt", 100F)
+ .set("speed", 50F)
+ .set("currentElectricity", 80)
+ .set("mileageRange", 300f)
+ .set("hasOrder", 0)
+ .set("orderId", orderId)
+ .set("totalOdometer", 10000L)
+ .set("addTime", System.currentTimeMillis());
+ mongoTemplate.updateFirst(new Query(Criteria.where("vin").is(xpVehicle.getVehicleVin())), update, VehiclePosition.class);
+ }
+
+ LonLatDto destination = new LonLatDto();
+ destination.setLongitude(xpOrder.getStartLon());
+ destination.setLatitude(xpOrder.getStartLat());
+ dto.setDestination(destination);
+ dto.setRouteType(1);
+ dto.setVehicleId(xpOrder.getVehicleId());
+ log.info("【模拟接单】请求规划接驾路线，origin=[{},{}], destination=[{},{}]", startLon, startLat, xpOrder.getStartLon(), xpOrder.getStartLat());
+ R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
+ if (200 != routeVoR.getCode()) {
+ log.error("【模拟接单】获取订单线路和运费失败，orderId={}, code={}, msg={}", orderId, routeVoR.getCode(), routeVoR.getMsg());
+ throw new RuntimeException("获取订单线路和运费失败");
+ }
+ RouteVo routeVo = routeVoR.getData();
+ log.info("【模拟接单】获取接驾路线成功，orderId={}, distance={}, duration={}, polylineSize={}", orderId, routeVo.getDistance(), routeVo.getDuration(), routeVo.getPolyline() != null ? routeVo.getPolyline().size() : 0);
+ //缓存数据，用于后续推给乘客导航线路
+ redisService.setCacheObject("ORDER_NAVIGATION_START_DATA:" + xpOrder.getAppUserId(), JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
+ log.info("【模拟接单】缓存接驾导航数据成功，key=ORDER_NAVIGATION_START_DATA:{}", xpOrder.getAppUserId());
+
+ PopOrderDto dto1 = new PopOrderDto();
+ dto1.setOrderId(Long.valueOf(orderId));
+ dto1.setXpVehicleVin(xpVehicle.getVehicleVin());
+ dto1.setOrderType(com.xiaopeng.api.vo.OrderType.USER_ORDER);
+ log.info("【模拟接单】调用popOrder，orderId={}, vin={}", orderId, xpVehicle.getVehicleVin());
+ R<?> r = xpOrderClient.popOrder(dto1);
+ log.info("【模拟接单】popOrder结果，orderId={}, code={}", orderId, r.getCode());
+
+ //构建推送消息
+ Map<String, Object> params = new HashMap<>();
+ Map<String, Object> content = new HashMap<>();
+ content.put("orderId", orderId.toString());
+ content.put("status", 3);
+ params.put("type", PushMessageTypeEnum.ORDER_STATUS.getDesc());
+ params.put("content", JSONObject.toJSONString(content));
+ params.put("timestamp", System.currentTimeMillis() + "");
+ String message = JSONObject.toJSONString(params);
+ Long appUserId = xpOrder.getAppUserId();
+ SendMessageDTO dto2 = new SendMessageDTO();
+ dto2.setAppUserId(appUserId + "");
+ dto2.setMessage(message);
+ log.info("【模拟接单】推送订单状态(status=3)给用户，appUserId={}, orderId={}", appUserId, orderId);
+ R<String> stringR = xpPushMessageClient.sendStatus(dto2);
+ if (R.isError(stringR)) {
+ log.error("【模拟接单】推送消息失败，appUserId={}, orderId={}, msg={}", appUserId, orderId, stringR.getMsg());
+ }
+ log.info("【模拟接单】更新订单状态为PICK_UP，orderId={}", orderId);
+ xpOrderClient.updateOrderStatus(orderId, OrderStatusEnum.PICK_UP.getCode(), false);
+ log.info("【模拟接单】流程完成，orderId={}", orderId);
+
+// PushOrderRouteDTO dto3 = new PushOrderRouteDTO();
+// dto3.setOrderId(orderId);
+// dto3.setRouteType(1);
+// dto3.setLongitude(startLon);
+// dto3.setLatitude(startLat);
+// dto3.setDuration(10);
+// dto3.setDistance(2);
+// dto3.setDirection(60);
+// xpPushMessageClient.pushOrderRoute(dto3);
+
+ return r;
+ }
+
+
+ /**
+ * 推送司机接驾轨迹和实时位置
+ * @param orderId
+ */
+ @GetMapping("/base/v1/order/pushStartDriverLocation")
+ private void pushStartDriverLocation(Long vehicleId, Long orderId, String code){
+ log.info("【推送接驾轨迹】开始，vehicleId={}, orderId={}, code={}", vehicleId, orderId, code);
+ if(null == vehicleId){
+ vehicleId = 1L;
+ log.info("【推送接驾轨迹】vehicleId为空，使用默认 vehicleId={}", vehicleId);
+ }
+ XpVehicle xpVehicle = xpVehicleClient.queryById(vehicleId).getData();
+ XpOrder xpOrder = null;
+ if(null != orderId){
+ xpOrder = xpOrderClient.queryOrderById(orderId).getData();
+ }
+ if(StringUtils.isNotEmpty(code)){
+ xpOrder = xpOrderClient.queryOrderByOrderNo(code).getData();
+ }
+ orderId = xpOrder.getId();
+ String vin = xpVehicle.getVehicleVin();
+ Long appUserId = xpOrder.getAppUserId();
+ log.info("【推送接驾轨迹】订单信息，orderId={}, orderNo={}, vin={}, appUserId={}", orderId, xpOrder.getOrderNumber(), vin, appUserId);
+ Object cacheObject = redisService.getCacheObject("ORDER_NAVIGATION_START_DATA:" + xpOrder.getAppUserId());
+ RouteVo routeVo = JSON.parseObject(cacheObject.toString(), RouteVo.class);
+ log.info("【推送接驾轨迹】获取接驾导航缓存数据，orderId={}, polylineSize={}", orderId, routeVo.getPolyline() != null ? routeVo.getPolyline().size() : 0);
+
+ Long finalOrderId = orderId;
+ Long finalOrderId1 = orderId;
+ DRIVER_LOCATION_EXECUTOR.execute(() -> {
+ //等待1秒后开始执行车子位移
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.error("pushStartDriverLocation 线程被中断", e);
+ return;
+ }
+ List<LonLatDto> polyline = routeVo.getPolyline();
+ log.info("【推送接驾轨迹】开始逐点推送位置，orderId={}, 总点数={}", finalOrderId, polyline.size());
+ int idx = 0;
+ for (LonLatDto lonLatDto : polyline) {
+ Double latitude = lonLatDto.getLatitude();
+ Double longitude = lonLatDto.getLongitude();
+ log.info("【推送接驾轨迹】推送第{}/{}个点，orderId={}, lon={}, lat={}", ++idx, polyline.size(), finalOrderId, longitude, latitude);
+
+ //保存车辆实时位置到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();
+ vehiclePosition.setVin(vin);
+ vehiclePosition.setPoint(new GeoJsonPoint(longitude, latitude));
+ vehiclePosition.setCourse(60D);
+ vehiclePosition.setAlt(100F);
+ vehiclePosition.setSpeed(50F);
+ vehiclePosition.setCurrentElectricity(80);
+ vehiclePosition.setMileageRange(300f);
+ vehiclePosition.setHasOrder(0);
+ vehiclePosition.setOrderId(finalOrderId1);
+ vehiclePosition.setTotalOdometer(10000L);
+ vehiclePosition.setAddTime(System.currentTimeMillis());
+ mongoTemplate.save(vehiclePosition);
+ }else{
+ vehiclePosition.setOrderId(finalOrderId1);
+ Update update = new Update()
+ .set("point", new GeoJsonPoint(longitude, latitude))
+ .set("course", 60D)
+ .set("alt", 100F)
+ .set("speed", 50F)
+ .set("currentElectricity", 80)
+ .set("mileageRange", 300f)
+ .set("hasOrder", 0)
+ .set("orderId", finalOrderId1)
+ .set("totalOdometer", 10000L)
+ .set("addTime", System.currentTimeMillis());;
+ mongoTemplate.updateFirst(new Query(Criteria.where("vin").is(vin)), update, VehiclePosition.class);
+ }
+ //调用推送服务接口
+ if (null != finalOrderId) {
+ PushOrderRouteDTO dto = new PushOrderRouteDTO();
+ dto.setOrderId(finalOrderId);
+ dto.setRouteType(1);
+ dto.setLongitude(longitude);
+ dto.setLatitude(latitude);
+ dto.setDuration(10.0);
+ dto.setDistance(2.0);
+ dto.setDirection(60);
+ dto.setMessageType(PushMessageTypeEnum.ORDER_ROUTE.getDesc());
+ xpPushMessageClient.pushOrderRoute(dto);
+ }
+
+ //2秒钟循环一次
+ try {
+ Thread.sleep(2000);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.error("pushStartDriverLocation 循环线程被中断", e);
+ return;
+ }
+ }
+
+ log.info("【推送接驾轨迹】所有点推送完毕，推送status=4给用户，orderId={}, appUserId={}", finalOrderId, appUserId);
+ //构建推送消息
+ Map<String, Object> params = new HashMap<>();
+ Map<String, Object> content = new HashMap<>();
+ content.put("orderId", finalOrderId.toString());
+ content.put("status", 4);
+ params.put("type", PushMessageTypeEnum.ORDER_STATUS.getDesc());
+ params.put("content", JSONObject.toJSONString(content));
+ params.put("timestamp", System.currentTimeMillis() + "");
+ String message = JSONObject.toJSONString(params);
+ SendMessageDTO dto2 = new SendMessageDTO();
+ dto2.setAppUserId(appUserId + "");
+ dto2.setMessage(message);
+ R<String> stringR = xpPushMessageClient.sendStatus(dto2);
+ if (R.isError(stringR)) {
+ log.error("【推送接驾轨迹】推送消息失败，appUserId={}, orderId={}, msg={}", appUserId, finalOrderId, stringR.getMsg());
+ }
+ log.info("【推送接驾轨迹】更新订单状态为PICK_UP_GUESTS，orderId={}", finalOrderId);
+ xpOrderClient.updateOrderStatus(finalOrderId, OrderStatusEnum.PICK_UP_GUESTS.getCode(), false);
+ log.info("【推送接驾轨迹】流程完成，orderId={}", finalOrderId);
+ });
+
+ }
+
+
+ /**
+ * 修改订单状态
+ * @param orderId
+ * @param status
+ * @return
+ */
+ @GetMapping("/base/v1/order/updateOrderStatus")
+ public R updateOrderStatus(Long orderId, String code, Integer status) {
+ log.info("【模拟修改订单状态】开始，orderId={}, code={}, status={}", orderId, code, status);
+ XpOrder xpOrder = null;
+ if(null != orderId){
+ xpOrder = xpOrderClient.queryOrderById(orderId).getData();
+ }
+ if(StringUtils.isNotEmpty(code)){
+ xpOrder = xpOrderClient.queryOrderByOrderNo(code).getData();
+ }
+ orderId = xpOrder.getId();
+ log.info("【模拟修改订单状态】订单信息，orderId={}, orderNo={}, appUserId={}", orderId, xpOrder.getOrderNumber(), xpOrder.getAppUserId());
+ //构建推送消息
+ Map<String, Object> params = new HashMap<>();
+ Map<String, Object> content = new HashMap<>();
+ content.put("orderId", orderId.toString());
+ content.put("status", status);
+ params.put("type", PushMessageTypeEnum.ORDER_STATUS.getDesc());
+ params.put("content", JSONObject.toJSONString(content));
+ params.put("timestamp", System.currentTimeMillis() + "");
+ String message = JSONObject.toJSONString(params);
+ SendMessageDTO dto2 = new SendMessageDTO();
+ dto2.setAppUserId(xpOrder.getAppUserId() + "");
+ dto2.setMessage(message);
+ log.info("【模拟修改订单状态】推送状态消息给用户，appUserId={}, orderId={}, status={}", xpOrder.getAppUserId(), orderId, status);
+ R<String> stringR = xpPushMessageClient.sendStatus(dto2);
+ if (R.isError(stringR)) {
+ log.error("【模拟修改订单状态】推送消息失败，appUserId={}, orderId={}, msg={}", xpOrder.getAppUserId(), orderId, stringR.getMsg());
+ }
+ log.info("【模拟修改订单状态】更新订单状态，orderId={}, status={}", orderId, status);
+ xpOrderClient.updateOrderStatus(orderId, status, false);
+ if(5 == status){
+ log.info("【模拟修改订单状态】status=5，主动推送全程轨迹，orderId={}", orderId);
+ //主动推一次全程轨迹
+ Object cacheObject = redisService.getCacheObject("ORDER_NAVIGATION_END_DATA:" + xpOrder.getAppUserId());
+ RouteVo routeVo = JSON.parseObject(cacheObject.toString(), RouteVo.class);
+ log.info("【模拟修改订单状态】获取送驾导航缓存，orderId={}, polylineSize={}", orderId, routeVo.getPolyline() != null ? routeVo.getPolyline().size() : 0);
+ JSONObject jsonObject = new JSONObject();
+ jsonObject.put("type", "ORDER_ROUTE");
+ jsonObject.put("timestamp", System.currentTimeMillis());
+ JSONObject content1 = new JSONObject();
+ content1.put("orderId", orderId.toString());
+ content1.put("routeType", 1);
+ JSONObject route = new JSONObject();
+ route.put("distance", routeVo.getDistance());
+ route.put("duration", routeVo.getDuration());
+ route.put("routeID", routeVo.getRouteID());
+
+ List<JSONObject> collect = routeVo.getPolyline().stream().map(item -> {
+ JSONObject point = new JSONObject();
+ point.put("latitude", item.getLatitude());
+ point.put("longitude", item.getLongitude());
+ return point;
+ }).collect(Collectors.toList());
+
+ route.put("polyline", JSON.toJSONString(collect));
+ content1.put("route", route.toJSONString());
+ jsonObject.put("content", content1.toJSONString());
+ SendMessageDTO messageDTO = new SendMessageDTO();
+ messageDTO.setAppUserId(xpOrder.getAppUserId().toString());
+ messageDTO.setMessage(jsonObject.toJSONString());
+ log.info("【模拟修改订单状态】推送全程轨迹，appUserId={}, orderId={}", xpOrder.getAppUserId(), orderId);
+ xpPushMessageClient.sendRoute(messageDTO);
+ }
+ log.info("【模拟修改订单状态】完成，orderId={}, status={}", orderId, status);
+ return R.ok();
+ }
+
+
+
+ /**
+ * 推送司机送驾轨迹和实时位置
+ * @param orderId
+ */
+ @GetMapping("/base/v1/order/pushEndDriverLocation")
+ private void pushEndDriverLocation(Long vehicleId, Long orderId, String code){
+ log.info("【推送送驾轨迹】开始，vehicleId={}, orderId={}, code={}", vehicleId, orderId, code);
+ if(null == vehicleId){
+ vehicleId = 1L;
+ log.info("【推送送驾轨迹】vehicleId为空，使用默认 vehicleId={}", vehicleId);
+ }
+ XpVehicle xpVehicle = xpVehicleClient.queryById(vehicleId).getData();
+ XpOrder xpOrder = null;
+ if(null != orderId){
+ xpOrder = xpOrderClient.queryOrderById(orderId).getData();
+ }
+ if(StringUtils.isNotEmpty(code)){
+ xpOrder = xpOrderClient.queryOrderByOrderNo(code).getData();
+ }
+ orderId = xpOrder.getId();
+ String vin = xpVehicle.getVehicleVin();
+ Long appUserId = xpOrder.getAppUserId();
+ Object cacheObject = redisService.getCacheObject("ORDER_NAVIGATION_END_DATA:" + xpOrder.getAppUserId());
+ RouteVo routeVo = JSON.parseObject(cacheObject.toString(), RouteVo.class);
+ log.info("开始实施推送车辆位置和剩余导航线路 {} {}", xpOrder.getOrderNumber(), JSON.toJSONString(routeVo));
+ log.info("【推送送驾轨迹】获取送驾导航缓存，orderId={}, vin={}, appUserId={}, polylineSize={}", orderId, vin, appUserId, routeVo.getPolyline() != null ? routeVo.getPolyline().size() : 0);
+
+ Long finalOrderId = orderId;
+ Long finalOrderId1 = orderId;
+ DRIVER_LOCATION_EXECUTOR.execute(() -> {
+ //等待1秒后开始执行车子位移
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.error("pushEndDriverLocation 线程被中断", e);
+ return;
+ }
+
+ List<LonLatDto> polyline = routeVo.getPolyline();
+ log.info("【推送送驾轨迹】开始逐点推送位置，orderId={}, 总点数={}", finalOrderId, polyline.size());
+ int idx = 0;
+ for (LonLatDto lonLatDto : polyline) {
+ Double latitude = lonLatDto.getLatitude();
+ Double longitude = lonLatDto.getLongitude();
+ log.info("【推送送驾轨迹】推送第{}/{}个点，orderId={}, lon={}, lat={}", ++idx, polyline.size(), finalOrderId, longitude, latitude);
+
+ //保存车辆实时位置到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();
+ vehiclePosition.setVin(vin);
+ vehiclePosition.setPoint(new GeoJsonPoint(longitude, latitude));
+ vehiclePosition.setCourse(60D);
+ vehiclePosition.setAlt(100F);
+ vehiclePosition.setSpeed(50F);
+ vehiclePosition.setCurrentElectricity(80);
+ vehiclePosition.setMileageRange(300f);
+ vehiclePosition.setHasOrder(0);
+ vehiclePosition.setOrderId(finalOrderId1);
+ vehiclePosition.setTotalOdometer(10000L);
+ vehiclePosition.setAddTime(System.currentTimeMillis());
+ mongoTemplate.save(vehiclePosition);
+ }else{
+ vehiclePosition.setOrderId(finalOrderId1);
+ Update update = new Update()
+ .set("point", new GeoJsonPoint(longitude, latitude))
+ .set("course", 60D)
+ .set("alt", 100F)
+ .set("speed", 50F)
+ .set("currentElectricity", 80)
+ .set("mileageRange", 300f)
+ .set("hasOrder", 0)
+ .set("orderId", finalOrderId1)
+ .set("totalOdometer", 10000L)
+ .set("addTime", System.currentTimeMillis());;
+ mongoTemplate.updateFirst(new Query(Criteria.where("vin").is(vin)), update, VehiclePosition.class);
+ }
+ //调用推送服务接口
+ if (null != finalOrderId) {
+ PushOrderRouteDTO dto = new PushOrderRouteDTO();
+ dto.setOrderId(finalOrderId);
+ dto.setRouteType(1);
+ dto.setLongitude(longitude);
+ dto.setLatitude(latitude);
+ dto.setDuration(20.0);
+ dto.setDistance(10.0);
+ dto.setDirection(60);
+ dto.setMessageType(PushMessageTypeEnum.ORDER_ROUTE.getDesc());
+ R<String> stringR = xpPushMessageClient.pushOrderRoute(dto);
+
+ //存储历史轨迹
+ OrderTrajectoryVo orderTrajectory = new OrderTrajectoryVo();
+ orderTrajectory.setOrderId(finalOrderId);
+ orderTrajectory.setLocation(longitude + "," + latitude);
+ orderTrajectory.setDirection(dto.getDirection());
+ orderTrajectory.setSpeed(0D);
+ orderTrajectory.setLocatetime(System.currentTimeMillis());
+ orderTrajectory.setCreateTime(new Date());
+ xpOrderClient.saveVehicleLocation(orderTrajectory);
+ }
+
+ //1秒钟循环一次
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.error("pushEndDriverLocation 循环线程被中断", e);
+ return;
+ }
+ }
+
+ log.info("【推送送驾轨迹】所有点推送完毕，推送status=7给用户，orderId={}, appUserId={}", finalOrderId, appUserId);
+ //构建推送消息
+ Map<String, Object> params = new HashMap<>();
+ Map<String, Object> content = new HashMap<>();
+ content.put("orderId", finalOrderId.toString());
+ content.put("status", 7);
+ params.put("type", PushMessageTypeEnum.ORDER_STATUS.getDesc());
+ params.put("content", JSONObject.toJSONString(content));
+ params.put("timestamp", System.currentTimeMillis() + "");
+ String message = JSONObject.toJSONString(params);
+ SendMessageDTO dto2 = new SendMessageDTO();
+ dto2.setAppUserId(appUserId + "");
+ dto2.setMessage(message);
+ R<String> stringR = xpPushMessageClient.sendStatus(dto2);
+ if (R.isError(stringR)) {
+ log.error("【推送送驾轨迹】推送消息失败，appUserId={}, orderId={}, msg={}", appUserId, finalOrderId, stringR.getMsg());
+ }
+ log.info("【推送送驾轨迹】更新订单状态为SEE_OFF_GUESTS，orderId={}", finalOrderId);
+ xpOrderClient.updateOrderStatus(finalOrderId, OrderStatusEnum.SEE_OFF_GUESTS.getCode(), false);
+ log.info("【推送送驾轨迹】流程完成，orderId={}", finalOrderId);
+ });
+ }
+
}
--
Gitblit v1.7.1