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