package com.tourguide.modules.user.service;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import com.tourguide.common.exception.BusinessException;
|
import com.tourguide.modules.operation.dto.PlatformSettingsResponse;
|
import com.tourguide.modules.operation.entity.OperationScenicSpot;
|
import com.tourguide.modules.operation.entity.ScenicMeetingPoint;
|
import com.tourguide.modules.operation.entity.ScenicPricing;
|
import com.tourguide.modules.operation.mapper.OperationScenicSpotMapper;
|
import com.tourguide.modules.operation.mapper.ScenicMeetingPointMapper;
|
import com.tourguide.modules.operation.mapper.ScenicPricingMapper;
|
import com.tourguide.modules.operation.service.PlatformSettingsService;
|
import com.tourguide.modules.order.domain.OrderStatus;
|
import com.tourguide.modules.order.entity.TourOrder;
|
import com.tourguide.modules.order.mapper.TourOrderMapper;
|
import com.tourguide.modules.order.service.GuideSessionTransitionService;
|
import com.tourguide.modules.user.dto.GuideReceivingOptionResponse;
|
import com.tourguide.modules.user.dto.GuideReceivingStartRequest;
|
import com.tourguide.modules.user.entity.GuideRealtimeStatus;
|
import com.tourguide.modules.user.entity.GuideReceivingSession;
|
import com.tourguide.modules.user.entity.GuideScenicConfig;
|
import com.tourguide.modules.user.entity.GuideTeamScenicConfig;
|
import com.tourguide.modules.user.entity.GuideUser;
|
import com.tourguide.modules.user.mapper.GuideRealtimeStatusMapper;
|
import com.tourguide.modules.user.mapper.GuideReceivingSessionMapper;
|
import com.tourguide.modules.user.mapper.GuideScenicConfigMapper;
|
import com.tourguide.modules.user.mapper.GuideTeamScenicConfigMapper;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.math.BigDecimal;
|
import java.time.LocalDateTime;
|
import java.util.ArrayList;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
|
@Service
|
public class GuideReceivingService {
|
private final GuideUserService guideUserService;
|
private final GuideScenicConfigMapper guideScenicMapper;
|
private final GuideTeamScenicConfigMapper teamScenicMapper;
|
private final OperationScenicSpotMapper scenicMapper;
|
private final ScenicMeetingPointMapper meetingPointMapper;
|
private final ScenicPricingMapper pricingMapper;
|
private final GuideReceivingSessionMapper sessionMapper;
|
private final GuideRealtimeStatusMapper realtimeStatusMapper;
|
private final PlatformSettingsService platformSettingsService;
|
private final TourOrderMapper orderMapper;
|
private final GuideSessionTransitionService sessionTransitionService;
|
|
public GuideReceivingService(GuideUserService guideUserService, GuideScenicConfigMapper guideScenicMapper,
|
GuideTeamScenicConfigMapper teamScenicMapper, OperationScenicSpotMapper scenicMapper,
|
ScenicMeetingPointMapper meetingPointMapper, ScenicPricingMapper pricingMapper,
|
GuideReceivingSessionMapper sessionMapper, GuideRealtimeStatusMapper realtimeStatusMapper,
|
PlatformSettingsService platformSettingsService, TourOrderMapper orderMapper,
|
GuideSessionTransitionService sessionTransitionService) {
|
this.guideUserService = guideUserService;
|
this.guideScenicMapper = guideScenicMapper;
|
this.teamScenicMapper = teamScenicMapper;
|
this.scenicMapper = scenicMapper;
|
this.meetingPointMapper = meetingPointMapper;
|
this.pricingMapper = pricingMapper;
|
this.sessionMapper = sessionMapper;
|
this.realtimeStatusMapper = realtimeStatusMapper;
|
this.platformSettingsService = platformSettingsService;
|
this.orderMapper = orderMapper;
|
this.sessionTransitionService = sessionTransitionService;
|
}
|
|
public GuideReceivingOptionResponse options(Long guideId) {
|
GuideUser guide = guideUserService.findEnabledById(guideId);
|
PlatformSettingsResponse settings = platformSettingsService.getSettings();
|
boolean premiumEnabled = premiumEnabled(guide, settings);
|
Set<String> scenicNames = configuredScenicNames(guide);
|
if (scenicNames.isEmpty()) {
|
return new GuideReceivingOptionResponse(premiumEnabled, value(settings.getPreciseDispatchOrderCount()),
|
settings.getPreciseDispatchRating(), new ArrayList<>());
|
}
|
List<OperationScenicSpot> scenics = scenicMapper.selectList(new LambdaQueryWrapper<OperationScenicSpot>()
|
.eq(OperationScenicSpot::getStatus, 1).in(OperationScenicSpot::getScenicName, scenicNames)
|
.orderByAsc(OperationScenicSpot::getId));
|
List<GuideReceivingOptionResponse.ScenicOption> rows = new ArrayList<>();
|
for (OperationScenicSpot scenic : scenics) {
|
List<GuideReceivingOptionResponse.MeetingPointOption> points = meetingPointMapper.selectList(
|
new LambdaQueryWrapper<ScenicMeetingPoint>().eq(ScenicMeetingPoint::getScenicSpotId, scenic.getId())
|
.eq(ScenicMeetingPoint::getStatus, 1).orderByAsc(ScenicMeetingPoint::getSortOrder))
|
.stream().map(point -> new GuideReceivingOptionResponse.MeetingPointOption(point.getId(),
|
point.getPointName(), point.getLongitude(), point.getLatitude())).collect(Collectors.toList());
|
List<GuideReceivingOptionResponse.ServiceOption> services = pricingMapper.selectList(
|
new LambdaQueryWrapper<ScenicPricing>().eq(ScenicPricing::getScenicSpotId, scenic.getId())
|
.orderByAsc(ScenicPricing::getId)).stream()
|
.map(item -> new GuideReceivingOptionResponse.ServiceOption(item.getId(), item.getServiceType(),
|
item.getDurationMinutes(), item.getMinParticipants(), item.getMaxParticipants(),
|
item.getOriginalPrice(), item.getDiscountPrice()))
|
.collect(Collectors.toList());
|
rows.add(new GuideReceivingOptionResponse.ScenicOption(scenic.getId(), scenic.getScenicName(),
|
positive(scenic.getFirstOrderLeadMinutes(), 15), points, services));
|
}
|
return new GuideReceivingOptionResponse(premiumEnabled, value(settings.getPreciseDispatchOrderCount()),
|
settings.getPreciseDispatchRating(), rows);
|
}
|
|
@Transactional
|
public GuideReceivingSession start(Long guideId, GuideReceivingStartRequest request) {
|
GuideUser guide = guideUserService.findEnabledById(guideId);
|
String mode = normalizeMode(request.getReceivingMode());
|
OperationScenicSpot scenic = requireAllowedScenic(guide, request.getScenicSpotId());
|
requireMeetingPoint(request.getMeetingPointId(), scenic.getId());
|
Set<String> serviceTypes = new HashSet<>(request.getServiceTypes());
|
if (serviceTypes.size() != request.getServiceTypes().size()) {
|
throw new BusinessException(400, "service type cannot be duplicated");
|
}
|
validateServiceTypes(guide, scenic.getId(), mode, serviceTypes);
|
stopActiveSessions(guideId);
|
|
GuideReceivingSession session = new GuideReceivingSession();
|
session.setGuideId(guideId);
|
session.setScenicSpotId(scenic.getId());
|
session.setMeetingPointId(request.getMeetingPointId());
|
session.setReceivingMode(mode);
|
session.setServiceTypes(String.join(",", serviceTypes));
|
session.setStatus("RECEIVING");
|
session.setCurrentPeopleCount(0);
|
sessionMapper.insert(session);
|
saveRealtimeStatus(guideId, request, scenic.getId());
|
return sessionMapper.selectById(session.getId());
|
}
|
|
public GuideReceivingSession current(Long guideId) {
|
guideUserService.findEnabledById(guideId);
|
GuideReceivingSession session = sessionMapper.selectOne(new LambdaQueryWrapper<GuideReceivingSession>()
|
.eq(GuideReceivingSession::getGuideId, guideId)
|
.in(GuideReceivingSession::getStatus, "RECEIVING", "ASSIGNED", "IN_SERVICE")
|
.orderByDesc(GuideReceivingSession::getId).last("LIMIT 1"));
|
if (session == null) {
|
return null;
|
}
|
if (hasActiveServiceOrder(session)) {
|
return session;
|
}
|
|
GuideRealtimeStatus realtimeStatus = realtimeStatusMapper.selectById(guideId);
|
if (realtimeStatus == null
|
|| !Integer.valueOf(1).equals(realtimeStatus.getOnlineStatus())
|
|| !Integer.valueOf(1).equals(realtimeStatus.getAvailableStatus())) {
|
return null;
|
}
|
return session;
|
}
|
|
@Transactional
|
public void stop(Long guideId) {
|
guideUserService.findEnabledById(guideId);
|
stopActiveSessions(guideId);
|
realtimeStatusMapper.update(null, new LambdaUpdateWrapper<GuideRealtimeStatus>()
|
.eq(GuideRealtimeStatus::getGuideId, guideId)
|
.set(GuideRealtimeStatus::getOnlineStatus, 0)
|
.set(GuideRealtimeStatus::getAvailableStatus, 0));
|
}
|
|
@Transactional
|
public void finish(Long guideId) {
|
guideUserService.findEnabledById(guideId);
|
GuideReceivingSession session = sessionMapper.selectOne(new LambdaQueryWrapper<GuideReceivingSession>()
|
.eq(GuideReceivingSession::getGuideId, guideId)
|
.eq(GuideReceivingSession::getStatus, "IN_SERVICE")
|
.orderByDesc(GuideReceivingSession::getId).last("LIMIT 1"));
|
if (session == null) {
|
throw new BusinessException(400, "no active service session");
|
}
|
|
LocalDateTime now = LocalDateTime.now();
|
if (!sessionTransitionService.completeSession(session, now)) {
|
throw new BusinessException(400, "no active service order");
|
}
|
}
|
|
private Set<String> configuredScenicNames(GuideUser guide) {
|
if (guide.getTeamId() == null) {
|
return guideScenicMapper.selectList(new LambdaQueryWrapper<GuideScenicConfig>()
|
.eq(GuideScenicConfig::getGuideId, guide.getId())).stream()
|
.map(GuideScenicConfig::getScenicName).collect(Collectors.toSet());
|
}
|
return teamScenicMapper.selectList(new LambdaQueryWrapper<GuideTeamScenicConfig>()
|
.eq(GuideTeamScenicConfig::getTeamId, guide.getTeamId())).stream()
|
.map(GuideTeamScenicConfig::getScenicName).collect(Collectors.toSet());
|
}
|
|
private OperationScenicSpot requireAllowedScenic(GuideUser guide, Long scenicId) {
|
OperationScenicSpot scenic = scenicMapper.selectOne(new LambdaQueryWrapper<OperationScenicSpot>()
|
.eq(OperationScenicSpot::getId, scenicId).eq(OperationScenicSpot::getStatus, 1));
|
if (scenic == null) throw new BusinessException(404, "scenic spot is unavailable");
|
if (!configuredScenicNames(guide).contains(scenic.getScenicName())) {
|
throw new BusinessException(403, "guide is not configured for this scenic spot");
|
}
|
return scenic;
|
}
|
|
private void requireMeetingPoint(Long meetingPointId, Long scenicId) {
|
long count = meetingPointMapper.selectCount(new LambdaQueryWrapper<ScenicMeetingPoint>()
|
.eq(ScenicMeetingPoint::getId, meetingPointId).eq(ScenicMeetingPoint::getScenicSpotId, scenicId)
|
.eq(ScenicMeetingPoint::getStatus, 1));
|
if (count == 0) throw new BusinessException(400, "meeting point does not belong to scenic spot");
|
}
|
|
private void validateServiceTypes(GuideUser guide, Long scenicId, String mode, Set<String> serviceTypes) {
|
if (serviceTypes.isEmpty()) throw new BusinessException(400, "select at least one service type");
|
Set<String> configured = pricingMapper.selectList(new LambdaQueryWrapper<ScenicPricing>()
|
.eq(ScenicPricing::getScenicSpotId, scenicId)).stream()
|
.map(ScenicPricing::getServiceType).collect(Collectors.toSet());
|
for (String type : serviceTypes) {
|
boolean modeMatches = "ALL".equals(mode)
|
? (type.startsWith("GROUP_") || type.startsWith("PRIVATE_"))
|
: type.startsWith(mode + "_");
|
if (!modeMatches || !configured.contains(type)) {
|
throw new BusinessException(400, "service type does not match receiving mode or scenic configuration");
|
}
|
if (type.endsWith("_PREMIUM") && !premiumEnabled(guide, platformSettingsService.getSettings())) {
|
throw new BusinessException(403, "premium service requirements are not met");
|
}
|
}
|
}
|
|
private boolean premiumEnabled(GuideUser guide, PlatformSettingsResponse settings) {
|
if (guide == null) {
|
return false;
|
}
|
if (Integer.valueOf(1).equals(guide.getPremiumEnabled())
|
|| Integer.valueOf(1).equals(guide.getAutoDisableWhitelisted())) {
|
return true;
|
}
|
if (settings == null) {
|
return false;
|
}
|
long orderCount = guide.getAcceptedOrderCount() == null ? 0 : guide.getAcceptedOrderCount();
|
BigDecimal rating = guide.getRating() == null ? BigDecimal.ZERO : guide.getRating();
|
BigDecimal requiredRating = settings.getPreciseDispatchRating() == null ? BigDecimal.ZERO : settings.getPreciseDispatchRating();
|
return orderCount >= value(settings.getPreciseDispatchOrderCount()) && rating.compareTo(requiredRating) >= 0;
|
}
|
|
private void stopActiveSessions(Long guideId) {
|
sessionMapper.update(null, new LambdaUpdateWrapper<GuideReceivingSession>()
|
.eq(GuideReceivingSession::getGuideId, guideId)
|
.in(GuideReceivingSession::getStatus, "RECEIVING", "ASSIGNED")
|
.set(GuideReceivingSession::getStatus, "STOPPED"));
|
|
// 订单取消后可能遗留 IN_SERVICE 会话；无未完成订单时才安全关闭。
|
long activeOrderCount = orderMapper.selectCount(new LambdaQueryWrapper<TourOrder>()
|
.eq(TourOrder::getGuideId, guideId)
|
.in(TourOrder::getStatus,
|
OrderStatus.PENDING_ACCEPT.getCode(),
|
OrderStatus.PENDING_MEETING.getCode(),
|
OrderStatus.IN_SERVICE.getCode()));
|
if (activeOrderCount == 0) {
|
sessionMapper.update(null, new LambdaUpdateWrapper<GuideReceivingSession>()
|
.eq(GuideReceivingSession::getGuideId, guideId)
|
.eq(GuideReceivingSession::getStatus, "IN_SERVICE")
|
.set(GuideReceivingSession::getStatus, "STOPPED"));
|
}
|
}
|
|
private boolean hasActiveServiceOrder(GuideReceivingSession session) {
|
return orderMapper.selectCount(new LambdaQueryWrapper<TourOrder>()
|
.eq(TourOrder::getGuideId, session.getGuideId())
|
.eq(TourOrder::getReceivingSessionId, session.getId())
|
.in(TourOrder::getStatus,
|
OrderStatus.PENDING_MEETING.getCode(),
|
OrderStatus.IN_SERVICE.getCode())) > 0;
|
}
|
|
private void saveRealtimeStatus(Long guideId, GuideReceivingStartRequest request, Long scenicId) {
|
GuideRealtimeStatus status = realtimeStatusMapper.selectById(guideId);
|
boolean insert = status == null;
|
if (insert) { status = new GuideRealtimeStatus(); status.setGuideId(guideId); }
|
status.setScenicSpotId(scenicId);
|
status.setMeetingPointId(request.getMeetingPointId());
|
status.setLongitude(request.getLongitude());
|
status.setLatitude(request.getLatitude());
|
status.setOnlineStatus(1);
|
status.setAvailableStatus(1);
|
status.setLastLocationAt(LocalDateTime.now());
|
if (insert) realtimeStatusMapper.insert(status); else realtimeStatusMapper.updateById(status);
|
}
|
|
private String normalizeMode(String mode) {
|
if (!"ALL".equals(mode) && !"GROUP".equals(mode) && !"PRIVATE".equals(mode)) {
|
throw new BusinessException(400, "invalid receiving mode");
|
}
|
return mode;
|
}
|
|
private long value(Integer number) { return number == null ? 0L : number.longValue(); }
|
|
private int positive(Integer number, int fallback) {
|
return number == null || number < 1 ? fallback : number;
|
}
|
}
|
