Files
hfb_sys/backend/internal/modules/pickup/repository.go
T

2080 lines
69 KiB
Go

package pickup
import (
"context"
crand "crypto/rand"
"encoding/json"
"errors"
"fmt"
"math"
"strconv"
"strings"
"time"
"hfb_sys/backend/internal/auditlog"
"hfb_sys/backend/internal/listingstatus"
"hfb_sys/backend/internal/model"
"hfb_sys/backend/internal/modules/invitation"
"hfb_sys/backend/internal/modules/notification"
"hfb_sys/backend/internal/modules/rentergrowth"
"hfb_sys/backend/internal/modules/wallet"
"hfb_sys/backend/internal/tenancy"
"hfb_sys/backend/internal/timeutil"
"hfb_sys/backend/pkg/money"
"gorm.io/datatypes"
"gorm.io/gorm"
"gorm.io/gorm/clause"
)
type Repository struct {
db *gorm.DB
}
func NewRepository(db *gorm.DB) *Repository {
return &Repository{db: db}
}
func pickupTenantScope(ctx context.Context, db *gorm.DB, column string) *gorm.DB {
return db.Where(column+" = ?", tenancy.IDFromContext(ctx))
}
// Create 创建提号订单(状态:提号中)。
// 与正常订单支付成功一致:listing 置 rented + in_transaction,从商品管理「已上架」中移出。
// 不结算、不动钱包。
func (r *Repository) Create(ctx context.Context, req CreateRequest, adminID uint64, meta auditlog.Meta) (*PickupDTO, error) {
if r == nil || r.db == nil {
return nil, ErrDependencyUnavailable
}
var createdID uint64
err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
var listing model.RentalListing
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&listing, req.ListingID).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return ErrListingUnavailable
}
return err
}
if listing.Status != "published" || listing.ReviewStatus != "approved" || listing.InTransaction {
return ErrListingUnavailable
}
// 同一 listing 不能有进行中的提号
var cnt int64
if err := tx.Model(&model.AdminPickup{}).
Where("listing_id = ? AND status = ?", listing.ID, StatusPickingUp).
Count(&cnt).Error; err != nil {
return err
}
if cnt > 0 {
return ErrDuplicatePickup
}
var account model.GameAccount
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&account, listing.AccountID).Error; err != nil {
return err
}
accountSource, sourceChannel, err := resolvePickupAccountSource(tx, listing.ID)
if err != nil {
return err
}
priceSnapshot := buildPickupPriceSnapshot(listing, account)
accountSnapshot, err := makePickupAccountSnapshot(account, listing)
if err != nil {
return err
}
pickupNo, err := newPickupNo()
if err != nil {
return err
}
shopName := strings.TrimSpace(req.ShopName)
rawShopName := shopName
if shopName != "" {
var mapping model.PickupShopMapping
if err := tx.Where("source_name = ?", shopName).First(&mapping).Error; err == nil && mapping.TargetShopName != "" {
shopName = mapping.TargetShopName
}
}
tenantID := tenancy.IDFromContext(ctx)
sourceTenantID := listing.SourceTenantID
if sourceTenantID == 0 {
sourceTenantID = tenantID
}
pickup := model.AdminPickup{
PickupNo: pickupNo,
TenantID: tenantID,
SourceTenantID: sourceTenantID,
ListingID: listing.ID,
AccountID: listing.AccountID,
OwnerID: listing.OwnerID,
AdminID: adminID,
Operator: strings.TrimSpace(req.Operator),
Platform: strings.TrimSpace(req.Platform),
ThirdPartyOrderNo: strings.TrimSpace(req.ThirdPartyOrderNo),
ShopName: shopName,
RawShopName: rawShopName,
AccountSource: accountSource,
SourceChannel: sourceChannel,
SettlementMode: pickupSettlementMode(listing.SettlementMode, accountSource),
ListingPriceCent: priceSnapshot.ListingPriceCent,
OrderAmountCent: req.OrderAmountCent,
DepositAmountCent: req.DepositAmountCent,
OwnerPriceCent: priceSnapshot.OwnerPriceCent,
WebsiteProfitCent: priceSnapshot.WebsiteProfitCent,
ProfitAmountCent: req.ProfitAmountCent,
SellerRatio: priceSnapshot.SellerRatio,
BuyerRatio: priceSnapshot.BuyerRatio,
AccountSnapshot: accountSnapshot,
Status: StatusPickingUp,
Remark: strings.TrimSpace(req.Remark),
}
if err := tx.Create(&pickup).Error; err != nil {
return err
}
if err := appendPickupEvent(tx, pickup, "pickup_created", adminID, "管理员创建线下提号。", pickup.Remark, map[string]any{
"tenant_id": pickup.TenantID,
"source_tenant_id": pickup.SourceTenantID,
"listing_price_cent": pickup.ListingPriceCent,
"order_amount_cent": pickup.OrderAmountCent,
"deposit_amount_cent": pickup.DepositAmountCent,
"profit_amount_cent": pickup.ProfitAmountCent,
"account_source": pickup.AccountSource,
"source_channel": pickup.SourceChannel,
"settlement_mode": pickup.SettlementMode,
"operator": pickup.Operator,
"third_party_order_no": pickup.ThirdPartyOrderNo,
}, map[string]any{}); err != nil {
return err
}
createdID = pickup.ID
// 锁定商品:status=rented,从「已上架」列表移除,进入「已锁定」
fromStatus := listing.Status
listing.InTransaction = true
listing.Status = "rented"
account.Status = "rented"
if err := tx.Save(&listing).Error; err != nil {
return err
}
if err := tx.Save(&account).Error; err != nil {
return err
}
if err := listingstatus.AppendTransition(
tx,
&listing,
fromStatus,
listingstatus.SourcePickup,
listingstatus.ActorAdmin,
adminID,
"管理员线下提号锁定",
); err != nil {
return err
}
bid := pickup.ID
if err := notification.Append(tx, notification.Entry{
UserID: listing.OwnerID,
Type: "pickup",
Title: "账号被管理员提号",
Content: fmt.Sprintf("您的账号「%s」已被管理员提号(线下交易),等待完成结算。", account.Title),
BizType: "pickup",
BizID: &bid,
}); err != nil {
return err
}
if err := auditlog.Append(tx, auditlog.Entry{
ActorType: "admin",
ActorID: adminID,
Action: "pickup_create",
BizType: "admin_pickup",
BizID: &bid,
Meta: meta,
Detail: map[string]any{
"pickup_no": pickupNo,
"tenant_id": pickup.TenantID,
"source_tenant_id": pickup.SourceTenantID,
"listing_id": listing.ID,
"platform": pickup.Platform,
"third_party_order_no": pickup.ThirdPartyOrderNo,
"shop_name": pickup.ShopName,
"operator": pickup.Operator,
"account_source": pickup.AccountSource,
"source_channel": pickup.SourceChannel,
"order_amount_cent": pickup.OrderAmountCent,
"deposit_amount_cent": pickup.DepositAmountCent,
"profit_cent": pickup.ProfitAmountCent,
},
}); err != nil {
return err
}
return nil
})
if err != nil {
return nil, err
}
return r.FindByID(ctx, createdID)
}
// Complete 完成提号。站内上传结算至卖家钱包;平台代管提号转为待线下结算。
func (r *Repository) Complete(ctx context.Context, pickupID uint64, req CompleteRequest, adminID uint64, meta auditlog.Meta) (*PickupDTO, error) {
if r == nil || r.db == nil {
return nil, ErrDependencyUnavailable
}
if req.SettleAmountCent <= 0 {
return nil, ErrInvalidAmount
}
err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
var pickup model.AdminPickup
if err := pickupTenantScope(ctx, tx, "tenant_id").
Clauses(clause.Locking{Strength: "UPDATE"}).First(&pickup, pickupID).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return ErrPickupNotFound
}
return err
}
if pickup.Status != StatusPickingUp {
return ErrPickupNotPickingUp
}
before := pickupState(pickup)
var listing model.RentalListing
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&listing, pickup.ListingID).Error; err != nil {
return err
}
var account model.GameAccount
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&account, pickup.AccountID).Error; err != nil {
return err
}
now := time.Now()
pickup.SettleAmountCent = req.SettleAmountCent
if req.ProfitAmountCent != nil {
pickup.ProfitAmountCent = *req.ProfitAmountCent
}
pickup.Status = StatusCompleted
pickup.CompleteRemark = strings.TrimSpace(req.CompleteRemark)
pickup.CompletedAt = &now
if err := tx.Save(&pickup).Error; err != nil {
return err
}
// listing 置 completed(售出终态,不可再上架),与正常订单 completeAssets 对齐。
fromStatus := listing.Status
listing.InTransaction = false
listing.Status = "completed"
listing.PublishedAt = nil
account.Status = "offline"
if err := tx.Save(&listing).Error; err != nil {
return err
}
if err := tx.Save(&account).Error; err != nil {
return err
}
if err := listingstatus.AppendTransition(
tx,
&listing,
fromStatus,
listingstatus.SourcePickup,
listingstatus.ActorAdmin,
adminID,
"管理员提号完成",
); err != nil {
return err
}
bid := pickup.ID
if pickupRequiresOfflineSettlement(pickup) {
pickup.OfflineSettlementStatus = OfflineSettlementStatusPending
if err := tx.Save(&pickup).Error; err != nil {
return err
}
if err := notification.Append(tx, notification.Entry{
UserID: pickup.OwnerID,
Type: "pickup",
Title: "提号已完成,待线下结算",
Content: fmt.Sprintf("账号「%s」提号完成,结算金额 %s 将通过线下方式支付。", account.Title, money.FormatWithSymbol(req.SettleAmountCent)),
BizType: "pickup",
BizID: &bid,
}); err != nil {
return err
}
} else {
if err := wallet.AppendEntries(tx, wallet.Entry{
UserID: pickup.OwnerID,
Direction: "in",
AmountCent: req.SettleAmountCent,
BalanceType: "available",
BizType: "admin_pickup_settle",
BizNo: pickup.PickupNo,
Remark: fmt.Sprintf("管理员提号结算:%s", pickup.PickupNo),
}); err != nil {
return err
}
if err := notification.Append(tx, notification.Entry{
UserID: pickup.OwnerID,
Type: "pickup",
Title: "提号已完成,已结算到账",
Content: fmt.Sprintf("账号「%s」提号完成,已结算 %s 到您的钱包。", account.Title, money.FormatWithSymbol(req.SettleAmountCent)),
BizType: "pickup",
BizID: &bid,
}); err != nil {
return err
}
}
if _, err := rentergrowth.AwardPickupOwnerCompleted(
tx,
pickup.ID,
pickup.PickupNo,
pickup.OwnerID,
pickup.SettleAmountCent,
rentergrowth.SourcePickupCompleted,
); err != nil {
return err
}
// 邀请返利:线下提号不走正常订单结账流程,必须在这里补发号主(卖家)侧返利,
// 否则号主邀请人永远拿不到提号产生的分成。
// 基准取「网站加价」与「线下利润」的较小值,避免按虚高的单一利润口径多算。
if grossBasisCent := pickupRebateGrossBasis(pickup.WebsiteProfitCent, pickup.ProfitAmountCent); grossBasisCent > 0 {
sellerSiteID := uint64(0)
if listing.DistributionSiteID != nil {
sellerSiteID = *listing.DistributionSiteID
}
if _, err := invitation.AwardSellerSideRebateTx(tx, invitation.SellerSideRebateInput{
Source: invitation.RebateSourcePickup,
SourceID: pickup.ID,
SourceNo: pickup.PickupNo,
SellerID: pickup.OwnerID,
GrossBasisCent: grossBasisCent,
BasisCent: grossBasisCent / 2,
SiteID: sellerSiteID,
RateReferenceAt: now,
SettledAt: now,
RemarkPrefix: "邀请卖家提号返利",
}); err != nil {
return err
}
}
if err := appendPickupEvent(tx, pickup, "pickup_completed", adminID, "管理员完成提号。", pickup.CompleteRemark, map[string]any{
"settle_amount_cent": pickup.SettleAmountCent, "profit_amount_cent": pickup.ProfitAmountCent,
"settlement_mode": pickup.SettlementMode, "offline_settlement_status": pickup.OfflineSettlementStatus,
}, before); err != nil {
return err
}
if err := auditlog.Append(tx, auditlog.Entry{
ActorType: "admin",
ActorID: adminID,
Action: "pickup_complete",
BizType: "admin_pickup",
BizID: &bid,
Meta: meta,
Detail: map[string]any{
"pickup_no": pickup.PickupNo,
"settle_amount_cent": req.SettleAmountCent,
"profit_amount_cent": pickup.ProfitAmountCent,
"settlement_mode": pickup.SettlementMode,
"offline_settlement_status": pickup.OfflineSettlementStatus,
},
}); err != nil {
return err
}
return nil
})
if err != nil {
return nil, err
}
return r.FindByID(ctx, pickupID)
}
// MarkOfflineSettlement 确认平台代管提号已完成实际线下打款。
func (r *Repository) MarkOfflineSettlement(ctx context.Context, pickupID uint64, req OfflineSettlementRequest, adminID uint64, meta auditlog.Meta) (*PickupDTO, error) {
if r == nil || r.db == nil {
return nil, ErrDependencyUnavailable
}
err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
var pickup model.AdminPickup
if err := pickupTenantScope(ctx, tx, "tenant_id").
Clauses(clause.Locking{Strength: "UPDATE"}).First(&pickup, pickupID).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return ErrPickupNotFound
}
return err
}
if !pickupRequiresOfflineSettlement(pickup) || pickup.Status != StatusCompleted ||
pickup.OfflineSettlementStatus != OfflineSettlementStatusPending || pickup.SettleAmountCent <= 0 {
return ErrOfflineSettlementCannotMark
}
before := pickupState(pickup)
pendingTotals, err := pendingPickupFinancialAdjustmentTotals(tx, pickup.ID)
if err != nil {
return err
}
effectiveSettleAmountCent := pickup.SettleAmountCent + pendingTotals.SettleAdjustmentCent
if effectiveSettleAmountCent < 0 {
return ErrFinancialAdjustmentInvalid
}
now := time.Now()
pickup.OfflineSettlementStatus = OfflineSettlementStatusSettled
pickup.OfflineSettlementRemark = strings.TrimSpace(req.Remark)
pickup.ActualPayoutOperator = strings.TrimSpace(req.ActualOperator)
pickup.OfflineSettledBy = &adminID
pickup.OfflineSettledAt = &now
if err := tx.Save(&pickup).Error; err != nil {
return err
}
if pendingTotals.Count > 0 {
if err := tx.Model(&model.AdminPickupFinancialAdjustment{}).
Where("pickup_id = ? AND status IN ?", pickup.ID, []string{FinancialAdjustmentStatusPending, FinancialAdjustmentStatusRecovery}).
Updates(map[string]any{
"status": FinancialAdjustmentStatusSettled,
"settled_by": adminID,
"settled_at": now,
"settlement_remark": pickup.OfflineSettlementRemark,
}).Error; err != nil {
return err
}
}
if err := appendPickupEvent(tx, pickup, "pickup_offline_settlement_confirmed", adminID, "确认已完成提号线下结算。", pickup.OfflineSettlementRemark, map[string]any{
"settle_amount_cent": effectiveSettleAmountCent, "settled_adjustment_count": pendingTotals.Count,
"offline_settlement_actual_operator": pickup.ActualPayoutOperator,
}, before); err != nil {
return err
}
bid := pickup.ID
return auditlog.Append(tx, auditlog.Entry{
ActorType: "admin",
ActorID: adminID,
Action: "pickup_offline_settlement",
BizType: "admin_pickup",
BizID: &bid,
Meta: meta,
Detail: map[string]any{
"pickup_no": pickup.PickupNo,
"settle_amount_cent": effectiveSettleAmountCent,
"settled_adjustment_count": pendingTotals.Count,
"before_offline_settlement_status": OfflineSettlementStatusPending,
"after_offline_settlement_status": pickup.OfflineSettlementStatus,
"offline_settlement_actual_operator": pickup.ActualPayoutOperator,
"remark": pickup.OfflineSettlementRemark,
},
})
})
if err != nil {
return nil, err
}
return r.FindByID(ctx, pickupID)
}
// UpdateProfit 修改提号中的线下利润,已完成和已取消的提号不可修改。
func (r *Repository) UpdateProfit(ctx context.Context, pickupID uint64, req UpdateProfitRequest, adminID uint64, meta auditlog.Meta) (*PickupDTO, error) {
if r == nil || r.db == nil {
return nil, ErrDependencyUnavailable
}
err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
var pickup model.AdminPickup
if err := pickupTenantScope(ctx, tx, "tenant_id").
Clauses(clause.Locking{Strength: "UPDATE"}).First(&pickup, pickupID).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return ErrPickupNotFound
}
return err
}
if pickup.Status != StatusPickingUp {
return ErrPickupNotPickingUp
}
before := pickupState(pickup)
oldProfitAmountCent := pickup.ProfitAmountCent
pickup.ProfitAmountCent = req.ProfitAmountCent
if err := tx.Model(&pickup).Update("profit_amount_cent", pickup.ProfitAmountCent).Error; err != nil {
return err
}
if err := appendPickupEvent(tx, pickup, "pickup_profit_updated", adminID, "修改提号利润。", strings.TrimSpace(req.Reason), map[string]any{
"old_profit_amount_cent": oldProfitAmountCent, "profit_amount_cent": pickup.ProfitAmountCent,
}, before); err != nil {
return err
}
bid := pickup.ID
return auditlog.Append(tx, auditlog.Entry{
ActorType: "admin",
ActorID: adminID,
Action: "pickup_profit_update",
BizType: "admin_pickup",
BizID: &bid,
Meta: meta,
Detail: map[string]any{
"pickup_no": pickup.PickupNo,
"old_profit_amount_cent": oldProfitAmountCent,
"new_profit_amount_cent": pickup.ProfitAmountCent,
"reason": strings.TrimSpace(req.Reason),
},
})
})
if err != nil {
return nil, err
}
return r.FindByID(ctx, pickupID)
}
// UpdateThirdPartyOrderNo 补录或修改提号单第三方单号。
func (r *Repository) UpdateThirdPartyOrderNo(ctx context.Context, pickupID uint64, req UpdateThirdPartyOrderNoRequest, adminID uint64, meta auditlog.Meta) (*PickupDTO, error) {
if r == nil || r.db == nil {
return nil, ErrDependencyUnavailable
}
newThirdPartyOrderNo := strings.TrimSpace(req.ThirdPartyOrderNo)
if newThirdPartyOrderNo == "" || len([]rune(newThirdPartyOrderNo)) > 128 {
return nil, ErrInvalidThirdPartyOrderNo
}
err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
var pickup model.AdminPickup
if err := pickupTenantScope(ctx, tx, "tenant_id").
Clauses(clause.Locking{Strength: "UPDATE"}).First(&pickup, pickupID).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return ErrPickupNotFound
}
return err
}
if pickup.Status == StatusCancelled {
return ErrPickupCancelled
}
before := pickupState(pickup)
oldThirdPartyOrderNo := pickup.ThirdPartyOrderNo
pickup.ThirdPartyOrderNo = newThirdPartyOrderNo
if err := tx.Model(&pickup).Update("third_party_order_no", pickup.ThirdPartyOrderNo).Error; err != nil {
return err
}
if err := appendPickupEvent(tx, pickup, "pickup_third_party_order_no_updated", adminID, "补录/修改第三方单号。", "", map[string]any{
"old_third_party_order_no": oldThirdPartyOrderNo,
"third_party_order_no": pickup.ThirdPartyOrderNo,
}, before); err != nil {
return err
}
bid := pickup.ID
return auditlog.Append(tx, auditlog.Entry{
ActorType: "admin",
ActorID: adminID,
Action: "pickup_third_party_order_no_update",
BizType: "admin_pickup",
BizID: &bid,
Meta: meta,
Detail: map[string]any{
"pickup_no": pickup.PickupNo,
"old_third_party_order_no": oldThirdPartyOrderNo,
"new_third_party_order_no": pickup.ThirdPartyOrderNo,
},
})
})
if err != nil {
return nil, err
}
return r.FindByID(ctx, pickupID)
}
// CreateFinancialAdjustment 为已完成提号追加财务差额,不改写完成时的原始金额。
func (r *Repository) CreateFinancialAdjustment(ctx context.Context, pickupID uint64, req FinancialAdjustmentRequest, adminID uint64, meta auditlog.Meta) (*PickupDTO, error) {
if r == nil || r.db == nil {
return nil, ErrDependencyUnavailable
}
err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
var pickup model.AdminPickup
if err := pickupTenantScope(ctx, tx, "tenant_id").
Clauses(clause.Locking{Strength: "UPDATE"}).First(&pickup, pickupID).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return ErrPickupNotFound
}
return err
}
if pickup.Status != StatusCompleted {
return ErrFinancialAdjustmentInvalid
}
before := pickupState(pickup)
totals, err := pickupFinancialAdjustmentTotals(tx, pickup.ID)
if err != nil {
return err
}
profitDeltaCent := int64(0)
if req.ProfitAmountCent != nil {
profitDeltaCent = *req.ProfitAmountCent - (pickup.ProfitAmountCent + totals.ProfitAdjustmentCent)
}
settleDeltaCent := int64(0)
if req.SettleAmountCent != nil {
settleDeltaCent = *req.SettleAmountCent - (pickup.SettleAmountCent + totals.SettleAdjustmentCent)
}
if profitDeltaCent == 0 && settleDeltaCent == 0 {
return ErrFinancialAdjustmentInvalid
}
status := FinancialAdjustmentStatusSettled
if settleDeltaCent != 0 {
if pickupRequiresOfflineSettlement(pickup) && pickup.OfflineSettlementStatus == OfflineSettlementStatusPending {
// 原结算尚未付款时,差额随同一次线下打款处理。
status = FinancialAdjustmentStatusPending
} else if settleDeltaCent < 0 {
status = FinancialAdjustmentStatusRecovery
} else if pickupRequiresOfflineSettlement(pickup) {
status = FinancialAdjustmentStatusPending
}
}
adjustment := model.AdminPickupFinancialAdjustment{
TenantID: pickup.TenantID,
PickupID: pickup.ID,
ProfitDeltaCent: profitDeltaCent,
SettleDeltaCent: settleDeltaCent,
SettlementMode: pickup.SettlementMode,
Status: status,
Reason: strings.TrimSpace(req.Reason),
CreatedBy: adminID,
}
if err := tx.Create(&adjustment).Error; err != nil {
return err
}
if err := appendPickupEvent(tx, pickup, "pickup_financial_adjusted", adminID, "创建提号财务调整。", adjustment.Reason, map[string]any{
"adjustment_id": adjustment.ID, "profit_delta_cent": adjustment.ProfitDeltaCent,
"settle_delta_cent": adjustment.SettleDeltaCent, "settlement_mode": adjustment.SettlementMode,
"adjustment_status": adjustment.Status,
}, before); err != nil {
return err
}
// 站内钱包的补款在创建调整时立即到账;扣款统一转待追回,避免余额被扣成负数。
if pickup.SettlementMode == SettlementModeOwnerWallet && settleDeltaCent > 0 {
if err := wallet.AppendEntries(tx, wallet.Entry{
UserID: pickup.OwnerID,
Direction: "in",
AmountCent: settleDeltaCent,
BalanceType: "available",
BizType: "admin_pickup_adjustment",
BizNo: fmt.Sprintf("%s-A%d", pickup.PickupNo, adjustment.ID),
Remark: fmt.Sprintf("管理员提号结算补款:%s", pickup.PickupNo),
}); err != nil {
return err
}
}
bid := adjustment.ID
return auditlog.Append(tx, auditlog.Entry{
ActorType: "admin",
ActorID: adminID,
Action: "pickup_financial_adjustment_create",
BizType: "admin_pickup",
BizID: &bid,
Meta: meta,
Detail: map[string]any{
"pickup_id": pickup.ID,
"pickup_no": pickup.PickupNo,
"profit_delta_cent": profitDeltaCent,
"settle_delta_cent": settleDeltaCent,
"settlement_mode": pickup.SettlementMode,
"adjustment_status": status,
"reason": adjustment.Reason,
},
})
})
if err != nil {
return nil, err
}
return r.FindByID(ctx, pickupID)
}
// ListFinancialAdjustments 返回提号的不可变财务调整流水。
func (r *Repository) ListFinancialAdjustments(ctx context.Context, pickupID uint64) ([]FinancialAdjustmentDTO, error) {
if r == nil || r.db == nil {
return nil, ErrDependencyUnavailable
}
var count int64
if err := pickupTenantScope(ctx, r.db.WithContext(ctx).Model(&model.AdminPickup{}), "tenant_id").
Where("id = ?", pickupID).Count(&count).Error; err != nil {
return nil, err
}
if count == 0 {
return nil, ErrPickupNotFound
}
items := make([]FinancialAdjustmentDTO, 0)
if err := pickupTenantScope(ctx, r.db.WithContext(ctx).Model(&model.AdminPickupFinancialAdjustment{}), "tenant_id").
Where("pickup_id = ?", pickupID).
Order("id DESC").
Find(&items).Error; err != nil {
return nil, err
}
return items, nil
}
// SettleFinancialAdjustment 确认平台代管的补款或追回调整已在线下处理。
func (r *Repository) SettleFinancialAdjustment(ctx context.Context, adjustmentID uint64, req FinancialAdjustmentSettlementRequest, adminID uint64, meta auditlog.Meta) error {
if r == nil || r.db == nil {
return ErrDependencyUnavailable
}
return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
var adjustment model.AdminPickupFinancialAdjustment
if err := pickupTenantScope(ctx, tx, "tenant_id").
Clauses(clause.Locking{Strength: "UPDATE"}).First(&adjustment, adjustmentID).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return ErrFinancialAdjustmentNotFound
}
return err
}
if adjustment.Status != FinancialAdjustmentStatusPending && adjustment.Status != FinancialAdjustmentStatusRecovery {
return ErrFinancialAdjustmentCannotSettle
}
beforeStatus := adjustment.Status
now := time.Now()
adjustment.Status = FinancialAdjustmentStatusSettled
adjustment.SettledBy = &adminID
adjustment.SettledAt = &now
adjustment.SettlementRemark = strings.TrimSpace(req.Remark)
if err := tx.Save(&adjustment).Error; err != nil {
return err
}
var pickup model.AdminPickup
if err := pickupTenantScope(ctx, tx, "tenant_id").First(&pickup, adjustment.PickupID).Error; err != nil {
return err
}
if err := appendPickupEvent(tx, pickup, "pickup_adjustment_settled", adminID, "确认提号财务调整已处理。", adjustment.SettlementRemark, map[string]any{
"adjustment_id": adjustment.ID, "profit_delta_cent": adjustment.ProfitDeltaCent,
"settle_delta_cent": adjustment.SettleDeltaCent, "before_status": beforeStatus,
"adjustment_status": adjustment.Status,
}, pickupState(pickup)); err != nil {
return err
}
bid := adjustment.ID
return auditlog.Append(tx, auditlog.Entry{
ActorType: "admin",
ActorID: adminID,
Action: "pickup_financial_adjustment_settle",
BizType: "admin_pickup",
BizID: &bid,
Meta: meta,
Detail: map[string]any{
"pickup_id": adjustment.PickupID,
"profit_delta_cent": adjustment.ProfitDeltaCent,
"settle_delta_cent": adjustment.SettleDeltaCent,
"before_status": beforeStatus,
"after_status": adjustment.Status,
"settlement_remark": adjustment.SettlementRemark,
},
})
})
}
// Cancel 取消提号:恢复 listing 为 published + 解锁 in_transaction,账号恢复可租。
func (r *Repository) Cancel(ctx context.Context, pickupID uint64, reason string, adminID uint64, meta auditlog.Meta) error {
if r == nil || r.db == nil {
return ErrDependencyUnavailable
}
return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
var pickup model.AdminPickup
if err := pickupTenantScope(ctx, tx, "tenant_id").
Clauses(clause.Locking{Strength: "UPDATE"}).First(&pickup, pickupID).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return ErrPickupNotFound
}
return err
}
if pickup.Status != StatusPickingUp {
return ErrPickupNotPickingUp
}
before := pickupState(pickup)
var listing model.RentalListing
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&listing, pickup.ListingID).Error; err != nil {
return err
}
var account model.GameAccount
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&account, pickup.AccountID).Error; err != nil {
return err
}
now := time.Now()
pickup.Status = StatusCancelled
pickup.CancelledAt = &now
if err := tx.Save(&pickup).Error; err != nil {
return err
}
if err := appendPickupEvent(tx, pickup, "pickup_cancelled", adminID, "管理员取消提号。", reason, nil, before); err != nil {
return err
}
// 取消提号:恢复上架,重新出现在商品管理「已上架」
fromStatus := listing.Status
listing.InTransaction = false
listing.Status = "published"
account.Status = "published"
if err := tx.Save(&listing).Error; err != nil {
return err
}
if err := tx.Save(&account).Error; err != nil {
return err
}
if err := listingstatus.AppendTransition(
tx,
&listing,
fromStatus,
listingstatus.SourcePickup,
listingstatus.ActorAdmin,
adminID,
"取消提号恢复上架",
); err != nil {
return err
}
bid := pickup.ID
_ = notification.Append(tx, notification.Entry{
UserID: pickup.OwnerID,
Type: "pickup",
Title: "提号已取消",
Content: fmt.Sprintf("提号订单 %s 已取消,原因:%s", pickup.PickupNo, reason),
BizType: "pickup",
BizID: &bid,
})
_ = auditlog.Append(tx, auditlog.Entry{
ActorType: "admin",
ActorID: adminID,
Action: "pickup_cancel",
BizType: "admin_pickup",
BizID: &bid,
Meta: meta,
Detail: map[string]any{"pickup_no": pickup.PickupNo, "reason": reason},
})
return nil
})
}
func (r *Repository) FindByID(ctx context.Context, id uint64) (*PickupDTO, error) {
if r == nil || r.db == nil {
return nil, ErrDependencyUnavailable
}
var row pickupRow
if err := r.adminBaseQuery(ctx).Where("p.id = ?", id).First(&row).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, ErrPickupNotFound
}
return nil, err
}
dto := row.toDTO()
if isEmptyPickupAccountSnapshot(dto.AccountSnapshot) {
if snapshot, err := r.fallbackAccountSnapshot(ctx, row.ListingID, row.AccountID); err == nil {
dto.AccountSnapshot = snapshot
}
}
return &dto, nil
}
func applyAdminPickupFilters(db *gorm.DB, query AdminPickupQuery) *gorm.DB {
if status := strings.TrimSpace(query.Status); status != "" {
db = db.Where("p.status = ?", status)
}
if shopName := strings.TrimSpace(query.ShopName); shopName != "" {
db = db.Where("p.shop_name = ?", shopName)
}
if accountSource := strings.TrimSpace(query.AccountSource); accountSource != "" {
db = db.Where("p.account_source = ?", accountSource)
}
if offlineSettlementStatus := strings.TrimSpace(query.OfflineSettlementStatus); offlineSettlementStatus != "" {
db = db.Where("p.offline_settlement_status = ?", offlineSettlementStatus)
}
if operator := strings.TrimSpace(query.Operator); operator != "" {
db = db.Where("p.operator = ?", operator)
}
if thirdPartyOrderNo := strings.TrimSpace(query.ThirdPartyOrderNo); thirdPartyOrderNo != "" {
db = db.Where("p.third_party_order_no = ?", thirdPartyOrderNo)
}
if query.StartTime != nil {
db = db.Where("p.created_at >= ?", *query.StartTime)
}
if query.EndTime != nil {
db = db.Where("p.created_at <= ?", *query.EndTime)
}
if kw := strings.TrimSpace(query.Keyword); kw != "" {
upper := strings.ToUpper(kw)
if isPhoneKeyword(kw) {
// 同手机号可同时存在于多个经营站点,必须按提号单已关联的 owner_id 精确匹配。
db = db.Where(
"EXISTS (SELECT 1 FROM users AS pickup_owner WHERE pickup_owner.id = p.owner_id AND pickup_owner.phone = ?)",
kw,
)
} else if strings.HasPrefix(upper, "PK") || strings.HasPrefix(upper, "P") {
// 提号编号:命中 admin_pickups(pickup_no) 唯一索引
db = db.Where("p.pickup_no = ?", kw)
} else if strings.HasPrefix(upper, "L") || (len(kw) >= 12 && isAllDigits(kw)) {
// 商品编号(如 L前缀或时间计算生成的 12位纯数字如 202609040184):命中 rental_listings(listing_no) 唯一索引
db = db.Where("l.listing_no = ?", kw)
} else if id, err := strconv.ParseUint(kw, 10, 64); err == nil && id > 0 && kw[0] != '0' && id < 100000000 {
// 短纯数字 ID(非零开头):命中 admin_pickups 主键及关联 ID
db = db.Where("(p.id = ? OR p.listing_id = ? OR p.account_id = ? OR p.owner_id = ?)", id, id, id, id)
} else {
like := "%" + kw + "%"
db = db.Where(
"p.pickup_no LIKE ? OR l.listing_no LIKE ? OR a.title LIKE ? OR owner.phone LIKE ? OR p.third_party_order_no LIKE ? OR p.operator LIKE ?",
like,
like,
like,
like,
like,
like,
)
}
}
return db
}
func (r *Repository) adminPickupCountQuery(ctx context.Context, query AdminPickupQuery) *gorm.DB {
base := pickupTenantScope(ctx, r.db.WithContext(ctx).Table("admin_pickups AS p"), "p.tenant_id")
kw := strings.TrimSpace(query.Keyword)
if kw == "" {
return base
}
upper := strings.ToUpper(kw)
if strings.HasPrefix(upper, "PK") || strings.HasPrefix(upper, "P") {
return base
}
if id, err := strconv.ParseUint(kw, 10, 64); err == nil && id > 0 && kw[0] != '0' && id < 100000000 {
return base
}
if isPhoneKeyword(kw) {
return base
}
if strings.HasPrefix(upper, "L") || (len(kw) >= 12 && isAllDigits(kw)) {
return base.
Joins("JOIN rental_listings AS l ON l.id = p.listing_id")
}
return base.
Joins("JOIN rental_listings AS l ON l.id = p.listing_id").
Joins("JOIN game_accounts AS a ON a.id = p.account_id").
Joins("JOIN users AS owner ON owner.id = p.owner_id")
}
func (r *Repository) ListAdmin(ctx context.Context, query AdminPickupQuery) (*PaginatedResult, error) {
if r == nil || r.db == nil {
return nil, ErrDependencyUnavailable
}
page, pageSize := normalizePaging(query.Page, query.PageSize)
offset := (page - 1) * pageSize
var rows []pickupRow
db := applyAdminPickupFilters(r.adminBaseQuery(ctx), query)
if err := db.Order("p.id DESC").Offset(offset).Limit(pageSize).Scan(&rows).Error; err != nil {
return nil, err
}
var total int64
// 首页查询且返回条数小于 pageSize 时,总数等于当前返回条数,彻底免除第二次 COUNT(*) 扫描
if page == 1 && len(rows) < pageSize {
total = int64(len(rows))
} else {
countDB := applyAdminPickupFilters(r.adminPickupCountQuery(ctx, query), query)
if err := countDB.Count(&total).Error; err != nil {
return nil, err
}
}
items := make([]PickupDTO, 0, len(rows))
for _, row := range rows {
item := row.toDTO()
item.AccountSnapshot = nil
items = append(items, item)
}
return &PaginatedResult{Items: items, Total: total, Page: page, PageSize: pageSize}, nil
}
// ListShopNames 返回店铺配置与历史提号中已使用的店铺名称,供后台选择和筛选。
// 优先返回 pickup_shops 中配置的 active 店铺(按权重排序),再补充历史提号中未在配置表但已有的店铺。
func (r *Repository) ListShopNames(ctx context.Context, platform string) ([]string, error) {
if r == nil || r.db == nil {
return nil, ErrDependencyUnavailable
}
result := make([]string, 0)
seen := make(map[string]struct{})
// 1. 查询店铺配置表中的 active 店铺
shopDB := pickupTenantScope(ctx, r.db.WithContext(ctx).Model(&model.PickupShop{}), "tenant_id").
Where("status = ?", PickupShopStatusActive)
if val := strings.TrimSpace(platform); val != "" {
shopDB = shopDB.Where("platform = ? OR platform = ''", val)
}
var configuredNames []string
if err := shopDB.Order("sort_order DESC, name ASC").Pluck("name", &configuredNames).Error; err == nil {
for _, name := range configuredNames {
trimmed := strings.TrimSpace(name)
if trimmed != "" {
if _, ok := seen[trimmed]; !ok {
seen[trimmed] = struct{}{}
result = append(result, trimmed)
}
}
}
}
// 2. 查询 admin_pickups 中的历史店铺作为补充
historyDB := pickupTenantScope(ctx, r.db.WithContext(ctx).Model(&model.AdminPickup{}), "tenant_id").
Where("shop_name <> ''")
if val := strings.TrimSpace(platform); val != "" {
historyDB = historyDB.Where("platform = ?", val)
}
var historyNames []string
if err := historyDB.Distinct("shop_name").Order("shop_name ASC").Limit(200).Pluck("shop_name", &historyNames).Error; err != nil {
return nil, err
}
for _, name := range historyNames {
trimmed := strings.TrimSpace(name)
if trimmed != "" {
if _, ok := seen[trimmed]; !ok {
seen[trimmed] = struct{}{}
result = append(result, trimmed)
}
}
}
return result, nil
}
// ListShops 查询店铺配置列表
func (r *Repository) ListShops(ctx context.Context, query PickupShopQuery) ([]PickupShopDTO, error) {
if r == nil || r.db == nil {
return nil, ErrDependencyUnavailable
}
db := pickupTenantScope(ctx, r.db.WithContext(ctx).Model(&model.PickupShop{}), "tenant_id")
if kw := strings.TrimSpace(query.Keyword); kw != "" {
like := "%" + kw + "%"
db = db.Where("name LIKE ? OR remark LIKE ?", like, like)
}
if p := strings.TrimSpace(query.Platform); p != "" {
db = db.Where("platform = ?", p)
}
if s := strings.TrimSpace(query.Status); s != "" {
db = db.Where("status = ?", s)
}
var rows []model.PickupShop
if err := db.Order("sort_order DESC, id DESC").Find(&rows).Error; err != nil {
return nil, err
}
items := make([]PickupShopDTO, 0, len(rows))
for _, row := range rows {
items = append(items, PickupShopDTO{
ID: row.ID,
Name: row.Name,
Platform: row.Platform,
Status: row.Status,
SortOrder: row.SortOrder,
Remark: row.Remark,
CreatedAt: row.CreatedAt,
UpdatedAt: row.UpdatedAt,
})
}
return items, nil
}
// CreateShop 创建店铺配置
func (r *Repository) CreateShop(ctx context.Context, req CreatePickupShopRequest, adminID uint64, meta auditlog.Meta) (*PickupShopDTO, error) {
if r == nil || r.db == nil {
return nil, ErrDependencyUnavailable
}
name := strings.TrimSpace(req.Name)
if name == "" {
return nil, ErrInvalidAmount
}
var count int64
tenantID := tenancy.IDFromContext(ctx)
if err := pickupTenantScope(ctx, r.db.WithContext(ctx).Model(&model.PickupShop{}), "tenant_id").
Where("name = ?", name).Count(&count).Error; err != nil {
return nil, err
}
if count > 0 {
return nil, ErrPickupShopNameExists
}
status := strings.TrimSpace(req.Status)
if status == "" {
status = PickupShopStatusActive
}
now := time.Now()
shop := model.PickupShop{
TenantID: tenantID,
Name: name,
Platform: strings.TrimSpace(req.Platform),
Status: status,
SortOrder: req.SortOrder,
Remark: strings.TrimSpace(req.Remark),
CreatedAt: now,
UpdatedAt: now,
}
if err := r.db.WithContext(ctx).Create(&shop).Error; err != nil {
return nil, err
}
bid := shop.ID
_ = auditlog.Append(r.db.WithContext(ctx), auditlog.Entry{
ActorType: "admin",
ActorID: adminID,
Action: "pickup_shop_create",
BizType: "pickup_shop",
BizID: &bid,
Meta: meta,
Detail: map[string]any{
"tenant_id": tenantID,
"shop_id": shop.ID,
"name": shop.Name,
"platform": shop.Platform,
"status": shop.Status,
},
})
return &PickupShopDTO{
ID: shop.ID,
Name: shop.Name,
Platform: shop.Platform,
Status: shop.Status,
SortOrder: shop.SortOrder,
Remark: shop.Remark,
CreatedAt: shop.CreatedAt,
UpdatedAt: shop.UpdatedAt,
}, nil
}
// UpdateShop 更新店铺配置
func (r *Repository) UpdateShop(ctx context.Context, id uint64, req UpdatePickupShopRequest, adminID uint64, meta auditlog.Meta) (*PickupShopDTO, error) {
if r == nil || r.db == nil {
return nil, ErrDependencyUnavailable
}
name := strings.TrimSpace(req.Name)
if name == "" {
return nil, ErrInvalidAmount
}
var shop model.PickupShop
if err := pickupTenantScope(ctx, r.db.WithContext(ctx), "tenant_id").First(&shop, id).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, ErrPickupShopNotFound
}
return nil, err
}
var count int64
if err := pickupTenantScope(ctx, r.db.WithContext(ctx).Model(&model.PickupShop{}), "tenant_id").
Where("name = ? AND id <> ?", name, id).Count(&count).Error; err != nil {
return nil, err
}
if count > 0 {
return nil, ErrPickupShopNameExists
}
shop.Name = name
shop.Platform = strings.TrimSpace(req.Platform)
shop.Status = strings.TrimSpace(req.Status)
shop.SortOrder = req.SortOrder
shop.Remark = strings.TrimSpace(req.Remark)
shop.UpdatedAt = time.Now()
if err := r.db.WithContext(ctx).Save(&shop).Error; err != nil {
return nil, err
}
bid := shop.ID
_ = auditlog.Append(r.db.WithContext(ctx), auditlog.Entry{
ActorType: "admin",
ActorID: adminID,
Action: "pickup_shop_update",
BizType: "pickup_shop",
BizID: &bid,
Meta: meta,
Detail: map[string]any{
"tenant_id": shop.TenantID,
"shop_id": shop.ID,
"name": shop.Name,
"platform": shop.Platform,
"status": shop.Status,
},
})
return &PickupShopDTO{
ID: shop.ID,
Name: shop.Name,
Platform: shop.Platform,
Status: shop.Status,
SortOrder: shop.SortOrder,
Remark: shop.Remark,
CreatedAt: shop.CreatedAt,
UpdatedAt: shop.UpdatedAt,
}, nil
}
// DeleteShop 删除店铺配置
func (r *Repository) DeleteShop(ctx context.Context, id uint64, adminID uint64, meta auditlog.Meta) error {
if r == nil || r.db == nil {
return ErrDependencyUnavailable
}
var shop model.PickupShop
if err := pickupTenantScope(ctx, r.db.WithContext(ctx), "tenant_id").First(&shop, id).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return ErrPickupShopNotFound
}
return err
}
if err := r.db.WithContext(ctx).Delete(&shop).Error; err != nil {
return err
}
bid := shop.ID
_ = auditlog.Append(r.db.WithContext(ctx), auditlog.Entry{
ActorType: "admin",
ActorID: adminID,
Action: "pickup_shop_delete",
BizType: "pickup_shop",
BizID: &bid,
Meta: meta,
Detail: map[string]any{
"tenant_id": shop.TenantID,
"shop_id": shop.ID,
"name": shop.Name,
},
})
return nil
}
// GetHistoricalShopStats 聚合统计 admin_pickups 中的全部历史店铺,并对照标准库与映射规则
func (r *Repository) GetHistoricalShopStats(ctx context.Context) (*PickupShopHistoricalStatsDTO, error) {
if r == nil || r.db == nil {
return nil, ErrDependencyUnavailable
}
type rawCountRow struct {
SourceName string `gorm:"column:source_name"`
Cnt int64 `gorm:"column:cnt"`
}
var rows []rawCountRow
err := pickupTenantScope(ctx, r.db.WithContext(ctx).Model(&model.AdminPickup{}), "tenant_id").
Select("CASE WHEN raw_shop_name <> '' THEN raw_shop_name ELSE shop_name END AS source_name, COUNT(*) AS cnt").
Group("source_name").
Order("cnt DESC, source_name ASC").
Scan(&rows).Error
if err != nil {
return nil, err
}
var standardShops []model.PickupShop
if err := pickupTenantScope(ctx, r.db.WithContext(ctx).Model(&model.PickupShop{}), "tenant_id").
Find(&standardShops).Error; err != nil {
return nil, err
}
standardMap := make(map[string]model.PickupShop)
for _, s := range standardShops {
standardMap[s.Name] = s
}
var mappings []model.PickupShopMapping
if err := pickupTenantScope(ctx, r.db.WithContext(ctx).Model(&model.PickupShopMapping{}), "tenant_id").
Find(&mappings).Error; err != nil {
return nil, err
}
mappingMap := make(map[string]model.PickupShopMapping)
for _, m := range mappings {
mappingMap[m.SourceName] = m
}
var totalPickups int64
standardCount := 0
mappedCount := 0
unmappedCount := 0
seenSource := make(map[string]bool)
items := make([]PickupShopHistoricalItemDTO, 0, len(rows)+len(mappings))
for _, row := range rows {
seenSource[row.SourceName] = true
totalPickups += row.Cnt
item := PickupShopHistoricalItemDTO{
SourceName: row.SourceName,
Count: row.Cnt,
}
if mapping, ok := mappingMap[row.SourceName]; ok {
item.MappingStatus = "mapped"
item.TargetShopID = mapping.TargetShopID
item.TargetShopName = mapping.TargetShopName
item.Remark = mapping.Remark
mappedCount++
} else if std, ok := standardMap[row.SourceName]; ok && row.SourceName != "" {
item.MappingStatus = "standard"
item.TargetShopID = std.ID
item.TargetShopName = std.Name
standardCount++
} else {
item.MappingStatus = "unmapped"
unmappedCount++
}
items = append(items, item)
}
for _, m := range mappings {
if !seenSource[m.SourceName] {
mappedCount++
items = append(items, PickupShopHistoricalItemDTO{
SourceName: m.SourceName,
Count: m.MappedCount,
MappingStatus: "mapped",
TargetShopID: m.TargetShopID,
TargetShopName: m.TargetShopName,
Remark: m.Remark,
})
}
}
return &PickupShopHistoricalStatsDTO{
Items: items,
TotalPickups: totalPickups,
TotalShops: len(items),
StandardCount: standardCount,
MappedCount: mappedCount,
UnmappedCount: unmappedCount,
}, nil
}
// MapHistoricalShops 批量将历史店铺名称映射至目标标准店铺,并同步清洗历史提号单中的店铺名
func (r *Repository) MapHistoricalShops(ctx context.Context, req MapHistoricalShopsRequest, adminID uint64, meta auditlog.Meta) (*MapHistoricalShopsResultDTO, error) {
if r == nil || r.db == nil {
return nil, ErrDependencyUnavailable
}
targetName := strings.TrimSpace(req.TargetShopName)
if targetName == "" {
return nil, ErrInvalidAmount
}
fromNames := make([]string, 0, len(req.FromShopNames))
seen := make(map[string]bool)
for _, name := range req.FromShopNames {
if seen[name] {
continue
}
seen[name] = true
fromNames = append(fromNames, name)
}
if len(fromNames) == 0 {
return nil, ErrInvalidAmount
}
var result MapHistoricalShopsResultDTO
result.TargetShopName = targetName
tenantID := tenancy.IDFromContext(ctx)
err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
var targetShop model.PickupShop
findErr := pickupTenantScope(ctx, tx, "tenant_id").Where("name = ?", targetName).First(&targetShop).Error
if errors.Is(findErr, gorm.ErrRecordNotFound) {
if !req.CreateTargetMissing {
return ErrPickupShopNotFound
}
now := time.Now()
targetShop = model.PickupShop{
TenantID: tenantID,
Name: targetName,
Platform: strings.TrimSpace(req.TargetPlatform),
Status: PickupShopStatusActive,
SortOrder: 0,
Remark: "历史映射自动创建",
CreatedAt: now,
UpdatedAt: now,
}
if err := tx.Create(&targetShop).Error; err != nil {
return err
}
result.CreatedStandardShop = true
} else if findErr != nil {
return findErr
}
result.TargetShopID = targetShop.ID
// 将未初始化 raw_shop_name 的记录填入旧 shop_name
if err := tx.Exec(`UPDATE admin_pickups
SET raw_shop_name = shop_name
WHERE (raw_shop_name = '' OR raw_shop_name IS NULL)
AND tenant_id = ?
AND (shop_name IN ? OR (shop_name = '' AND '' IN ?))`, tenantID, fromNames, fromNames).Error; err != nil {
return err
}
// 批量更新 admin_pickups 的 shop_name
res := pickupTenantScope(ctx, tx.Model(&model.AdminPickup{}), "tenant_id").
Where("raw_shop_name IN ?", fromNames).
Update("shop_name", targetName)
if res.Error != nil {
return res.Error
}
result.UpdatedPickupsCount = res.RowsAffected
now := time.Now()
for _, fromName := range fromNames {
if fromName == targetName {
continue
}
var mappedCount int64
pickupTenantScope(ctx, tx.Model(&model.AdminPickup{}), "tenant_id").
Where("raw_shop_name = ?", fromName).Count(&mappedCount)
var existing model.PickupShopMapping
if err := pickupTenantScope(ctx, tx, "tenant_id").
Where("source_name = ?", fromName).First(&existing).Error; errors.Is(err, gorm.ErrRecordNotFound) {
newMapping := model.PickupShopMapping{
TenantID: tenantID,
SourceName: fromName,
TargetShopID: targetShop.ID,
TargetShopName: targetName,
MappedCount: mappedCount,
Remark: strings.TrimSpace(req.Remark),
CreatedAt: now,
UpdatedAt: now,
}
if err := tx.Create(&newMapping).Error; err != nil {
return err
}
} else if err == nil {
existing.TargetShopID = targetShop.ID
existing.TargetShopName = targetName
existing.MappedCount = mappedCount
if req.Remark != "" {
existing.Remark = strings.TrimSpace(req.Remark)
}
existing.UpdatedAt = now
if err := tx.Save(&existing).Error; err != nil {
return err
}
} else {
return err
}
}
bid := targetShop.ID
_ = auditlog.Append(tx, auditlog.Entry{
ActorType: "admin",
ActorID: adminID,
Action: "pickup_shop_map_historical",
BizType: "pickup_shop",
BizID: &bid,
Meta: meta,
Detail: map[string]any{
"tenant_id": tenantID,
"target_shop_id": targetShop.ID,
"target_shop_name": targetName,
"from_shop_names": fromNames,
"updated_count": result.UpdatedPickupsCount,
},
})
return nil
})
if err != nil {
return nil, err
}
return &result, nil
}
// DeleteShopMapping 删除指定历史店铺的映射规则,并还原历史提号单中的原始店铺名
func (r *Repository) DeleteShopMapping(ctx context.Context, sourceName string, adminID uint64, meta auditlog.Meta) error {
if r == nil || r.db == nil {
return ErrDependencyUnavailable
}
return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
var mapping model.PickupShopMapping
if err := pickupTenantScope(ctx, tx, "tenant_id").
Where("source_name = ?", sourceName).First(&mapping).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil
}
return err
}
if err := pickupTenantScope(ctx, tx.Model(&model.AdminPickup{}), "tenant_id").
Where("raw_shop_name = ?", sourceName).
Update("shop_name", sourceName).Error; err != nil {
return err
}
if err := tx.Delete(&mapping).Error; err != nil {
return err
}
bid := mapping.ID
_ = auditlog.Append(tx, auditlog.Entry{
ActorType: "admin",
ActorID: adminID,
Action: "pickup_shop_unmap_historical",
BizType: "pickup_shop",
BizID: &bid,
Meta: meta,
Detail: map[string]any{
"tenant_id": mapping.TenantID,
"source_name": sourceName,
"target_shop_name": mapping.TargetShopName,
},
})
return nil
})
}
func (r *Repository) ListForSeller(ctx context.Context, ownerID uint64, query SellerPickupQuery) (*PaginatedResult, error) {
if r == nil || r.db == nil {
return nil, ErrDependencyUnavailable
}
db := r.baseQuery(ctx).Where("p.owner_id = ?", ownerID)
if status := strings.TrimSpace(query.Status); status != "" {
db = db.Where("p.status = ?", status)
}
return r.paginatePickups(db, query.Page, query.PageSize, true)
}
func (r *Repository) paginatePickups(db *gorm.DB, page, pageSize int, sellerView bool) (*PaginatedResult, error) {
page, pageSize = normalizePaging(page, pageSize)
var rows []pickupRow
if err := db.Order("p.id DESC").Offset((page - 1) * pageSize).Limit(pageSize).Scan(&rows).Error; err != nil {
return nil, err
}
var total int64
if page == 1 && len(rows) < pageSize {
total = int64(len(rows))
} else {
// 使用独立干净的 Count 查询,避免触发 baseQuery 中的关联子查询
countDB := db.Session(&gorm.Session{}).Select("p.id")
if err := countDB.Count(&total).Error; err != nil {
return nil, err
}
}
items := make([]PickupDTO, 0, len(rows))
for _, row := range rows {
item := row.toDTO()
item.AccountSnapshot = nil
if sellerView {
item.WebsiteProfitCent = 0
item.ProfitAmountCent = 0
item.ProfitAdjustmentCent = 0
item.EffectiveProfitAmountCent = 0
item.BuyerRatio = 0
item.ShopName = ""
item.SourceChannel = ""
}
items = append(items, item)
}
return &PaginatedResult{Items: items, Total: total, Page: page, PageSize: pageSize}, nil
}
// ListAvailableListings 可提号的 listing:已发布、已审核、未在交易中。
func (r *Repository) ListAvailableListings(ctx context.Context, query AvailableListingQuery) (*AvailableListingsResult, error) {
if r == nil || r.db == nil {
return nil, ErrDependencyUnavailable
}
latestUploads := r.db.WithContext(ctx).Table("listing_uploads").
Select("listing_id, MAX(id) AS upload_id").
Where("listing_id IS NOT NULL").
Group("listing_id")
buildQuery := func() *gorm.DB {
q := r.db.WithContext(ctx).Table("rental_listings AS l").
Joins("JOIN game_accounts AS a ON a.id = l.account_id").
Joins("JOIN users AS owner ON owner.id = l.owner_id").
Joins("LEFT JOIN tenants AS source_tenant ON source_tenant.id = l.source_tenant_id").
Joins("LEFT JOIN (?) AS latest_upload ON latest_upload.listing_id = l.id", latestUploads).
Joins("LEFT JOIN listing_uploads AS lu ON lu.id = latest_upload.upload_id").
Where("l.status = ? AND l.review_status = ? AND l.in_transaction = ?", "published", "approved", false).
Where("(l.distribution_site_id IS NULL OR l.distribution_site_id = 0)")
if kw := strings.TrimSpace(query.Keyword); kw != "" {
upper := strings.ToUpper(kw)
if strings.HasPrefix(upper, "L") || (len(kw) >= 12 && isAllDigits(kw)) {
q = q.Where("l.listing_no = ?", kw)
} else {
like := "%" + kw + "%"
q = q.Where("l.listing_no LIKE ? OR a.title LIKE ?", like, like)
}
}
switch strings.TrimSpace(query.SourceType) {
case ListingSourceExternal:
q = q.Where("lu.id IS NOT NULL")
case ListingSourceInternal:
q = q.Where("lu.id IS NULL")
}
return q
}
page, pageSize := normalizePaging(query.Page, query.PageSize)
var rows []availableListingRow
if err := buildQuery().Select(`l.id, l.source_tenant_id,
COALESCE(source_tenant.code, '') AS source_tenant_code,
COALESCE(source_tenant.name, '') AS source_tenant_name,
l.listing_no, l.account_id, l.owner_id, l.price_cent AS listing_price_cent,
a.title AS account_title, a.server_region, a.login_platform, a.haf_coin_amount, a.asset_summary,
owner.phone AS owner_phone, l.handoff_mode, l.settlement_mode,
CASE WHEN lu.id IS NULL THEN 0 ELSE 1 END AS is_external_upload,
COALESCE(lu.source_channel, '') AS source_channel`).
Order("l.id DESC").Offset((page - 1) * pageSize).Limit(pageSize).Scan(&rows).Error; err != nil {
return nil, err
}
var total int64
if page == 1 && len(rows) < pageSize {
total = int64(len(rows))
} else {
if err := buildQuery().Count(&total).Error; err != nil {
return nil, err
}
}
items := make([]AvailableListingDTO, 0, len(rows))
currentTenantID := tenancy.IDFromContext(ctx)
for _, row := range rows {
item := row.toDTO()
item.IsCrossTenant = currentTenantID > 0 && item.SourceTenantID > 0 && item.SourceTenantID != currentTenantID
items = append(items, item)
}
return &AvailableListingsResult{Items: items, Total: total, Page: page, PageSize: pageSize}, nil
}
func (r *Repository) baseQuery(ctx context.Context) *gorm.DB {
return r.db.WithContext(ctx).Table("admin_pickups AS p").
Select(`p.*, l.listing_no, a.title AS account_title, a.server_region, a.login_platform, owner.phone AS owner_phone,
COALESCE(pickup_tenant.code, '') AS tenant_code,
COALESCE(pickup_tenant.name, '') AS tenant_name,
COALESCE(source_tenant.code, '') AS source_tenant_code,
COALESCE(source_tenant.name, '') AS source_tenant_name,
COALESCE((SELECT SUM(fa.profit_delta_cent) FROM admin_pickup_financial_adjustments AS fa WHERE fa.pickup_id = p.id), 0) AS profit_adjustment_cent,
COALESCE((SELECT SUM(fa.settle_delta_cent) FROM admin_pickup_financial_adjustments AS fa WHERE fa.pickup_id = p.id), 0) AS settle_adjustment_cent`).
Joins("JOIN rental_listings AS l ON l.id = p.listing_id").
Joins("JOIN game_accounts AS a ON a.id = p.account_id").
Joins("JOIN users AS owner ON owner.id = p.owner_id").
Joins("LEFT JOIN tenants AS pickup_tenant ON pickup_tenant.id = p.tenant_id").
Joins("LEFT JOIN tenants AS source_tenant ON source_tenant.id = p.source_tenant_id")
}
func (r *Repository) adminBaseQuery(ctx context.Context) *gorm.DB {
return pickupTenantScope(ctx, r.baseQuery(ctx), "p.tenant_id")
}
type pickupRow struct {
model.AdminPickup
TenantCode string
TenantName string
SourceTenantCode string
SourceTenantName string
ListingNo string
AccountTitle string
ServerRegion string
LoginPlatform string
OwnerPhone string
ProfitAdjustmentCent int64
SettleAdjustmentCent int64
}
func (row pickupRow) toDTO() PickupDTO {
return PickupDTO{
ID: row.ID,
TenantID: row.TenantID,
TenantCode: row.TenantCode,
TenantName: row.TenantName,
SourceTenantID: row.SourceTenantID,
SourceTenantCode: row.SourceTenantCode,
SourceTenantName: row.SourceTenantName,
IsCrossTenant: row.TenantID > 0 && row.SourceTenantID > 0 && row.TenantID != row.SourceTenantID,
PickupNo: row.PickupNo,
ListingID: row.ListingID,
ListingNo: row.ListingNo,
AccountID: row.AccountID,
AccountTitle: row.AccountTitle,
ServerRegion: row.ServerRegion,
LoginPlatform: row.LoginPlatform,
OwnerID: row.OwnerID,
OwnerPhone: row.OwnerPhone,
AdminID: row.AdminID,
Operator: row.Operator,
Platform: row.Platform,
ThirdPartyOrderNo: row.ThirdPartyOrderNo,
ShopName: row.ShopName,
RawShopName: row.RawShopName,
AccountSource: row.AccountSource,
SourceChannel: row.SourceChannel,
SettlementMode: row.SettlementMode,
ListingPriceCent: row.ListingPriceCent,
OrderAmountCent: row.OrderAmountCent,
DepositAmountCent: row.DepositAmountCent,
OwnerPriceCent: row.OwnerPriceCent,
WebsiteProfitCent: row.WebsiteProfitCent,
ProfitAmountCent: row.ProfitAmountCent,
ProfitAdjustmentCent: row.ProfitAdjustmentCent,
EffectiveProfitAmountCent: row.ProfitAmountCent + row.ProfitAdjustmentCent,
SellerRatio: row.SellerRatio,
BuyerRatio: row.BuyerRatio,
AccountSnapshot: row.AccountSnapshot,
SettleAmountCent: row.SettleAmountCent,
SettleAdjustmentCent: row.SettleAdjustmentCent,
EffectiveSettleAmountCent: row.SettleAmountCent + row.SettleAdjustmentCent,
Status: row.Status,
OfflineSettlementStatus: row.OfflineSettlementStatus,
OfflineSettlementRemark: row.OfflineSettlementRemark,
ActualPayoutOperator: row.ActualPayoutOperator,
OfflineSettledBy: row.OfflineSettledBy,
OfflineSettledAt: row.OfflineSettledAt,
Remark: row.Remark,
CompleteRemark: row.CompleteRemark,
CreatedAt: row.CreatedAt,
CompletedAt: row.CompletedAt,
CancelledAt: row.CancelledAt,
}
}
type pickupAdjustmentTotals struct {
ProfitAdjustmentCent int64
SettleAdjustmentCent int64
}
type pendingPickupAdjustmentTotals struct {
SettleAdjustmentCent int64
Count int64
}
func pickupFinancialAdjustmentTotals(db *gorm.DB, pickupID uint64) (pickupAdjustmentTotals, error) {
var totals pickupAdjustmentTotals
err := db.Model(&model.AdminPickupFinancialAdjustment{}).
Select(`COALESCE(SUM(profit_delta_cent), 0) AS profit_adjustment_cent,
COALESCE(SUM(settle_delta_cent), 0) AS settle_adjustment_cent`).
Where("pickup_id = ?", pickupID).
Scan(&totals).Error
return totals, err
}
func pendingPickupFinancialAdjustmentTotals(db *gorm.DB, pickupID uint64) (pendingPickupAdjustmentTotals, error) {
var totals pendingPickupAdjustmentTotals
err := db.Model(&model.AdminPickupFinancialAdjustment{}).
Select(`COALESCE(SUM(settle_delta_cent), 0) AS settle_adjustment_cent, COUNT(id) AS count`).
Where("pickup_id = ? AND status IN ?", pickupID, []string{FinancialAdjustmentStatusPending, FinancialAdjustmentStatusRecovery}).
Scan(&totals).Error
return totals, err
}
func pickupSettlementMode(listingMode, accountSource string) string {
if listingMode == SettlementModePlatformManaged || accountSource == AccountSourceExternalPlatformManaged {
return SettlementModePlatformManaged
}
return SettlementModeOwnerWallet
}
func pickupRequiresOfflineSettlement(pickup model.AdminPickup) bool {
return pickup.SettlementMode == SettlementModePlatformManaged
}
type availableListingRow struct {
ID uint64
SourceTenantID uint64
SourceTenantCode string
SourceTenantName string
ListingNo string
AccountID uint64
AccountTitle string
ServerRegion string
LoginPlatform string
OwnerID uint64
OwnerPhone string
ListingPriceCent int64
HafCoinAmount int64
AssetSummary datatypes.JSON
IsExternalUpload bool
SourceChannel string
HandoffMode string
SettlementMode string
}
func (row availableListingRow) toDTO() AvailableListingDTO {
snapshot := buildPickupPriceSnapshot(
model.RentalListing{PriceCent: row.ListingPriceCent},
model.GameAccount{HafCoinAmount: row.HafCoinAmount, AssetSummary: row.AssetSummary},
)
accountSource := AccountSourceInternal
if row.IsExternalUpload {
accountSource = AccountSourceExternalPlatformManaged
}
return AvailableListingDTO{
ID: row.ID,
SourceTenantID: row.SourceTenantID,
SourceTenantCode: row.SourceTenantCode,
SourceTenantName: row.SourceTenantName,
ListingNo: row.ListingNo,
AccountID: row.AccountID,
AccountTitle: row.AccountTitle,
ServerRegion: row.ServerRegion,
LoginPlatform: row.LoginPlatform,
OwnerID: row.OwnerID,
OwnerPhone: row.OwnerPhone,
ListingPriceCent: snapshot.ListingPriceCent,
OwnerPriceCent: snapshot.OwnerPriceCent,
OwnerPurePriceCent: snapshot.OwnerPurePriceCent,
OwnerExtraItemPriceCent: snapshot.OwnerExtraItemPriceCent,
OwnerTotalPriceCent: snapshot.OwnerTotalPriceCent,
WebsiteProfitCent: snapshot.WebsiteProfitCent,
SellerRatio: snapshot.SellerRatio,
BuyerRatio: snapshot.BuyerRatio,
AccountSource: accountSource,
IsExternalUpload: row.IsExternalUpload,
SourceChannel: row.SourceChannel,
HandoffMode: row.HandoffMode,
SettlementMode: row.SettlementMode,
}
}
func resolvePickupAccountSource(tx *gorm.DB, listingID uint64) (string, string, error) {
var upload model.ListingUpload
err := tx.Where("listing_id = ?", listingID).Order("id DESC").First(&upload).Error
if errors.Is(err, gorm.ErrRecordNotFound) {
return AccountSourceInternal, "", nil
}
if err != nil {
return "", "", err
}
return AccountSourceExternalPlatformManaged, strings.TrimSpace(upload.SourceChannel), nil
}
func makePickupAccountSnapshot(account model.GameAccount, listing model.RentalListing) (datatypes.JSON, error) {
payload := map[string]any{
"listing_id": listing.ID,
"listing_no": listing.ListingNo,
"account_id": account.ID,
"title": account.Title,
"game_name": account.GameName,
"server_region": account.ServerRegion,
"login_platform": account.LoginPlatform,
"rank_level": account.RankLevel,
"haf_coin_amount": account.HafCoinAmount,
"asset_summary": account.AssetSummary,
"season_tags": account.SeasonTags,
"screenshot_urls": account.ScreenshotURLS,
"snapshot_version": 1,
}
raw, err := json.Marshal(payload)
return datatypes.JSON(raw), err
}
func (r *Repository) fallbackAccountSnapshot(ctx context.Context, listingID uint64, accountID uint64) (datatypes.JSON, error) {
var listing model.RentalListing
if err := r.db.WithContext(ctx).First(&listing, listingID).Error; err != nil {
return nil, err
}
var account model.GameAccount
if err := r.db.WithContext(ctx).First(&account, accountID).Error; err != nil {
return nil, err
}
return makePickupAccountSnapshot(account, listing)
}
func isEmptyPickupAccountSnapshot(raw datatypes.JSON) bool {
trimmed := strings.TrimSpace(string(raw))
return trimmed == "" || trimmed == "null" || trimmed == "{}"
}
type pickupPriceSnapshot struct {
ListingPriceCent int64
OwnerPriceCent int64
OwnerPurePriceCent int64
OwnerExtraItemPriceCent int64
OwnerTotalPriceCent int64
WebsiteProfitCent int64
SellerRatio float64
BuyerRatio float64
}
func buildPickupPriceSnapshot(listing model.RentalListing, account model.GameAccount) pickupPriceSnapshot {
summary := decodePickupAssetSummary(account.AssetSummary)
breakdown := pickupPriceBreakdown(summary)
listingPriceCent := maxPickupCent(listing.PriceCent, 0)
ownerPurePriceCent := yuanToPickupCent(readPickupNumber(breakdown["seller_coin_base_price"]))
ownerExtraItemPriceCent := yuanToPickupCent(readPickupNumber(breakdown["consumable_price"]))
ownerTotalPriceCent := yuanToPickupCent(readPickupNumber(breakdown["seller_total_price"]))
if ownerTotalPriceCent <= 0 && (ownerPurePriceCent > 0 || ownerExtraItemPriceCent > 0) {
ownerTotalPriceCent = ownerPurePriceCent + ownerExtraItemPriceCent
}
if ownerTotalPriceCent <= 0 || (listingPriceCent > 0 && ownerTotalPriceCent > listingPriceCent) {
ownerTotalPriceCent = listingPriceCent
}
ownerPurePriceCent, ownerExtraItemPriceCent = normalizePickupOwnerPriceSplit(
ownerTotalPriceCent,
ownerPurePriceCent,
ownerExtraItemPriceCent,
)
websiteProfitCent := yuanToPickupCent(readPickupNumber(breakdown["platform_markup_amount"]))
if websiteProfitCent <= 0 {
websiteProfitCent = listingPriceCent - ownerTotalPriceCent
}
if websiteProfitCent < 0 {
websiteProfitCent = 0
}
sellerRatio := readPickupNumber(breakdown["seller_ratio"])
if sellerRatio <= 0 {
sellerRatio = ratioFromCoin(account.HafCoinAmount, readPickupNumber(breakdown["seller_coin_base_price"]))
}
buyerRatio := readPickupNumber(breakdown["buyer_ratio"])
if buyerRatio <= 0 {
buyerRatio = readPickupNumber(summary["publish_ratio"])
}
if buyerRatio <= 0 {
buyerRatio = ratioFromCoin(account.HafCoinAmount, readPickupNumber(breakdown["buyer_coin_base_price"]))
}
return pickupPriceSnapshot{
ListingPriceCent: listingPriceCent,
OwnerPriceCent: ownerTotalPriceCent,
OwnerPurePriceCent: ownerPurePriceCent,
OwnerExtraItemPriceCent: ownerExtraItemPriceCent,
OwnerTotalPriceCent: ownerTotalPriceCent,
WebsiteProfitCent: websiteProfitCent,
SellerRatio: roundPickupRatio(sellerRatio),
BuyerRatio: roundPickupRatio(buyerRatio),
}
}
func normalizePickupOwnerPriceSplit(totalCent, pureCent, extraCent int64) (int64, int64) {
if totalCent <= 0 {
return 0, 0
}
pureCent = maxPickupCent(pureCent, 0)
extraCent = maxPickupCent(extraCent, 0)
switch {
case pureCent == 0 && extraCent == 0:
pureCent = totalCent
case pureCent == 0:
pureCent = maxPickupCent(totalCent-extraCent, 0)
case extraCent == 0:
extraCent = maxPickupCent(totalCent-pureCent, 0)
case pureCent+extraCent != totalCent:
if pureCent > totalCent {
pureCent = totalCent
extraCent = 0
} else {
extraCent = totalCent - pureCent
}
}
return pureCent, extraCent
}
func decodePickupAssetSummary(raw datatypes.JSON) map[string]any {
if len(raw) == 0 {
return map[string]any{}
}
var summary map[string]any
if err := json.Unmarshal(raw, &summary); err != nil {
return map[string]any{}
}
return summary
}
func pickupPriceBreakdown(summary map[string]any) map[string]any {
if summary == nil {
return map[string]any{}
}
if breakdown, ok := summary["price_breakdown"].(map[string]any); ok {
return breakdown
}
if raw, ok := summary["price_breakdown"].(string); ok && strings.TrimSpace(raw) != "" {
var breakdown map[string]any
if err := json.Unmarshal([]byte(raw), &breakdown); err == nil {
return breakdown
}
}
return map[string]any{}
}
func readPickupNumber(value any) float64 {
switch typed := value.(type) {
case float64:
return typed
case float32:
return float64(typed)
case int:
return float64(typed)
case int64:
return float64(typed)
case json.Number:
number, err := typed.Float64()
if err != nil {
return 0
}
return number
case string:
number, err := strconv.ParseFloat(strings.TrimSpace(typed), 64)
if err != nil {
return 0
}
return number
default:
return 0
}
}
func yuanToPickupCent(value float64) int64 {
if value <= 0 || math.IsNaN(value) || math.IsInf(value, 0) {
return 0
}
return int64(math.Round(value * 100))
}
func ratioFromCoin(coinAmount int64, basePrice float64) float64 {
if coinAmount <= 0 || basePrice <= 0 {
return 0
}
return float64(coinAmount) / 10000 / basePrice
}
func roundPickupRatio(value float64) float64 {
if value <= 0 || math.IsNaN(value) || math.IsInf(value, 0) {
return 0
}
return math.Round(value*100) / 100
}
func maxPickupCent(a, b int64) int64 {
if a > b {
return a
}
return b
}
// pickupRebateGrossBasis 取网站加价与线下利润的较小值,负数按 0 处理。
func pickupRebateGrossBasis(websiteProfitCent, offlineProfitCent int64) int64 {
if websiteProfitCent < 0 {
websiteProfitCent = 0
}
if offlineProfitCent < 0 {
offlineProfitCent = 0
}
if websiteProfitCent < offlineProfitCent {
return websiteProfitCent
}
return offlineProfitCent
}
func normalizePaging(page, pageSize int) (int, int) {
if page < 1 {
page = 1
}
if pageSize < 1 {
pageSize = 20
}
if pageSize > 100 {
pageSize = 100
}
return page, pageSize
}
// newPickupNo 生成提号编号:PK + YYYYMMDDHHMMSS + 3位随机。
func newPickupNo() (string, error) {
now := timeutil.ShanghaiNow()
timeStr := now.Format("20060102150405")
buf := make([]byte, 2)
if _, err := crand.Read(buf); err != nil {
return "", err
}
randomNum := (int(buf[0])<<8 | int(buf[1])) % 1000
return "PK" + timeStr + strconv.Itoa(1000 + randomNum)[1:], nil
}
func isAllDigits(s string) bool {
if s == "" {
return false
}
for i := 0; i < len(s); i++ {
if s[i] < '0' || s[i] > '9' {
return false
}
}
return true
}
func isPhoneKeyword(s string) bool {
return len(s) == 11 && s[0] == '1' && isAllDigits(s)
}