public async Task LinkUnlinkDeletesTest() { var db = UnitTestHelper.CreateDefaultDb(); var mgr = new UserManager<IdentityUser>(new UserStore<IdentityUser>(db)); var user = new IdentityUser("linkunlinktest"); UnitTestHelper.IsSuccess(await mgr.CreateAsync(user)); var userLogin1 = new UserLoginInfo("provider1", "p1-1"); var userLogin2 = new UserLoginInfo("provider2", "p2-1"); Assert.Equal(0, (await mgr.GetLoginsAsync(user.Id)).Count); UnitTestHelper.IsSuccess(await mgr.AddLoginAsync(user.Id, userLogin1)); Assert.Equal(1, user.Logins.Count(l => l.ProviderKey == "p1-1")); Assert.Equal(1, (await mgr.GetLoginsAsync(user.Id)).Count); UnitTestHelper.IsSuccess(await mgr.AddLoginAsync(user.Id, userLogin2)); Assert.Equal(1, user.Logins.Count(l => l.ProviderKey == "p2-1")); Assert.Equal(2, (await mgr.GetLoginsAsync(user.Id)).Count); UnitTestHelper.IsSuccess(await mgr.RemoveLoginAsync(user.Id, userLogin1)); Assert.Equal(0, user.Logins.Count(l => l.ProviderKey == "p1-1")); Assert.Equal(1, user.Logins.Count(l => l.ProviderKey == "p2-1")); Assert.Equal(1, (await mgr.GetLoginsAsync(user.Id)).Count()); UnitTestHelper.IsSuccess(await mgr.RemoveLoginAsync(user.Id, userLogin2)); Assert.Equal(0, (await mgr.GetLoginsAsync(user.Id)).Count); Assert.Equal(0, db.Set<IdentityUserLogin>().Count()); }
public static async Task<IndexViewModel> ToViewModel(this ApplicationUser user, UserManager<ApplicationUser> userManager, SignInManager<ApplicationUser> signInManager) { var result = new IndexViewModel { HasPassword = await userManager.HasPasswordAsync(user), EmailAddress = user.Email, IsEmailAddressConfirmed = user.EmailConfirmed, IsPhoneNumberConfirmed = user.PhoneNumberConfirmed, PhoneNumber = await userManager.GetPhoneNumberAsync(user), TwoFactor = await userManager.GetTwoFactorEnabledAsync(user), Logins = await userManager.GetLoginsAsync(user), BrowserRemembered = await signInManager.IsTwoFactorClientRememberedAsync(user), AssociatedSkills = user.AssociatedSkills, TimeZoneId = user.TimeZoneId, Name = user.Name, ProposedNewEmailAddress = user.PendingNewEmail }; return result; }
public static async Task<IndexViewModel> ToViewModel(this ApplicationUser user, UserManager<ApplicationUser> userManager, SignInManager<ApplicationUser> signInManager) { var profileCompletenessWarnings = user.ValidateProfileCompleteness(); var result = new IndexViewModel { HasPassword = await userManager.HasPasswordAsync(user), EmailAddress = user.Email, IsEmailAddressConfirmed = user.EmailConfirmed, IsPhoneNumberConfirmed = user.PhoneNumberConfirmed, PhoneNumber = await userManager.GetPhoneNumberAsync(user), TwoFactor = await userManager.GetTwoFactorEnabledAsync(user), Logins = await userManager.GetLoginsAsync(user), BrowserRemembered = await signInManager.IsTwoFactorClientRememberedAsync(user), AssociatedSkills = user.AssociatedSkills, TimeZoneId = user.TimeZoneId, FirstName = user.FirstName, LastName = user.LastName, ProposedNewEmailAddress = user.PendingNewEmail, IsProfileComplete = user.IsProfileComplete(), ProfileCompletenessWarnings = profileCompletenessWarnings.Select(p => p.ErrorMessage) }; return result; }
private async Task <ExternalLoginsState> GetExternalLoginsState() { var user = await GetCurrentUserAsync(); var userLogins = await _userManager.GetLoginsAsync(user); var schemes = await _signInManager.GetExternalAuthenticationSchemesAsync(); foreach (var userLogin in userLogins.Where(userLogin => string.IsNullOrEmpty(userLogin.ProviderDisplayName))) { userLogin.ProviderDisplayName = schemes .SingleOrDefault(x => x.Name.Equals(userLogin.LoginProvider))? .DisplayName; if (string.IsNullOrEmpty(userLogin.ProviderDisplayName)) { userLogin.ProviderDisplayName = userLogin.LoginProvider; } } var otherLogins = schemes.Where(auth => userLogins.All(ul => auth.Name != ul.LoginProvider)).ToList(); return(new ExternalLoginsState { CurrentLogins = userLogins.Select(x => new ExternalLoginsState.ExternalLogin { ProviderKey = x.ProviderKey, LoginProvider = x.LoginProvider, LoginProviderDisplayName = x.ProviderDisplayName }).ToList(), OtherLogins = otherLogins.Select(x => new ExternalLoginState.ExternalLoginProvider { DisplayName = x.DisplayName, Scheme = x.Name }).ToList() }); }
private async Task <ProfileVM> GetProfileVM(UserWithClaims?user, ChangeProfileModel?model = null, string?errorMessage = null, string?successMessage = null) { if (user == null) { throw new DomainException("Cannot find user."); } var taskForProviders = signInManager.GetExternalProvidersAsync(); var taskForPassword = userManager.HasPasswordAsync(user.Identity); var taskForLogins = userManager.GetLoginsAsync(user.Identity); await Task.WhenAll(taskForProviders, taskForPassword, taskForLogins); var result = new ProfileVM { Id = user.Id, ClientSecret = user.ClientSecret() !, Email = user.Email, ErrorMessage = errorMessage, ExternalLogins = taskForLogins.Result, ExternalProviders = taskForProviders.Result, DisplayName = user.DisplayName() !, IsHidden = user.IsHidden(), HasPassword = taskForPassword.Result, HasPasswordAuth = identityOptions.AllowPasswordAuth, SuccessMessage = successMessage }; if (model != null) { SimpleMapper.Map(model, result); } return(result); } }
public async Task <ActionResult> DeleteUser(string userid) { if (AdmUsrRole == "Admin") { return(RedirectToAction("Index", "Admin", new { Message = ManageMessageId.HighRankedUser })); } userid = context.Users.Where(x => x.UserName == AdmUsrName).Select(x => x.Id).FirstOrDefault(); var user = await UserManager.FindByIdAsync(userid); var userClaims = await UserManager.GetClaimsAsync(user.Id); var userRoles = await UserManager.GetRolesAsync(user.Id); var userLogins = await UserManager.GetLoginsAsync(user.Id); foreach (var claim in userClaims) { await UserManager.RemoveClaimAsync(user.Id, claim); } string[] roles = new string[userRoles.Count]; userRoles.CopyTo(roles, 0); await UserManager.RemoveFromRolesAsync(user.Id, roles); foreach (var log in userLogins) { await UserManager.RemoveLoginAsync(user.Id, new UserLoginInfo(log.LoginProvider, log.ProviderKey)); } await UserManager.DeleteAsync(user); return(RedirectToAction("Index", "Admin", new { Message = ManageMessageId.UserDeleted })); }
public async Task <ActionResult> IncompleteSellerIndex() { var user = await UserManager.FindByIdAsync(User.Identity.GetUserId()); var model = new UserIndexViewModel { HasPassword = HasPassword(), PhoneNumber = await UserManager.GetPhoneNumberAsync(user.Id), TwoFactor = await UserManager.GetTwoFactorEnabledAsync(user.Id), Logins = await UserManager.GetLoginsAsync(user.Id), BrowserRemembered = await AuthenticationManager.TwoFactorBrowserRememberedAsync(user.Id), Mobile = await UserManager.GetPhoneNumberAsync(user.Id), AddressLine1 = user.AddressLine1, AddressLine2 = user.AddressLine2, AddressLine3 = user.AddressLine3, FirstName = user.FirstName, LastName = user.LastName, Country = user.Country, Email = user.Email, ImagePath = user.ImagePath }; return(View(model)); }
// // GET: /Manage/Index public async Task <ActionResult> Index(ManageMessageId?message) { ViewBag.StatusMessage = message == ManageMessageId.ChangePasswordSuccess ? "Ваш пароль изменен." : message == ManageMessageId.SetPasswordSuccess ? "Пароль задан." : message == ManageMessageId.SetTwoFactorSuccess ? "Настроен поставщик двухфакторной проверки подлинности." : message == ManageMessageId.Error ? "Произошла ошибка." : message == ManageMessageId.AddPhoneSuccess ? "Ваш номер телефона добавлен." : message == ManageMessageId.RemovePhoneSuccess ? "Ваш номер телефона удален." : ""; var userId = User.Identity.GetUserId(); var user = await UserManager.FindByIdAsync(userId); var roleId = user.Roles.FirstOrDefault().RoleId; var image = string.Empty; if (user.Image != null) { image = "data:image/png;base64," + Convert.ToBase64String(user.Image, 0, user.Image.Length); } var model = new IndexViewModel { HasPassword = HasPassword(), Logins = await UserManager.GetLoginsAsync(userId), FName = user.FName, Name = user.Name, SurName = user.SurName, RolesName = RoleManager.Roles.FirstOrDefault(r => r.Id == roleId).Name, Image = image, Email = user.Email }; return(View(model)); }
public async Task <IActionResult> ExternalLogins() { var user = await _userManager.GetUserAsync(User); if (user == null) { return(NotFound(_localizer["UserNotFound", _userManager.GetUserId(User)])); } var model = new ExternalLoginsViewModel { CurrentLogins = await _userManager.GetLoginsAsync(user) }; model.OtherLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()) .Where(auth => model.CurrentLogins.All(ul => auth.Name != ul.LoginProvider)) .ToList(); model.ShowRemoveButton = await _userManager.HasPasswordAsync(user) || model.CurrentLogins.Count > 1; model.StatusMessage = StatusMessage; return(View(model)); }
public async Task <IActionResult> Index(ManageMessageId?message = null) { ViewBag.StatusMessage = message == ManageMessageId.ChangePasswordSuccess ? "Your password has been changed." : message == ManageMessageId.SetPasswordSuccess ? "Your password has been set." : message == ManageMessageId.SetTwoFactorSuccess ? "Your two-factor authentication provider has been set." : message == ManageMessageId.Error ? "An error has occurred." : message == ManageMessageId.AddPhoneSuccess ? "Your phone number was added." : message == ManageMessageId.RemovePhoneSuccess ? "Your phone number was removed." : ""; var user = await GetCurrentUserAsync(); var model = new IndexViewModel { HasPassword = await UserManager.HasPasswordAsync(user), PhoneNumber = await UserManager.GetPhoneNumberAsync(user), TwoFactor = await UserManager.GetTwoFactorEnabledAsync(user), Logins = await UserManager.GetLoginsAsync(user), BrowserRemembered = await SignInManager.IsTwoFactorClientRememberedAsync(user) }; return(View(model)); }
public static async Task <IndexViewModel> ToViewModel(this ApplicationUser user, UserManager <ApplicationUser> userManager, SignInManager <ApplicationUser> signInManager) { var profileCompletenessWarnings = user.ValidateProfileCompleteness(); var result = new IndexViewModel { HasPassword = await userManager.HasPasswordAsync(user), EmailAddress = user.Email, IsEmailAddressConfirmed = user.EmailConfirmed, IsPhoneNumberConfirmed = user.PhoneNumberConfirmed, PhoneNumber = await userManager.GetPhoneNumberAsync(user), TwoFactor = await userManager.GetTwoFactorEnabledAsync(user), Logins = await userManager.GetLoginsAsync(user), BrowserRemembered = await signInManager.IsTwoFactorClientRememberedAsync(user), AssociatedSkills = user.AssociatedSkills, TimeZoneId = user.TimeZoneId, FirstName = user.FirstName, LastName = user.LastName, ProposedNewEmailAddress = user.PendingNewEmail, IsProfileComplete = user.IsProfileComplete(), ProfileCompletenessWarnings = profileCompletenessWarnings.Select(p => p.ErrorMessage) }; return(result); }
// // GET: /Manage/ManageLogins public async Task <ActionResult> ManageLogins(ManageMessageId?message) { ViewBag.StatusMessage = message == ManageMessageId.RemoveLoginSuccess ? "The external login was removed." : message == ManageMessageId.Error ? "An error has occurred." : ""; var user = await UserManager.FindByIdAsync(CurrentUserId); if (user == null) { return(View("Error")); } var userLogins = await UserManager.GetLoginsAsync(CurrentUserId); var otherLogins = AuthenticationManager.GetExternalAuthenticationTypes() .Where(auth => userLogins.All(ul => auth.AuthenticationType != ul.LoginProvider)) .ToList(); ViewBag.ShowRemoveButton = user.HasPassword || userLogins.Count > 1; return(View(new ManageLoginsViewModel { CurrentLogins = userLogins.Select(ul => new UserLoginInfoViewModel() { LoginProvider = ul.LoginProvider, ProviderKey = ul.ProviderKey }).ToList(), OtherLogins = otherLogins.Select(ol => new AuthenticationDescriptionViewModel() { AuthenticationType = ol.AuthenticationType, Caption = ol.Caption }).ToList(), })); }
public async Task <IActionResult> ExternalLogins() { ViewData["AlleCategorien"] = _categorieRepository.GetAll().ToList(); var user = await _userManager.GetUserAsync(User); if (user == null) { throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'."); } var model = new ExternalLoginsViewModel { CurrentLogins = await _userManager.GetLoginsAsync(user) }; model.OtherLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()) .Where(auth => model.CurrentLogins.All(ul => auth.Name != ul.LoginProvider)) .ToList(); model.ShowRemoveButton = await _userManager.HasPasswordAsync(user) || model.CurrentLogins.Count > 1; model.StatusMessage = StatusMessage; return(View(model)); }
public async Task <LoginResultDTO> Login(LoginDTO loginDTO) { var user = _userManager.Users.SingleOrDefault(u => u.Email == loginDTO.Email); if (!await _userManager.IsEmailConfirmedAsync(user) && !_userManager.GetLoginsAsync(user).Result.Any()) { throw new ApplicationException(DictionaryResources.EmailNotConfirmed); } var result = await _signInManager.PasswordSignInAsync(loginDTO.Email, loginDTO.Password, false, false); if (!result.Succeeded) { throw new ApplicationException(DictionaryResources.InvalidLoginAttempt); } var loginResult = new LoginResultDTO { Token = GenerateJwtToken(user), Id = user.Id }; return(loginResult); }
// GET: /Manage/Index public async Task <ActionResult> Index(ManageMessageId?message) { ViewBag.StatusMessage = message == ManageMessageId.ChangePasswordSuccess ? "Your password has been changed." : message == ManageMessageId.SetPasswordSuccess ? "Your password has been set." : message == ManageMessageId.SetTwoFactorSuccess ? "Your two-factor authentication provider has been set." : message == ManageMessageId.Error ? "An error has occurred." : message == ManageMessageId.AddPhoneSuccess ? "Your phone number was added." : message == ManageMessageId.RemovePhoneSuccess ? "Your phone number was removed." : ""; var userId = User.Identity.GetUserId <Int64>(); var model = new IndexViewModel { HasPassword = HasPassword(), PhoneNumber = await UserManager.GetPhoneNumberAsync(userId), TwoFactor = await UserManager.GetTwoFactorEnabledAsync(userId), Logins = await UserManager.GetLoginsAsync(userId), // TODO: BrowserRemembered = false // await AuthenticationManager.TwoFactorBrowserRememberedAsync(userId) }; return(View(model)); }
public async Task <IActionResult> ManageLogins(ManageMessageId?message = null) { ViewBag.StatusMessage = message == ManageMessageId.RemoveLoginSuccess ? "The external login was removed." : message == ManageMessageId.AddLoginSuccess ? "The external login was added." : message == ManageMessageId.Error ? "An error has occurred." : ""; var user = await GetCurrentUserAsync(); if (user == null) { return(View("Error")); } var userLogins = await UserManager.GetLoginsAsync(user); var otherLogins = SignInManager.GetExternalAuthenticationSchemes().Where(auth => userLogins.All(ul => auth.AuthenticationScheme != ul.LoginProvider)).ToList(); ViewBag.ShowRemoveButton = user.PasswordHash != null || userLogins.Count > 1; return(View(new ManageLoginsViewModel { CurrentLogins = userLogins, OtherLogins = otherLogins })); }
private async Task <SignInResult> LinkUser(MemberIdentityUser autoLinkUser, ExternalLoginInfo loginInfo) { var existingLogins = await UserManager.GetLoginsAsync(autoLinkUser); var exists = existingLogins.FirstOrDefault(x => x.LoginProvider == loginInfo.LoginProvider && x.ProviderKey == loginInfo.ProviderKey); // if it already exists (perhaps it was added in the AutoLink callbak) then we just continue if (exists != null) { //sign in return(await SignInOrTwoFactorAsync(autoLinkUser, isPersistent : false, loginInfo.LoginProvider)); } var linkResult = await UserManager.AddLoginAsync(autoLinkUser, loginInfo); if (linkResult.Succeeded) { //we're good! sign in return(await SignInOrTwoFactorAsync(autoLinkUser, isPersistent : false, loginInfo.LoginProvider)); } //If this fails, we should really delete the user since it will be in an inconsistent state! var deleteResult = await UserManager.DeleteAsync(autoLinkUser); if (deleteResult.Succeeded) { var errors = linkResult.Errors.Select(x => x.Description).ToList(); return(AutoLinkSignInResult.FailedLinkingUser(errors)); } else { //DOH! ... this isn't good, combine all errors to be shown var errors = linkResult.Errors.Concat(deleteResult.Errors).Select(x => x.Description).ToList(); return(AutoLinkSignInResult.FailedLinkingUser(errors)); } }
public async Task <IList <UserLoginInfo> > GetLoginsAsync(dynamic user) { return(await UserManager.GetLoginsAsync(user)); }
private async Task RefreshTokens(ClaimsPrincipal claimUser, ApplicationUser user, UserManager <ApplicationUser> userManager, SignInManager <ApplicationUser> signInManager, IConfiguration configuration) { var userLogins = await userManager.GetLoginsAsync(user); var login = userLogins.First(); var refreshToken = await userManager.GetAuthenticationTokenAsync(user, BluebeamAuthenticationDefaults.AuthenticationScheme, "refresh_token"); AuthModel authData = null; using (var client = new HttpClient()) { var uri = new Uri("https://authserver.bluebeam.com/auth/token"); var content = new FormUrlEncodedContent(new[] { new KeyValuePair <string, string>("grant_type", "refresh_token"), new KeyValuePair <string, string>("refresh_token", refreshToken), new KeyValuePair <string, string>("client_id", configuration["ClientID"]), new KeyValuePair <string, string>("client_secret", configuration["ClientSecret"]) }); var response = await client.PostAsync(uri, content); string tokenResponse = await response.Content.ReadAsStringAsync(); System.Console.WriteLine(tokenResponse); authData = JsonConvert.DeserializeObject <AuthModel>(tokenResponse); System.Console.WriteLine(authData.ToString()); /*var nameIdentifier = * _user.FindFirstValue("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier");*/ System.Console.WriteLine("Access Token: " + authData.AccessToken); System.Console.WriteLine("Refresh Token: " + authData.RefreshToken); System.Console.WriteLine("Provider: " + login.LoginProvider); System.Console.WriteLine("ProviderKey: " + login.ProviderKey); //System.Console.WriteLine("Name Identifier: " + nameIdentifier); var externalLoginInfo = new ExternalLoginInfo(claimUser, login.LoginProvider, login.ProviderKey, claimUser.Identity.Name) { AuthenticationTokens = new List <AuthenticationToken>() { new AuthenticationToken() { Name = "access_token", Value = authData.AccessToken }, new AuthenticationToken() { Name = "refresh_token", Value = authData.RefreshToken }, new AuthenticationToken() { Name = "token_type", Value = authData.TokenType }, new AuthenticationToken() { Name = "expires_at", Value = authData.Expires } } }; var result = await signInManager.UpdateExternalAuthenticationTokensAsync(externalLoginInfo); if (!result.Succeeded) { System.Console.WriteLine(result.Errors.ToString()); } } }
public async Task <IActionResult> DeleteConfirmed(string id) { if (ModelState.IsValid) { if (id == null) { return(NotFound()); } var user = await _userManager.FindByIdAsync(id); var logins = await _userManager.GetLoginsAsync(user); var rolesForUser = await _userManager.GetRolesAsync(user); var userPosts = _context.Post.Where(p => p.Owner == user).ToList(); userPosts.ForEach(p => _context.Post.Remove(p)); var userComments = _context.Comments.Where(c => c.Owner == user).ToList(); userComments.ForEach(c => _context.Comments.Remove(c)); using (var transaction = _context.Database.BeginTransaction()) { IdentityResult result = IdentityResult.Success; foreach (var login in logins) { result = await _userManager.RemoveLoginAsync(user, login.LoginProvider, login.ProviderKey); if (result != IdentityResult.Success) { break; } } if (result == IdentityResult.Success) { foreach (var item in rolesForUser) { result = await _userManager.RemoveFromRoleAsync(user, item); if (result != IdentityResult.Success) { break; } } } if (result == IdentityResult.Success) { result = await _userManager.DeleteAsync(user); if (result == IdentityResult.Success) { transaction.Commit(); } } } return(RedirectToAction("Index")); } else { return(View()); } }
/// <summary> /// Method to perform login of the external customer /// </summary> /// <param name="returnUrl"></param> /// <param name="remoteError"></param> /// <returns></returns> public async Task <DefaultServiceResponse> ExternalLoginCallBack(string returnUrl = null, string remoteError = null) { var loginCallBackResult = new DefaultServiceResponse { ActionName = "Index", ControllerName = "HomePage", ResponseData = null, StatusCode = StatusCodesEnum.Ok, ValidationErrors = new List <string>() }; if (remoteError == null) { var accountDetailsFromProvider = await SignInManager.GetExternalLoginInfoAsync(); #region Check, that data is provided if (accountDetailsFromProvider != null) { // Search for the customer in our db var accountData = await UserManager.FindByEmailAsync(accountDetailsFromProvider.Principal.FindFirstValue(ClaimTypes.Email)); #region New account for our DB if (accountData == null) // new account { var serviceUser = new ServiceUser { Email = accountDetailsFromProvider.Principal.FindFirstValue(ClaimTypes.Email), UserName = accountDetailsFromProvider.Principal.FindFirstValue(ClaimTypes.GivenName) }; var userResponse = await UserManager.CreateAsync(serviceUser); #region Customer created without any error --> send him email to verify email and add password ( or not ) if (userResponse.Succeeded) { if (CheckIfWeHaveRole("User")) { await UserManager.AddToRoleAsync(serviceUser, "User"); } else { await RoleManager.CreateAsync(new IdentityRole { Id = new Guid().ToString(), Name = "User", NormalizedName = "USER" }); await UserManager.AddToRoleAsync(serviceUser, "User"); } var claims = CustomerContext.UserClaims.Select(x => x).ToList(); var newClaimId = claims.Count > 0 ? claims.Last().Id + 1 : 1; CustomerContext.UserClaims.Add(new IdentityUserClaim <string> { Id = newClaimId, ClaimType = "UploadPhoto", ClaimValue = "true", UserId = serviceUser.Id }); await CustomerContext.SaveChangesAsync(); await UserManager.AddLoginAsync(serviceUser, accountDetailsFromProvider); // Creates point in AspNetUserLogins var token = await UserManager.GenerateEmailConfirmationTokenAsync(serviceUser); var emailUrlConfirmation = UrlHelper.Action("ConfirmEmail", "Account", new { Token = token, UserId = serviceUser.Id }, Context.HttpContext.Request.Scheme); await SendEmailService.SendEmail(new ServiceEmail { FromEmail = "*****@*****.**", FromName = "Yevhen", ToEmail = serviceUser.Email, ToName = serviceUser.UserName, EmailSubject = "Thank you for register!!!", EmailHtmlText = $"<strong>Hello, {serviceUser.UserName}! Thank you for registering, please confirm your email using this link : {emailUrlConfirmation}</strong>", EmailText = $"Hello there! Thank you for registering, please confirm your email using this link : {emailUrlConfirmation}", }); loginCallBackResult.ActionName = "ConfirmPartnerRegister"; loginCallBackResult.ControllerName = "Registration"; loginCallBackResult.ResponseData = serviceUser.UserName; loginCallBackResult.StatusCode = StatusCodesEnum.RedirectNeeded; return(loginCallBackResult); } #endregion else { loginCallBackResult.ValidationErrors.Add(DefaultResponseMessages.ExternalLoginFailed); loginCallBackResult.StatusCode = StatusCodesEnum.BadDataProvided; return(loginCallBackResult); } } #endregion else { #region Customer already has account on our db, but email is not confirmed if (!accountData.EmailConfirmed) { var loginsData = await UserManager.GetLoginsAsync(accountData); if (loginsData == null) { await UserManager.AddLoginAsync(accountData, accountDetailsFromProvider); } var token = await UserManager.GenerateEmailConfirmationTokenAsync(accountData); var emailUrlConfirmation = UrlHelper.Action("ConfirmEmail", "Account", new { Token = token, UserId = accountData.Id }, Context.HttpContext.Request.Scheme); await SendEmailService.SendEmail(new ServiceEmail { FromEmail = "*****@*****.**", FromName = "Yevhen", ToEmail = accountData.Email, ToName = accountData.UserName, EmailSubject = "Thank you for register!!!", EmailHtmlText = $"<strong>Hello, {accountData.UserName}! Thank you for registering, please confirm your email using this link : {emailUrlConfirmation}</strong>", EmailText = $"Hello there! Thank you for registering, please confirm your email using this link : {emailUrlConfirmation}", }); loginCallBackResult.StatusCode = StatusCodesEnum.RedirectNeeded; loginCallBackResult.ResponseData = accountData.UserName; loginCallBackResult.ActionName = "ConfirmPartnerRegister"; loginCallBackResult.ControllerName = "Registration"; return(loginCallBackResult); } #endregion #region Email is confirmed but we need to check, that customer has row in ASPNETUSERLOGINS else { var loginReponse = await SignInManager.ExternalLoginSignInAsync(accountDetailsFromProvider.LoginProvider, accountDetailsFromProvider.ProviderKey, false); if (loginReponse.Succeeded) { loginCallBackResult.StatusCode = StatusCodesEnum.Ok; } else { await UserManager.AddLoginAsync(accountData, accountDetailsFromProvider); await SignInManager.SignInAsync(accountData, false); } loginCallBackResult.ActionName = "Index"; loginCallBackResult.ControllerName = "HomePage"; return(loginCallBackResult); } #endregion } } #endregion #region No data provided from external provider else { loginCallBackResult.ValidationErrors.Add(DefaultResponseMessages.ExternalLoginFailed); loginCallBackResult.StatusCode = StatusCodesEnum.BadDataProvided; return(loginCallBackResult); } #endregion } #region Error from external provider else { loginCallBackResult.ValidationErrors.Add(DefaultResponseMessages.ExternalLoginFailed); loginCallBackResult.StatusCode = StatusCodesEnum.RedirectNeeded; loginCallBackResult.ActionName = "Login"; loginCallBackResult.ControllerName = "Account"; return(loginCallBackResult); } #endregion }
public Task <IList <UserLoginInfo> > GetLoginsAsync(T user) { return(u.GetLoginsAsync(user)); }
public Task <IList <UserLoginInfo> > GetLoginsAsync(IUser user) { Guard.NotNull(user, nameof(user)); return(userManager.GetLoginsAsync((IdentityUser)user.Identity)); }
public async Task <IActionResult> Delete([FromRoute] string id) { if (ModelState.IsValid) { if (id == null) { return(BadRequest(new { invalid = "User is not found" })); } var user = await _userManager.FindByIdAsync(id); var rolesForUser = await _userManager.GetRolesAsync(user); var logins = await _userManager.GetLoginsAsync(user); string path = user.AvatarUrl; using (var transaction = _context.Database.BeginTransaction()) { IdentityResult result = IdentityResult.Success; foreach (var login in logins) { result = await _userManager.RemoveLoginAsync(user, login.LoginProvider, login.ProviderKey); if (result != IdentityResult.Success) { break; } } if (result == IdentityResult.Success) { foreach (var item in rolesForUser) { result = await _userManager.RemoveFromRoleAsync(user, item); if (result != IdentityResult.Success) { break; } } } if (result == IdentityResult.Success) { result = await _userManager.DeleteAsync(user); //only commit if user and all his logins/roles have been deleted if (result == IdentityResult.Success) { transaction.Commit(); _fileService.DeleteImage(path); } } } return(Ok(user.Id)); } return(Ok()); }
public async Task <IActionResult> Update(ProfileModel profile) { try { if (ModelState.IsValid) { AppUser user = await userManager.FindByNameAsync(User.Identity.Name); bool isSameEmail = user.Email.Equals(profile.Email, StringComparison.OrdinalIgnoreCase); user.FirstName = profile.FirstName; user.LastName = profile.LastName; user.Address = profile.Address; user.Email = profile.Email; user.BirthDate = profile.BirthDate; user.Gender = profile.Gender; user.PhoneNumber = profile.Tel; string avatar; if (profile.Photo != null && !string.IsNullOrWhiteSpace(profile.Photo.FileName)) // if photo is change then copy { string filePath = user.UserName + "." + profile.Photo.FileName.Substring(profile.Photo.FileName.LastIndexOf(".") + 1); avatar = await blobService.UploadFile("avatars", filePath, profile.Photo); } else // if not, preserve old one { avatar = user.Avatar; } if (avatar != null) { user.Avatar = avatar; IdentityResult result = null; if (!isSameEmail) // remove external login when email changed { IEnumerable <UserLoginInfo> loginInfos = await userManager.GetLoginsAsync(user); foreach (UserLoginInfo info in loginInfos) { result = await userManager.RemoveLoginAsync(user, info.LoginProvider, info.ProviderKey); } } if (result == null || result.Succeeded) { result = await userManager.UpdateAsync(user); if (result.Succeeded) { return(RedirectToAction(nameof(Index))); } } AddErrorFromResult(result); } else { ModelState.AddModelError("", "Can't upload avatar"); } } return(RedirectToAction(nameof(Edit))); } catch (Exception ex) { logger.Error(ex.Message); throw; } }
public async Task <string> ExternalSignIn(HttpContext httpContext) { try { // read external identity from the temporary cookie var result = await httpContext.AuthenticateAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme); if (result?.Succeeded != true) { return($"~/externalauth/error/{ErrorEnum.ExternalAuthError}"); } // retrieve claims of the external user var externalUser = result.Principal; if (externalUser == null) { return($"~/externalauth/error/{ErrorEnum.ExternalAuthError}"); } // retrieve claims of the external user 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); if (userIdClaim == null) { userIdClaim = claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier); } if (userIdClaim == null) { return($"~/externalauth/error/{ErrorEnum.ExternalUnknownUserId}"); } var externalUserId = userIdClaim.Value; var externalProvider = userIdClaim.Issuer; //Quick check to sign in var externalSignInResult = await _signInManager.ExternalLoginSignInAsync(externalProvider, externalUserId, true); if (externalSignInResult.Succeeded) { //// delete temporary cookie used during external authentication await httpContext.SignOutAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme); return("~/externalauth/success"); } //If external login/signin failed var userNameClaim = claims.FirstOrDefault(x => x.Type == ClaimTypes.Name); var userEmailClaim = claims.FirstOrDefault(x => x.Type == ClaimTypes.Email); //get the user by Email (we are forcing it to be unique) var user = await _userManager.FindByEmailAsync(userEmailClaim.Value); if (user != null) { //check if the login for this provider exists var userLogins = await _userManager.GetLoginsAsync(user); if (userLogins.Any(ul => ul.LoginProvider == externalProvider && ul.ProviderKey == externalUserId)) { //something went wrong, it should get logged in // If lock out activated and the max. amounts of attempts is reached. if (externalSignInResult.IsLockedOut) { _logger.LogInformation("User Locked out: {0}", user.UserName); return($"~/externalauth/error/{ErrorEnum.UserLockedOut}"); } // If your email is not confirmed but you require it in the settings for login. if (externalSignInResult.IsNotAllowed) { _logger.LogInformation("User not allowed to log in: {0}", user.UserName); return($"~/externalauth/error/{ErrorEnum.UserIsNotAllowed}"); } return($"~/externalauth/error/{ErrorEnum.Unknown}"); } } else // create new user first { var requireConfirmEmail = Convert.ToBoolean(_configuration["SpotToSpotMuzik:RequireConfirmedEmail"] ?? "false"); try { user = await _accountManager.RegisterNewUserAsync(userNameClaim.Value, userEmailClaim.Value, null, requireConfirmEmail); } catch (DomainException ex) { _logger.LogError("External login Failed: {0}, {1}", ex.Description, ex.Message); return($"~/externalauth/error/{ErrorEnum.UserCreationFailed}/{ex.Description}"); } catch (Exception ex) { _logger.LogInformation("External login Failed: " + ex.Message); return($"~/externalauth/error/{ErrorEnum.UserCreationFailed}"); } if (requireConfirmEmail) { //ToDo: suggestion - after confirm, the sign in might fail, user needs to relogin using the external provider //Consider removing this constrain and auto-confirm the email - it has been confirmed by the 3rd party auth provider already return($"~/externalauth/confirm"); } } //All if fine, this user (email) did not try to log in before using this external provider //Add external login info var addExternalLoginResult = await _userManager.AddLoginAsync(user, new UserLoginInfo(externalProvider, externalUserId, userNameClaim.Value)); if (addExternalLoginResult.Succeeded == false) { return($"~/externalauth/error/{ErrorEnum.CannotAddExternalLogin}"); } //Try to sign in again externalSignInResult = await _signInManager.ExternalLoginSignInAsync(externalProvider, externalUserId, true); if (externalSignInResult.Succeeded) { //// delete temporary cookie used during external authentication await httpContext.SignOutAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme); return("~/externalauth/success"); } else { //Something went terrible wrong, user exists, external login info added // If lock out activated and the max. amounts of attempts is reached. if (externalSignInResult.IsLockedOut) { _logger.LogInformation("User Locked out: {0}", user.UserName); return($"~/externalauth/error/{ErrorEnum.UserLockedOut}"); } // If your email is not confirmed but you require it in the settings for login. if (externalSignInResult.IsNotAllowed) { _logger.LogInformation("User not allowed to log in: {0}", user.UserName); return($"~/externalauth/error/{ErrorEnum.UserIsNotAllowed}"); } return($"~/externalauth/error/{ErrorEnum.Unknown}"); } } catch (Exception ex) { _logger.LogInformation("External login Failed: " + ex.Message); return($"~/externalauth/error/{ErrorEnum.Unknown}"); } }
public virtual async Task <IList <ApplicationUserLoginInfo> > GetLoginsAsync(int userId) { var list = await _userManager.GetLoginsAsync(userId).ConfigureAwait(false); return(list.ToApplicationUserLoginInfoList()); }
public async Task <LoginResult> PerfromExternalLogin() { var info = await signin_manager.GetExternalLoginInfoAsync(); if (info == null) { throw new UnauthorizedAccessException(); } var user = await user_manager.FindByLoginAsync(info.LoginProvider, info.ProviderKey); if (user == null) { string username = info.Principal.FindFirstValue(ClaimTypes.Name); string email = info.Principal.FindFirstValue(ClaimTypes.Email); var new_user = new Entities.User { UserName = username, Email = email, PictureUrl = null }; var id_result = await user_manager.CreateAsync(new_user); if (id_result.Succeeded) { user = new_user; } else { // User creation failed, probably because the email address is already present in the database if (id_result.Errors.Any(e => e.Code == "DuplicateEmail")) { var existing = await user_manager.FindByEmailAsync(email); var existing_logins = await user_manager.GetLoginsAsync(existing); if (existing_logins.Any()) { throw new OtherAccountException(existing_logins); } else { throw new Exception("Could not create account from social profile"); } } else { throw new Exception("Could not create account from social profile"); } } await user_manager.AddLoginAsync(user, new UserLoginInfo(info.LoginProvider, info.ProviderKey, info.ProviderDisplayName)); } await signin_manager.SignInAsync(user, true); return(new LoginResult { Status = true, Platform = info.LoginProvider, User = ToDto(user) }); }
public async Task <IActionResult> EditUser(UserViewModel model) { if (!ModelState.IsValid) { return(View(model)); } //Get some info on the user var au = await _userManager.Users.Where(u => u.Id == model.Id).FirstOrDefaultAsync(); // The user should not be null! if (au != null) { var author = await _qpa.ProcessAsync(new GetAuthorByAppUserIdQuery { Id = au.Id }); if (author != null) { au.Author = author; } // Make the user an author if it's not already, no author fields can be "updated right now" if (model.IsAuthor) { if (string.IsNullOrEmpty(model.FirstName) || string.IsNullOrEmpty(model.LastName)) { ModelState.AddModelError("", "Author requires both first and last name to be set."); return(View(model)); } if (au.Author == null) { var aac = new AddAuthorCommand { ApplicatoinUserId = model.Id, FirstName = model.FirstName, LastName = model.LastName }; var aacResult = await _cp.ProcessAsync(aac); if (aacResult.Succeeded) { _logger.LogInformation("Set user {0} to be author {1} {2}", au.Email, model.FirstName, model.LastName); await _userManager.AddToRoleAsync(au, "Authors"); _logger.LogInformation("Added role Authors to user {0}", au.Email); au.Author = aacResult.Command.Author; } else { _logger.LogWarning("Unable to make user {0} author {1} {2}", au.Email, model.FirstName, model.LastName); ModelState.AddModelError("", "Error making the user an author, perhaps first and last name are not unique in database"); return(View(model)); } } else { var uac = new UpdateAuthorCommand { Id = au.Author.Id, NewFirstName = model.FirstName, NewLastName = model.LastName }; var uacResult = await _cp.ProcessAsync(uac); if (uacResult.Succeeded) { _logger.LogInformation("Updated author {0} {1} to {2} {3}", au.Author.FirstName, au.Author.LastName, model.FirstName, model.LastName); // do nothing } else { _logger.LogWarning("Unable to update author {0} {1} to {2} {3}", au.Author.FirstName, au.Author.LastName, model.FirstName, model.LastName); ModelState.AddModelError("", "Error updating the author, perhaps the first and last name are not unique in the database"); return(View(model)); } } } // It's not an author else { if (au.Author != null) { // Remove it from authors if it was and remove the role var sauidnfa = new SetAppUserIdNullForAuthorCommand { Id = au.Id }; var sauidnfaResult = await _cp.ProcessAsync(sauidnfa); if (sauidnfaResult.Succeeded) { _logger.LogInformation("Set AppUserId Null for Author {0} {1} with id {3}", au.Author.FirstName, au.Author.LastName, au.Author.Id); await _userManager.RemoveFromRoleAsync(au, "Authors"); } else { // Error _logger.LogWarning("Unable to set AppUserId {0} to Null for Author {1} ", au.Id, au.Author.Id); ModelState.AddModelError("", "Error removing author from user!"); return(View(model)); } } } // Logic goes like this: // Validate user with new email and username // If it has an external login, just change the stuff and update the user assuming it passes validation au.Email = model.Email; au.UserName = model.UserName; var validUser = await _userValidator.ValidateAsync(_userManager, au); if (!validUser.Succeeded) { foreach (var error in validUser.Errors) { ModelState.AddModelError("", error.Description); return(View(model)); } } var logins = await _userManager.GetLoginsAsync(au); if (logins.Count != 0) { var result = await _userManager.UpdateAsync(au); if (au == await _userManager.GetUserAsync(User)) { await _signInManager.RefreshSignInAsync(au); } if (result.Succeeded) { _logger.LogInformation("Updated user {0} to new email {1} username {2}", au.Id, model.Email, model.UserName); return(RedirectToAction("ManageUsers")); } _logger.LogWarning("Unable to update user {0} to new email {1} username {2}", au.Id, model.Email, model.UserName); // something happened, throw an exception or something // for now just return to the edit page } else { // If the password string isn't empty and they want to change the password if (!string.IsNullOrEmpty(model.Password) && model.ChangePassword) { var validPassword = await _passwordValidator.ValidateAsync(_userManager, au, model.Password); if (validPassword.Succeeded) { au.PasswordHash = _passwordHasher.HashPassword(au, model.Password); var securityStampUpdate = await _userManager.UpdateSecurityStampAsync(au); if (securityStampUpdate.Succeeded) { _logger.LogInformation("Updated security stamp for user {0}", au.Id); var result = await _userManager.UpdateAsync(au); if (result.Succeeded) { _logger.LogInformation("Updated user and password for user {0}", au.Id); if (au == await _userManager.GetUserAsync(User)) { await _signInManager.RefreshSignInAsync(au); } return(RedirectToAction("ManageUsers")); } _logger.LogWarning("Unable to update user and password for user {0}", au.Id); foreach (var error in result.Errors) { ModelState.AddModelError("", error.Description); } } else { _logger.LogWarning("Unexpected error updating security stamp for user {0}", au.Id); foreach (var error in securityStampUpdate.Errors) { ModelState.AddModelError("", error.Description); } } } else { foreach (var error in validPassword.Errors) { ModelState.AddModelError("", error.Description); } } } // Can't change the password and have no password there! else if (string.IsNullOrEmpty(model.Password) && model.ChangePassword) { ModelState.AddModelError("", "Password can't be empty"); } // Just update the user and don't change the password else { var result = await _userManager.UpdateAsync(au); if (result.Succeeded) { _logger.LogInformation("Updated user {0}", au.Id); if (au == await _userManager.GetUserAsync(User)) { await _signInManager.RefreshSignInAsync(au); } return(RedirectToAction("ManageUsers")); } _logger.LogWarning("Unable to update user {0}", au.Id); foreach (var error in result.Errors) { ModelState.AddModelError("", error.Description); } } } // end if au == null } else { _logger.LogWarning("Edit user called with non-existant id {0}", model.Id); } return(View(model)); }
public void AddRemoveUserLogin() { using (UserStore <IdentityUser> store = new UserStore <IdentityUser>()) { using (UserManager <IdentityUser> manager = new UserManager <IdentityUser>(store)) { var user = GenTestUser(); WriteLineObject <IdentityUser>(user); var taskUser = manager.CreateAsync(user, DefaultUserPassword); taskUser.Wait(); Assert.IsTrue(taskUser.Result.Succeeded, string.Concat(taskUser.Result.Errors)); var loginInfo = GenGoogleLogin(); var userAddLoginTask = manager.AddLoginAsync(user.Id, loginInfo); userAddLoginTask.Wait(); Assert.IsTrue(userAddLoginTask.Result.Succeeded, string.Concat(userAddLoginTask.Result.Errors)); var loginGetTask = manager.GetLoginsAsync(user.Id); loginGetTask.Wait(); Assert.IsTrue(loginGetTask.Result .Any(log => log.LoginProvider == loginInfo.LoginProvider & log.ProviderKey == loginInfo.ProviderKey), "LoginInfo not found: GetLoginsAsync"); var loginGetTask2 = manager.FindAsync(loginGetTask.Result.First()); loginGetTask2.Wait(); Assert.IsNotNull(loginGetTask2.Result, "LoginInfo not found: FindAsync"); var userRemoveLoginTaskNeg1 = manager.RemoveLoginAsync(user.Id, new UserLoginInfo(string.Empty, loginInfo.ProviderKey)); userRemoveLoginTaskNeg1.Wait(); var userRemoveLoginTaskNeg2 = manager.RemoveLoginAsync(user.Id, new UserLoginInfo(loginInfo.LoginProvider, string.Empty)); userRemoveLoginTaskNeg2.Wait(); var userRemoveLoginTask = manager.RemoveLoginAsync(user.Id, loginInfo); userRemoveLoginTask.Wait(); Assert.IsTrue(userRemoveLoginTask.Result.Succeeded, string.Concat(userRemoveLoginTask.Result.Errors)); var loginGetTask3 = manager.GetLoginsAsync(user.Id); loginGetTask3.Wait(); Assert.IsTrue(!loginGetTask3.Result.Any(), "LoginInfo not removed"); //Negative cases var loginFindNeg = manager.FindAsync(new UserLoginInfo("asdfasdf", "http://4343443dfaksjfaf")); loginFindNeg.Wait(); Assert.IsNull(loginFindNeg.Result, "LoginInfo found: FindAsync"); try { var t1 = store.AddLoginAsync(null, loginInfo); t1.Wait(); } catch (AggregateException aggex) { aggex.ValidateAggregateException <ArgumentNullException>(); } try { var t2 = store.AddLoginAsync(user, null); t2.Wait(); } catch (AggregateException aggex) { aggex.ValidateAggregateException <ArgumentNullException>(); } try { var t3 = store.RemoveLoginAsync(null, loginInfo); t3.Wait(); } catch (ArgumentException) { } try { var t4 = store.RemoveLoginAsync(user, null); t4.Wait(); } catch (ArgumentException) { } try { var t5 = store.FindAsync(null); t5.Wait(); } catch (AggregateException aggex) { aggex.ValidateAggregateException <ArgumentNullException>(); } try { var t6 = store.GetLoginsAsync(null); t6.Wait(); } catch (ArgumentException) { } } } }
public async Task <IActionResult> OnPostAsync() { User user = await _userManager.GetUserAsync(User); if (user == null) { return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'.")); } _logger.LogInformation("User with ID '{UserId}' asked for their personal data.", _userManager.GetUserId(User)); // Only include personal data for download var personalData = new Dictionary <string, object>(); IEnumerable <PropertyInfo> personalDataProps = typeof(User).GetProperties().Where( prop => Attribute.IsDefined(prop, typeof(PersonalDataAttribute))); // Include methods that return personal data IEnumerable <MethodInfo> personalDataMethods = typeof(User).GetMethods().Where(x => Attribute.IsDefined(x, typeof(PersonalDataAttribute))); foreach (PropertyInfo p in personalDataProps) { personalData.Add(p.Name, p.GetValue(user)); } foreach (MethodInfo method in personalDataMethods) { // Assert that the method returns a task and that it returns an IDictionary if (!typeof(Task).IsAssignableFrom(method.ReturnType) || !method.ReturnType.IsGenericType || !typeof(IDictionary).IsAssignableFrom(method.ReturnType.GetGenericArguments()[0])) { throw new InvalidOperationException("Personal data method must have a return type that inherits from Task<System.Collections.IDictionary>"); } // Resolve dependencies of the method var dependencies = new List <object>(); foreach (ParameterInfo param in method.GetParameters()) { dependencies.Add(_serviceProvider.GetService(param.ParameterType)); } // Get the dictionary and add it to the personal data var task = method.Invoke(user, dependencies.ToArray()) as Task; await task.ConfigureAwait(false); var result = task.GetType().GetProperty(nameof(Task <object> .Result)).GetValue(task) as IDictionary; foreach (var key in result.Keys.Cast <object>()) { personalData.Add(key.ToString(), result[key]); } } if ((await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList().Any()) { IList <UserLoginInfo> logins = await _userManager.GetLoginsAsync(user); foreach (UserLoginInfo l in logins) { personalData.Add($"{l.LoginProvider} external login provider key", l.ProviderKey); } } Response.Headers.Add("Content-Disposition", "attachment; filename=PersonalData.json"); return(new FileContentResult( JsonSerializer.SerializeToUtf8Bytes(personalData, new JsonSerializerOptions { WriteIndented = true }), "application/json" )); }
public async Task <IActionResult> GetLogins() { var user = await GetCurrentUserAsync(); return(Ok(await _userManager.GetLoginsAsync(user))); }
public async Task <IActionResult> Index(ManageMessageId?message = null) { // Optionaly use the region info to get default currency for user ViewData["StatusMessage"] = message == ManageMessageId.ChangePasswordSuccess ? "Your password has been changed." : message == ManageMessageId.SetPasswordSuccess ? "Your password has been set." : message == ManageMessageId.SetTwoFactorSuccess ? "Your two-factor authentication provider has been set." : message == ManageMessageId.Error ? "An error has occurred." : message == ManageMessageId.AddPhoneSuccess ? "Your phone number was added." : message == ManageMessageId.RemovePhoneSuccess ? "Your phone number was removed." : ""; var user = await GetCurrentUserAsync(); if (user == null) { return(View("Error")); } // Give the user a default currency if they dont have if (string.IsNullOrEmpty(user.Currency)) { var requestCulture = Request.HttpContext.Features.Get <IRequestCultureFeature>(); var culture = requestCulture.RequestCulture.Culture; user.Currency = _currencyService.GetCurrent().Name; } var currencies = _currencyService.GetAll(); var model = new IndexViewModel { HasPassword = await _userManager.HasPasswordAsync(user), PhoneNumber = await _userManager.GetPhoneNumberAsync(user), TwoFactor = await _userManager.GetTwoFactorEnabledAsync(user), Logins = await _userManager.GetLoginsAsync(user), BrowserRemembered = await _signInManager.IsTwoFactorClientRememberedAsync(user), FullName = user.FullName, Culture = user.Culture, Currency = user.Currency, CurrencyList = new List <SelectListItem>(currencies.Select(c => new SelectListItem { Text = c.Symbol, Value = c.CultureName })), CultureList = new List <SelectListItem> { new SelectListItem { Value = "en-US", Text = "English" }, new SelectListItem { Value = "zh-CN", Text = "Chinese" } } }; return(View(model)); }