1778 lines
53 KiB
Go
1778 lines
53 KiB
Go
package card
|
||
|
||
import (
|
||
"fmt"
|
||
"strconv"
|
||
|
||
"go-common/app/interface/main/app-card/model"
|
||
"go-common/app/interface/main/app-card/model/bplus"
|
||
"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/show"
|
||
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/api"
|
||
"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"
|
||
season "go-common/app/service/openplatform/pgc-season/api/grpc/season/v1"
|
||
"go-common/library/log"
|
||
)
|
||
|
||
func singleHandle(cardGoto model.CardGt, cardType model.CardType, rcmd *ai.Item, tagm map[int64]*tag.Tag, isAttenm map[int64]int8, statm map[int64]*relation.Stat, cardm map[int64]*account.Card) (hander Handler) {
|
||
base := &Base{CardType: cardType, CardGoto: cardGoto, Rcmd: rcmd, Tagm: tagm, IsAttenm: isAttenm, Statm: statm, Cardm: cardm, Columnm: model.ColumnSvrSingle}
|
||
switch cardType {
|
||
case model.LargeCoverV1:
|
||
hander = &LargeCoverV1{Base: base}
|
||
case model.OnePicV1:
|
||
hander = &OnePicV1{Base: base}
|
||
case model.ThreePicV1:
|
||
hander = &ThreePicV1{Base: base}
|
||
case model.SmallCoverV5:
|
||
hander = &SmallCoverV5{Base: base}
|
||
case model.OptionsV1:
|
||
hander = &Option{Base: base}
|
||
case model.Select:
|
||
hander = &Select{Base: base}
|
||
default:
|
||
switch cardGoto {
|
||
case model.CardGotoAv, model.CardGotoBangumi, model.CardGotoLive, model.CardGotoPlayer, model.CardGotoPlayerLive, model.CardGotoChannelRcmd, model.CardGotoUpRcmdAv, model.CardGotoPGC:
|
||
base.CardType = model.LargeCoverV1
|
||
hander = &LargeCoverV1{Base: base}
|
||
case model.CardGotoAudio, model.CardGotoBangumiRcmd, model.CardGotoGameDownloadS, model.CardGotoShoppingS, model.CardGotoSpecialS, model.CardGotoMoe:
|
||
base.CardType = model.SmallCoverV1
|
||
hander = &SmallCoverV1{Base: base}
|
||
case model.CardGotoSpecial:
|
||
base.CardType = model.MiddleCoverV1
|
||
hander = &MiddleCover{Base: base}
|
||
case model.CardGotoConverge, model.CardGotoRank:
|
||
base.CardType = model.ThreeItemV1
|
||
hander = &ThreeItemV1{Base: base}
|
||
case model.CardGotoSubscribe, model.CardGotoSearchSubscribe:
|
||
base.CardType = model.ThreeItemHV1
|
||
hander = &ThreeItemH{Base: base}
|
||
case model.CardGotoArticleS:
|
||
base.CardType = model.ThreeItemHV3
|
||
hander = &ThreeItemHV3{Base: base}
|
||
case model.CardGotoLiveUpRcmd:
|
||
base.CardType = model.TwoItemV1
|
||
hander = &TwoItemV1{Base: base}
|
||
case model.CardGotoLogin:
|
||
base.CardType = model.CoverOnlyV1
|
||
hander = &CoverOnly{Base: base}
|
||
case model.CardGotoBanner:
|
||
base.CardType = model.BannerV1
|
||
hander = &Banner{Base: base}
|
||
case model.CardGotoAdAv:
|
||
base.CardType = model.CmV1
|
||
hander = &LargeCoverV1{Base: base}
|
||
case model.CardGotoAdWebS, model.CardGotoAdWeb:
|
||
base.CardType = model.CmV1
|
||
hander = &SmallCoverV1{Base: base}
|
||
case model.CardGotoHotTopic:
|
||
base.CardType = model.HotTopic
|
||
hander = &HotTopic{Base: base}
|
||
case model.CardGotoTopstick:
|
||
base.CardType = model.TopStick
|
||
hander = &Topstick{Base: base}
|
||
case model.CardGotoChannelSquare:
|
||
base.CardType = model.ChannelSquare
|
||
hander = &ChannelSquare{Base: base}
|
||
case model.CardGotoPgcsRcmd:
|
||
base.CardType = model.ThreeItemHV4
|
||
hander = &ThreeItemHV4{Base: base}
|
||
case model.CardGotoUpRcmdS:
|
||
base.CardType = model.UpRcmdCover
|
||
hander = &UpRcmdCover{Base: base}
|
||
case model.CardGotoSearchUpper:
|
||
base.CardType = model.ThreeItemAll
|
||
hander = &ThreeItemAll{Base: base}
|
||
case model.CardGotoUpRcmdNew:
|
||
base.CardType = model.TwoItemHV1
|
||
hander = &TwoItemHV1{Base: base}
|
||
case model.CardGotoUpRcmdNewV2:
|
||
base.CardType = model.ThreeItemAllV2
|
||
hander = &ThreeItemAllV2{Base: base}
|
||
case model.CardGotoDynamicHot:
|
||
base.CardType = model.ThreeItemHV5
|
||
hander = &DynamicHot{Base: base}
|
||
case model.CardGotoEventTopic:
|
||
base.CardType = model.MiddleCoverV3
|
||
hander = &MiddleCoverV3{Base: base}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
type LargeCoverV1 struct {
|
||
*Base
|
||
Avatar *Avatar `json:"avatar,omitempty"`
|
||
CoverLeftText1 string `json:"cover_left_text_1,omitempty"`
|
||
CoverLeftText2 string `json:"cover_left_text_2,omitempty"`
|
||
CoverLeftText3 string `json:"cover_left_text_3,omitempty"`
|
||
CoverBadge string `json:"cover_badge,omitempty"`
|
||
TopRcmdReason string `json:"top_rcmd_reason,omitempty"`
|
||
BottomRcmdReason string `json:"bottom_rcmd_reason,omitempty"`
|
||
Desc string `json:"desc,omitempty"`
|
||
OfficialIcon model.Icon `json:"official_icon,omitempty"`
|
||
CanPlay int32 `json:"can_play,omitempty"`
|
||
CoverBadgeColor model.CoverColor `json:"cover_badge_color,omitempty"`
|
||
TopRcmdReasonStyle *ReasonStyle `json:"top_rcmd_reason_style,omitempty"`
|
||
BottomRcmdReasonStyle *ReasonStyle `json:"bottom_rcmd_reason_style,omitempty"`
|
||
CoverBadge2 string `json:"cover_badge_2,omitempty"`
|
||
}
|
||
|
||
func (c *LargeCoverV1) From(main interface{}, op *operate.Card) {
|
||
if op == nil {
|
||
return
|
||
}
|
||
var (
|
||
button interface{}
|
||
avatar *AvatarStatus
|
||
upID int64
|
||
)
|
||
switch main.(type) {
|
||
case map[int64]*archive.ArchiveWithPlayer:
|
||
am := main.(map[int64]*archive.ArchiveWithPlayer)
|
||
a, ok := am[op.ID]
|
||
if !ok || !model.AvIsNormal(a) {
|
||
return
|
||
}
|
||
c.Base.from(op.Param, a.Pic, a.Title, model.GotoAv, op.URI, model.AvPlayHandler(a.Archive3, a.PlayerInfo, op.TrackID))
|
||
c.CoverLeftText1 = model.DurationString(a.Duration)
|
||
c.CoverLeftText2 = model.ArchiveViewString(a.Stat.View)
|
||
c.CoverLeftText3 = model.DanmakuString(a.Stat.Danmaku)
|
||
if op.SwitchLike == model.SwitchFeedIndexLike {
|
||
c.CoverLeftText2 = model.LikeString(a.Stat.Like)
|
||
c.CoverLeftText3 = model.ArchiveViewString(a.Stat.View)
|
||
}
|
||
switch op.CardGoto {
|
||
case model.CardGotoAv, model.CardGotoUpRcmdAv, model.CardGotoPlayer:
|
||
var (
|
||
authorface = a.Author.Face
|
||
authorname = a.Author.Name
|
||
)
|
||
if a.Author.Name != "" {
|
||
if op.Switch != model.SwitchCooperationHide {
|
||
authorname = unionAuthor(a)
|
||
}
|
||
}
|
||
if (authorface == "" || authorname == "") && c.Cardm != nil {
|
||
if au, ok := c.Cardm[a.Author.Mid]; ok {
|
||
authorface = au.Face
|
||
authorname = au.Name
|
||
}
|
||
}
|
||
avatar = &AvatarStatus{Cover: authorface, Goto: model.GotoMid, Param: strconv.FormatInt(a.Author.Mid, 10), Type: model.AvatarRound}
|
||
if c.Rcmd != nil && c.Rcmd.RcmdReason != nil && c.Rcmd.RcmdReason.Style == 3 && c.IsAttenm[a.Author.Mid] == 1 {
|
||
c.Desc = authorname
|
||
} else {
|
||
c.Desc = authorname + " · " + model.PubDataString(a.PubDate.Time())
|
||
}
|
||
if op.CardGoto == model.CardGotoUpRcmdAv {
|
||
button = &ButtonStatus{Goto: model.GotoMid, Param: strconv.FormatInt(a.Author.Mid, 10), IsAtten: c.IsAttenm[a.Author.Mid]}
|
||
} else {
|
||
if t, ok := c.Tagm[op.Tid]; ok {
|
||
button = t
|
||
} else {
|
||
button = &ButtonStatus{Text: a.TypeName}
|
||
}
|
||
}
|
||
c.Base.PlayerArgs = playerArgsFrom(a.Archive3)
|
||
if op.CardGoto == model.CardGotoPlayer && c.Base.PlayerArgs == nil {
|
||
log.Warn("player card aid(%d) can't auto player", a.Aid)
|
||
return
|
||
}
|
||
c.Args.fromArchive(a.Archive3, c.Tagm[op.Tid])
|
||
upID = a.Author.Mid
|
||
case model.CardGotoChannelRcmd:
|
||
t, ok := c.Tagm[op.Tid]
|
||
if !ok {
|
||
return
|
||
}
|
||
avatar = &AvatarStatus{Cover: t.Cover, Goto: model.GotoTag, Param: strconv.FormatInt(t.ID, 10), Type: model.AvatarSquare}
|
||
c.Desc = model.SubscribeString(int32(t.Count.Atten))
|
||
button = &ButtonStatus{Goto: model.GotoTag, Param: strconv.FormatInt(t.ID, 10), IsAtten: t.IsAtten}
|
||
c.Base.PlayerArgs = playerArgsFrom(a.Archive3)
|
||
c.Args.fromArchive(a.Archive3, c.Tagm[op.Tid])
|
||
case model.CardGotoAdAv:
|
||
c.AdInfo = c.Rcmd.Ad
|
||
avatar = &AvatarStatus{Cover: a.Author.Face, Goto: model.GotoMid, Param: strconv.FormatInt(a.Author.Mid, 10), Type: model.AvatarRound}
|
||
c.Desc = a.Author.Name + " · " + model.PubDataString(a.PubDate.Time())
|
||
button = c.Tagm[op.Tid]
|
||
c.Args.fromArchive(a.Archive3, c.Tagm[op.Tid])
|
||
upID = a.Author.Mid
|
||
default:
|
||
log.Warn("LargeCoverV1 From: unexpected card_goto %s", op.CardGoto)
|
||
return
|
||
}
|
||
c.CanPlay = a.Rights.Autoplay
|
||
if a.Rights.UGCPay == 1 && op.ShowUGCPay {
|
||
c.CoverBadge2 = "付费"
|
||
}
|
||
case map[int64]*bangumi.Season:
|
||
sm := main.(map[int64]*bangumi.Season)
|
||
s, ok := sm[op.ID]
|
||
if !ok {
|
||
return
|
||
}
|
||
c.Base.from(s.EpisodeID, s.Cover, s.Title, model.GotoBangumi, s.EpisodeID, nil)
|
||
c.CoverLeftText2 = model.ArchiveViewString(s.PlayCount)
|
||
c.CoverLeftText3 = model.BangumiFavString(s.Favorites)
|
||
avatar = &AvatarStatus{Cover: s.SeasonCover, Type: model.AvatarSquare}
|
||
c.CoverBadge = s.TypeBadge
|
||
c.Desc = s.UpdateDesc
|
||
case map[int32]*season.CardInfoProto:
|
||
sm := main.(map[int32]*season.CardInfoProto)
|
||
s, ok := sm[int32(op.ID)]
|
||
if !ok {
|
||
return
|
||
}
|
||
c.Base.from(op.Param, s.Cover, s.Title, model.GotoPGC, op.URI, nil)
|
||
if s.Stat != nil {
|
||
c.CoverLeftText2 = model.ArchiveViewString(int32(s.Stat.View))
|
||
c.CoverLeftText3 = model.BangumiFavString(int32(s.Stat.Follow))
|
||
}
|
||
avatar = &AvatarStatus{Cover: s.Cover, Type: model.AvatarSquare}
|
||
c.CoverBadge = s.SeasonTypeName
|
||
if s.NewEp != nil {
|
||
c.Desc = s.NewEp.IndexShow
|
||
}
|
||
case map[int32]*episodegrpc.EpisodeCardsProto:
|
||
sm := main.(map[int32]*episodegrpc.EpisodeCardsProto)
|
||
s, ok := sm[int32(op.ID)]
|
||
if !ok {
|
||
return
|
||
}
|
||
title := s.Season.Title + "：" + s.ShowTitle
|
||
c.Base.from(op.Param, s.Cover, title, model.GotoBangumi, op.URI, nil)
|
||
c.Goto = model.GotoPGC
|
||
if s.Season.Stat != nil {
|
||
c.CoverLeftText2 = model.ArchiveViewString(int32(s.Season.Stat.View))
|
||
c.CoverLeftText3 = model.BangumiFavString(int32(s.Season.Stat.Follow))
|
||
}
|
||
avatar = &AvatarStatus{Cover: s.Season.Cover, Type: model.AvatarSquare}
|
||
c.CoverBadge = s.Season.SeasonTypeName
|
||
if s.Season != nil {
|
||
c.Desc = s.Season.NewEpShow
|
||
}
|
||
case map[int64]*live.Room:
|
||
rm := main.(map[int64]*live.Room)
|
||
r, ok := rm[op.ID]
|
||
if !ok || r.LiveStatus != 1 {
|
||
return
|
||
}
|
||
c.Base.from(strconv.FormatInt(op.ID, 10), r.Cover, r.Uname, model.GotoLive, strconv.FormatInt(r.RoomID, 10), model.LiveRoomHandler(r))
|
||
c.CoverLeftText2 = model.LiveOnlineString(r.Online)
|
||
avatar = &AvatarStatus{Cover: r.Cover, Goto: model.GotoMid, Param: strconv.FormatInt(r.UID, 10), Type: model.AvatarRound}
|
||
c.CoverBadge = "直播"
|
||
c.Desc = r.Title
|
||
c.Base.PlayerArgs = playerArgsFrom(r)
|
||
c.Args.fromLiveRoom(r)
|
||
upID = r.UID
|
||
button = r
|
||
c.CanPlay = 1
|
||
// SmallCoverV1
|
||
case map[int64]*show.Shopping:
|
||
const _buttonText = "进入"
|
||
sm := main.(map[int64]*show.Shopping)
|
||
s, ok := sm[op.ID]
|
||
if !ok {
|
||
return
|
||
}
|
||
c.Base.from(strconv.FormatInt(op.ID, 10), model.ShoppingCover(s.PerformanceImageP), s.Name, model.GotoWeb, s.URL, nil)
|
||
if s.Type == 1 {
|
||
c.CoverLeftText2 = s.Want
|
||
c.CoverLeftText3 = s.CityName
|
||
c.Desc = s.STime + " - " + s.ETime
|
||
} else if s.Type == 2 {
|
||
c.CoverLeftText2 = s.Want
|
||
c.CoverLeftText3 = s.Subname
|
||
c.Desc = s.Pricelt
|
||
}
|
||
button = &ButtonStatus{Text: _buttonText, Goto: model.GotoWeb, Param: s.URL, Type: model.ButtonTheme, Event: model.EventButtonClick}
|
||
c.Args.fromShopping(s)
|
||
c.CoverBadgeColor = model.PurpleCoverBadge
|
||
case nil:
|
||
c.Base.from(op.Param, op.Coverm[model.ColumnSvrDouble], op.Title, op.Goto, op.URI, nil)
|
||
switch op.CardGoto {
|
||
case model.CardGotoDownload:
|
||
const _buttonText = "进入"
|
||
c.Desc = op.Desc
|
||
c.CoverLeftText2 = model.DownloadString(op.Download)
|
||
if (op.Plat == model.PlatIPhone && op.Build > 8220) || (op.Plat == model.PlatAndroid && op.Build > 5335001) {
|
||
button = &ButtonStatus{Text: _buttonText, Goto: op.Goto, Param: op.URI, Type: model.ButtonTheme, Event: model.EventGameClick}
|
||
} else {
|
||
button = &ButtonStatus{Text: _buttonText, Goto: op.Goto, Param: op.URI, Type: model.ButtonTheme, Event: model.EventButtonClick}
|
||
}
|
||
c.CoverBadgeColor = model.PurpleCoverBadge
|
||
case model.CardGotoSpecial:
|
||
c.Desc = op.Desc
|
||
c.CoverBadge = op.Badge
|
||
c.CoverBadgeColor = model.PurpleCoverBadge
|
||
default:
|
||
log.Warn("LargeCoverV1 From: unexpected card_goto %s", op.CardGoto)
|
||
return
|
||
}
|
||
default:
|
||
log.Warn("LargeCoverV1 From: unexpected type %T", main)
|
||
return
|
||
}
|
||
if c.Rcmd != nil {
|
||
c.TopRcmdReason, c.BottomRcmdReason = TopBottomRcmdReason(c.Rcmd.RcmdReason, c.IsAttenm[upID], c.Cardm)
|
||
c.TopRcmdReasonStyle = topReasonStyleFrom(c.Rcmd, c.TopRcmdReason, c.Base.Goto)
|
||
c.BottomRcmdReasonStyle = bottomReasonStyleFrom(c.Rcmd, c.BottomRcmdReason, c.Base.Goto)
|
||
}
|
||
c.OfficialIcon = model.OfficialIcon(c.Cardm[upID])
|
||
c.Avatar = avatarFrom(avatar)
|
||
if c.Rcmd == nil || !c.Rcmd.HideButton {
|
||
c.DescButton = buttonFrom(button, op.Plat)
|
||
}
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *LargeCoverV1) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type SmallCoverV1 struct {
|
||
*Base
|
||
CoverBadge string `json:"cover_badge,omitempty"`
|
||
Desc1 string `json:"desc_1,omitempty"`
|
||
Desc2 string `json:"desc_2,omitempty"`
|
||
Desc3 string `json:"desc_3,omitempty"`
|
||
TitleRightText string `json:"title_right_text,omitempty"`
|
||
TitleRightPic model.Icon `json:"title_right_pic,omitempty"`
|
||
}
|
||
|
||
func (c *SmallCoverV1) From(main interface{}, op *operate.Card) {
|
||
if op == nil {
|
||
return
|
||
}
|
||
var button interface{}
|
||
switch main.(type) {
|
||
case map[int64]*audio.Audio:
|
||
var firstSong string
|
||
am := main.(map[int64]*audio.Audio)
|
||
a, ok := am[op.ID]
|
||
if !ok {
|
||
return
|
||
}
|
||
if len(a.Songs) != 0 {
|
||
firstSong = a.Songs[0].Title
|
||
}
|
||
c.Base.from(op.Param, a.CoverURL, a.Title, model.GotoAudio, op.URI, nil)
|
||
c.Desc1, c.Desc2 = model.AudioDescString(firstSong, a.RecordNum)
|
||
c.Desc3 = model.AudioPlayString(a.PlayNum) + " " + model.AudioFavString(a.FavoriteNum)
|
||
c.Args.fromAudio(a)
|
||
button = a.Ctgs
|
||
case *bangumi.Update:
|
||
const (
|
||
_title = "你的追番更新啦"
|
||
_updates = 99
|
||
)
|
||
u := main.(*bangumi.Update)
|
||
if u == nil || u.Updates == 0 {
|
||
return
|
||
}
|
||
c.Base.from("", u.SquareCover, _title, "", "", nil)
|
||
updates := u.Updates
|
||
if updates > _updates {
|
||
updates = _updates
|
||
c.TitleRightPic = model.IconBomb
|
||
} else {
|
||
c.TitleRightPic = model.IconTV
|
||
}
|
||
c.Desc1 = u.Title
|
||
c.TitleRightText = strconv.Itoa(updates)
|
||
case map[int64]*show.Shopping:
|
||
const _buttonText = "进入"
|
||
sm := main.(map[int64]*show.Shopping)
|
||
s, ok := sm[op.ID]
|
||
if !ok {
|
||
return
|
||
}
|
||
c.Base.from(strconv.FormatInt(op.ID, 10), model.ShoppingCover(s.PerformanceImageP), s.Name, model.GotoWeb, s.URL, nil)
|
||
if s.Type == 1 {
|
||
c.Desc1 = s.STime + " - " + s.ETime
|
||
c.Desc2 = s.CityName
|
||
c.Desc3 = "￥" + s.Pricelt
|
||
} else if s.Type == 2 {
|
||
c.Desc1 = s.Subname
|
||
c.Desc2 = s.Want
|
||
c.Desc3 = s.Pricelt
|
||
}
|
||
button = &ButtonStatus{Text: _buttonText, Goto: model.GotoWeb, Param: s.URL, Type: model.ButtonTheme, Event: model.EventButtonClick}
|
||
c.Args.fromShopping(s)
|
||
case *cm.AdInfo:
|
||
ad := main.(*cm.AdInfo)
|
||
c.AdInfo = ad
|
||
case *bangumi.Moe:
|
||
m := main.(*bangumi.Moe)
|
||
if m == nil {
|
||
return
|
||
}
|
||
c.Base.from(strconv.FormatInt(m.ID, 10), m.Square, m.Title, model.GotoWeb, m.Link, nil)
|
||
c.Desc1 = m.Desc
|
||
c.CoverBadge = m.Badge
|
||
case nil:
|
||
c.Base.from(op.Param, op.Coverm[c.Columnm], op.Title, op.Goto, op.URI, nil)
|
||
switch op.CardGoto {
|
||
case model.CardGotoDownload:
|
||
const _buttonText = "进入"
|
||
c.Desc1 = op.Desc
|
||
c.Desc2 = model.DownloadString(op.Download)
|
||
if (op.Plat == model.PlatIPhone && op.Build > 8220) || (op.Plat == model.PlatAndroid && op.Build > 5335001) {
|
||
button = &ButtonStatus{Text: _buttonText, Goto: op.Goto, Param: op.URI, Type: model.ButtonTheme, Event: model.EventGameClick}
|
||
} else {
|
||
button = &ButtonStatus{Text: _buttonText, Goto: op.Goto, Param: op.URI, Type: model.ButtonTheme, Event: model.EventButtonClick}
|
||
}
|
||
case model.CardGotoSpecial:
|
||
c.Desc1 = op.Desc
|
||
c.CoverBadge = op.Badge
|
||
default:
|
||
log.Warn("SmallCoverV1 From: unexpected card_goto %s", op.CardGoto)
|
||
return
|
||
}
|
||
default:
|
||
log.Warn("SmallCoverV1 From: unexpected type %T", main)
|
||
return
|
||
}
|
||
c.DescButton = buttonFrom(button, op.Plat)
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *SmallCoverV1) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type MiddleCover struct {
|
||
*Base
|
||
Ratio int `json:"ratio,omitempty"`
|
||
Badge string `json:"badge,omitempty"`
|
||
Desc string `json:"desc,omitempty"`
|
||
}
|
||
|
||
func (c *MiddleCover) From(main interface{}, op *operate.Card) {
|
||
switch main.(type) {
|
||
case *cm.AdInfo:
|
||
ad := main.(*cm.AdInfo)
|
||
c.AdInfo = ad
|
||
case nil:
|
||
if op == nil {
|
||
return
|
||
}
|
||
c.Base.from(op.Param, op.Coverm[c.Columnm], op.Title, op.Goto, op.URI, nil)
|
||
switch op.CardGoto {
|
||
case model.CardGotoSpecial:
|
||
c.Desc = op.Desc
|
||
c.Badge = op.Badge
|
||
c.Ratio = op.Ratio
|
||
default:
|
||
log.Warn("MiddleCover From: unexpected card_goto %s", op.CardGoto)
|
||
return
|
||
}
|
||
default:
|
||
log.Warn("MiddleCover From: unexpected type %T", main)
|
||
return
|
||
}
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *MiddleCover) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type Topstick struct {
|
||
*Base
|
||
Desc string `json:"desc,omitempty"`
|
||
}
|
||
|
||
func (c *Topstick) From(main interface{}, op *operate.Card) {
|
||
switch main.(type) {
|
||
case nil:
|
||
if op == nil {
|
||
return
|
||
}
|
||
c.Base.from(op.Param, op.Coverm[c.Columnm], op.Title, op.Goto, op.URI, nil)
|
||
switch op.CardGoto {
|
||
case model.CardGotoTopstick:
|
||
c.Desc = op.Desc
|
||
default:
|
||
return
|
||
}
|
||
}
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *Topstick) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type ThreeItemV1 struct {
|
||
*Base
|
||
TitleIcon model.Icon `json:"title_icon,omitempty"`
|
||
BannerCover string `json:"banner_cover,omitempty"`
|
||
BannerURI string `json:"banner_uri,omitempty"`
|
||
MoreURI string `json:"more_uri,omitempty"`
|
||
MoreText string `json:"more_text,omitempty"`
|
||
Items []*ThreeItemV1Item `json:"items,omitempty"`
|
||
}
|
||
|
||
type ThreeItemV1Item struct {
|
||
Base
|
||
CoverLeftText string `json:"cover_left_text,omitempty"`
|
||
CoverLeftIcon model.Icon `json:"cover_left_icon,omitempty"`
|
||
Desc1 string `json:"desc_1,omitempty"`
|
||
Desc2 string `json:"desc_2,omitempty"`
|
||
Badge string `json:"badge,omitempty"`
|
||
}
|
||
|
||
func (c *ThreeItemV1) From(main interface{}, op *operate.Card) {
|
||
switch main.(type) {
|
||
case map[model.Gt]interface{}:
|
||
intfcm := main.(map[model.Gt]interface{})
|
||
if op == nil {
|
||
return
|
||
}
|
||
switch op.CardGoto {
|
||
case model.CardGotoRank:
|
||
const (
|
||
_title = "全站排行榜"
|
||
_limit = 3
|
||
)
|
||
c.Base.from("0", "", _title, "", "", nil)
|
||
// c.TitleIcon = model.IconRank
|
||
c.MoreURI = model.FillURI(op.Goto, op.URI, nil)
|
||
c.MoreText = "查看更多"
|
||
c.Items = make([]*ThreeItemV1Item, 0, _limit)
|
||
for _, v := range op.Items {
|
||
if v == nil {
|
||
continue
|
||
}
|
||
intfc, ok := intfcm[v.Goto]
|
||
if !ok {
|
||
continue
|
||
}
|
||
am := intfc.(map[int64]*archive.ArchiveWithPlayer)
|
||
a, ok := am[v.ID]
|
||
if !ok || !model.AvIsNormal(a) {
|
||
continue
|
||
}
|
||
item := &ThreeItemV1Item{
|
||
CoverLeftText: model.DurationString(a.Duration),
|
||
Desc1: model.ScoreString(v.Score),
|
||
}
|
||
item.Base.from(v.Param, a.Pic, a.Title, model.GotoAv, v.URI, model.AvPlayHandler(a.Archive3, a.PlayerInfo, op.TrackID))
|
||
item.Args.fromArchive(a.Archive3, nil)
|
||
c.Items = append(c.Items, item)
|
||
if len(c.Items) == _limit {
|
||
break
|
||
}
|
||
}
|
||
if len(c.Items) < _limit {
|
||
return
|
||
}
|
||
c.Items[0].CoverLeftIcon = model.IconGoldMedal
|
||
c.Items[1].CoverLeftIcon = model.IconSilverMedal
|
||
c.Items[2].CoverLeftIcon = model.IconBronzeMedal
|
||
case model.CardGotoConverge:
|
||
limit := 3
|
||
if op.Coverm[c.Columnm] != "" {
|
||
limit = 2
|
||
}
|
||
c.Base.from(op.Param, op.Coverm[c.Columnm], op.Title, op.Goto, op.URI, nil)
|
||
c.MoreURI = model.FillURI(model.GotoConverge, op.Param, nil)
|
||
c.MoreText = "查看更多"
|
||
c.Items = make([]*ThreeItemV1Item, 0, len(op.Items))
|
||
for _, v := range op.Items {
|
||
if v == nil {
|
||
continue
|
||
}
|
||
intfc, ok := intfcm[v.Goto]
|
||
if !ok {
|
||
continue
|
||
}
|
||
var item *ThreeItemV1Item
|
||
switch intfc.(type) {
|
||
case map[int64]*archive.ArchiveWithPlayer:
|
||
am := intfc.(map[int64]*archive.ArchiveWithPlayer)
|
||
a, ok := am[v.ID]
|
||
if !ok || !model.AvIsNormal(a) {
|
||
continue
|
||
}
|
||
item = &ThreeItemV1Item{
|
||
CoverLeftText: model.DurationString(a.Duration),
|
||
Desc1: model.ArchiveViewString(a.Stat.View),
|
||
Desc2: model.DanmakuString(a.Stat.Danmaku),
|
||
}
|
||
if op.SwitchLike == model.SwitchFeedIndexLike {
|
||
item.Desc1 = model.LikeString(a.Stat.Like)
|
||
item.Desc2 = model.ArchiveViewString(a.Stat.View)
|
||
}
|
||
item.Base.from(v.Param, a.Pic, a.Title, model.GotoAv, v.URI, model.AvPlayHandler(a.Archive3, a.PlayerInfo, op.TrackID))
|
||
item.Args.fromArchive(a.Archive3, nil)
|
||
case map[int64]*live.Room:
|
||
rm := intfc.(map[int64]*live.Room)
|
||
r, ok := rm[v.ID]
|
||
if !ok || r.LiveStatus != 1 {
|
||
continue
|
||
}
|
||
item = &ThreeItemV1Item{
|
||
Desc1: model.LiveOnlineString(r.Online),
|
||
Badge: "直播",
|
||
}
|
||
item.Base.from(v.Param, r.Cover, r.Title, model.GotoLive, v.URI, model.LiveRoomHandler(r))
|
||
item.Args.fromLiveRoom(r)
|
||
case map[int64]*article.Meta:
|
||
mm := intfc.(map[int64]*article.Meta)
|
||
m, ok := mm[v.ID]
|
||
if !ok {
|
||
continue
|
||
}
|
||
if len(m.ImageURLs) == 0 {
|
||
continue
|
||
}
|
||
item = &ThreeItemV1Item{
|
||
Badge: "文章",
|
||
}
|
||
item.Base.from(v.Param, m.ImageURLs[0], m.Title, model.GotoArticle, v.URI, nil)
|
||
if m.Stats != nil {
|
||
item.Desc1 = model.ArticleViewString(m.Stats.View)
|
||
item.Desc2 = model.ArticleReplyString(m.Stats.Reply)
|
||
}
|
||
item.Args.fromArticle(m)
|
||
default:
|
||
log.Warn("ThreeItemV1 From: unexpected type %T", intfc)
|
||
continue
|
||
}
|
||
c.Items = append(c.Items, item)
|
||
if len(c.Items) == limit {
|
||
break
|
||
}
|
||
}
|
||
if len(c.Items) < limit {
|
||
return
|
||
}
|
||
default:
|
||
log.Warn("ThreeItemV1 From: unexpected card_goto %s", op.CardGoto)
|
||
return
|
||
}
|
||
default:
|
||
log.Warn("ThreeItemV1 From: unexpected type %T", main)
|
||
return
|
||
}
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *ThreeItemV1) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type ThreeItemH struct {
|
||
*Base
|
||
Items []*ThreeItemHItem `json:"items,omitempty"`
|
||
}
|
||
|
||
type ThreeItemHItem struct {
|
||
Base
|
||
CoverType model.Type `json:"cover_type,omitempty"`
|
||
Desc string `json:"desc,omitempty"`
|
||
OfficialIcon model.Icon `json:"official_icon,omitempty"`
|
||
}
|
||
|
||
func (c *ThreeItemH) From(main interface{}, op *operate.Card) {
|
||
switch main.(type) {
|
||
case nil:
|
||
if op == nil {
|
||
return
|
||
}
|
||
switch op.CardGoto {
|
||
case model.CardGotoSubscribe, model.CardGotoSearchSubscribe:
|
||
const _limit = 3
|
||
c.Base.from(op.Param, "", op.Title, "", "", nil)
|
||
c.Items = make([]*ThreeItemHItem, 0, _limit)
|
||
for _, v := range op.Items {
|
||
if v == nil {
|
||
continue
|
||
}
|
||
var (
|
||
item *ThreeItemHItem
|
||
button interface{}
|
||
)
|
||
switch v.Goto {
|
||
case model.GotoTag:
|
||
t, ok := c.Tagm[v.ID]
|
||
if !ok || t.IsAtten == 1 {
|
||
continue
|
||
}
|
||
item = &ThreeItemHItem{
|
||
CoverType: model.AvatarSquare,
|
||
Desc: model.SubscribeString(int32(t.Count.Atten)),
|
||
}
|
||
item.Base.from(v.Param, t.Cover, t.Name, v.Goto, v.URI, nil)
|
||
button = &ButtonStatus{Goto: model.GotoTag, Param: strconv.FormatInt(t.ID, 10)}
|
||
case model.GotoMid:
|
||
cd, ok := c.Cardm[v.ID]
|
||
if !ok || c.IsAttenm[v.ID] == 1 {
|
||
continue
|
||
}
|
||
item = &ThreeItemHItem{
|
||
CoverType: model.AvatarRound,
|
||
}
|
||
item.Base.from(v.Param, cd.Face, cd.Name, v.Goto, v.URI, nil)
|
||
button = &ButtonStatus{Goto: model.GotoMid, Param: strconv.FormatInt(cd.Mid, 10)}
|
||
if v.Desc != "" {
|
||
item.Desc = v.Desc
|
||
} else if stat, ok := c.Statm[cd.Mid]; ok {
|
||
item.Desc = model.FanString(int32(stat.Follower))
|
||
}
|
||
item.OfficialIcon = model.OfficialIcon(cd)
|
||
default:
|
||
log.Warn("ThreeItemH From: unexpected type %T", v.Goto)
|
||
continue
|
||
}
|
||
item.DescButton = buttonFrom(button, op.Plat)
|
||
c.Items = append(c.Items, item)
|
||
if len(c.Items) == _limit {
|
||
break
|
||
}
|
||
}
|
||
if len(c.Items) < _limit {
|
||
return
|
||
}
|
||
default:
|
||
log.Warn("ThreeItemH From: unexpected card_goto %s", op.CardGoto)
|
||
return
|
||
}
|
||
default:
|
||
log.Warn("ThreeItemH From: unexpected type %T", main)
|
||
return
|
||
}
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *ThreeItemH) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type ThreeItemHV3 struct {
|
||
*Base
|
||
Covers []string `json:"covers,omitempty"`
|
||
CoverTopText1 string `json:"cover_top_text_1,omitempty"`
|
||
CoverTopText2 string `json:"cover_top_text_2,omitempty"`
|
||
Desc string `json:"desc,omitempty"`
|
||
Avatar *Avatar `json:"avatar,omitempty"`
|
||
OfficialIcon model.Icon `json:"official_icon,omitempty"`
|
||
}
|
||
|
||
func (c *ThreeItemHV3) From(main interface{}, op *operate.Card) {
|
||
if op == nil {
|
||
return
|
||
}
|
||
var (
|
||
upID int64
|
||
)
|
||
switch main.(type) {
|
||
case map[int64]*article.Meta:
|
||
mm := main.(map[int64]*article.Meta)
|
||
m, ok := mm[op.ID]
|
||
if !ok {
|
||
return
|
||
}
|
||
c.Base.from(op.Param, "", m.Title, model.GotoArticle, op.URI, nil)
|
||
c.Covers = m.ImageURLs
|
||
c.CoverTopText1 = model.ArticleViewString(m.Stats.View)
|
||
c.CoverTopText2 = model.ArticleReplyString(m.Stats.Reply)
|
||
c.Desc = m.Summary
|
||
if m.Author != nil {
|
||
c.Avatar = avatarFrom(&AvatarStatus{Cover: m.Author.Face, Text: m.Author.Name + "·" + model.PubDataString(m.PublishTime.Time()), Goto: model.GotoMid, Param: strconv.FormatInt(m.Author.Mid, 10), Type: model.AvatarRound})
|
||
upID = m.Author.Mid
|
||
}
|
||
c.Args.fromArticle(m)
|
||
default:
|
||
log.Warn("ThreeItemHV3 From: unexpected type %T", main)
|
||
return
|
||
}
|
||
c.OfficialIcon = model.OfficialIcon(c.Cardm[upID])
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *ThreeItemHV3) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type TwoItemV1 struct {
|
||
*Base
|
||
Items []*TwoItemV1Item `json:"items,omitempty"`
|
||
}
|
||
|
||
type TwoItemV1Item struct {
|
||
Base
|
||
CoverBadge string `json:"cover_badge,omitempty"`
|
||
CoverLeftText1 string `json:"cover_left_text_1,omitempty"`
|
||
}
|
||
|
||
func (c *TwoItemV1) From(main interface{}, op *operate.Card) {
|
||
if op == nil {
|
||
return
|
||
}
|
||
switch main.(type) {
|
||
case map[int64][]*live.Card:
|
||
const _limit = 2
|
||
csm := main.(map[int64][]*live.Card)
|
||
cs, ok := csm[op.ID]
|
||
if !ok {
|
||
return
|
||
}
|
||
c.Base.from(op.Param, "", "", "", "", nil)
|
||
c.Items = make([]*TwoItemV1Item, 0, _limit)
|
||
for _, card := range cs {
|
||
if card == nil || card.LiveStatus != 1 {
|
||
continue
|
||
}
|
||
item := &TwoItemV1Item{
|
||
CoverBadge: "直播",
|
||
CoverLeftText1: model.LiveOnlineString(card.Online),
|
||
}
|
||
item.DescButton = buttonFrom(card, op.Plat)
|
||
item.Base.from(strconv.FormatInt(card.RoomID, 10), card.ShowCover, card.Title, model.GotoLive, strconv.FormatInt(card.RoomID, 10), model.LiveUpHandler(card))
|
||
item.Args.fromLiveUp(card)
|
||
c.Items = append(c.Items, item)
|
||
if len(c.Items) == _limit {
|
||
break
|
||
}
|
||
}
|
||
}
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *TwoItemV1) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type CoverOnly struct {
|
||
*Base
|
||
}
|
||
|
||
func (c *CoverOnly) From(main interface{}, op *operate.Card) {
|
||
if op == nil {
|
||
return
|
||
}
|
||
switch main.(type) {
|
||
case nil:
|
||
switch op.CardGoto {
|
||
case model.CardGotoLogin:
|
||
c.Base.from(op.Param, "", "", "", "", nil)
|
||
}
|
||
default:
|
||
log.Warn("CoverOnly From: unexpected type %T", main)
|
||
return
|
||
}
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *CoverOnly) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type Banner struct {
|
||
*Base
|
||
Hash string `json:"hash,omitempty"`
|
||
BannerItem []*banner.Banner `json:"banner_item,omitempty"`
|
||
}
|
||
|
||
func (c *Banner) From(main interface{}, op *operate.Card) {
|
||
if op == nil {
|
||
return
|
||
}
|
||
switch main.(type) {
|
||
case nil:
|
||
switch op.CardGoto {
|
||
case model.CardGotoBanner:
|
||
if len(op.Banner) == 0 {
|
||
log.Warn("Banner len is null")
|
||
return
|
||
}
|
||
c.BannerItem = op.Banner
|
||
c.Hash = op.Hash
|
||
default:
|
||
log.Warn("Banner From: unexpected card_goto %s", op.CardGoto)
|
||
return
|
||
}
|
||
default:
|
||
log.Warn("Banner From: unexpected type %T", main)
|
||
return
|
||
}
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *Banner) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type HotTopic struct {
|
||
*Base
|
||
Desc string `json:"desc,omitempty"`
|
||
Items []*HotTopicItem `json:"items,omitempty"`
|
||
}
|
||
|
||
type HotTopicItem struct {
|
||
Cover string `json:"cover,omitempty"`
|
||
URI string `json:"uri,omitempty"`
|
||
Param string `json:"param,omitempty"`
|
||
Name string `json:"name,omitempty"`
|
||
}
|
||
|
||
func (c *HotTopic) From(main interface{}, op *operate.Card) {
|
||
switch main.(type) {
|
||
case []*live.TopicHot:
|
||
th := main.([]*live.TopicHot)
|
||
if len(th) == 0 {
|
||
return
|
||
}
|
||
items := make([]*HotTopicItem, 0, len(th))
|
||
for _, t := range th {
|
||
it := &HotTopicItem{
|
||
Name: t.TName,
|
||
Param: strconv.Itoa(t.TID),
|
||
Cover: t.ImageURL,
|
||
URI: model.FillURI(model.GotoHotTopic, strconv.Itoa(t.TID), model.HottopicHandler(t)),
|
||
}
|
||
items = append(items, it)
|
||
}
|
||
c.Items = items
|
||
c.Base.from("0", "", "热门话题", model.GotoWeb, "bilibili://following/hot_topic_list", nil)
|
||
c.Desc = "更多热门话题"
|
||
default:
|
||
log.Warn("HotTopic From: unexpected type %T", main)
|
||
return
|
||
}
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *HotTopic) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type Text struct {
|
||
*Base
|
||
Content string `json:"content,omitempty"`
|
||
}
|
||
|
||
func (c *Text) From(main interface{}, op *operate.Card) {
|
||
if op == nil {
|
||
return
|
||
}
|
||
switch main.(type) {
|
||
case nil:
|
||
switch op.CardGoto {
|
||
case model.CardGotoNews:
|
||
c.Base.from(op.Param, "", op.Title, model.GotoWeb, op.URI, nil)
|
||
c.Content = op.Desc
|
||
default:
|
||
log.Warn("Text From: unexpected card_goto %s", op.CardGoto)
|
||
return
|
||
}
|
||
default:
|
||
log.Warn("Text From: unexpected type %T", main)
|
||
return
|
||
}
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *Text) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type ThreeItemHV4 struct {
|
||
*Base
|
||
MoreURI string `json:"more_uri,omitempty"`
|
||
MoreText string `json:"more_text,omitempty"`
|
||
Items []*ThreeItemHV4Item `json:"items,omitempty"`
|
||
}
|
||
|
||
type ThreeItemHV4Item struct {
|
||
Cover string `json:"cover,omitempty"`
|
||
Title string `json:"title,omitempty"`
|
||
Desc string `json:"desc,omitempty"`
|
||
Goto model.Gt `json:"goto,omitempty"`
|
||
Param string `json:"param,omitempty"`
|
||
URI string `json:"uri,omitempty"`
|
||
CoverBadge string `json:"cover_badge,omitempty"`
|
||
CoverBadgeColor model.CoverColor `json:"cover_badge_color,omitempty"`
|
||
}
|
||
|
||
func (c *ThreeItemHV4) From(main interface{}, op *operate.Card) {
|
||
if op == nil {
|
||
return
|
||
}
|
||
switch main.(type) {
|
||
case map[int32]*season.CardInfoProto:
|
||
const _limit = 3
|
||
c.Base.from(op.Param, "", op.Title, op.Goto, "", nil)
|
||
c.Items = make([]*ThreeItemHV4Item, 0, _limit)
|
||
for _, v := range op.Items {
|
||
if v == nil {
|
||
continue
|
||
}
|
||
var (
|
||
item *ThreeItemHV4Item
|
||
)
|
||
sm := main.(map[int32]*season.CardInfoProto)
|
||
s, ok := sm[int32(v.ID)]
|
||
if !ok {
|
||
return
|
||
}
|
||
item = &ThreeItemHV4Item{
|
||
Title: s.Title,
|
||
Cover: s.Cover,
|
||
Goto: model.GotoPGC,
|
||
URI: model.FillURI(model.GotoPGC, strconv.FormatInt(int64(s.SeasonId), 10), nil),
|
||
Param: strconv.FormatInt(int64(s.SeasonId), 10),
|
||
CoverBadge: s.Badge,
|
||
// CoverBadgeColor: model.PurpleCoverBadge,
|
||
// Desc:SeasonTypeName + " · " +
|
||
}
|
||
if s.Rating != nil && s.Rating.Score > 0 {
|
||
item.Desc = fmt.Sprintf("%s · %.1f分", s.SeasonTypeName, s.Rating.Score)
|
||
}
|
||
c.Items = append(c.Items, item)
|
||
if len(c.Items) == _limit {
|
||
break
|
||
}
|
||
}
|
||
if len(c.Items) > _limit {
|
||
// c.MoreText = "查看更多"
|
||
// c.MoreURI = model.FillURI(op.Goto, op.URI, nil)
|
||
c.Items = c.Items[:_limit]
|
||
}
|
||
if len(c.Items) < _limit {
|
||
return
|
||
}
|
||
default:
|
||
log.Warn("ThreeItemHV4Item From: unexpected card_goto %s", op.CardGoto)
|
||
return
|
||
}
|
||
c.Right = true
|
||
return
|
||
}
|
||
|
||
func (c *ThreeItemHV4) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type UpRcmdCover struct {
|
||
*Base
|
||
CoverType model.Type `json:"cover_type,omitempty"`
|
||
Level int32 `json:"level,omitempty"`
|
||
OfficialIcon model.Icon `json:"official_icon,omitempty"`
|
||
DescButton *Button `json:"desc_button,omitempty"`
|
||
Desc1 string `json:"desc_1,omitempty"`
|
||
Desc2 string `json:"desc_2,omitempty"`
|
||
Desc3 string `json:"desc_3,omitempty"`
|
||
}
|
||
|
||
func (c *UpRcmdCover) From(main interface{}, op *operate.Card) {
|
||
if op == nil {
|
||
return
|
||
}
|
||
switch main.(type) {
|
||
case nil:
|
||
switch op.CardGoto {
|
||
case model.CardGotoUpRcmdS:
|
||
c.Base.from(strconv.FormatInt(op.ID, 10), "", "", model.GotoMid, strconv.FormatInt(op.ID, 10), nil)
|
||
var (
|
||
button interface{}
|
||
)
|
||
cd, ok := c.Cardm[op.ID]
|
||
if !ok {
|
||
return
|
||
}
|
||
c.Cover = cd.Face
|
||
c.CoverType = model.AvatarRound
|
||
c.Title = cd.Name
|
||
c.Level = cd.Level
|
||
c.OfficialIcon = model.OfficialIcon(cd)
|
||
if stat, ok := c.Statm[cd.Mid]; ok {
|
||
c.Desc1 = "粉丝: " + model.StatString(int32(stat.Follower), "")
|
||
}
|
||
c.Desc2 = "视频: " + strconv.Itoa(op.Limit)
|
||
c.Desc3 = cd.Sign
|
||
button = &ButtonStatus{
|
||
Goto: model.GotoMid,
|
||
Param: strconv.FormatInt(cd.Mid, 10),
|
||
IsAtten: c.IsAttenm[op.ID],
|
||
Event: model.EventUpClick,
|
||
}
|
||
c.DescButton = buttonFrom(button, op.Plat)
|
||
default:
|
||
log.Warn("UpRcmdCover From: unexpected card_goto %s", op.CardGoto)
|
||
return
|
||
}
|
||
c.Right = true
|
||
}
|
||
}
|
||
|
||
func (c *UpRcmdCover) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type ThreeItemAll struct {
|
||
*Base
|
||
Items []*ThreeItemAllItem `json:"items,omitempty"`
|
||
}
|
||
|
||
type ThreeItemAllItem struct {
|
||
Base
|
||
CoverType model.Type `json:"cover_type,omitempty"`
|
||
Desc string `json:"desc,omitempty"`
|
||
DescButton *Button `json:"desc_button,omitempty"`
|
||
OfficialIcon model.Icon `json:"official_icon,omitempty"`
|
||
}
|
||
|
||
func (c *ThreeItemAll) From(main interface{}, op *operate.Card) {
|
||
switch main.(type) {
|
||
case nil:
|
||
if op == nil {
|
||
return
|
||
}
|
||
switch op.CardGoto {
|
||
case model.CardGotoSearchUpper:
|
||
const _limit = 3
|
||
c.Base.from(op.Param, "", op.Title, "", "", nil)
|
||
c.Items = []*ThreeItemAllItem{}
|
||
for _, v := range op.Items {
|
||
if v == nil {
|
||
continue
|
||
}
|
||
var (
|
||
item *ThreeItemAllItem
|
||
button interface{}
|
||
)
|
||
switch v.Goto {
|
||
case model.GotoMid:
|
||
cd, ok := c.Cardm[v.ID]
|
||
if !ok || c.IsAttenm[v.ID] == 1 {
|
||
continue
|
||
}
|
||
item = &ThreeItemAllItem{
|
||
CoverType: model.AvatarRound,
|
||
}
|
||
item.Base.from(v.Param, cd.Face, cd.Name, v.Goto, v.URI, nil)
|
||
button = &ButtonStatus{Goto: model.GotoMid, Param: strconv.FormatInt(cd.Mid, 10)}
|
||
if v.Desc != "" {
|
||
item.Desc = v.Desc
|
||
} else if stat, ok := c.Statm[cd.Mid]; ok {
|
||
item.Desc = model.FanString(int32(stat.Follower))
|
||
}
|
||
item.OfficialIcon = model.OfficialIcon(cd)
|
||
if item.OfficialIcon == 0 {
|
||
switch cd.Vip.Type {
|
||
case 1:
|
||
item.OfficialIcon = model.IconRoleVipRed
|
||
case 2:
|
||
item.OfficialIcon = model.IconRoleYearVipRed
|
||
}
|
||
}
|
||
default:
|
||
log.Warn("ThreeItemAll From: unexpected type %T", v.Goto)
|
||
continue
|
||
}
|
||
item.DescButton = buttonFrom(button, op.Plat)
|
||
c.Items = append(c.Items, item)
|
||
}
|
||
if len(c.Items) < _limit {
|
||
return
|
||
}
|
||
default:
|
||
log.Warn("ThreeItemAll From: unexpected card_goto %s", op.CardGoto)
|
||
return
|
||
}
|
||
c.Right = true
|
||
}
|
||
}
|
||
|
||
func (c *ThreeItemAll) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type ChannelSquare struct {
|
||
*Base
|
||
Desc1 string `json:"desc_1,omitempty"`
|
||
Desc2 string `json:"desc_2,omitempty"`
|
||
Item []*ChannelSquareItem `json:"item,omitempty"`
|
||
}
|
||
|
||
type ChannelSquareItem struct {
|
||
Title string `json:"title,omitempty"`
|
||
Cover string `json:"cover,omitempty"`
|
||
URI string `json:"uri,omitempty"`
|
||
Param string `json:"param,omitempty"`
|
||
Goto string `json:"goto,omitempty"`
|
||
CoverLeftText1 string `json:"cover_left_text_1,omitempty"`
|
||
CoverLeftIcon1 model.Icon `json:"cover_left_icon_1,omitempty"`
|
||
CoverLeftText2 string `json:"cover_left_text_2,omitempty"`
|
||
CoverLeftIcon2 model.Icon `json:"cover_left_icon_2,omitempty"`
|
||
CoverLeftText3 string `json:"cover_left_text_3,omitempty"`
|
||
FromType string `json:"from_type"`
|
||
}
|
||
|
||
//From ChannelSquare op:channel--av对应关系, main:av map, c.base.tagm:tag map
|
||
func (c *ChannelSquare) From(main interface{}, op *operate.Card) {
|
||
switch main.(type) {
|
||
case map[int64]*api.Arc:
|
||
t := c.Base.Tagm[op.ID]
|
||
c.Base.from(op.Param, t.Cover, t.Name, model.GotoTag, op.Param, nil)
|
||
button := &ButtonStatus{Goto: model.GotoTag, IsAtten: t.IsAtten}
|
||
c.DescButton = buttonFrom(button, op.Plat)
|
||
c.Desc1 = t.Content
|
||
c.Desc2 = model.SubscribeString(int32(t.Count.Atten))
|
||
for _, item := range op.Items {
|
||
am := main.(map[int64]*api.Arc)
|
||
av := am[item.ID]
|
||
c.Item = append(c.Item, &ChannelSquareItem{
|
||
Title: av.Title,
|
||
Cover: av.Pic,
|
||
URI: model.FillURI(model.GotoAv, strconv.FormatInt(item.ID, 10), model.AvPlayHandler(archive.BuildArchive3(av), nil, "")),
|
||
Goto: string(model.GotoAv),
|
||
Param: strconv.FormatInt(item.ID, 10),
|
||
CoverLeftText1: model.StatString(av.Stat.View, ""),
|
||
CoverLeftIcon1: model.IconPlay,
|
||
CoverLeftText2: model.StatString(av.Stat.Danmaku, ""),
|
||
CoverLeftIcon2: model.IconDanmaku,
|
||
CoverLeftText3: model.DurationString(av.Duration),
|
||
FromType: item.FromType,
|
||
})
|
||
}
|
||
}
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *ChannelSquare) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type TwoItemHV1 struct {
|
||
*Base
|
||
Desc string `json:"desc,omitempty"`
|
||
DescButton *Button `json:"desc_button,omitempty"`
|
||
Items []*TwoItemHV1Item `json:"item,omitempty"`
|
||
}
|
||
|
||
type TwoItemHV1Item struct {
|
||
Title string `json:"title,omitempty"`
|
||
Cover string `json:"cover,omitempty"`
|
||
URI string `json:"uri,omitempty"`
|
||
Param string `json:"param,omitempty"`
|
||
Args Args `json:"args,omitempty"`
|
||
Goto string `json:"goto,omitempty"`
|
||
CoverLeftText1 string `json:"cover_left_text_1,omitempty"`
|
||
CoverLeftIcon1 model.Icon `json:"cover_left_icon_1,omitempty"`
|
||
CoverRightText string `json:"cover_right_text,omitempty"`
|
||
}
|
||
|
||
func (c *TwoItemHV1) From(main interface{}, op *operate.Card) {
|
||
if op == nil {
|
||
return
|
||
}
|
||
au, ok := c.Cardm[op.ID]
|
||
if !ok {
|
||
return
|
||
}
|
||
c.Base.from(op.Param, au.Face, au.Name, model.GotoMid, op.Param, nil)
|
||
button := &ButtonStatus{Goto: model.GotoMid, Param: strconv.FormatInt(op.ID, 10), IsAtten: c.IsAttenm[op.ID]}
|
||
c.DescButton = buttonFrom(button, op.Plat)
|
||
if op.Desc != "" {
|
||
c.Desc = op.Desc
|
||
} else {
|
||
c.Desc = au.Sign
|
||
}
|
||
switch main.(type) {
|
||
case map[int64]*archive.ArchiveWithPlayer:
|
||
for _, item := range op.Items {
|
||
am := main.(map[int64]*archive.ArchiveWithPlayer)
|
||
var (
|
||
a *archive.ArchiveWithPlayer
|
||
ok bool
|
||
)
|
||
if a, ok = am[item.ID]; !ok {
|
||
continue
|
||
}
|
||
args := Args{}
|
||
args.fromArchive(a.Archive3, c.Tagm[op.Tid])
|
||
c.Items = append(c.Items, &TwoItemHV1Item{
|
||
Title: a.Title,
|
||
Cover: a.Pic,
|
||
URI: model.FillURI(model.GotoAv, strconv.FormatInt(item.ID, 10), model.AvPlayHandler(a.Archive3, nil, "")),
|
||
Goto: string(model.GotoAv),
|
||
Param: strconv.FormatInt(item.ID, 10),
|
||
CoverLeftText1: model.StatString(a.Stat.View, ""),
|
||
CoverLeftIcon1: model.IconPlay,
|
||
CoverRightText: model.DurationString(a.Duration),
|
||
Args: args,
|
||
})
|
||
if len(c.Items) >= 2 {
|
||
break
|
||
}
|
||
}
|
||
if len(c.Items) < 2 {
|
||
return
|
||
}
|
||
}
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *TwoItemHV1) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type OnePicV1 struct {
|
||
*Base
|
||
Desc1 string
|
||
Desc2 string
|
||
Avatar *Avatar `json:"avatar,omitempty"`
|
||
CoverLeftText1 string `json:"cover_left_text_1,omitempty"`
|
||
CoverLeftText2 string `json:"cover_left_text_2,omitempty"`
|
||
CoverRightText string `json:"cover_right_text,omitempty"`
|
||
CoverRightBackgroundColor string `json:"cover_right_background_color,omitempty"`
|
||
CoverBadge string `json:"cover_badge,omitempty"`
|
||
TopRcmdReason string `json:"top_rcmd_reason,omitempty"`
|
||
BottomRcmdReason string `json:"bottom_rcmd_reason,omitempty"`
|
||
Desc string `json:"desc,omitempty"`
|
||
OfficialIcon model.Icon `json:"official_icon,omitempty"`
|
||
CanPlay int32 `json:"can_play,omitempty"`
|
||
CoverBadgeColor model.CoverColor `json:"cover_badge_color,omitempty"`
|
||
TopRcmdReasonStyle *ReasonStyle `json:"top_rcmd_reason_style,omitempty"`
|
||
BottomRcmdReasonStyle *ReasonStyle `json:"bottom_rcmd_reason_style,omitempty"`
|
||
}
|
||
|
||
func (c *OnePicV1) From(main interface{}, op *operate.Card) {
|
||
if op == nil {
|
||
return
|
||
}
|
||
var (
|
||
button interface{}
|
||
avatar *AvatarStatus
|
||
upID int64
|
||
)
|
||
switch main.(type) {
|
||
case map[int64]*bplus.Picture:
|
||
pm := main.(map[int64]*bplus.Picture)
|
||
p, ok := pm[op.ID]
|
||
if !ok || len(p.Imgs) == 0 || p.ViewCount == 0 {
|
||
return
|
||
}
|
||
c.Base.from(op.Param, p.Imgs[0], p.DynamicText, model.GotoPicture, strconv.FormatInt(p.DynamicID, 10), nil)
|
||
c.CoverLeftText1 = model.PictureViewString(p.ViewCount)
|
||
c.CoverLeftText2 = model.ArticleReplyString(p.CommentCount)
|
||
if p.ImgCount > 1 {
|
||
c.CoverRightText = model.PictureCountString(p.ImgCount)
|
||
c.CoverRightBackgroundColor = "#66666666"
|
||
}
|
||
c.Desc1 = p.NickName
|
||
c.Desc2 = model.PubDataString(p.PublishTime.Time())
|
||
avatar = &AvatarStatus{Cover: p.FaceImg, Goto: model.GotoDynamicMid, Param: strconv.FormatInt(p.Mid, 10), Type: model.AvatarRound}
|
||
button = p
|
||
upID = p.Mid
|
||
default:
|
||
log.Warn("OnePicV1 From: unexpected type %T", main)
|
||
}
|
||
if c.Rcmd != nil {
|
||
c.TopRcmdReason, c.BottomRcmdReason = TopBottomRcmdReason(c.Rcmd.RcmdReason, c.IsAttenm[upID], c.Cardm)
|
||
c.TopRcmdReasonStyle = topReasonStyleFrom(c.Rcmd, c.TopRcmdReason, c.Base.Goto)
|
||
c.BottomRcmdReasonStyle = bottomReasonStyleFrom(c.Rcmd, c.BottomRcmdReason, c.Base.Goto)
|
||
}
|
||
c.OfficialIcon = model.OfficialIcon(c.Cardm[upID])
|
||
c.Avatar = avatarFrom(avatar)
|
||
c.DescButton = buttonFrom(button, op.Plat)
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *OnePicV1) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type ThreePicV1 struct {
|
||
*Base
|
||
Covers []string `json:"covers,omitempty"`
|
||
Desc1 string `json:"desc_1,omitempty"`
|
||
Desc2 string `json:"desc_2,omitempty"`
|
||
Avatar *Avatar `json:"avatar,omitempty"`
|
||
TitleLeftText1 string `json:"title_left_text_1,omitempty"`
|
||
TitleLeftText2 string `json:"title_left_text_2,omitempty"`
|
||
CoverRightText string `json:"cover_right_text,omitempty"`
|
||
CoverRightBackgroundColor string `json:"cover_right_background_color,omitempty"`
|
||
TopRcmdReason string `json:"top_rcmd_reason,omitempty"`
|
||
BottomRcmdReason string `json:"bottom_rcmd_reason,omitempty"`
|
||
TopRcmdReasonStyle *ReasonStyle `json:"top_rcmd_reason_style,omitempty"`
|
||
BottomRcmdReasonStyle *ReasonStyle `json:"bottom_rcmd_reason_style,omitempty"`
|
||
}
|
||
|
||
func (c *ThreePicV1) From(main interface{}, op *operate.Card) {
|
||
if op == nil {
|
||
return
|
||
}
|
||
var (
|
||
button interface{}
|
||
avatar *AvatarStatus
|
||
upID int64
|
||
)
|
||
switch main.(type) {
|
||
case map[int64]*bplus.Picture:
|
||
pm := main.(map[int64]*bplus.Picture)
|
||
p, ok := pm[op.ID]
|
||
if !ok || len(p.Imgs) < 3 || p.ViewCount == 0 {
|
||
return
|
||
}
|
||
c.Base.from(op.Param, "", p.DynamicText, model.GotoPicture, strconv.FormatInt(p.DynamicID, 10), nil)
|
||
c.Covers = p.Imgs[:3]
|
||
c.TitleLeftText1 = model.PictureViewString(p.ViewCount)
|
||
c.TitleLeftText2 = model.ArticleReplyString(p.CommentCount)
|
||
if p.ImgCount > 3 {
|
||
c.CoverRightText = model.PictureCountString(p.ImgCount)
|
||
c.CoverRightBackgroundColor = "#66666666"
|
||
}
|
||
c.Desc1 = p.NickName
|
||
c.Desc2 = model.PubDataString(p.PublishTime.Time())
|
||
avatar = &AvatarStatus{Cover: p.FaceImg, Goto: model.GotoDynamicMid, Param: strconv.FormatInt(p.Mid, 10), Type: model.AvatarRound}
|
||
button = p
|
||
upID = p.Mid
|
||
default:
|
||
log.Warn("ThreePicV1 From: unexpected type %T", main)
|
||
}
|
||
if c.Rcmd != nil {
|
||
c.TopRcmdReason, c.BottomRcmdReason = TopBottomRcmdReason(c.Rcmd.RcmdReason, c.IsAttenm[upID], c.Cardm)
|
||
c.TopRcmdReasonStyle = topReasonStyleFrom(c.Rcmd, c.TopRcmdReason, c.Base.Goto)
|
||
c.BottomRcmdReasonStyle = bottomReasonStyleFrom(c.Rcmd, c.BottomRcmdReason, c.Base.Goto)
|
||
}
|
||
c.Avatar = avatarFrom(avatar)
|
||
c.DescButton = buttonFrom(button, op.Plat)
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *ThreePicV1) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type SmallCoverV5 struct {
|
||
*Base
|
||
Up *Up `json:"up,omitempty"`
|
||
CoverRightText1 string `json:"cover_right_text_1,omitempty"`
|
||
RightDesc1 string `json:"right_desc_1,omitempty"`
|
||
RightDesc2 string `json:"right_desc_2,omitempty"`
|
||
CanPlay int32 `json:"can_play,omitempty"`
|
||
RcmdReasonStyle *ReasonStyle `json:"rcmd_reason_style,omitempty"`
|
||
}
|
||
|
||
type Up struct {
|
||
ID int64 `json:"id,omitempty"`
|
||
Name string `json:"name,omitempty"`
|
||
Desc string `json:"desc,omitempty"`
|
||
Avatar *Avatar `json:"avatar,omitempty"`
|
||
OfficialIcon model.Icon `json:"official_icon,omitempty"`
|
||
DescButton *Button `json:"desc_button,omitempty"`
|
||
Cooperation string `json:"cooperation,omitempty"`
|
||
}
|
||
|
||
func (c *SmallCoverV5) From(main interface{}, op *operate.Card) {
|
||
if op == nil {
|
||
return
|
||
}
|
||
var (
|
||
button interface{}
|
||
avatar *AvatarStatus
|
||
rcmdReason string
|
||
)
|
||
switch main.(type) {
|
||
case map[int64]*archive.ArchiveWithPlayer:
|
||
am := main.(map[int64]*archive.ArchiveWithPlayer)
|
||
a, ok := am[op.ID]
|
||
if !ok || !model.AvIsNormal(a) {
|
||
return
|
||
}
|
||
c.Base.from(op.Param, a.Pic, a.Title, model.GotoAv, op.URI, model.AvPlayHandler(a.Archive3, a.PlayerInfo, op.TrackID))
|
||
c.CoverRightText1 = model.DurationString(a.Duration)
|
||
if c.Rcmd != nil {
|
||
rcmdReason, _ = TopBottomRcmdReason(c.Rcmd.RcmdReason, c.IsAttenm[a.Author.Mid], c.Cardm)
|
||
c.RcmdReasonStyle = topReasonStyleFrom(c.Rcmd, rcmdReason, c.Base.Goto)
|
||
}
|
||
switch op.CardGoto {
|
||
case model.CardGotoAv:
|
||
var (
|
||
authorface = a.Author.Face
|
||
authorname = a.Author.Name
|
||
)
|
||
if (authorface == "" || authorname == "") && c.Cardm != nil {
|
||
if au, ok := c.Cardm[a.Author.Mid]; ok {
|
||
authorface = au.Face
|
||
authorname = au.Name
|
||
}
|
||
}
|
||
switch c.Rcmd.Style {
|
||
case model.HotCardStyleShowUp:
|
||
c.Up = &Up{
|
||
ID: a.Author.Mid,
|
||
Name: authorname,
|
||
}
|
||
if stat, ok := c.Statm[a.Author.Mid]; ok {
|
||
c.Up.Desc = model.AttentionString(int32(stat.Follower))
|
||
}
|
||
avatar = &AvatarStatus{Cover: authorface, Goto: model.GotoMid, Param: strconv.FormatInt(a.Author.Mid, 10), Type: model.AvatarRound}
|
||
c.Up.Avatar = avatarFrom(avatar)
|
||
c.Up.OfficialIcon = model.OfficialIcon(c.Cardm[a.Author.Mid])
|
||
c.RightDesc1 = model.ArchiveViewString(a.Stat.View) + " · " + model.PubDataString(a.PubDate.Time())
|
||
button = &ButtonStatus{Goto: model.GotoMid, Param: strconv.FormatInt(a.Author.Mid, 10), IsAtten: c.IsAttenm[a.Author.Mid]}
|
||
c.Up.DescButton = buttonFrom(button, op.Plat)
|
||
if a.Rights.IsCooperation > 0 {
|
||
c.Up.Cooperation = "等联合创作"
|
||
}
|
||
default:
|
||
if op.Switch != model.SwitchCooperationHide {
|
||
c.RightDesc1 = unionAuthor(a)
|
||
} else {
|
||
c.RightDesc1 = authorname
|
||
}
|
||
c.RightDesc2 = model.ArchiveViewString(a.Stat.View) + " · " + model.PubDataString(a.PubDate.Time())
|
||
}
|
||
// c.CanPlay = a.Rights.Autoplay
|
||
default:
|
||
log.Warn("SmallCoverV5 From: unexpected type %T", main)
|
||
return
|
||
}
|
||
}
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *SmallCoverV5) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
// Option struct.
|
||
type Option struct {
|
||
*Base
|
||
Option []string `json:"option,omitempty"`
|
||
}
|
||
|
||
// From is.
|
||
func (c *Option) From(main interface{}, op *operate.Card) {
|
||
if op == nil {
|
||
return
|
||
}
|
||
switch main.(type) {
|
||
case []string:
|
||
os := main.([]string)
|
||
if len(os) == 0 {
|
||
return
|
||
}
|
||
c.Base.from(op.Param, "", "选择感兴趣的内容", "", "", nil)
|
||
c.Option = os
|
||
c.DescButton = &Button{Text: "选好啦，刷新首页"}
|
||
default:
|
||
log.Warn("Option From: unexpected type %T", main)
|
||
return
|
||
}
|
||
c.Right = true
|
||
}
|
||
|
||
// Get is.
|
||
func (c *Option) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type DynamicHot struct {
|
||
*Base
|
||
TopLeftTitle string `json:"top_left_title,omitempty"`
|
||
Desc1 string `json:"desc1,omitempty"`
|
||
Desc2 string `json:"desc2,omitempty"`
|
||
MoreURI string `json:"more_uri,omitempty"`
|
||
MoreText string `json:"more_text,omitempty"`
|
||
Covers []string `json:"covers,omitempty"`
|
||
CoverRightText string `json:"cover_right_text,omitempty"`
|
||
TopRcmdReasonStyle *ReasonStyle `json:"top_rcmd_reason_style,omitempty"`
|
||
}
|
||
|
||
func (c *DynamicHot) From(main interface{}, op *operate.Card) {
|
||
if op == nil {
|
||
return
|
||
}
|
||
switch main.(type) {
|
||
case []*live.DynamicHot:
|
||
lds := main.([]*live.DynamicHot)
|
||
if len(lds) == 0 {
|
||
return
|
||
}
|
||
ld := lds[0]
|
||
c.Base.from("", "", "", model.GotoHotDynamic, strconv.FormatInt(ld.ID, 10), nil)
|
||
c.TopLeftTitle = "热门动态"
|
||
c.MoreURI = "bilibili://following/recommend"
|
||
c.MoreText = "查看更多"
|
||
c.Title = ld.DynamicText
|
||
if len(ld.Imgs) < 3 {
|
||
return
|
||
}
|
||
c.Covers = ld.Imgs[:3]
|
||
c.CoverRightText = strconv.Itoa(ld.ImgCount) + "P"
|
||
c.Desc1 = ld.NickName
|
||
var tmpdesc string
|
||
if ld.ViewCount > 0 {
|
||
tmpdesc = model.PictureViewString(ld.ViewCount)
|
||
}
|
||
if tmpdesc != "" && ld.CommentCount > 0 {
|
||
tmpdesc = tmpdesc + " " + model.ArticleReplyString(ld.CommentCount)
|
||
} else if ld.CommentCount > 0 {
|
||
tmpdesc = model.ArticleReplyString(ld.CommentCount)
|
||
}
|
||
if tmpdesc != "" {
|
||
c.Desc2 = model.PictureViewString(ld.ViewCount) + " " + model.ArticleReplyString(ld.CommentCount)
|
||
}
|
||
if ld.RcmdReason != "" {
|
||
c.TopRcmdReasonStyle = reasonStyleFrom(model.BgColorOrange, ld.RcmdReason)
|
||
}
|
||
default:
|
||
log.Warn("DynamicHot From: unexpected type %T", main)
|
||
return
|
||
}
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *DynamicHot) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type ThreeItemAllV2 struct {
|
||
*Base
|
||
DescButton *Button `json:"desc_button,omitempty"`
|
||
TopRcmdReasonStyle *ReasonStyle `json:"top_rcmd_reason_style,omitempty"`
|
||
Items []*TwoItemHV1Item `json:"item,omitempty"`
|
||
}
|
||
|
||
type ThreeItemAllV2Item struct {
|
||
Title string `json:"title,omitempty"`
|
||
Cover string `json:"cover,omitempty"`
|
||
URI string `json:"uri,omitempty"`
|
||
Param string `json:"param,omitempty"`
|
||
Args Args `json:"args,omitempty"`
|
||
Goto string `json:"goto,omitempty"`
|
||
CoverLeftText1 string `json:"cover_left_text_1,omitempty"`
|
||
CoverLeftIcon1 model.Icon `json:"cover_left_icon_1,omitempty"`
|
||
CoverRightText string `json:"cover_right_text,omitempty"`
|
||
}
|
||
|
||
func (c *ThreeItemAllV2) From(main interface{}, op *operate.Card) {
|
||
if op == nil {
|
||
return
|
||
}
|
||
au, ok := c.Cardm[op.ID]
|
||
if !ok {
|
||
return
|
||
}
|
||
c.Base.from(op.Param, au.Face, au.Name, model.GotoMid, op.Param, nil)
|
||
button := &ButtonStatus{Goto: model.GotoMid, Param: strconv.FormatInt(op.ID, 10), IsAtten: c.IsAttenm[op.ID]}
|
||
c.DescButton = buttonFrom(button, op.Plat)
|
||
if op.Desc != "" {
|
||
c.TopRcmdReasonStyle = reasonStyleFrom(model.BgColorOrange, op.Desc)
|
||
}
|
||
switch main.(type) {
|
||
case map[int64]*archive.ArchiveWithPlayer:
|
||
for _, item := range op.Items {
|
||
am := main.(map[int64]*archive.ArchiveWithPlayer)
|
||
var (
|
||
a *archive.ArchiveWithPlayer
|
||
ok bool
|
||
)
|
||
if a, ok = am[item.ID]; !ok {
|
||
continue
|
||
}
|
||
args := Args{}
|
||
args.fromArchive(a.Archive3, c.Tagm[op.Tid])
|
||
c.Items = append(c.Items, &TwoItemHV1Item{
|
||
Title: a.Title,
|
||
Cover: a.Pic,
|
||
URI: model.FillURI(model.GotoAv, strconv.FormatInt(item.ID, 10), model.AvPlayHandler(a.Archive3, nil, "")),
|
||
Goto: string(model.GotoAv),
|
||
Param: strconv.FormatInt(item.ID, 10),
|
||
CoverLeftText1: model.StatString(a.Stat.View, ""),
|
||
CoverLeftIcon1: model.IconPlay,
|
||
CoverRightText: model.DurationString(a.Duration),
|
||
Args: args,
|
||
})
|
||
}
|
||
if len(c.Items) < 3 {
|
||
return
|
||
}
|
||
}
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *ThreeItemAllV2) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type MiddleCoverV3 struct {
|
||
*Base
|
||
Desc1 string `json:"desc1,omitempty"`
|
||
Desc2 string `json:"desc2,omitempty"`
|
||
CoverBadge *ReasonStyle `json:"cover_badge_style,omitempty"`
|
||
}
|
||
|
||
func (c *MiddleCoverV3) From(main interface{}, op *operate.Card) {
|
||
if op == nil {
|
||
return
|
||
}
|
||
c.Base.from(op.Param, op.Cover, op.Title, model.GotoWeb, op.URI, nil)
|
||
c.Goto = op.Goto
|
||
if op.Badge != "" {
|
||
c.CoverBadge = reasonStyleFrom(model.BgColorPurple, op.Badge)
|
||
}
|
||
c.Desc1 = op.Desc
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *MiddleCoverV3) Get() *Base {
|
||
return c.Base
|
||
}
|
||
|
||
type Select struct {
|
||
*Base
|
||
Desc string `json:"desc,omitempty"`
|
||
LeftButton *Button `json:"left_button,omitempty"`
|
||
RightButton *Button `json:"right_button,omitempty"`
|
||
}
|
||
|
||
func (c *Select) From(main interface{}, op *operate.Card) {
|
||
if op == nil {
|
||
return
|
||
}
|
||
switch main.(type) {
|
||
case nil:
|
||
switch op.CardGoto {
|
||
case model.CardGotoFollowMode:
|
||
if len(op.Buttons) < 2 {
|
||
return
|
||
}
|
||
c.Base.from(op.Param, "", op.Title, "", "", nil)
|
||
c.Desc = op.Desc
|
||
c.LeftButton = buttonFrom(&ButtonStatus{Text: op.Buttons[0].Text, Event: model.Event(op.Buttons[0].Event)}, op.Plat)
|
||
c.RightButton = buttonFrom(&ButtonStatus{Text: op.Buttons[1].Text, Event: model.Event(op.Buttons[1].Event)}, op.Plat)
|
||
default:
|
||
log.Warn("Select From: unexpected card_goto %s", op.CardGoto)
|
||
return
|
||
}
|
||
default:
|
||
log.Warn("Select From: unexpected type %T", main)
|
||
return
|
||
}
|
||
c.Right = true
|
||
}
|
||
|
||
func (c *Select) Get() *Base {
|
||
return c.Base
|
||
}
|