订单服务

if (redisUtils.hasKey(key)) {
    // redis是否有该缓存
    Object obj = redisUtils.get(key);
    NoTakeBusResponse response = (NoTakeBusResponse) obj;
    for (NoTakeDto noTakeDto : response.getNoTakeDtos()) {
        // 如果场次发车时间-当前时间是大0的，那么说明已经发车了
        String beginTime = noTakeDto.getBeginTime();
        if (beginTime.compareTo(DateUtil.getHours()) <= -1) {
            // 删掉当前缓存
            redisUtils.del(key);
            // 重新获取最新的数据
            response = orderService.getNoTakeOrdersById(request);
            // 写缓存
            redisUtils.set(key, response, RedisConstants.NO_TAKE_OREDERS_EXPIRE.getTime());
            return new ResponseUtil().setData(response);
        }
    }
    log.warn("getNoTakeOrdersById->redis\n");
    return new ResponseUtil().setData(obj);
}

// 从redis中是否有缓存
if (redisUtils.hasKey(key)) {
    // 有就获取
    Object obj = redisUtils.get(key);
    log.warn("getNoPayOrdersById->redis\n");
    return new ResponseUtil().setData(obj);
}

String countKey = RedisConstants.COUNT_DETAIL_EXPIRE.getKey() + request.getCountId();
// 座位缓存失效
if (redisUtils.hasKey(countKey)) {
    redisUtils.del(countKey);
}
String noPayKey = RedisConstants.NO_PAY_ORDERS_EXPIRE.getKey() + userId;
// 未支付列表缓存失效
if (redisUtils.hasKey(noPayKey)) {
    redisUtils.del(noPayKey);
}

// 删掉订单详情缓存
if (redisUtils.hasKey(selectOrderKey)) {
    redisUtils.del(selectOrderKey);
}
// 删除未乘坐缓存
if (redisUtils.hasKey(noTakeKey)) {
    redisUtils.del(noTakeKey);
}
// 删除未支付缓存
if (redisUtils.hasKey(noPayKey)) {
    redisUtils.del(noPayKey);
}
// 删除评价缓存
if (redisUtils.hasKey(evaluateKey)) {
    redisUtils.del(evaluateKey);
}

IPage<NoTakeDto> orderIPage = new  Page<>(request.getCurrentPage(), request.getPageSize());
QueryWrapper<NoTakeDto> queryWrapper = new QueryWrapper<>();
// 获取系统年月日
// 比如5.30
String day = DateUtil.getDay();
// 比如20:00
String hours = DateUtil.getHours();
System.out.println("当前日期:" + day);
System.out.println("当前时间:" + hours);
queryWrapper
        .eq("user_id", request.getUserId()) // 用户id
        .eq("order_status", "1")// 1：已经支付
        .ge("sc.begin_date", day) // 比如订单日期大于等于今天
        .ge("sc.begin_time", hours) // 订单时间大于等于当前时间
        .orderByAsc("sc.begin_time") // 排序
        .orderByDesc("so.order_time"); // 排序

IPage<EvaluateDto> orderIPage = new Page<>(request.getCurrentPage(), request.getPageSize());
QueryWrapper<EvaluateDto> queryWrapper = new QueryWrapper<>();
// 获取系统年月日
String day = DateUtil.getDay();
String hours = DateUtil.getHours();
System.out.println("当前日期:" + day);
System.out.println("当前时间:" + hours);
queryWrapper
        .eq("user_id", request.getUserId()) // 用户di
        .eq("order_status", "1") // 状态为1
        // 两种情况：
        // 1. 符合当天日期，并且订单场次发车时间小于当前日期
        // 2. 订单场次的发车日期小于当前日期
        .and(o -> o.eq("sc.begin_date", day)
                   .lt("sc.begin_time", hours)
                   .or().lt("sc.begin_date", day))
        .eq("evaluate_status", request.getEvaluateStatus()) // 评价状态
        .orderByDesc("sc.begin_time") // 排序
        .orderByDesc("so.order_time"); // 排序

IPage<NoPayDto> noPayDtoIPage = new Page<>(request.getCurrentPage(), request.getPageSize());
QueryWrapper<NoPayDto> queryWrapper = new QueryWrapper<>();
// 获取系统年月日
String day = DateUtil.getDay();
String hours = DateUtil.getHours();
System.out.println("当前日期:" + day);
System.out.println("当前时间:" + hours);
queryWrapper
        .eq("so.user_id", request.getUserId()) // 用户id
        .eq("so.order_status", "0") // 未支付状态
        .ge("sc.begin_date", day) // 比如，订单场次日期大于当前日期
        .ge("sc.begin_time", hours)// 订单场次时间大于当前日期
        .orderByDesc("sc.begin_time") // 排序
        .orderByDesc("so.order_time"); // 未支付

public AddOrderResponse addOrder(AddOrderRequest request) {
    // 判断座位，如果重复，直接退出，否则更新场次的座位信息
    AddOrderResponse response = new AddOrderResponse();
    // 全局orderId
    Long orderId = UUIDUtils.flakesUUID();
    // 1。 判断座位，如果重复，直接退出，否则下一步
    // 2。 更新座位，如果没有异常，这是写操作
    // 3。 计算总金额，如果没有异常
    // 4。 添加订单，如果异常，这是写操作
    try {
        // 1。 判断座位，如果重复，直接退出，否则下一步
        tag = MqTags.ORDER_SEATS_CANCEL.getTag();
        boolean repeatSeats = busService.repeatSeats(request.getSeatsIds(), request.getCountId());
        if (repeatSeats) {
            // b:true 说明重复
            response.setCode(SbCode.SELECTED_SEATS.getCode());
            response.setMsg(SbCode.SELECTED_SEATS.getMessage());
            return response;
        }
//            CastException.cast(SbCode.SYSTEM_ERROR);
        // 2。 更新座位，如果没有异常，这是写操作
        // 用tags来过滤消息
        tag = MqTags.ORDER_ADD_SEATS_CANCLE.getTag();
        boolean addSeats = busService.addSeats(request.getSeatsIds(), request.getCountId());
        if (!addSeats) {
            response.setCode(SbCode.DB_EXCEPTION.getCode());
            response.setMsg(SbCode.DB_EXCEPTION.getMessage());
            return response;
        }
        // 模拟系统异常
//            CastException.cast(SbCode.SYSTEM_ERROR);
        // 3。 计算总金额，如果没有异常
        tag = MqTags.ORDER_CALC_MONEY_CANCLE.getTag();
        String seatIds = request.getSeatsIds();
        Integer seatNumber = seatIds.split(",").length;
        Double countPrice = request.getCountPrice();
        Double totalPrice = getTotalPrice(seatNumber, countPrice);

//            CastException.cast(SbCode.SYSTEM_ERROR);
        // 4。 添加订单，如果异常，这是写操作
        Order order = orderConvertver.res2Order(request);
        order.setOrderPrice(totalPrice);
        order.setEvaluateStatus("0"); // 未评价
        order.setOrderStatus("0"); // 未支付
        order.setUuid(orderId); // 唯一id
        tag = MqTags.ORDER_ADD_CANCLE.getTag();
        int insert = orderMapper.insert(order);// 插入 不判断了
//            CastException.cast(SbCode.SYSTEM_ERROR);
        // 这里就不读了，耗时
//            QueryWrapper<OrderDto> wrapper = new QueryWrapper<>();
//            wrapper.eq("so.uuid", order.getUuid());
//            OrderDto orderDto = orderMapper.selectOrderById(wrapper);
        response.setCode(SbCode.SUCCESS.getCode());
        response.setMsg(SbCode.SUCCESS.getMessage());
        response.setOrderId(orderId);
//            response.setOrderDto(orderDto);
        // 这里放redis 未支付缓存，时间前端给定
        redisUtils.set(RedisConstants.ORDER_CANCLE_EXPIRE.getKey() + orderId, orderId, request.getExpireTime());
        return response;
    } catch (Exception e) {
        // 以上操作如果程序都不发生异常的话， 是不会执行这里的代码的
        // 也就是说不会发送回退消息的。
        // 目的是在高并发的情况下，程序内部发生异常，依然高可用
//            e.printStackTrace();
        log.error("订单业务发生异常");
        // 发消息，将座位退回，将订单退回
        MQDto mqDto = new MQDto();
        mqDto.setOrderId(orderId);
        mqDto.setCountId(request.getCountId());
        mqDto.setSeatsIds(request.getSeatsIds());
        try {
            String key = RedisConstants.ORDER_EXCEPTION_CANCLE_EXPIRE.getKey() + Convert.toStr(orderId);
            sendCancelOrder(topic,tag, key, JSON.toJSONString(mqDto));
            log.warn("订单回退消息发送成功..." + mqDto);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        response.setCode(SbCode.SYSTEM_ERROR.getCode());
        response.setMsg(SbCode.SYSTEM_ERROR.getMessage());
        return response;
    }
}

public OrderResponse updateOrderStatus(OrderRequest request) {
    OrderResponse response = new OrderResponse();
    try {
        // 获取orderDto
        QueryWrapper<OrderDto> wrapper = new QueryWrapper<>();
        wrapper.eq("so.uuid", request.getUuid());
        OrderDto orderDto = orderMapper.selectOrderById(wrapper);
        // 1， 检查状态是否为2
        if (request.getOrderStatus().equals("2")) {
            // 说明关闭订单，回退座位
            busService.filterRepeatSeats(orderDto.getSeatsIds(), orderDto.getCountId());
            redisUtils.del(RedisConstants.COUNT_DETAIL_EXPIRE.getKey()
                    + orderDto.getCountId());
            // 清除场次详情的缓存
        }
        if (request.getOrderStatus().equals("1")) {
            // 说明已经支付，删掉5分钟的订单缓存
            redisUtils.del(RedisConstants.ORDER_CANCLE_EXPIRE.getKey() + request.getUuid());
        }
        Order order = orderConvertver.res2Order(request);
        // 更新状态
        orderMapper.updateById(order);
        // 暂时就不获取了
        response.setCode(SbCode.SUCCESS.getCode());
        response.setMsg(SbCode.SUCCESS.getMessage());
        redisUtils.del(RedisConstants.NO_PAY_ORDERS_EXPIRE.getKey()+order.getUserId());
        redisUtils.del(RedisConstants.SELECT_ORDER_EXPIRE.getKey() + request.getUuid());
    } catch (Exception e) {
        log.error("updateOrderStatus", e);
        response.setCode(SbCode.DB_EXCEPTION.getCode());
        response.setMsg(SbCode.DB_EXCEPTION.getMessage());
        return response;
    }
    return response;
}