237 lines
6.3 KiB
Go
237 lines
6.3 KiB
Go
package vidser
|
|
|
|
import (
|
|
"91porn-server/app/appg"
|
|
"91porn-server/app/service/vidhelpser"
|
|
"91porn-server/common"
|
|
"91porn-server/common/constant/redisconst"
|
|
"91porn-server/common/log"
|
|
"91porn-server/common/timeutil"
|
|
topser "91porn-server/common/top"
|
|
topasist "91porn-server/common/top/asistant"
|
|
"91porn-server/common/top/dailytop"
|
|
"91porn-server/common/top/monthtop"
|
|
"91porn-server/common/top/weektop"
|
|
"91porn-server/models/cache/sysconfdata"
|
|
"91porn-server/models/cache/viddata"
|
|
"91porn-server/models/commod"
|
|
"91porn-server/models/v/sysconfmod"
|
|
"91porn-server/models/v/vidmod"
|
|
"encoding/json"
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
"go.mongodb.org/mongo-driver/bson/primitive"
|
|
"go.mongodb.org/mongo-driver/mongo/options"
|
|
"time"
|
|
)
|
|
|
|
type RankingReq struct {
|
|
Type int `json:"type" form:"type"` // 1-日榜 2-周榜 3-月榜 4-总榜 5-年榜
|
|
NewsType string `json:"newsType" form:"newsType"` // SP-长视频 SHORT-短视频 COVER-帖子 PIC-图集 HOT-热点榜单
|
|
UID uint64 `json:"-" form:"-"`
|
|
commod.Page
|
|
}
|
|
|
|
type RankingResp struct {
|
|
List []*vidmod.VideoInfo `json:"list"`
|
|
HasNext bool `json:"hasNext"`
|
|
}
|
|
|
|
const (
|
|
DailyRank = 1 // 日榜
|
|
WeekRank = 2 // 周榜
|
|
MonthRank = 3 // 周榜
|
|
AllRank = 4 // 总榜
|
|
YearRank = 5 // 年榜
|
|
)
|
|
|
|
func (q *RankingReq) List() (res RankingResp, err error) {
|
|
defer func() {
|
|
vidhelpser.ApplyFreeTrialBadgeToVideoInfos(vidhelpser.LoadFreeTrialBadgeContext(q.UID), res.List)
|
|
}()
|
|
if q.NewsType == "HOT" {
|
|
return q.getHotRank()
|
|
}
|
|
switch q.Type {
|
|
case DailyRank, WeekRank, MonthRank:
|
|
// 日榜
|
|
res, err = q.getRank(q.Type, q.NewsType)
|
|
|
|
case AllRank, YearRank:
|
|
res, err = q.getAllRank(q.NewsType, q.Type == YearRank)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (q *RankingReq) getHotRank() (res RankingResp, err error) {
|
|
// 获取配置的标签
|
|
configure, _ := sysconfdata.GetAllFromCache()
|
|
tagStrList := configure.GetStrSlice(sysconfmod.VCodeHotRankingTags)
|
|
tagIds := []primitive.ObjectID{}
|
|
for _, v := range tagStrList {
|
|
tagId, _ := primitive.ObjectIDFromHex(v)
|
|
if tagId.IsZero() {
|
|
continue
|
|
}
|
|
tagIds = append(tagIds, tagId)
|
|
}
|
|
if len(tagIds) == 0 {
|
|
return
|
|
}
|
|
key := redisconst.GetHotRankingListCacheKey(tagIds, q.PageNumber, q.PageSize)
|
|
s, err := appg.Redis.Get(key)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
if s != nil {
|
|
err = json.Unmarshal([]byte(*s), &res)
|
|
if err == nil {
|
|
return res, nil
|
|
}
|
|
}
|
|
defer func() {
|
|
b, err := json.Marshal(res)
|
|
if err != nil {
|
|
log.Error("video getRank json.Marshal(res) error:", log.E(err))
|
|
return
|
|
}
|
|
ran := time.Duration(common.RandInt(20, 60) + 240)
|
|
appg.Redis.Set(key, string(b), time.Second*ran)
|
|
}()
|
|
|
|
t := timeutil.BeginningOfDay(time.Now())
|
|
filter := bson.M{
|
|
"tags": bson.M{"$in": tagIds},
|
|
"newsType": bson.M{"$in": []string{vidmod.SP, vidmod.SHORT}},
|
|
"status": bson.M{"$in": []int{1, 3}},
|
|
"reviewAt": bson.M{"$gt": t.AddDate(0, 0, -30)},
|
|
}
|
|
sorts := bson.D{{Key: "liaoBaTopSort", Value: -1}, {Key: "playCount", Value: -1}, {Key: "reviewAt", Value: -1}}
|
|
opts := options.Find().SetLimit(q.Limit64()).SetSkip(q.Skip64()).SetSort(sorts)
|
|
vidList, hasNext, err := vidmod.FindList(filter, opts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
res.List = vidhelpser.EncodeVideoInfoNoUID(vidList)
|
|
res.HasNext = hasNext
|
|
|
|
return res, nil
|
|
}
|
|
|
|
func (q *RankingReq) getAllRank(newsType string, isYear bool) (res RankingResp, err error) {
|
|
key := redisconst.GetRankingListCacheKey(q.Type, newsType, q.PageSize, q.PageNumber)
|
|
s, err := appg.Redis.Get(key)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
if s != nil {
|
|
err = json.Unmarshal([]byte(*s), &res)
|
|
if err == nil {
|
|
return res, nil
|
|
}
|
|
}
|
|
defer func() {
|
|
b, err := json.Marshal(res)
|
|
if err != nil {
|
|
log.Error("video getRank json.Marshal(res) error:", log.E(err))
|
|
return
|
|
}
|
|
ran := time.Duration(common.RandInt(20, 60) + 60)
|
|
appg.Redis.Set(key, string(b), time.Second*ran)
|
|
}()
|
|
|
|
t := timeutil.BeginningOfDay(time.Now())
|
|
t = t.AddDate(-1, -2, 0)
|
|
if isYear {
|
|
t = t.AddDate(0, -6, 0)
|
|
}
|
|
|
|
filter := bson.M{
|
|
"newsType": newsType,
|
|
"status": bson.M{"$in": []int{1, 3}},
|
|
"reviewAt": bson.M{"$gt": t},
|
|
}
|
|
sorts := bson.D{{Key: "collectCount", Value: -1}, {Key: "reviewAt", Value: -1}}
|
|
|
|
vidList, hasNext, err := viddata.GetListFromCache(filter, int64(q.Skip()), int64(q.Limit()), sorts)
|
|
if err != nil {
|
|
return
|
|
}
|
|
res.List = vidhelpser.EncodeVideoInfoNoUID(vidList)
|
|
res.HasNext = hasNext
|
|
|
|
return res, nil
|
|
}
|
|
|
|
func (q *RankingReq) getRank(rankinType int, newsType string) (res RankingResp, err error) {
|
|
|
|
var list []string
|
|
var hasNext bool
|
|
switch rankinType {
|
|
case DailyRank:
|
|
list, _, hasNext = dailytop.GetTopByPage(topser.TypeVideo(newsType), int64(q.Skip()), int64(q.Limit()))
|
|
case WeekRank:
|
|
list, _, hasNext = weektop.GetTopByPage(topser.TypeVideo(newsType), int64(q.Skip()), int64(q.Limit()))
|
|
case MonthRank:
|
|
list, _, hasNext = monthtop.GetTopByPage(topser.TypeVideo(newsType), int64(q.Skip()), int64(q.Limit()))
|
|
default:
|
|
return
|
|
}
|
|
periodRankHasContent := len(list) > 0
|
|
if !periodRankHasContent && q.Skip64() > 0 {
|
|
periodRankHasContent = q.periodRankHasContent(rankinType, newsType)
|
|
}
|
|
|
|
ids := []primitive.ObjectID{}
|
|
for _, v := range list {
|
|
id, _ := primitive.ObjectIDFromHex(v)
|
|
if id.IsZero() {
|
|
continue
|
|
}
|
|
ids = append(ids, id)
|
|
}
|
|
// 通过id获取列表
|
|
vidList, _, err := vidmod.FindList(bson.M{"_id": bson.M{"$in": ids}}, options.Find())
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
vidMap := make(map[primitive.ObjectID]*vidmod.VideoModel)
|
|
var videoList []*vidmod.VideoModel
|
|
for _, v := range vidList {
|
|
vidMap[v.ID] = v
|
|
}
|
|
for _, id := range ids {
|
|
item, ok := vidMap[id]
|
|
if !ok || (item.Status != 1 && item.Status != 3) {
|
|
topasist.Remove(topser.TypeVideo(newsType), id.Hex())
|
|
continue
|
|
}
|
|
videoList = append(videoList, item)
|
|
}
|
|
|
|
if len(videoList) == 0 && !periodRankHasContent {
|
|
videoList, hasNext, err = vidmod.FindCumulativeRanking(newsType, q.Page)
|
|
if err != nil {
|
|
return res, err
|
|
}
|
|
}
|
|
|
|
res.List = vidhelpser.EncodeVideoInfoNoUID(videoList)
|
|
res.HasNext = hasNext
|
|
|
|
return res, nil
|
|
}
|
|
|
|
func (q *RankingReq) periodRankHasContent(rankingType int, newsType string) bool {
|
|
var list []string
|
|
switch rankingType {
|
|
case DailyRank:
|
|
list, _, _ = dailytop.GetTopByPage(topser.TypeVideo(newsType), 0, 1)
|
|
case WeekRank:
|
|
list, _, _ = weektop.GetTopByPage(topser.TypeVideo(newsType), 0, 1)
|
|
case MonthRank:
|
|
list, _, _ = monthtop.GetTopByPage(topser.TypeVideo(newsType), 0, 1)
|
|
}
|
|
return len(list) > 0
|
|
}
|