667 lines
17 KiB
Go
667 lines
17 KiB
Go
package channel
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strconv"
|
|
"time"
|
|
|
|
cdm "go-common/app/interface/main/app-card/model"
|
|
"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/live"
|
|
"go-common/app/interface/main/app-card/model/card/operate"
|
|
shopping "go-common/app/interface/main/app-card/model/card/show"
|
|
"go-common/app/interface/main/app-channel/model"
|
|
"go-common/app/interface/main/app-channel/model/activity"
|
|
"go-common/app/interface/main/app-channel/model/card"
|
|
"go-common/app/interface/main/app-channel/model/feed"
|
|
bustag "go-common/app/interface/main/tag/model"
|
|
tag "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"
|
|
relation "go-common/app/service/main/relation/model"
|
|
episodegrpc "go-common/app/service/openplatform/pgc-season/api/grpc/episode/v1"
|
|
"go-common/library/log"
|
|
"go-common/library/sync/errgroup"
|
|
)
|
|
|
|
var (
|
|
_emptyItem = []*feed.Item{}
|
|
)
|
|
|
|
// Index channel index
|
|
func (s *Service) Index(c context.Context, mid, channelID, idx int64, plat int8, mobiApp, device, buvid, channelName string, build, loginEvent, displayID, qn, fnver, fnval int, pull bool, now time.Time) (res *feed.Show, err error) {
|
|
var (
|
|
aids []int64
|
|
requestCnt = 10
|
|
isIpad = plat == model.PlatIPad
|
|
topic *feed.Item
|
|
item []*feed.Item
|
|
channelResource *tag.ChannelResource
|
|
topChannel, isRec int
|
|
)
|
|
if isIpad {
|
|
requestCnt = 20
|
|
}
|
|
if channelID > 0 {
|
|
channelName = ""
|
|
}
|
|
g, ctx := errgroup.WithContext(c)
|
|
g.Go(func() (err error) {
|
|
if channelResource, err = s.tg.Resources(ctx, plat, channelID, mid, channelName, buvid, build, requestCnt, loginEvent, displayID); err != nil {
|
|
log.Error("index s.tg.Resources error(%v)", err)
|
|
return
|
|
}
|
|
if channelResource != nil {
|
|
aids = channelResource.Oids
|
|
if channelResource.Failover {
|
|
isRec = 0
|
|
} else {
|
|
isRec = 1
|
|
}
|
|
if channelResource.IsChannel {
|
|
topChannel = 1
|
|
} else {
|
|
topChannel = 0
|
|
}
|
|
}
|
|
return
|
|
})
|
|
g.Go(func() (err error) {
|
|
var t *tag.ChannelDetail
|
|
if t, err = s.tg.ChannelDetail(c, mid, channelID, channelName, s.isOverseas(plat)); err != nil {
|
|
log.Error("s.tag.ChannelDetail(%d, %d, %s) error(%v)", mid, channelID, channelName, err)
|
|
return
|
|
}
|
|
channelID = t.Tag.ID
|
|
channelName = t.Tag.Name
|
|
return
|
|
})
|
|
if err = g.Wait(); err != nil {
|
|
if (mobiApp == "iphone" && build > 8050) || (mobiApp == "android" && build > 5305000) {
|
|
log.Error("%+v", err)
|
|
res = &feed.Show{
|
|
Feed: _emptyItem,
|
|
}
|
|
return
|
|
}
|
|
err = nil
|
|
}
|
|
if loginEvent == 1 || loginEvent == 2 {
|
|
if cards, ok := s.cardCache[channelID]; ok {
|
|
topic, item, err = s.dealItem(c, mid, idx, channelID, plat, build, qn, fnver, fnval, mobiApp, buvid, pull, now, cards, aids)
|
|
} else {
|
|
item, err = s.feedItem(c, plat, aids, mobiApp, qn, fnver, fnval, build)
|
|
}
|
|
} else {
|
|
item, err = s.feedItem(c, plat, aids, mobiApp, qn, fnver, fnval, build)
|
|
}
|
|
res = &feed.Show{
|
|
Topic: topic,
|
|
Feed: item,
|
|
}
|
|
//infoc
|
|
infoc := &feedInfoc{
|
|
mobiApp: mobiApp,
|
|
device: device,
|
|
build: strconv.Itoa(build),
|
|
now: now.Format("2006-01-02 15:04:05"),
|
|
pull: strconv.FormatBool(pull),
|
|
loginEvent: strconv.Itoa(loginEvent),
|
|
channelID: strconv.FormatInt(channelID, 10),
|
|
channelName: channelName,
|
|
mid: strconv.FormatInt(mid, 10),
|
|
buvid: buvid,
|
|
displayID: strconv.Itoa(displayID),
|
|
feed: res,
|
|
isRec: strconv.Itoa(isRec),
|
|
topChannel: strconv.Itoa(topChannel),
|
|
ServerCode: "0",
|
|
}
|
|
s.infoc(infoc)
|
|
return
|
|
}
|
|
|
|
// dealItem
|
|
func (s *Service) dealItem(c context.Context, mid, idx, channelID int64, plat int8, build, qn, fnver, fnval int, mobiApp, buvid string, pull bool, now time.Time, cards []*card.Card, listAID []int64) (top *feed.Item, is []*feed.Item, err error) {
|
|
if len(cards) == 0 {
|
|
is = _emptyItem
|
|
return
|
|
}
|
|
var (
|
|
aids, sids, roomIDs, metaIDs, shopIDs, audioIDs []int64
|
|
upIDs, tids, avUpIDs, rmUpIDs, mtUpIDs []int64
|
|
seasonIDs []int32
|
|
am map[int64]*archive.ArchiveWithPlayer
|
|
tagm map[int64]*bustag.Tag
|
|
follows map[int64]bool
|
|
rm map[int64]*live.Room
|
|
sm map[int64]*bangumi.Season
|
|
actIDs, topIDs []int64
|
|
actm, topm map[int64]*activity.Activity
|
|
atm map[int64]*article.Meta
|
|
scm map[int64]*shopping.Shopping
|
|
aum map[int64]*audio.Audio
|
|
infocard map[int64]*account.Card
|
|
upStatm map[int64]*relation.Stat
|
|
cardAids = map[int64]struct{}{}
|
|
channelCards []*card.Card
|
|
seasonCards map[int32]*episodegrpc.EpisodeCardsProto
|
|
// key
|
|
_initCardPlatKey = "card_platkey_%d_%d"
|
|
_fTypeOperation = "operation"
|
|
_fTypeRecommend = "recommend"
|
|
)
|
|
convergem := map[int64]*operate.Converge{}
|
|
downloadm := map[int64]*operate.Download{}
|
|
liveUpm := map[int64][]*live.Card{}
|
|
followm := map[int64]*operate.Follow{}
|
|
LOOP:
|
|
for _, c := range cards {
|
|
key := fmt.Sprintf(_initCardPlatKey, plat, c.ID)
|
|
if cardPlat, ok := s.cardPlatCache[key]; ok {
|
|
for _, l := range cardPlat {
|
|
if model.InvalidBuild(build, l.Build, l.Condition) {
|
|
continue LOOP
|
|
}
|
|
}
|
|
} else {
|
|
continue LOOP
|
|
}
|
|
channelCards = append(channelCards, c)
|
|
switch c.Type {
|
|
case model.GotoAv, model.GotoPlayer, model.GotoUpRcmdAv:
|
|
if c.Value != 0 {
|
|
aids = append(aids, c.Value)
|
|
cardAids[c.Value] = struct{}{}
|
|
}
|
|
case model.GotoLive, model.GotoPlayerLive:
|
|
if c.Value != 0 {
|
|
roomIDs = append(roomIDs, c.Value)
|
|
}
|
|
case model.GotoBangumi:
|
|
if c.Value != 0 {
|
|
sids = append(sids, c.Value)
|
|
}
|
|
case model.GotoPGC:
|
|
if c.Value != 0 {
|
|
seasonIDs = append(seasonIDs, int32(c.Value))
|
|
}
|
|
case model.GotoActivity:
|
|
if c.Value != 0 {
|
|
actIDs = append(actIDs, c.Value)
|
|
}
|
|
case model.GotoTopic:
|
|
if c.Value != 0 {
|
|
topIDs = append(topIDs, c.Value)
|
|
}
|
|
case model.GotoConverge:
|
|
if card, ok := s.convergeCardCache[c.Value]; 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[c.Value] = card
|
|
}
|
|
case model.GotoGameDownload, model.GotoGameDownloadS:
|
|
if card, ok := s.gameDownloadCache[c.Value]; ok {
|
|
downloadm[c.Value] = card
|
|
}
|
|
case model.GotoArticle, model.GotoArticleS:
|
|
if c.Value != 0 {
|
|
metaIDs = append(metaIDs, c.Value)
|
|
}
|
|
case model.GotoShoppingS:
|
|
if c.Value != 0 {
|
|
shopIDs = append(shopIDs, c.Value)
|
|
}
|
|
case model.GotoAudio:
|
|
if c.Value != 0 {
|
|
audioIDs = append(audioIDs, c.Value)
|
|
}
|
|
case model.GotoLiveUpRcmd:
|
|
if c.Value != 0 {
|
|
if cs, ok := s.liveCardCache[c.Value]; ok {
|
|
for _, c := range cs {
|
|
upIDs = append(upIDs, c.UID)
|
|
}
|
|
}
|
|
}
|
|
case model.GotoSubscribe:
|
|
if c.Value != 0 {
|
|
if card, ok := s.upCardCache[c.Value]; 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[c.Value] = card
|
|
}
|
|
}
|
|
case model.GotoChannelRcmd:
|
|
if c.Value != 0 {
|
|
if card, ok := s.upCardCache[c.Value]; ok {
|
|
if card.Pid != 0 {
|
|
aids = append(aids, card.Pid)
|
|
}
|
|
if card.Tid != 0 {
|
|
tids = append(tids, card.Tid)
|
|
}
|
|
followm[c.Value] = card
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if len(listAID) != 0 {
|
|
aids = append(aids, listAID...)
|
|
}
|
|
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, build); err != nil {
|
|
return
|
|
}
|
|
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.EpidsCardsInfoReply(ctx, seasonIDs); 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.sp.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 len(actIDs) != 0 {
|
|
g.Go(func() (err error) {
|
|
if actm, err = s.act.Activitys(ctx, actIDs); err != nil {
|
|
log.Error("%+v", err)
|
|
err = nil
|
|
}
|
|
return
|
|
})
|
|
}
|
|
if len(topIDs) != 0 {
|
|
g.Go(func() (err error) {
|
|
if topm, err = s.act.Activitys(ctx, topIDs); err != nil {
|
|
log.Error("%+v", err)
|
|
err = nil
|
|
}
|
|
return
|
|
})
|
|
}
|
|
if err = g.Wait(); err != nil {
|
|
log.Error("%+v", err)
|
|
return
|
|
}
|
|
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 infocard, 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
|
|
})
|
|
}
|
|
}
|
|
if err = g.Wait(); err != nil {
|
|
log.Error("%+v", err)
|
|
return
|
|
}
|
|
for _, c := range channelCards {
|
|
i := &feed.Item{}
|
|
i.Pos = c.Pos
|
|
i.FromType = _fTypeOperation
|
|
switch c.Type {
|
|
case model.GotoAv, model.GotoUpRcmdAv:
|
|
a := am[c.Value]
|
|
isOsea := model.IsOverseas(plat)
|
|
if a != nil && a.IsNormal() && (!isOsea || (isOsea && a.AttrVal(archive.AttrBitOverseaLock) == 0)) {
|
|
i.FromPlayerAv(a)
|
|
i.FromDislikeReason()
|
|
i.FromRcmdReason(c)
|
|
if follows[i.Mid] {
|
|
i.IsAtten = 1
|
|
if i.RcmdReason != nil && i.RcmdReason.Content == "已关注" {
|
|
i.RcmdReason.Content = ""
|
|
}
|
|
}
|
|
//for GotoUpRcmdAv
|
|
i.Goto = c.Type
|
|
is = append(is, i)
|
|
}
|
|
case model.GotoLive:
|
|
if r, ok := rm[c.Value]; ok {
|
|
i.FromLive(r)
|
|
if card, ok := infocard[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)
|
|
}
|
|
}
|
|
case model.GotoBangumi:
|
|
if s, ok := sm[c.Value]; ok {
|
|
i.FromSeason(s)
|
|
is = append(is, i)
|
|
}
|
|
case model.GotoPGC:
|
|
if s, ok := seasonCards[int32(c.Value)]; ok {
|
|
i.FromPGCSeason(s)
|
|
is = append(is, i)
|
|
}
|
|
case model.GotoActivity:
|
|
if act, ok := actm[c.Value]; ok && act.H5Cover != "" && act.H5URL != "" {
|
|
i.FromActivity(act, now)
|
|
if i.Goto != "" {
|
|
is = append(is, i)
|
|
}
|
|
}
|
|
case model.GotoTopic:
|
|
if top, ok := topm[c.Value]; ok && top.H5Cover != "" && top.H5URL != "" {
|
|
i.FromTopic(top)
|
|
is = append(is, i)
|
|
}
|
|
case model.GotoSpecial:
|
|
if sc, ok := s.specialCardCache[c.Value]; ok {
|
|
i.FromSpecial(sc.ID, sc.Title, sc.Cover, sc.Desc, sc.ReValue, sc.ReType, sc.Badge, sc.Size)
|
|
}
|
|
if i.Goto != "" {
|
|
is = append(is, i)
|
|
}
|
|
case model.GotoSpecialS:
|
|
if sc, ok := s.specialCardCache[c.Value]; ok {
|
|
i.FromSpecialS(sc.ID, sc.Title, sc.Cover, sc.Desc, sc.ReValue, sc.ReType, sc.Badge)
|
|
}
|
|
if i.Goto != "" {
|
|
is = append(is, i)
|
|
}
|
|
case model.GotoTopstick:
|
|
if sc, ok := s.specialCardCache[c.Value]; ok {
|
|
i.FromTopstick(sc.ID, sc.Title, sc.Cover, sc.Desc, sc.ReValue, sc.ReType)
|
|
top = i
|
|
}
|
|
case model.GotoConverge:
|
|
if cc, ok := convergem[c.Value]; ok {
|
|
i.FromConverge(cc, am, rm, atm)
|
|
if i.Goto != "" {
|
|
is = append(is, i)
|
|
}
|
|
}
|
|
case model.GotoGameDownload:
|
|
if gd, ok := downloadm[c.Value]; ok {
|
|
i.FromGameDownload(gd, plat, build)
|
|
if i.Goto != "" {
|
|
is = append(is, i)
|
|
}
|
|
}
|
|
case model.GotoGameDownloadS:
|
|
if gd, ok := downloadm[c.Value]; ok {
|
|
i.FromGameDownloadS(gd, plat, build)
|
|
if i.Goto != "" {
|
|
is = append(is, i)
|
|
}
|
|
}
|
|
case model.GotoArticle:
|
|
if m, ok := atm[c.Value]; ok {
|
|
i.FromArticle(m)
|
|
if card, ok := infocard[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 != "" {
|
|
is = append(is, i)
|
|
}
|
|
}
|
|
case model.GotoArticleS:
|
|
if m, ok := atm[c.Value]; ok {
|
|
i.FromArticleS(m)
|
|
if card, ok := infocard[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 != "" {
|
|
is = append(is, i)
|
|
}
|
|
}
|
|
case model.GotoShoppingS:
|
|
if c, ok := scm[c.Value]; ok {
|
|
i.FromShoppingS(c)
|
|
if i.Goto != "" {
|
|
is = append(is, i)
|
|
}
|
|
}
|
|
case model.GotoAudio:
|
|
if au, ok := aum[c.Value]; ok {
|
|
i.FromAudio(au)
|
|
is = append(is, i)
|
|
}
|
|
case model.GotoPlayer:
|
|
if a, ok := am[c.Value]; ok {
|
|
i.FromPlayer(a)
|
|
if i.Goto != "" {
|
|
if follows[i.Mid] {
|
|
i.IsAtten = 1
|
|
}
|
|
if card, ok := infocard[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()
|
|
is = append(is, i)
|
|
}
|
|
}
|
|
case model.GotoPlayerLive:
|
|
if r, ok := rm[c.Value]; ok {
|
|
i.FromPlayerLive(r)
|
|
if i.Goto != "" {
|
|
if follows[i.Mid] {
|
|
i.IsAtten = 1
|
|
}
|
|
if card, ok := infocard[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
|
|
}
|
|
is = append(is, i)
|
|
}
|
|
}
|
|
case model.GotoSubscribe:
|
|
if c, ok := followm[c.Value]; ok {
|
|
i.FromSubscribe(c, infocard, follows, upStatm, tagm)
|
|
is = append(is, i)
|
|
}
|
|
case model.GotoChannelRcmd:
|
|
if c, ok := followm[c.Value]; ok {
|
|
i.FromChannelRcmd(c, am, tagm)
|
|
is = append(is, i)
|
|
}
|
|
case model.GotoLiveUpRcmd:
|
|
if l, ok := liveUpm[c.Value]; ok {
|
|
i.FromLiveUpRcmd(c.Value, l, infocard)
|
|
is = append(is, i)
|
|
}
|
|
}
|
|
}
|
|
if len(listAID) > 0 {
|
|
isOsea := model.IsOverseas(plat)
|
|
for _, aid := range listAID {
|
|
if _, ok := cardAids[aid]; ok {
|
|
continue
|
|
}
|
|
i := &feed.Item{}
|
|
a := am[aid]
|
|
if a != nil && a.IsNormal() && (!isOsea || (isOsea && a.AttrVal(archive.AttrBitOverseaLock) == 0)) {
|
|
i.FromType = _fTypeRecommend
|
|
i.FromPlayerAv(a)
|
|
i.FromDislikeReason()
|
|
//for GotoUpRcmdAv
|
|
i.Goto = model.GotoAv
|
|
is = append(is, i)
|
|
}
|
|
}
|
|
}
|
|
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)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *Service) feedItem(c context.Context, plat int8, cids []int64, mobiApp string, qn, fnver, fnval, build int) (is []*feed.Item, err error) {
|
|
var (
|
|
channelids map[int64]*archive.ArchiveWithPlayer
|
|
_fTypeRecommend = "recommend"
|
|
)
|
|
if len(cids) == 0 {
|
|
is = _emptyItem
|
|
return
|
|
}
|
|
if channelids, err = s.ArchivesWithPlayer(c, cids, qn, mobiApp, fnver, fnval, build); err != nil {
|
|
return
|
|
}
|
|
if len(channelids) > 0 {
|
|
isOsea := model.IsOverseas(plat)
|
|
for _, aid := range cids {
|
|
i := &feed.Item{}
|
|
i.FromType = _fTypeRecommend
|
|
a := channelids[aid]
|
|
if a != nil && a.IsNormal() && (!isOsea || (isOsea && a.AttrVal(archive.AttrBitOverseaLock) == 0)) {
|
|
i.FromPlayerAv(a)
|
|
i.FromDislikeReason()
|
|
i.Goto = model.GotoAv
|
|
is = append(is, i)
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|