microservice / rider-service · Files

package com.diligrp.rider.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.diligrp.rider.entity.*;
import com.diligrp.rider.mapper.*;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.diligrp.rider.common.exception.BizException;
import com.diligrp.rider.entity.*;
import com.diligrp.rider.mapper.*;
import com.diligrp.rider.service.RiderLevelService;
import com.diligrp.rider.service.RiderOrderService;
import com.diligrp.rider.service.WebhookService;
import com.diligrp.rider.vo.OrderVO;
import com.diligrp.rider.vo.RiderMonthCountVO;
import com.diligrp.rider.vo.RiderTodayCountVO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@Slf4j
@Service
@RequiredArgsConstructor
public class RiderOrderServiceImpl implements RiderOrderService {

    private final OrdersMapper ordersMapper;
    private final RiderOrderRefuseMapper refuseMapper;
    private final RiderOrderCountMapper countMapper;
    private final RiderBalanceMapper balanceMapper;
    private final RiderMapper riderMapper;
    private final RiderLevelService riderLevelService;
    private final ObjectMapper objectMapper;
    private final WebhookService webhookService;

    private static final int PAGE_SIZE = 20;

    @Override
    public List<OrderVO> getList(Long riderId, Long cityId, Integer type, int page) {
        if (type == null || !List.of(1, 2, 3).contains(type)) return List.of();

        LambdaQueryWrapper<Orders> wrapper = new LambdaQueryWrapper<Orders>()
                .eq(Orders::getCityId, cityId)
                .eq(Orders::getIsDel, 0);

        if (type == 1) {
            // 待接单：已支付、无骑手、非自己转出的单、未拒绝的单
            wrapper.eq(Orders::getStatus, 2)
                    .eq(Orders::getRiderId, 0)
                    .ne(Orders::getOldRiderId, riderId);
            List<Long> refusedIds = refuseMapper.selectRefuseOrderIds(riderId);
            if (!refusedIds.isEmpty()) {
                wrapper.notIn(Orders::getId, refusedIds);
            }
        } else if (type == 2) {
            // 待取货：已接单
            wrapper.eq(Orders::getRiderId, riderId).eq(Orders::getStatus, 3);
        } else {
            // 待完成：服务中
            wrapper.eq(Orders::getRiderId, riderId).eq(Orders::getStatus, 4);
        }

        int offset = (page - 1) * PAGE_SIZE;
        wrapper.orderByDesc(Orders::getId).last("LIMIT " + offset + "," + PAGE_SIZE);

        List<Orders> orders = ordersMapper.selectList(wrapper);
        List<OrderVO> result = new ArrayList<>();
        for (Orders o : orders) {
            result.add(toVO(o, riderId));
        }
        return result;
    }

    @Override
    public OrderVO getDetail(Long riderId, Long orderId) {
        Orders order = ordersMapper.selectById(orderId);
        if (order == null) throw new BizException(1001, "订单信息错误");
        // @TODO 注释
//        if (!riderId.equals(order.getRiderId())) throw new BizException(1002, "订单信息错误");
        if (order.getIsTrans() == 1 && riderId.equals(order.getOldRiderId())) {
            throw new BizException(1003, "转单的订单无法查看详情");
        }
        return toVO(order, riderId);
    }

    @Override
    @Transactional
    public void refuse(Long riderId, Long cityId, Long orderId) {
        Orders order = ordersMapper.selectById(orderId);
        if (order == null) throw new BizException(1001, "订单信息错误");
        if (!cityId.equals(order.getCityId())) throw new BizException(1002, "订单信息错误");
        if (order.getRiderId() != null && order.getRiderId() != 0) {
            throw new BizException(1003, "订单已被接");
        }
        RiderOrderRefuse refuse = new RiderOrderRefuse();
        refuse.setRiderId(riderId);
        refuse.setOid(orderId);
        refuse.setAddTime(System.currentTimeMillis() / 1000);
        refuseMapper.insert(refuse);
    }

    @Override
    @Transactional
    public void grap(Long riderId, Long cityId, Long orderId) {
        // 检查今日转单次数
        checkTransLimit(riderId, cityId);

        Rider rider = riderMapper.selectById(riderId);
        if (rider == null) throw new BizException(1000, "骑手信息不存在");
        if (rider.getIsRest() != null && rider.getIsRest() == 1) {
            throw new BizException(1000, "休息中无法接单");
        }

        Orders order = ordersMapper.selectById(orderId);
        if (order == null) throw new BizException(1001, "订单信息错误");
        if (!cityId.equals(order.getCityId())) throw new BizException(1002, "订单城市不匹配");
        if (order.getStatus() < 2) throw new BizException(1003, "订单状态错误");
        if (order.getRiderId() != null && order.getRiderId() != 0) {
            throw new BizException(980, "抢单失败，订单已被接");
        }
        if (order.getIsTrans() == 1 && riderId.equals(order.getOldRiderId())) {
            throw new BizException(980, "抢单失败，不能抢自己转出的单");
        }

        long now = System.currentTimeMillis() / 1000;
        LambdaUpdateWrapper<Orders> wrapper = new LambdaUpdateWrapper<Orders>()
                .eq(Orders::getId, orderId)
                .eq(Orders::getRiderId, 0)
                .eq(Orders::getStatus, 2)
                .set(Orders::getRiderId, riderId)
                .set(Orders::getStatus, 3)
                .set(Orders::getGrapTime, now);
        if (order.getOldRiderId() == null || order.getOldRiderId() == 0) {
            wrapper.set(Orders::getOldRiderId, riderId);
        }
        int updated = ordersMapper.update(null, wrapper);
        if (updated == 0) throw new BizException(980, "抢单失败，请重试");

        // 预置骑手收入
        presetIncome(orderId, riderId, order);

        // 通知接入方：骑手已接单
        notifyOrderEvent(orderId, "order.accepted");

        // 删除该骑手的拒单记录（抢到了就清掉）
        refuseMapper.delete(new LambdaQueryWrapper<RiderOrderRefuse>()
                .eq(RiderOrderRefuse::getOid, orderId));
    }

    @Override
    @Transactional
    public void start(Long riderId, Long orderId, String code) {
        if (code == null || code.isBlank()) throw new BizException(1001, "请输入完成码");

        Orders order = ordersMapper.selectById(orderId);
        if (order == null) throw new BizException(1004, "订单信息错误");
        if (!riderId.equals(order.getRiderId())) throw new BizException(1005, "订单信息错误");
        if (order.getStatus() != 3) throw new BizException(1006, "订单状态错误");
        // @TODO 注释
//        if (!code.equals(order.getCode())) throw new BizException(1007, "完成码错误");

        long now = System.currentTimeMillis() / 1000;
        int updated = ordersMapper.update(null, new LambdaUpdateWrapper<Orders>()
                .eq(Orders::getId, orderId)
                .eq(Orders::getRiderId, riderId)
                .eq(Orders::getStatus, 3)
                .set(Orders::getStatus, 4)
                .set(Orders::getPickTime, now));
        if (updated == 0) throw new BizException(980, "操作失败");
        // 通知接入方：骑手取件中
        notifyOrderEvent(orderId, "order.picking");
    }

    @Override
    @Transactional
    public void complete(Long riderId, Long orderId, String thumbsJson) {
        if (thumbsJson == null || thumbsJson.isBlank()) throw new BizException(1001, "请上传照片");

        List<String> thumbs;
        try {
            thumbs = objectMapper.readValue(thumbsJson, new TypeReference<>() {});
        } catch (Exception e) {
            throw new BizException(1002, "照片格式错误");
        }
        if (thumbs.isEmpty()) throw new BizException(1002, "请上传照片");
        if (thumbs.size() > 3) throw new BizException(1003, "最多上传3张照片");

        Orders order = ordersMapper.selectById(orderId);
        if (order == null) throw new BizException(1004, "订单信息错误");
        if (!riderId.equals(order.getRiderId())) throw new BizException(1005, "订单信息错误");
        if (order.getStatus() != 4) throw new BizException(1006, "订单状态错误");

        long now = System.currentTimeMillis() / 1000;
        int updated = ordersMapper.update(null, new LambdaUpdateWrapper<Orders>()
                .eq(Orders::getId, orderId)
                .eq(Orders::getRiderId, riderId)
                .eq(Orders::getStatus, 4)
                .set(Orders::getThumbs, thumbsJson)
                .set(Orders::getStatus, 6)
                .set(Orders::getCompleteTime, now));
        if (updated == 0) throw new BizException(1008, "操作失败");

        // 结算骑手收入
        settleIncome(orderId, riderId);

        // 通知接入方：订单已完成
        notifyOrderEvent(orderId, "order.completed");

        // 累计骑手统计
        long distance = getDistance(order);
        int countDate = Integer.parseInt(LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd")));
        countMapper.upsertCount(riderId, countDate, 1, distance, 0);
    }

    // ---- 私有辅助方法 ----

    /** 通知接入方订单状态变更 */
    private void notifyOrderEvent(Long orderId, String event) {
        try {
            Orders order = ordersMapper.selectById(orderId);
            if (order == null || order.getAppKey() == null) return;
            java.util.Map<String, Object> payload = new java.util.HashMap<>();
            payload.put("event", event);
            payload.put("outOrderNo", order.getOutOrderNo());
            payload.put("deliveryOrderId", order.getId());
            payload.put("orderNo", order.getOrderNo());
            payload.put("status", order.getStatus());
            payload.put("riderId", order.getRiderId());
            payload.put("timestamp", System.currentTimeMillis() / 1000);
            webhookService.send(event, orderId, objectMapper.writeValueAsString(payload));
        } catch (Exception e) {
            log.warn("订单事件通知失败 orderId={} event={}", orderId, event, e);
        }
    }

    private void checkTransLimit(Long riderId, Long cityId) {
        RiderLevel level = riderLevelService.getLevelByRider(riderId);
        if (level == null || level.getTransNums() == null) return;
        long todayStart = LocalDate.now().atStartOfDay(ZoneId.systemDefault()).toEpochSecond();
        int todayTrans = ordersMapper.countTodayTrans(riderId, todayStart);
        if (todayTrans >= level.getTransNums()) {
            throw new BizException(1000, "今日转单已超上限，无法接单");
        }
    }

    private void presetIncome(Long orderId, Long riderId, Orders order) {
        try {
            long distance = getDistance(order);
            BigDecimal income = riderLevelService.calcIncome(riderId, order.getType(),
                    order.getMoneyDelivery(), distance);
            ordersMapper.update(null, new LambdaUpdateWrapper<Orders>()
                    .eq(Orders::getId, orderId)
                    .set(Orders::getRiderIncome, income)
                    .set(Orders::getIsIncome, 1));
        } catch (Exception e) {
            log.warn("预置收入失败 orderId={}", orderId, e);
        }
    }

    private void settleIncome(Long orderId, Long riderId) {
        Orders order = ordersMapper.selectById(orderId);
        BigDecimal income = order.getRiderIncome();
        if (income == null) income = BigDecimal.ZERO;

        // 更新结算状态
        ordersMapper.update(null, new LambdaUpdateWrapper<Orders>()
                .eq(Orders::getId, orderId)
                .set(Orders::getIsIncome, 2));

        // 兼职骑手累加余额
        Rider rider = riderMapper.selectById(riderId);
        if (rider != null && rider.getType() == 1 && income.compareTo(BigDecimal.ZERO) > 0) {
            riderMapper.update(null, new LambdaUpdateWrapper<Rider>()
                    .eq(Rider::getId, riderId)
                    .setSql("balance = balance + " + income));
            // 记录流水
            RiderBalance balance = new RiderBalance();
            balance.setUid(riderId);
            balance.setType(1);
            balance.setAction("order_complete");
            balance.setActionId(orderId);
            balance.setOrderNo(order.getOrderNo());
            balance.setNums(income);
            balance.setAddTime(System.currentTimeMillis() / 1000);
            balanceMapper.insert(balance);
        }
    }

    private long getDistance(Orders order) {
        try {
            Map<String, Object> extra = objectMapper.readValue(order.getExtra(), new TypeReference<>() {});
            Object dist = extra.get("distance");
            if (dist != null) return Long.parseLong(dist.toString());
        } catch (Exception ignored) {}
        return 0;
    }

    private OrderVO toVO(Orders o, Long riderId) {
        OrderVO vo = new OrderVO();
        vo.setId(o.getId());
        vo.setOrderNo(o.getOrderNo());
        vo.setType(o.getType());
        vo.setTypeName(getTypeName(o.getType()));
        vo.setStatus(o.getStatus());
        vo.setFName(o.getFName());
        vo.setFAddr(o.getFAddr());
        vo.setFLng(o.getFLng());
        vo.setFLat(o.getFLat());
        vo.setTName(o.getTName());
        vo.setTAddr(o.getTAddr());
        vo.setTLng(o.getTLng());
        vo.setTLat(o.getTLat());
        vo.setRecipName(o.getRecipName());
        vo.setRecipPhone(o.getRecipPhone());
        vo.setIsTrans(o.getIsTrans());
        vo.setAddTime(o.getAddTime() != null ? formatTime(o.getAddTime()) : null);
        vo.setGrapTime(o.getGrapTime() != null && o.getGrapTime() > 0 ? formatTime(o.getGrapTime()) : null);
        vo.setPickTime(o.getPickTime() != null && o.getPickTime() > 0 ? formatTime(o.getPickTime()) : null);
        vo.setCompleteTime(o.getCompleteTime() != null && o.getCompleteTime() > 0 ? formatTime(o.getCompleteTime()) : null);
        vo.setTransTime(o.getTransTime() != null && o.getTransTime() > 0 ? formatTime(o.getTransTime()) : null);
        // 收入
        BigDecimal income = o.getRiderIncome() != null ? o.getRiderIncome() : BigDecimal.ZERO;
        if (o.getStatus() != 6 && (o.getIsIncome() == null || o.getIsIncome() == 0)) {
            income = riderLevelService.calcIncome(riderId, o.getType(), o.getMoneyDelivery(), getDistance(o));
        }
        vo.setIncome(income);
        vo.setOutOrderNo(o.getOutOrderNo());
        vo.setItemRemark(o.getItemRemark());
        try {
            if (o.getExtra() != null) {
                Map<String, Object> extraMap = objectMapper.readValue(o.getExtra(), new TypeReference<Map<String, Object>>() {});
                vo.setExtra(extraMap);
                // 从extra取备注
                Object remark = extraMap.get("remark");
                if (remark != null) vo.setDes(remark.toString());
                // 从extra取预约标识
                Object isPre = extraMap.get("ispre");
                if (isPre != null) vo.setIsPre(Integer.parseInt(isPre.toString()));
                // 从extra取服务时间
                Object serviceTime = extraMap.get("service_time");
                if (serviceTime != null) vo.setService_time(serviceTime.toString());
            }
            if (o.getItemsJson() != null && !o.getItemsJson().isBlank()) {
                vo.setItems(objectMapper.readValue(o.getItemsJson(), new TypeReference<List<Object>>() {}));
            }
        } catch (Exception ignored) {}
        return vo;
    }

    private String formatTime(long epochSecond) {
        return java.time.Instant.ofEpochSecond(epochSecond)
                .atZone(ZoneId.of("Asia/Shanghai"))
                .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));
    }

    private String getTypeName(Integer type) {
        if (type == null) return "";
        return switch (type) {
            case 1 -> "帮我送";
            case 2 -> "帮我取";
            case 3 -> "帮我买";
            case 4 -> "帮我排队";
            case 5 -> "帮我办";
            case 6 -> "外卖配送";
            default -> "";
        };
    }

    @Override
    @Transactional
    public void applyTrans(Long riderId, Long orderId) {
        Orders order = ordersMapper.selectById(orderId);
        if (order == null) throw new BizException(1001, "订单不存在");
        if (!riderId.equals(order.getRiderId())) throw new BizException(1002, "订单信息错误");
        if (order.getStatus() != 3 && order.getStatus() != 4) {
            throw new BizException(1003, "只有已接单或配送中的订单可以申请转单");
        }
        if (order.getIsTrans() != 0) throw new BizException(1004, "转单申请已提交，请勿重复操作");

        // 检查今日转单次数
        checkTransLimit(riderId, order.getCityId());

        long now = System.currentTimeMillis() / 1000;
        int countDate = Integer.parseInt(LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd")));

        if (order.getStatus() == 3) {
            // status=3（已接单，未取货）：直接回抢单池，无需审批
            ordersMapper.update(null, new LambdaUpdateWrapper<Orders>()
                    .eq(Orders::getId, orderId)
                    .eq(Orders::getRiderId, riderId)
                    .eq(Orders::getStatus, 3)
                    .set(Orders::getIsTrans, 1)       // 直接转单成功
                    .set(Orders::getStatus, 2)         // 回到待接单
                    .set(Orders::getRiderId, 0L)       // 清空骑手
                    .set(Orders::getGrapTime, 0L)
                    .set(Orders::getIsIncome, 0)
                    .set(Orders::getRiderIncome, BigDecimal.ZERO)
                    .set(Orders::getSubstationIncome, BigDecimal.ZERO)
                    .set(Orders::getTransTime, now));
        } else {
            // status=4（取货后配送中）：需分站审批，设为申请中
            ordersMapper.update(null, new LambdaUpdateWrapper<Orders>()
                    .eq(Orders::getId, orderId)
                    .eq(Orders::getRiderId, riderId)
                    .eq(Orders::getStatus, 4)
                    .set(Orders::getIsTrans, 2)        // 申请中，等待审批
                    .set(Orders::getTransTime, now));
        }

        // 累加骑手转单统计
        countMapper.upsertCount(riderId, countDate, 0, 0, 1);
    }

    @Override
    public RiderTodayCountVO getTodayCount(Long riderId) {
        long todayStart = LocalDate.now().atStartOfDay(ZoneId.of("Asia/Shanghai")).toEpochSecond();
        int countDate = Integer.parseInt(LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd")));

        RiderOrderCount count = countMapper.selectOne(
                new LambdaQueryWrapper<RiderOrderCount>()
                        .eq(RiderOrderCount::getUid, riderId)
                        .eq(RiderOrderCount::getCountDate, countDate)
                        .last("LIMIT 1"));

        RiderTodayCountVO vo = new RiderTodayCountVO();
        if (count != null) {
            vo.setOrders(count.getOrders());
            vo.setTransfers(count.getTransfers());
            vo.setDistance(count.getDistance());
        } else {
            vo.setOrders(0);
            vo.setTransfers(0);
            vo.setDistance(0L);
        }
        // 今日抢单数（今日接单总数， getGrapNums）
        long todayStartTs = LocalDate.now().atStartOfDay(ZoneId.of("Asia/Shanghai")).toEpochSecond();
        long todayEndTs = todayStartTs + 86400;
        int graps = ordersMapper.selectCount(new LambdaQueryWrapper<Orders>()
                .eq(Orders::getOldRiderId, riderId)
                .ge(Orders::getGrapTime, todayStartTs)
                .lt(Orders::getGrapTime, todayEndTs)).intValue();
        vo.setGraps(graps);
        return vo;
    }

    @Override
    public List<RiderMonthCountVO> getMonthCount(Long riderId, int year) {
        if (year == 0) year = LocalDate.now().getYear();
        int startDate = year * 10000 + 101;   // yyyyMMdd 格式起始
        int endDate = (year + 1) * 10000 + 101;

        List<RiderOrderCount> list = countMapper.selectList(
                new LambdaQueryWrapper<RiderOrderCount>()
                        .eq(RiderOrderCount::getUid, riderId)
                        .ge(RiderOrderCount::getCountDate, startDate)
                        .lt(RiderOrderCount::getCountDate, endDate)
                        .orderByAsc(RiderOrderCount::getCountDate));

        int currentYearMonth = Integer.parseInt(
                LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMM")));

        List<RiderMonthCountVO> result = new ArrayList<>();
        for (var c : list) {
            RiderMonthCountVO vo = new RiderMonthCountVO();
            int ym = c.getCountDate() / 100; // yyyyMM
            int month = ym % 100;
            if (ym == currentYearMonth) {
                vo.setTitle("本月");
                vo.setDes(String.format("%02d-01至%s", month,
                        LocalDate.now().format(DateTimeFormatter.ofPattern("MM-dd"))));
            } else {
                vo.setTitle(month + "月");
                vo.setDes("");
            }
            vo.setOrders(c.getOrders());
            vo.setTransfers(c.getTransfers());
            vo.setDistance(c.getDistance());
            result.add(vo);
        }
        return result;
    }

    @Override
    public List<OrderVO> getCountList(Long riderId, int type, int page) {
        //  getCountList：以 oldriderid 为维度查询骑手历史订单
        // type=0全部(完成+转单) 1已完成 2已转单
        if (!List.of(0, 1, 2).contains(type)) return List.of();

        LambdaQueryWrapper<Orders> wrapper = new LambdaQueryWrapper<Orders>()
                .eq(Orders::getOldRiderId, riderId)
                .orderByDesc(Orders::getId);

        if (type == 0) {
            // 全部：(status=6 且 isTrans=0) 或 isTrans=1（转单成功）
            wrapper.and(w -> w
                    .nested(n -> n.eq(Orders::getStatus, 6).eq(Orders::getIsTrans, 0))
                    .or()
                    .eq(Orders::getIsTrans, 1));
        } else if (type == 1) {
            wrapper.eq(Orders::getStatus, 6).eq(Orders::getIsTrans, 0);
        } else {
            wrapper.eq(Orders::getIsTrans, 1);
        }

        int offset = (page - 1) * PAGE_SIZE;
        wrapper.last("LIMIT " + offset + "," + PAGE_SIZE);

        List<Orders> orders = ordersMapper.selectList(wrapper);
        List<OrderVO> result = new ArrayList<>();
        for (Orders o : orders) result.add(toVO(o, riderId));
        return result;
    }
}