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.",
}
);
}
