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.automaticPilot.VehicleEventDTO;
|
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.model.order.XpOrder;
|
import com.xiaopeng.api.model.vehicleConvoy.XpVehicle;
|
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.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.beans.factory.annotation.Autowired;
|
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
|
@RequestMapping("")
|
@Api(tags = "订单任务Api")
|
public class OrderMissionController {
|
|
@Resource
|
private XPUUtil xpuUtil;
|
@Resource
|
private RedisService redisService;
|
@Resource
|
private XpVehicleClient xpVehicleClient;
|
@Resource
|
private VehicleBuriedPointClient vehicleBuriedPointClient;
|
@Resource(name = "hutoolSnowflake")
|
private Snowflake snowflake;
|
|
@PostMapping("/logan/inner/pushOrder")
|
public R<Boolean> pushOrder(@RequestBody PushOrderDto dto) {
|
log.info("创建订单，推送XPU报文：{}", JSON.toJSONString(dto));
|
//构建点位信息
|
Waypoint.Builder pointBuilderStart = Waypoint.newBuilder();
|
Waypoint.Builder pointBuilderEnd = Waypoint.newBuilder();
|
RtTaskList.Builder taskListBuilder = RtTaskList.newBuilder();
|
//巡游订单
|
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.getTaskId()) ? dto.getTaskId() : snowflake.nextId() + "");
|
taskBuilder.setTaskType(OrderType.ORDER_TYPE_CRUISE);
|
//构建起点坐标数据
|
pointBuilderStart.setWaypointId(dto.getOrderId() + "-001");
|
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.getOrderId() + "-002");
|
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);
|
taskListBuilder.addTasks(taskBuilder.build());
|
}else if(dto.getOrderType().equals(com.xiaopeng.api.vo.OrderType.USER_ORDER)){
|
//乘客单
|
for (int i = 1; i < 3; i++) {
|
RtTask.Builder taskBuilder = RtTask.newBuilder();
|
taskBuilder.setOrderId(dto.getOrderId().toString());
|
taskBuilder.setTaskId(StringUtils.isNotEmpty(dto.getTaskId()) ? dto.getTaskId() : snowflake.nextId() + "");
|
taskBuilder.setTaskType(OrderType.ORDER_TYPE_ROBOTAXI);
|
if(i == 1){
|
VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(dto.getVin())), VehiclePosition.class);
|
//构建车辆当前位置数据
|
pointBuilderStart.setWaypointId(dto.getOrderId() + "-JJ-001");
|
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.getOrderId() + "-JJ-002");
|
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);
|
}else{
|
//构建上车点位置信息
|
pointBuilderStart.setWaypointId(dto.getOrderId() + "-SD-001");
|
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.getOrderId() + "-SD-002");
|
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);
|
}
|
taskListBuilder.addTasks(taskBuilder.build());
|
}
|
}else if(dto.getOrderType().equals(com.xiaopeng.api.vo.OrderType.TEST_ORDER)){
|
//测试单
|
for (int i = 1; i < 3; i++) {
|
RtTask.Builder taskBuilder = RtTask.newBuilder();
|
taskBuilder.setOrderId(dto.getOrderId().toString());
|
taskBuilder.setTaskId(StringUtils.isNotEmpty(dto.getTaskId()) ? dto.getTaskId() : snowflake.nextId() + "");
|
taskBuilder.setTaskType(OrderType.ORDER_TYPE_ROBOTAXI);
|
if(i == 1){
|
VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(dto.getVin())), VehiclePosition.class);
|
//构建车辆当前位置数据
|
pointBuilderStart.setWaypointId(dto.getOrderId() + "-JJ-001");
|
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.getOrderId() + "-JJ-002");
|
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);
|
}else{
|
//构建上车点位置信息
|
pointBuilderStart.setWaypointId(dto.getOrderId() + "-SD-001");
|
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.getOrderId() + "-SD-002");
|
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);
|
}
|
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.getTaskId()) ? dto.getTaskId() : snowflake.nextId() + "");
|
taskBuilder.setTaskType(OrderType.ORDER_TYPE_CRUISE);
|
//构建起点坐标数据
|
pointBuilderStart.setWaypointId(dto.getOrderId() + "-001");
|
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.getOrderId() + "-002");
|
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);
|
taskListBuilder.addTasks(taskBuilder.build());
|
}
|
|
long sequence = snowflake.nextId();
|
MqttPublishDto mqttPublishDto = xpuUtil.cloudCreateOrder(taskListBuilder.build(), dto.getVin(),sequence);
|
//先将车辆修改状态，防止在异步通知之前被其他订单选中
|
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));
|
}
|
|
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("/logan/inner/cancelOrder")
|
public R<Boolean> cancelOrder(@RequestBody PushOrderDto dto) {
|
log.info("取消订单，推送XPU报文：{}", JSON.toJSONString(dto));
|
String taskId = StringUtils.isNotEmpty(dto.getTaskId()) ? dto.getTaskId() : 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()));
|
}
|
|
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.getTaskId()) ? dto.getTaskId() : 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.getStartLatitude());
|
geoPointBuilder.setLongitude(dto.getStartLongitude());
|
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){
|
if(null == vehicleId){
|
vehicleId = 11L;//默认使用造的测试车辆
|
}
|
if(null == startLat || null == startLon){
|
startLat = 23.146815D;
|
startLon = 113.459765D;
|
}
|
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();
|
OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
|
dto.setOrderId(orderId);
|
LonLatDto origin = new LonLatDto();
|
origin.setLongitude(startLon);
|
origin.setLatitude(startLat);
|
dto.setOrigin(origin);
|
LonLatDto destination = new LonLatDto();
|
destination.setLongitude(xpOrder.getStartLon());
|
destination.setLatitude(xpOrder.getStartLat());
|
dto.setDestination(destination);
|
dto.setRouteType(1);
|
dto.setVehicleId(xpOrder.getVehicleId());
|
R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
|
if (200 != routeVoR.getCode()) {
|
throw new RuntimeException("获取订单线路和运费失败");
|
}
|
RouteVo routeVo = routeVoR.getData();
|
//缓存数据，用于后续推给乘客导航线路
|
redisService.setCacheObject("ORDER_NAVIGATION_START_DATA:" + xpOrder.getAppUserId(), JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
|
|
PopOrderDto dto1 = new PopOrderDto();
|
dto1.setOrderId(Long.valueOf(orderId));
|
dto1.setXpVehicleVin(xpVehicle.getVehicleVin());
|
dto1.setOrderType(com.xiaopeng.api.vo.OrderType.USER_ORDER);
|
R<?> r = xpOrderClient.popOrder(dto1);
|
|
//构建推送消息
|
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);
|
R<String> stringR = xpPushMessageClient.sendStatus(dto2);
|
if (R.isError(stringR)) {
|
log.error("推送消息失败：{}", stringR.getMsg());
|
}
|
xpOrderClient.updateOrderStatus(orderId, OrderStatusEnum.PICK_UP.getCode(), false);
|
|
// 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){
|
if(null == vehicleId){
|
vehicleId = 1L;
|
}
|
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_START_DATA:" + xpOrder.getAppUserId());
|
RouteVo routeVo = JSON.parseObject(cacheObject.toString(), RouteVo.class);
|
// RouteVo routeVo =new RouteVo();
|
// ArrayList<LonLatDto> lonLatDtos = new ArrayList<>();
|
// LonLatDto lonLatDto1 = new LonLatDto();
|
// lonLatDto1.setLatitude(30.575685);
|
// lonLatDto1.setLongitude(104.001118);
|
// lonLatDtos.add(lonLatDto1);
|
// routeVo.setPolyline(lonLatDtos);
|
|
|
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(1000));
|
Long finalOrderId = orderId;
|
Long finalOrderId1 = orderId;
|
threadPoolExecutor.execute(() -> {
|
//等待10秒后开始执行车子位移
|
try {
|
Thread.sleep(1000);
|
} catch (InterruptedException e) {
|
throw new RuntimeException(e);
|
}
|
List<LonLatDto> polyline = routeVo.getPolyline();
|
for (LonLatDto lonLatDto : polyline) {
|
Double latitude = lonLatDto.getLatitude();
|
Double longitude = lonLatDto.getLongitude();
|
|
//保存车辆实时位置到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);
|
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);
|
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) {
|
throw new RuntimeException(e);
|
}
|
}
|
|
//构建推送消息
|
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("推送消息失败：{}", stringR.getMsg());
|
}
|
xpOrderClient.updateOrderStatus(finalOrderId, OrderStatusEnum.PICK_UP_GUESTS.getCode(), false);
|
});
|
|
}
|
|
|
/**
|
* 修改订单状态
|
* @param orderId
|
* @param status
|
* @return
|
*/
|
@GetMapping("/base/v1/order/updateOrderStatus")
|
public R updateOrderStatus(Long orderId, String code, Integer status) {
|
XpOrder xpOrder = null;
|
if(null != orderId){
|
xpOrder = xpOrderClient.queryOrderById(orderId).getData();
|
}
|
if(StringUtils.isNotEmpty(code)){
|
xpOrder = xpOrderClient.queryOrderByOrderNo(code).getData();
|
}
|
orderId = xpOrder.getId();
|
//构建推送消息
|
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);
|
R<String> stringR = xpPushMessageClient.sendStatus(dto2);
|
if (R.isError(stringR)) {
|
log.error("推送消息失败：{}", stringR.getMsg());
|
}
|
xpOrderClient.updateOrderStatus(orderId, status, false);
|
if(5 == status){
|
//主动推一次全程轨迹
|
Object cacheObject = redisService.getCacheObject("ORDER_NAVIGATION_END_DATA:" + xpOrder.getAppUserId());
|
RouteVo routeVo = JSON.parseObject(cacheObject.toString(), RouteVo.class);
|
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());
|
xpPushMessageClient.sendRoute(messageDTO);
|
}
|
return R.ok();
|
}
|
|
|
|
/**
|
* 推送司机接驾轨迹和实时位置
|
* @param orderId
|
*/
|
@GetMapping("/base/v1/order/pushEndDriverLocation")
|
private void pushEndDriverLocation(Long vehicleId, Long orderId, String code){
|
if(null == vehicleId){
|
vehicleId = 1L;
|
}
|
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));
|
|
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(1000));
|
Long finalOrderId = orderId;
|
Long finalOrderId1 = orderId;
|
threadPoolExecutor.execute(() -> {
|
//等待10秒后开始执行车子位移
|
try {
|
Thread.sleep(1000);
|
} catch (InterruptedException e) {
|
throw new RuntimeException(e);
|
}
|
|
List<LonLatDto> polyline = routeVo.getPolyline();
|
for (LonLatDto lonLatDto : polyline) {
|
Double latitude = lonLatDto.getLatitude();
|
Double longitude = lonLatDto.getLongitude();
|
|
//保存车辆实时位置到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);
|
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);
|
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());
|
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);
|
}
|
|
//5秒钟循环一次
|
try {
|
Thread.sleep(1000);
|
} catch (InterruptedException e) {
|
throw new RuntimeException(e);
|
}
|
}
|
|
//构建推送消息
|
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("推送消息失败：{}", stringR.getMsg());
|
}
|
xpOrderClient.updateOrderStatus(finalOrderId, OrderStatusEnum.SEE_OFF_GUESTS.getCode(), false);
|
});
|
}
|
|
|
}
|
