Unify organize ingest pipeline

internal/handler/downloads_extra.go

@@ -71,8 +71,8 @@ func downloadOrganizeOneHandler(svc *service.Container) gin.HandlerFunc {
 // existing OrganizerService for each library that contains those files.
 func downloadOrganizeAllHandler(svc *service.Container) gin.HandlerFunc {
 	return func(c *gin.Context) {
-		// Walk each library and re-organize. The OrganizerService is
-		// idempotent so this is safe to run repeatedly.
+		// Walk each library through the unified organize pipeline so rename,
+		// scan, scrape and task reporting stay identical to manual organize.
 		libs, err := svc.Repo.Library.List(c.Request.Context())
 		if err != nil {
 			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
@@ -80,15 +80,17 @@ func downloadOrganizeAllHandler(svc *service.Container) gin.HandlerFunc {
 		}
 		results := make([]any, 0, len(libs))
 		for _, l := range libs {
-			res, err := svc.Organizer.OrganizeLibrary(c.Request.Context(), l.ID)
+			resp, err := organizePipeline(svc).Run(c.Request.Context(), service.OrganizePipelineRequest{
+				Scope:     service.OrganizeScopeLibrary,
+				Trigger:   service.OrganizeTriggerManual,
+				TaskName:  "批量整理媒体库：" + l.Name,
+				LibraryID: l.ID,
+			})
 			if err != nil {
 				results = append(results, gin.H{"library": l.Name, "error": err.Error()})
 				continue
 			}
-			if svc.Scan != nil && res != nil && !res.DryRun {
-				res.Scans, res.Scrapes = scanAndScrapeAfterOrganize(c, svc, res.DestPath, l.ID, nil)
-			}
-			results = append(results, gin.H{"library": l.Name, "result": res})
+			results = append(results, gin.H{"library": l.Name, "result": resp.Result})
 		}
 		c.JSON(http.StatusOK, gin.H{"results": results})
 	}

internal/handler/media_favorite.go

@@ -129,15 +129,17 @@ func organizeBulkHandler(svc *service.Container) gin.HandlerFunc {
 		}
 		out := make([]any, 0, len(libs))
 		for _, l := range libs {
-			res, err := svc.Organizer.OrganizeLibrary(c.Request.Context(), l.ID)
+			resp, err := organizePipeline(svc).Run(c.Request.Context(), service.OrganizePipelineRequest{
+				Scope:     service.OrganizeScopeLibrary,
+				Trigger:   service.OrganizeTriggerManual,
+				TaskName:  "批量整理媒体库：" + l.Name,
+				LibraryID: l.ID,
+			})
 			if err != nil {
 				out = append(out, gin.H{"library": l.Name, "error": err.Error()})
 				continue
 			}
-			if svc.Scan != nil && res != nil && !res.DryRun {
-				res.Scans, res.Scrapes = scanAndScrapeAfterOrganize(c, svc, res.DestPath, l.ID, nil)
-			}
-			out = append(out, gin.H{"library": l.Name, "result": res})
+			out = append(out, gin.H{"library": l.Name, "result": resp.Result})
 		}
 		c.JSON(http.StatusOK, gin.H{"results": out})
 	}

internal/handler/organizer.go

@@ -57,22 +57,18 @@ func organizeMediaHandler(svc *service.Container) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		var req organizeReq
 		_ = c.ShouldBindJSON(&req)
-		opts := organizeOptionsFromReq(req)
-		task := startOrganizeHTTPTask(svc, "手动整理媒体", opts)
-		dst, err := svc.Organizer.OrganizeMediaWithOptions(c.Request.Context(), c.Param("id"), opts)
+		runReq := organizePipelineRequestFromReq(req, service.OrganizeScopeMedia, "手动整理媒体")
+		runReq.MediaID = c.Param("id")
+		resp, err := organizePipeline(svc).Run(c.Request.Context(), runReq)
 		if err != nil {
-			finishHTTPTask(task, err, "organize", "手动整理媒体失败", nil, nil)
 			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 			return
 		}
-		payload := gin.H{"path": dst}
-		if organizeScanAfter(req.ScanAfter) && !req.DryRun && svc.Scan != nil {
-			updateHTTPTask(task, "scan_scrape", "正在扫描入库并按设置刮削", nil, nil)
-			scans, scrapes := scanAndScrapeAfterOrganize(c, svc, dst, strings.TrimSpace(req.LibraryID), req.ScrapeAfter)
-			payload["scans"] = scans
-			payload["scrapes"] = scrapes
+		payload := gin.H{"path": resp.Path}
+		if resp.Result != nil {
+			payload["scans"] = resp.Result.Scans
+			payload["scrapes"] = resp.Result.Scrapes
 		}
-		finishHTTPTask(task, nil, "completed", "手动整理媒体结束", nil, nil)
 		c.JSON(http.StatusOK, payload)
 	}
 }
@@ -81,21 +77,14 @@ func organizeLibraryHandler(svc *service.Container) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		var req organizeReq
 		_ = c.ShouldBindJSON(&req)
-		opts := organizeOptionsFromReq(req)
-		task := startOrganizeHTTPTask(svc, "手动整理媒体库", opts)
-		res, err := svc.Organizer.OrganizeLibraryWithOptions(c.Request.Context(), c.Param("id"), opts)
+		runReq := organizePipelineRequestFromReq(req, service.OrganizeScopeLibrary, "手动整理媒体库")
+		runReq.LibraryID = c.Param("id")
+		resp, err := organizePipeline(svc).Run(c.Request.Context(), runReq)
 		if err != nil {
-			finishHTTPTask(task, err, "organize", "手动整理媒体库失败", nil, nil)
 			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 			return
 		}
-		details := service.OrganizeTaskDetails(res, 8)
-		if organizeScanAfter(req.ScanAfter) && !req.DryRun && svc.Scan != nil {
-			updateHTTPTask(task, "scan_scrape", "正在扫描入库并按设置刮削", service.OrganizeTaskMetrics(res), details)
-			res.Scans, res.Scrapes = scanAndScrapeAfterOrganize(c, svc, res.DestPath, c.Param("id"), req.ScrapeAfter)
-		}
-		finishHTTPTask(task, nil, "completed", "手动整理媒体库结束", service.OrganizeTaskMetrics(res), details)
-		c.JSON(http.StatusOK, res)
+		c.JSON(http.StatusOK, resp.Result)
 	}
 }
 
@@ -113,63 +102,40 @@ func organizeDirectoryHandler(svc *service.Container) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		var req organizeReq
 		_ = c.ShouldBindJSON(&req)
-		opts := organizeOptionsFromReq(req)
-		task := startOrganizeHTTPTask(svc, "手动整理入库", opts)
-		res, err := svc.Organizer.OrganizeDirectory(c.Request.Context(), opts)
+		runReq := organizePipelineRequestFromReq(req, service.OrganizeScopeDirectory, "手动整理入库")
+		runReq.PreferredLibraryID = strings.TrimSpace(req.LibraryID)
+		resp, err := organizePipeline(svc).Run(c.Request.Context(), runReq)
 		if err != nil {
-			finishHTTPTask(task, err, "organize", "手动整理入库失败", nil, nil)
 			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 			return
 		}
-		details := service.OrganizeTaskDetails(res, 8)
-		updateHTTPTask(task, "organize", "手动整理完成，准备扫描入库", service.OrganizeTaskMetrics(res), details)
-		if organizeScanAfter(req.ScanAfter) && !req.DryRun && svc.Scan != nil {
-			updateHTTPTask(task, "scan_scrape", "正在扫描入库并按设置刮削", service.OrganizeTaskMetrics(res), details)
-			res.Scans, res.Scrapes = scanAndScrapeAfterOrganize(c, svc, res.DestPath, strings.TrimSpace(req.LibraryID), req.ScrapeAfter)
-		}
-		finishHTTPTask(task, nil, "completed", "手动整理入库结束", service.OrganizeTaskMetrics(res), details)
-		c.JSON(http.StatusOK, res)
+		c.JSON(http.StatusOK, resp.Result)
 	}
 }
 
-func startOrganizeHTTPTask(svc *service.Container, name string, opts service.OrganizeOptions) *service.TaskHandle {
-	if svc == nil || svc.Tasks == nil {
-		return nil
+func organizePipelineRequestFromReq(req organizeReq, scope service.OrganizeScope, taskName string) service.OrganizePipelineRequest {
+	dest := strings.TrimSpace(req.DestPath)
+	if dest == "" {
+		dest = strings.TrimSpace(req.TargetPath)
 	}
-	message := "正在整理/重命名/入库"
-	if opts.DryRun {
-		message = "正在预览整理/重命名"
+	return service.OrganizePipelineRequest{
+		Scope:         scope,
+		Trigger:       service.OrganizeTriggerManual,
+		TaskName:      taskName,
+		SourcePath:    strings.TrimSpace(req.SourcePath),
+		DestPath:      dest,
+		TransferMode:  strings.TrimSpace(req.TransferMode),
+		MediaType:     strings.TrimSpace(req.MediaType),
+		MediaCategory: strings.TrimSpace(req.MediaCategory),
+		ScanAfter:     req.ScanAfter,
+		ScrapeAfter:   req.ScrapeAfter,
+		DryRun:        req.DryRun,
 	}
-	return svc.Tasks.Start(service.TaskKindOrganize, name, service.TaskUpdate{
-		Stage:      "organize",
-		SourcePath: opts.SourcePath,
-		DestPath:   opts.DestPath,
-		Message:    message,
-	})
 }
 
-func updateHTTPTask(task *service.TaskHandle, stage, message string, metrics map[string]int64, details []string) {
-	if task == nil {
-		return
+func organizePipeline(svc *service.Container) *service.OrganizePipelineService {
+	if svc.OrganizePipeline != nil {
+		return svc.OrganizePipeline
 	}
-	task.Update(service.TaskUpdate{Stage: stage, Message: message, Metrics: metrics, Details: details})
-}
-
-func finishHTTPTask(task *service.TaskHandle, err error, stage, message string, metrics map[string]int64, details []string) {
-	if task == nil {
-		return
-	}
-	task.Finish(err, service.TaskUpdate{Stage: stage, Message: message, Metrics: metrics, Details: details})
-}
-
-func scanAndScrapeAfterOrganize(c *gin.Context, svc *service.Container, destRoot, preferredLibraryID string, scrapeOverride *bool) ([]service.OrganizeScanSummary, []service.OrganizeScrapeSummary) {
-	scrapeAfter := service.OrganizeScrapeAfterEnabled(c.Request.Context(), svc.Repo)
-	if scrapeOverride != nil {
-		scrapeAfter = *scrapeOverride
-	}
-	return svc.Scan.ScanAndScrapeLibrariesForPath(c.Request.Context(), destRoot, preferredLibraryID, scrapeAfter)
-}
-
-func organizeScanAfter(value *bool) bool {
-	return value == nil || *value
+	return service.NewOrganizePipelineService(svc.Log, svc.Repo, svc.Organizer, svc.Scan, svc.Tasks)
 }

internal/handler/routes_authenticated.go

@@ -91,6 +91,7 @@ func registerAuthenticatedRoutes(api *gin.RouterGroup, cfg *config.Config, svc *
 
 		// Subscriptions.
 		authed.GET("/subscriptions", requirePermission(svc, "can_manage_subscriptions"), listSubscriptionsHandler(svc))
+		authed.GET("/subscriptions/history", requirePermission(svc, "can_manage_subscriptions"), listSubscriptionHistoryHandler(svc))
 		authed.POST("/subscriptions", requirePermission(svc, "can_manage_subscriptions"), createSubscriptionHandler(svc))
 		authed.DELETE("/subscriptions/:id", requirePermission(svc, "can_manage_subscriptions"), deleteSubscriptionHandler(svc))
 		authed.POST("/subscriptions/:id/run", requirePermission(svc, "can_manage_subscriptions"), runSubscriptionHandler(svc))

internal/handler/subscriptions.go

@@ -98,6 +98,18 @@ func listSubscriptionsHandler(svc *service.Container) gin.HandlerFunc {
 	}
 }
 
+func listSubscriptionHistoryHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		items, err := svc.Subscription.History(c.Request.Context())
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		service.EnrichSubscriptionProgress(c.Request.Context(), svc.Repo, items)
+		c.JSON(http.StatusOK, gin.H{"items": items})
+	}
+}
+
 func deleteSubscriptionHandler(svc *service.Container) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		if err := svc.Subscription.Delete(c.Request.Context(), c.Param("id")); err != nil {

internal/handler/system_extra.go

@@ -76,30 +76,6 @@ func schemaHandler(_ *service.Container) gin.HandlerFunc {
 						{"key": "ffprobe.max_concurrent", "type": "number", "label": "FFprobe 最大并发"},
 					},
 				},
-				{
-					"key":   "organize",
-					"label": "整理 & 刮削",
-					"items": []gin.H{
-						{"key": "organize.auto", "type": "toggle", "label": "整理源目录定时自动整理"},
-						{"key": "organizer.auto_after_download", "type": "toggle"},
-						{"key": "organize.scrape_after", "type": "toggle", "label": "整理后自动刮削"},
-						{"key": "downloads.smart_classify", "type": "toggle"},
-						{"key": "organizer.smart_classify", "type": "toggle"},
-						{"key": "organize.source_dir", "type": "text", "label": "整理源目录"},
-						{"key": "organize.target_dir", "type": "text", "label": "整理目的地目录"},
-						{"key": "organize.transfer_mode", "type": "select", "label": "默认转移方式"},
-						{"key": "organize.interval_seconds", "type": "number", "label": "自动整理间隔秒数"},
-						{"key": "organize.keep_seeding", "type": "toggle", "label": "保种"},
-						{"key": "organize.movie_format", "type": "text"},
-						{"key": "organize.tv_format", "type": "text"},
-						{"key": "organize.anime_format", "type": "text"},
-						{"key": "scrape.auto_on_scan", "type": "toggle"},
-						{"key": "scrape.providers", "type": "text"},
-						{"key": "scrape.language", "type": "text"},
-						{"key": "scrape.delay_min_ms", "type": "number", "label": "刮削最小间隔毫秒"},
-						{"key": "scrape.delay_max_ms", "type": "number", "label": "刮削最大间隔毫秒"},
-					},
-				},
 				{
 					"key":   "cloud-upload",
 					"label": "网盘转存",

internal/handler/task_helpers.go

@@ -0,0 +1,10 @@
+package handler
+
+import "github.com/ShukeBta/MediaStationGo/internal/service"
+
+func finishHTTPTask(task *service.TaskHandle, err error, stage, message string, metrics map[string]int64, details []string) {
+	if task == nil {
+		return
+	}
+	task.Finish(err, service.TaskUpdate{Stage: stage, Message: message, Metrics: metrics, Details: details})
+}