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.mapper.TourOrderMapper;
|
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.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.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;
|
|
public AdminFinanceService(TourOrderMapper orderMapper, GuideWithdrawalMapper withdrawalMapper,
|
GuideUserMapper guideUserMapper, GuideTeamMapper guideTeamMapper,
|
PlatformSettingsService settingsService,
|
GuideWithdrawalService guideWithdrawalService) {
|
this.orderMapper = orderMapper;
|
this.withdrawalMapper = withdrawalMapper;
|
this.guideUserMapper = guideUserMapper;
|
this.guideTeamMapper = guideTeamMapper;
|
this.settingsService = settingsService;
|
this.guideWithdrawalService = guideWithdrawalService;
|
}
|
|
public FinanceLedgerPageResponse ledger(long page, long size, String direction, String keyword,
|
String paymentMethod, LocalDate startDate, LocalDate endDate) {
|
boolean refund = "REFUND".equals(direction);
|
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, refund, settings, guides.get(order.getGuideId()), teams))
|
.collect(Collectors.toList());
|
BigDecimal totalAmount = orderMapper.selectList(
|
ledgerQuery(refund, keyword, paymentMethod, startDate, endDate)).stream()
|
.map(order -> refund ? safeAmount(order.getRefundAmount()) : paymentAmount(order))
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
if (refund) totalAmount = totalAmount.negate();
|
return new FinanceLedgerPageResponse(
|
new PageResponse<FinanceLedgerResponse>(records, result.getTotal(), result.getCurrent(), result.getSize()),
|
totalAmount.setScale(2, RoundingMode.HALF_UP));
|
}
|
|
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 FinanceLedgerResponse toLedger(TourOrder order, boolean refund, PlatformSettingsResponse settings,
|
GuideUser guide, Map<Long, String> teams) {
|
BigDecimal amount = refund ? safeAmount(order.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) {
|
platformIncome = platformIncome.negate();
|
guideIncome = guideIncome.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);
|
return new FinanceLedgerResponse(order.getId(),
|
refund ? order.getRefundOrderNo() : "IN" + order.getOrderNo(), order.getOrderNo(),
|
paymentAmount(order), platformIncome, guideIncome, guideName(order, guide), guideMobile(order, guide),
|
teamName, refund ? order.getRefundOrderNo() : order.getPaymentOrderNo(),
|
refund ? order.getRefundMethod() : order.getPaymentMethod(), amount,
|
refund ? order.getRefundTime() : order.getPaymentTime(), settledAt);
|
}
|
|
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;
|
}
|
}
|
