protected virtual async Task SaveMetaData(Discogs.ReleaseLookup releaseLookup)
{
var value = default(string);
if (releaseLookup.Release != null)
{
value = releaseLookup.Release.Id;
}
else
{
value = Discogs.Release.None;
}
foreach (var fileData in releaseLookup.FileDatas)
{
lock (fileData.MetaDatas)
{
fileData.AddOrUpdate(CustomMetaData.DiscogsRelease, MetaDataItemType.Tag, value);
}
Logger.Write(this, LogLevel.Debug, "Discogs release: {0} => {1}", fileData.FileName, value);
}
await this.MetaDataManager.Save(
releaseLookup.FileDatas,
false, //These tags cannot be "written".
false,
CustomMetaData.DiscogsRelease
).ConfigureAwait(false);
}
protected virtual async Task <bool> Lookup(Discogs.ReleaseLookup releaseLookup)
{
var description = releaseLookup.ToString();
Logger.Write(this, LogLevel.Debug, "Fetching master releases: {0}", description);
var releases = await this.Discogs.GetReleases(releaseLookup, true).ConfigureAwait(false);
if (!releases.Any())
{
Logger.Write(this, LogLevel.Warn, "No master releases: {0}, fetching others", description);
releases = await this.Discogs.GetReleases(releaseLookup, false).ConfigureAwait(false);
if (!releases.Any())
{
Logger.Write(this, LogLevel.Warn, "No releases: {0}", description);
return(false);
}
}
Logger.Write(this, LogLevel.Debug, "Ranking releases: {0}", description);
releaseLookup.Release = releases.ToDictionary(
//Map results to similarity
release => release,
release => release.Similarity(releaseLookup)
).Where(
//Where they have the required confidence.
pair => pair.Value >= this.MinConfidence.Value
).OrderByDescending(
//Order by highest confidence first.
pair => pair.Value
).ThenByDescending(
//Then by largest cover image.
pair => pair.Key.CoverSize
).ThenByDescending(
//Then by largest thumb size.
pair => pair.Key.ThumbSize
).Select(
//Select result.
pair => pair.Key
).FirstOrDefault();
if (releaseLookup.Release != null)
{
Logger.Write(this, LogLevel.Debug, "Best match {0}: {1}", description, releaseLookup.Release.Url);
return(await this.OnLookupSuccess(releaseLookup).ConfigureAwait(false));
}
else
{
Logger.Write(this, LogLevel.Warn, "No matches: {0}", description);
}
return(false);
}
protected override async Task <bool> OnLookupSuccess(Discogs.ReleaseLookup releaseLookup)
{
var value = await this.ImportImage(releaseLookup).ConfigureAwait(false);
if (!string.IsNullOrEmpty(value))
{
releaseLookup.MetaData[FRONT_COVER] = value;
return(true);
}
else
{
Logger.Write(this, LogLevel.Warn, "Failed to download artwork for album {0} - {1}: Releases don't contain images or they count not be downloaded.", releaseLookup.Artist, releaseLookup.Album);
releaseLookup.AddError(Strings.DiscogsFetchArtworkTask_NotFound);
return(false);
}
}
protected virtual string GetDescription(Discogs.ReleaseLookup releaseLookup)
{
var builder = new StringBuilder();
builder.AppendFormat("{0} - {1}", releaseLookup.Artist, releaseLookup.Album);
if (releaseLookup.Status != Discogs.ReleaseLookupStatus.Complete && releaseLookup.Errors.Any())
{
builder.AppendLine(" -> Error");
foreach (var error in releaseLookup.Errors)
{
builder.AppendLine('\t' + error);
}
}
else
{
builder.AppendLine(" -> OK");
}
return(builder.ToString());
}
protected virtual async Task <bool> ImportTags(Discogs.ReleaseLookup releaseLookup)
{
var release = default(Discogs.ReleaseDetails);
try
{
Logger.Write(this, LogLevel.Debug, "Fetching release details: {0}", releaseLookup.Release.ResourceUrl);
release = await this.Discogs.GetRelease(releaseLookup.Release).ConfigureAwait(false);
if (release == null)
{
Logger.Write(this, LogLevel.Error, "Failed to fetch release details \"{0}\": Unknown error.", releaseLookup.Release.ResourceUrl);
return(false);
}
}
catch (Exception e)
{
Logger.Write(this, LogLevel.Error, "Failed to fetch release details \"{0}\": {1}", releaseLookup.Release.ResourceUrl, e.Message);
releaseLookup.AddError(e.Message);
}
var names = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (var fileData in releaseLookup.FileDatas)
{
lock (fileData.MetaDatas)
{
fileData.AddOrUpdate(metaData =>
{
var track = this.GetTrackDetails(fileData, metaData, release);
return(this.GetMetaData(fileData, release, track));
}, names);
}
}
if (names.Any())
{
await this.MetaDataManager.Save(releaseLookup.FileDatas, this.WriteTags.Value, false, names.ToArray()).ConfigureAwait(false);
await this.HierarchyManager.Refresh(releaseLookup.FileDatas, names.ToArray()).ConfigureAwait(false);
}
return(true);
}
protected virtual async Task <string> ImportImage(Discogs.ReleaseLookup releaseLookup)
{
var urls = new[]
{
releaseLookup.Release.CoverUrl,
releaseLookup.Release.ThumbUrl
};
foreach (var url in urls)
{
if (!string.IsNullOrEmpty(url))
{
try
{
var fileName = await FileMetaDataStore.IfNotExistsAsync(PREFIX, url, async result =>
{
Logger.Write(this, LogLevel.Debug, "Downloading data from url: {0}", url);
var data = await this.Discogs.GetData(url).ConfigureAwait(false);
if (data == null)
{
Logger.Write(this, LogLevel.Error, "Failed to download data from url \"{0}\": Unknown error.", url);
return(string.Empty);
}
return(await FileMetaDataStore.WriteAsync(PREFIX, url, data).ConfigureAwait(false));
}).ConfigureAwait(false);
if (!string.IsNullOrEmpty(fileName))
{
return(fileName);
}
}
catch (Exception e)
{
Logger.Write(this, LogLevel.Error, "Failed to download data from url \"{0}\": {1}", url, e.Message);
releaseLookup.AddError(e.Message);
}
}
}
return(string.Empty);
}
public ReportRow(Guid id, Discogs.ReleaseLookup releaseLookup)
{
this.Id = id;
this.ReleaseLookup = releaseLookup;
}
protected abstract Task <bool> OnLookupSuccess(Discogs.ReleaseLookup releaseLookup);
protected override Task <bool> OnLookupSuccess(Discogs.ReleaseLookup releaseLookup)
{
return(this.ImportTags(releaseLookup));
}
