public bool DeleteByArtist(int id)
{
try
{
var artistGenreDtos = GetByArtist(id);
if (artistGenreDtos == null)
{
_logger.LogError($"EventGenres with artist id: {id}, haven't been found in db.");
return(false);
}
foreach (ArtistGenreDto artistGenreDto in artistGenreDtos)
{
ArtistGenre artistGenre = _mapper.Map <ArtistGenre>(artistGenreDto);
_repository.Delete(artistGenre);
}
_repository.Save();
return(true);
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside DeleteByArtist action: {ex.Message}");
throw new Exception();
}
}
public IHttpActionResult PutArtistGenre(long id, ArtistGenre artistGenre)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != artistGenre.artist_genre_id)
{
return(BadRequest());
}
db.InsertOrUpdate(artistGenre);
try
{
db.Save();
}
catch (DbUpdateConcurrencyException)
{
if (!ArtistGenreExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public void Save(ArtistGenre artistGenre)
{
try
{
unitWork.ArtistGenreRepository.Insert(artistGenre);
unitWork.Save();
}
catch (Exception ex) { }
}
public IHttpActionResult GetArtistGenre(long id)
{
ArtistGenre artistGenre = db.Find(id);
if (artistGenre == null)
{
return(NotFound());
}
return(Ok(artistGenre));
}
public IHttpActionResult PostArtistGenre(ArtistGenre artistGenre)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.InsertOrUpdate(artistGenre);
db.Save();
return(CreatedAtRoute("DefaultApi", new { id = artistGenre.artist_genre_id }, artistGenre));
}
public void InsertOrUpdate(ArtistGenre artistgenre)
{
if (artistgenre.artist_genre_id == default(long))
{
// New entity
context.ArtistGenres.Add(artistgenre);
}
else
{
// Existing entity
context.Entry(artistgenre).State = System.Data.Entity.EntityState.Modified;
}
}
public void Add(int genreId, int artistId)
{
var genre = _context.Genre.FirstOrDefault(g => g.Id == genreId);
var artist = _context.Artist.FirstOrDefault(a => a.Id == artistId);
var newArtistGenre = new ArtistGenre
{
Artist = artist,
Genre = genre
};
_context.Add(newArtistGenre);
_context.SaveChanges();
}
public IHttpActionResult DeleteArtistGenre(long id)
{
ArtistGenre artistGenre = db.Find(id);
if (artistGenre == null)
{
return(NotFound());
}
db.Delete(id);
db.Save();
return(Ok(artistGenre));
}
public bool Create(ArtistGenreForCreationDto artistGenreForCreation)
{
try
{
ArtistGenre DataEntity = _mapper.Map <ArtistGenre>(artistGenreForCreation);
_repository.Create(DataEntity);
_repository.Save();
return(true);
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside CreateArtist action: {ex.Message}");
throw new Exception();
}
}
// GET: MusicGenre/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
//MusicGenre musicGenre = db.MusicGenre.Find(id);
var musicGenre = db.MusicGenre.Find(id).Album.Id;
var artistGenre = new ArtistGenre()
{
Artist = db.Album.Where(a => a.Id == musicGenre).Select(a => a.Artist).Single(),
Genre = db.MusicGenre.Where(g => g.Album.Id == musicGenre).ToList()
};
if (musicGenre < 1)
{
return(HttpNotFound());
}
return(View(artistGenre));
}
public bool Delete(int event_id, int genre_id)
{
try
{
var artistGenreDto = GetByIds(event_id, genre_id);
if (artistGenreDto == null)
{
return(false);
}
ArtistGenre artistGenre = _mapper.Map <ArtistGenre>(artistGenreDto);
_repository.Delete(artistGenre);
_repository.Save();
return(true);
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside DeleteArtistGenre action: {ex.Message}");
throw new Exception();
}
}
public async Task <OperationResult <Artist> > PerformMetaDataProvidersArtistSearch(AudioMetaData metaData)
{
SimpleContract.Requires <ArgumentNullException>(metaData != null, "Invalid MetaData");
SimpleContract.Requires <ArgumentNullException>(!string.IsNullOrEmpty(metaData.Artist), "Invalid MetaData, Missing Artist");
var sw = new Stopwatch();
sw.Start();
var result = new Artist
{
Name = metaData.Artist.ToTitleCase(false)
};
var resultsExceptions = new List <Exception>();
var artistGenres = new List <string>();
var artistImageUrls = new List <string>();
var artistName = metaData.Artist;
try
{
if (ITunesArtistSearchEngine.IsEnabled)
{
var sw2 = Stopwatch.StartNew();
var iTunesResult = await ITunesArtistSearchEngine.PerformArtistSearch(artistName, 1).ConfigureAwait(false);
if (iTunesResult.IsSuccess)
{
var i = iTunesResult.Data.First();
if (i.AlternateNames != null)
{
result.AlternateNames = result.AlternateNames.AddToDelimitedList(i.AlternateNames);
}
if (i.Tags != null)
{
result.Tags = result.Tags.AddToDelimitedList(i.Tags);
}
if (i.Urls != null)
{
result.URLs = result.URLs.AddToDelimitedList(i.Urls);
}
if (i.ISNIs != null)
{
result.ISNI = result.ISNI.AddToDelimitedList(i.ISNIs);
}
if (i.ImageUrls != null)
{
artistImageUrls.AddRange(i.ImageUrls);
}
if (i.ArtistGenres != null)
{
artistGenres.AddRange(i.ArtistGenres);
}
result.CopyTo(new Artist
{
EndDate = i.EndDate,
BioContext = i.Bio,
Profile = i.Profile,
ITunesId = i.iTunesId,
BeginDate = i.BeginDate,
Name = result.Name ?? i.ArtistName,
SortName = result.SortName ?? i.ArtistSortName,
ArtistType = result.ArtistType ?? i.ArtistType
});
}
if (iTunesResult.Errors != null)
{
resultsExceptions.AddRange(iTunesResult.Errors);
}
sw2.Stop();
Logger.LogTrace($"PerformMetaDataProvidersArtistSearch: ITunesArtistSearchEngine Complete [{ sw2.ElapsedMilliseconds }]");
}
}
catch (Exception ex)
{
Logger.LogError(ex, "iTunesArtistSearch: " + ex.Serialize());
}
try
{
if (MusicBrainzArtistSearchEngine.IsEnabled)
{
var sw2 = Stopwatch.StartNew();
var mbResult = await MusicBrainzArtistSearchEngine.PerformArtistSearch(result.Name, 1).ConfigureAwait(false);
if (mbResult.IsSuccess)
{
var mb = mbResult.Data.First();
if (mb.AlternateNames != null)
{
result.AlternateNames = result.AlternateNames.AddToDelimitedList(mb.AlternateNames);
}
if (mb.Tags != null)
{
result.Tags = result.Tags.AddToDelimitedList(mb.Tags);
}
if (mb.Urls != null)
{
result.URLs = result.URLs.AddToDelimitedList(mb.Urls);
}
if (mb.ISNIs != null)
{
result.ISNI = result.ISNI.AddToDelimitedList(mb.ISNIs);
}
if (mb.ImageUrls != null)
{
artistImageUrls.AddRange(mb.ImageUrls);
}
if (mb.ArtistGenres != null)
{
artistGenres.AddRange(mb.ArtistGenres);
}
if (!string.IsNullOrEmpty(mb.ArtistName) &&
!mb.ArtistName.Equals(result.Name, StringComparison.OrdinalIgnoreCase))
{
result.AlternateNames.AddToDelimitedList(new[] { mb.ArtistName });
}
result.CopyTo(new Artist
{
EndDate = mb.EndDate,
BioContext = mb.Bio,
Profile = mb.Profile,
MusicBrainzId = mb.MusicBrainzId,
DiscogsId = mb.DiscogsId,
SpotifyId = mb.SpotifyId,
ITunesId = mb.iTunesId,
AmgId = mb.AmgId,
BeginDate = mb.BeginDate,
Name = result.Name ?? mb.ArtistName,
SortName = result.SortName ?? mb.ArtistSortName,
ArtistType = mb.ArtistType
});
}
if (mbResult.Errors != null)
{
resultsExceptions.AddRange(mbResult.Errors);
}
sw2.Stop();
Logger.LogTrace($"PerformMetaDataProvidersArtistSearch: MusicBrainzArtistSearchEngine Complete [{ sw2.ElapsedMilliseconds }]");
}
}
catch (Exception ex)
{
Logger.LogError(ex, "MusicBrainzArtistSearch: " + ex.Serialize());
}
try
{
if (LastFmArtistSearchEngine.IsEnabled)
{
var sw2 = Stopwatch.StartNew();
var lastFmResult = await LastFmArtistSearchEngine.PerformArtistSearch(result.Name, 1).ConfigureAwait(false);
if (lastFmResult.IsSuccess)
{
var l = lastFmResult.Data.First();
if (l.AlternateNames != null)
{
result.AlternateNames = result.AlternateNames.AddToDelimitedList(l.AlternateNames);
}
if (l.Tags != null)
{
result.Tags = result.Tags.AddToDelimitedList(l.Tags);
}
if (l.Urls != null)
{
result.URLs = result.URLs.AddToDelimitedList(l.Urls);
}
if (l.ISNIs != null)
{
result.ISNI = result.ISNI.AddToDelimitedList(l.ISNIs);
}
if (l.ImageUrls != null)
{
artistImageUrls.AddRange(l.ImageUrls);
}
if (l.ArtistGenres != null)
{
artistGenres.AddRange(l.ArtistGenres);
}
if (!string.IsNullOrEmpty(l.ArtistName) &&
!l.ArtistName.Equals(result.Name, StringComparison.OrdinalIgnoreCase))
{
result.AlternateNames.AddToDelimitedList(new[] { l.ArtistName });
}
result.CopyTo(new Artist
{
EndDate = l.EndDate,
BioContext = HttpEncoder.HtmlEncode(l.Bio),
Profile = HttpEncoder.HtmlEncode(l.Profile),
MusicBrainzId = l.MusicBrainzId,
BeginDate = l.BeginDate,
Name = result.Name ?? l.ArtistName,
SortName = result.SortName ?? l.ArtistSortName,
ArtistType = result.ArtistType ?? l.ArtistType
});
}
if (lastFmResult.Errors != null)
{
resultsExceptions.AddRange(lastFmResult.Errors);
}
sw2.Stop();
Logger.LogTrace($"PerformMetaDataProvidersArtistSearch: LastFmArtistSearchEngine Complete [{ sw2.ElapsedMilliseconds }]");
}
}
catch (Exception ex)
{
Logger.LogError(ex, "LastFMArtistSearch: " + ex.Serialize());
}
try
{
if (SpotifyArtistSearchEngine.IsEnabled)
{
var sw2 = Stopwatch.StartNew();
var spotifyResult = await SpotifyArtistSearchEngine.PerformArtistSearch(result.Name, 1).ConfigureAwait(false);
if (spotifyResult.IsSuccess)
{
var s = spotifyResult.Data.First();
if (s.Tags != null)
{
result.Tags = result.Tags.AddToDelimitedList(s.Tags);
}
if (s.Urls != null)
{
result.URLs = result.URLs.AddToDelimitedList(s.Urls);
}
if (s.ImageUrls != null)
{
artistImageUrls.AddRange(s.ImageUrls);
}
if (s.ArtistGenres != null)
{
artistGenres.AddRange(s.ArtistGenres);
}
if (!string.IsNullOrEmpty(s.ArtistName) &&
!s.ArtistName.Equals(result.Name, StringComparison.OrdinalIgnoreCase))
{
result.AlternateNames.AddToDelimitedList(new[] { s.ArtistName });
}
result.CopyTo(new Artist
{
EndDate = s.EndDate,
BioContext = s.Bio,
Profile = HttpEncoder.HtmlEncode(s.Profile),
MusicBrainzId = s.MusicBrainzId,
SpotifyId = s.SpotifyId,
BeginDate = s.BeginDate,
Name = result.Name ?? s.ArtistName,
SortName = result.SortName ?? s.ArtistSortName,
ArtistType = result.ArtistType ?? s.ArtistType
});
}
if (spotifyResult.Errors != null)
{
resultsExceptions.AddRange(spotifyResult.Errors);
}
sw2.Stop();
Logger.LogTrace($"PerformMetaDataProvidersArtistSearch: SpotifyArtistSearchEngine Complete [{ sw2.ElapsedMilliseconds }]");
}
}
catch (Exception ex)
{
Logger.LogError(ex, "SpotifyArtistSearch: " + ex.Serialize());
}
try
{
if (DiscogsArtistSearchEngine.IsEnabled)
{
var sw2 = Stopwatch.StartNew();
var discogsResult = await DiscogsArtistSearchEngine.PerformArtistSearch(result.Name, 1).ConfigureAwait(false);
if (discogsResult.IsSuccess)
{
var d = discogsResult?.Data?.FirstOrDefault();
if (d != null)
{
if (d.Urls != null)
{
result.URLs = result.URLs.AddToDelimitedList(d.Urls);
}
if (d.ImageUrls != null)
{
artistImageUrls.AddRange(d.ImageUrls);
}
if (d.AlternateNames != null)
{
result.AlternateNames = result.AlternateNames.AddToDelimitedList(d.AlternateNames);
}
if (!string.IsNullOrEmpty(d.ArtistName) &&
!d.ArtistName.Equals(result.Name, StringComparison.OrdinalIgnoreCase))
{
result.AlternateNames.AddToDelimitedList(new[] { d.ArtistName });
}
result.CopyTo(new Artist
{
Profile = HttpEncoder.HtmlEncode(d.Profile),
DiscogsId = d.DiscogsId,
Name = result.Name ?? d.ArtistName,
RealName = result.RealName ?? d.ArtistRealName,
ArtistType = result.ArtistType ?? d.ArtistType
});
}
}
if (discogsResult.Errors != null)
{
resultsExceptions.AddRange(discogsResult.Errors);
}
sw2.Stop();
Logger.LogTrace($"PerformMetaDataProvidersArtistSearch: DiscogsArtistSearchEngine Complete [{ sw2.ElapsedMilliseconds }]");
}
}
catch (Exception ex)
{
Logger.LogError(ex, "DiscogsArtistSearch: " + ex.Serialize());
}
try
{
if (WikipediaArtistSearchEngine.IsEnabled)
{
var sw2 = Stopwatch.StartNew();
var wikiName = result?.Name;
// Help get better results for bands with proper nouns (e.g. "Poison" vs "Poison Band")
if (!(result?.ArtistType ?? string.Empty).Equals("Person", StringComparison.OrdinalIgnoreCase))
{
wikiName += " band";
}
var wikipediaResult = await WikipediaArtistSearchEngine.PerformArtistSearch(wikiName, 1).ConfigureAwait(false);
if (wikipediaResult?.Data != null)
{
if (wikipediaResult.IsSuccess)
{
var w = wikipediaResult?.Data?.FirstOrDefault();
if (!string.IsNullOrEmpty(w?.Bio))
{
result.CopyTo(new Artist
{
BioContext = HttpEncoder.HtmlEncode(w.Bio)
});
}
}
if (wikipediaResult.Errors != null)
{
resultsExceptions.AddRange(wikipediaResult.Errors);
}
}
sw2.Stop();
Logger.LogTrace($"PerformMetaDataProvidersArtistSearch: WikipediaArtistSearchEngine Complete [{ sw2.ElapsedMilliseconds }]");
}
}
catch (Exception ex)
{
Logger.LogError(ex, "WikipediaArtistSearch: " + ex.Serialize());
}
try
{
if (result.AlternateNames != null)
{
result.AlternateNames = string.Join("|", result.AlternateNames.ToListFromDelimited().Distinct().OrderBy(x => x));
}
if (result.URLs != null)
{
result.URLs = string.Join("|", result.URLs.ToListFromDelimited().Distinct().OrderBy(x => x));
}
if (result.Tags != null)
{
result.Tags = string.Join("|", result.Tags.ToListFromDelimited().Distinct().OrderBy(x => x));
}
if (artistGenres.Count > 0)
{
var sw2 = Stopwatch.StartNew();
var genreInfos = from ag in artistGenres
join g in DbContext.Genres on ag equals g.Name into gg
from g in gg.DefaultIfEmpty()
select new
{
newGenre = ag.ToTitleCase(),
existingGenre = g
};
result.Genres = new List <ArtistGenre>();
foreach (var genreInfo in genreInfos)
{
var ag = new ArtistGenre
{
Genre = genreInfo.existingGenre ?? new Genre
{
Name = genreInfo.newGenre,
NormalizedName = genreInfo.newGenre.ToAlphanumericName()
}
};
if (!result.Genres.Any(x => x.Genre.NormalizedName == ag.Genre.NormalizedName))
{
result.Genres.Add(ag);
}
}
sw2.Stop();
Logger.LogTrace($"PerformMetaDataProvidersArtistSearch: Artist Genre Processing Complete [{ sw2.ElapsedMilliseconds }]");
}
if (artistImageUrls.Count > 0)
{
var sw2 = Stopwatch.StartNew();
var imageBag = new ConcurrentBag <IImage>();
var i = artistImageUrls.Select(async url => imageBag.Add(await WebHelper.GetImageFromUrlAsync(url).ConfigureAwait(false)));
await Task.WhenAll(i).ConfigureAwait(false);
result.Images = imageBag.Where(x => x?.Bytes != null)
.GroupBy(x => x.Signature)
.Select(x => x.First())
.Take(Configuration.Processing.MaximumArtistImagesToAdd)
.ToList();
sw2.Stop();
Logger.LogTrace($"PerformMetaDataProvidersArtistSearch: Image Url Processing Complete [{ sw2.ElapsedMilliseconds }]");
}
}
catch (Exception ex)
{
Logger.LogError(ex, "CombiningResults: " + ex.Serialize());
}
result.SortName = result.SortName.ToTitleCase();
if (!string.IsNullOrEmpty(result.ArtistType))
{
switch (result.ArtistType.ToLower().Replace('-', ' '))
{
case "artist":
case "artists":
case "one man band":
case "one woman band":
case "solo":
case "person":
result.ArtistType = "Person";
break;
case "band":
case "big band":
case "duet":
case "jug band":
case "quartet":
case "quartette":
case "sextet":
case "trio":
case "group":
result.ArtistType = "Group";
break;
case "orchestra":
result.ArtistType = "Orchestra";
break;
case "choir band":
case "choir":
result.ArtistType = "Choir";
break;
case "movie part":
case "movie role":
case "role":
case "character":
result.ArtistType = "Character";
break;
default:
Logger.LogWarning(string.Format("Unknown Artist Type [{0}]", result.ArtistType));
result.ArtistType = "Other";
break;
}
}
sw.Stop();
return(new OperationResult <Artist>
{
Data = result,
IsSuccess = result != null,
Errors = resultsExceptions,
OperationTime = sw.ElapsedMilliseconds
});
}
private void CalculateProbability(ArtistWithProbability artist, CharacteristicsQuery query)
{
if (query.Genres != null)
{
foreach (GenreModel genre in query.Genres)
{
ArtistGenre artistGenre = artist.ArtistGenres.FirstOrDefault(ag => ag.GenreId == genre.Id);
if (artistGenre == null)
{
artist.CalculateProbability(0);
return;
}
artist.CalculateProbability(artistGenre.Probability);
}
}
if (query.Instruments != null)
{
foreach (InstrumentModel instrument in query.Instruments)
{
ArtistInstrument artistInstrument = artist.ArtistInstruments.FirstOrDefault(ai => ai.InstrumentId == instrument.Id);
if (artistInstrument == null)
{
artist.CalculateProbability(0);
return;
}
artist.CalculateProbability(artistInstrument.Probability);
}
}
if (query.Tempos != null)
{
foreach (TempoModel tempo in query.Tempos)
{
ArtistTempo artistTempo = artist.ArtistTempos.FirstOrDefault(at => at.TempoId == tempo.Id);
if (artistTempo == null)
{
artist.CalculateProbability(0);
return;
}
artist.CalculateProbability(artistTempo.Probability);
}
}
if (query.Novelties != null)
{
foreach (NoveltyModel novelty in query.Novelties)
{
ArtistNovelty artistNovelty = artist.ArtistNovelties.FirstOrDefault(an => an.NoveltyId == novelty.Id);
if (artistNovelty == null)
{
artist.CalculateProbability(0);
return;
}
artist.CalculateProbability(artistNovelty.Probability);
}
}
}
public void Add(ArtistGenre newArtistGenre)
{
_context.Add(newArtistGenre);
_context.SaveChanges();
}
public void Delete(ArtistGenre model)
{
throw new NotImplementedException();
}
