feat: align smart media classification paths

internal/handler/system_extra.go

@@ -74,7 +74,7 @@ func schemaHandler(_ *service.Container) gin.HandlerFunc {
 					"key":   "organize",
 					"label": "整理 & 刮削",
 					"items": []gin.H{
-						{"key": "organize.auto", "type": "toggle"},
+						{"key": "organizer.auto_after_download", "type": "toggle"},
 						{"key": "organizer.smart_classify", "type": "toggle"},
 						{"key": "organize.movie_format", "type": "text"},
 						{"key": "organize.tv_format", "type": "text"},

internal/service/downloads.go

@@ -491,13 +491,18 @@ func (d *DownloadService) onTorrentComplete(ctx context.Context, hash string, sa
 	if d.organizer == nil || savePath == "" {
 		return
 	}
-	// 仅当显式开启 organizer.auto_after_download 时才在下载完成后整理。
+	// 仅当显式开启 organizer.auto_after_download / organize.auto 时才在下载完成后整理。
 	// 之前的代码错误地把 organizer.smart_classify 也当成"自动整理"开关，
 	// 让操作员只想启用"分类子目录"就被动触发了文件 move。
 	autoOrganize := false
 	if v, err := d.repo.Setting.Get(ctx, "organizer.auto_after_download"); err == nil {
 		autoOrganize = v == "true" || v == "1" || v == "on"
 	}
+	if !autoOrganize {
+		if v, err := d.repo.Setting.Get(ctx, "organize.auto"); err == nil {
+			autoOrganize = v == "true" || v == "1" || v == "on"
+		}
+	}
 	if !autoOrganize {
 		d.log.Info("download completed, auto-organize disabled", zap.String("hash", hash))
 		return

internal/service/media_classifier.go

@@ -219,9 +219,6 @@ func (s *SubscriptionService) resolveSubscriptionSavePath(ctx context.Context, s
 	if !s.isSmartClassifyEnabled(ctx) || category == "" {
 		return base
 	}
-	if mediaType != "" {
-		return filepath.Join(base, mediaType, sanitizeFilename(category))
-	}
 	return filepath.Join(base, sanitizeFilename(category))
 }
 

internal/service/media_classifier_test.go

@@ -91,7 +91,7 @@ func TestSubscriptionResolveClassifiedSavePath(t *testing.T) {
 		t.Fatalf("classification = %q/%q, want tv/综艺", mediaType, category)
 	}
 	got := svc.resolveSubscriptionSavePath(t.Context(), sub, mediaType, category)
-	want := filepath.Join("D:", "Downloads", "tv", "综艺")
+	want := filepath.Join("D:", "Downloads", "综艺")
 	if got != want {
 		t.Fatalf("save path = %q, want %q", got, want)
 	}

internal/service/organizer.go

@@ -59,7 +59,7 @@ func (o *OrganizerService) OrganizeMedia(ctx context.Context, mediaID string) (s
 	if err != nil || lib == nil {
 		return "", errors.New("library not found")
 	}
-	if lib.Type == "tv" || lib.Type == "anime" {
+	if isSeriesLibraryType(lib.Type) {
 		if err := o.refreshEpisodeIdentity(m, lib); err != nil {
 			return "", err
 		}
@@ -74,13 +74,14 @@ func (o *OrganizerService) OrganizeMedia(ctx context.Context, mediaID string) (s
 	category := o.SmartClassify(ctx, m)
 
 	var dst string
-	if lib.Type == "tv" || lib.Type == "anime" {
+	if isSeriesLibraryType(lib.Type) {
 		// TV: {lib.Path}/[分类]/{Title}/Season XX/{Title} - SxxExx.ext
 		season := fmt.Sprintf("Season %02d", m.SeasonNum)
 		epTag := fmt.Sprintf("S%02dE%02d", m.SeasonNum, m.EpisodeNum)
-		dir := filepath.Join(lib.Path, category, title, season)
+		root := o.organizeRoot(lib.Path, lib.Type, category)
+		dir := filepath.Join(root, category, title, season)
 		if category == "" {
-			dir = filepath.Join(lib.Path, title, season)
+			dir = filepath.Join(root, title, season)
 		}
 		dst = filepath.Join(dir, fmt.Sprintf("%s - %s%s", title, epTag, ext))
 	} else {
@@ -89,9 +90,10 @@ func (o *OrganizerService) OrganizeMedia(ctx context.Context, mediaID string) (s
 		if m.Year > 0 {
 			folder = fmt.Sprintf("%s (%d)", title, m.Year)
 		}
-		dir := filepath.Join(lib.Path, category, folder)
+		root := o.organizeRoot(lib.Path, lib.Type, category)
+		dir := filepath.Join(root, category, folder)
 		if category == "" {
-			dir = filepath.Join(lib.Path, folder)
+			dir = filepath.Join(root, folder)
 		}
 		dst = filepath.Join(dir, folder+ext)
 	}
@@ -268,6 +270,55 @@ func sanitizeFilename(s string) string {
 	return strings.TrimSpace(r.Replace(s))
 }
 
+func (o *OrganizerService) organizeRoot(libraryPath, mediaType, category string) string {
+	if strings.TrimSpace(category) == "" {
+		return libraryPath
+	}
+	typeDir := mediaTypeRootDir(mediaType)
+	if typeDir == "" || pathAlreadyEndsWith(libraryPath, typeDir) {
+		return libraryPath
+	}
+	if isGenericMediaRoot(libraryPath) {
+		return filepath.Join(libraryPath, typeDir)
+	}
+	return libraryPath
+}
+
+func mediaTypeRootDir(mediaType string) string {
+	switch normalizeMediaType(mediaType, "", "") {
+	case "movie":
+		return "电影"
+	case "tv", "anime", "variety":
+		return "电视剧"
+	default:
+		return ""
+	}
+}
+
+func isGenericMediaRoot(path string) bool {
+	base := strings.ToLower(strings.TrimSpace(filepath.Base(filepath.Clean(path))))
+	switch base {
+	case "media", "medias", "library", "libraries", "organized", "整理":
+		return true
+	default:
+		return false
+	}
+}
+
+func pathAlreadyEndsWith(path, suffix string) bool {
+	base := strings.TrimSpace(filepath.Base(filepath.Clean(path)))
+	return strings.EqualFold(base, suffix)
+}
+
+func isSeriesLibraryType(mediaType string) bool {
+	switch normalizeMediaType(mediaType, "", "") {
+	case "tv", "anime", "variety":
+		return true
+	default:
+		return false
+	}
+}
+
 // isSmartClassifyEnabled checks if smart classify is enabled.
 // It first checks the database setting, then falls back to config.yaml.
 func (o *OrganizerService) isSmartClassifyEnabled(ctx context.Context) bool {

internal/service/organizer_test.go

@@ -121,3 +121,58 @@ func TestOrganizeMediaUsesEpisodeNFOSeason(t *testing.T) {
 		t.Fatalf("dst = %q, want %q", dst, want)
 	}
 }
+
+func TestOrganizeMediaAddsMoviePilotStyleTypeRootForGenericMediaRoot(t *testing.T) {
+	root := t.TempDir()
+	mediaRoot := filepath.Join(root, "media")
+	sourceDir := filepath.Join(root, "downloads", "国产剧")
+	if err := os.MkdirAll(sourceDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	source := filepath.Join(sourceDir, "Some Show S01E02.mkv")
+	if err := os.WriteFile(source, []byte("episode"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := db.AutoMigrate(&model.Library{}, &model.Media{}, &model.Setting{}); err != nil {
+		t.Fatal(err)
+	}
+	repos := repository.New(db)
+	if err := repos.Setting.Set(t.Context(), "organizer.smart_classify", "true"); err != nil {
+		t.Fatal(err)
+	}
+	lib := model.Library{Name: "媒体库", Path: mediaRoot, Type: "tv", Enabled: true}
+	if err := repos.Library.Create(t.Context(), &lib); err != nil {
+		t.Fatal(err)
+	}
+	media := model.Media{
+		LibraryID:    lib.ID,
+		Title:        "Some Show",
+		Path:         source,
+		Container:    "mkv",
+		Countries:    "CN",
+		SeasonNum:    1,
+		EpisodeNum:   2,
+		ScrapeStatus: "matched",
+	}
+	if err := repos.Media.Upsert(t.Context(), &media); err != nil {
+		t.Fatal(err)
+	}
+
+	organizer := NewOrganizerService(&config.Config{}, zap.NewNop(), repos)
+	dst, err := organizer.OrganizeMedia(t.Context(), media.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := filepath.Join(mediaRoot, "电视剧", "国产剧", "Some Show", "Season 01", "Some Show - S01E02.mkv")
+	if dst != want {
+		t.Fatalf("dst = %q, want %q", dst, want)
+	}
+	if _, err := os.Stat(want); err != nil {
+		t.Fatalf("organized file missing: %v", err)
+	}
+}