public async Task <IActionResult> ChangeEmail(ChangeEmailModel model) { if (!ModelState.IsValid) { return(BadRequest(model)); } var user = await _userManager.GetUserAsync(HttpContext.User); if (user == null) { return(Unauthorized()); } var token = await _userManager.GenerateChangeEmailTokenAsync(user, model.NewEmail); var result = await _userManager.ChangeEmailAsync(user, model.NewEmail, token); if (result.Succeeded) { await _signInManager.SignInAsync(user, model.RememberMe); return(Ok()); } return(BadRequest()); }
public async Task <ActionResult> ChangeEmail(ChangeEmailModel model) { if (model.NewEmail == null || model.NewEmailAgain == null) { return(View(model)); } if (model.NewEmail == model.NewEmailAgain) { var account = await AccountFacade.GetAccountAccordingToEmailAsync(model.Email); if ((await AccountFacade.GetAccountAccordingToEmailAsync(model.NewEmail)) != null) { ModelState.AddModelError("", "Account with this Email already exist"); return(View(new ChangeEmailModel { Email = model.Email })); } account.Email = model.NewEmail; var result = await AccountFacade.EditAccountAsync(account); return(await Login(new LoginModel { EmailAddress = model.NewEmail, Password = account.Password }, null)); } ModelState.AddModelError("", "Entered Emails aren't same"); return(View(new ChangeEmailModel { Email = model.Email })); }
public ActionResult ChangeEmail_Post(ChangeEmailModel model) { if (!User.Identity.IsAuthenticated) { return(Redirect("/")); } if (String.IsNullOrEmpty(model.Password)) { return(RedirectToAction("ChangeEmail", new { userMessage = "Please enter your password to make this change." })); } if (String.IsNullOrEmpty(model.Email)) { return(RedirectToAction("ChangeEmail", new { userMessage = "Please enter the e-mail you wish to use." })); } //check password. MembershipUser u = Membership.GetUser(User.Identity.Name); if (!Membership.ValidateUser(User.Identity.Name, model.Password)) { return(RedirectToAction("ChangeEmail", new { userMessage = "Please enter your password to make this change." })); } var profile = db.UserProfiles.First(p => p.UserName == User.Identity.Name); profile.Email = model.Email; db.SaveChanges(); return(RedirectToAction("ChangeEmail")); }
public async Task <IActionResult> ChangeEmail(ChangeEmailModel changeEmailModel) { if (ModelState.IsValid) { if (await _userManager.FindByEmailAsync(changeEmailModel.Email) is var candidate && candidate != null) { TempData["ErrorMessage"] = new[] { ValidationMessages.EmailAlreadyInUse } } ; else { var user = await _userManager.FindByIdAsync(changeEmailModel.UserId.ToString()); if (user != null) { var result = await _userManager.ChangeEmailAsync(user, changeEmailModel.Email, changeEmailModel.Token.DecodeFromBase64()); if (result.Succeeded) { TempData["SuccessMessage"] = new[] { OtherMessages.EmailChangedSuccessfully } } ; } else { ModelState.AddModelError("NotSucceeded", OtherMessages.CouldNotChangeEmail); } } }
public void ChangeEmail(ChangeEmailModel model) { string result = null; try { Model = model.ToJsonExtension(); if (this.loginResult != null && !string.IsNullOrEmpty(this.loginResult.sessionId)) { var response = this.api.ChangeEmail( new SalesForceServiceNS.SessionHeader { sessionId = this.loginResult.sessionId }, new SalesForceServiceNS.CallOptions(), new SalesForceServiceNS.DebuggingHeader(), new SalesForceServiceNS.AllowFieldTruncationHeader(), Model, out result); Log.DebugFormat("Debug log: {0}", response == null ? "" : response.debugLog); } } catch (Exception ex) { var resultModel = new ApiResponse(null, ex.Message); result = resultModel.ToJsonExtension(); } LogResult("ChangeEmail", result, model.newEmail); }
public async Task <object> ChangeEmail([FromBody] ChangeEmailModel model) { if (!ModelState.IsValid) { return(new { success = false, errors = GetModelState() }); } var user = await GetCurrentUserAsync(); if (!await _userManager.CheckPasswordAsync(user, model.CurrentPassword)) { ModelState.AddModelError("currentPassword", "Invalid password."); return(new { success = false, errors = GetModelState() }); } // send an email to the user asking them to finish the change of email. var code = await _userManager.GenerateChangeEmailTokenAsync(user, model.Email); var callbackUrl = Url.RouteUrl("confirmemail", new { userId = user.Id, newEmail = model.Email, code = code }, protocol: HttpContext.Request.Scheme); await _emailSender.SendEmailAsync(model.Email, "Confirm your email change", "Please confirm your new email by clicking this link: <a href=\"" + callbackUrl + "\">link</a>"); return(new { success = true }); }
public async Task ChangeEmailAsync(ChangeEmailModel parameters) { if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } var user = await GetUserByEmailAsync(parameters.CurrentEmail); if (user == null) { throw new HESException(HESCode.UserNotFound); } var exist = await GetUserByEmailAsync(parameters.NewEmail); if (exist != null) { throw new HESException(HESCode.EmailAlreadyTaken); } var code = await _userManager.GenerateChangeEmailTokenAsync(user, parameters.NewEmail); code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code)); await _emailSenderService.SendUserConfirmEmailAsync(user.Id, parameters.NewEmail, code); }
/// <summary> /// This method changes user's email after authentication. /// </summary> /// <param name="model">A ChangeEmailModel instance for the ChangeEmail function.</param> public async Task <IActionResult> ChangeEmail([FromBody] ChangeEmailModel model) { string username = User.FindFirst(ClaimTypes.Name)?.Value; var user = await userManager.FindByNameAsync(username); if (user == null) { return(StatusCode(StatusCodes.Status500InternalServerError, new Response { Status = "Error", Message = "User not exists!" })); } IdentityResult result = await userManager.SetEmailAsync(user, model.NewEmail); if (result.Succeeded) { return(Ok(new Response { Status = "Success", Message = "email changed successfully!" })); } return(StatusCode(StatusCodes.Status500InternalServerError, new Response { Status = "Error", Message = "password change fail!" }));; }
public async Task <IActionResult> ChangeEmail(ChangeEmailModel model, string returnUrl) { var member = await HttpContext.GetMemberAsync(); model.OldEmail = member.Email; if (HttpMethods.IsGet(Request.Method)) { ModelState.Clear(); } else if (HttpMethods.IsPost(Request.Method)) { if (ModelState.IsValid) { var email = model.NewEmail; var token = await _userService.GenerateChangeEmailTokenAsync(member, email); var userId = member.Id; var link = Url.Action(nameof(ChangeEmailCallback), "Account", new { token, userId, email, returnUrl }, protocol: Request.Scheme); await _messageService.SendEmailAsync( messageRole : MessageRole.Notification, messageType : MessageType.ChangeEmail, messageDisplay : "Neimart Support", email : email, model : new ValueTuple <User, string>(member, link)); TempData.AddAlert(AlertMode.Alert, AlertType.Success, "We'll send you an email within a few minutes with instructions to change your email address. If the email does not arrive soon, check your spam, junk, and bulk mail folders."); } } return(PartialView(model)); }
protected override async Task OnInitializedAsync() { try { ApplicationUserService = ScopedServices.GetRequiredService <IApplicationUserService>(); var email = (await AuthenticationStateProvider.GetAuthenticationStateAsync()).User.Identity.Name; User = await ApplicationUserService.GetUserByEmailAsync(email); UserProfileModel = new UserProfileModel { UserId = User.Id, FullName = User.FullName, PhoneNumber = User.PhoneNumber }; ChangeEmailModel = new ChangeEmailModel { CurrentEmail = User.Email }; SetInitialized(); } catch (Exception ex) { Logger.LogError(ex.Message); SetLoadFailed(ex.Message); } }
public ActionResult ChangeEmail(ChangeEmailModel changeEmail) { try { // Validate. changeEmail.EmailAddress = changeEmail.EmailAddress == null ? null : changeEmail.EmailAddress.Trim(); changeEmail.SecondaryEmailAddress = changeEmail.SecondaryEmailAddress == null ? null : changeEmail.SecondaryEmailAddress.Trim(); changeEmail.Validate(); // If changing the email address make sure it is not already being used. var member = CurrentMember; if (changeEmail.EmailAddress != member.EmailAddresses[0].Address) { if (_loginCredentialsQuery.DoCredentialsExist(new LoginCredentials { LoginId = changeEmail.EmailAddress })) { throw new DuplicateUserException(); } } // Change the email addresses and login id for the user. member.EmailAddresses = new List <EmailAddress> { new EmailAddress { Address = changeEmail.EmailAddress, IsVerified = false } }; if (!string.IsNullOrEmpty(changeEmail.SecondaryEmailAddress)) { member.EmailAddresses.Add(new EmailAddress { Address = changeEmail.SecondaryEmailAddress, IsVerified = false }); } _memberAccountsCommand.UpdateMember(member); // Send activation. _accountVerificationsCommand.SendReactivation(member); _accountVerificationsCommand.StartActivationWorkflow(member); if (member.EmailAddresses.Count > 1 && !member.EmailAddresses[1].IsVerified) { _accountVerificationsCommand.SendVerification(member, member.EmailAddresses[1].Address); } // Redirect. return(RedirectToRoute(AccountsRoutes.ActivationSent)); } catch (UserException ex) { ModelState.AddModelError(ex, new ActivationErrorHandler()); } return(View(changeEmail)); }
public async Task <ActionResult> ChangeEmail(ChangeEmailModel model) { await UserService.ChangeEmail(model.UserId, model.NewEmail); await UserManager.UpdateSecurityStampAsync(model.UserId); return(RedirectToUserDetails(model.UserId)); }
public UserDto ChangeEmail(ChangeEmailModel model) { var user = _userRepository.ChangeEmail(model.UserId, model.NewEmail, model.Password); _mailService.ChangeEmailMail(Language.DefaultSign, user.Email, model.NewEmail, $"{user.FirstName} {user.LastName}"); return(_mapper.Map <UserDto>(user)); }
bool DoesChangedEmailExist(ChangeEmailModel model) { if (_db.ChangeEmailModels.Find(model.Email) != null) { return(true); } return(false); }
public async Task <IHttpActionResult> CreateChangedEmail([FromBody] ChangeEmailModel model) { try { } catch (Exception e) { } }
public ActionResult ChangeEmail() { var model = new ChangeEmailModel() { NewEmail = _accountRepository.FindById(User.Identity.GetUserId()).Email, }; return(View(model)); }
public static async Task SendChangeEmail(this IEmailSender emailSender, FantasyCriticUser user, string newEmailAddress, string changeCode, string baseURL) { string emailAddress = user.EmailAddress; string emailSubject = "FantasyCritic - Change Your Email."; ChangeEmailModel model = new ChangeEmailModel(user, newEmailAddress, changeCode, baseURL); var htmlResult = await GetHTMLString("ChangeEmail.cshtml", model); await emailSender.SendEmailAsync(emailAddress, emailSubject, htmlResult); }
public async Task SendChangeEmail(FantasyCriticUser user, string link) { string emailAddress = user.Email; string emailSubject = "FantasyCritic - Change Your Email."; ChangeEmailModel model = new ChangeEmailModel(user, link); var htmlResult = await GetHTMLString("ChangeEmail.cshtml", model); await _emailSender.SendEmailAsync(emailAddress, emailSubject, htmlResult); }
public void ChangeEmail(ChangeEmailModel model) { Log.InfoFormat("SalesForce ChangeEmail from {0} to {1}", model.currentEmail, model.newEmail); ApiResponse response = new ApiResponse(); if (!response.IsSuccess) { Log.ErrorFormat("SalesForce ChangeEmail failed from {0} to {1} failed, error: {2}", model.currentEmail, model.newEmail, response.Error); } }
public ActionResult ChangeEmailAddress(ChangeEmailModel model) { if (!ModelState.IsValid) { return(MvcHelper.JsonErrorResult("Model is invalid.")); } // backend update code goes here... return(MvcHelper.JsonSuccessResult()); }
public async Task <IActionResult> ChangeEmailAsync(int id, ChangeEmailModel model) { var result = await _userService.ChangeEmailAsync(id, model); if (result.IsFailure) { return(BadRequest(result.Errors)); } return(Ok()); }
public async Task <IActionResult> ChangeEmail(ChangeEmailViewModel model) { _logger.Log(LogLevel.Debug, "AccountController::ChangeEmail"); if (ModelState.IsValid) { try { var credentials = new ChangeEmailModel( model.Email, model.NewEmail, HashUtils.Hash(model.Password)); await _client.SendRequestWithBodyAsync(HttpMethod.Put, "Account/UpdateEmail", credentials); await HttpContext.SignOutAsync(); var userDto = new AppUser { Email = model.NewEmail, Password = HashUtils.Hash(model.Password), }; await Login(userDto); TempData["message"] = "Your email has been changed."; if (_contextAccessor.HttpContext.User.IsInRole("Physician")) { return(RedirectToAction("PhysicianAccount")); } if (_contextAccessor.HttpContext.User.IsInRole("Receptionist")) { return(RedirectToAction("ReceptionistAccount")); } return(RedirectToAction("PatientAccount")); } catch (HttpRequestException ex) { if (ex.Message.Contains("Email \"" + model.NewEmail + "\" is already taken")) { ModelState.AddModelError("WrongCredential", _localizer["EmailExists"]); } else if (ex.Message.Contains("Password is incorrect")) { ModelState.AddModelError("WrongCredential", _localizer["WrongPassword"]); } else { ModelState.AddModelError("WrongCredential", _localizer["WrongCredentials"]); } } } return(View(model)); }
public ActionResult ChangeEmail(ChangeEmailModel model) { if (!User.Identity.IsAuthenticated) { return(Redirect("/")); } var profile = db.UserProfiles.First(p => p.UserName == User.Identity.Name); model.Email = profile.Email; return(View(model)); }
public HttpResponseMessage ChangeEmail(ChangeEmailModel model) { HttpResponseMessage resp = new HttpResponseMessage(); IEnumerable <User> users = this.usersManager.GetItems() as IEnumerable <User>; IEnumerable <Claim> claims = (HttpContext.Current.User as ClaimsPrincipal).Claims; string userEmail = claims.Where(c => c.Type == ClaimTypes.Email).Select(c => c.Value).FirstOrDefault(); if (!string.IsNullOrEmpty(userEmail)) { User user = users.Where(u => u.Email == userEmail).FirstOrDefault(); string hashedPassword = PasswordHelper.CreatePasswordHash(model.Password, user.Salt); if (user.HashedPassword == hashedPassword) { if (users.Where(u => u.Email == model.Email).FirstOrDefault() == null) { user.Email = model.Email; this.usersManager.UpdateItem(user); this.usersManager.SaveChanges(); resp.Content = new StringContent(JsonConvert.SerializeObject(new ChangeGeneralResponseViewModel() { IsSuccessful = true })); resp.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); } else { resp.Content = new StringContent(JsonConvert.SerializeObject(new ChangeGeneralResponseViewModel() { IsSuccessful = false, State = "existing_mail" })); resp.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); } } else { resp.Content = new StringContent(JsonConvert.SerializeObject(new ChangeGeneralResponseViewModel() { IsSuccessful = false, State = "incorrect_password" })); resp.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); } } return(resp); }
public object ChangeEmail(string passwordChangedBy, [FromBody] ChangeEmailModel model) { try { ApplicationUser userDetails = usersService.SingleOrDefault(model.ApplicationUserId, new ApplicationUser()); userDetails.UpdatedBy = passwordChangedBy; userDetails.ChangePassDt = DateTime.Now; return(usersService.UpdateEmail(passwordChangedBy, model)); } catch (Exception ex) { return(errorLogService.InsertToErrorLog(ex, MethodBase.GetCurrentMethod().Name, Request.Headers["UserInfo"].ToString())); } }
public async Task <ActionResult> ChangeEmail(ChangeEmailModel model) { var user = await UserManager.FindByIdAsync(model.UserId.ToString()); var token = await UserManager.GenerateChangeEmailTokenAsync(user, model.NewEmail); var result = await UserManager.ChangeEmailAsync(user, model.NewEmail, token); if (!result.Succeeded) { return(new ContentResult { Content = $"Ошибка!, {result}" }); } return(RedirectToUserDetails(model.UserId)); }
public async Task <ActionResult> ChangeEmail() { UserDTO userDTO = await AccountService.GetUser(User.Identity.GetUserId()); if (userDTO == null) { return(HttpNotFound()); } ChangeEmailModel model = new ChangeEmailModel { Email = userDTO.Email }; return(View(model)); }
public async Task <Result> ChangeEmailAsync(int id, ChangeEmailModel model) { var user = await _userRepository.GetUserByIdAsync(id); if (user == null) { return(Result.Fail(EC.UserNotFound, ET.UserNotFound)); } user.Email = model.NewEmail; user.EmailConfirmed = false; _userRepository.Put(user); await _unitOfWorks.CommitAsync(); return(Result.Ok()); }
public async Task <IActionResult> ChangeEmail(ChangeEmailModel changeEmailModel) { if (!ModelState.IsValid) { return(View()); } ApplicationUser loggedUser = await _userManager.FindByIdAsync(LoggedUserId); var token = await _userManager.GenerateChangeEmailTokenAsync(loggedUser, changeEmailModel.NewEmail); var confirmEmailLink = Url.Action(nameof(ConfirmChangeEmail), "Account", new { token, changeEmailModel.NewEmail }, Request.Scheme); var message = new Message(new string[] { changeEmailModel.NewEmail }, "Confirmation email link", confirmEmailLink); await _sendEmail.SendEmailAsync(message); return(RedirectToAction(nameof(CheckEmail))); }
public async Task <IActionResult> ChangeEmail(ChangeEmailModel Input) { var user = await _userManager.FindByIdAsync(Input.Id); if (user == null) { return(NotFound($"Unable to load user with ID '{Input.Id}'.")); } var email = await _userManager.GetEmailAsync(user); if (Input.NewEmail != email) { var userId = await _userManager.GetUserIdAsync(user); var code = await _userManager.GenerateChangeEmailTokenAsync(user, Input.NewEmail); // var callbackUrl = Url.Page( // "/Account/ConfirmEmailChange", // pageHandler: null, // values: new { userId = userId, email = Input.NewEmail, code = code }, // protocol: Request.Scheme); var callbackUrl = Url.Action("ConfirmEmail", "Account", values: new { userId = userId, email = Input.NewEmail, code = code }, protocol: Request.Scheme); _emailSender.SendEmail( Mail.DNR, Input.NewEmail, Input.NewEmail, "Confirm your email", $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>."); if (user == null) { return(NotFound($"Unable to load user with ID '{user.Id}'.")); } return(View(Input)); } return(View(Input)); }