From fa93c9eefcbfcb7ba8b7a9d0b41ba2b4e3523ae5 Mon Sep 17 00:00:00 2001
From: xuhy <3313886187@qq.com>
Date: 星期三, 22 四月 2026 11:07:23 +0800
Subject: [PATCH] [fix] 胶囊改进
---
xp-robotaxi-order-boot/src/main/java/com/xiaopeng/order/controller/XpOrderController.java | 412 ++++++++++++++++++++++++++++++++++++++++++++++++++--------
1 files changed, 350 insertions(+), 62 deletions(-)
diff --git a/xp-robotaxi-order-boot/src/main/java/com/xiaopeng/order/controller/XpOrderController.java b/xp-robotaxi-order-boot/src/main/java/com/xiaopeng/order/controller/XpOrderController.java
index 80b264d..7c1f36f 100644
--- a/xp-robotaxi-order-boot/src/main/java/com/xiaopeng/order/controller/XpOrderController.java
+++ b/xp-robotaxi-order-boot/src/main/java/com/xiaopeng/order/controller/XpOrderController.java
@@ -3,46 +3,69 @@
import cn.afterturn.easypoi.excel.ExcelExportUtil;
import cn.afterturn.easypoi.excel.entity.ExportParams;
import cn.hutool.core.bean.BeanUtil;
+import com.alibaba.fastjson2.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.xiaopeng.api.dto.QueryOrderRouteDTO;
+import com.xiaopeng.api.dto.operation.LonLatDto;
import com.xiaopeng.api.dto.order.GetOrderNumDto;
+import com.xiaopeng.api.dto.order.PopOrderDto;
import com.xiaopeng.api.dto.statistics.OrderStatisticsDTO;
import com.xiaopeng.api.dto.statistics.StatisticsQueryDTO;
+import com.xiaopeng.api.feignClient.vehicleConvoy.XpVehicleClient;
import com.xiaopeng.api.model.order.XpOrder;
-import com.xiaopeng.api.vo.order.FareBreakdownVo;
-import com.xiaopeng.api.vo.order.XpHistoryEndPointsVo;
-import com.xiaopeng.api.vo.order.XpHistoryStartPointsVo;
-import com.xiaopeng.api.vo.order.XpPointInfoVo;
+import com.xiaopeng.api.model.vehicleConvoy.XpVehicle;
+import com.xiaopeng.api.vo.automaticPilot.VehiclePosition;
+import com.xiaopeng.api.vo.operation.NearestNextVo;
+import com.xiaopeng.api.vo.operation.RouteVo;
+import com.xiaopeng.api.vo.order.*;
import com.xiaopeng.common.core.domain.R;
+import com.xiaopeng.common.core.utils.StringUtils;
import com.xiaopeng.common.core.utils.WebUtils;
import com.xiaopeng.common.core.web.page.PageInfo;
+import com.xiaopeng.common.redis.service.RedisService;
+import com.xiaopeng.order.mangodb.model.OrderTrajectory;
+import com.xiaopeng.order.mangodb.service.OrderTrajectoryService;
import com.xiaopeng.order.model.dto.XpOrderCommentDto;
+import com.xiaopeng.order.model.dto.XpOrderOperateDTO;
import com.xiaopeng.order.model.dto.XpOrderPayDto;
+import com.xiaopeng.order.model.dto.XpOrderReassignDTO;
import com.xiaopeng.order.model.exportExcel.XpOrderExportExcel;
import com.xiaopeng.order.model.query.XpHistoryOrderListQuery;
+import com.xiaopeng.order.model.query.XpOrderExcelQuery;
import com.xiaopeng.order.model.query.XpOrderPageQuery;
-import com.xiaopeng.order.model.dto.XpOrderOperateDTO;
-import com.xiaopeng.order.model.dto.XpOrderReassignDTO;
import com.xiaopeng.order.model.vo.XpOrderDetailVO;
import com.xiaopeng.order.model.vo.XpOrderHistoryVO;
import com.xiaopeng.order.model.vo.XpOrderPageVO;
import com.xiaopeng.order.service.IXpOrderService;
+import com.xiaopeng.order.vo.OrderDetailVo;
import com.xiaopeng.unifiedverification.interceptor.XpClientCheck;
-import io.swagger.annotations.Api;
-import io.swagger.annotations.ApiOperation;
-import io.swagger.annotations.ApiParam;
+import io.swagger.annotations.*;
import lombok.RequiredArgsConstructor;
import org.apache.poi.ss.usermodel.Workbook;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.CollectionUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
+import javax.annotation.Resource;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
import java.net.URLEncoder;
+import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
+import java.util.Objects;
/**
* <p>
@@ -58,6 +81,12 @@
public class XpOrderController {
private final IXpOrderService xpOrderService;
+ private final RedisService redisService;
+ @Autowired
+ private MongoTemplate mongoTemplate;
+ @Resource
+ private XpVehicleClient xpVehicleClient;
+ private OrderTrajectoryService orderTrajectoryService;
/**
* 获取订单统计数据（内部接口）
@@ -66,7 +95,7 @@
* @return 订单统计数据
*/
@ApiOperation(value = "获取订单统计数据", tags = {"内部接口"})
- @PostMapping("/inner/order/statistics")
+ @PostMapping("/logan/inner/order/statistics")
public R<OrderStatisticsDTO> getOrderStatistics(@RequestBody StatisticsQueryDTO query) {
return R.ok(xpOrderService.getOrderStatistics(query));
}
@@ -76,14 +105,14 @@
* 查询是否有未支付订单 或 正在进行的订单
* 返回0 可以下单 1有进行中的订单 8有待支付的
*/
- @PostMapping("/inner/order/has-unpaid-order")
+ @PostMapping("/logan/inner/order/has-unpaid-order")
@ApiOperation(value = "查询是否有未支付订单 或 正在进行的订单", tags = {"内部接口"})
- public R<Long> hasUnPaodOrder(String uid){
- List<XpOrder> list = xpOrderService.list(new LambdaQueryWrapper<XpOrder>().eq(XpOrder::getAppUserId, uid).in(XpOrder::getStatus, Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8)));
- if(!list.isEmpty()){
+ public R<Long> hasUnPaodOrder(String uid) {
+ List<XpOrder> list = xpOrderService.list(new LambdaQueryWrapper<XpOrder>().eq(XpOrder::getAppUserId, Long.parseLong(uid)).in(XpOrder::getStatus, Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8)));
+ if (!list.isEmpty()) {
return R.ok(list.get(0).getId());
}
- return R.ok(0l);
+ return R.ok(0L);
}
@@ -93,13 +122,13 @@
* @param orderId 订单id
* @return 订单详情
*/
- @PostMapping("/inner/order/queryOrderById")
- public R<XpOrder> queryOrderById(@RequestParam Long orderId){
+ @PostMapping("/logan/inner/order/queryOrderById")
+ public R<XpOrder> queryOrderById(@RequestParam Long orderId) {
return R.ok(xpOrderService.getById(orderId));
}
- @PostMapping("/inner/order/queryOrderByOrderNo")
- public R<XpOrder> queryOrderByOrderNo(@RequestParam String orderNo){
+ @PostMapping("/logan/inner/order/queryOrderByOrderNo")
+ public R<XpOrder> queryOrderByOrderNo(@RequestParam String orderNo) {
return R.ok(xpOrderService.getOne(new LambdaQueryWrapper<XpOrder>().eq(XpOrder::getOrderNumber, orderNo)));
}
@@ -108,10 +137,43 @@
*
* @return 订单数量
*/
- @PostMapping("/inner/order/getOrderNum")
- public R<Integer> getOrderNum(@RequestBody GetOrderNumDto dto){
+ @PostMapping("/logan/inner/order/getOrderNum")
+ public R<Integer> getOrderNum(@RequestBody GetOrderNumDto dto) {
return R.ok(xpOrderService.getOrderNum(dto));
}
+
+ /**
+ * 查询指定城市进行中的订单数量（status=1）
+ *
+ * @param cityId 开通城市ID
+ * @return 进行中订单数量
+ */
+ @GetMapping("/logan/inner/order/countActiveOrders")
+ public R<Integer> countActiveOrdersByCityId(@RequestParam("cityId") Long cityId) {
+ return R.ok(xpOrderService.countActiveOrdersByCityId(cityId));
+ }
+
+
+ /**
+ * 成功操作下发命令后调用 用于弹出redis队列的获取成功的数据
+ */
+ @PostMapping("/logan/inner/order/popOrder")
+ public R<?> popOrder(@RequestBody PopOrderDto dto) {
+ xpOrderService.popOrder(dto);
+ return R.ok();
+ }
+
+ /**
+ * 修改订单信息
+ *
+ * @param xpOrder 订单信息
+ */
+ @PostMapping("/logan/inner/order/updateOrder")
+ public R<?> updateOrder(@RequestBody XpOrder xpOrder) {
+ xpOrder.setAppUserId(null);
+ return xpOrderService.updateById(xpOrder) ? R.ok() : R.fail();
+ }
+
/**
* 新增订单
@@ -119,10 +181,10 @@
* @param xpOrder 订单信息
* @return 订单ID
*/
- @PostMapping("/inner/order/addOrder")
- public R<Long> addOrder(@RequestBody XpOrder xpOrder){
+ @PostMapping("/logan/inner/order/addOrder")
+ public R<Long> addOrder(@RequestBody XpOrder xpOrder) {
boolean save = xpOrderService.addOrder(xpOrder);
- if(!save){
+ if (!save) {
return R.fail("新增失败");
}
return R.ok(xpOrder.getId());
@@ -135,8 +197,8 @@
* @param orderId 订单ID
* @return 操作结果
*/
- @PostMapping("/inner/order/cancelOrder")
- public R<?> cancelOrder(String orderId){
+ @PostMapping("/logan/inner/order/cancelOrder")
+ public R<?> cancelOrder(@RequestParam("orderId") String orderId) {
xpOrderService.cancelOrder(orderId);
return R.ok();
}
@@ -149,7 +211,7 @@
*/
@ApiOperation(value = "订单分页列表", tags = {"管理后台-交易管理-订单管理"})
@PostMapping("/api/v1/order/pageList")
- public R<PageInfo<XpOrderPageVO>> pageList(@Validated @RequestBody XpOrderPageQuery query) {
+ public R<PageInfo<XpOrderPageVO>> pageList( @RequestBody XpOrderPageQuery query) {
PageInfo<XpOrderPageVO> pageInfo = xpOrderService.pageList(query);
return R.ok(pageInfo);
}
@@ -187,7 +249,7 @@
*/
@ApiOperation(value = "订单导出", tags = {"管理后台-交易管理-订单管理"})
@PostMapping("/api/v1/order/exportExcel")
- public void exportExcel(@RequestBody XpOrderPageQuery query) {
+ public void exportExcel(@RequestBody XpOrderExcelQuery query) {
// 1. 查询导出数据
List<XpOrderPageVO> dataList = xpOrderService.exportList(query);
@@ -229,7 +291,7 @@
@ApiOperation(value = "取消/关闭订单", tags = {"管理后台-交易管理-订单管理"})
@PostMapping("/api/v1/order/cancelAndCloseById")
public R<?> cancelAndCloseById(@Validated @RequestBody XpOrderOperateDTO dto) {
- xpOrderService.cancelOrCloseOrder(dto.getOrderId(), dto.getType());
+ xpOrderService.cancelOrCloseOrder(dto.getOrderId(), dto.getType(),dto.getIsFree());
return R.ok();
}
@@ -239,29 +301,77 @@
* @param dto 改派请求参数
* @return 操作结果
*/
- @ApiOperation(value = "改派订单", tags = {"管理后台-交易管理-订单管理"},notes = "车辆列表在maintenance服务")
+ @ApiOperation(value = "改派订单", tags = {"管理后台-交易管理-订单管理"}, notes = "车辆列表在 vehicleConvoy.availableList 服务")
@PostMapping("/api/v1/order/reassignById")
public R<?> reassignById(@Validated @RequestBody XpOrderReassignDTO dto) {
xpOrderService.reassignOrder(
- dto.getOrderId(),
- dto.getVehicleId(),
- dto.getReassignReason()
+ dto.getOrderId(),
+ dto.getVehicleId(),
+ dto.getReassignReason()
);
return R.ok();
}
+ @ApiOperation(value = "订单改价", tags = {"管理后台-交易管理-订单管理"})
+ @PostMapping("/api/v1/order/changeAmount")
+ @ApiImplicitParams({
+ @ApiImplicitParam(name = "id", value = "订单ID", required = true, dataType = "Long"),
+ @ApiImplicitParam(name = "amount", value = "新的订单金额", required = true, dataType = "BigDecimal")
+ })
+ public R<?> changeAmount(@RequestParam("id") Long id, @RequestParam("amount") BigDecimal amount) {
+ xpOrderService.changeAmount(id, amount);
+ return R.ok();
+ }
+
/**
* 获取用户快捷胶囊 历史 时段 终点高点
*/
- @ApiOperation(value = "获取用户快捷胶囊 历史 时段 终点高点", tags = {"小程序-获取用户快捷胶囊 历史 时段 终点高点"})
+ @ApiOperation(value = "获取首页快捷胶囊推荐站点", notes = "根据当前起点和用户近30天有效订单，按场景优先推荐目的地；无匹配时返回空数据", tags = {"小程序-首页快捷胶囊"}, response = XpPointInfoVo.class)
+ @ApiImplicitParams({
+ @ApiImplicitParam(name = "startPointId", value = "当前首页起点站点ID", required = true, dataType = "Long", paramType = "query")
+ })
@GetMapping("/api/v1/mini-program/order/getUserQuickCapsule")
@XpClientCheck(checkToken = false, checkOtpToken = true)
- public R<XpPointInfoVo> getUserQuickCapsule(HttpServletRequest request) {
+ public R<XpPointInfoVo> getUserQuickCapsule(@RequestParam Long startPointId, HttpServletRequest request) {
// uid已通过拦截器otp校验，可以直接使用
String uid = request.getHeader("XP-Uid");
- return R.ok(xpOrderService.getUserQuickCapsule(uid));
+ return R.ok(xpOrderService.getUserQuickCapsule(uid, startPointId));
+ }
+
+ /**
+ * 获取用户快捷胶囊 历史 时段 终点高点
+ */
+ @ApiOperation(value = "获取首页快捷胶囊推荐站点", notes = "根据当前起点和用户近30天有效订单，按场景优先推荐目的地；无匹配时返回空数据", tags = {"小程序-首页快捷胶囊"}, response = XpPointInfoVo.class)
+ @ApiImplicitParams({
+ @ApiImplicitParam(name = "startPointId", value = "当前首页起点站点ID", required = true, dataType = "Long", paramType = "query")
+ })
+ @GetMapping("/api/v1/mini-program/order/quick-capsule")
+ @XpClientCheck(checkToken = false, checkOtpToken = true)
+ public R<NearestNextVo> quickCapsule(@RequestParam Long startPointId,HttpServletRequest request) {
+ String uid = request.getHeader("XP-Uid");
+ return R.ok(xpOrderService.quickCapsule(uid,startPointId));
+
+ }
+
+ /**
+ * 获取订单详情
+ */
+ @PutMapping("/api/v1/mini-program/order/orderDetail/{orderId}")
+ @ApiOperation(value = "获取订单详情", tags = {"小程序-获取订单详情"})
+ @XpClientCheck(checkToken = false, checkOtpToken = true)
+ public R<OrderDetailVo> orderDetail(@PathVariable("orderId") Long orderId, HttpServletRequest request) {
+ // uid已通过拦截器otp校验，可以直接使用
+ String uid = request.getHeader("XP-Uid");
+ OrderDetailVo orderDetailVo = xpOrderService.orderDetail(orderId, uid);
+ BigDecimal orderMoney = orderDetailVo.getOrderMoney();
+ if (orderMoney == null) {
+ orderDetailVo.setOrderMoneyStr("0.00");
+ } else {
+ orderDetailVo.setOrderMoneyStr(orderMoney.setScale(2, RoundingMode.HALF_UP).toString());
+ }
+ return R.ok(orderDetailVo);
}
@@ -271,21 +381,22 @@
@ApiOperation(value = "获取历史下单成功起点10条数据列表", tags = {"小程序-获取历史下单成功起点10条数据列表"})
@GetMapping("/base/v1/mini-program/history/startPoints")
@XpClientCheck(checkToken = false, checkOtpToken = true)
- public R<List<XpHistoryStartPointsVo>> getHistoryStartPoints(double lon,double lat,HttpServletRequest request) {
+ public R<List<XpHistoryStartPointsVo>> getHistoryStartPoints(double lon, double lat, Long electronicAreaId, HttpServletRequest request) {
// uid已通过拦截器otp校验，可以直接使用
String uid = request.getHeader("XP-Uid");
- return R.ok(xpOrderService.getHistoryStartPoints(uid,lon,lat));
+ return R.ok(xpOrderService.getHistoryStartPoints(uid, lon, lat, electronicAreaId));
}
+
/**
* 获取历史下单成功终点点10条数据列表
*/
@ApiOperation(value = "获取历史下单成功终点10条数据列表", tags = {"小程序-获取历史下单成功终点10条数据列表"})
@GetMapping("/base/v1/mini-program/history/endPoints")
@XpClientCheck(checkToken = false, checkOtpToken = true)
- public R<List<XpHistoryEndPointsVo>> getHistoryEndPoints(double lon, double lat, HttpServletRequest request) {
+ public R<List<XpHistoryEndPointsVo>> getHistoryEndPoints(double lon, double lat, Long electronicAreaId, HttpServletRequest request) {
// uid已通过拦截器otp校验，可以直接使用
String uid = request.getHeader("XP-Uid");
- return R.ok(xpOrderService.getHistoryEndPoints(uid,lon,lat));
+ return R.ok(xpOrderService.getHistoryEndPoints(uid, lon, lat, electronicAreaId));
}
@@ -295,12 +406,23 @@
@ApiOperation(value = "获取正在进行中的订单", tags = {"小程序-获取正在进行中的订单"})
@GetMapping("/api/v1/mini-program/order/active")
@XpClientCheck(checkToken = false, checkOtpToken = true)
- public R<XpOrderDetailVO> getActiveOrder(HttpServletRequest request) {
+ public R<XpOrderDetailVO> getActiveOrder(HttpServletRequest request) {
// uid已通过拦截器otp校验，可以直接使用
String uid = request.getHeader("XP-Uid");
return R.ok(xpOrderService.getActiveOrder(uid));
}
+ /**
+ * 获取正在进行中的订单_行程管理
+ */
+ @ApiOperation(value = "获取正在进行中的订单_行程管理", tags = {"小程序-获取正在进行中的订单_行程管理"})
+ @GetMapping("/api/v1/mini-program/order/active_itineraryManage")
+ @XpClientCheck(checkToken = false, checkOtpToken = true)
+ public R<XpOrderDetailVO> getActiveOrder_itineraryManage(HttpServletRequest request) {
+ // uid已通过拦截器otp校验，可以直接使用
+ String uid = request.getHeader("XP-Uid");
+ return R.ok(xpOrderService.getActiveOrder_itineraryManage(uid));
+ }
/**
* 查询历史订单列表
@@ -308,63 +430,98 @@
@ApiOperation(value = "查询历史订单列表", tags = {"小程序-查询历史订单列表"})
@PostMapping("/api/v1/mini-program/order/history/list")
@XpClientCheck(checkToken = false, checkOtpToken = true)
- public R<XpOrderHistoryVO> getHistoryOrderList(@RequestBody XpHistoryOrderListQuery query, HttpServletRequest request) {
+ public R<XpOrderHistoryVO> getHistoryOrderList(@RequestBody XpHistoryOrderListQuery query, HttpServletRequest request) {
// uid已通过拦截器otp校验，可以直接使用
String uid = request.getHeader("XP-Uid");
return R.ok(xpOrderService.getHistoryOrderList(query, uid));
}
- /**+
+ /**
+ * 1.0 获取待支付订单数量
+ */
+ @ApiOperation(value = "1.0 获取待支付订单数量", tags = {"小程序-1.0 获取待支付订单数量"})
+ @GetMapping("/api/v1/mini-program/order/getWaitPayOrderNum")
+ @XpClientCheck(checkToken = false, checkOtpToken = true)
+ public R<Integer> getWaitPayOrderNum(HttpServletRequest request) {
+ // uid已通过拦截器otp校验，可以直接使用
+ String uid = request.getHeader("XP-Uid");
+ return R.ok(xpOrderService.getWaitPayOrderNum(uid));
+ }
+
+ /**
+ * +
* 取消订单
*/
-
@PutMapping("/api/v1/mini-program/order/cancel/{orderId}")
@ApiOperation(value = "取消订单", tags = {"小程序-取消订单"})
@XpClientCheck(checkToken = false, checkOtpToken = true)
- public R cancelOrder(@PathVariable("orderId") Long orderId,HttpServletRequest request) {
+ public R cancelOrder(@PathVariable("orderId") Long orderId, HttpServletRequest request) {
// uid已通过拦截器otp校验，可以直接使用
String uid = request.getHeader("XP-Uid");
- xpOrderService.cancelOrder(orderId,uid);
+ xpOrderService.cancelOrder(orderId, uid);
return R.ok();
}
- /**+
+ /**
+ * +
* 手动结束订单
*/
- @PutMapping("/api/v1/order/endTrip/{order_id}")
+ @PutMapping("/api/v1/mini-program/order/endTrip/{orderId}")
@ApiOperation(value = "结束行程", tags = {"小程序-结束行程"})
@XpClientCheck(checkToken = false, checkOtpToken = true)
- public R endTrip(@PathVariable("orderId") Long orderId,HttpServletRequest request) {
+ public R<?> endTrip(@PathVariable("orderId") Long orderId, HttpServletRequest request) {
// uid已通过拦截器otp校验，可以直接使用
String uid = request.getHeader("XP-Uid");
- xpOrderService.endTrip(orderId,uid);
- return R.ok();
+ try {
+ Boolean b = xpOrderService.endTrip(orderId, uid);
+ return R.ok(b);
+
+ } catch (Exception e) {
+ return R.ok();
+ }
}
- /**+
+
+
+ /**
+ * +
* 获取行程费用明细
*/
-
- @PutMapping("/api/v1/order/fare-breakdown/{order_id}")
+ @PutMapping("/api/v1/mini-program/order/fare-breakdown/{orderId}")
@ApiOperation(value = "获取行程费用明细", tags = {"小程序-获取行程费用明细"})
@XpClientCheck(checkToken = false, checkOtpToken = true)
public R<FareBreakdownVo> fareBreakdown(@PathVariable("orderId") Long orderId, HttpServletRequest request) {
// uid已通过拦截器otp校验，可以直接使用
String uid = request.getHeader("XP-Uid");
- return xpOrderService.fareBreakdown(orderId,uid);
+ return xpOrderService.fareBreakdown(orderId, uid);
}
+
+ /**
+ * +
+ * 获取行程费用明细
+ */
+ @PutMapping("/api/v1/mini-program/order/feeDescription/{orderId}")
+ @ApiOperation(value = "获取费用说明", tags = {"小程序-获取费用说明"})
+ @XpClientCheck(checkToken = false, checkOtpToken = true)
+ public R<String> feeDescription(@PathVariable("orderId") Long orderId, HttpServletRequest request) {
+ // uid已通过拦截器otp校验，可以直接使用
+ String uid = request.getHeader("XP-Uid");
+ return xpOrderService.feeDescription(orderId, uid);
+ }
+
/**
* 订单评价
*/
- @PostMapping("/api/v1/order/payment")
+ @PostMapping("/api/v1/mini-program/order/payment")
@ApiOperation(value = "发起支付", tags = {"小程序-发起支付"})
@XpClientCheck(checkToken = false, checkOtpToken = true)
public R payment(@Validated @RequestBody XpOrderPayDto dto, HttpServletRequest request) {
// uid已通过拦截器otp校验，可以直接使用
String uid = request.getHeader("XP-Uid");
- return xpOrderService.payment(dto,uid);
+ return xpOrderService.payment(dto, uid);
}
+
/**
* 订单评价
*/
@@ -374,19 +531,150 @@
public R comment(@Validated @RequestBody XpOrderCommentDto dto, HttpServletRequest request) {
// uid已通过拦截器otp校验，可以直接使用
String uid = request.getHeader("XP-Uid");
- xpOrderService.comment(dto,uid);
+ xpOrderService.comment(dto, uid);
return R.ok();
}
/**
* 订单状态修改-车控消息推送我方调用（内部接口）
*/
- @PostMapping("/inner/v1/order/updateOrderStatus")
@ApiOperation(value = "订单状态推送修改")
+ @PostMapping("/logan/inner/v1/order/updateOrderStatus")
public R<String> updateOrderStatus(@RequestParam Long orderId,
- @RequestParam Integer status) {
- return xpOrderService.updateOrderStatus(orderId,status);
+ @RequestParam Integer status,
+ @RequestParam Boolean orderException) {
+ return xpOrderService.updateOrderStatus(orderId, status, orderException);
+ }
+
+ /**
+ * 行驶中车辆异常，订单状态修改- 修改状态=7 再修改 金额-再将状态修改成8
+ */
+ @ApiOperation(value = "行驶中车辆异常，订单状态修改- 修改状态=7 再修改 金额-再将状态修改成8")
+ @PostMapping("/logan/inner/v1/order/carAbnormalUpdateOrderStatus")
+ public R<String> carAbnormalUpdateOrderStatus(@RequestParam Long orderId) {
+// Integer status = OrderStatusEnum.SEE_OFF_GUESTS.getCode();
+ return xpOrderService.carAbnormalUpdateOrderStatus(orderId);
+ }
+
+ /**
+ * 业务流程-通过订单id查询车辆信息
+ */
+ @ApiOperation(value = "通过订单id查询车辆信息", tags = {"小程序-业务流程"})
+ @XpClientCheck(checkToken = false, checkOtpToken = true)
+ @GetMapping("/api/v1/mini-program/order/queryVehicleByOrderId")
+ public R<XpVehicle> queryVehicleByOrderId(@RequestParam Long orderId, HttpServletRequest request) {
+ String uid = request.getHeader("XP-Uid");
+ return R.ok(xpOrderService.queryVehicleByOrderId(orderId, uid));
+ }
+
+ /**
+ * 订单车辆定位实时存储-订单车辆定位实时存储（内部接口）
+ */
+ @ApiOperation(value = "订单车辆定位实时存储")
+ @PostMapping("/logan/inner/v1/order/saveVehicleLocation")
+ public R<String> saveVehicleLocation(@RequestBody OrderTrajectoryVo vo) {
+ OrderTrajectory orderTrajectory = new OrderTrajectory();
+ BeanUtils.copyProperties(vo, orderTrajectory);
+ xpOrderService.saveVehicleLocation(orderTrajectory);
+ return R.ok();
+ }
+
+ /**
+ * 订单查询实时轨迹路线
+ */
+ @ApiOperation(value = "订单查询实时轨迹路线")
+ @PostMapping("/api/v1/mini-program/order/queryOrderRoute")
+ @XpClientCheck(checkToken = false, checkOtpToken = true)
+ public R<RouteVo> queryOrderRoute(@Validated @RequestBody QueryOrderRouteDTO dto, HttpServletRequest request) {
+ if (dto.getOrderId() == null) {
+ return R.fail("参数不能为空");
+ }
+ String uid = request.getHeader("XP-Uid");
+ // 查询订单信息
+ XpOrder xpOrder = xpOrderService.getById(dto.getOrderId());
+ // 获取路线规划
+// RouteVo routeVo = redisService.getCacheObject(CacheConstants.ORDER_ROUTE_CAPTURE + "_" + dto.getOrderId() + "_" +dto.getRouteType());
+
+ String key = "";
+ //接驾情况，获取车辆位置到起点的导航
+ if (xpOrder.getStatus() < 5) {
+ key = "ORDER_NAVIGATION_START_DATA:" + xpOrder.getAppUserId();
+ }
+ //服务中，获取起点到终点的导航数据
+ if (xpOrder.getStatus() >= 5) {
+ key = "ORDER_NAVIGATION_END_DATA:" + xpOrder.getAppUserId();
+ }
+ Object cacheObject = redisService.getCacheObject(key);
+ RouteVo routeVo = JSON.parseObject(cacheObject.toString(), RouteVo.class);
+ XpVehicle xpVehicle = xpVehicleClient.queryById(xpOrder.getVehicleId()).getData();
+ VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(xpVehicle.getVehicleVin())), VehiclePosition.class);
+ routeVo.setDirection(null != vehiclePosition ? vehiclePosition.getCourse() : 90);
+ return R.ok(routeVo);
+ }
+
+ /**
+ * 订单查询轨迹路线
+ */
+ @ApiOperation(value = "订单查询轨迹路线")
+ @GetMapping("/api/v1/mini-program/order/queryOrderTrajectory")
+ @XpClientCheck(checkToken = false, checkOtpToken = true)
+ public R<RouteVo> queryOrderTrajectory(@RequestParam String orderId, HttpServletRequest request) {
+ if (orderId == null) {
+ return R.fail("参数不能为空");
+ }
+ List<OrderTrajectory> trajectories = mongoTemplate.find(
+ new Query(Criteria.where("orderId").is(Long.valueOf(orderId)))
+ .with(Sort.by(Sort.Direction.ASC, "locatetime")),
+ OrderTrajectory.class
+ );
+ // 封装信息
+ RouteVo routeVo = new RouteVo();
+ List<LonLatDto> polyline = new ArrayList<>();
+ if (!CollectionUtils.isEmpty(trajectories)) {
+ for (OrderTrajectory trajectory : trajectories) {
+ LonLatDto lonLatDto = new LonLatDto();
+ String[] split = trajectory.getLocation().split(",");
+ lonLatDto.setLongitude(Double.valueOf(split[0]));
+ lonLatDto.setLatitude(Double.valueOf(split[1]));
+ polyline.add(lonLatDto);
+ }
+ }
+ routeVo.setPolyline(polyline);
+ return R.ok(routeVo);
}
-}
+ /**
+ * 当日取消订单次数
+ *
+ * @param
+ * @return 订单数量
+ */
+ @PostMapping("/inner/order/todayCancellationCount")
+ public R<Integer> todayCancellationCount(@RequestParam Long userId) {
+ long count = xpOrderService.count(new QueryWrapper<XpOrder>().eq("app_user_id", userId).eq("status", 0)
+ .eq("is_deleted", 0).last(" and DATE_FORMAT(create_time, '%Y-%m-%d') = DATE_FORMAT(NOW(), '%Y-%m-%d')"));
+ return R.ok((int) count);
+ }
+
+
+
+ @ApiOperation(value = "通过订单id获取蓝牙开锁秘钥", tags = {"小程序-业务流程"})
+ @GetMapping("/api/v1/mini-program/bluetooth/getUnlocktToken/{orderId}")
+ @XpClientCheck(checkToken = false, checkOtpToken = true)
+ public R<String> getBluetoothToken(@PathVariable("orderId") Long orderId, HttpServletRequest request) {
+ String uid = request.getHeader("XP-Uid");
+ XpOrder xpOrder = xpOrderService.getById(orderId);
+ if (!Objects.equals(xpOrder.getAppUserId(), Long.valueOf(uid))) {
+ return R.ok();
+ }
+ if(!Arrays.asList(4, 5, 6, 7, 8).contains(xpOrder.getStatus())){
+ return R.ok();
+ }
+ String token = redisService.getCacheObject("rt:bluetooth:unlock:order:" + orderId);
+ if (StringUtils.isBlank(token)) {
+ return R.ok();
+ }
+ return R.ok(token);
+ }
+}
\ No newline at end of file
--
Gitblit v1.7.1