package com.talentcard.server.business.order;
|
|
import java.util.List;
|
import java.util.Map;
|
|
import com.talentcard.server.business.BusinessIdGenerator;
|
import com.talentcard.server.business.DatabaseRows;
|
import com.talentcard.server.business.payment.PaymentFundConfirmationService;
|
import com.talentcard.server.common.BusinessException;
|
import com.talentcard.server.common.ErrorCode;
|
import org.springframework.jdbc.core.JdbcTemplate;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
/**
|
* 订单核销的唯一实现。
|
*
|
* <p>「订单被核销」这件事要做三件必须一起发生的事：把订单置为已核销、留下核销记录、把延迟入账的钱
|
* 确认给商户。此前这三件事分散在商户端订单管理、扫码确认核销、后台核销三处各写一遍，结果是漏挂资金确认
|
* （扫码核销那条路线上钱会一直冻在通道延迟户）。
|
*
|
* <p>因此所有会核销订单的入口都必须经过这里：
|
* <ul>
|
* <li>商户端订单管理、扫码确认核销：{@link #verifyByMerchant}；</li>
|
* <li>支付即核销的到店消费订单：{@link #recordAutomaticVerification}（核销由支付完成，
|
* 这里只补核销记录并确认资金）。</li>
|
* </ul>
|
*/
|
@Service
|
public class OrderVerificationService {
|
|
/** 支付即核销：到店消费订单在支付成功时已经由支付流程置为已核销。 */
|
public static final String STORE_CONSUME_VERIFY_TYPE = "STORE_CONSUME";
|
|
private final JdbcTemplate jdbc;
|
private final OrderFundBoundaryService orderFundBoundary;
|
private final PaymentFundConfirmationService fundConfirmation;
|
|
public OrderVerificationService(JdbcTemplate jdbc, OrderFundBoundaryService orderFundBoundary,
|
PaymentFundConfirmationService fundConfirmation) {
|
this.jdbc = jdbc;
|
this.orderFundBoundary = orderFundBoundary;
|
this.fundConfirmation = fundConfirmation;
|
}
|
|
/**
|
* 核销一笔已支付订单：写入核销记录、置为已核销、确认资金、结束扫码尝试。
|
*
|
* <p>幂等：订单已被核销时不再写第二条记录，返回已有的核销记录号。调用方负责前置校验
|
* （订单属于该商户等），行锁与资金状态复查在方法内完成。
|
*
|
* <p>参数用商户/门店/操作员三个 id 而不是 {@code MerchantPrincipal}，因为扫码核销、订单管理、
|
* 后台核销三处拿到的身份来源不同，但核销这件事完全相同。
|
*
|
* @param attemptId 扫码尝试的主键；不来自扫码的核销传 {@code null}
|
* @param idempotencyKey 调用方的幂等键；没有则传 {@code null}
|
* @return 核销记录号；空串表示这笔订单已经被别的入口核销过且没有可用记录
|
*/
|
@Transactional
|
public String verifyByMerchant(long merchantId, Long storeId, Long staffId, long orderId, String verifyType,
|
long verifyAmount, long subsidyAmount, String remark, Long attemptId,
|
String idempotencyKey) {
|
return verifyByMerchant(merchantId, storeId, staffId, orderId, verifyType, verifyAmount, subsidyAmount,
|
remark, attemptId, idempotencyKey, null);
|
}
|
|
/**
|
* 同 {@link #verifyByMerchant(long, Long, Long, long, String, long, long, String, Long, String)}，
|
* 并可限定扫码码的有效期。
|
*
|
* @param credentialExpiresAt 扫码码有效期；非空且已过期时拒绝核销（持码人重新扫码即可）。
|
* 来自订单列表的直接核销传 {@code null}：那条路不依赖扫码码。
|
*/
|
@Transactional
|
public String verifyByMerchant(long merchantId, Long storeId, Long staffId, long orderId, String verifyType,
|
long verifyAmount, long subsidyAmount, String remark, Long attemptId,
|
String idempotencyKey, java.time.LocalDateTime credentialExpiresAt) {
|
OrderFundBoundaryService.LockedOrder locked = orderFundBoundary.lock(orderId);
|
// 先判订单本身能不能核销（未支付/已退款），再判扫码码是否过期：
|
// 否则一个未支付订单拿着过期码会报"码已失效"，掩盖真正的业务原因。
|
locked.requireVerifiable();
|
if (credentialExpiresAt != null && !credentialExpiresAt.isAfter(java.time.LocalDateTime.now())) {
|
throw new BusinessException(ErrorCode.CONFLICT, "核销凭证已失效，请重新扫码");
|
}
|
if (attemptId != null) {
|
// 扫码核销要消费掉这次的订单核销码，否则同一个码可以被反复用来核销。
|
jdbc.update("""
|
update order_dynamic_verification_code set status = 1
|
where order_id = ? and status in (0, 2)
|
""", orderId);
|
}
|
|
int updated = jdbc.update("update benefit_order set verify_status = 1 where id = ? and verify_status = 0", orderId);
|
if (updated != 1) {
|
// 并发下另一个入口已经核销：沿用它的核销记录，不重复记账。
|
return existingVerifyNo(orderId);
|
}
|
|
Map<String, Object> order = orderRow(orderId);
|
String verifyNo = insertRecord(merchantId, storeId, staffId,
|
orderId, number(order.get("talentId")), number(order.get("cardId")), number(order.get("benefitId")),
|
verifyType, verifyAmount, subsidyAmount, remark, idempotencyKey);
|
finishAttempt(attemptId, verifyNo);
|
// 核销通过后把钱放给商户：延迟入账的支付此前停在通道「待确认」，确认成功商户才真正拿到钱。
|
fundConfirmation.confirmForOrder(orderId);
|
return verifyNo;
|
}
|
|
/**
|
* 支付即核销：到店消费订单在支付成功那一刻就已经核销，这里补上缺失的核销记录并确认资金。
|
*
|
* <p>不重复置位订单状态（支付流程已经置过），只做幂等的补记；没有核销记录的订单才会补，
|
* 因此重复调用不会产生第二条记录。没有这一步，到店消费的核销在数据里就没有任何凭证。
|
*/
|
@Transactional
|
public void recordAutomaticVerification(long orderId, java.time.LocalDateTime verifiedAt) {
|
List<Map<String, Object>> orders = DatabaseRows.normalize(jdbc.queryForList("""
|
select id, talent_id, card_id, benefit_id, merchant_id, store_id, order_no, pay_amount, subsidy_amount
|
from benefit_order
|
where id = ? and deleted = 0 and order_status = 1 and verify_status = 1
|
limit 1
|
""", orderId));
|
if (orders.isEmpty()) return;
|
Map<String, Object> order = orders.get(0);
|
if (hasVerifyRecord(orderId)) {
|
fundConfirmation.confirmForOrder(orderId);
|
return;
|
}
|
// 支付回调没有操作员身份，staff_id 留空；记录类型标明这是支付即核销。
|
insertRecord(number(order.get("merchantId")), number(order.get("storeId")), null,
|
orderId, number(order.get("talentId")), number(order.get("cardId")), number(order.get("benefitId")),
|
STORE_CONSUME_VERIFY_TYPE, value(order.get("payAmount")), value(order.get("subsidyAmount")),
|
"支付即核销（到店消费）", null);
|
// 记录时间对齐支付完成时间，便于与支付流水对齐核对。
|
jdbc.update("update verify_record set verify_time = ? where order_id = ? and verify_type = ?",
|
verifiedAt, orderId, STORE_CONSUME_VERIFY_TYPE);
|
fundConfirmation.confirmForOrder(orderId);
|
}
|
|
private boolean hasVerifyRecord(long orderId) {
|
Integer count = jdbc.queryForObject(
|
"select count(*) from verify_record where order_id = ? and status = 1", Integer.class, orderId);
|
return count != null && count > 0;
|
}
|
|
private String existingVerifyNo(long orderId) {
|
List<Map<String, Object>> records = DatabaseRows.normalize(jdbc.queryForList(
|
"select verify_no from verify_record where order_id = ? and status = 1 order by id asc limit 1", orderId));
|
return records.isEmpty() ? "" : String.valueOf(records.get(0).get("verifyNo"));
|
}
|
|
private String insertRecord(Long merchantId, Long storeId, Long staffId, long orderId, Long talentId, Long cardId,
|
Long benefitId, String verifyType, long verifyAmount, long subsidyAmount, String remark,
|
String idempotencyKey) {
|
String verifyNo = BusinessIdGenerator.next("V");
|
jdbc.update("""
|
insert into verify_record(verify_no, order_id, talent_id, card_id, benefit_id, merchant_id, store_id,
|
staff_id, verify_type, verify_amount, subsidy_amount, remark, idempotency_key)
|
values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
""", verifyNo, orderId, talentId, cardId, benefitId, merchantId, storeId, staffId,
|
verifyType, verifyAmount, subsidyAmount, remark,
|
idempotencyKey == null || idempotencyKey.isBlank() ? null : idempotencyKey.trim());
|
return verifyNo;
|
}
|
|
private void finishAttempt(Long attemptId, String verifyNo) {
|
if (attemptId == null) return;
|
jdbc.update("""
|
update merchant_verification_attempt
|
set status = 1, verify_no = ?, confirmed_at = now()
|
where id = ? and status = 0
|
""", verifyNo, attemptId);
|
}
|
|
private Map<String, Object> orderRow(long orderId) {
|
List<Map<String, Object>> rows = DatabaseRows.normalize(jdbc.queryForList("""
|
select id, talent_id, card_id, benefit_id from benefit_order where id = ? limit 1
|
""", orderId));
|
return rows.isEmpty() ? Map.of() : rows.get(0);
|
}
|
|
private Long number(Object value) {
|
return value instanceof Number number ? number.longValue() : null;
|
}
|
|
private long value(Object value) {
|
return value instanceof Number number ? number.longValue() : 0L;
|
}
|
}
|
