public async Task <OperationResult <GetPlaylistsQuery, GetPlaylistsResponse> > HandleAsync(GetPlaylistsQuery query) { OperationResult <GetPlaylistsQuery, GetPlaylistsResponse> result; try { if (query?.AccessToken == null) { throw new APIUnauthorizedException(); } var config = SpotifyClientConfig .CreateDefault(query.AccessToken) .WithRetryHandler(new SimpleRetryHandler() { RetryTimes = 30, RetryAfter = TimeSpan.FromSeconds(1), TooManyRequestsConsumesARetry = false }); spotify = new SpotifyClient(config); var playlistsTuple = await GetUserPlaylists(query.Index, query.OwnerId); var response = new GetPlaylistsResponse { Playlists = playlistsTuple.Item1, IsFinished = playlistsTuple.Item2, Index = playlistsTuple.Item3 }; result = OperationResult <GetPlaylistsQuery, GetPlaylistsResponse> .Success(response); return(await Task.FromResult(result)); } catch (APIUnauthorizedException) { result = OperationResult <GetPlaylistsQuery, GetPlaylistsResponse> .Failure(StatusCodes.Unauthorized, ErrorMessages.SessionExpired); return(await Task.FromResult(result)); } catch (Exception ex) { logger.LogError(ex, "An unexpected error occurred."); result = OperationResult <GetPlaylistsQuery, GetPlaylistsResponse> .Failure(StatusCodes.InternalServerError, ErrorMessages.UnexpectedError); return(await Task.FromResult(result)); } }
//HashSet<Edge> Edges = new HashSet<Edge>(); public ArtistsConnectionsForm() { InitializeComponent(); var config = SpotifyClientConfig.CreateDefault().WithAuthenticator(new ClientCredentialsAuthenticator("e6bf2e305d98443190c472ee318fd511", "96bad35ecf9c41f581a761eb3a85348b")); Spotify = new SpotifyClient(config); ArtistsToCheck.Enqueue("4JxdBEK730fH7tgcyG3vuv", 0); int n = 0; while (ArtistsToCheck.Count > 0 && ArtistsToCheck.GetPriority(ArtistsToCheck.First) <= 2) { string first = ArtistsToCheck.First; float priority = ArtistsToCheck.GetPriority(first); ArtistsToCheck.Dequeue(); Task <List <string> > artistsTask = FindAllConnectedArtists(first, priority); artistsTask.Wait(); n++; } List <string> edges = new List <string>(); foreach (Edge edge in ArtistsGraph.Edges) { string sourceName; string targetName; ArtistIdToName.TryGetValue(edge.Source, out sourceName); ArtistIdToName.TryGetValue(edge.Source, out targetName); edges.Add(sourceName + " - " + edge.LabelText + " - " + targetName); } ListBox1.DataSource = edges; while (ArtistsToCheck.Count > 0) { string name; ArtistIdToName.TryGetValue(ArtistsToCheck.First, out name); float priority = ArtistsToCheck.GetPriority(ArtistsToCheck.First); ArtistsToCheck.Dequeue(); ListBox3.Items.Add(name + " - " + priority); } foreach (string id in CheckedArtists) { string name; ArtistIdToName.TryGetValue(id, out name); ListBox2.Items.Add(name); } label1.Text = ListBox1.Items.Count.ToString(); label2.Text = ListBox2.Items.Count.ToString(); label3.Text = ListBox3.Items.Count.ToString(); }
public async Task <ISpotifyClient> CreateSpotifyClientAsync() { PKCETokenResponse tokenResponse = _config.Tokens; if (String.IsNullOrEmpty(tokenResponse.AccessToken) || String.IsNullOrEmpty(tokenResponse.RefreshToken)) { tokenResponse = await UseNewTokens(); } else if (tokenResponse.HasExpired()) { tokenResponse = await RefreshTokens(); } var config = SpotifyClientConfig.CreateDefault().WithAuthenticator(new PKCEAuthenticator(_config.ClientId, tokenResponse)); return(new SpotifyClient(config)); }
private async Task <string?> SearchSpotify(string details) { var spotifyConfig = SpotifyClientConfig .CreateDefault() .WithAuthenticator( new ClientCredentialsAuthenticator(config["SpotifyId"], config["SpotifySecret"])); var spotify = new SpotifyClient(spotifyConfig); var searchResult = await spotify.Search.Item(new SearchRequest(SearchRequest.Types.Track, details)); var track = searchResult.Tracks?.Items?.FirstOrDefault(); var result = track?.ExternalUrls["spotify"]; return(result); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddHttpContextAccessor(); services.AddSingleton(SpotifyClientConfig.CreateDefault()); services.AddScoped <SpotifyClientBuilder>(); services.AddDbContext <MatchMusicContext>(options => { options.UseSqlServer(Configuration.GetConnectionString("Default")); }); services.AddAuthorization(options => { options.AddPolicy("Spotify", policy => { policy.AuthenticationSchemes.Add("Spotify"); policy.RequireAuthenticatedUser(); }); }); services.AddAuthentication(options => { options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme; }) .AddCookie(options => { options.ExpireTimeSpan = TimeSpan.FromMinutes(50); }) .AddSpotify(options => { options.ClientId = Configuration["**"]; options.ClientSecret = Configuration["**"]; options.SaveTokens = true; var scopes = new List <string> { UserReadEmail, UserReadPrivate, PlaylistReadPrivate, PlaylistReadCollaborative, UserTopRead }; options.Scope.Add(string.Join(",", scopes)); }) .Services.Configure <SpotifyAuthenticationOptions>("Spotify", Configuration.GetSection("Authentication:Spotify")); services.AddControllersWithViews(); }
private async Task OnAuthorizationCodeReceivedAsync(object sender, AuthorizationCodeResponse response) { await Server.Stop(); Server.Dispose(); var config = SpotifyClientConfig.CreateDefault(); var tokenResponse = await new OAuthClient(config).RequestToken(new AuthorizationCodeTokenRequest(CLIENT_ID, CLIENT_SECRET, response.Code, new Uri("http://localhost:5000/callback"))); SClient = new SpotifyClient(tokenResponse.AccessToken); SToken = tokenResponse.AccessToken; SRefresh = tokenResponse.RefreshToken; SReady = true; SExpiry = DateTime.Now.AddSeconds(tokenResponse.ExpiresIn); Console.Clear(); await Util.LoggerAsync(new LogMessage(LogSeverity.Info, "Spotify", "Spotify Connected. You can now start queueing songs.")); }
public async Task NextPageForIPaginatable() { var api = new Mock <IAPIConnector>(); var config = SpotifyClientConfig.CreateDefault("FakeToken").WithAPIConnector(api.Object); var spotify = new SpotifyClient(config); var response = new SearchResponse { Albums = new Paging <SimpleAlbum, SearchResponse> { Next = "https://next-url", } }; await spotify.NextPage(response.Albums); api.Verify(a => a.Get <SearchResponse>(new System.Uri("https://next-url")), Times.Once); }
public async void Start() { try { _authenticator = new PKCEAuthenticator(_clientId !, TokenResponse); var config = SpotifyClientConfig.CreateDefault() .WithAuthenticator(_authenticator); _spotifyClient = new SpotifyClient(config); var user = await _spotifyClient.UserProfile.Current(); //var playlists = await _spotifyClient.Playlists.GetUsers(user.Id); _user = user; //UserPlaylists = playlists; if (user.Product == "premium") { IsPremiumUser = true; } OnLoggedIn?.Invoke(_user, TokenResponse); _stateTaskCancellationTokenSource = new CancellationTokenSource(); var token = _stateTaskCancellationTokenSource.Token; var task = new Task(async(token) => { while (!((CancellationToken)token !).IsCancellationRequested) { var delayTask = Task.Delay(_playerRefreshTime); //Run timer every _playerRefreshTime await CheckPlayerState(); await delayTask; } }, _stateTaskCancellationTokenSource.Token); task.Start(); } catch (Exception e) { //We will just ignore for now, this should be handled better though } }
public void RenewToken(int seconds) { var renewThread = Task.Run(async() => { await Task.Delay(1000 * (seconds - 120)); SReady = false; await Util.LoggerAsync(new LogMessage(LogSeverity.Info, "Spotify", "Spotify token refreshing.")); var config = SpotifyClientConfig.CreateDefault(); var tokenResponse = await new OAuthClient(config).RequestToken(new AuthorizationCodeRefreshRequest(CLIENT_ID, CLIENT_SECRET, SRefresh)); SClient = new SpotifyClient(tokenResponse.AccessToken); SToken = tokenResponse.AccessToken; SReady = true; SExpiry = DateTime.Now.AddSeconds(tokenResponse.ExpiresIn); await Util.LoggerAsync(new LogMessage(LogSeverity.Info, "Spotify", "Spotify token refreshed.")); }); }
public async void GetSpotifyRecommandation(Object obj) { if (!string.IsNullOrEmpty(SpotifyId)) { List <string> nameList = new List <string>(); var config = SpotifyClientConfig.CreateDefault(); var request = new ClientCredentialsRequest("349e633cba5b499183d80b075c90da6c", "a19042332bd5470f9fc9d2fca33c7b23"); var response = await new OAuthClient(config).RequestToken(request); var spotify = new SpotifyClient(config.WithToken(response.AccessToken)); var related = await spotify.Artists.GetRelatedArtists(SpotifyId); foreach (var name in related.Artists) { nameList.Add(name.Name.ToString()); } UpdateRelatedList(nameList); } }
private static async Task <SpotifyClient> GetSpotifyClient(string spotifyToken) { var config = SpotifyClientConfig.CreateDefault() .WithToken(spotifyToken) .WithRetryHandler(new SimpleRetryHandler { RetryAfter = TimeSpan.FromSeconds(1), RetryTimes = 1 }); var spotify = new SpotifyClient(config); var me = await spotify.UserProfile.Current().ConfigureAwait(false); if (string.IsNullOrWhiteSpace(me.Id)) { throw new Exception("Authorization with Spotify failed."); } return(spotify); }
public static bool StartCached(Action <SpotifyClient> onComplete) { if (!File.Exists(m_TokenPath)) { return(false); } string json = File.ReadAllText(m_TokenPath); PKCETokenResponse token = JsonConvert.DeserializeObject <PKCETokenResponse>(json); PKCEAuthenticator authenticator = new PKCEAuthenticator(m_ClientId, token); authenticator.TokenRefreshed += (sender, refreshedToken) => File.WriteAllText(m_TokenPath, JsonConvert.SerializeObject(refreshedToken)); SpotifyClientConfig config = SpotifyClientConfig.CreateDefault().WithAuthenticator(authenticator); SpotifyClient client = new SpotifyClient(config); onComplete(client); return(true); }
public async void SkipRemovalIfLimitIsNotExceeded() { //Arrange var userService = new Mock<ICurrentUserService>(); userService.SetupGet(x => x.UserId).Returns("eimerreis"); var userTokenService = new Mock<IUserTokenService>(); var spotifyClientMock = new Mock<SpotifyClient>(); spotifyClientMock.Setup(x => x.Playlists.Get(It.IsAny<string>())) .ReturnsAsync(JsonConvert.DeserializeObject<FullPlaylist>("")); var spotifyConfig = SpotifyClientConfig.CreateDefault(); var spotifyService = new SpotifyService(userService.Object, spotifyConfig.WithToken(""), userTokenService.Object); //Act await spotifyService.RemoveOrArchiveTracksAsync("", 60, ""); //Assert spotifyClientMock.Verify(x => x.Playlists.RemoveItems(It.IsAny<string>(), It.IsAny<PlaylistRemoveItemsRequest>()), Times.Never); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddHttpContextAccessor(); services.AddSingleton(SpotifyClientConfig.CreateDefault()); services.AddScoped <SpotifyClientBuilder>(); services.AddAuthorization(options => { options.AddPolicy("Spotify", policy => { policy.AuthenticationSchemes.Add("Spotify"); policy.RequireAuthenticatedUser(); }); }); services .AddAuthentication(options => { options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme; }) .AddCookie(options => { options.ExpireTimeSpan = TimeSpan.FromMinutes(50); }) .AddSpotify(options => { options.ClientId = Configuration["SPOTIFY_CLIENT_ID"]; options.ClientSecret = Configuration["SPOTIFY_CLIENT_SECRET"]; options.CallbackPath = "/Auth/callback"; options.SaveTokens = true; var scopes = new List <string> { UserReadEmail, UserReadPrivate, PlaylistReadPrivate, PlaylistReadCollaborative }; options.Scope.Add(string.Join(",", scopes)); }); services.AddRazorPages() .AddRazorPagesOptions(options => { options.Conventions.AuthorizeFolder("/", "Spotify"); }); }
private async Task StartLoginSpotify(Stopwatch crono) { Log.Instance.PrintMessage("Logging to Spotify", MessageType.Info); var json = await File.ReadAllTextAsync(AuthPath); var token = JsonConvert.DeserializeObject <PKCETokenResponse>(json); var auth = new PKCEAuthenticator(PublicKey, token); auth.TokenRefreshed += (sender, token) => File.WriteAllText(AuthPath, JsonConvert.SerializeObject(token)); SpotifyConfig = SpotifyClientConfig.CreateDefault().WithAuthenticator(auth); SpotifyClient = new SpotifyClient(SpotifyConfig); AccountReady = true; User = SpotifyClient.UserProfile.Current().Result; Log.Instance.PrintMessage("Connected as " + User.Email, MessageType.Correct, crono, TimeType.Seconds); Config.LinkedWithSpotify = true; AccountLinked = true; Kernel.ActivarReproduccionSpotify(); Kernel.InternetAvaliable(true); Kernel.BringMainFormFront(); crono.Stop(); }
public static async Task <EmbedBuilder> Search(string requestString) { string song_name; string album_name; int popuarity; string artistname; string genres_string = ""; EmbedBuilder embedBuilder = new EmbedBuilder(); //Getting tokens from our json. GetSpotifyTokens(); //Connection of Bot client var config = SpotifyClientConfig.CreateDefault(); var request = new ClientCredentialsRequest(Bot_id, Bot_ids); var response = await new OAuthClient(config).RequestToken(request); var spotify = new SpotifyClient(config.WithToken(response.AccessToken)); // --- try { SearchRequest searchRequest = new SearchRequest(SearchRequest.Types.All, requestString); searchRequest.Limit = 5; var result = await spotify.Search.Item(searchRequest); //Sending search request and obtaining data obj EmbedBuilder embed = EmbedCreator(result, spotify); if (embed == null) { throw new ArgumentException(""); } return(embed); } catch (Exception e) { throw new ArgumentException($"No matches found for \"{requestString}\"."); } }
/// <summary> /// This method is created for command !listen. /// Returns string with genres of songs artist and popularity score. /// </summary> /// <param name="songName"></param> /// <returns></returns> /// <exception cref="ArgumentException"></exception> public static async Task <Tuple <int, string> > Listen(string songName) { GetSpotifyTokens(); //Connection of Bot client var config = SpotifyClientConfig.CreateDefault(); var request = new ClientCredentialsRequest(Bot_id, Bot_ids); var response = await new OAuthClient(config).RequestToken(request); var spotify = new SpotifyClient(config.WithToken(response.AccessToken)); // --- try { var result = await spotify.Search.Item(new SearchRequest(SearchRequest.Types.All, songName)); //Sending search request and creating json string data_json = result.Tracks.ToJson(); dynamic data = Newtonsoft.Json.JsonConvert.DeserializeObject(data_json); var popularity = data.Items[0].Popularity; //популярність треку //GenreSearch string artistid = data.Items[0].Album.Artists[0].Id.ToString(); var artist = await spotify.Artists.Get(artistid); var artistname = data.Items[0].Artists[0].Name.ToString(); string genres_string = ""; foreach (var genre in artist.Genres.ToArray()) { genres_string = genres_string + "+" + genre; } return(Tuple.Create((int)popularity, genres_string)); } catch (Exception e) { throw new ArgumentException($"Song \"{songName}\" was not found."); } }
public async void ShouldRemoveItems() { // Arrange var accessToken = "BQAqqcamWRPmlTQIXjJdU434qvufZ3FOp6yrgNTW38ug6YRz9PkI8b3RWT8oZREU2HNZDjUJGtBNs4t4omxa2oPWJteF9jvVVXoARVUkJKIj90zulM1qWeP8zxMd9ZSkJN9lSoxmbeO7U0eXbKcsKDodAXqyzaFGvdMgsHW3PbnWk34nBqzYlvMjlRTNmSY0jFJ_8jOEIPHh_rkMdmZDyZNqDlei_32nlyV93ZXwEyUIyMkM928mBBLpfIivnuE2Jx-2UXMQIMRpbs_rOq3p"; var playlistId = "5qwobGpX8XWmsT9sdbX8ms"; var archiveListId = "0nhkQH0NluA1M8sfXJKP8n"; var maximumTracks = 5; 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); // Act await spotifyService.RemoveOrArchiveTracksAsync(playlistId, maximumTracks, archiveListId); var assertPlaylist = await spotifyClient.Playlists.Get(playlistId); // Assert assertPlaylist.Tracks.Items.Count.Should().Be(maximumTracks); }
static Clients( ) { Log.Information("Connecting to Spotify..."); SpotifyClientConfig spotify_config = SpotifyClientConfig.CreateDefault( ) .WithAuthenticator( new ClientCredentialsAuthenticator( Config.SotifyClientID, Config.SotifyClientSecret)); _spotify_client = new SpotifyClient(spotify_config); Log.Information("Connection to Spotify successful"); Log.Information("Connecting to Yandex Music..."); _yAusthStorage = new AuthStorage( ); _yandex_music_client = new YandexMusicApi( ); _yandex_music_client.User.Authorize(_yAusthStorage, Config.YMLogin, Config.YMPassword); Log.Information("Connection to Yandex Music successful"); }
public static async Task SkipPrevius() { var json = await File.ReadAllTextAsync(CredentialsPath); var token = JsonConvert.DeserializeObject <PKCETokenResponse>(json); var authenticator = new PKCEAuthenticator(clientId !, token); authenticator.TokenRefreshed += (sender, token) => File.WriteAllText(CredentialsPath, JsonConvert.SerializeObject(token)); var config = SpotifyClientConfig.CreateDefault() .WithAuthenticator(authenticator); var spotify = new SpotifyClient(config); var me = await spotify.UserProfile.Current(); await spotify.Player.SkipPrevious(); _server.Dispose(); }
async Task GetAlbumsAsync() { if (IsBusy) { return; } try { IsBusy = true; var config = SpotifyClientConfig.CreateDefault(); var request = new ClientCredentialsRequest(clientId, clientSecret); var response = await new OAuthClient(config).RequestToken(request); var spotify = new SpotifyClient(config.WithToken(response.AccessToken)); var albumsRaw = await spotify.Artists.GetAlbums(Authors[AuthorSelected]); var albums = albumsRaw.Items; Albums.Clear(); foreach (var album in albums) { var songsRaw = await spotify.Albums.GetTracks(album.Id); var songs = songsRaw.Items; Albums.Add(Album.FromSimpleAlbum(album, songs)); } } catch (Exception ex) { Debug.WriteLine($"Error to get albums: {ex.Message}"); await Application.Current.MainPage.DisplayAlert("Error with albums! ", ex.Message, "Dobrá"); } finally { IsBusy = false; } }
/// <summary> /// Create a client to do calls to the spotify api with. /// </summary> /// <returns>A SpotifyClient, or null of no accessToken could be found.</returns> public async Task <ISpotifyClient> Create(long userId) { var token = await _authorizationTokenRepository.Get(userId); if (token == null) { return(null); } // Map the token to a model the Spotify library can work with. var tokenResponse = _mapper.Map <AuthorizationCodeTokenResponse>(token); // TODO: inject singleton httpclient from startup. var config = SpotifyClientConfig .CreateDefault() .WithAuthenticator(new AuthorizationCodeAuthenticator(_spotifyOptions.ClientId, _spotifyOptions.Secret, tokenResponse)) .WithRetryHandler(new SimpleRetryHandler() { RetryAfter = TimeSpan.FromSeconds(1), TooManyRequestsConsumesARetry = true }); return(new SpotifyClient(config)); }
/// <summary> /// For Spotify API calls that only require client authorization, not tied to a specific user /// See: https://developer.spotify.com/documentation/general/guides/authorization-guide/#client-credentials-flow /// </summary> private async Task <GetSpotifyApiOutput> GetApiWithClientCredentials() { string clientId = _configuration.GetValue <string>(AppSettingKeys.Spotify.ClientId); string clientSecret = _configuration.GetValue <string>(AppSettingKeys.Spotify.ClientSecret); var config = SpotifyClientConfig.CreateDefault(); try { var request = new ClientCredentialsRequest(clientId, clientSecret); var response = await new OAuthClient(config).RequestToken(request); return(new GetSpotifyApiOutput { Api = new SpotifyClient(response.AccessToken, response.TokenType), TokenResponse = response }); } catch (Exception ex) { Logger.LogError("ClientId: {0}, Message: {1}", clientId, ex.Message); throw new Exception("Error requesting Spotify access token: " + ex.Message); } }
private static async Task Start() { var json = await File.ReadAllTextAsync(CredentialsPath); var token = JsonConvert.DeserializeObject <PKCETokenResponse>(json); var authenticator = new PKCEAuthenticator(clientId !, token); authenticator.TokenRefreshed += (sender, token) => File.WriteAllText(CredentialsPath, JsonConvert.SerializeObject(token)); var config = SpotifyClientConfig.CreateDefault() .WithAuthenticator(authenticator); var spotify = new SpotifyClient(config); var me = await spotify.UserProfile.Current(); var playlists = await spotify.PaginateAll(await spotify.Playlists.CurrentUsers().ConfigureAwait(false)); _server.Dispose(); // Environment.Exit(0); }
public static IHostBuilder CreateHostBuilder(string[] args) => Host.CreateDefaultBuilder(args) .ConfigureServices((hostContext, services) => { Services.ConfigurationProvider configProvider = new Services.ConfigurationProvider(hostContext.Configuration); services.AddTransient <ISpotifyClient>(s => { SpotifyClientConfig config = SpotifyClientConfig .CreateDefault() .WithAuthenticator(new ClientCredentialsAuthenticator( configProvider.SpotifyClientId, configProvider.SpotifyClientSectret)); return(new SpotifyClient(config)); }); services.AddTransient(s => { CosmosClientOptions options = new CosmosClientOptions() { SerializerOptions = new CosmosSerializationOptions() { PropertyNamingPolicy = CosmosPropertyNamingPolicy.CamelCase } }; return(new CosmosClient(configProvider.CosmosConnectionString, options)); }); services.AddTransient <ISpotifyDataLayer, SpotifyDataLayer>(); services.AddSingleton <IConfigurationProvider>(configProvider); services.AddTransient <IMusicInfoService, MusicInfoService>(); services.AddTransient <ICosmosDataLayer, CosmosDataLayer>(); services.AddTransient <ISubscriptionService, SubscriptionService>(); services.AddTransient <INewMusicBotService, NewMusicBotService>(); services.AddSingleton <IDiscordClientWrapper, DiscordClientWrapper>(); services.AddHostedService <Worker>(); services.AddHostedService <NewMusicChecker>(); });
/// <summary> /// Start the authroization code flow or request for an access token if a refresh token is present and the scopes match. /// </summary> /// <param name="cancel">A <see cref="CancellationToken"/> to cancel the wait for users to authorize on their browsers</param> /// <exception cref="OperationCanceledException">Thrown if the wait is canceled</exception> public override async Task Authorize(CancellationToken cancel = default) { AuthorizationCodeTokenResponse tokenResponse; if (RefreshToken.IsNullOrEmpty() || !requiredScopes.IsSubsetOf(AuthorizedScopes)) { var taskCompletionSource = new TaskCompletionSource <AuthorizationCodeResponse>(); EmbedIOAuthServer _server = new EmbedIOAuthServer(new Uri("http://localhost:5000/callback"), 5000); await _server.Start(); _server.AuthorizationCodeReceived += (_, response) => { taskCompletionSource.SetResult(response); return(Task.CompletedTask); }; var request = new SpotifyAPI.Web.LoginRequest(_server.BaseUri, ClientId, SpotifyAPI.Web.LoginRequest.ResponseType.Code) { Scope = requiredScopes }; Helper.OpenUri(request.ToUri()); while (!taskCompletionSource.Task.IsCompleted) { cancel.ThrowIfCancellationRequested(); await Task.Delay(500); } await _server.Stop(); var response = taskCompletionSource.Task.Result; tokenResponse = await new OAuthClient().RequestToken( new AuthorizationCodeTokenRequest( ClientId, ClientSecret, response.Code, new Uri("http://localhost:5000/callback") ) ); RefreshToken = tokenResponse.RefreshToken; } else { var response = await new OAuthClient().RequestToken(new AuthorizationCodeRefreshRequest(ClientId, ClientSecret, RefreshToken)); tokenResponse = new AuthorizationCodeTokenResponse() { RefreshToken = RefreshToken, AccessToken = response.AccessToken, CreatedAt = response.CreatedAt, ExpiresIn = response.ExpiresIn, Scope = response.Scope, TokenType = response.TokenType }; } AccessToken = tokenResponse.AccessToken; AuthorizedScopes = tokenResponse.Scope.Split(' ').ToList(); var config = SpotifyClientConfig .CreateDefault() .WithAuthenticator(new AuthorizationCodeAuthenticator(ClientId, ClientSecret, tokenResponse)); spotify = new SpotifyClient(tokenResponse.AccessToken); RaiseConfigUpdated(EventArgs.Empty); }
// Function for 'search' button after click // Uses Spotify Search API to find the root song protected async void Button1_Submit_Click(object sender, EventArgs e) { // Get input from user via TextBox string song = Convert.ToString(TextBox1.Text); // Get input from user via TextBox string artist = Convert.ToString(TextBox2.Text); string searchSong = ""; if (song.Length > 0 && artist.Length > 0) { searchSong = song + " " + artist; } // else if (song.Length == 0) //no song input { // display an error message } else if (artist.Length > 0) { searchSong = song; } Label1.Text = "Searching for " + song; string CLIENTID = Environment.GetEnvironmentVariable("SPOTIFY_CLIENT_ID"); string CLIENTSECRET = Environment.GetEnvironmentVariable("SPOTIFY_CLIENT_SECRET"); var config = SpotifyClientConfig.CreateDefault(); var request = new ClientCredentialsRequest(CLIENTID, CLIENTSECRET); var response = await new OAuthClient(config).RequestToken(request); spotify = new SpotifyClient(config.WithToken(response.AccessToken)); // [placeholder] catch Spotify connection errors //perform search. CAN REPLACE WITH USER INPUTTED REQUEST HERE var search = await spotify.Search.Item(new SearchRequest(SearchRequest.Types.Track, searchSong)); //Get tracks from search result var trackResults = spotify.PaginateAll(search.Tracks, (s) => s.Tracks); //add the first 5 results into a list. This shouldn't be needed with paginate all /* List<FullTrack> trackList = new List<FullTrack>(); * for (int i = 0; i <= 5; i++) * { * trackList.Add(enumerator.Current); * await enumerator.MoveNextAsync(); * }*/ string temp = ""; //print list of first 5 items that appear in search result for (int i = 0; i < 5; i++) { if (trackResults.Result[i] != null) { //at this point we want user to input a number //Console.Write("Option " + i + ": \"" + trackList[i].Name + "\" by \"" + trackList[i].Artists[0].Name + "\""); //Console.WriteLine(" From the album \"" + trackList[i].Album.Name + "\""); temp = i + ": \"" + trackResults.Result[i].Name + "\" by \"" + trackResults.Result[i].Artists[0].Name + "\"" + " From the album \"" + trackResults.Result[i].Album.Name + "\""; } } // Each generated option is displayed as an option // User must choose one option Option1.Text = trackResults.Result[0].Name + "\" by \"" + trackResults.Result[0].Artists[0].Name + "\"" + " From the album \"" + trackResults.Result[0].Album.Name; Option2.Text = trackResults.Result[1].Name + "\" by \"" + trackResults.Result[1].Artists[0].Name + "\"" + " From the album \"" + trackResults.Result[1].Album.Name; Option3.Text = trackResults.Result[2].Name + "\" by \"" + trackResults.Result[2].Artists[0].Name + "\"" + " From the album \"" + trackResults.Result[2].Album.Name; Option4.Text = trackResults.Result[3].Name + "\" by \"" + trackResults.Result[3].Artists[0].Name + "\"" + " From the album \"" + trackResults.Result[3].Album.Name; Option5.Text = trackResults.Result[4].Name + "\" by \"" + trackResults.Result[4].Artists[0].Name + "\"" + " From the album \"" + trackResults.Result[4].Album.Name; // Matches the choice from the list // choice = input from default.aspx int choice = 1; string trackID = trackResults.Result[choice].Id; string artistID = trackResults.Result[choice].Artists[0].Id; //get the genres of the artist by searching for the exact artist name based on choice from user List <string> artistGenres = new List <string>(); search = await spotify.Search.Item(new SearchRequest(SearchRequest.Types.Artist, trackResults.Result[choice].Artists[0].Name)); var artistResults = spotify.PaginateAll(search.Artists, (s) => s.Artists); //go through every artist until we find a matching artist ID. //This may be problematic if we run into a weird case where we get the ID but when searching by name the artist doesnt show up //I set i to 50 because I wasn't sure how to iterate through the whole ilist, 80% sure we will have a 99% chance we find the artist for (int i = 0; i < 50; i++) { if (artistResults.Result[i] == null) { //if we ran out of results to look for? break; } //to ensure we have the right artis if (artistResults.Result[i].Id == artistID) { artistGenres = artistResults.Result[i].Genres; break; } } // information for generating the reccomendations RecommendationsRequest recFinder = new RecommendationsRequest(); recFinder.SeedTracks.Add(trackID); recFinder.SeedGenres.Add(artistGenres[0]); recFinder.SeedArtists.Add(artistID); //WE CAN CHANGE AMOUNT OF SONGS WE WANT TO GENERATE HERE recFinder.Limit = 20; //performt he recommendation search var recList = spotify.Browse.GetRecommendations(recFinder); Console.WriteLine("\nReccomendations found: "); string recommendations = ""; for (int i = 0; i < recList.Result.Tracks.Count; i++) { string tmp = ("Song " + (i + 1) + ": \"" + recList.Result.Tracks[i].Name + "\" by " + recList.Result.Tracks[i].Artists[0].Name); recommendations.Concat(tmp); //maybe print the URL for a track here idk how to find it I'm happy with what is done so far. } RecLabel.Text = "Reccomendations found: " + recommendations; }
// This method gets called by the runtime. Use this method to add services to the container. // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940 public void ConfigureServices(IServiceCollection services) { _secrets = new string[] { Configuration["DatabaseSettings:ConnectionString"], Configuration["DatabaseSettings:DatabaseName"], Configuration["Microsoft:Id"], Configuration["Microsoft:Secret"], Configuration["SpotifySettings:ClientID"], Configuration["SpotifySettings:ClientSecret"], }; services.AddHttpContextAccessor(); services.AddSingleton(SpotifyClientConfig.CreateDefault()); services.AddScoped <SpotifyBuilder>(); services.AddServerSideBlazor(); services.AddMudServices(); services.AddAuthorization(options => { options.AddPolicy("Spotify", policy => { policy.AuthenticationSchemes.Add("Spotify"); policy.RequireAuthenticatedUser(); }); }); services.AddAuthentication(opt => { opt.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme; }) .AddCookie(opt => { opt.ExpireTimeSpan = TimeSpan.FromMinutes(50); //opt.Cookie.Name = "AuthCookie"; }) .AddSpotify(opt => { opt.ClientId = Configuration["SpotifySettings:ClientID"]; opt.ClientSecret = Configuration["SpotifySettings:ClientSecret"]; opt.CallbackPath = "/Auth/callback"; opt.SaveTokens = true; var scopes = new List <string> { UserReadEmail, UserReadPrivate, PlaylistReadPrivate, PlaylistReadCollaborative, UserLibraryRead, UserFollowRead, UserTopRead }; opt.Scope.Add(string.Join(",", scopes)); }) .AddMicrosoftAccount(opt => { opt.SignInScheme = "Cookies"; opt.ClientId = Configuration["Microsoft:Id"]; opt.ClientSecret = Configuration["Microsoft:Secret"]; }); services.AddRazorPages(options => { options.Conventions.AuthorizeFolder("/", "Spotify"); }); services.AddScoped <HttpClient>(); services.AddScoped <DialogService>(); services.AddControllers(); services.AddSingleton <TrackDataAccess>(); services.Configure <DatabaseSettings>(Configuration.GetSection(nameof(DatabaseSettings))); services.AddSingleton <IDatabaseSettings>(x => x.GetRequiredService <IOptions <DatabaseSettings> >().Value); services.Configure <SpotifySettings>(Configuration.GetSection(nameof(SpotifySettings))); services.AddSingleton <ISpotifySettings>(x => x.GetRequiredService <IOptions <SpotifySettings> >().Value); }
public async Task NowPlayingSpotify() { using var typing = Context.Channel.EnterTypingState(); var userId = Context.User.Id; string?token = null; using (var connection = new SqliteConnection("Data Source=data.db")) { await connection.OpenAsync(); using (var command = connection.CreateCommand()) { command.CommandText = "SELECT * FROM users WHERE id=$id"; command.Parameters.AddWithValue("$id", userId); using (var reader = command.ExecuteReader()) { while (reader.Read()) { var isNull = await reader.IsDBNullAsync(2); token = isNull == true ? null : reader.GetString(2); } } } } if (token != null) { try { string?trackUri = null; string?trackDetails = null; var spotifyConfig = SpotifyClientConfig .CreateDefault() .WithAuthenticator( new ClientCredentialsAuthenticator(config["SpotifyId"], config["SpotifySecret"])); var spotify = new SpotifyClient(token); var currentlyPlaying = await spotify.Player.GetCurrentlyPlaying(new PlayerCurrentlyPlayingRequest(PlayerCurrentlyPlayingRequest.AdditionalTypes.Track)); if (currentlyPlaying.Item is FullTrack fullTrack) { trackUri = fullTrack.ExternalUrls["spotify"]; trackDetails = string.Empty; foreach (var artist in fullTrack.Artists) { trackDetails += artist.Name + " "; } trackDetails += " - " + fullTrack.Name; } await ReplyAsync(trackUri ?? "No Spotify match found."); if (string.IsNullOrEmpty(trackDetails) == false) { var youTubeResult = await SearchYouTube(trackDetails); await ReplyAsync(youTubeResult ?? "No YouTube match found"); } } catch (APIUnauthorizedException) { await ReplyAsync("Your Spotify API token has expired."); return; } } else { await ReplyAsync("Spotify token invalid. Use !npsetspotify <token> in a private message to TuneBot to set your Spotify token."); await ReplyAsync("Do not send this token in a public chanel."); } }
private static async Task Start() { // find the lights //var findBulbs = Task.Run(() => YeelightHelper.FindDevices()); //findBulbs.Wait(); // connect to the lights //Task.Run(() => YeelightHelper.ConnectToBulbs()); //YeelightHelper.ConnectToBulbs(); await YeelightHelper.InitializeYeelights(); // do all that cool Spotify authentication shit var json = await File.ReadAllTextAsync(CredentialsPath); var token = JsonConvert.DeserializeObject <AuthorizationCodeTokenResponse>(json); var authenticator = new AuthorizationCodeAuthenticator(clientId !, clientSecret !, token); authenticator.TokenRefreshed += (sender, token) => File.WriteAllText(CredentialsPath, JsonConvert.SerializeObject(token)); var config = SpotifyClientConfig.CreateDefault() .WithAuthenticator(authenticator); // build spotify client var spotify = new SpotifyClient(config); // get user account data var me = await spotify.UserProfile.Current(); Console.WriteLine($"[Spotify] Authenticated as {me.DisplayName} ({me.Id})."); // flash the lights green & back to default to show we're alive // YeelightHelper.bulbs.SetRGBColor(0, 255, 0, 250); await Task.Delay(1000); //YeelightHelper.bulbs.SetColorTemperature(2700, 250); string oldTrackId = ""; // used to track if we're playing a different track than last loop int loopDelay = 2000; // don't set below 1000ms. while (true) { // for measuring api times var stopwatch = new Stopwatch(); stopwatch.Start(); // get info on playback status var currentTrack = await spotify.Player.GetCurrentPlayback(new PlayerCurrentPlaybackRequest()); // check if we're playing something, or if we pulled null data somehow (API failure?) if (currentTrack == null || currentTrack.Item == null || currentTrack.IsPlaying == false) { await Task.Delay(loopDelay); continue; } // grab the track details var currentTrackDetails = (FullTrack)currentTrack.Item; // check if it's different from what we saw last loop - if so, wait and try the loop again if (currentTrackDetails.Id == oldTrackId) { await Task.Delay(loopDelay); continue; } // download the album art to memory var albumArtUrl = currentTrackDetails.Album.Images[0].Url; WebRequest request = WebRequest.Create(albumArtUrl); WebResponse response = request.GetResponse(); Stream responseStream = response.GetResponseStream(); // convert album art to color - color should be average color of image after some adjustments Color albumColor = new Color(); using (MagickImage image = new MagickImage(responseStream, MagickFormat.Jpg)) { // debug - output image before doing anything at all var debugOutputPreProcessing = new FileInfo("debug-output-album-pre-processing.jpg"); image.Write(debugOutputPreProcessing); // set white & black to transparent, to make sure they don't mess with the vibrancy of the image image.ColorFuzz = (Percentage)15; // shades within 15% of pure white/black will count as pure image.Opaque(new MagickColor(MagickColors.White), new MagickColor(MagickColors.Transparent)); image.Opaque(new MagickColor(MagickColors.Black), new MagickColor(MagickColors.Transparent)); // flatten image down to a few colors image.Quantize(new QuantizeSettings { Colors = 5 }); // debug - output image after quantizing var debugOutputQuantized = new FileInfo("debug-output-album-quantized.jpg"); image.Write(debugOutputQuantized); // massively boost saturation so the lights actually have color to them image.Modulate((Percentage)100, (Percentage)1000, (Percentage)100); // resize to 1px, as the built-in converter will average out all the remaining colors into one image.Resize(1, 1); // get color rgb values and set to albumColor var colorKey = image.Histogram().FirstOrDefault().Key; albumColor = Color.FromArgb(255, colorKey.R, colorKey.G, colorKey.B); // debug - output after all post processing. should return a 100x100px image of one solid color. image.Resize(100, 100); var debugOutputDone = new FileInfo("debug-output-done.jpg"); image.Write(debugOutputDone); // get rid of any junk we don't need anymore image.Dispose(); responseStream.Dispose(); } // set the light color to the album art's average color YeelightHelper.bulbs.SetRGBColor(albumColor.R, albumColor.G, albumColor.B, 250); stopwatch.Stop(); oldTrackId = currentTrackDetails.Id; Console.WriteLine($"[Spotify] {currentTrackDetails.Artists[0].Name} - {currentTrackDetails.Name}" + $" | {albumColor.R} {albumColor.G} {albumColor.B}" + $" | performed in {stopwatch.ElapsedMilliseconds}ms"); await Task.Delay(loopDelay); } }