修改tencent回调,领取奖励部分

This commit is contained in:
chy
2025-06-26 21:01:49 +08:00
parent 895eca3289
commit 5c47a9a9b0
27 changed files with 508 additions and 286 deletions

View File

@ -4,6 +4,7 @@ import (
"context"
"encoding/json"
"fmt"
"github.com/gogf/gf/v2/database/gdb"
"github.com/gogf/gf/v2/os/gtime"
"server/internal/consts"
"server/internal/dao"
@ -12,6 +13,7 @@ import (
"server/internal/service"
"server/utility/ecode"
"server/utility/gamelife"
"time"
)
type sReward struct{}
@ -373,50 +375,55 @@ func (s *sReward) GetLift(ctx context.Context, in *model.GetRewardIn) (out *mode
}
// 存储数据库记录
for _, item := range result.GiftItem {
marshal, err := json.Marshal(item.Water)
if err != nil {
return nil, ecode.Fail.Sub("序列化 json 数据出现异常")
}
_, err = dao.RewardWaters.Ctx(ctx).Insert(model.RewardWaters{
OrderId: item.Water.OrderId,
Status: int64(item.Result),
Uid: item.Water.Uid,
Water: string(marshal),
TaskId: in.TaskId,
GameId: int64(in.GameId),
})
if err = dao.RewardWaters.Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {
for _, item := range result.GiftItem {
marshal, err := json.Marshal(item.Water)
if err != nil {
return ecode.Fail.Sub("序列化 json 数据出现异常")
}
_, err = dao.RewardWaters.Ctx(ctx).Insert(model.RewardWaters{
OrderId: item.Water.OrderId,
Status: int64(item.Result),
Uid: item.Water.Uid,
Water: string(marshal),
TaskId: in.TaskId,
GameId: int64(in.GameId),
})
if err != nil {
return nil, ecode.Fail.Sub("添加奖励领取记录异常")
if err != nil {
return ecode.Fail.Sub("添加奖励领取记录异常")
}
// 根据 result判断
if item.Result == 1 {
// 奖励发放成功,修改状态,扣除数量
if _, err = dao.UserTaskRewards.Ctx(ctx).Where(do.UserTaskRewards{ExternalOrderId: item.Water.OrderId}).Update(consts.RewardSuccessStatus); err != nil {
return ecode.Fail.Sub("修改奖励领取记录状态异常")
}
value, err := dao.UserTaskRewards.Ctx(ctx).Where(do.UserTaskRewards{ExternalOrderId: item.Water.OrderId}).Value(dao.UserTaskRewards.Columns().RewardId)
if err != nil {
return ecode.Fail.Sub("获取奖励领取记录异常")
}
if value.IsEmpty() {
return ecode.Fail.Sub("获取奖励领取记录异常")
}
// 扣除数量
if _, err = dao.Rewards.Ctx(ctx).Where(do.Rewards{Id: value.Int()}).One(); err != nil {
return ecode.Fail.Sub("获取奖励记录异常")
}
return
} else if item.Result == 2 || item.Result == 3 {
// 发放背包成功,修改状态
} else if item.Result == 4 {
// 奖励领取失败,不做操作,直接返回
}
}
// 根据 result判断
if item.Result == 1 {
// 奖励发放成功,修改状态,扣除数量
_, err := dao.UserTaskRewards.Ctx(ctx).Where(do.UserTaskRewards{ExternalOrderId: item.Water.OrderId}).Update(consts.RewardSuccessStatus)
if err != nil {
return nil, ecode.Fail.Sub("修改奖励领取记录状态异常")
}
return
value, err := dao.UserTaskRewards.Ctx(ctx).Where(do.UserTaskRewards{ExternalOrderId: item.Water.OrderId}).Value(dao.UserTaskRewards.Columns().RewardId)
if err != nil {
return nil, ecode.Fail.Sub("获取奖励领取记录异常")
}
if value.IsEmpty() {
return nil, ecode.Fail.Sub("获取奖励领取记录异常")
}
// 扣除数量
_, err = dao.Rewards.Ctx(ctx).Where(do.Rewards{Id: value.Int()}).One()
if err != nil {
return nil, ecode.Fail.Sub("获取奖励记录异常")
}
} else if item.Result == 2 || item.Result == 3 {
// 发放背包成功,修改状态
} else if item.Result == 4 {
// 奖励领取失败,不做操作,直接返回
}
}); err != nil {
return
}
return nil, err
@ -513,6 +520,111 @@ func (s *sReward) OperateTaskReward(ctx context.Context, in *model.OperateTaskRe
// CallBack 奖励回调
func (s *sReward) CallBack(ctx context.Context, in *model.RewardCallbackIn) (out *model.RewardCallbackOut, err error) {
var reward *model.Reward
var res model.RewardCallbackOut
res.OrderId = in.OrderId
res.AppId = in.AppId
// 查询奖励
err = dao.Rewards.Ctx(ctx).Where(do.Rewards{PrizeId: in.PrizeId}).Scan(&reward)
if err != nil {
res.Errcode = -1
res.Errmsg = "查询奖励异常"
res.Datas = nil
return &res, ecode.Fail.Sub("查询奖励异常")
}
if reward == nil {
res.Errcode = -1
res.Errmsg = "查询奖励为空"
res.Datas = nil
return &res, ecode.Params.Sub("查询奖励为空")
}
// 判断是否过期
if reward.ExpireType == 1 {
//时间段过期
if reward.ValidTo.Before(gtime.Now()) {
res.Errcode = consts.BatchOutDate
res.Errmsg = consts.BatchOutDateMSG
}
}
// 日
now := time.Now()
// 当天开始时间
start := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
// 当天结束时间
end := time.Date(now.Year(), now.Month(), now.Day(), 23, 59, 59, 0, now.Location())
// 查先询用户当日已领取
dailyGetNum, err := dao.Rewards.Ctx(ctx).Where(dao.Rewards.Columns().PrizeId, in.PrizeId).InnerJoin(dao.UserTaskRewards.Table(), fmt.Sprintf("%s.id=%s.reward_id", dao.Rewards.Table(),
dao.UserTaskRewards.Table())).InnerJoin(dao.RewardWaters.Table(), fmt.Sprintf("%s.external_order_id = %s.order_id", dao.UserTaskRewards.Table(), dao.RewardWaters.Table())).
Where(dao.RewardWaters.Columns().Recvuid, in.Uid).Where(dao.UserTaskRewards.Columns().Status, 3).WhereOr(dao.UserTaskRewards.Columns().Status, 6).
WhereBetween(dao.UserTaskRewards.Columns().UpdatedAt, start, end).Fields(fmt.Sprintf("%s.*,%s.*", dao.Rewards.Table(), dao.UserTaskRewards.Table())).Count()
if err != nil {
res.Errcode = -1
res.Errmsg = "查询用户当日领取数量失败"
res.Datas = nil
return &res, ecode.Fail.Sub("查询用户当日领取数量失败")
}
// 判断是否达到用户日限制
if int(reward.UserDailyLimit) <= dailyGetNum {
res.Errcode = consts.UserDayLimit
res.Errmsg = consts.UserDayLimitMSG
}
// 查先询用户总共已领取
dailyTotalNum, err := dao.Rewards.Ctx(ctx).Where(dao.Rewards.Columns().PrizeId, in.PrizeId).InnerJoin(dao.UserTaskRewards.Table(), fmt.Sprintf("%s.id=%s.reward_id", dao.Rewards.Table(),
dao.UserTaskRewards.Table())).InnerJoin(dao.RewardWaters.Table(), fmt.Sprintf("%s.external_order_id = %s.order_id", dao.UserTaskRewards.Table(), dao.RewardWaters.Table())).
Where(dao.RewardWaters.Columns().Recvuid, in.Uid).Where(dao.UserTaskRewards.Columns().Status, 3).WhereOr(dao.UserTaskRewards.Columns().Status, 6).
Fields(fmt.Sprintf("%s.*,%s.*", dao.Rewards.Table(), dao.UserTaskRewards.Table())).Count()
if err != nil {
res.Errcode = -1
res.Errmsg = "查询用户当日总共领取数量失败"
res.Datas = nil
return &res, ecode.Fail.Sub("查询用户当日总共领取数量失败")
}
// 判断是否达到用户总限制
if int(reward.UserTotalLimit) <= dailyTotalNum {
res.Errcode = consts.UserTotalLimit
res.Errmsg = consts.UserTotalLimitMSG
}
// 查先询该批次当日已领取
batchDailyGetNum, err := dao.Rewards.Ctx(ctx).Where(dao.Rewards.Columns().PrizeId, in.PrizeId).InnerJoin(dao.UserTaskRewards.Table(), fmt.Sprintf("%s.id = %s.reward_id",
dao.Rewards.Table(), dao.UserTaskRewards.Table())).Where(dao.UserTaskRewards.Columns().Status, 3).WhereOr(dao.UserTaskRewards.Columns().Status, 6).
WhereBetween(dao.UserTaskRewards.Columns().UpdatedAt, start, end).Fields(fmt.Sprintf("%s.*,%s.*", dao.Rewards.Table(), dao.UserTaskRewards.Table())).Count()
if err != nil {
res.Errcode = -1
res.Errmsg = "查询该批次当日总共领取数量失败"
res.Datas = nil
return &res, ecode.Fail.Sub("查询该批次当日总共领取数量失败")
}
// 判断是否达到该批次日限制
if int(reward.DailyTotalLimit) <= batchDailyGetNum {
res.Errcode = consts.BatchDayLimit
res.Errmsg = consts.BatchDayLimitMSG
}
// 查先询该批次总共已领取
batchTotalGetNum, err := dao.Rewards.Ctx(ctx).Where(dao.Rewards.Columns().PrizeId, in.PrizeId).InnerJoin(dao.UserTaskRewards.Table(), fmt.Sprintf("%s.id = %s.reward_id",
dao.Rewards.Table(), dao.UserTaskRewards.Table())).Where(dao.UserTaskRewards.Columns().Status, 3).WhereOr(dao.UserTaskRewards.Columns().Status, 6).
Fields(fmt.Sprintf("%s.*,%s.*", dao.Rewards.Table(), dao.UserTaskRewards.Table())).Count()
if err != nil {
res.Errcode = -1
res.Errmsg = "查询该批次总共领取数量失败"
res.Datas = nil
return &res, ecode.Fail.Sub("查询该批次总共领取数量失败")
}
// 判断是否达到该批次总共限制
if int(reward.TotalLimit) <= batchTotalGetNum {
res.Errcode = consts.BatchTotalLimit
res.Errmsg = consts.BatchTotalLimitMSG
}
_, err = dao.RewardCallback.Ctx(ctx).OmitEmptyData().Insert(do.RewardCallback{
OrderId: in.OrderId,
@ -526,64 +638,34 @@ func (s *sReward) CallBack(ctx context.Context, in *model.RewardCallbackIn) (out
})
if err != nil {
return nil, ecode.Fail.Sub("存储奖励回调数据异常")
res.Errcode = -1
res.Errmsg = "存储奖励回调数据异常"
res.Datas = nil
return &res, ecode.Fail.Sub("存储奖励回调数据异常")
}
var reward *model.Reward
// 查询奖励,修改状态,扣除数量
err = dao.Rewards.Ctx(ctx).Where(do.Rewards{PrizeId: in.PrizeId}).Scan(&reward)
if err != nil {
return nil, ecode.Fail.Sub("查询奖励异常")
// 回调成功,组装响应参数
var userTaskReward []*model.UserTaskRewards
if err = dao.Rewards.Ctx(ctx).Where(dao.Rewards.Columns().PrizeId, in.PrizeId).InnerJoin(dao.UserTaskRewards.Table(), fmt.Sprintf("%s.%s = %s.%s",
dao.Rewards.Table(), dao.Rewards.Columns().Id, dao.UserTaskRewards.Table(), dao.UserTaskRewards.Columns().RewardId)).Scan(&userTaskReward); err != nil {
return nil, ecode.Fail.Sub("获取用户奖励记录异常")
}
if reward == nil {
return nil, ecode.Params.Sub("查询奖励为空")
if userTaskReward == nil {
res.Errcode = -1
res.Errmsg = "用户奖励记录为空"
res.Datas = nil
return &res, ecode.Fail.Sub("用户奖励记录为空")
}
// 判断是否过期
if reward.ExpireType == 1 {
//时间段过期
if reward.ValidTo.Before(gtime.Now()) {
out.Errcode = consts.BatchOutDate
out.Errmsg = consts.BatchOutDateMSG
}
callbackData := make([]model.CallbackData, 0)
for _, v := range userTaskReward {
callbackData = append(callbackData, model.CallbackData{
PrizeCode: v.InnerOrderId,
})
}
// 判断是否达到用户日限制
// 查先询用户当日已领取
var dailyGetNum int
dao.Users.Ctx(ctx).Where(do.Users{})
if int(reward.UserDailyLimit) <= dailyGetNum {
out.Errcode = consts.UserDayLimit
out.Errmsg = consts.UserDayLimitMSG
}
res.Datas = callbackData
// 判断是否达到用户总限制
// 查先询用户总共已领取
var dailyTotalNum int
if int(reward.UserTotalLimit) <= dailyTotalNum {
out.Errcode = consts.UserTotalLimit
out.Errmsg = consts.UserTotalLimitMSG
}
// 判断是否达到该批次日限制
// 查先询该批次当日已领取
var batchDailyGetNum int
if int(reward.DailyTotalLimit) <= batchDailyGetNum {
out.Errcode = consts.BatchDayLimit
out.Errmsg = consts.BatchDayLimitMSG
}
// 判断是否达到该批次总共限制
// 查先询该批次总共已领取
var batchTotalGetNum int
if int(reward.TotalLimit) <= batchTotalGetNum {
out.Errcode = consts.BatchTotalLimit
out.Errmsg = consts.BatchTotalLimitMSG
}
// 回调成功,
out.OrderId = in.OrderId
out.AppId = in.AppId
return out, err
return &res, err
}