public JsonResult ChangePassword(ChangePasswordInputModel inputModel)
{
try
{
Assert.ArgumentNotNull(inputModel, "ChangePasswordInputModel");
ChangePasswordBaseJsonResult result = new ChangePasswordBaseJsonResult();
this.ValidateModel(result);
if (result.HasErrors)
{
return(Json(result, JsonRequestBehavior.AllowGet));
}
var response = this.AccountManager.UpdateUserPassword(this.CurrentStorefront, this.CurrentVisitorContext, inputModel);
result = new ChangePasswordBaseJsonResult(response.ServiceProviderResult);
if (response.ServiceProviderResult.Success)
{
result.Initialize(this.CurrentVisitorContext.UserName);
}
return(Json(result));
}
catch (Exception e)
{
CommerceLog.Current.Error("ChangePassword", this, e);
return(Json(new BaseJsonResult("ChangePassword", e), JsonRequestBehavior.AllowGet));
}
}
public async Task <IActionResult> Post(ChangePasswordInputModel changePasswordInput)
{
var response = new Response();
if (!this.ModelState.IsValid)
{
response.Message = "Invalid data";
return(this.BadRequest(response));
}
if (changePasswordInput.Password != changePasswordInput.ConfirmPassword)
{
response.Message = "The new passwords don't match!";
return(this.BadRequest(response));
}
var userId = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
var success = await this.usersService.ChangePasswordAsync(userId, changePasswordInput.OldPassword, changePasswordInput.Password);
if (success)
{
response.Message = "Successfully updated password!";
}
else
{
response.Message = "The old password is incorrect!";
}
return(this.Ok(response));
}
public async Task <IActionResult> ChangePassword(ChangePasswordInputModel model)
{
if (ModelState.IsValid)
{
var user = await userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to find user. Please contact administrator."));
}
var changePasswordResult = await userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
if (!changePasswordResult.Succeeded)
{
foreach (var error in changePasswordResult.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(View("Index", await GetIndexViewModel()));
}
await signInManager.RefreshSignInAsync(user);
ViewData["change-password-message"] = "Password successfuly changed!";
return(View("Index", await GetIndexViewModel()));
}
return(View("Index", await GetIndexViewModel()));
}
public async Task <IActionResult> ChangePassword(ChangePasswordInputModel input)
{
if (!this.ModelState.IsValid)
{
return(this.View(input));
}
var user = await this.userManager.GetUserAsync(this.User);
if (user == null)
{
return(this.NotFound($"Unable to load user wid ID '{this.userManager.GetUserId(this.User)}'"));
}
var changePasswordResult =
await this.userManager.ChangePasswordAsync(user, input.OldPassword, input.NewPassword);
if (!changePasswordResult.Succeeded)
{
foreach (var error in changePasswordResult.Errors)
{
this.ModelState.AddModelError(error.Code, error.Description);
}
return(this.View(input));
}
await this.signInManager.RefreshSignInAsync(user);
return(this.RedirectToAction("Manage", "Account"));
}
public async Task <BaseModel> ChangePasswordAsync(string id, ChangePasswordInputModel model)
{
var user = await this.UserManager.FindByIdAsync(id);
if (user == null)
{
this.BaseModel.HasError = true;
this.BaseModel.Message = MessageConstants.InvalidUserId;
return(this.BaseModel);
}
var token = await this.UserManager.GeneratePasswordResetTokenAsync(user);
var result = await this.UserManager.ResetPasswordAsync(user, token, model.Password);
if (result.Succeeded)
{
this.BaseModel.HasError = false;
this.BaseModel.Message = MessageConstants.ChangePassword;
}
else
{
this.BaseModel.HasError = true;
this.BaseModel.Message = MessageConstants.NoChangePassword;
}
return(this.BaseModel);
}
public JsonResult ChangePassword(ChangePasswordInputModel inputModel)
{
try
{
Assert.ArgumentNotNull(inputModel, "ChangePasswordInputModel");
ChangePasswordBaseJsonResult result = new ChangePasswordBaseJsonResult();
this.ValidateModel(result);
if (result.HasErrors)
{
return(Json(result, JsonRequestBehavior.AllowGet));
}
result = _accountRepository.ChangePassword(inputModel);
return(Json(result));
}
catch (Exception e)
{
_logger.LogError("ChangePassword", this, e);
return(Json(new BaseJsonResult("ChangePassword", e), JsonRequestBehavior.AllowGet));
}
}
public async Task <IActionResult> Index(ChangePasswordInputModel model)
{
if (!ModelState.IsValid)
{
return(View(await BuildViewModel(model)));
}
var user = await _userManager.GetUserAsync(User);
IdentityResult result;
if (await _userManager.HasPasswordAsync(user))
{
result = await _userManager.ChangePasswordAsync(user, model.CurrentPassword, model.NewPassword);
}
else
{
result = await _userManager.AddPasswordAsync(user, model.CurrentPassword);
}
if (result.Succeeded)
{
AddSuccessMessage("Your password has been updated.");
}
else
{
foreach (var error in result.Errors)
{
AddFailureMessage(error.Description);
}
}
return(View(await BuildViewModel(model)));
}
public ActionResult Index(ChangePasswordInputModel model)
{
//if (!User.HasUserID())
//{
// return new HttpUnauthorizedResult();
//}
var _claimsID = new System.Security.Claims.ClaimsIdentity(User.Identity);
if (!_claimsID.HasClaim("sub"))
{
return new HttpUnauthorizedResult();
}
var acctID = System.Guid.Parse(_claimsID.Claims.GetValue("sub"));
if (ModelState.IsValid)
{
try
{
//this.userAccountService.ChangePassword(User.GetUserID(), model.OldPassword, model.NewPassword);
this.userAccountService.ChangePassword(acctID, model.OldPassword, model.NewPassword);
return View("Success");
}
catch (ValidationException ex)
{
ModelState.AddModelError("", ex.Message);
}
}
return View(model);
}
public async Task <IActionResult> ChangePassword([FromBody] ChangePasswordInputModel inputModel)
{
if (!ModelState.IsValid)
{
return(View(inputModel));
}
var user = await _userManager.GetUserAsync(HttpContext.User);
if (user == null)
{
return(View("Error"));
}
if (!await _userManager.HasPasswordAsync(user))
{
return(RedirectToRoute("AddPassword"));
}
var result = await _userManager.ChangePasswordAsync(user, inputModel.CurrentPassword, inputModel.NewPassword);
if (!result.Succeeded)
{
return(View("Error"));
}
await _signInManager.SignInAsync(user, false);
return(RedirectToRoute("Home", new { Message = "Your password has been changeed." }));
}
public IActionResult ChangePassword([Bind(Prefix = "Password")] ChangePasswordInputModel model)
{
if (!ModelState.IsValid)
{
return(CorrectErrors(BuildUserProfileModel(model), "password"));
}
try
{
var acct = _userAccountService.GetByID(User.GetId());
_userAccountService.ChangePassword(acct.ID, model.OldPassword, model.NewPassword);
return(RedirectToAction("Edit", new { changed = true }));
}
catch (AuthenticationException)
{
return(new HttpUnauthorizedResult());
}
catch (ValidationException ex) {
// this is more fragile than I'd like, but I don't see another way to check this exception's cause
if (ex.ValidationResult.ErrorMessage == "Invalid old password.")
{
ModelState.AddModelError("Password.OldPassword", ex.Message);
}
else
{
ModelState.AddModelError("Password.NewPassword", ex.Message);
ModelState.AddModelError("Password.NewPasswordConfirm", ex.Message);
}
}
return(CorrectErrors(BuildUserProfileModel(model), "password"));
}
private UserProfileModel BuildUserProfileModel(ChangePasswordInputModel passwordModel)
{
var profile = GetUserProfileModel();
profile.Password = passwordModel;
return(profile);
}
public async Task <IActionResult> UpdatePassword
([Bind(Prefix = nameof(UserDetailsViewModel.UserChangePassword))] ChangePasswordInputModel model, string id)
{
if (!ModelState.IsValid)
{
return(this.RedirectToAction(nameof(Details), new { id = id, tab = "1" }));
}
var result = await this.UserService.ChangePasswordAsync(id, model);
if (!result.HasError)
{
this.TempData.Put(MessageConstants.Name, new MessageModel()
{
Type = MessageType.Success,
Message = result.Message
});
}
else
{
this.TempData.Put(MessageConstants.Name, new MessageModel()
{
Type = MessageType.Danger,
Message = result.Message
});
}
return(RedirectToAction(nameof(Details), new { id = id }));
}
public ChangePasswordResponseModel ChangePasswordWithOldPassword(ChangePasswordInputModel data)
{
bool result = false;
string message = "Failed Change Password";
UserRepository repo = new UserRepository(DbContext);
var userInfo = repo.FindByID(data.UserID).FirstOrDefault();
ChangePasswordResponseModel res = new ChangePasswordResponseModel();
if (userInfo != null)
{
var response = repo.ChangePasswordWithOldPassword(userInfo.UserName, data.NewPassword.ConvertToMD5(), data.OldPassword.ConvertToMD5(), true);
if (response.Result)
{
ChangePasswordOutputModel resOut = new ChangePasswordOutputModel();
resOut.UserID = response.ID;
res.data = resOut;
}
result = response.Result;
message = response.Message;
}
res.Response = result;
res.Message = message;
return(res);
}
public JsonResult ChangePassword(ChangePasswordInputModel inputModel)
{
try
{
Assert.ArgumentNotNull(inputModel, nameof(inputModel));
var result = this.CreateJsonResult <ChangePasswordApiModel>();
if (result.HasErrors)
{
return(Json(result, JsonRequestBehavior.AllowGet));
}
var response = AccountManager.UpdateUserPassword(CommerceUserContext.Current.UserName, inputModel);
result = new ChangePasswordApiModel(response.ServiceProviderResult);
if (response.ServiceProviderResult.Success)
{
result.Initialize(CommerceUserContext.Current.UserName);
}
return(Json(result));
}
catch (Exception e)
{
return(Json(new ErrorApiModel("ChangePassword", e), JsonRequestBehavior.AllowGet));
}
}
public async Task <IActionResult> ChangePassword([FromBody] ChangePasswordInputModel model)
{
var user = await _userManager.FindByIdAsync(model.UserId);
if (user == null)
{
return(NotFound("Istifadeci tapilmadi"));
}
var token = await _userManager.GeneratePasswordResetTokenAsync(user);
if (token != null)
{
var result = await _userManager.ResetPasswordAsync(user, token, model.Password);
if (result.Succeeded)
{
return(Ok());
}
else
{
return(StatusCode(StatusCodes.Status500InternalServerError, new ResponseOutputModel {
Status = StatusCodes.Status500InternalServerError, Message = "Şifrə sıfırlanmadı.Şifrənizi kontrol edin"
}));
}
}
return(StatusCode(StatusCodes.Status500InternalServerError, new ResponseOutputModel {
Status = StatusCodes.Status500InternalServerError, Message = "Couldn't assign token"
}));
}
public ActionResult Change(string oldpassword, string newpassword, string renewpassword)
{
if (renewpassword == newpassword)
{
string userID = HttpContext.Session.GetString(SessionKeyID);
ChangePasswordInputModel data = new ChangePasswordInputModel();
data.UserID = Guid.Parse(userID);
data.OldPassword = oldpassword;
data.NewPassword = renewpassword;
JsonConvert.SerializeObject(data);
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(BaseAPI + "Profile/");
//HTTP POST
var postTask = client.PostAsJsonAsync <ChangePasswordInputModel>("ChangePassword", data);
postTask.Wait();
var result = postTask.Result;
if (result.IsSuccessStatusCode)
{
var datas = JsonConvert.DeserializeObject(result.Content.ReadAsStringAsync().Result);
if (datas.ToString().Contains("Gagal mengganti kata sandi."))
{
HttpContext.Session.SetString(SessionKeyCurrent, "true");
HttpContext.Session.SetString(SessionKeyError, "Gagal mengganti kata sandi.");
return(RedirectToAction("ChangePassword", "Profile"));
}
else
{
HttpContext.Session.SetString(SessionKeyID, "");
HttpContext.Session.SetString(SessionKeyName, "");
HttpContext.Session.SetString(SessionKeyRole, "");
//if (HttpContext.Session.GetString(Loginfrom) == "ADM/SPV")
//{
// return RedirectToAction("AdminLogon", "Login");
//}
//else if (HttpContext.Session.GetString(Loginfrom) == "MDO")
//{
// return RedirectToAction("OwnerLogon", "Login");
//}
//else
//{
// return RedirectToAction("OwnerLogon", "Login");
//}
return(RedirectToAction("Logon", "Login"));
}
}
}
HttpContext.Session.SetString(SessionKeyCurrent, "true");
HttpContext.Session.SetString(SessionKeyError, "Terjadi kesalahan. Mohon hubungi admin.");
return(RedirectToAction("ChangePassword", "Profile"));
}
else
{
HttpContext.Session.SetString(SessionKeyCurrent, "true");
HttpContext.Session.SetString(SessionKeyError, "New password is not same.");
return(RedirectToAction("ChangePassword", "Profile"));
}
}
public async Task <ActionResult> ChangePassword(
ChangePasswordInputModel input)
=> await this.identity.ChangePassword(new ChangePasswordInputModel
{
UserId = this.currentUser.UserId,
CurrentPassword = input.CurrentPassword,
NewPassword = input.NewPassword
});
public async Task <IActionResult> ChangePassword(ChangePasswordInputModel model)
{
var userId = User.GetAuthUserId();
await this.service.ChangePassword(userId, model);
return(this.Ok());
}
public async Task <ActionResult> ChangePassword(ChangePasswordInputModel input)
{
var result = await this.identity.ChangePassword(this.currentUser.UserId, new ChangePasswordInputModel
{
CurrentPassword = input.CurrentPassword,
NewPassword = input.NewPassword
});
return(result);
}
public async Task <IActionResult> ChangePasswordAsync([FromBody] ChangePasswordInputModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var result = await _userService.ChangePasswordAsync(model);
return(Ok(result));
}
public async Task ChangePassword([FromBody] ChangePasswordInputModel request)
{
if (!this.ModelState.IsValid)
{
throw new InvalidOperationException();
}
var user = await _userManager.FindByNameAsync(request.UserName);
await _userManager.ChangePasswordAsync(user, request.CurrentPassword, request.NewPassword);
}
public IActionResult ChangePassword()
{
var model = new ChangePasswordInputModel();
var claimsIdentity = User.Identity as ClaimsIdentity;
var username = claimsIdentity.Claims.Where(c => c.Type.Equals(ClaimTypes.Name));
if (username != null && username.Any())
{
model.Username = username.FirstOrDefault().Value;
}
return(View(model));
}
/// <summary>
/// Sets the change password.
/// </summary>
/// <param name="model">The model.</param>
/// <returns>
/// The <see cref="ActionResult" />.
/// </returns>
public ActionResult SetChangePassword(ChangePasswordInputModel model)
{
bool passwordChanged = false;
string error = string.Empty;
if (ModelState.IsValid)
{
try
{
this.Model.ChangePassword(SecurityManager.GetCurrentUserId(), model.OldPassword, model.NewPassword);
passwordChanged = true;
}
catch (Exception ex)
{
if (ex is ValidationFailedProviderException)
{
error = ex.Message;
}
else
{
error = Res.Get <ChangePasswordResources>().ChangePasswordGeneralErrorMessage;
}
}
}
else
{
try
{
error = Res.Get <ChangePasswordResources>().Get(this.Model.GetErrorFromViewModel(this.ModelState));
}
catch (KeyNotFoundException)
{
error = Res.Get <ChangePasswordResources>().ChangePasswordGeneralErrorMessage;
}
}
string redirectUrl = string.Empty;
if (passwordChanged && this.Model.ChangePasswordCompleteAction == ChangePasswordCompleteAction.RedirectToPage)
{
redirectUrl = this.Model.GetPageUrl(this.Model.ChangePasswordRedirectPageId);
}
else
{
error = HttpUtility.UrlEncode(error);
var pageUrl = this.Model.GetPageUrl(null);
var queryString = string.Format("?passwordChanged={0}&error={1}", passwordChanged, error);
redirectUrl = pageUrl + queryString;
}
return(this.Redirect(redirectUrl));
}
public ChangePasswordBaseJsonResult ChangePassword(ChangePasswordInputModel inputModel)
{
var response = this.AccountManager.UpdateUserPassword(this.CurrentStorefront, this.CurrentVisitorContext, inputModel);
var result = new ChangePasswordBaseJsonResult(response.ServiceProviderResult);
if (response.ServiceProviderResult.Success)
{
result.Initialize(this.CurrentVisitorContext.UserName);
}
return(result);
}
public async Task <IActionResult> ChangePassword(ChangePasswordInputModel input)
{
if (!this.ModelState.IsValid)
{
return(this.View(input));
}
var user = await this.userManager.GetUserAsync(this.User);
await this.userManager.ChangePasswordAsync(user, input.OldPassword, input.NewPassword);
return(this.RedirectToAction("MyAccount"));
}
public async Task <HttpResponseMessage> ChangePasswordAsync(ChangePasswordInputModel model)
{
using (var httpClient = new HttpClient())
{
string data = JsonConvert.SerializeObject(model);
var contentData = new StringContent(data, System.Text.Encoding.UTF8, "application/json");
HttpResponseMessage response = await httpClient.AddHeader()
.AddTokenToHeader(_loginManager.Token)
.PutAsync("/api/Account/ChangePassword", contentData);
return(response);
}
}
public async Task <IActionResult> Password()
{
ApplicationUser user = await _userManager.GetUserAsync(User);
ChangePasswordInputModel vm = new ChangePasswordInputModel {
};
vm.PasswordExists = (user.PasswordHash != null);
if (vm.PasswordExists != true)
{
vm.OldPassword = "******";
}
return(View(vm));
}
public ActionResult Index(ChangePasswordInputModel model)
{
if (ModelState.IsValid)
{
try
{
this.userAccountService.ChangePassword(User.GetUserID(), model.OldPassword, model.NewPassword);
return(View("Success"));
}
catch (ValidationException ex)
{
ModelState.AddModelError("", ex.Message);
}
}
return(View(model));
}
public void ChangePassword_Initialized_ShouldReturnUserName(Database db, IOrderManager orderManager, IContactFactory contactFactory)
{
// arrange
FakeSiteContext.Database = db;
Context.Items["__visitorContext"] = new MockVisitorContext("1", "fake", "1");
var rep = new AccountRepository(new MockAccountManager(), contactFactory, orderManager);
var model = new ChangePasswordInputModel {
OldPassword = "******", NewPassword = "******", ConfirmPassword = "******"
};
// act
var result = rep.ChangePassword(model);
// assert
result.UserName.ShouldBeEquivalentTo("fake");
result.Success.Should().BeTrue();
}
public ActionResult Change(ChangePasswordInputModel inputData)
{
string userID = HttpContext.Session.GetString(SessionKeyID);
ChangePasswordInputModel data = new ChangePasswordInputModel();
try
{
data = inputData;
data.UserID = Guid.Parse(userID);
JsonConvert.SerializeObject(data);
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(BaseAPI + "Profile/");
//HTTP POST
var postTask = client.PostAsJsonAsync <ChangePasswordInputModel>("ChangePassword", data);
postTask.Wait();
var result = postTask.Result;
if (result.IsSuccessStatusCode)
{
var datas = JsonConvert.DeserializeObject(result.Content.ReadAsStringAsync().Result);
if (datas.ToString().Contains("Gagal ganti password"))
{
HttpContext.Session.SetString(SessionKeyCurrent, "true");
HttpContext.Session.SetString(SessionKeyError, "Gagal ganti password.");
return(RedirectToAction("ChangePassword", "Profile"));
}
else
{
HttpContext.Session.SetString(SessionKeyID, "");
HttpContext.Session.SetString(SessionKeyName, "");
HttpContext.Session.SetString(SessionKeyRole, "");
return(RedirectToAction("Index", "Home"));
}
}
}
HttpContext.Session.SetString(SessionKeyCurrent, "true");
HttpContext.Session.SetString(SessionKeyError, "Terjadi kesalahan server. Hubungi admin.");
return(RedirectToAction("ChangePassword", "Profile"));
}
catch (Exception e)
{
ModelState.AddModelError(string.Empty, "Terjadi kesalahan server. Hubungi admin.");
return(RedirectToAction("ChangePassword", "Profile"));
}
}
private async Task <ChangePasswordViewModel> BuildViewModel(ChangePasswordInputModel model = null)
{
var user = await _userManager.GetUserAsync(User);
var vm = new ChangePasswordViewModel
{
NewPassword = model?.NewPassword,
NewPasswordConfirm = model?.NewPasswordConfirm,
HasPasswordSet = await _userManager.HasPasswordAsync(user)
};
if (!vm.HasPasswordSet)
{
throw new Exception("Not supported yet, until external logins are added.");
}
return(vm);
}
