protected async override Task OnSaveAsync(MouseEventArgs e)
{
try
{
DetailsViewModel dvm = Model as DetailsViewModel;
AuthenticationObject authObj = dvm.DetailsObject as AuthenticationObject;
authObj.Validate(true);
authObj.GetValidationErrors().AbortIfHasErrors();
var user = await RestServices.Authenticate(dvm.ServiceProvider,
authObj.EmailProperty.Value, authObj.PasswordProperty.Value);
if (authStateProvider is AuthStateProvider asp)
{
asp.SetCurrentPrincipal(user);
}
if (QueryHelpers.ParseQuery(new Uri(Navigation.Uri).Query).TryGetValue("redirectUri", out var param))
{
Navigation.NavigateTo(param.First());
}
else
{
Navigation.NavigateTo("/");
}
}
catch (Exception ex)
{
Model.Errors = Model.ErrorParser.FromException(ex);
}
}
private static void AddTracksToPlaylist(AuthenticationObject authObj, SpotifyPlaylist playlist, List <SpotifyTrack> tracks)
{
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", authObj.access_token);
var trackUris = "";
foreach (var uri in tracks.Select(x => x.uri))
{
trackUris += $"\"{uri}\",";
}
trackUris = trackUris.TrimEnd(',');
var httpRequest = new HttpRequestMessage(HttpMethod.Post, $"https://api.spotify.com/v1/playlists/{playlist.id}/tracks")
{
Content = new StringContent($"{{\"uris\":[{trackUris}]}}",
Encoding.UTF8,
"application/json")
};
httpRequest.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var response = client.SendAsync(httpRequest).Result;
var responseContent = response.Content.ReadAsStringAsync().Result;
}
}
public async Task <AuthenticationObject> RequestAsync()
{
if (_authResult.IsValid)
{
return(_authResult);
}
var formContent = GenerateAuthenticationBody();
var authenticationHeader = GenerateAuthenticationHeader();
_httpClient.DefaultRequestHeaders.Authorization = authenticationHeader;
var response = await _httpClient.PostAsync("https://accounts.spotify.com/api/token", formContent);
if (response.StatusCode == HttpStatusCode.BadRequest)
{
/*
* Spotify returns a BadRequest containing an Authentication Error Object in the body when authentication/authorization fails
* Look for Authentication Error Object in https://developer.spotify.com/documentation/web-api/#response-status-codes
*
* Example body: "{"error":"invalid_client","error_description":"Invalid client secret"}"
*/
var responseString = await response.Content.ReadAsStringAsync();
var authenticationError = JsonSerializer.Deserialize <AuthenticationErrorObject>(responseString);
throw new SpotifyAuthorizationException(authenticationError);
}
var responseStream = response.Content.ReadAsStreamAsync();
var spotifyAuthenticationResult = await JsonSerializer.DeserializeAsync <AuthenticationObject>(await responseStream);
_authResult = spotifyAuthenticationResult;
return(spotifyAuthenticationResult);
}
protected override void Save(object sender, EventArgs e)
{
DetailsViewModel dvm = Model as DetailsViewModel;
AuthenticationObject authObj = dvm.DetailsObject as AuthenticationObject;
try
{
dvm.Save(sender, e);
if (dvm.Errors != null && dvm.Errors.HasErrors())
{
return;
}
PersonInfo userInfo = dvm.ServiceProvider.GetService <IPersonService>().Read(authObj.EmailProperty.Value).Result;
ClaimsIdentity ci = SecurityManager.CreateIdentity(AuthenticationTypes.Password, userInfo);
Thread.CurrentPrincipal = new ClaimsPrincipal(ci);
MainView.Start();
Close();
}
catch (Exception ex)
{
ErrorParser ep = dvm.ServiceProvider.GetService <ErrorParser>();
ErrorList errors = ep.FromException(ex);
ErrorPresenter.Show(errors);
}
}
internal static void ExchangeCodeForToken(string code, AppDbContext context)
{
var responseString = "";
var authenticationObject = new AuthenticationObject();
if (code.Length > 0)
{
using (HttpClient client = new HttpClient())
{
string bearer = Convert.ToBase64String(Encoding.ASCII.GetBytes(ClientId + ":" + ClientSecret));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", bearer);
FormUrlEncodedContent formContent = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("code", code),
new KeyValuePair <string, string>("redirect_uri", ReturnURL),
new KeyValuePair <string, string>("grant_type", "authorization_code")
});
var response = client.PostAsync("https://accounts.spotify.com/api/token", formContent).Result;
var responseContent = response.Content;
responseString = response.Content.ReadAsStringAsync().Result;
authenticationObject = JsonConvert.DeserializeObject <AuthenticationObject>(responseString);
context.Add(authenticationObject);
}
context.SaveChanges();
}
}
protected override void OnViewEvents(object sender, ViewEvent e)
{
base.OnViewEvents(sender, e);
if (e.IsSaved()) // authenticated successfully
{
DetailsViewModel dvm = sender as DetailsViewModel;
AuthenticationObject authObj = dvm == null ? null : dvm.DetailsObject as AuthenticationObject;
ClaimsIdentity ci = null;
if (authObj != null && authObj.EmailProperty.Value != null)
{
PersonInfo userInfo = ServiceProvider.GetService <IPersonService>().Read(authObj.EmailProperty.Value).Result;
ci = SecurityManager.CreateIdentity(CookieAuthenticationDefaults.AuthenticationType, userInfo);
}
if (ci != null)
{
HttpContext.Current.GetOwinContext().Authentication.SignIn(ci);
string url = HttpContext.Current.Request.QueryString[CookieAuthenticationDefaults.ReturnUrlParameter];
if (url != null)
{
Response.Redirect(url);
}
}
}
}
protected async Task <ClaimsPrincipal> Authenticate()
{
DetailsViewModel dvm = Model as DetailsViewModel;
AuthenticationObject authObj = dvm.DetailsObject as AuthenticationObject;
#if REST
authObj.Validate(true);
authObj.GetValidationErrors().AbortIfHasErrors();
return(await RestServices.Authenticate(App.Services,
authObj.EmailProperty.Value, authObj.PasswordProperty.Value));
#endif
#if WCF
authObj.Validate(true);
authObj.GetValidationErrors().AbortIfHasErrors();
var principal = WcfServices.Authenticate(authObj.EmailProperty.Value, authObj.PasswordProperty.Value);
return(await Task.FromResult(principal));
#endif
#if TWO_TIER
await dvm.SaveAsync();
dvm.Errors.AbortIfHasErrors();
PersonInfo userInfo = null;
using (var s = dvm.ServiceProvider.CreateScope())
{
IPersonService personService = s.ServiceProvider.GetRequiredService <IPersonService>();
userInfo = (await personService.ReadAsync(authObj.EmailProperty.Value)).Result;
}
ClaimsIdentity ci = SecurityManager.CreateIdentity("Password", userInfo);
return(new ClaimsPrincipal(ci));
#endif
}
private static IEnumerable <SpotifyPlaylistTrack> GetPlaylistTracks(AuthenticationObject authObj, SpotifyPlaylist playlist)
{
var playlistTracks = new List <SpotifyPlaylistTrack>();
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", authObj.access_token);
var response = client.GetAsync($"{playlist.tracks.href}").Result;
var responseContent = response.Content.ReadAsStringAsync().Result;
var jobj = JObject.Parse(responseContent);
playlistTracks = JsonConvert.DeserializeObject <List <SpotifyPlaylistTrack> >(jobj["items"].ToString());
}
return(playlistTracks);
}
private static IEnumerable <SpotifyTrack> GenerateTracksForPlaylist(AuthenticationObject authObj, PlaylistRequest request)
{
var tracksForPlaylist = new List <SpotifyTrack>();
var avoidableTracks = new List <SpotifyTrack>();
var coveredDuration = 0;
var overshootLimit = 30000;
var maxNumberOfTries = 50;
var numberOfTries = 0;
while (coveredDuration < request.Duration * 60000 - 10000 && numberOfTries < maxNumberOfTries)
{
foreach (var playlistToLook in request.PlaylistsToLook)
{
var tracks = GetPlaylistTracks(authObj, playlistToLook).Select(x => x.track).ToList();
var trackToAdd = tracks
.OrderByDescending(x => x.popularity)
.First();
if (trackToAdd == null)
{
numberOfTries++;
continue;
}
if (tracksForPlaylist.Select(x => x.id).ToList().Contains(trackToAdd.id) ||
avoidableTracks.Select(x => x.id).ToList().Contains(trackToAdd.id))
{
var random = new Random();
var index = random.Next(2, tracks.Count());
trackToAdd = tracks.ElementAt(index);
}
if (coveredDuration + trackToAdd.duration_ms > request.Duration * 60000 + overshootLimit)
{
avoidableTracks.Add(trackToAdd);
numberOfTries++;
continue;
}
tracksForPlaylist.Add(trackToAdd);
coveredDuration += trackToAdd.duration_ms;
}
}
return(tracksForPlaylist);
}
public static SpotifyUser QueryServiceForCurrentUser(AuthenticationObject authObj)
{
SpotifyUser user = new SpotifyUser();
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", authObj.access_token);
var response = client.GetAsync($"https://api.spotify.com/v1/me").Result;
var responseContent = response.Content;
var responseString = response.Content.ReadAsStringAsync().Result;
user = JsonConvert.DeserializeObject <SpotifyUser>(responseString);
}
return(user);
}
public IActionResult Authenticate([FromBody] UserDto userDto)
{
var user = _userService.Authenticate(userDto.Username, userDto.Password);
if (user == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
//.........................................................
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.Id.ToString())
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
user.Stats = _statsService.getByUserId(user.Id);
user.gameStats = _gameStatsService.getByUserId(user.Id);
user.visitedSights = _visitedSightsService.getByUserId(user.Id);
user.PasswordHash = null;
user.PasswordSalt = null;
string _json = JsonConvert.SerializeObject(user, Formatting.Indented, new JsonSerializerSettings
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
JObject jsonUser = JObject.Parse(_json);
var authObj = new AuthenticationObject();
authObj.user = jsonUser;
authObj.token = tokenString;
return(Ok(authObj));
}
private static SpotifyPlaylist CreatePlaylist(PlaylistRequest request, AuthenticationObject authObj, SpotifyUser user)
{
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", authObj.access_token);
var httpRequest = new HttpRequestMessage(HttpMethod.Post, $"https://api.spotify.com/v1/users/{user.id}/playlists")
{
Content = new StringContent($"{{\"name\":\"{request.Name}\"}}",
Encoding.UTF8,
"application/json")
};
httpRequest.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var response = client.SendAsync(httpRequest).Result;
var responseContent = response.Content.ReadAsStringAsync().Result;
return(JsonConvert.DeserializeObject <SpotifyPlaylist>(responseContent));
}
}
protected override void Save(object sender, EventArgs e)
{
DetailsViewModel dvm = Model as DetailsViewModel;
AuthenticationObject authObj = dvm.DetailsObject as AuthenticationObject;
try
{
authObj.Validate(true);
authObj.GetValidationErrors().AbortIfHasErrors();
WcfServices.Authenticate(authObj.EmailProperty.Value, authObj.PasswordProperty.Value);
authObj.TrackModifications = false; // to prevent confirmation on closing of the login view
MainView.Start();
Close();
}
catch (Exception ex)
{
ErrorParser ep = dvm.ServiceProvider.GetService <ErrorParser>();
ErrorList errors = ep.FromException(ex);
ErrorPresenter.Show(errors);
}
}
public async Task <AuthResponse> Authenticate(string email, string password)
{
AuthenticationObject authentication = new AuthenticationObject {
email = email, password = password
};
var json = JsonConvert.SerializeObject(authentication);
var content = new StringContent(json, Encoding.UTF8, "application/json");
var res = await _client.PostAsync(new Uri(authenticationRoute), content);
if (res.IsSuccessStatusCode)
{
var resContent = await res.Content.ReadAsStringAsync();
Debug.WriteLine(resContent);
return(JsonConvert.DeserializeObject <AuthResponse>(resContent));
}
else
{
return(new AuthResponse {
error = true, message = "API call failed."
});
}
}
private static Mock <HttpMessageHandler> StubHttpCallForAuthorizationToReturn(AuthenticationObject expected)
{
var httpMessageHandler = new Mock <HttpMessageHandler>();
httpMessageHandler
.Protected()
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>()
)
.ReturnsAsync(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(JsonSerializer.Serialize(expected))
});
return(httpMessageHandler);
}
