public static void DownloadReleasesOld(int[] ids)
{
if (ids == null || ids.Length == 0)
{
return;
}
ProgressDialog progressDialog = new ProgressDialog {
InfoText = "downloading releases"
};
Task.Run(() =>
{
for (int i = 0; i < ids.Length; i++)
{
DiscogsRelease release = DiscogsService.GetRelease(ids[i]);
if (release.videos == null)
{
continue;
}
Task.WaitAll(release.videos.Select(v => Task.Run(() =>
{
MediaService.GetVideoFilePath(v.uri, out _, null);
MediaService.GetAudioFilePath(v.uri, out _);
})).ToArray());
progressDialog?.SetProgress(ProgressHelper.GetProgressPercentage(i + 1, ids.Length));
}
});
progressDialog.Show();
}
public async Task <DiscogsRelease> GetReleaseByTitle(string releaseTitle, string trackName, CancellationToken token)
{
var releaseId = 0;
DiscogsRelease release = null;
var searchParameters = new DiscogsSearchParameters()
{
query = releaseTitle, type = DiscogsSearchObjectType.release
};
var discogsSearchResults = await DiscogsSearch(searchParameters, token);
var results = discogsSearchResults.ToList();
foreach (var result in results)
{
//TODO: Add check for master releases
release = GetReleaseById(result.id, token).Result;
var tracks = release.tracklist;
if (tracks.Any(arg => arg.title.Equals(trackName, StringComparison.InvariantCultureIgnoreCase)))
{
releaseId = release.id;
break;
}
}
return(releaseId == 0 ? null : release);
}
private static DiscogsTrack getTrack(DiscogsVideo video, DiscogsRelease release)
{
DiscogsTrack[] tracksByTitle = release.tracklist.Where(t => video.title.ToLower().Contains(t.title.ToLower())).ToArray();
if (tracksByTitle.Length > 1)
{
DiscogsTrack[] tracksByArtist = tracksByTitle.Where(t => t.artists.Any(a => video.title.ToLower().Contains(a.name))).ToArray();
if (tracksByArtist.Length > 1)
{
return(null);
}
if (tracksByArtist.Length == 1)
{
return(tracksByArtist[0]);
}
}
if (tracksByTitle.Length == 1)
{
return(tracksByTitle[0]);
}
return(null);
}
public static void ExportReleasesOld(int[] ids)
{
if (ids == null || ids.Length == 0)
{
return;
}
using (FolderBrowserDialog dialog = new FolderBrowserDialog())
{
if (dialog.ShowDialog() != DialogResult.OK)
{
return;
}
string folder = dialog.SelectedPath;
ProgressDialog progressDialog = new ProgressDialog {
InfoText = $"exporting releases to {dialog.SelectedPath}"
};
Task.Run(() =>
{
for (int i = 0; i < ids.Length; i++)
{
DiscogsRelease release = DiscogsService.GetRelease(ids[i]);
MediaService.ExportRelease(release, folder);
progressDialog?.SetProgress(ProgressHelper.GetProgressPercentage(i + 1, ids.Length));
}
});
progressDialog.Show();
}
}
public DiscogsReleaseControlModel(DiscogsRelease release)
{
this.release = release;
this.Title = release.title;
this.Artists = release.artists;
this.LabelName = release.labels?[0].name;
this.Videos = (release.videos ?? new DiscogsVideo[0]).Select(v => new VideoModel(v.uri, v.title)).ToArray();
}
public static void ReleasesHelp(int[] ids, Help help)
{
string folder = null;
if (help == Help.Export)
{
using (FolderBrowserDialog dialog = new FolderBrowserDialog())
{
if (dialog.ShowDialog() != DialogResult.OK)
{
return;
}
folder = dialog.SelectedPath;
}
}
ProgressDialog progressDialog = new ProgressDialog {
InfoText = help.ToString()
};
Task.Run(() =>
{
for (int i = 0; i < ids.Length; i++)
{
DiscogsRelease release = DiscogsService.GetRelease(ids[i]);
if (release.videos == null || release.videos.Length == 0)
{
continue;
}
switch (help)
{
case Help.Download:
Task.WaitAll(release.videos.Select(v => Task.Run(() =>
{
MediaService.GetVideoFilePath(v.uri, out _, null);
MediaService.GetAudioFilePath(v.uri, out _);
})).ToArray());
break;
case Help.Export:
MediaService.ExportRelease(release, folder);
break;
default:
return;
}
progressDialog?.SetProgress(ProgressHelper.GetProgressPercentage(i + 1, ids.Length));
}
});
progressDialog.Show();
}
public DiscogsReleaseControl(DiscogsRelease release)
{
this.InitializeComponent();
this.viewmodel = new DiscogsReleaseControlModel(release);
this.linkLabelLabel.Text = this.viewmodel.LabelName;
this.DataBindings.Add(nameof(this.Title), this.viewmodel, nameof(this.viewmodel.Title), true, DataSourceUpdateMode.OnPropertyChanged);
this.viewmodel.ImageLoaded += () => { this.InvokeIfRequired(() => { this.Image = this.viewmodel.Image; }); };
this.viewmodel.LabelLoaded += this.viewmodelOnLabelLoaded;
this.viewmodel.ArtistLoaded += this.viewmodelOnArtistLoaded;
this.viewmodel.StartImageLoading();
if (this.viewmodel.Videos.Length == 0)
{
this.flowLayoutPanelVideos.Controls.Add(new NoVideosFoundControl());
}
foreach (VideoModel videoModel in this.viewmodel.Videos)
{
this.flowLayoutPanelVideos.InvokeIfRequired(() =>
{
VideoControl control = new VideoControl(videoModel);
this.flowLayoutPanelVideos.Controls.Add(control);
});
}
foreach (DiscogsReleaseArtist artist in this.viewmodel.Artists ?? new DiscogsReleaseArtist[0])
{
LinkLabel artistLink = new LinkLabel {
Text = artist.name
};
int height = artistLink.Height;
artistLink.AutoSize = false;
artistLink.Height = height;
artistLink.Width = this.flowLayoutPanelArtists.ClientSize.Width;
artistLink.LinkClicked += (sender, args) => { this.viewmodel.StartGetArtist(artist); };
this.flowLayoutPanelArtists.Controls.Add(artistLink);
}
}
public Album CreateAlbum(DiscogsRelease dRelease)
{
var album = new Album();
album.Title = dRelease.title;
album.ReleaseDate = dRelease.year;
album.DiscogsId = dRelease.id;
album.Styles = dRelease.styles.ToList();
album.Genres = dRelease.genres.ToList();
_genreAndStyleProvider.AddGenres(album.Genres);
_genreAndStyleProvider.AddStyles(album.Styles);
_genreAndStyleProvider.SaveAll();
foreach (var dTrack in dRelease.tracklist)
{
var track = CreateTrack(dTrack);
album.Tracks.Add(track);
}
return(album);
}
public bool CompareAlbums(IMusicDirInfo mDirInfo, DiscogsRelease dRelease)
{
if (mDirInfo.MusicFilesInDirectory != dRelease.tracklist.Length)
{
return(false);
}
var mDirTrackNames = new List <string>();
var dAlbumTrackNames = new List <string>();
foreach (var trackInfo in mDirInfo.TrackInfos)
{
mDirTrackNames.Add(trackInfo.TrackName);
}
foreach (var discogsTrack in dRelease.tracklist)
{
dAlbumTrackNames.Add(discogsTrack.title);
}
return(mDirTrackNames.OrderBy(t => t).SequenceEqual(dAlbumTrackNames.OrderBy(t => t)));
}
private Album ConvertFromRelease(DiscogsRelease release)
{
var album = new Album
{
Artist = release.artists?.FirstOrDefault()?.name,
Title = release.title,
YearReleased = release.year,
RecordLabel = release.LabelString,
Genre = release.GenreString,
Style = release.StylesString,
DiscogsID = release.id,
ImageUrl = release.images?.FirstOrDefault()?.uri,
// Tracklist = release.tracklist,
CountryOfOrigin = release.country
};
if (!string.IsNullOrWhiteSpace(album.ImageUrl) && !album.ImageUrl.Contains("https"))
{
album.ImageUrl = album.ImageUrl.Replace("http", "https");
}
return(album);
}
public ReleaseDeserializationTest()
{
_Result = JsonConvert.DeserializeObject <DiscogsRelease>(_Release);
}
public static void ExportRelease(DiscogsRelease release, string folder)
{
if (release.videos == null)
{
return;
}
foreach (DiscogsVideo releaseVideo in release.videos)
{
if (!GetAudioFilePath(releaseVideo.uri, out string src))
{
continue;
}
string filename = getEscaped(releaseVideo.title);
string releaseName = $"{string.Join(", ", release.artists?.Select(a => a.name).ToArray() ?? new string[0])} - {release.title}";
foreach (char invalidPathChar in Path.GetInvalidPathChars())
{
releaseName = releaseName.Replace(invalidPathChar, ' ');
}
string destFolder = Path.Combine(folder, releaseName);
if (!Directory.Exists(destFolder))
{
Directory.CreateDirectory(destFolder);
}
string dest = Path.Combine(destFolder, $"{filename}{AudioExtension}");
if (!File.Exists(src) || File.Exists(dest))
{
continue;
}
try
{
File.Copy(src, dest);
TagLib.File file = TagLib.File.Create(dest);
DiscogsTrack track = getTrack(releaseVideo, release);
file.Tag.Title = track?.title;
file.Tag.Performers = track?.artists?.Select(a => a.name).ToArray()
?? release.artists?.Select(a => a.name).ToArray()
?? new string[0];
file.Tag.Album = release.title;
file.Tag.AlbumArtists = release.artists?.Select(a => a.name).ToArray() ?? new string[0];
file.Tag.Genres = release.genres;
try
{
IPicture cover = new Picture(GetImageFilePath(release.images?[0]));
file.Tag.Pictures = new[] { cover };
}
catch (Exception e)
{
Console.WriteLine($@"tagging {release.title}{e}");
}
file.Save();
}
catch (Exception e)
{
Console.WriteLine($@"{src} --> {dest} {e}");
}
}
}
