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