DispatchScheduleTask.java 2.82 KB
package com.diligrp.rider.task;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.diligrp.rider.entity.City;
import com.diligrp.rider.entity.Orders;
import com.diligrp.rider.mapper.CityMapper;
import com.diligrp.rider.mapper.OrdersMapper;
import com.diligrp.rider.service.DispatchRuleService;
import com.diligrp.rider.service.DispatchService;
import com.diligrp.rider.vo.DispatchRuleTemplateVO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.List;

@Slf4j
@Component
@EnableScheduling
@RequiredArgsConstructor
public class DispatchScheduleTask {

    private final CityMapper cityMapper;
    private final OrdersMapper ordersMapper;
    private final DispatchRuleService dispatchRuleService;
    private final DispatchService dispatchService;

    /**
     * 抢单超时后自动派单
     * 每3秒执行一次
     */
    @Scheduled(fixedDelay = 3_000)
    public void autoDispatchTimeoutOrders() {
        try {
            List<City> cities = cityMapper.selectList(new LambdaQueryWrapper<City>()
                    .eq(City::getStatus, 1)
                    .select(City::getId));
            if (cities.isEmpty()) return;

            long now = System.currentTimeMillis() / 1000;
            for (City city : cities) {
                DispatchRuleTemplateVO rule = dispatchRuleService.getActiveRule(city.getId());
                if (rule == null || rule.getAutoDispatch() == null || rule.getAutoDispatch() != 1) {
                    continue;
                }
                if (rule.getGrabEnabled() == null || rule.getGrabEnabled() != 1) {
                    continue;
                }

                int timeoutMinutes = rule.getGrabTimeout() != null ? rule.getGrabTimeout() : 30;
                long expireTime = now - timeoutMinutes * 60L;

                List<Orders> timeoutOrders = ordersMapper.selectList(new LambdaQueryWrapper<Orders>()
                        .eq(Orders::getCityId, city.getId())
                        .eq(Orders::getStatus, 2)
                        .eq(Orders::getRiderId, 0)
                        .le(Orders::getAddTime, expireTime)
                        .orderByAsc(Orders::getAddTime)
                        .last("LIMIT 100"));

                for (Orders order : timeoutOrders) {
                    Long riderId = dispatchService.dispatch(order);
                    if (riderId != null) {
                        log.info("超时订单自动派单成功 orderId={} riderId={}", order.getId(), riderId);
                    }
                }
            }
        } catch (Exception e) {
            log.error("自动派单任务异常", e);
        }
    }
}