public AuthenticateResponse ExternalLogin(ExternalLoginRequest model, string ipAddress) { var account = _context.Accounts.SingleOrDefault(x => x.ExternalUserId == model.ExternalUserId); if (account == null) { ExternalRegister(model); account = _context.Accounts.SingleOrDefault(x => x.ExternalUserId == model.ExternalUserId); } // authentication successful so generate jwt and refresh tokens var jwtToken = generateJwtToken(account); var refreshToken = generateRefreshToken(ipAddress); account.RefreshTokens.Add(refreshToken); // remove old refresh tokens from account removeOldRefreshTokens(account); // save changes to db _context.Update(account); _context.SaveChanges(); var response = _mapper.Map <AuthenticateResponse>(account); response.JwtToken = jwtToken; response.RefreshToken = refreshToken.Token; return(response); }
private void OAuth2AuthenticatorCompleted(object sender, AuthenticatorCompletedEventArgs e) { try { if (e.IsAuthenticated) { ExternalLoginRequest externalLoginRequest = new ExternalLoginRequest { Provider = this.OAuth2AuthenticatorType.ToString(), }; var tokenResult = JsonConvert.DeserializeObject <OAuth2TokenResult>(JsonConvert.SerializeObject(e.Account.Properties)); externalLoginRequest.AccessToken = tokenResult.AccessToken; this.AuthenticationStore.RequestTokenWithExternalProviderAsync(externalLoginRequest); } } catch (Exception) { } finally { this.OAuth2Authenticator.Completed -= this.OAuth2AuthenticatorCompleted; this.OAuth2Authenticator.Error -= this.OAuth2AuthenticatorError; } }
public async Task <IActionResult> ExternalLoginCallback([FromBody] ExternalLoginRequest request, CancellationToken cancellationToken = default) { var response = await Mediator.Send(request, cancellationToken); Response.Cookies.Append(JwtBearerDefaults.AuthenticationScheme, response.Token); return(Ok(response.CurrentUserInformation)); }
/// <inheritdoc/> public async Task RequestTokenWithExternalProviderAsync(ExternalLoginRequest externalLoginRequest) { if (!this.IsAuthenticated) { this.authenticationResult = await this.authenticationServiceAgent.RequestTokenWithExternalProviderAsync(externalLoginRequest); await this.LoadUserTokensAsync(); } }
public async Task <IActionResult> GetInfoExternalAsync(ExternalLoginRequest request) { var result = await _userService.ExternalLoginCallback(request); if (string.IsNullOrEmpty(result.ResultObject)) { return(BadRequest(result)); } return(Ok(result)); }
public async Task <ApiResult <string> > ExternalLoginCallback(ExternalLoginRequest request) { var json = JsonConvert.SerializeObject(request); var httpContent = new StringContent(json, Encoding.UTF8, "application/json"); var response = await _client.PostAsync($"/api/users/ExternalSignIn/", httpContent); var data = await response.Content.ReadAsStringAsync(); if (response.IsSuccessStatusCode) { return(JsonConvert.DeserializeObject <ApiResultSuccess <string> >(data)); } return(JsonConvert.DeserializeObject <ApiResultErrors <string> >(data)); }
public async Task <ActionResult> ExternalLoginAsync([FromForm] ExternalLoginRequest model) { // describe real logic here //var user = await _userManager.FindByEmailAsync(model.Email); var user = new { Id = Guid.NewGuid(), LastName = "Less", FirstName = "Steve", EmailConfirmed = true, }; if (user == null) { return(BadRequest("User not found.!")); } if (!user.EmailConfirmed) { return(BadRequest("User should confirm his email.")); } // describe real logic here //var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, false, lockoutOnFailure: true); var result = new { Succeeded = true, }; if (result.Succeeded) { List <KeyValuePair <object, object> > keyValueList = new List <KeyValuePair <object, object> > { new KeyValuePair <object, object>(ClaimTypes.Email, model.Email), new KeyValuePair <object, object>(ClaimTypes.NameIdentifier, user.Id), }; var accessToken = _tokenProvider.CreateAccessToken(keyValueList, _jwtTokenOptions.Value.LifetimeExternal); var redirectUrl = model.RedirectUri + "#state=" + HttpUtility.UrlEncode(model.State) + "&access_token=" + HttpUtility.UrlEncode(accessToken.AccessToken) + "&token_type=Bearer"; return(new RedirectResult(redirectUrl)); } return(BadRequest()); }
public async Task <Result <AuthenticationProperties> > ExternalLogin(ExternalLoginRequest externalLoginRequest, string returnUrl) { ValidationResult validationResult = _externalLoginRequestValidator.Validate(externalLoginRequest); if (!validationResult.IsValid) { _logger.LogWarning($"Invalid {nameof(ExternalLoginRequest)} model"); return(Result.Fail <AuthenticationProperties>(validationResult.Errors)); } await _signInManager.SignOutAsync(); string redirectUrl = _urlGenerator.GenerateActionUrl("ExternalLoginCallback", "Account", new { returnUrl }); AuthenticationProperties properties = _signInManager.ConfigureExternalAuthenticationProperties(externalLoginRequest.Provider, redirectUrl); return(Result.Ok(properties)); }
public async Task<IActionResult> ExternalLogin(ExternalLoginRequest externalLoginRequest, string returnUrl) { returnUrl = returnUrl ?? Url.Content("~/"); if (!ModelState.IsValid) { LoginViewModel loginViewModel = await _accountDataService.GetLoginViewModel(returnUrl); return View(nameof(Login), loginViewModel); } Result<AuthenticationProperties> result = await _externalLoginService.ExternalLogin(externalLoginRequest, returnUrl); if(result.Failure) { LoginViewModel loginViewModel = await _accountDataService.GetLoginViewModel(returnUrl); return View(nameof(Login), loginViewModel); } return Challenge(result.Value, externalLoginRequest.Provider); }
public void ExternalRegister(ExternalLoginRequest model) { // map model to new account object var account = _mapper.Map <Account>(model); //account.Role = Role.User; var isFirstAccount = _context.Accounts.Count() == 0; account.Role = isFirstAccount ? Role.Admin : Role.User; account.Created = DateTime.UtcNow; account.LoginMethod = LoginMethod.External; account.Verified = DateTime.UtcNow; account.VerificationToken = null; account.AcceptTerms = true; // save account _context.Accounts.Add(account); _context.SaveChanges(); }
public async Task <Result <AuthenticationProperties> > ExternalLogin(ExternalLoginRequest externalLoginRequest, string returnUrl) { ValidationResult validationResult = _externalLoginRequestValidator.Validate(externalLoginRequest); if (!validationResult.IsValid) { _logger.LogWarning($"Invalid {nameof(ExternalLoginRequest)} model"); return(Result.Fail <AuthenticationProperties>(validationResult.Errors)); } await _signInManager.SignOutAsync(); string callbackUrl = QueryHelpers.AddQueryString($"{_identityUIOptions.BasePath}/Account/ExternalLoginCallback", "returnUrl", returnUrl); string redirectUrl = HtmlEncoder.Default.Encode(callbackUrl); AuthenticationProperties properties = _signInManager.ConfigureExternalAuthenticationProperties(externalLoginRequest.Provider, redirectUrl); return(Result.Ok(properties)); }
/// <inheritdoc/> public async Task <BearerAuthenticationResult> RequestTokenWithExternalProviderAsync(ExternalLoginRequest externalLoginRequest) { return(await this.PostAsync <ExternalLoginRequest, BearerAuthenticationResult>("/api/auth/external", externalLoginRequest)); }
public async Task <IActionResult> ExternalLoginCallback(string returnUrl, string remoteError = null) { ExternalLoginInfo info = await _signInManager.GetExternalLoginInfoAsync(); returnUrl = returnUrl ?? Url.Content("~/"); if (remoteError != null) { ModelState.AddModelError(string.Empty, $"Error from external provider:{remoteError}"); return(View("Index")); } var externalLoginRequest = new ExternalLoginRequest { FullName = info.Principal.FindFirstValue(ClaimTypes.Name), Email = info.Principal.FindFirstValue(ClaimTypes.Email), ProviderKey = info.ProviderKey, LoginProvider = info.LoginProvider, ProviderDisPlayName = info.ProviderDisplayName, ImagePath = info.Principal.Claims.FirstOrDefault(c => c.Type == "picture").Value, }; var result = await _userAPIClient.ExternalLoginCallback(externalLoginRequest); if (result.IsSuccessed == false) { TempData["message"] = result.Message; ModelState.AddModelError("", result.Message); ViewBag.ErrorServerSide = true; return(View()); } TempData["Succes"] = "Login Succsess!"; //HttpContext.Session.SetString("Token", result.ResultObject); CookieHelpers.SetObjectAsJson(Response.Cookies, "Token", result.ResultObject, 10); var userPrincipal = this.ValidateToken(result.ResultObject); var UserId = new Guid(userPrincipal.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier).Value); var cartResult = await _cartService.GetById(UserId); if (cartResult.IsSuccessed == true) { var CartSessionKey = _configuration.GetSection("CartSessionKey").Value; CookieHelpers.RemoveCookie(Response.Cookies, CartSessionKey); CookieHelpers.SetObjectAsJson(HttpContext.Response.Cookies, CartSessionKey, cartResult.ResultObject.CartItems, null); } var authProperties = new AuthenticationProperties { ExpiresUtc = DateTimeOffset.UtcNow.AddMinutes(10), IsPersistent = false // có sử dụng persistent cookie }; await HttpContext.SignInAsync( CookieAuthenticationDefaults.AuthenticationScheme, userPrincipal, authProperties); if (!string.IsNullOrEmpty(returnUrl)) { return(Redirect(returnUrl)); } else { return(RedirectToAction("index", "home")); } }
public async Task <IActionResult> ExternalLoginCallback(string returnUrl = null, string remoteError = null) { var result = await HttpContext.AuthenticateAsync(CookieAuthenticationDefaults.AuthenticationScheme); if (result.Succeeded != true) { return(Unauthorized(new { message = "External authentication error" })); } var externalUser = result.Principal; if (externalUser == null) { return(Unauthorized("External authentication error")); } var claims = externalUser.Claims.ToList(); // try to determine the unique id of the external user - the most common claim type for that are the sub claim and the NameIdentifier // depending on the external provider, some other claim type might be used //var userIdClaim = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.Subject); var userIdClaim = claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier); if (userIdClaim == null) { return(Unauthorized(new { message = "Unknown userId" })); } var externalUserId = userIdClaim.Value; var externalProvider = userIdClaim.Issuer; var userEmailClaim = claims.FirstOrDefault(x => x.Type == ClaimTypes.Email); var externalUserEmail = userEmailClaim?.Value; var userNameClaim = claims.FirstOrDefault(x => x.Type == ClaimTypes.Name); if (userNameClaim == null) { userNameClaim = claims.FirstOrDefault(x => x.Type == ClaimTypes.GivenName); } var externalUserName = userNameClaim.Value; Claim userPhotoUriClaim; string externalUserPhoto; if (externalProvider == "Vkontakte") { userPhotoUriClaim = claims.FirstOrDefault(x => x.Type == "urn:vkontakte:photo:link"); externalUserPhoto = userPhotoUriClaim.Value; } else { externalUserPhoto = null; } ExternalLoginRequest request = new ExternalLoginRequest { ExternalUserId = externalUserId, Email = externalUserEmail, Name = externalUserName, Provider = externalProvider, ExternalPhotoLink = externalUserPhoto }; var response = _accountService.ExternalLogin(request, ipAddress()); setTokenCookie(response.RefreshToken, "refreshToken", DateTime.UtcNow.AddDays(7)); setTokenCookie(response.JwtToken, "jwt", DateTime.UtcNow.AddDays(1)); return(Redirect("https://usa-invest.ru")); }
public async Task <ApiResult <string> > ExternalLoginCallback(ExternalLoginRequest request) { var signInResult = await _signInManager.ExternalLoginSignInAsync(request.LoginProvider, request.ProviderKey, isPersistent : false, bypassTwoFactor : true); if (signInResult.Succeeded) { var user = await _userManager.FindByEmailAsync(request.Email); var role = await _roleManager.FindByIdAsync(user.RoleID.ToString()); var cart = await _context.Carts.FirstOrDefaultAsync(x => x.UserId == user.Id); var userToken = new UserToken { CartId = cart.Id.ToString(), UserId = user.Id.ToString(), UserName = user.UserName, Role = string.Join(";", role.Name), ImagePath = user.ImagePath, Email = user.Email, }; var token = CreateToken(userToken); return(new ApiResultSuccess <string>(token)); } else { var email = request.Email; if (email != null) { var user = await _userManager.FindByEmailAsync(email); var roleDefault = await _roleManager.FindByNameAsync("client"); if (user == null) { user = new UserApp { FullName = request.FullName, ImagePath = request.ImagePath, Email = request.Email, RoleID = roleDefault.Id, UserName = request.Email, }; var result = await _userManager.CreateAsync(user); if (result.Succeeded) { var cartadd = new Cart { Created_At = DateTime.Now, UserId = user.Id, Price = 0, CartProducts = new List <CartProduct>(), }; _context.Carts.Add(cartadd); await _context.SaveChangesAsync(); } } var cart = await _context.Carts.FirstOrDefaultAsync(x => x.UserId == user.Id); var info = new UserLoginInfo(request.LoginProvider, request.ProviderKey, request.ProviderDisPlayName); await _userManager.AddLoginAsync(user, info); await _signInManager.SignInAsync(user, isPersistent : false); var role = _roleManager.FindByIdAsync(user.RoleID.ToString()); var userToken = new UserToken { CartId = cart.Id.ToString(), UserId = user.Id.ToString(), UserName = user.UserName, Role = string.Join(";", role.Result.Name), ImagePath = user.ImagePath, Email = user.Email, }; var token = CreateToken(userToken); return(new ApiResultSuccess <string>(token)); } return(new ApiResultErrors <string>($"Email claim not received from:{request.LoginProvider}")); } }