shanshanzhong
a1ab0fefa4
All checks were successful
Build docker and publish / build (20.15.1) (push) Successful in 8m15s
423 lines
18 KiB
Go
423 lines
18 KiB
Go
package apple
|
||
|
||
import (
|
||
"context"
|
||
"crypto/sha256"
|
||
"encoding/hex"
|
||
"encoding/json"
|
||
"fmt"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/google/uuid"
|
||
"github.com/hibiken/asynq"
|
||
commonLogic "github.com/perfect-panel/server/internal/logic/common"
|
||
iapmodel "github.com/perfect-panel/server/internal/model/iap/apple"
|
||
ordermodel "github.com/perfect-panel/server/internal/model/order"
|
||
"github.com/perfect-panel/server/internal/model/subscribe"
|
||
"github.com/perfect-panel/server/internal/model/user"
|
||
"github.com/perfect-panel/server/internal/svc"
|
||
"github.com/perfect-panel/server/internal/types"
|
||
"github.com/perfect-panel/server/pkg/constant"
|
||
iapapple "github.com/perfect-panel/server/pkg/iap/apple"
|
||
"github.com/perfect-panel/server/pkg/logger"
|
||
"github.com/perfect-panel/server/pkg/xerr"
|
||
queueType "github.com/perfect-panel/server/queue/types"
|
||
"github.com/pkg/errors"
|
||
"gorm.io/gorm"
|
||
)
|
||
|
||
type AttachTransactionLogic struct {
|
||
logger.Logger
|
||
ctx context.Context
|
||
svcCtx *svc.ServiceContext
|
||
}
|
||
|
||
const (
|
||
orderTypeSubscribe uint8 = 1
|
||
orderStatusPending uint8 = 1
|
||
orderStatusPaid uint8 = 2
|
||
)
|
||
|
||
func NewAttachTransactionLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AttachTransactionLogic {
|
||
return &AttachTransactionLogic{
|
||
Logger: logger.WithContext(ctx),
|
||
ctx: ctx,
|
||
svcCtx: svcCtx,
|
||
}
|
||
}
|
||
|
||
func (l *AttachTransactionLogic) Attach(req *types.AttachAppleTransactionRequest) (*types.AttachAppleTransactionResponse, error) {
|
||
l.Infow("开始绑定 Apple IAP 交易", logger.Field("orderNo", req.OrderNo))
|
||
u, ok := l.ctx.Value(constant.CtxKeyUser).(*user.User)
|
||
if !ok || u == nil {
|
||
l.Errorw("无效访问，用户信息缺失")
|
||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "invalid access")
|
||
}
|
||
if err := commonLogic.DenyIfFamilyMemberReadonly(l.ctx, l.svcCtx.DB, u.Id); err != nil {
|
||
return nil, err
|
||
}
|
||
if strings.TrimSpace(req.OrderNo) == "" {
|
||
l.Errorw("参数错误，orderNo 不能为空")
|
||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "order_no is required")
|
||
}
|
||
orderInfo, orderErr := l.svcCtx.OrderModel.FindOneByOrderNo(l.ctx, req.OrderNo)
|
||
switch {
|
||
case errors.Is(orderErr, gorm.ErrRecordNotFound):
|
||
l.Errorw("订单不存在", logger.Field("orderNo", req.OrderNo))
|
||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.OrderNotExist), "order not exist")
|
||
case orderErr != nil:
|
||
l.Errorw("查询订单失败", logger.Field("orderNo", req.OrderNo), logger.Field("error", orderErr.Error()))
|
||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find order error: %v", orderErr.Error())
|
||
case orderInfo == nil || orderInfo.Id == 0:
|
||
l.Errorw("订单不存在", logger.Field("orderNo", req.OrderNo))
|
||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.OrderNotExist), "order not exist")
|
||
case orderInfo.UserId != u.Id:
|
||
l.Errorw("订单与当前用户不匹配", logger.Field("orderNo", req.OrderNo), logger.Field("orderUserId", orderInfo.UserId), logger.Field("userId", u.Id))
|
||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "order owner mismatch")
|
||
}
|
||
isNewPurchaseOrder := orderInfo.Type == orderTypeSubscribe
|
||
if isNewPurchaseOrder {
|
||
l.Infow("首购订单将只由订单激活流程创建订阅", logger.Field("orderNo", req.OrderNo), logger.Field("orderType", orderInfo.Type))
|
||
}
|
||
|
||
txPayload, err := iapapple.VerifyTransactionJWS(req.SignedTransactionJWS)
|
||
if err != nil {
|
||
l.Errorw("JWS 验签失败", logger.Field("error", err.Error()))
|
||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "invalid jws")
|
||
}
|
||
l.Infow("JWS 验签成功", logger.Field("productId", txPayload.ProductId), logger.Field("originalTransactionId", txPayload.OriginalTransactionId), logger.Field("purchaseAt", txPayload.PurchaseDate))
|
||
// idempotency: check existing transaction by original id
|
||
var existTx *iapmodel.Transaction
|
||
existTx, _ = iapmodel.NewModel(l.svcCtx.DB, l.svcCtx.Redis).FindByOriginalId(l.ctx, txPayload.OriginalTransactionId)
|
||
l.Infow("幂等等检查", logger.Field("originalTransactionId", txPayload.OriginalTransactionId), logger.Field("exists", existTx != nil && existTx.Id > 0))
|
||
|
||
// 解析 Apple 商品ID中的单位与数量：支持 dayN / monthN / yearN
|
||
var parsedUnit string
|
||
var parsedQuantity int64
|
||
{
|
||
pid := strings.ToLower(txPayload.ProductId)
|
||
parts := strings.Split(pid, ".")
|
||
for i := len(parts) - 1; i >= 0; i-- {
|
||
p := parts[i]
|
||
if strings.HasPrefix(p, "day") || strings.HasPrefix(p, "month") || strings.HasPrefix(p, "year") {
|
||
switch {
|
||
case strings.HasPrefix(p, "day"):
|
||
parsedUnit = "Day"
|
||
p = p[len("day"):]
|
||
case strings.HasPrefix(p, "month"):
|
||
parsedUnit = "Month"
|
||
p = p[len("month"):]
|
||
case strings.HasPrefix(p, "year"):
|
||
parsedUnit = "Year"
|
||
p = p[len("year"):]
|
||
}
|
||
digits := p
|
||
for j := 0; j < len(digits); j++ {
|
||
if digits[j] < '0' || digits[j] > '9' {
|
||
digits = digits[:j]
|
||
break
|
||
}
|
||
}
|
||
if q, e := strconv.ParseInt(digits, 10, 64); e == nil && q > 0 {
|
||
parsedQuantity = q
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
l.Infow("商品映射解析", logger.Field("productId", txPayload.ProductId), logger.Field("解析单位", parsedUnit), logger.Field("解析数量", parsedQuantity))
|
||
|
||
// 基于订阅列表的折扣配置做匹配：UnitTime=Day 且 Discount.quantity == parsedQuantity
|
||
var duration int64
|
||
var tier string
|
||
var subscribeId int64
|
||
if parsedQuantity > 0 {
|
||
_, subs, e := l.svcCtx.SubscribeModel.FilterList(l.ctx, &subscribe.FilterParams{
|
||
Page: 1,
|
||
Size: 9999,
|
||
Show: true,
|
||
Sell: true,
|
||
DefaultLanguage: true,
|
||
})
|
||
if e == nil && len(subs) > 0 {
|
||
for _, item := range subs {
|
||
if parsedUnit != "" && !strings.EqualFold(item.UnitTime, parsedUnit) {
|
||
continue
|
||
}
|
||
var discounts []types.SubscribeDiscount
|
||
if item.Discount != "" {
|
||
_ = json.Unmarshal([]byte(item.Discount), &discounts)
|
||
}
|
||
for _, d := range discounts {
|
||
if int64(d.Quantity) == parsedQuantity {
|
||
switch parsedUnit {
|
||
case "Day":
|
||
duration = parsedQuantity
|
||
case "Month":
|
||
duration = parsedQuantity * 30
|
||
case "Year":
|
||
duration = parsedQuantity * 365
|
||
default:
|
||
duration = parsedQuantity
|
||
}
|
||
subscribeId = item.Id
|
||
tier = item.Name
|
||
l.Infow("订阅映射命中", logger.Field("subscribeId", subscribeId), logger.Field("name", tier), logger.Field("durationDays", duration))
|
||
break
|
||
}
|
||
}
|
||
if subscribeId > 0 {
|
||
break
|
||
}
|
||
}
|
||
} else {
|
||
l.Infow("订阅列表为空或查询失败", logger.Field("error", func() string {
|
||
if e != nil {
|
||
return e.Error()
|
||
}
|
||
return ""
|
||
}()))
|
||
}
|
||
}
|
||
if subscribeId == 0 {
|
||
// fallback from order_no if provided
|
||
duration = orderInfo.Quantity
|
||
subscribeId = orderInfo.SubscribeId
|
||
l.Infow("使用订单信息回退", logger.Field("orderNo", req.OrderNo), logger.Field("durationDays", duration), logger.Field("subscribeId", subscribeId))
|
||
// final fallback: use request fields
|
||
if duration <= 0 {
|
||
duration = req.DurationDays
|
||
}
|
||
if tier == "" {
|
||
tier = req.Tier
|
||
}
|
||
if subscribeId <= 0 {
|
||
subscribeId = req.SubscribeId
|
||
}
|
||
l.Infow("使用请求参数回退", logger.Field("durationDays", duration), logger.Field("tier", tier), logger.Field("subscribeId", subscribeId))
|
||
if duration <= 0 || subscribeId <= 0 {
|
||
l.Errorw("商品识别失败", logger.Field("durationDays", duration), logger.Field("tier", tier), logger.Field("subscribeId", subscribeId))
|
||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "unknown product")
|
||
}
|
||
}
|
||
exp := iapapple.CalcExpire(txPayload.PurchaseDate, duration)
|
||
l.Infow("计算订阅到期时间", logger.Field("expireAt", exp), logger.Field("expireUnix", exp.Unix()))
|
||
var orderLinkedSub *user.Subscribe
|
||
if !isNewPurchaseOrder && orderInfo != nil && orderInfo.SubscribeToken != "" {
|
||
orderSub, subErr := l.svcCtx.UserModel.FindOneSubscribeByToken(l.ctx, orderInfo.SubscribeToken)
|
||
switch {
|
||
case subErr == nil && orderSub != nil && orderSub.Id > 0:
|
||
if orderSub.UserId != u.Id {
|
||
l.Errorw("订单订阅与当前用户不匹配", logger.Field("orderNo", orderInfo.OrderNo), logger.Field("orderSubUserId", orderSub.UserId), logger.Field("userId", u.Id))
|
||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "order subscribe owner mismatch")
|
||
}
|
||
orderLinkedSub = orderSub
|
||
subscribeId = orderSub.SubscribeId
|
||
l.Infow("IAP 绑定命中订单订阅", logger.Field("orderNo", orderInfo.OrderNo), logger.Field("userSubscribeId", orderSub.Id), logger.Field("subscribeToken", orderInfo.SubscribeToken))
|
||
case subErr != nil && !errors.Is(subErr, gorm.ErrRecordNotFound):
|
||
l.Errorw("查询订单订阅失败", logger.Field("orderNo", orderInfo.OrderNo), logger.Field("subscribeToken", orderInfo.SubscribeToken), logger.Field("error", subErr.Error()))
|
||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find order subscribe error: %v", subErr.Error())
|
||
}
|
||
}
|
||
var singleModeAnchorSub *user.Subscribe
|
||
if !isNewPurchaseOrder && l.svcCtx.Config.Subscribe.SingleModel && orderLinkedSub == nil {
|
||
anchorSub, anchorErr := findSingleModeMergeTarget(l.ctx, l.svcCtx, u.Id, subscribeId)
|
||
switch {
|
||
case errors.Is(anchorErr, commonLogic.ErrSingleModePlanMismatch):
|
||
l.Errorw("单订阅模式下 IAP 套餐不匹配", logger.Field("userId", u.Id), logger.Field("orderNo", req.OrderNo), logger.Field("iapSubscribeId", subscribeId))
|
||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SingleSubscribePlanMismatch), "single subscribe mode plan mismatch")
|
||
case anchorErr == nil && anchorSub != nil && anchorSub.Id > 0:
|
||
singleModeAnchorSub = anchorSub
|
||
subscribeId = anchorSub.SubscribeId
|
||
l.Infow("IAP 绑定命中单订阅锚点", logger.Field("userSubscribeId", anchorSub.Id), logger.Field("subscribeId", anchorSub.SubscribeId))
|
||
case errors.Is(anchorErr, gorm.ErrRecordNotFound):
|
||
case anchorErr != nil:
|
||
l.Errorw("查询单订阅锚点失败", logger.Field("userId", u.Id), logger.Field("error", anchorErr.Error()))
|
||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find single mode anchor subscribe error: %v", anchorErr.Error())
|
||
}
|
||
}
|
||
|
||
if existTx != nil && existTx.Id > 0 {
|
||
if isNewPurchaseOrder {
|
||
if syncErr := l.syncOrderStatusAndEnqueue(orderInfo); syncErr != nil {
|
||
l.Errorw("事务已处理但同步订单状态失败", logger.Field("orderNo", req.OrderNo), logger.Field("error", syncErr.Error()))
|
||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "sync order status failed: %v", syncErr.Error())
|
||
}
|
||
l.Infow("事务已处理，首购订单等待激活队列发放订阅", logger.Field("orderNo", req.OrderNo), logger.Field("expiresAt", exp.Unix()))
|
||
return &types.AttachAppleTransactionResponse{ExpiresAt: exp.Unix(), Tier: tier}, nil
|
||
}
|
||
|
||
existSub, err := l.findIAPSubscribeByOriginalTransactionID(txPayload.OriginalTransactionId)
|
||
switch {
|
||
case err == nil && existSub != nil && existSub.Id > 0:
|
||
newExpire, updateErr := l.extendSubscribeForIAP(existSub, exp, subscribeId)
|
||
if updateErr != nil {
|
||
l.Errorw("刷新 IAP 订阅失败", logger.Field("error", updateErr.Error()), logger.Field("subscribeId", existSub.Id))
|
||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update iap subscribe failed: %v", updateErr.Error())
|
||
}
|
||
l.Infow("事务已处理，刷新订阅到期时间", logger.Field("originalTransactionId", txPayload.OriginalTransactionId), logger.Field("tier", tier), logger.Field("expiresAt", newExpire.Unix()))
|
||
return &types.AttachAppleTransactionResponse{
|
||
ExpiresAt: newExpire.Unix(),
|
||
Tier: tier,
|
||
}, nil
|
||
case err != nil && !errors.Is(err, gorm.ErrRecordNotFound):
|
||
l.Errorw("查询 IAP 订阅失败", logger.Field("error", err.Error()), logger.Field("originalTransactionId", txPayload.OriginalTransactionId))
|
||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find iap subscribe error: %v", err.Error())
|
||
}
|
||
if orderLinkedSub != nil {
|
||
newExpire, updateErr := l.extendSubscribeForIAP(orderLinkedSub, exp, subscribeId)
|
||
if updateErr != nil {
|
||
l.Errorw("刷新订单关联订阅失败", logger.Field("error", updateErr.Error()), logger.Field("subscribeId", orderLinkedSub.Id))
|
||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update order subscribe failed: %v", updateErr.Error())
|
||
}
|
||
l.Infow("事务已处理，刷新订单关联订阅到期时间", logger.Field("orderNo", req.OrderNo), logger.Field("userSubscribeId", orderLinkedSub.Id), logger.Field("expiresAt", newExpire.Unix()))
|
||
return &types.AttachAppleTransactionResponse{ExpiresAt: newExpire.Unix(), Tier: tier}, nil
|
||
}
|
||
if singleModeAnchorSub != nil {
|
||
newExpire, updateErr := l.extendSubscribeForIAP(singleModeAnchorSub, exp, subscribeId)
|
||
if updateErr != nil {
|
||
l.Errorw("刷新单订阅锚点订阅失败", logger.Field("error", updateErr.Error()), logger.Field("subscribeId", singleModeAnchorSub.Id))
|
||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update single mode anchor subscribe failed: %v", updateErr.Error())
|
||
}
|
||
l.Infow("事务已处理，刷新单订阅锚点到期时间", logger.Field("userSubscribeId", singleModeAnchorSub.Id), logger.Field("expiresAt", newExpire.Unix()))
|
||
return &types.AttachAppleTransactionResponse{ExpiresAt: newExpire.Unix(), Tier: tier}, nil
|
||
}
|
||
}
|
||
|
||
sum := sha256.Sum256([]byte(req.SignedTransactionJWS))
|
||
jwsHash := hex.EncodeToString(sum[:])
|
||
l.Infow("准备写入事务记录", logger.Field("userId", u.Id), logger.Field("transactionId", txPayload.TransactionId), logger.Field("originalTransactionId", txPayload.OriginalTransactionId), logger.Field("productId", txPayload.ProductId), logger.Field("jwsHash", jwsHash))
|
||
iapTx := &iapmodel.Transaction{
|
||
UserId: u.Id,
|
||
OriginalTransactionId: txPayload.OriginalTransactionId,
|
||
TransactionId: txPayload.TransactionId,
|
||
ProductId: txPayload.ProductId,
|
||
PurchaseAt: txPayload.PurchaseDate,
|
||
RevocationAt: txPayload.RevocationDate,
|
||
JWSHash: jwsHash,
|
||
}
|
||
err = l.svcCtx.DB.Transaction(func(tx *gorm.DB) error {
|
||
if existTx == nil || existTx.Id == 0 {
|
||
if e := tx.Model(&iapmodel.Transaction{}).Create(iapTx).Error; e != nil {
|
||
l.Errorw("写入事务表失败", logger.Field("error", e.Error()))
|
||
return e
|
||
}
|
||
l.Infow("写入事务表成功", logger.Field("id", iapTx.Id))
|
||
}
|
||
if !isNewPurchaseOrder {
|
||
merged := false
|
||
if orderLinkedSub != nil {
|
||
if _, e := l.extendSubscribeForIAP(orderLinkedSub, exp, subscribeId, tx); e != nil {
|
||
l.Errorw("更新订单关联订阅失败", logger.Field("error", e.Error()), logger.Field("userSubscribeId", orderLinkedSub.Id))
|
||
return e
|
||
}
|
||
merged = true
|
||
} else if singleModeAnchorSub != nil {
|
||
if _, e := l.extendSubscribeForIAP(singleModeAnchorSub, exp, subscribeId, tx); e != nil {
|
||
l.Errorw("更新单订阅锚点失败", logger.Field("error", e.Error()), logger.Field("userSubscribeId", singleModeAnchorSub.Id))
|
||
return e
|
||
}
|
||
merged = true
|
||
}
|
||
if !merged {
|
||
userSub := user.Subscribe{
|
||
UserId: u.Id,
|
||
SubscribeId: subscribeId,
|
||
StartTime: time.Now(),
|
||
ExpireTime: exp,
|
||
Traffic: 0,
|
||
Download: 0,
|
||
Upload: 0,
|
||
Token: fmt.Sprintf("iap:%s", txPayload.OriginalTransactionId),
|
||
UUID: uuid.New().String(),
|
||
Status: 1,
|
||
}
|
||
if e := l.svcCtx.UserModel.InsertSubscribe(l.ctx, &userSub, tx); e != nil {
|
||
l.Errorw("写入用户订阅失败", logger.Field("error", e.Error()))
|
||
return e
|
||
}
|
||
l.Infow("写入用户订阅成功", logger.Field("userId", u.Id), logger.Field("subscribeId", subscribeId), logger.Field("expireUnix", exp.Unix()))
|
||
}
|
||
} else {
|
||
l.Infow("首购订单跳过 attach 阶段订阅写入", logger.Field("orderNo", orderInfo.OrderNo), logger.Field("orderType", orderInfo.Type))
|
||
}
|
||
if e := l.syncOrderStatusAndEnqueue(orderInfo, tx); e != nil {
|
||
l.Errorw("同步订单状态失败", logger.Field("orderNo", req.OrderNo), logger.Field("error", e.Error()))
|
||
return e
|
||
}
|
||
return nil
|
||
})
|
||
if err != nil {
|
||
l.Errorw("绑定事务提交失败", logger.Field("error", err.Error()))
|
||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "insert error: %v", err.Error())
|
||
}
|
||
l.Infow("绑定完成", logger.Field("userId", u.Id), logger.Field("tier", tier), logger.Field("expiresAt", exp.Unix()))
|
||
return &types.AttachAppleTransactionResponse{
|
||
ExpiresAt: exp.Unix(),
|
||
Tier: tier,
|
||
}, nil
|
||
}
|
||
|
||
func (l *AttachTransactionLogic) syncOrderStatusAndEnqueue(orderInfo *ordermodel.Order, tx ...*gorm.DB) error {
|
||
if orderInfo == nil || orderInfo.OrderNo == "" {
|
||
return errors.New("order info is nil")
|
||
}
|
||
if orderInfo.Status == orderStatusPending {
|
||
if err := l.svcCtx.OrderModel.UpdateOrderStatus(l.ctx, orderInfo.OrderNo, orderStatusPaid, tx...); err != nil {
|
||
return err
|
||
}
|
||
orderInfo.Status = orderStatusPaid
|
||
l.Infow("更新订单状态成功", logger.Field("orderNo", orderInfo.OrderNo), logger.Field("status", orderStatusPaid))
|
||
}
|
||
// enqueue activation regardless (idempotent handler downstream)
|
||
payload := queueType.ForthwithActivateOrderPayload{OrderNo: orderInfo.OrderNo}
|
||
bytes, _ := json.Marshal(payload)
|
||
task := asynq.NewTask(queueType.ForthwithActivateOrder, bytes)
|
||
if _, err := l.svcCtx.Queue.EnqueueContext(l.ctx, task); err != nil {
|
||
// non-fatal
|
||
l.Errorw("enqueue activate task error", logger.Field("error", err.Error()))
|
||
} else {
|
||
l.Infow("已加入订单激活队列", logger.Field("orderNo", orderInfo.OrderNo))
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (l *AttachTransactionLogic) findIAPSubscribeByOriginalTransactionID(originalTransactionID string) (*user.Subscribe, error) {
|
||
if originalTransactionID == "" {
|
||
return nil, gorm.ErrRecordNotFound
|
||
}
|
||
candidates := []string{fmt.Sprintf("iap:%s", originalTransactionID), originalTransactionID}
|
||
for _, token := range candidates {
|
||
sub, err := l.svcCtx.UserModel.FindOneSubscribeByToken(l.ctx, token)
|
||
if err == nil && sub != nil && sub.Id > 0 {
|
||
return sub, nil
|
||
}
|
||
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
|
||
return nil, err
|
||
}
|
||
}
|
||
return nil, gorm.ErrRecordNotFound
|
||
}
|
||
|
||
func (l *AttachTransactionLogic) extendSubscribeForIAP(userSub *user.Subscribe, exp time.Time, subscribeId int64, tx ...*gorm.DB) (time.Time, error) {
|
||
if userSub == nil {
|
||
return time.Time{}, errors.New("user subscribe is nil")
|
||
}
|
||
newExpire := userSub.ExpireTime
|
||
if exp.After(newExpire) {
|
||
newExpire = exp
|
||
}
|
||
userSub.ExpireTime = newExpire
|
||
if subscribeId > 0 && userSub.SubscribeId != subscribeId {
|
||
userSub.SubscribeId = subscribeId
|
||
}
|
||
userSub.Status = 1
|
||
userSub.FinishedAt = nil
|
||
if err := l.svcCtx.UserModel.UpdateSubscribe(l.ctx, userSub, tx...); err != nil {
|
||
return time.Time{}, err
|
||
}
|
||
return newExpire, nil
|
||
}
|