public async Task <ActionResult> ForgotPassword(ForgotPasswordViewModel model) { if (ModelState.IsValid) { var user = await UserManager.FindByEmailAsync(model.Email); if (user == null || !(await UserManager.IsEmailConfirmedAsync(user.Id))) { // Don't reveal that the user does not exist or is not confirmed return(View("ForgotPasswordConfirmation")); } // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771 // Send an email with this link string code = await UserManager.GeneratePasswordResetTokenAsync(user.Id); var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme); await UserManager.SendEmailAsync(user.Id, "Alteração de Senha", "Altere a sua senha clicando <a href=\"" + callbackUrl + "\">aqui</a>"); return(View("ForgotPasswordConfirmation")); } // If we got this far, something failed, redisplay form return(View(model)); }
public async Task <ActionResult> LogIn(AccountLogInViewModel model, string returnUrl) { if (ModelState.IsValid) { AppUserEntity user = null; // if (_RegularExpressions.SimpleEmail.IsMatch(model.EmailOrUsername)) { user = await _appUserManager.FindByEmailAsync(model.EmailOrUsername); } else { user = await _appUserManager.FindByNameAsync(model.EmailOrUsername); } // if (user != null && user.Realms.Contains(Realm.AdminWebsite)) { _signInManager.InitialPersistenceState = model.RememberMe; var result = await _signInManager.PasswordSignInAsync( user.UserName, model.Password, model.RememberMe, shouldLockout : true ); switch (result) { case SignInStatus.LockedOut: { return(RedirectToAction("Locked", "Account")); } case SignInStatus.Success: { return(RedirectToLocal(returnUrl)); } } } ModelState.AddModelError("credentials", GetLocalizedString <AreaResources>("InvalidCredentialsMessage")); } ViewBag.ReturnUrl = returnUrl; return(View(model)); }
public async Task <IHttpActionResult> ForgotPassword(string email) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = await AppUserManager.FindByEmailAsync(email); if (user == null) { return(BadRequest("El email es incorrecto.")); } var code = await AppUserManager.GeneratePasswordResetTokenAsync(user.Id); code = HttpUtility.UrlEncode(code); var callbackUrl = string.Concat( Request.RequestUri.Scheme, "://", Request.RequestUri.Authority, "/#!/resetPassword?key=", user.Id, "&code=", code ); await AppUserManager.SendEmailAsync(user.Id, "Recuperar Contraseña", "Por favor, recupere su contraseña siguiendo <a href=\"" + callbackUrl + "\">este enlace.</a>"); return(Ok()); }
public async Task <IActionResult> OnPostSendVerificationEmailAsync() { if (!ModelState.IsValid) { return(Page()); } var user = await _userManager.FindByEmailAsync(Input.Email); if (user == null) { ModelState.AddModelError(string.Empty, "Verification email sent. Please check your email."); } var userId = await _userManager.GetUserIdAsync(user); var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); var callbackUrl = Url.Page( "/Account/ConfirmEmail", pageHandler: null, values: new { userId = userId, code = code }, protocol: Request.Scheme); await _emailSender.SendEmailAsync( Input.Email, "Confirm your email", $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>."); ModelState.AddModelError(string.Empty, "Verification email sent. Please check your email."); return(Page()); }
public async Task <IActionResult> ForgetPassword(ForgetPassword model) { if (!ModelState.IsValid) { return(View(model)); } var user = await _userManager.FindByEmailAsync(model.Email); if (user == null || !(await _userManager.IsEmailConfirmedAsync(user))) { return(View("ForgetPasswordConfirm")); } var code = await _userManager.GeneratePasswordResetTokenAsync(user); var callBackUrl = Url.RouteUrl( "GetResetPassword", new { key = user.GeneratedKey, code }, Request.Scheme); var message = $"<a href=\"{callBackUrl}\"> Rest Password </a>"; await _emailSender.SendEmailAsync(user.Email, "Rest Password", message); return(View("ForgetPasswordConfirm")); }
public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { return(Page()); } var user = await _userManager.FindByEmailAsync(Input.Email); if (user == null) { // Don't reveal that the user does not exist return(RedirectToPage("./ResetPasswordConfirmation")); } var result = await _userManager.ResetPasswordAsync(user, Input.Code, Input.Password); if (result.Succeeded) { return(RedirectToPage("./ResetPasswordConfirmation")); } foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } return(Page()); }
public async Task <IHttpActionResult> Register(RegisterClientModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var client = new Client { UserName = model.Email, Email = model.Email, Name = model.Name, Address = model.Address, Location = model.Location }; IdentityResult result; var existingUser = await _userManager.FindByEmailAsync(client.Email); if (existingUser != null) { result = IdentityResult.Failed(new[] { "User with this email already exists" }); } else { result = await _clientManager.CreateAsync(client, model.Password); } if (!result.Succeeded) { return(GetErrorResult(result)); } return(Ok()); }
public async Task <IActionResult> LoginViaEmailCode(LoginViaCodeInputModel parameters) { if (!ModelState.IsValid) { return(BadRequest(ModelState.Values.SelectMany(state => state.Errors) .Select(error => error.ErrorMessage) .FirstOrDefault())); } var user = await _userManager.FindByEmailAsync(parameters.Key); if (user == null) { return(BadRequest("User does not exist")); } var singInResult = await _signInManager.CheckPasswordSignInAsync(user, parameters.Code, false); if (!singInResult.Succeeded) { return(BadRequest("Invalid password")); } await _signInManager.SignInAsync(user, parameters.RememberMe); return(Ok()); }
public async Task <IHttpActionResult> Login(LoginModel model) { if (ModelState.IsValid) { var user = await AppUserManager.FindByEmailAsync(model.Email); //We don't want a deleted user to be able to log in. if (user != null && !user.IsDeleted) { var valid = await AppUserManager.CheckPasswordAsync(user, model.Password); if (valid) { await SignInAsync(user, model.RememberMe); return(Ok()); } } ModelState.AddModelError("", "Invalid username or password."); } // If we got this far, something failed, redisplay form return(BadRequest(ModelState)); }
public async Task <IActionResult> OnPostAsync() { if (ModelState.IsValid) { var user = await _userManager.FindByEmailAsync(Input.Email); if (user == null || !(await _userManager.IsEmailConfirmedAsync(user))) { // Don't reveal that the user does not exist or is not confirmed return(RedirectToPage("./ForgotPasswordConfirmation")); } // For more information on how to enable account confirmation and password reset please // visit https://go.microsoft.com/fwlink/?LinkID=532713 var code = await _userManager.GeneratePasswordResetTokenAsync(user); var callbackUrl = Url.Page( "/Account/ResetPassword", pageHandler: null, values: new { code }, protocol: Request.Scheme); await _emailSender.SendEmailAsync( Input.Email, "Reset Password", $"Please reset your password by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>."); return(RedirectToPage("./ForgotPasswordConfirmation")); } return(Page()); }
public static async Task <int> GetCurrentUserIdAsync(this AppUserManager appUserManager, string userEmail) { AppUser currentUser = await appUserManager.FindByEmailAsync(userEmail); int currentUserId = int.Parse(await appUserManager.GetUserIdAsync(currentUser)); return(currentUserId); }
public async Task <JsonResult> EmailExists(string email) { AppUser user = await UserManager.FindByEmailAsync(email); return(user == null?Json(true) : Json($"Email {email} is already in use.")); //return repository.EmailExists(email) ? Json(true): Json($"Email {email} is already in use."); }
public async Task <IHttpActionResult> Register(RegisterSantaModel model) { //var model = new RegisterSantaModel(); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } IdentityResult result; var existingUser = await _userManager.FindByEmailAsync(model.Email); if (existingUser != null) { result = IdentityResult.Failed(new[] { "User with this email already exists" }); } else { var santa = new Santa { UserName = model.Email, Email = model.Email, Name = model.Name, PhotoPath = "" }; result = await _santaManager.CreateAsync(santa, model.Password); if (result.Succeeded) { var photoPath = HttpContext.Current.Server.MapPath("~/App_Data/Photos"); if (!Directory.Exists(photoPath)) { Directory.CreateDirectory(photoPath); } var fileExtension = Path.GetExtension(model.Photo.Filename); var filename = $"{santa.Id}{fileExtension}"; photoPath = Path.Combine(photoPath, filename); File.WriteAllBytes(photoPath, model.Photo.Content); santa.PhotoPath = photoPath; await _santaManager.UpdateAsync(santa); } } if (!result.Succeeded) { return(GetErrorResult(result)); } return(Ok()); }
protected async Task <AppUser> GetCurrentUser() { if (_currentUser == null) { var email = _userEmail; if (string.IsNullOrWhiteSpace(email)) { return(null); } _currentUser = await _appUserManager.FindByEmailAsync(email); } return(_currentUser); }
public async Task <ActionResult> ForgotPassword(string email) { AppUser user = await _userManager.FindByEmailAsync(email); if (!string.IsNullOrEmpty(email) && user != null) { string code = await _userManager.GeneratePasswordResetTokenAsync(user.Id); string callbackUrl = Url.Action("ResetPassword", "Account", new { code = code }, protocol: Request.Url.Scheme); _mailingRepository.ResetPasswordMail(user.Email, callbackUrl); return(PartialView("ForgotPasswordConfirmation")); } ModelState.AddModelError("", "User Not Found"); Response.StatusCode = (int)HttpStatusCode.BadRequest; return(PartialView()); }
public async Task <IHttpActionResult> ForgotPassword(ForgotPasswordModel username) { var user = await AppUserManager.FindByEmailAsync(username.UserName); if (user == null) { return(BadRequest("Invalid email address")); } var token = await AppUserManager.GeneratePasswordResetTokenAsync(user.Id); var callbackUrl = Request.RequestUri.Scheme + "://" + Request.RequestUri.Authority + "/ResetPassword?userId=" + user.Id + "&code=" + HttpUtility.UrlEncode(token); await AppUserManager.SendEmailAsync(user.Id, "Password Reset", "Please reset your password by clicking " + callbackUrl); return(Ok()); }
public async Task <IHttpActionResult> RecoverPassword(string email) { var user = await AppUserManager.FindByEmailAsync(email); if (user == null) { return(BadRequest("E-mail is not registered")); } string code = await AppUserManager.GeneratePasswordResetTokenAsync(user.Id); string password = GetAutoGenPwd(); var callbackUrl = new Uri(Url.Link("ResetPasswordRoute", new { userId = user.Id, code, password })); await AppUserManager.SendEmailAsync(user.Id, "KeetFit Password Recovery", "Please follow <a href=\"" + callbackUrl + "\">this</a> link to reset your password. Then you'll be able to use new generated password: '******' for login."); return(Ok()); }
public async Task SignIn(UserLoginModel model) { if (model == null) { return; } var user = await _appUserManager.FindByEmailAsync(model.Email); if (user == null) { return; } var isPassword = await _appUserManager.CheckPasswordAsync(user, model.Password); var s = isPassword; }
public async Task <IHttpActionResult> RecoveryPassword(string email) { var user = await AppUserManager.FindByEmailAsync(email); if (user == null) { Logger.ServiceLog.Warn($"Пользователь с email {email} не зарегистрирован."); return(GetErrorFromModel("email", $"Пользователь с email {email} не зарегистрирован.")); } var recoveryToken = AppUserManager.GeneratePasswordResetTokenAsync(user.Id); var code = HttpUtility.UrlEncode(recoveryToken.Result); var password = RandomPasswordService.Generate(6); var callBackUri = new Uri(Url.Link("RecoveryPasswordRoute", new { userId = user.Id, code, newPassword = password })); await AppUserManager.SendEmailAsync(user.Id, "Восстановление пароля", "Ваш новый пароль: <strong>" + password + "</strong> <br> Для его подтверждения перейдите по ссылке <a href=\"" + callBackUri + "\">ССылка</a>"); Logger.ServiceLog.Info($"Пользователю на email {email} успешно выслана инструкция по восстановдению пароля."); return(Ok("Инструкция по смене пароля выслана на почту")); }
public async Task <IHttpActionResult> ForgotPassword(ForgotPasswordBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } //Use later when isEmailConfirmed implemented //if (user == null || !(await AppUserManager.IsEmailConfirmedAsync(user.Id))) var user = await AppUserManager.FindByEmailAsync(model.Email); //var role = await this.AppRoleManager.FindByIdAsync(Id); if (user == null) { // Don't reveal that the user does not exist or is not confirmed return(Ok()); } string pcode = await AppUserManager.GeneratePasswordResetTokenAsync(user.Id); System.Web.HttpUtility.UrlEncode(pcode); var callbackUrl = "http://rip-offnigeria.com/index.html#/resetpwd/" + user.Id + "/" + pcode; string response = "<h4>Reset password</h4>" + "<p>" + "<p>Dear " + user.Name + "," + "<p>" + "<p class=\"lead\">To get back into your rip-off Nigeria account,you'll need to create a new password.</p>" + "<p class=\"lead\">Click the link below to open a secure browser window.</p>"; await this.AppUserManager.SendEmailAsync(user.Id, "Reset your password", response + "<a href=\"" + callbackUrl + "\">Reset your password now</a>"); // If we got this far, something failed, redisplay form return(Ok()); }
public async Task <ActionResult> New(CreateUserModel model) { if (!ModelState.IsValid) { return(View(model)); } var identiyUser = await _userManager.FindByEmailAsync(model.Email); if (identiyUser != null) { return(RedirectToAction("Index", "User")); } var user = new ExtendedUser { Email = model.Email, FullName = model.FullName, UserName = model.Email, Id = Guid.NewGuid().ToString() }; var result = await _userManager.CreateAsync(user, model.Password); //Genrate Token var token = _userManager.GenerateEmailConfirmationTokenAsync(user.Id); var confirmUrl = Url.Action("ConfirmEmail", "Account", new { userid = user.Id, token = token }, Request.Url.Scheme); await _userManager.SendEmailAsync(user.Id, "Email Confirmation", $"Use link to confirm email:{confirmUrl}"); if (result.Succeeded) { return(RedirectToAction("Index", "User")); } ModelState.AddModelError("", result.Errors.FirstOrDefault()); return(View(model)); }
public async Task <HttpResponseMessage> ResetPassword(HttpRequestMessage request, AppUserViewModel model) { if (ModelState.IsValid) { var userEmail = await AppUserManager.FindByEmailAsync(model.Email); if (userEmail == null) { return(request.CreateErrorResponse(HttpStatusCode.NoContent, "Email không tồn tại")); } //Send an email with link string sendLink = await AppUserManager.GeneratePasswordResetTokenAsync(userEmail.Id); await AppUserManager.SendEmailAsync(userEmail.Id, "Reset password", "Click here "); return(request.CreateResponse(HttpStatusCode.OK, sendLink)); } else { return(request.CreateErrorResponse(HttpStatusCode.NoContent, "Models không thỏa mãn yêu cầu")); } }
// TODO: Apply capcha public async Task <IHttpActionResult> RegisterUser(RegisterUserReq registerUserDto) { // Create user IdentityResult identityResult = AppUserManager.RegisterUser(registerUserDto); if (!identityResult.Succeeded) { return(BadRequestWithIdentityErrors(identityResult)); } // Send confirmation email AppUser appUser = await AppUserManager.FindByEmailAsync(registerUserDto.Email); var resultMessage = await SendEmailConfirmationAsync(appUser); // Configure reponse var response = new BaseResponseDto(); response.Message = Responses.UserRegisteredMessage + " " + resultMessage; return(Ok(response)); }
public async Task <IHttpActionResult> GetPasscode(string email) { ApplicationUser user = await AppUserManager.FindByEmailAsync(email); if (user == null) { return(BadRequest()); } string code = PassCode.GeneratePresharedKey(); user.PasscodeHash = code; user.LockoutEndDateUtc = DateTime.UtcNow.AddMinutes(30); IdentityResult userResult = await this.AppUserManager.UpdateAsync(user); if (!userResult.Succeeded) { return(GetErrorResult(userResult)); } await this.AppUserManager.SendEmailAsync(user.Id, "Login Passcode", code); return(Ok()); }
public async Task <IActionResult> LoginPostAsync(string returnUrl = null) { returnUrl = returnUrl ?? Url.Content("~/"); if (ModelState.IsValid) { AppUser user = await userManager.FindByEmailAsync(UserSignInModel.Email); if (user != null) { await signInManager.SignOutAsync(); var result = await signInManager.PasswordSignInAsync( UserSignInModel.UserName, UserSignInModel.Password, UserSignInModel.RememberMe, lockoutOnFailure : true); if (result.Succeeded) { bool asd = User.Identity.IsAuthenticated; return(Redirect(returnUrl)); } if (result.IsLockedOut) { return(RedirectToPage("./Lockout")); } else { ModelState.AddModelError(string.Empty, "Invalid login attempt."); return(View(UserSignInModel)); } } else { ModelState.AddModelError(nameof(UserSignInModel.Email), "Invalid user or password"); } } return(View()); }
public async Task <HttpResponseMessage> CheckUser(HttpRequestMessage request, string id) { //var username = AppUserManager.FindByNameAsync(id).Result; var username = AppUserManager.FindByEmailAsync(id).Result; if (username != null) { var rolesForUser = await AppUserManager.GetRolesAsync(username.Id); if (rolesForUser.Count() > 0) { foreach (var item in rolesForUser.ToList()) { // item should be the name of the role var result = await AppUserManager.RemoveFromRoleAsync(username.Id, item); } } _userService.DeleteTableUser(username.Id); _unitOfWork.Commit(); return(request.CreateResponse(HttpStatusCode.OK, Common.Constants.MessageSystem.ChangePasswordSuccess)); } return(request.CreateResponse(HttpStatusCode.OK)); }
public async Task <OperationDetails> Register(RegisDTO userDto) { try { AppUser user = await _userMng.FindByEmailAsync(userDto.Email); if (user == null) { var entityId = await CreateClient(userDto); user = new AppUser { UserName = userDto.Email, Email = userDto.Email, BusinessEntityID = entityId }; var result = await _userMng.CreateAsync(user, userDto.Password); if (result.Errors.Count() > 0) { return(new OperationDetails(OperationDetails.Statuses.Error, result.Errors.FirstOrDefault(), "")); } await _userMng.AddToRoleAsync(user.Id, userDto.Role); _userMng.Dispose(); return(new OperationDetails(OperationDetails.Statuses.Success, "Registration was successful!", "")); } else { return(new OperationDetails(OperationDetails.Statuses.Error, "User with this login exists", "Email")); } } catch (Exception e) { return(new OperationDetails(OperationDetails.Statuses.Error, $"{e.Message}", "Exception")); } }
protected async Task <IHttpActionResult> ChangeProfileInternal <T>(UserManager <T> userManager, IProfileChangeModel model, Action <User> updateModel) where T : User { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { IdentityResult result; try { var id = User.Identity.GetUserId(); var user = await userManager.FindByIdAsync(id); if (user != null) { if (await userManager.CheckPasswordAsync(user, model.Password)) { updateModel(user); if (!string.IsNullOrEmpty(model.NewPassword.Password) && !string.IsNullOrEmpty(model.NewPassword.PasswordConfirmation)) { if (model.NewPassword.Password == model.NewPassword.PasswordConfirmation) { result = await userManager.ChangePasswordAsync(user.Id, model.Password, model.NewPassword.Password); if (!result.Succeeded) { throw new ChangeProfileException(result); } } else { throw new ChangeProfileException(IdentityResult.Failed(new[] { "Passwords don't match" })); } } } else { throw new ChangeProfileException(IdentityResult.Failed(new[] { "Incorrect password" })); } var existingUserWithThisEmail = await _commonUserManager.FindByEmailAsync(user.Email); if (existingUserWithThisEmail != null && existingUserWithThisEmail.Id != user.Id) { throw new ChangeProfileException(IdentityResult.Failed(new[] { "User with this email already exists" })); } result = await userManager.UpdateAsync(user); if (!result.Succeeded) { throw new ChangeProfileException(result); } } else { throw new ChangeProfileException(IdentityResult.Failed(new[] { "User does not exists" })); } scope.Complete(); return(Ok()); } catch (ChangeProfileException ex) { scope.Dispose(); return(GetErrorResult(ex.Result)); } catch (Exception ex) { scope.Dispose(); return(GetErrorResult(IdentityResult.Failed(ex.Message))); } } }
public async Task <ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var lastMonth = DateTime.Now.AddMonths(-1); var existingUser = await UserManager.FindByEmailAsync(model.Email); CompanyTeamMemberInvite invite = null; bool hasInvite = false; if (existingUser != null) { this.SetNotificationMessage(NotificationType.Error, string.Format("Email {0} is already taken.", model.Email)); return(View(model)); } if (!model.TermsAndConditions) { this.SetNotificationMessage(NotificationType.Error, "You must accept the Terms and Conditions and Privacy Policy."); return(View(model)); } // Check for invite if (model.Invite != null) { invite = _companyManager.GetTeamMemberInvite(model.Invite.UniqueId); if (invite == null) { return(View("InviteUnavailable")); } if (invite.ResultantUserId.HasValue) { this.SetNotificationMessage(NotificationType.Error, "There is already an account creating using this invitation. Please login to start using the application."); return(View(model)); } hasInvite = true; } IdentityResult result; AppUser registeredUser; using (var scope = new TransactionScope()) { // Create new user. registeredUser = new AppUser { UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName }; result = await UserManager.CreateAsync(registeredUser, model.Password); if (result.Succeeded) { // Mark the latest terms and conditions as accepted _termsAndConditionsManager.AcceptTermsAndConditions(registeredUser.Id); // Check if the user has been invited. if (hasInvite) { invite.ResultantUserId = registeredUser.Id; _companyManager.AcceptTeamMemberInvite(invite); } else { // Create a new company. var newCompany = _companyManager.Create(new Company { Name = model.CompanyName, StartMonth = lastMonth, ReportTitle = DefaultReportTitle, TwitterHandle = model.TwitterHandle }); // Associate the user to the company. _companyManager.AddUser(newCompany.Id, registeredUser.Id, true); // Create a trial subscription _subscriptionManager.CreateTrialSubscription(newCompany.Id); } } // Complete the scope. scope.Complete(); } // Send the email confirmation email. if (result.Succeeded) { // store UTM info var utmInfo = GetUtmInfo(); if (utmInfo != null) { utmInfo.UserId = registeredUser.Id; _adminManager.StoreUtmInfo(utmInfo); } var callbackUrl = await SendEmailConfirmationTokenAsync(registeredUser.Id, registeredUser.UniqueId, "Confirm your account"); ViewBag.Link = callbackUrl; return(Redirect("http://supdate.com/confirm-email")); } AddErrors(result); } // If we got this far, something failed, redisplay form return(View(model)); }
//[HttpPost("sign-in", Name = "PostLogin")] public async Task <IActionResult> Login(LoginAccount account, string returnTo) { if (account.Email.IndexOf('@') > -1) { //Validate email format string emailRegex = @"^([a-zA-Z0-9_\-\.]+)@((\[[0-9]{1,3}" + @"\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\" + @".)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$"; Regex re = new Regex(emailRegex); if (!re.IsMatch(account.Email)) { ModelState.AddModelError("Email", "ایمیل معتبر نمیباشد"); } if (ModelState.IsValid) { var user = await _userManager.FindByEmailAsync(account.Email); if (user != null) { var result = await _signInManager.PasswordSignInAsync( userName : user.UserName, password : account.Password, isPersistent : account.RememberMe, lockoutOnFailure : true); if (result.Succeeded) { return(RedirectToLocal(returnTo)); } if (result.RequiresTwoFactor) { return(RedirectToRoute("GetSendCode", new { returnTo, rememberMe = account.RememberMe })); } if (result.IsLockedOut) { // todo create lockout view return(View("LockOut")); } if (result.IsNotAllowed) { if (_userManager.Options.SignIn.RequireConfirmedPhoneNumber) { if (!await _userManager.IsPhoneNumberConfirmedAsync(new User { UserName = account.Email })) { ModelState.AddModelError(string.Empty, "شماره تلفن شما تایید نشده است."); return(View(account)); } } if (_userManager.Options.SignIn.RequireConfirmedEmail) { if (!await _userManager.IsEmailConfirmedAsync(new User { UserName = account.Email })) { ModelState.AddModelError(string.Empty, "آدرس ایمیل شما تایید نشده است."); return(View(account)); } } } } } } else { //validate Username format string emailRegex = @"^[a-zA-Z0-9]*$"; Regex re = new Regex(emailRegex); if (!re.IsMatch(account.Email)) { ModelState.AddModelError("Email", "نام کاربری معتبر نمیباشد"); } else { if (ModelState.IsValid) { var user = await _userManager.FindByNameAsync(account.Email); if (user != null) { var result = await _signInManager.PasswordSignInAsync( userName : account.Email, password : account.Password, isPersistent : account.RememberMe, lockoutOnFailure : false); if (result.Succeeded) { return(RedirectToLocal(returnTo)); } if (result.RequiresTwoFactor) { return(RedirectToRoute("GetSendCode", new { returnTo, rememberMe = account.RememberMe })); } if (result.IsLockedOut) { // todo create lockout view return(View("LockOut")); } if (result.IsNotAllowed) { if (_userManager.Options.SignIn.RequireConfirmedPhoneNumber) { if (!await _userManager.IsPhoneNumberConfirmedAsync(new User { UserName = account.Email })) { ModelState.AddModelError(string.Empty, "شماره تلفن شما تایید نشده است."); return(View(account)); } } if (_userManager.Options.SignIn.RequireConfirmedEmail) { if (!await _userManager.IsEmailConfirmedAsync(new User { UserName = account.Email })) { ModelState.AddModelError(string.Empty, "آدرس ایمیل شما تایید نشده است."); return(View(account)); } } } } } } } ModelState.AddModelError(string.Empty, "نام کاربری و یا کلمهی عبور وارد شده معتبر نیستند."); return(View(account)); }