public JsonResult getPlayList()
{
//Se não houver sessão ativa, redireciona para o login
if ((string)Session["Token"] == null)
{
return(Json(false, JsonRequestBehavior.AllowGet));
}
else
{
try {
_spotifyApi.Token = (string)Session["Token"];
SpotifyService spotifyService = new SpotifyService(_spotifyApi);
//Get user_id and user displayName
SpotifyUser spotifyUser = spotifyService.GetUserProfile();
ViewBag.UserName = spotifyUser.DisplayName;
//Get user playlists ids
Playlists playlists = spotifyService.GetPlaylists(spotifyUser.UserId);
//Get all tracks from user
List <string> tracks = spotifyService.GetTracksAndArtistsFromPlaylists(playlists);
//Generate the new playlist
List <string> newPlayList = spotifyService.GenerateNewPlaylist(spotifyUser.DisplayName, tracks);
return(Json(newPlayList, JsonRequestBehavior.AllowGet));
} catch (Exception ex) {
return(Json(false, JsonRequestBehavior.AllowGet));
}
}
}
List <AudioCard> GetAudioCardsForPreviews(string genre)
{
var genreID =
(from genreItem in genres
where genreItem.Name == genre
select genreItem.Id)
.SingleOrDefault();
List <Track> tracks = new SpotifyService().GetTracks(genreID);
var cards =
(from track in tracks
let artists =
string.Join(", ",
from artist in track.Artists
select artist.Name)
select new AudioCard
{
Title = track.Name,
Subtitle = artists,
Media = new List <MediaUrl>
{
new MediaUrl(track.Preview_url)
}
})
.ToList();
return(cards);
}
private object ListPlaylistTracksToListTracks(object data, IServiceProvider serviceProvider, Models.Account user)
{
List <PlaylistTrack> playlistTracks = data as List <PlaylistTrack>;
List <SimpleTrack> tracks = new List <SimpleTrack>();
SpotifyService service = (SpotifyService)serviceProvider.GetService(typeof(SpotifyService));
SpotifyWebAPI api = service.GetSpotifyWebApi(service.GetSpotifyToken(user));
Console.WriteLine("Adding tracks from playlist");
for (int i = 0; i < playlistTracks.Count; i++)
{
Console.WriteLine("Adding track " + playlistTracks[i].Track.Name);
SimpleTrack track = new SimpleTrack();
track.Artists = playlistTracks[i].Track.Artists;
track.AvailableMarkets = playlistTracks[i].Track.AvailableMarkets;
track.DiscNumber = playlistTracks[i].Track.DiscNumber;
track.DurationMs = playlistTracks[i].Track.DurationMs;
track.Error = playlistTracks[i].Track.Error;
track.Explicit = playlistTracks[i].Track.Explicit;
track.ExternUrls = playlistTracks[i].Track.ExternUrls;
track.Href = playlistTracks[i].Track.Href;
track.Id = playlistTracks[i].Track.Id;
track.Name = playlistTracks[i].Track.Name;
track.PreviewUrl = playlistTracks[i].Track.PreviewUrl;
track.Restrictions = playlistTracks[i].Track.Restrictions;
track.TrackNumber = playlistTracks[i].Track.TrackNumber;
track.Type = playlistTracks[i].Track.Type;
track.Uri = playlistTracks[i].Track.Uri;
tracks.Add(track);
}
return(tracks as object);
}
public PlaceController(IPlacesService placesService, IUserService userService, SpotifyService spotify, ILogger <PlaceController> log)
{
_placesService = placesService;
_userService = userService;
_spotify = spotify;
this.log = log;
}
public async Task <IActionResult> AddSongToRoom(RoomVM roomVM)
{
var spotify = new SpotifyService(roomVM.CurrentRoom.SpotifyAuthCode);
var song = await spotify.GetSong(roomVM.SongToAdd);
var token = Request.Headers["Authorization"].ToString().Replace("Bearer ", "");
var username = _tokenService.GetNameFromToken(token);
Room room = null;
try
{
room = await _roomDataStore.AddSongToRoomAsync(username, roomVM.CurrentRoom.Id.ToString(), song);
var playlist = await _spotifyPlaylistsStore.GetItemByRoomId(room.Id.ToString());
await spotify.AddSongToPlaylist(playlist, song);
await _roomDataStore.RemovePreviouslyPlayedSongsAsync(room.Id);
}
catch { }
if (room != null)
{
await _roomHub.Clients.All.SendAsync("Update", room.Id.ToString());
return(PartialView("Components/_roomSongListItem", room.RoomSongs));
}
return(PartialView("Components/_roomSongListItem", room.RoomSongs));
}
private async Task RequestSpotifyAuthForUser(MBUser user, Message message, ILogger logger)
{
if (message.Chat.Type != ChatType.Private)
{
await TelegramClient.SendTextMessageAsync(
message.Chat.Id,
$"Sure thing... Sending you a message shortly to get us connected to Spotify");
}
var state = new AuthorizationState()
{
Message = message,
UserId = user.Id,
};
await TelegramClient.SendTextMessageAsync(
user.ServiceId,
$"OK, in order to continue, I need to connect to your Spotify so I can add you to the fun. Click the button below to get started.",
replyMarkup : new InlineKeyboardMarkup(
new InlineKeyboardButton()
{
Text = "Connect Spotify Account",
Url = SpotifyService.GetAuthorizationUri(user, state, GetNetSpotifyScopesRequired(user)).ToString()
}));
}
public SongService(ISongDao <DataAccess.Firestore.Model.Song> dao, ISongMapper <DataAccess.Firestore.Model.Song> mapper, SpotifyService spotify, IUserService userService)
{
_dao = dao;
_mapper = mapper;
this.spotify = spotify;
this.userService = userService;
}
public async Task <IActionResult> AddVoteToSong(int roomId, int songId)
{
var token = Request.Headers["Authorization"].ToString().Replace("Bearer ", "");
var room = await(_roomDataStore).AddVoteToSong(token, roomId, songId, 1);
var spotify = new SpotifyService(room.SpotifyAuthCode);
try
{
var removeTask = _roomDataStore.RemovePreviouslyPlayedSongsAsync(room.Id);
var reorderTask = spotify.ReorderPlaylist(room.SpotifyPlaylist, room);
await Task.WhenAll(removeTask, reorderTask);
}
catch { }
if (room != null)
{
await _roomHub.Clients.All.SendAsync("Update", roomId.ToString());
return(PartialView("Components/_roomSongListItem", room.RoomSongs));
}
return(StatusCode(500));
}
/// <summary>
/// Save the new playlist to the users spotify account
/// </summary>
/// <returns></returns>
public async Task SavePlaylist()
{
var playlist = await SpotifyService.CreatePlaylist(AuthenticationService.User, AuthenticationService.AuthenticationToken, "Favorite Artists + Top Songs " + DateTime.Now.ToString(), "Created with Randify!", isPublic : true);
try
{
var tracks = new List <Track>();
for (int i = 0; i < Tracks.Count; i++)
{
if (!string.IsNullOrWhiteSpace(Tracks[i].Id))
{
tracks.Add(Tracks[i]);
}
if (i % 100 == 0)
{
await SpotifyService.AddTracksToPlaylist(AuthenticationService.User, AuthenticationService.AuthenticationToken, playlist, tracks);
tracks.Clear();
}
}
await SpotifyService.AddTracksToPlaylist(AuthenticationService.User, AuthenticationService.AuthenticationToken, playlist, tracks);
}
catch (Exception ex)
{
PageException = ex;
}
ShowPlaylistSaved = true;
StateHasChanged();
}
/// <summary>
/// Component Initialized
/// </summary>
protected override async Task OnInitializedAsync()
{
try
{
var cursorPage = await SpotifyService.GetArtists(AuthenticationService.AuthenticationToken);
Artists.AddRange(cursorPage.Items);
while (cursorPage != null && cursorPage.Next != null)
{
cursorPage = await SpotifyService.GetArtists(AuthenticationService.AuthenticationToken, cursorPage);
Artists.AddRange(cursorPage.Items);
StateHasChanged();
}
await BindPlaylist();
}
catch (Exception ex)
{
this.PageException = ex;
}
Loaded = true;
StateHasChanged();
}
public SpotifyServiceTest()
{
_webClient = new SpotifyWebClient();
_trackRepositoryMock = new Mock <ITrackRepository> ();
_genreRepositoryMock = new Mock <IGenreRepository> ();
_spotifyService = new SpotifyService(_webClient, _trackRepositoryMock.Object, _genreRepositoryMock.Object);
}
/// <summary>
/// Component Initialized
/// </summary>
protected override async Task OnInitializedAsync()
{
try
{
if (NavigationManager.Uri.Contains("access_denied") || !NavigationManager.Uri.Contains("access_token"))
{
NavigationManager.NavigateTo(Urls.Index);
}
var keyValuePairs = NavigationManager.Uri.Split('#')[1].Split('&');
var token = new AuthenticationToken();
token.AccessToken = keyValuePairs.FirstOrDefault(o => o.Contains("access_token")).Split('=')[1];
token.ExpiresOn = DateTime.Now.AddSeconds(Convert.ToInt32(keyValuePairs.FirstOrDefault(o => o.Contains("expires_in")).Split('=')[1]));
token.TokenType = keyValuePairs.FirstOrDefault(o => o.Contains("token_type")).Split('=')[1];
var user = await SpotifyService.GetCurrentUserProfile(token);
if (user == null)
{
NavigationManager.NavigateTo(Urls.Index);
}
AuthenticationService.User = user;
AuthenticationService.AuthenticationToken = token;
AuthenticationService.IsAuthenticated = true;
NavigationManager.NavigateTo(Urls.SiteIndex);
}
catch (Exception ex)
{
PageException = ex;
}
}
public async void ShouldSortItemsDescending()
{
// Arrange
var accessToken = "BQAqqcamWRPmlTQIXjJdU434qvufZ3FOp6yrgNTW38ug6YRz9PkI8b3RWT8oZREU2HNZDjUJGtBNs4t4omxa2oPWJteF9jvVVXoARVUkJKIj90zulM1qWeP8zxMd9ZSkJN9lSoxmbeO7U0eXbKcsKDodAXqyzaFGvdMgsHW3PbnWk34nBqzYlvMjlRTNmSY0jFJ_8jOEIPHh_rkMdmZDyZNqDlei_32nlyV93ZXwEyUIyMkM928mBBLpfIivnuE2Jx-2UXMQIMRpbs_rOq3p";
var playlistId = "5qwobGpX8XWmsT9sdbX8ms";
var userService = new Mock <ICurrentUserService>();
var tokenService = new Mock <IUserTokenService>();
var spotifyConfig = SpotifyClientConfig.CreateDefault();
var spotifyClient = new SpotifyClient(spotifyConfig.WithToken(accessToken));
var spotifyService = new SpotifyService(userService.Object, spotifyConfig, tokenService.Object);
var beforePlaylist = await spotifyClient.Playlists.Get(playlistId);
beforePlaylist.Tracks.Items.OrderByDescending(x => x.AddedAt);
// Act
await spotifyService.SortPlaylistAsync(playlistId, Domain.Enums.SortDirection.Descending, CancellationToken.None);
var assertPlaylist = await spotifyClient.Playlists.Get(playlistId);
// Assert
// AddedDate should be the same
assertPlaylist.Tracks.Items[0].AddedAt.Should().Be(beforePlaylist.Tracks.Items[0].AddedAt);
}
public MainPage()
{
this.InitializeComponent();
// Properites //
SpotifyService spotify = new SpotifyService();
// Spotify Auth Code //
spotify.SetAuthToken();
moodSubmit.Click += (sender, error) =>
{
// Get text from input //
string enteredMood = moodInput.Text;
// Build URL endpoint //
string endpoint = "https://api.spotify.com/v1/search?q=" + enteredMood + "&type=playlist" + "&limit=10";
spotify.Search(endpoint, (json) => this.populateList(json));
// Remove text from input to start over //
moodInput.Text = "";
moodTitle.Text = "When you are feeling " + enteredMood.ToLower();
};
playlistTable.ItemClick += async(sender, item) =>
{
// On select create URI and open in browser //
Playlist selectedPlaylist = (Playlist)item.ClickedItem;
Uri uri = new Uri(selectedPlaylist.ExternalUrl);
await Windows.System.Launcher.LaunchUriAsync(uri);
};
}
public async Task Should_pass_authorization_when_response_is_received()
{
//arrange
var webApiLibraryService = new Mock <IWebApiService>();
var webApiAuthorizationService = new Mock <IWebApiAuthorizationService>();
webApiAuthorizationService
.Setup(s => s
.PostFormAsync <AuthorizationResponse>(It.IsAny <string>(), It.IsAny <IEnumerable <KeyValuePair <string, string> > >(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new AuthorizationResponse
{
AccessToken = "1234",
TokenType = "Bearer",
});
webApiLibraryService
.Setup(s => s.GetAsync <CategoryResponse>(It.IsAny <string>(), It.IsAny <string>(), CancellationToken.None))
.ReturnsAsync(new CategoryResponse
{
CategoriesInformation = new CategoriesInformation
{
Categories = Enumerable.Empty <Category>(),
},
});
var spotifyService = new SpotifyService(webApiLibraryService.Object, webApiAuthorizationService.Object);
//act
var actual = await spotifyService.ListCategoriesAsync(CancellationToken.None);
//assert
Assert.NotNull(actual);
}
protected async void OnMuteSound()
{
if (!SpotifyService.IsMuted)
{
await SpotifyService.SetMuteAsync(true);
}
}
protected async void OnUnmuteSound()
{
if (SpotifyService.IsMuted)
{
await SpotifyService.SetMuteAsync(false);
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
protected override async Task OnInitAsync()
{
try
{
var uri = UriHelper.GetAbsoluteUri();
if (uri.Contains("access_denied"))
{
UriHelper.NavigateTo(ConfigurationService.SpotifyLoginUrl);
}
var keyValuePairs = uri.Split('#')[1].Split('&');
var token = new AuthenticationToken();
token.AccessToken = keyValuePairs.FirstOrDefault(o => o.Contains("access_token")).Split('=')[1];
token.ExpiresOn = DateTime.Now.AddSeconds(Convert.ToInt32(keyValuePairs.FirstOrDefault(o => o.Contains("expires_in")).Split('=')[1]));
token.TokenType = keyValuePairs.FirstOrDefault(o => o.Contains("token_type")).Split('=')[1];
Logger.LogInformation("Access Granted");
var user = await SpotifyService.GetCurrentUserProfile(token);
AuthenticationService.User = user;
AuthenticationService.Token = token;
UriHelper.NavigateTo("Authenticated/Randifier");
}
catch (Exception ex)
{
PageException = ex;
Logger.LogError(ex, ex.Message);
}
}
public HostController(SessionStorageService sessionStorageService, SpotifyService spotify, QuestionService questionService, GameService gameService)
{
sessionService = sessionStorageService;
this.spotify = spotify;
this.questionService = questionService;
this.gameService = gameService;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="configuration"></param>
/// <param name="spotifyService"></param>
/// <param name="userService"></param>
public HomeController(IConfiguration configuration, SpotifyService spotifyService, IUserService userService, ILogger <HomeController> log)
{
Configuration = configuration;
_spotifyService = spotifyService;
this.userService = userService;
this.log = log;
}
public HomeController(IConfiguration configuration, FirebaseApp app, FirestoreDb db, SpotifyService spotifyService)
{
Configuration = configuration;
firebaseApp = app;
firestoreDb = db;
_spotifyService = spotifyService;
}
public TrackCommands(Logger.Logger logger,
IPrefixService prefixService,
GuildService guildService,
UserService userService,
LastFMService lastFmService,
SpotifyService spotifyService,
WhoKnowsTrackService whoKnowsTrackService,
PlayService playService,
IUpdateService updateService,
IIndexService indexService)
{
this._logger = logger;
this._prefixService = prefixService;
this._guildService = guildService;
this._userService = userService;
this._lastFmService = lastFmService;
this._spotifyService = spotifyService;
this._whoKnowsTrackService = whoKnowsTrackService;
this._playService = playService;
this._updateService = updateService;
this._indexService = indexService;
this._embed = new EmbedBuilder()
.WithColor(DiscordConstants.LastFMColorRed);
this._embedAuthor = new EmbedAuthorBuilder();
this._embedFooter = new EmbedFooterBuilder();
}
public async void GivenSetlistServiceReturnsAnErrorResultFromSpotifyService_WhenCallingGetSetlist_ThenItReturnsTheCorrectError()
{
var testSetlist = "{ \"id\": \"testId\", " +
"\"eventDate\": \"30-07-2019\", " +
"\"artist\": {\"name\": \"artistName\"}, " +
"\"venue\": {\"name\": \"venueName\"}, " +
"\"sets\": {\"set\": [{\"song\": [{\"name\": \"songTitle1\"}]}]}}";
JObject parsedSetlist = JObject.Parse(testSetlist);
var mockHttpClientFactoryForSetlistFmService = TestSetup.CreateMockHttpClientFactory(HttpStatusCode.OK, parsedSetlist);
var mockSetlistFmService = new SetlistFmService(mockHttpClientFactoryForSetlistFmService);
var mockHttpClientFactoryforSpotifyService = TestSetup.CreateMockHttpClientFactory(HttpStatusCode.NotFound);
var mockSpotifyService = new SpotifyService(mockHttpClientFactoryforSpotifyService);
var mockSpotSetService = new SpotSetService(mockSetlistFmService, mockSpotifyService);
var controller = CreateController(mockSpotSetService);
var result = await controller.GetSetlist("invalidId");
var error = Assert.IsType <NotFoundObjectResult>(result);
Assert.Contains(ErrorConstants.SpotifyError, error.Value.ToString());
}
public async void GivenSetlistServiceReturnsASuccessResult_WhenCallingGetSetlist_ThenItReturnsAStatus200()
{
var testSetlist = "{ \"id\": \"testId\", " +
"\"eventDate\": \"30-07-2019\", " +
"\"artist\": {\"name\": \"artistName\"}, " +
"\"venue\": {\"name\": \"venueName\"}, " +
"\"sets\": {\"set\": [{\"song\": [{\"name\": \"songTitle1\"}]}]}}";
JObject parsedSetlist = JObject.Parse(testSetlist);
var testSpotifyTracks =
"{\"tracks\": {\"items\": [{\"name\": \"songTitle\", \"uri\": \"spotify:track:uri1\"}]}}";
JObject parsedSpotifyTracks = JObject.Parse(testSpotifyTracks);
var mockHttpClientFactoryForSetlistFmService = TestSetup.CreateMockHttpClientFactory(HttpStatusCode.OK, parsedSetlist);
var mockSetlistFmService = new SetlistFmService(mockHttpClientFactoryForSetlistFmService);
var setlistDto = mockSetlistFmService.SetlistRequest("testId");
var mockHttpClientFactoryforSpotifyService = TestSetup.CreateMockHttpClientFactory(HttpStatusCode.OK, parsedSpotifyTracks);
var mockSpotifyService = new SpotifyService(mockHttpClientFactoryforSpotifyService);
await mockSpotifyService.SpotifyRequest(setlistDto.Result);
var mockSpotSetService = new SpotSetService(mockSetlistFmService, mockSpotifyService);
var controller = CreateController(mockSpotSetService);
var result = await controller.GetSetlist("testId");
Assert.IsType <OkObjectResult>(result);
}
/// <summary>
/// Bind the users list of playlists to the view
/// </summary>
/// <returns></returns>
private async Task BindPlaylists()
{
try
{
var page = await SpotifyService.GetPlaylists(AuthenticationService.User, AuthenticationService.AuthenticationToken);
do
{
foreach (var playlist in page.Items)
{
Playlists.Add(playlist);
}
if (page.HasNextPage)
{
page = await SpotifyService.GetNextPage(page, AuthenticationService.AuthenticationToken);
}
else
{
page = null;
}
}while (page != null);
}
catch (Exception ex)
{
PageException = ex;
}
Loaded = true;
StateHasChanged();
}
public async void GetSetlistReturnsASpotSetDtoWhenCalledWithSetlistIdThatReturnsValidDataButMissingTrackInfo()
{
var testSetlist = "{ \"id\": \"testId\", " +
"\"eventDate\": \"30-07-2019\", " +
"\"artist\": {\"name\": \"artistName\"}, " +
"\"venue\": {\"name\": \"venueName\"}, " +
"\"sets\": {\"set\": [{\"song\": [{\"name\": \"songTitle\"}]}]}}";
JObject parsedSetlist = JObject.Parse(testSetlist);
var testSpotifyTracks =
"{\"tracks\": {\"items\": [{\"name\": \"songTitle\"}]}}";
JObject parsedSpotifyTracks = JObject.Parse(testSpotifyTracks);
var mockHttpClientFactoryForSetlistFmService = TestSetup.CreateMockHttpClientFactory(HttpStatusCode.OK, parsedSetlist);
var mockSetlistFmService = new SetlistFmService(mockHttpClientFactoryForSetlistFmService);
var mockHttpClientFactoryforSpotifyService = TestSetup.CreateMockHttpClientFactory(HttpStatusCode.OK, parsedSpotifyTracks);
var mockSpotifyService = new SpotifyService(mockHttpClientFactoryforSpotifyService);
var mockSpotSetService = new SpotSetService(mockSetlistFmService, mockSpotifyService);
var result = await mockSpotSetService.GetSetlist("testId");
Assert.Equal("testId", result.Id);
Assert.Equal("07-30-2019", result.EventDate);
Assert.Equal("artistName", result.Artist);
Assert.Equal("venueName", result.Venue);
Assert.Equal("songTitle", result.Tracks[0].Name);
Assert.Null(result.Tracks[0].TrackUri);
}
public async Task <ActionResult> FormTwo(Models.SocialMedia model)
{
ViewBag.Collection = null;
if (ModelState.IsValid)
{
if (model.Type.ToString() == "Youtube")
{
var instance = new YoutubeService();
string playListID = "PLrQMMjaEqBpNTb40EHXeD_3r5Q2UyMjC2";
Array testOutput = await instance.getPlayList(playListID);
ViewBag.Collection = testOutput;
}
if (model.Type.ToString() == "Spotify")
{
var instanceSpot = new SpotifyService();
SpotifyPlaylist testOutput123 = await instanceSpot.GetPlayList();
//System.Diagnostics.Debug.WriteLine(testOutput123.Tracks.Items[0].Track.Name);
ViewBag.Collection = testOutput123;
}
}
return(View("index", model));
}
private void OnFollowId()
{
if (string.IsNullOrEmpty(TargetId))
{
return;
}
bool followResult = false;
if (m_isFollowingId)
{
followResult = TargetIdType == AccountType.Artist ? SpotifyService.UnfollowArtists(TargetId) : SpotifyService.UnfollowUsers(TargetId);
}
else
{
followResult = TargetIdType == AccountType.Artist ? SpotifyService.FollowArtists(TargetId) : SpotifyService.FollowUsers(TargetId);
}
m_isFollowingId = !m_isFollowingId;
m_followBtn.GetComponentInChildren <Text>().text = m_isFollowingId ? "Unfollow" : "Follow";
if (!followResult)
{
Analysis.LogError("Not able to follow/unfollow the id", Analysis.LogLevel.All);
}
}
protected override void OnConnectedChanged(ConnectedChanged e)
{
base.OnConnectedChanged(e);
if (e.IsConnected && !string.IsNullOrEmpty(TargetId))
{
m_isFollowingId = TargetIdType == AccountType.Artist ? SpotifyService.IsUserFollowingArtist(TargetId) : SpotifyService.IsUserFollowingUser(TargetId);
// Gets information about the target id
AccountInfo details = TargetIdType == AccountType.Artist ? (AccountInfo)SpotifyService.GetArtistDetails(TargetId) : SpotifyService.GetUserDetails(TargetId);
if (details != null)
{
StartCoroutine(Spotify4Unity.Helpers.Utility.LoadImageFromUrl(details.ProfilePictureURL, Spotify4Unity.Enums.Resolution.x128, (sprite) =>
{
m_userImg.sprite = sprite;
}));
if (m_name != null)
{
m_name.text = details.Name;
}
if (m_followers != null)
{
m_followers.text = "Followers: " + details.Followers.ToString();
}
}
m_followBtn.GetComponentInChildren <Text>().text = m_isFollowingId ? "Unfollow" : "Follow";
}
}
public SpotifyController(
AccountService accountService,
SpotifyService spotifyService)
{
_spotifyService = spotifyService;
_accountService = accountService;
}
internal SpotifyArtistsEndpoint(SpotifyService service) {
Service = service;
}
