public async Task <IActionResult> SuggestedSongs(int limit = 5)
{
PartyGoer user = new PartyGoer(User.FindFirstValue(ClaimTypes.NameIdentifier));
List <Song> recommendedSongs = await _partyGoerService.GetRecommendedSongsAsync(user.Id);
return(new JsonResult(recommendedSongs));
}
private async Task<List<Track>> GenerateNewPlaylist(Party party)
{
if (party.Playlist.History.Count > 0)
{
return await _spotifyHttpClient.GetRecommendedSongsAsync(party.Listeners.ElementAt(0).Id, party.Playlist.History.ToList().GetRandomNItems(5).Select(p => p.Uri).ToList(), 0);
}
else
{
List<Track> songs = new List<Track>();
foreach (PartyGoer listener in party.Listeners)
{
songs.AddRange(await _partyGoerService.GetRecommendedSongsAsync(listener.Id, 2));
}
return await _spotifyHttpClient.GetRecommendedSongsAsync(party.Listeners.ElementAt(0).Id, songs.GetRandomNItems(5).Select(p => p.Uri).ToList(), 0);
}
}
public async Task <List <Track> > GenerateNewPlaylist(Party party, List <string> recommendedTrackUris, List <string> recommendedArtistUris)
{
if (recommendedTrackUris.Count > 0 || recommendedArtistUris.Count > 0)
{
return(await _spotifyHttpClient.GetRecommendedTracksAsync(party.GetHost(), new RecommendedTracksSeed
{
SeedArtistUris = recommendedArtistUris,
SeedTrackUris = recommendedTrackUris,
Market = party.GetHost().GetMarket()
}));
}
else
{
return(await _spotifyHttpClient.GetRecommendedTracksAsync(party.GetHost(), new RecommendedTracksSeed
{
SeedArtistUris = recommendedArtistUris,
SeedTrackUris = (await _partyGoerService.GetRecommendedSongsAsync(party.GetHost().GetId(), 5)).Select(track => track.Id).ToList(),
Market = party.GetHost().GetMarket()
}));
}
}
public async Task <IActionResult> Index(string errorMessage)
{
try
{
PartyGoer user = await _partyGoerService.GetCurrentPartyGoerAsync();
Party party = await _partyService.GetPartyWithAttendeeAsync(user);
List <Domain.Track> userRecommendedSongs = await _partyGoerService.GetRecommendedSongsAsync(User.FindFirstValue(ClaimTypes.NameIdentifier));
List <Party> topParties = await _partyService.GetTopParties(3);
DashboardModel model = new DashboardModel
{
Name = user.Id,
AvailableParties = topParties.Select(p => new PreviewPartyModel
{
AlbumArtUrl = p.Playlist?.CurrentSong?.AlbumImageUrl ?? "./assets/unknown-album-art.png",
ListenerCount = p.Listeners.Count,
Name = "Default Party Name",
PartyCode = p.PartyCode
}).ToList(),
SuggestedSongs = userRecommendedSongs.Select(p => new PreviewPlaylistSong {
Artist = p.Artist, Title = p.Name, TrackUri = p.Uri, Selected = true
}).ToList(),
RandomGreeting = GetRandomGreeting()
};
BaseModel baseModel = new BaseModel(party == null ? false : true, party?.PartyCode, errorMessage);
return(View(new BaseModel <DashboardModel>(model, baseModel)));
}
catch (Exception ex)
{
await _logService.LogExceptionAsync(ex, "Error occurred in Index()");
// Todo: Add error view
return(View());
}
}
public async Task <IActionResult> Index(string partyCode)
{
PartyGoer user = new PartyGoer(User.FindFirstValue(ClaimTypes.NameIdentifier));
Party party;
if (string.IsNullOrWhiteSpace(partyCode))
{
party = await _partyService.GetPartyWithAttendeeAsync(user);
}
else
{
party = await _partyService.GetPartyWithCodeAsync(partyCode);
}
if (party == null)
{
return(RedirectToAction("Index", "Dashboard"));
}
List <Track> usersSuggestedSongs = null;
bool isUserListening = party.Listeners.Contains(user);
if (party.Listeners.Contains(user))
{
usersSuggestedSongs = await _partyGoerService.GetRecommendedSongsAsync(user.Id);
}
PartyModel model = new PartyModel
{
PartyCode = party.PartyCode,
SuggestedSongs = usersSuggestedSongs?.Select(song => ConvertDomainSongToModelSong(song)).ToList(),
IsUserListening = isUserListening
};
BaseModel baseModel = new BaseModel(true, model.PartyCode);
return(View(new BaseModel <PartyModel>(model, baseModel)));
}
public async Task HandleAsync(PlaylistEnded args)
{
await _logService.LogAppActivityAsync($"Playlist has ended for party with code {args.PartyCode}. Sending to all listeners");
Party party = await _partyService.GetPartyWithCodeAsync(args.PartyCode);
if (party.Listeners.Count < 1)
{
await party.DeletePlaylistAsync();
await _partyService.EndPartyAsync(args.PartyCode);
return;
}
List <Song> songs = new List <Song>();
foreach (PartyGoer listener in party.Listeners)
{
songs.AddRange(await _partyGoerService.GetRecommendedSongsAsync(listener.Id, 5));
}
List <Song> playlistSongs = await _spotifyHttpClient.GetRecommendedSongsAsync(party.Listeners.ElementAt(0).Id, songs.GetRandomNItems(5).Select(p => p.TrackUri).ToList(), 0);
// If there is atleast 1 person still in the party, regenerate the playlist
party.Playlist = new Playlist(playlistSongs, party.Listeners, party.PartyCode, party.Playlist.History);
await party.Playlist.StartAsync();
await _partyHubContext.Clients.Group(args.PartyCode).SendAsync("UpdatePartyView",
new
{
Song = party.Playlist.CurrentSong,
Position = party.Playlist.CurrentPositionInSong()
},
party.Playlist.History,
party.Playlist.Queue
);
}
public async Task <IActionResult> SuggestedSongs(int limit = 5)
{
return(new JsonResult(await _partyGoerService.GetRecommendedSongsAsync((await _partyGoerService.GetCurrentPartyGoerAsync()).GetId(), limit)));
}
public async Task <IActionResult> SuggestedSongs(int limit = 5)
{
List <Track> recommendedSongs = await _partyGoerService.GetRecommendedSongsAsync((await _partyGoerService.GetCurrentPartyGoerAsync()).Id);
return(new JsonResult(recommendedSongs));
}
