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