Initial commit: web_hghl_server

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
2026-10-26 16:28:14 +08:00
co-authored by Claude Opus 4.7
commit 65fca60622
653 changed files with 135901 additions and 0 deletions
+678
View File
@@ -0,0 +1,678 @@
package srv_mediaresource
import (
"context"
"math/rand"
"strings"
"time"
"videoweb/pub/common/log"
"videoweb/pub/common/slugx"
"videoweb/pub/common/srvdef"
"videoweb/pub/common/utils"
"videoweb/pub/models/mwacc"
"videoweb/pub/models/playletchaptermod"
"videoweb/pub/models/playletmod"
"videoweb/web/api/proto"
"videoweb/web/middleware/auth"
"videoweb/web/webg"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo/options"
)
const (
defaultResourceSyncType = 1
defaultResourcePageNum = 1
defaultResourcePageSize = 20
maxResourcePageSize = 100
maxResourceImportIds = 100
playletResourceImportMsg = "同步任务已提交,后台正在处理"
playletHeatMinValue = 1000
playletHeatMaxValue = 5000
playletResourceMediaTypeAnime = 1 // 动漫
playletResourceMediaTypeComic = 4 // 漫画短剧
playletResourceMediaTypeShort = 5 // 短剧
playletResourceMediaTypeNormal = 6 // 普通短剧
)
// ListPlayletResource 分页查询短剧媒资列表
func ListPlayletResource(ctx context.Context, req *proto.PlayletResourceListReq) (*proto.PlayletResourceListResp, *srvdef.SrvErr) {
if req == nil {
return nil, srvdef.New(srvdef.ErrParamError, "", "")
}
syncType := defaultResourceSyncType
if req.SyncType != nil {
syncType = *req.SyncType
}
pageNumber := req.PageNumber
if pageNumber <= 0 {
pageNumber = defaultResourcePageNum
}
pageSize := req.PageSize
if pageSize <= 0 {
pageSize = defaultResourcePageSize
}
if pageSize > maxResourcePageSize {
pageSize = maxResourcePageSize
}
mediaType, err1 := resolvePlayletResourceMediaType(req.MediaType)
if err1 != nil {
return nil, err1
}
ms := newPlayletMediaCenterFromConfig()
data, err := ms.mediaList(&playletMediaListReq{
MediaType: mediaType,
Title: req.Title,
Tag: req.Tag,
SyncType: syncType,
Page: uint(pageNumber),
Size: uint(pageSize),
})
if err != nil {
return nil, srvdef.New(srvdef.Failure, err.Error(), "")
}
if err := fillPlayletResourceAddStatus(ctx, data.Data); err != nil {
return nil, err
}
return &proto.PlayletResourceListResp{
List: data.Data,
Total: data.Pagination.Count,
}, nil
}
// ListPlayletResourceChapters 查询短剧媒资剧集信息
func ListPlayletResourceChapters(ctx context.Context, req *proto.PlayletResourceChapterListReq) (*proto.PlayletResourceChapterListResp, *srvdef.SrvErr) {
if req == nil || req.Id == 0 {
return nil, srvdef.New(srvdef.ErrParamError, "媒资ID不能为空", "")
}
ms := newPlayletMediaCenterFromConfig()
result, err := ms.mediaSync(&playletMediaSyncReq{
Id: req.Id,
SyncTime: 0,
})
if err != nil {
return nil, srvdef.New(srvdef.Failure, err.Error(), "")
}
if result.IsDelete || result.Media == nil {
return nil, srvdef.New(srvdef.ErrNoData, "媒资不存在或已删除", "")
}
list := make([]*proto.PlayletResourceChapterItem, 0, len(result.MediaContentList))
for _, item := range result.MediaContentList {
videoUrl := strings.TrimSpace(item.M3u8Url)
if videoUrl == "" {
videoUrl = strings.TrimSpace(item.Urls)
}
list = append(list, &proto.PlayletResourceChapterItem{
Id: item.ID,
EpisodeNumber: item.EpisodeNumber,
Title: strings.TrimSpace(item.Title),
Cover: item.Cover,
VideoUrl: videoUrl,
Height: item.Height,
Width: item.Width,
MediaSize: item.MediaSize,
PlayTime: item.PlayTime,
SaleCoin: item.SaleCoin,
HashId: item.HashId,
CreateTime: item.CreateTime,
UpdateTime: item.UpdateTime,
})
}
return &proto.PlayletResourceChapterListResp{
MediaId: req.Id,
Title: result.Media.Title,
List: list,
Total: len(list),
}, nil
}
// resolvePlayletResourceMediaType 校验后台显式传入的媒资类型
func resolvePlayletResourceMediaType(mediaType *int) (int, *srvdef.SrvErr) {
if mediaType == nil {
return 0, srvdef.New(srvdef.ErrParamError, "媒体类型不能为空", "媒体类型不能为空")
}
if !validPlayletResourceMediaType(*mediaType) {
return 0, srvdef.New(srvdef.ErrParamError, "媒体类型无效,仅支持1-动漫、2-漫画、4-漫画短剧、5-短剧、6-普通短剧", "媒体类型无效,仅支持1-动漫、2-漫画、4-漫画短剧、5-短剧、6-普通短剧")
}
return *mediaType, nil
}
// validPlayletResourceMediaType 媒资列表当前允许的媒体类型
func validPlayletResourceMediaType(mediaType int) bool {
switch mediaType {
case playletResourceMediaTypeAnime, playletResourceMediaTypeComic, playletResourceMediaTypeShort, playletResourceMediaTypeNormal:
return true
default:
return false
}
}
// validPlayletImportMediaType 允许入库的媒资类型
func validPlayletImportMediaType(mediaType int) bool {
switch mediaType {
case playletResourceMediaTypeAnime, playletResourceMediaTypeComic, playletResourceMediaTypeShort, playletResourceMediaTypeNormal:
return true
default:
return false
}
}
// contentTypeFromMediaType 媒资中心 media_type 映射为本项目 contentType
func contentTypeFromMediaType(mediaType int) playletmod.ContentType {
switch mediaType {
case playletResourceMediaTypeAnime:
return playletmod.ContentTypeAnime
case playletResourceMediaTypeComic:
return playletmod.ContentTypeComic
case playletResourceMediaTypeNormal:
return playletmod.ContentTypeAlbum
default:
return playletmod.ContentTypeTheater
}
}
// fillPlayletResourceAddStatus 回填媒资列表是否已加入后台短剧库
func fillPlayletResourceAddStatus(ctx context.Context, list []*proto.PlayletResourceListItem) *srvdef.SrvErr {
mediaIds := make([]uint, 0, len(list))
seen := make(map[uint]struct{}, len(list))
for _, item := range list {
if item == nil || item.ID == 0 {
continue
}
if _, ok := seen[item.ID]; ok {
continue
}
seen[item.ID] = struct{}{}
mediaIds = append(mediaIds, item.ID)
}
if len(mediaIds) == 0 {
return nil
}
playletList, err := playletmod.FindManyPlaylet(ctx, bson.M{
playletmod.FN.Playlet.MediaCenterId: bson.M{"$in": mediaIds},
})
if err != nil {
log.Error("查询短剧媒资加入状态失败", log.Any("mediaIds", mediaIds), log.Any("err", err))
return err
}
addedMap := make(map[uint]bool, len(playletList))
for _, item := range playletList {
if item == nil || item.MediaCenterId == 0 {
continue
}
addedMap[item.MediaCenterId] = true
}
for _, item := range list {
if item != nil {
item.IsAdd = addedMap[item.ID]
}
}
return nil
}
// ImportPlayletResource 提交短剧媒资入库任务
func ImportPlayletResource(ctx context.Context, req *proto.PlayletResourceUseReq) (string, *srvdef.SrvErr) {
ids, err := validatePlayletResourceImportReq(req)
if err != nil {
return "", err
}
operatorId, operatorName := resolveImportOperator(ctx)
if err := pushPlayletResourceImportJob(ctx, ids, operatorId, operatorName); err != nil {
return "", err
}
return playletResourceImportMsg, nil
}
// importPlayletResourceBatch 批量处理短剧媒资入库任务
func importPlayletResourceBatch(ctx context.Context, ids []uint, operatorId int64, operatorName string) *proto.PlayletResourceUseResp {
resp := &proto.PlayletResourceUseResp{
Success: make([]*proto.PlayletResourceUseSuccess, 0, len(ids)),
Failed: make([]*proto.PlayletResourceUseFailed, 0),
}
importedMap, err := findImportedPlayletResourceMap(ctx, ids)
if err != nil {
for _, id := range ids {
resp.Failed = append(resp.Failed, &proto.PlayletResourceUseFailed{
MediaId: id,
Reason: "查询导入状态失败",
})
}
return resp
}
ms := newPlayletMediaCenterFromConfig()
for _, id := range ids {
if importedMap[id] {
resp.Failed = append(resp.Failed, &proto.PlayletResourceUseFailed{
MediaId: id,
Reason: "该媒资已导入",
})
continue
}
success, reason := importSinglePlayletResource(ctx, ms, id, operatorId, operatorName)
if reason != "" {
resp.Failed = append(resp.Failed, &proto.PlayletResourceUseFailed{
MediaId: id,
Reason: reason,
})
continue
}
resp.Success = append(resp.Success, success)
}
return resp
}
// findImportedPlayletResourceMap 批量查询已经导入的媒资ID
func findImportedPlayletResourceMap(ctx context.Context, ids []uint) (map[uint]bool, *srvdef.SrvErr) {
result := make(map[uint]bool, len(ids))
if len(ids) == 0 {
return result, nil
}
playletList, err := playletmod.FindManyPlaylet(ctx, bson.M{
playletmod.FN.Playlet.MediaCenterId: bson.M{"$in": ids},
})
if err != nil {
log.Error("批量查询短剧媒资导入状态失败", log.Any("mediaIds", ids), log.Any("err", err))
return nil, err
}
for _, item := range playletList {
if item == nil || item.MediaCenterId == 0 {
continue
}
result[item.MediaCenterId] = true
}
return result, nil
}
func newPlayletMediaCenterFromConfig() *playletMediaCenterService {
return newPlayletMediaCenterService(playletMediaCenterConfig{
Url: webg.Conf.MediaResourceDBCfg.BaseUrl,
ProId: webg.Conf.MediaResourceDBCfg.Merchat,
Secret: webg.Conf.MediaResourceDBCfg.Secret,
})
}
// validatePlayletResourceImportReq 校验短剧媒资入库请求
func validatePlayletResourceImportReq(req *proto.PlayletResourceUseReq) ([]uint, *srvdef.SrvErr) {
if req == nil {
return nil, srvdef.New(srvdef.ErrParamError, "参数不能为空", "")
}
ids := dedupePlayletResourceIds(req.Ids)
if len(ids) == 0 {
return nil, srvdef.New(srvdef.ErrParamError, "媒资ID不能为空", "")
}
if len(ids) > maxResourceImportIds {
return nil, srvdef.New(srvdef.ErrParamError, "单次最多导入100条媒资", "")
}
return ids, nil
}
// dedupePlayletResourceIds 去重并过滤无效媒资ID
func dedupePlayletResourceIds(ids []uint) []uint {
result := make([]uint, 0, len(ids))
seen := make(map[uint]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
}
// importSinglePlayletResource 导入单条短剧媒资
func importSinglePlayletResource(ctx context.Context, ms *playletMediaCenterService, mediaId uint, operatorId int64, operatorName string) (*proto.PlayletResourceUseSuccess, string) {
locked, err := lockPlayletResourceImportMedia(mediaId)
if err != nil {
log.Error("获取短剧媒资导入锁失败", log.Any("mediaId", mediaId), log.E(err))
return nil, "获取导入锁失败"
}
if !locked {
return nil, "该媒资正在导入"
}
defer unlockPlayletResourceImportMedia(mediaId)
if reason := checkPlayletResourceImported(ctx, mediaId); reason != "" {
return nil, reason
}
result, err := ms.mediaSync(&playletMediaSyncReq{
Id: mediaId,
SyncTime: 0,
})
if err != nil {
log.Error("同步短剧媒资失败", log.Any("mediaId", mediaId), log.E(err))
return nil, "同步媒资失败"
}
if result.IsDelete || result.Media == nil {
return nil, "媒资不存在或已删除"
}
if !validPlayletImportMediaType(result.Media.MediaType) {
return nil, "该媒资类型不支持导入短剧"
}
if len(result.MediaContentList) == 0 {
return nil, "媒资章节为空"
}
playlet := buildPlayletFromMedia(result.Media, operatorId, operatorName)
playlet.MediaSyncTime = maxPlayletMediaContentUpdateTime(0, result.MediaContentList)
if playlet.Title == "" {
return nil, "媒资标题为空"
}
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(&playlet.Slug, utils.SlugSourceFromKeywordsOrTitle(nil, playlet.Title), exists); serr != nil {
if serr.Tips != "" {
return nil, serr.Tips
}
return nil, "slug生成失败"
}
// 原图继续写入 Cover;压缩成功才写 CompressedCover,失败保持空。
playlet.CompressedCover = compressPlayletCoverOrEmpty(playlet.Cover)
chapters := buildPlayletChaptersFromMedia(result.MediaContentList)
if len(chapters) == 0 {
return nil, "媒资章节为空"
}
if err1 := playletmod.InsertOnePlaylet(ctx, playlet); err1 != nil {
log.Error("短剧媒资主表入库失败", log.Any("mediaId", mediaId), log.Any("err", err1))
return nil, "主资源入库失败"
}
for _, chapter := range chapters {
chapter.PlayletId = playlet.Id
}
if err1 := playletchaptermod.InsertManyPlayletChapter(ctx, chapters); err1 != nil {
log.Error("短剧媒资章节批量入库失败", log.Any("mediaId", mediaId), log.Any("playletId", playlet.Id), log.Any("chapterCount", len(chapters)), log.Any("err", err1))
rollbackImportedPlayletResource(ctx, playlet.Id, collectPlayletChapterIds(chapters))
return nil, "章节入库失败"
}
return &proto.PlayletResourceUseSuccess{
MediaId: mediaId,
PlayletId: playlet.Id,
}, ""
}
// collectPlayletChapterIds 收集章节ID
func collectPlayletChapterIds(chapters playletchaptermod.PlayletChapterList) []int64 {
ids := make([]int64, 0, len(chapters))
for _, chapter := range chapters {
if chapter == nil || chapter.Id == 0 {
continue
}
ids = append(ids, chapter.Id)
}
return ids
}
// checkPlayletResourceImported 检查媒资是否已经导入到本项目短剧表
func checkPlayletResourceImported(ctx context.Context, mediaId uint) string {
_, err := playletmod.FindOnePlaylet(ctx, bson.M{playletmod.FN.Playlet.MediaCenterId: mediaId})
if err == nil {
return "该媒资已导入"
}
if err.Code != srvdef.ErrNoData {
log.Error("查询短剧媒资导入状态失败", log.Any("mediaId", mediaId), log.Any("err", err))
return "查询导入状态失败"
}
return ""
}
// buildPlayletFromMedia 将媒资中心主资源转换为本项目 playlet 主表模型
func buildPlayletFromMedia(media *proto.PlayletResourceListItem, operatorId int64, operatorName string) *playletmod.Playlet {
cover := strings.TrimSpace(media.VerticalCover)
if cover == "" {
cover = strings.TrimSpace(media.HorizontalCover)
}
return &playletmod.Playlet{
MediaCenterId: uint(media.ID),
MediaCreatedAt: mediaResourceTime(media.CreateTime),
MediaUpdatedAt: mediaResourceTime(media.UpdateTime),
Title: strings.TrimSpace(media.Title),
Desc: strings.TrimSpace(media.Summary),
Anchor: strings.TrimSpace(media.Anchor),
Cover: cover,
OldTags: oldTagNamesFromPlayletTagsText(media.TagsText),
MediaBusiness: playletMediaBusiness(media),
ContentType: contentTypeFromMediaType(media.MediaType),
TotalEpisode: int64(media.TotalEpisode),
UpdateStatus: normalizePlayletUpdateStatus(media.UpdateStatus),
HeatValue: randomPlayletHeatValue(),
Status: playletmod.StatusDown,
OperatorId: operatorId,
OperatorName: operatorName,
}
}
// playletMediaBusinessCGDJ 赤果短剧、CGDJ 标题前缀对应的媒资业务来源。
const playletMediaBusinessCGDJ = "CGDJ"
// playletMediaBusinessRule 把媒资标题前缀映射成要写入的业务来源。先匹配先生效。
type playletMediaBusinessRule struct {
Prefix string
Business string
}
// playletMediaBusinessRules 多个前缀可以对应同一个业务来源。
// 新增来源时在这里追加;同一来源的不同叫法共用同一个 Business。
var playletMediaBusinessRules = []playletMediaBusinessRule{
//{Prefix: "赤果短剧", Business: playletMediaBusinessCGDJ},
{Prefix: "CGDJ", Business: playletMediaBusinessCGDJ},
}
func playletMediaBusiness(media *proto.PlayletResourceListItem) string {
if media == nil || media.MediaType != playletResourceMediaTypeShort {
return ""
}
title := strings.ToUpper(strings.TrimSpace(media.Title))
for _, rule := range playletMediaBusinessRules {
prefix := strings.ToUpper(strings.TrimSpace(rule.Prefix))
business := strings.TrimSpace(rule.Business)
if prefix == "" || business == "" {
continue
}
if strings.HasPrefix(title, prefix) {
return business
}
}
return ""
}
// playletMediaBusinessSearchTitles 返回回填时用来搜索媒资库的标题前缀。
func playletMediaBusinessSearchTitles() []string {
seen := make(map[string]struct{}, len(playletMediaBusinessRules))
titles := make([]string, 0, len(playletMediaBusinessRules))
for _, rule := range playletMediaBusinessRules {
prefix := strings.TrimSpace(rule.Prefix)
if prefix == "" {
continue
}
key := strings.ToUpper(prefix)
if _, ok := seen[key]; ok {
continue
}
seen[key] = struct{}{}
titles = append(titles, prefix)
}
return titles
}
func oldTagNamesFromPlayletTagsText(tagsText string) []string {
fields := strings.FieldsFunc(strings.TrimSpace(tagsText), func(r rune) bool {
switch r {
case ',', ',', '、', ';', ';', '/', '|':
return true
default:
return false
}
})
names := make([]string, 0, len(fields))
seen := make(map[string]struct{}, len(fields))
for _, field := range fields {
name := strings.TrimSpace(field)
if name == "" {
continue
}
if _, ok := seen[name]; ok {
continue
}
seen[name] = struct{}{}
names = append(names, name)
}
return names
}
func randomPlayletHeatValue() int64 {
return int64(rand.Intn(playletHeatMaxValue-playletHeatMinValue+1) + playletHeatMinValue)
}
// mediaResourceTime 转换媒资中心时间戳
func mediaResourceTime(ts int64) time.Time {
if ts <= 0 {
return time.Time{}
}
if ts > 1e12 {
return time.UnixMilli(ts)
}
return time.Unix(ts, 0)
}
// buildPlayletChaptersFromMedia 将媒资中心章节资源转换为本项目 playlet_chapter 模型
func buildPlayletChaptersFromMedia(mediaContentList []playletMediaContent) playletchaptermod.PlayletChapterList {
chapters := make(playletchaptermod.PlayletChapterList, 0, len(mediaContentList))
seenMediaContentIds := make(map[uint]struct{}, len(mediaContentList))
seenEpisodes := make(map[int]struct{}, len(mediaContentList))
seenHashIds := make(map[string]struct{}, len(mediaContentList))
seenVideoUrls := make(map[string]struct{}, len(mediaContentList))
for _, item := range mediaContentList {
videoUrl := strings.TrimSpace(item.M3u8Url)
if videoUrl == "" {
videoUrl = strings.TrimSpace(item.Urls)
}
if videoUrl == "" {
continue
}
if isDuplicatePlayletMediaChapter(item, videoUrl, seenMediaContentIds, seenEpisodes, seenHashIds, seenVideoUrls) {
continue
}
episodeNumber := int64(item.EpisodeNumber)
if episodeNumber <= 0 {
episodeNumber = int64(len(chapters) + 1)
}
height := int64(item.Height)
width := int64(item.Width)
ratio := item.Ratio
if ratio <= 0 && height > 0 {
ratio = float64(width) / float64(height)
}
chapters = append(chapters, &playletchaptermod.PlayletChapter{
MediaContentId: uint(item.ID),
CurrentEpisode: episodeNumber,
Title: strings.TrimSpace(item.Title),
Hash: item.HashId,
Height: height,
Width: width,
Ratio: ratio,
VideoUrl: videoUrl,
MediaSize: int64(item.MediaSize),
MediaTime: int64(item.PlayTime),
PayType: playletchaptermod.PayTypeFree,
SingleCoins: int64(item.SaleCoin),
WatermarkStatus: playletchaptermod.WatermarkStatusPending,
})
}
return chapters
}
// isDuplicatePlayletMediaChapter 判断媒资中心章节是否重复
func isDuplicatePlayletMediaChapter(item playletMediaContent, videoUrl string, seenMediaContentIds map[uint]struct{}, seenEpisodes map[int]struct{}, seenHashIds map[string]struct{}, seenVideoUrls map[string]struct{}) bool {
if item.ID > 0 {
if _, ok := seenMediaContentIds[item.ID]; ok {
log.Info("跳过重复短剧媒资章节", log.Any("mediaContentId", item.ID), log.Any("episodeNumber", item.EpisodeNumber))
return true
}
seenMediaContentIds[item.ID] = struct{}{}
return false
}
if item.EpisodeNumber > 0 {
if _, ok := seenEpisodes[item.EpisodeNumber]; ok {
log.Info("跳过重复短剧媒资章节", log.Any("episodeNumber", item.EpisodeNumber))
return true
}
seenEpisodes[item.EpisodeNumber] = struct{}{}
return false
}
hashId := strings.TrimSpace(item.HashId)
if hashId != "" {
if _, ok := seenHashIds[hashId]; ok {
log.Info("跳过重复短剧媒资章节", log.Any("hashId", hashId))
return true
}
seenHashIds[hashId] = struct{}{}
return false
}
if _, ok := seenVideoUrls[videoUrl]; ok {
log.Info("跳过重复短剧媒资章节", log.Any("videoUrl", videoUrl))
return true
}
seenVideoUrls[videoUrl] = struct{}{}
return false
}
// rollbackImportedPlayletResource 回滚单条媒资入库产生的数据
func rollbackImportedPlayletResource(ctx context.Context, playletId int64, chapterIds []int64) {
for _, chapterId := range chapterIds {
if _, err := playletchaptermod.DelOnePlayletChapter(ctx, bson.M{playletchaptermod.FN.PlayletChapter.Id: chapterId}); err != nil {
log.Error("回滚短剧媒资章节失败", log.Any("playletId", playletId), log.Any("chapterId", chapterId), log.Any("err", err))
}
}
if _, err := playletmod.DelOnePlaylet(ctx, bson.M{playletmod.FN.Playlet.Id: playletId}); err != nil {
log.Error("回滚短剧媒资主表失败", log.Any("playletId", playletId), log.Any("err", err))
}
}
// resolveImportOperator 从后台登录态解析当前操作人
func resolveImportOperator(ctx context.Context) (int64, string) {
c, ok := ctx.(*gin.Context)
if !ok || c == nil {
return 0, ""
}
accId := auth.GetAccount(c)
if accId <= 0 {
return 0, ""
}
acc, err := mwacc.FindOneAccByFilter(c, bson.M{
mwacc.FN.MwAcc.Id: accId,
}, 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 accId, ""
}
return acc.Id, acc.UserName
}
// maxPlayletMediaContentUpdateTime 记录本次同步返回章节中的最大更新时间
func maxPlayletMediaContentUpdateTime(syncTime int64, mediaContentList []playletMediaContent) int64 {
result := syncTime
for _, item := range mediaContentList {
if item.UpdateTime > result {
result = item.UpdateTime
}
}
return result
}
// normalizePlayletUpdateStatus 三方 update_status=0 在本项目按 2-已完结保存
func normalizePlayletUpdateStatus(updateStatus int) int {
if updateStatus == 0 {
return 2
}
return updateStatus
}