feat: 更新评价功能

wlzboy

2025-09-21 b5b16a26de0d84d7b5fb69b584377bdc3582e3ab

 ruoyi-system/src/main/java/com/ruoyi/system/service/impl/GpsCollectServiceImpl.java

@@ -1,8 +1,7 @@
package com.ruoyi.system.service.impl;

import com.ruoyi.common.utils.http.HttpUtils;
import com.ruoyi.system.domain.GpsLoginRequest;
import com.ruoyi.system.domain.GpsLoginResponse;
import com.ruoyi.system.domain.*;
import com.ruoyi.system.service.IGpsCollectService;
import com.ruoyi.system.config.GpsServiceConfig;
import com.ruoyi.common.utils.MD5Util;
@@ -14,10 +13,19 @@
import org.springframework.http.ResponseEntity;
import java.util.HashMap;
import java.util.Map;
import org.springframework.util.StringUtils;
import org.apache.commons.lang3.StringUtils;
import com.ruoyi.common.utils.HttpUtil;
import com.alibaba.fastjson.JSONObject;
import com.ruoyi.common.exception.ServiceException;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.ruoyi.system.service.IGpsConfigService;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import com.ruoyi.common.utils.DateUtils;
import java.util.Date;
import com.ruoyi.system.service.IVehicleInfoService;

/**
 * GPS采集服务实现
@@ -27,98 +35,157 @@

    private final RestTemplate restTemplate;
    private final GpsServiceConfig gpsServiceConfig;
    @Autowired
    private IGpsConfigService gpsConfigService;

    @Autowired
    private IVehicleInfoService vehicleInfoService;

    public GpsCollectServiceImpl(GpsServiceConfig gpsServiceConfig) {
        this.restTemplate = new RestTemplate();
        this.gpsServiceConfig = gpsServiceConfig;
    }



    @Override
    public GpsLoginResponse login(GpsLoginRequest request) {
        // 参数校验
        if (StringUtils.isEmpty(request.getType()) || StringUtils.isEmpty(request.getFrom())) {
            throw new ServiceException("参数不能为空");
        }

        // 构建请求URL
        String url = gpsServiceConfig.getDomain() + "/webapi?action=login";
        
        // 设置请求参数
        Map<String, String> params = new HashMap<>();
        params.put("username", gpsServiceConfig.getUsername());
        params.put("password", MD5Util.md5(gpsServiceConfig.getPassword()));
        params.put("type", request.getType());
        params.put("from", request.getFrom());
        params.put("browser", request.getBrowser());
        String url = request.getDomain() + "/webapi?action=login";

        StringBuilder paramStr = new StringBuilder();
        for (Map.Entry<String, String> entry : params.entrySet()) {
            if (paramStr.length() > 0) {
                paramStr.append("&");
            }
            paramStr.append(entry.getKey()).append("=").append(entry.getValue());
        }

        // 发送请求
        String response = HttpUtil.post(url,params);
        
        // 解析响应
        GpsLoginResponse loginResponse = new GpsLoginResponse();
        try {
            JSONObject jsonResponse = JSONObject.parseObject(response);
            int status = jsonResponse.getIntValue("status");
            String username = jsonResponse.getString("username");
            // 设置请求参数
            Map<String, String> params = new HashMap<>();
            params.put("username", request.getUsername());
            params.put("password", MD5Util.md5(request.getPassword()));
            params.put("type", request.getType());
            params.put("from", request.getFrom());
            params.put("browser", request.getBrowser());

          
            // 发送请求
            String result = HttpUtil.post(url, params);
            JSONObject jsonResult = JSON.parseObject(result);

            // 解析响应
            GpsLoginResponse response = new GpsLoginResponse();
            int status = jsonResult.getInteger("status");
            response.setStatus(status);
            
            // 根据返回码设置响应信息
            // 根据状态码设置响应信息
            switch (status) {
                case 0:
                    loginResponse.setSuccess(true);
                    loginResponse.setMessage("登录成功");
                    loginResponse.setToken(jsonResponse.getString("token"));
                    response.setSuccess(true);
                    response.setMessage("登录成功");
                    response.setToken(jsonResult.getString("token"));
                    response.setServerid(jsonResult.getInteger("serverid"));
                    break;
                case -1:
                    loginResponse.setSuccess(false);
                    loginResponse.setMessage("登录失败");
                    response.setSuccess(false);
                    response.setMessage("登录失败");
                    break;
                case 1:
                    loginResponse.setSuccess(false);
                    loginResponse.setMessage("密码错误");
                    response.setSuccess(false);
                    response.setMessage("密码错误");
                    break;
                case 2:
                    loginResponse.setSuccess(false);
                    loginResponse.setMessage("禁止登录");
                    response.setSuccess(false);
                    response.setMessage("禁止登录");
                    break;
                case 3:
                    loginResponse.setSuccess(false);
                    loginResponse.setMessage("账号已禁用");
                    response.setSuccess(false);
                    response.setMessage("账号已禁用");
                    break;
                case 4:
                    loginResponse.setSuccess(false);
                    loginResponse.setMessage("设备到期");
                    response.setSuccess(false);
                    response.setMessage("设备到期");
                    break;
                case 5:
                    loginResponse.setSuccess(false);
                    loginResponse.setMessage("设备过期");
                    response.setSuccess(false);
                    response.setMessage("设备过期");
                    break;
                case 9903:
                    loginResponse.setSuccess(false);
                    loginResponse.setMessage("Token过期");
                    response.setSuccess(false);
                    response.setMessage("Token过期");
                    break;
                case 9906:
                    loginResponse.setSuccess(false);
                    loginResponse.setMessage("账号在其他地方登录");
                    response.setSuccess(false);
                    response.setMessage("账号在其他地方登录");
                    break;
                default:
                    loginResponse.setSuccess(false);
                    loginResponse.setMessage("未知错误");
                    response.setSuccess(false);
                    response.setMessage("未知错误");
                    break;
            }

            return response;
        } catch (Exception e) {
            loginResponse.setSuccess(false);
            loginResponse.setMessage("解析响应失败：" + e.getMessage());
            GpsLoginResponse response = new GpsLoginResponse();
            response.setSuccess(false);
            response.setStatus(-1);
            response.setMessage("登录失败：" + e.getMessage());
            return response;
        }
        
        return loginResponse;
    }

    /**
     * 获取有效的token，如果token无效则自动登录
     */
    private String getValidTokenWithAutoLogin() {
        try {
            // 获取当前token
            String token = gpsConfigService.getValidToken("gps51");
            if (token == null || token.isEmpty()) {
                System.out.println("当前token无效，尝试重新登录");
                //读取gspconfig中的域名，用户名，密码
                SysGpsConfig config = gpsConfigService.selectGpsConfigByKey("gps51");
                if (config == null) {
                    System.err.println("GPS配置信息未找到，无法进行登录");
                    return null;
                }
                
                String username = config.getUsername();
                String password = config.getPassword();
                String domain = config.getDomain();
                
                if (username == null || password == null || domain == null) {
                    System.err.println("GPS配置信息不完整，用户名、密码或域名为空");
                    return null;
                }
                
                // token无效，尝试登录
                GpsLoginRequest loginRequest = new GpsLoginRequest();
                loginRequest.setType("USER");
                loginRequest.setFrom("WEB");
                loginRequest.setUsername(username);
                loginRequest.setPassword(password);
                loginRequest.setDomain(domain);
                
                System.out.println("开始登录GPS系统，用户名: " + username + ", 域名: " + domain);
                GpsLoginResponse loginResponse = login(loginRequest);
                
                if (loginResponse.isSuccess()) {
                    //将token写入gspconfig
                    token = loginResponse.getToken();
                    Integer serviceid = loginResponse.getServerid();
                    //getTokenExpireTime 这个是没有的 需要自己计算，当前时间+23小时
                    Date expireTime = DateUtils.addHours(new Date(), 23);
                    gpsConfigService.updateToken("gps51", token,serviceid, expireTime);
                    System.out.println("GPS系统登录成功，token已更新");
                    return token;
                } else {
                    System.err.println("GPS系统登录失败: " + loginResponse.getMessage());
                    return null;
                }
            } else {
                System.out.println("使用现有有效token");
            }
            return token;
        } catch (Exception e) {
            System.err.println("获取token时发生异常: " + e.getMessage());
            e.printStackTrace();
            return null;
        }
    }

    /**
@@ -141,4 +208,447 @@
        }
        return "USER".equals(type) || "DEVICE".equals(type);
    }

    /**
     * 更新车辆设备ID
     * 根据设备列表中的车牌号更新或新增车辆信息
     */
    private void updateVehicleDeviceIds(GpsDeviceListResponse response) {
        if (response.getStatus() != 0 || response.getGroups() == null) {
            return;
        }

        // 遍历所有分组和设备
        for (GpsGroup group : response.getGroups()) {
            for (GpsDevice device : group.getDevices()) {
                // 检查设备名称和备注中是否包含车牌号
                String deviceName = device.getDevicename();
                String remark = device.getRemark();
                String deviceId = device.getDeviceid();

                if (StringUtils.isNotEmpty(deviceName) || StringUtils.isNotEmpty(remark)) {
                    // 尝试从设备名称和备注中提取车牌号
                    String plateNumber = extractPlateNumber(deviceName, remark);
                    if (StringUtils.isNotEmpty(plateNumber)) {
                        // 查询车辆信息
                        VehicleInfo vehicleInfo = vehicleInfoService.selectVehicleInfoByPlateNumber(plateNumber);
                        if (vehicleInfo != null) {
                            // 更新现有车辆的设备ID
                            vehicleInfo.setDeviceId(deviceId);
                            vehicleInfoService.updateVehicleInfo(vehicleInfo);
                        } else {
                            // 创建新的车辆信息
                            VehicleInfo newVehicle = new VehicleInfo();
                            newVehicle.setVehicleNo(plateNumber);
                            newVehicle.setDeviceId(deviceId);
                            newVehicle.setStatus("0"); // 正常状态
                            vehicleInfoService.insertVehicleInfo(newVehicle);
                        }
                    }
                }
            }
        }
    }

    /**
     * 从设备名称和备注中提取车牌号
     */
    private String extractPlateNumber(String deviceName, String remark) {
        // 这里可以根据实际情况实现车牌号提取逻辑
        // 例如：从字符串中匹配车牌号格式
        if (StringUtils.isNotEmpty(deviceName)) {
            return deviceName;
        }
        if (StringUtils.isNotEmpty(remark)) {
            return remark;
        }
        return null;
    }

    @Override
    public GpsDeviceListResponse getDeviceList() {
        // 获取GPS配置信息
        SysGpsConfig config = gpsConfigService.selectGpsConfigByKey("gps51");
        if (config == null) {
            GpsDeviceListResponse response = new GpsDeviceListResponse();
            response.setStatus(-1);
            response.setCause("未找到GPS配置信息");
            return response;
        }

        // 获取有效的token，如果无效则自动登录
        String token = getValidTokenWithAutoLogin();
        if (token == null) {
            GpsDeviceListResponse response = new GpsDeviceListResponse();
            response.setStatus(-1);
            response.setCause("获取token失败");
            return response;
        }
        
        String username = config.getUsername();
        // 构建请求URL
        String url = config.getDomain() + "/webapi?action=querymonitorlist&token=" + token+"&serverid="+config.getServerid();
        Map<String, String> params = new HashMap<>();
        params.put("username", username);
        

        try {

            // 发送HTTP请求
            String result = HttpUtil.post(url, params);
            JSONObject jsonResult = JSON.parseObject(result);

            // 解析响应
            GpsDeviceListResponse response = new GpsDeviceListResponse();
            response.setStatus(jsonResult.getInteger("status"));
            response.setCause(jsonResult.getString("cause"));

            if (response.getStatus() == 0) {
                // 解析分组列表
                JSONArray groupsArray = jsonResult.getJSONArray("groups");
                List<GpsGroup> groups = new ArrayList<>();
                
                for (int i = 0; i < groupsArray.size(); i++) {
                    JSONObject groupJson = groupsArray.getJSONObject(i);
                    GpsGroup group = new GpsGroup();
                    group.setGroupid(groupJson.getInteger("groupid"));
                    group.setGroupname(groupJson.getString("groupname"));
                    group.setRemark(groupJson.getString("remark"));

                    // 解析设备列表
                    JSONArray devicesArray = groupJson.getJSONArray("devices");
                    List<GpsDevice> devices = new ArrayList<>();
                    
                    for (int j = 0; j < devicesArray.size(); j++) {
                        JSONObject deviceJson = devicesArray.getJSONObject(j);
                        GpsDevice device = new GpsDevice();
                        device.setDeviceid(deviceJson.getString("deviceid"));
                        device.setDevicename(deviceJson.getString("devicename"));
                        device.setDevicetype(deviceJson.getInteger("devicetype"));
                        device.setSimnum(deviceJson.getString("simnum"));
                        device.setOverduetime(deviceJson.getLong("overduetime"));
                        device.setExpirenotifytime(deviceJson.getLong("expirenotifytime"));
                        device.setRemark(deviceJson.getString("remark"));
                        device.setCreater(deviceJson.getString("creater"));
                        device.setVideochannelcount(deviceJson.getInteger("videochannelcount"));
                        device.setLastactivetime(deviceJson.getLong("lastactivetime"));
                        device.setIsfree(deviceJson.getInteger("isfree"));
                        device.setAllowedit(deviceJson.getInteger("allowedit"));
                        device.setIcon(deviceJson.getInteger("icon"));
                        device.setStared(deviceJson.getInteger("stared"));
                        device.setLoginname(deviceJson.getString("loginname"));
                        
                        devices.add(device);
                    }
                    
                    group.setDevices(devices);
                    groups.add(group);
                }
                
                response.setGroups(groups);

               
            }

            return response;
        } catch (Exception e) {
            GpsDeviceListResponse response = new GpsDeviceListResponse();
            response.setStatus(-1);
            response.setCause("请求设备列表失败：" + e.getMessage());
            return response;
        }
    }

    @Override
    public GpsLastPositionResponse getLastPosition(GpsLastPositionRequest request) {
        // 获取GPS配置信息
        SysGpsConfig config = gpsConfigService.selectGpsConfigByKey("gps51");
        if (config == null) {
            GpsLastPositionResponse response = new GpsLastPositionResponse();
            response.setStatus(-1);
            response.setCause("未找到GPS配置信息");
            return response;
        }
        System.out.println("GPS配置信息获取成功！");

        // 获取有效的token，如果无效则自动登录
        String token = getValidTokenWithAutoLogin();
        if (token == null) {
            GpsLastPositionResponse response = new GpsLastPositionResponse();
            response.setStatus(-1);
            response.setCause("获取token失败");
            return response;
        }

        System.out.println("token获取成功！"+token);

        // 构建请求URL
        String url = config.getDomain() + "/webapi?action=lastposition&token="+token+"&serverid="+config.getServerid();
        System.out.println("请求URL："+url);

        // 构建请求参数
        Map<String, String> params = new HashMap<>();
            
        
        // 使用配置中的lastquerypositiontime作为查询时间
        Long lastQueryTime = config.getLastquerypositiontime();
        if (lastQueryTime == null) {
            lastQueryTime = 0L; // 如果从未查询过，则从0开始
        }
        params.put("lastquerypositiontime", String.valueOf(lastQueryTime));
        
        // 添加设备ID列表
        if (request.getDeviceids() != null && !request.getDeviceids().isEmpty()) {
            params.put("deviceids", JSON.toJSONString(request.getDeviceids()));
        }

        System.out.println("请求参数："+params);

        try {
            

            // 发送HTTP请求
            String result = HttpUtil.post(url, params);
            JSONObject jsonResult = JSON.parseObject(result);

            // 解析响应
            GpsLastPositionResponse response = new GpsLastPositionResponse();
            response.setStatus(jsonResult.getInteger("status"));
            response.setCause(jsonResult.getString("cause"));
            
            // 获取新的lastquerypositiontime
            Long newLastQueryTime = jsonResult.getLong("lastquerypositiontime");
            response.setLastquerypositiontime(newLastQueryTime);

            // 如果请求成功，更新配置中的lastquerypositiontime
            if (response.getStatus() == 0 && newLastQueryTime != null) {
                config.setLastquerypositiontime(newLastQueryTime);
                gpsConfigService.updateGpsConfig(config);
            }

            if (response.getStatus() == 0) {
                // 解析位置记录列表
                JSONArray recordsArray = jsonResult.getJSONArray("records");
                List<GpsLastPosition> records = new ArrayList<>();
                
                for (int i = 0; i < recordsArray.size(); i++) {
                    JSONObject recordJson = recordsArray.getJSONObject(i);
                    GpsLastPosition record = new GpsLastPosition();
                    record.setDeviceid(recordJson.getString("deviceid"));
                    record.setDevicetime(recordJson.getLong("devicetime"));
                    record.setArrivedtime(recordJson.getLong("arrivedtime"));
                    record.setUpdatetime(recordJson.getLong("updatetime"));
                    record.setValidpoistiontime(recordJson.getLong("validpoistiontime"));
                    record.setCallat(recordJson.getDouble("callat"));
                    record.setCallon(recordJson.getDouble("callon"));
                    record.setAltitude(recordJson.getDouble("altitude"));
                    record.setRadius(recordJson.getInteger("radius"));
                    record.setSpeed(recordJson.getDouble("speed"));
                    record.setCourse(recordJson.getInteger("course"));
                    record.setTotaldistance(recordJson.getInteger("totaldistance"));
                    record.setTotaloil(recordJson.getInteger("totaloil"));
                    record.setTotalnotrunningad(recordJson.getInteger("totalnotrunningad"));
                    record.setMasteroil(recordJson.getInteger("masteroil"));
                    record.setAuxoil(recordJson.getInteger("auxoil"));
                    record.setThirdoil(recordJson.getInteger("thirdoil"));
                    record.setFourthoil(recordJson.getInteger("fourthoil"));
                    record.setSrcad0(recordJson.getInteger("srcad0"));
                    record.setSrcad1(recordJson.getInteger("srcad1"));
                    record.setSrcad2(recordJson.getInteger("srcad2"));
                    record.setSrcad3(recordJson.getInteger("srcad3"));
                    record.setStatus(recordJson.getLong("status"));
                    record.setStrstatus(recordJson.getString("strstatus"));
                    record.setStrstatusen(recordJson.getString("strstatusen"));
                    record.setAlarm(recordJson.getLong("alarm"));
                    record.setStralarm(recordJson.getString("stralarm"));
                    record.setStralarmsen(recordJson.getString("stralarmsen"));
                    record.setVideoalarm(recordJson.getLong("videoalarm"));
                    record.setStrvideoalarm(recordJson.getString("strvideoalarm"));
                    record.setStrvideoalarmen(recordJson.getString("strvideoalarmen"));
                    record.setVideosignalloststatus(recordJson.getLong("videosignalloststatus"));
                    record.setVideosignalcoverstatus(recordJson.getLong("videosignalcoverstatus"));
                    record.setVideobehavior(recordJson.getLong("videobehavior"));
                    record.setVideofatiguedegree(recordJson.getLong("videofatiguedegree"));
                    record.setGotsrc(recordJson.getString("gotsrc"));
                    record.setRxlevel(recordJson.getInteger("rxlevel"));
                    record.setGpsvalidnum(recordJson.getInteger("gpsvalidnum"));
                    record.setExvoltage(recordJson.getDouble("exvoltage"));
                    record.setVoltagev(recordJson.getDouble("voltagev"));
                    record.setVoltagepercent(recordJson.getDouble("voltagepercent"));
                    record.setMoving(recordJson.getInteger("moving"));
                    record.setParklat(recordJson.getDouble("parklat"));
                    record.setParklon(recordJson.getDouble("parklon"));
                    record.setParktime(recordJson.getLong("parktime"));
                    record.setParkduration(recordJson.getLong("parkduration"));
                    record.setTemp1(recordJson.getInteger("temp1"));
                    record.setTemp2(recordJson.getInteger("temp2"));
                    record.setTemp3(recordJson.getInteger("temp3"));
                    record.setTemp4(recordJson.getInteger("temp4"));
                    record.setHumi1(recordJson.getInteger("humi1"));
                    record.setHumi2(recordJson.getInteger("humi2"));
                    record.setIostatus(recordJson.getInteger("iostatus"));
                    record.setCurrentoverspeedstate(recordJson.getInteger("currentoverspeedstate"));
                    record.setRotatestatus(recordJson.getShort("rotatestatus"));
                    record.setLoadstatus(recordJson.getShort("loadstatus"));
                    record.setWeight(recordJson.getLong("weight"));
                    record.setSrcweightad0(recordJson.getInteger("srcweightad0"));
                    record.setReportmode(recordJson.getShort("reportmode"));
                    
                    records.add(record);
                }
                
                response.setRecords(records);
            }

            return response;
        } catch (Exception e) {
            GpsLastPositionResponse response = new GpsLastPositionResponse();
            response.setStatus(-1);
            response.setCause("请求设备最后位置失败：" + e.getMessage());
            return response;
        }
    }

    @Override
    public String getDeviceIdByPlateNumber(String plateNumber) {
        if (StringUtils.isEmpty(plateNumber)) {
            return null;
        }

        try {
            // 获取设备列表
            GpsDeviceListResponse response = getDeviceList();
            if (response.getStatus() != 0) {
                return null;
            }

            // 遍历所有分组和设备
            for (GpsGroup group : response.getGroups()) {
                for (GpsDevice device : group.getDevices()) {
                    // 检查设备备注中是否包含车牌号
                    if (device.getDevicename() != null && device.getDevicename().contains(plateNumber)) {
                        return device.getDeviceid();
                    }
                    if(device.getRemark()!=null && device.getRemark().contains(plateNumber)){
                        return device.getDeviceid();
                    }
                }
            }
        } catch (Exception e) {
            // 记录错误日志
            System.err.println("通过车牌号查询设备号失败：" + e.getMessage());
        }

        return null;
    }

    @Override
    public GpsTrackQueryResponse queryTracks(GpsTrackQueryRequest request) {
        try {
            // 获取GPS配置信息
            SysGpsConfig config = gpsConfigService.selectGpsConfigByKey("gps51");
            if (config == null) {
                System.err.println("GPS配置信息未找到，configKey: gps51");
                GpsTrackQueryResponse response = new GpsTrackQueryResponse();
                response.setStatus(-1);
                response.setCause("未找到GPS配置信息");
                return response;
            }
            
            System.out.println("GPS配置信息获取成功，域名: " + config.getDomain() + ", 用户名: " + config.getUsername());

            // 获取有效的token，如果无效则自动登录
            String token = getValidTokenWithAutoLogin();
            if (token == null) {
                System.err.println("获取token失败");
                GpsTrackQueryResponse response = new GpsTrackQueryResponse();
                response.setStatus(-1);
                response.setCause("获取token失败");
                return response;
            }
            
            System.out.println("Token获取成功: " + token);

            // 构建请求URL
            String url = config.getDomain() + "/webapi?action=querytracks&token=" + token+"&serverid="+config.getServerid();
            System.out.println("请求URL: " + url);
            
            // 构建请求参数
            Map<String, String> params = new HashMap<>();
            params.put("deviceid", request.getDeviceid());
            params.put("begintime", request.getBegintime());
            params.put("endtime", request.getEndtime());
            if (request.getTimezone() != null) {
                params.put("timezone", String.valueOf(request.getTimezone()));
            }
            
            System.out.println("请求参数: " + params);

            // 发送HTTP请求
            String result = HttpUtil.post(url, params);
            System.out.println("HTTP响应结果: " + result);
            
            if (result == null || result.trim().isEmpty()) {
                System.err.println("HTTP请求返回空结果");
                GpsTrackQueryResponse response = new GpsTrackQueryResponse();
                response.setStatus(-1);
                response.setCause("HTTP请求返回空结果");
                return response;
            }
            
            JSONObject jsonResult = JSON.parseObject(result);

            // 解析响应
            GpsTrackQueryResponse response = new GpsTrackQueryResponse();
            response.setStatus(jsonResult.getInteger("status"));
            response.setCause(jsonResult.getString("cause"));
            response.setDeviceid(jsonResult.getString("deviceid"));

            if (response.getStatus() == 0) {

                // 解析轨迹记录列表
                JSONArray recordsArray = jsonResult.getJSONArray("records");
                List<GpsTrackPoint> records = new ArrayList<>();
                
                for (int i = 0; i < recordsArray.size(); i++) {
                    JSONObject recordJson = recordsArray.getJSONObject(i);
                    GpsTrackPoint record = new GpsTrackPoint();
                    record.setTrackCount(recordJson.getInteger("trackCount"));
                    record.setStarttime(recordJson.getLong("starttime"));
                    record.setEndtime(recordJson.getLong("endtime"));
                    record.setTrackid(recordJson.getInteger("trackid"));
                    record.setArrivedtime(recordJson.getLong("arrivedtime"));
                    record.setUpdatetime(recordJson.getLong("updatetime"));
                    record.setLatitude(recordJson.getDouble("callat"));
                    record.setLongitude(recordJson.getDouble("callon"));
                    record.setAltitude(recordJson.getDouble("altitude"));
                    record.setRadius(recordJson.getInteger("radius"));
                    record.setSpeed(recordJson.getDouble("speed"));
                    record.setRecorderspeed(recordJson.getDouble("recorderspeed"));
                    record.setTotaldistance(recordJson.getInteger("totaldistance"));
                    record.setCourse(recordJson.getInteger("course"));
                    record.setStatus(recordJson.getLong("status"));
                    record.setStrstatus(recordJson.getString("strstatus"));
                    record.setStrstatusen(recordJson.getString("strstatusen"));
                    record.setGotsrc(recordJson.getString("gotsrc"));
                    record.setRxlevel(recordJson.getInteger("rxlevel"));
                    record.setGpsvalidnum(recordJson.getInteger("gpsvalidnum"));
                    record.setReportmode(recordJson.getShort("reportmode"));
                    
                    records.add(record);
                }
                
                response.setRecords(records);
            }

            return response;
        } catch (Exception e) {
            System.err.println("查询历史轨迹异常: " + e.getMessage());
            e.printStackTrace();
            GpsTrackQueryResponse response = new GpsTrackQueryResponse();
            response.setStatus(-1);
            response.setCause("查询历史轨迹失败：" + (e.getMessage() != null ? e.getMessage() : e.getClass().getSimpleName()));
            return response;
        }
    }
}