优化

internal/service/manual_scrape_providers.go

@@ -32,18 +32,21 @@ func (s *ScraperService) manualTMDbCandidates(ctx context.Context, query string,
 	for _, typ := range manualTMDbSearchTypes(mediaType) {
 		switch typ {
 		case "movie":
-			if matches, err := s.tmdb.SearchMovieCandidates(ctx, query, year); err == nil {
+			if matches, err := s.tmdb.SearchMovieCandidates(ctx, query, year); err == nil && len(matches) > 0 {
 				for _, match := range matches {
 					out = append(out, manualTMDbCandidate{MediaType: "movie", Match: match})
 				}
 			}
 		case "tv":
-			if matches, err := s.tmdb.SearchTVCandidates(ctx, query, year); err == nil {
+			if matches, err := s.tmdb.SearchTVCandidates(ctx, query, year); err == nil && len(matches) > 0 {
 				for _, match := range matches {
 					out = append(out, manualTMDbCandidate{MediaType: "tv", Match: match})
 				}
 			}
 		}
+		if len(out) > 0 {
+			break
+		}
 	}
 	return out
 }
@@ -70,15 +73,15 @@ func manualTMDbIDSearchTypes(mediaType string) []string {
 
 func manualTMDbSearchTypes(mediaType string) []string {
 	if strings.TrimSpace(mediaType) == "" {
-		return []string{"movie", "tv"}
+		return []string{"tv", "movie"}
 	}
 	switch normalizeMediaType(mediaType, "", "") {
 	case "tv", "anime", "variety":
 		return []string{"tv", "movie"}
 	case "movie", "adult":
-		return []string{"movie"}
-	default:
 		return []string{"movie", "tv"}
+	default:
+		return []string{"tv", "movie"}
 	}
 }
 

internal/service/manual_scrape_test.go

@@ -179,9 +179,9 @@ func TestManualSearchFallsBackToMovieFolderForGenericQuery(t *testing.T) {
 	if len(results) != 1 || results[0].TMDbID != 27205 {
 		t.Fatalf("manual search results=%#v, want folder fallback candidate; queries=%v", results, queries)
 	}
-	if len(queries) < 2 || queries[0] != "00000" || queries[1] != "inception" {
-		t.Fatalf("manual search queries=%v, want explicit query then folder fallback", queries)
-	}
+		if len(queries) < 2 || queries[0] != "00000" || queries[len(queries)-1] != "inception" {
+			t.Fatalf("manual search queries=%v, want explicit query then folder fallback", queries)
+		}
 }
 
 func TestManualSearchReturnsMovieFallbackForTVTypedTMDbSearch(t *testing.T) {

internal/service/media_library_roots.go

@@ -52,7 +52,14 @@ func (s *MediaService) CreateLibraryWithRootsAndCover(ctx context.Context, name,
 		s.invalidateMediaCache(ctx)
 		return lib, nil
 	}
-	lib := &model.Library{Name: strings.TrimSpace(name), Path: roots[0].Path, Type: kind, CoverURL: strings.TrimSpace(coverURL), Enabled: true}
+	lib := &model.Library{
+		Name:            strings.TrimSpace(name),
+		Path:            roots[0].Path,
+		Type:            kind,
+		CoverURL:        strings.TrimSpace(coverURL),
+		Enabled:         true,
+		CarouselEnabled: false,
+	}
 	if err := s.repo.Library.CreateWithRoots(ctx, lib, roots); err != nil {
 		return nil, err
 	}

internal/service/scraper_queue.go

@@ -0,0 +1,354 @@
+package service
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"go.uber.org/zap"
+
+	"github.com/ShukeBta/MMTL/internal/model"
+)
+
+type ScrapeQueueCounts struct {
+	Pending  int64 `json:"pending"`
+	Running  int64 `json:"running"`
+	Done     int64 `json:"done"`
+	Failed   int64 `json:"failed"`
+	Canceled int64 `json:"canceled"`
+}
+
+type ScrapeQueueSnapshot struct {
+	Counts   ScrapeQueueCounts  `json:"counts"`
+	Tasks    []model.ScrapeTask `json:"tasks"`
+	Total    int64              `json:"total"`
+	Page     int                `json:"page"`
+	PageSize int                `json:"page_size"`
+}
+
+// Start 启动刮削任务队列的后台消费者。
+func (s *ScraperService) Start(ctx context.Context) {
+	if s == nil {
+		return
+	}
+	go s.queueWorker(ctx)
+}
+
+func (s *ScraperService) queueWorker(ctx context.Context) {
+	const claimBatch = 4
+	sem := make(chan struct{}, 2) // 最大并发刮削数：2
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		default:
+		}
+
+		tasks, err := s.repo.ScrapeTask.ClaimPending(ctx, claimBatch)
+		if err != nil {
+			if s.log != nil {
+				s.log.Warn("claim pending scrape task failed", zap.Error(err))
+			}
+			sleepContext(ctx, 3*time.Second)
+			continue
+		}
+		if len(tasks) == 0 {
+			sleepContext(ctx, 2*time.Second)
+			continue
+		}
+
+		var wg sync.WaitGroup
+		for i := range tasks {
+			wg.Add(1)
+			go func(t *model.ScrapeTask) {
+				defer wg.Done()
+				select {
+				case <-ctx.Done():
+					return
+				case sem <- struct{}{}:
+				}
+				defer func() { <-sem }()
+
+				s.processScrapeTask(ctx, t)
+			}(&tasks[i])
+		}
+		wg.Wait()
+	}
+}
+
+func (s *ScraperService) processScrapeTask(ctx context.Context, task *model.ScrapeTask) {
+	media, err := s.repo.Media.FindByID(ctx, task.MediaID)
+	if err != nil || media == nil {
+		now := time.Now()
+		task.Status = model.ScrapeTaskFailed
+		task.Error = "媒体项已不存在或被删除"
+		task.FinishedAt = &now
+		_ = s.repo.ScrapeTask.Update(ctx, task)
+		return
+	}
+
+	epArtwork := task.EpisodeImages
+	options := ScrapeOptions{
+		EpisodeArtwork: &epArtwork,
+		IncludeMatched: task.RefreshMatched,
+		RetryNoMatch:   true,
+	}
+
+	enrichErr := s.EnrichOneWithOptions(ctx, media, options)
+	now := time.Now()
+	task.FinishedAt = &now
+
+	refreshed, _ := s.repo.Media.FindByID(ctx, media.ID)
+	if refreshed != nil && refreshed.ScrapeStatus == "matched" {
+		task.Status = model.ScrapeTaskDone
+		task.Error = ""
+		task.MatchedTitle = refreshed.Title
+		task.MatchedYear = refreshed.Year
+		task.PosterURL = refreshed.PosterURL
+		task.BackdropURL = refreshed.BackdropURL
+		if refreshed.TMDbID > 0 {
+			task.Provider = "tmdb"
+		} else if strings.TrimSpace(refreshed.DoubanID) != "" {
+			task.Provider = "douban"
+		} else if refreshed.BangumiID > 0 {
+			task.Provider = "bangumi"
+		} else if strings.TrimSpace(refreshed.TheTVDBID) != "" {
+			task.Provider = "thetvdb"
+		} else {
+			task.Provider = "metatube"
+		}
+	} else {
+		task.Status = model.ScrapeTaskFailed
+		if enrichErr != nil {
+			task.Error = enrichErr.Error()
+		} else if refreshed != nil && refreshed.ScrapeStatus == "no_match" {
+			task.Error = "未搜索到匹配的元数据"
+		} else {
+			task.Error = "刮削未完成匹配"
+		}
+	}
+
+	_ = s.repo.ScrapeTask.Update(ctx, task)
+
+	if s.hub != nil {
+		s.hub.Publish("scraper_queue", map[string]any{
+			"task_id": task.ID,
+			"status":  task.Status,
+			"title":   task.MediaTitle,
+		})
+	}
+}
+
+func (s *ScraperService) mediaKind(m *model.Media, lib *model.Library) string {
+	if m == nil {
+		return ""
+	}
+	if lib != nil && lib.Type != "" {
+		return lib.Type
+	}
+	if mediaIsEpisodic(m, lib) {
+		return "tv"
+	}
+	return "movie"
+}
+
+// EnqueueMedia 把单个媒体项放入刮削队列。
+func (s *ScraperService) EnqueueMedia(ctx context.Context, mediaID string, options ScrapeOptions) (*model.ScrapeTask, error) {
+	if s == nil || s.repo == nil {
+		return nil, errors.New("scraper service not initialized")
+	}
+	media, err := s.repo.Media.FindByID(ctx, mediaID)
+	if err != nil || media == nil {
+		return nil, errors.New("media not found")
+	}
+
+	if active, _ := s.repo.ScrapeTask.FindActiveByMediaID(ctx, mediaID); active != nil {
+		return active, nil
+	}
+
+	libName := ""
+	var lib *model.Library
+	if strings.TrimSpace(media.LibraryID) != "" {
+		lib, _ = s.repo.Library.FindByID(ctx, media.LibraryID)
+		if lib != nil {
+			libName = lib.Name
+		}
+	}
+
+	task := &model.ScrapeTask{
+		MediaID:        media.ID,
+		LibraryID:      media.LibraryID,
+		LibraryName:    libName,
+		MediaTitle:     media.Title,
+		MediaPath:      media.Path,
+		MediaType:      s.mediaKind(media, lib),
+		Status:         model.ScrapeTaskPending,
+		EpisodeImages:  options.episodeArtworkEnabled(),
+		RefreshMatched: options.IncludeMatched || options.RefreshWeakMatched,
+	}
+
+	if err := s.repo.ScrapeTask.Create(ctx, task); err != nil {
+		return nil, err
+	}
+	return task, nil
+}
+
+// EnqueueLibrary 把指定媒体库内的所有候选媒体批量推入刮削队列。
+func (s *ScraperService) EnqueueLibrary(ctx context.Context, libraryID string, options ScrapeOptions) (int, error) {
+	if s == nil || s.repo == nil {
+		return 0, errors.New("scraper service not initialized")
+	}
+
+	lib, err := s.repo.Library.FindByID(ctx, libraryID)
+	if err != nil || lib == nil {
+		return 0, errors.New("library not found")
+	}
+
+	rows, err := s.scrapeCandidateRows(ctx, libraryID, options)
+	if err != nil {
+		return 0, err
+	}
+	if len(rows) == 0 {
+		return 0, nil
+	}
+
+	tasks := make([]model.ScrapeTask, 0, len(rows))
+	for _, m := range rows {
+		tasks = append(tasks, model.ScrapeTask{
+			MediaID:        m.ID,
+			LibraryID:      lib.ID,
+			LibraryName:    lib.Name,
+			MediaTitle:     m.Title,
+			MediaPath:      m.Path,
+			MediaType:      s.mediaKind(&m, lib),
+			Status:         model.ScrapeTaskPending,
+			EpisodeImages:  options.episodeArtworkEnabled(),
+			RefreshMatched: options.IncludeMatched || options.RefreshWeakMatched,
+		})
+	}
+
+	if err := s.repo.ScrapeTask.CreateBatch(ctx, tasks); err != nil {
+		return 0, err
+	}
+	return len(tasks), nil
+}
+
+// EnqueueAll 把所有已启用媒体库的媒体推入刮削队列。
+func (s *ScraperService) EnqueueAll(ctx context.Context, options ScrapeOptions) (int, error) {
+	libs, err := s.repo.Library.List(ctx)
+	if err != nil {
+		return 0, err
+	}
+	total := 0
+	for _, lib := range libs {
+		if !lib.Enabled {
+			continue
+		}
+		n, err := s.EnqueueLibrary(ctx, lib.ID, options)
+		if err != nil {
+			if s.log != nil {
+				s.log.Warn("enqueue library for scrape failed", zap.String("library", lib.ID), zap.Error(err))
+			}
+			continue
+		}
+		total += n
+	}
+	return total, nil
+}
+
+func (s *ScraperService) ScrapeQueueSnapshot(ctx context.Context, status string, page, pageSize int) (*ScrapeQueueSnapshot, error) {
+	tasks, total, err := s.repo.ScrapeTask.List(ctx, status, page, pageSize)
+	if err != nil {
+		return nil, err
+	}
+	countsMap, err := s.repo.ScrapeTask.CountByStatus(ctx)
+	if err != nil {
+		return nil, err
+	}
+	snap := &ScrapeQueueSnapshot{
+		Counts: ScrapeQueueCounts{
+			Pending:  countsMap[model.ScrapeTaskPending],
+			Running:  countsMap[model.ScrapeTaskRunning],
+			Done:     countsMap[model.ScrapeTaskDone],
+			Failed:   countsMap[model.ScrapeTaskFailed],
+			Canceled: countsMap[model.ScrapeTaskCanceled],
+		},
+		Tasks:    tasks,
+		Total:    total,
+		Page:     page,
+		PageSize: pageSize,
+	}
+	return snap, nil
+}
+
+func (s *ScraperService) CancelScrapeTask(ctx context.Context, id string) error {
+	task, err := s.repo.ScrapeTask.FindByID(ctx, id)
+	if err != nil || task == nil {
+		return errors.New("刮削任务不存在")
+	}
+	if task.Status != model.ScrapeTaskPending && task.Status != model.ScrapeTaskRunning {
+		return errors.New("任务已完成或已终止，无法取消")
+	}
+	now := time.Now()
+	task.Status = model.ScrapeTaskCanceled
+	task.Error = "已取消"
+	task.FinishedAt = &now
+	return s.repo.ScrapeTask.Update(ctx, task)
+}
+
+func (s *ScraperService) RetryScrapeTask(ctx context.Context, id string) error {
+	task, err := s.repo.ScrapeTask.FindByID(ctx, id)
+	if err != nil || task == nil {
+		return errors.New("刮削任务不存在")
+	}
+	if task.Status != model.ScrapeTaskFailed && task.Status != model.ScrapeTaskCanceled {
+		return errors.New("只有失败或已取消的任务可以重试")
+	}
+	task.Status = model.ScrapeTaskPending
+	task.Error = ""
+	task.RetryCount = 0
+	task.StartedAt = nil
+	task.FinishedAt = nil
+	return s.repo.ScrapeTask.Update(ctx, task)
+}
+
+func (s *ScraperService) DeleteScrapeTask(ctx context.Context, id string) error {
+	return s.repo.ScrapeTask.Delete(ctx, id)
+}
+
+func (s *ScraperService) BatchActionScrapeTasks(ctx context.Context, action string, ids []string) (int64, error) {
+	switch action {
+	case "delete":
+		return s.repo.ScrapeTask.DeleteBatch(ctx, ids)
+	case "retry":
+		return s.repo.ScrapeTask.RetryBatch(ctx, ids)
+	case "cancel":
+		return s.repo.ScrapeTask.CancelBatch(ctx, ids)
+	default:
+		return 0, fmt.Errorf("不支持的操作: %s", action)
+	}
+}
+
+func (s *ScraperService) ClearDoneScrapeTasks(ctx context.Context) (int64, error) {
+	return s.repo.ScrapeTask.ClearDone(ctx)
+}
+
+func (s *ScraperService) ClearFinishedScrapeTasks(ctx context.Context) (int64, error) {
+	return s.repo.ScrapeTask.ClearFinished(ctx)
+}
+
+func (s *ScraperService) ClearCanceledScrapeTasks(ctx context.Context) (int64, error) {
+	return s.repo.ScrapeTask.ClearCanceled(ctx)
+}
+
+func (s *ScraperService) RetryAllFailedScrapeTasks(ctx context.Context) (int64, error) {
+	return s.repo.ScrapeTask.RetryAllFailed(ctx)
+}
+
+func (s *ScraperService) CancelPendingScrapeTasks(ctx context.Context) (int64, error) {
+	return s.repo.ScrapeTask.CancelPending(ctx)
+}

internal/service/service.go

@@ -102,7 +102,12 @@ func (c *Container) Boot() {
 		c.Strm.Start(c.stopCtx)
 	}
 
-	// Mgo 保号规则巡检：默认关闭，由管理员通过 Telegram Bot 命令开启。
+		// 启动刮削队列后台消费者
+		if c.Scraper != nil {
+			c.Scraper.Start(c.stopCtx)
+		}
+
+		// Mgo 保号规则巡检：默认关闭，由管理员通过 Telegram Bot 命令开启。
 	// 每天触发一次评估；规则里的窗口可随机，不固定。
 	if c.Device != nil {
 		go c.runInactivitySweeper(c.stopCtx)

internal/service/tmdb_search.go

@@ -57,7 +57,7 @@ func (t *TMDbProvider) searchMovieCandidates(ctx context.Context, query string,
 
 	apiKey := t.resolveAPIKey(ctx)
 	if apiKey == "" {
-		return nil, nil
+		return nil, errors.New("TMDb API Key 未配置，请先在「系统设置 → API配置」中填写")
 	}
 	base := t.resolveBaseURL(ctx)
 
@@ -65,7 +65,7 @@ func (t *TMDbProvider) searchMovieCandidates(ctx context.Context, query string,
 	q.Set("api_key", apiKey)
 	q.Set("query", query)
 	q.Set("language", language)
-	q.Set("include_adult", "false")
+	q.Set("include_adult", "true")
 	if year > 0 {
 		q.Set("year", fmt.Sprintf("%d", year))
 	}
@@ -79,6 +79,12 @@ func (t *TMDbProvider) searchMovieCandidates(ctx context.Context, query string,
 	if err := t.getJSON(ctx, u, &p); err != nil {
 		return nil, err
 	}
+	if len(p.Results) == 0 && year > 0 {
+		// 移除年份限制重试一次，避免年份微小差异（如 2019 vs 2020）导致无搜索结果
+		q.Del("year")
+		u = base + "/search/movie?" + q.Encode()
+		_ = t.getJSON(ctx, u, &p)
+	}
 	if len(p.Results) == 0 {
 		return nil, nil
 	}
@@ -137,7 +143,7 @@ func (t *TMDbProvider) searchTVCandidates(ctx context.Context, query string, yea
 
 	apiKey := t.resolveAPIKey(ctx)
 	if apiKey == "" {
-		return nil, nil
+		return nil, errors.New("TMDb API Key 未配置，请先在「系统设置 → API配置」中填写")
 	}
 	base := t.resolveBaseURL(ctx)
 
@@ -145,7 +151,7 @@ func (t *TMDbProvider) searchTVCandidates(ctx context.Context, query string, yea
 	q.Set("api_key", apiKey)
 	q.Set("query", query)
 	q.Set("language", language)
-	q.Set("include_adult", "false")
+	q.Set("include_adult", "true")
 	if year > 0 {
 		q.Set("first_air_date_year", fmt.Sprintf("%d", year))
 	}
@@ -159,6 +165,12 @@ func (t *TMDbProvider) searchTVCandidates(ctx context.Context, query string, yea
 	if err := t.getJSON(ctx, u, &p); err != nil {
 		return nil, err
 	}
+	if len(p.Results) == 0 && year > 0 {
+		// 移除年份限制重试一次，避免年份微小差异导致无搜索结果
+		q.Del("first_air_date_year")
+		u = base + "/search/tv?" + q.Encode()
+		_ = t.getJSON(ctx, u, &p)
+	}
 	if len(p.Results) == 0 {
 		return nil, nil
 	}