1177 lines
38 KiB
Go
1177 lines
38 KiB
Go
package handler
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"net/http"
|
||
"regexp"
|
||
"sort"
|
||
"strconv"
|
||
"strings"
|
||
"sync"
|
||
"time"
|
||
|
||
"soul-api/internal/cache"
|
||
"soul-api/internal/database"
|
||
"soul-api/internal/model"
|
||
|
||
"github.com/gin-gonic/gin"
|
||
"gorm.io/gorm"
|
||
)
|
||
|
||
// excludeParts 排除序言、尾声、附录（不参与精选推荐/热门排序）
|
||
var excludeParts = []string{"序言", "尾声", "附录"}
|
||
|
||
// chapterTitleBRTag 章节标题字段中误粘贴的 <br>（含大小写、自闭合）
|
||
var chapterTitleBRTag = regexp.MustCompile(`(?i)<br\s*/?>`)
|
||
|
||
// sanitizeChapterTitleField 去掉篇章/章节/小节标题中的异常换行、<br>，合并空白（DB 或编辑器误插入）
|
||
func sanitizeChapterTitleField(s string) string {
|
||
s = strings.TrimSpace(s)
|
||
if s == "" {
|
||
return ""
|
||
}
|
||
s = chapterTitleBRTag.ReplaceAllString(s, " ")
|
||
s = strings.NewReplacer("\r\n", " ", "\r", " ", "\n", " ").Replace(s)
|
||
return strings.Join(strings.Fields(s), " ")
|
||
}
|
||
|
||
// sortChaptersByNaturalID 同 sort_order 时按 id 自然排序（9.1 < 9.2 < 9.10），调用 db_book 的 naturalLessSectionID
|
||
func sortChaptersByNaturalID(list []model.Chapter) {
|
||
sort.Slice(list, func(i, j int) bool {
|
||
soI, soJ := 999999, 999999
|
||
if list[i].SortOrder != nil {
|
||
soI = *list[i].SortOrder
|
||
}
|
||
if list[j].SortOrder != nil {
|
||
soJ = *list[j].SortOrder
|
||
}
|
||
if soI != soJ {
|
||
return soI < soJ
|
||
}
|
||
return naturalLessSectionID(list[i].ID, list[j].ID)
|
||
})
|
||
}
|
||
|
||
// allChaptersSelectCols 列表不加载 content（longtext），避免 502 超时
|
||
var allChaptersSelectCols = []string{
|
||
"mid", "book_id", "id", "part_id", "part_title", "chapter_id", "chapter_title",
|
||
"section_title", "word_count", "is_free", "price", "sort_order", "status",
|
||
"is_new", "edition_standard", "edition_premium", "hot_score", "preview_percent", "created_at", "updated_at",
|
||
}
|
||
|
||
// chapterMetaCols 章节详情元数据（不含 content），用于 content 缓存命中时的轻量查询
|
||
var chapterMetaCols = []string{
|
||
"mid", "book_id", "id", "part_id", "part_title", "chapter_id", "chapter_title",
|
||
"section_title", "word_count", "is_free", "price", "sort_order", "status",
|
||
"is_new", "edition_standard", "edition_premium", "hot_score", "preview_percent", "created_at", "updated_at",
|
||
}
|
||
|
||
// allChaptersCache 内存缓存，减轻 DB 压力，30 秒 TTL
|
||
var allChaptersCache struct {
|
||
mu sync.RWMutex
|
||
data []model.Chapter
|
||
expires time.Time
|
||
key string // excludeFixed 不同则 key 不同
|
||
}
|
||
|
||
const allChaptersCacheTTL = 30 * time.Second
|
||
|
||
// bookPartsCache 目录接口内存缓存，30 秒 TTL，减轻 DB 压力
|
||
type cachedPartRow struct {
|
||
PartID string `json:"id"`
|
||
PartTitle string `json:"title"`
|
||
Subtitle string `json:"subtitle"`
|
||
ChapterCount int `json:"chapterCount"`
|
||
MinSortOrder int `json:"minSortOrder"`
|
||
// Icon 可选：system_config.book_part_icons JSON 中按 part_id 配置的封面图 URL
|
||
Icon string `json:"icon,omitempty"`
|
||
BadgeText string `json:"badgeText,omitempty"`
|
||
}
|
||
type cachedFixedItem struct {
|
||
ID string `json:"id"`
|
||
MID int `json:"mid"`
|
||
SectionTitle string `json:"title"`
|
||
}
|
||
|
||
// bookPartsRedisPayload Redis 缓存结构，与 BookParts 响应一致
|
||
type bookPartsRedisPayload struct {
|
||
Parts []cachedPartRow `json:"parts"`
|
||
TotalSections int64 `json:"totalSections"`
|
||
FixedSections []cachedFixedItem `json:"fixedSections"`
|
||
}
|
||
|
||
var bookPartsCache struct {
|
||
mu sync.RWMutex
|
||
parts []cachedPartRow
|
||
total int64
|
||
fixed []cachedFixedItem
|
||
expires time.Time
|
||
}
|
||
|
||
const bookPartsCacheTTL = 30 * time.Second
|
||
|
||
// loadBookPartIconURLs 读取 system_config.book_part_icons：{"part-1":"https://..."}，key 与 chapters.part_id 一致
|
||
func loadBookPartIconURLs() map[string]string {
|
||
out := map[string]string{}
|
||
var row model.SystemConfig
|
||
if err := database.DB().Where("config_key = ?", "book_part_icons").First(&row).Error; err != nil {
|
||
return out
|
||
}
|
||
var raw map[string]interface{}
|
||
if err := json.Unmarshal(row.ConfigValue, &raw); err != nil {
|
||
return out
|
||
}
|
||
for k, v := range raw {
|
||
k = strings.TrimSpace(k)
|
||
if k == "" {
|
||
continue
|
||
}
|
||
if s, ok := v.(string); ok {
|
||
s = strings.TrimSpace(s)
|
||
if s != "" {
|
||
out[k] = s
|
||
}
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
// loadBookPartBadgeTexts 读取 system_config.book_part_badges：{"part-1":"新"}，key 与 chapters.part_id 一致
|
||
func loadBookPartBadgeTexts() map[string]string {
|
||
out := map[string]string{}
|
||
var row model.SystemConfig
|
||
if err := database.DB().Where("config_key = ?", "book_part_badges").First(&row).Error; err != nil {
|
||
return out
|
||
}
|
||
var raw map[string]interface{}
|
||
if err := json.Unmarshal(row.ConfigValue, &raw); err != nil {
|
||
return out
|
||
}
|
||
for k, v := range raw {
|
||
k = strings.TrimSpace(k)
|
||
if k == "" {
|
||
continue
|
||
}
|
||
if s, ok := v.(string); ok {
|
||
s = strings.TrimSpace(s)
|
||
if s != "" {
|
||
out[k] = s
|
||
}
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
// mergeBookPartIcons 将配置中的篇封面 URL/角标写入 parts（每次接口响应前调用，避免 Redis 旧缓存缺字段）
|
||
func mergeBookPartIcons(parts []cachedPartRow) {
|
||
if len(parts) == 0 {
|
||
return
|
||
}
|
||
m := loadBookPartIconURLs()
|
||
bm := loadBookPartBadgeTexts()
|
||
for i := range parts {
|
||
if u := strings.TrimSpace(m[parts[i].PartID]); u != "" {
|
||
parts[i].Icon = u
|
||
}
|
||
if b := strings.TrimSpace(bm[parts[i].PartID]); b != "" {
|
||
parts[i].BadgeText = b
|
||
}
|
||
}
|
||
}
|
||
|
||
// chaptersByPartCache 篇章内章节列表内存缓存，30 秒 TTL
|
||
type chaptersByPartEntry struct {
|
||
data []model.Chapter
|
||
expires time.Time
|
||
}
|
||
|
||
var chaptersByPartCache struct {
|
||
mu sync.RWMutex
|
||
entries map[string]*chaptersByPartEntry
|
||
}
|
||
|
||
const chaptersByPartCacheTTL = 30 * time.Second
|
||
|
||
// InvalidateChaptersByPartCache 后台更新章节时调用，使 chapters-by-part 内存缓存失效
|
||
func InvalidateChaptersByPartCache() {
|
||
chaptersByPartCache.mu.Lock()
|
||
chaptersByPartCache.entries = nil
|
||
chaptersByPartCache.mu.Unlock()
|
||
}
|
||
|
||
// WarmAllChaptersCache 启动时预热缓存（Redis+内存），避免首请求冷启动 502
|
||
func WarmAllChaptersCache() {
|
||
db := database.DB()
|
||
q := db.Model(&model.Chapter{}).Select(allChaptersSelectCols)
|
||
var list []model.Chapter
|
||
if err := q.Order("COALESCE(sort_order, 999999) ASC, id ASC").Find(&list).Error; err != nil {
|
||
return
|
||
}
|
||
sortChaptersByNaturalID(list)
|
||
applyFreeChapterConfig(list, getFreeChapterIDs(db))
|
||
cache.Set(context.Background(), cache.KeyAllChapters("default"), list, cache.AllChaptersTTL)
|
||
allChaptersCache.mu.Lock()
|
||
allChaptersCache.data = list
|
||
allChaptersCache.expires = time.Now().Add(allChaptersCacheTTL)
|
||
allChaptersCache.key = "default"
|
||
allChaptersCache.mu.Unlock()
|
||
}
|
||
|
||
// fetchAndCacheBookParts 执行 DB 查询并更新缓存，供 BookParts 与 WarmBookPartsCache 复用
|
||
// bookID == 0 表示不过滤（兼容旧版），bookID > 0 按 book_id 过滤
|
||
func fetchAndCacheBookParts(bookID ...int) (parts []cachedPartRow, total int64, fixed []cachedFixedItem) {
|
||
bid := 0
|
||
if len(bookID) > 0 {
|
||
bid = bookID[0]
|
||
}
|
||
db := database.DB()
|
||
var wg sync.WaitGroup
|
||
wg.Add(3)
|
||
|
||
// 固定模块（序言/尾声/附录）仅在主书或不过滤时返回
|
||
go func() {
|
||
defer wg.Done()
|
||
if bid > 0 && bid != 1 {
|
||
return
|
||
}
|
||
conds := make([]string, len(excludeParts))
|
||
eArgs := make([]interface{}, len(excludeParts))
|
||
for i, p := range excludeParts {
|
||
conds[i] = "part_title LIKE ?"
|
||
eArgs[i] = "%" + p + "%"
|
||
}
|
||
w := "(" + strings.Join(conds, " OR ") + ")"
|
||
if bid == 1 {
|
||
w += " AND book_id = 1"
|
||
}
|
||
var rows []model.Chapter
|
||
if err := db.Model(&model.Chapter{}).Select("id", "mid", "section_title", "sort_order").
|
||
Where(w, eArgs...).
|
||
Order("COALESCE(sort_order, 999999) ASC, id ASC").
|
||
Find(&rows).Error; err == nil {
|
||
sortChaptersByNaturalID(rows)
|
||
for _, r := range rows {
|
||
fixed = append(fixed, cachedFixedItem{r.ID, r.MID, r.SectionTitle})
|
||
}
|
||
}
|
||
}()
|
||
|
||
where := "1=1"
|
||
args := []interface{}{}
|
||
if bid > 0 {
|
||
where += " AND book_id = ?"
|
||
args = append(args, bid)
|
||
}
|
||
for _, p := range excludeParts {
|
||
where += " AND part_title NOT LIKE ?"
|
||
args = append(args, "%"+p+"%")
|
||
}
|
||
sql := `SELECT part_id, part_title, '' as subtitle,
|
||
COUNT(DISTINCT chapter_id) as chapter_count,
|
||
MIN(COALESCE(sort_order, 999999)) as min_sort
|
||
FROM chapters WHERE ` + where + `
|
||
GROUP BY part_id, part_title ORDER BY min_sort ASC, part_id ASC`
|
||
var raw []struct {
|
||
PartID string `gorm:"column:part_id"`
|
||
PartTitle string `gorm:"column:part_title"`
|
||
Subtitle string `gorm:"column:subtitle"`
|
||
ChapterCount int `gorm:"column:chapter_count"`
|
||
MinSortOrder int `gorm:"column:min_sort"`
|
||
}
|
||
go func() {
|
||
defer wg.Done()
|
||
db.Raw(sql, args...).Scan(&raw)
|
||
}()
|
||
|
||
go func() {
|
||
defer wg.Done()
|
||
q := db.Model(&model.Chapter{})
|
||
if bid > 0 {
|
||
q = q.Where("book_id = ?", bid)
|
||
}
|
||
q.Count(&total)
|
||
}()
|
||
|
||
wg.Wait()
|
||
|
||
parts = make([]cachedPartRow, len(raw))
|
||
for i, r := range raw {
|
||
parts[i] = cachedPartRow{
|
||
PartID: r.PartID, PartTitle: r.PartTitle, Subtitle: r.Subtitle,
|
||
ChapterCount: r.ChapterCount, MinSortOrder: r.MinSortOrder,
|
||
}
|
||
}
|
||
|
||
if bid == 0 {
|
||
bookPartsCache.mu.Lock()
|
||
bookPartsCache.parts = parts
|
||
bookPartsCache.total = total
|
||
bookPartsCache.fixed = fixed
|
||
bookPartsCache.expires = time.Now().Add(bookPartsCacheTTL)
|
||
bookPartsCache.mu.Unlock()
|
||
}
|
||
|
||
return parts, total, fixed
|
||
}
|
||
|
||
// WarmBookPartsCache 启动时预热目录缓存（内存+Redis），避免首请求慢
|
||
func WarmBookPartsCache() {
|
||
parts, total, fixed := fetchAndCacheBookParts()
|
||
payload := bookPartsRedisPayload{Parts: parts, TotalSections: total, FixedSections: fixed}
|
||
cache.Set(context.Background(), cache.KeyBookParts, payload, cache.BookPartsTTL)
|
||
}
|
||
|
||
// BookAllChapters GET /api/book/all-chapters 返回所有章节（列表，来自 chapters 表）
|
||
//
|
||
// Deprecated: 小程序已迁移至 book/parts + chapters-by-part + book/stats，id↔mid 从各接口响应积累。
|
||
// 保留以兼容旧版/管理端，计划后续下线。
|
||
//
|
||
// 排序须与管理端 PUT /api/db/book action=reorder 一致：按 sort_order 升序，同序按 id
|
||
// 免费判断：system_config.free_chapters / chapter_config.freeChapters 优先于 chapters.is_free
|
||
// 支持 excludeFixed=1：排除序言、尾声、附录（目录页固定模块，不参与中间篇章）
|
||
// 缓存优先级：Redis（10min）> 内存（30s）> DB；后台更新时失效
|
||
func BookAllChapters(c *gin.Context) {
|
||
cacheKey := "default"
|
||
if c.Query("excludeFixed") == "1" {
|
||
cacheKey = "excludeFixed"
|
||
}
|
||
// 1. 优先 Redis
|
||
var list []model.Chapter
|
||
if cache.Get(context.Background(), cache.KeyAllChapters(cacheKey), &list) && len(list) > 0 {
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": list})
|
||
return
|
||
}
|
||
// 2. 内存缓存
|
||
allChaptersCache.mu.RLock()
|
||
if allChaptersCache.key == cacheKey && time.Now().Before(allChaptersCache.expires) && len(allChaptersCache.data) > 0 {
|
||
data := allChaptersCache.data
|
||
allChaptersCache.mu.RUnlock()
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": data})
|
||
return
|
||
}
|
||
allChaptersCache.mu.RUnlock()
|
||
|
||
// 3. DB 查询
|
||
db := database.DB()
|
||
q := db.Model(&model.Chapter{}).Select(allChaptersSelectCols)
|
||
if cacheKey == "excludeFixed" {
|
||
for _, p := range excludeParts {
|
||
q = q.Where("part_title NOT LIKE ?", "%"+p+"%")
|
||
}
|
||
}
|
||
if err := q.Order("COALESCE(sort_order, 999999) ASC, id ASC").Find(&list).Error; err != nil {
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": []interface{}{}})
|
||
return
|
||
}
|
||
sortChaptersByNaturalID(list)
|
||
applyFreeChapterConfig(list, getFreeChapterIDs(db))
|
||
|
||
// 回填 Redis + 内存
|
||
cache.Set(context.Background(), cache.KeyAllChapters(cacheKey), list, cache.AllChaptersTTL)
|
||
allChaptersCache.mu.Lock()
|
||
allChaptersCache.data = list
|
||
allChaptersCache.expires = time.Now().Add(allChaptersCacheTTL)
|
||
allChaptersCache.key = cacheKey
|
||
allChaptersCache.mu.Unlock()
|
||
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": list})
|
||
}
|
||
|
||
// BookChapterByID GET /api/book/chapter/:id 按业务 id 查询（兼容旧链接）
|
||
func BookChapterByID(c *gin.Context) {
|
||
id := c.Param("id")
|
||
if id == "" {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "error": "缺少 id"})
|
||
return
|
||
}
|
||
findChapterAndRespond(c, func(db *gorm.DB) *gorm.DB {
|
||
return db.Where("id = ?", id)
|
||
})
|
||
}
|
||
|
||
// BookParts GET /api/miniprogram/book/parts 目录懒加载：仅返回篇章列表，不含章节详情
|
||
// 返回 parts（排除序言/尾声/附录）、totalSections、fixedSections（id, mid, title 供序言/尾声/附录跳转用 mid）
|
||
// 缓存优先级：Redis（10min，后台更新时失效）> 内存（30s）> DB；Redis 不可用时回退内存+DB
|
||
func BookParts(c *gin.Context) {
|
||
bookID := 0
|
||
if bid := c.Query("bookId"); bid != "" {
|
||
if v, err := strconv.Atoi(bid); err == nil && v > 0 {
|
||
bookID = v
|
||
}
|
||
}
|
||
|
||
cacheKey := cache.KeyBookParts
|
||
if bookID > 0 {
|
||
cacheKey = cache.KeyBookPartsByBook(bookID)
|
||
}
|
||
|
||
// 1. 优先 Redis
|
||
var redisPayload bookPartsRedisPayload
|
||
if cache.Get(context.Background(), cacheKey, &redisPayload) && len(redisPayload.Parts) > 0 {
|
||
mergeBookPartIcons(redisPayload.Parts)
|
||
c.JSON(http.StatusOK, gin.H{
|
||
"success": true,
|
||
"parts": redisPayload.Parts,
|
||
"totalSections": redisPayload.TotalSections,
|
||
"fixedSections": redisPayload.FixedSections,
|
||
})
|
||
return
|
||
}
|
||
|
||
// 2. 内存缓存（仅不带 bookId 时可用旧缓存）
|
||
if bookID == 0 {
|
||
bookPartsCache.mu.RLock()
|
||
if time.Now().Before(bookPartsCache.expires) {
|
||
parts := bookPartsCache.parts
|
||
total := bookPartsCache.total
|
||
fixed := bookPartsCache.fixed
|
||
bookPartsCache.mu.RUnlock()
|
||
mergeBookPartIcons(parts)
|
||
c.JSON(http.StatusOK, gin.H{
|
||
"success": true,
|
||
"parts": parts,
|
||
"totalSections": total,
|
||
"fixedSections": fixed,
|
||
})
|
||
return
|
||
}
|
||
bookPartsCache.mu.RUnlock()
|
||
}
|
||
|
||
// 3. DB 查询并更新 Redis + 内存
|
||
parts, total, fixed := fetchAndCacheBookParts(bookID)
|
||
mergeBookPartIcons(parts)
|
||
payload := bookPartsRedisPayload{Parts: parts, TotalSections: total, FixedSections: fixed}
|
||
cache.Set(context.Background(), cacheKey, payload, cache.BookPartsTTL)
|
||
|
||
c.JSON(http.StatusOK, gin.H{
|
||
"success": true,
|
||
"parts": parts,
|
||
"totalSections": total,
|
||
"fixedSections": fixed,
|
||
})
|
||
}
|
||
|
||
// BookChaptersByPart GET /api/miniprogram/book/chapters-by-part?partId=xxx 按篇章返回章节列表（含 mid，供阅读页 by-mid 请求）
|
||
// 缓存优先级：Redis（10min）> 内存（30s）> DB；后台更新时失效
|
||
func BookChaptersByPart(c *gin.Context) {
|
||
partId := c.Query("partId")
|
||
if partId == "" {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "error": "缺少 partId"})
|
||
return
|
||
}
|
||
// 1. 优先 Redis
|
||
var list []model.Chapter
|
||
if cache.Get(context.Background(), cache.KeyChaptersByPart(partId), &list) && len(list) > 0 {
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": list})
|
||
return
|
||
}
|
||
// 2. 内存缓存
|
||
chaptersByPartCache.mu.RLock()
|
||
if chaptersByPartCache.entries != nil {
|
||
if e, ok := chaptersByPartCache.entries[partId]; ok && time.Now().Before(e.expires) {
|
||
list := e.data
|
||
chaptersByPartCache.mu.RUnlock()
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": list})
|
||
return
|
||
}
|
||
}
|
||
chaptersByPartCache.mu.RUnlock()
|
||
|
||
// 3. DB 查询
|
||
db := database.DB()
|
||
if err := db.Model(&model.Chapter{}).Select(allChaptersSelectCols).
|
||
Where("part_id = ?", partId).
|
||
Order("COALESCE(sort_order, 999999) ASC, id ASC").
|
||
Find(&list).Error; err != nil {
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": []interface{}{}})
|
||
return
|
||
}
|
||
sortChaptersByNaturalID(list)
|
||
applyFreeChapterConfig(list, getFreeChapterIDs(db))
|
||
|
||
// 回填 Redis + 内存
|
||
cache.Set(context.Background(), cache.KeyChaptersByPart(partId), list, cache.ChaptersByPartTTL)
|
||
chaptersByPartCache.mu.Lock()
|
||
if chaptersByPartCache.entries == nil {
|
||
chaptersByPartCache.entries = make(map[string]*chaptersByPartEntry)
|
||
}
|
||
chaptersByPartCache.entries[partId] = &chaptersByPartEntry{data: list, expires: time.Now().Add(chaptersByPartCacheTTL)}
|
||
chaptersByPartCache.mu.Unlock()
|
||
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": list})
|
||
}
|
||
|
||
// getOrderedChapterList 获取按 sort_order+id 排序的章节列表（复用 all-chapters 缓存）
|
||
func getOrderedChapterList() []model.Chapter {
|
||
var list []model.Chapter
|
||
if cache.Get(context.Background(), cache.KeyAllChapters("default"), &list) && len(list) > 0 {
|
||
return list
|
||
}
|
||
allChaptersCache.mu.RLock()
|
||
if allChaptersCache.key == "default" && time.Now().Before(allChaptersCache.expires) && len(allChaptersCache.data) > 0 {
|
||
list = allChaptersCache.data
|
||
allChaptersCache.mu.RUnlock()
|
||
return list
|
||
}
|
||
allChaptersCache.mu.RUnlock()
|
||
db := database.DB()
|
||
if err := db.Model(&model.Chapter{}).Select(allChaptersSelectCols).
|
||
Order("COALESCE(sort_order, 999999) ASC, id ASC").
|
||
Find(&list).Error; err != nil || len(list) == 0 {
|
||
return nil
|
||
}
|
||
sortChaptersByNaturalID(list)
|
||
return list
|
||
}
|
||
|
||
// BookChapterByMID GET /api/book/chapter/by-mid/:mid 按自增主键 mid 查询（新链接推荐）
|
||
func BookChapterByMID(c *gin.Context) {
|
||
midStr := c.Param("mid")
|
||
if midStr == "" {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "error": "缺少 mid"})
|
||
return
|
||
}
|
||
mid, err := strconv.Atoi(midStr)
|
||
if err != nil || mid < 1 {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "error": "mid 必须为正整数"})
|
||
return
|
||
}
|
||
findChapterAndRespond(c, func(db *gorm.DB) *gorm.DB {
|
||
return db.Where("mid = ?", mid)
|
||
})
|
||
}
|
||
|
||
// applyFreeChapterConfig 将 system_config 免费配置应用到章节列表
|
||
// 仅当章节自身 is_free 不是显式 false（管理员取消免费优先于 config 覆盖）时才生效
|
||
func applyFreeChapterConfig(list []model.Chapter, freeIDs map[string]bool) {
|
||
for i := range list {
|
||
if !freeIDs[list[i].ID] {
|
||
continue
|
||
}
|
||
if list[i].IsFree != nil && !*list[i].IsFree && list[i].Price != nil && *list[i].Price > 0 {
|
||
continue
|
||
}
|
||
t := true
|
||
z := float64(0)
|
||
list[i].IsFree = &t
|
||
list[i].Price = &z
|
||
}
|
||
}
|
||
|
||
// getFreeChapterIDs 从 system_config 读取免费章节 ID 列表（free_chapters 或 chapter_config.freeChapters）
|
||
// Redis 缓存 5min，后台更新时失效
|
||
func getFreeChapterIDs(db *gorm.DB) map[string]bool {
|
||
var ids map[string]bool
|
||
if cache.Get(context.Background(), cache.KeyFreeChapterIDs, &ids) {
|
||
if ids == nil {
|
||
return make(map[string]bool)
|
||
}
|
||
return ids
|
||
}
|
||
ids = make(map[string]bool)
|
||
for _, key := range []string{"free_chapters", "chapter_config"} {
|
||
var row model.SystemConfig
|
||
if err := db.Where("config_key = ?", key).First(&row).Error; err != nil {
|
||
continue
|
||
}
|
||
var val interface{}
|
||
if err := json.Unmarshal(row.ConfigValue, &val); err != nil {
|
||
continue
|
||
}
|
||
if key == "free_chapters" {
|
||
if arr, ok := val.([]interface{}); ok {
|
||
for _, v := range arr {
|
||
if s, ok := v.(string); ok {
|
||
ids[s] = true
|
||
}
|
||
}
|
||
}
|
||
} else if key == "chapter_config" {
|
||
if m, ok := val.(map[string]interface{}); ok {
|
||
if arr, ok := m["freeChapters"].([]interface{}); ok {
|
||
for _, v := range arr {
|
||
if s, ok := v.(string); ok {
|
||
ids[s] = true
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
cache.Set(context.Background(), cache.KeyFreeChapterIDs, ids, cache.FreeChapterIDsTTL)
|
||
return ids
|
||
}
|
||
|
||
// checkUserChapterAccess 判断 userId 是否有权读取 chapterID（VIP / 全书购买 / 单章购买）
|
||
// isPremium=true 表示增值版，fullbook 买断不含增值版
|
||
func checkUserChapterAccess(db *gorm.DB, userID, chapterID string, isPremium bool) bool {
|
||
if userID == "" {
|
||
return false
|
||
}
|
||
// VIP：is_vip=1 且未过期
|
||
var u model.User
|
||
if err := db.Select("id", "is_vip", "vip_expire_date", "has_full_book").Where("id = ?", userID).First(&u).Error; err != nil {
|
||
return false
|
||
}
|
||
if u.IsVip != nil && *u.IsVip && u.VipExpireDate != nil && u.VipExpireDate.After(time.Now()) {
|
||
return true
|
||
}
|
||
// 全书买断（不含增值版）
|
||
if !isPremium && u.HasFullBook != nil && *u.HasFullBook {
|
||
return true
|
||
}
|
||
// 全书订单（兜底）
|
||
if !isPremium {
|
||
var cnt int64
|
||
db.Model(&model.Order{}).Where("user_id = ? AND product_type = 'fullbook' AND status = 'paid'", userID).Count(&cnt)
|
||
if cnt > 0 {
|
||
return true
|
||
}
|
||
}
|
||
// 单章购买
|
||
var cnt int64
|
||
db.Model(&model.Order{}).Where(
|
||
"user_id = ? AND product_type = 'section' AND product_id = ? AND status = 'paid'",
|
||
userID, chapterID,
|
||
).Count(&cnt)
|
||
return cnt > 0
|
||
}
|
||
|
||
// getUnpaidPreviewPercent 从 system_config 读取 unpaid_preview_percent，默认 20
|
||
func getUnpaidPreviewPercent(db *gorm.DB) int {
|
||
var row model.SystemConfig
|
||
if err := db.Where("config_key = ?", "unpaid_preview_percent").First(&row).Error; err != nil || len(row.ConfigValue) == 0 {
|
||
return 20
|
||
}
|
||
var val interface{}
|
||
if err := json.Unmarshal(row.ConfigValue, &val); err != nil {
|
||
return 20
|
||
}
|
||
switch v := val.(type) {
|
||
case float64:
|
||
p := int(v)
|
||
if p < 1 {
|
||
p = 1
|
||
}
|
||
if p > 100 {
|
||
p = 100
|
||
}
|
||
return p
|
||
case int:
|
||
if v < 1 {
|
||
return 1
|
||
}
|
||
if v > 100 {
|
||
return 100
|
||
}
|
||
return v
|
||
}
|
||
return 20
|
||
}
|
||
|
||
// findChapterAndRespond 按条件查章节并返回统一格式
|
||
// 免费判断优先级：system_config.free_chapters / chapter_config.freeChapters > chapters.is_free/price
|
||
// data.content 始终返回完整 HTML；未解锁时的「试读比例」由小程序对渲染后高度做 overflow 裁切（见 miniprogram read _updatePreviewClipHeight）。
|
||
// 纯文本截取 previewContent 仅用于 H5 落地页等，不再用于小程序读章节响应。
|
||
// content 缓存：优先 Redis，命中时仅查元数据（不含 LONGTEXT），未命中时查全量并回填缓存
|
||
func findChapterAndRespond(c *gin.Context, whereFn func(*gorm.DB) *gorm.DB) {
|
||
var ch model.Chapter
|
||
db := database.DB()
|
||
// 1. 先查元数据（不含 content，轻量）
|
||
if err := whereFn(db).Select(chapterMetaCols).First(&ch).Error; err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
c.JSON(http.StatusNotFound, gin.H{"success": false, "error": "章节不存在"})
|
||
return
|
||
}
|
||
c.JSON(http.StatusOK, gin.H{"success": false, "error": err.Error()})
|
||
return
|
||
}
|
||
|
||
// 2. 取 content：优先 Redis，未命中再查 DB
|
||
if content, ok := cache.GetString(context.Background(), cache.KeyChapterContent(ch.MID)); ok && content != "" {
|
||
ch.Content = content
|
||
} else {
|
||
if err := db.Model(&model.Chapter{}).Where("mid = ?", ch.MID).Pluck("content", &ch.Content).Error; err != nil {
|
||
c.JSON(http.StatusOK, gin.H{"success": false, "error": err.Error()})
|
||
return
|
||
}
|
||
cache.SetString(context.Background(), cache.KeyChapterContent(ch.MID), ch.Content, cache.ChapterContentTTL)
|
||
}
|
||
|
||
isFreeFromConfig := getFreeChapterIDs(db)[ch.ID]
|
||
// 管理员显式取消免费（is_free=false 且 price>0）时，config 不覆盖
|
||
adminExplicitPaid := ch.IsFree != nil && !*ch.IsFree && ch.Price != nil && *ch.Price > 0
|
||
isFree := isFreeFromConfig && !adminExplicitPaid
|
||
if !isFree && ch.IsFree != nil && *ch.IsFree {
|
||
isFree = true
|
||
}
|
||
if !isFree && ch.Price != nil && *ch.Price == 0 {
|
||
isFree = true
|
||
}
|
||
|
||
userID := c.Query("userId")
|
||
isPremium := ch.EditionPremium != nil && *ch.EditionPremium
|
||
hasFullAccess := isFree || checkUserChapterAccess(db, userID, ch.ID, isPremium)
|
||
effectivePct := chapterPreviewPercent(db, &ch)
|
||
returnContent := ch.Content
|
||
|
||
chForResponse := ch
|
||
chForResponse.Content = returnContent
|
||
chForResponse.PartTitle = sanitizeChapterTitleField(ch.PartTitle)
|
||
chForResponse.ChapterTitle = sanitizeChapterTitleField(ch.ChapterTitle)
|
||
chForResponse.SectionTitle = sanitizeChapterTitleField(ch.SectionTitle)
|
||
|
||
out := gin.H{
|
||
"success": true,
|
||
"data": chForResponse,
|
||
"content": returnContent,
|
||
"chapterTitle": chForResponse.ChapterTitle,
|
||
"partTitle": chForResponse.PartTitle,
|
||
"id": ch.ID,
|
||
"mid": ch.MID,
|
||
"sectionTitle": chForResponse.SectionTitle,
|
||
"isFree": isFree,
|
||
"hasFullAccess": hasFullAccess,
|
||
"unpaidPreviewPercent": effectivePct,
|
||
"readPreviewUi": mergeReadPreviewUI(db),
|
||
}
|
||
if !hasFullAccess {
|
||
out["previewPercent"] = effectivePct
|
||
}
|
||
// 文章详情内直接输出上一篇/下一篇，按同一本书过滤，省去单独请求
|
||
if allList := getOrderedChapterList(); len(allList) > 0 {
|
||
// 只保留同一 book_id 的章节，避免跨书跳转
|
||
var list []model.Chapter
|
||
for _, item := range allList {
|
||
if item.BookID == ch.BookID {
|
||
list = append(list, item)
|
||
}
|
||
}
|
||
idx := -1
|
||
for i, item := range list {
|
||
if item.ID == ch.ID {
|
||
idx = i
|
||
break
|
||
}
|
||
}
|
||
if idx >= 0 {
|
||
toItem := func(c *model.Chapter) gin.H {
|
||
if c == nil {
|
||
return nil
|
||
}
|
||
t := sanitizeChapterTitleField(c.SectionTitle)
|
||
if t == "" {
|
||
t = sanitizeChapterTitleField(c.ChapterTitle)
|
||
}
|
||
return gin.H{"id": c.ID, "mid": c.MID, "title": t}
|
||
}
|
||
if idx > 0 {
|
||
out["prev"] = toItem(&list[idx-1])
|
||
} else {
|
||
out["prev"] = nil
|
||
}
|
||
if idx < len(list)-1 {
|
||
out["next"] = toItem(&list[idx+1])
|
||
} else {
|
||
out["next"] = nil
|
||
}
|
||
}
|
||
}
|
||
if isFreeFromConfig {
|
||
out["price"] = float64(0)
|
||
} else if ch.Price != nil {
|
||
out["price"] = *ch.Price
|
||
}
|
||
c.JSON(http.StatusOK, out)
|
||
}
|
||
|
||
// BookChapters GET/POST/PUT/DELETE /api/book/chapters（与 app/api/book/chapters 一致，用 GORM）
|
||
func BookChapters(c *gin.Context) {
|
||
db := database.DB()
|
||
switch c.Request.Method {
|
||
case http.MethodGet:
|
||
partId := c.Query("partId")
|
||
status := c.Query("status")
|
||
if status == "" {
|
||
status = "published"
|
||
}
|
||
page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
|
||
pageSize, _ := strconv.Atoi(c.DefaultQuery("pageSize", "100"))
|
||
if page < 1 {
|
||
page = 1
|
||
}
|
||
if pageSize < 1 || pageSize > 500 {
|
||
pageSize = 100
|
||
}
|
||
q := db.Model(&model.Chapter{})
|
||
if partId != "" {
|
||
q = q.Where("part_id = ?", partId)
|
||
}
|
||
if status != "" && status != "all" {
|
||
q = q.Where("status = ?", status)
|
||
}
|
||
var total int64
|
||
q.Count(&total)
|
||
var list []model.Chapter
|
||
q.Order("sort_order ASC, id ASC").Offset((page - 1) * pageSize).Limit(pageSize).Find(&list)
|
||
totalPages := int(total) / pageSize
|
||
if int(total)%pageSize > 0 {
|
||
totalPages++
|
||
}
|
||
c.JSON(http.StatusOK, gin.H{
|
||
"success": true,
|
||
"data": gin.H{
|
||
"list": list, "total": total, "page": page, "pageSize": pageSize, "totalPages": totalPages,
|
||
},
|
||
})
|
||
return
|
||
case http.MethodPost:
|
||
var body model.Chapter
|
||
if err := c.ShouldBindJSON(&body); err != nil {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "error": "请求体无效"})
|
||
return
|
||
}
|
||
if body.ID == "" || body.PartID == "" || body.ChapterID == "" {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "error": "缺少必要字段 id/partId/chapterId"})
|
||
return
|
||
}
|
||
if err := db.Create(&body).Error; err != nil {
|
||
c.JSON(http.StatusOK, gin.H{"success": false, "error": err.Error()})
|
||
return
|
||
}
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": body})
|
||
return
|
||
case http.MethodPut:
|
||
var body model.Chapter
|
||
if err := c.ShouldBindJSON(&body); err != nil || body.ID == "" {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "error": "缺少 id"})
|
||
return
|
||
}
|
||
updates := map[string]interface{}{
|
||
"part_title": body.PartTitle, "chapter_title": body.ChapterTitle, "section_title": body.SectionTitle,
|
||
"content": body.Content, "word_count": body.WordCount, "is_free": body.IsFree, "price": body.Price,
|
||
"sort_order": body.SortOrder, "status": body.Status,
|
||
}
|
||
if body.EditionStandard != nil {
|
||
updates["edition_standard"] = body.EditionStandard
|
||
}
|
||
if body.EditionPremium != nil {
|
||
updates["edition_premium"] = body.EditionPremium
|
||
}
|
||
if err := db.Model(&model.Chapter{}).Where("id = ?", body.ID).Updates(updates).Error; err != nil {
|
||
c.JSON(http.StatusOK, gin.H{"success": false, "error": err.Error()})
|
||
return
|
||
}
|
||
c.JSON(http.StatusOK, gin.H{"success": true})
|
||
return
|
||
case http.MethodDelete:
|
||
id := c.Query("id")
|
||
if id == "" {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "error": "缺少 id"})
|
||
return
|
||
}
|
||
if err := db.Where("id = ?", id).Delete(&model.Chapter{}).Error; err != nil {
|
||
c.JSON(http.StatusOK, gin.H{"success": false, "error": err.Error()})
|
||
return
|
||
}
|
||
c.JSON(http.StatusOK, gin.H{"success": true})
|
||
return
|
||
}
|
||
c.JSON(http.StatusOK, gin.H{"success": false, "error": "不支持的请求方法"})
|
||
}
|
||
|
||
// bookHotChaptersSorted 按精选推荐算法排序：阅读量优先，同量按更新时间；排除序言/尾声/附录
|
||
func bookHotChaptersSorted(db *gorm.DB, limit int) []model.Chapter {
|
||
q := db.Model(&model.Chapter{})
|
||
for _, p := range excludeParts {
|
||
q = q.Where("part_title NOT LIKE ?", "%"+p+"%")
|
||
}
|
||
var all []model.Chapter
|
||
if err := q.Order("sort_order ASC, id ASC").Find(&all).Error; err != nil || len(all) == 0 {
|
||
return nil
|
||
}
|
||
sortChaptersByNaturalID(all)
|
||
// 从 user_tracks(view_chapter) 统计浏览量（含未登录/朋友圈单页 PV）
|
||
ids := make([]string, 0, len(all))
|
||
for _, c := range all {
|
||
ids = append(ids, c.ID)
|
||
}
|
||
var counts []struct {
|
||
SectionID string `gorm:"column:section_id"`
|
||
Cnt int64 `gorm:"column:cnt"`
|
||
}
|
||
if len(ids) > 0 {
|
||
db.Table("user_tracks").Select("chapter_id AS section_id, COUNT(*) AS cnt").
|
||
Where("action = ? AND chapter_id IS NOT NULL AND chapter_id != '' AND chapter_id IN ?", "view_chapter", ids).
|
||
Group("chapter_id").Scan(&counts)
|
||
}
|
||
countMap := make(map[string]int64)
|
||
for _, r := range counts {
|
||
countMap[r.SectionID] = r.Cnt
|
||
}
|
||
// 按阅读量降序、同量按 updated_at 降序
|
||
type withSort struct {
|
||
ch model.Chapter
|
||
cnt int64
|
||
}
|
||
withCnt := make([]withSort, 0, len(all))
|
||
for _, c := range all {
|
||
withCnt = append(withCnt, withSort{ch: c, cnt: countMap[c.ID]})
|
||
}
|
||
for i := 0; i < len(withCnt)-1; i++ {
|
||
for j := i + 1; j < len(withCnt); j++ {
|
||
if withCnt[j].cnt > withCnt[i].cnt ||
|
||
(withCnt[j].cnt == withCnt[i].cnt && withCnt[j].ch.UpdatedAt.After(withCnt[i].ch.UpdatedAt)) {
|
||
withCnt[i], withCnt[j] = withCnt[j], withCnt[i]
|
||
}
|
||
}
|
||
}
|
||
out := make([]model.Chapter, 0, limit)
|
||
for i := 0; i < limit && i < len(withCnt); i++ {
|
||
out = append(out, withCnt[i].ch)
|
||
}
|
||
return out
|
||
}
|
||
|
||
// BookHot GET /api/book/hot 热门章节（按阅读量排序，排除序言/尾声/附录；支持 ?limit=，最大 50）
|
||
// Redis 缓存 5min，章节更新时失效
|
||
func BookHot(c *gin.Context) {
|
||
limit := 10
|
||
if l := c.Query("limit"); l != "" {
|
||
if n, err := strconv.Atoi(l); err == nil && n > 0 && n <= 50 {
|
||
limit = n
|
||
}
|
||
}
|
||
// 优先 Redis
|
||
var cached []model.Chapter
|
||
if cache.Get(context.Background(), cache.KeyBookHot(limit), &cached) && len(cached) > 0 {
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": cached})
|
||
return
|
||
}
|
||
list := bookHotChaptersSorted(database.DB(), limit)
|
||
if len(list) == 0 {
|
||
q := database.DB().Model(&model.Chapter{})
|
||
for _, p := range excludeParts {
|
||
q = q.Where("part_title NOT LIKE ?", "%"+p+"%")
|
||
}
|
||
q.Order("sort_order ASC, id ASC").Limit(10).Find(&list)
|
||
sortChaptersByNaturalID(list)
|
||
}
|
||
cache.Set(context.Background(), cache.KeyBookHot(limit), list, cache.BookRelatedTTL)
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": list})
|
||
}
|
||
|
||
// bookRecommendedMaxList 与小程序「展开更多」上限一致；排序统一走 computeArticleRankingSections
|
||
const bookRecommendedMaxList = 50
|
||
|
||
func sliceRecommendedResponse(full []gin.H, limit int) []gin.H {
|
||
if limit <= 0 || len(full) == 0 {
|
||
return []gin.H{}
|
||
}
|
||
if limit > len(full) {
|
||
limit = len(full)
|
||
}
|
||
return append([]gin.H(nil), full[:limit]...)
|
||
}
|
||
|
||
// BookRecommended GET /api/book/recommended 精选推荐（首页；?limit= 默认 3，最大 50，顺序与后台排行榜一致）
|
||
// Redis 缓存全量最多 50 条 5min，章节更新时失效
|
||
func BookRecommended(c *gin.Context) {
|
||
limit := 3
|
||
if l := c.Query("limit"); l != "" {
|
||
if n, err := strconv.Atoi(l); err == nil && n > 0 && n <= bookRecommendedMaxList {
|
||
limit = n
|
||
}
|
||
}
|
||
|
||
var fullCached []gin.H
|
||
if cache.Get(context.Background(), cache.KeyBookRecommendedList, &fullCached) && len(fullCached) > 0 {
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": sliceRecommendedResponse(fullCached, limit)})
|
||
return
|
||
}
|
||
|
||
sections, err := computeArticleRankingSections(database.DB())
|
||
if err != nil || len(sections) == 0 {
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": []gin.H{}})
|
||
return
|
||
}
|
||
cacheN := bookRecommendedMaxList
|
||
if len(sections) < cacheN {
|
||
cacheN = len(sections)
|
||
}
|
||
tags := []string{"热门", "推荐", "精选"}
|
||
fullList := make([]gin.H, 0, cacheN)
|
||
for i := 0; i < cacheN; i++ {
|
||
s := sections[i]
|
||
tag := tags[i%len(tags)]
|
||
fullList = append(fullList, gin.H{
|
||
"id": s.ID,
|
||
"mid": s.MID,
|
||
"sectionTitle": s.Title,
|
||
"partTitle": s.PartTitle,
|
||
"chapterTitle": s.ChapterTitle,
|
||
"tag": tag,
|
||
"isFree": s.IsFree,
|
||
"price": s.Price,
|
||
"isNew": s.IsNew,
|
||
})
|
||
}
|
||
cache.Set(context.Background(), cache.KeyBookRecommendedList, fullList, cache.BookRelatedTTL)
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": sliceRecommendedResponse(fullList, limit)})
|
||
}
|
||
|
||
// BookLatestChapters GET /api/book/latest-chapters 最新更新（按 updated_at 降序，排除序言/尾声/附录）
|
||
// Redis 缓存 5min，首页「最新更新」主接口
|
||
func BookLatestChapters(c *gin.Context) {
|
||
var list []model.Chapter
|
||
if cache.Get(context.Background(), cache.KeyBookLatestChapters, &list) && len(list) > 0 {
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": list})
|
||
return
|
||
}
|
||
db := database.DB()
|
||
q := db.Model(&model.Chapter{}).Select(allChaptersSelectCols)
|
||
for _, p := range excludeParts {
|
||
q = q.Where("part_title NOT LIKE ?", "%"+p+"%")
|
||
}
|
||
if err := q.Order("updated_at DESC, id ASC").Limit(20).Find(&list).Error; err != nil {
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": []interface{}{}})
|
||
return
|
||
}
|
||
sort.Slice(list, func(i, j int) bool {
|
||
if !list[i].UpdatedAt.Equal(list[j].UpdatedAt) {
|
||
return list[i].UpdatedAt.After(list[j].UpdatedAt)
|
||
}
|
||
return naturalLessSectionID(list[i].ID, list[j].ID)
|
||
})
|
||
applyFreeChapterConfig(list, getFreeChapterIDs(db))
|
||
cache.Set(context.Background(), cache.KeyBookLatestChapters, list, cache.BookRelatedTTL)
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": list})
|
||
}
|
||
|
||
// WarmLatestChaptersCache 启动时预热最新章节 Redis 缓存（首页主接口）
|
||
func WarmLatestChaptersCache() {
|
||
var list []model.Chapter
|
||
if cache.Get(context.Background(), cache.KeyBookLatestChapters, &list) && len(list) > 0 {
|
||
return
|
||
}
|
||
db := database.DB()
|
||
q := db.Model(&model.Chapter{}).Select(allChaptersSelectCols)
|
||
for _, p := range excludeParts {
|
||
q = q.Where("part_title NOT LIKE ?", "%"+p+"%")
|
||
}
|
||
if err := q.Order("updated_at DESC, id ASC").Limit(20).Find(&list).Error; err != nil {
|
||
return
|
||
}
|
||
sort.Slice(list, func(i, j int) bool {
|
||
if !list[i].UpdatedAt.Equal(list[j].UpdatedAt) {
|
||
return list[i].UpdatedAt.After(list[j].UpdatedAt)
|
||
}
|
||
return naturalLessSectionID(list[i].ID, list[j].ID)
|
||
})
|
||
applyFreeChapterConfig(list, getFreeChapterIDs(db))
|
||
cache.Set(context.Background(), cache.KeyBookLatestChapters, list, cache.BookRelatedTTL)
|
||
}
|
||
|
||
func escapeLikeBook(s string) string {
|
||
s = strings.ReplaceAll(s, "\\", "\\\\")
|
||
s = strings.ReplaceAll(s, "%", "\\%")
|
||
s = strings.ReplaceAll(s, "_", "\\_")
|
||
return s
|
||
}
|
||
|
||
// BookSearch GET /api/book/search?q= 章节搜索（与 /api/search 逻辑一致）
|
||
func BookSearch(c *gin.Context) {
|
||
q := strings.TrimSpace(c.Query("q"))
|
||
if q == "" {
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "results": []interface{}{}, "total": 0, "keyword": ""})
|
||
return
|
||
}
|
||
pattern := "%" + escapeLikeBook(q) + "%"
|
||
var list []model.Chapter
|
||
err := database.DB().Model(&model.Chapter{}).
|
||
Where("section_title LIKE ? OR content LIKE ?", pattern, pattern).
|
||
Order("sort_order ASC, id ASC").
|
||
Limit(20).
|
||
Find(&list).Error
|
||
if err != nil {
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "results": []interface{}{}, "total": 0, "keyword": q})
|
||
return
|
||
}
|
||
sortChaptersByNaturalID(list)
|
||
lowerQ := strings.ToLower(q)
|
||
results := make([]gin.H, 0, len(list))
|
||
for _, ch := range list {
|
||
matchType := "content"
|
||
if strings.Contains(strings.ToLower(ch.SectionTitle), lowerQ) {
|
||
matchType = "title"
|
||
}
|
||
results = append(results, gin.H{
|
||
"id": ch.ID, "mid": ch.MID, "title": ch.SectionTitle, "part": ch.PartTitle, "chapter": ch.ChapterTitle,
|
||
"isFree": ch.IsFree, "matchType": matchType,
|
||
})
|
||
}
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "results": results, "total": len(results), "keyword": q})
|
||
}
|
||
|
||
// BookStats GET /api/book/stats
|
||
// Redis 缓存 5min，章节更新时失效
|
||
func BookStats(c *gin.Context) {
|
||
type statsData struct {
|
||
TotalChapters int64 `json:"totalChapters"`
|
||
FreeChapters int `json:"freeChapters"`
|
||
}
|
||
var cached statsData
|
||
if cache.Get(context.Background(), cache.KeyBookStats, &cached) {
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": cached})
|
||
return
|
||
}
|
||
db := database.DB()
|
||
var total int64
|
||
db.Model(&model.Chapter{}).Count(&total)
|
||
freeIDs := getFreeChapterIDs(db)
|
||
var dbFreeCount int64
|
||
db.Model(&model.Chapter{}).Where("is_free = ? OR price = 0", true).Count(&dbFreeCount)
|
||
freeCount := len(freeIDs)
|
||
if int(dbFreeCount) > freeCount {
|
||
freeCount = int(dbFreeCount)
|
||
}
|
||
out := statsData{TotalChapters: total, FreeChapters: freeCount}
|
||
cache.Set(context.Background(), cache.KeyBookStats, out, cache.BookRelatedTTL)
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": out})
|
||
}
|
||
|
||
// BookSync GET/POST /api/book/sync
|
||
func BookSync(c *gin.Context) {
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "message": "同步由 DB 维护"})
|
||
}
|
||
|
||
// BookRanking GET /api/miniprogram/book/ranking 内容排行榜（与 BookRecommended 同一套 computeArticleRankingSections）
|
||
func BookRanking(c *gin.Context) {
|
||
limit := 50
|
||
if l := c.Query("limit"); l != "" {
|
||
if n, err := strconv.Atoi(l); err == nil && n > 0 && n <= 200 {
|
||
limit = n
|
||
}
|
||
}
|
||
sections, err := computeArticleRankingSections(database.DB())
|
||
if err != nil {
|
||
c.JSON(http.StatusInternalServerError, gin.H{"success": false, "message": "排行榜计算失败"})
|
||
return
|
||
}
|
||
if len(sections) > limit {
|
||
sections = sections[:limit]
|
||
}
|
||
out := make([]gin.H, 0, len(sections))
|
||
for _, s := range sections {
|
||
out = append(out, gin.H{
|
||
"id": s.ID, "mid": s.MID, "title": s.Title,
|
||
"partTitle": s.PartTitle, "chapterTitle": s.ChapterTitle,
|
||
"hotScore": s.HotScore, "isPinned": s.IsPinned,
|
||
"price": s.Price, "isFree": s.IsFree, "isNew": s.IsNew,
|
||
})
|
||
}
|
||
c.JSON(http.StatusOK, gin.H{"success": true, "data": out})
|
||
}
|