// Copyright © 2023 OpenIM. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package api import ( "context" "fmt" "math/rand" "strconv" "time" "github.com/gin-gonic/gin" "github.com/redis/go-redis/v9" "git.imall.cloud/openim/open-im-server-deploy/pkg/apistruct" "git.imall.cloud/openim/open-im-server-deploy/pkg/common/servererrs" "git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/database" "git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/database/mgo" "git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/model" "git.imall.cloud/openim/open-im-server-deploy/pkg/msgprocessor" "git.imall.cloud/openim/open-im-server-deploy/pkg/rpcli" "git.imall.cloud/openim/protocol/constant" "git.imall.cloud/openim/protocol/msg" "git.imall.cloud/openim/protocol/sdkws" "github.com/openimsdk/tools/apiresp" "github.com/openimsdk/tools/errs" "github.com/openimsdk/tools/log" "github.com/openimsdk/tools/mcontext" "github.com/openimsdk/tools/utils/idutil" "github.com/openimsdk/tools/utils/jsonutil" "github.com/openimsdk/tools/utils/timeutil" ) type RedPacketApi struct { groupClient *rpcli.GroupClient userClient *rpcli.UserClient msgClient msg.MsgClient redPacketDB database.RedPacket redPacketReceiveDB database.RedPacketReceive walletDB database.Wallet walletBalanceRecordDB database.WalletBalanceRecord redisClient redis.UniversalClient } func NewRedPacketApi(groupClient *rpcli.GroupClient, userClient *rpcli.UserClient, msgClient msg.MsgClient, redPacketDB database.RedPacket, redPacketReceiveDB database.RedPacketReceive, walletDB database.Wallet, walletBalanceRecordDB database.WalletBalanceRecord, redisClient redis.UniversalClient) *RedPacketApi { return &RedPacketApi{ groupClient: groupClient, userClient: userClient, msgClient: msgClient, redPacketDB: redPacketDB, redPacketReceiveDB: redPacketReceiveDB, walletDB: walletDB, walletBalanceRecordDB: walletBalanceRecordDB, redisClient: redisClient, } } // SendRedPacket 发送红包（只支持群聊，发送用户默认为群主） func (r *RedPacketApi) SendRedPacket(c *gin.Context) { var ( req apistruct.SendRedPacketReq resp apistruct.SendRedPacketResp ) if err := c.BindJSON(&req); err != nil { apiresp.GinError(c, errs.ErrArgs.WithDetail(err.Error()).Wrap()) return } // 验证红包参数 if req.TotalAmount <= 0 { apiresp.GinError(c, errs.ErrArgs.WrapMsg("totalAmount must be greater than 0")) return } if req.TotalCount <= 0 { apiresp.GinError(c, errs.ErrArgs.WrapMsg("totalCount must be greater than 0")) return } if req.RedPacketType != 1 && req.RedPacketType != 2 { apiresp.GinError(c, errs.ErrArgs.WrapMsg("redPacketType must be 1 (normal) or 2 (random)")) return } // 获取群信息，验证群是否存在 groupInfos, err := r.groupClient.GetGroupsInfo(c, []string{req.GroupID}) if err != nil { apiresp.GinError(c, err) return } if len(groupInfos) == 0 { apiresp.GinError(c, errs.ErrArgs.WrapMsg("group not found")) return } groupInfo := groupInfos[0] // 获取群主ID（发送用户默认为群主） sendUserID := groupInfo.OwnerUserID if sendUserID == "" { apiresp.GinError(c, errs.ErrArgs.WrapMsg("group owner not found")) return } // 获取群主用户信息（用于设置发送者昵称和头像） userInfos, err := r.userClient.GetUsersInfo(c, []string{sendUserID}) if err != nil { log.ZWarn(c, "SendRedPacket: failed to get user info", err, "sendUserID", sendUserID) // 如果获取用户信息失败，继续发送，但不设置昵称和头像 } var senderNickname, senderFaceURL string if len(userInfos) > 0 && userInfos[0] != nil { senderNickname = userInfos[0].Nickname senderFaceURL = userInfos[0].FaceURL } // 生成红包ID redPacketID := idutil.GetMsgIDByMD5(sendUserID + req.GroupID + timeutil.GetCurrentTimeFormatted()) // 计算会话ID conversationID := msgprocessor.GetConversationIDBySessionType(constant.ReadGroupChatType, req.GroupID) // 计算过期时间（默认24小时） expireTime := time.Now().Add(24 * time.Hour) // 初始化Redis数据结构（所有红包类型都需要） if r.redisClient == nil { apiresp.GinError(c, errs.ErrInternalServer.WrapMsg("redis client is not available")) return } ctx := context.Background() queueKey := r.getRedPacketQueueKey(redPacketID) usersKey := r.getRedPacketUsersKey(redPacketID) expireDuration := 24 * time.Hour if req.RedPacketType == model.RedPacketTypeRandom { // 拼手气红包：预先分配金额并推送到Redis队列 amounts, err := r.allocateRandomAmounts(req.TotalAmount, req.TotalCount) if err != nil { log.ZError(c, "SendRedPacket: failed to allocate random amounts", err, "redPacketID", redPacketID, "groupID", req.GroupID) apiresp.GinError(c, errs.ErrInternalServer.WrapMsg("failed to allocate random amounts")) return } pipe := r.redisClient.Pipeline() for _, amount := range amounts { pipe.RPush(ctx, queueKey, strconv.FormatInt(amount, 10)) } pipe.Expire(ctx, queueKey, expireDuration) pipe.Expire(ctx, usersKey, expireDuration) if _, err := pipe.Exec(ctx); err != nil { log.ZError(c, "SendRedPacket: failed to push amounts to redis queue", err, "redPacketID", redPacketID, "groupID", req.GroupID) apiresp.GinError(c, errs.ErrInternalServer.WrapMsg("failed to push amounts to redis queue")) return } log.ZInfo(c, "SendRedPacket: pushed amounts to redis queue", "redPacketID", redPacketID, "count", len(amounts)) } else { // 普通红包：初始化队列，每个元素为平均金额 avgAmount := req.TotalAmount / int64(req.TotalCount) pipe := r.redisClient.Pipeline() for i := int32(0); i < req.TotalCount; i++ { pipe.RPush(ctx, queueKey, strconv.FormatInt(avgAmount, 10)) } pipe.Expire(ctx, queueKey, expireDuration) pipe.Expire(ctx, usersKey, expireDuration) if _, err := pipe.Exec(ctx); err != nil { log.ZError(c, "SendRedPacket: failed to initialize redis queue", err, "redPacketID", redPacketID, "groupID", req.GroupID) apiresp.GinError(c, errs.ErrInternalServer.WrapMsg("failed to initialize redis queue")) return } log.ZInfo(c, "SendRedPacket: initialized redis queue for normal red packet", "redPacketID", redPacketID, "count", req.TotalCount, "avgAmount", avgAmount) } // 创建红包数据库记录 redPacketRecord := &model.RedPacket{ RedPacketID: redPacketID, SendUserID: sendUserID, GroupID: req.GroupID, ConversationID: conversationID, SessionType: constant.ReadGroupChatType, RedPacketType: req.RedPacketType, TotalAmount: req.TotalAmount, TotalCount: req.TotalCount, RemainAmount: req.TotalAmount, RemainCount: req.TotalCount, Blessing: req.Blessing, Status: model.RedPacketStatusActive, ExpireTime: expireTime, CreateTime: time.Now(), } // 保存红包记录到数据库 if err := r.redPacketDB.Create(c, redPacketRecord); err != nil { log.ZError(c, "SendRedPacket: failed to create red packet record", err, "redPacketID", redPacketID, "groupID", req.GroupID) apiresp.GinError(c, errs.ErrInternalServer.WrapMsg("failed to create red packet record")) return } // 创建红包消息内容（使用自定义消息格式） redPacketElem := apistruct.RedPacketElem{ RedPacketID: redPacketID, RedPacketType: req.RedPacketType, Blessing: req.Blessing, } // 将红包数据序列化为JSON字符串，存储在data字段中 redPacketData := jsonutil.StructToJsonString(redPacketElem) // 构建自定义消息结构 customElem := apistruct.CustomElem{ Data: redPacketData, Description: "redpacket", // 二级类型标识：红包消息 Extension: "", // 扩展字段，可用于未来扩展 } content := jsonutil.StructToJsonString(customElem) // 构建消息请求 msgData := &sdkws.MsgData{ SendID: sendUserID, GroupID: req.GroupID, ClientMsgID: idutil.GetMsgIDByMD5(sendUserID), SenderPlatformID: 0, // 系统发送 SenderNickname: senderNickname, SenderFaceURL: senderFaceURL, SessionType: constant.ReadGroupChatType, MsgFrom: constant.SysMsgType, ContentType: constant.Custom, // 使用自定义消息类型（110） CreateTime: timeutil.GetCurrentTimestampByMill(), SendTime: timeutil.GetCurrentTimestampByMill(), Content: []byte(content), Options: make(map[string]bool), } // 发送消息 sendMsgReq := &msg.SendMsgReq{ MsgData: msgData, } sendMsgResp, err := r.msgClient.SendMsg(c, sendMsgReq) if err != nil { log.ZError(c, "SendRedPacket: failed to send message", err, "redPacketID", redPacketID, "groupID", req.GroupID) apiresp.GinError(c, err) return } // 返回响应 resp.RedPacketID = redPacketID resp.ServerMsgID = sendMsgResp.ServerMsgID resp.ClientMsgID = msgData.ClientMsgID resp.SendTime = sendMsgResp.SendTime log.ZInfo(c, "SendRedPacket: success", "redPacketID", redPacketID, "groupID", req.GroupID, "sendUserID", sendUserID) apiresp.GinSuccess(c, resp) } // allocateRandomAmounts 分配拼手气红包金额（仿照微信红包算法） // 算法原理： // 1. 确保每个红包至少有最小金额（1分） // 2. 对于前n-1个红包，每次分配时动态计算最大可分配金额 // 3. 在最小金额和最大金额之间随机分配 // 4. 最后一个红包直接分配剩余金额 // 5. 打乱顺序增加随机性 func (r *RedPacketApi) allocateRandomAmounts(totalAmount int64, totalCount int32) ([]int64, error) { if totalCount <= 0 { return nil, errs.ErrArgs.WrapMsg("totalCount must be greater than 0") } if totalAmount < int64(totalCount) { return nil, errs.ErrArgs.WrapMsg("totalAmount must be at least totalCount (minimum 1 cent per packet)") } const minAmount = 1 // 最小金额：1分 amounts := make([]int64, totalCount) remainAmount := totalAmount remainCount := totalCount // 使用随机种子 rand.Seed(time.Now().UnixNano()) // 分配前n-1个红包 for i := int32(0); i < totalCount-1; i++ { // 计算最大可分配金额：剩余金额 / 剩余红包数 * 2 // 这样可以保证后续红包还能分配，避免出现0或全部的情况 // 但需要确保至少是最小金额 maxAmount := remainAmount / int64(remainCount) * 2 if maxAmount < minAmount { maxAmount = minAmount } // 如果剩余金额不足以分配给剩余红包（每个至少1分），则直接分配剩余金额 if remainAmount <= int64(remainCount)*minAmount { amounts[i] = minAmount remainAmount -= minAmount remainCount-- continue } // 确保最大金额不超过剩余金额减去剩余红包的最小金额 // 这样可以保证后续红包至少能分配到最小金额 maxAllowed := remainAmount - int64(remainCount-1)*minAmount if maxAmount > maxAllowed { maxAmount = maxAllowed } // 在最小金额和最大金额之间随机分配 // 如果最大金额等于最小金额，直接使用最小金额 var amount int64 if maxAmount <= minAmount { amount = minAmount } else { amount = rand.Int63n(maxAmount-minAmount+1) + minAmount } amounts[i] = amount remainAmount -= amount remainCount-- } // 最后一个红包，直接分配剩余金额 amounts[totalCount-1] = remainAmount // 验证：确保每个红包至少1分 if amounts[totalCount-1] < minAmount { return nil, errs.ErrInternalServer.WrapMsg("last packet amount is less than minimum") } // 打乱顺序（增加随机性） rand.Shuffle(len(amounts), func(i, j int) { amounts[i], amounts[j] = amounts[j], amounts[i] }) // 最终验证：确保每个红包至少1分，总和等于总金额 var sum int64 for i := int32(0); i < totalCount; i++ { if amounts[i] < minAmount { return nil, errs.ErrInternalServer.WrapMsg("allocated amount is less than minimum") } sum += amounts[i] } if sum != totalAmount { return nil, errs.ErrInternalServer.WrapMsg("allocated amount sum mismatch") } return amounts, nil } // writeRedPacketRecordToMongoDB 异步写入MongoDB领取记录 func (r *RedPacketApi) writeRedPacketRecordToMongoDB(ctx context.Context, redPacketID, userID string, amount int64) { receiveID := idutil.GetMsgIDByMD5(userID + redPacketID + timeutil.GetCurrentTimeFormatted()) receiveRecord := &model.RedPacketReceive{ ReceiveID: receiveID, RedPacketID: redPacketID, ReceiveUserID: userID, Amount: amount, ReceiveTime: time.Now(), IsLucky: false, } if err := r.redPacketReceiveDB.Create(ctx, receiveRecord); err != nil { // 检查是否是唯一索引冲突（MongoDB E11000错误） errStr := err.Error() if errs.ErrArgs.Is(err) || (len(errStr) > 0 && (errStr == "E11000 duplicate key error" || errStr == "duplicate key error collection" || len(errStr) > 5 && errStr[:5] == "E11000")) { log.ZDebug(ctx, "ReceiveRedPacket: receive record already exists (duplicate key)", "redPacketID", redPacketID, "userID", userID) return } // 其他错误记录日志，后续补偿机制会处理 log.ZError(ctx, "ReceiveRedPacket: failed to write receive record to MongoDB", err, "redPacketID", redPacketID, "userID", userID, "amount", amount) } } // updateWalletBalanceAsync 异步更新钱包余额 func (r *RedPacketApi) updateWalletBalanceAsync(ctx context.Context, userID string, amount int64, redPacketID string) { maxRetries := 3 var updateSuccess bool for retry := 0; retry < maxRetries; retry++ { // 查询或创建用户钱包 wallet, err := r.walletDB.Take(ctx, userID) if err != nil { // 如果钱包不存在，创建新钱包 if errs.ErrRecordNotFound.Is(err) || mgo.IsNotFound(err) { wallet = &model.Wallet{ UserID: userID, Balance: 0, Version: 1, CreateTime: time.Now(), UpdateTime: time.Now(), } if err := r.walletDB.Create(ctx, wallet); err != nil { log.ZError(ctx, "ReceiveRedPacket: failed to create wallet", err, "userID", userID, "retry", retry) // 如果创建失败，可能是并发创建，下次重试会查到 if retry < maxRetries-1 { time.Sleep(time.Millisecond * 50) continue } return } } else { log.ZError(ctx, "ReceiveRedPacket: failed to get wallet", err, "userID", userID, "retry", retry) if retry < maxRetries-1 { time.Sleep(time.Millisecond * 50) continue } return } } // 使用版本号更新余额（防止并发覆盖） params := &database.WalletUpdateParams{ UserID: userID, Operation: "add", Amount: amount, OldBalance: wallet.Balance, OldVersion: wallet.Version, } result, err := r.walletDB.UpdateBalanceWithVersion(ctx, params) if err != nil { // 如果是并发冲突（版本号不匹配），重试 log.ZWarn(ctx, "ReceiveRedPacket: concurrent modification detected, retrying", err, "userID", userID, "retry", retry+1, "maxRetries", maxRetries) if retry < maxRetries-1 { time.Sleep(time.Millisecond * 100) continue } log.ZError(ctx, "ReceiveRedPacket: failed to update wallet balance after retries", err, "userID", userID, "amount", amount) return } // 更新成功，创建余额记录 updateSuccess = true // 创建余额记录 recordID := idutil.GetMsgIDByMD5(userID + timeutil.GetCurrentTimeFormatted() + "add" + strconv.FormatInt(amount, 10) + redPacketID) balanceRecord := &model.WalletBalanceRecord{ ID: recordID, UserID: userID, Amount: amount, // 领取红包金额（正数） Type: 8, // 8 = 抢红包 BeforeBalance: params.OldBalance, AfterBalance: result.NewBalance, OrderID: "", TransactionID: "", RedPacketID: redPacketID, Remark: "领取红包", CreateTime: time.Now(), } if err := r.walletBalanceRecordDB.Create(ctx, balanceRecord); err != nil { log.ZWarn(ctx, "ReceiveRedPacket: failed to create balance record", err, "userID", userID, "redPacketID", redPacketID, "amount", amount) } log.ZInfo(ctx, "ReceiveRedPacket: wallet balance updated async", "userID", userID, "oldBalance", wallet.Balance, "newBalance", result.NewBalance, "amount", amount) break } if !updateSuccess { log.ZError(ctx, "ReceiveRedPacket: failed to update wallet balance after all retries", nil, "userID", userID, "maxRetries", maxRetries) } } // writeToCompensationStream 写入失败补偿Stream（Redis Stream） func (r *RedPacketApi) writeToCompensationStream(ctx context.Context, redPacketID, userID string, amount int64) { if r.redisClient == nil { return } streamKey := r.getRedPacketStreamKey(redPacketID) // 使用 XADD 写入Stream，字段包含必要信息 values := map[string]interface{}{ "userID": userID, "amount": amount, "time": time.Now().Unix(), } if err := r.redisClient.XAdd(ctx, &redis.XAddArgs{ Stream: streamKey, Values: values, }).Err(); err != nil { log.ZWarn(ctx, "ReceiveRedPacket: failed to write to compensation stream", err, "redPacketID", redPacketID, "userID", userID) } } // ReceiveRedPacket 领取红包（新方案：Redis负责并发控制，MongoDB异步写入） func (r *RedPacketApi) ReceiveRedPacket(c *gin.Context) { var ( req apistruct.ReceiveRedPacketReq resp apistruct.ReceiveRedPacketResp ) if err := c.BindJSON(&req); err != nil { apiresp.GinError(c, errs.ErrArgs.WithDetail(err.Error()).Wrap()) return } // 获取当前用户ID opUserID := mcontext.GetOpUserID(c) if opUserID == "" { apiresp.GinError(c, errs.ErrArgs.WrapMsg("userID is required")) return } // 查询红包基本信息（用于状态检查） redPacket, err := r.redPacketDB.Take(c, req.RedPacketID) if err != nil { log.ZError(c, "ReceiveRedPacket: failed to get red packet", err, "redPacketID", req.RedPacketID, "userID", opUserID) apiresp.GinError(c, errs.ErrArgs.WrapMsg("red packet not found")) return } // 检查红包状态（过期状态检查） if redPacket.Status == model.RedPacketStatusExpired { apiresp.GinError(c, servererrs.ErrRedPacketExpired) return } // 【核心】使用Redis Lua脚本原子性地抢红包 ctx := context.Background() amount, err := r.grabRedPacketFromRedis(ctx, req.RedPacketID, opUserID) if err != nil { if servererrs.ErrRedPacketAlreadyReceived.Is(err) { apiresp.GinError(c, err) return } if servererrs.ErrRedPacketFinished.Is(err) { apiresp.GinError(c, err) return } // 其他错误（可能是Lua脚本执行失败或返回值解析失败） log.ZError(c, "ReceiveRedPacket: failed to grab red packet from redis", err, "redPacketID", req.RedPacketID, "userID", opUserID, "error", err.Error()) apiresp.GinError(c, errs.ErrInternalServer.WrapMsg("failed to grab red packet: "+err.Error())) return } // Redis抢红包成功，立即返回结果 resp.RedPacketID = req.RedPacketID resp.Amount = amount resp.IsLucky = false log.ZInfo(c, "ReceiveRedPacket: successfully grabbed from redis", "redPacketID", req.RedPacketID, "userID", opUserID, "amount", amount) apiresp.GinSuccess(c, resp) // 【异步写入MongoDB】Redis成功后，异步写入MongoDB和补偿Stream go func() { // 写入失败补偿Stream（用于后续补偿） r.writeToCompensationStream(ctx, req.RedPacketID, opUserID, amount) // 异步写入MongoDB领取记录 r.writeRedPacketRecordToMongoDB(ctx, req.RedPacketID, opUserID, amount) // 异步更新钱包余额 r.updateWalletBalanceAsync(ctx, opUserID, amount, req.RedPacketID) }() } // getRedPacketQueueKey 获取红包队列的Redis key func (r *RedPacketApi) getRedPacketQueueKey(redPacketID string) string { return "rp:" + redPacketID + ":list" } // getRedPacketUsersKey 获取已领取用户Set的Redis key func (r *RedPacketApi) getRedPacketUsersKey(redPacketID string) string { return "rp:" + redPacketID + ":users" } // getRedPacketStreamKey 获取红包领取日志Stream的Redis key（用于失败补偿） func (r *RedPacketApi) getRedPacketStreamKey(redPacketID string) string { return "rp:" + redPacketID + ":stream" } // grabRedPacketLuaScript Redis Lua脚本：原子性地抢红包 // 返回值： // // -1: 用户已领取 // -2: 红包已领完 // -3: 金额解析失败（数据异常） // >0: 领取成功，返回金额（分） var grabRedPacketLuaScript = redis.NewScript(` -- KEYS[1] 红包金额 list (rp:{packetId}:list) -- KEYS[2] 已抢用户 set (rp:{packetId}:users) -- ARGV[1] userId -- 已抢判断 if redis.call('SISMEMBER', KEYS[2], ARGV[1]) == 1 then return -1 end -- 抢红包 local money = redis.call('LPOP', KEYS[1]) if not money then return -2 end -- 将字符串金额转换为数字 local amount = tonumber(money) if not amount then return -3 end -- 记录用户（在返回之前记录，确保原子性） redis.call('SADD', KEYS[2], ARGV[1]) -- 返回数字金额 return amount `) // grabRedPacketFromRedis 使用Redis Lua脚本原子性地抢红包 func (r *RedPacketApi) grabRedPacketFromRedis(ctx context.Context, redPacketID, userID string) (int64, error) { if r.redisClient == nil { return 0, errs.ErrInternalServer.WrapMsg("redis client is not available") } listKey := r.getRedPacketQueueKey(redPacketID) usersKey := r.getRedPacketUsersKey(redPacketID) // 执行Lua脚本 result, err := grabRedPacketLuaScript.Eval(ctx, r.redisClient, []string{listKey, usersKey}, userID).Result() if err != nil { log.ZError(ctx, "ReceiveRedPacket: lua script execution failed", err, "redPacketID", redPacketID, "userID", userID, "listKey", listKey, "usersKey", usersKey) return 0, errs.Wrap(err) } // 记录原始返回值，用于调试 log.ZDebug(ctx, "ReceiveRedPacket: lua script result", "redPacketID", redPacketID, "userID", userID, "result", result, "resultType", fmt.Sprintf("%T", result)) // 解析返回值（Lua脚本返回的是数字，但Redis可能返回字符串或数字） var code int64 switch v := result.(type) { case int64: code = v case int: code = int64(v) case string: // 如果返回字符串，尝试转换为数字 parsed, err := strconv.ParseInt(v, 10, 64) if err != nil { log.ZError(ctx, "ReceiveRedPacket: failed to parse lua script return value", err, "redPacketID", redPacketID, "userID", userID, "result", result) return 0, errs.ErrInternalServer.WrapMsg("invalid lua script return value: " + v) } code = parsed default: log.ZError(ctx, "ReceiveRedPacket: unexpected lua script return type", nil, "redPacketID", redPacketID, "userID", userID, "result", result, "type", fmt.Sprintf("%T", result)) return 0, errs.ErrInternalServer.WrapMsg(fmt.Sprintf("invalid lua script return value type: %T", result)) } switch code { case -1: return 0, servererrs.ErrRedPacketAlreadyReceived case -2: return 0, servererrs.ErrRedPacketFinished case -3: return 0, errs.ErrInternalServer.WrapMsg("invalid red packet amount data") default: // code > 0 表示领取成功，返回金额 return code, nil } } // paginationWrapper 实现 pagination.Pagination 接口 type paginationWrapper struct { pageNumber int32 showNumber int32 } func (p *paginationWrapper) GetPageNumber() int32 { if p.pageNumber <= 0 { return 1 } return p.pageNumber } func (p *paginationWrapper) GetShowNumber() int32 { if p.showNumber <= 0 { return 20 } return p.showNumber } // GetRedPacketsByGroup 根据群ID查询红包列表（后台管理接口） func (r *RedPacketApi) GetRedPacketsByGroup(c *gin.Context) { var ( req apistruct.GetRedPacketsByGroupReq resp apistruct.GetRedPacketsByGroupResp ) if err := c.BindJSON(&req); err != nil { apiresp.GinError(c, errs.ErrArgs.WithDetail(err.Error()).Wrap()) return } // 设置默认分页参数 if req.Pagination.PageNumber <= 0 { req.Pagination.PageNumber = 1 } if req.Pagination.ShowNumber <= 0 { req.Pagination.ShowNumber = 20 } // 创建分页对象 pagination := &paginationWrapper{ pageNumber: req.Pagination.PageNumber, showNumber: req.Pagination.ShowNumber, } // 查询红包列表 var total int64 var redPackets []*model.RedPacket var err error if req.GroupID == "" { // 如果群ID为空，查询所有红包 total, redPackets, err = r.redPacketDB.FindAllRedPackets(c, pagination) } else { // 如果群ID不为空，查询指定群的红包 total, redPackets, err = r.redPacketDB.FindRedPacketsByGroup(c, req.GroupID, pagination) } if err != nil { log.ZError(c, "GetRedPacketsByGroup: failed to find red packets", err, "groupID", req.GroupID) apiresp.GinError(c, errs.ErrInternalServer.WrapMsg("failed to find red packets")) return } // 收集所有唯一的群ID groupIDMap := make(map[string]bool) for _, rp := range redPackets { if rp.GroupID != "" { groupIDMap[rp.GroupID] = true } } // 批量查询群信息 groupIDList := make([]string, 0, len(groupIDMap)) for groupID := range groupIDMap { groupIDList = append(groupIDList, groupID) } groupInfoMap := make(map[string]string) // groupID -> groupName if len(groupIDList) > 0 { groupInfos, err := r.groupClient.GetGroupsInfo(c, groupIDList) if err == nil && groupInfos != nil { for _, groupInfo := range groupInfos { groupInfoMap[groupInfo.GroupID] = groupInfo.GroupName } } else { log.ZWarn(c, "GetRedPacketsByGroup: failed to get groups info", err, "groupIDs", groupIDList) } } // 转换为响应格式 resp.Total = total resp.RedPackets = make([]*apistruct.RedPacketInfo, 0, len(redPackets)) for _, rp := range redPackets { groupName := groupInfoMap[rp.GroupID] resp.RedPackets = append(resp.RedPackets, &apistruct.RedPacketInfo{ RedPacketID: rp.RedPacketID, SendUserID: rp.SendUserID, GroupID: rp.GroupID, GroupName: groupName, RedPacketType: rp.RedPacketType, TotalAmount: rp.TotalAmount, TotalCount: rp.TotalCount, RemainAmount: rp.RemainAmount, RemainCount: rp.RemainCount, Blessing: rp.Blessing, Status: rp.Status, ExpireTime: rp.ExpireTime.UnixMilli(), CreateTime: rp.CreateTime.UnixMilli(), }) } log.ZInfo(c, "GetRedPacketsByGroup: success", "groupID", req.GroupID, "total", total, "count", len(resp.RedPackets)) apiresp.GinSuccess(c, resp) } // GetRedPacketReceiveInfo 查询红包领取情况（后台管理接口） func (r *RedPacketApi) GetRedPacketReceiveInfo(c *gin.Context) { var ( req apistruct.GetRedPacketReceiveInfoReq resp apistruct.GetRedPacketReceiveInfoResp ) if err := c.BindJSON(&req); err != nil { apiresp.GinError(c, errs.ErrArgs.WithDetail(err.Error()).Wrap()) return } // 查询红包信息 redPacket, err := r.redPacketDB.Take(c, req.RedPacketID) if err != nil { log.ZError(c, "GetRedPacketReceiveInfo: failed to get red packet", err, "redPacketID", req.RedPacketID) apiresp.GinError(c, errs.ErrArgs.WrapMsg("red packet not found")) return } // 查询领取记录 receives, err := r.redPacketReceiveDB.FindByRedPacketID(c, req.RedPacketID) if err != nil { log.ZError(c, "GetRedPacketReceiveInfo: failed to find receives", err, "redPacketID", req.RedPacketID) apiresp.GinError(c, errs.ErrInternalServer.WrapMsg("failed to find receives")) return } // 填充响应数据 resp.RedPacketID = redPacket.RedPacketID resp.TotalAmount = redPacket.TotalAmount resp.TotalCount = redPacket.TotalCount resp.RemainAmount = redPacket.RemainAmount resp.RemainCount = redPacket.RemainCount resp.Status = redPacket.Status resp.Receives = make([]*apistruct.RedPacketReceiveDetail, 0, len(receives)) for _, rec := range receives { resp.Receives = append(resp.Receives, &apistruct.RedPacketReceiveDetail{ ReceiveID: rec.ReceiveID, ReceiveUserID: rec.ReceiveUserID, Amount: rec.Amount, ReceiveTime: rec.ReceiveTime.UnixMilli(), IsLucky: false, // 已去掉手气最佳功能，始终返回 false }) } log.ZInfo(c, "GetRedPacketReceiveInfo: success", "redPacketID", req.RedPacketID, "receiveCount", len(resp.Receives)) apiresp.GinSuccess(c, resp) } // PauseRedPacket 暂停红包（后台管理接口）- 清空Redis队列 func (r *RedPacketApi) PauseRedPacket(c *gin.Context) { var ( req apistruct.PauseRedPacketReq resp apistruct.PauseRedPacketResp ) if err := c.BindJSON(&req); err != nil { apiresp.GinError(c, errs.ErrArgs.WithDetail(err.Error()).Wrap()) return } // 查询红包信息，验证红包是否存在 redPacket, err := r.redPacketDB.Take(c, req.RedPacketID) if err != nil { log.ZError(c, "PauseRedPacket: failed to get red packet", err, "redPacketID", req.RedPacketID) apiresp.GinError(c, errs.ErrArgs.WrapMsg("red packet not found")) return } // 只有拼手气红包才有Redis队列，需要清空 if redPacket.RedPacketType == model.RedPacketTypeRandom { if r.redisClient == nil { apiresp.GinError(c, errs.ErrInternalServer.WrapMsg("redis client is not available")) return } // 获取Redis队列key queueKey := r.getRedPacketQueueKey(req.RedPacketID) ctx := context.Background() // 清空Redis队列（删除整个key） err = r.redisClient.Del(ctx, queueKey).Err() if err != nil { log.ZError(c, "PauseRedPacket: failed to delete redis queue", err, "redPacketID", req.RedPacketID, "queueKey", queueKey) apiresp.GinError(c, errs.ErrInternalServer.WrapMsg("failed to pause red packet")) return } log.ZInfo(c, "PauseRedPacket: cleared redis queue", "redPacketID", req.RedPacketID, "queueKey", queueKey) } else { // 普通红包没有Redis队列，直接返回成功 log.ZInfo(c, "PauseRedPacket: normal red packet, no redis queue to clear", "redPacketID", req.RedPacketID) } // 返回响应 resp.RedPacketID = req.RedPacketID log.ZInfo(c, "PauseRedPacket: success", "redPacketID", req.RedPacketID) apiresp.GinSuccess(c, resp) } // GetRedPacketDetail 查询红包详情（用户端接口） func (r *RedPacketApi) GetRedPacketDetail(c *gin.Context) { var ( req apistruct.GetRedPacketDetailReq resp apistruct.GetRedPacketDetailResp ) if err := c.BindJSON(&req); err != nil { apiresp.GinError(c, errs.ErrArgs.WithDetail(err.Error()).Wrap()) return } // 获取当前用户ID opUserID := mcontext.GetOpUserID(c) if opUserID == "" { apiresp.GinError(c, errs.ErrArgs.WrapMsg("userID is required")) return } // 查询红包信息 redPacket, err := r.redPacketDB.Take(c, req.RedPacketID) if err != nil { log.ZError(c, "GetRedPacketDetail: failed to get red packet", err, "redPacketID", req.RedPacketID, "userID", opUserID) apiresp.GinError(c, errs.ErrArgs.WrapMsg("red packet not found")) return } // 验证用户是否在群里 groupMember, err := r.groupClient.GetGroupMemberInfo(c, redPacket.GroupID, opUserID) if err != nil || groupMember == nil { log.ZWarn(c, "GetRedPacketDetail: user not in group", err, "redPacketID", req.RedPacketID, "groupID", redPacket.GroupID, "userID", opUserID) apiresp.GinError(c, errs.ErrNoPermission.WrapMsg("user not in group")) return } // 判断是否过期（超过一周） oneWeekAgo := time.Now().Add(-7 * 24 * time.Hour) isExpired := redPacket.CreateTime.Before(oneWeekAgo) // 查询当前用户的领取信息 myReceive, err := r.redPacketReceiveDB.FindByUserAndRedPacketID(c, opUserID, req.RedPacketID) var myReceiveDetail *apistruct.RedPacketMyReceiveDetail if err == nil && myReceive != nil { // 自己的领取信息不返回用户ID、昵称、头像 myReceiveDetail = &apistruct.RedPacketMyReceiveDetail{ ReceiveID: myReceive.ReceiveID, Amount: myReceive.Amount, ReceiveTime: myReceive.ReceiveTime.UnixMilli(), IsLucky: false, // 已去掉手气最佳功能，始终返回 false } } // 判断是否是群主或管理员 isOwnerOrAdmin := groupMember.RoleLevel == constant.GroupOwner || groupMember.RoleLevel == constant.GroupAdmin // 构建响应 resp.RedPacketID = redPacket.RedPacketID resp.GroupID = redPacket.GroupID resp.RedPacketType = redPacket.RedPacketType resp.TotalAmount = redPacket.TotalAmount resp.TotalCount = redPacket.TotalCount resp.RemainAmount = redPacket.RemainAmount resp.RemainCount = redPacket.RemainCount resp.Blessing = redPacket.Blessing resp.Status = redPacket.Status resp.IsExpired = isExpired resp.MyReceive = myReceiveDetail resp.Receives = []*apistruct.RedPacketUserReceiveDetail{} // 如果是群主或管理员，返回所有领取记录 if isOwnerOrAdmin { receives, err := r.redPacketReceiveDB.FindByRedPacketID(c, req.RedPacketID) if err != nil { log.ZWarn(c, "GetRedPacketDetail: failed to find receives", err, "redPacketID", req.RedPacketID) } else { // 收集所有领取者ID userIDs := make([]string, 0, len(receives)) for _, rec := range receives { userIDs = append(userIDs, rec.ReceiveUserID) } // 批量获取用户信息 userInfos, err := r.userClient.GetUsersInfo(c, userIDs) if err != nil { log.ZWarn(c, "GetRedPacketDetail: failed to get users info", err, "userIDs", userIDs) } // 构建用户信息映射 userInfoMap := make(map[string]*sdkws.UserInfo) if userInfos != nil { for _, userInfo := range userInfos { if userInfo != nil { userInfoMap[userInfo.UserID] = userInfo } } } // 构建领取记录列表 resp.Receives = make([]*apistruct.RedPacketUserReceiveDetail, 0, len(receives)) for _, rec := range receives { userInfo := userInfoMap[rec.ReceiveUserID] nickname := rec.ReceiveUserID faceURL := "" if userInfo != nil { nickname = userInfo.Nickname faceURL = userInfo.FaceURL } resp.Receives = append(resp.Receives, &apistruct.RedPacketUserReceiveDetail{ ReceiveID: rec.ReceiveID, ReceiveUserID: rec.ReceiveUserID, Nickname: nickname, FaceURL: faceURL, Amount: rec.Amount, ReceiveTime: rec.ReceiveTime.UnixMilli(), IsLucky: false, // 已去掉手气最佳功能，始终返回 false }) } } } log.ZInfo(c, "GetRedPacketDetail: success", "redPacketID", req.RedPacketID, "userID", opUserID, "isOwnerOrAdmin", isOwnerOrAdmin, "isExpired", isExpired) apiresp.GinSuccess(c, resp) }