public void GetDummyDataFromMusicBrainz()
{
var cd = DummyData.MuchAgainstEveryonesAdvice;
var api = new MusicBrainzApi("http://musicbrainz.org/");
var coverApi = new CoverArtArchiveApi("http://coverartarchive.org");
var discIdResponse = api.GetReleasesByDiscId(MusicBrainzDiscIdCalculator.CalculateDiscId(cd.TableOfContents));
Assert.That(discIdResponse.Json, Is.EqualTo(cd.GetReleaseByDiscIdResponse), discIdResponse.Json.Replace(@"""", @"\"""));
if (cd.MusicBrainzReleases != null)
{
foreach (var release in cd.MusicBrainzReleases)
{
var releaseResponse = api.GetRelease(release.Key);
Assert.That(releaseResponse.Json, Is.EqualTo(release.Value), releaseResponse.Json.Replace(@"""", @"\"""));
}
}
if (cd.AlbumArtResponse != null)
{
foreach (var art in cd.AlbumArtResponse)
{
var cover = coverApi.GetReleasesByDiscId(art.Key);
Assert.That(cover.Json, Is.EqualTo(art.Value), cover.Json);
}
}
}
private async Task <Response> SearchMusic(string searchTerm)
{
var apiAlbums = new List <Release>();
await Task.Run(() => MusicBrainzApi.SearchAlbum(searchTerm)).ContinueWith((t) =>
{
apiAlbums = t.Result.releases ?? new List <Release>();
});
var allResults = await RequestService.GetAllAsync();
allResults = allResults.Where(x => x.Type == RequestType.Album);
var dbAlbum = allResults.ToDictionary(x => x.MusicBrainzId);
var plexAlbums = Checker.GetPlexAlbums();
var viewAlbum = new List <SearchMusicViewModel>();
foreach (var a in apiAlbums)
{
var viewA = new SearchMusicViewModel
{
Title = a.title,
Id = a.id,
Artist = a.ArtistCredit?.Select(x => x.artist?.name).FirstOrDefault(),
Overview = a.disambiguation,
ReleaseDate = a.date,
TrackCount = a.TrackCount,
ReleaseType = a.status,
Country = a.country
};
DateTime release;
DateTimeHelper.CustomParse(a.ReleaseEvents?.FirstOrDefault()?.date, out release);
var artist = a.ArtistCredit?.FirstOrDefault()?.artist;
if (Checker.IsAlbumAvailable(plexAlbums.ToArray(), a.title, release.ToString("yyyy"), artist?.name))
{
viewA.Available = true;
}
if (!string.IsNullOrEmpty(a.id) && dbAlbum.ContainsKey(a.id))
{
var dba = dbAlbum[a.id];
viewA.Requested = true;
viewA.Approved = dba.Approved;
viewA.Available = dba.Available;
}
viewAlbum.Add(viewA);
}
return(Response.AsJson(viewAlbum));
}
private string GetMusicBrainzCoverArt(string id)
{
var coverArt = MusicBrainzApi.GetCoverArt(id);
var firstImage = coverArt?.images?.FirstOrDefault();
var img = string.Empty;
if (firstImage != null)
{
img = firstImage.thumbnails?.small ?? firstImage.image;
}
return(img);
}
private async Task <Artist> SearchArtist(string tagArtistName, string internetArtistName, string filenameArtistName, string trackMusicBrainzId)
{
Artist tempArtist;
//we search the artist names offline.
if (!string.IsNullOrWhiteSpace(tagArtistName) &&
_musicDataManager.LastfmApi.SearchArtist(tagArtistName, out tempArtist))
{
return(tempArtist);
}
if (!string.IsNullOrWhiteSpace(internetArtistName) &&
_musicDataManager.LastfmApi.SearchArtist(internetArtistName, out tempArtist))
{
return(tempArtist);
}
if (!string.IsNullOrWhiteSpace(filenameArtistName) &&
_musicDataManager.LastfmApi.SearchArtist(filenameArtistName, out tempArtist))
{
return(tempArtist);
}
if (!string.IsNullOrEmpty(trackMusicBrainzId))
{
var artistId = await MusicBrainzApi.GetArtistIdByTrackId(trackMusicBrainzId);
if (!string.IsNullOrEmpty(artistId))
{
var artist =
await
_musicDataManager.LastfmApi.GetArtistByMusicbrainzId(artistId,
CultureInfo.CurrentCulture);
return(artist);
}
}
return(null);
}
private Response RequestAlbum(string releaseId)
{
var settings = PrService.GetSettings();
var existingRequest = RequestService.CheckRequest(releaseId);
Log.Debug("Checking for an existing request");
if (existingRequest != null)
{
Log.Debug("We do have an existing album request");
if (!existingRequest.UserHasRequested(Username))
{
Log.Debug("Not in the requested list so adding them and updating the request. User: {0}", Username);
existingRequest.RequestedUsers.Add(Username);
RequestService.UpdateRequest(existingRequest);
}
return(Response.AsJson(new JsonResponseModel {
Result = true, Message = settings.UsersCanViewOnlyOwnRequests ? $"{existingRequest.Title} was successfully added!" : $"{existingRequest.Title} has already been requested!"
}));
}
Log.Debug("This is a new request");
var albumInfo = MusicBrainzApi.GetAlbum(releaseId);
DateTime release;
DateTimeHelper.CustomParse(albumInfo.ReleaseEvents?.FirstOrDefault()?.date, out release);
var artist = albumInfo.ArtistCredits?.FirstOrDefault()?.artist;
if (artist == null)
{
return(Response.AsJson(new JsonResponseModel {
Result = false, Message = "We could not find the artist on MusicBrainz. Please try again later or contact your admin"
}));
}
var albums = Checker.GetPlexAlbums();
var alreadyInPlex = Checker.IsAlbumAvailable(albums.ToArray(), albumInfo.title, release.ToString("yyyy"), artist.name);
if (alreadyInPlex)
{
return(Response.AsJson(new JsonResponseModel
{
Result = false,
Message = $"{albumInfo.title} is already in Plex!"
}));
}
var img = GetMusicBrainzCoverArt(albumInfo.id);
Log.Trace("Album Details:");
Log.Trace(albumInfo.DumpJson());
Log.Trace("CoverArt Details:");
Log.Trace(img.DumpJson());
var model = new RequestedModel
{
Title = albumInfo.title,
MusicBrainzId = albumInfo.id,
Overview = albumInfo.disambiguation,
PosterPath = img,
Type = RequestType.Album,
ProviderId = 0,
RequestedUsers = new List <string> {
Username
},
Status = albumInfo.status,
Issues = IssueState.None,
RequestedDate = DateTime.UtcNow,
ReleaseDate = release,
ArtistName = artist.name,
ArtistId = artist.id
};
if (ShouldAutoApprove(RequestType.Album, settings))
{
Log.Debug("We don't require approval OR the user is in the whitelist");
var hpSettings = HeadphonesService.GetSettings();
Log.Trace("Headphone Settings:");
Log.Trace(hpSettings.DumpJson());
if (!hpSettings.Enabled)
{
RequestService.AddRequest(model);
return
(Response.AsJson(new JsonResponseModel
{
Result = true,
Message = $"{model.Title} was successfully added!"
}));
}
var sender = new HeadphonesSender(HeadphonesApi, hpSettings, RequestService);
sender.AddAlbum(model).Wait();
model.Approved = true;
RequestService.AddRequest(model);
if (ShouldSendNotification())
{
var notify2 = new NotificationModel
{
Title = model.Title,
User = Username,
DateTime = DateTime.Now,
NotificationType = NotificationType.NewRequest
};
NotificationService.Publish(notify2);
}
return
(Response.AsJson(new JsonResponseModel
{
Result = true,
Message = $"{model.Title} was successfully added!"
}));
}
if (ShouldSendNotification())
{
var notify2 = new NotificationModel
{
Title = model.Title,
User = Username,
DateTime = DateTime.Now,
NotificationType = NotificationType.NewRequest
};
NotificationService.Publish(notify2);
}
var result = RequestService.AddRequest(model);
return(Response.AsJson(new JsonResponseModel
{
Result = true,
Message = $"{model.Title} was successfully added!"
}));
}