新增自定义时间记录

internal/boot/boot.go

@@ -22,7 +22,7 @@ func Boot() (err error) {
 	service.SystemCron().AddCronV2(v1.CronType_HOUR, func(context.Context) error {
 		go func() {
 			err = service.GameKv().SavesV1()
-			err = service.GameAct().Saves()
+			err = service.GameAct().SavesV2()
 			if err != nil {
 				g.Log().Error(gctx.New(), err)
 			}

internal/logic/gameAct/gameAct.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/ayflying/utility_go/internal/model/do"
@@ -14,6 +15,7 @@ import (
 	service2 "github.com/ayflying/utility_go/service"
 	"github.com/ayflying/utility_go/tools"
 	"github.com/gogf/gf/v2/container/gset"
+	"github.com/gogf/gf/v2/errors/gerror"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gctx"
 	"github.com/gogf/gf/v2/os/gtime"
@@ -110,6 +112,12 @@ func (s *sGameAct) Set(uid int64, actId int, data interface{}) (err error) {
 	return
 }
 
+// Saves 保存游戏活动数据
+//
+// @Description: 保存游戏活动数据
+// @receiver s *sGameAct: 游戏活动服务结构体指针
+// @return err error: 返回错误信息
+// Deprecated: 该方法已被弃用，建议使用SavesV2方法
 func (s *sGameAct) Saves() (err error) {
 	var ctx = gctx.New()
 	g.Log().Debug(ctx, "开始执行游戏act数据保存了")
@@ -130,12 +138,19 @@ func (s *sGameAct) Saves() (err error) {
 	return
 }
 
+// Save 保存游戏活动数据
+//
+// @Description: 保存游戏活动数据
+// @receiver s *sGameAct: 游戏活动服务结构体指针
+// @param ctx context.Context: 上下文对象
+// @param actId int: 活动ID
+// @return err error: 返回错误信息
+// deprecated: 该方法已被弃用，建议使用SaveV2方法
 func (s *sGameAct) Save(ctx context.Context, actId int) (err error) {
 
 	cacheKey := fmt.Sprintf("act:%v:*", actId)
 	var add = make([]*entity.GameAct, 0)
 	var update = make([]*entity.GameAct, 0)
-
 	//循环获取缓存数据
 	err = tools.Redis.RedisScanV2(cacheKey, func(keys []string) (err error) {
 		//判断是否超时
@@ -203,7 +218,7 @@ func (s *sGameAct) Save(ctx context.Context, actId int) (err error) {
 		//批量写入数据库
 		updateCount := 0
 
-		g.Log().Debugf(ctx, "当前 %v 要更新的数据: %v 条", actId, len(update))
+		//g.Log().Debugf(ctx, "当前 %v 要更新的数据: %v 条", actId, len(update))
 		if len(update) > 100 {
 			for _, v := range update {
 				v.UpdatedAt = gtime.Now()
@@ -231,7 +246,7 @@ func (s *sGameAct) Save(ctx context.Context, actId int) (err error) {
 		}
 
 		var count int64
-		g.Log().Debugf(ctx, "当前 %v 要添加的数据: %v 条", actId, len(add))
+		//g.Log().Debugf(ctx, "当前 %v 要添加的数据: %v 条", actId, len(add))
 		if len(add) > 100 {
 			dbRes, err2 := g.Model(Name).Data(add).Save()
 
@@ -268,8 +283,272 @@ func (s *sGameAct) Save(ctx context.Context, actId int) (err error) {
 	return
 }
 
+// SavesV2 保存游戏活动数据
+//
+// @Description: 保存游戏活动数据
+// @receiver s *sGameAct: 游戏活动服务结构体指针
+// @return err error: 返回错误信息
+// SavesV2 保存游戏活动数据
+func (s *sGameAct) SavesV2() (err error) {
+	var ctx = gctx.New()
+	g.Log().Debug(ctx, "开始执行游戏act数据保存了")
+	RunTimeMax = gtime.Now().Add(time.Minute * 30)
+
+	// 使用局部通道替代包级通道，避免并发冲突
+	addChan := make(chan *entity.GameAct, 1000)
+	updateChan := make(chan *entity.GameAct, 1000)
+
+	errChan := make(chan error, 1)
+	var wg sync.WaitGroup
+	wg.Add(1) // 仅需添加1次（对应Cache2SqlChan协程）
+	// wg.Add(1)  // 移除多余的Add调用，避免计数不平衡
+
+	go func() {
+		defer wg.Done() // Cache2SqlChan协程完成后减1
+		s.Cache2SqlChan(ctx, addChan, updateChan)
+	}()
+
+	go func() {
+		scanErr := tools.Redis.RedisScanV2("act:*", func(keys []string) error {
+			if gtime.Now().After(RunTimeMax) {
+				return errors.New("Redis扫描超时")
+			}
+			for _, key := range keys {
+				if keyErr := s.SaveV2(ctx, key, addChan, updateChan); keyErr != nil {
+					g.Log().Errorf(ctx, "处理key %s失败: %v", key, keyErr)
+				}
+			}
+			return nil
+		})
+		close(addChan)
+		close(updateChan)
+		errChan <- scanErr
+	}()
+
+	// 等待扫描和处理完成，同时监听上下文取消
+	select {
+	case scanErr := <-errChan:
+		wg.Wait() // 等待Cache2SqlChan处理完剩余数据
+		if scanErr != nil {
+			return gerror.New(fmt.Sprintf("Redis扫描失败: %v", scanErr))
+		}
+	case <-ctx.Done():
+		wg.Wait()
+		return ctx.Err() // 返回上下文取消原因
+	}
+	return
+}
+
+// SaveV2 保存游戏活动数据
+//
+// @Description: 保存游戏活动数据
+// @receiver s *sGameAct: 游戏活动服务结构体指针
+// @param ctx context.Context: 上下文对象
+// @param cacheKey string: 缓存键
+// @param add []*entity.GameAct: 添加数据
+// @param update []*entity.GameAct: 更新数据
+// @return err error: 返回错误信息
+func (s *sGameAct) SaveV2(ctx context.Context, cacheKey string, addChan, updateChan chan *entity.GameAct) (err error) {
+
+	result := strings.Split(cacheKey, ":")
+	actId := gconv.Int(result[1])
+	if actId == 0 {
+		return
+	}
+	var uid int64
+	uid = gconv.Int64(result[2])
+	if uid == 0 {
+		//跳过为空的用户缓存
+		return
+	}
+
+	//获取缓存数据
+	cacheGet, _ := g.Redis().Get(ctx, cacheKey)
+
+	if cacheGet.IsEmpty() {
+		//空数据也不保存
+		return
+	}
+
+	//如果有活跃，跳过持久化
+	if getBool, _ := pkg.Cache("redis").
+		Contains(ctx, fmt.Sprintf("act:update:%d", uid)); getBool {
+		return
+	}
+
+	//获取数据库数据
+	var data *entity.GameAct
+	// 从数据库中查询活动信息
+	err = g.Model(Name).Where(do.GameAct{
+		Uid:   uid,
+		ActId: actId,
+	}).Fields("uid,act_id").Scan(&data)
+	if err != nil {
+		g.Log().Errorf(ctx, "当前数据错误: %v", cacheKey)
+		return
+	}
+
+	//如果没有数据，添加
+	actionData := cacheGet.String()
+	if data == nil {
+		//add = append(add, &entity.GameAct{
+		//	ActId:  actId,
+		//	Uid:    uid,
+		//	Action: actionData,
+		//})
+		addChan <- &entity.GameAct{
+			ActId:  actId,
+			Uid:    uid,
+			Action: actionData,
+		}
+	} else {
+		//覆盖数据
+		data.ActId = actId
+		data.Uid = uid
+		data.Action = actionData
+		//update = append(update, data)
+		updateChan <- data
+	}
+
+	return
+}
+
+// Cache2Sql 缓存持久化到数据库
+// @Description: 缓存持久化到数据库
+// @receiver s *sGameAct: 游戏活动服务结构体指针
+// @param ctx context.Context: 上下文对象
+// @param add []*entity.GameAct: 添加数据
+// @param update []*entity.GameAct: 更新数据
+// @return err error: 返回错误信息
+func (s *sGameAct) Cache2Sql(ctx context.Context, add, update []*entity.GameAct) {
+	//批量写入数据库
+	updateCount := 0
+	if len(update) > 0 {
+		for _, v := range update {
+			v.UpdatedAt = gtime.Now()
+			updateRes, err2 := g.Model(Name).Where(do.GameAct{
+				Uid:   v.Uid,
+				ActId: v.ActId,
+			}).Data(v).Update()
+			if err2 != nil {
+				g.Log().Error(ctx, err2)
+				continue
+			}
+			if row, _ := updateRes.RowsAffected(); row == 0 {
+				g.Log().Error(ctx, "本次更新为0，更新数据失败: %v", v)
+				continue
+			}
+			//删除缓存
+			s.DelCacheKey(ctx, v.ActId, v.Uid)
+			updateCount++
+		}
+		g.Log().Debugf(ctx, "act当前更新数据库: %v 条", updateCount)
+		update = (update)[:0]
+	}
+
+	var addCount int64
+	if len(add) > 0 {
+		for _, v := range add {
+			addRes, err2 := g.Model(Name).Data(v).Insert()
+			if err2 != nil {
+				g.Log().Error(ctx, err2)
+				continue
+			}
+			if row, _ := addRes.RowsAffected(); row == 0 {
+				g.Log().Error(ctx, "本次新增为0，新增数据失败: %v", v)
+				continue
+			}
+			addCount++
+			//删除缓存
+			s.DelCacheKey(ctx, v.ActId, v.Uid)
+		}
+		g.Log().Debugf(ctx, "act当前写入数据库: %v 条", addCount)
+		add = (add)[:0]
+	}
+	return
+}
+
+// Cache2AddChan 批量添加数据库
+func (s *sGameAct) Cache2SqlChan(ctx context.Context, addChan, updateChan chan *entity.GameAct) {
+	//批量写入数据库计数
+	var addCount int64
+	//批量更新数据库计数
+	var updateCount int64
+	//通道关闭标志
+	addClosed := false
+	updateClosed := false
+
+	// 使用链式安全模式
+	var db = g.Model(Name).Safe()
+
+	for {
+		//检查是否两个通道都已关闭且为空
+		if addClosed && updateClosed {
+			break
+		}
+
+		select {
+		case v, ok := <-addChan:
+			if !ok {
+				addClosed = true // 仅标记关闭，不立即日志
+				continue
+			}
+			addRes, err2 := db.Data(v).Insert()
+			if err2 != nil {
+				g.Log().Error(ctx, err2)
+				continue
+			}
+			if row, _ := addRes.RowsAffected(); row == 0 {
+				//g.Log().Error(ctx, "本次新增为0，新增数据失败: %v", v)
+				continue
+			}
+			row, _ := addRes.RowsAffected()
+			addCount += row
+			//删除缓存
+			s.DelCacheKey(ctx, v.ActId, v.Uid)
+
+		case v, ok := <-updateChan:
+			if !ok {
+				updateClosed = true // 仅标记关闭，不立即日志
+				continue
+			}
+			v.UpdatedAt = gtime.Now()
+			updateRes, err2 := db.Where(do.GameAct{
+				Uid:   v.Uid,
+				ActId: v.ActId,
+			}).Data(v).Update()
+			if err2 != nil {
+				g.Log().Error(ctx, err2)
+				continue
+			}
+			if row, _ := updateRes.RowsAffected(); row == 0 {
+				//g.Log().Error(ctx, "本次更新为0，更新数据失败: %v", v)
+				continue
+			}
+			//删除缓存
+			s.DelCacheKey(ctx, v.ActId, v.Uid)
+			updateCount++
+
+		case <-ctx.Done():
+			g.Log().Debug(ctx, "act协程被上下文取消")
+			return
+		}
+	}
+
+	// 仅在所有通道处理完毕后打印最终计数（移除中间冗余日志）
+	g.Log().Debugf(ctx, "act当前写入数据库: %v 条", addCount)
+	g.Log().Debugf(ctx, "act当前更新数据库: %v 条", updateCount)
+	return
+}
+
 // 删除缓存key
 func (s *sGameAct) DelCacheKey(ctx context.Context, aid int, uid int64) {
+	//如果有活跃，跳过删除
+	if getBool, _ := pkg.Cache("redis").
+		Contains(ctx, fmt.Sprintf("act:update:%d", uid)); getBool {
+		return
+	}
+
 	cacheKey := fmt.Sprintf("act:%v:%v", aid, uid)
 	_, err := g.Redis().Del(ctx, cacheKey)
 	if err != nil {

internal/logic/gameKv/gameKv.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -15,6 +14,7 @@ import (
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gctx"
 	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 var (
@@ -72,19 +72,17 @@ func (s *sGameKv) SavesV1() (err error) {
 			//uid := v.Int64()
 			//cacheKey = "user:kv:" + strconv.FormatInt(uid, 10)
 			result := strings.Split(cacheKey, ":")
-			var uid int64
-			uid, err = strconv.ParseInt(result[2], 10, 64)
+			var uid = gconv.Int64(result[2])
+			if uid == 0 {
+				continue
+			}
+			//uid, err = strconv.ParseInt(result[2], 10, 64)
 			if err != nil {
 				g.Log().Error(ctx, err)
 				g.Redis().Del(ctx, cacheKey)
 				continue
 			}
 
-			////如果1天没有活跃，跳过
-			//user, _ := service.MemberUser().Info(uid)
-			//if user.UpdatedAt.Seconds < gtime.Now().Add(consts.ActSaveTime).Unix() {
-			//	continue
-			//}
 			//如果有活跃，跳过持久化
 			if getBool, _ := pkg.Cache("redis").
 				Contains(ctx, fmt.Sprintf("act:update:%d", uid)); getBool {
@@ -94,6 +92,9 @@ func (s *sGameKv) SavesV1() (err error) {
 			get, _ := g.Redis().Get(ctx, cacheKey)
 			var data interface{}
 			get.Scan(&data)
+			if data == nil {
+				continue
+			}
 			list = append(list, &ListData{
 				Uid: uid,
 				Kv:  data,
@@ -103,21 +104,17 @@ func (s *sGameKv) SavesV1() (err error) {
 		// 将列表数据保存到数据库
 		if len(list) > 100 {
 			_, err2 := g.Model("game_kv").Data(list).Save()
-
 			if err2 != nil {
-				g.Log().Error(ctx, err2)
+				g.Log().Error(ctx, "当前kv数据入库失败: %v", err2)
+				err = err2
 				return
 			}
 			//删除当前key
 			for _, v := range list {
-				go s.DelCacheKey(ctx, v.Uid)
+				s.DelCacheKey(ctx, v.Uid)
 			}
 			list = make([]*ListData, 0)
 		}
-		if err != nil {
-			g.Log().Error(ctx, "当前kv数据入库失败: %v", err)
-		}
-
 		return
 	})
 
@@ -126,6 +123,12 @@ func (s *sGameKv) SavesV1() (err error) {
 
 // 删除缓存key
 func (s *sGameKv) DelCacheKey(ctx context.Context, uid int64) {
+	//如果有活跃，跳过删除
+	if getBool, _ := pkg.Cache("redis").
+		Contains(ctx, fmt.Sprintf("act:update:%d", uid)); getBool {
+		return
+	}
+
 	cacheKey := fmt.Sprintf("user:kv:%v", uid)
 	_, err := g.Redis().Del(ctx, cacheKey)
 	if err != nil {

package/gamelog/sdk.go

@@ -268,25 +268,66 @@ func (sdk *SDK) Shutdown() {
 const datetimeFmt = time.DateOnly + " " + time.TimeOnly
 
 // 记录日志
-func (sdk *SDK) Log(uid, event string, property map[string]any, timezone string) {
+func (sdk *SDK) Log(uid, event string, property map[string]any, timezone string, customEventTime ...time.Time) {
 	loc := time.Local
 	if _loc := getLocationMapValue(timezone); _loc != nil {
 		loc = _loc
 	}
+	if len(property) == 0 {
+		property = map[string]any{"ts": gtime.Now().Timestamp()}
+	}
+	var et *gtime.Time
+	if len(customEventTime) > 0 {
+		et = gtime.NewFromTime(customEventTime[0])
+	} else {
+		et = gtime.Now()
+	}
 	log := GameLog{
 		Uid:          uid,
 		Event:        event,
 		Property:     property,
-		EventTimems:  gtime.Now().TimestampMilli(),
-		EventTimeLoc: gtime.Now().In(loc).Format(datetimeFmt),
+		EventTimems:  et.TimestampMilli(),
+		EventTimeLoc: et.In(loc).Format(datetimeFmt),
 	}
 	// 线程安全
 	sdk.bufferChan <- log
 }
 
 // 按服务器时区记录日志
-func (sdk *SDK) LogLtz(uid, event string, property map[string]any) {
-	sdk.Log(uid, event, property, time.Local.String())
+func (sdk *SDK) LogLtz(uid, event string, property map[string]any, customEventTime ...time.Time) {
+	sdk.Log(uid, event, property, time.Local.String(), customEventTime...)
+}
+
+// 用户属性初始化
+func (sdk *SDK) Uinit(uid string, property map[string]any, timezone string, customEventTime ...time.Time) {
+	sdk.Log(uid, "u_init", property, timezone, customEventTime...)
+}
+func (sdk *SDK) UinitLtz(uid string, property map[string]any, customEventTime ...time.Time) {
+	sdk.Uinit(uid, property, time.Local.String(), customEventTime...)
+}
+
+// 用户属性设置
+func (sdk *SDK) Uset(uid string, property map[string]any, timezone string, customEventTime ...time.Time) {
+	sdk.Log(uid, "u_set", property, timezone, customEventTime...)
+}
+func (sdk *SDK) UsetLtz(uid string, property map[string]any, customEventTime ...time.Time) {
+	sdk.Uset(uid, property, time.Local.String(), customEventTime...)
+}
+
+// 用户属性删除
+func (sdk *SDK) Uunset(uid string, property map[string]any, timezone string, customEventTime ...time.Time) {
+	sdk.Log(uid, "u_unset", property, timezone, customEventTime...)
+}
+func (sdk *SDK) UunsetLtz(uid string, property map[string]any, customEventTime ...time.Time) {
+	sdk.Uunset(uid, property, time.Local.String(), customEventTime...)
+}
+
+// 用户属性自增/减
+func (sdk *SDK) Uinc(uid string, property map[string]any, timezone string, customEventTime ...time.Time) {
+	sdk.Log(uid, "u_inc", property, timezone, customEventTime...)
+}
+func (sdk *SDK) UincLtz(uid string, property map[string]any, customEventTime ...time.Time) {
+	sdk.Uinc(uid, property, time.Local.String(), customEventTime...)
 }
 
 // 这个方法只会在内部协程调用

package/pay/honor/const.go

@@ -1,5 +1,6 @@
 package honor
 
 const (
-	Host = "https://iap-api.cloud.honor.com"
+	Host      = "https://iap-api-drcn.cloud.honor.com"
+	TokenHost = "https://hnoauth-login-drcn.cloud.honor.com"
 )

package/pay/honor/honor.go

@@ -9,19 +9,50 @@ import (
 	"encoding/base64"
 	"encoding/pem"
 	"errors"
+	"time"
+
 	"github.com/ayflying/utility_go/package/pay/common"
+	"github.com/ayflying/utility_go/pkg"
+	"github.com/gogf/gf/v2/frame/g"
 )
 
 type Pay struct {
-	PubKey string `json:"pubKey"`
-	AppId  string `json:"appId"`
+	PubKey       string `json:"pubKey"`
+	AppId        string `json:"appId"`
+	ClientSecret string `json:"client_secret"`
 }
 
 func New(pay *Pay) *Pay {
-	return &Pay{
-		AppId:  pay.AppId,
-		PubKey: pay.PubKey,
+	return pay
+}
+
+func (p *Pay) GetToken(ctx context.Context) (accessToken string, err error) {
+	type TokenResp struct {
+		AccessToken string `json:"access_token"`
+		ExpiresIn   int    `json:"expires_in"`
+		TokenType   string `json:"token_type"`
 	}
+
+	get, err := pkg.Cache("redis", "cache").GetOrSetFunc(ctx, "pay:honor:Sign:token", func(ctx context.Context) (value interface{}, err error) {
+
+		url := TokenHost + "/oauth2/v3/token"
+		get, err := g.Client().Post(ctx, url, g.Map{
+			"client_id":     p.AppId,
+			"client_secret": p.ClientSecret,
+			"grant_type":    "client_credentials",
+		})
+
+		//var res *TokenResp
+		//gjson.DecodeTo(get, &res)
+		value = get.ReadAllString()
+		return
+	}, time.Hour)
+
+	var res *TokenResp
+	err = get.Scan(&res)
+	accessToken = res.AccessToken
+
+	return
 }
 
 // VerifyRSASignature 验证RSA数字签名
@@ -29,13 +60,13 @@ func New(pay *Pay) *Pay {
 // sign: 签名的Base64编码字符串
 // pubKey: PEM格式的公钥字符串
 // 返回验证结果和可能的错误
-func (p *Pay) VerifyRSASignature(ctx context.Context, data []byte, sign string) (bool, error) {
+func (p *Pay) VerifyRSASignature(ctx context.Context, data []byte, signature string) (bool, error) {
 	//req := g.RequestFromCtx(ctx).Request
 	//post, err := common.ParseNotifyToBodyMap(req)
 	//var data = gjson.MustEncode(post)
 
 	// 解码Base64格式的签名
-	signBytes, err := base64.StdEncoding.DecodeString(sign)
+	signBytes, err := base64.StdEncoding.DecodeString(signature)
 	if err != nil {
 		return false, errors.New("签名解码失败: " + err.Error())
 	}

package/pay/honor/notification.go

@@ -1,11 +1,40 @@
 package honor
 
 import (
+	"errors"
+
+	"github.com/gogf/gf/v2/encoding/gjson"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gctx"
+	"github.com/gogf/gf/v2/util/grand"
+
 	"net/http"
 )
 
+type Response struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+	Data    struct {
+		PurchaseProductInfo string `json:"purchaseProductInfo"`
+		DataSig             string `json:"dataSig"`
+		SigAlgorithm        string `json:"sigAlgorithm"`
+	} `json:"data"`
+}
+
+//// 响应结果结构体
+//type Response struct {
+//	Code    int          `json:"code"`    // 结果码 0: 成功，其他: 失败
+//	Message string       `json:"message"` // 错误信息
+//	Data    *DataContent `json:"data"`    // 包含购买信息的结构体
+//}
+//
+//// 数据内容结构体，对应data字段
+//type DataContent struct {
+//	PurchaseProductInfo string `json:"purchaseProductInfo"` // 消耗结果数据的JSON字符串
+//	DataSig             string `json:"dataSig"`             // purchaseProductInfo的签名
+//	SigAlgorithm        string `json:"sigAlgorithm"`        // 签名算法，云侧加密算法为"RSA"
+//}
+
 func (p *Pay) Notification(r *http.Request) {
 
 }
@@ -13,14 +42,33 @@ func (p *Pay) Notification(r *http.Request) {
 // ConsumeProduct 商品消耗
 func (p *Pay) ConsumeProduct(purchaseToken string) (err error) {
 	url := Host + "/iap/server/consumeProduct"
-	_, err = g.Client().ContentJson().Post(gctx.New(), url, g.Map{
-		"purchaseToken":      purchaseToken,
-		"developerChallenge": "",
-	})
+	//获取token
+	token, err := p.GetToken(gctx.New())
 	if err != nil {
-
 		return
 	}
+	var header = g.MapStrStr{
+		"access-token":  token,
+		"x-iap-appid":   p.AppId,
+		"purchaseToken": purchaseToken,
+	}
+	var params = g.Map{
+		"purchaseToken":      purchaseToken,
+		"developerChallenge": grand.S(16),
+	}
+
+	get := g.Client().ContentJson().Header(header).PostContent(gctx.New(), url, params)
+	g.Log().Debugf(gctx.New(), "商品消耗请求发送:url=%v, header=%v, params=%v", url, header, params)
+	g.Log().Debugf(gctx.New(), "商品消耗请求收到回复: %s", get)
+	var res *Response
+	err = gjson.DecodeTo(get, &res)
+	if err != nil {
+		return
+	}
+	if res.Code != 0 {
+		g.Log().Error(gctx.New(), "商品消耗失败: "+res.Message)
+		return errors.New(res.Message)
+	}
 
 	return
 }

service/game_act.go

@@ -8,6 +8,7 @@ package service
 import (
 	"context"
 
+	"github.com/ayflying/utility_go/internal/model/entity"
 	"github.com/gogf/gf/v2/frame/g"
 )
 
@@ -31,8 +32,48 @@ type (
 		// @param data interface{}: 要存储的活动信息数据。
 		// @return err error: 返回错误信息，如果操作成功，则返回nil。
 		Set(uid int64, actId int, data interface{}) (err error)
+		// Saves 保存游戏活动数据
+		//
+		// @Description: 保存游戏活动数据
+		// @receiver s *sGameAct: 游戏活动服务结构体指针
+		// @return err error: 返回错误信息
+		// Deprecated: 该方法已被弃用，建议使用SavesV2方法
 		Saves() (err error)
+		// Save 保存游戏活动数据
+		//
+		// @Description: 保存游戏活动数据
+		// @receiver s *sGameAct: 游戏活动服务结构体指针
+		// @param ctx context.Context: 上下文对象
+		// @param actId int: 活动ID
+		// @return err error: 返回错误信息
+		// deprecated: 该方法已被弃用，建议使用SaveV2方法
 		Save(ctx context.Context, actId int) (err error)
+		// SavesV2 保存游戏活动数据
+		//
+		// @Description: 保存游戏活动数据
+		// @receiver s *sGameAct: 游戏活动服务结构体指针
+		// @return err error: 返回错误信息
+		SavesV2() (err error)
+		// SaveV2 保存游戏活动数据
+		//
+		// @Description: 保存游戏活动数据
+		// @receiver s *sGameAct: 游戏活动服务结构体指针
+		// @param ctx context.Context: 上下文对象
+		// @param cacheKey string: 缓存键
+		// @param add []*entity.GameAct: 添加数据
+		// @param update []*entity.GameAct: 更新数据
+		// @return err error: 返回错误信息
+		SaveV2(ctx context.Context, cacheKey string, addChan chan *entity.GameAct, updateChan chan *entity.GameAct) (err error)
+		// Cache2Sql 缓存持久化到数据库
+		// @Description: 缓存持久化到数据库
+		// @receiver s *sGameAct: 游戏活动服务结构体指针
+		// @param ctx context.Context: 上下文对象
+		// @param add []*entity.GameAct: 添加数据
+		// @param update []*entity.GameAct: 更新数据
+		// @return err error: 返回错误信息
+		Cache2Sql(ctx context.Context, add []*entity.GameAct, update []*entity.GameAct)
+		// Cache2AddChan 批量添加数据库
+		Cache2SqlChan(ctx context.Context, addChan chan *entity.GameAct, updateChan chan *entity.GameAct)
 		// 删除缓存key
 		DelCacheKey(ctx context.Context, aid int, uid int64)
 		// 清空GetRedDot缓存