public async Task <bool> PutTracksAsync(SpotifyToken token, PutTracks tracks) { _apiClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token.AccessToken); var response = await _apiClient.PutAsync($"me/tracks?ids={tracks.Ids}", null); return(response.IsSuccessStatusCode); }
public async Task <bool> FollowPlaylistAsync(SpotifyToken token, string playlistId) { _apiClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token.AccessToken); var response = await _apiClient.PutAsync($"playlists/{playlistId}/followers", null); return(response.IsSuccessStatusCode); }
public async Task <PlaylistObject> PostPlaylistAsync(SpotifyToken token, string userId, PostPlaylist playlist) { _apiClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token.AccessToken); var response = await _apiClient.PostAsJsonAsync($"users/{userId}/playlists", playlist); return(await response.JsonContentObject <PlaylistObject>()); }
public async Task <bool> PostPlaylistTracksAsync(SpotifyToken token, string playlistId, PostPlaylistTracks tracks) { _apiClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token.AccessToken); var response = await _apiClient.PostAsJsonAsync($"playlists/{playlistId}/tracks", tracks); return(response.IsSuccessStatusCode); }
private async Task <SpotifyUserToken> GetDbToken(string synthbotUserId) { var spotifyUserId = await _db.UserLogins .Where(ul => ul.LoginProvider == "Spotify") .Select(ul => ul.ProviderKey) .FirstOrDefaultAsync(); if (string.IsNullOrEmpty(spotifyUserId)) { return(null); } var userTokensQueryable = _db.UserTokens.Where(ut => ut.UserId == synthbotUserId && ut.LoginProvider == "Spotify"); var spotifyToken = SpotifyToken.FromUserTokens(userTokensQueryable); spotifyToken.Validate(); var userToken = new SpotifyUserToken() { SynthbotUserId = synthbotUserId, SpotifyUserId = spotifyUserId, SpotifyAccessToken = spotifyToken.AccessToken, SpotifyAccessTokenExpiry = spotifyToken.ExpiresAt, SpotifyRefreshToken = spotifyToken.RefreshToken }; return(userToken); }
/// <summary> /// Takes code recieved from spotify and requests a Token /// </summary> /// <param name="code">code returned from spotify</param> /// <returns>SpotifyToken</returns> public SpotifyToken GetSpotifyToken(string code) { SpotifyToken = new SpotifyToken(); SpotifyToken newToken = new SpotifyToken(); string responseString = string.Empty; using (HttpClient client = new HttpClient()) { client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(System.Text.ASCIIEncoding.ASCII.GetBytes(_user.ClientId + ":" + _user.ClientSecret))); FormUrlEncodedContent formContent = new FormUrlEncodedContent( new[] { new KeyValuePair <string, string>("code", code), new KeyValuePair <string, string>("redirect_uri", _user.CallbackUri), new KeyValuePair <string, string>("grant_type", "authorization_code") }); var response = client.PostAsync("https://accounts.spotify.com/api/token", formContent).Result; if (response.IsSuccessStatusCode) { var responseContent = response.Content; responseString = responseContent.ReadAsStringAsync().Result; newToken = JsonConvert.DeserializeObject <SpotifyToken>(responseString); //SpotifyToken = newToken; } } SpotifyToken.AccessToken = newToken.AccessToken; SpotifyToken.Expiration = newToken.Expiration; SpotifyToken.RefreshToken = newToken.RefreshToken; SpotifyToken.Scope = newToken.Scope; SpotifyToken.TokenType = newToken.TokenType; return(SpotifyToken); }
public async Task <SpotifyPlaylist> GetPlayList() { SpotifyToken tokenfile = await GetAuthHeader(); string token = tokenfile.AccessToken; StringBuilder builder = new StringBuilder("Bearer " + token); token = builder.ToString(); //NEED TO ADD CHECK FOR EXPIRED TOKEN just example playlist used string playlistUrl = GetPlayListUrl("1YVfgqp3GsQrI47CXzWiRd"); HttpClient client = new HttpClient(); client.DefaultRequestHeaders.Add("Authorization", token); HttpResponseMessage resp = await client.GetAsync(playlistUrl); string msg = await resp.Content.ReadAsStringAsync(); //System.Diagnostics.Debug.WriteLine(msg); return(JsonConvert.DeserializeObject <SpotifyPlaylist>(msg)); }
private static async Task <string> GetAccessToken() { SpotifyToken token = new SpotifyToken(); string postString = string.Format("grant_type=client_credentials"); byte[] byteArray = Encoding.UTF8.GetBytes(postString); string url = "https://accounts.spotify.com/api/token"; WebRequest request = WebRequest.Create(url); request.Method = "POST"; request.Headers.Add("Authorization", "Basic N2FmYTU2MjcxZDdkNDI5NGJmNGYyNzUyN2MzYmEzMzY6YWExYTc0MjlkYjU1NDgzZGFkZjFjZDIyNzY4OTdhMzA="); request.ContentType = "application/x-www-form-urlencoded"; request.ContentLength = byteArray.Length; using (Stream dataStream = request.GetRequestStream()) { dataStream.Write(byteArray, 0, byteArray.Length); using (WebResponse response = await request.GetResponseAsync()) { using (Stream responseStream = response.GetResponseStream()) { using (StreamReader reader = new StreamReader(responseStream)) { string responseFromServer = reader.ReadToEnd(); token = JsonConvert.DeserializeObject <SpotifyToken>(responseFromServer); } } } } return(token.access_token); }
private async Task <SpotifyToken> GetAuthHeader() { var instance = new Helpers.AuthSpot(); SpotifyToken token = await instance.ActivateToken(); return(token); }
/// <summary> /// Refreshes user token. /// </summary> /// <param name="token"></param> /// <returns></returns> public IActionResult GetRefreshToken(SpotifyToken token) { var responseString = string.Empty; //code if (token == null) { return(Redirect(_user.Authorize())); } using (HttpClient refreshClient = new HttpClient()) { refreshClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(System.Text.ASCIIEncoding.ASCII.GetBytes(_user.ClientId + ":" + _user.ClientSecret))); FormUrlEncodedContent formContent = new FormUrlEncodedContent( new[] { new KeyValuePair <string, string>("grant_type", "refresh_token"), new KeyValuePair <string, string>("refresh_token", token.RefreshToken) } ); var response = refreshClient.PostAsync("https://accounts.spotify.com/api/token", formContent).Result; if (response.IsSuccessStatusCode) { var responseContent = response.Content; responseString = responseContent.ReadAsStringAsync().Result; var newToken = JsonConvert.DeserializeObject <SpotifyToken>(responseString); token.AccessToken = newToken.AccessToken; token.TokenType = newToken.TokenType; token.Expiration = newToken.Expiration; } return(View("Index", token)); } }
public async Task <IActionResult> Profile() { var spotifyToken = new SpotifyToken(); if (Request.Cookies.ContainsKey("Spotify")) { spotifyToken.AccessToken = Request.Cookies["Spotify"]; } using (HttpClient client = new HttpClient()) { client.DefaultRequestHeaders.Clear(); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", spotifyToken.AccessToken); var task = await client.GetAsync("https://api.spotify.com/v1/me"); if (task.IsSuccessStatusCode) { var jsonString = await task.Content.ReadAsStringAsync(); userProfile = JsonConvert.DeserializeObject <Profile>(jsonString); } else { ViewBag.NotSuccessful = task.StatusCode.ToString(); return(View(userProfile)); } } return(View(userProfile)); }
public async Task <GetPlaylists> GetPlaylistsAsync(SpotifyToken token, int offset = 0, int limit = 50) { _apiClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token.AccessToken); var response = await _apiClient.GetAsync($"me/playlists?offset={offset}&limit={limit}"); return(await response.JsonContentObject <GetPlaylists>()); }
public async Task <GetMe> GetMeAsync(SpotifyToken token) { _apiClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token.AccessToken); var response = await _apiClient.GetAsync("me"); return(await response.JsonContentObject <GetMe>()); }
public async Task OnGetAsync([FromQuery] SpotifyToken token, string message, string type = "success") { Token = token; ViewData["AlertMessage"] = message; ViewData["AlertType"] = type; IsLogged = !(token == null || string.IsNullOrEmpty(token?.AccessToken)); MeModel = await _spotifyService.GetMeAsync(Token); }
public bool RequestAccessAndRefreshTokens(HttpContext context) { string state = context.Request.Query["state"]; if (!context.Request.Cookies.ContainsKey(SpotifyHelpers.stateCookieKey)) { return(false); } if (state == null || !state.Equals(context.Request.Cookies[SpotifyHelpers.stateCookieKey])) { return(false); } string error = context.Request.Query["error"]; if (error != null) { return(false); } context.Response.Cookies.Delete(SpotifyHelpers.stateCookieKey); string code = context.Request.Query["code"]; if (code == null) { return(false); } var client = new HttpClient(); var requestContent = new FormUrlEncodedContent(new[] { new KeyValuePair <string, string> ("grant_type", "authorization_code"), new KeyValuePair <string, string> ("code", code), new KeyValuePair <string, string> ("redirect_uri", _spotifyCredentialsSettings.RedirectURI) }); string clientCredentialsString = _spotifyCredentialsSettings.ClientId + ":" + _spotifyCredentialsSettings.ClientSecret; byte[] clientCredentialsBytes = System.Text.Encoding.UTF8.GetBytes(clientCredentialsString); client.DefaultRequestHeaders.Add("Authorization", "Basic " + Convert.ToBase64String(clientCredentialsBytes)); var response = client.PostAsync(tokenEndpoint, requestContent).Result; if (!response.IsSuccessStatusCode) { return(false); } var responseContent = response.Content.ReadAsStringAsync().Result; Token = JsonConvert.DeserializeObject <SpotifyToken> (responseContent); Token.TokenObtained = DateTime.Now; return(true); }
/// <summary> /// Get a Track /// </summary> /// <param name="trackId">Track ID</param> /// <returns>The task result contains the Track</returns> public async Task <FullTrack> GetTrack(string trackId) { if (_spotifyToken == null) { _spotifyToken = await GetAccessToken(); } return(await Get <FullTrack>(_spotifyToken.AccessToken, new Uri($"https://api.spotify.com/v1/tracks/{trackId}"))); }
public static AuthenticationToken ToAuthenticationToken(this SpotifyToken token) { return(new AuthenticationToken() { AccessToken = token.AccessToken, TokenType = token.TokenType, ExpiresOn = token.ExpiresOn, RefreshToken = token.RefreshToken }); }
public static void ConverterParaSpotifyToken(this Task <JObject> obj) { if (obj.Result == null) { return; } var acessToken = obj.Result["access_token"].ToString(); var expiresIn = obj.Result["expires_in"].ToString(); SpotifyToken.Initialize(acessToken, expiresIn); }
// Gets the access token from web API. private async Task <string> GetAccessToken() { SpotifyToken token = new SpotifyToken(); using (var message = new HttpRequestMessage(HttpMethod.Post, tokenURL)) { message.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", "MDZkNDFlZDkxZDllNGJkY2JmNjE5YzM0MDliZDJiMDQ6MDA0ZTE1ZTNiZDkxNGVlN2JkNWE3MzJlOGU3N2MyYjc="); string postString = string.Format("grant_type=client_credentials"); using (HttpContent content = new StringContent(postString, UTF8Encoding.UTF8, "application/x-www-form-urlencoded")) { message.Content = content; var response = await client.SendAsync(message); if (response.IsSuccessStatusCode) { var responseContentString = await response.Content.ReadAsStringAsync(); token = JsonConvert.DeserializeObject <SpotifyToken>(responseContentString); } } } #region Web Request Method //string postString = string.Format("grant_type=client_credentials"); //byte[] byteArray = Encoding.UTF8.GetBytes(postString); //WebRequest request = WebRequest.Create(tokenURL); //request.Method = "POST"; //// Basic MDZkNDFlZDkxZDllNGJkY2JmNjE5YzM0MDliZDJiMDQ6MDA0ZTE1ZTNiZDkxNGVlN2JkNWE3MzJlOGU3N2MyYjc= => this is the code string getted from spotify developers page(Client ID:Secret) and encoded as UTF8 //request.Headers.Add("Authorization", "Basic MDZkNDFlZDkxZDllNGJkY2JmNjE5YzM0MDliZDJiMDQ6MDA0ZTE1ZTNiZDkxNGVlN2JkNWE3MzJlOGU3N2MyYjc="); //request.ContentType = "application/x-www-form-urlencoded"; //request.ContentLength = byteArray.Length; //using (Stream dataStream = request.GetRequestStream()) //{ // dataStream.Write(byteArray, 0, byteArray.Length); // using (WebResponse response = await request.GetResponseAsync()) // { // using (Stream responseStream = response.GetResponseStream()) // { // using (StreamReader reader = new StreamReader(responseStream)) // { // string responseFromServer = reader.ReadToEnd(); // token = JsonConvert.DeserializeObject<SpotifyToken>(responseFromServer); // } // } // } //} #endregion return(token.access_token); }
void SetToken(string response) { /* Creating object from JSON response */ SpotifyToken spotifyToken = SpotifyToken.CreateFromJSON(response); /* Saving access_token into device */ PlayerPrefs.SetString("access_token", spotifyToken.access_token); /* Saving the expiration date */ DateTime expDate = System.DateTime.Now.AddSeconds(spotifyToken.expires_in); string binaryDate = expDate.ToBinary().ToString(); PlayerPrefs.SetString("expiration_date", binaryDate); }
public IActionResult Index() { //Will be null upon initial entry. once Authenticate is clicked cookie will store the AccessToken. var spotifyToken = new SpotifyToken(); if (string.IsNullOrEmpty(spotifyToken.AccessToken)) { if (Request.Cookies.ContainsKey("Spotify")) { spotifyToken.AccessToken = Request.Cookies["Spotify"]; } } return(View(spotifyToken)); }
public IActionResult SearchResult(string title, string limit) { if (string.IsNullOrWhiteSpace(limit)) { limit = "1"; } var spotifyToken = new SpotifyToken(); if (Request.Cookies.ContainsKey("Spotify")) { spotifyToken.AccessToken = Request.Cookies["Spotify"]; } var track = GetSearchResults(title, limit, spotifyToken.AccessToken).Result; return(View(track)); }
public async Task SincronizarPorGenero(GeneroDisco genero, SpotifyToken token) { var spotifyApi = RestService.For <ISpotifyApi>(_config.ApiUrl, RecuperarConfiguracoesRefit(token.AccessToken)); var result = spotifyApi.SearchAlbums(genero.ToString(), _config.AlbumTypeParamValue, genero.ToString(), 50).Result; if (result != null) { var random = new Random(); var albums = result.Albums; foreach (var album in albums.Items) { await _bus.SendCommand(new InsertDiscoCommand(Guid.NewGuid(), album.Name, genero, random.Next(10, 100))); } } }
public SpotifyToken GetAccessToken() { SpotifyToken token = new SpotifyToken(); string url5 = "https://accounts.spotify.com/api/token"; var encode_clientid_clientsecret = Convert. ToBase64String(Encoding.UTF8.GetBytes(string.Format("{0}:{1}", "b49eac7e20ae4dac90a11f528089c830", //clientid "a0449ecc93524cc5a9028d4fe036ac18"))); //clientsecret HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(url5); webRequest.Method = "POST"; webRequest.ContentType = "application/x-www-form-urlencoded"; webRequest.Accept = "application/json"; webRequest.Headers.Add("Authorization: Basic " + encode_clientid_clientsecret); var request = ("grant_type=client_credentials"); byte[] req_bytes = Encoding.ASCII.GetBytes(request); webRequest.ContentLength = req_bytes.Length; Stream strm = webRequest.GetRequestStream(); strm.Write(req_bytes, 0, req_bytes.Length); strm.Close(); HttpWebResponse resp = (HttpWebResponse)webRequest.GetResponse(); String json = ""; using (Stream respStr = resp.GetResponseStream()) { using (StreamReader rdr = new StreamReader(respStr, Encoding.UTF8)) { //should get back a string i can then turn to json and parse for accesstoken json = rdr.ReadToEnd(); rdr.Close(); } } token = JsonConvert.DeserializeObject <SpotifyToken>(json); return(token); }
public static string GetAccessToken() { SpotifyToken token = new SpotifyToken(); string url5 = "https://accounts.spotify.com/api/token"; var encode_clientid_clientsecret = Convert.ToBase64String(Encoding.UTF8.GetBytes(string.Format("{0}:{1}", clientid, clientsecret))); HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(url5); webRequest.Method = "POST"; webRequest.ContentType = "application/x-www-form-urlencoded"; webRequest.Accept = "application/json"; webRequest.Headers.Add("Authorization: Basic " + encode_clientid_clientsecret); var request = ("grant_type=client_credentials"); byte[] req_bytes = Encoding.ASCII.GetBytes(request); webRequest.ContentLength = req_bytes.Length; Stream strm = webRequest.GetRequestStream(); strm.Write(req_bytes, 0, req_bytes.Length); strm.Close(); HttpWebResponse resp = (HttpWebResponse)webRequest.GetResponse(); String json = ""; using (Stream respStr = resp.GetResponseStream()) { using (StreamReader rdr = new StreamReader(respStr, Encoding.UTF8)) { json = rdr.ReadToEnd(); rdr.Close(); } } token = JsonConvert.DeserializeObject <SpotifyToken>(json); return(token.access_token); }
private async Task <List <string> > GetTracksListAsync(SpotifyToken token) { var hasMore = false; var offset = 0; var result = new List <string>(); do { var tracks = await _spotifyService.GetTracksAsync(token, offset); foreach (var track in tracks.Items) { result.Add(track.Track.Uri); } hasMore = !string.IsNullOrEmpty(tracks.Next); offset = tracks.Offset + tracks.Limit; } while (hasMore); return(result); }
// gets the access tokens and authorization needed to access user data public IActionResult Callback() { string code = Request.Query["code"]; //gets the authorization code from header if (code != null) { string tokenURL = "https://accounts.spotify.com/api/token"; //request to get the access token var encode_clientid_clientsecret = Convert.ToBase64String(Encoding.UTF8.GetBytes(string.Format("{0}:{1}", clientID, clientSecret))); HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(tokenURL); webRequest.Method = "POST"; webRequest.ContentType = "application/x-www-form-urlencoded"; webRequest.Accept = "application/json"; webRequest.Headers.Add("Authorization: Basic " + encode_clientid_clientsecret); var request = "grant_type=authorization_code&code=" + code + "&redirect_uri=" + loginRedirectUri; byte[] req_bytes = Encoding.ASCII.GetBytes(request); webRequest.ContentLength = req_bytes.Length; Stream strm = webRequest.GetRequestStream(); strm.Write(req_bytes, 0, req_bytes.Length); strm.Close(); string json = Helpers.ReadResponseToString(webRequest); token = JsonConvert.DeserializeObject <SpotifyToken>(json); //add tokens to cookies Response.Cookies.Append("access_token", token.access_token); Response.Cookies.Append("scope", token.scope); Response.Cookies.Append("refresh_token", token.refresh_token); return(View("Callback")); } else { return(View("Home")); } }
private async Task <string> GetToken() { SpotifyToken token = new SpotifyToken(); var encoded = Base64Helper.Encode(string.Format("{0}:{1}", _spotifySettings.ClientId, _spotifySettings.ClientSecret)); string postString = string.Format("grant_type=client_credentials"); byte[] byteArray = Encoding.UTF8.GetBytes(postString); WebRequest request = WebRequest.Create(_spotifySettings.TokenUrl); request.Method = "POST"; request.Headers.Add("Authorization", "Basic " + encoded); request.ContentType = "application/x-www-form-urlencoded"; request.ContentLength = byteArray.Length; try { using (Stream dataStream = request.GetRequestStream()) { dataStream.Write(byteArray, 0, byteArray.Length); using (WebResponse response = await request.GetResponseAsync()) { using (Stream responseStream = response.GetResponseStream()) { using (StreamReader reader = new StreamReader(responseStream)) { string responseFromServer = reader.ReadToEnd(); token = JsonConvert.DeserializeObject <SpotifyToken>(responseFromServer); } } } } } catch (Exception) { } return(token.access_token); }
public void Authorize() { var url = "https://accounts.spotify.com/api/token"; var clientId = "0868aaffb9814da7b2c5b46c70e6f8a4"; var clientSecret = "241762ee32b6451c9d35264c6683e1c7"; //request to get the access token var data = Convert.ToBase64String(Encoding.UTF8.GetBytes(string.Format("{0}:{1}", clientId, clientSecret))); HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(url); webRequest.Method = "POST"; webRequest.ContentType = "application/x-www-form-urlencoded"; webRequest.Accept = "application/json"; webRequest.Headers.Add("Authorization: Basic " + data); byte[] reqBytes = Encoding.ASCII.GetBytes("grant_type=client_credentials"); webRequest.ContentLength = reqBytes.Length; Stream strm = webRequest.GetRequestStream(); strm.Write(reqBytes, 0, reqBytes.Length); strm.Close(); HttpWebResponse resp = (HttpWebResponse)webRequest.GetResponse(); String json = ""; using (Stream respStr = resp.GetResponseStream()) { using (StreamReader rdr = new StreamReader(respStr, Encoding.UTF8)) { //should get back a string i can then turn to json and parse for accesstoken json = rdr.ReadToEnd(); rdr.Close(); SpotifyToken token = JsonConvert.DeserializeObject <SpotifyToken>(json); this.AccessToken = token.access_token; } } }
public string GetAccessToken() { SpotifyToken token = new SpotifyToken(); HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(CreateSpotifyUri()); webRequest.Method = "POST"; webRequest.ContentType = "application/x-www-form-urlencoded"; webRequest.Accept = "application/json"; webRequest.Headers.Add("Authorization: Basic " + WebConfigurationManager.AppSettings["APIKEY"]); var request = ("grant_type=client_credentials"); byte[] req_bytes = Encoding.ASCII.GetBytes(request); webRequest.ContentLength = req_bytes.Length; Stream strm = webRequest.GetRequestStream(); strm.Write(req_bytes, 0, req_bytes.Length); strm.Close(); HttpWebResponse resp = (HttpWebResponse)webRequest.GetResponse(); String json = ""; using (Stream respStr = resp.GetResponseStream()) { using (StreamReader rdr = new StreamReader(respStr, Encoding.UTF8)) { //should get back a string i can then turn to json and parse for accesstoken json = rdr.ReadToEnd(); rdr.Close(); } } token = JsonConvert.DeserializeObject <SpotifyToken>(json); return(token.Access_Token); }