public void SaveRelease(VpdbRelease release)
{
_games.Upsert(release.Game);
if (release.Game.Backglass != null)
{
_files.Upsert(release.Game.Backglass);
}
if (release.Game.Logo != null)
{
_files.Upsert(release.Game.Logo);
}
release.Versions.ToList().ForEach(version => {
version.Files.ToList().ForEach(file => {
_files.Upsert(file.Reference);
_files.Upsert(file.PlayfieldImage);
if (file.PlayfieldVideo != null)
{
_files.Upsert(file.PlayfieldVideo);
}
file.Compatibility.ToList().ForEach(build => _builds.Upsert(build));
});
});
release.Authors.ToList().ForEach(author => {
_users.Upsert(author.User);
});
_releases.Upsert(release);
}
/// <summary>
/// Constructor called when creating a new job through the application for
/// downloading a file not part of a release but related to a release,
/// like playfield image or backglass.
/// </summary>
/// <param name="release">Release to be downloaded</param>
/// <param name="file">File to be downloaded</param>
/// <param name="filetype">Where does this end up?</param>
/// <param name="platform">Platform the file belongs to</param>
public Job(VpdbRelease release, VpdbFile file, FileType filetype, VpdbTableFile.VpdbPlatform platform) : this(release, file)
{
FileType = filetype;
Platform = platform;
Thumb = release.Thumb?.Image;
_logger.Info("Creating new download job for {0} {1}.", filetype, File.Uri.AbsoluteUri);
}
/// <summary>
/// Constructor called when creating a new job through the application for
/// downloading a table file.
/// </summary>
/// <param name="release">Release to be downloaded</param>
/// <param name="tableFile">File of the release to be downloaded</param>
/// <param name="filetype">Where does this end up?</param>
/// <param name="platform">Platform the file belongs to</param>
public Job(VpdbRelease release, VpdbTableFile tableFile, FileType filetype, VpdbTableFile.VpdbPlatform platform) : this(release, tableFile.Reference)
{
FileType = filetype;
Thumb = tableFile.Thumb;
Platform = platform;
_logger.Info("Creating new release download job for {0} {1}.", filetype, File.Uri.AbsoluteUri);
}
/// <summary>
/// Maps this mapping to a VPDB release.
/// </summary>
/// <param name="release">Release to map to</param>
/// <param name="fileId">File ID of the release corresponding to the mapping</param>
/// <returns>This mapping</returns>
public Mapping Map(VpdbRelease release, string fileId)
{
ReleaseId = release.Id;
FileId = fileId;
return(this);
}
public void MapGame(AggregatedGame game, VpdbRelease release, string fileId)
{
// update in case we didn't catch the last version.
_vpdbManager.GetRelease(release.Id).Subscribe(updatedRelease => {
_logger.Info("Mapping {0} to {1} ({2})", game, release, fileId);
GetOrCreateMapping(game).Map(release, fileId);
}, exception => _vpdbClient.HandleApiError(exception, "retrieving release details during linking"));
}
public Message LogReleaseLinked(AggregatedGame game, VpdbRelease release, string fileId)
{
var msg = new Message(MessageType.ReleaseLinked, MessageLevel.Info, new Dictionary <string, string> {
{ DataGameName, game.FileId },
{ DataRelease, release.Id },
{ DataFile, fileId }
});
return(Log(msg));
}
public Message LogReleaseDownloaded(VpdbRelease release, VpdbVersion version, VpdbFile file, double bytesPerSecond)
{
var msg = new Message(MessageType.ReleaseDownloaded, MessageLevel.Info, new Dictionary <string, string> {
{ DataRelease, release.Id },
{ DataReleaseName, release.Name },
{ DataVersion, version.Name },
{ DataFile, file.Id },
{ DataSubject, release.Game.DisplayName },
{ DownloadSpeed, $"{bytesPerSecond.Bytes().ToString("#.0")}/s" },
});
return(Log(msg));
}
public GameResultItemViewModel(AggregatedGame game, VpdbRelease release, VpdbVersion version, VpdbTableFile tableFile, ICommand closeCommand)
{
Game = game;
Version = version;
Release = release;
TableFile = tableFile;
SelectResult = ReactiveCommand.Create(() => {
GameManager.MapGame(game, release, tableFile.Reference.Id);
//MessageManager.LogReleaseLinked(game, release, tableFile.Reference.Id);
closeCommand.Execute(null);
});
}
public void AddOrUpdateRelease(VpdbRelease release)
{
var dirtyRelease = _releases.FindOne(r => r.Id == release.Id);
if (dirtyRelease == null)
{
_logger.Info("Adding new release data for release {0} ({1})", release.Id, release.Name);
_releases.Insert(release);
}
else
{
_logger.Info("Updating release data of release {0} ({1})", release.Id, release.Name);
dirtyRelease.Update(release);
_releases.Update(dirtyRelease);
}
}
public VpdbTableFile FindLatestFile(VpdbRelease release, string currentFileId = null)
{
if (release == null)
{
return(null);
}
var currentFile = _databaseManager.GetTableFile(release.Id, currentFileId);
var file = release.Versions
.SelectMany(v => v.Files)
.Where(f => FlavorMatches(f, currentFile))
.Select(f => new { f, weight = FlavorWeight(f, currentFile) })
.OrderByDescending(x => x.weight)
.ThenByDescending(x => x.f.ReleasedAt)
.Select(x => x.f)
.FirstOrDefault();
// check for newer version
if (file != null && currentFile != null)
{
var currentVersion = _databaseManager.GetVersion(release.Id, currentFile.Reference.Id);
var latestVersion = _databaseManager.GetVersion(release.Id, file.Reference.Id);
if (latestVersion != null && currentVersion != null && currentVersion.ReleasedAt >= latestVersion.ReleasedAt)
{
_logger.Info("Update check: No update found.");
return(null);
}
if (latestVersion != null && currentVersion != null)
{
_logger.Info("Update check: Found new version from v{0} to v{1}", currentVersion.Name, latestVersion.Name);
}
else
{
_logger.Warn("Update check: Failed to retrieve version for file {0}/{1}", file.Reference.Id, currentFile.Reference.Id);
}
}
if (file == null)
{
_logger.Info("Update check: Nothing matched.");
}
return(file);
}
/// <summary>
/// Sets VPDB release data when mapping data is available.
/// </summary>
/// <param name="release"></param>
/// <param name="fileId"></param>
private void SetRelease(VpdbRelease release, string fileId)
{
MappedRelease = release;
MappedVersion = release.GetVersion(fileId);
MappedTableFile = release.GetFile(fileId);
}
/// <summary>
/// Constructor called when de-serializing
/// </summary>
private Job(VpdbRelease release, VpdbFile file) : this()
{
Release = release;
File = file;
}
/// <summary>
/// Constructor when linking game to VPDB
/// </summary>
/// <param name="game">Game to link to</param>
/// <param name="system">System to link to</param>
/// <param name="release">VPDB release</param>
/// <param name="fileId">File ID of VPDB release</param>
public Mapping(AggregatedGame game, PinballXSystem system, VpdbRelease release, string fileId) : this(game, system)
{
ReleaseId = release.Id;
FileId = fileId;
}
