307 lines
8.3 KiB
Go
307 lines
8.3 KiB
Go
package show
|
|
|
|
import (
|
|
"context"
|
|
"hash/crc32"
|
|
"strconv"
|
|
"time"
|
|
|
|
cdm "go-common/app/interface/main/app-card/model"
|
|
cardm "go-common/app/interface/main/app-card/model/card"
|
|
operate "go-common/app/interface/main/app-card/model/card/operate"
|
|
"go-common/app/interface/main/app-card/model/card/rank"
|
|
"go-common/app/interface/main/app-show/model"
|
|
"go-common/app/interface/main/app-show/model/card"
|
|
"go-common/app/interface/main/app-show/model/feed"
|
|
account "go-common/app/service/main/account/model"
|
|
"go-common/app/service/main/archive/api"
|
|
"go-common/app/service/main/archive/model/archive"
|
|
relation "go-common/app/service/main/relation/model"
|
|
"go-common/library/ecode"
|
|
"go-common/library/log"
|
|
"go-common/library/sync/errgroup"
|
|
)
|
|
|
|
var (
|
|
_emptyList2 = []cardm.Handler{}
|
|
)
|
|
|
|
// FeedIndex feed index
|
|
func (s *Service) FeedIndex2(c context.Context, mid, idx int64, plat int8, build, loginEvent int, lastParam, mobiApp, device, buvid string, now time.Time) (res []cardm.Handler, ver string, err error) {
|
|
var (
|
|
ps = 10
|
|
isIpad = plat == model.PlatIPad
|
|
cards, cardCache []*card.PopularCard
|
|
infocs []*feed.Item
|
|
style int8
|
|
)
|
|
if isIpad {
|
|
ps = 20
|
|
}
|
|
var key int
|
|
if mid > 0 {
|
|
key = int((mid / 1000) % 10)
|
|
} else {
|
|
key = int((crc32.ChecksumIEEE([]byte(buvid)) / 1000) % 10)
|
|
}
|
|
cardCache = s.PopularCardTenList(c, key)
|
|
if len(cardCache) > int(idx) {
|
|
cards = cardCache[idx:]
|
|
} else {
|
|
err = ecode.AppNotData
|
|
res = _emptyList2
|
|
return
|
|
}
|
|
// HotDynamic====================
|
|
// cards = append(cards[:0], append([]*card.PopularCard{&card.PopularCard{Type: model.GotoHotDynamic, ReasonType: 0, FromType: "recommend"}}, cards[0:]...)...)
|
|
// HotDynamic====================
|
|
//build
|
|
if plat == model.PlatIPhone && build > 8230 || plat == model.PlatAndroid && build > 5345000 {
|
|
// switch key {
|
|
// // case 0, 3:
|
|
// // style = cdm.HotCardStyleShowUp
|
|
// case 2, 5:
|
|
// style = cdm.HotCardStyleHideUp
|
|
// default:
|
|
// style = cdm.HotCardStyleOld
|
|
// }
|
|
style = cdm.HotCardStyleHideUp
|
|
} else {
|
|
style = cdm.HotCardStyleOld
|
|
}
|
|
//build
|
|
res, infocs = s.dealItem2(c, plat, build, ps, cards, mid, idx, lastParam, now, style)
|
|
ver = strconv.FormatInt(now.Unix(), 10)
|
|
if len(res) == 0 {
|
|
err = ecode.AppNotData
|
|
res = _emptyList2
|
|
return
|
|
}
|
|
//infoc
|
|
infoc := &feedInfoc{
|
|
mobiApp: mobiApp,
|
|
device: device,
|
|
build: strconv.Itoa(build),
|
|
now: now.Format("2006-01-02 15:04:05"),
|
|
loginEvent: strconv.Itoa(loginEvent),
|
|
mid: strconv.FormatInt(mid, 10),
|
|
buvid: buvid,
|
|
page: strconv.Itoa((int(idx) / ps) + 1),
|
|
feed: infocs,
|
|
}
|
|
s.infocfeed(infoc)
|
|
return
|
|
}
|
|
|
|
// dealItem feed item
|
|
func (s *Service) dealItem2(c context.Context, plat int8, build, ps int, cards []*card.PopularCard, mid, idx int64, lastParam string, now time.Time, style int8) (is []cardm.Handler, infocs []*feed.Item) {
|
|
var (
|
|
max = int64(100)
|
|
_fTypeOperation = "operation"
|
|
aids, avUpIDs, upIDs, rnUpIDs []int64
|
|
am map[int64]*archive.ArchiveWithPlayer
|
|
feedcards []*card.PopularCard
|
|
err error
|
|
rank *operate.Card
|
|
accountm map[int64]*account.Card
|
|
isAtten map[int64]int8
|
|
statm map[int64]*relation.Stat
|
|
)
|
|
cardSet := map[int64]*operate.Card{}
|
|
eventTopic := map[int64]*operate.Card{}
|
|
LOOP:
|
|
for pos, ca := range cards {
|
|
var cardIdx = idx + int64(pos+1)
|
|
if cardIdx > max && ca.FromType != _fTypeOperation {
|
|
continue
|
|
}
|
|
if config, ok := ca.PopularCardPlat[plat]; ok {
|
|
for _, l := range config {
|
|
if model.InvalidBuild(build, l.Build, l.Condition) {
|
|
continue LOOP
|
|
}
|
|
}
|
|
} else if ca.FromType == _fTypeOperation {
|
|
continue LOOP
|
|
}
|
|
tmp := &card.PopularCard{}
|
|
*tmp = *ca
|
|
if plat == model.PlatIPhone && build > 8290 || plat == model.PlatAndroid && build > 5365000 {
|
|
switch ca.Type {
|
|
case model.GotoUpRcmdNew:
|
|
tmp.Type = model.GotoUpRcmdNewV2
|
|
}
|
|
}
|
|
tmp.Idx = cardIdx
|
|
feedcards = append(feedcards, tmp)
|
|
switch ca.Type {
|
|
case model.GotoAv:
|
|
aids = append(aids, ca.Value)
|
|
case model.GotoRank:
|
|
rank = &operate.Card{}
|
|
rank.FromRank(s.rankCache2)
|
|
case model.GotoUpRcmdNew, model.GotoUpRcmdNewV2:
|
|
cardm, as, upid := s.cardSetChange(c, ca.Value)
|
|
aids = append(aids, as...)
|
|
for id, card := range cardm {
|
|
cardSet[id] = card
|
|
}
|
|
rnUpIDs = append(rnUpIDs, upid)
|
|
case model.GotoEventTopic:
|
|
eventTopic = s.eventTopicChange(c, ca.Value)
|
|
}
|
|
if len(feedcards) == ps {
|
|
break
|
|
}
|
|
}
|
|
if len(aids) != 0 {
|
|
var as map[int64]*api.Arc
|
|
if as, err = s.arc.ArchivesPB(c, aids); err != nil {
|
|
log.Error("%+v", err)
|
|
err = nil
|
|
} else {
|
|
am = map[int64]*archive.ArchiveWithPlayer{}
|
|
for _, a := range as {
|
|
avUpIDs = append(avUpIDs, a.Author.Mid)
|
|
am[a.Aid] = &archive.ArchiveWithPlayer{Archive3: archive.BuildArchive3(a)}
|
|
}
|
|
}
|
|
}
|
|
switch style {
|
|
case cdm.HotCardStyleShowUp, cdm.HotCardStyleHideUp:
|
|
upIDs = append(upIDs, avUpIDs...)
|
|
}
|
|
upIDs = append(upIDs, rnUpIDs...)
|
|
avUpIDs = append(avUpIDs, rnUpIDs...)
|
|
g, ctx := errgroup.WithContext(c)
|
|
if len(avUpIDs) > 0 {
|
|
g.Go(func() (err error) {
|
|
if accountm, err = s.acc.Cards3(ctx, avUpIDs); err != nil {
|
|
log.Error("%+v", err)
|
|
err = nil
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
if len(upIDs) > 0 {
|
|
g.Go(func() (err error) {
|
|
if statm, err = s.reldao.Stats(ctx, upIDs); err != nil {
|
|
log.Error("%+v", err)
|
|
err = nil
|
|
}
|
|
return nil
|
|
})
|
|
if mid != 0 {
|
|
g.Go(func() error {
|
|
isAtten = s.acc.IsAttention(ctx, upIDs, mid)
|
|
return nil
|
|
})
|
|
}
|
|
}
|
|
g.Wait()
|
|
for _, ca := range feedcards {
|
|
var (
|
|
r = ca.PopularCardToAiChange()
|
|
main interface{}
|
|
cardType cdm.CardType
|
|
)
|
|
r.Style = style
|
|
op := &operate.Card{}
|
|
op.From(cdm.CardGt(r.Goto), r.ID, 0, plat, build)
|
|
switch r.Style {
|
|
case cdm.HotCardStyleShowUp, cdm.HotCardStyleHideUp:
|
|
switch r.Goto {
|
|
case model.GotoAv:
|
|
cardType = cdm.SmallCoverV5
|
|
}
|
|
}
|
|
switch r.Goto {
|
|
case model.GotoAv:
|
|
if a, ok := am[r.ID]; ok && (a.AttrVal(archive.AttrBitOverseaLock) == 0 || !model.IsOverseas(plat)) {
|
|
main = map[int64]*archive.ArchiveWithPlayer{a.Aid: a}
|
|
// op.Tid = a.Aid
|
|
r.HideButton = true
|
|
if (plat == model.PlatIPhone && build > 8290 || plat == model.PlatAndroid && build > 5365000) && cardType == cdm.SmallCoverV5 {
|
|
op.Switch = cdm.SwitchCooperationShow
|
|
} else {
|
|
op.Switch = cdm.SwitchCooperationHide
|
|
}
|
|
}
|
|
case model.GotoRank:
|
|
ams := map[int64]*archive.ArchiveWithPlayer{}
|
|
for aid, a := range s.rankArchivesCache {
|
|
ams[aid] = &archive.ArchiveWithPlayer{Archive3: archive.BuildArchive3(a)}
|
|
}
|
|
main = map[cdm.Gt]interface{}{cdm.GotoAv: ams}
|
|
op = rank
|
|
case model.GotoHotTopic:
|
|
main = s.hottopicsCache
|
|
case model.GotoUpRcmdNew, model.GotoUpRcmdNewV2:
|
|
main = am
|
|
op = cardSet[r.ID]
|
|
case model.GotoHotDynamic:
|
|
main = s.dynamicHotCache
|
|
case model.GotoEventTopic:
|
|
op = eventTopic[r.ID]
|
|
}
|
|
h := cardm.Handle(plat, cdm.CardGt(r.Goto), cardType, cdm.ColumnSvrSingle, r, nil, isAtten, statm, accountm)
|
|
if h == nil {
|
|
continue
|
|
}
|
|
h.From(main, op)
|
|
h.Get().FromType = ca.FromType
|
|
h.Get().Idx = ca.Idx
|
|
if h.Get().Right {
|
|
h.Get().ThreePointWatchLater()
|
|
is = append(is, h)
|
|
}
|
|
// infoc
|
|
tinfo := &feed.Item{
|
|
Goto: ca.Type,
|
|
Param: strconv.FormatInt(ca.Value, 10),
|
|
URI: h.Get().URI,
|
|
FromType: ca.FromType,
|
|
Idx: h.Get().Idx,
|
|
CornerMark: ca.CornerMark,
|
|
CardStyle: r.Style,
|
|
}
|
|
if r.RcmdReason != nil {
|
|
tinfo.RcmdContent = r.RcmdReason.Content
|
|
}
|
|
if op != nil {
|
|
switch r.Goto {
|
|
case model.GotoEventTopic:
|
|
tinfo.Item = append(tinfo.Item, &feed.Item{Param: op.URI, Goto: string(op.Goto)})
|
|
default:
|
|
for _, tmp := range op.Items {
|
|
tinfo.Item = append(tinfo.Item, &feed.Item{Param: strconv.FormatInt(tmp.ID, 10), Goto: string(tmp.Goto)})
|
|
}
|
|
}
|
|
}
|
|
infocs = append(infocs, tinfo)
|
|
if len(is) == ps {
|
|
break
|
|
}
|
|
}
|
|
rl := len(is)
|
|
if rl == 0 {
|
|
is = _emptyList2
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *Service) RankCard() (ranks []*rank.Rank, aids []int64) {
|
|
const _limit = 3
|
|
ranks = make([]*rank.Rank, 0, _limit)
|
|
aids = make([]int64, 0, _limit)
|
|
for _, rank := range s.rankCache2 {
|
|
ranks = append(ranks, rank)
|
|
aids = append(aids, rank.Aid)
|
|
if len(ranks) == _limit {
|
|
break
|
|
}
|
|
}
|
|
return
|
|
}
|