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; }