package com.tourguide.modules.finance.service;
|
|
import com.alibaba.fastjson.JSONObject;
|
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.GuideWithdrawalCreateRequest;
|
import com.tourguide.modules.finance.dto.GuideWithdrawalSummaryResponse;
|
import com.tourguide.modules.finance.dto.WithdrawalResponse;
|
import com.tourguide.modules.finance.entity.GuideWithdrawal;
|
import com.tourguide.modules.finance.entity.GuideWithdrawalAccount;
|
import com.tourguide.modules.finance.mapper.GuideWithdrawalMapper;
|
import com.tourguide.modules.user.entity.GuideUser;
|
import com.tourguide.modules.user.entity.GuideTeam;
|
import com.tourguide.modules.user.mapper.GuideTeamMapper;
|
import com.tourguide.modules.user.mapper.GuideUserMapper;
|
import com.tourguide.modules.user.service.GuideUserService;
|
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.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.concurrent.ThreadLocalRandom;
|
import java.util.stream.Collectors;
|
|
/** 导游提现申请、审核发起和斗拱到账回调。 */
|
@Service
|
public class GuideWithdrawalService {
|
private static final DateTimeFormatter NO_TIME_FORMAT = DateTimeFormatter.ofPattern("yyyyMMddHHmmssSSS");
|
private static final String STATUS_PENDING = "PENDING";
|
private static final String STATUS_APPROVED = "APPROVED";
|
private static final String STATUS_REJECTED = "REJECTED";
|
|
private final GuideWithdrawalMapper withdrawalMapper;
|
private final GuideSettlementService settlementService;
|
private final GuideUserService guideUserService;
|
private final GuideWithdrawableBalanceService balanceService;
|
private final GuideWithdrawalStateService stateService;
|
private final GuideWithdrawalPayoutService payoutService;
|
private final GuideTeamMapper teamMapper;
|
private final GuideUserMapper guideUserMapper;
|
|
public GuideWithdrawalService(GuideWithdrawalMapper withdrawalMapper,
|
GuideSettlementService settlementService,
|
GuideUserService guideUserService,
|
GuideWithdrawableBalanceService balanceService,
|
GuideWithdrawalStateService stateService,
|
GuideWithdrawalPayoutService payoutService,
|
GuideTeamMapper teamMapper,
|
GuideUserMapper guideUserMapper) {
|
this.withdrawalMapper = withdrawalMapper;
|
this.settlementService = settlementService;
|
this.guideUserService = guideUserService;
|
this.balanceService = balanceService;
|
this.stateService = stateService;
|
this.payoutService = payoutService;
|
this.teamMapper = teamMapper;
|
this.guideUserMapper = guideUserMapper;
|
}
|
|
public GuideWithdrawalSummaryResponse summary(Long guideId) {
|
try {
|
settlementService.requireApproved(guideId);
|
GuideUser guide = guideUserService.findEnabledById(guideId);
|
GuideTeam collectionTeam = findCollectionTeam(guide);
|
return new GuideWithdrawalSummaryResponse(collectionTeam == null
|
? balanceService.getAvailableAmount(guideId)
|
: balanceService.getAvailableTeamAmount(collectionTeam.getId()));
|
} catch (BusinessException exception) {
|
if (exception.getCode() == 409) {
|
return new GuideWithdrawalSummaryResponse(money(BigDecimal.ZERO));
|
}
|
throw exception;
|
}
|
}
|
|
public PageResponse<WithdrawalResponse> page(Long guideId, long page, long size) {
|
guideUserService.findEnabledById(guideId);
|
long safePage = Math.max(page, 1);
|
long safeSize = Math.min(Math.max(size, 1), 100);
|
Page<GuideWithdrawal> result = withdrawalMapper.selectPage(
|
new Page<GuideWithdrawal>(safePage, safeSize),
|
new LambdaQueryWrapper<GuideWithdrawal>()
|
.eq(GuideWithdrawal::getGuideId, guideId)
|
.orderByDesc(GuideWithdrawal::getAppliedAt)
|
.orderByDesc(GuideWithdrawal::getId));
|
return new PageResponse<WithdrawalResponse>(result.getRecords().stream()
|
.map(WithdrawalResponse::new).collect(Collectors.toList()),
|
result.getTotal(), result.getCurrent(), result.getSize());
|
}
|
|
@Transactional
|
public WithdrawalResponse create(Long guideId, GuideWithdrawalCreateRequest request) {
|
GuideUser guide = guideUserMapper.selectForUpdate(guideId);
|
if (guide == null || !Integer.valueOf(1).equals(guide.getStatus())) {
|
throw new BusinessException(401, "导游用户不存在或已停用");
|
}
|
GuideWithdrawalAccount account = settlementService.requireApprovedCardForUpdate(
|
guideId, request.getBankCardId());
|
BigDecimal amount = money(request.getAmount());
|
if (amount.compareTo(BigDecimal.ZERO) <= 0) {
|
throw new BusinessException(400, "提现金额必须大于0");
|
}
|
GuideTeam collectionTeam = findCollectionTeam(guide);
|
boolean debited = collectionTeam == null
|
? balanceService.debit(guideId, amount)
|
: balanceService.debitTeam(collectionTeam.getId(), amount);
|
if (!debited) {
|
throw new BusinessException(409, "提现金额不能超过当前可提金额");
|
}
|
GuideWithdrawal withdrawal = new GuideWithdrawal();
|
withdrawal.setWithdrawalNo(generateWithdrawalNo());
|
withdrawal.setGuideId(guideId);
|
withdrawal.setTeamId(collectionTeam == null ? null : collectionTeam.getId());
|
withdrawal.setGuideName(StringUtils.hasText(guide.getRealName())
|
? guide.getRealName() : guide.getUsername());
|
withdrawal.setGuideMobile(guide.getMobile());
|
withdrawal.setAmount(amount);
|
withdrawal.setBankCardId(account.getId());
|
withdrawal.setBankName(account.getBankName());
|
withdrawal.setCardMasked(maskCard(account.getBankCardCode()));
|
withdrawal.setStatus(STATUS_PENDING);
|
withdrawal.setAppliedAt(LocalDateTime.now());
|
withdrawal.setCreatedAt(LocalDateTime.now());
|
withdrawal.setUpdatedAt(LocalDateTime.now());
|
withdrawalMapper.insert(withdrawal);
|
return new WithdrawalResponse(withdrawal);
|
}
|
|
public WithdrawalResponse process(Long id, String status, String remark, String processor) {
|
if (STATUS_REJECTED.equals(status)) {
|
return stateService.reject(id, remark, processor);
|
}
|
if (!STATUS_APPROVED.equals(status)) throw new BusinessException(400, "提现处理状态不正确");
|
return payoutService.approve(id, remark, processor);
|
}
|
|
@Transactional
|
public boolean handleCallback(JSONObject body) {
|
List<String> requestSequences = callbackSequences(body);
|
if (requestSequences.isEmpty()) {
|
throw new BusinessException(400, "汇付提现回调缺少请求流水号");
|
}
|
String requestSequence = null;
|
GuideWithdrawal withdrawal = null;
|
for (String candidate : requestSequences) {
|
GuideWithdrawal matched = withdrawalMapper.selectByPayoutSequenceForUpdate(candidate);
|
if (matched != null) {
|
requestSequence = candidate;
|
withdrawal = matched;
|
break;
|
}
|
}
|
if (withdrawal == null) throw new BusinessException(404, "提现申请不存在");
|
if (STATUS_APPROVED.equals(withdrawal.getStatus()) || STATUS_REJECTED.equals(withdrawal.getStatus())) {
|
return false;
|
}
|
boolean processing = GuideWithdrawalStateService.PROCESSING.equals(withdrawal.getStatus());
|
boolean recoverableTransferred = GuideWithdrawalStateService.TRANSFERRED.equals(withdrawal.getStatus())
|
&& (requestSequence.equals(withdrawal.getCashReqSeqId())
|
|| requestSequence.equals(withdrawal.getCashHfSeqId()));
|
if (!processing && !recoverableTransferred) {
|
return false;
|
}
|
validateCallback(body, withdrawal);
|
String transStatus = first(body, "trans_stat", "cash_stat", "cash_status",
|
"trans_status", "status");
|
LocalDateTime now = LocalDateTime.now();
|
if (isFailure(body, transStatus)) {
|
String message = "导游账户取现失败：" + callbackMessage(body);
|
if (withdrawalMapper.resetCashForRetry(withdrawal.getId(), message, now, now) != 1) {
|
throw new BusinessException(500, "提现回调状态更新失败");
|
}
|
withdrawal.setStatus(GuideWithdrawalStateService.TRANSFERRED);
|
withdrawal.setCashReqSeqId(null);
|
withdrawal.setCashReqDate(null);
|
withdrawal.setCashHfSeqId(null);
|
withdrawal.setPayoutMessage(message);
|
withdrawal.setProcessedAt(now);
|
withdrawal.setUpdatedAt(now);
|
return true;
|
}
|
String hfSeqId = first(body, "hf_seq_id", "trans_seq_id", "cash_hf_seq_id");
|
if (StringUtils.hasText(hfSeqId)) withdrawal.setCashHfSeqId(hfSeqId);
|
if (isSuccess(transStatus)) {
|
withdrawal.setStatus(STATUS_APPROVED);
|
withdrawal.setPayoutMessage("取现到账成功");
|
withdrawal.setProcessedAt(now);
|
} else {
|
withdrawal.setStatus(GuideWithdrawalStateService.PROCESSING);
|
withdrawal.setPayoutMessage("导游账户取现结果待确认：" + callbackMessage(body));
|
}
|
withdrawal.setUpdatedAt(now);
|
if (withdrawalMapper.updateById(withdrawal) != 1) {
|
throw new BusinessException(500, "提现回调状态更新失败");
|
}
|
return true;
|
}
|
|
private void validateCallback(JSONObject body, GuideWithdrawal withdrawal) {
|
GuideWithdrawalAccount account = settlementService.findCurrent(withdrawal.getGuideId());
|
String callbackHuifuId = first(body, "huifu_id", "out_huifu_id");
|
if (account == null || !StringUtils.hasText(callbackHuifuId)
|
|| !callbackHuifuId.equals(account.getHuifuId())) {
|
throw new BusinessException(400, "汇付提现回调账户不匹配");
|
}
|
String amountText = first(body, "cash_amt", "trans_amt", "ord_amt");
|
if (StringUtils.hasText(amountText)) {
|
try {
|
if (withdrawal.getAmount().compareTo(new BigDecimal(amountText)) != 0) {
|
throw new BusinessException(409, "汇付提现回调金额不匹配");
|
}
|
} catch (NumberFormatException exception) {
|
throw new BusinessException(400, "汇付提现回调金额格式错误");
|
}
|
}
|
}
|
|
private String callbackMessage(JSONObject body) {
|
String message = first(body, "resp_desc", "fail_reason", "failure_reason");
|
return StringUtils.hasText(message) ? message : "斗拱未返回终态说明";
|
}
|
|
private String generateWithdrawalNo() {
|
return "WD" + LocalDateTime.now().format(NO_TIME_FORMAT)
|
+ String.format("%04d", ThreadLocalRandom.current().nextInt(10000));
|
}
|
|
private GuideTeam findCollectionTeam(GuideUser guide) {
|
if (guide == null || guide.getTeamId() == null) return null;
|
GuideTeam team = teamMapper.selectById(guide.getTeamId());
|
return team != null && guide.getId().equals(team.getCollectionGuideId()) ? team : null;
|
}
|
|
private String maskCard(String cardNumber) {
|
if (!StringUtils.hasText(cardNumber)) return "";
|
String value = cardNumber.trim();
|
return "****" + value.substring(Math.max(0, value.length() - 4));
|
}
|
|
private BigDecimal money(BigDecimal value) {
|
return (value == null ? BigDecimal.ZERO : value).setScale(2, RoundingMode.HALF_UP);
|
}
|
|
private boolean isSuccess(String status) {
|
return "S".equalsIgnoreCase(status) || "SUCCESS".equalsIgnoreCase(status)
|
|| "SUCCEEDED".equalsIgnoreCase(status);
|
}
|
|
private boolean isFailure(JSONObject body, String status) {
|
if ("F".equalsIgnoreCase(status) || "FAIL".equalsIgnoreCase(status)
|
|| "FAILED".equalsIgnoreCase(status)) {
|
return true;
|
}
|
String responseCode = first(body, "resp_code", "code");
|
return StringUtils.hasText(responseCode)
|
&& !"00000000".equals(responseCode)
|
&& !"00000100".equals(responseCode);
|
}
|
|
private String first(JSONObject body, String... keys) {
|
if (body == null) return null;
|
for (String key : keys) {
|
String value = body.getString(key);
|
if (StringUtils.hasText(value)) return value;
|
}
|
JSONObject data = body.getJSONObject("data");
|
if (data != null) return first(data, keys);
|
String dataText = body.getString("data");
|
if (StringUtils.hasText(dataText)) {
|
try {
|
JSONObject nested = JSONObject.parseObject(dataText);
|
return nested == null ? null : first(nested, keys);
|
} catch (RuntimeException ignored) {
|
// 非 JSON 包装直接按字段缺失处理。
|
}
|
}
|
return null;
|
}
|
|
private List<String> callbackSequences(JSONObject body) {
|
List<String> sequences = new ArrayList<>();
|
collectCallbackSequences(body, sequences);
|
return sequences;
|
}
|
|
private void collectCallbackSequences(JSONObject body, List<String> sequences) {
|
if (body == null) return;
|
String[] keys = {"req_seq_id", "org_req_seq_id", "cash_req_seq_id", "withdrawal_no",
|
"hf_seq_id", "trans_seq_id", "cash_hf_seq_id"};
|
for (String key : keys) {
|
String value = body.getString(key);
|
if (StringUtils.hasText(value) && !sequences.contains(value)) sequences.add(value);
|
}
|
JSONObject data = body.getJSONObject("data");
|
if (data != null) {
|
collectCallbackSequences(data, sequences);
|
return;
|
}
|
String dataText = body.getString("data");
|
if (StringUtils.hasText(dataText)) {
|
try {
|
JSONObject nested = JSONObject.parseObject(dataText);
|
collectCallbackSequences(nested, sequences);
|
} catch (RuntimeException ignored) {
|
// 非 JSON 包装继续使用顶层字段。
|
}
|
}
|
}
|
}
|
