Initial commit

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
谢宇宁
2026-09-29 11:47:47 +07:00
co-authored by Claude Opus 5.5
commit 0fbdba5ccf
622 changed files with 72105 additions and 0 deletions
+56
View File
@@ -0,0 +1,56 @@
package playletser
import (
"fmt"
"net/url"
"strconv"
"videoweb/app/service/upstream"
"github.com/gin-gonic/gin"
)
const boughtListPath = "/api/app/playlet/bought/list"
// PlayletBoughtData 对应 proto.PlayletBoughtData;只列出页面所需字段。
type PlayletBoughtData struct {
ID int64 `json:"id"`
Title string `json:"title"`
PlayName string `json:"playName"`
Slug string `json:"slug"`
Cover string `json:"cover"`
ThemeNames []string `json:"themeNames"`
TotalEpisode int `json:"totalEpisode"`
BoughtChapterCount int `json:"boughtChapterCount"`
CostCoins int64 `json:"costCoins"`
BoughtAt string `json:"boughtAt"`
LastChapterID int64 `json:"lastChapterId"`
LastEpisode int `json:"lastEpisode"`
WatchedCount int `json:"watchedCount"`
}
type PlayletBoughtListResp struct {
List []PlayletBoughtData `json:"list"`
PageNum int `json:"pageNum"`
PageSize int `json:"pageSize"`
TotalCount int64 `json:"totalCount"`
}
func FetchBoughtList(c *gin.Context, pageNum, pageSize int) (*PlayletBoughtListResp, int, error) {
if pageNum < 1 {
pageNum = 1
}
if pageSize < 1 {
pageSize = 20
}
params := url.Values{}
params.Set("pageNum", strconv.Itoa(pageNum))
params.Set("pageSize", strconv.Itoa(pageSize))
var env APIEnvelope[PlayletBoughtListResp]
if err := upstream.GetJSON(c, boughtListPath+"?"+params.Encode(), &env); err != nil {
return nil, 0, err
}
if env.Code != 200 {
return nil, env.Code, fmt.Errorf("playlet bought list code=%d msg=%s", env.Code, env.Msg)
}
return &env.Data, env.Code, nil
}
+81
View File
@@ -0,0 +1,81 @@
package playletser
import (
"fmt"
"net/url"
"strconv"
"strings"
"videoweb/app/service/upstream"
"videoweb/pub/common/log"
"github.com/gin-gonic/gin"
)
const (
categoryDetailPath = "/api/app/playlet/recommend/list"
defaultCategoryPageSize = 25
)
// CategoryDetailQuery 分类详情分页参数。categorySlug 非空时优先使用 slug。
type CategoryDetailQuery struct {
PageNum int
PageSize int
CategoryID int64
CategorySlug string
}
func (q *CategoryDetailQuery) Normalize() {
if q.PageNum <= 0 {
q.PageNum = 1
}
if q.PageSize <= 0 {
q.PageSize = defaultCategoryPageSize
}
if q.PageSize > 100 {
q.PageSize = 100
}
if q.CategoryID < 0 {
q.CategoryID = 0
}
q.CategorySlug = strings.TrimSpace(q.CategorySlug)
}
func categoryDetailListURL(q CategoryDetailQuery) string {
q.Normalize()
params := url.Values{}
params.Set("pageNum", strconv.Itoa(q.PageNum))
params.Set("pageSize", strconv.Itoa(q.PageSize))
if q.CategorySlug != "" {
params.Set("categorySlug", q.CategorySlug)
} else if q.CategoryID > 0 {
params.Set("categoryId", strconv.FormatInt(q.CategoryID, 10))
}
return categoryDetailPath + "?" + params.Encode()
}
// FetchCategoryDetail 根据分类 slug 或 ID 获取分类详情列表。
func FetchCategoryDetail(c *gin.Context, q CategoryDetailQuery) (*PlayletRecommendListResp, error) {
var env APIEnvelope[PlayletRecommendListResp]
if err := upstream.GetPublicJSON(c, categoryDetailListURL(q), &env); err != nil {
return nil, err
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet category detail code=%d msg=%s", env.Code, env.Msg)
}
return &env.Data, nil
}
// FetchCategoryDetailOrEmpty 保持页面可渲染,接口失败时返回当前分页的空结果。
func FetchCategoryDetailOrEmpty(c *gin.Context, q CategoryDetailQuery) *PlayletRecommendListResp {
q.Normalize()
data, err := FetchCategoryDetail(c, q)
if err != nil {
log.Error("fetch playlet category detail failed", log.E(err))
return &PlayletRecommendListResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
if data == nil {
return &PlayletRecommendListResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
data.SeoInfo.Normalize()
return data
}
@@ -0,0 +1,63 @@
package playletser
import (
"strconv"
"strings"
)
func categoryDetailPageURL(categoryID int64, categorySlug string, pageNum int) string {
if pageNum <= 0 {
pageNum = 1
}
path := "/category"
if segment := pathSegment(categorySlug, categoryID); segment != "" {
path += "/" + segment
}
if pageNum > 1 {
path += "/page/" + strconv.Itoa(pageNum)
}
return path
}
func categoryDetailURL(categorySlug string, categoryID int64) string {
return categoryDetailPageURL(categoryID, categorySlug, 1)
}
// ParseCategoryDetailQuery 从语义化路由读取分类标识和页码。
func ParseCategoryDetailQuery(identifier, pageStr string) CategoryDetailQuery {
q := CategoryDetailQuery{PageSize: defaultCategoryPageSize}
identifier = strings.TrimSpace(identifier)
if id, err := strconv.ParseInt(identifier, 10, 64); err == nil && id > 0 {
q.CategoryID = id
} else {
q.CategorySlug = identifier
}
if page, err := strconv.Atoi(strings.TrimSpace(pageStr)); err == nil {
q.PageNum = page
}
q.Normalize()
return q
}
func CategoryDetailCanonicalPath(q CategoryDetailQuery) string {
q.Normalize()
return categoryDetailPageURL(q.CategoryID, q.CategorySlug, q.PageNum)
}
func BuildCategoryDetailPagination(q CategoryDetailQuery, totalCount int64) PaginationVM {
q.Normalize()
return BuildPagination(func(page int) string {
return categoryDetailPageURL(q.CategoryID, q.CategorySlug, page)
}, q.PageNum, q.PageSize, totalCount)
}
func CategoryDetailPageTitle(categoryName string, pageNum int, seo SeoInfo) string {
name := strings.TrimSpace(categoryName)
if name == "" {
name = strings.TrimSpace(seo.Title)
}
if name == "" {
name = "分类短剧"
}
return name + PageTitleSuffix(pageNum)
}
+272
View File
@@ -0,0 +1,272 @@
package playletser
import (
"fmt"
"net/url"
"strconv"
"strings"
"videoweb/app/service/authser"
"videoweb/app/service/upstream"
"videoweb/pub/common/log"
"github.com/gin-gonic/gin"
)
const (
chapterDetailPath = "/api/app/playlet/chapter/detail"
chapterListPath = "/api/app/playlet/chapter/list"
)
// PlayQuery 播放页参数。
type PlayQuery struct {
PlayletID int64
PlayletSlug string
ChapterID int64
}
// ParsePlayQuery 解析播放页的路径参数。
func ParsePlayQuery(playletKey, chapterIDRaw string) PlayQuery {
q := PlayQuery{PlayletSlug: strings.TrimSpace(playletKey)}
if n, err := strconv.ParseInt(strings.TrimSpace(playletKey), 10, 64); err == nil && n > 0 {
q.PlayletID = n
q.PlayletSlug = ""
}
if n, err := strconv.ParseInt(strings.TrimSpace(chapterIDRaw), 10, 64); err == nil && n > 0 {
q.ChapterID = n
}
return q
}
// FetchChapterDetail 查询剧集播放详情。
func FetchChapterDetail(c *gin.Context, chapterID, playletID int64, playletSlug string) (*PlayletChapterInfoResp, error) {
if chapterID <= 0 {
return nil, fmt.Errorf("chapter detail invalid chapterId")
}
params := url.Values{}
params.Set("chapterId", strconv.FormatInt(chapterID, 10))
if playletSlug = strings.TrimSpace(playletSlug); playletSlug != "" {
params.Set("playletSlug", playletSlug)
} else if playletID > 0 {
params.Set("playletId", strconv.FormatInt(playletID, 10))
}
authser.EnsureGuestOnEnter(c)
var env APIEnvelope[PlayletChapterInfoResp]
if err := upstream.GetJSON(c, chapterDetailPath+"?"+params.Encode(), &env); err != nil {
return nil, err
}
if env.Code != 200 && authser.IsSessionExpiredCode(env.Code) {
if authser.RecoverContentSession(c, env.Code) {
if err := upstream.GetJSON(c, chapterDetailPath+"?"+params.Encode(), &env); err != nil {
return nil, err
}
}
}
if env.Code != 200 {
return nil, fmt.Errorf("chapter detail code=%d msg=%s tip=%s", env.Code, env.Msg, env.Tip)
}
env.Data.SeoInfo.Normalize()
return &env.Data, nil
}
// FetchChapterDetailOrNil 失败返回 nil。
func FetchChapterDetailOrNil(c *gin.Context, chapterID, playletID int64, playletSlug string) *PlayletChapterInfoResp {
data, err := FetchChapterDetail(c, chapterID, playletID, playletSlug)
if err != nil {
log.Error("fetch chapter detail failed", log.E(err))
return nil
}
if data == nil || data.ID <= 0 {
return nil
}
return data
}
// FetchChapterList 根据短剧 slug 或 ID 查询选集列表,slug 优先。
func FetchChapterList(c *gin.Context, playletID int64, playletSlug string) (*PlayletChapterListResp, error) {
params := url.Values{}
if playletSlug = strings.TrimSpace(playletSlug); playletSlug != "" {
params.Set("playletSlug", playletSlug)
} else if playletID > 0 {
params.Set("playletId", strconv.FormatInt(playletID, 10))
} else {
return nil, fmt.Errorf("chapter list missing playletSlug or playletId")
}
authser.EnsureGuestOnEnter(c)
var env APIEnvelope[PlayletChapterListResp]
if err := upstream.GetJSON(c, chapterListPath+"?"+params.Encode(), &env); err != nil {
return nil, err
}
if env.Code != 200 && authser.IsSessionExpiredCode(env.Code) {
if authser.RecoverContentSession(c, env.Code) {
if err := upstream.GetJSON(c, chapterListPath+"?"+params.Encode(), &env); err != nil {
return nil, err
}
}
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet chapter list code=%d msg=%s tip=%s", env.Code, env.Msg, env.Tip)
}
return &env.Data, nil
}
// ResolvePlayChapterID 无 chapterId 时取第 1 集(currentEpisode=1),否则取列表首条。
func ResolvePlayChapterID(playlet *PlayletInfoResp, chapterID int64) int64 {
if chapterID > 0 {
return chapterID
}
if playlet == nil {
return 0
}
var firstID int64
for _, ch := range playlet.PlayletChapterInfo {
if ch.ID <= 0 {
continue
}
if firstID == 0 {
firstID = ch.ID
}
if ch.CurrentEpisode == 1 {
return ch.ID
}
}
return firstID
}
// FindChapter 在详情选集中按 chapterId 查找。
func FindChapter(playlet *PlayletInfoResp, chapterID int64) *PlayletChapterData {
if playlet == nil || chapterID <= 0 {
return nil
}
for i := range playlet.PlayletChapterInfo {
if playlet.PlayletChapterInfo[i].ID == chapterID {
return &playlet.PlayletChapterInfo[i]
}
}
return nil
}
// NextChapterID 返回下一集 chapterId;没有则 0。
func NextChapterID(playlet *PlayletInfoResp, chapterID int64) int64 {
if playlet == nil || chapterID <= 0 {
return 0
}
found := false
for _, ch := range playlet.PlayletChapterInfo {
if found && ch.ID > 0 {
return ch.ID
}
if ch.ID == chapterID {
found = true
}
}
return 0
}
// FirstUnlockCost 取第一个需金币解锁的单集价格。
func FirstUnlockCost(chapters []PlayletChapterData) int {
for _, ch := range chapters {
if ch.NeedCoinGate() {
return ch.UnlockCost()
}
}
return 0
}
// ChapterFromList 将详情选集条目转成章节详情结构(chapter/detail 失败时的 UI 兜底)。
func ChapterFromList(ch PlayletChapterData) *PlayletChapterInfoResp {
return &PlayletChapterInfoResp{
ID: ch.ID,
PlayletID: ch.PlayletID,
CurrentEpisode: ch.CurrentEpisode,
Title: ch.Title,
MD5: ch.MD5,
Hash: ch.Hash,
Height: ch.Height,
Width: ch.Width,
Ratio: ch.Ratio,
VideoURL: ch.VideoURL,
MediaSize: ch.MediaSize,
MediaTime: ch.MediaTime,
PayType: ch.PayType,
SingleCoins: ch.SingleCoins,
CostCoins: ch.CostCoins,
Balance: ch.Balance,
CanWatch: ch.CanWatch,
IsUnlocked: ch.IsUnlocked,
NeedUnlock: ch.NeedUnlock,
NeedVip: ch.NeedVip,
VipValid: ch.VipValid,
}
}
// AllowWatch 是否可播放(优先 canWatch;兼容仅返回 videoUrl 的旧数据)。
func (c *PlayletChapterInfoResp) AllowWatch() bool {
if c == nil {
return false
}
if c.CanWatch {
return true
}
if c.NeedUnlock || c.NeedVip {
return false
}
return strings.TrimSpace(c.VideoURL) != "" && c.PayType == 0
}
// UnlockCost 金币解锁消耗:优先 costCoins。
func (c *PlayletChapterInfoResp) UnlockCost() int64 {
if c == nil {
return 0
}
if c.CostCoins > 0 {
return c.CostCoins
}
if c.SingleCoins > 0 {
return int64(c.SingleCoins)
}
return 0
}
// AllowWatch 详情选集是否可直达播放(优先 canWatch)。
func (c PlayletChapterData) AllowWatch() bool {
if c.CanWatch {
return true
}
if c.NeedUnlock || c.NeedVip {
return false
}
if c.IsUnlocked {
return true
}
return c.PayType == 0
}
// NeedCoinGate 是否弹出金币解锁。
func (c PlayletChapterData) NeedCoinGate() bool {
if c.AllowWatch() {
return false
}
if c.NeedUnlock {
return true
}
return c.PayType == 1
}
// NeedVipGate 是否弹出 VIP 开通。
func (c PlayletChapterData) NeedVipGate() bool {
if c.AllowWatch() || c.NeedCoinGate() {
return false
}
if c.NeedVip {
return true
}
return c.PayType == 2
}
// UnlockCost 金币解锁消耗:优先 costCoins。
func (c PlayletChapterData) UnlockCost() int {
if c.CostCoins > 0 {
return int(c.CostCoins)
}
return c.SingleCoins
}
+84
View File
@@ -0,0 +1,84 @@
package playletser
import (
"fmt"
"net/url"
"strconv"
"videoweb/app/service/authser"
"videoweb/app/service/upstream"
"videoweb/pub/common/log"
"github.com/gin-gonic/gin"
)
const chapterCollectListPath = "/api/app/playlet/chapter/collect/list"
// PlayletChapterCollectData 对应 swagger proto.PlayletChapterCollectData
type PlayletChapterCollectData struct {
ChapterID int64 `json:"chapterId"`
ChapterTitle string `json:"chapterTitle"`
PlayletID int64 `json:"playletId"`
PlayletSlug string `json:"playletSlug"`
PlayletTitle string `json:"playletTitle"`
PlayletCover string `json:"playletCover"`
CurrentEpisode int `json:"currentEpisode"`
TotalEpisode int `json:"totalEpisode"`
UpdateStatus int `json:"updateStatus"`
CountBrowse int64 `json:"countBrowse"`
CountCollect int64 `json:"countCollect"`
CountLike int64 `json:"countLike"`
IsCollect int `json:"isCollect"`
CollectedAt string `json:"collectedAt"`
MediaTime int `json:"mediaTime"`
PayType int `json:"payType"`
SingleCoins int `json:"singleCoins"`
VideoURL string `json:"videoUrl"`
}
// PlayletChapterCollectListResp 对应 swagger proto.PlayletChapterCollectListResp
type PlayletChapterCollectListResp struct {
List []PlayletChapterCollectData `json:"list"`
PageNum int `json:"pageNum"`
PageSize int `json:"pageSize"`
TotalCount int64 `json:"totalCount"`
}
// FetchChapterCollectList 拉取当前用户剧集收藏列表。
// 第二个返回值为上游业务 code(网络错误时为 0)。
func FetchChapterCollectList(c *gin.Context, q CollectListQuery) (*PlayletChapterCollectListResp, int, error) {
q.Normalize()
params := url.Values{}
params.Set("pageNum", strconv.Itoa(q.PageNum))
params.Set("pageSize", strconv.Itoa(q.PageSize))
var env APIEnvelope[PlayletChapterCollectListResp]
if err := upstream.GetJSON(c, chapterCollectListPath+"?"+params.Encode(), &env); err != nil {
return nil, 0, err
}
if env.Code != 200 {
return nil, env.Code, fmt.Errorf("playlet chapter collect list code=%d msg=%s", env.Code, env.Msg)
}
return &env.Data, env.Code, nil
}
// FetchChapterCollectListOrEmpty 失败时返回空列表;游客会话失效时尝试重登后重试一次。
func FetchChapterCollectListOrEmpty(c *gin.Context, q CollectListQuery) *PlayletChapterCollectListResp {
data, code, err := FetchChapterCollectList(c, q)
if err == nil {
if data == nil {
return &PlayletChapterCollectListResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
return data
}
if retry, _ := authser.OnSessionExpired(c, code); retry {
data, _, err = FetchChapterCollectList(c, q)
if err == nil {
if data == nil {
return &PlayletChapterCollectListResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
return data
}
}
log.Error("fetch playlet chapter collect list failed", log.E(err))
return &PlayletChapterCollectListResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
+63
View File
@@ -0,0 +1,63 @@
package playletser
import (
"fmt"
"videoweb/app/service/upstream"
"github.com/gin-gonic/gin"
)
const (
chapterLikeSetPath = "/api/app/playlet/chapter/like/set"
chapterCollectSetPath = "/api/app/playlet/chapter/collect/set"
)
// PlayletChapterLikeSetReq 对应 swagger proto.PlayletChapterLikeSetReq
type PlayletChapterLikeSetReq struct {
ChapterID int64 `json:"chapterId"`
IsLike bool `json:"isLike"`
}
// PlayletChapterLikeSetResp 对应 swagger proto.PlayletChapterLikeSetResp
type PlayletChapterLikeSetResp struct {
ChapterID int64 `json:"chapterId"`
CountLike int64 `json:"countLike"`
IsLike int `json:"isLike"`
}
// ChapterLikeSet 设置剧集点赞/取消点赞。
func ChapterLikeSet(c *gin.Context, req PlayletChapterLikeSetReq) (*APIEnvelope[PlayletChapterLikeSetResp], error) {
if req.ChapterID <= 0 {
return nil, fmt.Errorf("chapter like invalid chapterId")
}
var env APIEnvelope[PlayletChapterLikeSetResp]
if _, err := upstream.PostJSON(c, chapterLikeSetPath, req, &env); err != nil {
return nil, err
}
return &env, nil
}
// PlayletChapterCollectSetReq 对应 swagger proto.PlayletChapterCollectSetReq
type PlayletChapterCollectSetReq struct {
ChapterID int64 `json:"chapterId"`
IsCollect bool `json:"isCollect"`
}
// PlayletChapterCollectSetResp 对应 swagger proto.PlayletChapterCollectSetResp
type PlayletChapterCollectSetResp struct {
ChapterID int64 `json:"chapterId"`
CountCollect int64 `json:"countCollect"`
IsCollect int `json:"isCollect"`
}
// ChapterCollectSet 设置剧集收藏/取消收藏。
func ChapterCollectSet(c *gin.Context, req PlayletChapterCollectSetReq) (*APIEnvelope[PlayletChapterCollectSetResp], error) {
if req.ChapterID <= 0 {
return nil, fmt.Errorf("chapter collect invalid chapterId")
}
var env APIEnvelope[PlayletChapterCollectSetResp]
if _, err := upstream.PostJSON(c, chapterCollectSetPath, req, &env); err != nil {
return nil, err
}
return &env, nil
}
+40
View File
@@ -0,0 +1,40 @@
package playletser
import (
"fmt"
"videoweb/app/service/upstream"
"github.com/gin-gonic/gin"
)
const chapterUnlockPath = "/api/app/playlet/chapter/unlock"
// PlayletChapterUnlockReq 对应 swagger proto.PlayletChapterUnlockReq
// POST /api/app/playlet/chapter/unlock
type PlayletChapterUnlockReq struct {
ChapterID int64 `json:"chapterId"`
PlayletID int64 `json:"playletId"`
}
// PlayletChapterUnlockResp 对应 swagger proto.PlayletChapterUnlockResp
type PlayletChapterUnlockResp struct {
Balance int64 `json:"balance"`
CanWatch bool `json:"canWatch"`
ChangeCoin int64 `json:"changeCoin"`
ChapterID int64 `json:"chapterId"`
CostCoins int64 `json:"costCoins"`
PlayletID int64 `json:"playletId"`
Unlocked bool `json:"unlocked"`
}
// ChapterUnlock 使用金币解锁剧集(幂等)。
func ChapterUnlock(c *gin.Context, req PlayletChapterUnlockReq) (*APIEnvelope[PlayletChapterUnlockResp], error) {
if req.ChapterID <= 0 || req.PlayletID <= 0 {
return nil, fmt.Errorf("chapter unlock invalid chapterId/playletId")
}
var env APIEnvelope[PlayletChapterUnlockResp]
if _, err := upstream.PostJSON(c, chapterUnlockPath, req, &env); err != nil {
return nil, err
}
return &env, nil
}
+39
View File
@@ -0,0 +1,39 @@
package playletser
import (
"fmt"
"videoweb/app/service/upstream"
"github.com/gin-gonic/gin"
)
const chapterWatchReportPath = "/api/app/playlet/chapter/watch/report"
// PlayletChapterWatchReportReq 对应 swagger proto.PlayletChapterWatchReportReq
type PlayletChapterWatchReportReq struct {
ChapterID int64 `json:"chapterId"`
PlayletID int64 `json:"playletId,omitempty"`
}
// PlayletChapterWatchReportResp 对应 swagger proto.PlayletChapterWatchReportResp
type PlayletChapterWatchReportResp struct {
ChapterID int64 `json:"chapterId"`
PlayletID int64 `json:"playletId"`
CurrentEpisode int `json:"currentEpisode"`
LastChapterID int64 `json:"lastChapterId"`
LastEpisode int `json:"lastEpisode"`
WatchedCount int `json:"watchedCount"`
UnwatchedCount int `json:"unwatchedCount"`
}
// ChapterWatchReport 上报短剧剧集观看。
func ChapterWatchReport(c *gin.Context, req PlayletChapterWatchReportReq) (*APIEnvelope[PlayletChapterWatchReportResp], error) {
if req.ChapterID <= 0 {
return nil, fmt.Errorf("chapter watch report invalid chapterId")
}
var env APIEnvelope[PlayletChapterWatchReportResp]
if _, err := upstream.PostJSON(c, chapterWatchReportPath, req, &env); err != nil {
return nil, err
}
return &env, nil
}
+161
View File
@@ -0,0 +1,161 @@
package playletser
import (
"fmt"
"net/url"
"strconv"
"strings"
"videoweb/app/service/authser"
"videoweb/app/service/upstream"
"videoweb/pub/common/log"
"github.com/gin-gonic/gin"
)
const (
collectSetPath = "/api/app/playlet/collect/set"
collectListPath = "/api/app/playlet/collect/list"
defaultCollectPageSize = 40
CollectTypePlaylet = "playlet"
CollectTypeChapter = "chapter"
)
// PlayletCollectSetReq 对应 swagger proto.PlayletCollectSetReq
type PlayletCollectSetReq struct {
ID int64 `json:"id"`
IsCollect bool `json:"isCollect"`
}
// PlayletCollectSetResp 对应 swagger proto.PlayletCollectSetResp
type PlayletCollectSetResp struct {
ID int64 `json:"id"`
CountCollect int64 `json:"countCollect"`
IsCollect int `json:"isCollect"`
}
// PlayletCollectData 对应 swagger proto.PlayletCollectData
type PlayletCollectData struct {
ID int64 `json:"id"`
Title string `json:"title"`
PlayName string `json:"playName"`
Slug string `json:"slug"`
Cover string `json:"cover"`
Desc string `json:"desc"`
TagIDs []int64 `json:"tagIds"`
TagNames []string `json:"tagNames"`
TagSlugs []string `json:"tagSlugs"`
ThemeIDs []int64 `json:"themeIds"`
ThemeNames []string `json:"themeNames"`
ThemeSlugs []string `json:"themeSlugs"`
TotalEpisode int `json:"totalEpisode"`
UpdateStatus int `json:"updateStatus"`
CountBrowse int64 `json:"countBrowse"`
CountCollect int64 `json:"countCollect"`
CountLike int64 `json:"countLike"`
IsFeatured bool `json:"isFeatured"`
IsNew bool `json:"isNew"`
IsRecommend bool `json:"isRecommend"`
IsCollect int `json:"isCollect"`
CollectedAt string `json:"collectedAt"`
WatchedCount int `json:"watchedCount"`
UnwatchedCount int `json:"unwatchedCount"`
LastChapterID int64 `json:"lastChapterId"`
LastEpisode int `json:"lastEpisode"`
}
// PlayletCollectListResp 对应 swagger proto.PlayletCollectListResp
type PlayletCollectListResp struct {
List []PlayletCollectData `json:"list"`
PageNum int `json:"pageNum"`
PageSize int `json:"pageSize"`
TotalCount int64 `json:"totalCount"`
}
// CollectListQuery 收藏列表分页参数。
type CollectListQuery struct {
PageNum int
PageSize int
WatchStatus int // 0 全部、1 追剧中、2 已看完;仅短剧收藏列表使用
Type string // playlet | chapter
}
// NormalizeCollectType 归一化收藏类型。
func NormalizeCollectType(raw string) string {
switch strings.TrimSpace(strings.ToLower(raw)) {
case CollectTypeChapter, "2", "episode", "ep":
return CollectTypeChapter
default:
return CollectTypePlaylet
}
}
// Normalize 校正分页默认值。
func (q *CollectListQuery) Normalize() {
if q.PageNum <= 0 {
q.PageNum = 1
}
if q.PageSize <= 0 {
q.PageSize = defaultCollectPageSize
}
if q.PageSize > 50 {
q.PageSize = 50
}
if q.WatchStatus < 0 || q.WatchStatus > 2 {
q.WatchStatus = 0
}
q.Type = NormalizeCollectType(q.Type)
}
// CollectSet 设置短剧收藏/取消收藏。
func CollectSet(c *gin.Context, req PlayletCollectSetReq) (*APIEnvelope[PlayletCollectSetResp], error) {
if req.ID <= 0 {
return nil, fmt.Errorf("playlet collect invalid id")
}
var env APIEnvelope[PlayletCollectSetResp]
if _, err := upstream.PostJSON(c, collectSetPath, req, &env); err != nil {
return nil, err
}
return &env, nil
}
// FetchCollectList 拉取当前用户短剧收藏列表。
// 第二个返回值为上游业务 code(网络错误时为 0)。
func FetchCollectList(c *gin.Context, q CollectListQuery) (*PlayletCollectListResp, int, error) {
q.Normalize()
params := url.Values{}
params.Set("pageNum", strconv.Itoa(q.PageNum))
params.Set("pageSize", strconv.Itoa(q.PageSize))
params.Set("watchStatus", strconv.Itoa(q.WatchStatus))
var env APIEnvelope[PlayletCollectListResp]
if err := upstream.GetJSON(c, collectListPath+"?"+params.Encode(), &env); err != nil {
return nil, 0, err
}
if env.Code != 200 {
return nil, env.Code, fmt.Errorf("playlet collect list code=%d msg=%s", env.Code, env.Msg)
}
return &env.Data, env.Code, nil
}
// FetchCollectListOrEmpty 失败时返回空列表;游客会话失效时尝试重登后重试一次。
func FetchCollectListOrEmpty(c *gin.Context, q CollectListQuery) *PlayletCollectListResp {
data, code, err := FetchCollectList(c, q)
if err == nil {
if data == nil {
return &PlayletCollectListResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
return data
}
if retry, _ := authser.OnSessionExpired(c, code); retry {
data, _, err = FetchCollectList(c, q)
if err == nil {
if data == nil {
return &PlayletCollectListResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
return data
}
}
log.Error("fetch playlet collect list failed", log.E(err))
return &PlayletCollectListResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
+89
View File
@@ -0,0 +1,89 @@
package playletser
import (
"fmt"
"net/url"
"strconv"
"strings"
)
func collectPageURL(pageNum int, collectType string) string {
collectType = NormalizeCollectType(collectType)
path := "/collect"
if collectType != CollectTypePlaylet {
path += "/" + url.PathEscape(collectType)
}
if pageNum > 1 {
path += "/page/" + strconv.Itoa(pageNum)
}
return path
}
func CollectCanonicalPath(q CollectListQuery) string {
q.Normalize()
return collectPageURL(q.PageNum, q.Type)
}
// BuildCollectPagination 收藏列表分页。
func BuildCollectPagination(q CollectListQuery, totalCount int64) PaginationVM {
q.Normalize()
return BuildPagination(func(p int) string {
return collectPageURL(p, q.Type)
}, q.PageNum, q.PageSize, totalCount)
}
// ParseCollectListQuery 从 query 解析分页与类型(playlet 短剧 / chapter 剧集)。
func ParseCollectListQuery(pageStr, typeStr string) CollectListQuery {
q := CollectListQuery{
PageSize: defaultCollectPageSize,
Type: NormalizeCollectType(typeStr),
}
if n, err := strconv.Atoi(strings.TrimSpace(pageStr)); err == nil {
q.PageNum = n
}
q.Normalize()
return q
}
// collectProgressText 进度文案:优先最近观看集,其次未看/已看完。
func collectProgressText(item PlayletCollectData) string {
if item.LastEpisode > 0 {
return fmt.Sprintf("第%d集", item.LastEpisode)
}
if item.TotalEpisode > 0 && item.UnwatchedCount <= 0 {
return "已看完"
}
if item.UnwatchedCount > 0 {
return fmt.Sprintf("%d集未看", item.UnwatchedCount)
}
return ""
}
// collectTagText 收藏卡片标签:仅展示 TagNames 第一项,无标签时不显示。
func collectTagText(item PlayletCollectData) string {
return firstName(item.TagNames)
}
// chapterCollectEpisodeLabel 剧集收藏角标:总集数。
func chapterCollectEpisodeLabel(item PlayletChapterCollectData) string {
return episodeText(item.TotalEpisode)
}
// chapterCollectDesc 剧集收藏副标题。
func chapterCollectDesc(item PlayletChapterCollectData) string {
if t := strings.TrimSpace(item.ChapterTitle); t != "" {
return t
}
if item.CurrentEpisode > 0 {
return fmt.Sprintf("第%d集", item.CurrentEpisode)
}
return ""
}
// chapterCollectMeta 剧集收藏右侧文案:第 N 集。
func chapterCollectMeta(item PlayletChapterCollectData) string {
if item.CurrentEpisode > 0 {
return fmt.Sprintf("第%d集", item.CurrentEpisode)
}
return updateStatusText(item.UpdateStatus)
}
+133
View File
@@ -0,0 +1,133 @@
package playletser
import (
"fmt"
"net/url"
"strconv"
"strings"
"videoweb/app/service/authser"
"videoweb/app/service/upstream"
"videoweb/pub/common/log"
"github.com/gin-gonic/gin"
)
const (
detailPath = "/api/app/playlet/detail"
defaultEpisodeRange = 30
)
// EpisodeRange 剧集分段(仅 UI 分页展示,非接口字段映射)。
type EpisodeRange struct {
Start int
End int
Label string
}
// FetchDetail 根据短剧 ID 查询详情。
func FetchDetail(c *gin.Context, id int64) (*PlayletInfoResp, error) {
if id <= 0 {
return nil, fmt.Errorf("playlet detail invalid id")
}
return fetchDetail(c, "id", strconv.FormatInt(id, 10))
}
// FetchDetailByKey 优先按 slug 查询;纯数字路由段按 ID 查询。
func FetchDetailByKey(c *gin.Context, key string) (*PlayletInfoResp, error) {
key = strings.TrimSpace(key)
if key == "" {
return nil, fmt.Errorf("playlet detail missing route key")
}
if id := ParseDetailID(key); id > 0 {
return FetchDetail(c, id)
}
return fetchDetail(c, "slug", key)
}
func fetchDetail(c *gin.Context, queryKey, value string) (*PlayletInfoResp, error) {
authser.EnsureGuestOnEnter(c)
env, err := fetchDetailOnce(c, queryKey, value)
if err != nil {
return nil, err
}
if env.Code != 200 && authser.IsSessionExpiredCode(env.Code) {
if authser.RecoverContentSession(c, env.Code) {
env, err = fetchDetailOnce(c, queryKey, value)
if err != nil {
return nil, err
}
}
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet detail code=%d msg=%s tip=%s", env.Code, env.Msg, env.Tip)
}
env.Data.SeoInfo.Normalize()
return &env.Data, nil
}
func fetchDetailOnce(c *gin.Context, queryKey, value string) (*APIEnvelope[PlayletInfoResp], error) {
params := url.Values{}
params.Set(queryKey, value)
var env APIEnvelope[PlayletInfoResp]
if err := upstream.GetJSON(c, detailPath+"?"+params.Encode(), &env); err != nil {
return nil, err
}
return &env, nil
}
// FetchDetailOrNilByKey 失败或无效时返回 nil。
func FetchDetailOrNilByKey(c *gin.Context, key string) *PlayletInfoResp {
data, err := FetchDetailByKey(c, key)
if err != nil {
log.Error("fetch playlet detail by route key failed", log.E(err))
return nil
}
if data == nil || data.ID <= 0 {
return nil
}
return data
}
// ParseDetailID 解析纯数字路由段。
func ParseDetailID(raw string) int64 {
id, err := strconv.ParseInt(strings.TrimSpace(raw), 10, 64)
if err != nil || id <= 0 {
return 0
}
return id
}
// BuildEpisodeRanges 按集数分段(默认每段 30 集)。
func BuildEpisodeRanges(chapters []PlayletChapterData, totalEpisode, size int) []EpisodeRange {
if size <= 0 {
size = defaultEpisodeRange
}
maxEp := 0
for _, ch := range chapters {
if ch.CurrentEpisode > maxEp {
maxEp = ch.CurrentEpisode
}
}
if totalEpisode > maxEp {
maxEp = totalEpisode
}
if maxEp <= 0 {
maxEp = len(chapters)
}
if maxEp <= 0 {
return nil
}
out := make([]EpisodeRange, 0, (maxEp+size-1)/size)
for start := 1; start <= maxEp; start += size {
end := start + size - 1
if end > maxEp {
end = maxEp
}
out = append(out, EpisodeRange{
Start: start,
End: end,
Label: fmt.Sprintf("%d–%d", start, end),
})
}
return out
}
+69
View File
@@ -0,0 +1,69 @@
package playletser
import (
"bytes"
"encoding/json"
"strings"
)
// UnmarshalJSON 兼容上游 data 为对象、null、空字符串,或二次 JSON 编码的字符串。
func (e *APIEnvelope[T]) UnmarshalJSON(raw []byte) error {
if e == nil {
return nil
}
raw = bytes.TrimSpace(raw)
if len(raw) == 0 || bytes.Equal(raw, []byte("null")) {
return nil
}
var aux struct {
Code int `json:"code"`
Msg string `json:"msg"`
Tip string `json:"tip"`
Data json.RawMessage `json:"data"`
}
if err := json.Unmarshal(raw, &aux); err != nil {
return err
}
e.Code = aux.Code
e.Msg = aux.Msg
e.Tip = aux.Tip
data, err := unmarshalEnvelopeData[T](aux.Data)
if err != nil {
return err
}
e.Data = data
return nil
}
func unmarshalEnvelopeData[T any](raw json.RawMessage) (T, error) {
var zero T
raw = bytes.TrimSpace(raw)
if len(raw) == 0 || bytes.Equal(raw, []byte("null")) {
return zero, nil
}
if raw[0] == '"' {
var s string
if err := json.Unmarshal(raw, &s); err != nil {
return zero, err
}
s = strings.TrimSpace(s)
if s == "" {
return zero, nil
}
inner := bytes.TrimSpace([]byte(s))
if len(inner) == 0 {
return zero, nil
}
if inner[0] != '{' && inner[0] != '[' {
return zero, nil
}
if err := json.Unmarshal(inner, &zero); err != nil {
return zero, err
}
return zero, nil
}
if err := json.Unmarshal(raw, &zero); err != nil {
return zero, err
}
return zero, nil
}
+33
View File
@@ -0,0 +1,33 @@
package playletser
import (
"fmt"
"videoweb/app/service/upstream"
"github.com/gin-gonic/gin"
)
const forwardHeatPath = "/api/app/playlet/forward/heat"
// PlayletForwardHeatReq 对应 swagger proto.PlayletForwardHeatReq
type PlayletForwardHeatReq struct {
ID int64 `json:"id"`
}
// PlayletForwardHeatResp 对应 swagger proto.PlayletForwardHeatResp
type PlayletForwardHeatResp struct {
ID int64 `json:"id"`
HeatValue int64 `json:"heatValue"`
}
// ForwardHeat 短剧转发增加热度。
func ForwardHeat(c *gin.Context, req PlayletForwardHeatReq) (*APIEnvelope[PlayletForwardHeatResp], error) {
if req.ID <= 0 {
return nil, fmt.Errorf("playlet forward heat invalid id")
}
var env APIEnvelope[PlayletForwardHeatResp]
if _, err := upstream.PostJSON(c, forwardHeatPath, req, &env); err != nil {
return nil, err
}
return &env, nil
}
+132
View File
@@ -0,0 +1,132 @@
package playletser
import (
"fmt"
"net/url"
"strconv"
"videoweb/app/service/upstream"
"videoweb/pub/common/log"
"github.com/gin-gonic/gin"
)
const (
guessLikeListPath = "/api/app/playlet/guess-like/list"
defaultGuessLikeSize = 6
)
// PlayletGuessLikeListResp 对应 swagger proto.PlayletGuessLikeListResp。
// GET /api/app/playlet/guess-like/list
// 文档:http://172.104.181.99:25319/swagger/index.html#/app短剧相关接口/get_api_app_playlet_guess_like_list
type PlayletGuessLikeListResp struct {
List []CommonData `json:"list"`
PageNum int `json:"pageNum"`
PageSize int `json:"pageSize"`
TotalCount int64 `json:"totalCount"`
}
// GuessLikeQuery 猜你喜欢分页参数。
type GuessLikeQuery struct {
PlayletID int64
PageNum int
PageSize int
}
// Normalize 校正分页默认值。
func (q *GuessLikeQuery) Normalize() {
if q.PageNum <= 0 {
q.PageNum = 1
}
if q.PageSize <= 0 {
q.PageSize = defaultGuessLikeSize
}
if q.PageSize > 30 {
q.PageSize = 30
}
}
// ParseGuessLikePage 解析播放页 /recommendations/page/:guessPage。
func ParseGuessLikePage(c *gin.Context) int {
n, err := strconv.Atoi(c.Param("guessPage"))
if err != nil || n <= 0 {
return 1
}
return n
}
// FetchGuessLikeList 分页查询猜你喜欢。
func FetchGuessLikeList(c *gin.Context, q GuessLikeQuery) (*PlayletGuessLikeListResp, error) {
q.Normalize()
if q.PlayletID <= 0 {
return nil, fmt.Errorf("guess-like missing playletId")
}
params := url.Values{}
params.Set("playletId", strconv.FormatInt(q.PlayletID, 10))
params.Set("pageNum", strconv.Itoa(q.PageNum))
params.Set("pageSize", strconv.Itoa(q.PageSize))
var env APIEnvelope[PlayletGuessLikeListResp]
if err := upstream.GetPublicJSON(c, guessLikeListPath+"?"+params.Encode(), &env); err != nil {
return nil, err
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet guess-like list code=%d msg=%s tip=%s", env.Code, env.Msg, env.Tip)
}
return &env.Data, nil
}
// FetchGuessLikeListOrEmpty 失败时返回空列表。
func FetchGuessLikeListOrEmpty(c *gin.Context, q GuessLikeQuery) *PlayletGuessLikeListResp {
q.Normalize()
data, err := FetchGuessLikeList(c, q)
if err != nil {
log.Error("fetch playlet guess-like list failed", log.E(err))
return &PlayletGuessLikeListResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
if data == nil {
return &PlayletGuessLikeListResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
if data.PageNum <= 0 {
data.PageNum = q.PageNum
}
if data.PageSize <= 0 {
data.PageSize = q.PageSize
}
return data
}
// GuessLikeTotalPages 总页数。
func GuessLikeTotalPages(pageSize int, totalCount int64) int {
if pageSize <= 0 || totalCount <= 0 {
return 0
}
return int((totalCount + int64(pageSize) - 1) / int64(pageSize))
}
// GuessLikeNextPage 下一页;到末页后回到第 1 页。
func GuessLikeNextPage(pageNum, pageSize int, totalCount int64) int {
totalPages := GuessLikeTotalPages(pageSize, totalCount)
if totalPages <= 1 {
return 1
}
if pageNum < 1 {
pageNum = 1
}
next := pageNum + 1
if next > totalPages {
return 1
}
return next
}
// GuessLikePageURL 播放页猜你喜欢分页链接(换一批)。
func GuessLikePageURL(slug string, playletID, chapterID int64, pageNum int) string {
base := chapterPlayURL(slug, playletID, chapterID)
if base == "#" {
return base
}
if pageNum <= 1 {
return base
}
return base + "/recommendations/page/" + strconv.Itoa(pageNum)
}
+166
View File
@@ -0,0 +1,166 @@
package playletser
import (
"fmt"
"net/url"
"strconv"
"videoweb/app/service/authser"
"videoweb/app/service/upstream"
"videoweb/pub/common/log"
"github.com/gin-gonic/gin"
)
const (
historyListPath = "/api/app/playlet/history/list"
historyClearPath = "/api/app/playlet/history/clear"
historyDeletePath = "/api/app/playlet/history/delete"
defaultHistoryPageSize = 40
)
// PlayletHistoryData 对应 swagger proto.PlayletHistoryData
// GET /api/app/playlet/history/list
type PlayletHistoryData struct {
ID int64 `json:"id"`
Status int `json:"status"`
IsFeatured bool `json:"isFeatured"`
IsNew bool `json:"isNew"`
IsRecommend bool `json:"isRecommend"`
ShowOnBanner bool `json:"showOnBanner"`
Banner string `json:"banner"`
OnlineAt string `json:"onlineAt"`
MediaCreatedAt string `json:"mediaCreatedAt"`
MediaUpdatedAt string `json:"mediaUpdatedAt"`
ThemeIDs []int64 `json:"themeIds"`
ThemeNames []string `json:"themeNames"`
ThemeSlugs []string `json:"themeSlugs"`
Title string `json:"title"`
PlayName string `json:"playName"`
Slug string `json:"slug"`
Desc string `json:"desc"`
Anchor string `json:"anchor"`
Cover string `json:"cover"`
TagIDs []int64 `json:"tagIds"`
TagNames []string `json:"tagNames"`
TagSlugs []string `json:"tagSlugs"`
TotalEpisode int `json:"totalEpisode"`
UpdateStatus int `json:"updateStatus"`
CountBrowse int64 `json:"countBrowse"`
CountCollect int64 `json:"countCollect"`
CountLike int64 `json:"countLike"`
CreatedAt string `json:"createdAt"`
UpdatedAt string `json:"updatedAt"`
WatchedCount int `json:"watchedCount"`
UnwatchedCount int `json:"unwatchedCount"`
LastChapterID int64 `json:"lastChapterId"`
LastEpisode int `json:"lastEpisode"`
IsFinished bool `json:"isFinished"`
HistoryAt string `json:"historyAt"`
}
// PlayletHistoryListResp 对应 swagger proto.PlayletHistoryListResp
type PlayletHistoryListResp struct {
List []PlayletHistoryData `json:"list"`
PageNum int `json:"pageNum"`
PageSize int `json:"pageSize"`
TotalCount int64 `json:"totalCount"`
}
// PlayletHistoryClearResp 对应 swagger proto.PlayletHistoryClearResp
type PlayletHistoryClearResp struct {
DeletedCount int `json:"deletedCount"`
}
// PlayletHistoryDeleteReq 对应 swagger proto.PlayletHistoryDeleteReq
type PlayletHistoryDeleteReq struct {
PlayletID int64 `json:"playletId"`
}
// PlayletHistoryDeleteResp 对应 swagger proto.PlayletHistoryDeleteResp
type PlayletHistoryDeleteResp struct {
DeletedCount int `json:"deletedCount"`
}
// HistoryListQuery 观看历史分页参数。
type HistoryListQuery struct {
PageNum int
PageSize int
}
// Normalize 校正分页默认值。
func (q *HistoryListQuery) Normalize() {
if q.PageNum <= 0 {
q.PageNum = 1
}
if q.PageSize <= 0 {
q.PageSize = defaultHistoryPageSize
}
if q.PageSize > 100 {
q.PageSize = 100
}
}
// FetchHistoryList 分页查询当前用户观看历史。
// 第二个返回值为上游业务 code(网络错误时为 0)。
func FetchHistoryList(c *gin.Context, q HistoryListQuery) (*PlayletHistoryListResp, int, error) {
q.Normalize()
params := url.Values{}
params.Set("pageNum", strconv.Itoa(q.PageNum))
params.Set("pageSize", strconv.Itoa(q.PageSize))
var env APIEnvelope[PlayletHistoryListResp]
if err := upstream.GetJSON(c, historyListPath+"?"+params.Encode(), &env); err != nil {
return nil, 0, err
}
if env.Code != 200 {
return nil, env.Code, fmt.Errorf("playlet history list code=%d msg=%s", env.Code, env.Msg)
}
return &env.Data, env.Code, nil
}
// FetchHistoryListOrEmpty 失败时返回空列表;游客会话失效时尝试重登后重试一次。
func FetchHistoryListOrEmpty(c *gin.Context, q HistoryListQuery) *PlayletHistoryListResp {
data, code, err := FetchHistoryList(c, q)
if err == nil {
if data == nil {
return &PlayletHistoryListResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
return data
}
if retry, _ := authser.OnSessionExpired(c, code); retry {
data, _, err = FetchHistoryList(c, q)
if err == nil {
if data == nil {
return &PlayletHistoryListResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
return data
}
}
log.Error("fetch playlet history list failed", log.E(err))
return &PlayletHistoryListResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
// HistoryClear 清空当前用户短剧观看历史。
// POST /api/app/playlet/history/clear,无请求体。
// 文档:http://172.104.181.99:25319/swagger/index.html#/app短剧相关接口/post_api_app_playlet_history_clear
func HistoryClear(c *gin.Context) (*APIEnvelope[PlayletHistoryClearResp], error) {
var env APIEnvelope[PlayletHistoryClearResp]
if _, err := upstream.PostJSON(c, historyClearPath, nil, &env); err != nil {
return nil, err
}
return &env, nil
}
// HistoryDelete 删除单条短剧观看历史。
// POST /api/app/playlet/history/delete
// 文档:http://172.104.181.99:25319/swagger/index.html#/app短剧相关接口/post_api_app_playlet_history_delete
func HistoryDelete(c *gin.Context, req PlayletHistoryDeleteReq) (*APIEnvelope[PlayletHistoryDeleteResp], error) {
if req.PlayletID <= 0 {
return nil, fmt.Errorf("playlet history delete invalid playletId")
}
var env APIEnvelope[PlayletHistoryDeleteResp]
if _, err := upstream.PostJSON(c, historyDeletePath, req, &env); err != nil {
return nil, err
}
return &env, nil
}
+229
View File
@@ -0,0 +1,229 @@
package playletser
import (
"fmt"
"strconv"
"strings"
"time"
)
func historyPageURL(pageNum int) string {
if pageNum <= 1 {
return "/history"
}
return "/history/page/" + strconv.Itoa(pageNum)
}
func HistoryCanonicalPath(q HistoryListQuery) string {
q.Normalize()
return historyPageURL(q.PageNum)
}
// BuildHistoryPagination 观看历史分页。
func BuildHistoryPagination(q HistoryListQuery, totalCount int64) PaginationVM {
q.Normalize()
return BuildPagination(func(p int) string {
return historyPageURL(p)
}, q.PageNum, q.PageSize, totalCount)
}
// ParseHistoryListQuery 从 query 解析分页。
func ParseHistoryListQuery(pageStr string) HistoryListQuery {
q := HistoryListQuery{PageSize: defaultHistoryPageSize}
if n, err := strconv.Atoi(strings.TrimSpace(pageStr)); err == nil {
q.PageNum = n
}
q.Normalize()
return q
}
func historyFinished(item PlayletHistoryData) bool {
if item.IsFinished {
return true
}
return item.TotalEpisode > 0 && item.UnwatchedCount <= 0 && item.WatchedCount > 0
}
// historyStatus 卡片筛选状态:finished / unfinished。
func historyStatus(item PlayletHistoryData) string {
if historyFinished(item) {
return "finished"
}
return "unfinished"
}
// historyProgressText PC 卡片未看文案,使用接口 unwatchedCount / isFinished。
func historyProgressText(item PlayletHistoryData) string {
if historyFinished(item) {
return "已看完"
}
if item.UnwatchedCount > 0 {
return fmt.Sprintf("%d集未看", item.UnwatchedCount)
}
if item.LastEpisode > 0 {
return fmt.Sprintf("看到第%d集", item.LastEpisode)
}
return "未看完"
}
// historyWatchLine H5 进度行。
func historyWatchLine(item PlayletHistoryData) string {
if historyFinished(item) {
if item.LastEpisode > 0 {
return fmt.Sprintf("第%d集 · 已看完", item.LastEpisode)
}
return "已看完"
}
ep := "未开始"
if item.LastEpisode > 0 {
ep = fmt.Sprintf("第%d集", item.LastEpisode)
}
if item.UnwatchedCount > 0 {
return ep + fmt.Sprintf(" · 还有%d集未看", item.UnwatchedCount)
}
return ep + " · 未看完"
}
// historyTagText 历史卡片标签:仅展示 TagNames 第一项,无标签时不显示。
func historyTagText(item PlayletHistoryData) string {
return firstName(item.TagNames)
}
// historyPlayURL 继续播放:优先最近观看剧集。
func historyPlayURL(item PlayletHistoryData) string {
return chapterPlayURL(item.Slug, item.ID, item.LastChapterID)
}
// historyContinueMeta 首页「继续观看」文案:看至第 N 集 / 剩 M 集。
func historyContinueMeta(item PlayletHistoryData) string {
if item.LastEpisode <= 0 {
return "观看记录"
}
meta := fmt.Sprintf("看至第 %d 集", item.LastEpisode)
if item.UnwatchedCount > 0 {
meta += fmt.Sprintf(" 剩 %d 集", item.UnwatchedCount)
}
return meta
}
// historyProgressPct 观看进度百分比,供卡片 --p 使用。
func historyProgressPct(item PlayletHistoryData) string {
progress := 0
if item.TotalEpisode > 0 {
progress = item.WatchedCount * 100 / item.TotalEpisode
}
if progress < 0 {
progress = 0
}
if progress > 100 {
progress = 100
}
return fmt.Sprintf("%d%%", progress)
}
// FormatHistoryAt 最近观看时间展示。
func FormatHistoryAt(raw string) string {
return formatHistoryAt(raw)
}
// FormatHistoryListTime 观看历史列表时间:今天/昨天带时刻,更早仅日期。
func FormatHistoryListTime(raw string) string {
raw = strings.TrimSpace(raw)
if raw == "" {
return ""
}
t, ok := parseHistoryTime(raw)
if !ok {
return raw
}
now := time.Now()
startToday := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
startThat := time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, t.Location())
dayDiff := int(startToday.Sub(startThat).Hours() / 24)
hm := t.Format("15:04")
switch {
case dayDiff <= 0:
return "今天 " + hm
case dayDiff == 1:
return "昨天 " + hm
default:
return fmt.Sprintf("%d 月 %d 日", int(t.Month()), t.Day())
}
}
// HistoryDayBucket 列表分组标题:今天 / 昨天 / 更早。
func HistoryDayBucket(raw string) string {
raw = strings.TrimSpace(raw)
t, ok := parseHistoryTime(raw)
if !ok {
return "更早"
}
now := time.Now()
startToday := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
startThat := time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, t.Location())
dayDiff := int(startToday.Sub(startThat).Hours() / 24)
switch {
case dayDiff <= 0:
return "今天"
case dayDiff == 1:
return "昨天"
default:
return "更早"
}
}
func formatHistoryAt(raw string) string {
raw = strings.TrimSpace(raw)
if raw == "" {
return ""
}
t, ok := parseHistoryTime(raw)
if !ok {
return raw
}
now := time.Now()
startToday := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
startThat := time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, t.Location())
dayDiff := int(startToday.Sub(startThat).Hours() / 24)
hm := t.Format("15:04")
switch {
case dayDiff <= 0:
return "今天 " + hm
case dayDiff == 1:
return "昨天 " + hm
case dayDiff == 2:
return "前天 " + hm
case dayDiff < 7:
return fmt.Sprintf("%d天前 %s", dayDiff, hm)
case dayDiff < 14:
return "一周前 " + hm
default:
return fmt.Sprintf("%d 月 %d 日", int(t.Month()), t.Day())
}
}
func parseHistoryTime(raw string) (time.Time, bool) {
layouts := []string{
time.RFC3339Nano,
time.RFC3339,
"2006-01-02 15:04:05",
"2006-01-02T15:04:05",
"2006-01-02T15:04:05Z07:00",
"2006-01-02 15:04:05.000",
"2006-01-02 15:04:05.999999999",
}
for _, layout := range layouts {
if t, err := time.ParseInLocation(layout, raw, time.Local); err == nil {
return t, true
}
if t, err := time.Parse(layout, raw); err == nil {
return t.In(time.Local), true
}
}
return time.Time{}, false
}
// ParseHistoryTime 解析观看历史时间字符串。
func ParseHistoryTime(raw string) (time.Time, bool) {
return parseHistoryTime(strings.TrimSpace(raw))
}
+239
View File
@@ -0,0 +1,239 @@
package playletser
import (
"fmt"
"strings"
"sync"
"time"
"videoweb/app/service/upstream"
"videoweb/pub/common/log"
"github.com/gin-gonic/gin"
)
const homePath = "/api/app/playlet/home"
const homeCacheTTL = 30 * time.Second
var (
homeMu sync.Mutex
homeCache *HomePlayletResponse
homeAt time.Time
)
// FetchHome 拉取首页短剧聚合数据。
func FetchHome(c *gin.Context) (*HomePlayletResponse, error) {
var env APIEnvelope[HomePlayletResponse]
if err := upstream.GetPublicJSON(c, homePath, &env); err != nil {
return nil, err
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet home code=%d msg=%s", env.Code, env.Msg)
}
return &env.Data, nil
}
// FetchHomeOrEmpty 带短缓存;失败时打日志并返回空结构,保证 SSR 页面可渲染。
func FetchHomeOrEmpty(c *gin.Context) *HomePlayletResponse {
homeMu.Lock()
defer homeMu.Unlock()
if homeCache != nil && time.Since(homeAt) < homeCacheTTL {
return cloneHome(homeCache)
}
data, err := FetchHome(c)
if err != nil {
log.Error("fetch playlet home failed", log.E(err))
if homeCache != nil {
return cloneHome(homeCache)
}
return &HomePlayletResponse{}
}
if data == nil {
if homeCache != nil {
return cloneHome(homeCache)
}
return &HomePlayletResponse{}
}
data.SeoInfo.Normalize()
homeCache = data
homeAt = time.Now()
return cloneHome(homeCache)
}
func cloneHome(src *HomePlayletResponse) *HomePlayletResponse {
if src == nil {
return &HomePlayletResponse{}
}
out := *src
if src.Announcements != nil {
out.Announcements = append([]AnnouncementItem(nil), src.Announcements...)
}
if src.HomeBannerData != nil {
out.HomeBannerData = append([]CommonData(nil), src.HomeBannerData...)
}
if src.HomeConfigData != nil {
out.HomeConfigData = make([]HomeConfigData, len(src.HomeConfigData))
for i, cfg := range src.HomeConfigData {
out.HomeConfigData[i] = cfg
if cfg.SeoInfo.Keywords != nil {
out.HomeConfigData[i].SeoInfo.Keywords = append([]string(nil), cfg.SeoInfo.Keywords...)
}
if cfg.List != nil {
out.HomeConfigData[i].List = append([]CommonData(nil), cfg.List...)
}
if cfg.ThemeList != nil {
out.HomeConfigData[i].ThemeList = make([]HomeConfigThemeData, len(cfg.ThemeList))
for j, theme := range cfg.ThemeList {
out.HomeConfigData[i].ThemeList[j] = theme
if theme.List != nil {
out.HomeConfigData[i].ThemeList[j].List = append([]CommonData(nil), theme.List...)
}
}
}
if cfg.VideoList != nil {
out.HomeConfigData[i].VideoList = append([]VideoItemResp(nil), cfg.VideoList...)
}
}
}
if src.HomeTodayUpdateData != nil {
out.HomeTodayUpdateData = append([]CommonData(nil), src.HomeTodayUpdateData...)
}
if src.HomeCategoryData != nil {
out.HomeCategoryData = make([]HomeCategoryData, len(src.HomeCategoryData))
for i, cat := range src.HomeCategoryData {
out.HomeCategoryData[i] = cat
if cat.List != nil {
out.HomeCategoryData[i].List = append([]CommonData(nil), cat.List...)
}
}
}
if src.HomeRecommendThemes != nil {
out.HomeRecommendThemes = append([]HomeRecommendTheme(nil), src.HomeRecommendThemes...)
}
if src.SeoInfo.Keywords != nil {
out.SeoInfo.Keywords = append([]string(nil), src.SeoInfo.Keywords...)
}
return &out
}
// ActiveHomeBanners 过滤未启用 banner;无 showOnBanner 标记时保留全部。
func ActiveHomeBanners(list []CommonData) []CommonData {
if len(list) == 0 {
return list
}
hasFlag := false
for _, item := range list {
if item.ShowOnBanner {
hasFlag = true
break
}
}
if !hasFlag {
return append([]CommonData(nil), list...)
}
out := make([]CommonData, 0, len(list))
for _, item := range list {
if item.ShowOnBanner {
out = append(out, item)
}
}
return out
}
// ActiveHomeConfigs 仅保留上架配置,按接口顺序。
func ActiveHomeConfigs(list []HomeConfigData) []HomeConfigData {
if len(list) == 0 {
return list
}
out := make([]HomeConfigData, 0, len(list))
for _, item := range list {
if !item.Status {
continue
}
out = append(out, item)
}
return out
}
// HomeConfigsByType 上架且 type 匹配的首页配置(保持接口顺序)。
func HomeConfigsByType(list []HomeConfigData, typ int) []HomeConfigData {
out := make([]HomeConfigData, 0, len(list))
for _, item := range ActiveHomeConfigs(list) {
if item.Type == typ {
out = append(out, item)
}
}
return out
}
// FirstHomeConfigSEOByType 返回首页第一个已上架指定类型配置的 TDK。
// 专题更多页没有配置 ID 路径,因此按首页实际展示顺序匹配首个专题配置。
func FirstHomeConfigSEOByType(list []HomeConfigData, typ int) (SeoInfo, bool) {
for _, item := range ActiveHomeConfigs(list) {
if item.Type != typ {
continue
}
seo := item.SeoInfo
seo.Normalize()
return seo, true
}
return SeoInfo{}, false
}
// FindHomeConfigByIdentity 按路由携带的 ID 或 slug 精确查找已上架首页配置。
func FindHomeConfigByIdentity(list []HomeConfigData, id int64, slug string) (HomeConfigData, bool) {
slug = strings.TrimSpace(slug)
for _, item := range ActiveHomeConfigs(list) {
if id > 0 {
if item.ID == id {
return item, true
}
continue
}
if slug != "" && strings.EqualFold(strings.TrimSpace(item.Slug), slug) {
return item, true
}
}
return HomeConfigData{}, false
}
// FindHomeConfigByName 按名称查找上架首页配置(精确匹配 trim 后名称)。
func FindHomeConfigByName(list []HomeConfigData, name string) (HomeConfigData, bool) {
name = strings.TrimSpace(name)
if name == "" {
return HomeConfigData{}, false
}
for _, item := range ActiveHomeConfigs(list) {
if strings.TrimSpace(item.Name) == name {
return item, true
}
}
return HomeConfigData{}, false
}
// MoreListURLByHomeConfigName 生成指定首页配置区块的更多页链接。
func MoreListURLByHomeConfigName(c *gin.Context, name string) string {
cfg, ok := FindHomeConfigByName(FetchHomeOrEmpty(c).HomeConfigData, name)
if !ok || cfg.ID <= 0 {
return "/more-list"
}
return MoreListURL(cfg.Slug, cfg.ID, 0, "", 0, 1)
}
var navMegaIcons = []string{
"/static/images/nav_trend.svg",
"/static/images/nav_zap.svg",
"/static/images/nav_star.svg",
"/static/images/nav_grid.svg",
}
// NavMegaIcon 快捷入口图标,按序号循环。
func NavMegaIcon(index int) string {
if len(navMegaIcons) == 0 {
return "/static/images/nav_star.svg"
}
if index < 0 {
index = 0
}
return navMegaIcons[index%len(navMegaIcons)]
}
+37
View File
@@ -0,0 +1,37 @@
package playletser
import (
"videoweb/app/service/configser"
)
const homeAdsPerBlock = 2
// AdSlice 从 detailbannerList 按偏移取 n 条;用尽后从头循环。仅做切片,不改字段名。
func AdSlice(list []configser.Advertisement, offset, n int) []configser.Advertisement {
ads := usableHomeAds(list)
if len(ads) == 0 || n <= 0 {
return nil
}
if offset < 0 {
offset = 0
}
out := make([]configser.Advertisement, 0, n)
for i := 0; i < n; i++ {
out = append(out, ads[(offset+i)%len(ads)])
}
return out
}
func usableHomeAds(list []configser.Advertisement) []configser.Advertisement {
if len(list) == 0 {
return nil
}
out := make([]configser.Advertisement, 0, len(list))
for _, item := range list {
if item.Images == "" {
continue
}
out = append(out, item)
}
return out
}
+44
View File
@@ -0,0 +1,44 @@
package playletser
import (
"fmt"
"videoweb/app/service/upstream"
"github.com/gin-gonic/gin"
)
const hotLikePath = "/api/app/playlet/hot-like"
// PlayletHotSearchItem 对应 swagger proto.PlayletHotSearchItem。
type PlayletHotSearchItem struct {
Keyword string `json:"keyword"`
Count int64 `json:"count"`
}
// PlayletHotLikeResp 对应 swagger proto.PlayletHotLikeResp。
type PlayletHotLikeResp struct {
HotSearch []PlayletHotSearchItem `json:"hotSearch"`
GuessLike []CommonData `json:"guessLike"`
}
// FetchHotLike 获取前 10 个热搜词及按收藏量排序的 15 部猜你喜欢短剧。
// 文档:GET /api/app/playlet/hot-like → proto.PlayletHotLikeResp
func FetchHotLike(c *gin.Context) (*PlayletHotLikeResp, error) {
var env APIEnvelope[PlayletHotLikeResp]
if err := upstream.GetPublicJSON(c, hotLikePath, &env); err != nil {
return nil, err
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet hot-like code=%d msg=%s tip=%s", env.Code, env.Msg, env.Tip)
}
return &env.Data, nil
}
// FetchHotLikeOrEmpty 失败时返回空热搜与猜你喜欢。
func FetchHotLikeOrEmpty(c *gin.Context) *PlayletHotLikeResp {
data, err := FetchHotLike(c)
if err != nil || data == nil {
return &PlayletHotLikeResp{}
}
return data
}
+83
View File
@@ -0,0 +1,83 @@
package playletser
import (
"fmt"
"net/url"
"strconv"
"videoweb/app/service/upstream"
"videoweb/pub/common/log"
"github.com/gin-gonic/gin"
)
const (
hotRankPath = "/api/app/playlet/hot/rank/list"
defaultHotRankPageSize = 24
// hot/rank/list rankType:1-热播榜,2-新剧榜,3-追剧榜
hotRankHot = 1
hotRankNew = 2
hotRankBinge = 3
)
// HotRankQuery 热榜查询参数。
type HotRankQuery struct {
PageNum int
PageSize int
RankType int
}
// Normalize 校正分页与榜单类型。
func (q *HotRankQuery) Normalize() {
if q.PageNum <= 0 {
q.PageNum = 1
}
if q.PageSize <= 0 {
q.PageSize = defaultHotRankPageSize
}
if q.PageSize > 50 {
q.PageSize = 50
}
switch q.RankType {
case hotRankNew, hotRankBinge:
default:
q.RankType = hotRankHot
}
}
// FetchHotRankList 分页查询短剧热榜。
// 文档:http://172.104.181.99:25319/swagger/index.html#/app短剧相关接口/get_api_app_playlet_hot_rank_list
func FetchHotRankList(c *gin.Context, q HotRankQuery) (*PlayletHotRankListResp, error) {
q.Normalize()
params := url.Values{}
params.Set("pageNum", strconv.Itoa(q.PageNum))
params.Set("pageSize", strconv.Itoa(q.PageSize))
params.Set("rankType", strconv.Itoa(q.RankType))
var env APIEnvelope[PlayletHotRankListResp]
if err := upstream.GetPublicJSON(c, hotRankPath+"?"+params.Encode(), &env); err != nil {
return nil, err
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet hot rank list code=%d msg=%s", env.Code, env.Msg)
}
return &env.Data, nil
}
// FetchHotRankListOrEmpty 失败时返回空榜单。
func FetchHotRankListOrEmpty(c *gin.Context, q HotRankQuery) *PlayletHotRankListResp {
data, err := FetchHotRankList(c, q)
if err != nil {
log.Error("fetch playlet hot rank list failed", log.E(err))
return &PlayletHotRankListResp{PageNum: q.PageNum, PageSize: q.PageSize, RankType: q.RankType}
}
if data == nil {
return &PlayletHotRankListResp{PageNum: q.PageNum, PageSize: q.PageSize, RankType: q.RankType}
}
data.SeoInfo.Normalize()
if data.RankType == 0 {
data.RankType = q.RankType
}
return data
}
+82
View File
@@ -0,0 +1,82 @@
package playletser
import (
"strconv"
"strings"
"github.com/gin-gonic/gin"
)
func hotRankPageURL(rankType, pageNum int) string {
switch rankType {
case hotRankNew, hotRankBinge:
default:
rankType = hotRankHot
}
if pageNum <= 0 {
pageNum = 1
}
path := "/popular-recommend"
if rankType != hotRankHot {
path += "/" + strconv.Itoa(rankType)
}
if pageNum > 1 {
path += "/page/" + strconv.Itoa(pageNum)
}
return path
}
// HotRankPageURL 生成热榜页链接(供模板使用)。
func HotRankPageURL(rankType, pageNum int) string {
return hotRankPageURL(rankType, pageNum)
}
// BuildHotRankTabs 热榜类型 Tab。
func BuildHotRankTabs(q HotRankQuery) []FilterChipVM {
q.Normalize()
return []FilterChipVM{
{Label: "热播榜", URL: hotRankPageURL(hotRankHot, 1), Active: q.RankType == hotRankHot},
{Label: "新剧榜", URL: hotRankPageURL(hotRankNew, 1), Active: q.RankType == hotRankNew},
{Label: "追剧榜", URL: hotRankPageURL(hotRankBinge, 1), Active: q.RankType == hotRankBinge},
}
}
// BuildHotRankPagination 热榜分页。
func BuildHotRankPagination(q HotRankQuery, totalCount int64) PaginationVM {
q.Normalize()
return BuildPagination(func(p int) string {
return hotRankPageURL(q.RankType, p)
}, q.PageNum, q.PageSize, totalCount)
}
// HotRankCanonicalPath 返回热榜筛选和分页对应的唯一规范路径。
func HotRankCanonicalPath(q HotRankQuery) string {
q.Normalize()
return hotRankPageURL(q.RankType, q.PageNum)
}
// ParseHotRankQuery 从路径参数解析热榜筛选。
// 路由:/popular-recommend/ 、/popular-recommend/page/:page/ 、/popular-recommend/:rankType/ 、/popular-recommend/:rankType/page/:page/
func ParseHotRankQuery(c *gin.Context) HotRankQuery {
q := HotRankQuery{PageSize: defaultHotRankPageSize}
if n, err := strconv.Atoi(strings.TrimSpace(c.Param("rankType"))); err == nil {
q.RankType = n
}
if n, err := strconv.Atoi(strings.TrimSpace(c.Param("page"))); err == nil {
q.PageNum = n
}
q.Normalize()
return q
}
// HotRankTabTitle 当前热榜标题。
func HotRankTabTitle(rankType int) string {
switch rankType {
case hotRankNew:
return "新剧榜"
case hotRankBinge:
return "追剧榜"
default:
return "热播榜"
}
}
+35
View File
@@ -0,0 +1,35 @@
package playletser
import (
"fmt"
"videoweb/app/service/upstream"
"github.com/gin-gonic/gin"
)
const likeSetPath = "/api/app/playlet/like/set"
// PlayletLikeSetReq 对应 swagger proto.PlayletLikeSetReq
type PlayletLikeSetReq struct {
ID int64 `json:"id"`
IsLike bool `json:"isLike"`
}
// PlayletLikeSetResp 对应 swagger proto.PlayletLikeSetResp
type PlayletLikeSetResp struct {
ID int64 `json:"id"`
CountLike int64 `json:"countLike"`
IsLike int `json:"isLike"`
}
// LikeSet 设置短剧点赞/取消点赞。
func LikeSet(c *gin.Context, req PlayletLikeSetReq) (*APIEnvelope[PlayletLikeSetResp], error) {
if req.ID <= 0 {
return nil, fmt.Errorf("playlet like invalid id")
}
var env APIEnvelope[PlayletLikeSetResp]
if _, err := upstream.PostJSON(c, likeSetPath, req, &env); err != nil {
return nil, err
}
return &env, nil
}
+355
View File
@@ -0,0 +1,355 @@
package playletser
import (
"fmt"
"net/url"
"sort"
"strconv"
"strings"
"videoweb/app/service/upstream"
"videoweb/pub/common/log"
"github.com/gin-gonic/gin"
)
const (
listPath = "/api/app/playlet/list"
allListPath = "/api/app/playlet/all/list"
themePath = "/api/app/theme/list"
defaultListPageSize = 24
// all/list sortType:1最新 2最热 3收藏最多
allSortNewest = 1
allSortHeat = 2
allSortCollect = 3
// all/list updateStatus:0全部 1连载中 2已完结
allUpdateAll = 0
allUpdateOngoing = 1
allUpdateDone = 2
sortHeat = 1 // 热度优先(旧 playlet/list)
sortTodayUpdate = 2 // 今日更新(旧 playlet/list)
// 站点统一类型:1-非成人 2-成人(与 themeType 一致)。
contentTypeNonAdult = 1
contentTypeAdult = 2
// playlet/list 上游 type 与站点定义相反:1-成人 2-非成人。
upstreamListTypeAdult = 1
upstreamListTypeNonAdult = 2
)
// ListQuery 短剧列表查询参数(旧 playlet/list)。
type ListQuery struct {
PageNum int
PageSize int
SortOrder int
ThemeID int64
ThemeSlug string
Type int
}
// AllListQuery 对应 GET /api/app/playlet/all/list 查询参数。
type AllListQuery struct {
PageNum int
PageSize int
SortType int // 1最新 2最热 3收藏最多
ThemeID int64
ThemeSlug string
UpdateStatus int // 0全部 1连载中 2已完结
}
// Normalize 校正分页与排序默认值。
func (q *ListQuery) Normalize() {
if q.PageNum <= 0 {
q.PageNum = 1
}
if q.PageSize <= 0 {
q.PageSize = defaultListPageSize
}
if q.PageSize > 50 {
q.PageSize = 50
}
if q.SortOrder != sortTodayUpdate {
q.SortOrder = sortHeat
}
if q.ThemeID < 0 {
q.ThemeID = 0
}
q.Type = normalizeContentType(q.Type)
}
// Normalize 校正 all/list 查询参数。
func (q *AllListQuery) Normalize() {
if q.PageNum <= 0 {
q.PageNum = 1
}
if q.PageSize <= 0 {
q.PageSize = defaultListPageSize
}
if q.PageSize > 50 {
q.PageSize = 50
}
switch q.SortType {
case allSortHeat, allSortCollect:
default:
q.SortType = allSortNewest
}
switch q.UpdateStatus {
case allUpdateOngoing, allUpdateDone:
default:
q.UpdateStatus = allUpdateAll
}
if q.ThemeID < 0 {
q.ThemeID = 0
}
q.ThemeSlug = strings.TrimSpace(q.ThemeSlug)
}
// ParseAllListQuery 从路径参数解析 all/list 筛选。
// 路由:/list/ 、/list/:theme/ 、/list/:theme/:updateStatus/:sortType/ 、
//
// /list/:theme/:updateStatus/:sortType/page/:page/
func ParseAllListQuery(c *gin.Context) AllListQuery {
q := AllListQuery{PageSize: defaultListPageSize}
theme := strings.TrimSpace(c.Param("theme"))
if theme != "" {
if decoded, err := url.PathUnescape(theme); err == nil {
theme = strings.TrimSpace(decoded)
}
}
if theme != "" && !strings.EqualFold(theme, "all") {
if id, err := strconv.ParseInt(theme, 10, 64); err == nil && id > 0 {
q.ThemeID = id
} else {
q.ThemeSlug = theme
}
}
if n, err := strconv.Atoi(strings.TrimSpace(c.Param("updateStatus"))); err == nil {
q.UpdateStatus = n
}
if n, err := strconv.Atoi(strings.TrimSpace(c.Param("sortType"))); err == nil {
q.SortType = n
}
if n, err := strconv.Atoi(strings.TrimSpace(c.Param("page"))); err == nil {
q.PageNum = n
}
q.Normalize()
return q
}
// AllListURL 生成列表页筛选链接(纯路径,无 query)。
func AllListURL(themeSlug string, themeID int64, updateStatus, sortType, pageNum int) string {
q := AllListQuery{
PageNum: pageNum,
PageSize: defaultListPageSize,
SortType: sortType,
ThemeID: themeID,
ThemeSlug: themeSlug,
UpdateStatus: updateStatus,
}
q.Normalize()
return q.URL()
}
// URL 输出路径模式:/list/{theme}/{updateStatus}/{sortType}/[page/{n}/]
// theme 优先 slug,无 slug 时才用 id;都没有则为 all。
func (q AllListQuery) URL() string {
q.Normalize()
slug := strings.TrimSpace(q.ThemeSlug)
id := q.ThemeID
if slug != "" {
id = 0
}
segment := pathSegment(slug, id)
if segment == "" {
segment = "all"
}
defaults := q.UpdateStatus == allUpdateAll && q.SortType == allSortNewest
if defaults && q.PageNum <= 1 {
if segment == "all" {
return "/list"
}
return "/list/" + segment
}
path := "/list/" + segment + "/" + strconv.Itoa(q.UpdateStatus) + "/" + strconv.Itoa(q.SortType)
if q.PageNum > 1 {
path += "/page/" + strconv.Itoa(q.PageNum)
}
return path
}
// ResolveAllListTheme 用题材列表补全 slug / id:路径与跳转优先 slug。
func ResolveAllListTheme(q *AllListQuery, themes []PlayletThemeItem) {
if q == nil {
return
}
q.Normalize()
slug := strings.TrimSpace(q.ThemeSlug)
if slug != "" {
for _, t := range themes {
if strings.TrimSpace(t.Slug) == slug {
q.ThemeID = t.ID
q.ThemeSlug = strings.TrimSpace(t.Slug)
return
}
}
return
}
if q.ThemeID > 0 {
if found := FindThemeSlugByID(themes, q.ThemeID); found != "" {
q.ThemeSlug = found
}
}
}
// BuildAllListPagination 列表分页。
func BuildAllListPagination(q AllListQuery, totalCount int64) PaginationVM {
q.Normalize()
return BuildPagination(func(p int) string {
nq := q
nq.PageNum = p
return nq.URL()
}, q.PageNum, q.PageSize, totalCount)
}
// FetchAllList 拉取 GET /api/app/playlet/all/list。
// 文档:http://172.104.181.99:25319/swagger/index.html#/app短剧相关接口/get_api_app_playlet_all_list
func FetchAllList(c *gin.Context, q AllListQuery) (*PlayletAllListResp, error) {
q.Normalize()
params := url.Values{}
params.Set("pageNum", strconv.Itoa(q.PageNum))
params.Set("pageSize", strconv.Itoa(q.PageSize))
params.Set("sortType", strconv.Itoa(q.SortType))
params.Set("updateStatus", strconv.Itoa(q.UpdateStatus))
if q.ThemeSlug != "" {
params.Set("themeSlug", q.ThemeSlug)
} else if q.ThemeID > 0 {
params.Set("themeId", strconv.FormatInt(q.ThemeID, 10))
}
var env APIEnvelope[PlayletAllListResp]
if err := upstream.GetPublicJSON(c, allListPath+"?"+params.Encode(), &env); err != nil {
return nil, err
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet all list code=%d msg=%s", env.Code, env.Msg)
}
return &env.Data, nil
}
// FetchAllListOrEmpty 失败时返回空列表。
func FetchAllListOrEmpty(c *gin.Context, q AllListQuery) *PlayletAllListResp {
data, err := FetchAllList(c, q)
if err != nil {
log.Error("fetch playlet all list failed", log.E(err))
return &PlayletAllListResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
if data == nil {
return &PlayletAllListResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
data.SeoInfo.Normalize()
return data
}
// FetchList 分页查询已上架短剧。
func FetchList(c *gin.Context, q ListQuery) (*PlayletVideoResp, error) {
q.Normalize()
params := url.Values{}
params.Set("pageNum", strconv.Itoa(q.PageNum))
params.Set("pageSize", strconv.Itoa(q.PageSize))
params.Set("sortOrder", strconv.Itoa(q.SortOrder))
if strings.TrimSpace(q.ThemeSlug) != "" {
params.Set("themeSlug", strings.TrimSpace(q.ThemeSlug))
} else if q.ThemeID > 0 {
params.Set("themeId", strconv.FormatInt(q.ThemeID, 10))
} else {
params.Set("type", strconv.Itoa(listTypeForUpstream(q.Type)))
}
var env APIEnvelope[PlayletVideoResp]
if err := upstream.GetPublicJSON(c, listPath+"?"+params.Encode(), &env); err != nil {
return nil, err
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet list code=%d msg=%s", env.Code, env.Msg)
}
return &env.Data, nil
}
// FetchListOrEmpty 失败时返回空列表。
func FetchListOrEmpty(c *gin.Context, q ListQuery) *PlayletVideoResp {
data, err := FetchList(c, q)
if err != nil {
log.Error("fetch playlet list failed", log.E(err))
return &PlayletVideoResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
if data == nil {
return &PlayletVideoResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
data.SeoInfo.Normalize()
return data
}
// FetchThemes 拉取题材列表。
func FetchThemes(c *gin.Context, contentType int) ([]PlayletThemeItem, error) {
contentType = normalizeContentType(contentType)
params := url.Values{}
params.Set("themeType", strconv.Itoa(contentType))
var env APIEnvelope[PlayletThemeListResponse]
if err := upstream.GetPublicJSON(c, themePath+"?"+params.Encode(), &env); err != nil {
return nil, err
}
if env.Code != 200 {
return nil, fmt.Errorf("theme list code=%d msg=%s", env.Code, env.Msg)
}
return env.Data.List, nil
}
// FetchThemesOrEmpty 失败时返回空题材。
func FetchThemesOrEmpty(c *gin.Context, contentType int) []PlayletThemeItem {
list, err := FetchThemes(c, contentType)
if err != nil {
log.Error("fetch theme list failed", log.E(err))
return nil
}
return ActiveThemes(list)
}
// ActiveThemes 仅保留上架题材,按 rank 降序(越大越靠前)。
func ActiveThemes(list []PlayletThemeItem) []PlayletThemeItem {
out := make([]PlayletThemeItem, 0, len(list))
for _, item := range list {
if !item.Status {
continue
}
item.Name = strings.TrimSpace(item.Name)
item.Slug = strings.TrimSpace(item.Slug)
if item.Name == "" || item.ID <= 0 {
continue
}
out = append(out, item)
}
sort.SliceStable(out, func(i, j int) bool {
if out[i].Rank != out[j].Rank {
return out[i].Rank > out[j].Rank
}
return out[i].ID < out[j].ID
})
return out
}
func normalizeContentType(contentType int) int {
if contentType == contentTypeAdult {
return contentTypeAdult
}
return contentTypeNonAdult
}
// listTypeForUpstream 将站点统一类型转为 playlet/list 的 type(该接口 1=成人 2=非成人)。
func listTypeForUpstream(contentType int) int {
if normalizeContentType(contentType) == contentTypeAdult {
return upstreamListTypeAdult
}
return upstreamListTypeNonAdult
}
+254
View File
@@ -0,0 +1,254 @@
package playletser
import (
"strconv"
"strings"
)
// PaginationVM 分页条数据(页面 UI,非接口字段映射)。
type PaginationVM struct {
Visible bool
HasPrev bool
HasNext bool
PrevURL string
NextURL string
Page int
TotalPages int
TotalText string
Items []PaginationItemVM
}
// PaginationItemVM 页码或省略号。
type PaginationItemVM struct {
Label string
URL string
Active bool
Dots bool
}
// FilterChipVM 筛选 / Tab UI。
type FilterChipVM struct {
Label string
URL string
Active bool
}
// ThemeChipVM 题材筛选芯片(ID/Name 来自接口,URL/Active 为页面状态)。
type ThemeChipVM struct {
ID int64 `json:"id"`
Name string `json:"name"`
URL string
Active bool
}
// FindThemeSlugByID 查询 ID 对应的 slug;无 slug 时继续使用 ID 路由。
func FindThemeSlugByID(themes []PlayletThemeItem, id int64) string {
if id <= 0 {
return ""
}
for _, theme := range themes {
if theme.ID == id {
return strings.TrimSpace(theme.Slug)
}
}
return ""
}
func listPageURL(themeID int64, themeSlug string, sortOrder, pageNum, contentType int) string {
if sortOrder != sortTodayUpdate {
sortOrder = sortHeat
}
if pageNum <= 0 {
pageNum = 1
}
cleanSlug := strings.TrimSpace(themeSlug)
id := themeID
if cleanSlug != "" {
id = 0
}
defaultSort := sortHeat
if cleanSlug == "ai-short-play" || cleanSlug == "ai-series" {
defaultSort = sortTodayUpdate
}
if id <= 0 && cleanSlug == "" && sortOrder == sortHeat && pageNum == 1 {
return "/list"
}
path := "/list"
segment := pathSegment(cleanSlug, id)
if segment == "" {
segment = "all"
}
path += "/" + segment + "/" + strconv.Itoa(sortOrder)
if id <= 0 && cleanSlug != "" && sortOrder == defaultSort && pageNum == 1 {
return "/list/" + segment
}
if pageNum > 1 {
path += "/page/" + strconv.Itoa(pageNum)
}
return path
}
// ListCanonicalPath 返回列表页唯一的无 query 规范路径。
func ListCanonicalPath(q ListQuery) string {
q.Normalize()
return listPageURL(q.ThemeID, q.ThemeSlug, q.SortOrder, q.PageNum, q.Type)
}
// ListResetURL 重置筛选并生成无 query 的默认排序路径。
func ListResetURL(q ListQuery) string {
q.Normalize()
return ListCanonicalPath(ListQuery{Type: q.Type})
}
// BuildListThemes 题材芯片;Name/ID 保持接口字段语义。
func BuildListThemes(themes []PlayletThemeItem, q ListQuery) []ThemeChipVM {
q.Normalize()
out := make([]ThemeChipVM, 0, len(themes)+1)
out = append(out, ThemeChipVM{
ID: 0,
Name: "全部",
URL: listPageURL(0, "", q.SortOrder, 1, q.Type),
Active: q.ThemeID == 0 && strings.TrimSpace(q.ThemeSlug) == "",
})
for _, t := range themes {
if !t.Status {
continue
}
name := strings.TrimSpace(t.Name)
if name == "" || t.ID <= 0 {
continue
}
out = append(out, ThemeChipVM{
ID: t.ID,
Name: name,
URL: listPageURL(t.ID, t.Slug, q.SortOrder, 1, q.Type),
Active: q.ThemeID == t.ID || (strings.TrimSpace(q.ThemeSlug) != "" && strings.TrimSpace(q.ThemeSlug) == strings.TrimSpace(t.Slug)),
})
}
return out
}
// BuildListSortChips 排序芯片。
func BuildListSortChips(q ListQuery) (heat, update FilterChipVM) {
q.Normalize()
heat = FilterChipVM{
Label: "热度优先",
URL: listPageURL(q.ThemeID, q.ThemeSlug, sortHeat, 1, q.Type),
Active: q.SortOrder == sortHeat,
}
update = FilterChipVM{
Label: "今日更新",
URL: listPageURL(q.ThemeID, q.ThemeSlug, sortTodayUpdate, 1, q.Type),
Active: q.SortOrder == sortTodayUpdate,
}
return heat, update
}
// BuildListPagination 列表分页。
func BuildListPagination(q ListQuery, totalCount int64) PaginationVM {
q.Normalize()
return BuildPagination(func(p int) string {
return listPageURL(q.ThemeID, q.ThemeSlug, q.SortOrder, p, q.Type)
}, q.PageNum, q.PageSize, totalCount)
}
// BuildPagination 生成分页 VM;pageURL 生成指定页链接。
func BuildPagination(pageURL func(int) string, pageNum, pageSize int, totalCount int64) PaginationVM {
if pageURL == nil {
pageURL = func(int) string { return "#" }
}
if pageNum <= 0 {
pageNum = 1
}
if pageSize <= 0 {
pageSize = defaultListPageSize
}
totalPages := int((totalCount + int64(pageSize) - 1) / int64(pageSize))
if totalPages <= 1 {
return PaginationVM{
Visible: false,
TotalText: "共 " + strconv.FormatInt(totalCount, 10) + " 部",
}
}
if pageNum > totalPages {
pageNum = totalPages
}
return PaginationVM{
Visible: true,
HasPrev: pageNum > 1,
HasNext: pageNum < totalPages,
PrevURL: pageURL(pageNum - 1),
NextURL: pageURL(pageNum + 1),
Page: pageNum,
TotalPages: totalPages,
TotalText: "共 " + strconv.FormatInt(totalCount, 10) + " 部",
Items: buildPageItems(pageNum, totalPages, pageURL),
}
}
func buildPageItems(current, total int, pageURL func(int) string) []PaginationItemVM {
if total <= 0 {
return nil
}
if total <= 7 {
out := make([]PaginationItemVM, 0, total)
for i := 1; i <= total; i++ {
out = append(out, PaginationItemVM{
Label: strconv.Itoa(i),
URL: pageURL(i),
Active: i == current,
})
}
return out
}
addPage := func(out *[]PaginationItemVM, p int) {
*out = append(*out, PaginationItemVM{
Label: strconv.Itoa(p),
URL: pageURL(p),
Active: p == current,
})
}
addDots := func(out *[]PaginationItemVM) {
*out = append(*out, PaginationItemVM{Dots: true, Label: "…"})
}
var out []PaginationItemVM
addPage(&out, 1)
if current > 3 {
addDots(&out)
}
start := current - 1
end := current + 1
if start < 2 {
start = 2
}
if end > total-1 {
end = total - 1
}
for p := start; p <= end; p++ {
addPage(&out, p)
}
if current < total-2 {
addDots(&out)
}
addPage(&out, total)
return out
}
// ParseListQuery 从 gin query 解析列表参数。
func ParseListQuery(pageStr, sortStr, typeStr string) ListQuery {
q := ListQuery{PageSize: defaultListPageSize, SortOrder: sortHeat, Type: contentTypeNonAdult}
if n, err := strconv.Atoi(strings.TrimSpace(pageStr)); err == nil {
q.PageNum = n
}
if n, err := strconv.Atoi(strings.TrimSpace(sortStr)); err == nil {
q.SortOrder = n
}
if n, err := strconv.Atoi(strings.TrimSpace(typeStr)); err == nil {
q.Type = n
}
q.Normalize()
return q
}
+152
View File
@@ -0,0 +1,152 @@
package playletser
import (
"fmt"
"net/url"
"strconv"
"strings"
"videoweb/app/service/upstream"
"videoweb/pub/common/log"
"github.com/gin-gonic/gin"
)
const (
homeConfigDetailListPath = "/api/app/playlet/home/config/detail/list"
defaultMoreListPageSize = 24
// timeRange:0综合 1本周 2本月
moreTimeAll = 0
moreTimeWeek = 1
moreTimeMonth = 2
// operateType type=1:0全部 1短剧 2漫剧
moreOperateAll = 0
moreOperateShort = 1
moreOperateComic = 2
)
// MoreListQuery 首页配置详情列表查询参数。
type MoreListQuery struct {
HomeConfigID int64
HomeConfigSlug string
PageNum int
PageSize int
TimeRange int
ThemeID int64
ThemeSlug string
OperateType int
}
// Normalize 校正分页与筛选默认值。
func (q *MoreListQuery) Normalize() {
if q.HomeConfigID < 0 {
q.HomeConfigID = 0
}
if q.PageNum <= 0 {
q.PageNum = 1
}
if q.PageSize <= 0 {
q.PageSize = defaultMoreListPageSize
}
if q.PageSize > 50 {
q.PageSize = 50
}
switch q.TimeRange {
case moreTimeWeek, moreTimeMonth:
default:
q.TimeRange = moreTimeAll
}
switch q.OperateType {
case moreOperateShort, moreOperateComic:
default:
q.OperateType = moreOperateAll
}
if q.ThemeID < 0 {
q.ThemeID = 0
}
}
// FetchHomeConfigDetailList 分页查询首页配置详情列表。
// 文档:http://172.104.181.99:25319/swagger/index.html#/app短剧相关接口/get_api_app_playlet_home_config_detail_list
func FetchHomeConfigDetailList(c *gin.Context, q MoreListQuery) (*HomeConfigDetailListResp, error) {
q.Normalize()
slug := strings.TrimSpace(q.HomeConfigSlug)
if slug == "" && q.HomeConfigID <= 0 {
return nil, fmt.Errorf("playlet home config detail list missing homeConfigSlug")
}
params := url.Values{}
if slug != "" {
params.Set("homeConfigSlug", slug)
} else {
params.Set("homeConfigId", strconv.FormatInt(q.HomeConfigID, 10))
}
params.Set("pageNum", strconv.Itoa(q.PageNum))
params.Set("pageSize", strconv.Itoa(q.PageSize))
params.Set("timeRange", strconv.Itoa(q.TimeRange))
params.Set("operateType", strconv.Itoa(q.OperateType))
if slug := strings.TrimSpace(q.ThemeSlug); slug != "" && slug != "all" {
params.Set("themeSlug", slug)
} else if q.ThemeID > 0 {
params.Set("themeId", strconv.FormatInt(q.ThemeID, 10))
}
var env APIEnvelope[HomeConfigDetailListResp]
if err := upstream.GetPublicJSON(c, homeConfigDetailListPath+"?"+params.Encode(), &env); err != nil {
return nil, err
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet home config detail list code=%d msg=%s", env.Code, env.Msg)
}
return &env.Data, nil
}
// FetchHomeConfigDetailListOrEmpty 失败时返回空列表。
func FetchHomeConfigDetailListOrEmpty(c *gin.Context, q MoreListQuery) *HomeConfigDetailListResp {
data, err := FetchHomeConfigDetailList(c, q)
if err != nil {
log.Error("fetch playlet home config detail list failed", log.E(err))
return &HomeConfigDetailListResp{
HomeConfigID: q.HomeConfigID,
PageNum: q.PageNum,
PageSize: q.PageSize,
}
}
if data == nil {
return &HomeConfigDetailListResp{
HomeConfigID: q.HomeConfigID,
PageNum: q.PageNum,
PageSize: q.PageSize,
}
}
if data.HomeConfigID == 0 {
data.HomeConfigID = q.HomeConfigID
}
if strings.TrimSpace(data.HomeConfigSlug) == "" {
data.HomeConfigSlug = q.HomeConfigSlug
}
data.SeoInfo.Normalize()
return data
}
// ApplyHomeConfigDetailIdentity 把接口回填的 ID/slug 写回查询参数。
func ApplyHomeConfigDetailIdentity(q *MoreListQuery, raw *HomeConfigDetailListResp) {
if q == nil || raw == nil {
return
}
if raw.HomeConfigID > 0 {
q.HomeConfigID = raw.HomeConfigID
}
if slug := strings.TrimSpace(raw.HomeConfigSlug); slug != "" {
q.HomeConfigSlug = slug
}
}
// MoreListEntityValid 判断更多页对应的首页配置是否存在。
// slug 路由下 URL 没有数字 ID,必须先回填再判定,否则会把有效配置打成 404。
func MoreListEntityValid(q MoreListQuery, name string, total int64) bool {
if q.HomeConfigID <= 0 && strings.TrimSpace(q.HomeConfigSlug) == "" {
return false
}
return strings.TrimSpace(name) != "" || total > 0
}
+177
View File
@@ -0,0 +1,177 @@
package playletser
import (
"strconv"
"strings"
"github.com/gin-gonic/gin"
)
func moreListPageURL(configSlug string, configID int64, timeRange int, themeSlug string, themeID int64, pageNum int) string {
return moreConfigListPageURL("/more-list/", configSlug, configID, timeRange, themeSlug, themeID, pageNum)
}
func moreSeriesListPageURL(configSlug string, configID int64, timeRange int, themeSlug string, themeID int64, pageNum int) string {
return moreConfigListPageURL("/more-series-list/", configSlug, configID, timeRange, themeSlug, themeID, pageNum)
}
func moreConfigListPageURL(prefix, configSlug string, configID int64, timeRange int, themeSlug string, themeID int64, pageNum int) string {
configSeg := pathSegment(configSlug, configID)
if configSeg == "" {
return strings.TrimRight(prefix, "/")
}
if pageNum <= 0 {
pageNum = 1
}
switch timeRange {
case moreTimeWeek, moreTimeMonth:
default:
timeRange = moreTimeAll
}
slug := strings.TrimSpace(themeSlug)
if slug == "all" {
slug = ""
themeID = 0
}
themeSeg := pathSegment(slug, themeID)
if themeSeg == "" {
themeSeg = "all"
}
path := strings.TrimRight(prefix, "/") + "/" + configSeg
defaults := timeRange == moreTimeAll && themeSeg == "all"
if defaults && pageNum <= 1 {
return path
}
if defaults {
return path + "/page/" + strconv.Itoa(pageNum)
}
path += "/" + strconv.Itoa(timeRange) + "/" + themeSeg
if pageNum > 1 {
path += "/page/" + strconv.Itoa(pageNum)
}
return path
}
// MoreListURL 生成首页配置更多页链接(供模板使用),优先 slug。
func MoreListURL(configSlug string, configID int64, timeRange int, themeSlug string, themeID int64, pageNum int) string {
return moreListPageURL(configSlug, configID, timeRange, themeSlug, themeID, pageNum)
}
// MoreSeriesListURL 生成首页影集配置更多页链接(type=2),优先 slug。
func MoreSeriesListURL(configSlug string, configID int64, timeRange int, themeSlug string, themeID int64, pageNum int) string {
return moreSeriesListPageURL(configSlug, configID, timeRange, themeSlug, themeID, pageNum)
}
// MoreListCanonicalPath 返回更多页规范路径。
func MoreListCanonicalPath(q MoreListQuery) string {
q.Normalize()
return moreListPageURL(q.HomeConfigSlug, q.HomeConfigID, q.TimeRange, q.ThemeSlug, q.ThemeID, q.PageNum)
}
// MoreSeriesListCanonicalPath 返回影集更多页规范路径。
func MoreSeriesListCanonicalPath(q MoreListQuery) string {
q.Normalize()
return moreSeriesListPageURL(q.HomeConfigSlug, q.HomeConfigID, q.TimeRange, q.ThemeSlug, q.ThemeID, q.PageNum)
}
// BuildMoreListPagination 更多页分页。
func BuildMoreListPagination(q MoreListQuery, totalCount int64) PaginationVM {
q.Normalize()
return BuildPagination(func(p int) string {
return moreListPageURL(q.HomeConfigSlug, q.HomeConfigID, q.TimeRange, q.ThemeSlug, q.ThemeID, p)
}, q.PageNum, q.PageSize, totalCount)
}
// BuildMoreSeriesListPagination 影集更多页分页。
func BuildMoreSeriesListPagination(q MoreListQuery, totalCount int64) PaginationVM {
q.Normalize()
return BuildPagination(func(p int) string {
return moreSeriesListPageURL(q.HomeConfigSlug, q.HomeConfigID, q.TimeRange, q.ThemeSlug, q.ThemeID, p)
}, q.PageNum, q.PageSize, totalCount)
}
// BuildMoreTimeTabs 时间范围筛选。
func BuildMoreTimeTabs(q MoreListQuery) []FilterChipVM {
q.Normalize()
return []FilterChipVM{
{Label: "综合", URL: moreListPageURL(q.HomeConfigSlug, q.HomeConfigID, moreTimeAll, q.ThemeSlug, q.ThemeID, 1), Active: q.TimeRange == moreTimeAll},
{Label: "本周", URL: moreListPageURL(q.HomeConfigSlug, q.HomeConfigID, moreTimeWeek, q.ThemeSlug, q.ThemeID, 1), Active: q.TimeRange == moreTimeWeek},
{Label: "本月", URL: moreListPageURL(q.HomeConfigSlug, q.HomeConfigID, moreTimeMonth, q.ThemeSlug, q.ThemeID, 1), Active: q.TimeRange == moreTimeMonth},
}
}
// BuildMoreSeriesTimeTabs 影集更多页时间范围筛选。
func BuildMoreSeriesTimeTabs(q MoreListQuery) []FilterChipVM {
q.Normalize()
return []FilterChipVM{
{Label: "综合", URL: moreSeriesListPageURL(q.HomeConfigSlug, q.HomeConfigID, moreTimeAll, q.ThemeSlug, q.ThemeID, 1), Active: q.TimeRange == moreTimeAll},
{Label: "本周", URL: moreSeriesListPageURL(q.HomeConfigSlug, q.HomeConfigID, moreTimeWeek, q.ThemeSlug, q.ThemeID, 1), Active: q.TimeRange == moreTimeWeek},
{Label: "本月", URL: moreSeriesListPageURL(q.HomeConfigSlug, q.HomeConfigID, moreTimeMonth, q.ThemeSlug, q.ThemeID, 1), Active: q.TimeRange == moreTimeMonth},
}
}
// ResolveMoreListTheme 根据题材列表解析 slug/id。
func ResolveMoreListTheme(q *MoreListQuery, themes []PlayletThemeItem) {
if q == nil {
return
}
slug := strings.TrimSpace(q.ThemeSlug)
if slug == "" || slug == "all" {
q.ThemeSlug = ""
if q.ThemeID <= 0 {
return
}
if found := FindThemeSlugByID(themes, q.ThemeID); found != "" {
q.ThemeSlug = found
q.ThemeID = 0
}
return
}
for _, theme := range themes {
if strings.EqualFold(strings.TrimSpace(theme.Slug), slug) {
q.ThemeSlug = theme.Slug
q.ThemeID = 0
return
}
}
if n, err := strconv.ParseInt(slug, 10, 64); err == nil && n > 0 {
q.ThemeID = n
q.ThemeSlug = FindThemeSlugByID(themes, n)
if q.ThemeSlug != "" {
q.ThemeID = 0
}
}
}
// ParseMoreListQuery 从路径参数解析更多页筛选。
// 路由:/more-list/:configId/ 、/more-list/:configId/page/:page/ 、
//
// /more-list/:configId/:timeRange/:theme/ 、/more-list/:configId/:timeRange/:theme/page/:page/
//
// configId 优先按 slug 解析,纯数字时回退为首页配置 ID。
func ParseMoreListQuery(c *gin.Context) MoreListQuery {
q := MoreListQuery{PageSize: defaultMoreListPageSize}
if raw := strings.TrimSpace(c.Param("configId")); raw != "" {
if n, err := strconv.ParseInt(raw, 10, 64); err == nil && n > 0 {
q.HomeConfigID = n
} else {
q.HomeConfigSlug = raw
}
}
if n, err := strconv.Atoi(strings.TrimSpace(c.Param("timeRange"))); err == nil {
q.TimeRange = n
}
if theme := strings.TrimSpace(c.Param("theme")); theme != "" && theme != "all" {
if n, err := strconv.ParseInt(theme, 10, 64); err == nil && n > 0 {
q.ThemeID = n
} else {
q.ThemeSlug = theme
}
}
if n, err := strconv.Atoi(strings.TrimSpace(c.Param("page"))); err == nil {
q.PageNum = n
}
q.Normalize()
return q
}
+81
View File
@@ -0,0 +1,81 @@
package playletser
import (
"fmt"
"net/url"
"strconv"
"videoweb/app/service/upstream"
"videoweb/pub/common/log"
"github.com/gin-gonic/gin"
)
const operateListPath = "/api/app/playlet/operate/list"
type OperateListQuery struct {
OperateType int
FilterType int
PageNum int
PageSize int
}
func (q *OperateListQuery) Normalize() {
if q.OperateType < 1 || q.OperateType > 2 {
q.OperateType = 1
}
if q.FilterType < 1 || q.FilterType > 3 {
q.FilterType = 1
}
if q.PageNum <= 0 {
q.PageNum = 1
}
if q.PageSize <= 0 {
q.PageSize = 40
}
if q.PageSize > 100 {
q.PageSize = 100
}
}
// FetchOperateList 按运营类型和筛选类型查询已上架短剧。
func FetchOperateList(c *gin.Context, q OperateListQuery) (*PlayletOperateListResp, error) {
q.Normalize()
params := url.Values{}
params.Set("operateType", strconv.Itoa(q.OperateType))
params.Set("filterType", strconv.Itoa(q.FilterType))
params.Set("pageNum", strconv.Itoa(q.PageNum))
params.Set("pageSize", strconv.Itoa(q.PageSize))
var env APIEnvelope[PlayletOperateListResp]
if err := upstream.GetPublicJSON(c, operateListPath+"?"+params.Encode(), &env); err != nil {
return nil, err
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet operate list code=%d msg=%s tip=%s", env.Code, env.Msg, env.Tip)
}
return &env.Data, nil
}
// FetchOperateListOrEmpty 为 SSR 页面提供容错,接口异常时仍渲染完整页面骨架。
func FetchOperateListOrEmpty(c *gin.Context, q OperateListQuery) *PlayletOperateListResp {
q.Normalize()
data, err := FetchOperateList(c, q)
if err != nil {
log.Error("fetch playlet operate list failed", log.E(err))
return &PlayletOperateListResp{
OperateType: q.OperateType,
FilterType: q.FilterType,
PageNum: q.PageNum,
PageSize: q.PageSize,
}
}
if data == nil {
return &PlayletOperateListResp{
OperateType: q.OperateType,
FilterType: q.FilterType,
PageNum: q.PageNum,
PageSize: q.PageSize,
}
}
return data
}
+80
View File
@@ -0,0 +1,80 @@
package playletser
import (
"fmt"
"net/url"
"strconv"
"videoweb/app/service/upstream"
"videoweb/pub/common/log"
"github.com/gin-gonic/gin"
)
const (
rankPath = "/api/app/playlet/rank"
defaultRankPageSize = 48
// 排行榜 sortOrder:1-热播榜,2-新剧榜,3-追剧榜
rankSortHot = 1
rankSortNew = 2
rankSortBinge = 3
)
// RankQuery 排行榜查询参数。
type RankQuery struct {
PageNum int
PageSize int
SortOrder int
}
// Normalize 校正分页与榜单类型。
func (q *RankQuery) Normalize() {
if q.PageNum <= 0 {
q.PageNum = 1
}
if q.PageSize <= 0 {
q.PageSize = defaultRankPageSize
}
if q.PageSize > 50 {
q.PageSize = 50
}
switch q.SortOrder {
case rankSortNew, rankSortBinge:
default:
q.SortOrder = rankSortHot
}
}
// FetchRank 分页查询短剧排行榜。
// 文档:http://172.104.181.99:25319/swagger/index.html#/app短剧相关接口/get_api_app_playlet_rank
func FetchRank(c *gin.Context, q RankQuery) (*PlayletVideoResp, error) {
q.Normalize()
params := url.Values{}
params.Set("pageNum", strconv.Itoa(q.PageNum))
params.Set("pageSize", strconv.Itoa(q.PageSize))
params.Set("sortOrder", strconv.Itoa(q.SortOrder))
var env APIEnvelope[PlayletVideoResp]
if err := upstream.GetPublicJSON(c, rankPath+"?"+params.Encode(), &env); err != nil {
return nil, err
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet rank code=%d msg=%s", env.Code, env.Msg)
}
return &env.Data, nil
}
// FetchRankOrEmpty 失败时返回空榜单。
func FetchRankOrEmpty(c *gin.Context, q RankQuery) *PlayletVideoResp {
data, err := FetchRank(c, q)
if err != nil {
log.Error("fetch playlet rank failed", log.E(err))
return &PlayletVideoResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
if data == nil {
return &PlayletVideoResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
data.SeoInfo.Normalize()
return data
}
+111
View File
@@ -0,0 +1,111 @@
package playletser
import (
"fmt"
"strconv"
"strings"
"github.com/gin-gonic/gin"
)
func formatCollectHeat(n int64) string {
if n <= 0 {
return "0 收藏"
}
if n < 10000 {
return fmt.Sprintf("%d 收藏", n)
}
v := float64(n) / 10000
if v >= 100 {
return fmt.Sprintf("%.0f万 收藏", v)
}
return fmt.Sprintf("%.1f万 收藏", v)
}
func rankPageURL(sortOrder, pageNum int) string {
switch sortOrder {
case rankSortNew, rankSortBinge:
default:
sortOrder = rankSortHot
}
if pageNum <= 0 {
pageNum = 1
}
path := "/rank"
if sortOrder != rankSortHot {
path += "/" + strconv.Itoa(sortOrder)
}
if pageNum > 1 {
path += "/page/" + strconv.Itoa(pageNum)
}
return path
}
// BuildRankTabs 排行榜 Tab。
func BuildRankTabs(q RankQuery) []FilterChipVM {
q.Normalize()
return []FilterChipVM{
{Label: "热播榜", URL: rankPageURL(rankSortHot, 1), Active: q.SortOrder == rankSortHot},
{Label: "新剧榜", URL: rankPageURL(rankSortNew, 1), Active: q.SortOrder == rankSortNew},
{Label: "追剧榜", URL: rankPageURL(rankSortBinge, 1), Active: q.SortOrder == rankSortBinge},
}
}
// BuildRankPagination 排行榜分页。
func BuildRankPagination(q RankQuery, totalCount int64) PaginationVM {
q.Normalize()
return BuildPagination(func(p int) string {
return rankPageURL(q.SortOrder, p)
}, q.PageNum, q.PageSize, totalCount)
}
// RankCanonicalPath 返回排行榜筛选和分页对应的唯一规范路径。
func RankCanonicalPath(q RankQuery) string {
q.Normalize()
return rankPageURL(q.SortOrder, q.PageNum)
}
// RankOffset 当前页起始排名偏移(0-based)。
func RankOffset(q RankQuery) int {
q.Normalize()
return (q.PageNum - 1) * q.PageSize
}
// ParseRankQuery 从路径参数解析排行榜筛选。
// 路由:/rank/ 、/rank/page/:page/ 、/rank/:sortOrder/ 、/rank/:sortOrder/page/:page/
func ParseRankQuery(c *gin.Context) RankQuery {
q := RankQuery{PageSize: defaultRankPageSize}
if n, err := strconv.Atoi(strings.TrimSpace(c.Param("sortOrder"))); err == nil {
q.SortOrder = n
}
if n, err := strconv.Atoi(strings.TrimSpace(c.Param("page"))); err == nil {
q.PageNum = n
}
q.Normalize()
return q
}
// RankTabTitle 当前榜单标题。
func RankTabTitle(sortOrder int) string {
switch sortOrder {
case rankSortNew:
return "新剧榜"
case rankSortBinge:
return "追剧榜"
default:
return "热播榜"
}
}
// RankNo 排名展示:01、02…
func RankNo(n int) string {
if n <= 0 {
return "00"
}
return fmt.Sprintf("%02d", n)
}
// IsRankBinge 是否追剧榜(热度展示用 countCollect)。
func IsRankBinge(sortOrder int) bool {
return sortOrder == rankSortBinge
}
+83
View File
@@ -0,0 +1,83 @@
package playletser
import (
"fmt"
"net/url"
"strconv"
"strings"
"videoweb/app/service/upstream"
"videoweb/pub/common/log"
"github.com/gin-gonic/gin"
)
const (
recommendListPath = "/api/app/playlet/list"
defaultRecommendSize = 25
)
// RecommendQuery 专题详情分页参数。
type RecommendQuery struct {
PageNum int
PageSize int
SortOrder int
ThemeID int64
ThemeSlug string
}
// Normalize 校正分页默认值。
func (q *RecommendQuery) Normalize() {
if q.PageNum <= 0 {
q.PageNum = 1
}
if q.PageSize <= 0 {
q.PageSize = defaultRecommendSize
}
if q.PageSize > 100 {
q.PageSize = 100
}
if q.SortOrder != sortTodayUpdate {
q.SortOrder = sortHeat
}
}
func recommendListURL(q RecommendQuery) string {
q.Normalize()
params := url.Values{}
params.Set("pageNum", strconv.Itoa(q.PageNum))
params.Set("pageSize", strconv.Itoa(q.PageSize))
params.Set("sortOrder", strconv.Itoa(q.SortOrder))
if slug := strings.TrimSpace(q.ThemeSlug); slug != "" {
params.Set("themeSlug", slug)
} else if q.ThemeID > 0 {
params.Set("themeId", strconv.FormatInt(q.ThemeID, 10))
}
return recommendListPath + "?" + params.Encode()
}
// FetchRecommendList 按 Swagger 的题材 ID 或 slug 参数分页查询专题短剧。
func FetchRecommendList(c *gin.Context, q RecommendQuery) (*PlayletVideoResp, error) {
var env APIEnvelope[PlayletVideoResp]
if err := upstream.GetPublicJSON(c, recommendListURL(q), &env); err != nil {
return nil, err
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet recommend list code=%d msg=%s", env.Code, env.Msg)
}
return &env.Data, nil
}
// FetchRecommendListOrEmpty 失败时返回空列表。
func FetchRecommendListOrEmpty(c *gin.Context, q RecommendQuery) *PlayletVideoResp {
q.Normalize()
data, err := FetchRecommendList(c, q)
if err != nil {
log.Error("fetch playlet recommend list failed", log.E(err))
return &PlayletVideoResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
if data == nil {
return &PlayletVideoResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
data.SeoInfo.Normalize()
return data
}
+64
View File
@@ -0,0 +1,64 @@
package playletser
import (
"strconv"
"strings"
)
func recommendPageURL(themeID int64, themeSlug string, pageNum int) string {
if pageNum <= 0 {
pageNum = 1
}
path := "/topic-detail"
if segment := pathSegment(themeSlug, themeID); segment != "" {
path += "/" + segment
}
if pageNum > 1 {
path += "/page/" + strconv.Itoa(pageNum)
}
return path
}
func RecommendPagePath(q RecommendQuery) string {
q.Normalize()
return recommendPageURL(q.ThemeID, q.ThemeSlug, q.PageNum)
}
// RecommendThemeTitle 专题页标题:优先题材名称,其次使用列表接口 SEO 标题。
func RecommendThemeTitle(name, seoTitle string, themeID int64) string {
name = strings.TrimSpace(name)
if name != "" {
return name
}
seoTitle = strings.TrimSpace(seoTitle)
if seoTitle != "" {
return seoTitle
}
if themeID > 0 {
return "专题短剧"
}
return "专题推荐"
}
// RecommendCanonicalPath 推荐页 canonical(不含 page)。
func RecommendCanonicalPath(themeID int64, themeSlug string) string {
return recommendPageURL(themeID, themeSlug, 1)
}
// BuildRecommendPagination 推荐列表分页。
func BuildRecommendPagination(q RecommendQuery, totalCount int64) PaginationVM {
q.Normalize()
return BuildPagination(func(p int) string {
return recommendPageURL(q.ThemeID, q.ThemeSlug, p)
}, q.PageNum, q.PageSize, totalCount)
}
// ParseRecommendQuery 从路由解析分页。
func ParseRecommendQuery(pageStr string) RecommendQuery {
q := RecommendQuery{PageSize: defaultRecommendSize, SortOrder: sortHeat}
if n, err := strconv.Atoi(strings.TrimSpace(pageStr)); err == nil {
q.PageNum = n
}
q.Normalize()
return q
}
+176
View File
@@ -0,0 +1,176 @@
package playletser
import (
"fmt"
"net/url"
"strconv"
"strings"
"videoweb/app/service/authser"
"videoweb/app/service/upstream"
"videoweb/pub/common/log"
"github.com/gin-gonic/gin"
)
const (
searchPath = "/api/app/playlet/search"
searchSuggestPath = "/api/app/playlet/search/suggest"
defaultSearchPageSize = 25
)
// SearchQuery 搜索分页参数(上游 query:keyword / pageNum / pageSize)。
type SearchQuery struct {
Keyword string
PageNum int
PageSize int
}
// Normalize 校正分页默认值。
func (q *SearchQuery) Normalize() {
q.Keyword = strings.TrimSpace(q.Keyword)
if q.PageNum <= 0 {
q.PageNum = 1
}
if q.PageSize <= 0 {
q.PageSize = defaultSearchPageSize
}
if q.PageSize > 50 {
q.PageSize = 50
}
}
// FetchSearch ES 分页搜索短剧。
// 文档:GET /api/app/playlet/search → proto.PlayletSearchResp
func FetchSearch(c *gin.Context, q SearchQuery) (*PlayletSearchResp, error) {
q.Normalize()
if q.Keyword == "" {
return nil, fmt.Errorf("playlet search keyword is empty")
}
authser.EnsureGuestOnEnter(c)
env, err := fetchSearchOnce(c, q)
if err != nil {
return nil, err
}
if env.Code != 200 && authser.IsSessionExpiredCode(env.Code) {
if authser.RecoverContentSession(c, env.Code) {
env, err = fetchSearchOnce(c, q)
if err != nil {
return nil, err
}
}
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet search code=%d msg=%s tip=%s", env.Code, env.Msg, env.Tip)
}
return &env.Data, nil
}
func fetchSearchOnce(c *gin.Context, q SearchQuery) (*APIEnvelope[PlayletSearchResp], error) {
params := url.Values{}
params.Set("pageNum", strconv.Itoa(q.PageNum))
params.Set("pageSize", strconv.Itoa(q.PageSize))
params.Set("keyword", q.Keyword)
var env APIEnvelope[PlayletSearchResp]
if err := upstream.GetJSON(c, searchPath+"?"+params.Encode(), &env); err != nil {
return nil, err
}
return &env, nil
}
// FetchSearchOrEmpty 失败时返回空列表。
func FetchSearchOrEmpty(c *gin.Context, q SearchQuery) *PlayletSearchResp {
data, err := FetchSearch(c, q)
if err != nil {
log.Error("fetch playlet search failed", log.E(err))
return &PlayletSearchResp{Keyword: q.Keyword, PageNum: q.PageNum, PageSize: q.PageSize}
}
if data == nil {
return &PlayletSearchResp{Keyword: q.Keyword, PageNum: q.PageNum, PageSize: q.PageSize}
}
return data
}
// FetchSearchSuggest 搜索框下拉联想。
// 文档:GET /api/app/playlet/search/suggest → proto.PlayletSearchSuggestResp
// http://172.104.181.99:25319/swagger/index.html#/app短剧相关接口/get_api_app_playlet_search_suggest
func FetchSearchSuggest(c *gin.Context, keyword string) (*PlayletSearchSuggestResp, error) {
keyword = strings.TrimSpace(keyword)
if keyword == "" {
return nil, fmt.Errorf("playlet search suggest keyword is empty")
}
authser.EnsureGuestOnEnter(c)
env, err := fetchSearchSuggestOnce(c, keyword)
if err != nil {
return nil, err
}
if env.Code != 200 && authser.IsSessionExpiredCode(env.Code) {
if authser.RecoverContentSession(c, env.Code) {
env, err = fetchSearchSuggestOnce(c, keyword)
if err != nil {
return nil, err
}
}
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet search suggest code=%d msg=%s tip=%s", env.Code, env.Msg, env.Tip)
}
return &env.Data, nil
}
func fetchSearchSuggestOnce(c *gin.Context, keyword string) (*APIEnvelope[PlayletSearchSuggestResp], error) {
params := url.Values{}
params.Set("keyword", keyword)
var env APIEnvelope[PlayletSearchSuggestResp]
if err := upstream.GetJSON(c, searchSuggestPath+"?"+params.Encode(), &env); err != nil {
return nil, err
}
return &env, nil
}
// FetchSearchSuggestOrEmpty 失败时返回空列表。
func FetchSearchSuggestOrEmpty(c *gin.Context, keyword string) *PlayletSearchSuggestResp {
data, err := FetchSearchSuggest(c, keyword)
if err != nil {
log.Error("fetch playlet search suggest failed", log.E(err))
return &PlayletSearchSuggestResp{Keyword: strings.TrimSpace(keyword)}
}
if data == nil {
return &PlayletSearchSuggestResp{Keyword: strings.TrimSpace(keyword)}
}
return data
}
func searchPageURL(keyword string, pageNum int) string {
keyword = strings.TrimSpace(keyword)
if keyword == "" {
return "/search"
}
path := "/search/" + url.PathEscape(keyword)
if pageNum > 1 {
path += "/page/" + strconv.Itoa(pageNum)
}
return path
}
func SearchCanonicalPath(q SearchQuery) string {
q.Normalize()
return searchPageURL(q.Keyword, q.PageNum)
}
// BuildSearchPagination 搜索分页。
func BuildSearchPagination(q SearchQuery, totalCount int64) PaginationVM {
q.Normalize()
return BuildPagination(func(p int) string {
return searchPageURL(q.Keyword, p)
}, q.PageNum, q.PageSize, totalCount)
}
// ParseSearchQuery 从站点 query 解析(q → keyword)。
func ParseSearchQuery(qStr, pageStr string) SearchQuery {
q := SearchQuery{PageSize: defaultSearchPageSize, Keyword: strings.TrimSpace(qStr)}
if n, err := strconv.Atoi(strings.TrimSpace(pageStr)); err == nil {
q.PageNum = n
}
q.Normalize()
return q
}
+381
View File
@@ -0,0 +1,381 @@
package playletser
import (
"bytes"
"encoding/json"
"fmt"
"regexp"
"strconv"
"strings"
)
// PageOutOfRange 判断分页是否越界(第 1 页始终合法,即使列表为空)。
func PageOutOfRange(pageNum, pageSize int, totalCount int64) bool {
if pageNum <= 1 {
return false
}
if pageSize <= 0 {
pageSize = defaultListPageSize
}
totalPages := int((totalCount + int64(pageSize) - 1) / int64(pageSize))
if totalPages < 1 {
return true
}
return pageNum > totalPages
}
// PageTitleSuffix 分页标题后缀:第 1 页为空,其余为「 - 第N页」。
func PageTitleSuffix(pageNum int) string {
if pageNum <= 1 {
return ""
}
return fmt.Sprintf(" - 第%d页", pageNum)
}
// PaginatedTitle 为第 2 页及以后追加页码,并避免重复追加。
func PaginatedTitle(title string, pageNum int) string {
title = strings.TrimSpace(title)
if title == "" || pageNum <= 1 {
return title
}
marker := fmt.Sprintf("第%d页", pageNum)
if strings.Contains(title, marker) {
return title
}
return title + PageTitleSuffix(pageNum)
}
// PaginateSeoInfo 统一生成分页页的唯一 title 与 description。
// fallbackDescription 仅在上游未提供 description 时使用。
func PaginateSeoInfo(base SeoInfo, fallbackDescription string, pageNum int) SeoInfo {
base.Normalize()
if pageNum <= 1 {
return base
}
base.Title = PaginatedTitle(base.Title, pageNum)
if base.Description == "" {
base.Description = strings.TrimSpace(fallbackDescription)
}
marker := fmt.Sprintf("第%d页", pageNum)
if base.Description != "" {
if !strings.Contains(base.Description, marker) {
base.Description = strings.TrimRight(base.Description, "。;; ") + " - " + marker
}
}
keywordFound := false
for _, keyword := range base.Keywords {
if strings.EqualFold(strings.TrimSpace(keyword), marker) {
keywordFound = true
break
}
}
if !keywordFound {
base.Keywords = append(base.Keywords, marker)
}
base.Normalize()
return base
}
// UnmarshalJSON 兼容 swagger proto.SeoInfo,并容忍上游别名 / 字符串 keywords。
// 主字段:title、description、keywords[]、canonicalUrl。
func (s *SeoInfo) UnmarshalJSON(raw []byte) error {
if s == nil {
return nil
}
raw = bytes.TrimSpace(raw)
if len(raw) == 0 || bytes.Equal(raw, []byte("null")) {
return nil
}
if raw[0] == '"' {
var encoded string
if err := json.Unmarshal(raw, &encoded); err != nil {
return err
}
encoded = strings.TrimSpace(encoded)
if encoded == "" {
return nil
}
inner := bytes.TrimSpace([]byte(encoded))
if len(inner) == 0 || inner[0] != '{' {
return nil
}
return s.UnmarshalJSON(inner)
}
var aux struct {
Title string `json:"title"`
WebTitle string `json:"webTitle"`
Description string `json:"description"`
WebDescription string `json:"webDescription"`
CanonicalURL string `json:"canonicalUrl"`
Canonical string `json:"canonical"`
WebSiteName string `json:"webSiteName"`
Keywords json.RawMessage `json:"keywords"`
Keyworld json.RawMessage `json:"keyworld"`
WebKeyworld json.RawMessage `json:"webKeyworld"`
}
if err := json.Unmarshal(raw, &aux); err != nil {
return err
}
s.Title = firstNonEmpty(aux.Title, aux.WebTitle)
s.Description = firstNonEmpty(aux.Description, aux.WebDescription)
s.CanonicalURL = firstNonEmpty(aux.CanonicalURL, aux.Canonical)
s.WebSiteName = strings.TrimSpace(aux.WebSiteName)
s.Keywords = decodeKeywordList(aux.Keywords, aux.Keyworld, aux.WebKeyworld)
s.Normalize()
return nil
}
// Normalize 去掉 seoInfo 空白项,保证模板可直接渲染。
func (s *SeoInfo) Normalize() {
if s == nil {
return
}
s.Title = strings.TrimSpace(s.Title)
s.Description = strings.TrimSpace(s.Description)
s.CanonicalURL = strings.TrimSpace(s.CanonicalURL)
s.WebSiteName = strings.TrimSpace(s.WebSiteName)
if len(s.Keywords) == 0 {
return
}
out := make([]string, 0, len(s.Keywords))
seen := make(map[string]struct{}, len(s.Keywords))
for _, k := range s.Keywords {
k = strings.TrimSpace(k)
if k == "" {
continue
}
if _, ok := seen[k]; ok {
continue
}
seen[k] = struct{}{}
out = append(out, k)
}
s.Keywords = out
}
func decodeKeywordList(vals ...json.RawMessage) []string {
for _, raw := range vals {
if items := parseKeywordsRaw(raw); len(items) > 0 {
return items
}
}
return nil
}
func parseKeywordsRaw(raw json.RawMessage) []string {
raw = bytes.TrimSpace(raw)
if len(raw) == 0 || bytes.Equal(raw, []byte("null")) {
return nil
}
switch raw[0] {
case '"':
var s string
if err := json.Unmarshal(raw, &s); err != nil {
return nil
}
return splitKeywordText(s)
case '[':
var anyItems []any
if err := json.Unmarshal(raw, &anyItems); err != nil {
return nil
}
out := make([]string, 0, len(anyItems))
for _, it := range anyItems {
s, ok := it.(string)
if !ok {
continue
}
s = strings.TrimSpace(s)
if s != "" {
out = append(out, s)
}
}
return out
default:
return nil
}
}
func splitKeywordText(s string) []string {
s = strings.TrimSpace(s)
if s == "" {
return nil
}
s = strings.NewReplacer(",", ",", "、", ",", ";", ",", ";", ",").Replace(s)
parts := strings.Split(s, ",")
out := make([]string, 0, len(parts))
for _, p := range parts {
if t := strings.TrimSpace(p); t != "" {
out = append(out, t)
}
}
return out
}
func joinStrings(items []string, sep string) string {
parts := make([]string, 0, len(items))
for _, s := range items {
s = strings.TrimSpace(s)
if s != "" {
parts = append(parts, s)
}
}
return strings.Join(parts, sep)
}
// MergeSeoInfo 按字段合并 SEO:优先 primary,缺失时回退 fallback。
func MergeSeoInfo(primary, fallback SeoInfo) SeoInfo {
out := SeoInfo{
Title: firstNonEmpty(primary.Title, fallback.Title),
Description: firstNonEmpty(primary.Description, fallback.Description),
CanonicalURL: firstNonEmpty(primary.CanonicalURL, fallback.CanonicalURL),
WebSiteName: firstNonEmpty(primary.WebSiteName, fallback.WebSiteName),
}
if len(primary.Keywords) > 0 {
out.Keywords = append([]string(nil), primary.Keywords...)
} else {
out.Keywords = append([]string(nil), fallback.Keywords...)
}
out.Normalize()
return out
}
// SEOSelection 描述页面当前选中的筛选维度,用于生成差异化 TDK。
type SEOSelection struct {
Dimension string
Value string
}
// DifferentiateSeoInfo 按基础 TDK - 选项1 - 选项2 的顺序拼接筛选条件。
func DifferentiateSeoInfo(base SeoInfo, selections []SEOSelection) SeoInfo {
base.Normalize()
normalized := make([]SEOSelection, 0, len(selections))
seen := make(map[string]struct{}, len(selections))
for _, selection := range selections {
dimension := strings.TrimSpace(selection.Dimension)
value := strings.TrimSpace(selection.Value)
if value == "" {
continue
}
key := dimension + "\x00" + value
if _, ok := seen[key]; ok {
continue
}
seen[key] = struct{}{}
normalized = append(normalized, SEOSelection{Dimension: dimension, Value: value})
}
if len(normalized) == 0 {
return base
}
titleValues := make([]string, 0, len(normalized))
descriptionValues := make([]string, 0, len(normalized))
keywords := append([]string(nil), base.Keywords...)
for _, selection := range normalized {
if !strings.Contains(base.Title, selection.Value) {
titleValues = append(titleValues, selection.Value)
}
if !strings.Contains(base.Description, selection.Value) {
descriptionValues = append(descriptionValues, selection.Value)
}
keywords = append(keywords, selection.Value)
}
base.Title = joinSEOParts(base.Title, titleValues)
base.Description = joinSEOParts(base.Description, descriptionValues)
base.Keywords = keywords
base.Normalize()
return base
}
func joinSEOParts(base string, values []string) string {
parts := make([]string, 0, len(values)+1)
if base = strings.TrimSpace(base); base != "" {
parts = append(parts, base)
}
for _, value := range values {
value = strings.TrimSpace(value)
if value != "" {
parts = append(parts, value)
}
}
return strings.Join(parts, " - ")
}
// ResolvePlayPageSEO 播放页 SEO:章节详情 seoInfo 优先,短剧详情作字段级回退。
// description 追加剧名与集数,避免同一短剧的多个播放页生成重复描述。
func ResolvePlayPageSEO(chapter *PlayletChapterInfoResp, playlet *PlayletInfoResp) SeoInfo {
var chapterSEO, playletSEO SeoInfo
if chapter != nil {
chapterSEO = chapter.SeoInfo
}
if playlet != nil {
playletSEO = playlet.SeoInfo
}
seo := MergeSeoInfo(chapterSEO, playletSEO)
seo.Description = resolvePlayPageDescription(seo.Description, chapter, playlet)
return seo
}
func resolvePlayPageDescription(description string, chapter *PlayletChapterInfoResp, playlet *PlayletInfoResp) string {
description = strings.TrimSpace(description)
if description == "" && playlet != nil {
description = firstNonEmpty(playlet.Desc, playlet.Description)
}
if chapter == nil || chapter.CurrentEpisode <= 0 {
return description
}
episode := fmt.Sprintf("第%d集", chapter.CurrentEpisode)
if strings.Contains(description, episode) {
return description
}
title := "本剧"
if playlet != nil && strings.TrimSpace(playlet.Title) != "" {
title = fmt.Sprintf("《%s》", strings.TrimSpace(playlet.Title))
}
suffix := fmt.Sprintf("%s%s高清在线观看。", title, episode)
if description == "" {
return "正在播放" + suffix
}
return strings.TrimRight(description, "。;;,, -") + ";" + suffix
}
// ResolvePlayPageTitle 仅保留包含真实剧名的 SEO 标题,防止站点通用标题覆盖不同短剧。
func ResolvePlayPageTitle(chapter *PlayletChapterInfoResp, playlet *PlayletInfoResp) string {
var chapterTitle, playletTitle, name string
if chapter != nil {
chapterTitle = strings.TrimSpace(chapter.SeoInfo.Title)
}
if playlet != nil {
name = strings.TrimSpace(playlet.Title)
playletTitle = strings.TrimSpace(playlet.SeoInfo.Title)
}
title := firstNonEmpty(name, "在线播放")
for _, candidate := range []string{chapterTitle, playletTitle} {
if candidate != "" && (name == "" || strings.Contains(candidate, name)) {
title = candidate
break
}
}
if chapter != nil && chapter.CurrentEpisode > 0 {
// 剧名中的数字属于作品名称,只在 SEO 的额外文字中识别已有集数。
if title != name {
episodeText := strings.TrimSpace(strings.Replace(title, name, "", 1))
for _, match := range playTitleEpisodePattern.FindAllStringSubmatch(episodeText, -1) {
// 末尾独立数字仅在章节 SEO 中视为集数,避免误判短剧 SEO 中的年份。
if match[3] != "" && title != chapterTitle {
continue
}
n, _ := strconv.Atoi(firstNonEmpty(match[1], match[2], match[3]))
if n == chapter.CurrentEpisode {
return title
}
}
}
return fmt.Sprintf("%s - 第%d集", title, chapter.CurrentEpisode)
}
return title
}
var playTitleEpisodePattern = regexp.MustCompile(`(?i)(?:第\s*([0-9]+)\s*集|\bEP\s*([0-9]+)\b|(?:^|\s)([0-9]+)$)`)
+123
View File
@@ -0,0 +1,123 @@
package playletser
import (
"strconv"
"strings"
)
const (
seriesOperateType = 2
seriesPageSize = 25
seriesFilterLatest = 1
seriesFilterHot = 2
seriesFilterOrigin = 3
)
var seriesFilters = []struct {
Type int
Slug string
Label string
}{
{Type: seriesFilterLatest, Slug: "latest", Label: "最新更新"},
{Type: seriesFilterHot, Slug: "popular", Label: "当前热播"},
{Type: seriesFilterOrigin, Slug: "original", Label: "独家原创"},
}
// ParseSeriesQuery 将语义化筛选路由转换为 Swagger 的 operateType/filterType 参数。
func ParseSeriesQuery(filterSlug, pageStr string) (OperateListQuery, bool) {
filterType, ok := seriesFilterType(filterSlug)
if !ok {
return OperateListQuery{}, false
}
q := OperateListQuery{
OperateType: seriesOperateType,
FilterType: filterType,
PageSize: seriesPageSize,
}
if page, err := strconv.Atoi(strings.TrimSpace(pageStr)); err == nil {
q.PageNum = page
}
q.Normalize()
return q, true
}
func seriesFilterType(slug string) (int, bool) {
slug = strings.TrimSpace(slug)
if slug == "" || slug == "latest" {
return seriesFilterLatest, true
}
for _, filter := range seriesFilters {
if filter.Slug == slug {
return filter.Type, true
}
}
return 0, false
}
func seriesFilterSlug(filterType int) string {
for _, filter := range seriesFilters {
if filter.Type == filterType {
return filter.Slug
}
}
return "latest"
}
func seriesPageURL(filterType, pageNum int) string {
if pageNum <= 0 {
pageNum = 1
}
path := "/series"
if filterType != seriesFilterLatest {
path += "/" + seriesFilterSlug(filterType)
}
if pageNum > 1 {
path += "/page/" + strconv.Itoa(pageNum)
}
return path
}
// SeriesCanonicalPath 返回 AI 成人剧集页唯一规范路径。
func SeriesCanonicalPath(q OperateListQuery) string {
q.Normalize()
return seriesPageURL(q.FilterType, q.PageNum)
}
// BuildSeriesFilterTabs 构建 Figma 中的三个运营筛选项。
func BuildSeriesFilterTabs(q OperateListQuery) []FilterChipVM {
q.Normalize()
out := make([]FilterChipVM, 0, len(seriesFilters))
for _, filter := range seriesFilters {
out = append(out, FilterChipVM{
Label: filter.Label,
URL: seriesPageURL(filter.Type, 1),
Active: q.FilterType == filter.Type,
})
}
return out
}
func SeriesSectionTitle(filterType int) string {
for _, filter := range seriesFilters {
if filter.Type == filterType {
return filter.Label + "的AI成人剧集"
}
}
return "最新更新的AI成人剧集"
}
func BuildSeriesPagination(q OperateListQuery, totalCount int64) PaginationVM {
q.Normalize()
return BuildPagination(func(page int) string {
return seriesPageURL(q.FilterType, page)
}, q.PageNum, q.PageSize, totalCount)
}
// SeriesPathFromLegacyList 将原 /list/ai-series 排序地址映射到新页面。
func SeriesPathFromLegacyList(sortOrder, pageNum int) string {
filterType := seriesFilterLatest
if sortOrder == sortHeat {
filterType = seriesFilterHot
}
return seriesPageURL(filterType, pageNum)
}
+110
View File
@@ -0,0 +1,110 @@
package playletser
import (
"strconv"
"strings"
)
const (
shortPlayOperateType = 1
shortPlayPageSize = 25
)
var shortPlayFilters = []struct {
Type int
Slug string
Label string
}{
{Type: 1, Slug: "latest", Label: "最新更新"},
{Type: 2, Slug: "popular", Label: "当前热播"},
{Type: 3, Slug: "original", Label: "独家原创"},
}
// ParseShortPlayQuery 将短剧页路由转换为 operate/list 的 Swagger 参数。
func ParseShortPlayQuery(filter, page string) (OperateListQuery, bool) {
filterType, ok := shortPlayFilterType(filter)
if !ok {
return OperateListQuery{}, false
}
q := OperateListQuery{
OperateType: shortPlayOperateType,
FilterType: filterType,
PageSize: shortPlayPageSize,
}
if pageNum, err := strconv.Atoi(strings.TrimSpace(page)); err == nil {
q.PageNum = pageNum
}
q.Normalize()
return q, true
}
func shortPlayFilterType(filter string) (int, bool) {
filter = strings.TrimSpace(filter)
switch filter {
case "", "latest", "2":
return 1, true
case "popular", "1":
return 2, true
case "original", "3":
return 3, true
default:
return 0, false
}
}
func shortPlayFilterSlug(filterType int) string {
for _, filter := range shortPlayFilters {
if filter.Type == filterType {
return filter.Slug
}
}
return "latest"
}
func shortPlayPageURL(filterType, pageNum int) string {
if pageNum <= 0 {
pageNum = 1
}
path := "/list/ai-short-play"
if filterType != 1 || pageNum > 1 {
path += "/" + shortPlayFilterSlug(filterType)
}
if pageNum > 1 {
path += "/page/" + strconv.Itoa(pageNum)
}
return path
}
func ShortPlayCanonicalPath(q OperateListQuery) string {
q.Normalize()
return shortPlayPageURL(q.FilterType, q.PageNum)
}
func BuildShortPlayFilterTabs(q OperateListQuery) []FilterChipVM {
q.Normalize()
out := make([]FilterChipVM, 0, len(shortPlayFilters))
for _, filter := range shortPlayFilters {
out = append(out, FilterChipVM{
Label: filter.Label,
URL: shortPlayPageURL(filter.Type, 1),
Active: q.FilterType == filter.Type,
})
}
return out
}
func ShortPlaySectionTitle(filterType int) string {
for _, filter := range shortPlayFilters {
if filter.Type == filterType {
return filter.Label + "的AI成人短剧"
}
}
return "最新更新的AI成人短剧"
}
func BuildShortPlayPagination(q OperateListQuery, totalCount int64) PaginationVM {
q.Normalize()
return BuildPagination(func(page int) string {
return shortPlayPageURL(q.FilterType, page)
}, q.PageNum, q.PageSize, totalCount)
}
+155
View File
@@ -0,0 +1,155 @@
package playletser
import (
"fmt"
"net/url"
"sort"
"strconv"
"strings"
"sync"
"time"
"videoweb/app/service/upstream"
"videoweb/pub/common/log"
"github.com/gin-gonic/gin"
)
const (
tagListPath = "/api/app/playlet/tag/list"
tagOptionsPath = "/api/app/playlet/tag/options"
defaultTagSize = 12
tagOptionsTTL = 60 * time.Second
// tag/list sortType:1最新 2最热 3收藏最多
tagSortNewest = 1
tagSortHeat = 2
tagSortCollect = 3
)
var (
tagOptionsMu sync.Mutex
tagOptionsCache []PlayletTagItem
tagOptionsAt time.Time
)
type TagListQuery struct {
PageNum int
PageSize int
TagID int64
TagSlug string
SortType int // 1最新 2最热 3收藏最多
}
func (q *TagListQuery) Normalize() {
if q.PageNum <= 0 {
q.PageNum = 1
}
if q.PageSize <= 0 {
q.PageSize = defaultTagSize
}
if q.PageSize > 100 {
q.PageSize = 100
}
if q.TagID < 0 {
q.TagID = 0
}
q.TagSlug = strings.TrimSpace(q.TagSlug)
switch q.SortType {
case tagSortHeat, tagSortCollect:
default:
q.SortType = tagSortNewest
}
}
func FetchTagList(c *gin.Context, q TagListQuery) (*PlayletVideoResp, error) {
q.Normalize()
params := url.Values{}
params.Set("pageNum", strconv.Itoa(q.PageNum))
params.Set("pageSize", strconv.Itoa(q.PageSize))
params.Set("sortType", strconv.Itoa(q.SortType))
if slug := strings.TrimSpace(q.TagSlug); slug != "" {
params.Set("tagSlug", slug)
} else if q.TagID > 0 {
params.Set("tagId", strconv.FormatInt(q.TagID, 10))
}
var env APIEnvelope[PlayletVideoResp]
if err := upstream.GetPublicJSON(c, tagListPath+"?"+params.Encode(), &env); err != nil {
return nil, err
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet tag list code=%d msg=%s", env.Code, env.Msg)
}
return &env.Data, nil
}
func FetchTagListOrEmpty(c *gin.Context, q TagListQuery) *PlayletVideoResp {
data, err := FetchTagList(c, q)
if err != nil {
log.Error("fetch playlet tag list failed", log.E(err))
return &PlayletVideoResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
if data == nil {
return &PlayletVideoResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
data.SeoInfo.Normalize()
return data
}
// FetchTagOptions 拉取 GET /api/app/playlet/tag/options(已上架标签,不分页)。
// 文档:http://172.104.181.99:25319/swagger/index.html#/app短剧标签相关接口/get_api_app_playlet_tag_options
func FetchTagOptions(c *gin.Context) (*PlayletTagListResponse, error) {
var env APIEnvelope[PlayletTagListResponse]
if err := upstream.GetPublicJSON(c, tagOptionsPath, &env); err != nil {
return nil, err
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet tag options code=%d msg=%s", env.Code, env.Msg)
}
return &env.Data, nil
}
// FetchTagOptionsOrEmpty 返回上架标签(按 rank 降序);失败时返回空切片。
func FetchTagOptionsOrEmpty(c *gin.Context) []PlayletTagItem {
tagOptionsMu.Lock()
defer tagOptionsMu.Unlock()
if tagOptionsCache != nil && time.Since(tagOptionsAt) < tagOptionsTTL {
return append([]PlayletTagItem(nil), tagOptionsCache...)
}
resp, err := FetchTagOptions(c)
if err != nil {
log.Error("fetch playlet tag options failed", log.E(err))
return nil
}
list := ActiveTagOptions(nil)
if resp != nil {
list = ActiveTagOptions(resp.List)
}
tagOptionsCache = list
tagOptionsAt = time.Now()
return append([]PlayletTagItem(nil), list...)
}
// ActiveTagOptions 仅保留上架标签,按 rank 降序(越大越靠前)。
func ActiveTagOptions(list []PlayletTagItem) []PlayletTagItem {
out := make([]PlayletTagItem, 0, len(list))
for _, item := range list {
if !item.Status {
continue
}
item.Name = strings.TrimSpace(item.Name)
item.Slug = strings.TrimSpace(item.Slug)
if item.Name == "" {
continue
}
out = append(out, item)
}
sort.SliceStable(out, func(i, j int) bool {
if out[i].Rank != out[j].Rank {
return out[i].Rank > out[j].Rank
}
return out[i].ID < out[j].ID
})
return out
}
+291
View File
@@ -0,0 +1,291 @@
package playletser
import (
"net/url"
"strconv"
"strings"
"github.com/gin-gonic/gin"
)
func tagListPageURL(tagID int64, tagSlug string, sortType, pageNum int) string {
if pageNum <= 0 {
pageNum = 1
}
switch sortType {
case tagSortHeat, tagSortCollect:
default:
sortType = tagSortNewest
}
path := "/tags"
if segment := pathSegment(tagSlug, tagID); segment != "" {
path += "/" + segment
}
if sortType == tagSortNewest {
if pageNum > 1 {
path += "/page/" + strconv.Itoa(pageNum)
}
return path
}
path += "/sort/" + strconv.Itoa(sortType)
if pageNum > 1 {
path += "/page/" + strconv.Itoa(pageNum)
}
return path
}
func tagListURL(item CommonData) string {
return cardTag(item).URL
}
func tagListURLByKey(slug string, id int64) string {
if segment := pathSegment(slug, id); segment != "" {
return "/tags/" + segment
}
return ""
}
func themeListURLByKey(slug string, id int64) string {
if segment := pathSegment(slug, id); segment != "" {
return "/list/" + segment
}
return ""
}
// TagListURL 生成标签页筛选链接(纯路径)。
func TagListURL(slug string, id int64, sortType, pageNum int) string {
q := TagListQuery{
TagID: id,
TagSlug: slug,
SortType: sortType,
PageNum: pageNum,
PageSize: defaultTagSize,
}
q.Normalize()
return tagListPageURL(q.TagID, q.TagSlug, q.SortType, q.PageNum)
}
type NamedTag struct {
Name string
URL string
}
func cardTag(item CommonData) NamedTag {
tags := cardTags(item)
if len(tags) > 0 {
return tags[0]
}
return NamedTag{}
}
// cardTags returns at most three distinct labels for a poster card. Regular
// tags keep their API order, followed by theme labels when space remains.
func cardTags(item CommonData) []NamedTag {
out := make([]NamedTag, 0, 3)
seen := make(map[string]struct{}, 3)
appendUnique := func(tags []NamedTag) {
for _, tag := range tags {
name := strings.TrimSpace(tag.Name)
if name == "" {
continue
}
key := strings.ToLower(name)
if _, ok := seen[key]; ok {
continue
}
tag.Name = name
out = append(out, tag)
seen[key] = struct{}{}
if len(out) == 3 {
return
}
}
}
appendUnique(namedTags(item.TagIDs, item.TagNames, item.TagSlugs))
if len(out) < 3 {
appendUnique(namedThemeTags(item.ThemeIDs, item.ThemeNames, item.ThemeSlugs))
}
return out
}
func namedTags(ids []int64, names, slugs []string) []NamedTag {
out := make([]NamedTag, 0, len(names))
for i, name := range names {
name = strings.TrimSpace(name)
if name == "" {
continue
}
item := NamedTag{Name: name}
id := int64(0)
slug := ""
if i < len(ids) {
id = ids[i]
}
if i < len(slugs) {
slug = slugs[i]
}
item.URL = tagListURLByKey(slug, id)
out = append(out, item)
}
return out
}
func namedThemeTags(ids []int64, names, slugs []string) []NamedTag {
out := make([]NamedTag, 0, len(names))
for i, name := range names {
name = strings.TrimSpace(name)
if name == "" {
continue
}
item := NamedTag{Name: name}
id := int64(0)
slug := ""
if i < len(ids) {
id = ids[i]
}
if i < len(slugs) {
slug = slugs[i]
}
item.URL = themeListURLByKey(slug, id)
out = append(out, item)
}
return out
}
func TagListCanonicalPath(q TagListQuery) string {
q.Normalize()
return tagListPageURL(q.TagID, q.TagSlug, q.SortType, q.PageNum)
}
func BuildTagListPagination(q TagListQuery, totalCount int64) PaginationVM {
q.Normalize()
return BuildPagination(func(p int) string {
return tagListPageURL(q.TagID, q.TagSlug, q.SortType, p)
}, q.PageNum, q.PageSize, totalCount)
}
// ParseTagListQuery 从路径参数解析标签列表筛选。
// 路由:/tags/:slug/ 、/tags/:slug/page/:page/ 、
//
// /tags/:slug/sort/:sortType/ 、/tags/:slug/sort/:sortType/page/:page/
func ParseTagListQuery(c *gin.Context) TagListQuery {
q := TagListQuery{PageSize: defaultTagSize}
ident := strings.TrimSpace(c.Param("slug"))
if ident != "" {
if decoded, err := url.PathUnescape(ident); err == nil {
ident = strings.TrimSpace(decoded)
}
}
if id, err := strconv.ParseInt(ident, 10, 64); err == nil && id > 0 {
q.TagID = id
} else {
q.TagSlug = ident
}
if n, err := strconv.Atoi(strings.TrimSpace(c.Param("sortType"))); err == nil {
q.SortType = n
}
if n, err := strconv.Atoi(strings.TrimSpace(c.Param("page"))); err == nil {
q.PageNum = n
}
q.Normalize()
return q
}
// ResolveTagListIdentity 用标签选项补全 slug / id / 名称。
func ResolveTagListIdentity(q *TagListQuery, tags []PlayletTagItem) (name string) {
if q == nil {
return ""
}
q.Normalize()
slug := strings.TrimSpace(q.TagSlug)
if slug != "" {
for _, t := range tags {
if strings.EqualFold(strings.TrimSpace(t.Slug), slug) {
q.TagID = t.ID
q.TagSlug = strings.TrimSpace(t.Slug)
return strings.TrimSpace(t.Name)
}
}
return ""
}
if q.TagID > 0 {
for _, t := range tags {
if t.ID == q.TagID {
q.TagSlug = strings.TrimSpace(t.Slug)
return strings.TrimSpace(t.Name)
}
}
}
return ""
}
// RelatedTagOptions 相关标签(排除当前)。
func RelatedTagOptions(tags []PlayletTagItem, currentID int64, currentSlug string) []PlayletTagItem {
currentSlug = strings.TrimSpace(currentSlug)
out := make([]PlayletTagItem, 0, len(tags))
for _, t := range tags {
if currentID > 0 && t.ID == currentID {
continue
}
if currentSlug != "" && strings.EqualFold(strings.TrimSpace(t.Slug), currentSlug) {
continue
}
out = append(out, t)
}
return out
}
func FindTagNameBySlug(list []CommonData, slug string) string {
slug = strings.TrimSpace(slug)
if slug == "" {
return ""
}
for _, item := range list {
for i, itemSlug := range item.TagSlugs {
if strings.TrimSpace(itemSlug) == slug && i < len(item.TagNames) {
return strings.TrimSpace(item.TagNames[i])
}
}
}
return ""
}
func FindTagName(list []CommonData, tagID int64) string {
if tagID <= 0 {
return ""
}
for _, item := range list {
for i, id := range item.TagIDs {
if id == tagID && i < len(item.TagNames) {
return strings.TrimSpace(item.TagNames[i])
}
}
}
return ""
}
func FindTagSlug(list []CommonData, tagID int64) string {
if tagID <= 0 {
return ""
}
for _, item := range list {
for i, id := range item.TagIDs {
if id == tagID && i < len(item.TagSlugs) {
return strings.TrimSpace(item.TagSlugs[i])
}
}
}
return ""
}
func TagListPageTitle(tagName string, pageNum int, seo SeoInfo) string {
if title := strings.TrimSpace(seo.Title); title != "" {
return title + PageTitleSuffix(pageNum)
}
base := "标签短剧"
if tagName != "" {
base = tagName + "短剧"
}
return base + PageTitleSuffix(pageNum)
}
+72
View File
@@ -0,0 +1,72 @@
package playletser
import (
"strconv"
"strings"
)
const defaultThemeIndexPageSize = 20
// ThemeIndexQuery 专题列表页分页参数。
type ThemeIndexQuery struct {
PageNum int
PageSize int
}
func (q *ThemeIndexQuery) Normalize() {
if q.PageNum <= 0 {
q.PageNum = 1
}
if q.PageSize <= 0 {
q.PageSize = defaultThemeIndexPageSize
}
}
// ParseThemeIndexQuery 从语义化分页路由读取页码。
func ParseThemeIndexQuery(page string) ThemeIndexQuery {
q := ThemeIndexQuery{PageSize: defaultThemeIndexPageSize}
if n, err := strconv.Atoi(strings.TrimSpace(page)); err == nil {
q.PageNum = n
}
q.Normalize()
return q
}
// BuildThemeIndexPage 过滤已启用专题,并按设计稿每页 20 项分页。
func BuildThemeIndexPage(themes []PlayletThemeItem, q ThemeIndexQuery) ([]PlayletThemeItem, int64) {
q.Normalize()
visible := make([]PlayletThemeItem, 0, len(themes))
for _, theme := range themes {
if !theme.Status || theme.ID <= 0 || strings.TrimSpace(theme.Name) == "" {
continue
}
visible = append(visible, theme)
}
total := int64(len(visible))
start := (q.PageNum - 1) * q.PageSize
if start >= len(visible) {
return nil, total
}
end := start + q.PageSize
if end > len(visible) {
end = len(visible)
}
return visible[start:end], total
}
func themeIndexPageURL(page int) string {
if page <= 1 {
return "/topic"
}
return "/topic/page/" + strconv.Itoa(page)
}
func ThemeIndexCanonicalPath(q ThemeIndexQuery) string {
q.Normalize()
return themeIndexPageURL(q.PageNum)
}
func BuildThemeIndexPagination(q ThemeIndexQuery, totalCount int64) PaginationVM {
q.Normalize()
return BuildPagination(themeIndexPageURL, q.PageNum, q.PageSize, totalCount)
}
+67
View File
@@ -0,0 +1,67 @@
package playletser
import (
"fmt"
"net/url"
"strconv"
"videoweb/app/service/upstream"
"videoweb/pub/common/log"
"github.com/gin-gonic/gin"
)
const (
todayUpdatePath = "/api/app/playlet/today-update"
defaultTodayUpdateSize = 40
)
// TodayUpdateQuery 今日更新分页参数。
type TodayUpdateQuery struct {
PageNum int
PageSize int
}
// Normalize 校正分页默认值。
func (q *TodayUpdateQuery) Normalize() {
if q.PageNum <= 0 {
q.PageNum = 1
}
if q.PageSize <= 0 {
q.PageSize = defaultTodayUpdateSize
}
if q.PageSize > 50 {
q.PageSize = 50
}
}
// FetchTodayUpdate 分页查询今日更新短剧。
// 文档:http://172.104.181.99:25319/swagger/index.html#/app短剧相关接口/get_api_app_playlet_today_update
func FetchTodayUpdate(c *gin.Context, q TodayUpdateQuery) (*PlayletVideoResp, error) {
q.Normalize()
params := url.Values{}
params.Set("pageNum", strconv.Itoa(q.PageNum))
params.Set("pageSize", strconv.Itoa(q.PageSize))
var env APIEnvelope[PlayletVideoResp]
if err := upstream.GetPublicJSON(c, todayUpdatePath+"?"+params.Encode(), &env); err != nil {
return nil, err
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet today-update code=%d msg=%s", env.Code, env.Msg)
}
return &env.Data, nil
}
// FetchTodayUpdateOrEmpty 失败时返回空列表。
func FetchTodayUpdateOrEmpty(c *gin.Context, q TodayUpdateQuery) *PlayletVideoResp {
data, err := FetchTodayUpdate(c, q)
if err != nil {
log.Error("fetch playlet today-update failed", log.E(err))
return &PlayletVideoResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
if data == nil {
return &PlayletVideoResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
data.SeoInfo.Normalize()
return data
}
@@ -0,0 +1,36 @@
package playletser
import (
"strconv"
"strings"
)
func todayUpdatePageURL(pageNum int) string {
if pageNum <= 1 {
return "/recently-added"
}
return "/recently-added/page/" + strconv.Itoa(pageNum)
}
func TodayUpdateCanonicalPath(q TodayUpdateQuery) string {
q.Normalize()
return todayUpdatePageURL(q.PageNum)
}
// BuildTodayUpdatePagination 今日更新分页。
func BuildTodayUpdatePagination(q TodayUpdateQuery, totalCount int64) PaginationVM {
q.Normalize()
return BuildPagination(func(p int) string {
return todayUpdatePageURL(p)
}, q.PageNum, q.PageSize, totalCount)
}
// ParseTodayUpdateQuery 从 query 解析分页。
func ParseTodayUpdateQuery(pageStr string) TodayUpdateQuery {
q := TodayUpdateQuery{PageSize: defaultTodayUpdateSize}
if n, err := strconv.Atoi(strings.TrimSpace(pageStr)); err == nil {
q.PageNum = n
}
q.Normalize()
return q
}
+218
View File
@@ -0,0 +1,218 @@
package playletser
import (
"fmt"
"net/url"
"strconv"
"strings"
"videoweb/app/service/upstream"
"videoweb/pub/common/log"
"github.com/gin-gonic/gin"
)
const (
topicDetailPath = "/api/app/playlet/topic/detail"
defaultTopicDetailPageSize = 24
// topic/detail sortType:1编辑排序 2最新 3最热
topicDetailSortEditor = 1
topicDetailSortNewest = 2
topicDetailSortHeat = 3
)
// TopicDetailQuery 对应 GET /api/app/playlet/topic/detail 查询参数。
// 上游必填 id;路径优先 slug,服务端解析后再请求。
type TopicDetailQuery struct {
ID int64
Slug string
PageNum int
PageSize int
SortType int // 1编辑排序 2最新 3最热
}
// Normalize 校正分页与排序默认值。
func (q *TopicDetailQuery) Normalize() {
if q.PageNum <= 0 {
q.PageNum = 1
}
if q.PageSize <= 0 {
q.PageSize = defaultTopicDetailPageSize
}
if q.PageSize > 50 {
q.PageSize = 50
}
switch q.SortType {
case topicDetailSortNewest, topicDetailSortHeat:
default:
q.SortType = topicDetailSortEditor
}
if q.ID < 0 {
q.ID = 0
}
q.Slug = strings.TrimSpace(q.Slug)
}
// ParseTopicDetailQuery 从路径参数解析专题详情筛选。
// 路由:/topic-detail/:slug/ 、/topic-detail/:slug/page/:page/ 、
//
// /topic-detail/:slug/sort/:sortType/ 、/topic-detail/:slug/sort/:sortType/page/:page/
func ParseTopicDetailQuery(c *gin.Context) TopicDetailQuery {
q := TopicDetailQuery{PageSize: defaultTopicDetailPageSize}
ident := strings.TrimSpace(c.Param("slug"))
if ident != "" {
if decoded, err := url.PathUnescape(ident); err == nil {
ident = strings.TrimSpace(decoded)
}
}
if id, err := strconv.ParseInt(ident, 10, 64); err == nil && id > 0 {
q.ID = id
} else {
q.Slug = ident
}
if n, err := strconv.Atoi(strings.TrimSpace(c.Param("sortType"))); err == nil {
q.SortType = n
}
if n, err := strconv.Atoi(strings.TrimSpace(c.Param("page"))); err == nil {
q.PageNum = n
}
q.Normalize()
return q
}
// TopicDetailURL 生成专题详情筛选链接(纯路径,无 query)。
func TopicDetailURL(slug string, id int64, sortType, pageNum int) string {
q := TopicDetailQuery{
ID: id,
Slug: slug,
PageNum: pageNum,
PageSize: defaultTopicDetailPageSize,
SortType: sortType,
}
q.Normalize()
return q.URL()
}
// URL 输出:/topic-detail/{slug|id}/[sort/{s}/][page/{n}/]
func (q TopicDetailQuery) URL() string {
q.Normalize()
segment := pathSegment(q.Slug, q.ID)
if segment == "" {
return "/topic"
}
base := "/topic-detail/" + segment
if q.SortType == topicDetailSortEditor {
if q.PageNum <= 1 {
return base
}
return base + "/page/" + strconv.Itoa(q.PageNum)
}
path := base + "/sort/" + strconv.Itoa(q.SortType)
if q.PageNum > 1 {
path += "/page/" + strconv.Itoa(q.PageNum)
}
return path
}
// BuildTopicDetailPagination 专题详情作品分页。
func BuildTopicDetailPagination(q TopicDetailQuery, totalCount int64) PaginationVM {
q.Normalize()
return BuildPagination(func(p int) string {
nq := q
nq.PageNum = p
return nq.URL()
}, q.PageNum, q.PageSize, totalCount)
}
// ResolveTopicDetailID 路径为 slug 时,用专题列表解析上游必填 id。
func ResolveTopicDetailID(c *gin.Context, q *TopicDetailQuery) {
if q == nil || q.ID > 0 {
return
}
q.Normalize()
slug := q.Slug
if slug == "" {
return
}
for page := 1; page <= 5; page++ {
raw := FetchTopicListOrEmpty(c, TopicListQuery{
PageNum: page,
PageSize: 50,
SortType: topicSortNewest,
})
for _, item := range raw.List {
if strings.EqualFold(strings.TrimSpace(item.Slug), slug) {
q.ID = item.ID
q.Slug = strings.TrimSpace(item.Slug)
return
}
}
if len(raw.List) == 0 || int64(page*50) >= raw.TotalCount {
return
}
}
}
// FetchTopicDetail 拉取 GET /api/app/playlet/topic/detail。
// 文档:http://172.104.181.99:25319/swagger/index.html#/app短剧相关接口/get_api_app_playlet_topic_detail
func FetchTopicDetail(c *gin.Context, q TopicDetailQuery) (*PlayletTopicDetailResp, error) {
q.Normalize()
if q.ID <= 0 {
return nil, fmt.Errorf("playlet topic detail missing id")
}
params := url.Values{}
params.Set("id", strconv.FormatInt(q.ID, 10))
params.Set("pageNum", strconv.Itoa(q.PageNum))
params.Set("pageSize", strconv.Itoa(q.PageSize))
params.Set("sortType", strconv.Itoa(q.SortType))
var env APIEnvelope[PlayletTopicDetailResp]
if err := upstream.GetPublicJSON(c, topicDetailPath+"?"+params.Encode(), &env); err != nil {
return nil, err
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet topic detail code=%d msg=%s", env.Code, env.Msg)
}
return &env.Data, nil
}
// FetchTopicDetailOrEmpty 失败时返回空详情。
func FetchTopicDetailOrEmpty(c *gin.Context, q TopicDetailQuery) *PlayletTopicDetailResp {
data, err := FetchTopicDetail(c, q)
if err != nil {
log.Error("fetch playlet topic detail failed", log.E(err))
return &PlayletTopicDetailResp{ID: q.ID, Slug: q.Slug, PageNum: q.PageNum, PageSize: q.PageSize}
}
if data == nil {
return &PlayletTopicDetailResp{ID: q.ID, Slug: q.Slug, PageNum: q.PageNum, PageSize: q.PageSize}
}
data.SeoInfo.Normalize()
return data
}
// TopicDetailCoverURLs 专题详情顶部封面,最多 3 张。
func TopicDetailCoverURLs(detail PlayletTopicDetailResp) []string {
return TopicCoverURLs(PlayletTopicPageItem{Covers: detail.Covers, List: detail.List})
}
// TopicDetailHeroCover 头图背景用第一张封面。
func TopicDetailHeroCover(detail PlayletTopicDetailResp) string {
covers := TopicDetailCoverURLs(detail)
if len(covers) == 0 {
return ""
}
return covers[0]
}
// TopicDetailSortLabel 排序文案。
func TopicDetailSortLabel(sortType int) string {
switch sortType {
case topicDetailSortNewest:
return "最新"
case topicDetailSortHeat:
return "最热"
default:
return "编辑排序"
}
}
+167
View File
@@ -0,0 +1,167 @@
package playletser
import (
"fmt"
"net/url"
"strconv"
"strings"
"videoweb/app/service/upstream"
"videoweb/pub/common/log"
"github.com/gin-gonic/gin"
)
const (
topicListPath = "/api/app/playlet/topic/list"
defaultTopicListPageSize = 12
// topic/list sortType:1最新 2最热
topicSortNewest = 1
topicSortHeat = 2
)
// TopicListQuery 对应 GET /api/app/playlet/topic/list 查询参数。
type TopicListQuery struct {
PageNum int
PageSize int
SortType int // 1最新 2最热
}
// Normalize 校正分页与排序默认值。
func (q *TopicListQuery) Normalize() {
if q.PageNum <= 0 {
q.PageNum = 1
}
if q.PageSize <= 0 {
q.PageSize = defaultTopicListPageSize
}
if q.PageSize > 50 {
q.PageSize = 50
}
if q.SortType != topicSortHeat {
q.SortType = topicSortNewest
}
}
// ParseTopicListQuery 从路径参数解析专题剧单筛选。
// 路由:/topic/ 、/topic/page/:page/ 、/topic/sort/:sortType/ 、
//
// /topic/sort/:sortType/page/:page/
func ParseTopicListQuery(c *gin.Context) TopicListQuery {
q := TopicListQuery{PageSize: defaultTopicListPageSize}
if n, err := strconv.Atoi(strings.TrimSpace(c.Param("sortType"))); err == nil {
q.SortType = n
}
if n, err := strconv.Atoi(strings.TrimSpace(c.Param("page"))); err == nil {
q.PageNum = n
}
q.Normalize()
return q
}
// TopicListURL 生成专题剧单页筛选链接(纯路径,无 query)。
func TopicListURL(sortType, pageNum int) string {
q := TopicListQuery{
PageNum: pageNum,
PageSize: defaultTopicListPageSize,
SortType: sortType,
}
q.Normalize()
return q.URL()
}
// URL 输出路径:/topic/ 、/topic/page/{n}/ 、/topic/sort/{s}/ 、/topic/sort/{s}/page/{n}/
func (q TopicListQuery) URL() string {
q.Normalize()
if q.SortType == topicSortNewest {
if q.PageNum <= 1 {
return "/topic"
}
return "/topic/page/" + strconv.Itoa(q.PageNum)
}
path := "/topic/sort/" + strconv.Itoa(q.SortType)
if q.PageNum > 1 {
path += "/page/" + strconv.Itoa(q.PageNum)
}
return path
}
// BuildTopicListPagination 专题剧单分页。
func BuildTopicListPagination(q TopicListQuery, totalCount int64) PaginationVM {
q.Normalize()
return BuildPagination(func(p int) string {
nq := q
nq.PageNum = p
return nq.URL()
}, q.PageNum, q.PageSize, totalCount)
}
// FetchTopicList 拉取 GET /api/app/playlet/topic/list。
// 文档:http://172.104.181.99:25319/swagger/index.html#/app短剧相关接口/get_api_app_playlet_topic_list
func FetchTopicList(c *gin.Context, q TopicListQuery) (*PlayletTopicPageListResp, error) {
q.Normalize()
params := url.Values{}
params.Set("pageNum", strconv.Itoa(q.PageNum))
params.Set("pageSize", strconv.Itoa(q.PageSize))
params.Set("sortType", strconv.Itoa(q.SortType))
var env APIEnvelope[PlayletTopicPageListResp]
if err := upstream.GetPublicJSON(c, topicListPath+"?"+params.Encode(), &env); err != nil {
return nil, err
}
if env.Code != 200 {
return nil, fmt.Errorf("playlet topic list code=%d msg=%s", env.Code, env.Msg)
}
return &env.Data, nil
}
// FetchTopicListOrEmpty 失败时返回空列表。
func FetchTopicListOrEmpty(c *gin.Context, q TopicListQuery) *PlayletTopicPageListResp {
data, err := FetchTopicList(c, q)
if err != nil {
log.Error("fetch playlet topic list failed", log.E(err))
return &PlayletTopicPageListResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
if data == nil {
return &PlayletTopicPageListResp{PageNum: q.PageNum, PageSize: q.PageSize}
}
data.SeoInfo.Normalize()
return data
}
// TopicCoverURLs 取专题展示封面,优先 covers,不足时用 list.cover 补齐,最多 3 张。
func TopicCoverURLs(item PlayletTopicPageItem) []string {
out := make([]string, 0, 3)
for _, cover := range item.Covers {
cover = strings.TrimSpace(cover)
if cover == "" {
continue
}
out = append(out, cover)
if len(out) >= 3 {
return out
}
}
for _, playlet := range item.List {
cover := strings.TrimSpace(playlet.Cover)
if cover == "" {
continue
}
dup := false
for _, existing := range out {
if existing == cover {
dup = true
break
}
}
if dup {
continue
}
out = append(out, cover)
if len(out) >= 3 {
break
}
}
return out
}
+488
View File
@@ -0,0 +1,488 @@
package playletser
import (
"fmt"
"html/template"
"net/url"
"strings"
"time"
"videoweb/app/service/configser"
)
// TemplateFuncs 模板辅助:仅做展示格式化 / URL,不把接口字段映射成另一套名字。
func TemplateFuncs() template.FuncMap {
return template.FuncMap{
"detailURL": detailURL,
"playURL": playURL,
"chapterPlayURL": chapterPlayURL,
"categoryURL": categoryURL,
"categoryDetailURL": categoryDetailURL,
"themeListURL": themeListURLByKey,
"tagOptionsURL": tagListURLByKey,
"allListURL": AllListURL,
"moreListURL": MoreListURL,
"moreSeriesListURL": MoreSeriesListURL,
"navMegaIcon": NavMegaIcon,
"topicListURL": TopicListURL,
"topicDetailURL": TopicDetailURL,
"topicCoverURLs": TopicCoverURLs,
"tagPageURL": TagListURL,
"hotRankPageURL": HotRankPageURL,
"searchResultsURL": SearchResultsURL,
"coverURL": coverURL,
"formatHeat": formatHeat,
"formatCollect": formatCollectHeat,
"formatLikeCount": formatLikeCount,
"formatMediaTime": formatMediaTime,
"playletDisplayName": playletDisplayName,
"rankNo": RankNo,
"episodeLabel": episodeText,
"displayTag": displayTag,
"firstTagName": firstTagName,
"themeTagText": themeTagText,
"tagListURL": tagListURL,
"cardTag": cardTag,
"cardTags": cardTags,
"namedTags": namedTags,
"namedThemeTags": namedThemeTags,
"firstName": firstName,
"rankClass": rankClass,
"add": addInt,
"mod": modInt,
"contains": strings.Contains,
"hasPrefix": strings.HasPrefix,
"footerLinkURL": footerLinkURL,
"footerLinkIsExternal": footerLinkIsExternal,
"externalLinkAttrs": externalLinkAttrs,
"footerContactURL": footerContactURL,
"footerContactName": footerContactName,
"footerContactValue": footerContactValue,
"navDisplayURL": navDisplayURL,
"urlquery": url.QueryEscape,
"pathescape": url.PathEscape,
"metaLine": metaLine,
"adSlice": AdSlice,
"cssCover": cssCover,
"cssCoverPlaceholder": cssCoverPlaceholder,
"updateStatusText": updateStatusText,
"browseText": browseText,
"usableAnchor": usableAnchor,
"playletYearText": playletYearText,
"playletDateText": playletDateText,
"isPlayletAllFree": isPlayletAllFree,
"collectProgressText": collectProgressText,
"collectTagText": collectTagText,
"chapterCollectEpisodeLabel": chapterCollectEpisodeLabel,
"chapterCollectDesc": chapterCollectDesc,
"chapterCollectMeta": chapterCollectMeta,
"historyProgressText": historyProgressText,
"historyWatchLine": historyWatchLine,
"historyTagText": historyTagText,
"historyPlayURL": historyPlayURL,
"historyContinueMeta": historyContinueMeta,
"historyProgressPct": historyProgressPct,
"historyStatus": historyStatus,
"formatHistoryAt": formatHistoryAt,
"formatShortDateTime": formatShortDateTime,
"absInt64": absInt64Tpl,
"absURL": absURLTpl,
"canonicalOr": canonicalOr,
"joinStrings": joinStrings,
"dict": dict,
}
}
// dict builds a map for nested template calls: {{template "x" dict "K" v}}.
func dict(values ...interface{}) (map[string]interface{}, error) {
if len(values)%2 != 0 {
return nil, fmt.Errorf("dict requires an even number of arguments")
}
out := make(map[string]interface{}, len(values)/2)
for i := 0; i < len(values); i += 2 {
key, ok := values[i].(string)
if !ok {
return nil, fmt.Errorf("dict keys must be strings")
}
out[key] = values[i+1]
}
return out, nil
}
func navDisplayURL(raw string) string {
value := strings.TrimSpace(raw)
value = strings.TrimPrefix(value, "https://")
value = strings.TrimPrefix(value, "http://")
return strings.TrimRight(value, "/")
}
// footerLinkURL 按配置地址跳转:/richtext/xxx 进入富文本页,http 开头视为外链原样返回。
func footerLinkURL(name, raw string) string {
raw = strings.TrimSpace(raw)
if raw == "" || raw == "/" || raw == "#" {
return ""
}
if footerLinkIsExternal(raw) {
return raw
}
if href := footerRichtextHref(name, raw); href != "" {
return href
}
return normalizeFooterInternalURL(raw)
}
func footerLinkIsExternal(raw string) bool {
return isExternalWebURL(raw)
}
// externalLinkAttrs 为运行时配置的站外网页链接补齐统一的打开方式和 SEO 关系。
// 返回固定属性而不是拼接用户输入,避免配置值进入 HTML 属性上下文。
func externalLinkAttrs(raw string) template.HTMLAttr {
if !isExternalWebURL(raw) {
return ""
}
return template.HTMLAttr(`target="_blank" rel="sponsored nofollow noopener"`)
}
func isExternalWebURL(raw string) bool {
value := strings.ToLower(strings.TrimSpace(raw))
return strings.HasPrefix(value, "http://") ||
strings.HasPrefix(value, "https://") ||
strings.HasPrefix(value, "//")
}
func footerRichtextHref(name, raw string) string {
path := raw
if i := strings.IndexAny(raw, "?#"); i >= 0 {
path = raw[:i]
}
path = strings.TrimRight(strings.TrimSpace(path), "/")
if path == "/richtext" {
return "/richtext"
}
if strings.HasPrefix(path, "/richtext/") {
title := strings.TrimPrefix(path, "/richtext/")
if decoded, err := url.PathUnescape(title); err == nil {
title = decoded
}
if semanticPath, ok := configser.RichTextSemanticHref(name); ok {
return semanticPath
}
return configser.RichTextHref(title)
}
return ""
}
func normalizeFooterInternalURL(raw string) string {
parsed, err := url.Parse(raw)
if err != nil {
return raw
}
if parsed.Scheme != "" || parsed.Host != "" || !strings.HasPrefix(parsed.Path, "/") {
return raw
}
if parsed.Path != "/" && strings.HasSuffix(parsed.Path, "/") {
parsed.Path = strings.TrimRight(parsed.Path, "/")
href := parsed.Path
if parsed.RawQuery != "" {
href += "?" + parsed.RawQuery
}
if parsed.Fragment != "" {
href += "#" + parsed.Fragment
}
return href
}
return raw
}
// footerContactURL 把页脚联系方式转换为可点击地址,并使用全站配置补齐按钮型文案。
func footerContactURL(name, value, gmailAddr, tgGroup, customerServiceHost string) string {
normalizedName := strings.ToLower(strings.ReplaceAll(footerContactName(name), " ", ""))
switch {
case strings.Contains(normalizedName, "官方群") || strings.Contains(normalizedName, "telegram") || strings.Contains(normalizedName, "tg群"):
return firstContactURL(tgGroup, value)
case strings.Contains(normalizedName, "商务") || strings.Contains(normalizedName, "合作"):
return firstContactURL(customerServiceHost, value, gmailAddr)
case strings.Contains(normalizedName, "邮箱") || strings.Contains(normalizedName, "email") || strings.Contains(normalizedName, "e-mail"):
return firstContactURL(value, gmailAddr)
default:
return firstContactURL(value)
}
}
func footerContactName(name string) string {
return cleanFooterContactAction(name)
}
func footerContactValue(value string) string {
return cleanFooterContactAction(value)
}
func cleanFooterContactAction(value string) string {
value = strings.TrimSpace(value)
for _, action := range []string{"立即联系", "立即加入"} {
value = strings.ReplaceAll(value, action, "")
}
for {
cleaned := strings.TrimSpace(strings.Trim(value, "::"))
if cleaned == value {
return cleaned
}
value = cleaned
}
}
func firstContactURL(values ...string) string {
for _, value := range values {
if href := normalizeContactURL(value); href != "" {
return href
}
}
return ""
}
func normalizeContactURL(value string) string {
value = footerContactValue(value)
if value == "" || strings.ContainsAny(value, " \t\r\n") {
return ""
}
lower := strings.ToLower(value)
if strings.HasPrefix(lower, "https://") || strings.HasPrefix(lower, "http://") || strings.HasPrefix(lower, "mailto:") || strings.HasPrefix(lower, "tel:") {
return value
}
if strings.HasPrefix(value, "//") {
return "https:" + value
}
if strings.HasPrefix(value, "/") {
return value
}
if strings.Contains(value, "@") && strings.Contains(value, ".") {
return "mailto:" + value
}
if strings.Contains(value, ".") {
return "https://" + value
}
return ""
}
// absURLTpl 模板内绝对化 URL:absURL foreverUrlAddr path
func absURLTpl(siteURL, path string) string {
return joinAbs(siteURL, path)
}
// canonicalOr 优先使用接口返回的 canonical,否则用 foreverUrlAddr+fallbackPath。
func canonicalOr(siteURL, preferred, fallbackPath string) string {
preferred = strings.TrimSpace(preferred)
if preferred != "" {
if strings.HasPrefix(preferred, "http://") || strings.HasPrefix(preferred, "https://") {
return preferred
}
return joinAbs(siteURL, preferred)
}
return joinAbs(siteURL, fallbackPath)
}
func joinAbs(siteURL, path string) string {
siteURL = strings.TrimRight(strings.TrimSpace(siteURL), "/")
path = strings.TrimSpace(path)
if path == "" {
if siteURL == "" {
return "/"
}
return siteURL + "/"
}
if strings.HasPrefix(path, "http://") || strings.HasPrefix(path, "https://") {
return path
}
if !strings.HasPrefix(path, "/") {
path = "/" + path
}
if siteURL == "" {
return path
}
return siteURL + path
}
// ImgPlaceholder 默认/失败占位图(与 imgDecypt.js 保持一致)。
const ImgPlaceholder = "/static/images/placeholder.png?v=2"
// coverURL 选出封面地址。返回 template.URL,避免 html/template 把 data-src
// 当 URL 上下文时把已百分号编码的中文路径再次转成 %25xx(导致封面 404)。
// 无有效地址时回退占位图。
func coverURL(values ...string) template.URL {
u := firstNonEmpty(values...)
if u == "" {
return template.URL(ImgPlaceholder)
}
return template.URL(u)
}
// cssCover 生成卡片封面 CSS 变量,供 style="{{cssCover ...}}" 使用。
// 无有效地址时使用占位图。
func cssCover(values ...string) template.CSS {
u := firstNonEmpty(values...)
if u == "" {
u = ImgPlaceholder
}
return template.CSS("--cover:url(" + u + ")")
}
// cssCoverPlaceholder 仅占位,真实图放 data-cover-src 由前端解密后写入 --cover。
func cssCoverPlaceholder() template.CSS {
return template.CSS("--cover:url(" + ImgPlaceholder + ")")
}
func displayTag(item CommonData) string {
if name := firstName(item.TagNames); name != "" {
return name
}
if name := firstName(item.ThemeNames); name != "" {
return name
}
return "短剧"
}
func firstTagName(item CommonData) string {
if len(item.TagNames) == 0 {
return ""
}
return strings.TrimSpace(item.TagNames[0])
}
func firstName(names []string) string {
for _, n := range names {
n = strings.TrimSpace(n)
if n != "" {
return n
}
}
return ""
}
func themeTagText(themeNames, tagNames []string) string {
theme := firstName(themeNames)
tag := firstName(tagNames)
switch {
case theme != "" && tag != "" && theme != tag:
return theme + " · " + tag
case tag != "":
return tag
default:
return theme
}
}
func addInt(a, b int) int { return a + b }
func modInt(a, b int) int {
if b == 0 {
return 0
}
return a % b
}
func absInt64Tpl(n int64) int64 {
if n < 0 {
return -n
}
return n
}
func formatShortDateTime(raw string) string {
raw = strings.TrimSpace(raw)
if raw == "" || strings.HasPrefix(raw, "0001") {
return ""
}
raw = strings.ReplaceAll(raw, "T", " ")
if i := strings.Index(raw, "."); i > 0 {
raw = raw[:i]
}
if i := strings.IndexAny(raw, "Z+"); i > 10 {
raw = strings.TrimSpace(raw[:i])
}
if len(raw) >= 16 {
raw = raw[:16]
}
raw = strings.ReplaceAll(raw, "-", "/")
return raw
}
func metaLine(item CommonData) string {
cat := firstName(item.ThemeNames)
if cat == "" {
cat = firstName(item.TagNames)
}
if item.TotalEpisode > 0 {
if cat != "" {
return fmt.Sprintf("%s·%d集", cat, item.TotalEpisode)
}
return fmt.Sprintf("%d集", item.TotalEpisode)
}
return cat
}
// playletYearText 详情 PC 元信息年份;无有效 onlineAt 时展示「年份未知」。
func playletYearText(onlineAt string) string {
onlineAt = strings.TrimSpace(onlineAt)
if len(onlineAt) < 4 {
return "年份未知"
}
year := onlineAt[:4]
for _, c := range year {
if c < '0' || c > '9' {
return "年份未知"
}
}
if year == "0001" || year == "1970" {
return "年份未知"
}
return year
}
// playletDateText formats the first valid detail-page date as YYYY.MM.DD.
func playletDateText(values ...string) string {
for _, value := range values {
value = strings.TrimSpace(value)
if len(value) < 10 {
continue
}
date := strings.NewReplacer("-", ".", "/", ".").Replace(value[:10])
parts := strings.Split(date, ".")
if len(parts) != 3 || len(parts[0]) != 4 || len(parts[1]) != 2 || len(parts[2]) != 2 {
continue
}
validDigits := true
for _, part := range parts {
for _, c := range part {
if c < '0' || c > '9' {
validDigits = false
break
}
}
if !validDigits {
break
}
}
if !validDigits || parts[0] == "0001" || parts[0] == "1970" {
continue
}
parsed, err := time.Parse("2006.01.02", date)
if err != nil {
continue
}
return parsed.Format("2006.01.02")
}
return "时间未知"
}
// isPlayletAllFree 全部剧集 PayType==0 时视为全站免费。
func isPlayletAllFree(chapters []PlayletChapterData) bool {
if len(chapters) == 0 {
return false
}
for _, ch := range chapters {
if ch.PayType != 0 {
return false
}
}
return true
}
+429
View File
@@ -0,0 +1,429 @@
package playletser
import "videoweb/app/service/configser"
// HomePlayletResponse 对应 swagger proto.HomePlayletResponse
// GET /api/app/playlet/home
// 文档:http://172.104.181.99:25319/swagger/index.html#/app短剧相关接口/get_api_app_playlet_home
type HomePlayletResponse struct {
SeoInfo SeoInfo `json:"seoInfo"`
Announcements []AnnouncementItem `json:"announcements"`
HomeBannerData []CommonData `json:"homeBannerData"`
HomeConfigData []HomeConfigData `json:"homeConfigData"`
Advitise configser.AdvitiseData `json:"advitise"`
// 以下为历史/扩展字段:上游若仍返回则透传,swagger 当前未声明。
HomeTodayUpdateData []CommonData `json:"homeTodayUpdateData"`
HomeCategoryData []HomeCategoryData `json:"homeCategoryData"`
HomeRecommendThemes []HomeRecommendTheme `json:"homeRecommendThemes"`
}
type AnnouncementItem struct {
ID int64 `json:"id"`
Title string `json:"title"`
Content string `json:"content"`
}
type HomeRecommendTheme struct {
ID int64 `json:"id"`
Name string `json:"name"`
Slug string `json:"slug"`
Icon string `json:"icon"`
Rank int `json:"rank"`
PlayletCount int64 `json:"playletCount"`
}
// HomeConfigData 对应 swagger proto.HomeConfigData(首页配置区块)。
type HomeConfigData struct {
ID int64 `json:"id"`
Name string `json:"name"`
Slug string `json:"slug"`
Desc string `json:"desc"`
SeoInfo SeoInfo `json:"seoInfo"`
Rank int `json:"rank"`
SortType int `json:"sortType"`
Status bool `json:"status"`
Type int `json:"type"` // 1短剧 2视频 3题材
List []CommonData `json:"list"`
ThemeList []HomeConfigThemeData `json:"themeList"`
VideoList []VideoItemResp `json:"videoList"` // type=2
CreatedAt string `json:"createdAt"`
UpdatedAt string `json:"updatedAt"`
}
// VideoItemResp 对应 swagger proto.VideoItemResp(homeConfigData.type=2)。
type VideoItemResp struct {
ID int64 `json:"id"`
Title string `json:"title"`
Slug string `json:"slug"`
CoverImg string `json:"coverImg"`
CreatorID int64 `json:"creatorId"`
CreatorName string `json:"creatorName"`
Keyworld []string `json:"keyworld"`
Tags []int64 `json:"tags"`
VideoTime int `json:"videoTime"`
WatchTimes int64 `json:"watchTimes"`
AddedTime string `json:"addedTime"`
}
// HomeConfigThemeData 对应 swagger proto.HomeConfigThemeData。
type HomeConfigThemeData struct {
ID int64 `json:"id"`
Name string `json:"name"`
Slug string `json:"slug"`
Desc string `json:"desc"`
Icon string `json:"icon"`
Rank int `json:"rank"`
PlayletCount int64 `json:"playletCount"`
List []CommonData `json:"list"`
SeoInfo SeoInfo `json:"seoInfo"`
}
// HomeConfigDetailListResp 对应 swagger proto.HomeConfigDetailListResp。
// GET /api/app/playlet/home/config/detail/list
type HomeConfigDetailListResp struct {
HomeConfigID int64 `json:"homeConfigId"`
HomeConfigSlug string `json:"homeConfigSlug"`
Name string `json:"name"`
Desc string `json:"desc"`
SeoInfo SeoInfo `json:"seoInfo"`
Type int `json:"type"`
SortType int `json:"sortType"`
List []CommonData `json:"list"`
VideoList []VideoItemResp `json:"videoList"`
ThemeList []HomeConfigThemeData `json:"themeList"`
PageNum int `json:"pageNum"`
PageSize int `json:"pageSize"`
TotalCount int64 `json:"totalCount"`
Advitise configser.AdvitiseData `json:"advitise"`
}
// HomeCategoryData 对应历史字段 homeCategoryData(若上游仍返回则透传)。
type HomeCategoryData struct {
ID int64 `json:"id"`
Name string `json:"name"`
Slug string `json:"slug"`
Desc string `json:"desc"`
Icon string `json:"icon"`
Rank int `json:"rank"`
List []CommonData `json:"list"`
}
// CommonData 对应 swagger proto.CommonData
type CommonData struct {
ID int64 `json:"id"`
Status int `json:"status"`
IsFeatured bool `json:"isFeatured"`
IsNew bool `json:"isNew"`
IsRecommend bool `json:"isRecommend"`
OperateType int `json:"operateType"`
ShowOnBanner bool `json:"showOnBanner"`
Banner string `json:"banner"`
OnlineAt string `json:"onlineAt"`
MediaCreatedAt string `json:"mediaCreatedAt"`
MediaUpdatedAt string `json:"mediaUpdatedAt"`
ThemeIDs []int64 `json:"themeIds"`
ThemeNames []string `json:"themeNames"`
ThemeSlugs []string `json:"themeSlugs"`
Title string `json:"title"`
PlayName string `json:"playName"`
Description string `json:"description"`
Slug string `json:"slug"`
Desc string `json:"desc"`
Anchor string `json:"anchor"`
Cover string `json:"cover"`
HorizontalCover string `json:"horizontalCover"`
TagIDs []int64 `json:"tagIds"`
TagNames []string `json:"tagNames"`
TagSlugs []string `json:"tagSlugs"`
TotalEpisode int `json:"totalEpisode"`
UpdateStatus int `json:"updateStatus"`
CountBrowse int64 `json:"countBrowse"`
CountCollect int64 `json:"countCollect"`
CountLike int64 `json:"countLike"`
HeatValue int64 `json:"heatValue"`
CreatedAt string `json:"createdAt"`
UpdatedAt string `json:"updatedAt"`
SeoInfo SeoInfo `json:"seoInfo"`
}
// PlayletVideoResp 对应 swagger proto.PlayletVideoResp / proto.PlayletRankResp。
// GET /api/app/playlet/list、GET /api/app/playlet/rank
type PlayletVideoResp struct {
SeoInfo SeoInfo `json:"seoInfo"`
List []CommonData `json:"list"`
PageNum int `json:"pageNum"`
PageSize int `json:"pageSize"`
TotalCount int64 `json:"totalCount"`
}
// PlayletSearchResp 对应 swagger proto.PlayletSearchResp。
// GET /api/app/playlet/search
type PlayletSearchResp struct {
Keyword string `json:"keyword"`
List []CommonData `json:"list"`
EveryoneWatching []CommonData `json:"everyoneWatching"`
PageNum int `json:"pageNum"`
PageSize int `json:"pageSize"`
TotalCount int64 `json:"totalCount"`
}
// PlayletSearchSuggestResp 对应 swagger proto.PlayletSearchSuggestResp。
// GET /api/app/playlet/search/suggest
type PlayletSearchSuggestResp struct {
Keyword string `json:"keyword"`
List []CommonData `json:"list"`
}
// PlayletHotRankListResp 对应 swagger proto.PlayletHotRankListResp。
// GET /api/app/playlet/hot/rank/list
type PlayletHotRankListResp struct {
SeoInfo SeoInfo `json:"seoInfo"`
List []CommonData `json:"list"`
PageNum int `json:"pageNum"`
PageSize int `json:"pageSize"`
TotalCount int64 `json:"totalCount"`
RankType int `json:"rankType"` // 1热播榜 2新剧榜 3追剧榜
}
// PlayletAllListResp 对应 swagger proto.PlayletAllListResp
// GET /api/app/playlet/all/list
type PlayletAllListResp struct {
SeoInfo SeoInfo `json:"seoInfo"`
List []CommonData `json:"list"`
PageNum int `json:"pageNum"`
PageSize int `json:"pageSize"`
TotalCount int64 `json:"totalCount"`
Advitise configser.AdvitiseData `json:"advitise"`
}
// PlayletRecommendListResp 对应 swagger proto.PlayletRecommendListResp。
// GET /api/app/playlet/recommend/list
type PlayletRecommendListResp struct {
CategoryID int64 `json:"categoryId"`
CategoryName string `json:"categoryName"`
CategorySlug string `json:"categorySlug"`
CategoryDesc string `json:"categoryDesc"`
List []CommonData `json:"list"`
PageNum int `json:"pageNum"`
PageSize int `json:"pageSize"`
SeoInfo SeoInfo `json:"seoInfo"`
TotalCount int64 `json:"totalCount"`
}
// PlayletTopicDetailResp 对应 swagger proto.PlayletTopicDetailResp。
// GET /api/app/playlet/topic/detail
type PlayletTopicDetailResp struct {
ID int64 `json:"id"`
Name string `json:"name"`
Slug string `json:"slug"`
Desc string `json:"desc"`
Icon string `json:"icon"`
Rank int `json:"rank"`
PlayletCount int64 `json:"playletCount"`
Covers []string `json:"covers"`
List []CommonData `json:"list"`
MoreTopics []PlayletTopicPageItem `json:"moreTopics"`
PageNum int `json:"pageNum"`
PageSize int `json:"pageSize"`
TotalCount int64 `json:"totalCount"`
SeoInfo SeoInfo `json:"seoInfo"`
}
// PlayletTopicPageItem 对应 swagger proto.PlayletTopicPageItem。
// GET /api/app/playlet/topic/list 列表项。
type PlayletTopicPageItem struct {
ID int64 `json:"id"`
Name string `json:"name"`
Slug string `json:"slug"`
Desc string `json:"desc"`
Icon string `json:"icon"`
Rank int `json:"rank"`
PlayletCount int64 `json:"playletCount"`
Covers []string `json:"covers"`
List []CommonData `json:"list"`
SeoInfo SeoInfo `json:"seoInfo"`
}
// PlayletTopicPageListResp 对应 swagger proto.PlayletTopicPageListResp。
// GET /api/app/playlet/topic/list
type PlayletTopicPageListResp struct {
List []PlayletTopicPageItem `json:"list"`
PageNum int `json:"pageNum"`
PageSize int `json:"pageSize"`
TotalCount int64 `json:"totalCount"`
SeoInfo SeoInfo `json:"seoInfo"`
}
// PlayletThemeItem 对应 swagger proto.PlayletThemeItem
type PlayletThemeItem struct {
ID int64 `json:"id"`
Name string `json:"name"`
Slug string `json:"slug"`
Desc string `json:"desc"`
Icon string `json:"icon"`
Rank int `json:"rank"`
Status bool `json:"status"`
IsRecommend bool `json:"isRecommend"`
PlayletCount int64 `json:"playletCount"`
SeoInfo SeoInfo `json:"seoInfo"`
}
// PlayletThemeListResponse 对应 swagger proto.PlayletThemeListResponse
// GET /api/app/theme/list
type PlayletThemeListResponse struct {
List []PlayletThemeItem `json:"list"`
}
// PlayletChapterData 对应 swagger proto.PlayletChapterData
// 出现在 GET /api/app/playlet/detail 的 playletChapterInfo。
type PlayletChapterData struct {
ID int64 `json:"id"`
PlayletID int64 `json:"playletId"`
CurrentEpisode int `json:"currentEpisode"`
Title string `json:"title"`
MD5 string `json:"md5"`
Hash string `json:"hash"`
Height int `json:"height"`
Width int `json:"width"`
Ratio float64 `json:"ratio"`
VideoURL string `json:"videoUrl"`
MediaSize int64 `json:"mediaSize"`
MediaTime int `json:"mediaTime"`
PayType int `json:"payType"`
SingleCoins int `json:"singleCoins"`
CostCoins int64 `json:"costCoins"`
Balance int64 `json:"balance"`
CanWatch bool `json:"canWatch"`
IsUnlocked bool `json:"isUnlocked"`
NeedUnlock bool `json:"needUnlock"`
NeedVip bool `json:"needVip"`
VipValid bool `json:"vipValid"`
}
// PlayletChapterListResp 对应 swagger proto.PlayletChapterListResp。
type PlayletChapterListResp struct {
PlayletID int64 `json:"playletId"`
List []PlayletChapterData `json:"list"`
}
// PlayletOperateListResp 对应 swagger proto.PlayletOperateListResp。
type PlayletOperateListResp struct {
OperateType int `json:"operateType"`
FilterType int `json:"filterType"`
PageNum int `json:"pageNum"`
PageSize int `json:"pageSize"`
TotalCount int64 `json:"totalCount"`
List []CommonData `json:"list"`
}
// PlayletInfoResp 对应 swagger proto.PlayletInfoResp
// GET /api/app/playlet/detail
type PlayletInfoResp struct {
ID int64 `json:"id"`
Status int `json:"status"`
IsFeatured bool `json:"isFeatured"`
IsNew bool `json:"isNew"`
IsRecommend bool `json:"isRecommend"`
OperateType int `json:"operateType"`
ShowOnBanner bool `json:"showOnBanner"`
Banner string `json:"banner"`
OnlineAt string `json:"onlineAt"`
MediaCreatedAt string `json:"mediaCreatedAt"`
MediaUpdatedAt string `json:"mediaUpdatedAt"`
ThemeIDs []int64 `json:"themeIds"`
ThemeNames []string `json:"themeNames"`
ThemeSlugs []string `json:"themeSlugs"`
Title string `json:"title"`
PlayName string `json:"playName"`
Description string `json:"description"`
Slug string `json:"slug"`
Desc string `json:"desc"`
Anchor string `json:"anchor"`
Cover string `json:"cover"`
HorizontalCover string `json:"horizontalCover"`
Preview string `json:"preview"`
TagIDs []int64 `json:"tagIds"`
TagNames []string `json:"tagNames"`
TagSlugs []string `json:"tagSlugs"`
TotalEpisode int `json:"totalEpisode"`
UpdateStatus int `json:"updateStatus"`
CountBrowse int64 `json:"countBrowse"`
CountCollect int64 `json:"countCollect"`
CountLike int64 `json:"countLike"`
HeatValue int64 `json:"heatValue"`
CreatedAt string `json:"createdAt"`
UpdatedAt string `json:"updatedAt"`
IsLike int `json:"isLike"`
IsCollect int `json:"isCollect"`
SeoInfo SeoInfo `json:"seoInfo"`
RelatedRecommendData []CommonData `json:"relatedRecommendData"`
PlayletChapterInfo []PlayletChapterData `json:"playletChapterInfo"`
Advitise configser.AdvitiseData `json:"advitise"`
}
// SeoInfo 对应 GET /api/app/playlet/detail 的 proto.SeoInfo。
// 字段:title / description / keywords / canonicalUrl / webSiteName。
type SeoInfo struct {
Title string `json:"title"`
Description string `json:"description"`
Keywords []string `json:"keywords"`
CanonicalURL string `json:"canonicalUrl"`
WebSiteName string `json:"webSiteName"`
}
// PlayletTagListResponse 对应 swagger proto.PlayletTagListResponse
// GET /api/app/playlet/tag/options
type PlayletTagListResponse struct {
List []PlayletTagItem `json:"list"`
}
// PlayletTagItem 对应 swagger proto.PlayletTagItem
type PlayletTagItem struct {
ID int64 `json:"id"`
Name string `json:"name"`
Slug string `json:"slug"`
Rank int `json:"rank"`
Status bool `json:"status"`
SeoInfo SeoInfo `json:"seoInfo"`
}
// PlayletChapterInfoResp 对应 swagger proto.PlayletChapterInfoResp
// GET /api/app/playlet/chapter/detail
type PlayletChapterInfoResp struct {
ID int64 `json:"id"`
PlayletID int64 `json:"playletId"`
CurrentEpisode int `json:"currentEpisode"`
Title string `json:"title"`
MD5 string `json:"md5"`
Hash string `json:"hash"`
Height int `json:"height"`
Width int `json:"width"`
Ratio float64 `json:"ratio"`
VideoURL string `json:"videoUrl"`
MediaSize int64 `json:"mediaSize"`
MediaTime int `json:"mediaTime"`
CountComment int64 `json:"countComment"`
CountBrowse int64 `json:"countBrowse"`
CountCollect int64 `json:"countCollect"`
CountLike int64 `json:"countLike"`
IsLike int `json:"isLike"`
IsCollect int `json:"isCollect"`
PayType int `json:"payType"`
SingleCoins int `json:"singleCoins"`
CostCoins int64 `json:"costCoins"`
Balance int64 `json:"balance"`
CanWatch bool `json:"canWatch"`
IsUnlocked bool `json:"isUnlocked"`
NeedUnlock bool `json:"needUnlock"`
NeedVip bool `json:"needVip"`
VipValid bool `json:"vipValid"`
SeoInfo SeoInfo `json:"seoInfo"`
}
// APIEnvelope 上游统一响应壳
type APIEnvelope[T any] struct {
Code int `json:"code"`
Msg string `json:"msg"`
Tip string `json:"tip"`
Data T `json:"data"`
}
+180
View File
@@ -0,0 +1,180 @@
package playletser
import (
"fmt"
"net/url"
"strconv"
"strings"
)
// pathSegment 生成路径段:优先 slug,没有 slug 时才用 id。
func pathSegment(slug string, id int64) string {
slug = strings.TrimSpace(slug)
if slug != "" {
return url.PathEscape(slug)
}
if id > 0 {
return strconv.FormatInt(id, 10)
}
return ""
}
// SearchResultsURL 搜索结果页路径:/search/{q}/(对应 search.html)
func SearchResultsURL(q string) string {
q = strings.TrimSpace(q)
if q == "" {
return "/search"
}
return "/search/" + url.PathEscape(q)
}
func detailURL(slug string, id int64) string {
if segment := pathSegment(slug, id); segment != "" {
return "/play/" + segment
}
return "#"
}
func playURL(slug string, playletID int64) string {
return chapterPlayURL(slug, playletID, 0)
}
func chapterPlayURL(slug string, playletID, chapterID int64) string {
segment := pathSegment(slug, playletID)
if segment == "" {
return "#"
}
if chapterID <= 0 {
return "/play/" + segment
}
return fmt.Sprintf("/play/%s/%d", segment, chapterID)
}
func categoryURL(slug string, id int64) string {
if segment := pathSegment(slug, id); segment != "" {
return "/topic-detail/" + segment
}
return "/topic"
}
func DetailPath(slug string, id int64) string {
return detailURL(slug, id)
}
func PlayPath(slug string, id int64) string {
return playURL(slug, id)
}
func ChapterPlayPath(slug string, playletID, chapterID int64) string {
return chapterPlayURL(slug, playletID, chapterID)
}
func updateStatusText(status int) string {
if status == 2 {
return "已完结"
}
return "连载中"
}
func browseText(n int64) string {
if n <= 0 {
return "0次播放"
}
if n < 10000 {
return fmt.Sprintf("%d次播放", n)
}
v := float64(n) / 10000
if v >= 100 {
return fmt.Sprintf("%.0f万次播放", v)
}
return fmt.Sprintf("%.1f万次播放", v)
}
func usableAnchor(anchor string) string {
anchor = strings.TrimSpace(anchor)
if anchor == "" || anchor == "暂无" {
return ""
}
return anchor
}
func rankClass(rank int) string {
switch rank {
case 1:
return "gold"
case 2:
return "silver"
case 3:
return "bronze"
default:
return "dark"
}
}
func episodeText(n int) string {
if n <= 0 {
return ""
}
return fmt.Sprintf("%d集", n)
}
func formatHeat(n int64) string {
if n <= 0 {
return "0 热度"
}
if n < 10000 {
return fmt.Sprintf("%d 热度", n)
}
v := float64(n) / 10000
if v >= 100 {
return fmt.Sprintf("%.0f万 热度", v)
}
return fmt.Sprintf("%.1f万 热度", v)
}
func formatMediaTime(sec int) string {
if sec <= 0 {
return "00:00"
}
h := sec / 3600
m := (sec % 3600) / 60
s := sec % 60
if h > 0 {
return fmt.Sprintf("%02d:%02d:%02d", h, m, s)
}
return fmt.Sprintf("%02d:%02d", m, s)
}
// playletDisplayName 优先 playName,其次 title。
func playletDisplayName(playName, title string) string {
return firstNonEmpty(playName, title)
}
// PlayletDisplayName 对外导出的剧名展示。
func PlayletDisplayName(playName, title string) string {
return playletDisplayName(playName, title)
}
// formatLikeCount 封面点赞数展示:不足一万原样,否则 x.x 万。
func formatLikeCount(n int64) string {
if n <= 0 {
return "0"
}
if n < 10000 {
return fmt.Sprintf("%d", n)
}
v := float64(n) / 10000
if v >= 100 {
return fmt.Sprintf("%.0f 万", v)
}
return fmt.Sprintf("%.1f 万", v)
}
func firstNonEmpty(values ...string) string {
for _, v := range values {
if strings.TrimSpace(v) != "" {
return v
}
}
return ""
}