yml/hfb_sys
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

支付确认强一致化: 订单推进与标 paid 合并为单事务

Browse Source 
confirmPaid 原为「先 ConfirmPaidFromChannel 独立事务推进订单, 再 Updates 标 paid」两步非原子, 崩溃在中间会出现订单已 pending_handoff 但 payment 仍 paying 的不一致窗口, 恢复依赖渠道回调重发而非事务闭环。

改造:
- 新增 ConfirmPaidFromChannelTx(tx, orderID) 让 order 模块共享 payment 模块的外部事务, 订单推进与 payment 标 paid 落进同一事务, 崩溃一致性窗口消除
- NotifyNewConversation 提到事务提交后触发, 避免事务回滚后误发会话通知
- payment_orders 加行锁后 Updates, 防并发回调覆盖写
- 删除未使用的 providerBizNo 死参数

锁顺序全局一致 (order→listing→account→payment), 与 payment_start/refund/Cancel 路径无反向加锁, 无死锁风险。

新增集成测试:
- 正向: 验证 confirmPaid 后 order/listing/account/payment 全部正确推进
- 回滚: payment 更新失败时 order 不残留 pending_handoff, 验证事务原子性

go build/vet/test 通过。
This commit is contained in:
yml
2026-06-14 09:42:26 +08:00
parent c6ff7c1f3a
commit 6ff7692f3e
4 changed files with 270 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/internal/modules/payment/channel_status.go
+33 -13
View File
@@ -4,6 +4,9 @@ import (
"context"
"hfb_sys/backend/internal/model"
"time"
"gorm.io/gorm"
"gorm.io/gorm/clause"
)
func (r *Repository) applyChannelStatus(ctx context.Context, payment *model.PaymentOrder, status string, payTime string, raw map[string]string, source string) error {
@@ -34,24 +37,41 @@ func (r *Repository) updateChannelStatus(ctx context.Context, paymentID uint64,
return r.db.WithContext(ctx).Model(&model.PaymentOrder{}).Where("id = ?", paymentID).Updates(updates).Error
}
func (r *Repository) confirmPaid(ctx context.Context, payment *model.PaymentOrder, status string, paidAt time.Time, raw map[string]string, source string) error {
if payment.Status != "paid" && payment.OrderID != 0 {
if r.orderRepo == nil {
return ErrDependencyUnavailable
var newConvID uint64
err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
if payment.OrderID != 0 {
if r.orderRepo == nil {
return ErrDependencyUnavailable
}
convID, err := r.orderRepo.ConfirmPaidFromChannelTx(tx, payment.OrderID)
if err != nil {
return err
}
newConvID = convID
}
if err := r.orderRepo.ConfirmPaidFromChannel(ctx, payment.OrderID, firstNonEmpty(payment.ProviderOrderID, payment.PaymentNo)); err != nil {
var latest model.PaymentOrder
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&latest, payment.ID).Error; err != nil {
return err
}
updates := map[string]any{
"status": "paid",
"provider_order_id": firstNonEmpty(raw["provider_order_id"], raw["leshua_order_id"], raw["pay_order_no"], raw["trade_no"], latest.ProviderOrderID),
"raw_response": jsonMap(withRawSource(raw, source)),
"paid_at": paidAt,
}
if source == channelSourceNotify {
updates["notified_at"] = time.Now()
}
return tx.Model(&model.PaymentOrder{}).Where("id = ?", payment.ID).Updates(updates).Error
})
if err != nil {
return err
}
updates := map[string]any{
"status": "paid",
"provider_order_id": firstNonEmpty(raw["provider_order_id"], raw["leshua_order_id"], raw["pay_order_no"], raw["trade_no"], payment.ProviderOrderID),
"raw_response": jsonMap(withRawSource(raw, source)),
"paid_at": paidAt,
if newConvID > 0 && r.orderRepo != nil {
r.orderRepo.NotifyNewConversation(newConvID)
}
if source == channelSourceNotify {
updates["notified_at"] = time.Now()
}
return r.db.WithContext(ctx).Model(&model.PaymentOrder{}).Where("id = ?", payment.ID).Updates(updates).Error
return nil
}
func (r *Repository) markPaymentFailed(ctx context.Context, paymentID uint64, raw map[string]string, message string) error {
if raw == nil {
backend/internal/modules/payment/repository_integration_test.go
+166
View File
@@ -2,8 +2,10 @@ package payment
import (
"testing"
"time"
"hfb_sys/backend/internal/model"
ordermodule "hfb_sys/backend/internal/modules/order"
"gorm.io/driver/sqlite"
"gorm.io/gorm"
@@ -22,7 +24,13 @@ func setupPaymentTestDB(t *testing.T) *gorm.DB {
if err := db.AutoMigrate(
&model.PaymentOrder{},
&model.RentalOrder{},
&model.RentalListing{},
&model.GameAccount{},
&model.User{},
&model.ChatConversation{},
&model.ChatParticipant{},
&model.ChatMessage{},
&model.Notification{},
); err != nil {
t.Fatalf("数据库迁移失败: %v", err)
}
@@ -30,6 +38,82 @@ func setupPaymentTestDB(t *testing.T) *gorm.DB {
return db
}
type payableOrderFixture struct {
Owner model.User
Renter model.User
Account model.GameAccount
Listing model.RentalListing
Order model.RentalOrder
Payment model.PaymentOrder
}
func createPayableOrderFixture(t *testing.T, db *gorm.DB, suffix string, createPayment bool) payableOrderFixture {
t.Helper()
f := payableOrderFixture{
Owner: model.User{Phone: "13800001" + suffix},
Renter: model.User{Phone: "13900001" + suffix},
}
if err := db.Create(&f.Owner).Error; err != nil {
t.Fatalf("create owner failed: %v", err)
}
if err := db.Create(&f.Renter).Error; err != nil {
t.Fatalf("create renter failed: %v", err)
}
f.Account = model.GameAccount{
OwnerID: f.Owner.ID,
ServerRegion: "国服",
LoginPlatform: "steam",
Title: "测试账号",
Status: "published",
}
if err := db.Create(&f.Account).Error; err != nil {
t.Fatalf("create account failed: %v", err)
}
f.Listing = model.RentalListing{
ListingNo: "LST20260614" + suffix,
OwnerID: f.Owner.ID,
AccountID: f.Account.ID,
Status: "published",
ReviewStatus: "approved",
InTransaction: true,
PriceCent: 1000,
}
if err := db.Create(&f.Listing).Error; err != nil {
t.Fatalf("create listing failed: %v", err)
}
f.Order = model.RentalOrder{
OrderNo: "ORD20260614" + suffix,
ListingID: f.Listing.ID,
AccountID: f.Account.ID,
OwnerID: f.Owner.ID,
RenterID: f.Renter.ID,
RentAmountCent: 1000,
Status: "pending_payment",
HandoffStatus: "none",
}
if err := db.Create(&f.Order).Error; err != nil {
t.Fatalf("create order failed: %v", err)
}
f.Payment = model.PaymentOrder{
PaymentNo: "PAY20260614" + suffix,
OrderID: f.Order.ID,
OrderNo: f.Order.OrderNo,
UserID: f.Renter.ID,
Provider: "mock",
ThirdOrderID: "PAY20260614" + suffix,
ProviderOrderID: "MOCKPAY20260614" + suffix,
AmountCent: 1000,
BizType: "order_pay",
Status: "paying",
}
if createPayment {
if err := db.Create(&f.Payment).Error; err != nil {
t.Fatalf("create payment failed: %v", err)
}
}
return f
}
// TestCanReusePaymentWithSameProvider 测试相同渠道可复用
func TestCanReusePaymentWithSameProvider(t *testing.T) {
payment := model.PaymentOrder{
@@ -346,3 +430,85 @@ func TestStartRefundDoesNotCreateNewOrderWhenFailedRefundExists(t *testing.T) {
t.Fatalf("refund order count = %d, want 1", count)
}
}
func TestConfirmPaidUpdatesOrderAndPaymentInOnePath(t *testing.T) {
db := setupPaymentTestDB(t)
orderRepo := ordermodule.NewRepository(db)
repo := NewRepository(db, nil, orderRepo)
fixture := createPayableOrderFixture(t, db, "0010", true)
paidAt := time.Date(2026, 6, 14, 12, 0, 0, 0, time.UTC)
err := repo.confirmPaid(t.Context(), &fixture.Payment, "paid", paidAt, map[string]string{
"provider_order_id": "PROVIDER202606140010",
}, channelSourceNotify)
if err != nil {
t.Fatalf("confirmPaid() error = %v", err)
}
var latestPayment model.PaymentOrder
if err := db.First(&latestPayment, fixture.Payment.ID).Error; err != nil {
t.Fatalf("find payment failed: %v", err)
}
if latestPayment.Status != "paid" {
t.Fatalf("payment status = %q, want paid", latestPayment.Status)
}
if latestPayment.ProviderOrderID != "PROVIDER202606140010" {
t.Fatalf("provider order id = %q, want provider response", latestPayment.ProviderOrderID)
}
var latestOrder model.RentalOrder
if err := db.First(&latestOrder, fixture.Order.ID).Error; err != nil {
t.Fatalf("find order failed: %v", err)
}
if latestOrder.Status != "pending_handoff" || latestOrder.HandoffStatus != "pending_owner" {
t.Fatalf("order status = %q/%q, want pending_handoff/pending_owner", latestOrder.Status, latestOrder.HandoffStatus)
}
var latestListing model.RentalListing
if err := db.First(&latestListing, fixture.Listing.ID).Error; err != nil {
t.Fatalf("find listing failed: %v", err)
}
var latestAccount model.GameAccount
if err := db.First(&latestAccount, fixture.Account.ID).Error; err != nil {
t.Fatalf("find account failed: %v", err)
}
if latestListing.Status != "rented" || latestAccount.Status != "rented" {
t.Fatalf("asset status = %q/%q, want rented/rented", latestListing.Status, latestAccount.Status)
}
}
func TestConfirmPaidRollsBackOrderWhenPaymentUpdateFails(t *testing.T) {
db := setupPaymentTestDB(t)
orderRepo := ordermodule.NewRepository(db)
repo := NewRepository(db, nil, orderRepo)
fixture := createPayableOrderFixture(t, db, "0011", false)
fixture.Payment.ID = 999999
paidAt := time.Date(2026, 6, 14, 12, 0, 0, 0, time.UTC)
err := repo.confirmPaid(t.Context(), &fixture.Payment, "paid", paidAt, map[string]string{
"provider_order_id": "PROVIDER202606140011",
}, channelSourceNotify)
if err == nil {
t.Fatal("confirmPaid() error = nil, want payment lookup failure")
}
var latestOrder model.RentalOrder
if findErr := db.First(&latestOrder, fixture.Order.ID).Error; findErr != nil {
t.Fatalf("find order failed: %v", findErr)
}
if latestOrder.Status != "pending_payment" || latestOrder.HandoffStatus != "none" {
t.Fatalf("order status = %q/%q, want rollback to pending_payment/none", latestOrder.Status, latestOrder.HandoffStatus)
}
var latestListing model.RentalListing
if findErr := db.First(&latestListing, fixture.Listing.ID).Error; findErr != nil {
t.Fatalf("find listing failed: %v", findErr)
}
var latestAccount model.GameAccount
if findErr := db.First(&latestAccount, fixture.Account.ID).Error; findErr != nil {
t.Fatalf("find account failed: %v", findErr)
}
if latestListing.Status != "published" || latestAccount.Status != "published" {
t.Fatalf("asset status = %q/%q, want rollback to published/published", latestListing.Status, latestAccount.Status)
}
}