480 lines
10 KiB
Go
480 lines
10 KiB
Go
package services
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"fmt"
|
|
"platform/pkg/u"
|
|
"platform/web/core"
|
|
bill2 "platform/web/domains/bill"
|
|
resource2 "platform/web/domains/resource"
|
|
trade2 "platform/web/domains/trade"
|
|
g "platform/web/globals"
|
|
"platform/web/globals/orm"
|
|
m "platform/web/models"
|
|
q "platform/web/queries"
|
|
"time"
|
|
|
|
"github.com/shopspring/decimal"
|
|
)
|
|
|
|
var Resource = &resourceService{}
|
|
|
|
type resourceService struct{}
|
|
|
|
func (s *resourceService) CreateResource(uid int32, now time.Time, ser *CreateResourceData) error {
|
|
|
|
data, err := ser.ToData()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var name = data.GetName()
|
|
var amount = data.GetPrice()
|
|
|
|
// 保存交易信息
|
|
err = q.Q.Transaction(func(q *q.Query) error {
|
|
|
|
// 检查用户
|
|
user, err := q.User.
|
|
Where(q.User.ID.Eq(uid)).
|
|
Take()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// 检查余额
|
|
if user.Balance.Cmp(amount) < 0 {
|
|
return ErrBalanceNotEnough
|
|
}
|
|
|
|
// 保存套餐
|
|
resource, err := createResource(q, uid, now, data)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// 生成账单
|
|
bill := m.Bill{
|
|
UserID: uid,
|
|
ResourceID: &resource.ID,
|
|
BillNo: ID.GenReadable("bil"),
|
|
Info: u.P("购买套餐 - " + name),
|
|
Type: int32(bill2.TypeConsume),
|
|
Amount: amount,
|
|
}
|
|
err = q.Bill.
|
|
Omit(q.Bill.TradeID, q.Bill.RefundID).
|
|
Create(&bill)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// 更新用户余额
|
|
_, err = q.User.
|
|
Where(q.User.ID.Eq(uid)).
|
|
UpdateSimple(q.User.Balance.Value(user.Balance.Sub(amount)))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}, &sql.TxOptions{Isolation: sql.LevelRepeatableRead})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *resourceService) PrepareResource(uid int32, now time.Time, ser *PrepareResourceData) (*TradeCreateResult, error) {
|
|
|
|
data, err := ser.ToData()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
name := data.GetName()
|
|
amount := data.GetPrice()
|
|
|
|
method := ser.PaymentMethod
|
|
platform := ser.PaymentPlatform
|
|
|
|
// 保存到数据库
|
|
var result *TradeCreateResult
|
|
err = q.Q.Transaction(func(q *q.Query) error {
|
|
var err error
|
|
|
|
// 生成交易订单
|
|
result, err = Trade.CreateTrade(q, uid, now, &TradeCreateData{
|
|
Subject: "购买套餐 - " + name,
|
|
Amount: amount,
|
|
ExpireAt: time.Now().Add(30 * time.Minute),
|
|
Type: trade2.TypeRecharge,
|
|
Method: method,
|
|
Platform: platform,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// 保存请求缓存
|
|
resourceSerializer := new(PrepareResourceData)
|
|
if err := resourceSerializer.ByData(data); err != nil {
|
|
return err
|
|
}
|
|
|
|
err = g.Redis.Set(context.Background(), resPrepareKey(result.TradeNo), &PrepareResourceCache{
|
|
Uid: uid,
|
|
TradeId: result.Trade.ID,
|
|
BillId: result.Bill.ID,
|
|
PrepareResourceData: resourceSerializer,
|
|
}, 30*time.Minute).Err()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func (s *resourceService) CompleteResource(tradeNo string, now time.Time, opResult ...*TradeSuccessResult) error {
|
|
|
|
// 获取请求缓存
|
|
reqStr, err := g.Redis.Get(context.Background(), resPrepareKey(tradeNo)).Result()
|
|
if err != nil {
|
|
return core.NewBizErr("交易不存在或已过期")
|
|
}
|
|
cache := new(PrepareResourceCache)
|
|
if err := json.Unmarshal([]byte(reqStr), cache); err != nil {
|
|
return err
|
|
}
|
|
|
|
// 检查交易结果
|
|
var rs *TradeSuccessResult
|
|
if len(opResult) > 0 && opResult[0] != nil {
|
|
rs = opResult[0]
|
|
} else {
|
|
var err error
|
|
rs, err = Trade.VerifyTrade(&TradeVerifyData{
|
|
TradeNo: tradeNo,
|
|
Method: cache.PaymentMethod,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
data, err := cache.ToData()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// 保存交易信息
|
|
err = q.Q.Transaction(func(q *q.Query) error {
|
|
|
|
// 完成交易
|
|
_, err = Trade.OnTradeCreated(q, &OnTradeCreateData{
|
|
TradeNo: tradeNo,
|
|
TradeSuccessResult: *rs,
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("完成交易失败: %w", err)
|
|
}
|
|
|
|
// 保存套餐
|
|
resource, err := createResource(q, cache.Uid, now, data)
|
|
if err != nil {
|
|
return fmt.Errorf("创建套餐失败: %w", err)
|
|
}
|
|
|
|
// 更新账单
|
|
_, err = q.Bill.Debug().
|
|
Select(q.Bill.ResourceID).
|
|
Updates(&m.Bill{
|
|
ID: cache.BillId,
|
|
ResourceID: &resource.ID,
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("更新账单失败: %w", err)
|
|
}
|
|
|
|
// 删除缓存
|
|
err = g.Redis.Del(context.Background(), tradeNo).Err()
|
|
if err != nil {
|
|
return fmt.Errorf("删除缓存失败: %w", err)
|
|
}
|
|
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *resourceService) CancelResource(tradeNo string, now time.Time, opRevoked ...bool) error {
|
|
// 删除请求缓存
|
|
cacheStr, err := g.Redis.GetDel(context.Background(), tradeNo).Result()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
cache := new(PrepareResourceCache)
|
|
if err := json.Unmarshal([]byte(cacheStr), cache); err != nil {
|
|
return err
|
|
}
|
|
|
|
// 取消交易
|
|
if len(opRevoked) <= 0 {
|
|
err = Trade.CancelTrade(tradeNo, cache.PaymentMethod)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// 更新订单状态
|
|
err = Trade.OnTradeCanceled(q.Q, tradeNo, now)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func createResource(q *q.Query, uid int32, now time.Time, data CreateTypeResourceDataInter) (*m.Resource, error) {
|
|
|
|
// 套餐基本信息
|
|
var resource = m.Resource{
|
|
UserID: uid,
|
|
ResourceNo: u.P(ID.GenReadable("res")),
|
|
Active: true,
|
|
}
|
|
|
|
switch data := data.(type) {
|
|
|
|
// 短效套餐
|
|
case *CreateShortResourceData:
|
|
var duration = time.Duration(data.Expire) * 24 * time.Hour
|
|
resource.Type = int32(resource2.TypeShort)
|
|
resource.Short = &m.ResourceShort{
|
|
Type: data.Mode,
|
|
Live: data.Live,
|
|
Quota: &data.Quota,
|
|
Expire: u.P(orm.LocalDateTime(now.Add(duration))),
|
|
DailyLimit: data.DailyLimit,
|
|
}
|
|
|
|
// 长效套餐
|
|
case *CreateLongResourceData:
|
|
var duration = time.Duration(data.Expire) * 24 * time.Hour
|
|
resource.Type = int32(resource2.TypeLong)
|
|
resource.Long = &m.ResourceLong{
|
|
Type: data.Mode,
|
|
Live: data.Live,
|
|
Quota: &data.Quota,
|
|
Expire: u.P(orm.LocalDateTime(now.Add(duration))),
|
|
DailyLimit: data.DailyLimit,
|
|
}
|
|
default:
|
|
return nil, fmt.Errorf("不支持的套餐类型")
|
|
}
|
|
|
|
err := q.Resource.Create(&resource)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &resource, nil
|
|
}
|
|
|
|
func resPrepareKey(tradeNo string) string {
|
|
return fmt.Sprintf("resource:prepare:%s", tradeNo)
|
|
}
|
|
|
|
type CreateTypeResourceDataInter interface {
|
|
GetName() string
|
|
GetPrice() decimal.Decimal
|
|
}
|
|
|
|
type CreateShortResourceData struct {
|
|
Live int32 `json:"live" validate:"required,min=180"`
|
|
Mode int32 `json:"mode" validate:"required"`
|
|
Expire int32 `json:"expire"`
|
|
DailyLimit int32 `json:"daily_limit" validate:"min=2000"`
|
|
Quota int32 `json:"quota" validate:"min=10000"`
|
|
|
|
name string
|
|
price *decimal.Decimal
|
|
}
|
|
|
|
func (data *CreateShortResourceData) GetName() string {
|
|
if data.name == "" {
|
|
var mode string
|
|
switch data.Mode {
|
|
case 1:
|
|
mode = "包时"
|
|
case 2:
|
|
mode = "包量"
|
|
}
|
|
data.name = fmt.Sprintf("短效动态%s %v 分钟", mode, data.Live/60)
|
|
}
|
|
return data.name
|
|
}
|
|
|
|
func (data *CreateShortResourceData) GetPrice() decimal.Decimal {
|
|
if data.price == nil {
|
|
var factor int32
|
|
switch data.Mode {
|
|
case 1:
|
|
factor = data.DailyLimit * data.Expire
|
|
case 2:
|
|
factor = data.Quota
|
|
}
|
|
|
|
var base = data.Live
|
|
if base == 180 {
|
|
base = 150
|
|
}
|
|
|
|
var dec = decimal.Decimal{}.
|
|
Add(decimal.NewFromInt32(base * factor)).
|
|
Div(decimal.NewFromInt(30000))
|
|
data.price = &dec
|
|
}
|
|
return *data.price
|
|
}
|
|
|
|
type CreateLongResourceData struct {
|
|
Live int32 `json:"live" validate:"required,oneof=1 4 8 12 24"`
|
|
Mode int32 `json:"mode" validate:"required,oneof=1 2"`
|
|
Expire int32 `json:"expire"`
|
|
DailyLimit int32 `json:"daily_limit" validate:"min=100"`
|
|
Quota int32 `json:"quota" validate:"min=500"`
|
|
|
|
name string
|
|
price *decimal.Decimal
|
|
}
|
|
|
|
func (data *CreateLongResourceData) GetName() string {
|
|
if data.name == "" {
|
|
var mode string
|
|
switch data.Mode {
|
|
case 1:
|
|
mode = "包时"
|
|
case 2:
|
|
mode = "包量"
|
|
}
|
|
data.name = fmt.Sprintf("长效动态%s %d 小时", mode, data.Live)
|
|
}
|
|
return data.name
|
|
}
|
|
|
|
func (data *CreateLongResourceData) GetPrice() decimal.Decimal {
|
|
if data.price == nil {
|
|
var factor int32 = 0
|
|
switch resource2.Mode(data.Mode) {
|
|
|
|
case resource2.ModeTime:
|
|
factor = data.Expire * data.DailyLimit
|
|
case resource2.ModeCount:
|
|
factor = data.Quota
|
|
}
|
|
|
|
var base int32
|
|
switch data.Live {
|
|
case 1:
|
|
base = 30
|
|
case 4:
|
|
base = 80
|
|
case 8:
|
|
base = 120
|
|
case 12:
|
|
base = 180
|
|
case 24:
|
|
base = 350
|
|
}
|
|
|
|
// data.price = big.NewRat(int64(base*factor), 100)
|
|
var dec = decimal.Decimal{}.
|
|
Add(decimal.NewFromInt32(base * factor)).
|
|
Div(decimal.NewFromInt(100))
|
|
data.price = &dec
|
|
}
|
|
return *data.price
|
|
}
|
|
|
|
type CreateResourceData struct {
|
|
Type resource2.Type `json:"type" validate:"required"`
|
|
Short *CreateShortResourceData `json:"short,omitempty"`
|
|
Long *CreateLongResourceData `json:"long,omitempty"`
|
|
}
|
|
|
|
func (s *CreateResourceData) ToData() (CreateTypeResourceDataInter, error) {
|
|
switch s.Type {
|
|
case resource2.TypeShort:
|
|
return s.Short, nil
|
|
case resource2.TypeLong:
|
|
return s.Long, nil
|
|
}
|
|
return nil, fmt.Errorf("不支持的套餐类型")
|
|
}
|
|
|
|
func (s *CreateResourceData) ByData(data CreateTypeResourceDataInter) error {
|
|
switch data := data.(type) {
|
|
case *CreateShortResourceData:
|
|
s.Type = resource2.TypeShort
|
|
s.Short = data
|
|
case *CreateLongResourceData:
|
|
s.Type = resource2.TypeLong
|
|
s.Long = data
|
|
default:
|
|
return fmt.Errorf("不支持的套餐类型")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type PrepareResourceData struct {
|
|
CreateResourceData
|
|
PaymentMethod trade2.Method `json:"payment_method" validate:"required"`
|
|
PaymentPlatform trade2.Platform `json:"payment_platform" validate:"required"`
|
|
}
|
|
|
|
type PrepareResourceCache struct {
|
|
Uid int32 `json:"uid"`
|
|
TradeId int32 `json:"trade_id"`
|
|
BillId int32 `json:"bill_id"`
|
|
*PrepareResourceData
|
|
}
|
|
|
|
func (c PrepareResourceCache) MarshalBinary() (data []byte, err error) {
|
|
data, err = json.Marshal(c)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data, nil
|
|
}
|
|
|
|
func (c PrepareResourceCache) UnmarshalBinary(data []byte) error {
|
|
if err := json.Unmarshal(data, &c); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ResourceServiceErr string
|
|
|
|
func (e ResourceServiceErr) Error() string {
|
|
return string(e)
|
|
}
|
|
|
|
const (
|
|
ErrBalanceNotEnough = ResourceServiceErr("余额不足")
|
|
)
|