1089 lines
29 KiB
Go
1089 lines
29 KiB
Go
package feed
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"time"
|
||
|
||
cdm "go-common/app/interface/main/app-card/model"
|
||
"go-common/app/interface/main/app-card/model/card/ai"
|
||
"go-common/app/interface/main/app-card/model/card/audio"
|
||
"go-common/app/interface/main/app-card/model/card/bangumi"
|
||
"go-common/app/interface/main/app-card/model/card/banner"
|
||
"go-common/app/interface/main/app-card/model/card/cm"
|
||
"go-common/app/interface/main/app-card/model/card/live"
|
||
"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-card/model/card/show"
|
||
"go-common/app/interface/main/app-feed/model"
|
||
"go-common/app/interface/main/app-feed/model/feed"
|
||
bustag "go-common/app/interface/main/tag/model"
|
||
article "go-common/app/interface/openplatform/article/model"
|
||
account "go-common/app/service/main/account/model"
|
||
"go-common/app/service/main/archive/model/archive"
|
||
locmdl "go-common/app/service/main/location/model"
|
||
relation "go-common/app/service/main/relation/model"
|
||
episodegrpc "go-common/app/service/openplatform/pgc-season/api/grpc/episode/v1"
|
||
"go-common/library/ecode"
|
||
"go-common/library/log"
|
||
"go-common/library/net/metadata"
|
||
"go-common/library/sync/errgroup"
|
||
)
|
||
|
||
const (
|
||
_cardAdAv = 1
|
||
_cardAdWeb = 2
|
||
_cardAdWebS = 3
|
||
_cardAdLarge = 7
|
||
_feedgroups = "tianma2.0_autoplay_card"
|
||
)
|
||
|
||
// Index is
|
||
func (s *Service) Index(c context.Context, mid int64, plat int8, build int, buvid, network, mobiApp, device, platform, openEvent string, loginEvent int, idx int64, pull bool, now time.Time, bannerHash, adExtra string, qn int, interest string, style, flush, fnver, fnval, autoplayCard int) (is []*feed.Item, userFeature json.RawMessage, isRcmd, newUser bool, code, clean int, autoPlayInfoc string, err error) {
|
||
var (
|
||
ris []*ai.Item
|
||
adm map[int]*cm.AdInfo
|
||
adAidm map[int64]struct{}
|
||
hasBanner bool
|
||
bs []*banner.Banner
|
||
version string
|
||
blackAidm map[int64]struct{}
|
||
adInfom map[int]*cm.AdInfo
|
||
follow *operate.Follow
|
||
autoPlay int
|
||
ip = metadata.String(c, metadata.RemoteIP)
|
||
info *locmdl.Info
|
||
)
|
||
//abtest================
|
||
// if mid > 0 && mid%20 == 19 {
|
||
// clean = 1
|
||
// } else {
|
||
// clean = 0
|
||
// }
|
||
clean = 0
|
||
if ab, ok := s.abtestCache[_feedgroups]; ok {
|
||
if ab.AbTestIn(buvid + _feedgroups) {
|
||
switch autoplayCard {
|
||
case 0, 1, 2, 3:
|
||
autoPlay = 1
|
||
default:
|
||
autoPlay = 2
|
||
}
|
||
} else {
|
||
autoPlay = 2
|
||
}
|
||
} else {
|
||
switch autoplayCard {
|
||
case 1, 3:
|
||
autoPlay = 1
|
||
default:
|
||
autoPlay = 2
|
||
}
|
||
}
|
||
autoPlayInfoc = fmt.Sprintf("%d|%d", autoPlay, autoplayCard)
|
||
if info, err = s.loc.Info(c, ip); err != nil {
|
||
log.Warn("s.loc.Info(%v) error(%v)", ip, err)
|
||
err = nil
|
||
}
|
||
//abtest================
|
||
group := s.group(mid, buvid)
|
||
g, ctx := errgroup.WithContext(c)
|
||
g.Go(func() error {
|
||
ris, userFeature, isRcmd, newUser, code = s.indexRcmd(ctx, plat, build, buvid, mid, group, loginEvent, 0, info, interest, network, style, -1, flush, autoPlayInfoc, now)
|
||
return nil
|
||
})
|
||
// 暂停实验
|
||
// if !((group == 18 || group == 19) && style == 3) {
|
||
g.Go(func() (err error) {
|
||
if adm, adAidm, err = s.indexAd(ctx, plat, build, buvid, mid, network, mobiApp, device, openEvent, info, now, adExtra, style); err != nil {
|
||
log.Error("%+v", err)
|
||
err = nil
|
||
}
|
||
return
|
||
})
|
||
// }
|
||
g.Go(func() (err error) {
|
||
if hasBanner, bs, version, err = s.indexBanner(ctx, plat, build, buvid, mid, loginEvent, bannerHash, network, mobiApp, device, "", adExtra); err != nil {
|
||
log.Error("%+v", err)
|
||
err = nil
|
||
}
|
||
return
|
||
})
|
||
g.Go(func() (err error) {
|
||
if blackAidm, err = s.BlackList(ctx, mid); err != nil {
|
||
log.Error("%+v", err)
|
||
err = nil
|
||
}
|
||
return
|
||
})
|
||
g.Go(func() (err error) {
|
||
if follow, err = s.SearchFollow(ctx, platform, mobiApp, device, buvid, build, mid); err != nil {
|
||
log.Error("%+v", err)
|
||
err = nil
|
||
}
|
||
return
|
||
})
|
||
if err = g.Wait(); err != nil {
|
||
return
|
||
}
|
||
ris, adInfom = s.mergeItem(c, mid, ris, adm, adAidm, hasBanner, blackAidm, plat, follow)
|
||
is, isRcmd, err = s.dealItem(c, mid, plat, build, buvid, ris, bs, version, isRcmd, network, mobiApp, device, openEvent, idx, pull, qn, now, adExtra, adInfom, fnver, fnval, autoPlay, follow)
|
||
return
|
||
}
|
||
|
||
// Dislike is.
|
||
func (s *Service) Dislike(c context.Context, mid, id int64, buvid, gt string, reasonID, cmreasonID, feedbackID, upperID, rid, tagID int64, adcb string, now time.Time) (err error) {
|
||
if gt == model.GotoAv {
|
||
s.blk.AddBlacklist(mid, id)
|
||
}
|
||
return s.rcmd.PubDislike(c, buvid, gt, id, mid, reasonID, cmreasonID, feedbackID, upperID, rid, tagID, adcb, now)
|
||
}
|
||
|
||
// DislikeCancel is.
|
||
func (s *Service) DislikeCancel(c context.Context, mid, id int64, buvid, gt string, reasonID, cmreasonID, feedbackID, upperID, rid, tagID int64, adcb string, now time.Time) (err error) {
|
||
if gt == model.GotoAv {
|
||
s.blk.DelBlacklist(mid, id)
|
||
}
|
||
return s.rcmd.PubDislikeCancel(c, buvid, gt, id, mid, reasonID, cmreasonID, feedbackID, upperID, rid, tagID, adcb, now)
|
||
}
|
||
|
||
func (s *Service) indexRcmd(c context.Context, plat int8, build int, buvid string, mid int64, group int, loginEvent, parentMode int, zone *locmdl.Info, interest, network string, style int, column cdm.ColumnStatus, flush int, autoPlay string, now time.Time) (is []*ai.Item, userFeature json.RawMessage, isRcmd, newUser bool, code int) {
|
||
count := s.indexCount(plat)
|
||
if buvid != "" || mid != 0 {
|
||
var (
|
||
err error
|
||
zoneID int64
|
||
)
|
||
if zone != nil {
|
||
zoneID = zone.ZoneID
|
||
}
|
||
if is, userFeature, code, newUser, err = s.rcmd.Recommend(c, plat, buvid, mid, build, loginEvent, parentMode, 0, zoneID, group, interest, network, style, column, flush, autoPlay, now); err != nil {
|
||
log.Error("%+v", err)
|
||
} else if len(is) != 0 {
|
||
isRcmd = true
|
||
}
|
||
var fromCache bool
|
||
if len(is) == 0 && mid != 0 && !ecode.ServiceUnavailable.Equal(err) {
|
||
if is, err = s.indexCache(c, mid, count); err != nil {
|
||
log.Error("%+v", err)
|
||
}
|
||
if len(is) != 0 {
|
||
s.pHit.Incr("index_cache")
|
||
} else {
|
||
s.pMiss.Incr("index_cache")
|
||
}
|
||
fromCache = true
|
||
}
|
||
if len(is) == 0 || (fromCache && len(is) < count) {
|
||
is = s.recommendCache(count)
|
||
}
|
||
} else {
|
||
is = s.recommendCache(count)
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *Service) indexAd(c context.Context, plat int8, build int, buvid string, mid int64, network, mobiApp, device, openEvent string, zone *locmdl.Info, now time.Time, adExtra string, style int) (adm map[int]*cm.AdInfo, adAidm map[int64]struct{}, err error) {
|
||
var advert *cm.Ad
|
||
resource := s.adResource(plat, build)
|
||
if resource == 0 {
|
||
return
|
||
}
|
||
// 兼容老的style逻辑，3为新单列，上报给商业产品的参数定义为：1 单列 2双列
|
||
if style == 3 {
|
||
style = 1
|
||
}
|
||
var country, province, city string
|
||
if zone != nil {
|
||
country = zone.Country
|
||
province = zone.Province
|
||
city = zone.City
|
||
}
|
||
if advert, err = s.ad.Ad(c, mid, build, buvid, []int64{resource}, country, province, city, network, mobiApp, device, openEvent, adExtra, style, now); err != nil {
|
||
return
|
||
}
|
||
if advert == nil || len(advert.AdsInfo) == 0 {
|
||
return
|
||
}
|
||
if adsInfo, ok := advert.AdsInfo[resource]; ok {
|
||
adm = make(map[int]*cm.AdInfo, len(adsInfo))
|
||
adAidm = make(map[int64]struct{}, len(adsInfo))
|
||
for source, info := range adsInfo {
|
||
if info == nil {
|
||
continue
|
||
}
|
||
var adInfo *cm.AdInfo
|
||
if info.AdInfo != nil {
|
||
adInfo = info.AdInfo
|
||
adInfo.RequestID = advert.RequestID
|
||
adInfo.Resource = resource
|
||
adInfo.Source = source
|
||
adInfo.IsAd = info.IsAd
|
||
adInfo.IsAdLoc = true
|
||
adInfo.CmMark = info.CmMark
|
||
adInfo.Index = info.Index
|
||
adInfo.CardIndex = info.CardIndex
|
||
adInfo.ClientIP = advert.ClientIP
|
||
if adInfo.CreativeID != 0 && adInfo.CardType == _cardAdAv {
|
||
adAidm[adInfo.CreativeContent.VideoID] = struct{}{}
|
||
}
|
||
} else {
|
||
adInfo = &cm.AdInfo{RequestID: advert.RequestID, Resource: resource, Source: source, IsAdLoc: true, IsAd: info.IsAd, CmMark: info.CmMark, Index: info.Index, CardIndex: info.CardIndex, ClientIP: advert.ClientIP}
|
||
}
|
||
adm[adInfo.CardIndex-1] = adInfo
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *Service) indexBanner(c context.Context, plat int8, build int, buvid string, mid int64, loginEvent int, hash, network, mobiApp, device, openEvent, adExtra string) (has bool, bs []*banner.Banner, version string, err error) {
|
||
const (
|
||
_androidBanBannerHash = 515009
|
||
_iphoneBanBannerHash = 6120
|
||
_ipadBanBannerHash = 6160
|
||
)
|
||
if (plat == model.PlatAndroid && build > _androidBanBannerHash) || (plat == model.PlatIPhone && build > _iphoneBanBannerHash) || (plat == model.PlatIPad && build > _ipadBanBannerHash) || loginEvent != 0 {
|
||
if bs, version, err = s.banners(c, plat, build, mid, buvid, network, mobiApp, device, openEvent, adExtra, ""); err != nil {
|
||
return
|
||
} else if loginEvent != 0 {
|
||
has = true
|
||
} else if version != "" {
|
||
has = hash != version
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *Service) mergeItem(c context.Context, mid int64, rs []*ai.Item, adm map[int]*cm.AdInfo, adAidm map[int64]struct{}, hasBanner bool, blackAids map[int64]struct{}, plat int8, follow *operate.Follow) (is []*ai.Item, adInfom map[int]*cm.AdInfo) {
|
||
if len(rs) == 0 {
|
||
return
|
||
}
|
||
const (
|
||
cardIndex = 7
|
||
cardIndexIPad = 17
|
||
cardOffset = 2
|
||
)
|
||
if hasBanner {
|
||
rs = append([]*ai.Item{&ai.Item{Goto: model.GotoBanner}}, rs...)
|
||
for index, ad := range adm {
|
||
if ((model.IsIPad(plat) && index <= cardIndexIPad) || index <= cardIndex) && (ad.CardType == _cardAdWeb || ad.CardType == _cardAdLarge) {
|
||
ad.CardIndex = ad.CardIndex + cardOffset
|
||
}
|
||
}
|
||
}
|
||
if follow != nil {
|
||
followPos := s.c.Feed.Index.FollowPosition
|
||
if followPos-1 >= 0 && followPos-1 <= len(rs) {
|
||
rs = append(rs[:followPos-1], append([]*ai.Item{&ai.Item{ID: follow.ID, Goto: model.GotoSearchSubscribe}}, rs[followPos-1:]...)...)
|
||
}
|
||
}
|
||
is = make([]*ai.Item, 0, len(rs)+len(adm))
|
||
adInfom = make(map[int]*cm.AdInfo, len(adm))
|
||
var existsBanner, existsAdWeb bool
|
||
for _, r := range rs {
|
||
for {
|
||
if ad, ok := adm[len(is)]; ok {
|
||
if ad.CreativeID != 0 {
|
||
var item *ai.Item
|
||
if ad.CardType == _cardAdAv {
|
||
item = &ai.Item{ID: ad.CreativeContent.VideoID, Goto: model.GotoAdAv, Ad: ad}
|
||
} else if ad.CardType == _cardAdWeb {
|
||
item = &ai.Item{Goto: model.GotoAdWeb, Ad: ad}
|
||
existsAdWeb = true
|
||
} else if ad.CardType == _cardAdWebS {
|
||
item = &ai.Item{Goto: model.GotoAdWebS, Ad: ad}
|
||
} else if ad.CardType == _cardAdLarge {
|
||
item = &ai.Item{Goto: model.GotoAdLarge, Ad: ad}
|
||
} else {
|
||
b, _ := json.Marshal(ad)
|
||
log.Error("ad---%s", b)
|
||
break
|
||
}
|
||
is = append(is, item)
|
||
continue
|
||
} else {
|
||
adInfom[len(is)] = ad
|
||
}
|
||
}
|
||
break
|
||
}
|
||
if r.Goto == model.GotoAv {
|
||
if _, ok := blackAids[r.ID]; ok {
|
||
continue
|
||
} else if _, ok := s.blackCache[r.ID]; ok {
|
||
continue
|
||
}
|
||
if _, ok := adAidm[r.ID]; ok {
|
||
continue
|
||
}
|
||
} else if r.Goto == model.GotoBanner {
|
||
if existsBanner {
|
||
continue
|
||
} else {
|
||
existsBanner = true
|
||
}
|
||
} else if r.Goto == model.GotoRank && existsAdWeb {
|
||
continue
|
||
} else if r.Goto == model.GotoLogin && mid != 0 {
|
||
continue
|
||
}
|
||
is = append(is, r)
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *Service) dealItem(c context.Context, mid int64, plat int8, build int, buvid string, rs []*ai.Item, bs []*banner.Banner, version string, isRcmd bool, network, mobiApp, device, openEvent string, idx int64, pull bool, qn int, now time.Time, adExtra string, adInfom map[int]*cm.AdInfo, fnver, fnval, autoPlay int, follow *operate.Follow) (is []*feed.Item, isAI bool, err error) {
|
||
if len(rs) == 0 {
|
||
is = _emptyItem
|
||
return
|
||
}
|
||
var (
|
||
aids, tids, roomIDs, sids, metaIDs, shopIDs, audioIDs []int64
|
||
upIDs, avUpIDs, rmUpIDs, mtUpIDs []int64
|
||
seasonIDs []int32
|
||
ranks []*rank.Rank
|
||
am map[int64]*archive.ArchiveWithPlayer
|
||
tagm map[int64]*bustag.Tag
|
||
follows map[int64]bool
|
||
rm map[int64]*live.Room
|
||
sm map[int64]*bangumi.Season
|
||
hasBangumiRcmd bool
|
||
update *bangumi.Update
|
||
atm map[int64]*article.Meta
|
||
scm map[int64]*show.Shopping
|
||
aum map[int64]*audio.Audio
|
||
hasBanner bool
|
||
card map[int64]*account.Card
|
||
upStatm map[int64]*relation.Stat
|
||
arcOK bool
|
||
seasonCards map[int32]*episodegrpc.EpisodeCardsProto
|
||
)
|
||
isAI = isRcmd
|
||
convergem := map[int64]*operate.Converge{}
|
||
downloadm := map[int64]*operate.Download{}
|
||
liveUpm := map[int64][]*live.Card{}
|
||
followm := map[int64]*operate.Follow{}
|
||
for _, r := range rs {
|
||
switch r.Goto {
|
||
case model.GotoAv, model.GotoAdAv, model.GotoPlayer, model.GotoUpRcmdAv:
|
||
if r.ID != 0 {
|
||
aids = append(aids, r.ID)
|
||
}
|
||
if r.Tid != 0 {
|
||
tids = append(tids, r.Tid)
|
||
}
|
||
case model.GotoLive, model.GotoPlayerLive:
|
||
if r.ID != 0 {
|
||
roomIDs = append(roomIDs, r.ID)
|
||
}
|
||
case model.GotoBangumi:
|
||
if r.ID != 0 {
|
||
sids = append(sids, r.ID)
|
||
}
|
||
case model.GotoPGC:
|
||
if r.ID != 0 {
|
||
seasonIDs = append(seasonIDs, int32(r.ID))
|
||
}
|
||
case model.GotoRank:
|
||
card, aid := s.RankCard(model.PlatIPhone)
|
||
ranks = card
|
||
aids = append(aids, aid...)
|
||
case model.GotoBangumiRcmd:
|
||
hasBangumiRcmd = true
|
||
case model.GotoBanner:
|
||
hasBanner = true
|
||
case model.GotoConverge:
|
||
if card, ok := s.convergeCache[r.ID]; ok {
|
||
for _, item := range card.Items {
|
||
switch item.Goto {
|
||
case model.GotoAv:
|
||
if item.Pid != 0 {
|
||
aids = append(aids, item.Pid)
|
||
}
|
||
case model.GotoLive:
|
||
if item.Pid != 0 {
|
||
roomIDs = append(roomIDs, item.Pid)
|
||
}
|
||
case model.GotoArticle:
|
||
if item.Pid != 0 {
|
||
metaIDs = append(metaIDs, item.Pid)
|
||
}
|
||
}
|
||
}
|
||
convergem[r.ID] = card
|
||
}
|
||
case model.GotoGameDownloadS:
|
||
if card, ok := s.downloadCache[r.ID]; ok {
|
||
downloadm[r.ID] = card
|
||
}
|
||
case model.GotoArticleS:
|
||
if r.ID != 0 {
|
||
metaIDs = append(metaIDs, r.ID)
|
||
}
|
||
case model.GotoShoppingS:
|
||
if r.ID != 0 {
|
||
shopIDs = append(shopIDs, r.ID)
|
||
}
|
||
case model.GotoAudio:
|
||
if r.ID != 0 {
|
||
audioIDs = append(audioIDs, r.ID)
|
||
}
|
||
case model.GotoLiveUpRcmd:
|
||
if r.ID != 0 {
|
||
if cs, ok := s.liveCardCache[r.ID]; ok {
|
||
for _, c := range cs {
|
||
upIDs = append(upIDs, c.UID)
|
||
}
|
||
}
|
||
}
|
||
case model.GotoSubscribe:
|
||
if r.ID != 0 {
|
||
if card, ok := s.followCache[r.ID]; ok {
|
||
for _, item := range card.Items {
|
||
switch item.Goto {
|
||
case cdm.GotoMid:
|
||
if item.Pid != 0 {
|
||
upIDs = append(upIDs, item.Pid)
|
||
}
|
||
case cdm.GotoTag:
|
||
if item.Pid != 0 {
|
||
tids = append(tids, item.Pid)
|
||
}
|
||
}
|
||
}
|
||
followm[r.ID] = card
|
||
}
|
||
}
|
||
case model.GotoChannelRcmd:
|
||
if r.ID != 0 {
|
||
if card, ok := s.followCache[r.ID]; ok {
|
||
if card.Pid != 0 {
|
||
aids = append(aids, card.Pid)
|
||
}
|
||
if card.Tid != 0 {
|
||
tids = append(tids, card.Tid)
|
||
}
|
||
followm[r.ID] = card
|
||
}
|
||
}
|
||
case model.GotoSearchSubscribe:
|
||
if follow != nil {
|
||
followm[follow.ID] = follow
|
||
for _, item := range follow.Items {
|
||
upIDs = append(upIDs, item.Pid)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
g, ctx := errgroup.WithContext(c)
|
||
if len(aids) != 0 {
|
||
g.Go(func() (err error) {
|
||
if am, err = s.ArchivesWithPlayer(ctx, aids, qn, mobiApp, fnver, fnval, 0, build); err != nil {
|
||
return
|
||
}
|
||
arcOK = true
|
||
for _, a := range am {
|
||
avUpIDs = append(avUpIDs, a.Author.Mid)
|
||
}
|
||
return
|
||
})
|
||
}
|
||
if len(tids) != 0 {
|
||
g.Go(func() (err error) {
|
||
if tagm, err = s.tg.InfoByIDs(ctx, mid, tids); err != nil {
|
||
log.Error("%+v", err)
|
||
err = nil
|
||
}
|
||
return
|
||
})
|
||
}
|
||
if len(roomIDs) != 0 {
|
||
g.Go(func() (err error) {
|
||
if rm, err = s.lv.AppMRoom(ctx, roomIDs); err != nil {
|
||
log.Error("%+v", err)
|
||
err = nil
|
||
}
|
||
for _, r := range rm {
|
||
rmUpIDs = append(rmUpIDs, r.UID)
|
||
}
|
||
return
|
||
})
|
||
}
|
||
if len(sids) != 0 {
|
||
g.Go(func() (err error) {
|
||
if sm, err = s.bgm.Seasons(ctx, sids, now); err != nil {
|
||
log.Error("%+v", err)
|
||
err = nil
|
||
}
|
||
return
|
||
})
|
||
}
|
||
if len(seasonIDs) != 0 {
|
||
g.Go(func() (err error) {
|
||
if seasonCards, err = s.bgm.CardsInfoReply(ctx, seasonIDs); err != nil {
|
||
log.Error("%+v", err)
|
||
err = nil
|
||
}
|
||
return
|
||
})
|
||
}
|
||
// TODO DEL
|
||
// if hasBangumiRcmd && mid != 0 {
|
||
if hasBangumiRcmd {
|
||
g.Go(func() (err error) {
|
||
if update, err = s.bgm.Updates(ctx, mid, now); err != nil {
|
||
log.Error("%+v", err)
|
||
err = nil
|
||
}
|
||
return
|
||
})
|
||
}
|
||
if hasBanner && version == "" {
|
||
g.Go(func() (err error) {
|
||
if bs, version, err = s.banners(ctx, plat, build, mid, buvid, network, mobiApp, device, openEvent, adExtra, ""); err != nil {
|
||
log.Error("%+v", err)
|
||
err = nil
|
||
}
|
||
return
|
||
})
|
||
}
|
||
if len(metaIDs) != 0 {
|
||
g.Go(func() (err error) {
|
||
if atm, err = s.art.Articles(ctx, metaIDs); err != nil {
|
||
log.Error("%+v", err)
|
||
err = nil
|
||
}
|
||
for _, at := range atm {
|
||
if at.Author != nil {
|
||
mtUpIDs = append(mtUpIDs, at.Author.Mid)
|
||
}
|
||
}
|
||
return
|
||
})
|
||
}
|
||
if len(shopIDs) != 0 {
|
||
g.Go(func() (err error) {
|
||
if scm, err = s.show.Card(ctx, shopIDs); err != nil {
|
||
log.Error("%+v", err)
|
||
err = nil
|
||
}
|
||
return
|
||
})
|
||
}
|
||
if len(audioIDs) != 0 {
|
||
g.Go(func() (err error) {
|
||
if aum, err = s.audio.Audios(ctx, audioIDs); err != nil {
|
||
log.Error("%+v", err)
|
||
err = nil
|
||
}
|
||
return
|
||
})
|
||
}
|
||
if err = g.Wait(); err != nil {
|
||
log.Error("%+v", err)
|
||
if isRcmd {
|
||
count := s.indexCount(plat)
|
||
rs = s.recommendCache(count)
|
||
}
|
||
} else {
|
||
upIDs = append(upIDs, avUpIDs...)
|
||
upIDs = append(upIDs, rmUpIDs...)
|
||
upIDs = append(upIDs, mtUpIDs...)
|
||
g, ctx = errgroup.WithContext(c)
|
||
if len(upIDs) != 0 {
|
||
g.Go(func() (err error) {
|
||
if card, err = s.acc.Cards3(ctx, upIDs); err != nil {
|
||
log.Error("%+v", err)
|
||
err = nil
|
||
}
|
||
return
|
||
})
|
||
g.Go(func() (err error) {
|
||
if upStatm, err = s.rel.Stats(ctx, upIDs); err != nil {
|
||
log.Error("%+v", err)
|
||
err = nil
|
||
}
|
||
return
|
||
})
|
||
if mid != 0 {
|
||
g.Go(func() error {
|
||
follows = s.acc.Relations3(ctx, upIDs, mid)
|
||
return nil
|
||
})
|
||
}
|
||
}
|
||
g.Wait()
|
||
}
|
||
isAI = isAI && arcOK
|
||
// init feed items
|
||
is = make([]*feed.Item, 0, len(rs))
|
||
var (
|
||
smallCardCnt int
|
||
middleCardCnt int
|
||
)
|
||
ip := metadata.String(c, metadata.RemoteIP)
|
||
adm := map[int]*feed.Item{}
|
||
isIpad := plat == model.PlatIPad
|
||
for _, r := range rs {
|
||
il := len(is)
|
||
i := &feed.Item{AI: r}
|
||
i.FromRcmd(r)
|
||
switch r.Goto {
|
||
case model.GotoAv, model.GotoUpRcmdAv:
|
||
a, ok := am[r.ID]
|
||
if !ok && !arcOK {
|
||
a = &archive.ArchiveWithPlayer{Archive3: r.Archive}
|
||
}
|
||
isOsea := model.IsOverseas(plat)
|
||
if a != nil && a.Archive3 != nil && a.IsNormal() && (!isOsea || (isOsea && a.AttrVal(archive.AttrBitOverseaLock) == 0)) {
|
||
i.FromPlayerAv(a)
|
||
if arcOK {
|
||
if info, ok := tagm[r.Tid]; ok {
|
||
i.Tag = &feed.Tag{TagID: info.ID, TagName: info.Name, IsAtten: info.IsAtten, Count: &feed.TagCount{Atten: info.Count.Atten}}
|
||
}
|
||
} else if r.Tag != nil {
|
||
i.Tag = &feed.Tag{TagID: r.Tag.ID, TagName: r.Tag.Name}
|
||
}
|
||
i.FromDislikeReason(plat, build)
|
||
i.FromRcmdReason(r.RcmdReason)
|
||
if follows[i.Mid] {
|
||
i.IsAtten = 1
|
||
}
|
||
if card, ok := card[i.Mid]; ok {
|
||
if card.Official.Role != 0 {
|
||
i.Official = &feed.OfficialInfo{Role: card.Official.Role, Title: card.Official.Title, Desc: card.Official.Desc}
|
||
}
|
||
}
|
||
// for GotoUpRcmdAv
|
||
i.Goto = r.Goto
|
||
if i.Goto == model.GotoUpRcmdAv {
|
||
// TODO 等待开启
|
||
// percent := i.Like / (i.Like + i.Dislike) * 100
|
||
// if percent != 0 {
|
||
// i.Desc = strconv.Itoa(percent) + "%的人推荐"
|
||
// }
|
||
i.Desc = ""
|
||
}
|
||
is = append(is, i)
|
||
smallCardCnt++
|
||
}
|
||
case model.GotoLive:
|
||
if r, ok := rm[r.ID]; ok {
|
||
i.FromLive(r)
|
||
if card, ok := card[i.Mid]; ok {
|
||
if card.Official.Role != 0 {
|
||
i.Official = &feed.OfficialInfo{Role: card.Official.Role, Title: card.Official.Title, Desc: card.Official.Desc}
|
||
}
|
||
}
|
||
if stat, ok := upStatm[i.Mid]; ok {
|
||
i.Fans = stat.Follower
|
||
}
|
||
if follows[i.Mid] {
|
||
i.IsAtten = 1
|
||
}
|
||
if i.Goto != "" {
|
||
is = append(is, i)
|
||
smallCardCnt++
|
||
}
|
||
}
|
||
case model.GotoBangumi:
|
||
if s, ok := sm[r.ID]; ok {
|
||
i.FromSeason(s)
|
||
is = append(is, i)
|
||
smallCardCnt++
|
||
}
|
||
case model.GotoPGC:
|
||
if s, ok := seasonCards[int32(r.ID)]; ok {
|
||
i.FromPGCSeason(s)
|
||
is = append(is, i)
|
||
smallCardCnt++
|
||
}
|
||
case model.GotoLogin:
|
||
i.FromLogin()
|
||
is = append(is, i)
|
||
smallCardCnt++
|
||
case model.GotoAdAv:
|
||
if r.Ad != nil {
|
||
if a, ok := am[r.ID]; ok && model.AdAvIsNormal(a) {
|
||
i.FromAdAv(r.Ad, a)
|
||
if follows[i.Mid] {
|
||
i.IsAtten = 1
|
||
}
|
||
if card, ok := card[i.Mid]; ok {
|
||
if card.Official.Role != 0 {
|
||
i.Official = &feed.OfficialInfo{Role: card.Official.Role, Title: card.Official.Title, Desc: card.Official.Desc}
|
||
}
|
||
}
|
||
i.ClientIP = ip
|
||
adm[i.CardIndex-1] = i
|
||
}
|
||
}
|
||
case model.GotoAdWebS:
|
||
if r.Ad != nil {
|
||
i.FromAdWebS(r.Ad)
|
||
i.ClientIP = ip
|
||
adm[i.CardIndex-1] = i
|
||
}
|
||
case model.GotoAdWeb:
|
||
if r.Ad != nil {
|
||
i.FromAdWeb(r.Ad)
|
||
i.ClientIP = ip
|
||
adm[i.CardIndex-1] = i
|
||
}
|
||
case model.GotoAdLarge:
|
||
if r.Ad != nil {
|
||
i.FromAdLarge(r.Ad)
|
||
i.ClientIP = ip
|
||
adm[i.CardIndex-1] = i
|
||
}
|
||
case model.GotoSpecial:
|
||
if sc, ok := s.specialCache[r.ID]; ok {
|
||
i.FromSpecial(sc.ID, sc.Title, sc.Cover, sc.Desc, sc.ReValue, sc.ReType, sc.Badge, sc.Size)
|
||
}
|
||
if i.Goto != "" {
|
||
if !isIpad {
|
||
if smallCardCnt%2 != 0 {
|
||
is = swapTwoItem(is, i)
|
||
} else {
|
||
is = append(is, i)
|
||
}
|
||
} else {
|
||
if (smallCardCnt+middleCardCnt*2)%2 != 0 {
|
||
is = swapTwoItem(is, i)
|
||
} else {
|
||
is = append(is, i)
|
||
}
|
||
middleCardCnt++
|
||
}
|
||
}
|
||
case model.GotoSpecialS:
|
||
if sc, ok := s.specialCache[r.ID]; ok {
|
||
i.FromSpecialS(sc.ID, sc.Title, sc.Cover, sc.SingleCover, sc.Desc, sc.ReValue, sc.ReType, sc.Badge)
|
||
}
|
||
if i.Goto != "" {
|
||
if !isIpad {
|
||
is = append(is, i)
|
||
smallCardCnt++
|
||
}
|
||
}
|
||
case model.GotoRank:
|
||
i.FromRank(ranks, am)
|
||
if i.Goto != "" {
|
||
if !isIpad {
|
||
if smallCardCnt%2 != 0 {
|
||
is = swapTwoItem(is, i)
|
||
} else {
|
||
is = append(is, i)
|
||
}
|
||
} else {
|
||
if (smallCardCnt+middleCardCnt*2)%2 != 0 {
|
||
is = swapTwoItem(is, i)
|
||
} else {
|
||
is = append(is, i)
|
||
}
|
||
middleCardCnt++
|
||
}
|
||
}
|
||
case model.GotoBangumiRcmd:
|
||
if mid != 0 && update != nil && update.Updates != 0 {
|
||
i.FromBangumiRcmd(update)
|
||
if !isIpad {
|
||
if smallCardCnt%2 != 0 {
|
||
is = swapTwoItem(is, i)
|
||
} else {
|
||
is = append(is, i)
|
||
}
|
||
} else {
|
||
is = append(is, i)
|
||
smallCardCnt++
|
||
}
|
||
}
|
||
case model.GotoBanner:
|
||
if len(bs) != 0 {
|
||
i.FromBanner(bs, version)
|
||
if !isIpad {
|
||
if smallCardCnt%2 != 0 {
|
||
is = swapTwoItem(is, i)
|
||
} else {
|
||
is = append(is, i)
|
||
}
|
||
} else {
|
||
switch (smallCardCnt + middleCardCnt*2) % 4 {
|
||
case 0:
|
||
is = append(is, i)
|
||
case 1:
|
||
is = swapTwoItem(is, i)
|
||
case 2:
|
||
switch is[len(is)-1].Goto {
|
||
case model.GotoRank, model.GotoAdWeb, model.GotoAdLarge:
|
||
is = swapTwoItem(is, i)
|
||
default:
|
||
is = swapThreeItem(is, i)
|
||
}
|
||
case 3:
|
||
is = swapThreeItem(is, i)
|
||
}
|
||
}
|
||
}
|
||
case model.GotoConverge:
|
||
if cc, ok := convergem[r.ID]; ok {
|
||
i.FromConverge(cc, am, rm, atm)
|
||
if i.Goto != "" {
|
||
if !isIpad {
|
||
if smallCardCnt%2 != 0 {
|
||
is = swapTwoItem(is, i)
|
||
} else {
|
||
is = append(is, i)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
case model.GotoGameDownloadS:
|
||
if gd, ok := downloadm[r.ID]; ok {
|
||
i.FromGameDownloadS(gd, plat, build)
|
||
if i.Goto != "" {
|
||
if !isIpad {
|
||
is = append(is, i)
|
||
smallCardCnt++
|
||
}
|
||
}
|
||
}
|
||
case model.GotoArticleS:
|
||
if m, ok := atm[r.ID]; ok {
|
||
i.FromArticleS(m)
|
||
if card, ok := card[i.Mid]; ok {
|
||
if card.Official.Role != 0 {
|
||
i.Official = &feed.OfficialInfo{Role: card.Official.Role, Title: card.Official.Title, Desc: card.Official.Desc}
|
||
}
|
||
}
|
||
if i.Goto != "" {
|
||
if !isIpad {
|
||
is = append(is, i)
|
||
smallCardCnt++
|
||
}
|
||
}
|
||
}
|
||
case model.GotoShoppingS:
|
||
if c, ok := scm[r.ID]; ok {
|
||
i.FromShoppingS(c)
|
||
if i.Goto != "" {
|
||
if !isIpad {
|
||
is = append(is, i)
|
||
smallCardCnt++
|
||
}
|
||
}
|
||
}
|
||
case model.GotoAudio:
|
||
if au, ok := aum[r.ID]; ok {
|
||
i.FromAudio(au)
|
||
is = append(is, i)
|
||
smallCardCnt++
|
||
}
|
||
case model.GotoPlayer:
|
||
if a, ok := am[r.ID]; ok {
|
||
i.FromPlayer(a)
|
||
if i.Goto != "" {
|
||
if info, ok := tagm[r.Tid]; ok {
|
||
i.Tag = &feed.Tag{TagID: info.ID, TagName: info.Name, IsAtten: info.IsAtten, Count: &feed.TagCount{Atten: info.Count.Atten}}
|
||
}
|
||
if follows[i.Mid] {
|
||
i.IsAtten = 1
|
||
}
|
||
if card, ok := card[i.Mid]; ok {
|
||
if card.Official.Role != 0 {
|
||
i.Official = &feed.OfficialInfo{Role: card.Official.Role, Title: card.Official.Title, Desc: card.Official.Desc}
|
||
}
|
||
}
|
||
i.FromDislikeReason(plat, build)
|
||
if !isIpad {
|
||
if smallCardCnt%2 != 0 {
|
||
is = swapTwoItem(is, i)
|
||
} else {
|
||
is = append(is, i)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
case model.GotoPlayerLive:
|
||
if r, ok := rm[r.ID]; ok {
|
||
i.FromPlayerLive(r)
|
||
if i.Goto != "" {
|
||
if follows[i.Mid] {
|
||
i.IsAtten = 1
|
||
}
|
||
if card, ok := card[i.Mid]; ok {
|
||
if card.Official.Role != 0 {
|
||
i.Official = &feed.OfficialInfo{Role: card.Official.Role, Title: card.Official.Title, Desc: card.Official.Desc}
|
||
}
|
||
}
|
||
if stat, ok := upStatm[i.Mid]; ok {
|
||
i.Fans = stat.Follower
|
||
}
|
||
if !isIpad {
|
||
if smallCardCnt%2 != 0 {
|
||
is = swapTwoItem(is, i)
|
||
} else {
|
||
is = append(is, i)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
case model.GotoSubscribe, model.GotoSearchSubscribe:
|
||
if c, ok := followm[r.ID]; ok {
|
||
if !isIpad {
|
||
i.FromSubscribe(c, card, follows, upStatm, tagm)
|
||
if i.Goto != "" {
|
||
if smallCardCnt%2 != 0 {
|
||
is = swapTwoItem(is, i)
|
||
} else {
|
||
is = append(is, i)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
case model.GotoChannelRcmd:
|
||
if c, ok := followm[r.ID]; ok {
|
||
if !isIpad {
|
||
i.FromChannelRcmd(c, am, tagm)
|
||
if i.Goto != "" {
|
||
if !isIpad {
|
||
is = append(is, i)
|
||
smallCardCnt++
|
||
}
|
||
}
|
||
}
|
||
}
|
||
case model.GotoLiveUpRcmd:
|
||
if c, ok := liveUpm[r.ID]; ok {
|
||
if !isIpad {
|
||
i.FromLiveUpRcmd(r.ID, c, card)
|
||
if i.Goto != "" {
|
||
if smallCardCnt%2 != 0 {
|
||
is = swapTwoItem(is, i)
|
||
} else {
|
||
is = append(is, i)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
default:
|
||
log.Warn("unexpected goto(%s) %+v", r.Goto, r)
|
||
continue
|
||
}
|
||
if ad, ok := adm[il]; ok {
|
||
switch ad.Goto {
|
||
case model.GotoAdAv, model.GotoAdWebS:
|
||
is = append(is, ad)
|
||
smallCardCnt++
|
||
case model.GotoAdWeb, model.GotoAdLarge:
|
||
if !isIpad {
|
||
if smallCardCnt%2 != 0 {
|
||
is = swapTwoItem(is, ad)
|
||
} else {
|
||
is = append(is, ad)
|
||
}
|
||
} else {
|
||
if (smallCardCnt+middleCardCnt*2)%2 != 0 {
|
||
is = swapTwoItem(is, ad)
|
||
} else {
|
||
is = append(is, ad)
|
||
}
|
||
middleCardCnt++
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if !isIpad {
|
||
is = is[:len(is)-smallCardCnt%2]
|
||
} else {
|
||
switch (smallCardCnt + middleCardCnt*2) % 4 {
|
||
case 1:
|
||
is = is[:len(is)-1]
|
||
case 2:
|
||
if isMiddleCard(is[len(is)-1].Goto) {
|
||
is = is[:len(is)-1]
|
||
} else {
|
||
is = is[:len(is)-2]
|
||
}
|
||
case 3:
|
||
if isMiddleCard(is[len(is)-1].Goto) {
|
||
is = is[:len(is)-2]
|
||
} else {
|
||
is = is[:len(is)-3]
|
||
}
|
||
}
|
||
}
|
||
rl := len(is)
|
||
if rl == 0 {
|
||
is = _emptyItem
|
||
return
|
||
}
|
||
if idx == 0 {
|
||
idx = now.Unix()
|
||
}
|
||
for i, r := range is {
|
||
if pull {
|
||
r.Idx = idx + int64(rl-i)
|
||
} else {
|
||
r.Idx = idx - int64(i+1)
|
||
}
|
||
if ad, ok := adInfom[i]; ok {
|
||
r.SrcID = ad.Source
|
||
r.RequestID = ad.RequestID
|
||
r.IsAdLoc = ad.IsAdLoc
|
||
r.IsAd = ad.IsAd
|
||
r.CmMark = ad.CmMark
|
||
r.AdIndex = ad.Index
|
||
r.ClientIP = ip
|
||
r.CardIndex = i + 1
|
||
} else if r.IsAd {
|
||
r.CardIndex = i + 1
|
||
}
|
||
if i == 0 {
|
||
r.AutoplayCard = autoPlay
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *Service) adResource(plat int8, build int) (resource int64) {
|
||
const (
|
||
_androidBanAd = 500001
|
||
)
|
||
if plat == model.PlatIPhone || plat == model.PlatIPhoneB || (plat == model.PlatAndroid && build >= _androidBanAd) || plat == model.PlatIPad {
|
||
resource = s.cmResourceMap[plat]
|
||
}
|
||
return
|
||
}
|
||
|
||
func swapTwoItem(rs []*feed.Item, i *feed.Item) (is []*feed.Item) {
|
||
rs[len(rs)-1].Idx, i.Idx = i.Idx, rs[len(rs)-1].Idx
|
||
is = append(rs, rs[len(rs)-1])
|
||
is[len(is)-2] = i
|
||
return
|
||
}
|
||
|
||
func swapThreeItem(rs []*feed.Item, i *feed.Item) (is []*feed.Item) {
|
||
rs[len(rs)-1].Idx, i.Idx = i.Idx, rs[len(rs)-1].Idx
|
||
rs[len(rs)-2].Idx, rs[len(is)-1].Idx = rs[len(rs)-1].Idx, rs[len(rs)-2].Idx
|
||
is = append(rs, rs[len(rs)-1])
|
||
is[len(is)-2] = i
|
||
is[len(is)-3], is[len(is)-2] = is[len(is)-2], is[len(is)-3]
|
||
return
|
||
}
|
||
|
||
func isMiddleCard(gt string) bool {
|
||
return gt == model.GotoRank || gt == model.GotoAdWeb || gt == model.GotoPlayer ||
|
||
gt == model.GotoPlayerLive || gt == model.GotoConverge || gt == model.GotoSpecial || gt == model.GotoAdLarge || gt == model.GotoLiveUpRcmd
|
||
}
|
||
|
||
func (s *Service) indexCount(plat int8) (count int) {
|
||
if plat == model.PlatIPad {
|
||
count = s.c.Feed.Index.IPadCount
|
||
} else {
|
||
count = s.c.Feed.Index.Count
|
||
}
|
||
return
|
||
}
|