/// <summary>
/// Initializes a new instance of the <see cref="MetadataUpdater"/> class.
/// </summary>
/// <param name="metadata"><see cref="MetadataFile"/> that is to be updated.</param>
/// <exception cref="ArgumentNullException"><paramref name="metadata"/> is null</exception>
public MetadataUpdater(MetadataFile metadata)
{
if (metadata == null)
throw new ArgumentNullException("metadata");
m_metadata = metadata;
}
public ProjectFile_v2 VisitMetadataFile(MetadataFile metadata)
{
return new MetadataFile_v2
{
Filename = metadata.Filename,
ModuleName = metadata.ModuleName,
};
}
protected MetadataMapping(MetadataFile file, string conceptElementName, string storageElementName) : base(MetadataElementKind.Mapping, file)
{
if(string.IsNullOrWhiteSpace(conceptElementName))
throw new ArgumentNullException("conceptElementName");
if(string.IsNullOrWhiteSpace(storageElementName))
throw new ArgumentNullException("storageElementName");
_conceptElementName = conceptElementName.Trim();
_storageElementName = storageElementName.Trim();
}
public async Task SkipExistingTest()
{
using (var temp = TempDirectory.Create())
{
var db = new GameDatabase(temp.TempPath);
db.OpenDatabase();
Game.DatabaseReference = db;
int callCount = 0;
var addedGame = db.ImportGame(new GameInfo()
{
Name = "Game1",
Description = "Description",
Developers = new List <string>()
{
"Developers"
},
Genres = new List <string>()
{
"Genres"
},
Links = new List <Link>()
{
new Link("Link", "URL")
},
Publishers = new List <string>()
{
"Publishers"
},
ReleaseDate = new DateTime(2012, 6, 6),
Tags = new List <string>()
{
"Tags"
},
UserScore = 1,
CommunityScore = 2,
CriticScore = 3
});
addedGame.Icon = "Icon";
addedGame.CoverImage = "Image";
addedGame.BackgroundImage = "BackgroundImage";
var igdbProvider = new Mock <LibraryMetadataProvider>();
igdbProvider.Setup(x => x.GetMetadata(It.IsAny <Game>())).Returns((Game g) =>
{
callCount++;
var gameId = g.Name;
var game = new GameInfo()
{
Name = "IGDB Game " + gameId,
Description = $"IGDB Description {gameId}",
Developers = new List <string>()
{
$"IGDB Developer {gameId}"
},
Genres = new List <string>()
{
$"IGDB Genre {gameId}"
},
Links = new List <Link>()
{
new Link($"IGDB link {gameId}", $"IGDB link url {gameId}")
},
Publishers = new List <string>()
{
$"IGDB publisher {gameId}"
},
ReleaseDate = new DateTime(2012, 6, 6),
Tags = new List <string>()
{
$"IGDB Tag {gameId}"
}
};
var icon = new MetadataFile($"IGDBIconName{gameId}.file", randomFile);
var image = new MetadataFile($"IGDBImageName{gameId}.file", randomFile);
var background = new MetadataFile($"IGDB backgournd {gameId}");
return(new GameMetadata(game, icon, image, background));
});
var downloader = new MetadataDownloader(db, igdbProvider.Object, null);
var settings = new MetadataDownloaderSettings()
{
SkipExistingValues = true
};
// No download - all values are kept
settings.ConfigureFields(MetadataSource.IGDB, true);
await downloader.DownloadMetadataAsync(
db.Games.ToList(), settings, null, null);
var dbGames = db.Games.ToList();
Assert.AreEqual(0, callCount);
var game1 = dbGames[0];
Assert.AreEqual("Description", game1.Description);
Assert.AreEqual("Developers", game1.Developers[0].Name);
Assert.AreEqual("Genres", game1.Genres[0].Name);
Assert.AreEqual("Link", game1.Links[0].Name);
Assert.AreEqual("URL", game1.Links[0].Url);
Assert.AreEqual("Publishers", game1.Publishers[0].Name);
Assert.AreEqual("Tags", game1.Tags[0].Name);
Assert.AreEqual(2012, game1.ReleaseDate.Value.Year);
Assert.IsNotEmpty(game1.BackgroundImage);
Assert.IsNotEmpty(game1.Icon);
Assert.IsNotEmpty(game1.CoverImage);
// Single download - values are changed even when present
settings.SkipExistingValues = false;
await downloader.DownloadMetadataAsync(
db.Games.ToList(), settings, null, null);
dbGames = db.Games.ToList();
Assert.AreEqual(1, callCount);
game1 = dbGames[0];
Assert.AreEqual("IGDB Description Game1", game1.Description);
Assert.AreEqual("IGDB Developer Game1", game1.Developers[0].Name);
Assert.AreEqual("IGDB Genre Game1", game1.Genres[0].Name);
Assert.AreEqual("IGDB link Game1", game1.Links[0].Name);
Assert.AreEqual("IGDB link url Game1", game1.Links[0].Url);
Assert.AreEqual("IGDB publisher Game1", game1.Publishers[0].Name);
Assert.AreEqual("IGDB Tag Game1", game1.Tags[0].Name);
Assert.AreEqual(2012, game1.ReleaseDate.Value.Year);
Assert.IsNotEmpty(game1.BackgroundImage);
Assert.IsNotEmpty(game1.Icon);
Assert.IsNotEmpty(game1.CoverImage);
// Single download - values are changed when skip enabled and values are not present
callCount = 0;
settings.SkipExistingValues = true;
db.Games.Remove(game1);
db.Games.Add(new Game("Game1"));
await downloader.DownloadMetadataAsync(
db.Games.ToList(), settings, null, null);
dbGames = db.Games.ToList();
Assert.AreEqual(1, callCount);
game1 = dbGames[0];
Assert.AreEqual("IGDB Description Game1", game1.Description);
Assert.AreEqual("IGDB Developer Game1", game1.Developers[0].Name);
Assert.AreEqual("IGDB Genre Game1", game1.Genres[0].Name);
Assert.AreEqual("IGDB link Game1", game1.Links[0].Name);
Assert.AreEqual("IGDB link url Game1", game1.Links[0].Url);
Assert.AreEqual("IGDB publisher Game1", game1.Publishers[0].Name);
Assert.AreEqual("IGDB Tag Game1", game1.Tags[0].Name);
Assert.AreEqual(2012, game1.ReleaseDate.Value.Year);
Assert.IsNotEmpty(game1.BackgroundImage);
Assert.IsNotEmpty(game1.Icon);
Assert.IsNotEmpty(game1.CoverImage);
}
}
public async Task IGDBSourceTest()
{
using (var temp = TempDirectory.Create())
{
var db = new GameDatabase(temp.TempPath);
db.OpenDatabase();
Game.DatabaseReference = db;
int callCount = 0;
var storeCalled = false;
var games = new List <Game>()
{
new Game("Game1"),
new Game("Game2")
{
PluginId = storePluginId, GameId = "Game2"
},
new Game("Game3")
};
db.Games.Add(games);
var igdbProvider = new Mock <LibraryMetadataProvider>();
igdbProvider.Setup(x => x.GetMetadata(It.IsAny <Game>())).Returns((Game g) =>
{
callCount++;
if (g.Name == "Game3")
{
return(GameMetadata.GetEmptyData());
}
var gameId = g.Name;
var game = new GameInfo()
{
Name = "IGDB Game " + gameId,
Description = $"IGDB Description {gameId}",
Developers = new List <string>()
{
$"IGDB Developer {gameId}"
},
Genres = new List <string>()
{
$"IGDB Genre {gameId}"
},
Links = new List <Link>()
{
new Link($"IGDB link {gameId}", $"IGDB link url {gameId}")
},
Publishers = new List <string>()
{
$"IGDB publisher {gameId}"
},
ReleaseDate = new DateTime(2012, 6, 6),
Tags = new List <string>()
{
$"IGDB Tag {gameId}"
}
};
var icon = new MetadataFile($"IGDBIconName{gameId}.file", randomFile);
var image = new MetadataFile($"IGDBImageName{gameId}.file", randomFile);
var background = new MetadataFile($"IGDB backgournd {gameId}");
return(new GameMetadata(game, icon, image, background));
});
var storeProvider = new Mock <LibraryMetadataProvider>();
storeProvider.Setup(x => x.GetMetadata(It.IsAny <Game>())).Returns((Game g) =>
{
callCount++;
storeCalled = true;
return(GameMetadata.GetEmptyData());
});
var downloader = new MetadataDownloader(db, igdbProvider.Object, GetLibraryPlugins(storeProvider.Object, storePluginId));
var settings = new MetadataDownloaderSettings()
{
SkipExistingValues = false
};
settings.Name.Import = false;
settings.ConfigureFields(MetadataSource.IGDB, true);
await downloader.DownloadMetadataAsync(
db.Games.ToList(), settings, null, null);
Assert.IsFalse(storeCalled);
Assert.AreEqual(3, callCount);
var game1 = db.Games[games[0].Id];
Assert.AreEqual("IGDB Description Game1", game1.Description);
Assert.AreEqual("IGDB Developer Game1", game1.Developers[0].Name);
Assert.AreEqual("IGDB Genre Game1", game1.Genres[0].Name);
Assert.AreEqual("IGDB link Game1", game1.Links[0].Name);
Assert.AreEqual("IGDB link url Game1", game1.Links[0].Url);
Assert.AreEqual("IGDB publisher Game1", game1.Publishers[0].Name);
Assert.AreEqual("IGDB Tag Game1", game1.Tags[0].Name);
Assert.AreEqual(2012, game1.ReleaseDate.Value.Year);
Assert.IsNotEmpty(game1.BackgroundImage);
Assert.IsNotEmpty(game1.Icon);
Assert.IsNotEmpty(game1.CoverImage);
var game2 = db.Games[games[1].Id];
Assert.AreEqual("IGDB Description Game2", game2.Description);
Assert.AreEqual(2, Directory.GetFiles(db.GetFileStoragePath(game1.Id)).Count());
Assert.AreEqual(2, Directory.GetFiles(db.GetFileStoragePath(game2.Id)).Count());
}
}
public static Assembly CreateAssembly(ITypeUniverse typeUniverse, MetadataFile metadataImport, IReflectionFactory factory, string manifestFile)
{
return(AssemblyFactory.CreateAssembly(typeUniverse, metadataImport, null, factory, manifestFile, null));
}
/// <summary>
/// Initializes a new instance of the <see cref="SerializableMetadata"/> class.
/// </summary>
/// <param name="metadataFile"><see cref="MetadataFile"/> object from which <see cref="SerializableMetadata"/> is to be initialized.</param>
/// <exception cref="ArgumentNullException"><paramref name="metadataFile"/> is null.</exception>
/// <exception cref="ArgumentException"><paramref name="metadataFile"/> is closed.</exception>
public SerializableMetadata(MetadataFile metadataFile)
: this()
{
if (metadataFile == null)
throw new ArgumentNullException("metadataFile");
if (!metadataFile.IsOpen)
throw new ArgumentException("metadataFile is closed");
// Process all records in the metadata file.
List<SerializableMetadataRecord> serializableMetadataRecords = new List<SerializableMetadataRecord>();
foreach (MetadataRecord metadataRecord in metadataFile.Read())
{
serializableMetadataRecords.Add(new SerializableMetadataRecord(metadataRecord));
}
MetadataRecords = serializableMetadataRecords.ToArray();
}
/// <summary>
/// Load metadata file from file system
/// </summary>
public void LoadMetadataFile(MetadataFile metadataFile)
{
try
{
metadataFile.CleanUpContent();
metadataFile.LoadContent(ReadMetadataFile(metadataFile.FileName));
}
catch (Exception ex)
{
metadataFile.ErrorInLoading = ex;
}
}
public override MetadataFile FindMetadataFile(Series series, string path)
{
var filename = Path.GetFileName(path);
if (filename == null)
{
return(null);
}
var metadata = new MetadataFile
{
SeriesId = series.Id,
Consumer = GetType().Name,
RelativePath = series.Path.GetRelativePath(path)
};
//Series and season images are both named folder.jpg, only season ones sit in season folders
if (Path.GetFileName(filename).Equals("folder.jpg", StringComparison.InvariantCultureIgnoreCase))
{
var parentdir = Directory.GetParent(path);
var seasonMatch = SeasonImagesRegex.Match(parentdir.Name);
if (seasonMatch.Success)
{
metadata.Type = MetadataType.SeasonImage;
if (seasonMatch.Groups["specials"].Success)
{
metadata.SeasonNumber = 0;
}
else
{
metadata.SeasonNumber = Convert.ToInt32(seasonMatch.Groups["season"].Value);
}
return(metadata);
}
metadata.Type = MetadataType.SeriesImage;
return(metadata);
}
var parseResult = Parser.Parser.ParseTitle(filename);
if (parseResult != null &&
!parseResult.FullSeason)
{
switch (Path.GetExtension(filename).ToLowerInvariant())
{
case ".xml":
metadata.Type = MetadataType.EpisodeMetadata;
return(metadata);
case ".metathumb":
metadata.Type = MetadataType.EpisodeImage;
return(metadata);
}
}
return(null);
}
public override string GetFilenameAfterMove(Movie movie, MovieFile movieFile, MetadataFile metadataFile)
{
var movieFilePath = Path.Combine(movie.Path, movieFile.RelativePath);
if (metadataFile.Type == MetadataType.MovieImage)
{
return(GetMovieFileImageFilename(movieFilePath));
}
if (metadataFile.Type == MetadataType.MovieMetadata)
{
return(GetMovieFileMetadataFilename(movieFilePath));
}
_logger.Debug("Unknown movie file metadata: {0}", metadataFile.RelativePath);
return(Path.Combine(movie.Path, metadataFile.RelativePath));
}
public virtual string GetFilenameAfterMove(Series series, EpisodeFile episodeFile, MetadataFile metadataFile)
{
var existingFilename = Path.Combine(series.Path, metadataFile.RelativePath);
var extension = Path.GetExtension(existingFilename).TrimStart('.');
var newFileName = Path.ChangeExtension(Path.Combine(series.Path, episodeFile.RelativePath), extension);
return(newFileName);
}
public MetadataOnlyModule LoadModuleFromFile(string moduleFileName)
{
MetadataFile metadataFile = this.m_dispenser.OpenFileAsFileMapping(moduleFileName);
return(new MetadataOnlyModule(this.m_universe, metadataFile, this.Factory, moduleFileName));
}
private static async Task Main(string[] args)
{
if (args == null || args.Length == 0)
{
#if DEBUG
args = new[] { @"..\..\..\..\.." };
#else
args = new string[] { Environment.CurrentDirectory };
#endif
}
string rootPath = args[0];
StringComparer comparer = StringComparer.InvariantCulture;
var metadata = new RoslynatorMetadata(rootPath);
ImmutableArray <AnalyzerMetadata> analyzers = metadata.Analyzers;
ImmutableArray <AnalyzerMetadata> codeAnalysisAnalyzers = metadata.CodeAnalysisAnalyzers;
ImmutableArray <AnalyzerMetadata> formattingAnalyzers = metadata.FormattingAnalyzers;
ImmutableArray <RefactoringMetadata> refactorings = metadata.Refactorings;
ImmutableArray <CodeFixMetadata> codeFixes = metadata.CodeFixes;
ImmutableArray <CompilerDiagnosticMetadata> compilerDiagnostics = metadata.CompilerDiagnostics;
WriteAllText(
@"..\docs\Options.md",
MarkdownGenerator.CreateListOfAnalyzerOptions(metadata));
WriteAnalyzersReadMe(@"Analyzers\README.md", analyzers, "Roslynator.Analyzers");
WriteAnalyzersReadMe(@"CodeAnalysis.Analyzers\README.md", codeAnalysisAnalyzers, "Roslynator.CodeAnalysis.Analyzers");
WriteAnalyzersReadMe(@"Formatting.Analyzers\README.md", formattingAnalyzers, "Roslynator.Formatting.Analyzers");
#if !DEBUG
VisualStudioInstance instance = MSBuildLocator.QueryVisualStudioInstances().First(f => f.Version.Major == 16);
MSBuildLocator.RegisterInstance(instance);
using (MSBuildWorkspace workspace = MSBuildWorkspace.Create())
{
workspace.WorkspaceFailed += (o, e) => Console.WriteLine(e.Diagnostic.Message);
string solutionPath = Path.Combine(rootPath, "Roslynator.sln");
Console.WriteLine($"Loading solution '{solutionPath}'");
Solution solution = await workspace.OpenSolutionAsync(solutionPath).ConfigureAwait(false);
Console.WriteLine($"Finished loading solution '{solutionPath}'");
RoslynatorInfo roslynatorInfo = await RoslynatorInfo.Create(solution).ConfigureAwait(false);
IOrderedEnumerable <SourceFile> sourceFiles = analyzers
.Concat(codeAnalysisAnalyzers)
.Concat(formattingAnalyzers)
.Select(f => new SourceFile(f.Id, roslynatorInfo.GetAnalyzerFilesAsync(f.Identifier).Result))
.Concat(refactorings
.Select(f => new SourceFile(f.Id, roslynatorInfo.GetRefactoringFilesAsync(f.Identifier).Result)))
.OrderBy(f => f.Id);
MetadataFile.SaveSourceFiles(sourceFiles, @"..\SourceFiles.xml");
}
#endif
WriteAnalyzerMarkdowns(codeAnalysisAnalyzers, new (string, string)[] { ("Roslynator.CodeAnalysis.Analyzers", "https://www.nuget.org/packages/Roslynator.CodeAnalysis.Analyzers") });
public static Assembly CreateAssembly(ITypeUniverse typeUniverse, MetadataFile manifestModuleImport, MetadataFile[] netModuleImports, string manifestFile, string[] netModuleFiles)
{
return(AssemblyFactory.CreateAssembly(typeUniverse, manifestModuleImport, netModuleImports, new DefaultFactory(), manifestFile, netModuleFiles));
}
public override string GetFilenameAfterMove(Series series, EpisodeFile episodeFile, MetadataFile metadataFile)
{
var episodeFilePath = Path.Combine(series.Path, episodeFile.RelativePath);
if (metadataFile.Type == MetadataType.EpisodeImage)
{
return(GetEpisodeImageFilename(episodeFilePath));
}
if (metadataFile.Type == MetadataType.EpisodeMetadata)
{
return(GetEpisodeMetadataFilename(episodeFilePath));
}
_logger.Debug("Unknown episode file metadata: {0}", metadataFile.RelativePath);
return(Path.Combine(series.Path, metadataFile.RelativePath));
}
public MetadataContainer(string name, MetadataFile file, MetadataElementKind kind) : base(kind, file)
{
_name = name == null ? string.Empty : name.Trim();
}
public override MetadataFile FindMetadataFile(Series series, string path)
{
var filename = Path.GetFileName(path);
if (filename == null)
{
return(null);
}
var metadata = new MetadataFile
{
SeriesId = series.Id,
Consumer = GetType().Name,
RelativePath = series.Path.GetRelativePath(path)
};
if (SeriesImagesRegex.IsMatch(filename))
{
metadata.Type = MetadataType.SeriesImage;
return(metadata);
}
var seasonMatch = SeasonImagesRegex.Match(filename);
if (seasonMatch.Success)
{
metadata.Type = MetadataType.SeasonImage;
var seasonNumberMatch = seasonMatch.Groups["season"].Value;
int seasonNumber;
if (seasonNumberMatch.Contains("specials"))
{
metadata.SeasonNumber = 0;
}
else if (int.TryParse(seasonNumberMatch, out seasonNumber))
{
metadata.SeasonNumber = seasonNumber;
}
else
{
return(null);
}
return(metadata);
}
if (EpisodeImageRegex.IsMatch(filename))
{
metadata.Type = MetadataType.EpisodeImage;
return(metadata);
}
if (filename.Equals("tvshow.nfo", StringComparison.OrdinalIgnoreCase))
{
metadata.Type = MetadataType.SeriesMetadata;
return(metadata);
}
var parseResult = Parser.Parser.ParseTitle(filename);
if (parseResult != null &&
!parseResult.FullSeason &&
Path.GetExtension(filename).Equals(".nfo", StringComparison.OrdinalIgnoreCase) &&
_detectNfo.IsXbmcNfoFile(path))
{
metadata.Type = MetadataType.EpisodeMetadata;
return(metadata);
}
return(null);
}
/// <summary>
/// Write the metadata file.
/// </summary>
/// <param name="file">The metadata file to be written</param>
protected virtual void WriteMetadataFile(MetadataFile file)
{
throw new NotImplementedException();
}
public override string GetFilenameAfterMove(Artist artist, TrackFile trackFile, MetadataFile metadataFile)
{
var trackFilePath = trackFile.Path;
if (metadataFile.Type == MetadataType.TrackMetadata)
{
return(GetTrackMetadataFilename(trackFilePath));
}
_logger.Debug("Unknown track file metadata: {0}", metadataFile.RelativePath);
return(Path.Combine(artist.Path, metadataFile.RelativePath));
}
public void SetTreeNodeProperties(MetadataFile mf)
{
TreeNode.Text = Path.GetFileName(mf.ModuleName);
TreeNode.ImageName = "typelib.ico";
}
public async Task SkipExistingTest()
{
// Tests that existing data are not overriden even if metadata provider has them.
var testPlugin = GetTestPlugin();
testPlugin.SetSupportedFields(new List<MetadataField>
{
MetadataField.Description,
MetadataField.Icon,
MetadataField.CoverImage,
MetadataField.BackgroundImage,
MetadataField.Links,
MetadataField.Publishers,
MetadataField.Developers,
MetadataField.Tags,
MetadataField.Genres,
MetadataField.ReleaseDate,
MetadataField.Features
});
var gameId = "Game1";
var icon = new MetadataFile($"IGDBIconName{gameId}.file", randomFile);
var image = new MetadataFile($"IGDBImageName{gameId}.file", randomFile);
var background = new MetadataFile($"IGDB backgournd {gameId}");
testPlugin.ReturnMetadata = new GameMetadata()
{
Name = "IGDB Game " + gameId,
Description = $"IGDB Description {gameId}",
Developers = new HashSet<MetadataProperty> { new MetadataNameProperty($"IGDB Developer {gameId}") },
Genres = new HashSet<MetadataProperty> { new MetadataNameProperty($"IGDB Genre {gameId}") },
Links = new List<Link> { new Link($"IGDB link {gameId}", $"IGDB link url {gameId}") },
Publishers = new HashSet<MetadataProperty> { new MetadataNameProperty($"IGDB publisher {gameId}") },
ReleaseDate = new ReleaseDate(2012, 6, 6),
Tags = new HashSet<MetadataProperty> { new MetadataNameProperty($"IGDB Tag {gameId}") },
Features = new HashSet<MetadataProperty> { new MetadataNameProperty($"IGDB Feature {gameId}") },
Icon = icon,
BackgroundImage = background,
CoverImage = image
};
List<MetadataPlugin> metadataDownloaders = new List<MetadataPlugin>()
{
testPlugin
};
using (var temp = TempDirectory.Create())
using (var db = new GameDatabase(temp.TempPath))
using (var token = new CancellationTokenSource())
{
db.OpenDatabase();
Game.DatabaseReference = db;
var addedGame = db.ImportGame(new GameMetadata()
{
Name = "Game1",
Description = "Description",
Developers = new HashSet<MetadataProperty> { new MetadataNameProperty("Developers") },
Genres = new HashSet<MetadataProperty> { new MetadataNameProperty("Genres") },
Links = new List<Link>() { new Link("Link", "URL") },
Publishers = new HashSet<MetadataProperty> { new MetadataNameProperty("Publishers") },
ReleaseDate = new ReleaseDate(2012, 6, 6),
Tags = new HashSet<MetadataProperty> { new MetadataNameProperty("Tags") },
Features = new HashSet<MetadataProperty> { new MetadataNameProperty("Features") },
UserScore = 1,
CommunityScore = 2,
CriticScore = 3
});
addedGame.Icon = "Icon";
addedGame.CoverImage = "Image";
addedGame.BackgroundImage = "BackgroundImage";
var downloader = new MetadataDownloader(db, metadataDownloaders, new List<LibraryPlugin>());
var settings = new MetadataDownloaderSettings() { SkipExistingValues = true };
// No download - all values are kept
settings.ConfigureFields(new List<Guid> { testPlugin.Id }, true);
await downloader.DownloadMetadataAsync(
db.Games.ToList(), settings, new PlayniteSettings(), null, token.Token);
var dbGames = db.Games.ToList();
Assert.AreEqual(0, testPlugin.CallCount);
var game1 = dbGames[0];
Assert.AreEqual("Description", game1.Description);
Assert.AreEqual("Developers", game1.Developers[0].Name);
Assert.AreEqual("Genres", game1.Genres[0].Name);
Assert.AreEqual("Link", game1.Links[0].Name);
Assert.AreEqual("URL", game1.Links[0].Url);
Assert.AreEqual("Publishers", game1.Publishers[0].Name);
Assert.AreEqual("Tags", game1.Tags[0].Name);
Assert.AreEqual("Features", game1.Features[0].Name);
Assert.AreEqual(2012, game1.ReleaseDate.Value.Year);
Assert.IsNotEmpty(game1.BackgroundImage);
Assert.IsNotEmpty(game1.Icon);
Assert.IsNotEmpty(game1.CoverImage);
// Single download - values are changed even when present
settings.SkipExistingValues = false;
await downloader.DownloadMetadataAsync(
db.Games.ToList(), settings, new PlayniteSettings(), null, token.Token);
dbGames = db.Games.ToList();
Assert.AreEqual(1, testPlugin.CallCount);
game1 = dbGames[0];
Assert.AreEqual("IGDB Description Game1", game1.Description);
Assert.AreEqual("IGDB Developer Game1", game1.Developers[0].Name);
Assert.AreEqual("IGDB Genre Game1", game1.Genres[0].Name);
Assert.AreEqual("IGDB link Game1", game1.Links[0].Name);
Assert.AreEqual("IGDB link url Game1", game1.Links[0].Url);
Assert.AreEqual("IGDB publisher Game1", game1.Publishers[0].Name);
Assert.AreEqual("IGDB Tag Game1", game1.Tags[0].Name);
Assert.AreEqual("IGDB Feature Game1", game1.Features[0].Name);
Assert.AreEqual(2012, game1.ReleaseDate.Value.Year);
Assert.IsNotEmpty(game1.BackgroundImage);
Assert.IsNotEmpty(game1.Icon);
Assert.IsNotEmpty(game1.CoverImage);
// Single download - values are changed when skip enabled and values are not present
testPlugin.CallCount = 0;
settings.SkipExistingValues = true;
db.Games.Remove(game1);
db.Games.Add(new Game("Game1"));
await downloader.DownloadMetadataAsync(
db.Games.ToList(), settings, new PlayniteSettings(), null, token.Token);
dbGames = db.Games.ToList();
Assert.AreEqual(1, testPlugin.CallCount);
game1 = dbGames[0];
Assert.AreEqual("IGDB Description Game1", game1.Description);
Assert.AreEqual("IGDB Developer Game1", game1.Developers[0].Name);
Assert.AreEqual("IGDB Genre Game1", game1.Genres[0].Name);
Assert.AreEqual("IGDB link Game1", game1.Links[0].Name);
Assert.AreEqual("IGDB link url Game1", game1.Links[0].Url);
Assert.AreEqual("IGDB publisher Game1", game1.Publishers[0].Name);
Assert.AreEqual("IGDB Tag Game1", game1.Tags[0].Name);
Assert.AreEqual("IGDB Feature Game1", game1.Features[0].Name);
Assert.AreEqual(2012, game1.ReleaseDate.Value.Year);
Assert.IsNotEmpty(game1.BackgroundImage);
Assert.IsNotEmpty(game1.Icon);
Assert.IsNotEmpty(game1.CoverImage);
}
}
public ProjectFile_v3 VisitMetadataFile(string projectAbsPath, MetadataFile metadata)
{
return new MetadataFile_v3
{
Filename = ConvertToProjectRelativePath(projectAbsPath, metadata.Filename),
ModuleName = metadata.ModuleName,
};
}
public override string GetFilenameAfterMove(Movie movie, MovieFile movieFile, MetadataFile metadataFile)
{
var movieFilePath = Path.Combine(movie.Path, movieFile.RelativePath);
var metadataPath = Path.Combine(movie.Path, metadataFile.RelativePath);
if (metadataFile.Type == MetadataType.MovieMetadata)
{
return(GetMovieMetadataFilename(movieFilePath));
}
if (metadataFile.Type == MetadataType.MovieImage)
{
var isFanart = metadataFile.RelativePath.Contains("fanart.jpg") ? MediaCoverTypes.Fanart : MediaCoverTypes.Poster;
return(Path.Combine(movie.Path, GetMovieImageFilename(movieFilePath, isFanart)));
}
_logger.Debug("Unknown movie file metadata: {0}", metadataFile.RelativePath);
return(Path.Combine(movie.Path, metadataFile.RelativePath));
}
/// <summary>
/// Convert metadata loading errors into proxy generation error messages
/// </summary>
/// <return></return>
/// <remarks></remarks>
internal static ProxyGenerationError ConvertMetadataErrorToProxyGenerationError(MetadataFile metadataItem, Exception ex)
{
ProxyGenerationError generationError = null;
if (ex is XmlSchemaException)
{
generationError = new ProxyGenerationError(ProxyGenerationError.GeneratorState.LoadMetadata, metadataItem.FileName, (XmlSchemaException)ex);
}
else if (ex is XmlException)
{
generationError = new ProxyGenerationError(ProxyGenerationError.GeneratorState.LoadMetadata, metadataItem.FileName, (XmlException)ex);
}
else if (ex is InvalidOperationException)
{
System.Xml.Schema.XmlSchemaException schemaException = ex.InnerException as System.Xml.Schema.XmlSchemaException;
if (schemaException != null)
{
generationError = new ProxyGenerationError(ProxyGenerationError.GeneratorState.LoadMetadata, metadataItem.FileName, schemaException);
}
else
{
System.Xml.XmlException xmlException = ex.InnerException as System.Xml.XmlException;
if (xmlException != null)
{
generationError = new ProxyGenerationError(ProxyGenerationError.GeneratorState.LoadMetadata, metadataItem.FileName, xmlException);
}
else
{
generationError = new ProxyGenerationError(ProxyGenerationError.GeneratorState.LoadMetadata, metadataItem.FileName, (InvalidOperationException)ex);
}
}
}
else
{
generationError = new ProxyGenerationError(ProxyGenerationError.GeneratorState.LoadMetadata, metadataItem.FileName, ex);
}
return generationError;
}
public static Assembly CreateAssembly(ITypeUniverse typeUniverse, MetadataFile metadataImport, string manifestFile)
{
return(AssemblyFactory.CreateAssembly(typeUniverse, metadataImport, new DefaultFactory(), manifestFile));
}
