public async static Task <MetaData> ParseFileAsync(string path, MetaParserConfig config)
{
if (String.IsNullOrEmpty(path))
{
throw new ArgumentNullException(nameof(path));
}
if (!File.Exists(path))
{
throw new MetaParseException("File not found: {0}", path);
}
string extension = Path.GetExtension(path).ToLower();
IEnumerable <FileParser> parsers = _fileParsers.Where(parser => {
MetaType?type = parser.GetMetaTypeByFileExtension(extension);
return(type.HasValue && (config.FilterTypes == null || config.FilterTypes.Contains(type.Value)));
});
if (!parsers.Any())
{
return(await Task.FromResult <MetaData>(null));
}
IEnumerable <MetaData> meta = await Task.WhenAll(parsers.Select(parser => parser.ParseAsync(path)).ToArray());
return(await Task.FromResult(meta.Aggregate((a, b) => a.Merge(b))));
}
public static IEnumerable <MetaData> ParseDirectory(string path, MetaParserConfig config)
{
Task <IEnumerable <MetaData> > task = ParseDirectoryAsync(path, config);
task.ConfigureAwait(false); // Prevent deadlock of caller
return(task.Result);
}
public static MetaData ParseFile(string path, MetaParserConfig config)
{
Task <MetaData> task = ParseFileAsync(path, config);
task.ConfigureAwait(false); // Prevent deadlock of caller
return(task.Result);
}
public static async Task<IEnumerable<MetaData>> ParseAsync(string path, MetaParserConfig config)
{
if (path == null)
throw new ArgumentNullException("path");
if (Directory.Exists(path))
return await ParseDirectoryAsync(path, config);
else if (File.Exists(path))
return new MetaData[] { await ParseFileAsync(path, config) };
else
throw new FileNotFoundException(String.Format("Could not find file or directory: {0}", path));
}
public static Task<MetaData> ParseFileAsync(string path, MetaParserConfig config)
{
if (String.IsNullOrEmpty(path))
throw new ArgumentNullException("path");
if (!File.Exists(path))
throw new MetaParseException("File not found: {0}", path);
string extension = Path.GetExtension(path).ToLower();
switch (extension)
{
// Images (Exif)
case ".jpg":
case ".jpeg":
case ".tif":
case ".tiff":
if (config.FilterTypes != null && !config.FilterTypes.Contains(MetaType.Image))
return Task.FromResult<MetaData>(null);
return ExifParser.ParseAsync(path);
// Images (generic)
case ".png":
case ".gif":
case ".bmp":
if (config.FilterTypes != null && !config.FilterTypes.Contains(MetaType.Image))
return Task.FromResult<MetaData>(null);
return GenericFileParser.ParseAsync(path, MetaType.Image);
// Music (generic)
case ".mp3": // TODO: id3
case ".wav": // TODO: exif
case ".flac":
case ".aac":
if (config.FilterTypes != null && !config.FilterTypes.Contains(MetaType.Music))
return Task.FromResult<MetaData>(null);
return GenericFileParser.ParseAsync(path, MetaType.Music);
// Movies (generic)
case ".mpg":
case ".mpeg":
case ".mov":
case ".mp4":
if (config.FilterTypes != null && !config.FilterTypes.Contains(MetaType.Video))
return Task.FromResult<MetaData>(null);
return GenericFileParser.ParseAsync(path, MetaType.Video);
default:
if (config.FilterTypes != null && !config.FilterTypes.Contains(MetaType.File))
return Task.FromResult<MetaData>(null);
return GenericFileParser.ParseAsync(path, MetaType.File);
}
}
public static async Task <IEnumerable <MetaData> > ParseAsync(string path, MetaParserConfig config)
{
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
if (Directory.Exists(path))
{
return(await ParseDirectoryAsync(path, config));
}
else if (File.Exists(path))
{
return new MetaData[] { await ParseFileAsync(path, config) }
}
;
else
{
throw new FileNotFoundException($"Could not find file or directory: {path}");
}
}
public static async Task <IEnumerable <MetaData> > ParseDirectoryAsync(string path, MetaParserConfig config)
{
if (String.IsNullOrEmpty(path))
{
throw new ArgumentNullException(nameof(path));
}
if (!Directory.Exists(path))
{
throw new MetaParseException("Directory not found: {0}", path);
}
List <MetaData> list = new List <MetaData>();
if (config.IgnorePaths != null)
{
foreach (string ignorePath in config.IgnorePaths)
{
if (ignorePath.DirectoryIsSubPath(path, true))
{
return(list);
}
}
}
LinkedList <Task <MetaData> > fileTasks = new LinkedList <Task <MetaData> >();
fileTasks.AddLast(_directoryParser.ParseAsync(path));
foreach (string file in Directory.GetFiles(path))
{
fileTasks.AddLast(ParseFileAsync(file, config));
}
list.AddRange(await Task.WhenAll(fileTasks));
if (config.Recursive)
{
LinkedList <Task <IEnumerable <MetaData> > > directoryTasks = new LinkedList <Task <IEnumerable <MetaData> > >();
foreach (string directory in Directory.GetDirectories(path))
{
directoryTasks.AddLast(ParseDirectoryAsync(directory, config));
}
foreach (IEnumerable <MetaData> nestedMetaData in await Task.WhenAll(directoryTasks))
{
list.AddRange(nestedMetaData);
}
}
return(list.Where(x => x != null));
}
public static MetaData ParseFile(string path, MetaParserConfig config)
{
Task<MetaData> task = ParseFileAsync(path, config);
task.ConfigureAwait(false); // Prevent deadlock of caller
return task.Result;
}
public static async Task<IEnumerable<MetaData>> ParseDirectoryAsync(string path, MetaParserConfig config)
{
if (String.IsNullOrEmpty(path))
throw new ArgumentNullException("path");
if (!Directory.Exists(path))
throw new MetaParseException("Directory not found: {0}", path);
List<MetaData> list = new List<MetaData>();
if (config.IgnorePaths != null)
{
foreach (string ignorePath in config.IgnorePaths)
{
if (ignorePath.DirectoryIsSubPath(path, true))
return list;
}
}
// TODO: run sub directories in paralell with files
LinkedList<Task<MetaData>> fileTasks = new LinkedList<Task<MetaData>>();
fileTasks.AddLast(DirectoryParser.ParseAsync(path));
foreach (string file in Directory.GetFiles(path))
{
fileTasks.AddLast(ParseFileAsync(file, config));
}
list.AddRange(await Task.WhenAll(fileTasks));
if (config.Recursive)
{
LinkedList<Task<IEnumerable<MetaData>>> directoryTasks = new LinkedList<Task<IEnumerable<MetaData>>>();
foreach (string directory in Directory.GetDirectories(path))
directoryTasks.AddLast(ParseDirectoryAsync(directory, config));
foreach (IEnumerable<MetaData> nestedMetaData in await Task.WhenAll(directoryTasks))
list.AddRange(nestedMetaData);
}
return list.Where(x => x != null);
}
public static IEnumerable<MetaData> ParseDirectory(string path, MetaParserConfig config)
{
Task<IEnumerable<MetaData>> task = ParseDirectoryAsync(path, config);
task.ConfigureAwait(false); // Prevent deadlock of caller
return task.Result;
}
public async Task<IEnumerable<MetaData>> GetMetaData(string sourcePath, bool recursive, params MetaType[] types)
{
try
{
MetaParserConfig config = new MetaParserConfig() { Recursive = recursive, FilterTypes = types };
return await MetaParser.ParseAsync(sourcePath, config);
}
catch (MetaParseException ex)
{
throw new MediaQuerierException("Failed to parse meta data", ex);
}
}
private async Task<List<CopyItem>> ParseItemsAsync(string sourcePath, string destinationPath, OrganizeSummary summary)
{
List<string> ignore = new List<string>();
if (IgnorePaths != null)
ignore.AddRange(IgnorePaths);
if (!sourcePath.DirectoryAreSame(destinationPath))
ignore.Add(destinationPath);
IEnumerable<MetaData> data;
try
{
MetaParserConfig config = new MetaParserConfig() { Recursive = Recursive, IgnorePaths = ignore };
data = await MetaParser.ParseAsync(sourcePath, config);
}
catch (MetaParseException ex)
{
throw new MediaOrganizerException("Failed to parse meta data", ex);
}
PatternPathParser parser = new PatternPathParser(Locale);
parser.Preload(data);
HashSet<string> files = new HashSet<string>();
HashSet<string> directories = new HashSet<string>();
HashSet<string> valid = new HashSet<string>();
HashSet<string> ignored = new HashSet<string>();
List<CopyItem> items = new List<CopyItem>();
foreach (MetaData meta in data)
{
if (workerAborted)
break;
string path = meta.Path;
switch (meta.Type)
{
case MetaType.Directory:
directories.Add(path);
continue;
case MetaType.File:
files.Add(path);
ignored.Add(path);
continue;
default:
files.Add(path);
break;
}
CopyItem item = ParseItem(parser, destinationPath, meta);
items.Add(item);
valid.Add(path);
}
summary.totalDirectories = directories.ToArray();
summary.totalFiles = files.ToArray();
summary.parsed = valid.ToArray();
summary.ignored = ignored.ToArray();
return items;
}
