public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword); if (!result.Succeeded) { return(GetErrorResult(result)); } return(Ok()); }
public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { //return BadRequest(ModelState); return(BadRequest("Two password are not same !")); } IdentityResult result = await this.AppUserManager .ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword); if (!result.Succeeded) { //return GetErrorResult(result); return(BadRequest("Old Password is not correct !")); } return(Ok()); }
public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), Codec.DecryptStringAES(model.OldPassword), Codec.DecryptStringAES(model.NewPassword)); IHttpActionResult errorResult = GetErrorResult(result); if (errorResult != null) { return(errorResult); } return(Ok()); }
public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { //var user = await this.AppUserManager.FindByIdAsync(model.UserId); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var token = await this.AppUserManager.GeneratePasswordResetTokenAsync(model.UserId); var result = await this.AppUserManager.ResetPasswordAsync(model.UserId, token, model.NewPassword); if (!result.Succeeded) { return(GetErrorResult(result)); } return(Ok()); }
private void ValidateMenu(ChangePasswordBindingModel menu) { if (string.IsNullOrEmpty(menu.OldPassword)) { ModelState.AddModelError("OldPassword", "Bắt buộc nhập mật khẩu cũ"); ModelState.AddModelError("OldPassword", "has-error"); } if (string.IsNullOrEmpty(menu.NewPassword)) { ModelState.AddModelError("NewPassword", "Bắt buộc nhập mật khẩu mới"); ModelState.AddModelError("NewPassword", "has-error"); } if (string.IsNullOrEmpty(menu.ConfirmPassword)) { ModelState.AddModelError("ConfirmPassword", "Vui lòng nhập xác nhận mật khẩu mới"); ModelState.AddModelError("ConfirmPassword", "has-error"); } }
public async Task <IActionResult> ChangePassword() { var user = await this.CheckUser(); var hasPassword = await this.userManager .HasPasswordAsync(user); if (!hasPassword) { return(this.RedirectToAction(nameof(this.SetPassword))); } var model = new ChangePasswordBindingModel { StatusMessage = this.StatusMessage }; return(this.View(model)); }
public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId <int>(), model.OldPassword, model.NewPassword); if (!result.Succeeded) { ModelState.AddModelError("model.OldPassword", "Incorrect Password."); return(BadRequest(ModelState)); } return(Ok()); }
public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } string userId = UserManager.FindByName(model.Email)?.Id; // User.Identity.GetUserId() vraca null.. ovo gore vrati userId koji je potreban u ChangePasswordAsync IdentityResult result = await UserManager.ChangePasswordAsync(userId, model.OldPassword, model.NewPassword); if (!result.Succeeded) { return(GetErrorResult(result)); } return(Ok()); }
public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var id = IdentityExtensions.GetUserId(User.Identity); IdentityResult result = await UserManager.ChangePasswordAsync(IdentityExtensions.GetUserId(User.Identity), model.OldPassword, model.NewPassword); IHttpActionResult errorResult = GetErrorResult(result); if (errorResult != null) { return(errorResult); } return(Ok()); }
public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (!HasPassword()) { return(BadRequest()); } var result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword); var errorResult = GetErrorResult(result); return(errorResult ?? Ok()); }
public async Task <IActionResult> ChangePasswordAsync([FromBody] ChangePasswordBindingModel collection) { Log.Debug($"ChangePassword => {JsonConvert.SerializeObject(collection)}"); try { if (string.IsNullOrEmpty(collection?.Password) || string.IsNullOrEmpty(collection.NewPassword) || string.IsNullOrEmpty(collection.ConfirmPassword)) { return(BadRequest(_localizer[DataTransferer.DefectivePassword().Message])); } if (collection.NewPassword != collection.ConfirmPassword) { return(BadRequest(_localizer[DataTransferer.PasswordsMissmatch().Message])); } var account = await _accountService.FirstAsync(new AccountGetFirstSchema { Id = CurrentAccount.Id }).ConfigureAwait(true); if (account == null) { return(BadRequest(_localizer[DataTransferer.UserNotFound().Message])); } if (_cryptograph.IsEqual(collection.Password, account.Password)) { await _accountService.UpdateAsync(new AccountUpdateSchema { Id = account.Id.Value, Password = _cryptograph.RNG(collection.NewPassword) }).ConfigureAwait(false); return(Ok(_localizer[DataTransferer.PasswordChanged().Message])); } else { return(Unauthorized(_localizer[DataTransferer.WrongPassword().Message])); } } catch (Exception ex) { Log.Error(ex, ex.Source); return(Problem(_localizer[DataTransferer.SomethingWentWrong().Message])); } }
public async Task <IActionResult> ChangePassword(ChangePasswordBindingModel model, string id) { var user = this.userService.GetUserById(id); if (!this.ModelState.IsValid) { return(this.View(model)); } if (user == null || model == null) { return(base.ErrorPage()); } var resetToken = await this.userManager.GeneratePasswordResetTokenAsync(user); IdentityResult passwordChangeResult = await this.userManager.ResetPasswordAsync(user, resetToken, model.Password); return(RedirectToAction("All", "Users", new { message = $"Password for {user.Email} successfully changed!" })); }
public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } IdentityResult result = await IdentityManager.Passwords.ChangePasswordAsync(User.Identity.GetUserName(), model.OldPassword, model.NewPassword); IHttpActionResult errorResult = GetErrorResult(result); if (errorResult != null) { return(errorResult); } return(Ok()); }
public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return(BadRequest("Password is not match")); } IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword); if (!result.Succeeded) { return(BadRequest("Internal Server Problem")); } AuditTrialReport.SaveAuditReport(User.Identity.Name, "Change Password", null, null); return(Ok("Password change successfull")); }
public async Task <ResultObj> ChangePassword(ChangePasswordBindingModel model) { try { if (!ModelState.IsValid) { return(WebHelpers.ProcessException(ModelState.Values)); } var result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword); return(!result.Succeeded ? WebHelpers.ProcessException(result) : WebHelpers.BuildResponse(model, "Password changed sucessfully.", true, 1)); } catch (Exception exception) { return(WebHelpers.ProcessException(exception)); } }
public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid || model == null) { string messages = string.Join(" ", ModelState.Values .SelectMany(x => x.Errors) .Select(x => x.ErrorMessage).FirstOrDefault()); return(BadRequest(messages)); } IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword); if (!result.Succeeded) { return(BadRequest(result.Errors.ToList()[0])); } return(Ok(new { status = "success" })); }
public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var userId = User.Identity.GetUserId(); IdentityResult result = await AppUserManager.ChangePasswordAsync(userId, model.OldPassword, model.NewPassword); if (!result.Succeeded) { return(GetErrorResult(result)); } await AppUserManager.SendEmailAsync(userId, "Password Change", "Your password has been changed"); return(Ok()); }
public async Task <bool> ChangePassword(string oldPW, string newPW, string conPW) { var client = new HttpClient(); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", Settings.AccessToken); var model = new ChangePasswordBindingModel() { OldPassword = oldPW, NewPassword = newPW, ConfirmPassword = conPW }; var json = JsonConvert.SerializeObject(model); HttpContent content = new StringContent(json); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); var response = await client.PostAsync("https://asestudyhelper.azurewebsites.net/api/Account/ChangePassword", content); return(response.IsSuccessStatusCode); }
public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { System.Diagnostics.Debug.WriteLine("\n\nU change password"); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } System.Diagnostics.Debug.WriteLine("\n\nModel state valid"); IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword); System.Diagnostics.Debug.WriteLine("\n\nStvoren identity result"); if (!result.Succeeded) { return(GetErrorResult(result)); } return(Ok()); }
public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (!await IdentityStore.ValidateLocalLogin(User.Identity.GetUserName(), model.OldPassword)) { return(BadRequest("The current password is incorrect.")); } if (!await IdentityStore.Context.Secrets.Update(User.Identity.GetUserName(), model.NewPassword)) { return(BadRequest("The new password is invalid.")); } await IdentityStore.Context.SaveChanges(); return(OK()); }
public async Task <IHttpActionResult> ChangeUserPassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return(this.BadRequest(this.ModelState)); } IdentityResult result = await this.UserManager.ChangePasswordAsync( this.idProvider.GetId(), model.OldPassword, model.NewPassword); if (!result.Succeeded) { return(this.GetErrorResult(result)); } return(this.Ok( new { message = "Password changed successfully.", } )); }
public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword); if (!result.Succeeded) { return(GetErrorResult(result)); } var user = UserManager.FindById(User.Identity.GetUserId()); user.EmailConfirmed = true; UserManager.Update(user); return(Ok()); }
public async Task<IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!this.ModelState.IsValid) { return this.BadRequest(this.ModelState); } var changePasswordResult = await this.UserManager.ChangePasswordAsync( this.User.Identity.GetUserId(), model.OldPassword, model.NewPassword); if (!changePasswordResult.Succeeded) { return this.GetErrorResult(changePasswordResult); } return this.Ok(new { message = "Password changed successfully." }); }
public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId <long>(), model.oldpassword, model.newpassword); if (!result.Succeeded) { return(GetErrorResult(result)); } var user = await UserManager.FindByIdAsync(User.Identity.GetUserId <int>()); user = UserManager2.Update(user); return(Ok()); }
public async Task <ActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return(HttpNotFound()); } UserManager.RemovePassword(model.UserId); IdentityResult result = await UserManager.AddPasswordAsync(model.UserId, model.NewPassword); //IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword); if (!result.Succeeded) { return(View("Error")); } Logger.Info("Изменен пароль пользователя. UserId = {0}", model.UserId); TempData["Result"] = "Пароль успешно изменен."; return(RedirectToAction("ChangePassword", "Account")); }
public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var u = UserManager.FindByEmail(model.Email); if (u != null) { IdentityResult result = await UserManager.ChangePasswordAsync(u.Id, model.OldPassword, model.NewPassword); if (!result.Succeeded) { return(Json(new { success = false, cause = "Invalid password provided" })); } return(Json(new { success = true })); } return(Json(new { success = false, cause = "Invalid user / password provided" })); }
public async Task <IActionResult> ChangePassword([FromBody] ChangePasswordBindingModel model) { var user = await GetCurrentUserAsync(); if (user == null) { return(this.BadRequest()); } if (model.NewPassword != model.ConfirmPassword) { return(BadRequest(new ErrorResponse(Application.ErrorCode.PasswordsDoNotMatch, "Passwords do not match."))); } var result = await this.userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword); if (result.Succeeded) { await signInManager.SignInAsync(user, isPersistent : false); } return(this.CheckResult(result)); }
public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { ModelState.AddModelError("Message", "The data provided is invalid!"); return(BadRequest(ModelState)); } IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword); if (!result.Succeeded) { ModelState.AddModelError("Message", "The old password is invalid!"); return(BadRequest(ModelState)); } // if all good ApplicationUserListDTO trader = new ApplicationUserListDTO(); trader = ((OkNegotiatedContentResult <ApplicationUserListDTO>)GetTraderByTraderId(User.Identity.GetUserId())).Content; return(Ok <ApplicationUserListDTO>(trader)); }
public async Task <HttpResponseMessage> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)); } IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword); if (!result.Succeeded) { ApplicationResult applicationResult = new ApplicationResult(); applicationResult.Status.IsError = true; applicationResult.Status.ErrorMessage = string.Format("Change Password Failed"); return(Request.CreateResponse <ApplicationResult>(HttpStatusCode.ExpectationFailed, applicationResult)); } return(Request.CreateResponse <ApplicationResult>(HttpStatusCode.OK, new ApplicationResult() { Result = 0 })); }
public async Task <IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword); emailService = DIContainerST.GetInstance().Resolve <IEmailService>(); var id = RequestContext.Principal.Identity.GetUserId(); string email = UserManager.GetEmail(id); if (result.Succeeded) { emailService.SendEmail(email, Const.EmailChangePasswordSubject, Const.EmailChangePasswordBody); } else { return(GetErrorResult(result)); } return(Ok()); }
public async Task<IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return BadRequest(ModelState); } IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword); if (!result.Succeeded) { return GetErrorResult(result); } return Ok(); }
public async Task<HttpResponseMessage> ChangePassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { var errors = ModelState.Keys.SelectMany(k => ModelState[k].Errors).Select(m => m.ErrorMessage).ToArray(); return Request.CreateResponse(HttpStatusCode.BadRequest, errors); } IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId<int>(), model.OldPassword, model.NewPassword); if (!result.Succeeded) { return Request.CreateResponse(HttpStatusCode.BadRequest, result.Errors.ToArray()); } return Request.CreateResponse(HttpStatusCode.OK); }
public async Task<IHttpActionResult> ChangeUserPassword(ChangePasswordBindingModel model) { if (!this.ModelState.IsValid) { return this.BadRequest(this.ModelState); } if (this.User.Identity.GetUserName() == "admin") { return this.BadRequest("Password change for user 'admin' is not allowed!"); } var result = await this.UserManager.ChangePasswordAsync( this.User.Identity.GetUserId(), model.OldPassword, model.NewPassword); if (!result.Succeeded) { return this.GetErrorResult(result); } return this.Ok( new { message = "Password successfully changed.", } ); }
public async Task<IHttpActionResult> ChangeProfilePassword(ChangePasswordBindingModel passChangeBindingModel) { var userPassword = this.User.Identity.GetUserId(); if (!this.ModelState.IsValid) { return this.BadRequest(this.ModelState); } var result = await this.UserManager.ChangePasswordAsync( userPassword, passChangeBindingModel.OldPassword, passChangeBindingModel.NewPassword); if (!result.Succeeded) { return this.GetErrorResult(result); } return this.Ok(new { message = PasswordChangedSuccessfullyMessage }); }
public async Task<IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!this.ModelState.IsValid) { return this.BadRequest(this.ModelState); } var result = await this.UserManager.ChangePasswordAsync( this.User.Identity.GetUserId(), model.OldPassword, model.NewPassword); return result.Succeeded ? this.Ok() : this.GetErrorResult(result); }
public async Task<IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { if (!this.ModelState.IsValid) { return this.BadRequest(ModelState); } IdentityResult result = await this.UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword); if (!result.Succeeded) { return this.GetErrorResult(result); } return this.Ok(new { Message = "Password changed" }); }
public async Task<IHttpActionResult> ChangePassword(ChangePasswordBindingModel model) { try { if (!ModelState.IsValid) { return BadRequest(ModelState); } var tokenObj = new ParsedTokenHelper().GetParsedToken(Request.Properties); IdentityResult result = await UserManager.ChangePasswordAsync(tokenObj.UserId, model.OldPassword, model.NewPassword); IHttpActionResult errorResult = GetErrorResult(result); if (errorResult != null) { return errorResult; } return Ok(); } catch (BankClientException ex) { return BadRequest(ex.Message); } catch (Exception ex) { return InternalServerError(ex); } }
public async Task<IHttpActionResult> ChangeUserPassword(ChangePasswordBindingModel model) { if (!ModelState.IsValid) { return this.BadRequest(this.ModelState); } IdentityResult result = await this.UserManager.ChangePasswordAsync( this.idProvider.GetId(), model.OldPassword, model.NewPassword); if (!result.Succeeded) { return this.GetErrorResult(result); } return this.Ok( new { message = "Password changed successfully.", } ); }