582 lines
13 KiB
Go
582 lines
13 KiB
Go
package view
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"time"
|
||
|
||
"go-common/app/interface/main/app-intl/model"
|
||
"go-common/app/interface/main/app-intl/model/bangumi"
|
||
"go-common/app/interface/main/app-intl/model/manager"
|
||
"go-common/app/interface/main/app-intl/model/view"
|
||
"go-common/app/service/main/archive/api"
|
||
"go-common/app/service/main/archive/model/archive"
|
||
location "go-common/app/service/main/location/model"
|
||
thumbup "go-common/app/service/main/thumbup/model"
|
||
"go-common/library/ecode"
|
||
"go-common/library/log"
|
||
"go-common/library/sync/errgroup"
|
||
"go-common/library/text/translate/chinese"
|
||
)
|
||
|
||
var (
|
||
_rate = map[int]int64{15: 464, 16: 464, 32: 1028, 48: 1328, 64: 2192, 74: 3192, 80: 3192, 112: 6192, 116: 6192, 66: 1820}
|
||
)
|
||
|
||
const (
|
||
_dmformat = "http://comment.bilibili.com/%d.xml"
|
||
_qn480 = 32
|
||
_qnAndroidBuild = 5325000
|
||
_qnIosBuild = 8170
|
||
)
|
||
|
||
// initReqUser init Req User
|
||
func (s *Service) initReqUser(c context.Context, v *view.View, mid int64, plat int8, build int) {
|
||
// owner ext
|
||
g, ctx := errgroup.WithContext(c)
|
||
if v.Author.Mid > 0 {
|
||
g.Go(func() (err error) {
|
||
v.OwnerExt.OfficialVerify.Type = -1
|
||
card, err := s.accDao.Card3(ctx, v.Author.Mid)
|
||
if err != nil {
|
||
log.Error("%+v", err)
|
||
err = nil
|
||
return
|
||
}
|
||
if card != nil {
|
||
otp := -1
|
||
odesc := ""
|
||
if card.Official.Role != 0 {
|
||
if card.Official.Role <= 2 {
|
||
otp = 0
|
||
} else {
|
||
otp = 1
|
||
}
|
||
odesc = card.Official.Title
|
||
}
|
||
v.OwnerExt.OfficialVerify.Type = otp
|
||
v.OwnerExt.OfficialVerify.Desc = odesc
|
||
v.OwnerExt.Vip.Type = int(card.Vip.Type)
|
||
v.OwnerExt.Vip.VipStatus = int(card.Vip.Status)
|
||
v.OwnerExt.Vip.DueDate = card.Vip.DueDate
|
||
v.Author.Name = card.Name
|
||
v.Author.Face = card.Face
|
||
}
|
||
return
|
||
})
|
||
g.Go(func() (err error) {
|
||
stat, err := s.relDao.Stat(c, v.Author.Mid)
|
||
if err != nil {
|
||
log.Error("%+v", err)
|
||
err = nil
|
||
return
|
||
}
|
||
if stat != nil {
|
||
v.OwnerExt.Fans = int(stat.Follower)
|
||
}
|
||
return
|
||
})
|
||
g.Go(func() error {
|
||
if ass, err := s.assDao.Assist(ctx, v.Author.Mid); err != nil {
|
||
log.Error("%+v", err)
|
||
} else {
|
||
v.OwnerExt.Assists = ass
|
||
}
|
||
return nil
|
||
})
|
||
}
|
||
// req user
|
||
v.ReqUser = &view.ReqUser{Favorite: 0, Attention: -999, Like: 0, Dislike: 0}
|
||
// check req user
|
||
if mid > 0 {
|
||
g.Go(func() error {
|
||
if is, _ := s.favDao.IsFav(ctx, mid, v.Aid); is {
|
||
v.ReqUser.Favorite = 1
|
||
}
|
||
return nil
|
||
})
|
||
g.Go(func() error {
|
||
res, err := s.thumbupDao.HasLike(ctx, mid, _businessLike, []int64{v.Aid})
|
||
if err != nil {
|
||
log.Error("%+v", err)
|
||
return nil
|
||
}
|
||
if typ, ok := res[v.Aid]; ok {
|
||
if typ == thumbup.StateLike {
|
||
v.ReqUser.Like = 1
|
||
} else if typ == thumbup.StateDislike {
|
||
v.ReqUser.Dislike = 1
|
||
}
|
||
}
|
||
return nil
|
||
})
|
||
g.Go(func() (err error) {
|
||
res, err := s.coinDao.ArchiveUserCoins(ctx, v.Aid, mid, _avTypeAv)
|
||
if err != nil {
|
||
log.Error("%+v", err)
|
||
err = nil
|
||
}
|
||
if res != nil && res.Multiply > 0 {
|
||
v.ReqUser.Coin = 1
|
||
}
|
||
return
|
||
})
|
||
if v.Author.Mid > 0 {
|
||
g.Go(func() error {
|
||
fl, err := s.accDao.Following3(ctx, mid, v.Author.Mid)
|
||
if err != nil {
|
||
log.Error("%+v", err)
|
||
return nil
|
||
}
|
||
if fl {
|
||
v.ReqUser.Attention = 1
|
||
}
|
||
return nil
|
||
})
|
||
}
|
||
}
|
||
if err := g.Wait(); err != nil {
|
||
log.Error("%+v", err)
|
||
}
|
||
}
|
||
|
||
// initRelateCMTag is.
|
||
func (s *Service) initRelateCMTag(c context.Context, v *view.View, plat int8, build int, mid int64, buvid, mobiApp, device, network, adExtra, from string, now time.Time, isTW bool) {
|
||
var (
|
||
rls []*view.Relate
|
||
mr *manager.Relate
|
||
err error
|
||
)
|
||
tids := s.initTag(c, v, mid)
|
||
g, ctx := errgroup.WithContext(c)
|
||
g.Go(func() (err error) {
|
||
if mid > 0 || buvid != "" {
|
||
if rls, v.UserFeature, v.ReturnCode, err = s.newRcmdRelate(ctx, plat, v.Aid, mid, buvid, mobiApp, from, build); err != nil {
|
||
log.Error("s.newRcmdRelate(%d) error(%+v)", v.Aid, err)
|
||
}
|
||
}
|
||
if len(rls) == 0 {
|
||
rls, err = s.dealRcmdRelate(ctx, plat, v.Aid)
|
||
log.Warn("s.dealRcmdRelate aid(%d) mid(%d) buvid(%s)", v.Aid, mid, buvid)
|
||
return
|
||
}
|
||
v.IsRec = 1
|
||
log.Warn("s.newRcmdRelate returncode(%s) aid(%d) mid(%d) buvid(%s)", v.ReturnCode, v.Aid, mid, buvid)
|
||
return
|
||
})
|
||
g.Go(func() (err error) {
|
||
mr = s.relateCache(ctx, plat, build, now, v.Aid, tids, v.TypeID)
|
||
return
|
||
})
|
||
if err = g.Wait(); err != nil {
|
||
log.Error("%+v", err)
|
||
return
|
||
}
|
||
if len(rls) == 0 {
|
||
s.prom.Incr("zero_relates")
|
||
return
|
||
}
|
||
var (
|
||
r *view.Relate
|
||
rm map[int]*view.Relate
|
||
)
|
||
aidm := map[int64]struct{}{}
|
||
if r, err = s.dealManagerRelate(c, plat, mr); err != nil {
|
||
log.Error("%+v", err)
|
||
}
|
||
if r != nil {
|
||
// 相关推荐的第一位是运营插入位
|
||
rm = map[int]*view.Relate{0: r}
|
||
aidm[r.Aid] = struct{}{}
|
||
}
|
||
// 权重：详情页稿件>相关推荐运营位稿件>AI相关推荐稿件
|
||
for _, rl := range rls {
|
||
// AI相关推荐稿件不能和详情页稿件重复
|
||
if rl.Aid == v.Aid {
|
||
continue
|
||
}
|
||
if len(rm) != 0 {
|
||
for {
|
||
// 相关推荐运营位稿件不能和详情页稿件重复
|
||
if r, ok := rm[len(v.Relates)]; ok && r.Aid != v.Aid {
|
||
v.Relates = append(v.Relates, r)
|
||
continue
|
||
}
|
||
// AI相关推荐稿件不能和相关推荐运营位稿件重复
|
||
if _, ok := aidm[rl.Aid]; !ok {
|
||
v.Relates = append(v.Relates, rl)
|
||
}
|
||
break
|
||
}
|
||
} else {
|
||
v.Relates = append(v.Relates, rl)
|
||
}
|
||
}
|
||
if isTW {
|
||
for _, rl := range v.Relates {
|
||
rl.Title = chinese.Convert(c, rl.Title)
|
||
}
|
||
}
|
||
}
|
||
|
||
// initMovie is.
|
||
func (s *Service) initMovie(c context.Context, v *view.View, mid int64, build int, mobiApp, device string, nMovie bool) (err error) {
|
||
s.pHit.Incr("is_movie")
|
||
var m *bangumi.Movie
|
||
if m, err = s.banDao.Movie(c, v.Aid, mid, build, mobiApp, device); err != nil || m == nil {
|
||
log.Error("%+v", err)
|
||
err = ecode.NothingFound
|
||
s.pMiss.Incr("err_is_PGC")
|
||
return
|
||
}
|
||
if v.Rights.HD5 == 1 && m.PayUser.Status == 0 && !s.checkVIP(c, mid) {
|
||
v.Rights.HD5 = 0
|
||
}
|
||
if len(m.List) == 0 {
|
||
err = ecode.NothingFound
|
||
return
|
||
}
|
||
vps := make([]*view.Page, 0, len(m.List))
|
||
for _, l := range m.List {
|
||
vp := &view.Page{
|
||
Page3: &archive.Page3{Cid: l.Cid, Page: int32(l.Page), From: l.Type, Part: l.Part, Vid: l.Vid},
|
||
}
|
||
vps = append(vps, vp)
|
||
}
|
||
m.List = nil
|
||
// view
|
||
v.Pages = vps
|
||
v.Rights.Download = int32(m.AllowDownload)
|
||
m.AllowDownload = 0
|
||
v.Rights.Bp = 0
|
||
if nMovie {
|
||
v.Movie = m
|
||
v.Desc = m.Season.Evaluate
|
||
}
|
||
return
|
||
}
|
||
|
||
// initPGC is.
|
||
func (s *Service) initPGC(c context.Context, v *view.View, mid int64, build int, mobiApp, device string) (err error) {
|
||
s.pHit.Incr("is_PGC")
|
||
var season *bangumi.Season
|
||
if season, err = s.banDao.PGC(c, v.Aid, mid, build, mobiApp, device); err != nil {
|
||
log.Error("%+v", err)
|
||
err = ecode.NothingFound
|
||
s.pMiss.Incr("err_is_PGC")
|
||
return
|
||
}
|
||
if season != nil {
|
||
if season.Player != nil {
|
||
if len(v.Pages) != 0 {
|
||
if season.Player.Cid != 0 {
|
||
v.Pages[0].Cid = season.Player.Cid
|
||
}
|
||
if season.Player.From != "" {
|
||
v.Pages[0].From = season.Player.From
|
||
}
|
||
if season.Player.Vid != "" {
|
||
v.Pages[0].Vid = season.Player.Vid
|
||
}
|
||
}
|
||
season.Player = nil
|
||
}
|
||
if season.AllowDownload == "1" {
|
||
v.Rights.Download = 1
|
||
} else {
|
||
v.Rights.Download = 0
|
||
}
|
||
if season.SeasonID != "" {
|
||
season.AllowDownload = ""
|
||
v.Season = season
|
||
}
|
||
}
|
||
if v.Rights.HD5 == 1 && !s.checkVIP(c, mid) {
|
||
v.Rights.HD5 = 0
|
||
}
|
||
v.Rights.Bp = 0
|
||
return
|
||
}
|
||
|
||
// initPages is.
|
||
func (s *Service) initPages(c context.Context, vs *view.ViewStatic, ap []*archive.Page3) {
|
||
pages := make([]*view.Page, 0, len(ap))
|
||
for _, v := range ap {
|
||
page := &view.Page{}
|
||
metas := make([]*view.Meta, 0, 4)
|
||
for q, r := range _rate {
|
||
meta := &view.Meta{
|
||
Quality: q,
|
||
Size: int64(float64(r*v.Duration) * 1.1 / 8.0),
|
||
}
|
||
metas = append(metas, meta)
|
||
}
|
||
if vs.AttrVal(archive.AttrBitIsBangumi) == archive.AttrYes {
|
||
v.From = "bangumi"
|
||
}
|
||
page.Page3 = v
|
||
page.Metas = metas
|
||
page.DMLink = fmt.Sprintf(_dmformat, v.Cid)
|
||
pages = append(pages, page)
|
||
}
|
||
vs.Pages = pages
|
||
}
|
||
|
||
// initDownload is.
|
||
func (s *Service) initDownload(c context.Context, v *view.View, mid int64, cdnIP string) (err error) {
|
||
var download int64
|
||
if v.AttrVal(archive.AttrBitLimitArea) == archive.AttrYes {
|
||
if download, err = s.ipLimit(c, mid, v.Aid, cdnIP); err != nil {
|
||
return
|
||
}
|
||
} else {
|
||
download = location.AllowDown
|
||
}
|
||
if download == location.ForbiddenDown {
|
||
v.Rights.Download = int32(download)
|
||
return
|
||
}
|
||
for _, p := range v.Pages {
|
||
if p.From == "qq" {
|
||
download = location.ForbiddenDown
|
||
break
|
||
}
|
||
}
|
||
v.Rights.Download = int32(download)
|
||
return
|
||
}
|
||
|
||
// initContributions is.
|
||
func (s *Service) initContributions(c context.Context, v *view.View, isTW bool) {
|
||
const _count = 5
|
||
if v.ReqUser != nil && v.ReqUser.Attention == 1 {
|
||
return
|
||
}
|
||
var hasAudio bool
|
||
for _, page := range v.Pages {
|
||
if page.Audio != nil {
|
||
hasAudio = true
|
||
break
|
||
}
|
||
}
|
||
if hasAudio || v.OwnerExt.Archives < 20 {
|
||
return
|
||
}
|
||
aids, err := s.arcDao.ViewContributeCache(c, v.Author.Mid)
|
||
if err != nil {
|
||
log.Error("%+v", err)
|
||
return
|
||
}
|
||
if len(aids) < _count+1 {
|
||
return
|
||
}
|
||
as, err := s.arcDao.Archives(c, aids)
|
||
if err != nil {
|
||
log.Error("%+v", err)
|
||
return
|
||
}
|
||
if len(as) == 0 {
|
||
return
|
||
}
|
||
ctbt := make([]*view.Contribution, 0, len(as))
|
||
for _, aid := range aids {
|
||
if a, ok := as[aid]; ok && a.IsNormal() {
|
||
if a.Aid != v.Aid {
|
||
if isTW {
|
||
a.Title = chinese.Convert(c, a.Title)
|
||
}
|
||
vc := &view.Contribution{Aid: a.Aid, Title: a.Title, Pic: a.Pic, Author: a.Author, Stat: a.Stat, CTime: a.PubDate}
|
||
ctbt = append(ctbt, vc)
|
||
}
|
||
}
|
||
}
|
||
if len(ctbt) > _count {
|
||
ctbt = ctbt[:_count]
|
||
}
|
||
if len(ctbt) == _count {
|
||
v.Contributions = ctbt
|
||
}
|
||
}
|
||
|
||
// initAudios is.
|
||
func (s *Service) initAudios(c context.Context, v *view.View) {
|
||
pLen := len(v.Pages)
|
||
if pLen == 0 || pLen > 100 {
|
||
return
|
||
}
|
||
if pLen > 50 {
|
||
pLen = 50
|
||
}
|
||
cids := make([]int64, 0, len(v.Pages[:pLen]))
|
||
for _, p := range v.Pages[:pLen] {
|
||
cids = append(cids, p.Cid)
|
||
}
|
||
vam, err := s.audioDao.AudioByCids(c, cids)
|
||
if err != nil {
|
||
log.Error("%+v", err)
|
||
return
|
||
}
|
||
if len(vam) != 0 {
|
||
for _, p := range v.Pages[:pLen] {
|
||
if va, ok := vam[p.Cid]; ok {
|
||
p.Audio = va
|
||
}
|
||
}
|
||
if len(v.Pages) == 1 {
|
||
if va, ok := vam[v.Pages[0].Cid]; ok {
|
||
v.Audio = va
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// initTag is.
|
||
func (s *Service) initTag(c context.Context, v *view.View, mid int64) (tids []int64) {
|
||
tags, err := s.tagDao.ArcTags(c, v.Aid, mid)
|
||
if err != nil {
|
||
log.Error("%+v", err)
|
||
return
|
||
}
|
||
tids = make([]int64, 0, len(tags))
|
||
for _, tag := range tags {
|
||
tids = append(tids, tag.ID)
|
||
}
|
||
v.Tag = tags
|
||
return
|
||
}
|
||
|
||
// initDM is.
|
||
func (s *Service) initDM(c context.Context, v *view.View) {
|
||
const (
|
||
_dmTypeAv = 1
|
||
_dmPlatMobie = 1
|
||
)
|
||
pLen := len(v.Pages)
|
||
if pLen == 0 || pLen > 100 {
|
||
return
|
||
}
|
||
if pLen > 50 {
|
||
pLen = 50
|
||
}
|
||
cids := make([]int64, 0, len(v.Pages[:pLen]))
|
||
for _, p := range v.Pages[:pLen] {
|
||
cids = append(cids, p.Cid)
|
||
}
|
||
res, err := s.dmDao.SubjectInfos(c, _dmTypeAv, _dmPlatMobie, cids...)
|
||
if err != nil {
|
||
log.Error("%+v", err)
|
||
return
|
||
}
|
||
if len(res) == 0 {
|
||
return
|
||
}
|
||
for _, p := range v.Pages[:pLen] {
|
||
if r, ok := res[p.Cid]; ok {
|
||
p.DM = r
|
||
}
|
||
}
|
||
}
|
||
|
||
// dealRcmdRelate is.
|
||
func (s *Service) dealRcmdRelate(c context.Context, plat int8, aid int64) (rls []*view.Relate, err error) {
|
||
if rls, err = s.arcDao.RelatesCache(c, aid); err != nil {
|
||
return
|
||
}
|
||
if len(rls) != 0 {
|
||
return
|
||
}
|
||
s.prom.Incr("need_relates")
|
||
var aids []int64
|
||
if aids, err = s.arcDao.RelateAids(c, aid); err != nil {
|
||
return
|
||
}
|
||
if len(aids) == 0 {
|
||
return
|
||
}
|
||
var as map[int64]*api.Arc
|
||
if as, err = s.arcDao.Archives(c, aids); err != nil {
|
||
return
|
||
}
|
||
for _, aid := range aids {
|
||
if a, ok := as[aid]; ok {
|
||
if s.overseaCheck(archive.BuildArchive3(a), plat) || !a.IsNormal() {
|
||
continue
|
||
}
|
||
r := &view.Relate{}
|
||
r.FromAv(a, "", "", nil)
|
||
rls = append(rls, r)
|
||
}
|
||
}
|
||
if len(rls) != 0 {
|
||
// 如果是繁体区会修改relate的title，addcache是异步操作，需要深度拷贝，避免并发读写的panci
|
||
rels := make([]*view.Relate, 0, len(rls))
|
||
for _, rl := range rls {
|
||
r := &view.Relate{}
|
||
*r = *rl
|
||
rels = append(rels, r)
|
||
}
|
||
s.arcDao.AddRelatesCache(aid, rels)
|
||
}
|
||
return
|
||
}
|
||
|
||
// dealManagerRelate is.
|
||
func (s *Service) dealManagerRelate(c context.Context, plat int8, mr *manager.Relate) (r *view.Relate, err error) {
|
||
if mr == nil || mr.Param < 1 {
|
||
return
|
||
}
|
||
switch mr.Goto {
|
||
case model.GotoAv:
|
||
var a *api.Arc
|
||
if a, err = s.arcDao.Archive(c, mr.Param); err != nil {
|
||
return
|
||
}
|
||
if a != nil {
|
||
r = &view.Relate{}
|
||
r.FromOperate(mr, a, model.FromOperation)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// newRcmdRelate is.
|
||
func (s *Service) newRcmdRelate(c context.Context, plat int8, aid, mid int64, buvid, mobiApp, from string, build int) (rls []*view.Relate, userFeature, returnCode string, err error) {
|
||
recData, userFeature, returnCode, err := s.arcDao.NewRelateAids(c, aid, mid, build, buvid, from, plat)
|
||
if err != nil || len(recData) == 0 {
|
||
return
|
||
}
|
||
var (
|
||
aids []int64
|
||
arcm map[int64]*api.Arc
|
||
)
|
||
for _, rec := range recData {
|
||
switch rec.Goto {
|
||
case model.GotoAv:
|
||
aids = append(aids, rec.Oid)
|
||
}
|
||
}
|
||
if len(aids) == 0 {
|
||
return
|
||
}
|
||
if arcm, err = s.arcDao.Archives(c, aids); err != nil {
|
||
log.Error("%+v", err)
|
||
return
|
||
}
|
||
if len(arcm) == 0 {
|
||
return
|
||
}
|
||
for _, rec := range recData {
|
||
switch rec.Goto {
|
||
case model.GotoAv:
|
||
arc, ok := arcm[rec.Oid]
|
||
if !ok || s.overseaCheck(archive.BuildArchive3(arc), plat) || !arc.IsNormal() {
|
||
continue
|
||
}
|
||
r := &view.Relate{AvFeature: rec.AvFeature, Source: rec.Source}
|
||
r.FromAv(arc, "", rec.TrackID, nil)
|
||
rls = append(rls, r)
|
||
}
|
||
}
|
||
return
|
||
}
|