test(tenant): 增加本地双站演示数据与跨站验收

This commit is contained in:
yml
2026-11-15 16:33:17 +08:00
parent e994fd9166
commit 899e9155d0
7 changed files with 856 additions and 4 deletions
+18
View File
@@ -60,6 +60,24 @@ npm run dev
数据库 SQL 约束、执行计划、慢查询观测、连接池和备份恢复要求见 [`docs/数据库SQL约束与运维.md`](docs/数据库SQL约束与运维.md)。
## 本地双站演示数据
不需要生产库副本。启动本地 MySQL 后执行:
```bash
./scripts/seed-tenant-demo.sh
```
脚本会先执行最新迁移,再幂等写入大锤、解忧两个本地站点、演示用户、客服账号、双站货架、两套 mock 支付商户和双向跨站订单。默认访问地址:
- 大锤:`http://dachui.localhost:5189`
- 解忧:`http://jieyou.localhost:5189`
- 用户密码:`demo123456`
- 大锤客服:`demo_dachui_cs / demo123456`
- 解忧客服:`demo_jieyou_cs / demo123456`
演示数据和支付均为本地 mock,不连接真实支付渠道。跨站完整链路已包含在 `go test ./internal/e2e -run TestCrossTenantFlowWithMockPayments`。
需要在本地推送前自动执行同一套检查时,启用 Git hook:
```bash
+495
View File
@@ -0,0 +1,495 @@
package main
import (
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"fmt"
"os"
"time"
"hfb_sys/backend/internal/config"
"hfb_sys/backend/internal/database"
"hfb_sys/backend/internal/model"
"hfb_sys/backend/internal/modules/chat"
"hfb_sys/backend/internal/modules/order"
"hfb_sys/backend/internal/modules/payment"
"hfb_sys/backend/internal/modules/paymentconfig"
"hfb_sys/backend/internal/tenancy"
"go.uber.org/zap"
"golang.org/x/crypto/bcrypt"
"gorm.io/datatypes"
"gorm.io/gorm"
"gorm.io/gorm/clause"
)
const (
demoPassword = "demo123456"
ownerDPhone = "13920000001"
renterDPhone = "13920000002"
ownerJPhone = "13920000003"
renterJPhone = "13920000004"
)
type demoEnv struct {
db *gorm.DB
dachui model.Tenant
jieyou model.Tenant
ownerD model.User
renterD model.User
ownerJ model.User
renterJ model.User
cashierD *payment.Repository
cashierJ *payment.Repository
orderRepo *order.Repository
paymentRepo *payment.Repository
orders []model.RentalOrder
}
func main() {
cfg := config.Load()
logger := zap.NewNop()
db, err := database.OpenMySQLWithOptions(cfg.MySQLDSN, cfg.Log.Level, logger, database.MySQLOptions{
MaxOpenConns: cfg.Database.MaxOpenConns,
MaxIdleConns: cfg.Database.MaxIdleConns,
ConnMaxLifetime: cfg.Database.ConnMaxLifetime,
ConnMaxIdleTime: cfg.Database.ConnMaxIdleTime,
SlowQueryThreshold: cfg.Database.SlowQueryThreshold,
})
if err != nil {
fail("连接 MySQL 失败", err)
}
if err := seed(context.Background(), db); err != nil {
fail("写入双站演示数据失败", err)
}
}
func seed(ctx context.Context, db *gorm.DB) error {
if db == nil {
return fmt.Errorf("数据库未连接")
}
env := &demoEnv{db: db}
if err := env.ensureTenants(ctx); err != nil {
return err
}
if err := env.ensureDomains(ctx); err != nil {
return err
}
if err := env.ensureAdmins(ctx); err != nil {
return err
}
if err := env.ensureUsers(ctx); err != nil {
return err
}
if err := env.ensureMerchants(ctx); err != nil {
return err
}
listingD, err := env.ensureListing(ctx, env.dachui, env.ownerD, "L-DEMO-DACHUI", "大锤演示·烽火账号", 10000, 80)
if err != nil {
return err
}
listingJ, err := env.ensureListing(ctx, env.jieyou, env.ownerJ, "L-DEMO-JIEYOU", "解忧演示·烽火账号", 12000, 96)
if err != nil {
return err
}
if _, err := env.ensureListing(ctx, env.dachui, env.ownerD, "L-DEMO-DACHUI-FREE", "大锤演示·可下单账号", 15000, 120); err != nil {
return err
}
if _, err := env.ensureListing(ctx, env.jieyou, env.ownerJ, "L-DEMO-JIEYOU-FREE", "解忧演示·可下单账号", 13000, 104); err != nil {
return err
}
if err := env.ensurePaidOrder(ctx, env.dachui, env.renterD, *listingJ); err != nil {
return err
}
if err := env.ensurePaidOrder(ctx, env.jieyou, env.renterJ, *listingD); err != nil {
return err
}
env.printSummary()
return nil
}
func (e *demoEnv) ensureTenants(ctx context.Context) error {
rows := []model.Tenant{
{Code: "dachui", Name: "大锤商行", Status: "active", ProfileJSON: jsonValue(map[string]any{"site_name": "大锤商行"}), FeaturesJSON: jsonValue(map[string]any{})},
{Code: "jieyou", Name: "解忧商行", Status: "active", ProfileJSON: jsonValue(map[string]any{"site_name": "解忧商行"}), FeaturesJSON: jsonValue(map[string]any{})},
}
for index := range rows {
if err := e.db.WithContext(ctx).Clauses(clause.OnConflict{
Columns: []clause.Column{{Name: "code"}},
DoUpdates: clause.AssignmentColumns([]string{"name", "status", "profile_json", "features_json", "updated_at"}),
}).Create(&rows[index]).Error; err != nil {
return err
}
}
if err := e.db.WithContext(ctx).Where("code = ?", "dachui").First(&e.dachui).Error; err != nil {
return err
}
if err := e.db.WithContext(ctx).Where("code = ?", "jieyou").First(&e.jieyou).Error; err != nil {
return err
}
return nil
}
func (e *demoEnv) ensureDomains(ctx context.Context) error {
for _, item := range []struct {
tenantID uint64
host string
}{
{tenantID: e.dachui.ID, host: "dachui.localhost"},
{tenantID: e.jieyou.ID, host: "jieyou.localhost"},
} {
row := model.TenantDomain{
TenantID: item.tenantID,
Host: item.host,
DomainType: "storefront",
Status: "active",
}
if err := e.db.WithContext(ctx).Clauses(clause.OnConflict{
Columns: []clause.Column{{Name: "host"}},
DoUpdates: clause.AssignmentColumns([]string{"tenant_id", "domain_type", "status", "updated_at"}),
}).Create(&row).Error; err != nil {
return err
}
}
return nil
}
func (e *demoEnv) ensureAdmins(ctx context.Context) error {
var role model.Role
if err := e.db.WithContext(ctx).Where("code = ?", "cs").First(&role).Error; err != nil {
if err != gorm.ErrRecordNotFound {
return err
}
role = model.Role{Code: "cs", Name: "客服", Description: "双站演示客服"}
if err := e.db.WithContext(ctx).Create(&role).Error; err != nil {
return err
}
}
hash, err := bcrypt.GenerateFromPassword([]byte(demoPassword), bcrypt.DefaultCost)
if err != nil {
return err
}
for _, item := range []struct {
username string
nickname string
tenantID uint64
}{
{username: "demo_dachui_cs", nickname: "大锤演示客服", tenantID: e.dachui.ID},
{username: "demo_jieyou_cs", nickname: "解忧演示客服", tenantID: e.jieyou.ID},
} {
admin := model.AdminUser{}
err := e.db.WithContext(ctx).Where("username = ?", item.username).First(&admin).Error
if err == gorm.ErrRecordNotFound {
admin = model.AdminUser{
Username: item.username,
PasswordHash: string(hash),
Nickname: item.nickname,
Status: "active",
TokenVersion: 1,
}
if err := e.db.WithContext(ctx).Create(&admin).Error; err != nil {
return err
}
} else if err != nil {
return err
} else if err := e.db.WithContext(ctx).Model(&admin).Updates(map[string]any{
"password_hash": string(hash),
"nickname": item.nickname,
"status": "active",
}).Error; err != nil {
return err
}
binding := model.AdminUserRole{AdminID: admin.ID, RoleID: role.ID, TenantID: item.tenantID}
if err := e.db.WithContext(ctx).Clauses(clause.OnConflict{DoNothing: true}).Create(&binding).Error; err != nil {
return err
}
}
return nil
}
func (e *demoEnv) ensureUsers(ctx context.Context) error {
hash, err := bcrypt.GenerateFromPassword([]byte(demoPassword), bcrypt.DefaultCost)
if err != nil {
return err
}
var errs []error
e.ownerD = e.ensureUser(ctx, e.dachui.ID, ownerDPhone, "大锤演示号主", string(hash), &errs)
e.renterD = e.ensureUser(ctx, e.dachui.ID, renterDPhone, "大锤演示租客", string(hash), &errs)
e.ownerJ = e.ensureUser(ctx, e.jieyou.ID, ownerJPhone, "解忧演示号主", string(hash), &errs)
e.renterJ = e.ensureUser(ctx, e.jieyou.ID, renterJPhone, "解忧演示租客", string(hash), &errs)
for _, item := range errs {
if item != nil {
return item
}
}
for _, user := range []model.User{e.ownerD, e.renterD, e.ownerJ, e.renterJ} {
if err := e.ensureRealname(ctx, user); err != nil {
return err
}
}
return nil
}
func (e *demoEnv) ensureUser(ctx context.Context, tenantID uint64, phone, nickname, passwordHash string, errs *[]error) model.User {
var user model.User
err := e.db.WithContext(ctx).Where("tenant_id = ? AND phone = ?", tenantID, phone).First(&user).Error
if err == gorm.ErrRecordNotFound {
user = model.User{
TenantID: tenantID,
Phone: phone,
PasswordHash: passwordHash,
Nickname: nickname,
RealnameStatus: "verified",
RiskStatus: "normal",
CreditScore: 100,
Status: "active",
}
*errs = append(*errs, e.db.WithContext(ctx).Create(&user).Error)
return user
}
if err != nil {
*errs = append(*errs, err)
return user
}
*errs = append(*errs, e.db.WithContext(ctx).Model(&user).Updates(map[string]any{
"password_hash": passwordHash,
"nickname": nickname,
"realname_status": "verified",
"status": "active",
}).Error)
return user
}
func (e *demoEnv) ensureRealname(ctx context.Context, user model.User) error {
hashRaw := sha256.Sum256([]byte(fmt.Sprintf("%d:%s", user.TenantID, user.Phone)))
hash := hex.EncodeToString(hashRaw[:])
now := time.Now()
row := model.UserRealname{
TenantID: user.TenantID,
UserID: user.ID,
Provider: "mock",
ProviderOrderNo: fmt.Sprintf("DEMO-RN-%d", user.ID),
Status: "verified",
MaskedName: "演示**",
EncryptedName: user.Nickname,
MaskedIDNo: "110***********001",
EncryptedIDNo: "demo-id-" + user.Phone,
IDNoHash: &hash,
VerifiedAt: &now,
}
return e.db.WithContext(ctx).Clauses(clause.OnConflict{
Columns: []clause.Column{{Name: "tenant_id"}, {Name: "user_id"}},
DoUpdates: clause.AssignmentColumns([]string{
"provider", "provider_order_no", "status", "masked_name", "encrypted_name",
"masked_id_no", "encrypted_id_no", "id_no_hash", "verified_at", "updated_at",
}),
}).Create(&row).Error
}
func (e *demoEnv) ensureMerchants(ctx context.Context) error {
for _, item := range []struct {
tenantID uint64
merchant string
name string
}{
{tenantID: e.dachui.ID, merchant: "DACHUI-DEMO-MOCK", name: "大锤演示 Mock 支付"},
{tenantID: e.jieyou.ID, merchant: "JIEYOU-DEMO-MOCK", name: "解忧演示 Mock 支付"},
} {
var count int64
if err := e.db.WithContext(ctx).Model(&model.PaymentMerchantConfig{}).
Where("owner_tenant_id = ? AND merchant_id = ?", item.tenantID, item.merchant).
Count(&count).Error; err != nil {
return err
}
if count > 0 {
continue
}
if err := e.db.WithContext(ctx).Model(&model.PaymentMerchantConfig{}).
Where("owner_tenant_id = ? AND pay_way = ?", item.tenantID, "ZFBZF").
Update("is_default", false).Error; err != nil {
return err
}
row := model.PaymentMerchantConfig{
OwnerTenantID: item.tenantID,
Name: item.name,
Provider: "mock",
MerchantID: item.merchant,
PayWay: "ZFBZF",
SignType: "MD5",
IsDefault: true,
Status: "active",
Environment: "sandbox",
BusinessTags: model.JSONArray{"order_pay"},
}
if err := e.db.WithContext(ctx).Create(&row).Error; err != nil {
return err
}
}
return nil
}
func (e *demoEnv) ensureListing(ctx context.Context, tenant model.Tenant, owner model.User, listingNo, title string, priceCent, sourcePriceYuan int64) (*model.RentalListing, error) {
var listing model.RentalListing
err := e.db.WithContext(ctx).Where("listing_no = ?", listingNo).First(&listing).Error
if err == nil {
if err := e.ensureListingGroup(listing); err != nil {
return nil, err
}
return &listing, e.ensureOffers(ctx, listing)
}
if err != gorm.ErrRecordNotFound {
return nil, err
}
summary, _ := json.Marshal(map[string]any{
"fire_level": 50,
"online_time": map[string]any{"start": "09:00", "end": "23:00"},
"price_breakdown": map[string]any{
"seller_total_price": sourcePriceYuan,
"buyer_total_price": priceCent / 100,
"consumable_price": 120,
},
})
account := model.GameAccount{
SourceTenantID: tenant.ID,
OwnerID: owner.ID,
ServerRegion: "烽火地带",
LoginPlatform: "QQ",
Title: title,
Description: "本地双站演示数据,可直接下单并用 mock 支付。",
RankLevel: "钻石",
HafCoinAmount: 100_000_000,
AssetSummary: datatypes.JSON(summary),
SeasonTags: datatypes.JSON([]byte(`["S7"]`)),
ScreenshotURLS: datatypes.JSON([]byte(`[]`)),
Status: "published",
}
if err := e.db.WithContext(ctx).Create(&account).Error; err != nil {
return nil, err
}
publishedAt := time.Now()
listing = model.RentalListing{
SourceTenantID: tenant.ID,
ListingNo: listingNo,
AccountID: account.ID,
OwnerID: owner.ID,
PriceCent: priceCent,
DepositAmountCent: 5000,
Status: "published",
ReviewStatus: "approved",
HandoffMode: "owner",
SettlementMode: "owner_wallet",
PublishedAt: &publishedAt,
}
if err := e.db.WithContext(ctx).Create(&listing).Error; err != nil {
return nil, err
}
if err := e.ensureListingGroup(listing); err != nil {
return nil, err
}
return &listing, e.ensureOffers(ctx, listing)
}
func (e *demoEnv) ensureListingGroup(listing model.RentalListing) error {
return e.db.Transaction(func(tx *gorm.DB) error {
_, err := chat.EnsureListingConversation(tx, listing, 0)
return err
})
}
func (e *demoEnv) ensureOffers(ctx context.Context, listing model.RentalListing) error {
for _, item := range []struct {
tenantID uint64
price *int64
}{
{tenantID: e.dachui.ID, price: nil},
{tenantID: e.jieyou.ID, price: nil},
} {
if listing.SourceTenantID == e.dachui.ID && item.tenantID == e.jieyou.ID {
price := listing.PriceCent + 2000
item.price = &price
}
if listing.SourceTenantID == e.jieyou.ID && item.tenantID == e.dachui.ID {
price := listing.PriceCent + 2000
item.price = &price
}
offer := model.TenantListingOffer{
TenantID: item.tenantID,
ListingID: listing.ID,
DisplayStatus: "enabled",
PriceCent: item.price,
}
if err := e.db.WithContext(ctx).Clauses(clause.OnConflict{
Columns: []clause.Column{{Name: "tenant_id"}, {Name: "listing_id"}},
DoUpdates: clause.AssignmentColumns([]string{"display_status", "price_cent", "updated_at"}),
}).Create(&offer).Error; err != nil {
return err
}
}
return nil
}
func (e *demoEnv) ensurePaidOrder(ctx context.Context, buyerTenant model.Tenant, renter model.User, listing model.RentalListing) error {
if e.paymentRepo == nil {
configRepo := paymentconfig.NewRepository(e.db, &paymentconfig.MockEncryptor{})
chatRepo := chat.NewRepository(e.db, nil, nil)
e.orderRepo = order.NewRepository(e.db, order.Dependencies{
ChatNotifier: chatRepo,
ChatArchiver: chat.NewOrderChatArchiverAdapter(),
})
e.paymentRepo = payment.NewRepository(e.db, configRepo, e.orderRepo)
}
tenantCtx := tenancy.WithScope(ctx, tenancy.Scope{TenantID: buyerTenant.ID, TenantCode: buyerTenant.Code, TenantName: buyerTenant.Name})
var existing model.RentalOrder
err := e.db.WithContext(ctx).
Where("listing_id = ? AND buyer_tenant_id = ?", listing.ID, buyerTenant.ID).
Order("id DESC").
First(&existing).Error
if err == nil {
if existing.Status == "pending_payment" {
if _, err := e.paymentRepo.Start(tenantCtx, renter.ID, existing.ID, payment.StartPaymentRequest{PayWay: "ZFBZF"}, "127.0.0.1"); err != nil {
return err
}
}
e.orders = append(e.orders, existing)
return nil
}
if err != gorm.ErrRecordNotFound {
return err
}
created, err := e.orderRepo.Create(tenantCtx, renter.ID, order.CreateRequest{ListingID: listing.ID})
if err != nil {
return err
}
if _, err := e.paymentRepo.Start(tenantCtx, renter.ID, created.ID, payment.StartPaymentRequest{PayWay: "ZFBZF"}, "127.0.0.1"); err != nil {
return err
}
var paid model.RentalOrder
if err := e.db.WithContext(ctx).First(&paid, created.ID).Error; err != nil {
return err
}
e.orders = append(e.orders, paid)
return nil
}
func (e *demoEnv) printSummary() {
fmt.Println("双站本地演示数据已就绪")
fmt.Printf("大锤前台: http://dachui.localhost:5189 (账号 %s / %s,密码 %s)\n", ownerDPhone, renterDPhone, demoPassword)
fmt.Printf("解忧前台: http://jieyou.localhost:5189 (账号 %s / %s,密码 %s)\n", ownerJPhone, renterJPhone, demoPassword)
fmt.Printf("大锤后台: http://dachui.localhost:5189/admin/login (demo_dachui_cs / %s)\n", demoPassword)
fmt.Printf("解忧后台: http://jieyou.localhost:5189/admin/login (demo_jieyou_cs / %s)\n", demoPassword)
for _, row := range e.orders {
fmt.Printf("演示订单: %s buyer=%d source=%d status=%s\n", row.OrderNo, row.BuyerTenantID, row.SourceTenantID, row.Status)
}
}
func jsonValue(value any) datatypes.JSON {
raw, _ := json.Marshal(value)
return datatypes.JSON(raw)
}
func fail(message string, err error) {
fmt.Fprintf(os.Stderr, "%s: %v\n", message, err)
os.Exit(1)
}
+4
View File
@@ -12,6 +12,7 @@ import (
"hfb_sys/backend/internal/database"
"hfb_sys/backend/internal/model"
"hfb_sys/backend/internal/modules/adminfinance"
"hfb_sys/backend/internal/modules/chat"
"hfb_sys/backend/internal/modules/dispute"
"hfb_sys/backend/internal/modules/listing"
"hfb_sys/backend/internal/modules/order"
@@ -205,7 +206,10 @@ func newFlowServices(db *gorm.DB) flowServices {
walletRepo := wallet.NewRepository(db)
configRepo := paymentconfig.NewRepository(db, &paymentconfig.MockEncryptor{})
var paymentRepo *payment.Repository
chatRepo := chat.NewRepository(db, nil, nil)
orderRepo := order.NewRepository(db, order.Dependencies{
ChatNotifier: chatRepo,
ChatArchiver: chat.NewOrderChatArchiverAdapter(),
RefundStarter: order.RefundStarterFunc(func(ctx context.Context, orderID uint64, refundAmountCent int64, bizType string, remark string) (string, error) {
refund, err := paymentRepo.StartRefund(ctx, orderID, refundAmountCent, bizType, remark)
if err != nil {
+291
View File
@@ -0,0 +1,291 @@
package e2e
import (
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"fmt"
"testing"
"time"
"hfb_sys/backend/internal/auditlog"
"hfb_sys/backend/internal/database"
"hfb_sys/backend/internal/model"
"hfb_sys/backend/internal/modules/chat"
"hfb_sys/backend/internal/modules/order"
"hfb_sys/backend/internal/modules/payment"
"hfb_sys/backend/internal/modules/paymentconfig"
"hfb_sys/backend/internal/tenancy"
"gorm.io/datatypes"
"gorm.io/gorm"
)
// TestCrossTenantFlowWithMockPayments 验证本地双站首期闭环:
// 双方商品互相可见、买方租户收款、货源方交接、号主进入货源租户钱包、退款固定原商户。
func TestCrossTenantFlowWithMockPayments(t *testing.T) {
db := database.NewTestDB()
now := time.Now()
dachui := model.Tenant{Code: "dachui", Name: "大锤商行", Status: "active"}
jieyou := model.Tenant{Code: "jieyou", Name: "解忧商行", Status: "active"}
if err := db.Create(&dachui).Error; err != nil {
t.Fatalf("创建大锤租户: %v", err)
}
if err := db.Create(&jieyou).Error; err != nil {
t.Fatalf("创建解忧租户: %v", err)
}
services := newFlowServices(db)
admin := model.AdminUser{Username: "cross-tenant-admin", Nickname: "双站测试管理员", Status: "active"}
if err := db.Create(&admin).Error; err != nil {
t.Fatalf("创建管理员: %v", err)
}
dachuiMerchant := createTenantMockMerchant(t, services.paymentConfig, dachui.ID, admin.ID, "DACHUI-MOCK")
jieyouMerchant := createTenantMockMerchant(t, services.paymentConfig, jieyou.ID, admin.ID, "JIEYOU-MOCK")
ownerD := createVerifiedTenantUser(t, db, dachui.ID, "13910000001", "大锤号主", now)
renterD := createVerifiedTenantUser(t, db, dachui.ID, "13910000002", "大锤租客", now)
ownerJ := createVerifiedTenantUser(t, db, jieyou.ID, "13910000003", "解忧号主", now)
renterJ := createVerifiedTenantUser(t, db, jieyou.ID, "13910000004", "解忧租客", now)
listingD := createCrossTenantListing(t, db, dachui, ownerD, "L-DEMO-DACHUI", "大锤跨站商品", 10000, 80)
listingJ := createCrossTenantListing(t, db, jieyou, ownerJ, "L-DEMO-JIEYOU", "解忧跨站商品", 12000, 96)
seedCrossTenantOffers(t, db, listingD, dachui.ID, jieyou.ID, 12000)
seedCrossTenantOffers(t, db, listingJ, dachui.ID, jieyou.ID, 14000)
ctxD := tenancy.WithScope(t.Context(), tenancy.Scope{TenantID: dachui.ID, TenantCode: dachui.Code})
ctxJ := tenancy.WithScope(t.Context(), tenancy.Scope{TenantID: jieyou.ID, TenantCode: jieyou.Code})
orderJ := createPaidCrossOrder(t, services, ctxD, renterD.ID, listingJ.ID, dachui.ID, jieyou.ID, dachuiMerchant.ID)
completeCrossOrder(t, services, ctxD, ctxJ, orderJ.ID, renterD.ID, ownerJ.ID)
orderD := createPaidCrossOrder(t, services, ctxJ, renterJ.ID, listingD.ID, jieyou.ID, dachui.ID, jieyouMerchant.ID)
completeCrossOrder(t, services, ctxJ, ctxD, orderD.ID, renterJ.ID, ownerD.ID)
assertCrossTenantCompletedOrder(t, db, orderJ.ID, dachui.ID, jieyou.ID, ownerJ.ID)
assertCrossTenantCompletedOrder(t, db, orderD.ID, jieyou.ID, dachui.ID, ownerD.ID)
refundListing := createCrossTenantListing(t, db, dachui, ownerD, "L-DEMO-REFUND", "大锤退款商品", 9000, 72)
seedCrossTenantOffers(t, db, refundListing, dachui.ID, jieyou.ID, 10000)
refundOrder := createPaidCrossOrder(t, services, ctxJ, renterJ.ID, refundListing.ID, jieyou.ID, dachui.ID, jieyouMerchant.ID)
refundAmount := int64(0)
if refundOrder.RentAmountCent != nil {
refundAmount = *refundOrder.RentAmountCent
}
refund, err := services.payment.StartRefund(ctxJ, refundOrder.ID, refundAmount, "admin_refund", "双站 mock 退款验收")
if err != nil {
t.Fatalf("发起 mock 退款: %v", err)
}
if refund.TenantID != jieyou.ID || refund.Status != "refunded" {
t.Fatalf("退款租户/状态 = %d/%s, want %d/refunded", refund.TenantID, refund.Status, jieyou.ID)
}
var refundPayment model.PaymentOrder
if err := db.Where("order_id = ? AND biz_type = ?", refundOrder.ID, "admin_refund").First(&refundPayment).Error; err != nil {
t.Fatalf("查询退款支付单: %v", err)
}
if refundPayment.TenantID != jieyou.ID || refundPayment.PaymentConfigID != jieyouMerchant.ID {
t.Fatalf("退款未固定原租户商户: tenant=%d config=%d", refundPayment.TenantID, refundPayment.PaymentConfigID)
}
}
func createTenantMockMerchant(t *testing.T, service *paymentconfig.Service, tenantID, adminID uint64, merchantID string) *paymentconfig.ConfigDTO {
t.Helper()
ctx := tenancy.WithScope(t.Context(), tenancy.Scope{TenantID: tenantID})
dto, err := service.Create(ctx, paymentconfig.CreateRequest{
Name: fmt.Sprintf("双站演示 Mock %d", tenantID),
Provider: "mock",
MerchantID: merchantID,
PayWay: "ZFBZF",
IsDefault: true,
Status: "active",
Environment: "sandbox",
BusinessTags: []string{"order_pay"},
}, adminID, auditlog.Meta{IP: "127.0.0.1", RequestID: "tenant-e2e-mock"})
if err != nil {
t.Fatalf("创建租户 %d mock 商户: %v", tenantID, err)
}
return dto
}
func createVerifiedTenantUser(t *testing.T, db *gorm.DB, tenantID uint64, phone, nickname string, now time.Time) model.User {
t.Helper()
user := model.User{
TenantID: tenantID,
Phone: phone,
Nickname: nickname,
RealnameStatus: "verified",
RiskStatus: "normal",
CreditScore: 100,
Status: "active",
}
if err := db.Create(&user).Error; err != nil {
t.Fatalf("创建租户用户 %s: %v", phone, err)
}
idHash := sha256.Sum256([]byte(fmt.Sprintf("%d:%s", tenantID, phone)))
hash := hex.EncodeToString(idHash[:])
verifiedAt := now
realname := model.UserRealname{
TenantID: tenantID,
UserID: user.ID,
Provider: "mock",
ProviderOrderNo: fmt.Sprintf("MOCK-RN-%d", user.ID),
Status: "verified",
MaskedName: string([]rune(nickname)[0]) + "**",
EncryptedName: nickname,
MaskedIDNo: "110***********001",
EncryptedIDNo: "demo-id-" + phone,
IDNoHash: &hash,
VerifiedAt: &verifiedAt,
}
if err := db.Create(&realname).Error; err != nil {
t.Fatalf("创建租户实名 %s: %v", phone, err)
}
return user
}
func createCrossTenantListing(t *testing.T, db *gorm.DB, tenant model.Tenant, owner model.User, listingNo, title string, priceCent, sourceAmountCent int64) model.RentalListing {
t.Helper()
assetSummary, _ := json.Marshal(map[string]any{
"fire_level": 50,
"price_breakdown": map[string]any{
"seller_total_price": sourceAmountCent / 100,
"buyer_total_price": priceCent / 100,
},
})
account := model.GameAccount{
SourceTenantID: tenant.ID,
OwnerID: owner.ID,
GameName: "delta_force",
ServerRegion: "烽火地带",
LoginPlatform: "QQ",
Title: title,
Description: "双站本地验收数据",
RankLevel: "钻石",
HafCoinAmount: 100_000_000,
AssetSummary: datatypes.JSON(assetSummary),
SeasonTags: datatypes.JSON([]byte(`[]`)),
ScreenshotURLS: datatypes.JSON([]byte(`[]`)),
Status: "published",
}
if err := db.Create(&account).Error; err != nil {
t.Fatalf("创建商品账号 %s: %v", listingNo, err)
}
publishedAt := time.Now()
listing := model.RentalListing{
SourceTenantID: tenant.ID,
ListingNo: listingNo,
AccountID: account.ID,
OwnerID: owner.ID,
PriceCent: priceCent,
DepositAmountCent: 5000,
Status: "published",
ReviewStatus: "approved",
HandoffMode: "owner",
SettlementMode: "owner_wallet",
PublishedAt: &publishedAt,
}
if err := db.Create(&listing).Error; err != nil {
t.Fatalf("创建商品 %s: %v", listingNo, err)
}
if err := db.Transaction(func(tx *gorm.DB) error {
_, err := chat.EnsureListingConversation(tx, listing, 0)
return err
}); err != nil {
t.Fatalf("创建商品群 %s: %v", listingNo, err)
}
return listing
}
func seedCrossTenantOffers(t *testing.T, db *gorm.DB, listing model.RentalListing, tenantA, tenantB uint64, crossPrice int64) {
t.Helper()
offers := []model.TenantListingOffer{
{TenantID: tenantA, ListingID: listing.ID, DisplayStatus: "enabled"},
{TenantID: tenantB, ListingID: listing.ID, DisplayStatus: "enabled", PriceCent: &crossPrice},
}
if err := db.Create(&offers).Error; err != nil {
t.Fatalf("创建双站货架 %s: %v", listing.ListingNo, err)
}
}
func createPaidCrossOrder(t *testing.T, services flowServices, ctx context.Context, renterID, listingID, buyerTenantID, sourceTenantID, merchantConfigID uint64) *order.OrderDTO {
t.Helper()
dto, err := services.order.Create(ctx, renterID, order.CreateRequest{ListingID: listingID})
if err != nil {
t.Fatalf("创建跨站订单: %v", err)
}
if dto.BuyerTenantID != buyerTenantID || dto.SourceTenantID != sourceTenantID || dto.PaymentTenantID != buyerTenantID {
t.Fatalf("订单租户快照 = buyer:%d source:%d payment:%d", dto.BuyerTenantID, dto.SourceTenantID, dto.PaymentTenantID)
}
paid, err := services.payment.Start(ctx, renterID, dto.ID, payment.StartPaymentRequest{PayWay: "ZFBZF"}, "127.0.0.1")
if err != nil {
t.Fatalf("mock 支付: %v", err)
}
if paid.Status != "paid" || paid.TenantID != buyerTenantID || paid.PaymentConfigID != merchantConfigID {
t.Fatalf("支付租户/商户 = %d/%d status=%s", paid.TenantID, paid.PaymentConfigID, paid.Status)
}
loaded, err := services.order.FindAdmin(ctx, dto.ID)
if err != nil {
t.Fatalf("读取支付后订单: %v", err)
}
if loaded.Status != "pending_handoff" {
t.Fatalf("支付后状态 = %s, want pending_handoff", loaded.Status)
}
return dto
}
func completeCrossOrder(t *testing.T, services flowServices, buyerCtx, sourceCtx context.Context, orderID, renterID, ownerID uint64) {
t.Helper()
if _, err := services.order.SubmitHandoff(sourceCtx, ownerID, orderID, order.SubmitHandoffRequest{Content: "双站 mock 交接信息"}); err != nil {
t.Fatalf("货源方提交交接: %v", err)
}
if err := services.order.ConfirmReceive(buyerCtx, renterID, orderID); err != nil {
t.Fatalf("买方确认收号: %v", err)
}
if _, err := services.order.SubmitCheckout(buyerCtx, renterID, orderID, order.SubmitCheckoutRequest{
Content: "双站 mock 结账",
ConsumableAmountCent: 500,
}); err != nil {
t.Fatalf("买方发起结账: %v", err)
}
if err := services.order.ConfirmCheckout(sourceCtx, ownerID, orderID); err != nil {
t.Fatalf("货源方确认结账: %v", err)
}
}
func assertCrossTenantCompletedOrder(t *testing.T, db *gorm.DB, orderID, buyerTenantID, sourceTenantID, ownerID uint64) {
t.Helper()
var row model.RentalOrder
if err := db.First(&row, orderID).Error; err != nil {
t.Fatalf("读取完成订单: %v", err)
}
if row.Status != "completed" || row.SettlementStatus != "settled" {
t.Fatalf("订单状态/结算 = %s/%s", row.Status, row.SettlementStatus)
}
if row.BuyerTenantID != buyerTenantID || row.SourceTenantID != sourceTenantID {
t.Fatalf("订单租户 = %d/%d", row.BuyerTenantID, row.SourceTenantID)
}
var wallet model.WalletAccount
if err := db.Where("tenant_id = ? AND user_id = ?", sourceTenantID, ownerID).First(&wallet).Error; err != nil {
t.Fatalf("查询货源租户号主钱包: %v", err)
}
if wallet.AvailableBalanceCent <= 0 {
t.Fatalf("货源租户号主钱包余额 = %d, want > 0", wallet.AvailableBalanceCent)
}
var conversation model.ChatConversation
if err := db.Where("listing_id = ?", row.ListingID).First(&conversation).Error; err != nil {
t.Fatalf("查询跨站商品会话: %v", err)
}
if conversation.TenantID != sourceTenantID {
t.Fatalf("商品会话租户 = %d, want source %d", conversation.TenantID, sourceTenantID)
}
var participantCount int64
if err := db.Model(&model.ChatParticipant{}).
Where("conversation_id = ? AND participant_type = ? AND participant_id = ?", conversation.ID, "user", row.RenterID).
Count(&participantCount).Error; err != nil {
t.Fatalf("查询跨站会话买方成员: %v", err)
}
if participantCount == 0 {
t.Fatal("买方租客未加入货源方商品群")
}
}
@@ -1,6 +1,6 @@
# 解忧商行双站点改造方案
> 状态:阶段 1~6 已完成,准备进入迁移与灰度验证
> 状态:阶段 1~7 本地验收已完成,待真实域名切换
> 更新时间:2026-11-15
> 目标:用一套后端、一套数据库和一套前端,上线大锤商行、解忧商行两个经营站点
@@ -321,7 +321,8 @@ A 站商品进入 B 站货架
- 创建大锤和解忧租户。
- 回填历史大锤用户和业务数据。
- 生产库副本执行迁移和并发、支付、退款、越权测试。
- 本地执行迁移、回填,并构造双站演示数据。
- 使用本地 mock 支付完成双向购买、退款、并发、越权和统计验收。
- 解忧先内部访问,再灰度开放。
预计 30~40 人日。两个后端、一个前端和测试并行时,约 4~6 周进入灰度。
+12 -2
View File
@@ -81,10 +81,20 @@ export default defineConfig({
port: frontendPort,
strictPort: true,
proxy: {
'/api': apiProxyTarget,
'/r': apiProxyTarget,
'/api': {
target: apiProxyTarget,
changeOrigin: false,
xfwd: true,
},
'/r': {
target: apiProxyTarget,
changeOrigin: false,
xfwd: true,
},
},
allowedHosts: [
'dachui.localhost',
'jieyou.localhost',
'221329.cc.cd',
'd4aa-77-93-89-84.ngrok-free.app',
'frp-bus.com',
+33
View File
@@ -0,0 +1,33 @@
#!/usr/bin/env bash
set -euo pipefail
ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
BACKEND_DIR="${ROOT_DIR}/backend"
MYSQL_DSN="${MYSQL_DSN:-hfb:secret@tcp(127.0.0.1:13306)/hfb_sys?charset=utf8mb4&parseTime=True&loc=Local}"
GOOSE_VERSION="${GOOSE_VERSION:-v3.27.1}"
GOPROXY="${GOPROXY:-https://goproxy.cn,direct}"
export GOPROXY
if [[ "${MYSQL_DSN}" == *"multiStatements=true"* ]]; then
GOOSE_DSN="${MYSQL_DSN}"
elif [[ "${MYSQL_DSN}" == *"?"* ]]; then
GOOSE_DSN="${MYSQL_DSN}&multiStatements=true"
else
GOOSE_DSN="${MYSQL_DSN}?multiStatements=true"
fi
printf '[tenant-demo] 执行数据库迁移...\n'
(
cd "${BACKEND_DIR}"
go run "github.com/pressly/goose/v3/cmd/goose@${GOOSE_VERSION}" \
-dir migrations \
mysql "${GOOSE_DSN}" \
up
)
printf '[tenant-demo] 写入双站演示数据...\n'
(
cd "${BACKEND_DIR}"
MYSQL_DSN="${MYSQL_DSN}" go run ./cmd/tenant-demo-seed
)