修改bug

Pu Zhibing

9 天以前 b6da936b0c7379c3e1ef07409f81702074b45f47

 UserQYTTravel/guns-admin/src/main/java/com/stylefeng/guns/modular/api/OrderController.java

@@ -13,12 +13,19 @@
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.dao.CarMapper;
import com.stylefeng.guns.modular.system.dao.SystemPriceMapper;
import com.stylefeng.guns.modular.system.model.*;
import com.stylefeng.guns.modular.system.model.vo.TripOrderVo;
import com.stylefeng.guns.modular.system.model.vo.TripSheetVo;
import com.stylefeng.guns.modular.system.model.vo.UnPayOrderVO;
import com.stylefeng.guns.modular.system.pdf.TripSheetGenerator;
import com.stylefeng.guns.modular.system.service.*;
import com.stylefeng.guns.modular.system.util.*;
import com.stylefeng.guns.modular.system.util.qianyuntong.OrderUtil;
import com.stylefeng.guns.modular.system.util.qianyuntong.model.ModifyTravelItineraryRequest;
import com.stylefeng.guns.modular.system.util.qianyuntong.model.QYTPaymentCallback;
import com.stylefeng.guns.modular.system.util.qianyuntong.model.QYTPaymentCallbackData;
import com.stylefeng.guns.modular.system.warpper.*;
import com.stylefeng.guns.modular.taxi.model.OrderTaxi;
import com.stylefeng.guns.modular.taxi.model.PaymentRecord;
@@ -31,6 +38,9 @@
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
@@ -39,8 +49,13 @@
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.PrintWriter;
import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.*;

/**
@@ -138,7 +153,20 @@
   
   @Resource
   private ISystemPriceCityService systemPriceCityService;
	
    
    @Value("${trip.sheet.filePath}")
    private  String filePath;
    @Autowired
    private EmailUtil emailUtil;
    @Autowired
    private  TripSheetGenerator tripSheetGenerator;
    @Autowired
    private IServerCarModelService serverCarModelService;
    
    
    
    
    
   
   /**
    * 获取正在进行中的订单
@@ -493,7 +521,7 @@
            }
            orderList = orderPrivateCarService.queryOrderInfo2(orderId, 6, null, null);
            if (orderInfoWarpper.getState() > 1 && orderInfoWarpper.getDriverId() != 0) {
               String value = (String) redisTemplate.opsForValue().get("DRIVER" + String.valueOf(orderInfoWarpper.getDriverId()));
               String value = (String) redisTemplate.opsForValue().get("dache:DRIVER" + String.valueOf(orderInfoWarpper.getDriverId()));
               if (value == null || value.equals("")) {
                  if (orderList.isEmpty()) {
                     orderList = orderPrivateCarService.queryOrderInfo2(orderId, 5, "0", "0");
@@ -534,8 +562,8 @@
                  return ResultUtil.error("请先配置价格规则");
               }
               Map<String, Object> query1 = systemPriceMapper.query(orderPrivateCar.getCompanyId(), 1, orderPrivateCar.getServerCarModelId(), systemPriceCity.getId());
               System.out.println("参数：" + orderPrivateCar.getCompanyId() + "|" + orderPrivateCar.getServerCarModelId());
               System.out.println("query1:" + query1);
//               System.out.println("参数：" + orderPrivateCar.getCompanyId() + "|" + orderPrivateCar.getServerCarModelId());
//               System.out.println("query1:" + query1);
               //开始根据不同的方式计算金额
               if (query1 != null) {
                  JSONObject jsonObject = JSON.parseObject(query1.get("content").toString());//等待费
@@ -1370,9 +1398,11 @@
         @ApiImplicitParam(value = "优惠数据id", name = "objectId", required = false, dataType = "int"),
         @ApiImplicitParam(value = "数据类型（1=优惠券，2=打车卡）", name = "objectType", required = false, dataType = "int"),
         @ApiImplicitParam(value = "支付端（1=用户APP端，2=司机APP端，3=用户小程序端）", name = "type", required = true, dataType = "int"),
         @ApiImplicitParam(value = "小程序支付成功跳转路径", name = "path", required = true, dataType = "String"),
         @ApiImplicitParam(value = "设备当前IP地址", name = "ip", required = true, dataType = "String"),
         @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
   })
   public ResultUtil payTaxiOrder1(Integer payType, Integer orderId, Integer orderType, Integer objectId, Integer objectType, Integer type, HttpServletRequest request) {
   public ResultUtil payTaxiOrder1(Integer payType, Integer orderId, Integer orderType, Integer objectId, Integer objectType, Integer type, String path, String ip, HttpServletRequest request) {
      System.out.println(objectType);
      System.out.println(objectId);
      try {
@@ -1382,11 +1412,15 @@
         }
         switch (orderType) {
            case 1:
               return orderPrivateCarService.payPrivateCarOrder1(payType, orderId, objectId, objectType, type);
               return orderPrivateCarService.payPrivateCarOrder1(payType, orderId, objectId, objectType, type, path, ip);
            case 2:
               return orderTaxiService.payTaxiOrder1(payType, orderId, objectId, objectType, type);
               return orderTaxiService.payTaxiOrder1(payType, orderId, objectId, objectType, type, path, ip);
            case 3:
               return orderCrossCityService.payCrossCityOrder1(payType, orderId, objectId, objectType, type);
               ResultUtil resultUtil = orderCrossCityService.payCrossCityOrder1(payType, orderId, objectId, objectType, type);

               orderCrossCityService.promotion(orderId);

               return resultUtil;
            case 4:
               return orderLogisticsService.payLogisticsOrder1(payType, orderId, objectId, objectType, type);
            case 5:
@@ -1427,6 +1461,23 @@
                  OrderPrivateCar orderPrivateCar = orderPrivateCarService.selectById(orderId);
                  orderPrivateCar.setState(9);
                  orderPrivateCarService.updateById(orderPrivateCar);
                  Driver driver1 = null;
                  Company company = null;
                  //中台修改订单状态
                  ModifyTravelItineraryRequest request = new ModifyTravelItineraryRequest();
                  request.setOrderId(orderPrivateCar.getTravelId());
                  request.setStatus(orderPrivateCar.getState());
                  if (null != orderPrivateCar.getDriverId()) {
                     driver1 = driverService.selectById(orderPrivateCar.getDriverId());
                     company = companyService.selectById(driver1.getCompanyId());
                     request.setDriverId(driver1.getEmpId().toString());
                     request.setSupplierShopId(company.getEnterCode());
                  }
                  if (2 == orderPrivateCar.getPromotion()) {
                     Driver driver2 = driverService.selectById(orderPrivateCar.getPromotionDriverId());
                     request.setPromoterId(driver2.getEmpId().toString());
                  }
                  OrderUtil.modifyTravelItinerary(request);
                  new Thread(new Runnable() {
                     @Override
                     public void run() {
@@ -1441,6 +1492,23 @@
                  OrderTaxi orderTaxi = orderTaxiService.selectById(orderId);
                  orderTaxi.setState(9);
                  orderTaxiService.updateById(orderTaxi);
                  Driver driver = null;
                  Company company1 = null;
                  //中台修改订单状态
                  ModifyTravelItineraryRequest request2 = new ModifyTravelItineraryRequest();
                  request2.setOrderId(orderTaxi.getTravelId());
                  request2.setStatus(orderTaxi.getState());
                  if (null != orderTaxi.getDriverId()) {
                     driver = driverService.selectById(orderTaxi.getDriverId());
                     company1 = companyService.selectById(driver.getCompanyId());
                     request2.setDriverId(driver.getEmpId().toString());
                     request2.setSupplierShopId(company1.getEnterCode());
                  }
                  if (2 == orderTaxi.getPromotion()) {
                     Driver driver2 = driverService.selectById(orderTaxi.getPromotionDriverId());
                     request2.setPromoterId(driver2.getEmpId().toString());
                  }
                  OrderUtil.modifyTravelItinerary(request2);
                  break;
               case 3:
                  OrderCrossCity orderCrossCity = orderCrossCityService.selectById(orderId);
@@ -2080,7 +2148,30 @@
   @PostMapping("/base/order/qytPaymentCallback")
   public String qytPaymentCallback(@RequestBody QYTPaymentCallback qytPaymentCallback) {
      log.info("【黔云通支付回调通知】请求参数:" + JSON.toJSONString(qytPaymentCallback));
      if (null == qytPaymentCallback) {
      try {
         if (null == qytPaymentCallback) {
            return "error";
         }
         QYTPaymentCallbackData data = qytPaymentCallback.getData();
         if("1".equals(data.getStatus())){
            return "error";
         }
         String orderNo = data.getOrderNo();
         String payId = data.getPayId();
         //网约车
         if(orderNo.contains("PR")){
            orderNo = orderNo.substring(2);
            orderPrivateCarService.payOrderPrivateCarCallback(Integer.valueOf(orderNo), payId, 1);
            orderPrivateCarService.promotion(Integer.valueOf(orderNo));
         }
         //出租车
         if(orderNo.contains("TA")){
            orderNo = orderNo.substring(2);
            orderTaxiService.payOrderTaxiCallback(Integer.valueOf(orderNo), payId, 1, 0);
            orderTaxiService.promotion(Integer.valueOf(orderNo));
         }
      }catch (Exception e){
         e.printStackTrace();
         return "error";
      }
      return "success";
@@ -2095,12 +2186,6 @@
    */
   private void promotion(Integer orderType, Integer orderId) {
      switch (orderType) {
         case 1:
            orderPrivateCarService.promotion(orderId);
            break;
         case 2:
            orderTaxiService.promotion(orderId);
            break;
         case 3:
            orderCrossCityService.promotion(orderId);
            break;
@@ -2165,5 +2250,290 @@
         return ResultUtil.runErr();
      }
   }
    
    @PostMapping("/api/order/queryMyTripList")
    @ApiOperation(value = "获取我的行程列表", tags = {"用户端-个人中心"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单类型（1=专车，2=出租车，3=跨城出行）", name = "type", required = true, dataType = "int"),
            @ApiImplicitParam(value = "页码（首页1）", name = "pageNum", required = true, dataType = "int"),
            @ApiImplicitParam(value = "页条数", name = "size", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil<List<TripOrderVo>> queryMyTripList(Integer type, Integer pageNum, Integer size, HttpServletRequest request){
        try {
            Integer uid = userInfoService.getUserIdFormRedis(request);
            if(null == uid){
                return ResultUtil.tokenErr();
            }
            
            List<Map<String,Object>> raw = fetchTrips(uid, type, pageNum, size);
            return ResultUtil.success(TripOrderVo.getTripOrderVo(raw));
            
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }
    /**
     * 私有：拉取指定 type 的行程列表。
     * type=0 → 全部类型；1/2/3 → 对应三种服务；pageNum/size 负责分页。
     * 对于 type==1 或 3，内部额外加载 serverCarModel 信息。
     */
    private List<Map<String,Object>> fetchTrips(
            Integer uid, Integer type, Integer pageNum, Integer size) throws Exception {
        
        List<Map<String, Object>> list = new ArrayList<>();
        if (type == null || type == 0) {
            list.addAll(orderPrivateCarService.queryMyTripListAll(uid));
            list.addAll(orderTaxiService.queryMyTripListAll(uid));
            list.addAll(orderCrossCityService.queryMyTripListAll(uid));
        } else {
            switch (type) {
                case 1:
                    list = orderPrivateCarService.queryMyTripList(uid, pageNum, size);
                    break;
                case 2:
                    list = orderTaxiService.queryMyTripList(uid, pageNum, size);
                    break;
                case 3:
                    list = orderCrossCityService.queryMyTripList(uid, pageNum, size);
                    break;
                default:
                    throw new IllegalArgumentException("无效的订单类型：" + type);
            }
        }
        // 排序
        list.sort((a, b) -> {
            Date da = (Date) a.get("boardingTime");
            Date db = (Date) b.get("boardingTime");
            if (da == null && db == null) return 0;
            if (da == null) return 1;   // a 在后面
            if (db == null) return -1;  // b 在后面
            return da.compareTo(db);    // 按时间正序（升序）排列
        });
        // 将经纬度转换为城市并设置到数据中
        if (list != null && !list.isEmpty()) {
            for (Map<String, Object> orderMap : list) {
                // 获取经纬度（根据实际字段名调整）
                Object lonObj = orderMap.get("boardingLon");
                Object latObj = orderMap.get("boardingLat");
                //获取公司id
                Object companyId = orderMap.get("companyId");
                
                Object serverCarModelId =null;
                ServerCarModel serverCarModel = null;
                if (orderMap.get("serverCarModelId") != null ){
                    //获取车型id
                    serverCarModelId = orderMap.get("serverCarModelId");
                    serverCarModel = serverCarModelService.selectById((Serializable) serverCarModelId);
                }
                
                if (lonObj != null && latObj != null) {
                    String lon = lonObj.toString();
                    String lat = latObj.toString();
                    Company company = companyService.selectById((Serializable) companyId);
                    
                    try {
                        // 调用逆地理编码接口获取城市信息
                        Map<String, String> geoInfo = gdMapGeocodingUtil.geocode(lon, lat);
                        // 将城市信息存入map，供后续转换VO使用
                        orderMap.put("city", geoInfo.getOrDefault("city", ""));
                        orderMap.put("companyName", company.getName());
                        if (serverCarModel != null) {
                            orderMap.put("serverCarModel", serverCarModel.getName());
                        }
                    } catch (Exception e) {
                        // 记录转换失败日志，不中断流程
                        System.err.println("经纬度转城市失败: " + lon + "," + lat + "，错误: " + e.getMessage());
                        orderMap.put("city", ""); // 转换失败时设为空
                    }
                } else {
                    orderMap.put("city", ""); // 经纬度为空时设为空
                }
            }
        }
        return list;
    }
    @PostMapping("/api/user/sendTripSheetEmail")
    @ApiOperation(value = "发送行程单邮件", tags = {"用户端-个人中心"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "行程单信息", name = "tripSheet", required = false, dataType = "com.stylefeng.guns.modular.system.model.vo.TripSheetVo"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil sendTripSheetEmail(@RequestBody TripSheetVo tripSheet,
                                         HttpServletRequest  request) {
        try {
            // 从Redis中获取当前用户ID
            Integer uid = userInfoService.getUserIdFormRedis(request);
            if (null == uid) {
                return ResultUtil.tokenErr();
            }
            List<TripOrderVo> orderList = new ArrayList<>();
            if (tripSheet.isAllOrders()) {
                // 这里复用 queryMyTripList 逻辑，不分页，type=0 表示全部
                List<Map<String, Object>> rawList = fetchTrips(uid, 0, null, null);
                orderList = TripOrderVo.getTripOrderVo(rawList);
            } else {
                // 指定订单ID集合：验证并查询订单
                if (tripSheet.getOrderIdList() == null || tripSheet.getOrderIdList().isEmpty()) {
                    return ResultUtil.error("请传入订单ID集合或者选择全部订单");
                }
                // 根据订单类型和ID查询订单
                orderList = queryOrdersByTypeAndIds(uid, tripSheet.getOrderType(), tripSheet.getOrderIdList());
            }
            List<TripOrderVo> tripOrderVos = processTripOrderVos(orderList);
            String filePath = tripSheetGenerator.generatePdf(tripOrderVos);
            File attachment = new File(filePath);
            String displayFileName = "贵人家园行程单.pdf";
            emailUtil.sendEmailWithAttachment(tripSheet.getRecipientEmail(), "行程单", "请查收您的行程单", attachment,displayFileName);
            attachment.delete(); // 发送成功后删除临时文件
            Map<String, Object> result = new HashMap<>();
            result.put("orderNum", orderList.size());
            return ResultUtil.success(result);
        } catch (Exception e) {
            e.printStackTrace();
            return ResultUtil.error("邮件发送失败"+e.getMessage());
        }
    }
    /**
     * 根据订单类型和ID集合查询订单
     */
    private List<TripOrderVo> queryOrdersByTypeAndIds(Integer userId, Integer orderType, List<Integer> orderIds) throws InvocationTargetException, IllegalAccessException {
        List<TripOrderVo> orderList = new ArrayList<>();
        List<Integer> states = Arrays.asList(8, 9);
        // 根据订单类型查询对应表的订单
        switch (orderType) {
            case 1:
                EntityWrapper<OrderPrivateCar> wrapper = new EntityWrapper<>();
                wrapper.in("id", orderIds);
                wrapper.in("state", states);
                List<OrderPrivateCar> orderPrivateCars = orderPrivateCarService.selectList(wrapper);
                for (OrderPrivateCar orderPrivateCar : orderPrivateCars) {
                    TripOrderVo vo = new TripOrderVo();
                    BeanUtils.copyProperties(orderPrivateCar, vo);
                    orderList.add(vo);
                }
                break;
            case 2:
                EntityWrapper<OrderTaxi> wrapper2 = new EntityWrapper<>();
                wrapper2.in("id", orderIds);
                wrapper2.in("state", states);
                List<OrderTaxi> orderTaxis = orderTaxiService.selectList(wrapper2);
                for (OrderTaxi orderTaxi : orderTaxis) {
                    TripOrderVo vo = new TripOrderVo();
                    BeanUtils.copyProperties(orderTaxi, vo);
                    orderList.add(vo);
                }
                break;
            case 3:
                EntityWrapper<OrderCrossCity> wrapper3 = new EntityWrapper<>();
                wrapper3.in("id", orderIds);
                wrapper3.in("state", states);
                List<OrderCrossCity> orderCrossCities = orderCrossCityService.selectList(wrapper3);
                for (OrderCrossCity orderCrossCity : orderCrossCities) {
                    TripOrderVo vo = new TripOrderVo();
                    BeanUtils.copyProperties(orderCrossCity, vo);
                    orderList.add(vo);
                }
                break;
            default:
                throw new IllegalArgumentException("无效的订单类型：" + orderType);
        }
        orderList.sort((a, b) -> {
            Date da =  a.getBoardingTime();
            Date db =  b.getBoardingTime();
            if (da == null && db == null) return 0;
            if (da == null) return 1;   // a 在后面
            if (db == null) return -1;  // b 在后面
            return da.compareTo(db);    // 按时间正序（升序）排列
        });
        
        
        return  orderList;
    }
    
    /**
     * 处理行程订单VO列表，补充经纬度、公司和车型信息
     */
    private List<TripOrderVo> processTripOrderVos(List<TripOrderVo> orderVoList) {
        if (orderVoList == null || orderVoList.isEmpty()) {
            return new ArrayList<>();
        }
        
        for (TripOrderVo orderVo : orderVoList) {
            // 处理经纬度转城市信息
            handleGeoInfoForVo(orderVo);
            
            // 处理公司信息
            handleCompanyInfoForVo(orderVo);
            
            // 处理车型信息
            handleCarModelInfoForVo(orderVo);
        }
        
        return orderVoList;
    }
    
    /**
     * 处理经纬度转城市信息
     */
    private void handleGeoInfoForVo(TripOrderVo orderVo) {
        // 直接从VO获取经纬度（假设VO中有对应的getter方法）
        String lon = String.valueOf(orderVo.getBoardingLon());
        String lat = String.valueOf(orderVo.getBoardingLat());
        
        if (StringUtils.isEmpty(lon) || StringUtils.isEmpty(lat)) {
            orderVo.setCity("");
            return;
        }
        
        try {
            // 调用逆地理编码接口获取城市信息
            Map<String, String> geoInfo = gdMapGeocodingUtil.geocode(lon, lat);
            orderVo.setCity(geoInfo.getOrDefault("city", ""));
        } catch (Exception e) {
            // 记录转换失败日志，不中断流程
            System.err.println("经纬度转城市失败: " + lon + "," + lat + "，错误: " + e.getMessage());
            orderVo.setCity("");
        }
    }
    
    /**
     * 处理公司信息
     */
    private void handleCompanyInfoForVo(TripOrderVo orderVo) {
        // 从VO获取公司ID
        Integer companyId = orderVo.getCompanyId();
        if (companyId == null) {
            orderVo.setCompanyName("");
            return;
        }
        
        Company company = companyService.selectById(companyId);
        if (company != null) {
            orderVo.setCompanyName(company.getName());
        } else {
            orderVo.setCompanyName("");
        }
    }
    
    /**
     * 处理车型信息
     */
    private void handleCarModelInfoForVo(TripOrderVo orderVo) {
        // 从VO获取车型ID
        Integer serverCarModelId = orderVo.getServerCarModelId();
        if (serverCarModelId == null) {
            orderVo.setServerCarModel("");
            return;
        }
        
        ServerCarModel serverCarModel = serverCarModelService.selectById(serverCarModelId);
        if (serverCarModel != null) {
            orderVo.setServerCarModel(serverCarModel.getName());
        } else {
            orderVo.setServerCarModel("");
        }
    }
   
}