public ArtistResponse GetArtist(int id)
{
var artistExist = _context.Artist.Any(t => t.IdArtist.Equals(id));
if (!artistExist)
{
throw new Exception("Nie ma Artysty");
}
else
{
var artist = _context.Artist.Where(e => e.IdArtist == id).Single();
var artistEvent = _context.ArtistEvent.Where(e => e.IdArtist == id).ToList();
List <Event> eventResults = new List <Event>();
foreach (var eventItem in artistEvent)
{
eventResults.Add(
_context.Event.Single(x => x.IdEvent.Equals(eventItem.IdEvent))
);
}
List <Event> sortList = new List <Event>(eventResults.OrderByDescending(e => e.StartDate));
ArtistResponse artistResponse = new ArtistResponse {
IdArtist = artist.IdArtist,
Nickname = artist.Nickname,
Events = sortList
};
return(artistResponse);
}
}
public async Task <ActionResult <ArtistResponse> > Put(int id, [FromBody] ArtistResponse input,
CancellationToken ct = default)
{
try
{
if (input == null)
{
return(BadRequest());
}
if (await _chinookSupervisor.GetArtistByIdAsync(id, ct) == null)
{
return(NotFound());
}
var errors = JsonConvert.SerializeObject(ModelState.Values
.SelectMany(state => state.Errors)
.Select(error => error.ErrorMessage));
Debug.WriteLine(errors);
if (await _chinookSupervisor.UpdateArtistAsync(input, ct))
{
return(Ok(input));
}
return(StatusCode(500));
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
}
public static async Task <List <SongListItem> > GetSongs(int id)
{
string url = string.Format(Constants.URLs.ArtistSongs, id);
HttpWebRequest request = HttpWebRequest.Create(url) as HttpWebRequest;
HttpWebResponse response = await request.GetResponseAsync() as HttpWebResponse;
return(ArtistResponse.GetSongs(response));
}
public async Task <ArtistResponse> Get(int id)
{
var artist = await _artistCollection.GetArtistByIdAsync(id);
if (artist == null)
{
throw new HttpException(HttpStatusCode.NotFound);
}
return(await ArtistResponse.CreateFromArtistAsync(artist));
}
public async Task <ArtistResponse> AddArtistAsync(ArtistResponse newArtistViewModel,
CancellationToken ct = default)
{
var artist = new Artist
{
Name = newArtistViewModel.Name
};
artist = await _artistRepository.AddAsync(artist, ct);
newArtistViewModel.ArtistId = artist.ArtistId;
return(newArtistViewModel);
}
public async Task <bool> UpdateArtistAsync(ArtistResponse artistViewModel,
CancellationToken ct = default)
{
var artist = await _artistRepository.GetByIdAsync(artistViewModel.ArtistId, ct);
if (artist == null)
{
return(false);
}
artist.ArtistId = artistViewModel.ArtistId;
artist.Name = artistViewModel.Name;
return(await _artistRepository.UpdateAsync(artist, ct));
}
public async Task <string> GetOrStoreArtistImageAsync(ArtistResponse lastFmArtist, string artistNameBeforeCorrect)
{
await using var db = new FMBotDbContext(ConfigData.Data.Database.ConnectionString);
var artist = await db.Artists
.AsQueryable()
.FirstOrDefaultAsync(f => f.Name.ToLower() == lastFmArtist.Artist.Name.ToLower());
var imageUrlToReturn = "";
if (artist == null)
{
var spotifyArtist = await GetArtistFromSpotify(lastFmArtist.Artist.Name);
var artistToAdd = new Artist
{
Name = lastFmArtist.Artist.Name,
LastFmUrl = lastFmArtist.Artist.Url,
Mbid = lastFmArtist.Artist.Mbid
};
if (spotifyArtist != null)
{
artistToAdd.SpotifyId = spotifyArtist.Id;
if (spotifyArtist.Images.Any())
{
artistToAdd.SpotifyImageUrl = spotifyArtist.Images.OrderByDescending(o => o.Height).First().Url;
artistToAdd.SpotifyImageDate = DateTime.UtcNow;
imageUrlToReturn = artistToAdd.SpotifyImageUrl;
}
}
if (!string.Equals(artistNameBeforeCorrect, lastFmArtist.Artist.Name, StringComparison.CurrentCultureIgnoreCase))
{
artistToAdd.Aliases = new[] { artistNameBeforeCorrect };
}
await db.Artists.AddAsync(artistToAdd);
await db.SaveChangesAsync();
}
else
{
if (!string.Equals(artistNameBeforeCorrect, lastFmArtist.Artist.Name, StringComparison.CurrentCultureIgnoreCase))
{
if (artist.Aliases != null && artist.Aliases.Length > 0)
{
var aliases = artist.Aliases;
Array.Resize(ref aliases, aliases.Length + 1);
aliases[^ 1] = artistNameBeforeCorrect;
/// <summary>
/// Attach Get Artist Toggle
/// </summary>
/// <param name="client">Spotify Sdk Client</param>
/// <param name="response">Artist Response</param>
public async static Task AttachGetArtistToggles(
this ISpotifySdkClient client,
ArtistResponse response)
{
if (client.Config.IsAttachGetArtistToggles && response != null)
{
// Toggle Favourites
response.ToggleFavourite = await client.GetToggleAsync(
ToggleType.Favourites, response.Id, (byte)FavouriteType.Artist);
// Toggle Follow
response.ToggleFollow = await client.GetToggleAsync(
ToggleType.Follow, response.Id, (byte)FollowType.Artist);
}
}
public IActionResult GetArtist(int id)
{
var artist = _service.GetArtist(id);
if (artist == null)
{
return(NotFound());
}
ArtistResponse artistResponse = new ArtistResponse();
artistResponse.Artist = artist;
artistResponse.Paintings = _service.GetPaintingByArtist(id);
artistResponse.ArtMovements = _service.GetArtMovementByArtist(id);
return(Ok(artistResponse));
}
public async Task <ActionResult <ArtistResponse> > Post([FromBody] ArtistResponse input,
CancellationToken ct = default)
{
try
{
if (input == null)
{
return(BadRequest());
}
return(StatusCode(201, await _chinookSupervisor.AddArtistAsync(input, ct)));
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
}
public async Task <ArtistResponse> Create([FromBody] CreateArtistRequest request)
{
var user = await _authenticatedUser.GetUserAsync();
var artist = await user.GetArtistAsync();
if (artist != null)
{
throw new HttpException(HttpStatusCode.Unauthorized);
}
var result = await _artistCollection.CreateArtistAsync(user.Id, request.Name);
if (result == null)
{
throw new HttpException(HttpStatusCode.InternalServerError);
}
return(await ArtistResponse.CreateFromArtistAsync(result));
}
public ArtistResponse GetArtist(string artist)
{
string link = $"{_host}.art?apiKey=660a4395f992ff67786584e238f501aa&q={artist}&limit=10";
var music = new Music();
var musicApi = new ArtistResponse();
try
{
var result = _client.GetAsync(link).Result;
music = result.Content.ReadAsAsync <Music>().Result;
musicApi.Result = music.response.Docs;
musicApi.StatusCode = result.StatusCode;
}
catch (Exception)
{
musicApi.StatusCode = HttpStatusCode.BadGateway;
}
return(musicApi);
}
public IActionResult GetArtist([FromRoute] int id)
{
var artist = _context.Artist.Where(a => a.IdArtist == id)
.Include(a => a.ArtistEvent)
.ThenInclude(ae => ae.Event)
.FirstOrDefault();
if (artist == null)
{
return(NotFound());
}
var events = new List <Event>();
foreach (var ae in artist.ArtistEvent)
{
events.Add(ae.Event);
}
events = events.OrderByDescending(e => e.StartDate).ToList();
var response = new ArtistResponse();
response.IdArtist = artist.IdArtist;
response.Nickname = artist.Nickname;
var eventsResp = new List <EventResponse>();
foreach (var e in events)
{
var er = new EventResponse();
er.IdEvent = e.IdEvent;
er.Name = e.Name;
er.StartDate = e.StartDate;
er.EndDate = e.EndDate;
eventsResp.Add(er);
}
response.Events = eventsResp;
return(Ok(response));
}
/// <summary>
/// Attach Get Artist Commands
/// </summary>
/// <param name="client">Spotify Sdk Client</param>
/// <param name="response">Artist Response</param>
/// <param name="overrideIsAttach">Override Is Attach?</param>
public static void AttachGetArtistCommands(
this ISpotifySdkClient client,
ArtistResponse response,
bool?overrideIsAttach = null)
{
var isAttach = GetConfig(client.Config.IsAttachGetArtistCommands, overrideIsAttach);
if (isAttach && response != null)
{
// Artist Command
if (client.CommandActions.Artist != null)
{
response.Command = new GenericCommand <ArtistResponse>(
client.CommandActions.Artist);
}
// Add User Playback Command
response.AddUserPlaybackCommand = new GenericCommand <IPlaybackResponse>(
client.AddUserPlaybackHandler);
}
}
public ArtistResponse GetArtist(int id)
{
var artist = _context.Artists.Where(a => a.IdArtist == id).FirstOrDefault();
if (artist == null)
{
return(null);
}
var events = (from e in _context.Events
join ae in _context.Artist_Events on e.IdEvent equals ae.IdEvent
where ae.IdArtist == artist.IdArtist
select e).ToList();
var res = new ArtistResponse
{
Artist = artist,
Events = events
};
return(res);
}
public Music GetRelatedMusic(string music)
{
var url = $"{_host}.excerpt?apikey=8225b96502a09ad6758f6c4d593b4230s&q={music}&limit=10";
var musics = new Music();
var musicApi = new ArtistResponse();
try
{
var result = _client.GetAsync(url).Result;
musics = result.Content.ReadAsAsync <Music>().Result;
musicApi.Result = musics.response.Docs;
musics.StatusCode = result.StatusCode;
}
catch (Exception)
{
musics.StatusCode = HttpStatusCode.BadGateway;
}
return(musics);
}
public ArtistResponse Search(string criteria, int pageNumber, int pageSize)
{
//Fetch the unfiltered list from the repository layer so obtain the count of the results
var artistResults = ArtistRepository.SearchArtist(criteria);
//Filtered and paginated by LINQ
var artistListResults = artistResults.OrderBy(a => a.Lastname).Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList();
//Initialize the response to be returned
var artistResponse = new ArtistResponse {
ArtistCollectionResponse = new List <ArtistCollectionResponse>()
};
//Build the response to be returned
foreach (var artistResult in artistListResults)
{
artistResponse.ArtistCollectionResponse.Add(new ArtistCollectionResponse
{
Name = string.Concat(artistResult.Firstname.Trim(), " ", artistResult.Lastname.Trim()).Trim(),
Country = artistResult.CountryIso,
Alias = new List <string>(AliasRepository.GetByArtistId(artistResult.Id).Select(a => a.Text).ToList())
});
}
//Assign proper values to the 'page' properties
artistResponse.NumberOfSearchResults = artistResults.Count();
//Round up the number to prevent decimal.
//Example if there are 5 item and 2 per page, there should be 3 pages. so that 2.5 pages should be rounded up to 3 pages
var numberOfpages = (int)Math.Ceiling((double)artistResponse.NumberOfSearchResults / pageSize);
artistResponse.Page = pageNumber.ToString();
artistResponse.PageSize = pageSize.ToString();
artistResponse.NumberOfPages = numberOfpages.ToString();
return(artistResponse);
}
public async Task <IActionResult> Post(AddArtistRequest request)
{
ArtistResponse result = await _artistService.AddArtistAsync(request);
return(CreatedAtAction(nameof(GetById), new { id = result.ArtistId }, null));
}
public async Task <string> GetOrStoreArtistImageAsync(ArtistResponse lastFmArtist, string artistNameBeforeCorrect)
{
await using var db = new FMBotDbContext(ConfigData.Data.Database.ConnectionString);
var dbArtist = await db.Artists
.AsQueryable()
.FirstOrDefaultAsync(f => f.Name.ToLower() == lastFmArtist.Artist.Name.ToLower());
var imageUrlToReturn = "";
try
{
if (dbArtist == null)
{
var spotifyArtist = await GetArtistFromSpotify(lastFmArtist.Artist.Name);
var artistToAdd = new Artist
{
Name = lastFmArtist.Artist.Name,
LastFmUrl = lastFmArtist.Artist.Url,
Mbid = lastFmArtist.Artist.Mbid
};
if (spotifyArtist != null)
{
artistToAdd.SpotifyId = spotifyArtist.Id;
if (spotifyArtist.Images.Any())
{
artistToAdd.SpotifyImageUrl = spotifyArtist.Images.OrderByDescending(o => o.Height).First().Url;
artistToAdd.SpotifyImageDate = DateTime.UtcNow;
imageUrlToReturn = artistToAdd.SpotifyImageUrl;
}
}
if (!string.Equals(artistNameBeforeCorrect, lastFmArtist.Artist.Name, StringComparison.CurrentCultureIgnoreCase))
{
artistToAdd.Aliases = new[] { artistNameBeforeCorrect };
}
await db.Artists.AddAsync(artistToAdd);
await db.SaveChangesAsync();
}
else
{
if (!string.Equals(artistNameBeforeCorrect, lastFmArtist.Artist.Name, StringComparison.CurrentCultureIgnoreCase))
{
AddAliasToExistingArtist(artistNameBeforeCorrect, dbArtist);
db.Entry(dbArtist).State = EntityState.Modified;
}
if (dbArtist.SpotifyImageUrl == null || dbArtist.SpotifyImageDate < DateTime.UtcNow.AddMonths(-2))
{
var spotifyArtist = await GetArtistFromSpotify(lastFmArtist.Artist.Name);
if (spotifyArtist != null && spotifyArtist.Images.Any())
{
dbArtist.SpotifyImageUrl = spotifyArtist.Images.OrderByDescending(o => o.Height).First().Url;
imageUrlToReturn = dbArtist.SpotifyImageUrl;
}
dbArtist.SpotifyImageDate = DateTime.UtcNow;
db.Entry(dbArtist).State = EntityState.Modified;
}
else
{
imageUrlToReturn = dbArtist.SpotifyImageUrl;
}
await db.SaveChangesAsync();
}
return(!string.IsNullOrEmpty(imageUrlToReturn) ? imageUrlToReturn : null);
}
catch (Exception e)
{
Log.Error(e, "Something went wrong while retrieving artist image");
return(null);
}
}
public ArtistResponse Get(int id)
{
string baseUrl = Request.RequestUri.GetLeftPart(UriPartial.Authority);
using (var session = library.sessionFactory.OpenSession())
{
var res = new ArtistResponse();
res.artist = session.Query<Artist>().FirstOrDefault(x=>x.Id == id);
if(res.artist == null){
return null;
}
res.artist._links = new Dictionary<string, Link>();
res.artist._links.Add("self", new Link(baseUrl + "/api/Artist/" + res.artist.Id));
res.artist._links.Add("collection", new Link(baseUrl + "/api/Library/"));
res.albums = res.artist.Albums.ToList();
res.albums.ForEach(x =>
{
x._links = new Dictionary<string, Link>();
x._links.Add("self", new Link(baseUrl + "/api/Album/" + x.Id));
});
return res;
}
}
public static string ArtistWithUserToStringList(IList <ArtistWithUser> artists, ArtistResponse artistResponse, int userId)
{
var reply = "";
var artistsCount = artists.Count;
if (artistsCount > 14)
{
artistsCount = 14;
}
for (var index = 0; index < artistsCount; index++)
{
var artist = artists[index];
var nameWithLink = NameWithLink(artist);
var playString = GetPlaysString(artist.Playcount);
if (index == 0)
{
reply += $"👑 {nameWithLink}";
}
else
{
reply += $" {index + 1}.  {nameWithLink} ";
}
if (artist.UserId != userId)
{
reply += $"- **{artist.Playcount}** {playString}\n";
}
else
{
reply += $"- **{artistResponse.Artist.Stats.Userplaycount}** {playString}\n";
}
}
if (artists.Count == 1)
{
reply += $"\nNobody else has this artist in their top {Constants.ArtistsToIndex} artists.";
}
return(reply);
}
public static IList <ArtistWithUser> AddUserToIndexList(IList <ArtistWithUser> artists, User userSettings, IGuildUser user, ArtistResponse artist)
{
artists.Add(new ArtistWithUser
{
UserId = userSettings.UserId,
ArtistName = artist.Artist.Name,
Playcount = Convert.ToInt32(artist.Artist.Stats.Userplaycount.Value),
LastFMUsername = userSettings.UserNameLastFM,
DiscordUserId = userSettings.DiscordUserId,
DiscordName = user.Nickname ?? user.Username
});
return(artists.OrderByDescending(o => o.Playcount).ToList());
}
public async Task <IActionResult> GetById(Guid id)
{
ArtistResponse result = await _artistService.GetArtistAsync(new GetArtistRequest { Id = id });
return(Ok(result));
}
