public void TestMixedExpressions()
{
var files = new[]
{
"Bad Boys (2006) part1.mkv",
"Bad Boys (2006) part2.mkv",
"Bad Boys (2006) part3.mkv",
"Bad Boys (2006) part4.mkv",
"Bad Boys (2006)-trailer.mkv",
"300 (2006) parta.mkv",
"300 (2006) partb.mkv",
"300 (2006) partc.mkv",
"300 (2006) partd.mkv",
"300 (2006)-trailer.mkv",
"300a.mkv",
"300b.mkv",
"300c.mkv",
"300-trailer.mkv"
};
var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
Assert.Equal(3, result.Count);
TestStackInfo(result[0], "300 (2006)", 4);
TestStackInfo(result[1], "300", 3);
TestStackInfo(result[2], "Bad Boys (2006)", 4);
}
/// <summary>
/// Resolves Name, Year and differentiate alternative files and extras from regular audiobook files.
/// </summary>
/// <param name="files">List of files related to audiobook.</param>
/// <returns>Returns IEnumerable of <see cref="AudioBookInfo"/>.</returns>
public IEnumerable <AudioBookInfo> Resolve(IEnumerable <FileSystemMetadata> files)
{
// File with empty fullname will be sorted out here.
var audiobookFileInfos = files
.Select(i => _audioBookResolver.Resolve(i.FullName))
.OfType <AudioBookFileInfo>()
.ToList();
var stackResult = StackResolver.ResolveAudioBooks(audiobookFileInfos);
foreach (var stack in stackResult)
{
var stackFiles = stack.Files
.Select(i => _audioBookResolver.Resolve(i))
.OfType <AudioBookFileInfo>()
.ToList();
stackFiles.Sort();
var nameParserResult = new AudioBookNameParser(_options).Parse(stack.Name);
FindExtraAndAlternativeFiles(ref stackFiles, out var extras, out var alternativeVersions, nameParserResult);
var info = new AudioBookInfo(
nameParserResult.Name,
nameParserResult.Year,
stackFiles,
extras,
alternativeVersions);
yield return(info);
}
}
public void TestMixed()
{
var files = new[]
{
new FileSystemMetadata {
FullName = "Bad Boys (2006) part1.mkv", IsDirectory = false
},
new FileSystemMetadata {
FullName = "Bad Boys (2006) part2.mkv", IsDirectory = false
},
new FileSystemMetadata {
FullName = "300 (2006) part2", IsDirectory = true
},
new FileSystemMetadata {
FullName = "300 (2006) part3", IsDirectory = true
},
new FileSystemMetadata {
FullName = "300 (2006) part1", IsDirectory = true
}
};
var result = StackResolver.Resolve(files, _namingOptions).ToList();
Assert.Equal(2, result.Count);
TestStackInfo(result[0], "300 (2006)", 3);
TestStackInfo(result[1], "Bad Boys (2006)", 2);
}
public IEnumerable <AudioBookInfo> Resolve(IEnumerable <FileSystemMetadata> files)
{
var audioBookResolver = new AudioBookResolver(_options);
var audiobookFileInfos = files
.Select(i => audioBookResolver.Resolve(i.FullName, i.IsDirectory))
.Where(i => i != null)
.ToList();
// Filter out all extras, otherwise they could cause stacks to not be resolved
// See the unit test TestStackedWithTrailer
var metadata = audiobookFileInfos
.Select(i => new FileSystemMetadata
{
FullName = i.Path,
IsDirectory = i.IsDirectory
});
var stackResult = new StackResolver(_options)
.ResolveAudioBooks(metadata);
foreach (var stack in stackResult)
{
var stackFiles = stack.Files.Select(i => audioBookResolver.Resolve(i, stack.IsDirectoryStack)).ToList();
stackFiles.Sort();
var info = new AudioBookInfo
{
Files = stackFiles,
Name = stack.Name
};
yield return(info);
}
}
/// <summary>
/// Gets the multi disc movie.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="multiDiscFolders">The folders.</param>
/// <param name="directoryService">The directory service.</param>
/// <returns>``0.</returns>
private T GetMultiDiscMovie <T>(List <FileSystemInfo> multiDiscFolders, IDirectoryService directoryService)
where T : Video, new()
{
var videoTypes = new List <VideoType>();
var folderPaths = multiDiscFolders.Select(i => i.FullName).Where(i =>
{
var subfolders = directoryService.GetDirectories(i)
.Select(d => d.Name)
.ToList();
if (subfolders.Any(IsDvdDirectory))
{
videoTypes.Add(VideoType.Dvd);
return(true);
}
if (subfolders.Any(IsBluRayDirectory))
{
videoTypes.Add(VideoType.BluRay);
return(true);
}
return(false);
}).OrderBy(i => i).ToList();
// If different video types were found, don't allow this
if (videoTypes.Distinct().Count() > 1)
{
return(null);
}
if (folderPaths.Count == 0)
{
return(null);
}
var resolver = new StackResolver(new ExtendedNamingOptions(), new Naming.Logging.NullLogger());
var result = resolver.ResolveDirectories(folderPaths);
if (result.Stacks.Count != 1)
{
return(null);
}
return(new T
{
Path = folderPaths[0],
IsMultiPart = true,
VideoType = videoTypes[0],
Name = result.Stacks[0].Name
});
}
public void TestFalsePositives4()
{
var files = new[]
{
"300 2006.mkv",
"300 2007.mkv"
};
var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
Assert.Empty(result);
}
public void TestFalsePositives5()
{
var files = new[]
{
"Star Trek 1 - The motion picture.mkv",
"Star Trek 2- The wrath of khan.mkv"
};
var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
Assert.Empty(result);
}
public void TestStackName()
{
var files = new[]
{
"d:/movies/300 2006 part1.mkv",
"d:/movies/300 2006 part2.mkv"
};
var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
Assert.Single(result);
TestStackInfo(result[0], "300 2006", 2);
}
public void TestFalsePositives6()
{
var files = new[]
{
"Red Riding in the Year of Our Lord 1983 (2009).mkv",
"Red Riding in the Year of Our Lord 1980 (2009).mkv",
"Red Riding in the Year of Our Lord 1974 (2009).mkv"
};
var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
Assert.Empty(result);
}
public void TestDirectories()
{
var files = new[]
{
"blah blah - cd 1",
"blah blah - cd 2"
};
var result = StackResolver.ResolveDirectories(files, _namingOptions).ToList();
Assert.Single(result);
TestStackInfo(result[0], "blah blah", 2);
}
public void TestMultiDiscs()
{
// No stacking here because there is no part/disc/etc
var files = new[]
{
@"M:/Movies (DVD)/Movies (Musical)/The Sound of Music/The Sound of Music (1965) (Disc 01)",
@"M:/Movies (DVD)/Movies (Musical)/The Sound of Music/The Sound of Music (1965) (Disc 02)"
};
var result = StackResolver.ResolveDirectories(files, _namingOptions).ToList();
Assert.Single(result);
Assert.Equal(2, result[0].Files.Count);
}
public void TestNumbersAppearingBeforePartNumber()
{
// No stacking here because there is no part/disc/etc
var files = new[]
{
"Neverland (2011)[720p][PG][Voted 6.5][Family-Fantasy]part1.mkv",
"Neverland (2011)[720p][PG][Voted 6.5][Family-Fantasy]part2.mkv"
};
var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
Assert.Single(result);
Assert.Equal(2, result[0].Files.Count);
}
public void ResolveFiles_GivenPartInMiddleOfName_ReturnsNoStack()
{
var files = new[]
{
"Bad Boys (2006).part1.stv.unrated.multi.1080p.bluray.x264-rough.mkv",
"Bad Boys (2006).part2.stv.unrated.multi.1080p.bluray.x264-rough.mkv",
"Bad Boys (2006).part3.stv.unrated.multi.1080p.bluray.x264-rough.mkv",
"Bad Boys (2006).part4.stv.unrated.multi.1080p.bluray.x264-rough.mkv",
"Bad Boys (2006)-trailer.mkv"
};
var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
Assert.Empty(result);
}
public void ResolveFiles_FileNamesWithMissingPartType_ReturnsNoStack()
{
var files = new[]
{
"Bad Boys (2006).mkv",
"Bad Boys (2006) 1.mkv",
"Bad Boys (2006) 2.mkv",
"Bad Boys (2006) 3.mkv",
"Bad Boys (2006)-trailer.mkv"
};
var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
Assert.Empty(result);
}
public IEnumerable <AudioBookInfo> Resolve(IEnumerable <FileSystemMetadata> files)
{
var audioBookResolver = new AudioBookResolver(_options);
var audiobookFileInfos = files
.Select(i => audioBookResolver.Resolve(i.FullName, i.IsDirectory))
.Where(i => i != null)
.ToList();
// Filter out all extras, otherwise they could cause stacks to not be resolved
// See the unit test TestStackedWithTrailer
var metadata = audiobookFileInfos
.Select(i => new FileSystemMetadata
{
FullName = i.Path,
IsDirectory = i.IsDirectory
});
var stackResult = new StackResolver(_options)
.ResolveAudioBooks(metadata);
var list = new List <AudioBookInfo>();
foreach (var stack in stackResult.Stacks)
{
var stackFiles = stack.Files.Select(i => audioBookResolver.Resolve(i, stack.IsDirectoryStack)).ToList();
stackFiles.Sort();
var info = new AudioBookInfo
{
Files = stackFiles,
Name = stack.Name
};
list.Add(info);
}
// Whatever files are left, just add them
/*list.AddRange(remainingFiles.Select(i => new AudioBookInfo
* {
* Files = new List<AudioBookFileInfo> { i },
* Name = i.,
* Year = i.Year
* }));*/
var orderedList = list.OrderBy(i => i.Name);
return(orderedList);
}
public void TestNamesWithoutParts()
{
// No stacking here because there is no part/disc/etc
var files = new[]
{
"Harry Potter and the Deathly Hallows.mkv",
"Harry Potter and the Deathly Hallows 1.mkv",
"Harry Potter and the Deathly Hallows 2.mkv",
"Harry Potter and the Deathly Hallows 3.mkv",
"Harry Potter and the Deathly Hallows 4.mkv"
};
var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
Assert.Empty(result);
}
public void TestSimpleStackWithNumericName()
{
var files = new[]
{
"300 (2006) part1.mkv",
"300 (2006) part2.mkv",
"300 (2006) part3.mkv",
"300 (2006) part4.mkv",
"300 (2006)-trailer.mkv"
};
var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
Assert.Single(result);
TestStackInfo(result[0], "300 (2006)", 4);
}
public void TestMixedExpressionsNotAllowed()
{
var files = new[]
{
"Bad Boys (2006) part1.mkv",
"Bad Boys (2006) part2.mkv",
"Bad Boys (2006) part3.mkv",
"Bad Boys (2006) parta.mkv",
"Bad Boys (2006)-trailer.mkv"
};
var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
Assert.Single(result);
TestStackInfo(result[0], "Bad Boys (2006)", 3);
}
public void TestFalsePositive()
{
var files = new[]
{
"300a.mkv",
"300b.mkv",
"300c.mkv",
"300-trailer.mkv"
};
var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
Assert.Single(result);
TestStackInfo(result[0], "300", 3);
}
public void TestFailSequence()
{
var files = new[]
{
"300 part1.mkv",
"300 part2.mkv",
"Avatar",
"Avengers part1.mkv",
"Avengers part2.mkv",
"Avengers part3.mkv"
};
var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
Assert.Equal(2, result.Count);
TestStackInfo(result[0], "300", 2);
TestStackInfo(result[1], "Avengers", 3);
}
public void TestAlphaLimitOfFour()
{
var files = new[]
{
"300 (2006) parta.mkv",
"300 (2006) partb.mkv",
"300 (2006) partc.mkv",
"300 (2006) partd.mkv",
"300 (2006) parte.mkv",
"300 (2006) partf.mkv",
"300 (2006) partg.mkv",
"300 (2006)-trailer.mkv"
};
var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
Assert.Single(result);
TestStackInfo(result[0], "300 (2006)", 4);
}
public void TestDualStacks()
{
var files = new[]
{
"Bad Boys (2006) part1.mkv",
"Bad Boys (2006) part2.mkv",
"Bad Boys (2006) part3.mkv",
"Bad Boys (2006) part4.mkv",
"Bad Boys (2006)-trailer.mkv",
"300 (2006) part1.mkv",
"300 (2006) part2.mkv",
"300 (2006) part3.mkv",
"300 (2006)-trailer.mkv"
};
var result = StackResolver.ResolveFiles(files, _namingOptions).ToList();
Assert.Equal(2, result.Count);
TestStackInfo(result[1], "Bad Boys (2006)", 4);
TestStackInfo(result[0], "300 (2006)", 3);
}
/// <summary>
/// Gets the multi file movie.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="movies">The movies.</param>
/// <returns>``0.</returns>
private T GetMultiFileMovie <T>(IEnumerable <T> movies)
where T : Video, new()
{
var sortedMovies = movies.OrderBy(i => i.Path).ToList();
var firstMovie = sortedMovies[0];
var paths = sortedMovies.Select(i => i.Path).ToList();
var resolver = new StackResolver(new ExtendedNamingOptions(), new Naming.Logging.NullLogger());
var result = resolver.ResolveFiles(paths);
if (result.Stacks.Count != 1)
{
return(null);
}
firstMovie.IsMultiPart = true;
firstMovie.Name = result.Stacks[0].Name;
// They must all be part of the sequence if we're going to consider it a multi-part movie
return(firstMovie);
}
/// <summary>
/// Gets the multi disc movie.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="multiDiscFolders">The folders.</param>
/// <param name="directoryService">The directory service.</param>
/// <returns>``0.</returns>
private T GetMultiDiscMovie <T>(List <FileSystemMetadata> multiDiscFolders, IDirectoryService directoryService)
where T : Video, new()
{
var videoTypes = new List <VideoType>();
var folderPaths = multiDiscFolders.Select(i => i.FullName).Where(i =>
{
var subFileEntries = directoryService.GetFileSystemEntries(i);
var subfolders = subFileEntries
.Where(e => e.IsDirectory)
.ToList();
if (subfolders.Any(s => IsDvdDirectory(s.FullName, s.Name, directoryService)))
{
videoTypes.Add(VideoType.Dvd);
return(true);
}
if (subfolders.Any(s => IsBluRayDirectory(s.FullName, s.Name, directoryService)))
{
videoTypes.Add(VideoType.BluRay);
return(true);
}
var subFiles = subFileEntries
.Where(e => !e.IsDirectory)
.Select(d => d.Name);
if (subFiles.Any(IsDvdFile))
{
videoTypes.Add(VideoType.Dvd);
return(true);
}
return(false);
}).OrderBy(i => i).ToList();
// If different video types were found, don't allow this
if (videoTypes.Distinct().Count() > 1)
{
return(null);
}
if (folderPaths.Count == 0)
{
return(null);
}
var namingOptions = ((LibraryManager)LibraryManager).GetNamingOptions();
var resolver = new StackResolver(namingOptions);
var result = resolver.ResolveDirectories(folderPaths);
if (result.Stacks.Count != 1)
{
return(null);
}
var returnVideo = new T
{
Path = folderPaths[0],
AdditionalParts = folderPaths.Skip(1).ToArray(),
VideoType = videoTypes[0],
Name = result.Stacks[0].Name
};
SetIsoType(returnVideo);
return(returnVideo);
}
public MovieResolver(IImageProcessor imageProcessor, NamingOptions namingOptions)
: base(namingOptions)
{
_imageProcessor = imageProcessor;
_stackResolver = new StackResolver(NamingOptions);
}
