1814 lines
60 KiB
Go
1814 lines
60 KiB
Go
package srv_playlet
|
|
|
|
import (
|
|
"context"
|
|
"math/rand"
|
|
"regexp"
|
|
"strings"
|
|
"time"
|
|
"videoweb/pub/common/enum/redisconst"
|
|
"videoweb/pub/common/log"
|
|
"videoweb/pub/common/playletcache"
|
|
"videoweb/pub/common/response"
|
|
"videoweb/pub/common/slugx"
|
|
"videoweb/pub/common/srvdef"
|
|
"videoweb/pub/common/utils"
|
|
"videoweb/pub/models"
|
|
"videoweb/pub/models/commentlikemod"
|
|
"videoweb/pub/models/commentmod"
|
|
"videoweb/pub/models/contenttagmod"
|
|
"videoweb/pub/models/mwacc"
|
|
"videoweb/pub/models/playletcategorymod"
|
|
"videoweb/pub/models/playletchaptermod"
|
|
"videoweb/pub/models/playletfavoritemod"
|
|
"videoweb/pub/models/playletlikemod"
|
|
"videoweb/pub/models/playletmod"
|
|
"videoweb/pub/models/playletthememod"
|
|
"videoweb/pub/mongos"
|
|
"videoweb/pub/pubdef"
|
|
"videoweb/pub/redis"
|
|
"videoweb/web/api/proto"
|
|
"videoweb/web/service/srv_contenttag"
|
|
"videoweb/web/service/srv_mediaresource"
|
|
"videoweb/web/service/srv_search"
|
|
"videoweb/web/service/srv_seopush"
|
|
"videoweb/web/skd/playletwatermark"
|
|
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
"go.mongodb.org/mongo-driver/mongo"
|
|
"go.mongodb.org/mongo-driver/mongo/options"
|
|
)
|
|
|
|
var playletWebProjection = bson.D{
|
|
{Key: playletmod.FN.Playlet.Id, Value: 1},
|
|
{Key: playletmod.FN.Playlet.Status, Value: 1},
|
|
{Key: playletmod.FN.Playlet.IsFeatured, Value: 1},
|
|
{Key: playletmod.FN.Playlet.IsOriginal, Value: 1},
|
|
{Key: playletmod.FN.Playlet.ShowOriginal, Value: 1},
|
|
{Key: playletmod.FN.Playlet.IsRecommend, Value: 1},
|
|
{Key: playletmod.FN.Playlet.ShowOnBanner, Value: 1},
|
|
{Key: playletmod.FN.Playlet.Banner, Value: 1},
|
|
{Key: playletmod.FN.Playlet.ReviewAt, Value: 1},
|
|
{Key: playletmod.FN.Playlet.OnlineAt, Value: 1},
|
|
{Key: playletmod.FN.Playlet.Title, Value: 1},
|
|
{Key: playletmod.FN.Playlet.Slug, Value: 1},
|
|
{Key: playletmod.FN.Playlet.Desc, Value: 1},
|
|
{Key: playletmod.FN.Playlet.Anchor, Value: 1},
|
|
{Key: playletmod.FN.Playlet.Cover, Value: 1},
|
|
{Key: playletmod.FN.Playlet.CompressedCover, Value: 1},
|
|
{Key: playletmod.FN.Playlet.Preview, Value: 1},
|
|
{Key: playletmod.FN.Playlet.CategoryIds, Value: 1},
|
|
{Key: playletmod.FN.Playlet.CategoryBinds, Value: 1},
|
|
{Key: playletmod.FN.Playlet.ThemeIds, Value: 1},
|
|
{Key: playletmod.FN.Playlet.TagIds, Value: 1},
|
|
{Key: playletmod.FN.Playlet.ContentType, Value: 1},
|
|
{Key: playletmod.FN.Playlet.PayType, Value: 1},
|
|
{Key: playletmod.FN.Playlet.SingleCoins, Value: 1},
|
|
{Key: playletmod.FN.Playlet.TotalEpisode, Value: 1},
|
|
{Key: playletmod.FN.Playlet.FreeEpisodeCount, Value: 1},
|
|
{Key: playletmod.FN.Playlet.UpdateStatus, Value: 1},
|
|
{Key: playletmod.FN.Playlet.TopRank, Value: 1},
|
|
{Key: playletmod.FN.Playlet.RecommendRank, Value: 1},
|
|
{Key: playletmod.FN.Playlet.CountComment, Value: 1},
|
|
{Key: playletmod.FN.Playlet.CountBuy, Value: 1},
|
|
{Key: playletmod.FN.Playlet.CountBrowse, Value: 1},
|
|
{Key: playletmod.FN.Playlet.VirtualCountBrowse, Value: 1},
|
|
{Key: playletmod.FN.Playlet.HeatValue, Value: 1},
|
|
{Key: playletmod.FN.Playlet.VirtualHeatValue, Value: 1},
|
|
{Key: playletmod.FN.Playlet.CountCollect, Value: 1},
|
|
{Key: playletmod.FN.Playlet.CountLike, Value: 1},
|
|
{Key: playletmod.FN.Playlet.VirtualCountLike, Value: 1},
|
|
{Key: playletmod.FN.Playlet.CountDisLike, Value: 1},
|
|
{Key: playletmod.FN.Playlet.SeoInfo.Title, Value: 1},
|
|
{Key: playletmod.FN.Playlet.SeoInfo.Description, Value: 1},
|
|
{Key: playletmod.FN.Playlet.SeoInfo.Keyworld, Value: 1},
|
|
{Key: playletmod.FN.Playlet.OperatorId, Value: 1},
|
|
{Key: playletmod.FN.Playlet.OperatorName, Value: 1},
|
|
{Key: playletmod.FN.Playlet.CreatedAt, Value: 1},
|
|
{Key: playletmod.FN.Playlet.UpdatedAt, Value: 1},
|
|
}
|
|
|
|
// ListPlaylet 分页查询短剧列表
|
|
func ListPlaylet(ctx context.Context, req *proto.PlayletListReq) (*proto.PlayletListPageResp, *srvdef.SrvErr) {
|
|
if req == nil {
|
|
return nil, srvdef.New(srvdef.ErrParamError, "", "")
|
|
}
|
|
filter := buildPlayletListFilter(req)
|
|
pageNum, pageSize := normalizePage(req.PageNum, req.PageSize)
|
|
totalCount, err := playletmod.CountPlaylet(ctx, filter)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resp := &proto.PlayletListPageResp{
|
|
BasePageResp: response.BasePageResp{
|
|
TotalCount: totalCount,
|
|
PageSize: int(pageSize),
|
|
PageNum: int(pageNum),
|
|
List: make([]*proto.PlayletListResp, 0),
|
|
},
|
|
}
|
|
if totalCount == 0 {
|
|
return resp, nil
|
|
}
|
|
var list playletmod.PlayletList
|
|
if req.CategoryId != nil && *req.CategoryId > 0 {
|
|
list, err = playletmod.FindManyPlayletByCategoryRank(ctx, filter, *req.CategoryId, (pageNum-1)*pageSize, pageSize, playletmod.CategoryRankAdminSort(), playletWebProjection)
|
|
} else {
|
|
list, err = playletmod.FindManyPlaylet(ctx, filter, options.Find().
|
|
SetProjection(playletWebProjection).
|
|
SetSort(bson.D{
|
|
{Key: playletmod.FN.Playlet.CreatedAt, Value: -1},
|
|
{Key: playletmod.FN.Playlet.Id, Value: -1},
|
|
}).
|
|
SetSkip((pageNum-1)*pageSize).
|
|
SetLimit(pageSize))
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
categoryNameMap, err := buildCategoryNameMap(ctx, list)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
themeNameMap, err := buildThemeNameMap(ctx, list)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
tagNameMap, err := buildTagNameMap(ctx, list)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
items := make([]*proto.PlayletListResp, 0, len(list))
|
|
for _, item := range list {
|
|
if item == nil {
|
|
continue
|
|
}
|
|
webItem := playletToWebResp(item, categoryNameMap, themeNameMap, tagNameMap)
|
|
if req.CategoryId != nil {
|
|
webItem.CategoryRank = playletmod.CategoryRankOf(playletmod.EffectiveCategoryBinds(item), *req.CategoryId)
|
|
}
|
|
items = append(items, webItem)
|
|
}
|
|
resp.List = items
|
|
return resp, nil
|
|
}
|
|
|
|
// AddPlaylet 新增短剧
|
|
func AddPlaylet(ctx context.Context, req *proto.PlayletAddReq, operatorId int64) (*proto.PlayletAddResp, *srvdef.SrvErr) {
|
|
if req == nil {
|
|
return nil, srvdef.New(srvdef.ErrParamError, "参数不能为空", "")
|
|
}
|
|
title := strings.TrimSpace(req.Title)
|
|
if title == "" {
|
|
return nil, srvdef.New(srvdef.ErrParamError, "短剧标题不能为空", "")
|
|
}
|
|
categoryBinds, err := resolveAddCategoryBinds(req.CategoryBinds, req.CategoryIds)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
categoryIds := playletmod.CategoryIdsFromBinds(categoryBinds)
|
|
if err := validatePlayletCategoryIds(ctx, categoryIds); err != nil {
|
|
return nil, err
|
|
}
|
|
themeIds := dedupePositiveInt64Ids(req.ThemeIds)
|
|
if len(themeIds) == 0 {
|
|
return nil, srvdef.New(srvdef.ErrParamError, "题材ID不能为空", "")
|
|
}
|
|
if err := validatePlayletThemeIds(ctx, themeIds); err != nil {
|
|
return nil, err
|
|
}
|
|
tagIds, err := srv_contenttag.NormalizeContentTagIds(req.TagIds)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := srv_contenttag.ValidateContentTags(ctx, tagIds, contenttagmod.ContentTagTypePlaylet); err != nil {
|
|
return nil, err
|
|
}
|
|
if !isValidPlayletStatus(req.Status) {
|
|
return nil, srvdef.New(srvdef.ErrParamError, "上下架状态无效", "")
|
|
}
|
|
if !isValidPlayletContentType(req.ContentType) {
|
|
return nil, srvdef.New(srvdef.ErrParamError, "内容类型无效", "")
|
|
}
|
|
payType, singleCoins, err := normalizePlayletPaySetting(req.PayType, &req.SingleCoins, true)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
freeEpisodeCount := int64(2)
|
|
if req.FreeEpisodeCount != nil {
|
|
if !validOfficialFreeEpisodeCount(*req.FreeEpisodeCount) {
|
|
return nil, srvdef.New(srvdef.ErrParamError, "官网开放集数无效", "")
|
|
}
|
|
freeEpisodeCount = *req.FreeEpisodeCount
|
|
}
|
|
banner := strings.TrimSpace(req.Banner)
|
|
if req.ShowOnBanner && banner == "" {
|
|
return nil, srvdef.New(srvdef.ErrParamError, "显示首页banner时banner图不能为空", "")
|
|
}
|
|
now := time.Now()
|
|
operatorId, operatorName := resolvePlayletOperator(ctx, operatorId)
|
|
doc := &playletmod.Playlet{
|
|
Status: req.Status,
|
|
IsFeatured: req.IsFeatured,
|
|
IsOriginal: true, // 管理后台新增的短剧都是原创
|
|
ShowOriginal: req.ShowOriginal,
|
|
IsRecommend: req.IsRecommend,
|
|
ShowOnBanner: req.ShowOnBanner,
|
|
Banner: banner,
|
|
ReviewAt: now,
|
|
OnlineAt: playletOnlineAt(req.Status, now),
|
|
CategoryIds: categoryIds,
|
|
CategoryBinds: categoryBinds,
|
|
ThemeIds: themeIds,
|
|
Title: title,
|
|
Slug: req.Slug,
|
|
Desc: strings.TrimSpace(req.Desc),
|
|
Anchor: strings.TrimSpace(req.Anchor),
|
|
Cover: strings.TrimSpace(req.Cover),
|
|
Preview: strings.TrimSpace(req.Preview),
|
|
TagIds: tagIds,
|
|
ContentType: req.ContentType,
|
|
PayType: payType,
|
|
SingleCoins: singleCoins,
|
|
TotalEpisode: req.TotalEpisode,
|
|
FreeEpisodeCount: freeEpisodeCount,
|
|
TopRank: req.TopRank,
|
|
RecommendRank: req.RecommendRank,
|
|
SeoInfo: normalizeSeoValue(req.SeoInfo),
|
|
OperatorId: operatorId,
|
|
OperatorName: operatorName,
|
|
}
|
|
exists := func(s string) bool {
|
|
item, _ := playletmod.FindOnePlaylet(ctx, slugx.Filter(playletmod.FN.Playlet.Slug, playletmod.FN.Playlet.Id, s, 0))
|
|
return item != nil
|
|
}
|
|
if serr := slugx.Ensure(&doc.Slug, utils.SlugSourceFromKeywordsOrTitle(doc.SeoInfo.Keyworld, title), exists); serr != nil {
|
|
return nil, serr
|
|
}
|
|
if err := playletmod.InsertOnePlaylet(ctx, doc); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := srv_contenttag.SyncContentTagBindCount(ctx, nil, tagIds, contenttagmod.ContentTagTypePlaylet); err != nil {
|
|
return nil, err
|
|
}
|
|
go srv_mediaresource.FillPlayletCompressedCover(context.Background(), doc)
|
|
clearAppPlayletHomeCache()
|
|
if req.ShowOriginal {
|
|
playletcache.ClearRankCache()
|
|
}
|
|
srv_seopush.NotifyPlayletAfterWrite(ctx, doc.Id, nil, doc.Status, doc.OnlineAt)
|
|
if doc.Status == playletmod.StatusUp {
|
|
asyncSyncPlayletESByStatus([]int64{doc.Id}, doc.Status, "短剧新增")
|
|
}
|
|
return &proto.PlayletAddResp{Id: doc.Id}, nil
|
|
}
|
|
|
|
// UpdatePlaylet 更新短剧
|
|
func UpdatePlaylet(ctx context.Context, req *proto.PlayletUpdateReq, operatorId int64) *srvdef.SrvErr {
|
|
if req == nil || req.Id <= 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "短剧ID无效", "")
|
|
}
|
|
current, err := playletmod.FindOnePlaylet(ctx, bson.M{
|
|
playletmod.FN.Playlet.Id: req.Id,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
now := time.Now()
|
|
setDoc := bson.M{playletmod.FN.Playlet.UpdatedAt: now}
|
|
if req.Status != nil {
|
|
if !isValidPlayletStatus(*req.Status) {
|
|
return srvdef.New(srvdef.ErrParamError, "上下架状态无效", "")
|
|
}
|
|
setDoc[playletmod.FN.Playlet.Status] = *req.Status
|
|
setDoc[playletmod.FN.Playlet.ReviewAt] = now
|
|
if *req.Status == playletmod.StatusUp {
|
|
setDoc[playletmod.FN.Playlet.OnlineAt] = now
|
|
setDoc[playletmod.FN.Playlet.IndexNow] = int64(0)
|
|
}
|
|
}
|
|
if req.FreeEpisodeCount != nil {
|
|
if !validOfficialFreeEpisodeCount(*req.FreeEpisodeCount) {
|
|
return srvdef.New(srvdef.ErrParamError, "官网开放集数无效", "")
|
|
}
|
|
setDoc[playletmod.FN.Playlet.FreeEpisodeCount] = *req.FreeEpisodeCount
|
|
}
|
|
if req.IsFeatured != nil {
|
|
setDoc[playletmod.FN.Playlet.IsFeatured] = *req.IsFeatured
|
|
}
|
|
if req.ShowOriginal != nil {
|
|
setDoc[playletmod.FN.Playlet.ShowOriginal] = *req.ShowOriginal
|
|
}
|
|
if req.IsRecommend != nil {
|
|
setDoc[playletmod.FN.Playlet.IsRecommend] = *req.IsRecommend
|
|
}
|
|
if req.ShowOnBanner != nil {
|
|
setDoc[playletmod.FN.Playlet.ShowOnBanner] = *req.ShowOnBanner
|
|
}
|
|
if req.Banner != nil {
|
|
setDoc[playletmod.FN.Playlet.Banner] = strings.TrimSpace(*req.Banner)
|
|
}
|
|
if req.CategoryBinds != nil || req.CategoryIds != nil {
|
|
categoryBinds, err := resolveCategoryBinds(req.CategoryBinds, req.CategoryIds, playletmod.EffectiveCategoryBinds(current))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
categoryIds := playletmod.CategoryIdsFromBinds(categoryBinds)
|
|
if err := validatePlayletCategoryIds(ctx, categoryIds); err != nil {
|
|
return err
|
|
}
|
|
setDoc[playletmod.FN.Playlet.CategoryIds] = categoryIds
|
|
setDoc[playletmod.FN.Playlet.CategoryBinds] = categoryBinds
|
|
}
|
|
if req.ThemeIds != nil {
|
|
themeIds := dedupePositiveInt64Ids(*req.ThemeIds)
|
|
if len(themeIds) == 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "题材ID不能为空", "")
|
|
}
|
|
if err := validatePlayletThemeIds(ctx, themeIds); err != nil {
|
|
return err
|
|
}
|
|
setDoc[playletmod.FN.Playlet.ThemeIds] = themeIds
|
|
}
|
|
if req.Title != nil {
|
|
title := strings.TrimSpace(*req.Title)
|
|
if title == "" {
|
|
return srvdef.New(srvdef.ErrParamError, "短剧标题不能为空", "")
|
|
}
|
|
setDoc[playletmod.FN.Playlet.Title] = title
|
|
}
|
|
if req.Desc != nil {
|
|
setDoc[playletmod.FN.Playlet.Desc] = strings.TrimSpace(*req.Desc)
|
|
}
|
|
if req.Anchor != nil {
|
|
setDoc[playletmod.FN.Playlet.Anchor] = strings.TrimSpace(*req.Anchor)
|
|
}
|
|
coverChanged := false
|
|
if req.Cover != nil {
|
|
newCover := strings.TrimSpace(*req.Cover)
|
|
setDoc[playletmod.FN.Playlet.Cover] = newCover
|
|
if strings.TrimSpace(current.Cover) != newCover {
|
|
setDoc[playletmod.FN.Playlet.CompressedCover] = ""
|
|
coverChanged = true
|
|
}
|
|
}
|
|
if req.Preview != nil {
|
|
setDoc[playletmod.FN.Playlet.Preview] = strings.TrimSpace(*req.Preview)
|
|
}
|
|
var oldTagIds []int64
|
|
var newTagIds []int64
|
|
if req.TagIds != nil {
|
|
tagIds, err := srv_contenttag.NormalizeContentTagIds(*req.TagIds)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := srv_contenttag.ValidateContentTags(ctx, tagIds, contenttagmod.ContentTagTypePlaylet); err != nil {
|
|
return err
|
|
}
|
|
oldTagIds = append([]int64{}, current.TagIds...)
|
|
newTagIds = tagIds
|
|
setDoc[playletmod.FN.Playlet.TagIds] = tagIds
|
|
}
|
|
if req.ContentType != nil {
|
|
if !isValidPlayletContentType(*req.ContentType) {
|
|
return srvdef.New(srvdef.ErrParamError, "内容类型无效", "")
|
|
}
|
|
setDoc[playletmod.FN.Playlet.ContentType] = *req.ContentType
|
|
}
|
|
if req.PayType != nil {
|
|
payType, singleCoins, err := normalizePlayletPaySetting(*req.PayType, req.SingleCoins, true)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
setDoc[playletmod.FN.Playlet.PayType] = payType
|
|
setDoc[playletmod.FN.Playlet.SingleCoins] = singleCoins
|
|
} else if req.SingleCoins != nil {
|
|
if *req.SingleCoins < 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "单集金币不能小于0", "")
|
|
}
|
|
setDoc[playletmod.FN.Playlet.SingleCoins] = *req.SingleCoins
|
|
}
|
|
if req.TotalEpisode != nil {
|
|
setDoc[playletmod.FN.Playlet.TotalEpisode] = *req.TotalEpisode
|
|
}
|
|
if req.TopRank != nil {
|
|
setDoc[playletmod.FN.Playlet.TopRank] = *req.TopRank
|
|
}
|
|
if req.RecommendRank != nil {
|
|
setDoc[playletmod.FN.Playlet.RecommendRank] = *req.RecommendRank
|
|
}
|
|
if req.SeoInfo != nil {
|
|
setDoc["seoInfo"] = normalizeSeoValue(*req.SeoInfo)
|
|
}
|
|
title := current.Title
|
|
if req.Title != nil {
|
|
title = strings.TrimSpace(*req.Title)
|
|
}
|
|
keywords := current.SeoInfo.Keyworld
|
|
if req.SeoInfo != nil {
|
|
keywords = normalizeSeoValue(*req.SeoInfo).Keyworld
|
|
}
|
|
exists := func(s string) bool {
|
|
item, _ := playletmod.FindOnePlaylet(ctx, slugx.Filter(playletmod.FN.Playlet.Slug, playletmod.FN.Playlet.Id, s, req.Id))
|
|
return item != nil
|
|
}
|
|
slug, changed, serr := slugx.PrepareOnUpdate(current.Slug, req.Slug,
|
|
utils.SlugSourceFromKeywordsOrTitle(keywords, title), exists)
|
|
if serr != nil {
|
|
return serr
|
|
}
|
|
if changed {
|
|
setDoc[playletmod.FN.Playlet.Slug] = slug
|
|
}
|
|
if len(setDoc) <= 1 {
|
|
return srvdef.New(srvdef.ErrParamError, "没有可更新字段", "")
|
|
}
|
|
operatorId, operatorName := resolvePlayletOperator(ctx, operatorId)
|
|
setDoc[playletmod.FN.Playlet.OperatorId] = operatorId
|
|
setDoc[playletmod.FN.Playlet.OperatorName] = operatorName
|
|
if err := playletmod.UpdateOnePlaylet(ctx,
|
|
bson.M{playletmod.FN.Playlet.Id: req.Id},
|
|
bson.M{"$set": setDoc},
|
|
); err != nil {
|
|
return err
|
|
}
|
|
if req.TagIds != nil {
|
|
if err := srv_contenttag.SyncContentTagBindCount(ctx, oldTagIds, newTagIds, contenttagmod.ContentTagTypePlaylet); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if coverChanged {
|
|
go func(playletId int64, cover string) {
|
|
srv_mediaresource.FillPlayletCompressedCover(context.Background(), &playletmod.Playlet{
|
|
Id: playletId,
|
|
Cover: cover,
|
|
})
|
|
}(req.Id, strings.TrimSpace(*req.Cover))
|
|
}
|
|
clearAppPlayletHomeCache()
|
|
if req.ShowOriginal != nil {
|
|
playletcache.ClearRankCache()
|
|
}
|
|
status := current.Status
|
|
onlineAt := current.OnlineAt
|
|
if req.Status != nil {
|
|
status = *req.Status
|
|
if status == playletmod.StatusUp {
|
|
onlineAt = now
|
|
}
|
|
}
|
|
prevStatus := current.Status
|
|
srv_seopush.NotifyPlayletAfterWrite(ctx, req.Id, &prevStatus, status, onlineAt)
|
|
asyncSyncPlayletESByLatestStatus([]int64{req.Id}, "短剧更新")
|
|
return nil
|
|
}
|
|
|
|
// DelPlaylet 删除短剧、剧集及关联的用户数据
|
|
func DelPlaylet(ctx context.Context, req *proto.PlayletDelReq) *srvdef.SrvErr {
|
|
if req == nil || len(req.Ids) == 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "短剧ID不能为空", "")
|
|
}
|
|
for _, id := range req.Ids {
|
|
if id <= 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "短剧ID无效", "")
|
|
}
|
|
}
|
|
ids := dedupePositiveInt64Ids(req.Ids)
|
|
playletFilter := bson.M{playletmod.FN.Playlet.Id: bson.M{"$in": ids}}
|
|
chapterFilter := bson.M{playletchaptermod.FN.PlayletChapter.PlayletId: bson.M{"$in": ids}}
|
|
var serviceErr *srvdef.SrvErr
|
|
var chapterIDs []int64
|
|
txnErr := mongos.Shop.Transaction(ctx, func(sctx mongo.SessionContext) error {
|
|
serviceErr = nil
|
|
playlets, err := playletmod.FindManyPlaylet(sctx, playletFilter, options.Find().SetProjection(bson.M{
|
|
playletmod.FN.Playlet.Id: 1,
|
|
playletmod.FN.Playlet.TagIds: 1,
|
|
}))
|
|
if err != nil {
|
|
serviceErr = err
|
|
return err
|
|
}
|
|
changes := make([]srv_contenttag.ContentTagBindChange, 0, len(playlets))
|
|
for _, playlet := range playlets {
|
|
if playlet != nil && len(playlet.TagIds) > 0 {
|
|
changes = append(changes, srv_contenttag.ContentTagBindChange{OldTagIds: playlet.TagIds})
|
|
}
|
|
}
|
|
if len(changes) > 0 {
|
|
if err := srv_contenttag.SyncContentTagBindCountBatch(sctx, changes, contenttagmod.ContentTagTypePlaylet); err != nil {
|
|
serviceErr = err
|
|
return err
|
|
}
|
|
}
|
|
chapters, err := playletchaptermod.FindManyPlayletChapter(sctx, chapterFilter, options.Find().SetProjection(bson.M{
|
|
playletchaptermod.FN.PlayletChapter.Id: 1,
|
|
}))
|
|
if err != nil {
|
|
serviceErr = err
|
|
return err
|
|
}
|
|
commentFilters := bson.A{bson.M{
|
|
commentmod.FN.Comment.ObjectType: pubdef.CommentObjectTypePlaylet,
|
|
commentmod.FN.Comment.ObjectId: bson.M{"$in": ids},
|
|
}}
|
|
chapterIDs = make([]int64, 0, len(chapters))
|
|
for _, chapter := range chapters {
|
|
if chapter != nil {
|
|
chapterIDs = append(chapterIDs, chapter.Id)
|
|
}
|
|
}
|
|
if len(chapterIDs) > 0 {
|
|
commentFilters = append(commentFilters, bson.M{
|
|
commentmod.FN.Comment.ObjectType: pubdef.CommentObjectTypePlayletChapter,
|
|
commentmod.FN.Comment.ObjectId: bson.M{"$in": chapterIDs},
|
|
})
|
|
}
|
|
commentFilter := bson.M{"$or": commentFilters}
|
|
comments, err := commentmod.FindManyComment(sctx, commentFilter, options.Find().SetProjection(bson.M{
|
|
commentmod.FN.Comment.Id: 1,
|
|
}))
|
|
if err != nil {
|
|
serviceErr = err
|
|
return err
|
|
}
|
|
commentIDs := make([]int64, 0, len(comments))
|
|
for _, comment := range comments {
|
|
if comment != nil {
|
|
commentIDs = append(commentIDs, comment.Id)
|
|
}
|
|
}
|
|
if err := commentlikemod.DeleteByCommentIds(sctx, commentIDs); err != nil {
|
|
serviceErr = err
|
|
return err
|
|
}
|
|
deletions := []struct {
|
|
collection string
|
|
filter bson.M
|
|
}{
|
|
{commentmod.TN.Comment, commentFilter},
|
|
{playletlikemod.TN.PlayletLike, bson.M{playletlikemod.FN.PlayletLike.PlayletID: bson.M{"$in": ids}}},
|
|
{playletfavoritemod.CollectionName, bson.M{playletfavoritemod.FieldPlayletID: bson.M{"$in": ids}}},
|
|
{models.WatchHistoryCollectionName, bson.M{models.WatchHistoryDataType: models.WatchHistoryTypePlaylet, models.WatchHistoryContentID: bson.M{"$in": ids}}},
|
|
{playletchaptermod.TN.PlayletChapter, chapterFilter},
|
|
{playletmod.TN.Playlet, playletFilter},
|
|
}
|
|
for _, deletion := range deletions {
|
|
if _, err := mongos.Shop.Coll(deletion.collection).DeleteMany(sctx, deletion.filter); err != nil {
|
|
log.Warn("删除短剧关联数据失败", log.Any("collection", deletion.collection), log.E(err))
|
|
serviceErr = srvdef.New(srvdef.ErrDbDeleteError, "", "")
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
if txnErr != nil {
|
|
if serviceErr != nil {
|
|
return serviceErr
|
|
}
|
|
log.Warn("删除短剧事务失败", log.E(txnErr))
|
|
return srvdef.New(srvdef.ErrDbDeleteError, "", "")
|
|
}
|
|
clearAppPlayletHomeCache()
|
|
playletcache.ClearRankCache()
|
|
if redis.Client() != nil {
|
|
for _, id := range ids {
|
|
if err := redis.Del(redisconst.CommentListCacheKey(id, pubdef.CommentObjectTypePlaylet)); err != nil {
|
|
log.Warn("清理短剧评论缓存失败", log.Any("playletId", id), log.E(err))
|
|
}
|
|
}
|
|
for _, id := range chapterIDs {
|
|
if err := redis.Del(redisconst.CommentListCacheKey(id, pubdef.CommentObjectTypePlayletChapter)); err != nil {
|
|
log.Warn("清理剧集评论缓存失败", log.Any("chapterId", id), log.E(err))
|
|
}
|
|
}
|
|
}
|
|
srv_seopush.MarkSitemapDirty(ctx)
|
|
for _, id := range ids {
|
|
srv_seopush.EnqueueDeleted(ctx, srv_seopush.KindPlaylet, id)
|
|
}
|
|
if err := srv_search.SyncPlayletStatusToES(ctx, ids, playletmod.StatusDown); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// SetPlayletStatus 单/批量设置短剧上下架
|
|
func SetPlayletStatus(ctx context.Context, req *proto.PlayletStatusSetReq) *srvdef.SrvErr {
|
|
if req == nil {
|
|
return srvdef.New(srvdef.ErrParamError, "参数不能为空", "")
|
|
}
|
|
ids := dedupePositiveInt64Ids(req.Ids)
|
|
if len(ids) == 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "短剧ID不能为空", "")
|
|
}
|
|
if !isValidPlayletStatus(req.Status) {
|
|
return srvdef.New(srvdef.ErrParamError, "上下架状态无效", "")
|
|
}
|
|
now := time.Now()
|
|
setDoc := bson.M{
|
|
playletmod.FN.Playlet.Status: req.Status,
|
|
playletmod.FN.Playlet.ReviewAt: now,
|
|
playletmod.FN.Playlet.UpdatedAt: now,
|
|
}
|
|
if req.Status == playletmod.StatusUp {
|
|
setDoc[playletmod.FN.Playlet.OnlineAt] = now
|
|
setDoc[playletmod.FN.Playlet.IndexNow] = int64(0)
|
|
}
|
|
if err := playletmod.UpdateManyPlaylet(ctx,
|
|
bson.M{playletmod.FN.Playlet.Id: bson.M{"$in": ids}},
|
|
bson.M{"$set": setDoc},
|
|
); err != nil {
|
|
return err
|
|
}
|
|
clearAppPlayletHomeCache()
|
|
srv_seopush.NotifyPlayletAfterStatus(ctx, ids, req.Status, now)
|
|
asyncSyncPlayletESByStatus(ids, req.Status, "短剧上下架")
|
|
return nil
|
|
}
|
|
|
|
// SetPlayletRecommend 单/批量设置短剧是否推荐
|
|
func SetPlayletRecommend(ctx context.Context, req *proto.PlayletRecommendSetReq) *srvdef.SrvErr {
|
|
if req == nil {
|
|
return srvdef.New(srvdef.ErrParamError, "参数不能为空", "")
|
|
}
|
|
ids := dedupePositiveInt64Ids(req.Ids)
|
|
if len(ids) == 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "短剧ID不能为空", "")
|
|
}
|
|
setDoc := bson.M{
|
|
playletmod.FN.Playlet.IsRecommend: req.IsRecommend,
|
|
playletmod.FN.Playlet.UpdatedAt: time.Now(),
|
|
}
|
|
if err := playletmod.UpdateManyPlaylet(ctx,
|
|
bson.M{playletmod.FN.Playlet.Id: bson.M{"$in": ids}},
|
|
bson.M{"$set": setDoc},
|
|
); err != nil {
|
|
return err
|
|
}
|
|
clearAppPlayletHomeCache()
|
|
asyncSyncPlayletESByLatestStatus(ids, "短剧推荐状态变更")
|
|
return nil
|
|
}
|
|
|
|
// SetPlayletFeatured 单/批量设置短剧是否爆剧
|
|
func SetPlayletFeatured(ctx context.Context, req *proto.PlayletFeaturedSetReq) *srvdef.SrvErr {
|
|
if req == nil {
|
|
return srvdef.New(srvdef.ErrParamError, "参数不能为空", "")
|
|
}
|
|
ids := dedupePositiveInt64Ids(req.Ids)
|
|
if len(ids) == 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "短剧ID不能为空", "")
|
|
}
|
|
setDoc := bson.M{
|
|
playletmod.FN.Playlet.IsFeatured: req.IsFeatured,
|
|
playletmod.FN.Playlet.UpdatedAt: time.Now(),
|
|
}
|
|
if err := playletmod.UpdateManyPlaylet(ctx,
|
|
bson.M{playletmod.FN.Playlet.Id: bson.M{"$in": ids}},
|
|
bson.M{"$set": setDoc},
|
|
); err != nil {
|
|
return err
|
|
}
|
|
clearAppPlayletHomeCache()
|
|
asyncSyncPlayletESByLatestStatus(ids, "短剧爆剧状态变更")
|
|
return nil
|
|
}
|
|
|
|
// SetPlayletBanner 单/批量设置短剧是否显示在首页banner
|
|
func SetPlayletBanner(ctx context.Context, req *proto.PlayletBannerSetReq) *srvdef.SrvErr {
|
|
if req == nil {
|
|
return srvdef.New(srvdef.ErrParamError, "参数不能为空", "")
|
|
}
|
|
ids := dedupePositiveInt64Ids(req.Ids)
|
|
if len(ids) == 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "短剧ID不能为空", "")
|
|
}
|
|
setDoc := bson.M{
|
|
playletmod.FN.Playlet.ShowOnBanner: req.ShowOnBanner,
|
|
playletmod.FN.Playlet.UpdatedAt: time.Now(),
|
|
}
|
|
if err := playletmod.UpdateManyPlaylet(ctx,
|
|
bson.M{playletmod.FN.Playlet.Id: bson.M{"$in": ids}},
|
|
bson.M{"$set": setDoc},
|
|
); err != nil {
|
|
return err
|
|
}
|
|
clearAppPlayletHomeCache()
|
|
asyncSyncPlayletESByLatestStatus(ids, "短剧banner状态变更")
|
|
return nil
|
|
}
|
|
|
|
// SetPlayletTag 单/批量设置短剧标签
|
|
func SetPlayletTag(ctx context.Context, req *proto.PlayletTagSetReq) *srvdef.SrvErr {
|
|
if req == nil {
|
|
return srvdef.New(srvdef.ErrParamError, "参数不能为空", "")
|
|
}
|
|
ids := dedupePositiveInt64Ids(req.Ids)
|
|
if len(ids) == 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "短剧ID不能为空", "")
|
|
}
|
|
if req.TagIds == nil {
|
|
return srvdef.New(srvdef.ErrParamError, "标签ID不能为空", "")
|
|
}
|
|
tagIds, err := srv_contenttag.NormalizeContentTagIds(*req.TagIds)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := srv_contenttag.ValidateContentTags(ctx, tagIds, contenttagmod.ContentTagTypePlaylet); err != nil {
|
|
return err
|
|
}
|
|
list, err := playletmod.FindManyPlaylet(ctx, bson.M{
|
|
playletmod.FN.Playlet.Id: bson.M{"$in": ids},
|
|
}, options.Find().SetProjection(bson.D{
|
|
{Key: playletmod.FN.Playlet.Id, Value: 1},
|
|
{Key: playletmod.FN.Playlet.TagIds, Value: 1},
|
|
}))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
setDoc := bson.M{
|
|
playletmod.FN.Playlet.TagIds: tagIds,
|
|
playletmod.FN.Playlet.UpdatedAt: time.Now(),
|
|
}
|
|
if err := playletmod.UpdateManyPlaylet(ctx,
|
|
bson.M{playletmod.FN.Playlet.Id: bson.M{"$in": ids}},
|
|
bson.M{"$set": setDoc},
|
|
); err != nil {
|
|
return err
|
|
}
|
|
changes := make([]srv_contenttag.ContentTagBindChange, 0, len(list))
|
|
for _, item := range list {
|
|
if item == nil {
|
|
continue
|
|
}
|
|
changes = append(changes, srv_contenttag.ContentTagBindChange{
|
|
OldTagIds: append([]int64{}, item.TagIds...),
|
|
NewTagIds: append([]int64{}, tagIds...),
|
|
})
|
|
}
|
|
if err := srv_contenttag.SyncContentTagBindCountBatch(ctx, changes, contenttagmod.ContentTagTypePlaylet); err != nil {
|
|
return err
|
|
}
|
|
clearAppPlayletHomeCache()
|
|
asyncSyncPlayletESByLatestStatus(ids, "短剧标签变更")
|
|
return nil
|
|
}
|
|
|
|
// SetPlayletCategory 单/批量设置短剧分类
|
|
func SetPlayletCategory(ctx context.Context, req *proto.PlayletCategorySetReq) *srvdef.SrvErr {
|
|
if req == nil {
|
|
return srvdef.New(srvdef.ErrParamError, "参数不能为空", "")
|
|
}
|
|
ids := dedupePositiveInt64Ids(req.Ids)
|
|
if len(ids) == 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "短剧ID不能为空", "")
|
|
}
|
|
if req.CategoryIds == nil {
|
|
return srvdef.New(srvdef.ErrParamError, "分类ID不能为空", "")
|
|
}
|
|
categoryIds, err := normalizePlayletCategoryIds(*req.CategoryIds)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := validatePlayletCategoryIds(ctx, categoryIds); err != nil {
|
|
return err
|
|
}
|
|
list, err := playletmod.FindManyPlaylet(ctx, bson.M{playletmod.FN.Playlet.Id: bson.M{"$in": ids}})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, item := range list {
|
|
binds := playletmod.MergeCategoryBindsByIds(playletmod.EffectiveCategoryBinds(item), categoryIds)
|
|
if err := playletmod.UpdateOnePlaylet(ctx, bson.M{playletmod.FN.Playlet.Id: item.Id}, bson.M{"$set": bson.M{
|
|
playletmod.FN.Playlet.CategoryIds: categoryIds,
|
|
playletmod.FN.Playlet.CategoryBinds: binds,
|
|
playletmod.FN.Playlet.UpdatedAt: time.Now(),
|
|
}}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
clearAppPlayletHomeCache()
|
|
asyncSyncPlayletESByLatestStatus(ids, "短剧分类变更")
|
|
return nil
|
|
}
|
|
|
|
// SetPlayletTheme 单/批量设置短剧题材
|
|
func SetPlayletTheme(ctx context.Context, req *proto.PlayletThemeSetReq) *srvdef.SrvErr {
|
|
if req == nil {
|
|
return srvdef.New(srvdef.ErrParamError, "参数不能为空", "")
|
|
}
|
|
ids := dedupePositiveInt64Ids(req.Ids)
|
|
if len(ids) == 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "短剧ID不能为空", "")
|
|
}
|
|
themeIds := dedupePositiveInt64Ids(req.ThemeIds)
|
|
if len(themeIds) == 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "题材ID不能为空", "")
|
|
}
|
|
if err := validatePlayletThemeIds(ctx, themeIds); err != nil {
|
|
return err
|
|
}
|
|
setDoc := bson.M{
|
|
playletmod.FN.Playlet.ThemeIds: themeIds,
|
|
playletmod.FN.Playlet.UpdatedAt: time.Now(),
|
|
}
|
|
if err := playletmod.UpdateManyPlaylet(ctx,
|
|
bson.M{playletmod.FN.Playlet.Id: bson.M{"$in": ids}},
|
|
bson.M{"$set": setDoc},
|
|
); err != nil {
|
|
return err
|
|
}
|
|
clearAppPlayletHomeCache()
|
|
asyncSyncPlayletESByLatestStatus(ids, "短剧题材变更")
|
|
return nil
|
|
}
|
|
|
|
// SetPlayletVirtualLike 单/批量设置短剧虚拟点赞数
|
|
func SetPlayletVirtualLike(ctx context.Context, req *proto.PlayletVirtualLikeSetReq) *srvdef.SrvErr {
|
|
if req == nil {
|
|
return srvdef.New(srvdef.ErrParamError, "参数不能为空", "")
|
|
}
|
|
ids := dedupePositiveInt64Ids(req.Ids)
|
|
if len(ids) == 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "短剧ID不能为空", "")
|
|
}
|
|
if req.MinVirtualCountLike < 0 || req.MaxVirtualCountLike < req.MinVirtualCountLike {
|
|
return srvdef.New(srvdef.ErrParamError, "虚拟点赞数范围无效", "")
|
|
}
|
|
if req.MaxVirtualCountLike-req.MinVirtualCountLike < int64(len(ids))-1 {
|
|
return srvdef.New(srvdef.ErrParamError, "虚拟点赞数范围不足，无法保证每条短剧数值不同", "")
|
|
}
|
|
values := randomUniqueVirtualLikeValues(req.MinVirtualCountLike, req.MaxVirtualCountLike, len(ids))
|
|
now := time.Now()
|
|
docs := make([]mongo.WriteModel, 0, len(ids))
|
|
for index, id := range ids {
|
|
setDoc := bson.M{
|
|
playletmod.FN.Playlet.VirtualCountLike: values[index],
|
|
playletmod.FN.Playlet.UpdatedAt: now,
|
|
}
|
|
docs = append(docs, mongo.NewUpdateOneModel().
|
|
SetFilter(bson.M{playletmod.FN.Playlet.Id: id}).
|
|
SetUpdate(bson.M{"$set": setDoc}))
|
|
}
|
|
if err := playletmod.BulkWritePlaylet(ctx, docs); err != nil {
|
|
return err
|
|
}
|
|
clearAppPlayletHomeCache()
|
|
asyncSyncPlayletESByLatestStatus(ids, "短剧虚拟点赞数变更")
|
|
return nil
|
|
}
|
|
|
|
// SetPlayletVirtualBrowse 单/批量设置短剧虚拟观看数
|
|
func SetPlayletVirtualBrowse(ctx context.Context, req *proto.PlayletVirtualBrowseSetReq) *srvdef.SrvErr {
|
|
if req == nil {
|
|
return srvdef.New(srvdef.ErrParamError, "参数不能为空", "")
|
|
}
|
|
return setPlayletVirtualMetric(ctx, req.Ids, req.MinVirtualCountBrowse, req.MaxVirtualCountBrowse,
|
|
playletmod.FN.Playlet.VirtualCountBrowse, "短剧虚拟观看数变更")
|
|
}
|
|
|
|
// SetPlayletVirtualHeat 单/批量设置短剧虚拟热度
|
|
func SetPlayletVirtualHeat(ctx context.Context, req *proto.PlayletVirtualHeatSetReq) *srvdef.SrvErr {
|
|
if req == nil {
|
|
return srvdef.New(srvdef.ErrParamError, "参数不能为空", "")
|
|
}
|
|
return setPlayletVirtualMetric(ctx, req.Ids, req.MinVirtualHeatValue, req.MaxVirtualHeatValue,
|
|
playletmod.FN.Playlet.VirtualHeatValue, "短剧虚拟热度变更")
|
|
}
|
|
|
|
// setPlayletVirtualMetric 按区间为每部短剧设置不同虚拟数值
|
|
func setPlayletVirtualMetric(ctx context.Context, rawIds []int64, min, max int64, field, reason string) *srvdef.SrvErr {
|
|
ids := dedupePositiveInt64Ids(rawIds)
|
|
if len(ids) == 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "短剧ID不能为空", "")
|
|
}
|
|
if min < 0 || max < min || max-min < int64(len(ids))-1 {
|
|
return srvdef.New(srvdef.ErrParamError, "虚拟数值区间无效或不足", "")
|
|
}
|
|
values := randomUniqueVirtualLikeValues(min, max, len(ids))
|
|
now := time.Now()
|
|
docs := make([]mongo.WriteModel, 0, len(ids))
|
|
for index, id := range ids {
|
|
docs = append(docs, mongo.NewUpdateOneModel().
|
|
SetFilter(bson.M{playletmod.FN.Playlet.Id: id}).
|
|
SetUpdate(bson.M{"$set": bson.M{field: values[index], playletmod.FN.Playlet.UpdatedAt: now}}))
|
|
}
|
|
if err := playletmod.BulkWritePlaylet(ctx, docs); err != nil {
|
|
return err
|
|
}
|
|
clearAppPlayletHomeCache()
|
|
playletcache.ClearRankCache()
|
|
asyncSyncPlayletESByLatestStatus(ids, reason)
|
|
return nil
|
|
}
|
|
|
|
// SetPlayletPayType 单/批量设置短剧默认支付方式
|
|
func SetPlayletPayType(ctx context.Context, req *proto.PlayletPayTypeSetReq) *srvdef.SrvErr {
|
|
if req == nil {
|
|
return srvdef.New(srvdef.ErrParamError, "参数不能为空", "")
|
|
}
|
|
ids := dedupePositiveInt64Ids(req.Ids)
|
|
if len(ids) == 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "短剧ID不能为空", "")
|
|
}
|
|
payType, singleCoins, err := normalizePlayletPaySetting(req.PayType, req.SingleCoins, true)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
setDoc := bson.M{
|
|
playletmod.FN.Playlet.PayType: payType,
|
|
playletmod.FN.Playlet.SingleCoins: singleCoins,
|
|
playletmod.FN.Playlet.UpdatedAt: time.Now(),
|
|
}
|
|
if err := playletmod.UpdateManyPlaylet(ctx,
|
|
bson.M{playletmod.FN.Playlet.Id: bson.M{"$in": ids}},
|
|
bson.M{"$set": setDoc},
|
|
); err != nil {
|
|
return err
|
|
}
|
|
clearAppPlayletHomeCache()
|
|
return nil
|
|
}
|
|
|
|
// ResetPlayletWatermark 按短剧ID批量重置其下全部剧集水印，等待定时任务重新加水印。
|
|
// 已有水印地址不清理，新水印完成回写时直接覆盖。
|
|
// 原创短剧保留 mediaSourceId / videoUrl / mediaTaskId，直接进入已登记后按原片重跑水印。
|
|
// 非原创清空 media 关联并回到未处理，由 SyncMediaFile 重新登记。
|
|
func ResetPlayletWatermark(ctx context.Context, req *proto.PlayletWatermarkResetReq) *srvdef.SrvErr {
|
|
if req == nil {
|
|
return srvdef.New(srvdef.ErrParamError, "参数不能为空", "")
|
|
}
|
|
ids := dedupePositiveInt64Ids(req.Ids)
|
|
if len(ids) == 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "短剧ID不能为空", "")
|
|
}
|
|
originalIds, otherIds, err := splitPlayletIdsByOriginal(ctx, ids)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
now := time.Now()
|
|
if resetErr := resetOriginalChaptersWatermark(ctx, originalIds, now); resetErr != nil {
|
|
return resetErr
|
|
}
|
|
return resetChaptersWatermark(ctx, otherIds, playletchaptermod.WatermarkStatusPending, now)
|
|
}
|
|
|
|
func splitPlayletIdsByOriginal(ctx context.Context, ids []int64) (originalIds, otherIds []int64, err *srvdef.SrvErr) {
|
|
originalList, err := playletmod.FindManyPlaylet(ctx, bson.M{
|
|
playletmod.FN.Playlet.Id: bson.M{"$in": ids},
|
|
playletmod.FN.Playlet.IsOriginal: true,
|
|
}, options.Find().SetProjection(bson.M{playletmod.FN.Playlet.Id: 1}))
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
originalSet := make(map[int64]struct{}, len(originalList))
|
|
for _, item := range originalList {
|
|
if item == nil || item.Id <= 0 {
|
|
continue
|
|
}
|
|
originalSet[item.Id] = struct{}{}
|
|
originalIds = append(originalIds, item.Id)
|
|
}
|
|
for _, id := range ids {
|
|
if _, ok := originalSet[id]; !ok {
|
|
otherIds = append(otherIds, id)
|
|
}
|
|
}
|
|
return originalIds, otherIds, nil
|
|
}
|
|
|
|
func resetOriginalChaptersWatermark(ctx context.Context, playletIds []int64, now time.Time) *srvdef.SrvErr {
|
|
if len(playletIds) == 0 {
|
|
return nil
|
|
}
|
|
// 原创剧集保留 mediaSourceId / videoUrl / mediaTaskId，以及已有水印地址。
|
|
// 新水印完成回写时会直接覆盖 WatermarkVideoUrl。
|
|
err := playletchaptermod.UpdateManyPlayletChapter(ctx,
|
|
bson.M{playletchaptermod.FN.PlayletChapter.PlayletId: bson.M{"$in": playletIds}},
|
|
bson.M{"$set": bson.M{
|
|
playletchaptermod.FN.PlayletChapter.WatermarkStatus: playletchaptermod.WatermarkStatusRegistered,
|
|
playletchaptermod.FN.PlayletChapter.UpdatedAt: now,
|
|
}},
|
|
)
|
|
if err != nil && err.Code == srvdef.ErrNoData {
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
|
|
func resetChaptersWatermark(ctx context.Context, playletIds []int64, status playletchaptermod.WatermarkStatus, now time.Time) *srvdef.SrvErr {
|
|
if len(playletIds) == 0 {
|
|
return nil
|
|
}
|
|
err := playletchaptermod.UpdateManyPlayletChapter(ctx,
|
|
bson.M{playletchaptermod.FN.PlayletChapter.PlayletId: bson.M{"$in": playletIds}},
|
|
bson.M{"$set": bson.M{
|
|
playletchaptermod.FN.PlayletChapter.WatermarkStatus: status,
|
|
playletchaptermod.FN.PlayletChapter.MediaSourceId: "",
|
|
playletchaptermod.FN.PlayletChapter.MediaTaskId: "",
|
|
playletchaptermod.FN.PlayletChapter.UpdatedAt: now,
|
|
}},
|
|
)
|
|
if err != nil && err.Code == srvdef.ErrNoData {
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
|
|
// ListPlayletChapter 分页查询短剧剧集列表
|
|
func ListPlayletChapter(ctx context.Context, req *proto.PlayletChapterListReq) (*proto.PlayletChapterListPageResp, *srvdef.SrvErr) {
|
|
if req == nil {
|
|
return nil, srvdef.New(srvdef.ErrParamError, "参数不能为空", "")
|
|
}
|
|
filter := bson.M{}
|
|
if req.Id != nil && *req.Id > 0 {
|
|
filter[playletchaptermod.FN.PlayletChapter.Id] = *req.Id
|
|
}
|
|
if req.PlayletId != nil && *req.PlayletId > 0 {
|
|
filter[playletchaptermod.FN.PlayletChapter.PlayletId] = *req.PlayletId
|
|
}
|
|
if req.WatermarkStatus != nil {
|
|
filter[playletchaptermod.FN.PlayletChapter.WatermarkStatus] = *req.WatermarkStatus
|
|
}
|
|
pageNum, pageSize := normalizePage(req.PageNum, req.PageSize)
|
|
totalCount, err := playletchaptermod.CountPlayletChapter(ctx, filter)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resp := &proto.PlayletChapterListPageResp{
|
|
BasePageResp: response.BasePageResp{
|
|
TotalCount: totalCount,
|
|
PageSize: int(pageSize),
|
|
PageNum: int(pageNum),
|
|
List: make([]*proto.PlayletChapterListResp, 0),
|
|
},
|
|
}
|
|
if totalCount == 0 {
|
|
return resp, nil
|
|
}
|
|
list, err := playletchaptermod.FindManyPlayletChapter(ctx, filter, options.Find().
|
|
SetSort(bson.D{
|
|
{Key: playletchaptermod.FN.PlayletChapter.CurrentEpisode, Value: 1},
|
|
{Key: playletchaptermod.FN.PlayletChapter.Id, Value: 1},
|
|
}).
|
|
SetSkip((pageNum-1)*pageSize).
|
|
SetLimit(pageSize))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
items := make([]*proto.PlayletChapterListResp, 0, len(list))
|
|
for _, item := range list {
|
|
if item == nil {
|
|
continue
|
|
}
|
|
items = append(items, chapterToWebResp(item))
|
|
}
|
|
resp.List = items
|
|
return resp, nil
|
|
}
|
|
|
|
// AddPlayletChapter 新增短剧剧集
|
|
func AddPlayletChapter(ctx context.Context, req *proto.PlayletChapterAddReq) (*proto.PlayletChapterAddResp, *srvdef.SrvErr) {
|
|
if req == nil || req.PlayletId <= 0 || req.CurrentEpisode <= 0 {
|
|
return nil, srvdef.New(srvdef.ErrParamError, "playletId/currentEpisode无效", "")
|
|
}
|
|
if !isValidPlayletChapterPayType(req.PayType) {
|
|
return nil, srvdef.New(srvdef.ErrParamError, "支付方式无效", "")
|
|
}
|
|
if req.PayType == playletchaptermod.PayTypeCoin && req.SingleCoins <= 0 {
|
|
return nil, srvdef.New(srvdef.ErrParamError, "金币支付时单集金币必须大于0", "")
|
|
}
|
|
singleCoins := req.SingleCoins
|
|
if req.PayType != playletchaptermod.PayTypeCoin {
|
|
singleCoins = 0
|
|
}
|
|
playlet, err := playletmod.FindOnePlaylet(ctx, bson.M{playletmod.FN.Playlet.Id: req.PlayletId})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if playlet == nil || !playlet.IsOriginal {
|
|
return nil, srvdef.New(srvdef.ErrParamError, "只有原创短剧支持新增剧集", "")
|
|
}
|
|
doc := &playletchaptermod.PlayletChapter{
|
|
PlayletId: req.PlayletId,
|
|
CurrentEpisode: req.CurrentEpisode,
|
|
Title: strings.TrimSpace(req.Title),
|
|
Md5: strings.TrimSpace(req.Md5),
|
|
Hash: strings.TrimSpace(req.Hash),
|
|
Height: req.Height,
|
|
Width: req.Width,
|
|
Ratio: req.Ratio,
|
|
VideoUrl: strings.TrimSpace(req.VideoUrl),
|
|
MediaSize: req.MediaSize,
|
|
MediaTime: req.MediaTime,
|
|
PayType: req.PayType,
|
|
SingleCoins: singleCoins,
|
|
}
|
|
mediaSourceId := strings.TrimSpace(req.MediaSourceId)
|
|
if playlet.IsOriginal && (doc.VideoUrl != "" || mediaSourceId != "") {
|
|
doc.WatermarkStatus = playletchaptermod.WatermarkStatusRegistered
|
|
if mediaSourceId != "" {
|
|
// 后台上传正片已在 media 创建原片，直接沿用该 ID，避免再 SyncMediaFile 重复处理。
|
|
doc.MediaSourceId = mediaSourceId
|
|
} else {
|
|
sourceID, regErr := playletwatermark.RegisterChapterSource(doc)
|
|
if regErr != nil {
|
|
log.Error("AddPlayletChapter RegisterChapterSource 失败",
|
|
log.Any("playletId", req.PlayletId),
|
|
log.Any("videoUrl", doc.VideoUrl),
|
|
log.E(regErr))
|
|
} else {
|
|
doc.MediaSourceId = sourceID
|
|
}
|
|
}
|
|
}
|
|
if err := playletchaptermod.InsertOnePlayletChapter(ctx, doc); err != nil {
|
|
return nil, err
|
|
}
|
|
return &proto.PlayletChapterAddResp{Id: doc.Id}, nil
|
|
}
|
|
|
|
// DelPlayletChapter 单/批量删除原创短剧剧集。
|
|
func DelPlayletChapter(ctx context.Context, req *proto.PlayletChapterDelReq) *srvdef.SrvErr {
|
|
if req == nil {
|
|
return srvdef.New(srvdef.ErrParamError, "参数不能为空", "")
|
|
}
|
|
ids := dedupePositiveInt64Ids(req.Ids)
|
|
if len(ids) == 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "剧集ID不能为空", "")
|
|
}
|
|
filter := bson.M{playletchaptermod.FN.PlayletChapter.Id: bson.M{"$in": ids}}
|
|
chapters, findErr := playletchaptermod.FindManyPlayletChapter(ctx, filter)
|
|
if findErr != nil {
|
|
return findErr
|
|
}
|
|
if len(chapters) == 0 {
|
|
return srvdef.New(srvdef.ErrNoData, "", "")
|
|
}
|
|
playletIds := make([]int64, 0, len(chapters))
|
|
seenPlaylet := make(map[int64]struct{}, len(chapters))
|
|
for _, item := range chapters {
|
|
if item == nil || item.PlayletId <= 0 {
|
|
continue
|
|
}
|
|
if _, ok := seenPlaylet[item.PlayletId]; ok {
|
|
continue
|
|
}
|
|
seenPlaylet[item.PlayletId] = struct{}{}
|
|
playletIds = append(playletIds, item.PlayletId)
|
|
}
|
|
if len(playletIds) > 0 {
|
|
playlets, playletErr := playletmod.FindManyPlaylet(ctx, bson.M{
|
|
playletmod.FN.Playlet.Id: bson.M{"$in": playletIds},
|
|
}, options.Find().SetProjection(bson.M{
|
|
playletmod.FN.Playlet.Id: 1,
|
|
playletmod.FN.Playlet.IsOriginal: 1,
|
|
}))
|
|
if playletErr != nil {
|
|
return playletErr
|
|
}
|
|
for _, item := range playlets {
|
|
if item == nil || !item.IsOriginal {
|
|
return srvdef.New(srvdef.ErrParamError, "只有原创短剧支持删除剧集", "")
|
|
}
|
|
}
|
|
}
|
|
count, err := playletchaptermod.DelManyPlayletChapter(ctx, filter)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if count == 0 {
|
|
return srvdef.New(srvdef.ErrNoData, "", "")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// UpdatePlayletChapter 编辑短剧剧集
|
|
func UpdatePlayletChapter(ctx context.Context, req *proto.PlayletChapterUpdateReq) *srvdef.SrvErr {
|
|
if req == nil || req.Id <= 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "id无效", "")
|
|
}
|
|
setDoc := bson.M{playletchaptermod.FN.PlayletChapter.UpdatedAt: time.Now()}
|
|
if req.CurrentEpisode != nil {
|
|
if *req.CurrentEpisode <= 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "集数无效", "")
|
|
}
|
|
setDoc[playletchaptermod.FN.PlayletChapter.CurrentEpisode] = *req.CurrentEpisode
|
|
}
|
|
if req.Title != nil {
|
|
setDoc[playletchaptermod.FN.PlayletChapter.Title] = strings.TrimSpace(*req.Title)
|
|
}
|
|
if req.Md5 != nil {
|
|
setDoc[playletchaptermod.FN.PlayletChapter.Md5] = strings.TrimSpace(*req.Md5)
|
|
}
|
|
if req.Hash != nil {
|
|
setDoc[playletchaptermod.FN.PlayletChapter.Hash] = strings.TrimSpace(*req.Hash)
|
|
}
|
|
if req.Height != nil {
|
|
setDoc[playletchaptermod.FN.PlayletChapter.Height] = *req.Height
|
|
}
|
|
if req.Width != nil {
|
|
setDoc[playletchaptermod.FN.PlayletChapter.Width] = *req.Width
|
|
}
|
|
if req.Ratio != nil {
|
|
setDoc[playletchaptermod.FN.PlayletChapter.Ratio] = *req.Ratio
|
|
}
|
|
if req.VideoUrl != nil {
|
|
setDoc[playletchaptermod.FN.PlayletChapter.VideoUrl] = strings.TrimSpace(*req.VideoUrl)
|
|
}
|
|
if req.MediaSize != nil {
|
|
setDoc[playletchaptermod.FN.PlayletChapter.MediaSize] = *req.MediaSize
|
|
}
|
|
if req.MediaTime != nil {
|
|
setDoc[playletchaptermod.FN.PlayletChapter.MediaTime] = *req.MediaTime
|
|
}
|
|
if req.PayType != nil {
|
|
if !isValidPlayletChapterPayType(*req.PayType) {
|
|
return srvdef.New(srvdef.ErrParamError, "支付方式无效", "")
|
|
}
|
|
setDoc[playletchaptermod.FN.PlayletChapter.PayType] = *req.PayType
|
|
if *req.PayType != playletchaptermod.PayTypeCoin && req.SingleCoins == nil {
|
|
setDoc[playletchaptermod.FN.PlayletChapter.SingleCoins] = int64(0)
|
|
}
|
|
}
|
|
if req.SingleCoins != nil {
|
|
if *req.SingleCoins < 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "单集金币不能小于0", "")
|
|
}
|
|
setDoc[playletchaptermod.FN.PlayletChapter.SingleCoins] = *req.SingleCoins
|
|
}
|
|
if len(setDoc) <= 1 {
|
|
return srvdef.New(srvdef.ErrParamError, "没有可更新字段", "")
|
|
}
|
|
return playletchaptermod.UpdateOnePlayletChapter(ctx,
|
|
bson.M{playletchaptermod.FN.PlayletChapter.Id: req.Id},
|
|
bson.M{"$set": setDoc},
|
|
)
|
|
}
|
|
|
|
// SetPlayletChapterPayType 单/批量设置短剧剧集支付方式
|
|
func SetPlayletChapterPayType(ctx context.Context, req *proto.PlayletChapterPayTypeSetReq) *srvdef.SrvErr {
|
|
if req == nil {
|
|
return srvdef.New(srvdef.ErrParamError, "参数不能为空", "")
|
|
}
|
|
ids := dedupePositiveInt64Ids(req.Ids)
|
|
if len(ids) == 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "剧集ID不能为空", "")
|
|
}
|
|
if !isValidPlayletChapterPayType(req.PayType) {
|
|
return srvdef.New(srvdef.ErrParamError, "支付方式无效", "")
|
|
}
|
|
setDoc := bson.M{
|
|
playletchaptermod.FN.PlayletChapter.PayType: req.PayType,
|
|
playletchaptermod.FN.PlayletChapter.UpdatedAt: time.Now(),
|
|
}
|
|
if req.PayType == playletchaptermod.PayTypeCoin {
|
|
if req.SingleCoins == nil || *req.SingleCoins <= 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "金币支付时单集金币必须大于0", "")
|
|
}
|
|
setDoc[playletchaptermod.FN.PlayletChapter.SingleCoins] = *req.SingleCoins
|
|
} else {
|
|
setDoc[playletchaptermod.FN.PlayletChapter.SingleCoins] = int64(0)
|
|
}
|
|
return playletchaptermod.UpdateManyPlayletChapter(ctx,
|
|
bson.M{playletchaptermod.FN.PlayletChapter.Id: bson.M{"$in": ids}},
|
|
bson.M{"$set": setDoc},
|
|
)
|
|
}
|
|
|
|
func buildPlayletListFilter(req *proto.PlayletListReq) bson.M {
|
|
filter := bson.M{}
|
|
if req.Id != nil && *req.Id > 0 {
|
|
filter[playletmod.FN.Playlet.Id] = *req.Id
|
|
}
|
|
if req.CategoryId != nil && *req.CategoryId > 0 {
|
|
filter[playletmod.FN.Playlet.CategoryIds] = bson.M{"$in": []int64{*req.CategoryId}}
|
|
}
|
|
if req.TagId != nil && *req.TagId > 0 {
|
|
filter[playletmod.FN.Playlet.TagIds] = bson.M{"$in": []int64{*req.TagId}}
|
|
}
|
|
if req.ThemeId != nil && *req.ThemeId > 0 {
|
|
filter[playletmod.FN.Playlet.ThemeIds] = bson.M{"$in": []int64{*req.ThemeId}}
|
|
}
|
|
if req.ContentType != nil {
|
|
filter[playletmod.FN.Playlet.ContentType] = *req.ContentType
|
|
}
|
|
if req.PayType != nil {
|
|
filter[playletmod.FN.Playlet.PayType] = *req.PayType
|
|
}
|
|
if req.Status != nil {
|
|
filter[playletmod.FN.Playlet.Status] = *req.Status
|
|
}
|
|
if req.IsFeatured != nil {
|
|
filter[playletmod.FN.Playlet.IsFeatured] = *req.IsFeatured
|
|
}
|
|
if req.IsOriginal != nil {
|
|
if *req.IsOriginal {
|
|
filter[playletmod.FN.Playlet.IsOriginal] = true
|
|
} else {
|
|
// 历史入库数据可能没有该字段，按非原创处理
|
|
filter[playletmod.FN.Playlet.IsOriginal] = bson.M{"$ne": true}
|
|
}
|
|
}
|
|
if req.ShowOriginal != nil {
|
|
if *req.ShowOriginal {
|
|
filter[playletmod.FN.Playlet.ShowOriginal] = true
|
|
} else {
|
|
filter[playletmod.FN.Playlet.ShowOriginal] = bson.M{"$ne": true}
|
|
}
|
|
}
|
|
if req.IsRecommend != nil {
|
|
filter[playletmod.FN.Playlet.IsRecommend] = *req.IsRecommend
|
|
}
|
|
if req.ShowOnBanner != nil {
|
|
filter[playletmod.FN.Playlet.ShowOnBanner] = *req.ShowOnBanner
|
|
}
|
|
if title := strings.TrimSpace(req.Title); title != "" {
|
|
filter[playletmod.FN.Playlet.Title] = bson.M{"$regex": regexp.QuoteMeta(title)}
|
|
}
|
|
if operatorName := strings.TrimSpace(req.OperatorName); operatorName != "" {
|
|
filter[playletmod.FN.Playlet.OperatorName] = bson.M{"$regex": regexp.QuoteMeta(operatorName)}
|
|
}
|
|
return filter
|
|
}
|
|
|
|
func playletToWebResp(item *playletmod.Playlet, categoryNameMap map[int64]string, themeNameMap map[int64]string, tagNameMap map[int64]string) *proto.PlayletListResp {
|
|
return &proto.PlayletListResp{
|
|
Id: item.Id,
|
|
Status: item.Status,
|
|
IsFeatured: item.IsFeatured,
|
|
IsOriginal: item.IsOriginal,
|
|
ShowOriginal: item.ShowOriginal,
|
|
MediaBusiness: item.MediaBusiness,
|
|
IsRecommend: item.IsRecommend,
|
|
ShowOnBanner: item.ShowOnBanner,
|
|
Banner: item.Banner,
|
|
ReviewAt: item.ReviewAt,
|
|
OnlineAt: item.OnlineAt,
|
|
Title: item.Title,
|
|
Slug: item.Slug,
|
|
Desc: item.Desc,
|
|
Anchor: item.Anchor,
|
|
Cover: item.Cover,
|
|
CompressedCover: item.CompressedCover,
|
|
Preview: item.Preview,
|
|
CategoryIds: item.CategoryIds,
|
|
CategoryBinds: toProtoCategoryBinds(playletmod.EffectiveCategoryBinds(item)),
|
|
CategoryNames: categoryNamesFromMap(item.CategoryIds, categoryNameMap),
|
|
ThemeIds: item.ThemeIds,
|
|
ThemeNames: themeNamesFromMap(item.ThemeIds, themeNameMap),
|
|
TagIds: item.TagIds,
|
|
TagNames: tagNamesFromMap(item.TagIds, tagNameMap),
|
|
OldTags: normalizePlayletOldTags(item.OldTags),
|
|
ContentType: item.ContentType,
|
|
PayType: item.PayType,
|
|
SingleCoins: item.SingleCoins,
|
|
TotalEpisode: item.TotalEpisode,
|
|
FreeEpisodeCount: item.EffectiveFreeEpisodeCount(),
|
|
UpdateStatus: item.UpdateStatus,
|
|
TopRank: item.TopRank,
|
|
RecommendRank: item.RecommendRank,
|
|
CountComment: item.CountComment,
|
|
CountBuy: item.CountBuy,
|
|
CountBrowse: item.CountBrowse,
|
|
VirtualCountBrowse: item.VirtualCountBrowse,
|
|
DisplayCountBrowse: item.CountBrowse + item.VirtualCountBrowse,
|
|
HeatValue: item.HeatValue,
|
|
VirtualHeatValue: item.VirtualHeatValue,
|
|
DisplayHeatValue: item.HeatValue + item.VirtualHeatValue,
|
|
CountCollect: item.CountCollect,
|
|
CountLike: item.CountLike,
|
|
VirtualCountLike: item.VirtualCountLike,
|
|
DisplayCountLike: playletDisplayCountLike(item),
|
|
CountDisLike: item.CountDisLike,
|
|
SeoInfo: normalizeSeoValue(item.SeoInfo),
|
|
OperatorId: item.OperatorId,
|
|
OperatorName: item.OperatorName,
|
|
CreatedAt: item.CreatedAt,
|
|
UpdatedAt: item.UpdatedAt,
|
|
}
|
|
}
|
|
|
|
func validOfficialFreeEpisodeCount(count int64) bool {
|
|
return count == -1 || count >= 1 && count <= 1000
|
|
}
|
|
|
|
func playletDisplayCountLike(item *playletmod.Playlet) int64 {
|
|
if item == nil {
|
|
return 0
|
|
}
|
|
return item.CountLike + item.VirtualCountLike
|
|
}
|
|
|
|
func chapterToWebResp(item *playletchaptermod.PlayletChapter) *proto.PlayletChapterListResp {
|
|
if item == nil {
|
|
return nil
|
|
}
|
|
return &proto.PlayletChapterListResp{
|
|
Id: item.Id,
|
|
PlayletId: item.PlayletId,
|
|
MediaContentId: item.MediaContentId,
|
|
CurrentEpisode: item.CurrentEpisode,
|
|
Title: item.Title,
|
|
Md5: item.Md5,
|
|
Hash: item.Hash,
|
|
Height: item.Height,
|
|
Width: item.Width,
|
|
Ratio: item.Ratio,
|
|
VideoUrl: item.VideoUrl,
|
|
WatermarkVideoUrl: item.WatermarkVideoUrl,
|
|
MediaSize: item.MediaSize,
|
|
MediaTime: item.MediaTime,
|
|
CountComment: item.CountComment,
|
|
CountBuy: item.CountBuy,
|
|
CountBrowse: item.CountBrowse,
|
|
CountCollect: item.CountCollect,
|
|
CountLike: item.CountLike,
|
|
CountDisLike: item.CountDisLike,
|
|
PayType: item.PayType,
|
|
SingleCoins: item.SingleCoins,
|
|
WatermarkStatus: item.WatermarkStatus,
|
|
MediaSourceId: item.MediaSourceId,
|
|
MediaTaskId: item.MediaTaskId,
|
|
CreatedAt: item.CreatedAt,
|
|
UpdatedAt: item.UpdatedAt,
|
|
}
|
|
}
|
|
|
|
func buildCategoryNameMap(ctx context.Context, list playletmod.PlayletList) (map[int64]string, *srvdef.SrvErr) {
|
|
categoryIds := make([]int64, 0)
|
|
seen := make(map[int64]struct{})
|
|
for _, item := range list {
|
|
if item == nil {
|
|
continue
|
|
}
|
|
for _, categoryId := range item.CategoryIds {
|
|
if categoryId <= 0 {
|
|
continue
|
|
}
|
|
if _, ok := seen[categoryId]; ok {
|
|
continue
|
|
}
|
|
seen[categoryId] = struct{}{}
|
|
categoryIds = append(categoryIds, categoryId)
|
|
}
|
|
}
|
|
result := make(map[int64]string, len(categoryIds))
|
|
if len(categoryIds) == 0 {
|
|
return result, nil
|
|
}
|
|
categories, err := playletcategorymod.FindManyPlayletCategory(ctx, bson.M{
|
|
playletcategorymod.FN.PlayletCategory.Id: bson.M{"$in": categoryIds},
|
|
}, options.Find().SetProjection(bson.M{
|
|
playletcategorymod.FN.PlayletCategory.Id: 1,
|
|
playletcategorymod.FN.PlayletCategory.Name: 1,
|
|
}))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, category := range categories {
|
|
if category != nil {
|
|
result[category.Id] = category.Name
|
|
}
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func categoryNamesFromMap(categoryIds []int64, categoryNameMap map[int64]string) []string {
|
|
result := make([]string, 0, len(categoryIds))
|
|
for _, categoryId := range categoryIds {
|
|
if name := categoryNameMap[categoryId]; name != "" {
|
|
result = append(result, name)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func buildThemeNameMap(ctx context.Context, list playletmod.PlayletList) (map[int64]string, *srvdef.SrvErr) {
|
|
themeIds := make([]int64, 0)
|
|
seen := make(map[int64]struct{})
|
|
for _, item := range list {
|
|
if item == nil {
|
|
continue
|
|
}
|
|
for _, themeId := range item.ThemeIds {
|
|
if themeId <= 0 {
|
|
continue
|
|
}
|
|
if _, ok := seen[themeId]; ok {
|
|
continue
|
|
}
|
|
seen[themeId] = struct{}{}
|
|
themeIds = append(themeIds, themeId)
|
|
}
|
|
}
|
|
result := make(map[int64]string, len(themeIds))
|
|
if len(themeIds) == 0 {
|
|
return result, nil
|
|
}
|
|
themes, err := playletthememod.FindManyPlayletTheme(ctx, bson.M{
|
|
playletthememod.FN.PlayletTheme.Id: bson.M{"$in": themeIds},
|
|
}, options.Find().SetProjection(bson.M{
|
|
playletthememod.FN.PlayletTheme.Id: 1,
|
|
playletthememod.FN.PlayletTheme.Name: 1,
|
|
}))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, theme := range themes {
|
|
if theme != nil {
|
|
result[theme.Id] = theme.Name
|
|
}
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func themeNamesFromMap(themeIds []int64, themeNameMap map[int64]string) []string {
|
|
result := make([]string, 0, len(themeIds))
|
|
for _, themeId := range themeIds {
|
|
if name := themeNameMap[themeId]; name != "" {
|
|
result = append(result, name)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func buildTagNameMap(ctx context.Context, list playletmod.PlayletList) (map[int64]string, *srvdef.SrvErr) {
|
|
tagIds := make([]int64, 0)
|
|
seen := make(map[int64]struct{})
|
|
for _, item := range list {
|
|
if item == nil {
|
|
continue
|
|
}
|
|
for _, tagId := range item.TagIds {
|
|
if tagId <= 0 {
|
|
continue
|
|
}
|
|
if _, ok := seen[tagId]; ok {
|
|
continue
|
|
}
|
|
seen[tagId] = struct{}{}
|
|
tagIds = append(tagIds, tagId)
|
|
}
|
|
}
|
|
result := make(map[int64]string, len(tagIds))
|
|
if len(tagIds) == 0 {
|
|
return result, nil
|
|
}
|
|
tags, err := contenttagmod.GetMapTags(ctx, tagIds)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, tag := range tags {
|
|
if tag != nil {
|
|
result[tag.Id] = tag.Name
|
|
}
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func tagNamesFromMap(tagIds []int64, tagNameMap map[int64]string) []string {
|
|
result := make([]string, 0, len(tagIds))
|
|
for _, tagId := range tagIds {
|
|
if name := tagNameMap[tagId]; name != "" {
|
|
result = append(result, name)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func normalizePlayletOldTags(oldTags []string) []string {
|
|
if oldTags == nil {
|
|
return make([]string, 0)
|
|
}
|
|
return oldTags
|
|
}
|
|
|
|
func dedupePositiveInt64Ids(ids []int64) []int64 {
|
|
result := make([]int64, 0, len(ids))
|
|
seen := make(map[int64]struct{}, len(ids))
|
|
for _, id := range ids {
|
|
if id <= 0 {
|
|
continue
|
|
}
|
|
if _, ok := seen[id]; ok {
|
|
continue
|
|
}
|
|
seen[id] = struct{}{}
|
|
result = append(result, id)
|
|
}
|
|
return result
|
|
}
|
|
|
|
func isValidPlayletStatus(status playletmod.Status) bool {
|
|
return status == playletmod.StatusDown || status == playletmod.StatusUp
|
|
}
|
|
|
|
func isValidPlayletPayType(payType playletmod.PayType) bool {
|
|
return payType == playletmod.PayTypeFree ||
|
|
payType == playletmod.PayTypeCoin ||
|
|
payType == playletmod.PayTypeVip
|
|
}
|
|
|
|
func isValidPlayletChapterPayType(payType playletchaptermod.PayType) bool {
|
|
return payType == playletchaptermod.PayTypeFree ||
|
|
payType == playletchaptermod.PayTypeCoin ||
|
|
payType == playletchaptermod.PayTypeVip
|
|
}
|
|
|
|
func isValidPlayletContentType(contentType playletmod.ContentType) bool {
|
|
return contentType == playletmod.ContentTypeTheater ||
|
|
contentType == playletmod.ContentTypeAlbum ||
|
|
contentType == playletmod.ContentTypeComic ||
|
|
contentType == playletmod.ContentTypeAnime ||
|
|
contentType == playletmod.ContentTypeManga
|
|
}
|
|
|
|
func normalizePlayletPaySetting(payType playletmod.PayType, singleCoins *int64, requireCoinAmount bool) (playletmod.PayType, int64, *srvdef.SrvErr) {
|
|
if !isValidPlayletPayType(payType) {
|
|
return 0, 0, srvdef.New(srvdef.ErrParamError, "支付方式无效", "")
|
|
}
|
|
if payType == playletmod.PayTypeCoin {
|
|
if requireCoinAmount && (singleCoins == nil || *singleCoins <= 0) {
|
|
return 0, 0, srvdef.New(srvdef.ErrParamError, "金币支付时单集金币必须大于0", "")
|
|
}
|
|
if singleCoins == nil {
|
|
return payType, 0, nil
|
|
}
|
|
return payType, *singleCoins, nil
|
|
}
|
|
return payType, 0, nil
|
|
}
|
|
|
|
func normalizePlayletTagIds(tagIds []int64) ([]int64, *srvdef.SrvErr) {
|
|
result := make([]int64, 0, len(tagIds))
|
|
seen := make(map[int64]struct{}, len(tagIds))
|
|
for _, tagId := range tagIds {
|
|
if tagId <= 0 {
|
|
return nil, srvdef.New(srvdef.ErrParamError, "标签ID无效", "")
|
|
}
|
|
if _, ok := seen[tagId]; ok {
|
|
continue
|
|
}
|
|
seen[tagId] = struct{}{}
|
|
result = append(result, tagId)
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func validatePlayletTagIds(ctx context.Context, tagIds []int64) *srvdef.SrvErr {
|
|
if len(tagIds) == 0 {
|
|
return nil
|
|
}
|
|
return srv_contenttag.ValidateContentTags(ctx, tagIds, contenttagmod.ContentTagTypePlaylet)
|
|
}
|
|
|
|
// resolveAddCategoryBinds 新增短剧时根据分类绑定或分类ID生成排序配置
|
|
func resolveAddCategoryBinds(binds []proto.PlayletCategoryBind, ids []int64) ([]playletmod.PlayletCategoryBind, *srvdef.SrvErr) {
|
|
if len(binds) > 0 {
|
|
return resolveCategoryBinds(&binds, nil, nil)
|
|
}
|
|
return resolveCategoryBinds(nil, &ids, nil)
|
|
}
|
|
|
|
// resolveCategoryBinds 保留旧分类排序，新增分类默认排序为0
|
|
func resolveCategoryBinds(binds *[]proto.PlayletCategoryBind, ids *[]int64, old []playletmod.PlayletCategoryBind) ([]playletmod.PlayletCategoryBind, *srvdef.SrvErr) {
|
|
if binds != nil {
|
|
result := make([]playletmod.PlayletCategoryBind, 0, len(*binds))
|
|
seen := make(map[int64]bool, len(*binds))
|
|
for _, bind := range *binds {
|
|
if bind.Id <= 0 || seen[bind.Id] {
|
|
return nil, srvdef.New(srvdef.ErrParamError, "分类ID无效或重复", "")
|
|
}
|
|
seen[bind.Id] = true
|
|
result = append(result, playletmod.PlayletCategoryBind{Id: bind.Id, Rank: bind.Rank})
|
|
}
|
|
return result, nil
|
|
}
|
|
if ids != nil {
|
|
categoryIds, err := normalizePlayletCategoryIds(*ids)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return playletmod.MergeCategoryBindsByIds(old, categoryIds), nil
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func toProtoCategoryBinds(binds []playletmod.PlayletCategoryBind) []proto.PlayletCategoryBind {
|
|
result := make([]proto.PlayletCategoryBind, 0, len(binds))
|
|
for _, bind := range binds {
|
|
result = append(result, proto.PlayletCategoryBind{Id: bind.Id, Rank: bind.Rank})
|
|
}
|
|
return result
|
|
}
|
|
|
|
func normalizePlayletCategoryIds(categoryIds []int64) ([]int64, *srvdef.SrvErr) {
|
|
result := make([]int64, 0, len(categoryIds))
|
|
seen := make(map[int64]struct{}, len(categoryIds))
|
|
for _, categoryId := range categoryIds {
|
|
if categoryId <= 0 {
|
|
return nil, srvdef.New(srvdef.ErrParamError, "分类ID无效", "")
|
|
}
|
|
if _, ok := seen[categoryId]; ok {
|
|
continue
|
|
}
|
|
seen[categoryId] = struct{}{}
|
|
result = append(result, categoryId)
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func validatePlayletCategoryIds(ctx context.Context, categoryIds []int64) *srvdef.SrvErr {
|
|
if len(categoryIds) == 0 {
|
|
return nil
|
|
}
|
|
count, err := playletcategorymod.CountPlayletCategory(ctx, bson.M{
|
|
playletcategorymod.FN.PlayletCategory.Id: bson.M{"$in": categoryIds},
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if count != int64(len(categoryIds)) {
|
|
return srvdef.New(srvdef.ErrParamError, "分类不存在", "")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func validatePlayletThemeIds(ctx context.Context, themeIds []int64) *srvdef.SrvErr {
|
|
if len(themeIds) == 0 {
|
|
return srvdef.New(srvdef.ErrParamError, "题材ID不能为空", "")
|
|
}
|
|
count, err := playletthememod.CountPlayletTheme(ctx, bson.M{
|
|
playletthememod.FN.PlayletTheme.Id: bson.M{"$in": themeIds},
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if count != int64(len(themeIds)) {
|
|
return srvdef.New(srvdef.ErrParamError, "题材不存在", "")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func playletOnlineAt(status playletmod.Status, now time.Time) time.Time {
|
|
if status == playletmod.StatusUp {
|
|
return now
|
|
}
|
|
return time.Time{}
|
|
}
|
|
|
|
func resolvePlayletOperator(ctx context.Context, operatorId int64) (int64, string) {
|
|
if operatorId <= 0 {
|
|
return 0, ""
|
|
}
|
|
acc, err := mwacc.FindOneAccByFilter(ctx, bson.M{
|
|
mwacc.FN.MwAcc.Id: operatorId,
|
|
}, options.FindOne().SetProjection(bson.D{
|
|
{Key: mwacc.FN.MwAcc.Id, Value: 1},
|
|
{Key: mwacc.FN.MwAcc.UserName, Value: 1},
|
|
}))
|
|
if err != nil || acc == nil {
|
|
return operatorId, ""
|
|
}
|
|
return acc.Id, acc.UserName
|
|
}
|
|
|
|
func asyncSyncPlayletESByStatus(ids []int64, status playletmod.Status, action string) {
|
|
syncIds := append([]int64(nil), ids...)
|
|
go func() {
|
|
if err1 := srv_search.SyncPlayletStatusToES(context.Background(), syncIds, status); err1 != nil {
|
|
log.Error(action+"同步ES失败", log.Any("短剧ID", syncIds), log.Any("状态", status), log.E(err1))
|
|
}
|
|
}()
|
|
}
|
|
|
|
func asyncSyncPlayletESByLatestStatus(ids []int64, action string) {
|
|
syncIds := append([]int64(nil), ids...)
|
|
go func() {
|
|
if err1 := srv_search.SyncPlayletsToESByLatestStatus(context.Background(), syncIds); err1 != nil {
|
|
log.Error(action+"同步ES失败", log.Any("短剧ID", syncIds), log.E(err1))
|
|
}
|
|
}()
|
|
}
|
|
|
|
func randomUniqueVirtualLikeValues(min int64, max int64, count int) []int64 {
|
|
if count <= 0 {
|
|
return nil
|
|
}
|
|
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
|
result := make([]int64, 0, count)
|
|
selected := make(map[int64]struct{}, count)
|
|
start := max - int64(count) + 1
|
|
for offset := int64(0); offset < int64(count); offset++ {
|
|
current := start + offset
|
|
picked := min + rng.Int63n(current-min+1)
|
|
if _, ok := selected[picked]; ok {
|
|
picked = current
|
|
}
|
|
selected[picked] = struct{}{}
|
|
result = append(result, picked)
|
|
}
|
|
return result
|
|
}
|