update

liujie

2026-07-30 280ef5100bece9b40ac51736aef037704a52a4ca

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
package com.tourguide.modules.order.service;
 
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.tourguide.common.api.PageResponse;
import com.tourguide.common.exception.BusinessException;
import com.tourguide.modules.order.domain.OrderStatus;
import com.tourguide.modules.order.dto.GuideOrderResponse;
import com.tourguide.modules.order.entity.TourOrder;
import com.tourguide.modules.order.mapper.TourOrderMapper;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
 
import java.util.Arrays;
import java.util.stream.Collectors;
 
/** 导游端订单查询服务，所有查询均限定当前导游本人。 */
@Service
public class GuideTourOrderService {
    private static final String TAB_ALL = "all";
    private static final String TAB_ACCEPTED = "accepted";
    private static final String TAB_SERVING = "serving";
    private static final String TAB_COMPLETED = "completed";
 
    private final TourOrderMapper orderMapper;
 
    public GuideTourOrderService(TourOrderMapper orderMapper) {
        this.orderMapper = orderMapper;
    }
 
    public PageResponse<GuideOrderResponse> page(Long guideId, String tab, long page, long size) {
        LambdaQueryWrapper<TourOrder> query = new LambdaQueryWrapper<TourOrder>()
                .eq(TourOrder::getGuideId, guideId);
        applyTabFilter(query, normalizeTab(tab));
        query.orderByDesc(TourOrder::getAcceptedAt)
                .orderByDesc(TourOrder::getId);
        Page<TourOrder> result = orderMapper.selectPage(new Page<TourOrder>(page, size), query);
        return new PageResponse<GuideOrderResponse>(
                result.getRecords().stream().map(GuideOrderResponse::from).collect(Collectors.toList()),
                result.getTotal(), result.getCurrent(), result.getSize());
    }
 
    public GuideOrderResponse detail(Long guideId, Long orderId) {
        TourOrder order = orderMapper.selectOne(new LambdaQueryWrapper<TourOrder>()
                .eq(TourOrder::getId, orderId)
                .eq(TourOrder::getGuideId, guideId)
                .last("LIMIT 1"));
        if (order == null) {
            throw new BusinessException(404, "订单不存在");
        }
        return GuideOrderResponse.from(order);
    }
 
    private String normalizeTab(String tab) {
        return StringUtils.hasText(tab) ? tab.trim() : TAB_ALL;
    }
 
    private void applyTabFilter(LambdaQueryWrapper<TourOrder> query, String tab) {
        if (TAB_ALL.equals(tab)) {
            query.ne(TourOrder::getStatus, OrderStatus.PENDING_PAYMENT.getCode());
            return;
        }
        if (TAB_ACCEPTED.equals(tab)) {
            query.in(TourOrder::getStatus,
                    OrderStatus.PENDING_ACCEPT.getCode(), OrderStatus.PENDING_MEETING.getCode());
            return;
        }
        if (TAB_SERVING.equals(tab)) {
            query.eq(TourOrder::getStatus, OrderStatus.IN_SERVICE.getCode());
            return;
        }
        if (TAB_COMPLETED.equals(tab)) {
            query.in(TourOrder::getStatus, Arrays.asList(
                    OrderStatus.COMPLETED.getCode(), OrderStatus.CANCELLED.getCode(), OrderStatus.REFUNDED.getCode()));
            return;
        }
        throw new BusinessException(400, "订单筛选状态不合法");
    }
}