1280 lines
45 KiB
Go
1280 lines
45 KiB
Go
package v1
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"net/url"
|
||
"reflect"
|
||
"strconv"
|
||
"sync/atomic"
|
||
"time"
|
||
|
||
v1indexpb "go-common/app/interface/live/app-interface/api/http/v1"
|
||
"go-common/app/interface/live/app-interface/conf"
|
||
"go-common/app/interface/live/app-interface/dao"
|
||
liveuserV1 "go-common/app/service/live/live_user/api/liverpc/v1"
|
||
relationV2 "go-common/app/service/live/relation/api/liverpc/v2"
|
||
roomV1 "go-common/app/service/live/room/api/liverpc/v1"
|
||
roomV2 "go-common/app/service/live/room/api/liverpc/v2"
|
||
bannerV1 "go-common/app/service/live/room_ex/api/liverpc/v1"
|
||
"go-common/app/service/live/third_api/bvc"
|
||
userextV1 "go-common/app/service/live/userext/api/liverpc/v1"
|
||
"go-common/library/ecode"
|
||
"go-common/library/log"
|
||
"go-common/library/net/metadata"
|
||
"go-common/library/net/rpc/liverpc"
|
||
rpcCtx "go-common/library/net/rpc/liverpc/context"
|
||
"go-common/library/sync/errgroup"
|
||
"go-common/library/xstr"
|
||
|
||
"math/rand"
|
||
|
||
"github.com/bitly/go-simplejson"
|
||
"github.com/pkg/errors"
|
||
|
||
"go-common/library/net/http/blademaster"
|
||
)
|
||
|
||
const (
|
||
_bannerType = 1
|
||
_navigatorType = 2
|
||
_yunyingRecFormType = 3
|
||
_yunyingRecSquareType = 4
|
||
_recFormType = 6
|
||
_recSquareType = 7
|
||
_feedType = 8
|
||
_parentAreaFormType = 9
|
||
_parentAreaSquareType = 10
|
||
_myAreaTagType = 12
|
||
_seaPatrolType = 14
|
||
_myAreaTagListType = 13
|
||
_activityType = 11
|
||
|
||
// _recTypeOnline = 1
|
||
// _recTypeIncome = 2
|
||
_recTypeForce = 3
|
||
_recTypeSkyHorse = 4
|
||
|
||
_defaultRecNum = 24
|
||
|
||
_skyHorseRecTimeOut = 100
|
||
|
||
_areaModuleLink = "https://live.bilibili.com/app/area?parent_area_id=%d&parent_area_name=%s&area_id=%d&area_name=%s"
|
||
|
||
_activityGo = 0
|
||
_activityBook = 1
|
||
_activityUnbook = 2
|
||
|
||
_mobileIndexBadgeColorDefault = "#FB9E60"
|
||
)
|
||
|
||
// Service struct
|
||
type Service struct {
|
||
conf *conf.Config
|
||
// optionally add other properties here, such as dao
|
||
dao *dao.Dao
|
||
allListInfo atomic.Value
|
||
}
|
||
|
||
type roomItem struct {
|
||
RoomId int64 `json:"roomid"`
|
||
Title string `json:"title"`
|
||
Uname string `json:"uname"`
|
||
Online int64 `json:"online"`
|
||
Cover string `json:"cover"`
|
||
Link string `json:"link"`
|
||
Face string `json:"face"`
|
||
AreaV2ParentId int64 `json:"area_v2_parent_id"`
|
||
AreaV2ParentName string `json:"area_v2_parent_name"`
|
||
AreaV2Id int64 `json:"area_v2_id"`
|
||
AreaV2Name string `json:"area_v2_name"`
|
||
PlayUrl string `json:"play_url"`
|
||
PlayUrlH265 string `json:"play_url_h265"`
|
||
CurrentQuality int64 `json:"current_quality"`
|
||
BroadcastType int64 `json:"broadcast_type"`
|
||
PendentRu string `json:"pendent_ru"`
|
||
PendentRuPic string `json:"pendent_ru_pic"`
|
||
PendentRuColor string `json:"pendent_ru_color"`
|
||
RecType int64 `json:"rec_type"`
|
||
PkId int64 `json:"pk_id"`
|
||
AcceptQuality []int64 `json:"accept_quality"`
|
||
}
|
||
|
||
type offlineItem struct {
|
||
Id int `json:"id"`
|
||
Name string `json:"name"`
|
||
}
|
||
|
||
type userTagItem struct {
|
||
AreaV2Id int `json:"area_v2_id"`
|
||
AreaV2Name string `json:"area_v2_name"`
|
||
AreaV2ParentId int `json:"area_v2_parent_id"`
|
||
AreaV2ParentName string `json:"area_v2_parent_name"`
|
||
Pic string `json:"pic"`
|
||
Link string `json:"link"`
|
||
IsAdvice int `json:"is_advice"`
|
||
}
|
||
|
||
type commonResp struct {
|
||
ModuleInfo map[string]interface{}
|
||
ExtraInfo map[string]interface{}
|
||
List interface{}
|
||
}
|
||
|
||
type ModuleResp struct {
|
||
Interval int `json:"interval"`
|
||
ModuleList []map[string]interface{} `json:"module_list"`
|
||
}
|
||
|
||
// New init
|
||
func New(c *conf.Config) (s *Service) {
|
||
s = &Service{
|
||
conf: c,
|
||
dao: dao.New(c),
|
||
}
|
||
go s.tickCacheAllList(context.TODO())
|
||
return s
|
||
}
|
||
|
||
// GetAllList implementation
|
||
// 首页大接口
|
||
func (s *Service) GetAllList(ctx context.Context, req *v1indexpb.GetAllListReq) (ret interface{}, err error) {
|
||
resp := &ModuleResp{
|
||
Interval: 10,
|
||
}
|
||
build := req.Build
|
||
relationTimeout := conf.GetTimeout("relation", 200)
|
||
// dao.LiveUserApi.V1UserSetting.GetTag(ctx, &liveuserV1.UserSettingGetTagReq{})
|
||
midInterface, isUIDSet := metadata.Value(ctx, metadata.Mid).(int64) // 大多使用header里的mid解析, 框架已封装请求的header
|
||
isSkyHorseGray := false
|
||
mid := int64(0)
|
||
if isUIDSet {
|
||
mid = midInterface
|
||
// 天马灰度
|
||
isSkyHorseGray = s.isSkyHorseRec(mid)
|
||
}
|
||
|
||
buvid := ""
|
||
// 主站封好的，可从device里获取到sid、buvid、buvid3、build、channel、device、mobi_app、platform
|
||
device, ok := metadata.Value(ctx, metadata.Device).(*blademaster.Device)
|
||
if ok {
|
||
buvid = device.Buvid
|
||
}
|
||
// deviceInterface := req.Device
|
||
// device := deviceInterface.(*bm.Device)
|
||
if req.Platform == "" || req.Device == "" || req.Scale == "" || req.RelationPage == 0 {
|
||
err = errors.WithMessage(ecode.InvalidParam, "INVALID PARAM")
|
||
return
|
||
}
|
||
|
||
allListTimeout := time.Duration(conf.GetTimeout("allList", 50)) * time.Millisecond
|
||
rawModuleList := s.getAllListFromCache(rpcCtx.WithTimeout(ctx, allListTimeout))
|
||
|
||
if rawModuleList == nil {
|
||
err = errors.WithMessage(ecode.GetAllListReturnError, "")
|
||
return
|
||
}
|
||
|
||
// 大分区常量定义
|
||
parentName := map[int64]string{
|
||
1: "娱乐",
|
||
2: "游戏",
|
||
3: "手游",
|
||
4: "绘画",
|
||
5: "电台",
|
||
}
|
||
|
||
// 天马灰度/保底
|
||
defaultRecSlice := make([]map[string]interface{}, 0)
|
||
loginRecRoomIDSlice := make([]int64, 0)
|
||
// [{module_info:{},list:{}}...]
|
||
resp.ModuleList = make([]map[string]interface{}, len(rawModuleList))
|
||
for _, m := range rawModuleList {
|
||
module := m.(map[string]interface{})
|
||
if module["module_info"] == nil {
|
||
log.Error("empty_module_info:%+v \n", m)
|
||
fmt.Printf("empty_module_info:raw_all:%+v \n", rawModuleList)
|
||
}
|
||
moduleInfo := module["module_info"].(map[string]interface{})
|
||
moduleType := jsonMustInt(moduleInfo["type"], 0)
|
||
if moduleType == 0 {
|
||
continue
|
||
}
|
||
list := module["list"].([]interface{})
|
||
if moduleType == _recFormType || moduleType == _recSquareType {
|
||
for _, r := range list {
|
||
recItem := r.(map[string]interface{})
|
||
defaultRecSlice = append(defaultRecSlice, recItem)
|
||
roomID := jsonMustInt(recItem["roomid"], 0)
|
||
if roomID == 0 {
|
||
continue
|
||
}
|
||
// 登录了也有可能请求不到数据，登录的保底用
|
||
loginRecRoomIDSlice = append(loginRecRoomIDSlice, roomID)
|
||
}
|
||
}
|
||
}
|
||
// 常用标签 roomListMap
|
||
myTagRoomListMap := make(map[int64][]*roomV2.AppIndexGetMultiRoomListResp_RoomList)
|
||
myTagAreaIds := make([]int64, 0, 4)
|
||
myTagAreaInfoMap := make(map[int64]*liveuserV1.UserSettingGetTagResp_Tags)
|
||
|
||
myTagResp := commonResp{
|
||
List: make([]interface{}, 0),
|
||
}
|
||
attentionResp := commonResp{
|
||
List: make([]interface{}, 0),
|
||
}
|
||
loginRecResp := commonResp{}
|
||
seaResp := commonResp{}
|
||
bannerResp := commonResp{
|
||
List: make([]interface{}, 0),
|
||
}
|
||
// playurl定义
|
||
attentionRoomListPlayURLMap := make(map[int64]*bvc.PlayUrlItem)
|
||
loginRecRoomListPlayURLMap := make(map[int64]*bvc.PlayUrlItem)
|
||
myTagRoomListPlayURLMap := make(map[int64]*bvc.PlayUrlItem)
|
||
otherRoomListPlayURLMap := make(map[int64]*bvc.PlayUrlItem)
|
||
otherRoomIDSlice := make([]int64, 0)
|
||
|
||
isSkyHorseGrayOk := 0
|
||
|
||
// 此group包含首页的一些任务
|
||
// 但是任务之间不能同时cancel
|
||
// 不然一个接口出错所有任务都cancel首页就空了
|
||
// 所以return固定为nil(一个wg的任务使用的是从bm context继承来的ctx，cancel后一起推出)
|
||
// 只有上层ctx（http的ctx）出问题（超时等）才会退出后续任务1
|
||
wg, _ := errgroup.WithContext(ctx)
|
||
for _, m := range rawModuleList {
|
||
// {module_info:xx}
|
||
module := m.(map[string]interface{})
|
||
// {id:xx,type:xx,pic:xx,title:xx,link:xx,...}
|
||
moduleInfo := module["module_info"].(map[string]interface{})
|
||
moduleList := module["list"].([]interface{})
|
||
moduleType := jsonMustInt(moduleInfo["type"], 0)
|
||
if moduleType == 0 {
|
||
continue
|
||
}
|
||
// banner分支 分端分版本
|
||
if moduleType == _bannerType {
|
||
bannerTimeout := time.Duration(conf.GetTimeout("banner", 100)) * time.Millisecond
|
||
wg.Go(func() error {
|
||
bannerList, bannerErr := dao.RoomExtApi.V1Banner.GetNewBanner(rpcCtx.WithTimeout(ctx, time.Duration(bannerTimeout)*time.Millisecond), &bannerV1.BannerGetNewBannerReq{UserPlatform: req.Platform, Build: build, UserDevice: req.Device})
|
||
if bannerErr != nil {
|
||
log.Error("[GetAllList]get banner rpc error, roomex.v1.Banner.GetNewBanner, error:%+v,rpctimeout:%d", bannerErr, bannerTimeout)
|
||
return nil
|
||
}
|
||
if bannerList.Code != 0 || bannerList.Data == nil {
|
||
log.Error("[GetAllList]get banner response error, code, %d, msg: %s, error:%+v", bannerList.Code, bannerList.Msg, bannerErr)
|
||
return nil
|
||
}
|
||
if len(bannerList.Data) > 0 {
|
||
for _, bannerInfo := range bannerList.Data {
|
||
bannerResp.List = append(bannerResp.List.([]interface{}), map[string]interface{}{
|
||
"id": bannerInfo.Id,
|
||
"pic": bannerInfo.Pic,
|
||
"link": bannerInfo.Link,
|
||
"title": bannerInfo.Title,
|
||
})
|
||
}
|
||
}
|
||
return nil
|
||
})
|
||
}
|
||
// 关注分支
|
||
if moduleType == _feedType {
|
||
if !isUIDSet {
|
||
continue
|
||
}
|
||
wg.Go(func() error {
|
||
currentAttentionRoomMap := make(map[int64]bool)
|
||
currentAttentionRoomSlice := make([]int64, 0)
|
||
attentionResp.ModuleInfo = moduleInfo
|
||
currentAttention, attentionErr := dao.RelationApi.V2App.LiveHomePage(rpcCtx.WithTimeout(ctx, time.Duration(relationTimeout)*time.Millisecond), &relationV2.AppLiveHomePageReq{RelationPage: req.RelationPage})
|
||
if attentionErr != nil {
|
||
log.Error("[GetAllList]get user attention rpc error, relation.v2.App.liveHomePage, error:%+v,rpctimeout:%d", attentionErr, relationTimeout)
|
||
} else if currentAttention.Code != 0 || currentAttention.Data == nil {
|
||
log.Error("[GetAllList]get user attention response error, code, %d, msg: %s, error:%+v", currentAttention.Code, currentAttention.Msg, attentionErr)
|
||
} else {
|
||
attentionResp.ExtraInfo = map[string]interface{}{
|
||
"total_count": currentAttention.Data.TotalCount,
|
||
"time_desc": currentAttention.Data.TimeDesc,
|
||
"uname_desc": currentAttention.Data.UnameDesc,
|
||
"tags_desc": currentAttention.Data.TagsDesc,
|
||
"relation_page": currentAttention.Data.RelationPage,
|
||
}
|
||
// 存关注map
|
||
for _, attentionCard := range currentAttention.Data.Rooms {
|
||
currentAttentionRoomMap[attentionCard.Roomid] = true
|
||
currentAttentionRoomSlice = append(currentAttentionRoomSlice, attentionCard.Roomid)
|
||
attentionResp.List = append(attentionResp.List.([]interface{}), attentionCard)
|
||
}
|
||
// playurl
|
||
attentionRoomListPlayURLMap = dao.BvcApi.GetPlayUrlMulti(ctx, currentAttentionRoomSlice, 0, 4, build, req.Platform)
|
||
}
|
||
useDefaultRec := false
|
||
isOpen := conf.Conf.SkyHorseStatus
|
||
if isOpen && isSkyHorseGray {
|
||
// 取天马数据，传入关注当前刷列表roomid+强推，天马会对传入的roomid去重
|
||
// duplicates := append(currentAttentionRoomSlice, forceRecSlice...)
|
||
// getSkyHorseRoomList已经对强推去重
|
||
duplicates := currentAttentionRoomSlice
|
||
skyRecResult, skyHorseErr := getSkyHorseRoomList(ctx, mid, buvid, req.Build, req.Platform, duplicates, 1)
|
||
if skyHorseErr != nil {
|
||
log.Warn("[GetAllList]get data from skyHorse err: %v", skyHorseErr)
|
||
useDefaultRec = true
|
||
}
|
||
if skyRecResult == nil {
|
||
log.Warn("[GetAllList]get data from skyHorse empty: %v", skyHorseErr)
|
||
useDefaultRec = true
|
||
}
|
||
if len(skyRecResult) < 6 {
|
||
log.Warn("[GetAllList]get data from skyHorse not enough: %v", skyRecResult)
|
||
useDefaultRec = true
|
||
}
|
||
skyRecResultInterface := make([]map[string]interface{}, 0)
|
||
for _, item := range skyRecResult {
|
||
loginRecRoomIDSlice = append(loginRecRoomIDSlice, item.RoomId)
|
||
skyRecResultInterface = append(skyRecResultInterface, map[string]interface{}{
|
||
"roomid": item.RoomId,
|
||
"title": item.Title,
|
||
"uname": item.Uname,
|
||
"online": item.Online,
|
||
"cover": item.Cover,
|
||
"link": item.Link,
|
||
"face": item.Face,
|
||
"area_v2_parent_id": item.AreaV2ParentId,
|
||
"area_v2_parent_name": item.AreaV2ParentName,
|
||
"area_v2_id": item.AreaV2Id,
|
||
"area_v2_name": item.AreaV2Name,
|
||
"play_url": item.PlayUrl,
|
||
"current_quality": item.CurrentQuality,
|
||
"broadcast_type": item.BroadcastType,
|
||
"pendent_ru": item.PendentRu,
|
||
"pendent_ru_pic": item.PendentRuPic,
|
||
"pendent_ru_color": item.PendentRuColor,
|
||
"rec_type": item.RecType,
|
||
"pk_id": item.PkId,
|
||
"accept_quality": item.AcceptQuality,
|
||
})
|
||
}
|
||
loginRecResp.List = skyRecResultInterface
|
||
isSkyHorseGrayOk = 1
|
||
}
|
||
// 保底逻辑
|
||
if !isOpen || !isSkyHorseGray || useDefaultRec {
|
||
newDefaultRecSlice := make([]map[string]interface{}, 0)
|
||
for _, defaultRecRoom := range defaultRecSlice {
|
||
roomID := jsonMustInt(defaultRecRoom["roomid"], 0)
|
||
if roomID == 0 {
|
||
continue
|
||
}
|
||
if _, exist := currentAttentionRoomMap[roomID]; !exist {
|
||
// 天马没取到保底：默认推荐要对关注当前刷去重
|
||
newDefaultRecSlice = append(newDefaultRecSlice, defaultRecRoom)
|
||
}
|
||
}
|
||
// 只返24个
|
||
if len(newDefaultRecSlice) > _defaultRecNum {
|
||
loginRecResp.List = newDefaultRecSlice[:_defaultRecNum]
|
||
} else {
|
||
loginRecResp.List = newDefaultRecSlice
|
||
}
|
||
isSkyHorseGrayOk = 0
|
||
}
|
||
loginRecRoomListPlayURLMap = dao.BvcApi.GetPlayUrlMulti(ctx, loginRecRoomIDSlice, 0, 4, build, req.Platform)
|
||
return nil
|
||
})
|
||
}
|
||
|
||
// 常用标签分支
|
||
if moduleType == _myAreaTagType {
|
||
wg.Go(func() error {
|
||
myTagResp.ModuleInfo = moduleInfo
|
||
getMyTagTimeout := time.Duration(conf.GetTimeout("getMyTag", 100)) * time.Millisecond
|
||
myTagListResp, userTagError := dao.LiveUserApi.V1UserSetting.GetTag(rpcCtx.WithTimeout(ctx, getMyTagTimeout), &liveuserV1.UserSettingGetTagReq{})
|
||
if userTagError != nil {
|
||
log.Error("[GetAllList]get user tag rpc error, live_user.v1.usersetting.get_tag, error:%+v", userTagError)
|
||
return nil // 如果return err 则所有当前group的任务都会cancel
|
||
}
|
||
|
||
if myTagListResp.Code != 0 || myTagListResp.Data == nil {
|
||
log.Error("[GetAllList]get user tag return error, code, %d, msg: %s, error:%+v", myTagListResp.Code, myTagListResp.Msg, userTagError)
|
||
return nil
|
||
}
|
||
if myTagListResp.Data != nil {
|
||
myTagResp.ExtraInfo = make(map[string]interface{})
|
||
myTagResp.ExtraInfo["is_gray"] = myTagListResp.Data.IsGray
|
||
myTagResp.ExtraInfo["offline"] = make([]interface{}, 0)
|
||
for _, offlineInfo := range myTagListResp.Data.Offline {
|
||
myTagResp.ExtraInfo["offline"] = append(myTagResp.ExtraInfo["offline"].([]interface{}), &offlineItem{Id: int(offlineInfo.Id), Name: offlineInfo.Name})
|
||
}
|
||
}
|
||
|
||
for _, tagInfo := range myTagListResp.Data.Tags {
|
||
myTagAreaIds = append(myTagAreaIds, tagInfo.Id)
|
||
myTagAreaInfoMap[tagInfo.Id] = tagInfo
|
||
link := fmt.Sprintf("http://live.bilibili.com/app/area?parent_area_id=%d&parent_area_name=%s&area_id=%d&area_name=%s", tagInfo.ParentId, parentName[tagInfo.ParentId], tagInfo.Id, tagInfo.Name)
|
||
myTagResp.List = append(myTagResp.List.([]interface{}), &userTagItem{AreaV2Id: int(tagInfo.Id), AreaV2Name: tagInfo.Name, AreaV2ParentId: int(tagInfo.ParentId), AreaV2ParentName: parentName[tagInfo.ParentId], Link: link, Pic: tagInfo.Pic, IsAdvice: int(tagInfo.IsAdvice)})
|
||
}
|
||
if (req.Platform == "ios" && build > 8220) || (req.Platform == "android" && build > 5333002) {
|
||
myTagResp.List = append(myTagResp.List.([]interface{}), &userTagItem{AreaV2Id: int(0), AreaV2Name: "全部标签", AreaV2ParentId: int(0), AreaV2ParentName: "", Pic: "http://i0.hdslb.com/bfs/vc/ff03528785fc8c91491d79e440398484811d6d87.png", Link: "http://live.bilibili.com/app/mytag/", IsAdvice: 1})
|
||
}
|
||
if len(myTagAreaIds) <= 0 {
|
||
log.Error("[GetAllList]get user tag return empty!uid:%d", mid)
|
||
return nil
|
||
}
|
||
// 常用标签房间列表 先生成最后wait替换就好了
|
||
getMultiRoomListTimeout := time.Duration(conf.GetTimeout("getMultiRoomList", 100)) * time.Millisecond
|
||
myTagRoomListResp, multiRoomListErr := dao.RoomApi.V2AppIndex.GetMultiRoomList(rpcCtx.WithTimeout(ctx, getMultiRoomListTimeout), &roomV2.AppIndexGetMultiRoomListReq{AreaIds: xstr.JoinInts(myTagAreaIds), Platform: req.Platform})
|
||
|
||
if multiRoomListErr != nil {
|
||
log.Error("[GetAllList]get multi list rpc error, room.v2.AppIndex.GetMultiRoomList, error:%+v", multiRoomListErr)
|
||
return nil
|
||
}
|
||
if myTagRoomListResp.Code != 0 || myTagRoomListResp.Data == nil {
|
||
log.Error("[GetAllList]get multi list response error, code, %d, msg: %s, error:%+v", myTagRoomListResp.Code, myTagRoomListResp.Msg, multiRoomListErr)
|
||
return nil
|
||
}
|
||
// 保存roomListMap，wait 聚合数据
|
||
myTagRoomIDSlice := make([]int64, 0)
|
||
for _, myTagRoomItem := range myTagRoomListResp.Data {
|
||
myTagRoomListMap[myTagRoomItem.Id] = myTagRoomItem.List
|
||
for _, item := range myTagRoomItem.List {
|
||
myTagRoomIDSlice = append(myTagRoomIDSlice, item.Roomid)
|
||
}
|
||
}
|
||
myTagRoomListPlayURLMap = dao.BvcApi.GetPlayUrlMulti(ctx, myTagRoomIDSlice, 0, 4, build, req.Platform)
|
||
|
||
return nil
|
||
})
|
||
}
|
||
|
||
if moduleType == _seaPatrolType {
|
||
seaPatrolList := make([]interface{}, 0)
|
||
if !isUIDSet {
|
||
continue
|
||
}
|
||
// 大航海分支
|
||
wg.Go(func() error {
|
||
seaPatrolTimeout := time.Duration(conf.GetTimeout("seaPatrol", 100)) * time.Millisecond
|
||
seaPatrol, seaPatrolError := dao.LiveUserApi.V1Note.Get(rpcCtx.WithTimeout(ctx, seaPatrolTimeout), &liveuserV1.NoteGetReq{})
|
||
if seaPatrolError != nil {
|
||
log.Error("[GetAllList]get sea patrol rpc error, liveuser.v1.Note.Get, error:%+v", seaPatrolError)
|
||
return nil
|
||
}
|
||
if seaPatrol.Code != 0 || seaPatrol.Data == nil {
|
||
log.Error("[GetAllList]get sea patrol note from liveuser response error, code, %d, msg: %s, error:%+v", seaPatrol.Code, seaPatrol.Msg, seaPatrolError)
|
||
return nil
|
||
}
|
||
|
||
if seaPatrol.Data.Title != "" {
|
||
seaPatrolList = append(seaPatrolList, map[string]interface{}{
|
||
"pic": seaPatrol.Data.Logo,
|
||
"title": seaPatrol.Data.Title,
|
||
"link": seaPatrol.Data.Link,
|
||
"content": seaPatrol.Data.Content,
|
||
})
|
||
}
|
||
seaResp.List = seaPatrolList
|
||
seaResp.ModuleInfo = moduleInfo
|
||
seaResp.ExtraInfo = make(map[string]interface{})
|
||
return nil
|
||
})
|
||
}
|
||
|
||
if moduleType == _activityType {
|
||
cardList := module["list"].([]interface{})
|
||
actyInfo := cardList[0].(map[string]interface{})
|
||
bookStatus := jsonMustInt(actyInfo["status"], 0)
|
||
// status=0(非预约类型的活动)
|
||
if bookStatus == _activityGo {
|
||
actyInfo["button_text"] = "去围观"
|
||
actyInfo["status"] = _activityGo
|
||
continue
|
||
}
|
||
// 未登入 显示预约
|
||
if !isUIDSet {
|
||
actyInfo["button_text"] = "预约"
|
||
actyInfo["status"] = _activityBook
|
||
continue
|
||
}
|
||
// 登入状态 设置保底数据
|
||
actyInfo["button_text"] = "去围观"
|
||
actyInfo["status"] = _activityGo
|
||
// 获取活动id
|
||
materialID := jsonMustInt(moduleInfo["material_id"], 0)
|
||
if materialID == 0 {
|
||
continue
|
||
}
|
||
log.Info("[GetAllList]materialID is %v", materialID)
|
||
wg.Go(func() error {
|
||
activityQueryTimeout := time.Duration(conf.GetTimeout("activityQuery", 100)) * time.Millisecond
|
||
bookInfo, userExtError := dao.UserExtApi.V1Remind.Query(rpcCtx.WithTimeout(ctx, activityQueryTimeout), &userextV1.RemindQueryReq{Aid: materialID})
|
||
if userExtError != nil {
|
||
log.Error("[GetAllList]get activity book info rpc error, userext.v1.Remind.Query, error:%+v", userExtError)
|
||
return nil
|
||
}
|
||
if bookInfo.Code != 0 {
|
||
log.Error("[GetAllList]get activity book info response error, code, %d, msg: %s, error:%+v", bookInfo.Code, bookInfo.Msg, userExtError)
|
||
return nil
|
||
}
|
||
log.Info("[GetAllList]materialID is %v and bookInfo.Data.Status is %v", materialID, bookInfo.Data.Status)
|
||
switch bookInfo.Data.Status {
|
||
case _activityBook:
|
||
actyInfo["button_text"] = "已预约"
|
||
actyInfo["status"] = _activityUnbook
|
||
case _activityUnbook:
|
||
actyInfo["button_text"] = "预约"
|
||
actyInfo["status"] = _activityBook
|
||
default:
|
||
actyInfo["button_text"] = "去围观"
|
||
actyInfo["status"] = _activityGo
|
||
}
|
||
return nil
|
||
})
|
||
}
|
||
|
||
// 其他playurl，注意这里取的推荐是未登录下的推荐play_url
|
||
if moduleType == _yunyingRecFormType || moduleType == _yunyingRecSquareType ||
|
||
moduleType == _parentAreaFormType || moduleType == _parentAreaSquareType ||
|
||
moduleType == _recFormType || moduleType == _recSquareType {
|
||
// append Roomid
|
||
for _, item := range moduleList {
|
||
itemV := item.(map[string]interface{})
|
||
roomID := jsonMustInt(itemV["roomid"], 0)
|
||
if roomID == 0 {
|
||
continue
|
||
}
|
||
otherRoomIDSlice = append(otherRoomIDSlice, roomID)
|
||
}
|
||
}
|
||
}
|
||
// +其他模块playurl
|
||
wg.Go(func() error {
|
||
otherRoomListPlayURLMap = dao.BvcApi.GetPlayUrlMulti(ctx, otherRoomIDSlice, 0, 4, build, req.Platform)
|
||
return nil
|
||
})
|
||
|
||
waitErr := wg.Wait()
|
||
if waitErr != nil {
|
||
log.Error("[GetAllList]wait error: %s", waitErr)
|
||
return
|
||
}
|
||
|
||
// 封装
|
||
tagIndex := 0
|
||
for index, m := range rawModuleList {
|
||
module := m.(map[string]interface{})
|
||
moduleInfo := module["module_info"].(map[string]interface{})
|
||
moduleList := module["list"].([]interface{})
|
||
moduleType := jsonMustInt(moduleInfo["type"], 0)
|
||
if moduleType == 0 {
|
||
continue
|
||
}
|
||
// 初始化
|
||
resp.ModuleList[index] = make(map[string]interface{})
|
||
resp.ModuleList[index]["list"] = moduleList
|
||
resp.ModuleList[index]["module_info"] = moduleInfo
|
||
|
||
if moduleType == _bannerType {
|
||
resp.ModuleList[index]["list"] = bannerResp.List
|
||
}
|
||
if moduleType == _navigatorType && req.Platform == "android" && build <= 5333002 {
|
||
// 分区入口5.33版本还返回4个(前3个+全部)，5.34透传后台的5个
|
||
if len(moduleList) > 3 {
|
||
resp.ModuleList[index]["list"] = append(moduleList[:3], map[string]interface{}{
|
||
"id": 12,
|
||
"pic": "https://i0.hdslb.com/bfs/vc/ff03528785fc8c91491d79e440398484811d6d87.png",
|
||
"link": "https://live.bilibili.com/app/mytag/",
|
||
"title": "全部标签",
|
||
})
|
||
}
|
||
}
|
||
if moduleType == _seaPatrolType {
|
||
if seaResp.List != nil {
|
||
resp.ModuleList[index]["list"] = seaResp.List
|
||
}
|
||
if seaResp.ModuleInfo != nil {
|
||
resp.ModuleList[index]["module_info"] = seaResp.ModuleInfo
|
||
}
|
||
if seaResp.ExtraInfo != nil {
|
||
resp.ModuleList[index]["extra_info"] = seaResp.ExtraInfo
|
||
}
|
||
}
|
||
if moduleType == _myAreaTagType {
|
||
if myTagResp.List != nil {
|
||
resp.ModuleList[index]["list"] = myTagResp.List
|
||
}
|
||
if myTagResp.ModuleInfo != nil {
|
||
resp.ModuleList[index]["module_info"] = myTagResp.ModuleInfo
|
||
}
|
||
if myTagResp.ExtraInfo != nil {
|
||
resp.ModuleList[index]["extra_info"] = myTagResp.ExtraInfo
|
||
}
|
||
}
|
||
var isTagGray int
|
||
iTmp, _ := myTagResp.ExtraInfo["is_gray"].(int64)
|
||
isTagGray = int(iTmp)
|
||
// 常用分区房间列表填充
|
||
if moduleType == _myAreaTagListType {
|
||
if isTagGray == 0 {
|
||
continue
|
||
}
|
||
if len(myTagAreaIds) == 0 || tagIndex >= len(myTagAreaIds) {
|
||
continue
|
||
}
|
||
mTagAreaID := myTagAreaIds[tagIndex]
|
||
if _, ok := myTagRoomListMap[mTagAreaID]; ok {
|
||
for _, v := range myTagRoomListMap[mTagAreaID] {
|
||
if myTagRoomListPlayURLMap[v.Roomid] != nil {
|
||
v.AcceptQuality = myTagRoomListPlayURLMap[v.Roomid].AcceptQuality
|
||
v.CurrentQuality = myTagRoomListPlayURLMap[v.Roomid].CurrentQuality
|
||
v.PlayUrl = myTagRoomListPlayURLMap[v.Roomid].Url["h264"]
|
||
v.PlayUrlH265 = myTagRoomListPlayURLMap[v.Roomid].Url["h265"]
|
||
}
|
||
}
|
||
resp.ModuleList[index]["list"] = myTagRoomListMap[mTagAreaID]
|
||
if _, ok := myTagAreaInfoMap[mTagAreaID]; ok {
|
||
areaInfo := myTagAreaInfoMap[mTagAreaID]
|
||
moduleInfo["title"] = areaInfo.Name
|
||
moduleInfo["link"] = fmt.Sprintf(_areaModuleLink, areaInfo.ParentId, parentName[areaInfo.ParentId], areaInfo.Id, areaInfo.Name)
|
||
resp.ModuleList[index]["module_info"] = moduleInfo
|
||
}
|
||
}
|
||
tagIndex++
|
||
}
|
||
|
||
// 运营推荐分区对常用分区去重
|
||
if moduleType == _yunyingRecFormType || moduleType == _yunyingRecSquareType {
|
||
link := moduleInfo["link"]
|
||
u, err := url.Parse(link.(string))
|
||
if err != nil {
|
||
log.Warn("[GetAllList]url.Parse (%s) error: %v", link, err)
|
||
continue
|
||
}
|
||
m, err := url.ParseQuery(u.RawQuery)
|
||
if err != nil {
|
||
log.Warn("[GetAllList]url.ParseQuery (%s) error: %v", link, err)
|
||
continue
|
||
}
|
||
area, ok := m["area_id"]
|
||
if !ok {
|
||
log.Warn("[GetAllList]url ((%s) area_id lost: %v", link, ok)
|
||
continue
|
||
}
|
||
|
||
trueArea, err := strconv.Atoi(area[0])
|
||
if err != nil {
|
||
log.Warn("[GetAllList]get trueAreaId error: %v", link, ok)
|
||
continue
|
||
}
|
||
if _, ok := myTagRoomListMap[int64(trueArea)]; ok && isTagGray == 1 {
|
||
resp.ModuleList[index]["list"] = nil
|
||
} else {
|
||
for _, v := range moduleList {
|
||
if v == nil {
|
||
continue
|
||
}
|
||
vv := v.(map[string]interface{})
|
||
roomID := jsonMustInt(vv["roomid"], 0)
|
||
if roomID == 0 {
|
||
continue
|
||
}
|
||
if otherRoomListPlayURLMap[roomID] != nil {
|
||
vv["accept_quality"] = otherRoomListPlayURLMap[roomID].AcceptQuality
|
||
vv["current_quality"] = otherRoomListPlayURLMap[roomID].CurrentQuality
|
||
vv["play_url"] = otherRoomListPlayURLMap[roomID].Url["h264"]
|
||
vv["play_url_h265"] = otherRoomListPlayURLMap[roomID].Url["h265"]
|
||
}
|
||
}
|
||
|
||
resp.ModuleList[index]["list"] = moduleList
|
||
resp.ModuleList[index]["module_info"] = moduleInfo
|
||
}
|
||
}
|
||
|
||
if moduleType == _feedType {
|
||
if attentionResp.ModuleInfo != nil {
|
||
resp.ModuleList[index]["module_info"] = attentionResp.ModuleInfo
|
||
}
|
||
if attentionResp.ExtraInfo != nil {
|
||
resp.ModuleList[index]["extra_info"] = attentionResp.ExtraInfo
|
||
}
|
||
if attentionResp.List != nil {
|
||
for _, v := range attentionResp.List.([]interface{}) {
|
||
vv := v.(*relationV2.AppLiveHomePageResp_Rooms)
|
||
if attentionRoomListPlayURLMap[vv.Roomid] != nil {
|
||
vv.AcceptQuality = attentionRoomListPlayURLMap[vv.Roomid].AcceptQuality
|
||
vv.CurrentQuality = attentionRoomListPlayURLMap[vv.Roomid].CurrentQuality
|
||
vv.PlayUrl = attentionRoomListPlayURLMap[vv.Roomid].Url["h264"]
|
||
vv.PlayUrlH265 = attentionRoomListPlayURLMap[vv.Roomid].Url["h265"]
|
||
}
|
||
}
|
||
resp.ModuleList[index]["list"] = attentionResp.List
|
||
}
|
||
}
|
||
|
||
if moduleType == _recFormType || moduleType == _recSquareType {
|
||
moduleInfo["is_sky_horse_gray"] = isSkyHorseGrayOk
|
||
resp.ModuleList[index]["module_info"] = moduleInfo
|
||
if loginRecResp.List != nil {
|
||
// is uid set
|
||
for _, v := range loginRecResp.List.([]map[string]interface{}) {
|
||
roomID := int64(0)
|
||
r, ok := v["roomid"].(json.Number)
|
||
if ok {
|
||
rr, intErr := r.Int64()
|
||
if intErr != nil {
|
||
continue
|
||
}
|
||
roomID = rr
|
||
} else {
|
||
roomID = v["roomid"].(int64)
|
||
}
|
||
if roomID == 0 {
|
||
continue
|
||
}
|
||
|
||
if loginRecRoomListPlayURLMap[roomID] != nil {
|
||
v["accept_quality"] = loginRecRoomListPlayURLMap[roomID].AcceptQuality
|
||
v["current_quality"] = loginRecRoomListPlayURLMap[roomID].CurrentQuality
|
||
v["play_url"] = loginRecRoomListPlayURLMap[roomID].Url["h264"]
|
||
v["play_url_h265"] = loginRecRoomListPlayURLMap[roomID].Url["h265"]
|
||
}
|
||
}
|
||
resp.ModuleList[index]["list"] = loginRecResp.List
|
||
} else {
|
||
for _, v := range moduleList {
|
||
if v == nil {
|
||
continue
|
||
}
|
||
vv := v.(map[string]interface{})
|
||
roomID := jsonMustInt(vv["roomid"], 0)
|
||
if roomID == 0 {
|
||
continue
|
||
}
|
||
if otherRoomListPlayURLMap[roomID] != nil {
|
||
vv["accept_quality"] = otherRoomListPlayURLMap[roomID].AcceptQuality
|
||
vv["current_quality"] = otherRoomListPlayURLMap[roomID].CurrentQuality
|
||
vv["play_url"] = otherRoomListPlayURLMap[roomID].Url["h264"]
|
||
vv["play_url_h265"] = otherRoomListPlayURLMap[roomID].Url["h265"]
|
||
}
|
||
}
|
||
// 只返24个，新推荐已在上面做处理
|
||
if len(moduleList) > _defaultRecNum {
|
||
resp.ModuleList[index]["list"] = moduleList[:_defaultRecNum]
|
||
} else {
|
||
resp.ModuleList[index]["list"] = moduleList
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
if moduleType == _parentAreaFormType || moduleType == _parentAreaSquareType {
|
||
for _, v := range moduleList {
|
||
if v == nil {
|
||
continue
|
||
}
|
||
vv := v.(map[string]interface{})
|
||
roomID := jsonMustInt(vv["roomid"], 0)
|
||
if roomID == 0 {
|
||
continue
|
||
}
|
||
if otherRoomListPlayURLMap[roomID] != nil {
|
||
vv["accept_quality"] = otherRoomListPlayURLMap[roomID].AcceptQuality
|
||
vv["current_quality"] = otherRoomListPlayURLMap[roomID].CurrentQuality
|
||
vv["play_url"] = otherRoomListPlayURLMap[roomID].Url["h264"]
|
||
vv["play_url_h265"] = otherRoomListPlayURLMap[roomID].Url["h265"]
|
||
}
|
||
}
|
||
resp.ModuleList[index]["list"] = moduleList
|
||
}
|
||
}
|
||
ret = resp
|
||
return
|
||
}
|
||
|
||
func jsonMustInt(arg interface{}, def int64) int64 {
|
||
if arg == nil {
|
||
log.Warn("jsonMustInt arg(%v) nil!", arg)
|
||
return def
|
||
}
|
||
r, ok := arg.(json.Number)
|
||
if !ok {
|
||
log.Warn("jsonMustInt arg(%v) is not json.Number but %v", arg, reflect.TypeOf(arg))
|
||
return def
|
||
}
|
||
rr, err := r.Int64()
|
||
if err != nil {
|
||
log.Warn("jsonMustInt arg(%v) transfer error: %v", arg, err)
|
||
return def
|
||
}
|
||
return rr
|
||
}
|
||
|
||
// Change implementation
|
||
// 首页换一换接口 for 天马
|
||
func (s *Service) Change(ctx context.Context, req *v1indexpb.ChangeReq) (resp *v1indexpb.ChangeResp, err error) {
|
||
resp = &v1indexpb.ChangeResp{
|
||
ModuleList: make([]*v1indexpb.ChangeResp_ModuleList, 0),
|
||
}
|
||
mid, isUIDSet := metadata.Value(ctx, metadata.Mid).(int64)
|
||
|
||
var uid int64
|
||
|
||
if isUIDSet {
|
||
uid = mid
|
||
}
|
||
// deviceInterface, _ := ctx.Get("device")
|
||
// device := req.Device
|
||
|
||
duplicates, _ := xstr.SplitInts(req.AttentionRoomId)
|
||
duplicatesMap := make(map[int64]bool)
|
||
|
||
for _, roomID := range duplicates {
|
||
duplicatesMap[roomID] = true
|
||
}
|
||
build := req.Build
|
||
buvid := ""
|
||
// 主站封好的，可从device里获取到sid、buvid、buvid3、build、channel、device、mobi_app、platform
|
||
device, ok := metadata.Value(ctx, metadata.Device).(*blademaster.Device)
|
||
if ok {
|
||
buvid = device.Buvid
|
||
}
|
||
var recModuleInfo *v1indexpb.ChangeResp_ModuleInfo
|
||
allListOut, callErr := dao.RoomApi.V2AppIndex.GetAllList(rpcCtx.WithTimeout(ctx, 100*time.Millisecond), &roomV2.AppIndexGetAllListReq{
|
||
Platform: req.Platform,
|
||
Device: req.Device,
|
||
Scale: req.Scale,
|
||
Build: int64(build),
|
||
ModuleId: req.ModuleId,
|
||
})
|
||
|
||
if callErr != nil {
|
||
log.Error("[Change]get all list rpc error, room.v2.AppIndex.setAllList, error:%+v", callErr)
|
||
err = errors.WithMessage(ecode.ChangeGetAllListRPCError, "CHANGE GET ALL LIST FAIL#1")
|
||
return
|
||
}
|
||
|
||
if allListOut.Code != 0 || allListOut.Data == nil {
|
||
log.Error("[Change]get all list return data error, code, %d, msg: %s, error:%+v", allListOut.Code, allListOut.Msg, err)
|
||
err = errors.WithMessage(ecode.ChangeGetAllListReturnError, "CHANGE GET ALL LIST FAIL#2")
|
||
return
|
||
}
|
||
|
||
if len(allListOut.Data.ModuleList) == 0 {
|
||
log.Error("[Change]get all list return empty, code, %d, msg: %s, error:%+v", allListOut.Code, allListOut.Msg, err)
|
||
err = errors.WithMessage(ecode.ChangeGetAllListEmptyError, "CHANGE GET ALL LIST FAIL#3")
|
||
return
|
||
}
|
||
|
||
m := allListOut.Data.ModuleList[0]
|
||
duplicateList := make([]*roomV2.AppIndexGetAllListResp_RoomList, 0)
|
||
for _, itemInfo := range m.List {
|
||
if _, ok := duplicatesMap[itemInfo.Roomid]; !ok {
|
||
duplicateList = append(duplicateList, itemInfo)
|
||
}
|
||
}
|
||
|
||
m.List = duplicateList
|
||
|
||
recModuleInfo = &v1indexpb.ChangeResp_ModuleInfo{
|
||
Id: m.ModuleInfo.Id,
|
||
Title: m.ModuleInfo.Title,
|
||
Pic: m.ModuleInfo.Pic,
|
||
Type: m.ModuleInfo.Type,
|
||
Link: m.ModuleInfo.Link,
|
||
Count: m.ModuleInfo.Count,
|
||
IsSkyHorseGray: 0,
|
||
}
|
||
// 目前只有推荐-天马有换一换，都必须有登陆态
|
||
|
||
roomIds := make([]int64, 0)
|
||
list := make([]*v1indexpb.ChangeResp_List, 0)
|
||
for i, itemInfo := range m.List {
|
||
if i >= 24 {
|
||
break
|
||
}
|
||
roomIds = append(roomIds, itemInfo.Roomid)
|
||
list = append(list, &v1indexpb.ChangeResp_List{
|
||
Roomid: itemInfo.Roomid,
|
||
Title: itemInfo.Title,
|
||
Uname: itemInfo.Uname,
|
||
Online: itemInfo.Online,
|
||
Cover: itemInfo.Cover,
|
||
Link: "/" + strconv.Itoa(int(itemInfo.Roomid)),
|
||
Face: itemInfo.Face,
|
||
AreaV2ParentId: itemInfo.AreaV2ParentId,
|
||
AreaV2ParentName: itemInfo.AreaV2ParentName,
|
||
AreaV2Id: itemInfo.AreaV2Id,
|
||
AreaV2Name: itemInfo.AreaV2Name,
|
||
BroadcastType: itemInfo.BroadcastType,
|
||
PendentRu: itemInfo.PendentRu,
|
||
PendentRuPic: itemInfo.PendentRuPic,
|
||
PendentRuColor: itemInfo.PendentRuColor,
|
||
RecType: itemInfo.RecType,
|
||
CurrentQuality: itemInfo.CurrentQuality,
|
||
AcceptQuality: itemInfo.AcceptQuality,
|
||
PlayUrl: itemInfo.PlayUrl,
|
||
})
|
||
}
|
||
|
||
resp.ModuleList = append(resp.ModuleList, &v1indexpb.ChangeResp_ModuleList{
|
||
List: list,
|
||
ModuleInfo: recModuleInfo,
|
||
})
|
||
|
||
isOpen := conf.Conf.SkyHorseStatus
|
||
if isOpen && isUIDSet && s.isSkyHorseRec(uid) {
|
||
recPage := rand.Intn(4)
|
||
if recPage == 1 || recPage == 0 {
|
||
recPage = 2
|
||
}
|
||
recList, skyHorseErr := getSkyHorseRoomList(ctx, uid, buvid, req.Build, req.Platform, duplicates, int64(recPage))
|
||
if skyHorseErr != nil {
|
||
log.Error("[Change]getSkyHorseRoomList error:%+v", skyHorseErr)
|
||
// err = errors.WithMessage(ecode.SkyHorseError, "")
|
||
} else if len(recList) <= 0 {
|
||
log.Error("[Change]getSkyHorseRoomList empty:%+v", recList)
|
||
// err = errors.WithMessage(ecode.ChangeSkyHorseEmptyError, "")
|
||
} else {
|
||
list := make([]*v1indexpb.ChangeResp_List, 0)
|
||
for i, recInfo := range recList {
|
||
if i >= 6 {
|
||
continue
|
||
}
|
||
roomIds = append(roomIds, recInfo.RoomId)
|
||
list = append(list, &v1indexpb.ChangeResp_List{
|
||
Roomid: recInfo.RoomId,
|
||
Title: recInfo.Title,
|
||
Uname: recInfo.Uname,
|
||
Online: recInfo.Online,
|
||
Cover: recInfo.Cover,
|
||
Link: "/" + strconv.Itoa(int(recInfo.RoomId)),
|
||
Face: recInfo.Face,
|
||
AreaV2ParentId: recInfo.AreaV2ParentId,
|
||
AreaV2ParentName: recInfo.AreaV2ParentName,
|
||
AreaV2Id: recInfo.AreaV2Id,
|
||
AreaV2Name: recInfo.AreaV2Name,
|
||
BroadcastType: recInfo.BroadcastType,
|
||
PendentRu: recInfo.PendentRu,
|
||
PendentRuPic: recInfo.PendentRuPic,
|
||
PendentRuColor: recInfo.PendentRuColor,
|
||
RecType: _recTypeSkyHorse,
|
||
})
|
||
}
|
||
skyHorseList := make([]*v1indexpb.ChangeResp_ModuleList, 0)
|
||
recModuleInfo.IsSkyHorseGray = 1
|
||
skyHorseList = append(skyHorseList, &v1indexpb.ChangeResp_ModuleList{
|
||
List: list,
|
||
ModuleInfo: recModuleInfo,
|
||
})
|
||
resp.ModuleList = skyHorseList
|
||
}
|
||
}
|
||
changeRoomListPlayURLMap := dao.BvcApi.GetPlayUrlMulti(ctx, roomIds, 0, 4, build, req.Platform)
|
||
|
||
for _, v := range resp.ModuleList[0].List {
|
||
if changeRoomListPlayURLMap[v.Roomid] != nil {
|
||
v.AcceptQuality = changeRoomListPlayURLMap[v.Roomid].AcceptQuality
|
||
v.CurrentQuality = changeRoomListPlayURLMap[v.Roomid].CurrentQuality
|
||
v.PlayUrl = changeRoomListPlayURLMap[v.Roomid].Url["h264"]
|
||
v.PlayUrlH265 = changeRoomListPlayURLMap[v.Roomid].Url["h265"]
|
||
}
|
||
}
|
||
// 赋值
|
||
return
|
||
}
|
||
|
||
// 获取天马房间信息列表
|
||
// 已将强推roomids传给天马，其他的可通过传duplicates来merge进去
|
||
func getSkyHorseRoomList(ctx context.Context, uid int64, buvid string, build int64, platform string, duplicates []int64, recPage int64) (resp []*roomItem, err error) {
|
||
clientRecStrongTimeout := time.Duration(conf.GetTimeout("clientRecStrong", 100)) * time.Millisecond
|
||
strongRecList, strongRecErr := dao.RoomApi.V1RoomRecommend.ClientRecStrong(rpcCtx.WithTimeout(ctx, clientRecStrongTimeout), &roomV1.RoomRecommendClientRecStrongReq{RecPage: recPage})
|
||
// liverpc.NewClient().CallRaw()
|
||
recDuplicate := make([]int64, 0)
|
||
if strongRecErr != nil {
|
||
log.Error("[getSkyHorseRoomList]room.v1.ClientRecStrong rpc error:%+v", strongRecErr)
|
||
} else if strongRecList.Code != 0 {
|
||
log.Error("[getSkyHorseRoomList]room.v1.ClientRecStrong response error:%+v,code:%d,msg:%s", strongRecErr, strongRecList.Code, strongRecList.Msg)
|
||
} else {
|
||
for _, strongInfo := range strongRecList.Data.Result {
|
||
if strongInfo.Roomid == 0 {
|
||
continue
|
||
}
|
||
recDuplicate = append(recDuplicate, strongInfo.Roomid)
|
||
}
|
||
}
|
||
|
||
strongLen := len(recDuplicate)
|
||
|
||
duplicates = append(duplicates, recDuplicate...)
|
||
skyHorseRec, skyHorseErr := dao.SkyHorseApi.GetSkyHorseRec(ctx, uid, buvid, build, platform, duplicates, strongLen, _skyHorseRecTimeOut)
|
||
if skyHorseErr != nil {
|
||
err = errors.WithMessage(ecode.SkyHorseError, "")
|
||
return
|
||
}
|
||
|
||
roomIds := make([]int64, 0)
|
||
|
||
for _, skyHorseInfo := range skyHorseRec.Data {
|
||
roomIds = append(roomIds, int64(skyHorseInfo.Id))
|
||
}
|
||
|
||
indexRoomListFields := []string{
|
||
"roomid",
|
||
"title",
|
||
"uname",
|
||
"online",
|
||
"cover",
|
||
"user_cover",
|
||
"link",
|
||
"face",
|
||
"area_v2_parent_id",
|
||
"area_v2_parent_name",
|
||
"area_v2_id",
|
||
"area_v2_name",
|
||
"broadcast_type",
|
||
"uid",
|
||
}
|
||
|
||
wg, _ := errgroup.WithContext(ctx)
|
||
|
||
// 房间基础信息（是map，但是天马返回是无序的）
|
||
var multiRoomListResp *roomV2.RoomGetByIdsResp
|
||
wg.Go(func() error {
|
||
getByIdsTimeout := time.Duration(conf.GetTimeout("getByIds", 50)) * time.Millisecond
|
||
multiRoomList, getByIdsError := dao.RoomApi.V2Room.GetByIds(rpcCtx.WithTimeout(ctx, getByIdsTimeout), &roomV2.RoomGetByIdsReq{
|
||
Ids: roomIds,
|
||
NeedBroadcastType: 1,
|
||
NeedUinfo: 1,
|
||
Fields: indexRoomListFields,
|
||
From: "app-interface.gateway",
|
||
})
|
||
if getByIdsError != nil {
|
||
log.Error("[getSkyHorseRoomList]room.v2.getByIds rpc error:%+v", getByIdsError)
|
||
// 这个是推荐房间列表的基础信息，如果失败需要cancel，不然返回值会很奇怪
|
||
return errors.WithMessage(ecode.GetRoomError, "room.v2.getByIds rpc error")
|
||
}
|
||
if multiRoomList.Code != 0 {
|
||
log.Error("[getSkyHorseRoomList]room.v2.getByIds response error:%+v,code:%d,msg:%s", getByIdsError, multiRoomList.Code, multiRoomList.Msg)
|
||
// 这个是推荐房间列表的基础信息，如果失败需要cancel，不然返回值会很奇怪
|
||
return errors.WithMessage(ecode.GetRoomError, "room.v2.getByIds response error")
|
||
}
|
||
multiRoomListResp = multiRoomList
|
||
|
||
return nil
|
||
})
|
||
|
||
// 房间角标信息
|
||
pendantRoomListResp := &roomV1.RoomPendantGetPendantByIdsResp{}
|
||
wg.Go(func() error {
|
||
getPendantByIdsTimeout := time.Duration(conf.GetTimeout("getPendantByIds", 50)) * time.Millisecond
|
||
pendantRoomList, getPendantError := dao.RoomApi.V1RoomPendant.GetPendantByIds(rpcCtx.WithTimeout(ctx, getPendantByIdsTimeout), &roomV1.RoomPendantGetPendantByIdsReq{
|
||
Ids: roomIds,
|
||
Type: "mobile_index_badge",
|
||
Position: 2, // 历史原因，取右上，但客户端展示在左上
|
||
})
|
||
|
||
if getPendantError != nil {
|
||
log.Error("[getSkyHorseRoomList]room.v1.getPendantByIds rpc error:%+v", getPendantError)
|
||
return nil
|
||
}
|
||
if pendantRoomList.Code != 0 {
|
||
log.Error("[getSkyHorseRoomList]room.v1.getPendantByIds response error:%+v,code:%d,msg:%s", getPendantError, pendantRoomList.Code, pendantRoomList.Msg)
|
||
return nil
|
||
}
|
||
pendantRoomListResp = pendantRoomList
|
||
return nil
|
||
})
|
||
|
||
waitErr := wg.Wait()
|
||
if waitErr != nil {
|
||
log.Error("[getSkyHorseRoomList]wait error(%+v)", waitErr)
|
||
return
|
||
}
|
||
|
||
pendantResult := make(map[int64]*roomV1.RoomPendantGetPendantByIdsResp_Result)
|
||
// 天马返回是无序的
|
||
if multiRoomListResp == nil {
|
||
err = errors.WithMessage(ecode.GetRoomEmptyError, "")
|
||
return
|
||
}
|
||
|
||
respSlice := make([]*roomV2.RoomGetByIdsResp_RoomInfo, 0)
|
||
for _, roomBaseInfo := range multiRoomListResp.Data {
|
||
respSlice = append(respSlice, roomBaseInfo)
|
||
}
|
||
for i := 0; i < 6; i++ {
|
||
if strongRecList != nil && strongRecList.Data != nil && strongRecList.Data.Result != nil {
|
||
if recInfo, ok := strongRecList.Data.Result[int64(i)]; ok {
|
||
resp = append(resp, &roomItem{
|
||
RoomId: recInfo.Roomid,
|
||
Title: recInfo.Title,
|
||
Uname: recInfo.Uname,
|
||
Online: recInfo.Online,
|
||
Cover: recInfo.Cover,
|
||
Link: "/" + strconv.Itoa(int(recInfo.Roomid)),
|
||
Face: recInfo.Face,
|
||
AreaV2ParentId: recInfo.AreaV2ParentId,
|
||
AreaV2ParentName: recInfo.AreaV2ParentName,
|
||
AreaV2Id: recInfo.AreaV2Id,
|
||
AreaV2Name: recInfo.AreaV2Name,
|
||
BroadcastType: recInfo.BroadcastType,
|
||
PendentRu: recInfo.PendentRu,
|
||
PendentRuPic: recInfo.PendentRuPic,
|
||
PendentRuColor: recInfo.PendentRuColor,
|
||
RecType: _recTypeForce,
|
||
CurrentQuality: recInfo.CurrentQuality,
|
||
AcceptQuality: recInfo.AcceptQuality,
|
||
})
|
||
continue
|
||
}
|
||
}
|
||
|
||
if len(respSlice) <= 0 {
|
||
continue
|
||
}
|
||
tmpItem := respSlice[0:1][0]
|
||
respSlice = respSlice[1:]
|
||
pendantValue := ""
|
||
pendantBgPic := ""
|
||
pendantBgColor := ""
|
||
if pendantRoomListResp != nil && pendantRoomListResp.Data != nil {
|
||
pendantResult = pendantRoomListResp.Data.Result
|
||
if pendantResult[tmpItem.Roomid] != nil {
|
||
// 移动端取value, web取name
|
||
pendantValue = pendantResult[tmpItem.Roomid].Value
|
||
pendantBgPic = pendantResult[tmpItem.Roomid].BgPic
|
||
if pendantResult[tmpItem.Roomid].BgColor != "" {
|
||
pendantBgColor = pendantResult[tmpItem.Roomid].BgColor
|
||
} else {
|
||
pendantBgColor = _mobileIndexBadgeColorDefault
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
cover := ""
|
||
if tmpItem.UserCover != "" {
|
||
cover = tmpItem.UserCover
|
||
} else {
|
||
cover = tmpItem.Cover
|
||
}
|
||
|
||
resp = append(resp, &roomItem{
|
||
RoomId: tmpItem.Roomid,
|
||
Title: tmpItem.Title,
|
||
Uname: tmpItem.Uname,
|
||
Online: tmpItem.Online,
|
||
Cover: cover,
|
||
Link: "/" + strconv.Itoa(int(tmpItem.Roomid)),
|
||
Face: tmpItem.Face,
|
||
AreaV2ParentId: tmpItem.AreaV2ParentId,
|
||
AreaV2ParentName: tmpItem.AreaV2ParentName,
|
||
AreaV2Id: tmpItem.AreaV2Id,
|
||
AreaV2Name: tmpItem.AreaV2Name,
|
||
BroadcastType: tmpItem.BroadcastType,
|
||
PendentRu: pendantValue,
|
||
PendentRuPic: pendantBgPic,
|
||
PendentRuColor: pendantBgColor,
|
||
RecType: _recTypeSkyHorse,
|
||
})
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
func (s *Service) isSkyHorseRec(mid int64) bool {
|
||
lastMid := strconv.Itoa(int(mid % 100))
|
||
if len(lastMid) < 2 {
|
||
lastMid = "0" + lastMid
|
||
}
|
||
_, isSkyHorseGray := s.conf.SkyHorseGray[lastMid]
|
||
|
||
return isSkyHorseGray
|
||
}
|
||
|
||
func (s *Service) getAllList(ctx context.Context) (json.RawMessage, error) {
|
||
allListOut, err := dao.RoomRawApi.CallRaw(ctx, 2,
|
||
"AppIndex.getAllRawList", &liverpc.Args{})
|
||
if err != nil {
|
||
log.Error("[getAllList]get all list rpc error, room.v2.AppIndex.getAllRawList, error:%+v", err)
|
||
err = errors.WithMessage(ecode.GetAllListRPCError, "GET ALL LIST FAIL#1")
|
||
return json.RawMessage{}, err
|
||
}
|
||
if allListOut == nil {
|
||
log.Error("[getAllList]get all list raw data nil, room.v2.AppIndex.getAllRawList")
|
||
err = errors.WithMessage(ecode.GetAllListRPCError, "GET ALL LIST FAIL#2")
|
||
return json.RawMessage{}, err
|
||
}
|
||
if allListOut.Code != 0 || allListOut.Data == nil {
|
||
log.Error("[getAllList]get all list return data error, code, %d, msg: %s, error:%+v", allListOut.Code, allListOut.Message, err)
|
||
err = errors.WithMessage(ecode.GetAllListReturnError, "GET ALL LIST FAIL#3")
|
||
return json.RawMessage{}, err
|
||
}
|
||
allListJSONObj, jsonErr := simplejson.NewJson(allListOut.Data)
|
||
if jsonErr != nil {
|
||
log.Error("[getAllList]get all list simplejson error, error:%+v", err)
|
||
err = errors.WithMessage(ecode.GetAllListReturnError, "GET ALL LIST FAIL#4")
|
||
return json.RawMessage{}, err
|
||
}
|
||
|
||
allListCache := allListJSONObj.Get("module_list").MustArray()
|
||
if len(allListCache) > 1 && allListCache[1] == nil {
|
||
log.Error("[getAllList]abnormal module, allListCache:%+v", allListCache)
|
||
err = errors.WithMessage(ecode.GetAllListReturnError, "GET ALL LIST FAIL#5")
|
||
return json.RawMessage{}, err
|
||
}
|
||
|
||
return allListOut.Data, nil
|
||
}
|
||
|
||
func (s *Service) tickCacheAllList(ctx context.Context) {
|
||
ticker := time.NewTicker(5 * time.Second)
|
||
for {
|
||
select {
|
||
case <-ticker.C:
|
||
allListData, err := s.getAllList(ctx)
|
||
if err != nil {
|
||
log.Error("[tickCacheAllList] setAllList error(%+v)", err)
|
||
continue
|
||
}
|
||
if len(allListData) <= 0 {
|
||
log.Error("[tickCacheAllList] setAllList empty data(%+v)", allListData)
|
||
continue
|
||
}
|
||
log.Info("[tickCacheAllList] setAllList success!")
|
||
s.allListInfo.Store(allListData)
|
||
}
|
||
}
|
||
}
|
||
|
||
func (s *Service) getAllListFromCache(ctx context.Context) (allListCache []interface{}) {
|
||
allListRawCache := s.allListInfo.Load()
|
||
|
||
if allListRawCache == nil {
|
||
log.Warn("[getAllListFromCache] cache miss!")
|
||
allList, err := s.getAllList(ctx)
|
||
if err != nil {
|
||
log.Error("[getAllListFromCache] pass through error(%+v)", err)
|
||
}
|
||
allListRawCache = allList
|
||
}
|
||
|
||
allListJSONObj, err := simplejson.NewJson(allListRawCache.(json.RawMessage))
|
||
if err != nil {
|
||
log.Error("[getAllListFromCache]get all list simplejson error, error:%+v", err)
|
||
return
|
||
}
|
||
|
||
allListCache = allListJSONObj.Get("module_list").MustArray()
|
||
if allListCache[1] == nil {
|
||
fmt.Printf("abnormal module, allListRawCache: %+v, module_list: %+v", allListRawCache, allListJSONObj.Get("module_list"))
|
||
}
|
||
log.Info("[getAllListFromCache] cache hit! len: %d", len(allListCache))
|
||
return
|
||
}
|