1036 lines
29 KiB
Go
1036 lines
29 KiB
Go
package newcomer
|
||
|
||
import (
|
||
"context"
|
||
"reflect"
|
||
"sort"
|
||
"strings"
|
||
"time"
|
||
|
||
"fmt"
|
||
"go-common/app/interface/main/creative/model/newcomer"
|
||
accapi "go-common/app/service/main/account/api"
|
||
"go-common/library/ecode"
|
||
"go-common/library/log"
|
||
xtime "go-common/library/time"
|
||
)
|
||
|
||
const (
|
||
creatorMID int64 = 37090048 //创作中心哔哩哔哩号
|
||
msgPendantCode = "1_17_4"
|
||
msgPendantTitle = "恭喜你通关UP主任务-新手任务！"
|
||
msgPendantContent = "新手任务通关奖励“小试身手”头像挂件已发送至你的“个人中心-我的头像-我的挂件”中，快来查看和佩戴吧！更多任务奖励正在准备中，敬请期待哦~"
|
||
)
|
||
|
||
// UserTaskInfo def user task info
|
||
type UserTaskInfo struct {
|
||
Mid int64
|
||
UserTaskLevel int8
|
||
Follower int64
|
||
IsChange bool
|
||
}
|
||
|
||
// AppIndexNewcomer index newcomer
|
||
func (s *Service) AppIndexNewcomer(c context.Context, mid int64, plat string) (res *newcomer.AppIndexNewcomer, err error) {
|
||
if !s.c.TaskCondition.AppIndexSwitch {
|
||
return
|
||
}
|
||
var (
|
||
count int64
|
||
todoTasks []*newcomer.UserTask
|
||
)
|
||
res = &newcomer.AppIndexNewcomer{
|
||
H5URL: s.c.H5Page.Mission,
|
||
}
|
||
// check task bind
|
||
count, err = s.CheckUserTaskBind(c, mid)
|
||
if err != nil {
|
||
return
|
||
}
|
||
showTaskIDs := make([]int64, 0)
|
||
if count > 0 {
|
||
// already get tasks
|
||
res.TaskReceived = newcomer.BindTask
|
||
todoTasks, err = s.newc.UserTasksByMID(c, mid)
|
||
if err != nil {
|
||
log.Error("AppIndexNewcomer s.newc.UserTasks mid(%d)|error(%v)", mid, err)
|
||
return
|
||
}
|
||
// get at most 2 tasks
|
||
maxCnt := 0
|
||
for _, v := range todoTasks {
|
||
if maxCnt >= 2 {
|
||
break
|
||
}
|
||
showTaskIDs = append(showTaskIDs, v.TaskID)
|
||
maxCnt++
|
||
}
|
||
} else {
|
||
// not bind
|
||
res.TaskReceived = newcomer.NoBindTask
|
||
if len(s.TaskCache) < 2 {
|
||
return
|
||
}
|
||
for i := 0; i < 2; i++ {
|
||
t := s.TaskCache[i]
|
||
showTaskIDs = append(showTaskIDs, t.ID)
|
||
}
|
||
}
|
||
|
||
// fill app tasks struct
|
||
for _, v := range showTaskIDs {
|
||
if t, ok := s.TaskMapCache[v]; ok {
|
||
appt := &newcomer.AppTasks{
|
||
ID: t.ID,
|
||
Title: t.Title,
|
||
Type: t.Type,
|
||
}
|
||
// get redirect url
|
||
if _, ok := newcomer.TaskRedirectMap[plat]; ok {
|
||
if r, ook := newcomer.TaskRedirectMap[plat][t.TargetType]; ook {
|
||
appt.Label = r[0]
|
||
appt.Redirect = r[1]
|
||
}
|
||
}
|
||
res.AppTasks = append(res.AppTasks, appt)
|
||
}
|
||
}
|
||
if len(res.AppTasks) == 0 {
|
||
res = nil
|
||
}
|
||
return
|
||
}
|
||
|
||
// IndexNewcomer index newcomer
|
||
func (s *Service) IndexNewcomer(c context.Context, mid int64) (res *newcomer.IndexNewcomer, err error) {
|
||
res = &newcomer.IndexNewcomer{}
|
||
|
||
// check task bind
|
||
count, err := s.CheckUserTaskBind(c, mid)
|
||
if err != nil {
|
||
return
|
||
}
|
||
if count > 0 {
|
||
res.TaskReceived = newcomer.BindTask
|
||
} else {
|
||
res.TaskReceived = newcomer.NoBindTask
|
||
}
|
||
|
||
var (
|
||
upCount int // Number of submissions
|
||
viewCount int64 // Number of plays
|
||
)
|
||
// if archives == 0 && plays == 0 , means zero data
|
||
dt := time.Now().AddDate(0, 0, -1).Add(-12 * time.Hour).Format("20060102")
|
||
stat, err := s.data.UpStat(c, mid, dt)
|
||
if err != nil {
|
||
log.Error("IndexNewcomer s.data.UpStat mid(%d)|error(%v)", mid, err)
|
||
} else {
|
||
viewCount = stat.View
|
||
}
|
||
up, err := s.arc.UpCount(c, mid)
|
||
if err != nil {
|
||
log.Error("IndexNewcomer s.arc.UpCount mid(%d)|error(%v)", mid, err)
|
||
} else {
|
||
upCount = up
|
||
}
|
||
log.Info("IndexNewcomer mid(%d)|stat.view(%d)|upcount(%d)", mid, viewCount, upCount)
|
||
|
||
if upCount > 0 || viewCount > 0 {
|
||
log.Info("IndexNewcomer upCount>0||viewCount>0 mid(%d)|stat.view(%d)|upcount(%d)", mid, viewCount, upCount)
|
||
// check no receive reward
|
||
noReceiveCount := 0
|
||
noReceiveCount, CountErr := s.getNoReceiveRewardCount(c, mid)
|
||
if CountErr != nil {
|
||
log.Error("IndexNewcomer s.newc.noReceiveRewardCount mid(%d)|error(%v)", mid, err)
|
||
}
|
||
res.NoReceive = noReceiveCount
|
||
res.SubZero = false
|
||
} else {
|
||
res.SubZero = true
|
||
}
|
||
// add three task
|
||
tasks := make([]*newcomer.Task, 0)
|
||
if len(s.TaskCache) > 3 {
|
||
for i := 0; i < 3; i++ {
|
||
tasks = append(tasks, s.TaskCache[i])
|
||
}
|
||
res.Tasks = tasks
|
||
} else {
|
||
log.Error("IndexNewcomer s.newc len(s.TaskCache)<3 mid(%d)|error(%v)", mid, err)
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
// getNoReceiveRewardCount get no receive reward count
|
||
func (s *Service) getNoReceiveRewardCount(c context.Context, mid int64) (count int, err error) {
|
||
userTasks, err := s.newc.UserTasks(c, mid)
|
||
if err != nil {
|
||
log.Error("getNoReceiveRewardCount s.newc.UserTasks mid(%d)|error(%v)", mid, err)
|
||
return
|
||
}
|
||
tasks := s.getTasksInfoByType(userTasks, newcomer.DefualtTaskType)
|
||
if len(tasks) == 0 {
|
||
return
|
||
}
|
||
var (
|
||
taskGroupMap map[int64][]*newcomer.Task
|
||
taskTypeMap map[int8][]*newcomer.Task
|
||
availableCount int
|
||
receivedCount int
|
||
groupIDs []int64
|
||
giftIDs []int64
|
||
)
|
||
// group by groupID & taskType
|
||
taskGroupMap, taskTypeMap = s.groupByTasks(tasks)
|
||
groupIDs = make([]int64, 0, len(taskGroupMap))
|
||
for k, v := range taskGroupMap {
|
||
if _, ok := s.TaskGroupRewardMapCache[k]; ok {
|
||
if s.getTaskCompleteCount(v) == len(v) {
|
||
availableCount++
|
||
}
|
||
groupIDs = append(groupIDs, k)
|
||
}
|
||
}
|
||
giftIDs = make([]int64, 0, len(taskTypeMap))
|
||
for k, v := range taskTypeMap {
|
||
if _, ok := s.GiftRewardMapCache[k]; ok {
|
||
if s.getTaskCompleteCount(v) == len(v) {
|
||
availableCount++
|
||
}
|
||
giftIDs = append(giftIDs, int64(k))
|
||
}
|
||
}
|
||
r1, err := s.newc.BaseRewardCount(c, mid, groupIDs) // 基础奖励 已领取个数
|
||
if err != nil {
|
||
log.Error("getNoReceiveRewardCount s.newc.BaseRewardCount mid(%v)|error(%v)", mid, err)
|
||
return
|
||
}
|
||
r2, err := s.newc.GiftRewardCount(c, mid, giftIDs) // 礼包奖励 已领取个数
|
||
if err != nil {
|
||
log.Error("getNoReceiveRewardCount s.newc.GiftRewardCount mid(%v)|error(%v)", mid, err)
|
||
return
|
||
}
|
||
receivedCount = int(r1 + r2)
|
||
// 可领取未领取的奖励 = 可领取 - 已领取
|
||
count = availableCount - receivedCount
|
||
if count < 0 {
|
||
count = 0
|
||
}
|
||
log.Info("getNoReceiveRewardCount mid(%d)|availableCount(%d)|receivedCount(%d)|count(%d)", mid, availableCount, receivedCount, count)
|
||
return
|
||
}
|
||
|
||
// getUserTaskInfo determine the userTaskLevel
|
||
func (s *Service) getUserTaskInfo(c context.Context, mid int64, tasks []*newcomer.Task) (u *UserTaskInfo, err error) {
|
||
u = &UserTaskInfo{
|
||
Mid: mid,
|
||
UserTaskLevel: newcomer.UserTaskLevel01,
|
||
IsChange: false,
|
||
}
|
||
var (
|
||
count int // Number of unfinished novice tasks
|
||
follower int64
|
||
profileStat *accapi.ProfileStatReply
|
||
taskTypeMap map[int8][]*newcomer.Task
|
||
taskMap map[int64]*newcomer.Task
|
||
)
|
||
|
||
// whether the advanced task is hidden
|
||
if s.isHiddenTaskType(newcomer.AdvancedTaskType) {
|
||
u.UserTaskLevel = newcomer.UserTaskLevel01
|
||
return
|
||
}
|
||
|
||
taskMap = make(map[int64]*newcomer.Task)
|
||
taskTypeMap = make(map[int8][]*newcomer.Task)
|
||
for _, task := range tasks {
|
||
if task == nil {
|
||
continue
|
||
}
|
||
t, ok := s.TaskMapCache[task.ID]
|
||
if !ok {
|
||
continue
|
||
}
|
||
tp := *t
|
||
tp.CompleteSate = task.CompleteSate
|
||
taskTypeMap[tp.Type] = append(taskTypeMap[tp.Type], &tp)
|
||
taskMap[tp.ID] = &tp
|
||
}
|
||
|
||
// If the user already has an advanced task, return UserTaskLevel02
|
||
if _, ok := taskTypeMap[newcomer.AdvancedTaskType]; ok {
|
||
u.UserTaskLevel = newcomer.UserTaskLevel02
|
||
return
|
||
}
|
||
|
||
// Calculate whether the novice task is not fully completed (compare with cache)
|
||
newcomerTasks := s.getTasksByType(newcomer.NewcomerTaskType)
|
||
if len(newcomerTasks) == 0 {
|
||
return
|
||
}
|
||
count = len(newcomerTasks)
|
||
for _, t := range newcomerTasks {
|
||
if task, ok := taskMap[t.ID]; ok {
|
||
if task.CompleteSate == newcomer.TaskCompleted {
|
||
count--
|
||
}
|
||
}
|
||
}
|
||
// judge fans count
|
||
profileStat, profileErr := s.acc.ProfileWithStat(c, mid)
|
||
if profileStat == nil || profileErr != nil {
|
||
log.Error("genUserTaskInfo s.acc.ProfileWithStat mid(%d)|error(%v)", mid, err)
|
||
follower = 0
|
||
} else {
|
||
follower = profileStat.Follower
|
||
}
|
||
//Number of unfinished tasks || fans >=100
|
||
if count == 0 || follower >= s.c.TaskCondition.Fans {
|
||
// insert advancedTask
|
||
tasks = s.TaskTypeMapCache[newcomer.AdvancedTaskType]
|
||
if len(tasks) == 0 {
|
||
log.Warn("genUserTaskInfo no taskType==newcomer.AdvancedTaskType mid(%d)", mid)
|
||
return
|
||
}
|
||
args, placeStr := genBatchParamsBindTasks(tasks, mid)
|
||
_, err = s.newc.BindTasks(c, mid, placeStr, args)
|
||
if err != nil {
|
||
log.Error("genUserTaskInfo s.newc.BindTasks mid(%d)|error(%v)", mid, err)
|
||
return
|
||
}
|
||
u.UserTaskLevel = newcomer.UserTaskLevel02
|
||
u.IsChange = true // user level changed
|
||
s.putCheckTaskState(mid) // add to checkTaskQueue
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
//RewardReceive insert reward receive records.
|
||
func (s *Service) RewardReceive(c context.Context, mid int64, rid int64, ty int8, ip string) (res string, err error) {
|
||
var (
|
||
rewardIDs []int64
|
||
rewards []*newcomer.Reward
|
||
lockSuccess bool
|
||
)
|
||
|
||
// check completed
|
||
err = s.isRewardComplete(c, mid, rid, ty)
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
// prevent concurrent collection
|
||
key := s.getReceiveKey(rid, ty, mid)
|
||
if lockSuccess, err = s.newc.Lock(c, key, 1000); !lockSuccess || err != nil {
|
||
if err == nil {
|
||
log.Info("RewardReceive s.newc.Lock mid(%d)|rid(%d)|ty(%d)", mid, rid, ty)
|
||
res = s.c.TaskCondition.ReceiveMsg
|
||
return
|
||
}
|
||
log.Error("RewardReceive s.newc.Lock mid(%d)|rid(%d)|ty(%d)|error(%v)", mid, rid, ty, err)
|
||
}
|
||
|
||
// check received
|
||
err = s.isRewardReceived(c, mid, rid, ty)
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
// get rewards
|
||
if ty == newcomer.RewardGiftType {
|
||
rewardIDs, err = s.newc.GiftRewards(c, int8(rid))
|
||
if err != nil {
|
||
log.Error("RewardReceive s.newc.GiftRewards mid(%d)|rewardID(%d)|ty(%d)|err(%v)", mid, rid, ty, err)
|
||
return
|
||
}
|
||
} else {
|
||
rewardIDs, err = s.newc.TaskGroupRewards(c, rid)
|
||
if err != nil {
|
||
log.Error("RewardReceive s.newc.TaskGroupRewards mid(%d)|rewardID(%d)|ty(%d)|err(%v)", mid, rid, ty, err)
|
||
return
|
||
}
|
||
}
|
||
if len(rewardIDs) == 0 {
|
||
err = ecode.RequestErr
|
||
return
|
||
}
|
||
rewards = make([]*newcomer.Reward, 0)
|
||
for _, v := range rewardIDs {
|
||
if r, ok := s.RewardMapCache[v]; ok {
|
||
rewards = append(rewards, r)
|
||
}
|
||
}
|
||
// get user info
|
||
profile, err := s.acc.Profile(c, mid, ip)
|
||
if err != nil || profile == nil {
|
||
log.Error("RewardReceive s.acc.Profile mid(%d)|rewardID(%d)|ty(%d)|err(%v)", mid, rid, ty, err)
|
||
return
|
||
}
|
||
|
||
// receive rewards
|
||
rrs := make([]*newcomer.RewardReceive2, 0)
|
||
for _, v := range rewards {
|
||
r := &newcomer.RewardReceive2{}
|
||
r.MID = mid
|
||
r.OID = rid
|
||
r.Type = ty
|
||
r.RewardID = v.ID
|
||
r.RewardType = v.Type
|
||
if v.IsActive == newcomer.RewardNeedActivate {
|
||
r.State = newcomer.RewardCanActivate
|
||
} else {
|
||
err = s.callBusiness(c, profile, v)
|
||
if err != nil {
|
||
log.Error("RewardReceive s.callBusiness mid(%d)|reward(%+v)|error(%v)", mid, v, err)
|
||
r.State = newcomer.RewardCanActivate
|
||
} else {
|
||
r.State = newcomer.RewardActivatedNotClick
|
||
}
|
||
}
|
||
rrs = append(rrs, r)
|
||
}
|
||
_, err = s.newc.RewardReceive2(c, mid, rrs)
|
||
if err != nil {
|
||
log.Error("RewardReceive s.newc.RewardReceive mid(%d)|rewardID(%d)|ty(%d)|err(%v)", mid, rid, ty, err)
|
||
s.newc.UnLock(c, key)
|
||
return
|
||
}
|
||
res = s.c.TaskCondition.ReceiveMsg
|
||
log.Info("RewardReceive success mid(%d)|rewardID(%d)|ty(%d)", mid, rid, ty)
|
||
return
|
||
}
|
||
|
||
// Determine if the reward can be collected
|
||
func (s *Service) isRewardComplete(c context.Context, mid int64, rid int64, ty int8) error {
|
||
tids := make([]int64, 0)
|
||
tasks := make([]*newcomer.Task, 0)
|
||
if ty == newcomer.RewardBaseType {
|
||
tasks = s.getTasksByGroupID(rid)
|
||
} else if ty == newcomer.RewardGiftType {
|
||
tasks = s.getTasksByType(int8(rid))
|
||
}
|
||
for _, t := range tasks {
|
||
if t == nil {
|
||
continue
|
||
}
|
||
tids = append(tids, t.ID)
|
||
}
|
||
if len(tids) == 0 {
|
||
log.Error("isRewardComplete len(tids) == 0 | mid(%d)", mid)
|
||
return ecode.CreativeNewcomerNotCompleteErr
|
||
}
|
||
|
||
count, err := s.newc.RewardCompleteState(c, mid, tids)
|
||
if err != nil {
|
||
log.Error("isRewardComplete s.newc.RewardCompleteState mid(%d)|rewardID(%d)|ty(%d)|err(%v)", mid, rid, ty, err)
|
||
return err
|
||
}
|
||
if count != 0 {
|
||
err = ecode.CreativeNewcomerNotCompleteErr
|
||
log.Error("isRewardComplete mission not completed mid(%d)|rewardID(%d)|ty(%d)|err(%v)", mid, rid, ty, err)
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// Determine whether to receive it repeatedly
|
||
func (s *Service) isRewardReceived(c context.Context, mid int64, rid int64, ty int8) error {
|
||
isReceived, err := s.newc.IsRewardReceived(c, mid, rid, ty)
|
||
if err != nil {
|
||
log.Error("isRewardReceived s.newc.IsGiftReceived mid(%d)|rewardID(%d)|ty(%d)|err(%v)", mid, rid, ty, err)
|
||
return err
|
||
}
|
||
if isReceived {
|
||
err = ecode.CreativeNewcomerRepeatRewardErr
|
||
log.Error("isRewardReceived receive multiple times mid(%d)|rewardID(%d)|ty(%d)|err(%v)", mid, rid, ty, err)
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// Calling the business side interface
|
||
func (s *Service) callBusiness(c context.Context, profile *accapi.Profile, v *newcomer.Reward) (err error) {
|
||
switch v.Type {
|
||
case newcomer.Bcoin: //B币券
|
||
err = s.newc.BCoin(c, profile.Mid, v.PriceID, int64(v.PrizeUnit))
|
||
case newcomer.MemberBuy: //会员购
|
||
err = s.newc.Mall(c, profile.Mid, v.PriceID, profile.Name)
|
||
case newcomer.IncentivePlan: //激励计划
|
||
err = s.SendRewardReceiveLog(c, profile.Mid)
|
||
case newcomer.BigMember: //大会员服务
|
||
err = s.newc.BigMemberCoupon(c, profile.Mid, v.PriceID)
|
||
case newcomer.PersonalCenter: //个人中心
|
||
err = s.newc.Pendant(c, profile.Mid, v.PriceID, int64(v.Expire))
|
||
if err != nil {
|
||
return
|
||
}
|
||
//发送消息通知
|
||
if e := s.newc.SendNotify(c, []int64{profile.Mid}, msgPendantCode, msgPendantTitle, msgPendantContent); e != nil {
|
||
log.Error("callBusiness s.newc.SendNotify mid(%d)|err(%v)", profile.Mid, err)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
//RewardActivate insert reward receive records.
|
||
func (s *Service) RewardActivate(c context.Context, mid, id int64, ip string) (res int64, err error) {
|
||
r, err := s.newc.RewardReceiveByID(c, mid, id)
|
||
if err != nil {
|
||
log.Error("RewardActivate s.newc.RewardIDByReceiveID mid(%d)|receiveID(%d)|err(%v)", mid, id, err)
|
||
return
|
||
}
|
||
// check repeat collection
|
||
if r.State != newcomer.RewardCanActivate {
|
||
err = ecode.CreativeNewcomerRepeatRewardErr
|
||
log.Error("RewardActivate check repeat collection mid(%d)|receiveID(%d)|state(%d)|err(%v)", mid, id, r.State, err)
|
||
return
|
||
}
|
||
|
||
// check expire
|
||
reward, ok := s.RewardMapCache[r.RewardID]
|
||
if !ok || reward == nil {
|
||
err = ecode.RequestErr
|
||
log.Error("RewardActivate check expire mid(%d)|receiveID(%d)|rewardID(%d)|err(%v)", mid, id, r.RewardID, err)
|
||
return
|
||
}
|
||
var expireTime int64
|
||
if r.RewardType == newcomer.Bcoin { //奖品到期时间
|
||
expireTime = reward.CTime.Time().Unix() + int64(reward.Expire*24*3600) //B币券显示截止时间
|
||
} else {
|
||
expireTime = r.ReceiveTime.Time().Unix() + int64(reward.Expire*24*3600)
|
||
}
|
||
if (time.Now().Unix() - expireTime) > 0 {
|
||
err = ecode.CreativeNewcomerReceiveExpireErr
|
||
log.Error("RewardActivate check expire mid(%d)|receiveID(%d)|rewardID(%d)|err(%v)", mid, id, r.RewardID, err)
|
||
return
|
||
}
|
||
|
||
// get new receive record
|
||
nr, err := s.newc.RewardReceiveByOldInfo(c, r)
|
||
if err != nil || nr == nil {
|
||
log.Error("RewardActivate s.newc.RewardReceiveByOldInfo mid(%d)|receive(%+v)|error(%v)", mid, r, err)
|
||
return
|
||
}
|
||
|
||
// prevent concurrent collection
|
||
var lockSuccess bool
|
||
key := s.getActivateKey(mid, id)
|
||
if lockSuccess, err = s.newc.Lock(c, key, 1000); !lockSuccess || err != nil {
|
||
if err == nil {
|
||
log.Info("RewardActivate s.newc.Lock mid(%d)|id(%d)", mid, id)
|
||
res = 0
|
||
return
|
||
}
|
||
log.Error("RewardActivate s.newc.Lock mid(%d)|id(%d)|error(%v)", mid, id, err)
|
||
}
|
||
|
||
profile, err := s.acc.Profile(c, mid, ip)
|
||
if err != nil || profile == nil {
|
||
log.Error("RewardActivate s.acc.Profile mid(%d)|receiveID(%d)|rewardID(%d)|err(%v)", mid, id, r.RewardID, err)
|
||
return
|
||
}
|
||
if err = s.callBusiness(c, profile, reward); err != nil {
|
||
log.Error("RewardActivate callBusiness mid(%d)|receiveID(%d)|rewardID(%d)|err(%v)", mid, id, r.RewardID, err)
|
||
return
|
||
}
|
||
|
||
res, err = s.newc.RewardActivate2(c, mid, id, nr.ID)
|
||
if err != nil {
|
||
log.Error("s.newc.RewardActivate mid(%d)|id(%d)|err(%v)", mid, id, err)
|
||
s.newc.UnLock(c, key)
|
||
return
|
||
}
|
||
log.Info("RewardActivate success mid(%d)|receiveID(%d)", mid, id)
|
||
return
|
||
}
|
||
|
||
//RewardReceives get reward receive records.
|
||
func (s *Service) RewardReceives(c context.Context, mid int64) (res []*newcomer.RewardReceiveGroup, err error) {
|
||
var items map[int8][]*newcomer.RewardReceive
|
||
items, err = s.newc.RewardReceives(c, mid)
|
||
if err != nil {
|
||
log.Error("s.newc.RewardReceives mid(%d)|err(%v)", mid, err)
|
||
return
|
||
}
|
||
if len(items) == 0 {
|
||
log.Error("s.newc.RewardReceives len(items) == 0")
|
||
return
|
||
}
|
||
|
||
keys := reflect.ValueOf(items).MapKeys()
|
||
pids := make([]int64, 0, len(keys)) //存储当前奖励 类型对应的 分类id
|
||
for _, v := range keys {
|
||
if k, ok := v.Interface().(int8); ok {
|
||
if pid, ook := s.RewardTyPIDMapCache[k]; ook {
|
||
pids = append(pids, pid)
|
||
}
|
||
}
|
||
}
|
||
sort.Slice(pids, func(i, j int) bool { //按奖励 类型对应id升序
|
||
return pids[i] < pids[j]
|
||
})
|
||
rkTypes := make([]int8, 0, len(keys)) //存储按照 奖励分类添加顺序排列的 奖励类型
|
||
for _, pid := range pids {
|
||
if ty, ok := s.RewardPIDTyMapCache[pid]; ok {
|
||
rkTypes = append(rkTypes, ty)
|
||
}
|
||
}
|
||
|
||
log.Info("RewardReceives mid(%d)|pids(%+v)|rkTypes(%+v)", mid, pids, rkTypes)
|
||
|
||
res = make([]*newcomer.RewardReceiveGroup, 0)
|
||
for _, k := range rkTypes {
|
||
|
||
item, ok := items[k]
|
||
if !ok || len(item) == 0 {
|
||
log.Error("RewardReceives items[k] k(%v) item(%+v) ok(%v)", k, item, ok)
|
||
return
|
||
}
|
||
|
||
pid, ok := s.RewardTyPIDMapCache[k]
|
||
if !ok || pid == 0 {
|
||
log.Error("RewardReceives s.RewardTyPIDMapCache[k] pid(%v) ok(%v)", pid, ok)
|
||
return
|
||
}
|
||
|
||
pr, ok := s.RewardMapCache[pid]
|
||
if !ok || pr == nil { //获取奖励类别名称和logo
|
||
log.Error("RewardReceives s.RewardMapCache[pid] pid(%d) pr(%+v) ok3(%v)", pid, pr, ok)
|
||
return
|
||
}
|
||
|
||
s0 := make([]*newcomer.RewardReceive, 0, len(item))
|
||
s1 := make([]*newcomer.RewardReceive, 0, len(item))
|
||
s2 := make([]*newcomer.RewardReceive, 0, len(item))
|
||
for _, v := range item {
|
||
r, ok := s.RewardMapCache[v.RewardID]
|
||
if !ok || r == nil {
|
||
log.Error("RewardReceives s.RewardMapCache[v.RewardID] v.RewardID(%v) r(%+v) ok(%v)", v.RewardID, r, ok)
|
||
return
|
||
}
|
||
|
||
v.RewardName = r.Name //获取奖品名称
|
||
var expireTime int64
|
||
if v.RewardType == newcomer.Bcoin { //奖品到期时间
|
||
expireTime = r.CTime.Time().Unix() + int64(r.Expire*24*3600)
|
||
v.ExpireTime = xtime.Time(expireTime) //B币券显示截止时间
|
||
} else {
|
||
expireTime = v.ReceiveTime.Time().Unix() + int64(r.Expire*24*3600)
|
||
v.ExpireTime = xtime.Time(expireTime)
|
||
}
|
||
// set RewardExpireNotClick state
|
||
if (time.Now().Unix() - expireTime) > 0 {
|
||
v.State = newcomer.RewardExpireNotClick
|
||
}
|
||
|
||
switch v.State { //按照0-可激活 >1-已激活不可点击>2-已过期不可点击 优先级展示
|
||
case newcomer.RewardCanActivate:
|
||
s0 = append(s0, v)
|
||
case newcomer.RewardActivatedNotClick:
|
||
s1 = append(s1, v)
|
||
case newcomer.RewardExpireNotClick:
|
||
s2 = append(s2, v)
|
||
}
|
||
}
|
||
|
||
r := &newcomer.RewardReceiveGroup{
|
||
Count: len(item),
|
||
RewardType: pr.Type,
|
||
RewardTypeName: pr.Name,
|
||
RewardTypeLogo: pr.Logo,
|
||
Comment: pr.Comment,
|
||
Items: append(append(s0, s1...), s2...),
|
||
}
|
||
res = append(res, r)
|
||
}
|
||
return
|
||
}
|
||
|
||
// TaskBind user bind tasks
|
||
func (s *Service) TaskBind(c context.Context, mid int64) (res int64, err error) {
|
||
count, err := s.CheckUserTaskBind(c, mid)
|
||
if err != nil {
|
||
return
|
||
}
|
||
if count > 0 {
|
||
err = ecode.CreativeNewcomerReBindTaskErr
|
||
return
|
||
}
|
||
|
||
// Determining the number of fans owned by users
|
||
profileStat, err := s.acc.ProfileWithStat(c, mid)
|
||
if err != nil {
|
||
log.Error("TaskBind s.acc.ProfileWithStat mid(%d)|error(%v)", mid, err)
|
||
return
|
||
}
|
||
log.Info("TaskBind s.acc.ProfileWithStat mid(%d)|follower(%d)", mid, profileStat.Follower)
|
||
var tasks []*newcomer.Task
|
||
if profileStat.Follower >= s.c.TaskCondition.Fans {
|
||
tasks = s.TaskTypeMapCache[newcomer.DefualtTaskType]
|
||
} else {
|
||
tasks = s.TaskTypeMapCache[newcomer.NewcomerTaskType]
|
||
}
|
||
|
||
args, placeStr := genBatchParamsBindTasks(tasks, mid)
|
||
res, err = s.newc.BindTasks(c, mid, placeStr, args)
|
||
if err != nil {
|
||
log.Error("TaskBind s.newc.BindTasks mid(%v)|error(%v)", mid, err)
|
||
return
|
||
}
|
||
|
||
// sync check task status
|
||
s.syncCheckTaskStatus(c, mid, tasks)
|
||
return
|
||
}
|
||
|
||
// genBatchParamsBindTasks generate batch insert parameters
|
||
func genBatchParamsBindTasks(tasks []*newcomer.Task, mid int64) ([]interface{}, string) {
|
||
place := make([]string, 0)
|
||
args := make([]interface{}, 0)
|
||
for _, v := range tasks {
|
||
place = append(place, "(?, ?, ?, ?, ?)")
|
||
args = append(args, mid, v.ID, v.GroupID, v.Type, -1)
|
||
}
|
||
placeStr := strings.Join(place, ",")
|
||
return args, placeStr
|
||
}
|
||
|
||
//CheckUserTaskBind determine if the user has bound the task
|
||
func (s *Service) CheckUserTaskBind(c context.Context, mid int64) (count int64, err error) {
|
||
count, err = s.newc.UserTaskBind(c, mid)
|
||
if err != nil {
|
||
log.Error("CheckUserTaskBind s.newc.UserTaskBind mid(%v)|error(%v)", mid, err)
|
||
return
|
||
}
|
||
return
|
||
}
|
||
|
||
//TaskMakeup fix unfinish task state
|
||
func (s *Service) TaskMakeup(c context.Context, mid int64) (err error) {
|
||
tasks, err := s.newc.UserTasks(c, mid)
|
||
if err != nil {
|
||
log.Error("TaskMakeup s.newc.UserTasks mid(%d)|error(%v)", mid, err)
|
||
err = ecode.RequestErr
|
||
return
|
||
}
|
||
infoTasks := s.getTasksInfoByType(tasks, newcomer.DefualtTaskType)
|
||
ts := make([]*newcomer.Task, 0)
|
||
for _, v := range infoTasks {
|
||
if v == nil {
|
||
continue
|
||
}
|
||
if v.CompleteSate == newcomer.TaskIncomplete {
|
||
ts = append(ts, v)
|
||
}
|
||
}
|
||
s.syncCheckTaskStatus(c, mid, ts)
|
||
return
|
||
}
|
||
|
||
//TaskPubList to apply task list
|
||
func (s *Service) TaskPubList(c context.Context, mid int64) (res *newcomer.PubTaskList, err error) {
|
||
res = &newcomer.PubTaskList{}
|
||
tasks, err := s.newc.UserTasks(c, mid)
|
||
if err != nil {
|
||
log.Error("PubTaskList s.newc.UserTasks mid(%d)|error(%v)", mid, err)
|
||
return
|
||
}
|
||
if len(tasks) == 0 {
|
||
log.Warn("PubTaskList No binding task | mid(%d)", mid)
|
||
res.TaskReceived = newcomer.NoBindTask
|
||
return
|
||
}
|
||
res.TaskReceived = newcomer.BindTask
|
||
ts := s.getTasksInfoByType(tasks, newcomer.DefualtTaskType)
|
||
if len(ts) == 0 {
|
||
log.Error("PubTaskList no task | mid(%d)", mid)
|
||
return
|
||
}
|
||
for _, task := range ts {
|
||
if task == nil {
|
||
continue
|
||
}
|
||
tt := &newcomer.PubTask{
|
||
ID: task.ID,
|
||
Title: task.Title,
|
||
Desc: task.Desc,
|
||
Type: task.Type,
|
||
State: task.CompleteSate,
|
||
}
|
||
res.Tasks = append(res.Tasks, tt)
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
// TaskList for task detail
|
||
func (s *Service) TaskList(c context.Context, mid int64, ty int8) (res *newcomer.TaskRewardList, err error) {
|
||
var (
|
||
u *UserTaskInfo
|
||
tasks []*newcomer.Task
|
||
taskTypeMap = make(map[int8][]*newcomer.Task)
|
||
taskGroupMap = make(map[int64][]*newcomer.Task)
|
||
)
|
||
|
||
// get user tasks
|
||
userTasks, err := s.newc.UserTasks(c, mid)
|
||
if err != nil {
|
||
log.Error("TaskList s.newc.UserTasks mid(%d)|error(%v)", mid, err)
|
||
return
|
||
}
|
||
if len(userTasks) == 0 {
|
||
// return ：User did not receive the task
|
||
res = &newcomer.TaskRewardList{
|
||
TaskReceived: newcomer.NoBindTask,
|
||
TaskType: ty,
|
||
}
|
||
log.Warn("TaskList user did not receive the task mid(%d)", mid)
|
||
return
|
||
}
|
||
|
||
// get user info
|
||
u, err = s.getUserTaskInfo(c, mid, userTasks)
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
// Judging according to the "user logic level", showing the task type
|
||
if ty == newcomer.DefualtTaskType {
|
||
ty = u.UserTaskLevel
|
||
} else if ty == newcomer.AdvancedTaskType {
|
||
if ty > u.UserTaskLevel {
|
||
log.Warn("TaskList user unlocked this task mid(%d)", mid)
|
||
// return ：User has not unlocked this type of task
|
||
res = &newcomer.TaskRewardList{
|
||
TaskReceived: newcomer.BindTask,
|
||
TaskType: ty,
|
||
}
|
||
return
|
||
}
|
||
}
|
||
|
||
// get tasks
|
||
tasks = s.getTasksInfoByType(userTasks, newcomer.DefualtTaskType)
|
||
if len(tasks) == 0 {
|
||
err = ecode.CreativeNewcomerNoTask
|
||
log.Error("TaskList s.GetTaskByType len(tasks) == 0")
|
||
return
|
||
}
|
||
|
||
// group by groupID & taskType
|
||
for _, t := range tasks {
|
||
if t == nil {
|
||
continue
|
||
}
|
||
if t.Type == ty {
|
||
taskGroupMap[t.GroupID] = append(taskGroupMap[t.GroupID], t)
|
||
}
|
||
taskTypeMap[t.Type] = append(taskTypeMap[t.Type], t)
|
||
}
|
||
|
||
// task_kind
|
||
taskKinds := s.getTaskKindsData(u, taskTypeMap)
|
||
|
||
// task_gift
|
||
taskGift, err := s.getTaskGiftData(c, mid, taskTypeMap, newcomer.FromWeb)
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
// task_groups
|
||
tgs, err := s.getTaskGroupData(c, mid, taskGroupMap)
|
||
if err != nil {
|
||
return
|
||
}
|
||
|
||
res = &newcomer.TaskRewardList{
|
||
TaskReceived: newcomer.BindTask,
|
||
TaskType: ty,
|
||
TaskKinds: taskKinds,
|
||
TaskGroups: tgs,
|
||
TaskGift: taskGift,
|
||
}
|
||
return
|
||
}
|
||
|
||
// getTaskGroupData for get task_group data
|
||
func (s *Service) getTaskGroupData(c context.Context, mid int64, taskMap map[int64][]*newcomer.Task) (tgs []*newcomer.TaskRewardGroup, err error) {
|
||
if len(taskMap) == 0 {
|
||
return
|
||
}
|
||
tgs = make([]*newcomer.TaskRewardGroup, 0, len(taskMap))
|
||
ranks := make([]int64, 0, len(taskMap))
|
||
groups := make([]int64, 0, len(taskMap))
|
||
rankGroupMap := make(map[int64]int64)
|
||
// sort by groupID
|
||
for key := range taskMap {
|
||
taskGroup, ok := s.TaskGroupMapCache[key]
|
||
if !ok {
|
||
continue
|
||
}
|
||
ranks = append(ranks, taskGroup.Rank)
|
||
groups = append(groups, key)
|
||
rankGroupMap[taskGroup.Rank] = key
|
||
}
|
||
sort.Slice(ranks, func(i, j int) bool {
|
||
return ranks[i] < ranks[j]
|
||
})
|
||
|
||
// get TaskRewardGroup
|
||
for _, k := range ranks {
|
||
taskGroup, ok := taskMap[rankGroupMap[k]]
|
||
if !ok || len(taskGroup) == 0 {
|
||
log.Error("genTaskGroupData taskGroup not exist ID(%d)", rankGroupMap[k])
|
||
continue
|
||
}
|
||
rewardState := newcomer.RewardNotAvailable //奖励领取状态
|
||
total := len(taskGroup) // 任务组总数
|
||
complete := s.getTaskCompleteCount(taskGroup) // 完成的任务数量
|
||
if complete == total {
|
||
rewardState = newcomer.RewardAvailable
|
||
}
|
||
rewards := s.getRewardsByGroupID(rankGroupMap[k]) // 任务组对应的奖励
|
||
|
||
tg := &newcomer.TaskRewardGroup{
|
||
TaskType: taskGroup[0].Type,
|
||
Tasks: taskGroup,
|
||
Rewards: rewards,
|
||
GroupID: rankGroupMap[k],
|
||
RewardState: int8(rewardState),
|
||
Completed: int64(complete),
|
||
Total: int64(total),
|
||
}
|
||
tgs = append(tgs, tg)
|
||
}
|
||
|
||
// determine if the reward is received
|
||
rewardRecvGroup, err := s.newc.RewardReceivedGroup(c, mid, groups)
|
||
if err != nil {
|
||
log.Error("genTaskGroupData s.newc.RewardReceivedGroup mid(%d)|error(%v)", mid, err)
|
||
return
|
||
}
|
||
for _, v := range tgs {
|
||
for _, j := range rewardRecvGroup {
|
||
if v.GroupID == int64(j) {
|
||
v.RewardState = newcomer.RewardReceived
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// getTaskGiftData for get task_gift data
|
||
func (s *Service) getTaskGiftData(c context.Context, mid int64, taskTypeMap map[int8][]*newcomer.Task, from int8) (taskGift []*newcomer.TaskGift, err error) {
|
||
if len(taskTypeMap) == 0 {
|
||
return
|
||
}
|
||
taskGift = make([]*newcomer.TaskGift, 0, len(taskTypeMap))
|
||
// get gifts by taskType
|
||
gifts := make(map[int8][]*newcomer.Reward)
|
||
for k := range taskTypeMap {
|
||
gifts[k] = s.getRewardsByTaskType(k)
|
||
}
|
||
|
||
for tType, giftRewards := range gifts {
|
||
giftState := newcomer.RewardAvailable
|
||
complete := s.getTaskCompleteCount(taskTypeMap[tType])
|
||
total := len(taskTypeMap[tType])
|
||
if complete != total {
|
||
if from == newcomer.FromWeb {
|
||
giftState = newcomer.RewardNotAvailable
|
||
} else if from == newcomer.FromH5 {
|
||
giftState = newcomer.RewardUnlock
|
||
}
|
||
}
|
||
|
||
// judge the gift is received
|
||
isGiftReceived, err := s.newc.IsRewardReceived(c, mid, int64(tType), newcomer.RewardGiftType)
|
||
if err != nil {
|
||
log.Error("genTaskGiftData s.newc.IsGiftReceived mid(%d)|error(%v)", mid, err)
|
||
continue
|
||
}
|
||
if isGiftReceived {
|
||
giftState = newcomer.RewardReceived
|
||
}
|
||
|
||
tg := &newcomer.TaskGift{
|
||
State: int8(giftState),
|
||
Type: tType,
|
||
Rewards: giftRewards,
|
||
}
|
||
taskGift = append(taskGift, tg)
|
||
}
|
||
return
|
||
}
|
||
|
||
// getTaskKindsData for get task_kinds data
|
||
func (s *Service) getTaskKindsData(u *UserTaskInfo, taskTypeMap map[int8][]*newcomer.Task) (taskKinds []*newcomer.TaskKind) {
|
||
taskKinds = make([]*newcomer.TaskKind, 0, len(taskTypeMap))
|
||
for tType, tasks := range taskTypeMap {
|
||
complete := s.getTaskCompleteCount(tasks) // 完成数量
|
||
total := len(tasks) // 总数
|
||
state := newcomer.RewardNotAvailable // 完成状态
|
||
if complete == len(tasks) {
|
||
state = newcomer.RewardAvailable
|
||
}
|
||
kind := &newcomer.TaskKind{
|
||
Type: tType,
|
||
Completed: int64(complete),
|
||
Total: int64(total),
|
||
State: int8(state),
|
||
}
|
||
// determine the unlock type by user_task level
|
||
switch tType {
|
||
case newcomer.NewcomerTaskType:
|
||
taskKinds = append(taskKinds, kind)
|
||
case newcomer.AdvancedTaskType:
|
||
if u.UserTaskLevel == newcomer.UserTaskLevel01 {
|
||
kind.State = newcomer.RewardUnlock
|
||
}
|
||
taskKinds = append(taskKinds, kind)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// getTaskCompleteCount get tasks complete count
|
||
func (s *Service) getTaskCompleteCount(task []*newcomer.Task) int {
|
||
complete := 0
|
||
for _, t := range task {
|
||
if t == nil {
|
||
continue
|
||
}
|
||
if t.CompleteSate == newcomer.TaskCompleted {
|
||
complete++
|
||
}
|
||
}
|
||
return complete
|
||
}
|
||
|
||
// groupByTasks group by groupID & taskType
|
||
func (s *Service) groupByTasks(tasks []*newcomer.Task) (taskGroupMap map[int64][]*newcomer.Task, taskTypeMap map[int8][]*newcomer.Task) {
|
||
taskGroupMap = make(map[int64][]*newcomer.Task)
|
||
taskTypeMap = make(map[int8][]*newcomer.Task)
|
||
for _, t := range tasks {
|
||
if t == nil {
|
||
continue
|
||
}
|
||
taskGroupMap[t.GroupID] = append(taskGroupMap[t.GroupID], t)
|
||
taskTypeMap[t.Type] = append(taskTypeMap[t.Type], t)
|
||
}
|
||
return
|
||
}
|
||
|
||
// getReceiveKey get receive redis key
|
||
func (s *Service) getReceiveKey(oid int64, ty int8, mid int64) string {
|
||
return fmt.Sprintf("%d_%d_%d", oid, ty, mid)
|
||
}
|
||
|
||
// getActivateKey get active key
|
||
func (s *Service) getActivateKey(mid int64, id int64) string {
|
||
return fmt.Sprintf("%d_%d", mid, id)
|
||
}
|