public async Task ChangePassword(int id, ChangeUserPasswordModel model)
{
var user = Get(id);
user.Password = model.Password.WithBCrypt();
await _uow.CommitAsync();
}
public async Task <IActionResult> ChangePassword(ChangeUserPasswordModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
}
var changePasswordResult = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
if (!changePasswordResult.Succeeded)
{
AddErrors(changePasswordResult);
return(View(model));
}
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation("User changed their password successfully.");
StatusMessage = "Your password has been changed.";
return(RedirectToAction(nameof(ChangePassword)));
}
public IActionResult ChangeUserPassword(long id)
{
var model = new ChangeUserPasswordModel {
UserId = id
};
return(View(model));
}
public IHttpActionResult ChangePassword(long id, [FromBody] ChangeUserPasswordModel model)
{
using (var t = Repository.BeginTransaction())
{
var user = UserService.ChangePassword(id, model.CurrentPassword, model.NewPassword);
t.Commit();
return(Json(user));
}
}
public async Task <IActionResult> ChangeUserPassword([FromBody] ChangeUserPasswordModel changeUserPasswordModel)
{
return(await OnActionWorkAsync(async() =>
{
await _userService.ChangeUserPassword(changeUserPasswordModel);
return Ok();
}));
}
public string ChangePassword([FromBody] ChangeUserPasswordModel userData)
{
if (ModelState.IsValid)
{
var id = HttpContext.User.Claims.Where(c => c.Type == ClaimTypes.Name)
.Select(c => c.Value).SingleOrDefault();
UserReturnModel user = _repo.GetUserById(id);
return(_repo.ChangeUserPassword(userData));
}
return("Invalid Creds");
}
public string ChangePassword([FromBody] ChangeUserPasswordModel user)
{
if (ModelState.IsValid)
{
var email = HttpContext.User.Claims.Where(c => c.Type == ClaimTypes.Email).Select(c => c.Value).SingleOrDefault();
var sessionUser = _db.GetUserByEmail(email);
if (sessionUser.Id == user.Id)
{
return(_db.ChangeUserPassword(user));
}
}
return("How you do what you do?");
}
public string ChangePassword([FromBody] ChangeUserPasswordModel user)
{
if (ModelState.IsValid)
{
var id = HttpContext.User.Claims.Where(c => c.Type == ClaimTypes.Name)
.Select(c => c.Value).SingleOrDefault();
var sessionUser = _db.GetUserById(id);
if (sessionUser.Id == user.Id)
{
return(_db.ChangeUserPassword(user));
}
}
return("How did you even get here?");
}
public ActionResult ChangeUserPassword(ChangeUserPasswordModel model, Guid userId)
{
if (ModelState.IsValid)
{
MembershipUser usr = Membership.GetUser(userId);
usr.ChangePassword(usr.ResetPassword(), model.Password);
Membership.UpdateUser(usr);
return(RedirectToAction("UserList"));
}
UserInfo nfo = db.UserInfos.Single(p => p.UserId == userId);
GetOrgPosInfo(nfo);
return(View(model));
}
public ActionResult ChangeUserPassword(Guid userId)
{
UserInfo nfo = db.UserInfos.Single(p => p.UserId == userId);
ChangeUserPasswordModel model = new ChangeUserPasswordModel();
model.UserName = nfo.AspNetUser.UserName;
model.FullName = nfo.FullName;
model.JobTitle = nfo.JobTitle;
model.IsRCP = nfo.IsRiskOwner;
var usr = db.AspNetUsers.Single(u => u.Id == userId.ToString());
model.Email = usr.Email;
GetOrgPosInfo(nfo);
return(View(model));
}
public ActionResult ChangeUserPassword(ChangeUserPasswordModel model, Guid userId)
{
if (ModelState.IsValid)
{
var usr = db.AspNetUsers.Single(u => u.Id == userId.ToString());
usr.PasswordHash = (new PasswordHasher()).HashPassword(model.Password);
db.SaveChanges();
return(RedirectToAction("Index"));
}
UserInfo nfo = db.UserInfos.Single(p => p.UserId == userId);
GetOrgPosInfo(nfo);
return(View(model));
}
/// <inheritdoc/>
public async Task ChangeUserPasswordAsync(Guid id, ChangeUserPasswordModel model, CancellationToken cancellationToken)
{
using (var scope = _serviceProvider.CreateScope())
using (var context = scope.ServiceProvider.GetRequiredService <DatabaseContext>())
{
var user = await context.Users.FirstOrDefaultAsync(x => x.Id == id, cancellationToken).ConfigureAwait(false);
if (user == null)
{
throw new ArgumentException("User not found");
}
user.Password = _cryptoProvider.EncodeValue(model.NewPassword);
await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
}
}
public async Task ChangePasswordShouldCallUserQueryWithCurrentUser()
{
var user = new User { Id = _random.Next() };
_context.SetupGet(x => x.User).Returns(user);
var requestModel = new ChangeUserPasswordModel
{
Password = _random.Next().ToString()
};
_userQueryProcessor.Setup(x => x.ChangePassword(user.Id, requestModel))
.Returns(Task.FromResult(0))
.Verifiable();
await _query.ChangePassword(requestModel);
_userQueryProcessor.Verify();
}
public async Task <IActionResult> PostChangePasswordAsync(Guid userId, [FromBody] ChangeUserPasswordModel changeUserPasswordModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var identityName = (User.Identity as ClaimsIdentity).Claims.FirstOrDefault(en => en.Type == ClaimTypes.NameIdentifier)?.Value;
if (identityName == null || !Guid.TryParse(identityName, out var currentUserId))
{
return(Unauthorized());
}
var currentUser = await userRepository.FindByUserIdAsync(new UserId(currentUserId));
var commandResult = await commandDispatcher.PostAsync <ChangeUserPasswordCommand, bool>(new ChangeUserPasswordCommand(new UserId(userId), changeUserPasswordModel.Password), currentUser);
return(ResultHelper.HandleResult(commandResult, failureMessageService));
}
/// <summary>
/// Changes the password.
/// </summary>
/// <param name="changeUserPasswordModel">The change password model.</param>
/// <returns>
/// <see cref="Task" />
/// </returns>
public async Task ChangeUserPassword(ChangeUserPasswordModel changeUserPasswordModel)
{
var user = await _userManager.FindByIdAsync(changeUserPasswordModel.Id);
if (user == null)
{
throw new NotFoundException();
}
var result =
await _passwordValidator.ValidateAsync(_userManager, user, changeUserPasswordModel.NewPassword);
result.Verify();
result = await _userManager.ChangePasswordAsync(user, changeUserPasswordModel.CurrentPassword,
changeUserPasswordModel.NewPassword);
result.Verify();
}
internal string ChangeUserPassword(ChangeUserPasswordModel user)
{
User savedUser = _db.QueryFirstOrDefault <User>(@"
SELECT * FROM users WHERE id = @Id
", user);
var valid = BCrypt.Net.BCrypt.Verify(user.OldPassword, savedUser.Password);
if (valid)
{
user.NewPassword = BCrypt.Net.BCrypt.HashPassword(user.NewPassword);
var i = _db.Execute(@"
UPDATE users SET
password = @NewPassword
Where id = @Id
", user);
return("Password Changed Successfully");
}
return("Password Change Unsuccessful, Please try again");
}
public string ChangeUserPassword(ChangeUserPasswordModel user)
{
User savedUser = _db.QueryFirstOrDefault <User>(@"
SELECT * FROM users WHERE id = @id
", user);
var valid = BCrypt.Net.BCrypt.Verify(user.OldPassword, savedUser.Password);
if (valid)
{
user.NewPassword = BCrypt.Net.BCrypt.HashPassword(user.NewPassword);
var i = _db.Execute(@"
UPDATE users SET
password = @NewPassword
WHERE id = @id
", user);
return("Good Job!");
}
return("Ummm Nope!");
}
public async Task <IActionResult> ChangeUserPassword(ChangeUserPasswordModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
User user = await _userManager.FindByIdAsync(model.UserId.ToString());
if (user == null)
{
return(UserNotFound());
}
await _userManager.RemovePasswordAsync(user);
await _userManager.AddPasswordAsync(user, model.Password);
return(RedirectToAction("Index", new { msg = "Пароль изменен" }));
}
internal string ChangeUserPassword(ChangeUserPasswordModel user)
{
User savedUser = _db.QueryFirstOrDefault <User>(@"
SELECT * FROM users WHERE id = @id
", user);
var valid = BCrypt.Net.BCrypt.Verify(user.OldPassword, savedUser.Password);
if (valid)
{
user.NewPassword = BCrypt.Net.BCrypt.HashPassword(user.NewPassword);
var i = _db.Execute(@"
UPDATE users SET
password = @NewPassword
WHERE id = @id
", user);
return("You've changed your password!");
}
return("No bueno Julio!");
}
internal string ChangeUserPassword(ChangeUserPasswordModel user)
{
User savedUser = _db.QueryFirstOrDefault <User>(@"
SELECT * FROM users WHERE id = @id
", user);
var valid = BCrypt.Net.BCrypt.Verify(user.OldPassword, savedUser.Password);
if (valid)
{
user.NewPassword = BCrypt.Net.BCrypt.HashPassword(user.NewPassword);
var i = _db.Execute(@"
UPDATE users SET
password = @NewPassword
WHERE id = @id
", user);
return("Successfully Changed Password");
}
return("Unable to Set New Password");
}
public async Task <HttpResponseMessage> UpdatePassword(ChangeUserPasswordModel model)
{
try
{
bool result = await userService.UpdatePasswordAsync(model.UserId, model.OldPassword, model.NewPassword);
if (result)
{
return(Request.CreateResponse(HttpStatusCode.OK, "Password updated."));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Update failed."));
}
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
public async Task <BaseApiResponse> ChangePasswordAsync(ChangeUserPasswordModel model, UserManager <ApplicationUser> userManager, SignInManager <ApplicationUser> signInManager)
{
if (!IsAuthenticated)
{
return(new BaseApiResponse(false, ValidationMessages.YouAreNotAuthorized));
}
var validation = ValidateModel(model);
if (!validation.IsSucceeded)
{
return(validation);
}
if (model.NewPassword == model.OldPassword)
{
return(new BaseApiResponse(false, "Новый и старый пароль совпадют"));
}
var user = await userManager.FindByIdAsync(UserId);
if (user == null)
{
return(new BaseApiResponse(false, "Пользователь не найден по указанному идентификатору"));
}
var result = await userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
if (!result.Succeeded)
{
return(new BaseApiResponse(false, "Неправильно указан старый пароль"));
}
if (user != null)
{
await signInManager.SignInAsync(user, true);
}
return(new BaseApiResponse(true, "Ваш пароль изменен"));
}
public async Task <IActionResult> ChangePassword()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
}
var hasPassword = await _userManager.HasPasswordAsync(user);
if (!hasPassword)
{
return(RedirectToAction(nameof(SetPassword)));
}
var model = new ChangeUserPasswordModel {
StatusMessage = StatusMessage
};
return(View(model));
}
public async Task ChangePasswordShouldCallUserQueryWithCurrentUserAsync()
{
// arrange
var user = new UserEntity {
Id = Guid.NewGuid()
};
_securityContextMock.SetupGet(x => x.UserEntity).Returns(user);
var model = new ChangeUserPasswordModel {
Password = _random.Next().ToString()
};
_userQueryProcessorMock.Setup(x => x.ChangePassword(user.Id, model))
.Returns(Task.FromResult(0))
.Verifiable();
// act
await _accountQueryProcessor.ChangePassword(model);
// assert
_userQueryProcessorMock.Verify();
}
public async Task ChangePassword([FromBody] ChangeUserPasswordModel requestModel)
{
await _query.ChangePassword(requestModel);
}
public IActionResult ChangeUserPassword(ChangeUserPasswordModel model)
{
_userService.ChangeUserPassword(CurrentUserId, model.OldPassword, model.NewPassword);
return(Ok());
}
public IActionResult ChangePassword([FromBody] ChangeUserPasswordModel model)
{
_accountQuery.ChangePassword(model);
return(Ok());
}
public async Task ChangePassword(ChangeUserPasswordModel requestModel)
{
await _usersQuery.ChangePassword(_context.User.ID, requestModel);
}
/// <summary>
/// Updates user passowrd
/// </summary>
/// <param name="userId">user id</param>
/// <param name="oldPassword">old password</param>
/// <param name="newPassword">new password</param>
/// <returns>True is success</returns>
public async Task<bool> UpdatePasswordAsync(string userId, string oldPassword, string newPassword)
{
try
{
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Put, url + "UpdatePassword/" + userId);
// Content and authorization
ChangeUserPasswordModel modelToSend = new ChangeUserPasswordModel(oldPassword, newPassword);
string toSend = JsonConvert.SerializeObject(modelToSend);
request.Content = new StringContent(toSend, Encoding.UTF8, "application/json");
request.Headers.Add("Authorization", "Bearer " + GameStore.WindowsApp.Common.UserInfo.Token);
// Response
HttpResponseMessage response = await client.SendAsync(request);
if (response.IsSuccessStatusCode)
return true;
else
return false;
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IActionResult> ChangeUserPassword(Guid userId, ChangeUserPasswordModel model)
{
if (!await UserExists(userId))
{
return(NotFound());
}
const string actionViewPath = ViewsDirectoryPath + nameof(ChangeUserPassword) + ".cshtml";
var currentUserId = new Guid(_userManager.GetUserId(HttpContext.User));
if (!await _databaseContext.UserPermissionsOperator.GetUserDataEditPermissionAsync(userId, currentUserId))
{
return(Forbid());
}
model.UserId = userId;
if (!ModelState.IsValid)
{
return(View(actionViewPath));
}
var userObject = await _userManager.FindByIdAsync(userId.ToString());
if (userId == currentUserId)
{
if (string.IsNullOrWhiteSpace(model.OldPassword))
{
ModelState.AddModelError(
nameof(ChangeUserPasswordModel.OldPassword),
_localizer["Ви маєте вказати свій попередній пароль!"]
);
return(View(actionViewPath));
}
if (!await _userManager.CheckPasswordAsync(userObject, model.OldPassword))
{
ModelState.AddModelError(
nameof(ChangeUserPasswordModel.OldPassword),
_localizer["Ви ввели неправильний пароль від свого облікового запису!"]
);
return(View(actionViewPath));
}
}
var identityResult = await _userManager.ResetPasswordAsync(
userObject,
await _userManager.GeneratePasswordResetTokenAsync(userObject),
model.NewPassword
);
if (identityResult.Succeeded)
{
return(RedirectToAction("UserProfile", "Users", new { area = "Social", userId }));
}
foreach (var identityError in identityResult.Errors)
{
ModelState.AddModelError(string.Empty, $"Error #{identityError.Code}: {identityError.Description}");
}
return(View(actionViewPath, model));
}
public async Task <IActionResult> ChangeUserPassword(ChangeUserPasswordModel model)
{
await _UserService.ChangeUserPassword(CurrentUserId, model.OldPassword, model.NewPassword);
return(Ok());
}
public async Task<HttpResponseMessage> UpdatePassword(string id,ChangeUserPasswordModel model)
{
try
{
bool result = await userService.UpdatePasswordAsync(id, model.OldPassword, model.NewPassword);
if (result)
{
return Request.CreateResponse(HttpStatusCode.OK, "Password updated.");
}
else
{
return Request.CreateResponse(HttpStatusCode.BadRequest, "Update failed.");
}
}
catch (Exception ex)
{
return Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message);
}
}
