package com.tourguide.modules.finance.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.finance.dto.FinanceLedgerPageResponse;
|
import com.tourguide.modules.finance.dto.FinanceLedgerResponse;
|
import com.tourguide.modules.finance.dto.WithdrawalProcessRequest;
|
import com.tourguide.modules.finance.dto.WithdrawalResponse;
|
import com.tourguide.modules.finance.entity.GuideWithdrawal;
|
import com.tourguide.modules.finance.mapper.GuideWithdrawalMapper;
|
import com.tourguide.modules.operation.dto.PlatformSettingsResponse;
|
import com.tourguide.modules.operation.service.PlatformSettingsService;
|
import com.tourguide.modules.order.entity.TourOrder;
|
import com.tourguide.modules.order.entity.TourOrderRefund;
|
import com.tourguide.modules.order.mapper.TourOrderMapper;
|
import com.tourguide.modules.order.mapper.TourOrderRefundMapper;
|
import com.tourguide.modules.user.entity.GuideTeam;
|
import com.tourguide.modules.user.entity.GuideUser;
|
import com.tourguide.modules.user.mapper.GuideTeamMapper;
|
import com.tourguide.modules.user.mapper.GuideUserMapper;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.StringUtils;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
|
@Service
|
public class AdminFinanceService {
|
private final TourOrderMapper orderMapper;
|
private final GuideWithdrawalMapper withdrawalMapper;
|
private final GuideUserMapper guideUserMapper;
|
private final GuideTeamMapper guideTeamMapper;
|
private final PlatformSettingsService settingsService;
|
private final GuideWithdrawalService guideWithdrawalService;
|
private final TourOrderRefundMapper refundMapper;
|
|
public AdminFinanceService(TourOrderMapper orderMapper, GuideWithdrawalMapper withdrawalMapper,
|
GuideUserMapper guideUserMapper, GuideTeamMapper guideTeamMapper,
|
PlatformSettingsService settingsService,
|
GuideWithdrawalService guideWithdrawalService) {
|
this(orderMapper, withdrawalMapper, guideUserMapper, guideTeamMapper, settingsService,
|
guideWithdrawalService, null);
|
}
|
|
@Autowired
|
public AdminFinanceService(TourOrderMapper orderMapper, GuideWithdrawalMapper withdrawalMapper,
|
GuideUserMapper guideUserMapper, GuideTeamMapper guideTeamMapper,
|
PlatformSettingsService settingsService,
|
GuideWithdrawalService guideWithdrawalService,
|
TourOrderRefundMapper refundMapper) {
|
this.orderMapper = orderMapper;
|
this.withdrawalMapper = withdrawalMapper;
|
this.guideUserMapper = guideUserMapper;
|
this.guideTeamMapper = guideTeamMapper;
|
this.settingsService = settingsService;
|
this.guideWithdrawalService = guideWithdrawalService;
|
this.refundMapper = refundMapper;
|
}
|
|
public FinanceLedgerPageResponse ledger(long page, long size, String direction, String keyword,
|
String paymentMethod, LocalDate startDate, LocalDate endDate) {
|
boolean refund = "REFUND".equals(direction);
|
if (refund) {
|
return refundLedger(page, size, keyword, paymentMethod, startDate, endDate);
|
}
|
LambdaQueryWrapper<TourOrder> query = ledgerQuery(refund, keyword, paymentMethod, startDate, endDate);
|
Page<TourOrder> result = orderMapper.selectPage(new Page<TourOrder>(page, size), query);
|
PlatformSettingsResponse settings = settingsService.getSettings();
|
Map<Long, GuideUser> guides = loadGuides(result.getRecords());
|
Map<Long, String> teams = loadTeams(result.getRecords(), guides.values());
|
List<FinanceLedgerResponse> records = result.getRecords().stream()
|
.map(order -> toLedger(order, false, settings, guides.get(order.getGuideId()), teams, null))
|
.collect(Collectors.toList());
|
BigDecimal totalAmount = orderMapper.selectList(
|
ledgerQuery(refund, keyword, paymentMethod, startDate, endDate)).stream()
|
.map(this::paymentAmount)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
return new FinanceLedgerPageResponse(
|
new PageResponse<FinanceLedgerResponse>(records, result.getTotal(), result.getCurrent(), result.getSize()),
|
totalAmount.setScale(2, RoundingMode.HALF_UP));
|
}
|
|
private FinanceLedgerPageResponse refundLedger(long page, long size, String keyword,
|
String paymentMethod, LocalDate startDate, LocalDate endDate) {
|
List<TourOrder> orders = orderMapper.selectList(refundOrderQuery(keyword, paymentMethod));
|
PlatformSettingsResponse settings = settingsService.getSettings();
|
Map<Long, GuideUser> guides = loadGuides(orders);
|
Map<Long, String> teams = loadTeams(orders, guides.values());
|
Map<Long, List<TourOrderRefund>> refundRecords = loadRefundRecords(orders);
|
List<FinanceLedgerResponse> records = new ArrayList<FinanceLedgerResponse>();
|
for (TourOrder order : orders) {
|
List<TourOrderRefund> orderRefunds = refundRecords.get(order.getId());
|
if (orderRefunds == null || orderRefunds.isEmpty()) {
|
if (hasLegacyRefund(order) && inRefundDateRange(order.getRefundTime(), startDate, endDate)) {
|
records.add(toLedger(order, true, settings, guides.get(order.getGuideId()), teams, null));
|
}
|
continue;
|
}
|
for (TourOrderRefund refund : orderRefunds) {
|
LocalDateTime refundTime = firstPresent(refund.getRefundTime(), refund.getCreatedAt());
|
if (inRefundDateRange(refundTime, startDate, endDate)) {
|
records.add(toLedger(order, true, settings, guides.get(order.getGuideId()), teams, refund));
|
}
|
}
|
}
|
records.sort((left, right) -> {
|
LocalDateTime leftTime = left.getFlowTime();
|
LocalDateTime rightTime = right.getFlowTime();
|
if (leftTime == null && rightTime != null) return 1;
|
if (leftTime != null && rightTime == null) return -1;
|
if (leftTime != null && rightTime != null) {
|
int timeCompare = rightTime.compareTo(leftTime);
|
if (timeCompare != 0) return timeCompare;
|
}
|
Long leftId = left.getId();
|
Long rightId = right.getId();
|
if (leftId == null && rightId != null) return 1;
|
if (leftId != null && rightId == null) return -1;
|
return leftId == null || rightId == null ? 0 : rightId.compareTo(leftId);
|
});
|
BigDecimal totalAmount = records.stream()
|
.map(FinanceLedgerResponse::getFlowAmount)
|
.map(this::safeAmount)
|
.reduce(BigDecimal.ZERO, BigDecimal::add)
|
.setScale(2, RoundingMode.HALF_UP);
|
long normalizedPage = Math.max(1, page);
|
long normalizedSize = Math.max(1, size);
|
long fromLong = (normalizedPage - 1) * normalizedSize;
|
int from = fromLong >= records.size() ? records.size() : (int) fromLong;
|
long toLong = Math.min((long) records.size(), fromLong + normalizedSize);
|
int to = (int) Math.max(from, toLong);
|
return new FinanceLedgerPageResponse(
|
new PageResponse<FinanceLedgerResponse>(records.subList(from, to), records.size(),
|
normalizedPage, normalizedSize),
|
totalAmount);
|
}
|
|
public PageResponse<WithdrawalResponse> withdrawals(long page, long size, String keyword, String status,
|
LocalDate startDate, LocalDate endDate) {
|
LambdaQueryWrapper<GuideWithdrawal> query = new LambdaQueryWrapper<GuideWithdrawal>();
|
if (StringUtils.hasText(keyword)) {
|
String value = keyword.trim();
|
query.and(wrapper -> wrapper.like(GuideWithdrawal::getWithdrawalNo, value)
|
.or().like(GuideWithdrawal::getGuideName, value)
|
.or().like(GuideWithdrawal::getGuideMobile, value));
|
}
|
query.eq(StringUtils.hasText(status), GuideWithdrawal::getStatus, status)
|
.ge(startDate != null, GuideWithdrawal::getAppliedAt, startDate == null ? null : startDate.atStartOfDay())
|
.lt(endDate != null, GuideWithdrawal::getAppliedAt, endDate == null ? null : endDate.plusDays(1).atStartOfDay())
|
.orderByDesc(GuideWithdrawal::getId);
|
Page<GuideWithdrawal> result = withdrawalMapper.selectPage(new Page<GuideWithdrawal>(page, size), query);
|
return new PageResponse<WithdrawalResponse>(result.getRecords().stream()
|
.map(WithdrawalResponse::new).collect(Collectors.toList()),
|
result.getTotal(), result.getCurrent(), result.getSize());
|
}
|
|
@Transactional
|
public WithdrawalResponse processWithdrawal(Long id, WithdrawalProcessRequest request, String processor) {
|
return guideWithdrawalService.process(id, request.getStatus(), request.getAuditRemark(), processor);
|
}
|
|
private LambdaQueryWrapper<TourOrder> ledgerQuery(boolean refund, String keyword, String paymentMethod,
|
LocalDate startDate, LocalDate endDate) {
|
LambdaQueryWrapper<TourOrder> query = new LambdaQueryWrapper<TourOrder>();
|
if (StringUtils.hasText(keyword)) {
|
String value = keyword.trim();
|
query.and(wrapper -> wrapper.like(TourOrder::getOrderNo, value)
|
.or().like(TourOrder::getPaymentOrderNo, value)
|
.or().like(TourOrder::getRefundOrderNo, value));
|
}
|
if (refund) {
|
query.isNotNull(TourOrder::getRefundTime)
|
.ge(startDate != null, TourOrder::getRefundTime, startDate == null ? null : startDate.atStartOfDay())
|
.lt(endDate != null, TourOrder::getRefundTime, endDate == null ? null : endDate.plusDays(1).atStartOfDay())
|
.orderByDesc(TourOrder::getRefundTime);
|
} else {
|
query.isNotNull(TourOrder::getPaymentTime)
|
.ge(startDate != null, TourOrder::getPaymentTime, startDate == null ? null : startDate.atStartOfDay())
|
.lt(endDate != null, TourOrder::getPaymentTime, endDate == null ? null : endDate.plusDays(1).atStartOfDay())
|
.orderByDesc(TourOrder::getPaymentTime);
|
}
|
query.eq(StringUtils.hasText(paymentMethod), TourOrder::getPaymentMethod, paymentMethod);
|
return query;
|
}
|
|
private LambdaQueryWrapper<TourOrder> refundOrderQuery(String keyword, String paymentMethod) {
|
LambdaQueryWrapper<TourOrder> query = new LambdaQueryWrapper<TourOrder>();
|
if (StringUtils.hasText(keyword)) {
|
String value = keyword.trim();
|
query.and(wrapper -> wrapper.like(TourOrder::getOrderNo, value)
|
.or().like(TourOrder::getPaymentOrderNo, value)
|
.or().like(TourOrder::getRefundOrderNo, value));
|
}
|
query.eq(StringUtils.hasText(paymentMethod), TourOrder::getPaymentMethod, paymentMethod);
|
return query;
|
}
|
|
private Map<Long, List<TourOrderRefund>> loadRefundRecords(List<TourOrder> orders) {
|
if (refundMapper == null || orders == null || orders.isEmpty()) {
|
return Collections.emptyMap();
|
}
|
Set<Long> orderIds = orders.stream()
|
.map(TourOrder::getId)
|
.filter(id -> id != null)
|
.collect(Collectors.toSet());
|
if (orderIds.isEmpty()) {
|
return Collections.emptyMap();
|
}
|
List<TourOrderRefund> records = refundMapper.selectByOrderIds(orderIds);
|
if (records == null || records.isEmpty()) {
|
return Collections.emptyMap();
|
}
|
return records.stream().collect(Collectors.groupingBy(TourOrderRefund::getOrderId));
|
}
|
|
private boolean hasLegacyRefund(TourOrder order) {
|
return order.getRefundAmount() != null || StringUtils.hasText(order.getRefundOrderNo());
|
}
|
|
private boolean inRefundDateRange(LocalDateTime value, LocalDate startDate, LocalDate endDate) {
|
if (value == null) return startDate == null && endDate == null;
|
return (startDate == null || !value.isBefore(startDate.atStartOfDay()))
|
&& (endDate == null || value.isBefore(endDate.plusDays(1).atStartOfDay()));
|
}
|
|
private FinanceLedgerResponse toLedger(TourOrder order, boolean refund, PlatformSettingsResponse settings,
|
GuideUser guide, Map<Long, String> teams,
|
TourOrderRefund refundRecord) {
|
BigDecimal amount = refund
|
? safeAmount(refundRecord == null ? order.getRefundAmount() : refundRecord.getRefundAmount())
|
: paymentAmount(order);
|
BigDecimal orderAmount = paymentAmount(order);
|
BigDecimal guideIncome;
|
BigDecimal platformIncome;
|
if (order.getGuideEarningAmount() != null) {
|
guideIncome = order.getGuideEarningAmount().setScale(2, RoundingMode.HALF_UP);
|
platformIncome = orderAmount.subtract(guideIncome).setScale(2, RoundingMode.HALF_UP);
|
} else {
|
BigDecimal commissionRate = settings.getCommissionRate().movePointLeft(2);
|
platformIncome = orderAmount.multiply(commissionRate).setScale(2, RoundingMode.HALF_UP);
|
guideIncome = orderAmount.subtract(platformIncome).setScale(2, RoundingMode.HALF_UP);
|
}
|
if (refund) {
|
BigDecimal refundRatio = orderAmount.signum() == 0
|
? BigDecimal.ZERO : amount.divide(orderAmount, 10, RoundingMode.HALF_UP);
|
platformIncome = platformIncome.multiply(refundRatio).setScale(2, RoundingMode.HALF_UP).negate();
|
guideIncome = guideIncome.multiply(refundRatio).setScale(2, RoundingMode.HALF_UP).negate();
|
amount = amount.negate();
|
}
|
LocalDateTime settledAt = order.getSettledAt() == null
|
? order.getSettlementDueAt() : order.getSettledAt();
|
Long teamId = order.getCommissionTeamId() != null
|
? order.getCommissionTeamId()
|
: guide == null ? null : guide.getTeamId();
|
String teamName = teamId == null ? "个人导游" : teams.get(teamId);
|
String flowNo = refund
|
? refundRecord == null ? order.getRefundOrderNo() : refundRecord.getRefundOrderNo()
|
: "IN" + order.getOrderNo();
|
String channelFlowNo = refund
|
? StringUtils.hasText(refundRecord == null ? null : refundRecord.getRefundOrderNo())
|
? refundRecord.getRefundOrderNo() : order.getRefundOrderNo()
|
: order.getPaymentOrderNo();
|
String flowMethod = refund
|
? StringUtils.hasText(refundRecord == null ? null : refundRecord.getRefundMethod())
|
? refundRecord.getRefundMethod() : order.getRefundMethod()
|
: order.getPaymentMethod();
|
LocalDateTime flowTime = refund
|
? refundRecord == null
|
? order.getRefundTime() : firstPresent(refundRecord.getRefundTime(), refundRecord.getCreatedAt())
|
: order.getPaymentTime();
|
Long flowId = refund && refundRecord != null && refundRecord.getId() != null
|
? refundRecord.getId() : order.getId();
|
return new FinanceLedgerResponse(flowId, flowNo, order.getOrderNo(),
|
paymentAmount(order), platformIncome, guideIncome, guideName(order, guide), guideMobile(order, guide),
|
teamName, channelFlowNo, flowMethod, amount, flowTime, settledAt);
|
}
|
|
private LocalDateTime firstPresent(LocalDateTime first, LocalDateTime second) {
|
return first == null ? second : first;
|
}
|
|
private String guideName(TourOrder order, GuideUser guide) {
|
return StringUtils.hasText(order.getGuideName())
|
? order.getGuideName() : guide == null ? null
|
: StringUtils.hasText(guide.getRealName()) ? guide.getRealName() : guide.getUsername();
|
}
|
|
private String guideMobile(TourOrder order, GuideUser guide) {
|
return StringUtils.hasText(order.getGuideMobile())
|
? order.getGuideMobile() : guide == null ? null : guide.getMobile();
|
}
|
|
private Map<Long, GuideUser> loadGuides(List<TourOrder> orders) {
|
Set<Long> guideIds = orders.stream().map(TourOrder::getGuideId)
|
.filter(id -> id != null).collect(Collectors.toSet());
|
if (guideIds.isEmpty()) return new HashMap<Long, GuideUser>();
|
return guideUserMapper.selectBatchIds(guideIds).stream()
|
.collect(Collectors.toMap(GuideUser::getId, guide -> guide));
|
}
|
|
private Map<Long, String> loadTeams(List<TourOrder> orders, java.util.Collection<GuideUser> guides) {
|
Set<Long> teamIds = guides.stream().map(GuideUser::getTeamId)
|
.filter(id -> id != null).collect(Collectors.toSet());
|
orders.stream().map(TourOrder::getCommissionTeamId)
|
.filter(id -> id != null).forEach(teamIds::add);
|
if (teamIds.isEmpty()) return new HashMap<Long, String>();
|
return guideTeamMapper.selectBatchIds(teamIds).stream()
|
.collect(Collectors.toMap(GuideTeam::getId, GuideTeam::getTeamName));
|
}
|
|
private BigDecimal paymentAmount(TourOrder order) {
|
return safeAmount(order.getPaymentAmount() == null ? order.getAmount() : order.getPaymentAmount());
|
}
|
|
private BigDecimal safeAmount(BigDecimal amount) {
|
return amount == null ? BigDecimal.ZERO : amount;
|
}
|
}
|
