449 lines
11 KiB
Go
449 lines
11 KiB
Go
package service
|
||
|
||
import (
|
||
"bytes"
|
||
"context"
|
||
"fmt"
|
||
"sort"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"go-common/app/job/main/growup/model"
|
||
|
||
"go-common/library/log"
|
||
xtime "go-common/library/time"
|
||
"go-common/library/xstr"
|
||
)
|
||
|
||
const (
|
||
_like = "1"
|
||
_share = "2"
|
||
_play = "3"
|
||
_reply = "4"
|
||
_dm = "5"
|
||
)
|
||
|
||
// CreativeActivity creative activity job
|
||
func (s *Service) CreativeActivity(c context.Context, date time.Time) (err error) {
|
||
activities, err := s.dao.GetCActivities(c)
|
||
if err != nil {
|
||
log.Error("s.dao.GetCActivities error(%v)", err)
|
||
return
|
||
}
|
||
// get signed up
|
||
ups, err := s.signed(c, int64(_dbLimit))
|
||
if err != nil {
|
||
log.Error("s.signed error(%v)", err)
|
||
return
|
||
}
|
||
now := xtime.Time(date.Unix())
|
||
// calculate activity within the statistical period
|
||
for _, ac := range activities {
|
||
if now >= ac.StatisticsStart && now <= ac.StatisticsEnd {
|
||
log.Info("calculate ac: %d", ac.ID)
|
||
err = s.handleActivity(c, ac, ups, date)
|
||
if err != nil {
|
||
log.Error("s.handleActivity error(%v)", err)
|
||
return
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *Service) handleActivity(c context.Context, ac *model.CActivity, upInfo map[int64]*model.UpInfoVideo, date time.Time) (err error) {
|
||
// 获取已报名并且在签约时间内的up主，
|
||
signedUps, err := s.getSignedUps(c, ac, upInfo)
|
||
if err != nil {
|
||
log.Error("s.getSignedUps error(%v)", err)
|
||
return
|
||
}
|
||
// 获取活动稿件点赞、分享、播放、评论、弹幕
|
||
archiveInfo, err := s.getArchiveInfo(c, ac.ID)
|
||
if err != nil {
|
||
log.Error("s.getArchiveInfo error(%v)", err)
|
||
return
|
||
}
|
||
if len(archiveInfo) == 0 {
|
||
log.Info("activity(%d) get 0 archiveInfo", ac.ID)
|
||
return
|
||
}
|
||
log.Info("get %d archiveInfo", len(archiveInfo))
|
||
fmt.Printf("get %d archiveInfo\n", len(archiveInfo))
|
||
// 获取在投稿时间内的稿件
|
||
avs, err := s.getAvsUpload(c, signedUps)
|
||
if err != nil {
|
||
log.Error("s.getAvsByMID error(%v)", err)
|
||
return
|
||
}
|
||
if len(avs) == 0 {
|
||
log.Info("activity(%d) get 0 av", ac.ID)
|
||
return
|
||
}
|
||
log.Info("get %d archives", len(avs))
|
||
fmt.Printf("get %d archives\n", len(avs))
|
||
|
||
// 筛选在签约时间内的稿件
|
||
handleActivityAvs(signedUps, avs, ac)
|
||
for _, u := range signedUps {
|
||
// 获取up主对应稿件要求的和
|
||
err = s.getUpStatisData(c, u, ac, date, archiveInfo)
|
||
if err != nil {
|
||
log.Error("s.getUpData error(%v)", err)
|
||
return
|
||
}
|
||
}
|
||
// 计算中奖up主
|
||
upBonus, err := s.calUpWin(c, signedUps, ac)
|
||
if err != nil {
|
||
log.Error("s.calUpBonus error(%v)", err)
|
||
return
|
||
}
|
||
|
||
err = s.updateUpActivity(c, ac.ID, upBonus)
|
||
if err != nil {
|
||
log.Error("s.updateUpActivity error(%v)", err)
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *Service) calUpWin(c context.Context, ups map[int64]*model.UpActivity, ac *model.CActivity) (bonusUp []*model.UpActivity, err error) {
|
||
activityBonus, err := s.dao.GetActivityBonus(c, ac.ID)
|
||
if err != nil {
|
||
log.Error("s.dao.GetActivityBonus error(%v)", err)
|
||
return
|
||
}
|
||
bonusUp = make([]*model.UpActivity, 0)
|
||
var (
|
||
upList = make([]*model.UpActivity, len(ups))
|
||
index int
|
||
)
|
||
for _, up := range ups {
|
||
upList[index] = up
|
||
index++
|
||
}
|
||
sort.Slice(upList, func(i, j int) bool {
|
||
return upList[i].ItemVal > upList[j].ItemVal
|
||
})
|
||
|
||
// 1:达标型 2:排序型
|
||
if ac.WinType == 1 {
|
||
for _, up := range upList {
|
||
// uplist经过ItemVal,所以如果有ItemVal<RequireValue,可以直接break
|
||
if up.ItemVal < ac.RequireValue {
|
||
break
|
||
}
|
||
bonusUp = append(bonusUp, up)
|
||
}
|
||
} else if ac.WinType == 2 {
|
||
// 去掉item为0的up
|
||
for i := 0; i < len(upList); i++ {
|
||
if upList[i].ItemVal == 0 {
|
||
upList = upList[:i]
|
||
break
|
||
}
|
||
}
|
||
if len(upList) > int(ac.RequireValue) {
|
||
upList = upList[:int(ac.RequireValue)]
|
||
}
|
||
bonusUp = upList
|
||
}
|
||
if len(bonusUp) == 0 {
|
||
return
|
||
}
|
||
// 计算up主奖金
|
||
calUpBonus(bonusUp, activityBonus, ac.BonusType, ac.WinType)
|
||
return
|
||
}
|
||
|
||
// cal ups bonus
|
||
func calUpBonus(bonusUp []*model.UpActivity, activityBonus map[int64]int64, bonusType, winType int) (err error) {
|
||
// 中奖类型 1:达标型 2:排序型
|
||
// 奖金类型 1:平分 2:各得
|
||
if winType == 1 {
|
||
money, ok := activityBonus[0]
|
||
if !ok {
|
||
err = fmt.Errorf("活动奖金设置错误:达标型未设置金额")
|
||
return
|
||
}
|
||
if bonusType == 1 {
|
||
money = money / int64(len(bonusUp))
|
||
}
|
||
for _, up := range bonusUp {
|
||
up.Bonus = money
|
||
up.Rank = 0
|
||
if up.State < 2 {
|
||
// 中奖
|
||
up.State = 2
|
||
up.SuccessTime = xtime.Time(time.Now().Unix())
|
||
}
|
||
}
|
||
} else if winType == 2 {
|
||
other := len(activityBonus)
|
||
otherMoney, ok := activityBonus[int64(other)]
|
||
if !ok {
|
||
err = fmt.Errorf("活动奖金设置错误:排序型没有其他金额")
|
||
return
|
||
}
|
||
for i := 0; i < len(bonusUp); i++ {
|
||
var (
|
||
rank = i + 1
|
||
money int64
|
||
ok bool
|
||
)
|
||
if rank >= other {
|
||
money = otherMoney
|
||
} else {
|
||
money, ok = activityBonus[int64(rank)]
|
||
if !ok {
|
||
err = fmt.Errorf("活动奖金设置错误:没有名次金额")
|
||
return
|
||
}
|
||
}
|
||
if money == 0 {
|
||
continue
|
||
}
|
||
bonusUp[i].Bonus = money
|
||
bonusUp[i].Rank = i + 1
|
||
if bonusUp[i].State < 2 {
|
||
// 中奖
|
||
bonusUp[i].State = 2
|
||
bonusUp[i].SuccessTime = xtime.Time(time.Now().Unix())
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *Service) getUpStatisData(c context.Context, up *model.UpActivity, ac *model.CActivity, date time.Time, archiveInfo map[int64]map[int]*model.ArchiveStat) (err error) {
|
||
if len(up.AIDs) == 0 {
|
||
return
|
||
}
|
||
avItem := make([]*model.AvItem, 0)
|
||
aIDs := up.AIDs
|
||
for _, avID := range aIDs {
|
||
// 稿件统计数据: 计算当天的和 - 统计开始前一天的和
|
||
var itemSumStart, itemSumEnd int64
|
||
itemSumEnd, err = s.getAvStatisState(c, avID, ac, archiveInfo, 2)
|
||
if err != nil {
|
||
log.Error("s.getAvStatisState error(%v)", err)
|
||
return
|
||
}
|
||
itemSumStart, err = s.getAvStatisState(c, avID, ac, archiveInfo, 1)
|
||
if err != nil {
|
||
log.Error("s.getAvStatisState error(%v)", err)
|
||
return
|
||
}
|
||
itemSum := itemSumEnd - itemSumStart
|
||
if itemSum > 0 {
|
||
avItem = append(avItem, &model.AvItem{
|
||
AvID: avID,
|
||
Value: itemSum,
|
||
})
|
||
}
|
||
}
|
||
if len(avItem) == 0 {
|
||
return
|
||
}
|
||
sort.Slice(avItem, func(i, j int) bool {
|
||
return avItem[i].Value > avItem[j].Value
|
||
})
|
||
|
||
// 1:uid 2 avid
|
||
if ac.Object == 1 {
|
||
up.AIDs = make([]int64, 0)
|
||
for _, av := range avItem {
|
||
if len(up.AIDs) < 5 {
|
||
up.AIDs = append(up.AIDs, av.AvID)
|
||
}
|
||
up.ItemVal += av.Value
|
||
}
|
||
up.AIDNum = int64(len(avItem))
|
||
} else if ac.Object == 2 {
|
||
up.AIDs = []int64{avItem[0].AvID}
|
||
up.ItemVal = avItem[0].Value
|
||
up.AIDNum = 1
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *Service) getAvStatisState(c context.Context, avID int64, ac *model.CActivity, archiveInfo map[int64]map[int]*model.ArchiveStat, state int) (sum int64, err error) {
|
||
if _, ok := archiveInfo[avID]; !ok {
|
||
return
|
||
}
|
||
stat, ok := archiveInfo[avID][state]
|
||
if !ok {
|
||
return
|
||
}
|
||
requireItems := strings.Split(ac.RequireItems, ",")
|
||
for _, item := range requireItems {
|
||
switch item {
|
||
case _like:
|
||
sum += stat.Like
|
||
case _share:
|
||
sum += stat.Share
|
||
case _play:
|
||
sum += stat.Play
|
||
case _reply:
|
||
sum += stat.Reply
|
||
case _dm:
|
||
sum += stat.Dm
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func handleActivityAvs(ups map[int64]*model.UpActivity, avs []*model.AvUpload, ac *model.CActivity) {
|
||
for _, av := range avs {
|
||
if !(av.UploadTime >= ac.UploadStart && av.UploadTime <= ac.UploadEnd) {
|
||
continue
|
||
}
|
||
if _, ok := ups[av.MID]; ok {
|
||
if len(ups[av.MID].AIDs) == 0 {
|
||
ups[av.MID].AIDs = make([]int64, 0)
|
||
}
|
||
ups[av.MID].AIDs = append(ups[av.MID].AIDs, av.AvID)
|
||
}
|
||
}
|
||
}
|
||
|
||
func (s *Service) getAvsUpload(c context.Context, ups map[int64]*model.UpActivity) (avs []*model.AvUpload, err error) {
|
||
avs = make([]*model.AvUpload, 0)
|
||
var id int64
|
||
for {
|
||
var av []*model.AvUpload
|
||
av, err = s.dao.GetAvUploadByMID(c, id, _dbLimit)
|
||
if err != nil {
|
||
return
|
||
}
|
||
avs = append(avs, av...)
|
||
if len(av) < _dbLimit {
|
||
break
|
||
}
|
||
id = av[len(av)-1].ID
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *Service) getArchiveInfo(c context.Context, activityID int64) (archives map[int64]map[int]*model.ArchiveStat, err error) {
|
||
archives = make(map[int64]map[int]*model.ArchiveStat) // map[av_id][state]*model.ArchiveStat
|
||
var id int64
|
||
for {
|
||
var arch []*model.ArchiveStat
|
||
arch, err = s.dao.GetArchiveInfo(c, activityID, id, _dbLimit)
|
||
if err != nil {
|
||
return
|
||
}
|
||
for _, a := range arch {
|
||
if _, ok := archives[a.AvID]; !ok {
|
||
archives[a.AvID] = make(map[int]*model.ArchiveStat)
|
||
}
|
||
archives[a.AvID][a.State] = a
|
||
}
|
||
if len(arch) < _dbLimit {
|
||
break
|
||
}
|
||
id = arch[len(arch)-1].ID
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *Service) getSignedUps(c context.Context, ac *model.CActivity, upInfo map[int64]*model.UpInfoVideo) (signedUps map[int64]*model.UpActivity, err error) {
|
||
signedUps = make(map[int64]*model.UpActivity)
|
||
// if need sign up
|
||
if ac.SignUp == 1 {
|
||
var ups []*model.UpActivity
|
||
ups, err = s.dao.ListUpActivity(c, ac.ID)
|
||
if err != nil {
|
||
return
|
||
}
|
||
for _, up := range ups {
|
||
if info, ok := upInfo[up.MID]; ok && info.SignedAt >= ac.SignedStart && info.SignedAt <= ac.SignedEnd {
|
||
signedUps[up.MID] = up
|
||
}
|
||
}
|
||
} else {
|
||
for _, info := range upInfo {
|
||
if info.SignedAt >= ac.SignedStart && info.SignedAt <= ac.SignedEnd {
|
||
signedUps[info.MID] = &model.UpActivity{MID: info.MID, ActivityID: ac.ID, State: 1, Nickname: info.Nickname}
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *Service) updateUpActivity(c context.Context, id int64, upBonus []*model.UpActivity) (err error) {
|
||
// 更新所有之前获奖up主为已报名
|
||
// update state 2->1 将所有状态设置为已报名
|
||
_, err = s.dao.UpdateUpActivityState(c, id, 2, 1)
|
||
if err != nil {
|
||
log.Error("s.dao.UpdateUpActivityState error(%v)", err)
|
||
return
|
||
}
|
||
if len(upBonus) > 0 {
|
||
_, err = s.insertUpActivityBatch(c, upBonus)
|
||
if err != nil {
|
||
log.Error("s.insertUpActivity error(%v)", err)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
func (s *Service) insertUpActivityBatch(c context.Context, ups []*model.UpActivity) (rows int64, err error) {
|
||
insert := make([]*model.UpActivity, _dbBatchSize)
|
||
insertIndex := 0
|
||
for _, up := range ups {
|
||
insert[insertIndex] = up
|
||
insertIndex++
|
||
if insertIndex >= _dbBatchSize {
|
||
_, err = s.insertUpActivity(c, insert[:insertIndex])
|
||
if err != nil {
|
||
return
|
||
}
|
||
insertIndex = 0
|
||
}
|
||
}
|
||
if insertIndex > 0 {
|
||
_, err = s.insertUpActivity(c, insert[:insertIndex])
|
||
}
|
||
return
|
||
}
|
||
|
||
func assembleUpActivity(ups []*model.UpActivity) (vals string) {
|
||
var buf bytes.Buffer
|
||
for _, row := range ups {
|
||
buf.WriteString("(")
|
||
buf.WriteString(strconv.FormatInt(row.MID, 10))
|
||
buf.WriteByte(',')
|
||
buf.WriteString("\"" + row.Nickname + "\"")
|
||
buf.WriteByte(',')
|
||
buf.WriteString(strconv.FormatInt(row.ActivityID, 10))
|
||
buf.WriteByte(',')
|
||
buf.WriteString("'" + xstr.JoinInts(row.AIDs) + "'")
|
||
buf.WriteByte(',')
|
||
buf.WriteString(strconv.FormatInt(row.AIDNum, 10))
|
||
buf.WriteByte(',')
|
||
buf.WriteString(strconv.Itoa(row.Rank))
|
||
buf.WriteByte(',')
|
||
buf.WriteString(strconv.FormatInt(row.Bonus, 10))
|
||
buf.WriteByte(',')
|
||
buf.WriteString(strconv.Itoa(row.State))
|
||
buf.WriteByte(',')
|
||
buf.WriteString("'" + row.SuccessTime.Time().Format("2006-01-02 15:04:05") + "'")
|
||
buf.WriteString(")")
|
||
buf.WriteByte(',')
|
||
}
|
||
if buf.Len() > 0 {
|
||
buf.Truncate(buf.Len() - 1)
|
||
}
|
||
vals = buf.String()
|
||
buf.Reset()
|
||
return
|
||
}
|
||
|
||
func (s *Service) insertUpActivity(c context.Context, ups []*model.UpActivity) (rows int64, err error) {
|
||
vals := assembleUpActivity(ups)
|
||
rows, err = s.dao.InsertUpActivityBatch(c, vals)
|
||
return
|
||
}
|