531 lines
17 KiB
Go
531 lines
17 KiB
Go
package service
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"math"
|
|
"strings"
|
|
"time"
|
|
|
|
"affiliate_dash/internal/model"
|
|
|
|
"github.com/google/uuid"
|
|
"gorm.io/gorm"
|
|
"gorm.io/gorm/clause"
|
|
)
|
|
|
|
type FulfillmentService struct {
|
|
db *gorm.DB
|
|
callbacks *CallbackService
|
|
}
|
|
|
|
func NewFulfillmentService(db *gorm.DB, callbacks *CallbackService) *FulfillmentService {
|
|
return &FulfillmentService{db: db, callbacks: callbacks}
|
|
}
|
|
|
|
type CreateFulfillmentOrderInput struct {
|
|
MerchantID uint
|
|
APIClientID uint
|
|
ClientOrderNo string
|
|
SKU string
|
|
Quantity int64
|
|
BuyerReference string
|
|
RequestData interface{}
|
|
}
|
|
|
|
type CreateFulfillmentOrderResult struct {
|
|
Order *model.FulfillmentOrder `json:"order"`
|
|
Idempotent bool `json:"idempotent"`
|
|
}
|
|
|
|
func (s *FulfillmentService) CreateOrder(in CreateFulfillmentOrderInput) (*CreateFulfillmentOrderResult, error) {
|
|
in.ClientOrderNo = strings.TrimSpace(in.ClientOrderNo)
|
|
in.SKU = strings.TrimSpace(in.SKU)
|
|
if in.MerchantID == 0 || in.APIClientID == 0 {
|
|
return nil, errors.New("无效的商户或 API 客户端")
|
|
}
|
|
if in.ClientOrderNo == "" || len(in.ClientOrderNo) > 96 {
|
|
return nil, errors.New("client_order_no 不能为空且最长 96 位")
|
|
}
|
|
if in.SKU == "" {
|
|
return nil, errors.New("sku 不能为空")
|
|
}
|
|
if in.Quantity == 0 {
|
|
in.Quantity = 1
|
|
}
|
|
if in.Quantity < 1 {
|
|
return nil, errors.New("quantity 必须大于零")
|
|
}
|
|
requestData := ""
|
|
if in.RequestData != nil {
|
|
raw, err := json.Marshal(in.RequestData)
|
|
if err != nil {
|
|
return nil, errors.New("订单请求数据无法序列化")
|
|
}
|
|
requestData = string(raw)
|
|
}
|
|
|
|
result := &CreateFulfillmentOrderResult{}
|
|
err := s.db.Transaction(func(tx *gorm.DB) error {
|
|
var existing model.FulfillmentOrder
|
|
err := tx.Where("merchant_id = ? AND client_order_no = ?", in.MerchantID, in.ClientOrderNo).First(&existing).Error
|
|
if err == nil {
|
|
result.Order = &existing
|
|
result.Idempotent = true
|
|
return nil
|
|
}
|
|
if !errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return err
|
|
}
|
|
|
|
var product model.MerchantProduct
|
|
if err := tx.Preload("Product").Clauses(clause.Locking{Strength: "UPDATE"}).
|
|
Where("merchant_id = ? AND sku = ? AND status = ?", in.MerchantID, in.SKU, model.ProductStatusActive).
|
|
First(&product).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return errors.New("商品不存在或已下架")
|
|
}
|
|
return err
|
|
}
|
|
if product.Product == nil || product.Product.Status != model.ProductStatusActive {
|
|
return errors.New("商品目录已下架")
|
|
}
|
|
if product.Stock >= 0 && product.Stock < in.Quantity {
|
|
return errors.New("商品库存不足")
|
|
}
|
|
if product.PriceAmount > 0 && in.Quantity > math.MaxInt64/product.PriceAmount {
|
|
return errors.New("订单金额超出范围")
|
|
}
|
|
totalAmount := product.PriceAmount * in.Quantity
|
|
|
|
var wallet model.WalletAccount
|
|
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
|
|
Where("merchant_id = ?", in.MerchantID).First(&wallet).Error; err != nil {
|
|
return err
|
|
}
|
|
if wallet.AvailableBalance < totalAmount {
|
|
return errors.New("商户钱包余额不足")
|
|
}
|
|
newBalance := wallet.AvailableBalance - totalAmount
|
|
if err := tx.Model(&wallet).Update("available_balance", newBalance).Error; err != nil {
|
|
return err
|
|
}
|
|
|
|
order := &model.FulfillmentOrder{
|
|
MerchantID: in.MerchantID,
|
|
OrderNo: newFulfillmentOrderNo(),
|
|
ClientOrderNo: in.ClientOrderNo,
|
|
MerchantProductID: product.ID,
|
|
ProductSKU: product.SKU,
|
|
ProductName: fallbackName(product.DisplayName, product.Product.Name),
|
|
Quantity: in.Quantity,
|
|
Amount: totalAmount,
|
|
Currency: product.Currency,
|
|
PaymentStatus: model.PaymentStatusPaid,
|
|
FulfillmentStatus: model.FulfillmentStatusPending,
|
|
BuyerReference: in.BuyerReference,
|
|
RequestData: requestData,
|
|
}
|
|
if err := tx.Create(order).Error; err != nil {
|
|
return err
|
|
}
|
|
idempotencyKey := in.ClientOrderNo
|
|
if err := tx.Create(&model.WalletLedgerEntry{
|
|
MerchantID: in.MerchantID,
|
|
WalletAccountID: wallet.ID,
|
|
EntryNo: "WL" + uuid.NewString(),
|
|
Type: model.WalletLedgerDebit,
|
|
Amount: -totalAmount,
|
|
BalanceAfter: newBalance,
|
|
ReferenceType: "fulfillment_order",
|
|
ReferenceNo: order.OrderNo,
|
|
IdempotencyKey: &idempotencyKey,
|
|
Note: "开放接口下单扣款",
|
|
}).Error; err != nil {
|
|
return err
|
|
}
|
|
if product.Stock >= 0 {
|
|
if err := tx.Model(&model.MerchantProduct{}).Where("id = ? AND stock >= ?", product.ID, in.Quantity).
|
|
Update("stock", gorm.Expr("stock - ?", in.Quantity)).Error; err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if err := tx.Create(&model.FulfillmentJob{
|
|
MerchantID: in.MerchantID,
|
|
OrderID: order.ID,
|
|
Status: model.FulfillmentJobStatusPending,
|
|
NextRunAt: time.Now(),
|
|
}).Error; err != nil {
|
|
return err
|
|
}
|
|
if err := writeAudit(tx, &in.MerchantID, nil, &in.APIClientID, "open_order.create", "fulfillment_order", order.OrderNo, map[string]interface{}{"client_order_no": in.ClientOrderNo, "sku": in.SKU}); err != nil {
|
|
return err
|
|
}
|
|
if s.callbacks != nil {
|
|
if err := s.callbacks.Enqueue(tx, in.MerchantID, "order.created", orderCallbackData(order)); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
result.Order = order
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
// 并发请求恰好同时通过首次查询时，唯一约束冲突后返回既有订单。
|
|
if strings.Contains(err.Error(), "duplicate") || strings.Contains(err.Error(), "UNIQUE") {
|
|
var existing model.FulfillmentOrder
|
|
if queryErr := s.db.Where("merchant_id = ? AND client_order_no = ?", in.MerchantID, in.ClientOrderNo).First(&existing).Error; queryErr == nil {
|
|
return &CreateFulfillmentOrderResult{Order: &existing, Idempotent: true}, nil
|
|
}
|
|
}
|
|
return nil, err
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func (s *FulfillmentService) GetOrder(merchantID uint, orderNo string) (*model.FulfillmentOrder, error) {
|
|
var order model.FulfillmentOrder
|
|
err := s.db.Preload("MerchantProduct.Product").
|
|
Where("merchant_id = ? AND order_no = ?", merchantID, orderNo).
|
|
First(&order).Error
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, errors.New("订单不存在")
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &order, nil
|
|
}
|
|
|
|
func (s *FulfillmentService) ListOrders(merchantID uint, page, size int, fulfillmentStatus string) ([]model.FulfillmentOrder, int64, error) {
|
|
page, size = normalizePage(page, size)
|
|
tx := s.db.Model(&model.FulfillmentOrder{}).Where("merchant_id = ?", merchantID)
|
|
if fulfillmentStatus != "" {
|
|
tx = tx.Where("fulfillment_status = ?", fulfillmentStatus)
|
|
}
|
|
var total int64
|
|
if err := tx.Count(&total).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
var orders []model.FulfillmentOrder
|
|
err := tx.Preload("MerchantProduct.Product").Order("id DESC").Offset((page - 1) * size).Limit(size).Find(&orders).Error
|
|
return orders, total, err
|
|
}
|
|
|
|
type FulfillmentUpdateInput struct {
|
|
MerchantID uint
|
|
APIClientID uint
|
|
OrderNo string
|
|
Status string
|
|
ProviderOrderNo string
|
|
FailureReason string
|
|
ResultData interface{}
|
|
}
|
|
|
|
func (s *FulfillmentService) UpdateFulfillment(in FulfillmentUpdateInput) (*model.FulfillmentOrder, error) {
|
|
switch in.Status {
|
|
case model.FulfillmentStatusProcessing, model.FulfillmentStatusSucceeded, model.FulfillmentStatusFailed:
|
|
default:
|
|
return nil, errors.New("无效的履约状态")
|
|
}
|
|
resultData := ""
|
|
if in.ResultData != nil {
|
|
raw, err := json.Marshal(in.ResultData)
|
|
if err != nil {
|
|
return nil, errors.New("履约结果无法序列化")
|
|
}
|
|
resultData = string(raw)
|
|
}
|
|
var out model.FulfillmentOrder
|
|
err := s.db.Transaction(func(tx *gorm.DB) error {
|
|
var order model.FulfillmentOrder
|
|
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
|
|
Where("merchant_id = ? AND order_no = ?", in.MerchantID, in.OrderNo).
|
|
First(&order).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return errors.New("订单不存在")
|
|
}
|
|
return err
|
|
}
|
|
if order.FulfillmentStatus == model.FulfillmentStatusCancelled {
|
|
return errors.New("订单已取消，不能更新履约状态")
|
|
}
|
|
if order.PaymentStatus != model.PaymentStatusPaid {
|
|
return errors.New("订单未支付，不能履约")
|
|
}
|
|
if order.FulfillmentStatus == model.FulfillmentStatusSucceeded && in.Status == model.FulfillmentStatusSucceeded {
|
|
out = order
|
|
return nil
|
|
}
|
|
if order.FulfillmentStatus == model.FulfillmentStatusSucceeded {
|
|
return errors.New("订单已履约成功，不能回退状态")
|
|
}
|
|
now := time.Now()
|
|
updates := map[string]interface{}{
|
|
"fulfillment_status": in.Status,
|
|
"result_data": resultData,
|
|
}
|
|
if in.ProviderOrderNo != "" {
|
|
updates["provider_order_no"] = in.ProviderOrderNo
|
|
}
|
|
switch in.Status {
|
|
case model.FulfillmentStatusSucceeded:
|
|
updates["delivered_at"] = now
|
|
updates["failure_reason"] = ""
|
|
case model.FulfillmentStatusFailed:
|
|
updates["failure_reason"] = in.FailureReason
|
|
}
|
|
if err := tx.Model(&order).Updates(updates).Error; err != nil {
|
|
return err
|
|
}
|
|
jobStatus := model.FulfillmentJobStatusProcessing
|
|
if in.Status == model.FulfillmentStatusSucceeded {
|
|
jobStatus = model.FulfillmentJobStatusSucceeded
|
|
} else if in.Status == model.FulfillmentStatusFailed {
|
|
jobStatus = model.FulfillmentJobStatusFailed
|
|
}
|
|
if err := tx.Model(&model.FulfillmentJob{}).Where("order_id = ?", order.ID).Updates(map[string]interface{}{
|
|
"status": jobStatus,
|
|
"provider_order_no": in.ProviderOrderNo,
|
|
"result_payload": resultData,
|
|
"last_error": in.FailureReason,
|
|
}).Error; err != nil {
|
|
return err
|
|
}
|
|
if err := tx.First(&out, order.ID).Error; err != nil {
|
|
return err
|
|
}
|
|
if err := writeAudit(tx, &in.MerchantID, nil, &in.APIClientID, "fulfillment.update", "fulfillment_order", order.OrderNo, map[string]string{"status": in.Status}); err != nil {
|
|
return err
|
|
}
|
|
if s.callbacks != nil {
|
|
if err := s.callbacks.Enqueue(tx, in.MerchantID, "order.fulfillment.updated", orderCallbackData(&out)); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &out, nil
|
|
}
|
|
|
|
func (s *FulfillmentService) CancelOrder(merchantID, apiClientID uint, orderNo, reason string) (*model.FulfillmentOrder, error) {
|
|
var out model.FulfillmentOrder
|
|
err := s.db.Transaction(func(tx *gorm.DB) error {
|
|
var order model.FulfillmentOrder
|
|
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
|
|
Where("merchant_id = ? AND order_no = ?", merchantID, orderNo).
|
|
First(&order).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return errors.New("订单不存在")
|
|
}
|
|
return err
|
|
}
|
|
if order.FulfillmentStatus == model.FulfillmentStatusCancelled {
|
|
out = order
|
|
return nil
|
|
}
|
|
if order.FulfillmentStatus == model.FulfillmentStatusProcessing || order.FulfillmentStatus == model.FulfillmentStatusSucceeded {
|
|
return errors.New("订单已进入履约流程，不能取消")
|
|
}
|
|
now := time.Now()
|
|
updates := map[string]interface{}{
|
|
"payment_status": model.PaymentStatusRefunded,
|
|
"fulfillment_status": model.FulfillmentStatusCancelled,
|
|
"failure_reason": reason,
|
|
"cancelled_at": now,
|
|
}
|
|
if err := tx.Model(&order).Updates(updates).Error; err != nil {
|
|
return err
|
|
}
|
|
var wallet model.WalletAccount
|
|
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).Where("merchant_id = ?", merchantID).First(&wallet).Error; err != nil {
|
|
return err
|
|
}
|
|
newBalance := wallet.AvailableBalance + order.Amount
|
|
if err := tx.Model(&wallet).Update("available_balance", newBalance).Error; err != nil {
|
|
return err
|
|
}
|
|
idempotencyKey := "cancel:" + order.OrderNo
|
|
if err := tx.Create(&model.WalletLedgerEntry{
|
|
MerchantID: merchantID,
|
|
WalletAccountID: wallet.ID,
|
|
EntryNo: "WL" + uuid.NewString(),
|
|
Type: model.WalletLedgerRefund,
|
|
Amount: order.Amount,
|
|
BalanceAfter: newBalance,
|
|
ReferenceType: "fulfillment_order",
|
|
ReferenceNo: order.OrderNo,
|
|
IdempotencyKey: &idempotencyKey,
|
|
Note: "订单取消退款",
|
|
}).Error; err != nil {
|
|
return err
|
|
}
|
|
var product model.MerchantProduct
|
|
if err := tx.Where("id = ?", order.MerchantProductID).First(&product).Error; err != nil {
|
|
return err
|
|
}
|
|
if product.Stock >= 0 {
|
|
if err := tx.Model(&product).Update("stock", gorm.Expr("stock + ?", order.Quantity)).Error; err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if err := tx.Model(&model.FulfillmentJob{}).Where("order_id = ?", order.ID).Updates(map[string]interface{}{
|
|
"status": model.FulfillmentJobStatusFailed,
|
|
"last_error": "订单已取消",
|
|
}).Error; err != nil {
|
|
return err
|
|
}
|
|
if err := tx.First(&out, order.ID).Error; err != nil {
|
|
return err
|
|
}
|
|
if err := writeAudit(tx, &merchantID, nil, &apiClientID, "open_order.cancel", "fulfillment_order", order.OrderNo, nil); err != nil {
|
|
return err
|
|
}
|
|
if s.callbacks != nil {
|
|
if err := s.callbacks.Enqueue(tx, merchantID, "order.cancelled", orderCallbackData(&out)); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &out, nil
|
|
}
|
|
|
|
type WalletAdjustInput struct {
|
|
MerchantID uint
|
|
ActorUserID uint
|
|
Amount int64
|
|
IdempotencyKey string
|
|
Note string
|
|
}
|
|
|
|
func (s *FulfillmentService) AdjustWallet(in WalletAdjustInput) (*model.WalletAccount, error) {
|
|
if in.Amount == 0 {
|
|
return nil, errors.New("调整金额不能为零")
|
|
}
|
|
if in.IdempotencyKey == "" {
|
|
return nil, errors.New("账务调整必须提供幂等键")
|
|
}
|
|
var out model.WalletAccount
|
|
err := s.db.Transaction(func(tx *gorm.DB) error {
|
|
var existing model.WalletLedgerEntry
|
|
if err := tx.Where("merchant_id = ? AND idempotency_key = ?", in.MerchantID, in.IdempotencyKey).First(&existing).Error; err == nil {
|
|
if err := tx.First(&out, existing.WalletAccountID).Error; err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
} else if !errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return err
|
|
}
|
|
|
|
var wallet model.WalletAccount
|
|
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).Where("merchant_id = ?", in.MerchantID).First(&wallet).Error; err != nil {
|
|
return err
|
|
}
|
|
newBalance := wallet.AvailableBalance + in.Amount
|
|
if newBalance < 0 {
|
|
return errors.New("调整后余额不能小于零")
|
|
}
|
|
if err := tx.Model(&wallet).Update("available_balance", newBalance).Error; err != nil {
|
|
return err
|
|
}
|
|
entryType := model.WalletLedgerAdjust
|
|
if in.Amount > 0 {
|
|
entryType = model.WalletLedgerCredit
|
|
} else {
|
|
entryType = model.WalletLedgerDebit
|
|
}
|
|
idempotencyKey := in.IdempotencyKey
|
|
if err := tx.Create(&model.WalletLedgerEntry{
|
|
MerchantID: in.MerchantID,
|
|
WalletAccountID: wallet.ID,
|
|
EntryNo: "WL" + uuid.NewString(),
|
|
Type: entryType,
|
|
Amount: in.Amount,
|
|
BalanceAfter: newBalance,
|
|
ReferenceType: "manual_adjustment",
|
|
ReferenceNo: in.IdempotencyKey,
|
|
IdempotencyKey: &idempotencyKey,
|
|
Note: in.Note,
|
|
}).Error; err != nil {
|
|
return err
|
|
}
|
|
out = wallet
|
|
out.AvailableBalance = newBalance
|
|
return writeAudit(tx, &in.MerchantID, &in.ActorUserID, nil, "wallet.adjust", "wallet_account", fmt.Sprint(wallet.ID), map[string]int64{"amount": in.Amount})
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &out, nil
|
|
}
|
|
|
|
func (s *FulfillmentService) GetWallet(merchantID uint) (*model.WalletAccount, error) {
|
|
var wallet model.WalletAccount
|
|
if err := s.db.Where("merchant_id = ?", merchantID).First(&wallet).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, errors.New("商户钱包不存在")
|
|
}
|
|
return nil, err
|
|
}
|
|
return &wallet, nil
|
|
}
|
|
|
|
func (s *FulfillmentService) ListWalletLedger(merchantID uint, page, size int) ([]model.WalletLedgerEntry, int64, error) {
|
|
page, size = normalizePage(page, size)
|
|
tx := s.db.Model(&model.WalletLedgerEntry{}).Where("merchant_id = ?", merchantID)
|
|
var total int64
|
|
if err := tx.Count(&total).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
var entries []model.WalletLedgerEntry
|
|
err := tx.Order("id DESC").Offset((page - 1) * size).Limit(size).Find(&entries).Error
|
|
return entries, total, err
|
|
}
|
|
|
|
func newFulfillmentOrderNo() string {
|
|
return "FO" + time.Now().UTC().Format("20060102150405") + strings.ReplaceAll(uuid.NewString()[:12], "-", "")
|
|
}
|
|
|
|
func CanFulfill(order *model.FulfillmentOrder) (bool, string) {
|
|
if order.PaymentStatus != model.PaymentStatusPaid {
|
|
return false, "订单未支付或已退款"
|
|
}
|
|
switch order.FulfillmentStatus {
|
|
case model.FulfillmentStatusPending, model.FulfillmentStatusFailed:
|
|
return true, ""
|
|
case model.FulfillmentStatusProcessing:
|
|
return false, "订单履约中"
|
|
case model.FulfillmentStatusSucceeded:
|
|
return false, "订单已履约成功"
|
|
case model.FulfillmentStatusCancelled:
|
|
return false, "订单已取消"
|
|
default:
|
|
return false, "订单状态不可履约"
|
|
}
|
|
}
|
|
|
|
func orderCallbackData(order *model.FulfillmentOrder) map[string]interface{} {
|
|
canFulfill, cannotFulfillReason := CanFulfill(order)
|
|
return map[string]interface{}{
|
|
"order_no": order.OrderNo,
|
|
"client_order_no": order.ClientOrderNo,
|
|
"product_sku": order.ProductSKU,
|
|
"quantity": order.Quantity,
|
|
"amount": order.Amount,
|
|
"currency": order.Currency,
|
|
"payment_status": order.PaymentStatus,
|
|
"fulfillment_status": order.FulfillmentStatus,
|
|
"can_fulfill": canFulfill,
|
|
"cannot_fulfill_reason": cannotFulfillReason,
|
|
"provider_order_no": order.ProviderOrderNo,
|
|
"failure_reason": order.FailureReason,
|
|
}
|
|
}
|