mirror of
https://github.com/truewhile/MeBox.git
synced 2026-09-30 03:36:37 +08:00
ShukeBta
524 lines
18 KiB
Go
524 lines
18 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"go.uber.org/zap"
|
|
|
|
"github.com/ShukeBta/MediaStationGo/internal/model"
|
|
)
|
|
|
|
type organizeDirectoryLayout struct {
|
|
MediaType string
|
|
Category string
|
|
}
|
|
|
|
type organizeSourceFileRequest struct {
|
|
Source string
|
|
SourceRoot string
|
|
DestRoot string
|
|
Mode TransferMode
|
|
MediaTypeOverride string
|
|
MediaCategoryOverride string
|
|
DryRun bool
|
|
AllowReplaceExisting bool
|
|
MetadataCache map[string]*Match
|
|
Result *OrganizeResult
|
|
}
|
|
|
|
type organizeSourceIdentity struct {
|
|
Ext string
|
|
Title string
|
|
ParsedTitle string
|
|
Year int
|
|
Season int
|
|
Episode int
|
|
SourceMedia *model.Media
|
|
}
|
|
|
|
type organizeSourceFilePlan struct {
|
|
Identity organizeSourceIdentity
|
|
Layout organizeDirectoryLayout
|
|
LayoutRoot string
|
|
TargetLibraryID string
|
|
MetadataMatch *Match
|
|
Target organizeTargetPath
|
|
}
|
|
|
|
type organizeExistingSourceVersions struct {
|
|
External []string
|
|
Identity []string
|
|
Folder []string
|
|
All []string
|
|
}
|
|
|
|
// organizeSourceFile organizes a single video file from the source directory
|
|
// into destRoot, applying dedup + 洗版.
|
|
func (o *OrganizerService) organizeSourceFile(ctx context.Context, req organizeSourceFileRequest) error {
|
|
plan, err := o.buildOrganizeSourceFilePlan(ctx, req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if filepath.Clean(req.Source) == filepath.Clean(plan.Target.Path) {
|
|
skipAlreadyOrganizedSource(req, plan)
|
|
return nil
|
|
}
|
|
existing := o.collectExistingSourceVersions(ctx, req, plan)
|
|
if len(existing.All) > 0 {
|
|
return o.handleExistingSourceVersions(ctx, req, plan, existing)
|
|
}
|
|
return o.writeOrganizedSourceFile(ctx, req, plan)
|
|
}
|
|
|
|
func (o *OrganizerService) buildOrganizeSourceFilePlan(ctx context.Context, req organizeSourceFileRequest) (organizeSourceFilePlan, error) {
|
|
identity := o.resolveOrganizeSourceIdentity(ctx, req)
|
|
pathLayout := o.inferOrganizeDirectoryLayout(req.Source, req.SourceRoot)
|
|
layout := pathLayout
|
|
forcedType := normalizeOrganizeMediaType(req.MediaTypeOverride)
|
|
inferredType := o.inferMediaTypeForSourceFile(req.Source, identity.Title, identity.Season, identity.Episode)
|
|
layout = applyOrganizeSourceMediaType(layout, forcedType, inferredType)
|
|
lookupType := organizeSourceMetadataLookupType(req.Source, pathLayout, layout, forcedType, inferredType, identity)
|
|
metadataMatch := o.lookupOrganizeSourceMetadata(ctx, req, lookupType, &identity)
|
|
if metadataMatch == nil && lookupType != layout.MediaType {
|
|
metadataMatch = o.lookupOrganizeSourceMetadata(ctx, req, layout.MediaType, &identity)
|
|
}
|
|
if forcedType == "" && metadataMatch != nil {
|
|
if matchType := normalizeOrganizeMediaType(metadataMatch.MediaType); matchType != "" && matchType != layout.MediaType {
|
|
if categoryType, _ := o.mediaTypeForDirectoryCategory(layout.Category); categoryType != "" && !sourceCategoryCompatible(matchType, categoryType) {
|
|
layout.Category = ""
|
|
}
|
|
if o.log != nil {
|
|
o.log.Info("organize media type corrected by metadata",
|
|
zap.String("source", req.Source),
|
|
zap.String("from", layout.MediaType),
|
|
zap.String("to", matchType),
|
|
zap.String("title", metadataMatch.Title),
|
|
zap.Int("tmdb_id", metadataMatch.TMDbID))
|
|
}
|
|
layout.MediaType = matchType
|
|
}
|
|
}
|
|
layout = o.applyOrganizeSourceCategory(ctx, req, pathLayout, layout, forcedType, identity, metadataMatch)
|
|
layoutRoot, targetLibraryID := o.resolveOrganizeSourceLayoutRoot(ctx, req, layout)
|
|
target, err := o.buildOrganizeSourceTarget(ctx, req, layout, layoutRoot, identity)
|
|
if err != nil {
|
|
return organizeSourceFilePlan{}, err
|
|
}
|
|
return organizeSourceFilePlan{
|
|
Identity: identity,
|
|
Layout: layout,
|
|
LayoutRoot: layoutRoot,
|
|
TargetLibraryID: targetLibraryID,
|
|
MetadataMatch: metadataMatch,
|
|
Target: target,
|
|
}, nil
|
|
}
|
|
|
|
func (o *OrganizerService) resolveOrganizeSourceIdentity(ctx context.Context, req organizeSourceFileRequest) organizeSourceIdentity {
|
|
src := req.Source
|
|
ext := filepath.Ext(src)
|
|
season, episode := ParseEpisode(src)
|
|
title, year := CleanQuery(src)
|
|
if organizeWeakFileTitle(title) {
|
|
if folderTitle, folderYear := organizeTitleFromParentFolder(src, req.SourceRoot, season > 0 || episode > 0); folderTitle != "" {
|
|
title = folderTitle
|
|
if year <= 0 {
|
|
year = folderYear
|
|
}
|
|
} else {
|
|
title = strings.TrimSuffix(filepath.Base(src), ext)
|
|
}
|
|
}
|
|
parsedTitle := title
|
|
sourceMedia := o.lookupOrganizeSourceMedia(ctx, src)
|
|
title = sanitizeFilename(titleCaseWords(title))
|
|
if sourceMedia != nil {
|
|
if mediaTitle := sanitizeFilename(strings.TrimSpace(sourceMedia.Title)); mediaTitle != "" {
|
|
title = mediaTitle
|
|
parsedTitle = strings.TrimSpace(sourceMedia.Title)
|
|
}
|
|
if sourceMedia.Year > 0 {
|
|
year = sourceMedia.Year
|
|
}
|
|
if sourceMedia.SeasonNum > 0 {
|
|
season = sourceMedia.SeasonNum
|
|
}
|
|
if sourceMedia.EpisodeNum > 0 {
|
|
episode = sourceMedia.EpisodeNum
|
|
}
|
|
}
|
|
if title == "" {
|
|
title = "Unknown"
|
|
}
|
|
return organizeSourceIdentity{
|
|
Ext: ext,
|
|
Title: title,
|
|
ParsedTitle: parsedTitle,
|
|
Year: year,
|
|
Season: season,
|
|
Episode: episode,
|
|
SourceMedia: sourceMedia,
|
|
}
|
|
}
|
|
|
|
func applyOrganizeSourceMediaType(layout organizeDirectoryLayout, forcedType, inferredType string) organizeDirectoryLayout {
|
|
if forcedType != "" {
|
|
if layout.Category != "" && layout.MediaType != "" && layout.MediaType != forcedType {
|
|
layout.Category = ""
|
|
}
|
|
layout.MediaType = forcedType
|
|
return layout
|
|
}
|
|
if inferredType == "" {
|
|
return layout
|
|
}
|
|
if inferredType == "tv" && layout.MediaType == "movie" {
|
|
return organizeDirectoryLayout{MediaType: inferredType}
|
|
}
|
|
if layout.MediaType == "" {
|
|
layout.MediaType = inferredType
|
|
}
|
|
return layout
|
|
}
|
|
|
|
func organizeSourceMetadataLookupType(src string, pathLayout, layout organizeDirectoryLayout, forcedType, inferredType string, identity organizeSourceIdentity) string {
|
|
if forcedType != "" {
|
|
return layout.MediaType
|
|
}
|
|
if pathLayout.MediaType != "" && pathLayout.MediaType != "movie" && organizeStandaloneMovieSourceHint(src, identity) {
|
|
return "movie"
|
|
}
|
|
return layout.MediaType
|
|
}
|
|
|
|
func organizeStandaloneMovieSourceHint(src string, identity organizeSourceIdentity) bool {
|
|
if identity.Season > 0 || identity.Episode > 0 {
|
|
return organizeEpisodeLooksSourcedFromMovieYear(src, identity)
|
|
}
|
|
_, year := CleanQuery(filepath.Base(src))
|
|
if year <= 0 {
|
|
year = identity.Year
|
|
}
|
|
if year <= 0 {
|
|
return false
|
|
}
|
|
text := strings.ToLower(strings.Join([]string{filepath.Base(src), identity.Title, identity.ParsedTitle}, " "))
|
|
return !classifierEpisodeRE.MatchString(text) && !classifierSeasonRE.MatchString(text)
|
|
}
|
|
|
|
func organizeEpisodeLooksSourcedFromMovieYear(src string, identity organizeSourceIdentity) bool {
|
|
year := identity.Year
|
|
if identity.SourceMedia != nil && identity.SourceMedia.Year > 0 {
|
|
year = identity.SourceMedia.Year
|
|
}
|
|
if year < 1900 || year > 2099 || identity.Season != 1 || identity.Episode != year/10 {
|
|
return false
|
|
}
|
|
showDir := showDirFromEpisodePath(src)
|
|
if showDir == "" {
|
|
return false
|
|
}
|
|
_, folderYear := CleanQuery(filepath.Base(showDir))
|
|
return folderYear == year
|
|
}
|
|
|
|
func (o *OrganizerService) lookupOrganizeSourceMetadata(ctx context.Context, req organizeSourceFileRequest, mediaType string, identity *organizeSourceIdentity) *Match {
|
|
match := o.lookupOrganizeMetadata(ctx, req.Source, req.SourceRoot, mediaType, identity.Title, identity.Year, identity.Season, identity.Episode, req.MetadataCache)
|
|
if match == nil && identity.SourceMedia != nil {
|
|
match = organizeMatchFromMedia(identity.SourceMedia)
|
|
}
|
|
if match != nil {
|
|
applyOrganizeMetadataMatch(match, &identity.Title, &identity.ParsedTitle, &identity.Year)
|
|
}
|
|
return match
|
|
}
|
|
|
|
func (o *OrganizerService) applyOrganizeSourceCategory(
|
|
ctx context.Context,
|
|
req organizeSourceFileRequest,
|
|
pathLayout, layout organizeDirectoryLayout,
|
|
forcedType string,
|
|
identity organizeSourceIdentity,
|
|
metadataMatch *Match,
|
|
) organizeDirectoryLayout {
|
|
if category := strings.TrimSpace(req.MediaCategoryOverride); category != "" {
|
|
layout.Category = sanitizeFilename(category)
|
|
} else if category := o.smartClassifySourceFile(ctx, req.Source, req.SourceRoot, layout.MediaType, identity.Title, identity.ParsedTitle, metadataMatch); category != "" {
|
|
layout.Category = category
|
|
}
|
|
if forcedType == "" {
|
|
if impliedType, normalizedCategory := o.mediaTypeForDirectoryCategory(layout.Category); impliedType != "" {
|
|
layout.Category = normalizedCategory
|
|
if layout.MediaType == "" || layout.MediaType == "tv" || layout.MediaType == "anime" || pathLayout.Category != layout.Category {
|
|
layout.MediaType = impliedType
|
|
}
|
|
}
|
|
}
|
|
return layout
|
|
}
|
|
|
|
func (o *OrganizerService) resolveOrganizeSourceLayoutRoot(ctx context.Context, req organizeSourceFileRequest, layout organizeDirectoryLayout) (string, string) {
|
|
targetLibrary, matchedLibrary := o.organizeLibraryForLayout(ctx, req.DestRoot, layout.MediaType, layout.Category)
|
|
layoutRoot := targetLibrary.Path
|
|
targetLibraryID := targetLibrary.ID
|
|
if !matchedLibrary && layout.MediaType != "" {
|
|
layoutRoot = o.organizeRoot(req.DestRoot, layout.MediaType, layout.Category)
|
|
}
|
|
if !matchedLibrary && layout.Category != "" {
|
|
layoutRoot = categoryRoot(layoutRoot, sanitizeFilename(layout.Category))
|
|
}
|
|
if !matchedLibrary && !req.DryRun {
|
|
if targetLibrary, ok := o.ensureOrganizeLibraryForRoot(ctx, layoutRoot, layout.MediaType, layout.Category); ok {
|
|
targetLibraryID = targetLibrary.ID
|
|
}
|
|
}
|
|
return layoutRoot, targetLibraryID
|
|
}
|
|
|
|
func (o *OrganizerService) buildOrganizeSourceTarget(
|
|
ctx context.Context,
|
|
req organizeSourceFileRequest,
|
|
layout organizeDirectoryLayout,
|
|
layoutRoot string,
|
|
identity organizeSourceIdentity,
|
|
) (organizeTargetPath, error) {
|
|
isSeries := identity.Season > 0 || identity.Episode > 0
|
|
if layout.MediaType != "" {
|
|
isSeries = isSeriesLibraryType(layout.MediaType) && isSeries
|
|
}
|
|
return o.buildOrganizeTargetPath(ctx, organizeTargetInput{
|
|
Root: layoutRoot,
|
|
MediaType: layout.MediaType,
|
|
Category: layout.Category,
|
|
Title: identity.Title,
|
|
Source: req.Source,
|
|
Ext: identity.Ext,
|
|
Year: identity.Year,
|
|
Season: identity.Season,
|
|
Episode: identity.Episode,
|
|
Series: isSeries,
|
|
})
|
|
}
|
|
|
|
func skipAlreadyOrganizedSource(req organizeSourceFileRequest, plan organizeSourceFilePlan) {
|
|
req.Result.Skipped++
|
|
req.Result.Items = append(req.Result.Items, OrganizePreviewItem{
|
|
Source: req.Source, Target: plan.Target.Path, Action: "skip", Reason: organizeSkipAlreadyOrganized,
|
|
MediaType: plan.Layout.MediaType, Category: plan.Layout.Category, Title: plan.Identity.Title,
|
|
})
|
|
}
|
|
|
|
func (o *OrganizerService) collectExistingSourceVersions(ctx context.Context, req organizeSourceFileRequest, plan organizeSourceFilePlan) organizeExistingSourceVersions {
|
|
externalExisting := o.existingByExternalIdentity(ctx, req.DestRoot, plan.MetadataMatch, plan.Identity.Season, plan.Identity.Episode)
|
|
identityExisting := o.existingByIdentity(ctx, req.DestRoot, plan.Identity.ParsedTitle, plan.Identity.Year, plan.Identity.Season, plan.Identity.Episode)
|
|
folderExisting := o.existingByFolder(plan.Target.Dir, plan.Target.EpisodeTag)
|
|
return organizeExistingSourceVersions{
|
|
External: externalExisting,
|
|
Identity: identityExisting,
|
|
Folder: folderExisting,
|
|
All: mergeExistingVersionPaths(externalExisting, identityExisting, folderExisting),
|
|
}
|
|
}
|
|
|
|
func (o *OrganizerService) handleExistingSourceVersions(ctx context.Context, req organizeSourceFileRequest, plan organizeSourceFilePlan, existing organizeExistingSourceVersions) error {
|
|
reclassified, err := o.reclassifyExistingMedia(ctx, organizeExistingReclassifyRequest{
|
|
Source: req.Source,
|
|
Target: plan.Target.Path,
|
|
DestRoot: req.DestRoot,
|
|
TargetLibraryID: plan.TargetLibraryID,
|
|
Existing: existing.All,
|
|
DryRun: req.DryRun,
|
|
MediaType: plan.Layout.MediaType,
|
|
Category: plan.Layout.Category,
|
|
Title: plan.Identity.Title,
|
|
Year: plan.Identity.Year,
|
|
Season: plan.Identity.Season,
|
|
Episode: plan.Identity.Episode,
|
|
MetadataMatch: plan.MetadataMatch,
|
|
Result: req.Result,
|
|
})
|
|
if err != nil || reclassified {
|
|
return err
|
|
}
|
|
if replaced, err := o.replaceSourceWithBetterVersion(ctx, req, plan, existing.All); replaced || err != nil {
|
|
return err
|
|
}
|
|
o.skipExistingSourceDuplicate(ctx, req, plan, existing)
|
|
return nil
|
|
}
|
|
|
|
func (o *OrganizerService) replaceSourceWithBetterVersion(ctx context.Context, req organizeSourceFileRequest, plan organizeSourceFilePlan, existing []string) (bool, error) {
|
|
srcArea := o.resolutionArea(ctx, req.Source)
|
|
bestArea := 0
|
|
for _, e := range existing {
|
|
if a := o.resolutionArea(ctx, e); a > bestArea {
|
|
bestArea = a
|
|
}
|
|
}
|
|
if !req.AllowReplaceExisting || srcArea <= 0 || bestArea <= 0 || srcArea <= bestArea {
|
|
return false, nil
|
|
}
|
|
req.Result.Items = append(req.Result.Items, OrganizePreviewItem{
|
|
Source: req.Source, Target: plan.Target.Path, Action: "replace", Reason: "higher resolution",
|
|
MediaType: plan.Layout.MediaType, Category: plan.Layout.Category, Title: plan.Identity.Title,
|
|
})
|
|
if req.DryRun {
|
|
req.Result.Replaced++
|
|
return true, nil
|
|
}
|
|
if err := o.replaceVersions(ctx, req.Source, existing, plan.Target.Path, req.Mode); err != nil {
|
|
return true, err
|
|
}
|
|
o.log.Info("organize replaced lower-resolution media",
|
|
zap.String("from", req.Source),
|
|
zap.String("to", plan.Target.Path),
|
|
zap.Int("src_area", srcArea),
|
|
zap.Int("existing_area", bestArea),
|
|
)
|
|
req.Result.Replaced++
|
|
return true, nil
|
|
}
|
|
|
|
func (o *OrganizerService) skipExistingSourceDuplicate(ctx context.Context, req organizeSourceFileRequest, plan organizeSourceFilePlan, existing organizeExistingSourceVersions) {
|
|
reason := organizeSkipTargetExists
|
|
if len(existing.External) > 0 || len(existing.Identity) > 0 || o.allExistingPathsInDB(ctx, existing.All) {
|
|
reason = organizeSkipDuplicateLibrary
|
|
}
|
|
o.log.Debug("organize skip duplicate",
|
|
zap.String("src", req.Source), zap.String("dest_dir", plan.Target.Dir), zap.String("reason", reason))
|
|
req.Result.Skipped++
|
|
req.Result.Items = append(req.Result.Items, OrganizePreviewItem{
|
|
Source: req.Source, Target: plan.Target.Path, Action: "skip", Reason: reason,
|
|
MediaType: plan.Layout.MediaType, Category: plan.Layout.Category, Title: plan.Identity.Title,
|
|
})
|
|
}
|
|
|
|
func (o *OrganizerService) writeOrganizedSourceFile(ctx context.Context, req organizeSourceFileRequest, plan organizeSourceFilePlan) error {
|
|
req.Result.Items = append(req.Result.Items, OrganizePreviewItem{
|
|
Source: req.Source, Target: plan.Target.Path, Action: "organize",
|
|
MediaType: plan.Layout.MediaType, Category: plan.Layout.Category, Title: plan.Identity.Title,
|
|
})
|
|
if req.DryRun {
|
|
req.Result.Organized++
|
|
return nil
|
|
}
|
|
if err := os.MkdirAll(plan.Target.Dir, 0o755); err != nil { // #nosec G301 -- organized media directories must remain readable by NAS/player users.
|
|
return err
|
|
}
|
|
if _, err := os.Stat(plan.Target.Path); err == nil {
|
|
req.Result.Skipped++
|
|
if len(req.Result.Items) > 0 {
|
|
req.Result.Items[len(req.Result.Items)-1].Action = "skip"
|
|
req.Result.Items[len(req.Result.Items)-1].Reason = organizeSkipTargetExists
|
|
}
|
|
return nil
|
|
}
|
|
if err := transferFile(req.Source, plan.Target.Path, req.Mode); err != nil {
|
|
return err
|
|
}
|
|
if err := transferSidecarNFO(req.Source, plan.Target.Path, req.Mode); err != nil {
|
|
o.log.Warn("organize sidecar nfo failed",
|
|
zap.String("from", req.Source), zap.String("to", plan.Target.Path), zap.Error(err))
|
|
}
|
|
req.Result.Organized++
|
|
return nil
|
|
}
|
|
|
|
func organizeTitleFromParentFolder(src, sourceRoot string, seriesLike bool) (string, int) {
|
|
if !seriesLike {
|
|
return "", 0
|
|
}
|
|
raw := seriesFolderTitle(src, sourceRoot)
|
|
if strings.TrimSpace(raw) == "" {
|
|
return "", 0
|
|
}
|
|
title, year := CleanQuery(raw)
|
|
if title == "" {
|
|
title = strings.TrimSpace(raw)
|
|
}
|
|
return title, year
|
|
}
|
|
|
|
func shouldSkipOrganizeSourceVideo(path, sourceRoot string) (bool, string) {
|
|
cleanPath := filepath.Clean(path)
|
|
cleanRoot := filepath.Clean(sourceRoot)
|
|
if rel, err := filepath.Rel(cleanRoot, cleanPath); err == nil && rel != "." && !strings.HasPrefix(rel, "..") {
|
|
dir := filepath.Dir(rel)
|
|
if dir != "." {
|
|
for _, part := range strings.Split(dir, string(os.PathSeparator)) {
|
|
switch normalizeOrganizeCategoryKey(part) {
|
|
case "sample", "samples", "trailer", "trailers", "preview", "previews", "teaser", "teasers":
|
|
return true, organizeSkipSampleClip
|
|
}
|
|
}
|
|
}
|
|
}
|
|
base := strings.ToLower(strings.TrimSuffix(filepath.Base(cleanPath), filepath.Ext(cleanPath)))
|
|
normalized := strings.NewReplacer("_", " ", "-", " ", ".", " ").Replace(base)
|
|
fields := strings.Fields(normalized)
|
|
if len(fields) == 0 {
|
|
return false, ""
|
|
}
|
|
if len(fields) == 1 && strings.HasPrefix(fields[0], "sample") {
|
|
return true, organizeSkipSampleClip
|
|
}
|
|
last := fields[len(fields)-1]
|
|
switch last {
|
|
case "sample", "trailer", "preview", "teaser":
|
|
return true, organizeSkipSampleClip
|
|
}
|
|
return false, ""
|
|
}
|
|
|
|
func normalizeOrganizeMediaType(mediaType string) string {
|
|
switch strings.ToLower(strings.TrimSpace(mediaType)) {
|
|
case "movie", "film":
|
|
return "movie"
|
|
case "tv", "series", "show", "drama":
|
|
return "tv"
|
|
case "anime", "animation":
|
|
return "anime"
|
|
case "variety":
|
|
return "variety"
|
|
case "adult", "nsfw":
|
|
return "adult"
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
func organizeWeakFileTitle(title string) bool {
|
|
title = strings.TrimSpace(title)
|
|
if title == "" {
|
|
return true
|
|
}
|
|
fields := strings.Fields(strings.ToLower(title))
|
|
if len(fields) == 0 {
|
|
return true
|
|
}
|
|
meaningful := 0
|
|
for _, field := range fields {
|
|
if _, ok := noiseTokenSet[field]; ok {
|
|
continue
|
|
}
|
|
if _, ok := releaseBoundaryTokenSet[field]; ok {
|
|
continue
|
|
}
|
|
if len(field) == 4 && strings.HasPrefix(field, "20") {
|
|
continue
|
|
}
|
|
meaningful++
|
|
}
|
|
return meaningful == 0
|
|
}
|
|
|
|
func (o *OrganizerService) inferMediaTypeForSourceFile(src, title string, season, episode int) string {
|
|
if season > 0 || episode > 0 {
|
|
return "tv"
|
|
}
|
|
return normalizeMediaType("", title, src)
|
|
}
|