1419 lines
41 KiB
Go
1419 lines
41 KiB
Go
package vidhelpser
|
||
|
||
import (
|
||
"91porn-server/app/service/searchaccessser"
|
||
"91porn-server/models/v/cmtmod"
|
||
"91porn-server/models/v/moduleconfmod"
|
||
"math"
|
||
"sync"
|
||
"time"
|
||
|
||
"91porn-server/app/appg"
|
||
"91porn-server/app/service/walletser"
|
||
"91porn-server/common"
|
||
"91porn-server/common/constant/redisconst"
|
||
"91porn-server/common/log"
|
||
"91porn-server/common/maths"
|
||
"91porn-server/common/redis"
|
||
"91porn-server/common/timeutil/timerange"
|
||
"91porn-server/models/l/payvidlgmod"
|
||
"91porn-server/models/s/statrecordmod"
|
||
"91porn-server/models/v/collectmod"
|
||
"91porn-server/models/v/discount_area_mod"
|
||
"91porn-server/models/v/followmod"
|
||
"91porn-server/models/v/freeVidmod"
|
||
"91porn-server/models/v/likemod"
|
||
"91porn-server/models/v/locmod"
|
||
"91porn-server/models/v/tagmod"
|
||
"91porn-server/models/v/usermod"
|
||
"91porn-server/models/v/videodiscountmod"
|
||
"91porn-server/models/v/vidmod"
|
||
"91porn-server/skd/skdg"
|
||
|
||
"github.com/shopspring/decimal"
|
||
"go.mongodb.org/mongo-driver/bson"
|
||
"go.mongodb.org/mongo-driver/bson/primitive"
|
||
)
|
||
|
||
// OID 别名
|
||
type OID = primitive.ObjectID
|
||
|
||
const (
|
||
//MaxNewestCacheNum 最新帖子最大缓存条数
|
||
MaxNewestCacheNum = 500
|
||
// 视频点赞数放大倍数
|
||
VideoLikeCountMultiplier = 33
|
||
// 视频播放量放大倍数
|
||
VideoPlayCountMultiplier = 99
|
||
)
|
||
|
||
// GetLocationByIP 通过ip获取地理位置
|
||
func GetLocationByIP(ip string) string {
|
||
r := getRedis()
|
||
city, err := r.GetString(redisconst.IpLocationFmt(ip))
|
||
if city != "" && err == nil {
|
||
return city
|
||
}
|
||
city, _ = common.GetLocationByIP(ip)
|
||
_ = r.Set(redisconst.IpLocationFmt(ip), city, redisconst.IPLocationExpireMax)
|
||
return city
|
||
}
|
||
|
||
func addUserInfo(srcMap map[uint64]*vidmod.Publisher, add []*usermod.BaseInfoVip) map[uint64]*vidmod.Publisher {
|
||
if srcMap == nil {
|
||
srcMap = make(map[uint64]*vidmod.Publisher)
|
||
}
|
||
for _, info := range add {
|
||
p := vidmod.Publisher{
|
||
UInfo: *info,
|
||
}
|
||
srcMap[info.UID] = &p
|
||
}
|
||
return srcMap
|
||
}
|
||
|
||
// GetUserInfo2Map 获取用户基本信息到map
|
||
func GetUserInfo2Map(uid uint64, uids []uint64) map[uint64]*vidmod.Publisher {
|
||
m, unExistsUID, err := getUsersBaseInfoFromRedis(uids)
|
||
if err != nil || len(unExistsUID) != 0 {
|
||
unExistsUsers, err := getUsersBaseInfoFromMongo(unExistsUID)
|
||
if err != nil {
|
||
return nil
|
||
}
|
||
common.Go(func() {
|
||
_ = setUsersBaseInfo2Redis(unExistsUsers)
|
||
})
|
||
m = addUserInfo(m, unExistsUsers)
|
||
}
|
||
var wg sync.WaitGroup
|
||
var followMap map[uint64]bool
|
||
// var rchgLevelMap map[uint64]usermod.RechargeLevel
|
||
var userWorks []vidmod.WorkCount
|
||
wg.Add(2)
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
followMap, _ = followmod.IsFollowUsers(uid, uids)
|
||
})
|
||
// common.Go(func() {
|
||
// defer wg.Done()
|
||
// rchgLevelMap, _ = walletser.GetUidsRchgLevel(uids)
|
||
// })
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
var filter = bson.M{}
|
||
filter["publisherID"] = bson.M{"$in": uids}
|
||
filter["status"] = vidmod.CheckPass
|
||
userWorks, _ = vidmod.TotalWorks(filter)
|
||
})
|
||
wg.Wait()
|
||
|
||
for u, p := range m {
|
||
p.HasFollowed = followMap[u]
|
||
// p.RechargeLevel = rchgLevelMap[u].Level
|
||
for _, w := range userWorks {
|
||
if p.UID == w.Uid {
|
||
p.TotalWorks = w.Count
|
||
}
|
||
}
|
||
}
|
||
return m
|
||
}
|
||
|
||
// GetUserInfo2MapNoUID 获取用户基本信息到map
|
||
func GetUserInfo2MapNoUID(uids []uint64) map[uint64]*vidmod.Publisher {
|
||
m, unExistsUID, err := getUsersBaseInfoFromRedis(uids)
|
||
if err != nil || len(unExistsUID) != 0 {
|
||
unExistsUsers, err := getUsersBaseInfoFromMongo(unExistsUID)
|
||
if err != nil {
|
||
return nil
|
||
}
|
||
common.Go(func() {
|
||
_ = setUsersBaseInfo2Redis(unExistsUsers)
|
||
})
|
||
m = addUserInfo(m, unExistsUsers)
|
||
}
|
||
var rchgLevelMap map[uint64]usermod.RechargeLevel
|
||
rchgLevelMap, _ = walletser.GetUidsRchgLevel(uids)
|
||
for u, p := range m {
|
||
p.RechargeLevel = rchgLevelMap[u].Level
|
||
}
|
||
return m
|
||
}
|
||
|
||
// GetSimpleUserMapNoUID 获取用户基本信息到map
|
||
func GetSimpleUserMapNoUID(uids []uint64) map[uint64]*vidmod.Publisher {
|
||
m, unExistsUID, err := getUsersBaseInfoFromRedis(uids)
|
||
if err != nil || len(unExistsUID) != 0 {
|
||
unExistsUsers, err := getUsersBaseInfoFromMongo(unExistsUID)
|
||
if err != nil {
|
||
return nil
|
||
}
|
||
common.Go(func() {
|
||
_ = setUsersBaseInfo2Redis(unExistsUsers)
|
||
})
|
||
m = addUserInfo(m, unExistsUsers)
|
||
}
|
||
return m
|
||
}
|
||
|
||
// GetUserStatus 获取 用户状态信息
|
||
func GetUserStatus(uid uint64, videoIDs []OID) map[OID]vidmod.VideoStatus {
|
||
mLike := make(map[primitive.ObjectID]bool)
|
||
mPay := make(map[primitive.ObjectID]bool)
|
||
mCollect := make(map[primitive.ObjectID]bool)
|
||
var wg sync.WaitGroup
|
||
wg.Add(3)
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
mLike, _ = likemod.IsLikeVideos(uid, videoIDs)
|
||
})
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
mPay, _ = payvidlgmod.IsPay4Videos(uid, videoIDs)
|
||
})
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
mCollect, _ = collectmod.IsCollectVideos(uid, videoIDs)
|
||
})
|
||
wg.Wait()
|
||
m := make(map[OID]vidmod.VideoStatus)
|
||
for _, v := range videoIDs {
|
||
info := vidmod.VideoStatus{
|
||
HasLiked: mLike[v],
|
||
HasPaid: mPay[v],
|
||
HasCollected: mCollect[v],
|
||
TodayRank: 0,
|
||
TodayPlayCnt: 0,
|
||
}
|
||
m[v] = info
|
||
}
|
||
return m
|
||
}
|
||
|
||
// GetTagsByIDs 通过tagid列表获取tag详情列表
|
||
func GetTagsByIDs(ids []OID) ([]vidmod.TagInfo, bool) {
|
||
tags, unExistsTid, err := getTagsByIDsFromRedis(ids)
|
||
if err != nil || len(unExistsTid) != 0 {
|
||
unExistsTInfo, err := getTagsByIDsFromMongo(unExistsTid)
|
||
if err != nil {
|
||
return nil, false
|
||
}
|
||
common.Go(func() {
|
||
_ = setTagsByIDs2Redis(unExistsTInfo)
|
||
})
|
||
tags = append(tags, unExistsTInfo...)
|
||
}
|
||
return tags, true
|
||
}
|
||
|
||
// GetTagsByIDs2Map 通过tagid列表获取tag详情列表
|
||
func GetTagsByIDs2Map(ids []OID) map[primitive.ObjectID]vidmod.TagInfo {
|
||
m := make(map[primitive.ObjectID]vidmod.TagInfo)
|
||
tags, ok := GetTagsByIDs(ids)
|
||
if !ok {
|
||
return m
|
||
}
|
||
for _, info := range tags {
|
||
m[info.ID] = vidmod.TagInfo{
|
||
ID: info.ID,
|
||
Name: info.Name,
|
||
CoverImg: info.CoverImg,
|
||
Description: info.Description,
|
||
}
|
||
}
|
||
return m
|
||
}
|
||
|
||
// GetPartTags 从内存获取tagInfo
|
||
func GetPartTags(ids []OID, mTags map[primitive.ObjectID]vidmod.TagInfo) []vidmod.TagInfo {
|
||
infos := make([]vidmod.TagInfo, 0, len(ids))
|
||
for _, i := range ids {
|
||
if !mTags[i].ID.IsZero() {
|
||
infos = append(infos, mTags[i])
|
||
}
|
||
}
|
||
return infos
|
||
}
|
||
|
||
func getVideoParentCommentCountMap(objIDs []primitive.ObjectID) map[primitive.ObjectID]int {
|
||
res := make(map[primitive.ObjectID]int, len(objIDs))
|
||
countMap, err := cmtmod.CmtFindParentCountByObjIDs(cmtmod.CmtTypeVideo, objIDs)
|
||
if err != nil {
|
||
return res
|
||
}
|
||
for id, cnt := range countMap {
|
||
res[id] = int(cnt)
|
||
}
|
||
return res
|
||
}
|
||
|
||
// Transfer2Info 将视频数据库模式转为返回模式
|
||
func transfer2Info(v *vidmod.VideoModel, uInfo vidmod.Publisher, vStatus vidmod.VideoStatus, loc locmod.Location, ti []vidmod.TagInfo, com vidmod.CommentInfo, originCoins int64) *vidmod.VideoInfo {
|
||
if v.Status == 3 {
|
||
v.Status = 1
|
||
}
|
||
newType := vidmod.SP
|
||
if len(v.NewsType) != 0 {
|
||
newType = v.NewsType
|
||
}
|
||
base := vidmod.VideoBase{
|
||
ID: v.ID,
|
||
NewsType: newType,
|
||
Title: v.Title,
|
||
Content: v.Content,
|
||
Tags: ti,
|
||
PlayTime: v.PlayTime,
|
||
Cover: v.Cover,
|
||
CoverThumb: v.CoverThumb,
|
||
SeriesCover: v.SeriesCover,
|
||
PlayCount: (v.PlayCount + v.FakePlayCount) * VideoPlayCountMultiplier,
|
||
LikeCount: v.LikeCount, // 移除点赞数放大倍数，修复各处点赞数不一致问题
|
||
PageViewCount: v.PageViewCount * 3,
|
||
CommentCount: v.CommentCount,
|
||
ShareCount: v.FakeShareCount,
|
||
Coins: v.Coins,
|
||
Size: v.Size,
|
||
Resolution: v.Resolution,
|
||
Ratio: v.Ratio,
|
||
PurchaseCount: v.PurchaseCount,
|
||
CreatedAt: v.CreatedAt,
|
||
ReviewAt: v.ReviewAt,
|
||
FreeTime: v.FreeTime,
|
||
Status: v.Status,
|
||
Reason: v.Reason,
|
||
SourceURL: v.SourceURL,
|
||
H265Url: H265URLForApp(v),
|
||
PreviewURL: v.PreviewURL,
|
||
LinkUrl: v.LinkUrl,
|
||
IsHideLocation: v.IsHideLocation,
|
||
FreeArea: v.FreeArea,
|
||
IsTopping: v.IsTopping,
|
||
IsChoosen: v.IsChoosen,
|
||
IsRecommend: v.IsRecommend,
|
||
Rewarded: v.Rewarded.Add(v.FakeRewarded),
|
||
OriginCoins: originCoins,
|
||
CollectCount: v.CollectCount,
|
||
SeedLinkUrl: v.SeedLinkUrl,
|
||
SeedSize: v.SeedSize,
|
||
SeedPlayTime: v.SeedPlayTime,
|
||
RichText: v.RichText,
|
||
PreviewStart: v.PreviewStart,
|
||
TimeNodeList: v.TimeNodeList,
|
||
DownloadAllow: v.DownloadAllow,
|
||
ShowType: v.ShowType,
|
||
}
|
||
if v.Via == "laosiji" {
|
||
base.LsjId = v.SourceID
|
||
}
|
||
locInfo := vidmod.LocInfo{
|
||
ID: loc.ID,
|
||
City: loc.City,
|
||
Cover: loc.Cover,
|
||
Visit: loc.FakeVisit,
|
||
CreatedAt: loc.CreatedAt,
|
||
}
|
||
info := vidmod.VideoInfo{
|
||
VideoBase: base,
|
||
UInfo: uInfo,
|
||
Location: locInfo,
|
||
VidStatus: vStatus,
|
||
Comment: com,
|
||
}
|
||
return &info
|
||
}
|
||
|
||
// EncodeVideoInfoBlogger 视频上传博主查看自己上传视频（临时解决）
|
||
func EncodeVideoInfoBlogger(uid uint64, infos []*vidmod.VideoModel) []*vidmod.VideoInfoResp {
|
||
infos = filterOutsideSearch(infos)
|
||
infosLen := len(infos)
|
||
back := make([]*vidmod.VideoInfoResp, infosLen)
|
||
if infosLen == 0 {
|
||
return back
|
||
}
|
||
uids := make([]uint64, infosLen)
|
||
videos := make([]primitive.ObjectID, infosLen)
|
||
lids := make([]primitive.ObjectID, infosLen)
|
||
var tags []primitive.ObjectID
|
||
|
||
for i, v := range infos {
|
||
uids[i] = v.PublisherID
|
||
videos[i] = v.ID
|
||
lids[i] = v.Location
|
||
tags = append(tags, v.Tags...)
|
||
}
|
||
var (
|
||
mUser map[uint64]*vidmod.Publisher
|
||
mStatus map[OID]vidmod.VideoStatus
|
||
mTags map[primitive.ObjectID]vidmod.TagInfo
|
||
wg sync.WaitGroup
|
||
)
|
||
|
||
wg.Add(3)
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
mUser = GetUserInfo2Map(uid, uids)
|
||
})
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
mStatus = GetUserStatus(uid, videos)
|
||
})
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
mTags = GetTagsByIDs2Map(tags)
|
||
})
|
||
wg.Wait()
|
||
commentCountMap := getVideoParentCommentCountMap(videos)
|
||
for i, v := range infos {
|
||
originCoins := v.Coins
|
||
var uInfo vidmod.Publisher
|
||
if mUser[v.PublisherID] != nil {
|
||
uInfo = *mUser[v.PublisherID]
|
||
}
|
||
back[i] = NewTransfer2Info(v, uInfo, mStatus[v.ID], GetPartTags(v.Tags, mTags), originCoins)
|
||
back[i].CommentCount = commentCountMap[v.ID]
|
||
if v.Status != vidmod.CheckPass && v.PublisherID == uid {
|
||
back[i].PageViewCount = 0
|
||
}
|
||
}
|
||
return back
|
||
}
|
||
|
||
// EncodeVideoInfo 封装返回的视频列表信息
|
||
func EncodeVideoInfo(uid uint64, infos []*vidmod.VideoModel) []*vidmod.VideoInfo {
|
||
return encodeVideoInfo(uid, filterOutsideSearch(infos))
|
||
}
|
||
|
||
// EncodeVideoInfoForRecommend 过滤配置为不进入推荐场景的亚模块内容。
|
||
func EncodeVideoInfoForRecommend(uid uint64, infos []*vidmod.VideoModel) []*vidmod.VideoInfo {
|
||
return encodeVideoInfo(uid, filterRecommend(infos))
|
||
}
|
||
|
||
// EncodeVideoInfoForSearch 保留搜索专属内容，并给结果签发短时效访问凭证。
|
||
func EncodeVideoInfoForSearch(uid uint64, infos []*vidmod.VideoModel) []*vidmod.VideoInfo {
|
||
result := encodeVideoInfo(uid, filterSearch(infos))
|
||
attachVideoInfoSearchTokens(uid, result)
|
||
return result
|
||
}
|
||
|
||
func encodeVideoInfo(uid uint64, infos []*vidmod.VideoModel) []*vidmod.VideoInfo {
|
||
if uid == 0 {
|
||
return encodeVideoInfoNoUID(infos)
|
||
}
|
||
infosLen := len(infos)
|
||
//now := time.Now()
|
||
back := make([]*vidmod.VideoInfo, infosLen)
|
||
if infosLen == 0 {
|
||
return back
|
||
}
|
||
uids := make([]uint64, infosLen)
|
||
videos := make([]primitive.ObjectID, infosLen)
|
||
lids := make([]primitive.ObjectID, infosLen)
|
||
discountAreaIds := []primitive.ObjectID{}
|
||
var tags []primitive.ObjectID
|
||
mids := []primitive.ObjectID{}
|
||
for i, v := range infos {
|
||
uids[i] = v.PublisherID
|
||
videos[i] = v.ID
|
||
lids[i] = v.Location
|
||
if !v.DiscountAreaId.IsZero() {
|
||
discountAreaIds = append(discountAreaIds, v.DiscountAreaId)
|
||
}
|
||
tags = append(tags, v.Tags...)
|
||
mid, _ := primitive.ObjectIDFromHex(v.MID)
|
||
if !mid.IsZero() {
|
||
mids = append(mids, mid)
|
||
}
|
||
|
||
}
|
||
var mUser map[uint64]*vidmod.Publisher
|
||
var mStatus map[OID]vidmod.VideoStatus
|
||
var mLocation map[primitive.ObjectID]locmod.Location
|
||
var mComment map[primitive.ObjectID]vidmod.CommentInfo
|
||
var mTags map[primitive.ObjectID]vidmod.TagInfo
|
||
var mFree map[uint64]bool
|
||
discountAreaMap := make(map[primitive.ObjectID]*discount_area_mod.DiscountArea)
|
||
var self *usermod.User
|
||
var videoDiscLog videodiscountmod.VideoDiscountLog
|
||
var largestDiscount int
|
||
moduleMap := make(map[string]moduleconfmod.ModuleConf)
|
||
var wg sync.WaitGroup
|
||
wg.Add(9)
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
moduleList, err := moduleconfmod.FindByIDs(mids)
|
||
if err != nil {
|
||
log.Error("EncodeVideoInfo: moduleconfmod.FindByIDs fail", log.E(err))
|
||
return
|
||
}
|
||
for _, v := range moduleList {
|
||
moduleMap[v.ID.Hex()] = v
|
||
}
|
||
})
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
// 通过折扣专区id获取专区
|
||
vidDiscountArea, err := discount_area_mod.GetDiscountAreaByIds(discountAreaIds)
|
||
if err != nil {
|
||
log.Error("EncodeVideoInfo: discount_area_mod.GetDiscountAreaByIds", log.Any("discountAreaIds", discountAreaIds), log.E(err))
|
||
return
|
||
}
|
||
for _, v := range vidDiscountArea {
|
||
discountAreaMap[v.ID] = &v
|
||
}
|
||
})
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
user, findErr := usermod.FindUserByUID(uid)
|
||
if findErr != nil {
|
||
log.Error("EncodeVideoInfo: usermod.FindUserByUID", log.Any("uid", uid), log.E(findErr))
|
||
return
|
||
}
|
||
self = user
|
||
//if self != nil && !self.IsVIP(now) {
|
||
// largestDiscount, err = productmod.GetLargestDiscountVIPCard()
|
||
// if err != nil {
|
||
// log.Error("GetLargestDiscountVIPCard", log.Any("uid", uid), log.E(err))
|
||
// }
|
||
//}
|
||
})
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
mUser = GetUserInfo2Map(uid, uids)
|
||
})
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
mStatus = GetUserStatus(uid, videos)
|
||
})
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
//mLocation, _ = locmod.GetLocationInfoByIDs(lids)
|
||
mLocation = make(map[primitive.ObjectID]locmod.Location)
|
||
})
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
mTags = GetTagsByIDs2Map(tags)
|
||
})
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
mFree = freeVidmod.GetFreeVideoMapByUID(uid)
|
||
})
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
discountLog, findErr := videodiscountmod.GetByUID(uid)
|
||
if findErr != nil {
|
||
log.Error("videodiscountmod.GetByUID", log.Any("uid", uid), log.E(findErr))
|
||
return
|
||
}
|
||
videoDiscLog = discountLog
|
||
})
|
||
wg.Wait()
|
||
freeTrialContext := FreeTrialBadgeContextForUser(uid, self)
|
||
commentCountMap := getVideoParentCommentCountMap(videos)
|
||
for i, v := range infos {
|
||
var uInfo vidmod.Publisher
|
||
if mUser[v.PublisherID] != nil {
|
||
uInfo = *mUser[v.PublisherID]
|
||
} else {
|
||
//处理作者被删除的情况
|
||
if len(mUser) > 0 {
|
||
for i := range mUser {
|
||
uInfo = *mUser[i]
|
||
break
|
||
}
|
||
}
|
||
}
|
||
// 金币帖子 - 图片帖子对所有人原价
|
||
// 非图片帖子再按规则计算折扣价
|
||
originCoins := v.Coins
|
||
infos[i].Coins = originCoins
|
||
if v.NewsType != vidmod.COVER {
|
||
infos[i].Coins = CalcVideoCoins(v.Coins, v.PublisherID, self, mFree, videoDiscLog, largestDiscount, discountAreaMap[v.DiscountAreaId])
|
||
}
|
||
info := transfer2Info(v, uInfo, mStatus[v.ID], mLocation[v.Location], GetPartTags(v.Tags, mTags), mComment[v.ID], originCoins)
|
||
if v.NewsType != vidmod.COVER {
|
||
// 计算折扣专区价格
|
||
info.DiscountAreaPrice = CalcDiscountAreaPrice(originCoins, discountAreaMap[v.DiscountAreaId])
|
||
}
|
||
info.ShowFreeTrialBadge, info.FreeTrialRemaining, info.CanUseFreeTrial = freeTrialContext.Fields(
|
||
info.NewsType,
|
||
originCoins,
|
||
v.FreeArea,
|
||
v.PublisherID,
|
||
)
|
||
info.HappinessPlazaTop = infos[i].HappinessPlazaTop
|
||
back[i] = info
|
||
module, ok := moduleMap[v.MID]
|
||
if ok {
|
||
info.VideoTypeId = module.ID.Hex()
|
||
info.VideoTypeName = module.ModuleName
|
||
}
|
||
// 与 comment/list 口径一致：不统计置顶公共评论（该评论不在评论表内）。
|
||
back[i].CommentCount = commentCountMap[info.ID]
|
||
}
|
||
common.Go(func() {
|
||
incVideoPageView(videos)
|
||
})
|
||
return back
|
||
}
|
||
|
||
// NewEncodeVideoInfoNotStatus 封装返回的视频列表信息
|
||
func NewEncodeVideoInfoNotStatus(infos []*vidmod.VideoModel) []*vidmod.VideoInfoResp {
|
||
return newEncodeVideoInfoNotStatus(filterOutsideSearch(infos))
|
||
}
|
||
|
||
// NewEncodeVideoInfoNotStatusForUser 封装需要用户免费观看状态的无状态视频列表。
|
||
func NewEncodeVideoInfoNotStatusForUser(uid uint64, infos []*vidmod.VideoModel) []*vidmod.VideoInfoResp {
|
||
result := newEncodeVideoInfoNotStatus(filterOutsideSearch(infos))
|
||
ApplyFreeTrialBadgeToVideoInfoResps(LoadFreeTrialBadgeContext(uid), result)
|
||
return result
|
||
}
|
||
|
||
// NewEncodeVideoInfoNotStatusForRecommend 过滤配置为不进入推荐场景的亚模块内容。
|
||
func NewEncodeVideoInfoNotStatusForRecommend(infos []*vidmod.VideoModel) []*vidmod.VideoInfoResp {
|
||
return newEncodeVideoInfoNotStatus(filterRecommend(infos))
|
||
}
|
||
|
||
// NewEncodeVideoInfoNotStatusForSearch 保留搜索专属内容，并给结果签发短时效访问凭证。
|
||
func NewEncodeVideoInfoNotStatusForSearch(uid uint64, infos []*vidmod.VideoModel) []*vidmod.VideoInfoResp {
|
||
result := newEncodeVideoInfoNotStatus(filterSearch(infos))
|
||
ApplyFreeTrialBadgeToVideoInfoResps(LoadFreeTrialBadgeContext(uid), result)
|
||
attachVideoInfoRespSearchTokens(uid, result)
|
||
return result
|
||
}
|
||
|
||
func newEncodeVideoInfoNotStatus(infos []*vidmod.VideoModel) []*vidmod.VideoInfoResp {
|
||
if len(infos) == 0 {
|
||
return nil
|
||
}
|
||
var (
|
||
back []*vidmod.VideoInfoResp
|
||
uids []uint64
|
||
videos []primitive.ObjectID
|
||
lids []primitive.ObjectID
|
||
tags []primitive.ObjectID
|
||
|
||
mUser = map[uint64]*vidmod.Publisher{}
|
||
mTags = map[primitive.ObjectID]vidmod.TagInfo{}
|
||
mStatus = map[OID]vidmod.VideoStatus{}
|
||
)
|
||
for _, i := range infos {
|
||
uids = append(uids, i.PublisherID)
|
||
videos = append(videos, i.ID)
|
||
lids = append(lids, i.Location)
|
||
tags = append(tags, i.Tags...)
|
||
}
|
||
|
||
var wg sync.WaitGroup
|
||
wg.Add(2)
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
mUser = GetUserInfo2Map(0, uids)
|
||
})
|
||
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
mTags = GetTagsByIDs2Map(tags)
|
||
})
|
||
|
||
wg.Wait()
|
||
commentCountMap := getVideoParentCommentCountMap(videos)
|
||
for i, v := range infos {
|
||
temp := v
|
||
originCoins := temp.Coins
|
||
var uInfo vidmod.Publisher
|
||
if mUser[temp.PublisherID] != nil {
|
||
uInfo = *mUser[temp.PublisherID]
|
||
} else {
|
||
//处理作者被删除的情况
|
||
if len(mUser) > 0 {
|
||
for i := range mUser {
|
||
uInfo = *mUser[i]
|
||
break
|
||
}
|
||
}
|
||
}
|
||
infos[i].Coins = originCoins
|
||
info := NewTransfer2Info(temp, uInfo, mStatus[temp.ID], GetPartTags(temp.Tags, mTags), originCoins)
|
||
info.CommentCount = commentCountMap[temp.ID]
|
||
back = append(back, info)
|
||
}
|
||
common.Go(func() {
|
||
incVideoPageView(videos)
|
||
})
|
||
return back
|
||
}
|
||
|
||
// NewEncodeVideoInfo 封装返回的视频列表信息
|
||
func NewEncodeVideoInfo(uid uint64, infos []*vidmod.VideoModel) []*vidmod.VideoInfoResp {
|
||
return newEncodeVideoInfo(uid, filterOutsideSearch(infos))
|
||
}
|
||
|
||
func newEncodeVideoInfo(uid uint64, infos []*vidmod.VideoModel) []*vidmod.VideoInfoResp {
|
||
var back []*vidmod.VideoInfoResp
|
||
if uid == 0 {
|
||
return back
|
||
}
|
||
if len(infos) == 0 {
|
||
return back
|
||
}
|
||
var uids []uint64
|
||
var videos []primitive.ObjectID
|
||
var lids []primitive.ObjectID
|
||
var tags []primitive.ObjectID
|
||
for _, i := range infos {
|
||
uids = append(uids, i.PublisherID)
|
||
videos = append(videos, i.ID)
|
||
lids = append(lids, i.Location)
|
||
tags = append(tags, i.Tags...)
|
||
|
||
}
|
||
var (
|
||
mUser map[uint64]*vidmod.Publisher
|
||
mStatus map[OID]vidmod.VideoStatus
|
||
mTags map[primitive.ObjectID]vidmod.TagInfo
|
||
)
|
||
|
||
var wg sync.WaitGroup
|
||
wg.Add(3)
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
mUser = GetUserInfo2Map(uid, uids)
|
||
})
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
mStatus = GetUserStatus(uid, videos)
|
||
})
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
mTags = GetTagsByIDs2Map(tags)
|
||
})
|
||
wg.Wait()
|
||
freeTrialContext := LoadFreeTrialBadgeContext(uid)
|
||
commentCountMap := getVideoParentCommentCountMap(videos)
|
||
for i, v := range infos {
|
||
temp := v
|
||
originCoins := temp.Coins
|
||
var uInfo vidmod.Publisher
|
||
if mUser[temp.PublisherID] != nil {
|
||
uInfo = *mUser[temp.PublisherID]
|
||
} else {
|
||
//处理作者被删除的情况
|
||
if len(mUser) > 0 {
|
||
for i := range mUser {
|
||
uInfo = *mUser[i]
|
||
break
|
||
}
|
||
}
|
||
}
|
||
infos[i].Coins = originCoins
|
||
info := NewTransfer2Info(temp, uInfo, mStatus[temp.ID], GetPartTags(v.Tags, mTags), originCoins)
|
||
info.ShowFreeTrialBadge, info.FreeTrialRemaining, info.CanUseFreeTrial = freeTrialContext.Fields(
|
||
info.NewsType,
|
||
originCoins,
|
||
temp.FreeArea,
|
||
temp.PublisherID,
|
||
)
|
||
info.CommentCount = commentCountMap[temp.ID]
|
||
back = append(back, info)
|
||
}
|
||
common.Go(func() {
|
||
incVideoPageView(videos)
|
||
})
|
||
return back
|
||
}
|
||
|
||
// CalcVideoCoins 计算折扣后视频金币数，判断了包括用户是否为VIP，以及是否购买了视频折扣卡等状态
|
||
// 注意：调用此函数时，在用户为VIP的情况下，largestDiscount必须设为0！
|
||
func CalcVideoCoins(originCoins int64, publisherID uint64, self *usermod.User, mFree map[uint64]bool,
|
||
videoDiscLog videodiscountmod.VideoDiscountLog, largestDiscount int, discountArea *discount_area_mod.DiscountArea) (discountedCoins int64) {
|
||
if originCoins == 0 {
|
||
discountedCoins = 0
|
||
return
|
||
}
|
||
discountedCoins = math.MaxInt64
|
||
now := time.Now()
|
||
// 如果在折扣专区里，直接按照折扣专区的价格来
|
||
if self != nil && self.IsVIP(now) && discountArea != nil {
|
||
// 计算折扣专区价格
|
||
discountedCoins = CalcDiscountAreaPrice(originCoins, discountArea)
|
||
return
|
||
}
|
||
//判断当前视频 是否对uid为免费视频 则将金币置为0
|
||
if b, ok := mFree[publisherID]; ok && b {
|
||
discountedCoins = 0
|
||
return
|
||
}
|
||
goldVideoFreeLimit := usermod.GetGoldVideoFreeLimit(self)
|
||
// 预售卡全部金币视频免费
|
||
if self != nil && self.AllGoldVideoFree && self.GoldVideoFreeExpire.After(now) {
|
||
discountedCoins = 0
|
||
return
|
||
}
|
||
// 用户购买了视频免费卡(视频金币数少于30)
|
||
if originCoins <= goldVideoFreeLimit && self != nil && self.VideoFreeExpiration != nil && self.VideoFreeExpiration.After(now) {
|
||
discountedCoins = 0
|
||
return
|
||
}
|
||
|
||
// 用户购买VIP时赠送了视频免费天数
|
||
if self != nil && originCoins > 0 && originCoins <= goldVideoFreeLimit && (self.GoldVideoFreeExpire.After(now) ||
|
||
(self.VideoFreeExpiration != nil && self.VideoFreeExpiration.After(now))) {
|
||
discountedCoins = 0
|
||
return
|
||
}
|
||
// 用户购买VIP后赠送视频折扣
|
||
if originCoins > 0 && self != nil && self.IsVIP(now) && self.PayVidDiscount > 0 {
|
||
discountedCoins = decimal.NewFromInt(int64(self.PayVidDiscount)).Shift(-1).
|
||
Mul(decimal.NewFromInt(originCoins)).Round(0).IntPart()
|
||
}
|
||
if originCoins > 0 {
|
||
if videoDiscLog.VideoDiscount > 0 { // 用户购买了视频折扣卡
|
||
newDiscountedCoins := decimal.NewFromInt(int64(videoDiscLog.VideoDiscount)).Shift(-1).
|
||
Mul(decimal.NewFromInt(originCoins)).Round(0).IntPart()
|
||
if newDiscountedCoins < discountedCoins {
|
||
discountedCoins = newDiscountedCoins
|
||
}
|
||
} else if largestDiscount > 0 { // 用户未购买视频折扣卡，此时按系统中所有VIP卡最大折扣计算
|
||
newDiscountedCoins := decimal.NewFromInt(int64(largestDiscount)).Shift(-1).
|
||
Mul(decimal.NewFromInt(originCoins)).Round(0).IntPart()
|
||
if newDiscountedCoins < discountedCoins {
|
||
discountedCoins = newDiscountedCoins
|
||
}
|
||
}
|
||
}
|
||
if discountedCoins == math.MaxInt64 {
|
||
discountedCoins = originCoins
|
||
}
|
||
return
|
||
}
|
||
|
||
// CalcDiscountAreaPrice 计算折扣专区的价格
|
||
func CalcDiscountAreaPrice(originCoins int64, discountArea *discount_area_mod.DiscountArea) (price int64) {
|
||
price = originCoins
|
||
// 判断当前视频是否在vip折扣区
|
||
if discountArea != nil {
|
||
price = decimal.NewFromInt(int64(discountArea.Discount)).Shift(-2).
|
||
Mul(decimal.NewFromInt(originCoins)).Round(0).IntPart()
|
||
}
|
||
return
|
||
}
|
||
|
||
// EncodeVideoInfoNoUID 封装返回的视频列表信息(无用户)
|
||
func EncodeVideoInfoNoUID(infos []*vidmod.VideoModel) []*vidmod.VideoInfo {
|
||
return encodeVideoInfoNoUID(filterOutsideSearch(infos))
|
||
}
|
||
|
||
// EncodeVideoInfoNoUIDForRecommend 过滤配置为不进入推荐场景的亚模块内容。
|
||
func EncodeVideoInfoNoUIDForRecommend(infos []*vidmod.VideoModel) []*vidmod.VideoInfo {
|
||
return encodeVideoInfoNoUID(filterRecommend(infos))
|
||
}
|
||
|
||
func encodeVideoInfoNoUID(infos []*vidmod.VideoModel) []*vidmod.VideoInfo {
|
||
infosLen := len(infos)
|
||
back := make([]*vidmod.VideoInfo, infosLen)
|
||
if infosLen == 0 {
|
||
return back
|
||
}
|
||
uids := make([]uint64, infosLen)
|
||
videos := make([]primitive.ObjectID, infosLen)
|
||
lids := make([]primitive.ObjectID, infosLen)
|
||
var tags []primitive.ObjectID
|
||
for i, v := range infos {
|
||
uids[i] = v.PublisherID
|
||
videos[i] = v.ID
|
||
lids[i] = v.Location
|
||
tags = append(tags, v.Tags...)
|
||
}
|
||
var mUser map[uint64]*vidmod.Publisher
|
||
var mLocation map[primitive.ObjectID]locmod.Location
|
||
var mComment map[primitive.ObjectID]vidmod.CommentInfo
|
||
var mTags map[primitive.ObjectID]vidmod.TagInfo
|
||
var wg sync.WaitGroup
|
||
wg.Add(3)
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
mUser = GetUserInfo2MapNoUID(uids)
|
||
})
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
mLocation, _ = locmod.GetLocationInfoByIDs(lids)
|
||
})
|
||
common.Go(func() {
|
||
defer wg.Done()
|
||
mTags = GetTagsByIDs2Map(tags)
|
||
})
|
||
wg.Wait()
|
||
commentCountMap := getVideoParentCommentCountMap(videos)
|
||
for i, v := range infos {
|
||
originCoins := v.Coins
|
||
var uInfo vidmod.Publisher
|
||
if mUser[v.PublisherID] != nil {
|
||
uInfo = *mUser[v.PublisherID]
|
||
}
|
||
noUserStatus := vidmod.VideoStatus{}
|
||
info := transfer2Info(v, uInfo, noUserStatus, mLocation[v.Location], GetPartTags(v.Tags, mTags),
|
||
mComment[v.ID], originCoins)
|
||
info.CommentCount = commentCountMap[v.ID]
|
||
back[i] = info
|
||
}
|
||
common.Go(func() {
|
||
incVideoPageView(videos)
|
||
})
|
||
return back
|
||
}
|
||
|
||
func filterOutsideSearch(infos []*vidmod.VideoModel) []*vidmod.VideoModel {
|
||
if len(infos) == 0 {
|
||
return infos
|
||
}
|
||
moduleIDs := make([]string, 0, len(infos))
|
||
for _, video := range infos {
|
||
if video != nil && video.MID != "" {
|
||
moduleIDs = append(moduleIDs, video.MID)
|
||
}
|
||
}
|
||
blocked, err := moduleconfmod.BlockedOutsideSearchModuleIDs(moduleIDs, time.Now())
|
||
if err != nil {
|
||
log.Error("filterOutsideSearch module query failed", log.E(err))
|
||
return []*vidmod.VideoModel{}
|
||
}
|
||
if len(blocked) == 0 {
|
||
return infos
|
||
}
|
||
filtered := make([]*vidmod.VideoModel, 0, len(infos))
|
||
for _, video := range infos {
|
||
if video == nil {
|
||
continue
|
||
}
|
||
if _, exists := blocked[video.MID]; exists {
|
||
continue
|
||
}
|
||
filtered = append(filtered, video)
|
||
}
|
||
return filtered
|
||
}
|
||
|
||
func filterRecommend(infos []*vidmod.VideoModel) []*vidmod.VideoModel {
|
||
if len(infos) == 0 {
|
||
return infos
|
||
}
|
||
excluded, err := moduleconfmod.ExcludedVideoModuleIDs(time.Now(), true)
|
||
if err != nil {
|
||
log.Error("filterRecommend module query failed", log.E(err))
|
||
return []*vidmod.VideoModel{}
|
||
}
|
||
blocked := make(map[string]struct{}, len(excluded))
|
||
for _, moduleID := range excluded {
|
||
blocked[moduleID] = struct{}{}
|
||
}
|
||
if len(blocked) == 0 {
|
||
return infos
|
||
}
|
||
filtered := make([]*vidmod.VideoModel, 0, len(infos))
|
||
for _, video := range infos {
|
||
if video == nil {
|
||
continue
|
||
}
|
||
if _, exists := blocked[video.MID]; exists {
|
||
continue
|
||
}
|
||
filtered = append(filtered, video)
|
||
}
|
||
return filtered
|
||
}
|
||
|
||
func filterSearch(infos []*vidmod.VideoModel) []*vidmod.VideoModel {
|
||
if len(infos) == 0 {
|
||
return infos
|
||
}
|
||
excluded, err := moduleconfmod.ExcludedSearchModuleIDs()
|
||
if err != nil {
|
||
log.Error("filterSearch module query failed", log.E(err))
|
||
return []*vidmod.VideoModel{}
|
||
}
|
||
blocked := make(map[string]struct{}, len(excluded))
|
||
for _, moduleID := range excluded {
|
||
blocked[moduleID] = struct{}{}
|
||
}
|
||
if len(blocked) == 0 {
|
||
return infos
|
||
}
|
||
filtered := make([]*vidmod.VideoModel, 0, len(infos))
|
||
for _, video := range infos {
|
||
if video == nil {
|
||
continue
|
||
}
|
||
if _, exists := blocked[video.MID]; exists {
|
||
continue
|
||
}
|
||
filtered = append(filtered, video)
|
||
}
|
||
return filtered
|
||
}
|
||
|
||
func attachVideoInfoSearchTokens(uid uint64, videos []*vidmod.VideoInfo) {
|
||
now := time.Now()
|
||
for _, video := range videos {
|
||
if video == nil {
|
||
continue
|
||
}
|
||
token, err := searchaccessser.Issue(uid, video.ID.Hex(), now)
|
||
if err != nil {
|
||
log.Error("issue video search access token failed", log.Any("videoID", video.ID), log.E(err))
|
||
continue
|
||
}
|
||
video.SearchAccessToken = token
|
||
}
|
||
}
|
||
|
||
func attachVideoInfoRespSearchTokens(uid uint64, videos []*vidmod.VideoInfoResp) {
|
||
now := time.Now()
|
||
for _, video := range videos {
|
||
if video == nil {
|
||
continue
|
||
}
|
||
token, err := searchaccessser.Issue(uid, video.ID.Hex(), now)
|
||
if err != nil {
|
||
log.Error("issue video search access token failed", log.Any("videoID", video.ID), log.E(err))
|
||
continue
|
||
}
|
||
video.SearchAccessToken = token
|
||
}
|
||
}
|
||
|
||
func incVideoPageView(vids []primitive.ObjectID) {
|
||
now := time.Now()
|
||
recentMinute := timerange.RecentMinute(now, statrecordmod.FiveMinuteScale)
|
||
key := redisconst.VidPageViewListKey(recentMinute.Unix())
|
||
vidStrs := make([]string, len(vids))
|
||
for i := range vids {
|
||
vidStrs[i] = vids[i].Hex()
|
||
}
|
||
if err := appg.Redis.RPush(key, vidStrs); err != nil {
|
||
return
|
||
}
|
||
_, _ = appg.Redis.ExpireKey(key, time.Minute*20)
|
||
}
|
||
|
||
func incTagCount(v tagmod.Tag, isValidPlay bool) error {
|
||
// 增加总播放量
|
||
tPlayCount := v.TPlayCount + 1
|
||
// 增加有效播放量量&更新播放率
|
||
vPlayCount := v.VPlayCount
|
||
var playRating float64
|
||
if isValidPlay {
|
||
vPlayCount++
|
||
playRating = maths.Decimal6Bit(float64(vPlayCount) / float64(tPlayCount))
|
||
} else {
|
||
playRating = maths.Decimal6Bit(float64(vPlayCount) / float64(tPlayCount))
|
||
}
|
||
doc := tagmod.TagUpdateDoc{
|
||
VPlayCount: &vPlayCount,
|
||
TPlayCount: &tPlayCount,
|
||
PlayRating: &playRating,
|
||
UpdatedAt: time.Now(),
|
||
}
|
||
if err := tagmod.UpdateOneTagByID(v.ID, doc); err != nil {
|
||
log.Error("incTagCount error", log.Any("tid", v.ID), log.Any("isValidPlay", isValidPlay), log.E(err))
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// IncreaseTag 播放视频对标签计数
|
||
func IncreaseTag(vidID string, tid primitive.ObjectID, isValidPlay bool) error {
|
||
if !tid.IsZero() {
|
||
tag, err := tagmod.FindOneTagByID(tid)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
_ = incTagCount(tag, isValidPlay)
|
||
return err
|
||
}
|
||
tags, err := vidmod.GetVideoTag(vidID)
|
||
if err != nil || len(tags) <= 0 {
|
||
log.Error("IncreaseTag error", log.Any("vidID", vidID), log.Any("isValidPlay", isValidPlay), log.E(err))
|
||
return err
|
||
}
|
||
tagList, err := tagmod.FindTagsByIDS(tags)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
for _, v := range tagList {
|
||
_ = incTagCount(v, isValidPlay)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// GetVideosByIDs 通过id获取视频列表信息
|
||
func GetVideosByIDs(uid uint64, ids []primitive.ObjectID) []*vidmod.VideoInfo {
|
||
if len(ids) == 0 {
|
||
log.Warn("GetVideosByIDs error", log.Any("uid", uid), log.Any("ids", ids))
|
||
return nil
|
||
}
|
||
vInfo, unExistsVid, err := getVideoListByIDsFromRedis(ids)
|
||
if err != nil || len(unExistsVid) != 0 {
|
||
unExistsVInfo, err := getVideoListByIDsFromMongo(unExistsVid)
|
||
if err != nil {
|
||
log.Error("GetVideosByIDs getVideoListByIDsFromMongo", log.Any("udi", uid), log.Any("ids", ids),
|
||
log.E(err))
|
||
return nil
|
||
}
|
||
common.Go(func() {
|
||
if cacheErr := setVideoListByIDs2Redis(unExistsVInfo); cacheErr != nil {
|
||
log.Error("GetVideosByIDs setVideoListByIDs2Redis", log.Any("unExistsVid", unExistsVid), log.Any("uid", uid),
|
||
log.E(cacheErr))
|
||
}
|
||
})
|
||
vInfo = append(vInfo, unExistsVInfo...)
|
||
}
|
||
if uid == 0 { // 用户未登录
|
||
return EncodeVideoInfoNoUID(vInfo)
|
||
}
|
||
return EncodeVideoInfo(uid, vInfo)
|
||
}
|
||
|
||
// GetVideosByIDsNoCache 通过id直接从MongoDB获取视频列表信息，不读写Redis缓存。
|
||
// 按传入ID顺序返回，保证收藏列表维持收藏时间倒序。
|
||
func GetVideosByIDsNoCache(uid uint64, ids []primitive.ObjectID) []*vidmod.VideoInfo {
|
||
if len(ids) == 0 {
|
||
return nil
|
||
}
|
||
vInfo, err := getVideoListByIDsFromMongo(ids)
|
||
if err != nil {
|
||
log.Error("GetVideosByIDsNoCache getVideoListByIDsFromMongo", log.Any("uid", uid), log.Any("ids", ids),
|
||
log.E(err))
|
||
return nil
|
||
}
|
||
vInfo = orderVideoModelsByIDs(ids, vInfo)
|
||
if uid == 0 {
|
||
return EncodeVideoInfoNoUID(vInfo)
|
||
}
|
||
return EncodeVideoInfo(uid, vInfo)
|
||
}
|
||
|
||
func orderVideoModelsByIDs(ids []primitive.ObjectID, videos []*vidmod.VideoModel) []*vidmod.VideoModel {
|
||
videoByID := make(map[primitive.ObjectID]*vidmod.VideoModel, len(videos))
|
||
for _, video := range videos {
|
||
if video != nil {
|
||
videoByID[video.ID] = video
|
||
}
|
||
}
|
||
ordered := make([]*vidmod.VideoModel, 0, len(videos))
|
||
for _, id := range ids {
|
||
if video, ok := videoByID[id]; ok {
|
||
ordered = append(ordered, video)
|
||
}
|
||
}
|
||
return ordered
|
||
}
|
||
|
||
// NewGetVideosByIDs 通过id获取视频列表信息
|
||
func NewGetVideosByIDs(uid uint64, ids []primitive.ObjectID) []*vidmod.VideoInfoResp {
|
||
if len(ids) == 0 {
|
||
log.Warn("GetVideosByIDs error", log.Any("uid", uid), log.Any("ids", ids))
|
||
return nil
|
||
}
|
||
vInfo, unExistsVid, err := getVideoListByIDsFromRedis(ids)
|
||
if err != nil || len(unExistsVid) != 0 {
|
||
unExistsVInfo, err := getVideoListByIDsFromMongo(unExistsVid)
|
||
if err != nil {
|
||
log.Error("GetVideosByIDs getVideoListByIDsFromMongo", log.Any("udi", uid), log.Any("ids", ids),
|
||
log.E(err))
|
||
return nil
|
||
}
|
||
|
||
common.Go(func() {
|
||
if cacheErr := setVideoListByIDs2Redis(unExistsVInfo); cacheErr != nil {
|
||
log.Error("GetVideosByIDs setVideoListByIDs2Redis", log.Any("unExistsVid", unExistsVid), log.Any("uid", uid),
|
||
log.E(cacheErr))
|
||
}
|
||
})
|
||
vInfo = append(vInfo, unExistsVInfo...)
|
||
// 将redis中获取不到的写入切片中后得按照原来id顺序的重新排序
|
||
videoMap := make(map[primitive.ObjectID]*vidmod.VideoModel)
|
||
for _, v := range vInfo {
|
||
videoMap[v.ID] = v
|
||
}
|
||
videoList := []*vidmod.VideoModel{}
|
||
for _, id := range ids {
|
||
video, ok := videoMap[id]
|
||
if !ok {
|
||
continue
|
||
}
|
||
videoList = append(videoList, video)
|
||
}
|
||
vInfo = videoList
|
||
}
|
||
//if uid == 0 { // 用户未登录
|
||
// return EncodeVideoInfoNoUID(vInfo)
|
||
//}
|
||
return NewEncodeVideoInfo(uid, vInfo)
|
||
}
|
||
|
||
func getVideoModelByIDs(ids []primitive.ObjectID) []*vidmod.VideoModel {
|
||
if len(ids) == 0 {
|
||
log.Warn("getVideoModelByIDs error", log.Any("ids", ids))
|
||
return nil
|
||
}
|
||
vInfo, unExistsVid, err := getVideoListByIDsFromRedis(ids)
|
||
if err != nil || len(unExistsVid) != 0 {
|
||
unExistsVInfo, err := getVideoListByIDsFromMongoBaseNoStatus(unExistsVid)
|
||
if err != nil {
|
||
return nil
|
||
}
|
||
common.Go(func() {
|
||
_ = setVideoListByIDs2Redis(unExistsVInfo)
|
||
})
|
||
vInfo = append(vInfo, unExistsVInfo...)
|
||
}
|
||
return vInfo
|
||
}
|
||
|
||
// GetVideoListByIDsNoStatus 通过id获取视频列表信息 底层不判断视频状态, 由上次业务保证ID的正确性
|
||
func GetVideoListByIDsNoStatus(uid uint64, ids []primitive.ObjectID) []*vidmod.VideoInfoResp {
|
||
vInfo := getVideoModelByIDs(ids)
|
||
return NewEncodeVideoInfo(uid, vInfo)
|
||
}
|
||
|
||
func getRedis() *redis.Client {
|
||
if appg.Redis != nil {
|
||
return appg.Redis
|
||
}
|
||
if skdg.Redis != nil {
|
||
return skdg.Redis
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func setCache(recentMinute time.Time) {
|
||
common.Go(func() {
|
||
ids := getNewsTop200FromMongo(recentMinute)
|
||
if len(ids) != 0 {
|
||
setNewestNews2Redis(ids, recentMinute)
|
||
}
|
||
})
|
||
}
|
||
|
||
func setCache_old() {
|
||
common.Go(func() {
|
||
ids := getNewsTop200FromMongo_old()
|
||
if len(ids) != 0 {
|
||
setNewestNews2Redis_old(ids)
|
||
}
|
||
})
|
||
}
|
||
|
||
func setShortVideoCache() {
|
||
common.Go(func() {
|
||
ids := getNewsShortVideoTop200FromMongo()
|
||
if len(ids) != 0 {
|
||
setNewestShortVideo2Redis(ids)
|
||
}
|
||
})
|
||
}
|
||
|
||
// GetNewestNews 获取最新帖子
|
||
// 最新两百条存redis，其他数据库查找
|
||
func GetNewestNews(page, size uint64, reqTime time.Time) ([]*vidmod.VideoModel, bool, error) {
|
||
recentMinute := timerange.RecentMinute(reqTime, statrecordmod.FiveMinuteScale)
|
||
endpoint := page * size
|
||
if endpoint > MaxNewestCacheNum { //大于200条的数据库获取
|
||
return getNewestNewsFromMongo(page, size, recentMinute)
|
||
}
|
||
ids, err := getNewestNewsFromRedis(page, size, recentMinute)
|
||
if err != nil || uint64(len(ids)) < size { //缓存获取失败，数据库获取
|
||
infos, hasNext, err := getNewestNewsFromMongo(page, size, recentMinute)
|
||
setCache(recentMinute)
|
||
return infos, hasNext, err
|
||
}
|
||
oids := common.String2ObjectID(ids)
|
||
infos := getVideoModelByIDs(oids)
|
||
if len(infos) == 0 {
|
||
log.Warn("info length error", log.Any("page", page), log.Any("size", size), log.Any("reqTime", reqTime), log.Any("recentMinute", recentMinute), log.Any("ids", ids))
|
||
}
|
||
return infos, true, nil
|
||
}
|
||
|
||
// GetNewestNews 获取最新帖子
|
||
// 最新两百条存redis，其他数据库查找
|
||
func GetNewestNews_old(page, size uint64) ([]*vidmod.VideoModel, bool, error) {
|
||
if endpoint := page * size; endpoint > MaxNewestCacheNum { //大于200条的数据库获取
|
||
return getNewestNewsFromMongo_old(page, size)
|
||
}
|
||
ids, err := getNewestNewsFromRedis_old(page, size)
|
||
if err != nil || uint64(len(ids)) < size { //缓存获取失败，数据库获取
|
||
infos, hasNext, err := getNewestNewsFromMongo_old(page, size)
|
||
setCache_old()
|
||
return infos, hasNext, err
|
||
}
|
||
oids := common.String2ObjectID(ids)
|
||
infos := getVideoModelByIDs(oids)
|
||
if len(infos) == 0 {
|
||
log.Warn("info length error_old", log.Any("page", page), log.Any("size", size), log.Any("ids", ids))
|
||
}
|
||
return infos, true, nil
|
||
}
|
||
|
||
func GetNewestShortVideo(page, size uint64) ([]*vidmod.VideoModel, bool, error) {
|
||
if endpoint := page * size; endpoint > MaxNewestCacheNum { //大于200条的数据库获取
|
||
return getNewestShortVideoFromMongo(page, size)
|
||
}
|
||
ids, err := getNewestShortVideoFromRedis(page, size)
|
||
if err != nil || uint64(len(ids)) < size { //缓存获取失败，数据库获取
|
||
infos, hasNext, err := getNewestShortVideoFromMongo(page, size)
|
||
setShortVideoCache()
|
||
return infos, hasNext, err
|
||
}
|
||
oids := common.String2ObjectID(ids)
|
||
infos := getVideoModelByIDs(oids)
|
||
if len(infos) == 0 {
|
||
log.Warn("info length error_old", log.Any("page", page), log.Any("size", size), log.Any("ids", ids))
|
||
}
|
||
return infos, true, nil
|
||
}
|
||
|
||
// IncCommentCount 评论统计次数加加
|
||
func IncCommentCount(id primitive.ObjectID) error {
|
||
if err := vidmod.IncCommentCount(id); err != nil {
|
||
return err
|
||
}
|
||
incComment(id)
|
||
return nil
|
||
}
|
||
|
||
// 修正用户喜欢的视频记录
|
||
func FixLikeVideoRecord(uid uint64, oids []primitive.ObjectID) {
|
||
back, err := vidmod.GetVideoListByIDsUnPublish(oids)
|
||
if err != nil || len(back) == 0 {
|
||
return
|
||
}
|
||
vids := make([]primitive.ObjectID, len(back))
|
||
for i, v := range back {
|
||
vids[i] = v.ID
|
||
}
|
||
}
|
||
|
||
// NewTransfer2Info 将视频数据库模式转为返回模式
|
||
func NewTransfer2Info(v *vidmod.VideoModel, uInfo vidmod.Publisher, vStatus vidmod.VideoStatus, tags []vidmod.TagInfo, originCoins int64) *vidmod.VideoInfoResp {
|
||
if v.Status == 3 {
|
||
v.Status = 1
|
||
}
|
||
newType := vidmod.SP
|
||
if len(v.NewsType) != 0 {
|
||
newType = v.NewsType
|
||
}
|
||
base := vidmod.VideoInfoResp{
|
||
ID: v.ID,
|
||
NewsType: newType,
|
||
Title: v.Title,
|
||
PlayTime: v.PlayTime,
|
||
Cover: v.Cover,
|
||
SeriesCover: v.SeriesCover,
|
||
PlayCount: (v.PlayCount + v.FakePlayCount) * VideoPlayCountMultiplier,
|
||
LikeCount: v.LikeCount, // 移除like数量加倍，修复各处like数不一致问题
|
||
PageViewCount: v.PageViewCount * 3,
|
||
CommentCount: v.CommentCount,
|
||
Coins: v.Coins,
|
||
Size: v.Size,
|
||
Resolution: v.Resolution,
|
||
Ratio: v.Ratio,
|
||
CreatedAt: v.CreatedAt,
|
||
ReviewAt: v.ReviewAt,
|
||
FreeTime: v.FreeTime,
|
||
Status: v.Status,
|
||
Reason: v.Reason,
|
||
SourceURL: v.SourceURL,
|
||
H265Url: H265URLForApp(v),
|
||
LinkUrl: v.LinkUrl,
|
||
//IsTopping: v.IsTopping,
|
||
IsChoosen: v.IsChoosen,
|
||
IsRecommend: v.IsRecommend,
|
||
Rewarded: v.Rewarded.Add(v.FakeRewarded),
|
||
OriginCoins: originCoins,
|
||
Chosen: v.Chosen,
|
||
DownloadAllow: v.DownloadAllow,
|
||
ShowType: v.ShowType,
|
||
FreeArea: v.FreeArea,
|
||
Tags: tags,
|
||
}
|
||
if v.LiaoBaTopSort > 0 {
|
||
base.IsTopping = true
|
||
}
|
||
var vipLevel int
|
||
if uInfo.VipExpireDate.After(time.Now()) {
|
||
vipLevel = uInfo.VipLevel
|
||
}
|
||
u := vidmod.AppPublisherResp{
|
||
UID: uInfo.UID,
|
||
Name: uInfo.Name,
|
||
Portrait: uInfo.Portrait,
|
||
HasFollowed: uInfo.HasFollowed,
|
||
VipLevel: vipLevel,
|
||
VipName: uInfo.VipName,
|
||
}
|
||
base.UInfo = u
|
||
base.VidStatus = vStatus
|
||
info := base
|
||
|
||
return &info
|
||
}
|
||
|
||
func ToVideoBaseInfo(v *vidmod.VideoModel, ti []vidmod.TagInfo, originCoins int64) *vidmod.VideoBase {
|
||
if v.Status == 3 {
|
||
v.Status = 1
|
||
}
|
||
newType := vidmod.SP
|
||
if len(v.NewsType) != 0 {
|
||
newType = v.NewsType
|
||
}
|
||
|
||
base := vidmod.VideoBase{
|
||
ID: v.ID,
|
||
NewsType: newType,
|
||
Title: v.Title,
|
||
Content: v.Content,
|
||
Tags: ti,
|
||
SourceURL: v.SourceURL,
|
||
H265Url: H265URLForApp(v),
|
||
PreviewURL: v.PreviewURL,
|
||
LinkUrl: v.LinkUrl,
|
||
PlayTime: v.PlayTime,
|
||
Cover: v.Cover,
|
||
CoverThumb: v.CoverThumb,
|
||
SeriesCover: v.SeriesCover,
|
||
LikeCount: v.LikeCount, // 移除like数量加倍，修复各处like数不一致问题
|
||
PlayCount: (v.PlayCount + v.FakePlayCount) * VideoPlayCountMultiplier,
|
||
PurchaseCount: v.PurchaseCount,
|
||
CommentCount: v.CommentCount,
|
||
ShareCount: v.FakeShareCount,
|
||
Coins: v.Coins,
|
||
Size: v.Size,
|
||
Resolution: v.Resolution,
|
||
Ratio: v.Ratio,
|
||
Status: v.Status,
|
||
Reason: v.Reason,
|
||
FreeTime: v.FreeTime,
|
||
IsHideLocation: v.IsHideLocation,
|
||
FreeArea: v.FreeArea,
|
||
CreatedAt: v.CreatedAt,
|
||
ReviewAt: v.ReviewAt,
|
||
IsTopping: v.IsTopping,
|
||
IsRecommend: v.IsRecommend,
|
||
IsChoosen: v.IsChoosen,
|
||
Rewarded: v.Rewarded.Add(v.FakeRewarded),
|
||
OriginCoins: originCoins,
|
||
CollectCount: v.CollectCount,
|
||
PageViewCount: v.PageViewCount * 3,
|
||
SeedLinkUrl: v.SeedLinkUrl,
|
||
SeedSize: v.SeedSize,
|
||
SeedPlayTime: v.SeedPlayTime,
|
||
PreviewStart: v.PreviewStart,
|
||
RichText: v.RichText,
|
||
TimeNodeList: v.TimeNodeList,
|
||
DownloadAllow: v.DownloadAllow,
|
||
ShowType: v.ShowType,
|
||
}
|
||
return &base
|
||
}
|