966120Api.git - Gitblit

			@@ -1,7 +1,16 @@
			package com.ruoyi.web.controller.system;

			import java.util.List;
			import java.util.*;
			import java.text.SimpleDateFormat;
			import java.text.ParseException;
			import java.io.IOException;
			import java.net.URLEncoder;
			import java.nio.charset.StandardCharsets;

			import com.ruoyi.system.domain.*;
			import com.ruoyi.system.service.*;
			import com.ruoyi.common.config.TencentMapConfig;
			import com.ruoyi.common.config.BaiduMapConfig;
			import org.springframework.security.access.prepost.PreAuthorize;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.web.bind.annotation.GetMapping;
			@@ -18,10 +27,9 @@
			import com.ruoyi.common.core.controller.BaseController;
			import com.ruoyi.common.core.domain.AjaxResult;
			import com.ruoyi.common.enums.BusinessType;
			import com.ruoyi.system.domain.VehicleGps;
			import com.ruoyi.system.service.IVehicleGpsService;
			import com.ruoyi.common.utils.poi.ExcelUtil;
			import com.ruoyi.common.core.page.TableDataInfo;
			import com.ruoyi.common.utils.http.HttpUtils;

			/**
			* 车辆GPS坐标Controller
			@@ -32,16 +40,129 @@
			@Autowired
			private IVehicleGpsService vehicleGpsService;

			@Anonymous
			/**
			@Autowired
			private ITbVehicleOrderService tbVehicleOrderService;

			@Autowired
			private IDispatchOrdService dispatchOrdService;

			@Autowired
			private ITbOrdersService tbOrdersService;

			@Autowired
			private IGpsCollectService gpsCollectService;

			@Autowired
			private IVehicleInfoService vehicleInfoService;

			@Autowired
			private ICmsGpsCollectService cmsGpsCollectService;

			@Autowired
			private TencentMapConfig tencentMapConfig;

			@Autowired
			private BaiduMapConfig baiduMapConfig;

			/**
			* 查询车辆GPS坐标列表
			*/
			*/
			@PreAuthorize("@ss.hasPermi('system:gps:list')")
			@GetMapping("/list")
			public TableDataInfo list(VehicleGps vehicleGps) {

			startPage();
			// String vehicleNo=vehicleGps.getVehicleNo();
			// String beginTime=vehicleGps.getBeginTime();
			// String endTime=vehicleGps.getEndTime();
			// return this.getAnonymousTracks(vehicleNo,beginTime,endTime);
			//
			// // 设置按时间倒序排序
			vehicleGps.setOrderByColumn("collect_time");
			vehicleGps.setIsAsc("desc");
			List<VehicleGps> list = vehicleGpsService.selectVehicleGpsList(vehicleGps);
			return getDataTable(list);
			}
			@Anonymous(needSign=true)
			@GetMapping("/anonymousList")
			public TableDataInfo anonymousList(VehicleGps vehicleGps) {

			if(vehicleGps.getOrderId()==null)
			{
			return getDataTable(new ArrayList<>());
			}

			//查询订单
			TbVehicleOrder tbVehicleOrder = tbVehicleOrderService.selectTbVehicleOrderById(vehicleGps.getOrderId());
			if(tbVehicleOrder==null)
			{
			return getDataTable(new ArrayList<>());
			}

			if(!Objects.equals(tbVehicleOrder.getStatus(), "0"))
			{
			//非0表示订单完成了。
			try {
			TbOrders tbOrders = tbOrdersService.selectTbOrdersByOrderID(vehicleGps.getOrderId());
			if (tbOrders == null) {
			return getDataTable(new ArrayList<>());
			}


			DispatchOrd dispatchOrd = dispatchOrdService.selectDispatchOrdByServiceOrdIDDt(tbOrders.getServiceOrdID());
			if (dispatchOrd == null) {
			return getDataTable(new ArrayList<>());
			}

			String vehicleNo = tbVehicleOrder.getVehicle();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			String beginTime= sdf.format(dispatchOrd.getDispatchOrdStartDate());
			String endTime= sdf.format(dispatchOrd.getDispatchOrdUpdateTime());
			//如果订单没完成， endTime为当前时间；如何订单已经完成了，用订单的结束时间。

			return this.getAnonymousTracks(vehicleNo,beginTime,endTime);
			// Map<String, Object> params = new HashMap<>();
			// params.put("beginTime", dispatchOrd.getDispatchOrdStartDate());
			// params.put("endTime", dispatchOrd.getDispatchOrdUpdateTime());
			//
			// vehicleGps.setVehicleNo(tbVehicleOrder.getVehicle());
			// startPage();
			// // 设置按时间倒序排序
			// vehicleGps.setOrderByColumn("collect_time");
			// vehicleGps.setIsAsc("desc");
			// List<VehicleGps> list = vehicleGpsService.selectVehicleGpsList(vehicleGps);
			// return getDataTable(list);
			}
			catch (Exception ex)
			{
			logger.error("已完成的订单查询地图异常：{}",ex.getMessage());
			return getDataTable(new ArrayList<>());
			}
			}else{
			TbOrders tbOrders = tbOrdersService.selectTbOrdersByOrderID(vehicleGps.getOrderId());
			if (tbOrders == null) {
			return getDataTable(new ArrayList<>());
			}
			DispatchOrd dispatchOrd = dispatchOrdService.selectDispatchOrdByServiceOrdIDDt(tbOrders.getServiceOrdID());
			if (dispatchOrd == null) {
			return getDataTable(new ArrayList<>());
			}
			String vehicleNo = tbVehicleOrder.getVehicle();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			String beginTime= sdf.format(dispatchOrd.getDispatchOrdStartDate());
			String endTime= sdf.format(new Date());

			logger.info("查询车辆轨迹：车辆号：{}, 开始时间：{}, 结束时间：{}", vehicleNo, beginTime, endTime);
			return this.getAnonymousTracks(vehicleNo,beginTime,endTime);
			//
			// vehicleGps.setVehicleNo(tbVehicleOrder.getVehicle());
			// startPage();
			// // 设置按时间倒序排序
			// vehicleGps.setOrderByColumn("collect_time");
			// vehicleGps.setIsAsc("desc");
			// List<VehicleGps> list = vehicleGpsService.selectVehicleGpsList(vehicleGps);
			// return getDataTable(list);
			}
			}

			/**
			@@ -51,6 +172,9 @@
			@Log(title = "车辆GPS坐标", businessType = BusinessType.EXPORT)
			@GetMapping("/export")
			public AjaxResult export(VehicleGps vehicleGps) {
			// 设置按时间倒序排序
			vehicleGps.setOrderByColumn("collect_time");
			vehicleGps.setIsAsc("desc");
			List<VehicleGps> list = vehicleGpsService.selectVehicleGpsList(vehicleGps);
			ExcelUtil<VehicleGps> util = new ExcelUtil<VehicleGps>(VehicleGps.class);
			return util.exportExcel(list, "车辆GPS坐标数据");
			@@ -94,4 +218,385 @@
			public AjaxResult remove(@PathVariable Long[] gpsIds) {
			return toAjax(vehicleGpsService.deleteVehicleGpsByIds(gpsIds));
			}
			}

			/**
			* 查询车辆历史轨迹
			*/
			@PreAuthorize("@ss.hasPermi('system:gps:query')")
			@GetMapping("/tracks")
			public TableDataInfo getTracks(String vehicleNo, String beginTime, String endTime) {
			return getAnonymousTracks(vehicleNo, beginTime, endTime);
			}


			/**
			* 匿名查询车辆历史轨迹
			*/
			@Anonymous()
			@GetMapping("/anonymousTracks")
			public TableDataInfo getAnonymousTracks(String vehicleNo, String beginTime, String endTime) {
			try {
			// 通过车牌号获取设备ID
			VehicleInfo vehicleInfo = vehicleInfoService.selectVehicleInfoByPlateNumber(vehicleNo);
			if (vehicleInfo == null) {

			// throw new Error("未找到该车辆对应的GPS设备");
			return getDataTable(new ArrayList<>());
			}

			// 处理开始时间
			beginTime = beginTime.replace("T", " ");
			if (beginTime.split(":").length == 2) { // 只有小时和分钟
			beginTime += ":00";
			}

			// 处理结束时间
			// endTime = endTime.replace("T", " ").replace(" ","%20");
			endTime = endTime.replace("T", " ");
			if (endTime.split(":").length == 2) { // 只有小时和分钟
			endTime += ":59";
			}

			List<GpsTrackPoint> trackPoints = new ArrayList<>();

			//如果平台是cms，则调用cms的接口
			if(vehicleInfo.getPlatformCode().equals("CMS"))
			{

			CmsTrackDetailResponse response = cmsGpsCollectService.queryTrackDetail(
			vehicleInfo.getDeviceId(), // 设备号
			beginTime, // 开始时间
			endTime, // 结束时间
			null, // 距离（可选）
			null, // 停车时长（可选）
			1, // 解析地理位置
			null, // 当前页码（可选）
			null, // 每页记录数（可选）
			2 // 地图类型（2：百度地图）
			);

			if (response.getResult() != 0) {
			throw new Error("查询CMS轨迹失败");
			}

			// 转换CMS轨迹点为统一格式
			if (response.getTracks() != null) {
			for (CmsTrackDetailResponse.CmsTrackPoint point : response.getTracks()) {
			GpsTrackPoint trackPoint = new GpsTrackPoint();
			trackPoint.setVehicleNo(point.getVid());
			trackPoint.setDeviceId(point.getId());

			//经度纬度为空时，跳过
			if(point.getMlng()==null \|\| point.getMlat()==null)
			{
			continue;
			}

			// 经度，使用三元运算符
			trackPoint.setLongitude(point.getMlng() != null ? Double.parseDouble(point.getMlng()) : 0.0);

			// 纬度，使用三元运算符
			trackPoint.setLatitude(point.getMlat() != null ? Double.parseDouble(point.getMlat()) : 0.0);

			// 速度，直接使用int转double
			trackPoint.setSpeed(point.getSp() > 0 ? (double)point.getSp() : 0.0);

			// 方向，使用三元运算符处理
			trackPoint.setCourse(point.getFt() > 0 ? point.getFt() : 0);

			// ACC状态，使用三元运算符处理
			trackPoint.setAccStatus(point.getAc() > 0 ? point.getAc() : 0);

			// 在线状态，使用三元运算符处理
			trackPoint.setOnlineStatus(point.getNet() > 0 ? point.getNet() : 0);
			trackPoint.setAddress(point.getPs());

			// 上报时间，直接使用字符串
			trackPoint.setReportTime(point.getGt() != null ? point.getGt() : new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));

			trackPoints.add(trackPoint);
			}
			}
			}
			else {

			// 构建查询请求
			GpsTrackQueryRequest request = new GpsTrackQueryRequest();
			request.setDeviceid(vehicleInfo.getDeviceId());
			request.setBegintime(beginTime);
			request.setEndtime(endTime);
			request.setTimezone(8); // 中国时区

			logger.info("查询车辆轨迹：车辆号：{}, 设备ID：{}, 开始时间：{}, 结束时间：{}", vehicleNo, vehicleInfo.getDeviceId(), beginTime, endTime);
			// 查询轨迹
			GpsTrackQueryResponse response = gpsCollectService.queryTracks(request);
			if (response.getStatus() != 0) {
			logger.error("查询轨迹失败，状态码：{}, 错误信息：{}", response.getStatus(), response.getCause());
			throw new Error("查询轨迹失败：" + (response.getCause() != null ? response.getCause() : "未知错误"));
			}

			// 转换GPS51轨迹点为统一格式
			if (response.getRecords() != null) {
			for (GpsTrackPoint point : response.getRecords()) {
			GpsTrackPoint trackPoint = new GpsTrackPoint();
			trackPoint.setVehicleNo(vehicleNo);
			trackPoint.setDeviceId(vehicleInfo.getDeviceId());
			trackPoint.setLongitude(point.getLongitude()); // 经度
			trackPoint.setLatitude(point.getLatitude()); // 纬度
			trackPoint.setSpeed(point.getSpeed()); // 速度
			trackPoint.setCourse(point.getCourse()); // 方向
			trackPoint.setReportTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(point.getUpdatetime()))); // 上报时间
			trackPoints.add(trackPoint);
			}
			}
			}
			//转换成List<VehicleGps>
			List<VehicleGps> vehicleGpsList = new ArrayList<>();
			for(GpsTrackPoint trackPoint : trackPoints)
			{
			VehicleGps vehicleGps = new VehicleGps();
			vehicleGps.setVehicleNo(trackPoint.getVehicleNo());
			vehicleGps.setDeviceId(trackPoint.getDeviceId());
			vehicleGps.setLongitude(trackPoint.getLongitude());
			vehicleGps.setLatitude(trackPoint.getLatitude());
			vehicleGps.setSpeed(trackPoint.getSpeed());
			//方向
			vehicleGps.setDirection(Double.valueOf(trackPoint.getCourse()));
			//地址
			vehicleGps.setAddress(trackPoint.getAddress());
			vehicleGps.setCollectTime(trackPoint.getReportTime());
			//GPS平台处理时间
			vehicleGps.setPlatformProcessTime(trackPoint.getReportTime());
			vehicleGps.setDeviceReportTime(trackPoint.getReportTime());
			vehicleGpsList.add(vehicleGps);
			}
			//时间倒序排序
			vehicleGpsList.sort(Comparator.comparing(VehicleGps::getDeviceReportTime).reversed());

			//返回车辆Gps列表
			return getDataTable(vehicleGpsList);
			// return success(vehicleGpsList);
			} catch (Exception e) {
			logger.error("查询车辆轨迹异常", e);
			throw new Error("查询车辆轨迹失败：" + e.getMessage());
			}
			}

			/**
			* 腾讯地图地址搜索接口代理
			*/
			@Anonymous()
			@GetMapping("/address/search")
			public AjaxResult searchAddress(String keyword, String region) {
			try {
			// 构建腾讯地图搜索API URL
			String url = "https://apis.map.qq.com/ws/place/v1/search";
			String params = "keyword=" + URLEncoder.encode(keyword, StandardCharsets.UTF_8.toString()) +
			"&boundary=region(" + (region != null ? region : "广州") + ")" +
			"&key=" + tencentMapConfig.getKey();

			// 发送HTTP请求
			String response = HttpUtils.sendGet(url, params);

			// 返回结果
			return AjaxResult.success("查询成功", response);
			} catch (Exception e) {
			logger.error("地址搜索失败", e);
			return AjaxResult.error("地址搜索失败：" + e.getMessage());
			}
			}

			/**
			* 腾讯地图逆地址解析接口代理
			*/
			@Anonymous()
			@GetMapping("/address/geocoder")
			public AjaxResult reverseGeocoder(Double lat, Double lng) {
			try {
			// 检查参数
			logger.info("逆地址解析请求参数: lat={}, lng={}", lat, lng);

			if (lat == null \|\| lng == null) {
			logger.warn("参数不完整，缺少经纬度坐标: lat={}, lng={}", lat, lng);
			return AjaxResult.error("参数不完整，缺少经纬度坐标");
			}

			// 检查参数有效性
			if (Double.isNaN(lat) \|\| Double.isNaN(lng) \|\|
			Double.isInfinite(lat) \|\| Double.isInfinite(lng)) {
			logger.warn("参数无效，经纬度坐标包含非法值: lat={}, lng={}", lat, lng);
			return AjaxResult.error("参数无效，经纬度坐标格式错误");
			}

			// 构建腾讯地图逆地址解析API URL
			String url = "https://apis.map.qq.com/ws/geocoder/v1/";
			String params = "location=" + lat + "," + lng +
			"&key=" + tencentMapConfig.getKey() +
			"&get_poi=1";

			// 发送HTTP请求
			String response = HttpUtils.sendGet(url, params);

			// 返回结果
			return AjaxResult.success("查询成功", response);
			} catch (Exception e) {
			logger.error("逆地址解析失败: lat={}, lng={}", lat, lng, e);
			return AjaxResult.error("逆地址解析失败：" + e.getMessage());
			}
			}

			/**
			* 腾讯地图路线规划接口代理（计算两点间距离）
			*/
			@Anonymous()
			@GetMapping("/route/distance")
			public AjaxResult calculateDistance(Double fromLat, Double fromLng, Double toLat, Double toLng) {
			try {
			// 检查参数
			if (fromLat == null \|\| fromLng == null \|\| toLat == null \|\| toLng == null) {
			return AjaxResult.error("参数不完整，缺少起点或终点坐标");
			}

			// 构建腾讯地图路线规划API URL
			String url = "https://apis.map.qq.com/ws/distance/v1/";
			String params = "mode=driving" +
			"&from=" + fromLat + "," + fromLng +
			"&to=" + toLat + "," + toLng +
			"&key=" + tencentMapConfig.getKey();

			// 发送HTTP请求
			String response = HttpUtils.sendGet(url, params);

			// 返回结果
			return AjaxResult.success("计算成功", response);
			} catch (Exception e) {
			logger.error("距离计算失败", e);
			return AjaxResult.error("距离计算失败：" + e.getMessage());
			}
			}

			/**
			* 百度地图地理编码接口代理（地址转坐标）
			*/
			@Anonymous()
			@GetMapping("/baidu/geocoding")
			public AjaxResult baiduGeocoding(String address, String city) {
			try {
			// 检查参数
			if (address == null \|\| address.trim().isEmpty()) {
			return AjaxResult.error("参数不完整，缺少地址信息");
			}

			// 构建百度地图地理编码API URL
			String url = "https://api.map.baidu.com/geocoding/v3/";
			String params = "address=" + URLEncoder.encode(address, StandardCharsets.UTF_8.toString()) +
			(city != null && !city.trim().isEmpty() ?
			"&city=" + URLEncoder.encode(city, StandardCharsets.UTF_8.toString()) : "") +
			"&output=json" +
			"&ak=" + baiduMapConfig.getAk();

			logger.info("百度地图地理编码请求: address={}, city={}", address, city);

			// 发送HTTP请求
			String response = HttpUtils.sendGet(url, params);

			// 返回结果
			return AjaxResult.success("查询成功", response);
			} catch (Exception e) {
			logger.error("百度地图地理编码失败", e);
			return AjaxResult.error("地理编码失败：" + e.getMessage());
			}
			}

			/**
			* 百度地图路线规划接口代理（计算两个坐标之间的驾车距离）
			*/
			@Anonymous()
			@GetMapping("/baidu/route/driving")
			public AjaxResult baiduRouteDriving(String origin, String destination) {
			try {
			// 检查参数
			if (origin == null \|\| origin.trim().isEmpty() \|\|
			destination == null \|\| destination.trim().isEmpty()) {
			return AjaxResult.error("参数不完整，缺少起点或终点坐标");
			}

			// 验证坐标格式（纬度,经度）
			String[] originParts = origin.split(",");
			String[] destParts = destination.split(",");
			if (originParts.length != 2 \|\| destParts.length != 2) {
			return AjaxResult.error("坐标格式错误，应为：纬度,经度");
			}

			// 构建百度地图路线规划API URL
			String url = "https://api.map.baidu.com/directionlite/v1/driving";
			String params = "origin=" + origin +
			"&destination=" + destination +
			"&ak=" + baiduMapConfig.getAk();

			logger.info("百度地图路线规划请求: origin={}, destination={}", origin, destination);

			// 发送HTTP请求
			String response = HttpUtils.sendGet(url, params);

			// 返回结果
			return AjaxResult.success("计算成功", response);
			} catch (Exception e) {
			logger.error("百度地图路线规划失败", e);
			return AjaxResult.error("路线规划失败：" + e.getMessage());
			}
			}

			/**
			* 百度地图计算两个地址之间的距离（组合接口：地址转坐标 + 路线规划）
			*/
			@Anonymous()
			@GetMapping("/baidu/distance/byAddress")
			public AjaxResult baiduDistanceByAddress(String fromAddress, String fromCity,
			String toAddress, String toCity) {
			try {
			// 检查参数
			if (fromAddress == null \|\| fromAddress.trim().isEmpty() \|\|
			toAddress == null \|\| toAddress.trim().isEmpty()) {
			return AjaxResult.error("参数不完整，缺少起点或终点地址");
			}

			logger.info("开始计算地址距离: fromAddress={}, fromCity={}, toAddress={}, toCity={}",
			fromAddress, fromCity, toAddress, toCity);

			// 第一步：起点地址转坐标
			String geocodingUrl1 = "https://api.map.baidu.com/geocoding/v3/";
			String geocodingParams1 = "address=" + URLEncoder.encode(fromAddress, StandardCharsets.UTF_8.toString()) +
			(fromCity != null && !fromCity.trim().isEmpty() ?
			"&city=" + URLEncoder.encode(fromCity, StandardCharsets.UTF_8.toString()) : "") +
			"&output=json" +
			"&ak=" + baiduMapConfig.getAk();

			String geocodingResponse1 = HttpUtils.sendGet(geocodingUrl1, geocodingParams1);
			logger.info("起点地理编码响应: {}", geocodingResponse1);

			// 第二步：终点地址转坐标
			String geocodingUrl2 = "https://api.map.baidu.com/geocoding/v3/";
			String geocodingParams2 = "address=" + URLEncoder.encode(toAddress, StandardCharsets.UTF_8.toString()) +
			(toCity != null && !toCity.trim().isEmpty() ?
			"&city=" + URLEncoder.encode(toCity, StandardCharsets.UTF_8.toString()) : "") +
			"&output=json" +
			"&ak=" + baiduMapConfig.getAk();

			String geocodingResponse2 = HttpUtils.sendGet(geocodingUrl2, geocodingParams2);
			logger.info("终点地理编码响应: {}", geocodingResponse2);

			// 解析坐标（这里简化处理，实际应该解析JSON）
			// 注意：需要从响应中提取坐标，这里返回中间结果供前端处理
			Map<String, Object> result = new HashMap<>();
			result.put("fromGeocoding", geocodingResponse1);
			result.put("toGeocoding", geocodingResponse2);
			result.put("message", "请解析坐标后调用 /baidu/route/driving 接口计算距离");

			return AjaxResult.success("地理编码成功", result);
			} catch (Exception e) {
			logger.error("计算地址距离失败", e);
			return AjaxResult.error("计算距离失败：" + e.getMessage());
			}
			}
			}