You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
475 lines
15 KiB
475 lines
15 KiB
package timemachine |
|
|
|
import ( |
|
"context" |
|
"sort" |
|
"strconv" |
|
"strings" |
|
"time" |
|
|
|
model "go-common/app/interface/main/activity/model/timemachine" |
|
tagmdl "go-common/app/interface/main/tag/api" |
|
artmdl "go-common/app/interface/openplatform/article/model" |
|
accmdl "go-common/app/service/main/account/api" |
|
arcmdl "go-common/app/service/main/archive/api" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
"go-common/library/net/metadata" |
|
|
|
"go-common/library/sync/errgroup.v2" |
|
) |
|
|
|
// StartTmproc start tm proc. |
|
//func (s *Service) StartTmproc(c context.Context) (err error) { |
|
// s.dao.StartTmProc(context.Background()) |
|
// return |
|
//} |
|
|
|
// StopTmproc start tm proc. |
|
//func (s *Service) StopTmproc(c context.Context) (err error) { |
|
// s.dao.StopTmproc(c) |
|
// return |
|
//} |
|
|
|
// Timemachine2018Raw . |
|
func (s *Service) Timemachine2018Raw(c context.Context, loginMid, mid int64) (data *model.Item, err error) { |
|
if _, ok := s.tmMidMap[loginMid]; !ok { |
|
err = ecode.AccessDenied |
|
return |
|
} |
|
if mid == 0 { |
|
mid = loginMid |
|
} |
|
if data, err = s.dao.RawTimemachine(c, mid); err != nil { |
|
log.Error("Timemachine2018 s.dao.RawTimemachine(%d) error(%v)", mid, err) |
|
} |
|
return |
|
} |
|
|
|
// Timemachine2018Cache . |
|
func (s *Service) Timemachine2018Cache(c context.Context, loginMid, mid int64) (data *model.Item, err error) { |
|
if _, ok := s.tmMidMap[loginMid]; !ok { |
|
err = ecode.AccessDenied |
|
return |
|
} |
|
if mid == 0 { |
|
mid = loginMid |
|
} |
|
if data, err = s.dao.CacheTimemachine(c, mid); err != nil { |
|
log.Error("Timemachine2018Cache s.dao.CacheTimemachine(%d) error(%v)", mid, err) |
|
} |
|
return |
|
} |
|
|
|
// Timemachine2018 . |
|
func (s *Service) Timemachine2018(c context.Context, loginMid, mid int64) (data *model.Timemachine, err error) { |
|
if _, ok := s.tmMidMap[loginMid]; !ok { |
|
mid = loginMid |
|
} else { |
|
if mid == 0 { |
|
mid = loginMid |
|
} |
|
} |
|
var item *model.Item |
|
if item, err = s.dao.CacheTimemachine(c, mid); err != nil { |
|
log.Error("Timemachine2018 s.dao.Timemachine(%d) error(%v)", mid, err) |
|
err = nil |
|
} |
|
if item == nil || item.DurationHour == 0 || (item.LikeUpAvDuration == 0 && item.LikeUpLiveDuration == 0) { |
|
item = &model.Item{Mid: mid} |
|
} |
|
data = s.groupTmData(c, item) |
|
return |
|
} |
|
|
|
func (s *Service) groupTmData(c context.Context, item *model.Item) (data *model.Timemachine) { |
|
var ( |
|
aids, viewAids, upAids, artIDs, mids []int64 |
|
totalView, ugcView, pgcView []*model.AidView |
|
upBestLiveFanMid, liveMinute, upBestFanMid, favVv, subTidBest int64 |
|
) |
|
data = &model.Timemachine{ |
|
Mid: item.Mid, |
|
IsUp: item.IsUp, |
|
DurationHour: item.DurationHour, |
|
ArchiveVv: item.ArchiveVv, |
|
BrainwashCirVv: item.BrainwashCirVv, |
|
FirstSubmitType: item.FirstSubmitType, |
|
LikeSubtidVv: item.LikeSubtidVv, |
|
LikeUpAvDuration: item.LikeUpAvDuration, |
|
LikeUpLiveDuration: item.LikeUpLiveDuration, |
|
LikeUpDuration: item.LikeUpAvDuration + item.LikeUpLiveDuration, |
|
LikeLiveUpSubTname: item.LikeLiveUpSubTname, |
|
BestAvidType: item.BestAvidType, |
|
AllVv: item.AllVv, |
|
BestAvidOldType: item.BestAvidOldType, |
|
OldAvVv: item.OldAvVv, |
|
UpLiveDuration: item.UpLiveDuration, |
|
IsLiveUp: item.IsLiveUp, |
|
ValidLiveDays: item.ValidLiveDays, |
|
AddAttentions: item.Attentions, |
|
WinRatio: item.WinRatio, |
|
SubmitAvsRds: item.SubmitAvsRds, |
|
} |
|
// win ratio fix |
|
if data.WinRatio == "100%" { |
|
data.WinRatio = "99%" |
|
} |
|
if data.ValidLiveDays > 365 { |
|
data.ValidLiveDays = 365 |
|
} |
|
if item.Like2SubTids != "" { |
|
subTidBest = s.groupTagDesc(item, data) |
|
} |
|
if tagDesc, ok := s.tagDescMap[item.LikeTagID]; ok && tagDesc != nil { |
|
data.LikeTagDescFirst = tagDesc.Desc1 |
|
data.LikeTagDescSecond = tagDesc.Desc2Line1 |
|
data.LikeTagDescSecond2 = tagDesc.Desc2Line2 |
|
} else if subTidBest > 0 { |
|
if tagRegDesc, ok := s.tagRegionDescMap[subTidBest]; ok && tagRegDesc != nil { |
|
data.LikeTagDescFirst = tagRegDesc.Desc1 |
|
data.LikeTagDescSecond = tagRegDesc.Desc2Line1 |
|
data.LikeTagDescSecond2 = tagRegDesc.Desc2Line2 |
|
} |
|
} |
|
if braTime, e := time.Parse("20060102", item.BrainwashCirTime); e != nil { |
|
log.Warn("groupTmData BrainwashCirTime time.Parse(%s) warn(%v)", item.BrainwashCirTime, e) |
|
} else { |
|
data.BrainwashCirTime = braTime.Format("2006.01.02") |
|
} |
|
// LikeUpDuration data fix |
|
if data.LikeUpDuration > item.DurationHour*60 { |
|
if data.LikeUpDuration < (item.AvDurationHour*60 + item.LikeUpLiveDuration) { |
|
if (item.AvDurationHour*60 + item.LikeUpLiveDuration) > 0 { |
|
data.LikeUpDuration = int64(float64(item.DurationHour*60) * (float64(data.LikeUpDuration) / float64(item.AvDurationHour*60+item.LikeUpLiveDuration))) |
|
} |
|
} else { |
|
if (item.PlayDurationHourRep*60 + item.LikeUpLiveDuration) > 0 { |
|
data.LikeUpDuration = int64(float64(item.DurationHour*60) * (float64(item.LikeUpAvDurationRep+item.LikeUpLiveDuration) / float64(item.PlayDurationHourRep*60+item.LikeUpLiveDuration))) |
|
} |
|
} |
|
} |
|
realIP := metadata.String(c, metadata.RemoteIP) |
|
group := errgroup.WithCancel(c) |
|
// tag data |
|
if item.LikeTagID > 0 { |
|
group.Go(func(ctx context.Context) error { |
|
if tag, e := s.tagClient.Tag(ctx, &tagmdl.TagReq{Tid: item.LikeTagID}); e != nil || tag == nil { |
|
log.Error("s.tagClient.Tag tid(%d) error(%v)", item.LikeTagID, e) |
|
} else { |
|
data.LikeTagID = item.LikeTagID |
|
data.LikeTagName = tag.Tag.Name |
|
} |
|
return nil |
|
}) |
|
} |
|
// group aids |
|
if item.BestAvid > 0 { |
|
aids = append(aids, item.BestAvid) |
|
} |
|
if item.LikesUgc3Avids != "" { |
|
list := strings.Split(item.LikesUgc3Avids, ",") |
|
for _, v := range list { |
|
items := strings.Split(v, ":") |
|
if len(items) == 2 { |
|
aid, e := strconv.ParseInt(items[0], 10, 64) |
|
if e != nil { |
|
continue |
|
} |
|
vv, e := strconv.ParseInt(items[1], 10, 64) |
|
if e != nil { |
|
continue |
|
} |
|
ugcView = append(ugcView, &model.AidView{Aid: aid, View: vv}) |
|
} |
|
} |
|
} |
|
if item.LikePgc3Avids != "" { |
|
list := strings.Split(item.LikePgc3Avids, ",") |
|
for _, v := range list { |
|
items := strings.Split(v, "@") |
|
if len(items) == 2 { |
|
aid, e := strconv.ParseInt(items[0], 10, 64) |
|
if e != nil { |
|
continue |
|
} |
|
vv, e := strconv.ParseInt(items[1], 10, 64) |
|
if e != nil { |
|
continue |
|
} |
|
pgcView = append(pgcView, &model.AidView{Aid: aid, View: vv}) |
|
} |
|
} |
|
} |
|
ugcViewLen := len(ugcView) |
|
if ugcViewLen > 3 { |
|
ugcView = ugcView[:_totalViewLen] |
|
} |
|
sort.Slice(ugcView, func(i, j int) bool { |
|
return ugcView[i].View > ugcView[j].View |
|
}) |
|
pgcViewLen := len(pgcView) |
|
if pgcViewLen > 3 { |
|
pgcView = pgcView[:_totalViewLen] |
|
} |
|
sort.Slice(pgcView, func(i, j int) bool { |
|
return pgcView[i].View > pgcView[j].View |
|
}) |
|
totalView = append(totalView, ugcView...) |
|
switch { |
|
case ugcViewLen == 0: |
|
totalView = append(totalView, pgcView...) |
|
case ugcViewLen == 1: |
|
switch { |
|
case pgcViewLen == 1: |
|
totalView = append(totalView, pgcView[0]) |
|
case pgcViewLen > 1: |
|
totalView = append(totalView, pgcView[:2]...) |
|
} |
|
case ugcViewLen >= 2: |
|
if pgcViewLen > 0 { |
|
totalView = append(totalView, pgcView[0]) |
|
} |
|
} |
|
sort.Slice(totalView, func(i, j int) bool { |
|
return totalView[i].View > totalView[j].View |
|
}) |
|
if len(totalView) > _totalViewLen { |
|
totalView = totalView[:_totalViewLen] |
|
} |
|
for _, v := range totalView { |
|
viewAids = append(viewAids, v.Aid) |
|
} |
|
aids = append(aids, viewAids...) |
|
if item.LikeUp3Avs != "" { |
|
aidsStr := strings.Split(item.LikeUp3Avs, ",") |
|
for _, aidStr := range aidsStr { |
|
if aid, e := strconv.ParseInt(aidStr, 10, 64); e != nil { |
|
continue |
|
} else { |
|
upAids = append(upAids, aid) |
|
} |
|
} |
|
} |
|
aids = append(aids, upAids...) |
|
if item.BrainwashCirAvid > 0 { |
|
aids = append(aids, item.BrainwashCirAvid) |
|
} |
|
if item.BestAvid > 0 { |
|
switch item.BestAvidType { |
|
case _typeArticle: |
|
artIDs = append(artIDs, item.BestAvid) |
|
case _typeArchive: |
|
aids = append(aids, item.BestAvid) |
|
} |
|
} |
|
if item.BestAvidOld > 0 { |
|
switch item.BestAvidOldType { |
|
case _typeArticle: |
|
artIDs = append(artIDs, item.BestAvidOld) |
|
case _typeArchive: |
|
aids = append(aids, item.BestAvidOld) |
|
} |
|
} |
|
if item.FirstSubmitAvid > 0 { |
|
switch item.FirstSubmitType { |
|
case _typeArticle: |
|
artIDs = append(artIDs, item.FirstSubmitAvid) |
|
case _typeArchive: |
|
aids = append(aids, item.FirstSubmitAvid) |
|
} |
|
} |
|
if len(aids) > 0 { |
|
group.Go(func(ctx context.Context) error { |
|
s.groupArcData(ctx, aids, upAids, totalView, item, data) |
|
return nil |
|
}) |
|
} |
|
// article |
|
if len(artIDs) > 0 { |
|
group.Go(func(ctx context.Context) error { |
|
s.groupArtData(ctx, artIDs, item, data) |
|
return nil |
|
}) |
|
} |
|
group.Go(func(ctx context.Context) error { |
|
if acc, e := s.accClient.ProfileWithStat3(ctx, &accmdl.MidReq{Mid: item.Mid}); e != nil { |
|
log.Error("groupTmData s.arcClient.ProfileWithStat3(%v) error(%v)", item.Mid, e) |
|
} else { |
|
data.Uname = acc.Profile.Name |
|
data.Face = acc.Profile.Face |
|
data.Fans = acc.Follower |
|
data.RegTime = time.Unix(int64(acc.Profile.JoinTime), 0).Format("2006.01.02") |
|
data.RegDay = (time.Now().Unix() - int64(acc.Profile.JoinTime)) / 86400 |
|
} |
|
return nil |
|
}) |
|
// group mids |
|
if item.LikeBestUpID > 0 { |
|
mids = append(mids, item.LikeBestUpID) |
|
} |
|
if item.IsUp == 1 { |
|
if firstSubTime, e := time.Parse("2006-01-02 15:04:05", item.FirstSubmitTime); e != nil { |
|
log.Warn("groupTmData FirstSubmitTime time.Parse(%s) warn(%v)", item.FirstSubmitTime, e) |
|
} else { |
|
data.FirstSubmitTime = firstSubTime.Format("2006.01.02") |
|
} |
|
if item.UpBestFanVv != "" { |
|
list := strings.Split(item.UpBestFanVv, "@") |
|
if len(list) == 2 { |
|
if mid, e := strconv.ParseInt(list[0], 10, 64); e != nil { |
|
log.Error("UpBestFanVv parse(%s) error(%v)", list[0], e) |
|
} else { |
|
upBestFanMid = mid |
|
mids = append(mids, mid) |
|
} |
|
if vv, e := strconv.ParseInt(list[1], 10, 64); e != nil { |
|
log.Error("UpBestFanLiveMinute parse(%s) error(%v)", list[1], e) |
|
} else { |
|
favVv = vv |
|
} |
|
} |
|
} |
|
} |
|
if item.IsLiveUp == 1 { |
|
if maxCdnTime, e := time.Parse("20060102", item.MaxCdnNumDate); e != nil { |
|
log.Warn("groupTmData MaxCdnNumDate time.Parse(%s) warn(%v)", item.MaxCdnNumDate, e) |
|
} else { |
|
data.MaxCdnNumDate = maxCdnTime.Format("2006.01.02") |
|
} |
|
data.MaxCdnNum = item.MaxCdnNum |
|
if item.UpBestFanLiveMinute != "" { |
|
list := strings.Split(item.UpBestFanLiveMinute, "@") |
|
if len(list) == 2 { |
|
if mid, e := strconv.ParseInt(list[0], 10, 64); e != nil { |
|
log.Error("UpBestFanLiveMinute parse(%s) error(%v)", list[0], e) |
|
} else { |
|
upBestLiveFanMid = mid |
|
mids = append(mids, mid) |
|
} |
|
if minute, e := strconv.ParseInt(list[1], 10, 64); e != nil { |
|
log.Error("UpBestFanLiveMinute parse(%s) error(%v)", list[1], e) |
|
} else { |
|
liveMinute = minute |
|
} |
|
} |
|
} |
|
} |
|
if len(mids) > 0 { |
|
group.Go(func(ctx context.Context) error { |
|
if accs, e := s.accClient.Infos3(ctx, &accmdl.MidsReq{Mids: mids, RealIp: realIP}); e != nil || accs.Infos == nil { |
|
log.Error("groupTmData s.accClient.Cards3(%v) error(%v)", mids, e) |
|
} else { |
|
if item.LikeBestUpID > 0 { |
|
if info, ok := accs.Infos[item.LikeBestUpID]; ok { |
|
data.LikeBestUpID = item.LikeBestUpID |
|
data.LikeBestUpName = info.Name |
|
data.LikeBestUpFace = info.Face |
|
} |
|
} |
|
if item.IsUp == 1 && upBestFanMid > 0 { |
|
if info, ok := accs.Infos[upBestFanMid]; ok { |
|
data.UpBestFanVv = &model.FavVv{Mid: upBestFanMid, Name: info.Name, Face: info.Face, Vv: favVv} |
|
} |
|
} |
|
if item.IsLiveUp == 1 && upBestLiveFanMid > 0 { |
|
if info, ok := accs.Infos[upBestLiveFanMid]; ok { |
|
data.UpBestFanLiveMinute = &model.FanMinute{Mid: upBestLiveFanMid, Name: info.Name, Face: info.Face, Minute: liveMinute} |
|
} |
|
} |
|
} |
|
return nil |
|
}) |
|
} |
|
if e := group.Wait(); e != nil { |
|
log.Error("groupTmData group.Wait error(%v)", e) |
|
} |
|
if len(data.LikeUp3Arcs) == 0 { |
|
data.LikeUp3Arcs = make([]*model.TmArc, 0) |
|
} |
|
return |
|
} |
|
|
|
func (s *Service) groupArcData(c context.Context, aids, upAids []int64, totalView []*model.AidView, item *model.Item, data *model.Timemachine) { |
|
if arcs, e := s.arcClient.Arcs(c, &arcmdl.ArcsRequest{Aids: aids}); e != nil { |
|
log.Error("groupTmData s.arcClient.Arcs(%v) error(%v)", aids, e) |
|
} else if arcs != nil { |
|
if item.BrainwashCirAvid > 0 { |
|
if arc, ok := arcs.Arcs[item.BrainwashCirAvid]; ok && arc.IsNormal() { |
|
data.BrainwashCirArc = &model.TmArc{Aid: item.BrainwashCirAvid, Title: arc.Title, Cover: arc.Pic, Author: arc.Author} |
|
} |
|
} |
|
if item.BestAvid > 0 && item.BestAvidType == _typeArchive { |
|
if arc, ok := arcs.Arcs[item.BestAvid]; ok && arc.IsNormal() { |
|
data.BestArc = &model.TmArc{Aid: item.BestAvid, Title: arc.Title, Cover: arc.Pic, Author: arc.Author} |
|
} |
|
} |
|
if item.BestAvidOld > 0 && item.BestAvidOldType == _typeArchive { |
|
if arc, ok := arcs.Arcs[item.BestAvidOld]; ok && arc.IsNormal() { |
|
data.BestArcOld = &model.TmArc{Aid: item.BestAvidOld, Title: arc.Title, Cover: arc.Pic, Author: arc.Author} |
|
} |
|
} |
|
if item.FirstSubmitAvid > 0 && item.FirstSubmitType == _typeArchive { |
|
if arc, ok := arcs.Arcs[item.FirstSubmitAvid]; ok && arc.IsNormal() { |
|
data.FirstSubmitArc = &model.TmArc{Aid: item.FirstSubmitAvid, Title: arc.Title, Cover: arc.Pic, Author: arc.Author} |
|
} |
|
} |
|
for _, aid := range upAids { |
|
if arc, ok := arcs.Arcs[aid]; ok && arc.IsNormal() { |
|
data.LikeUp3Arcs = append(data.LikeUp3Arcs, &model.TmArc{Aid: aid, Title: arc.Title, Cover: arc.Pic, Author: arc.Author}) |
|
} |
|
} |
|
for _, item := range totalView { |
|
if arc, ok := arcs.Arcs[item.Aid]; ok && arc.IsNormal() { |
|
data.Likes3Arcs = append(data.Likes3Arcs, &model.TmArc{Aid: item.Aid, Title: arc.Title, Cover: arc.Pic, Author: arc.Author}) |
|
} |
|
} |
|
} |
|
} |
|
|
|
func (s *Service) groupArtData(c context.Context, artIDs []int64, item *model.Item, data *model.Timemachine) { |
|
if arts, e := s.article.ArticleMetas(c, &artmdl.ArgAids{Aids: artIDs}); e != nil { |
|
log.Error("groupTmData s.article.ArticleMetas(%v) error(%v)", artIDs, e) |
|
} else { |
|
if item.BestAvid > 0 && item.BestAvidType == _typeArticle { |
|
if art, ok := arts[item.BestAvid]; ok { |
|
data.BestArc = &model.TmArc{Aid: item.BestAvid, Title: art.Title} |
|
} |
|
} |
|
if item.BestAvidOld > 0 && item.BestAvidOldType == _typeArticle { |
|
if art, ok := arts[item.BestAvidOld]; ok { |
|
data.BestArcOld = &model.TmArc{Aid: item.BestAvidOld, Title: art.Title} |
|
} |
|
} |
|
if item.FirstSubmitAvid > 0 && item.FirstSubmitType == _typeArticle { |
|
if art, ok := arts[item.FirstSubmitAvid]; ok { |
|
data.FirstSubmitArc = &model.TmArc{Aid: item.FirstSubmitAvid, Title: art.Title} |
|
} |
|
} |
|
} |
|
} |
|
|
|
func (s *Service) groupTagDesc(item *model.Item, data *model.Timemachine) (subTidBest int64) { |
|
var subTid int64 |
|
subList := strings.Split(item.Like2SubTids, ",") |
|
if len(subList) == 2 { |
|
if subID, e := strconv.ParseInt(subList[0], 10, 64); e != nil { |
|
log.Warn("groupTmData Like2SubTids time.Parse(%s) warn(%v)", subList[0], e) |
|
} else if subID > 0 { |
|
subTidBest = subID |
|
} |
|
if subID, e := strconv.ParseInt(subList[1], 10, 64); e != nil { |
|
log.Warn("groupTmData Like2SubTids strconv.ParseInt(%s) warn(%v)", subList[1], e) |
|
} else if subID > 0 { |
|
subTid = subID |
|
} |
|
if regionDesc, ok := s.regionDescMap[subTidBest]; ok && regionDesc != nil { |
|
data.LikeSubDesc2 = regionDesc.Desc2 |
|
data.LikeSubDesc3 = regionDesc.Desc3 |
|
} |
|
if regionDesc, ok := s.regionDescMap[subTid]; ok && regionDesc != nil { |
|
data.LikeSubDesc1 = regionDesc.Desc1 |
|
} |
|
} |
|
return |
|
}
|
|
|