package com.stylefeng.guns.modular.api;
|
|
import com.alibaba.fastjson.JSONObject;
|
import com.stylefeng.guns.core.util.ToolUtil;
|
import com.stylefeng.guns.modular.crossCity.model.OrderCrossCity;
|
import com.stylefeng.guns.modular.crossCity.server.IOrderCrossCityService;
|
import com.stylefeng.guns.modular.smallLogistics.model.OrderLogistics;
|
import com.stylefeng.guns.modular.smallLogistics.server.IOrderLogisticsService;
|
import com.stylefeng.guns.modular.specialTrain.model.OrderPrivateCar;
|
import com.stylefeng.guns.modular.specialTrain.server.IOrderPrivateCarService;
|
import com.stylefeng.guns.modular.system.util.GeodesyUtil;
|
import com.stylefeng.guns.modular.system.util.PushUtil;
|
import com.stylefeng.guns.modular.system.util.ResultUtil;
|
import com.stylefeng.guns.modular.taxi.model.OrderTaxi;
|
import com.stylefeng.guns.modular.taxi.service.IOrderTaxiService;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.data.redis.core.RedisTemplate;
|
import org.springframework.web.bind.annotation.PostMapping;
|
import org.springframework.web.bind.annotation.RequestMapping;
|
import org.springframework.web.bind.annotation.ResponseBody;
|
import org.springframework.web.bind.annotation.RestController;
|
import org.springframework.web.client.RestTemplate;
|
|
import javax.annotation.Resource;
|
import java.math.BigDecimal;
|
import java.util.Map;
|
import java.util.concurrent.TimeUnit;
|
|
@RestController
|
@RequestMapping("/base/passenger/location")
|
public class PassengerLocationController {
|
|
@Autowired
|
private IOrderPrivateCarService orderPrivateCarService;
|
|
@Autowired
|
private IOrderTaxiService orderTaxiService;
|
|
@Autowired
|
private IOrderCrossCityService orderCrossCityService;
|
|
@Autowired
|
private IOrderLogisticsService orderLogisticsService;
|
|
@Autowired
|
private PushUtil pushUtil;
|
|
@Autowired
|
private GeodesyUtil geodesyUtil;
|
|
@Autowired
|
private RestTemplate restTemplate;
|
|
@Value("${qyt.management_uri:http://127.0.0.1:8010}")
|
private String managementUri;
|
|
@Resource
|
private RedisTemplate<String, Object> redisTemplate;
|
|
@ResponseBody
|
@PostMapping("/push")
|
public ResultUtil push(Integer userId, Integer orderId, Integer orderType, String lon, String lat, String timestamp) {
|
try {
|
// 校验乘客定位上报的必填参数
|
if (ToolUtil.isEmpty(userId) || ToolUtil.isEmpty(orderId) || ToolUtil.isEmpty(orderType)
|
|| ToolUtil.isEmpty(lon) || ToolUtil.isEmpty(lat)) {
|
return ResultUtil.paranErr();
|
}
|
Double lonValue;
|
Double latValue;
|
try {
|
lonValue = Double.valueOf(lon);
|
latValue = Double.valueOf(lat);
|
} catch (NumberFormatException e) {
|
return ResultUtil.paranErr();
|
}
|
if (lonValue == 0 || latValue == 0) {
|
return ResultUtil.paranErr();
|
}
|
if (ToolUtil.isEmpty(timestamp)) {
|
timestamp = String.valueOf(System.currentTimeMillis());
|
}
|
if (!isSupportedOrderType(orderType)) {
|
return ResultUtil.error("订单类型暂不支持");
|
}
|
|
// 根据订单类型查询对应订单，并校验乘客、司机和订单状态
|
OrderData orderData = queryOrder(orderId, orderType);
|
if (orderData == null) {
|
return ResultUtil.error("订单不存在");
|
}
|
if (!userId.equals(orderData.userId)) {
|
return ResultUtil.error("用户与订单不匹配");
|
}
|
if (ToolUtil.isEmpty(orderData.driverId) || orderData.driverId == 0) {
|
return ResultUtil.error("订单暂无司机");
|
}
|
if (!Integer.valueOf(3).equals(orderData.state)) {
|
return ResultUtil.error("订单状态不是待到达预约地点");
|
}
|
if (!validLonLat(orderData.startLon, orderData.startLat)) {
|
return ResultUtil.error("订单上车点经纬度异常");
|
}
|
if (exceedPassengerLocationDistance(orderData, lonValue, latValue)) {
|
return ResultUtil.success("乘客距离上车点超过配置范围，未推送司机", new JSONObject());
|
}
|
|
// 只缓存乘客最新位置，不记录历史轨迹
|
JSONObject location = new JSONObject();
|
location.put("orderId", orderId);
|
location.put("orderType", orderType);
|
location.put("userId", userId);
|
location.put("driverId", orderData.driverId);
|
location.put("lon", lon);
|
location.put("lat", lat);
|
location.put("timestamp", timestamp);
|
redisTemplate.opsForValue().set("dache:PASSENGER_LOCATION:" + orderType + ":" + orderId,
|
location.toJSONString(), 30, TimeUnit.SECONDS);
|
// 缓存成功后实时推送给订单司机
|
return pushUtil.pushPassengerLocationToDriver(orderData.driverId, userId, orderId, orderType, lon, lat, timestamp);
|
} catch (Exception e) {
|
e.printStackTrace();
|
return ResultUtil.runErr();
|
}
|
}
|
|
private boolean isSupportedOrderType(Integer orderType) {
|
return orderType == 1 || orderType == 2 || orderType == 3 || orderType == 4 || orderType == 5;
|
}
|
|
/**
|
* 判断乘客当前位置是否超过企业配置的上车点距离阈值
|
*/
|
private boolean exceedPassengerLocationDistance(OrderData orderData, Double lon, Double lat) {
|
BigDecimal passengerLocationDistance = queryPassengerLocationDistance(orderData.companyId);
|
if (passengerLocationDistance == null) {
|
return false;
|
}
|
Map<String, Double> distance = geodesyUtil.getDistance(lon + "," + lat, orderData.startLon + "," + orderData.startLat);
|
Double distanceMeter = distance == null ? null : distance.get("WGS84");
|
if (distanceMeter == null) {
|
return false;
|
}
|
BigDecimal distanceKm = BigDecimal.valueOf(distanceMeter).divide(BigDecimal.valueOf(1000));
|
return distanceKm.compareTo(passengerLocationDistance) > 0;
|
}
|
|
/**
|
* 远程查询企业乘客定位推送距离阈值，查询失败时不影响主流程
|
*/
|
private BigDecimal queryPassengerLocationDistance(Integer companyId) {
|
if (ToolUtil.isEmpty(companyId) || companyId == 0) {
|
return null;
|
}
|
try {
|
String result = restTemplate.postForObject(managementUri + "/base/distanceDisplay/passengerLocationDistance?companyId=" + companyId,
|
null, String.class);
|
JSONObject jsonObject = JSONObject.parseObject(result);
|
if (jsonObject == null || jsonObject.getIntValue("code") != 200 || jsonObject.get("data") == null) {
|
return null;
|
}
|
return jsonObject.getBigDecimal("data");
|
} catch (Exception e) {
|
System.err.println("查询乘客定位推送距离阈值失败：" + e.getMessage());
|
return null;
|
}
|
}
|
|
/**
|
* 校验经纬度是否有效
|
*/
|
private boolean validLonLat(Double lon, Double lat) {
|
return lon != null && lat != null && lon != 0 && lat != 0;
|
}
|
|
/**
|
* 根据订单类型查询对应订单的乘客、司机和状态
|
*/
|
private OrderData queryOrder(Integer orderId, Integer orderType) {
|
switch (orderType) {
|
case 1:
|
OrderPrivateCar orderPrivateCar = orderPrivateCarService.selectById(orderId);
|
return orderPrivateCar == null ? null : new OrderData(orderPrivateCar.getUserId(), orderPrivateCar.getDriverId(),
|
orderPrivateCar.getState(), orderPrivateCar.getCompanyId(), orderPrivateCar.getStartLon(), orderPrivateCar.getStartLat());
|
case 2:
|
OrderTaxi orderTaxi = orderTaxiService.selectById(orderId);
|
return orderTaxi == null ? null : new OrderData(orderTaxi.getUserId(), orderTaxi.getDriverId(),
|
orderTaxi.getState(), orderTaxi.getCompanyId(), orderTaxi.getStartLon(), orderTaxi.getStartLat());
|
case 3:
|
OrderCrossCity orderCrossCity = orderCrossCityService.selectById(orderId);
|
return orderCrossCity == null ? null : new OrderData(orderCrossCity.getUserId(), orderCrossCity.getDriverId(),
|
orderCrossCity.getState(), orderCrossCity.getCompanyId(), orderCrossCity.getStartLon(), orderCrossCity.getStartLat());
|
case 4:
|
case 5:
|
OrderLogistics orderLogistics = orderLogisticsService.selectById(orderId);
|
return orderLogistics == null ? null : new OrderData(orderLogistics.getUserId(), orderLogistics.getDriverId(),
|
orderLogistics.getState(), orderLogistics.getCompanyId(), orderLogistics.getStartLon(), orderLogistics.getStartLat());
|
default:
|
return null;
|
}
|
}
|
|
private static class OrderData {
|
private final Integer userId;
|
private final Integer driverId;
|
private final Integer state;
|
private final Integer companyId;
|
private final Double startLon;
|
private final Double startLat;
|
|
private OrderData(Integer userId, Integer driverId, Integer state, Integer companyId, Double startLon, Double startLat) {
|
this.userId = userId;
|
this.driverId = driverId;
|
this.state = state;
|
this.companyId = companyId;
|
this.startLon = startLon;
|
this.startLat = startLat;
|
}
|
}
|
}
|
