public bool ChangePassword(int userId, UserChangePasswordModel model, out string error)
{
error = string.Empty;
if (!model.NewPassword1.Equals(model.NewPassword2))
{
error = "Password mismatch";
return(false);
}
using (var scope = this.ServiceProvider.CreateScope())
{
var db = scope.ServiceProvider.GetRequiredService <NervboxDBContext>();
var user = db.Users.Where(u => u.Id == userId).FirstOrDefault();
if (user == null)
{
error = "User not found";
return(false);
}
if (!user.Password.Equals(GetPasswordHash(model.OldPassword)))
{
error = "Wrong password";
return(false);
}
user.Password = GetPasswordHash(model.NewPassword1);
db.SaveChanges();
return(true);
}
}
public IActionResult ChangePassword(UserChangePasswordModel model)
{
var id = int.Parse(this.User.Identity.Name);
var result = _userService.ChangePassword(id, model, out string error);
return(Ok(new { Success = result, Error = error }));
}
public ActionResult ChangePassword(string email)
{
UserChangePasswordModel user = new UserChangePasswordModel();
user.Email = email;
return(View(user));
}
public ActionResult ChangePasswordSumit(UserChangePasswordModel user)
{
ViewBag.ErrorLogin = "";
HomeModel model = new HomeModel()
{
Email = user.Email,
Password = user.Password
};
if (user.Password == user.PasswordValidated)
{
UserModel userm = new UserModel
{
Password = user.Password,
Email = user.Email
};
bool valid;
using (UserDataAccess userDataAccess = new UserDataAccess())
{
valid = userDataAccess.UpdateUser(userm, 3);
}
ViewBag.Succefull = "Cambio exitoso";
return(View("Index", new HomeModel()));
}
else
{
UserChangePasswordModel user1 = new UserChangePasswordModel();
user1.Email = user.Email;
ViewBag.Error = "Las Contraseñas son distintas";
return(View("ChangePassword", user1));
}
}
public async Task <IHttpActionResult> ChangePassword(UserChangePasswordModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!User.Identity.IsAuthenticated)
{
return(Unauthorized());
}
model.UserName = User.Identity.Name;
var result = await _repo.ChangePassword(model);
IHttpActionResult errorResult = GetErrorResult(result);
if (errorResult != null)
{
return(errorResult);
}
DatabaseContext.Shared.Dispose();
return(Ok());
}
public async Task <dynamic> ChangePassword([FromBody] UserChangePasswordModel userChangePasswordModel)
{
string accessToken = Request.Headers[HeaderNames.Authorization];
string token = accessToken.Split("Bearer ")[1];
UserReadDTO userRead = TokenUtil.GetSubFromToken(token);
if (ModelState.IsValid)
{
Services.Entities.CustomResponse UpdatePassword_Task = await _userService.UpdatePassword(userRead.UserID, userChangePasswordModel.OldPassword, userChangePasswordModel.NewPassword);
return(new
{
status = UpdatePassword_Task.status,
code = 200,
message = UpdatePassword_Task.message
});
}
return(new
{
status = false,
code = ReturnCodes.DataUpdateFailed,
message = "Có Lỗi Xảy Ra Khi Cố Gắng Thay Đổi Mật Khẩu"
});
}
public Response <object> ChangePassword(UserChangePasswordModel _)
{
var user = _repository.GetUserByUsername(_contextAccessor.HttpContext.User.Identity.Name);
var userBefore = CloneObject.Clone(user);
//if (user.IdUserAuthorizationType != (int)UserAuthorizationTypeIds.SystemAccount)
//{
// _saveLog.LogInformation("User with Active Directory cannot change password from this system!");
// return new Response<object>(PublicResultStatusCodes.NotAllowedOperation);
//}
var checkPassword = HashHelper.Verify(user.SaltedPassword, user.Password, _.OldPassword);
if (checkPassword)
{
var hashHelper = new HashHelper(_.NewPassword);
user.Password = hashHelper.Hash;
user.SaltedPassword = hashHelper.Salt;
user.LatestPasswordChangeDate = DateTime.Now;
var serials = ConvertToBinaryHelper <User> .SerializeAndConvert(userBefore, user);
_generalUpdateService.UpdateAddLogDataChange(user, serials.Item1, serials.Item2);
return(new Response <object>(PublicResultStatusCodes.Done));
}
_saveLog.LogInformation("Password do not match with data in Database!");
return(new Response <object>(PublicResultStatusCodes.WrongOldPassword));
}
public async Task <bool> ChangePasswordAsync([FromRoute] string id, [FromBody] UserChangePasswordModel model)
{
//get user by id
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
throw new ArgumentException("用户不存在！");
}
var valid = await _userManager.CheckPasswordAsync(user, model.OldPassword);
if (!valid)
{
throw new ArgumentException("旧密码错误！");
}
var result = await _userManager.ChangePasswordAsync(user,
model.OldPassword,
model.NewPassword);
if (result.Succeeded)
{
return(true);
}
else
{
throw new ApplicationException(string.Join(", ", result.Errors.Select(x => x.Description)));
}
}
public async Task <IActionResult> ChangePassword(UserChangePasswordModel credentials)
{
CustomValidation();
var subjectId = User.GetSubjectId();
var storedUser = await _databaseContext.UserData.Include(u => u.ProfileImage)
.FirstOrDefaultAsync(UserIdPredicate(subjectId));
if (storedUser == null)
{
throw new HttpResponseException();
}
var isValid = _authService.ValidatePassword(credentials.OldPassword, storedUser.PasswordHash,
storedUser.PasswordSalt);
if (!isValid)
{
throw new HttpResponseException(new UserChangePasswordError("Invalid credentials"),
HttpStatusCode.BadRequest);
}
var newCredentials = _authService.CreateCredentials(credentials.Password);
storedUser.PasswordHash = newCredentials.Hash;
storedUser.PasswordSalt = newCredentials.Salt;
await _databaseContext.SaveChangesAsync();
await _userActivityService.CreateActivityAsync(UserActivityActionName.PasswordChange, storedUser.Id);
return(Ok());
}
public async Task Change_user_password_and_response_ok_status_code()
{
//Arrange
var user = AdminAreaDefaults.DefaultUser;
using var server = new TestServerBuilder()
.UseUsers(user)
.UseCustomAuth(AdminAreaDefaults.DefaultUser, AuthSettings.Roles.Supervisor)
.Build();
var client = server.CreateClient();
var changePasswordModel = new UserChangePasswordModel
{
Id = user.Id,
Password = "******",
ConfirmPassword = "******"
};
var changePasswordModelJsonStr = JsonConvert.SerializeObject(changePasswordModel);
//Act
var response = await client.PostAsync("api/admin/users/changePassword",
new StringContent(changePasswordModelJsonStr, Encoding.UTF8, "application/json"));
//Assert
response.EnsureSuccessStatusCode();
}
public async Task <ActionResult> ChangePassword(
[Bind(Prefix = nameof(UserChangePasswordViewModel.Model))][BindRequired]
UserChangePasswordModel model)
{
if (!ModelState.IsValid)
{
var user = await _userQueries.GetUserAsync(model.Id);
return(View(new UserChangePasswordViewModel(model, user?.Email)));
}
try
{
var command = _mapper.Map <UserChangePasswordModel, ChangeUserPasswordCommand>(model);
await _mediator.Send(command);
}
catch (UserNotFoundException ex)
{
return(this.StatusCodeView(HttpStatusCode.NotFound, ex.Message));
}
catch (UserUnableToChangeStateException ex)
{
return(this.StatusCodeView(HttpStatusCode.Forbidden, ex.Message));
}
return(RedirectToAction("Index"));
}
public IActionResult ChangePassword(UserChangePasswordModel model)
{
var user = this.Request.HttpContext.User;
this.UserDAO.UpdatePassword(user, model.CurrentPassword, model.NewPassword, model.ConfirmPassword);
return(Ok());
}
public async Task ChangePassword(UserChangePasswordModel model)
{
var item = await _repository.GetAsync(model.Id);
UserFactory.ChangePassword(model, item, _userId);
_repository.ChangePassword(item);
await _unitOfWork.SaveChangesAsync();
}
public async Task <ActionResult> ChangePassword(UserChangePasswordModel changePassword)
{
var response = await service.ChangePassword(changePassword, User.GetUserId());
if (response.status)
{
return(Ok(response));
}
return(BadRequest(response));
}
public async Task <IActionResult> ChangePassword(UserChangePasswordModel model)
{
model.UserName = User.Identity.Name;
var resut = await _userApiClient.ChangePassword(model);
if (resut)
{
return(RedirectToAction("Index", "Home"));
}
return(BadRequest("Doi mat khau khong thanh cong"));
}
public void ChangePass(int id, UserChangePasswordModel value)
{
string newSalt = AppHelper.CreateSaltKey(10);
string newPassword = AppHelper.EncryptText(value.Password.Trim(), newSalt);
var x = Load(id);
x.Salt = newSalt;
x.Password = newPassword;
x.LastUpdate = DateTime.UtcNow;
UpdateEntity(x);
}
public string ChangePassword([FromBody] UserChangePasswordModel user)
{
if (ModelState.IsValid)
{
var email = HttpContext.User.Claims.Where(context => context.Type == ClaimTypes.Email)
.Select(context => context.Value).SingleOrDefault();
var sessionUser = _repo.GetUserByEmail(email);
if (sessionUser.Id == user.Id)
{
return(_repo.ChangeUserPassword(user));
}
}
return("Failed to update password");
}
public string ChangePassword([FromBody] UserChangePasswordModel 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 void ChangePassword(UserChangePasswordModel model)
{
model.NewPassword = hashCryptoHelper.HashString(model.NewPassword);
model.OldPassword = hashCryptoHelper.HashString(model.OldPassword);
var userId = int.Parse(aesCryptoHelper.DecryptString(clientContextScraper.GetClientClaimsIdentityName()));
var userData = userDataRepository.FetchAll().Where(x => x.Id == userId && x.UserEmail == model.UserEmail && x.PassHash == model.OldPassword).FirstOrDefault();
userServiceValidationHelper.ValidateUserData(userData);
userData.PassHash = model.NewPassword;
userData.FailedLoginCount = 0;
userDataRepository.Update(userData);
userDataRepository.Save();
}
public async Task <IActionResult> UserChangePasswordAsync([FromBody] UserChangePasswordModel model)
{
User user = await _userService.FindUserAsync(model.email);
var result = await _userService.ChangeUserPasswordAsync(user,
model.password, model.newpassword);
string Data_Created = "";
if (result.Succeeded)
{
Data_Created = "Password changed successfully.";
return(Ok(Json(Data_Created)));
}
return(BadRequest(result.Errors.Select(s => s.Description).ToString()));
}
public async Task <IActionResult> ChangePass([FromBody] UserChangePasswordModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorList()));
}
try
{
await _manager.ChangePassword(model);
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
return(Ok());
}
public ActionResult ChangePassword(UserChangePasswordModel model)
{
if (ModelState.IsValid)
{
var user = _db.FindByName(model.UserName);
_db.RemovePassword(user.Id);
var result = _db.AddPassword(user.Id, model.Password);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
}
ModelState.AddModelError(string.Empty, AuthStrings.UnableToChangePassword);
return(View(model));
}
public ActionResult ChangePassword(UserChangePasswordModel user)
{
var ss = Session[Common.UserSession];
if (ss != null)
{
try
{
var uid = Int32.Parse(ss.ToString().Split('_')[0]);
using (var db = new FBLEntities())
{
var us = db.SystemUsers.FirstOrDefault(x =>
x.Id == uid);
if (us != null)
{
var isMatch = us.Password.Equals((user.OldPassword + us.Salt).ToSHA());
if (!isMatch)
{
ModelState.AddModelError("OldPassword", "Old password does not match.");
return(View());
}
if (ModelState.IsValid)
{
us.Password = (user.Password + us.Salt).ToSHA();
db.SaveChanges();
Extension.Notifications.AddNotification(this, "Your password has changed!", NotificationType.SUCCESS);
return(RedirectToAction("Index", "Home"));
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
return(View());
}
internal string ChangeUserPassword(UserChangePasswordModel 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("Umm nope!");
}
public string ChangeUserPassword(UserChangePasswordModel 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 rowsAffected = _db.Execute(@"
UPDATE users SET
password = @NewPassword
WHERE id = @id
", user);
return("Password successfully changed");
}
return("Unable to change password");
}
public async Task <IResponse> ChangePassword(UserChangePasswordModel changePassword, int loggedInUser)
{
var result = await userManager.FindByIdAsync(loggedInUser + "");
if (result != null)
{
var isChanged = await userManager.ChangePasswordAsync(result, changePassword.OldPassword, changePassword.NewPassword);
if (!isChanged.Succeeded)
{
response.status = false;
response.error_EN = "Old Password Incorrect";
}
}
else
{
response.error_EN = "User Doesn't Exist";
response.status = false;
}
return(response);
}
public HttpResponseMessage ChangePasswordOfUser(
[FromBody] UserChangePasswordModel model, [FromUri] string sessionKey)
{
var responseMsg = this.PerformOperationAndHandleExceptions(() =>
{
var user = this.GetUserBySessionKey(sessionKey);
string userOldAuthCode = user.AuthCode;
this.ValidateAuthCodesMatch(userOldAuthCode, model.OldAuthCode);
this.ValidateAuthCodesMatch(model.NewAuthCode, model.ConfirmNewAuthCode);
this.ValidateAuthCode(model.NewAuthCode);
user.AuthCode = model.NewAuthCode;
this.db.Users.Update(user);
this.db.SaveChanges();
var response = this.Request.CreateResponse(HttpStatusCode.Created);
return(response);
});
return(responseMsg);
}
public async Task <ActionResult> ChangePassword(UserChangePasswordModel model)
{
if (!ModelState.IsValid)
{
return(ValidationProblem());
}
try
{
var command = _mapper.Map <UserChangePasswordModel, ChangeUserPasswordCommand>(model);
await _mediator.Send(command);
}
catch (UserNotFoundException ex)
{
return(NotFound(ex.Message));
}
catch (UserUnableToChangeStateException ex)
{
return(Conflict(ex.Message));
}
return(Ok());
}
public ActionResult SaveUpdatePassword(UserChangePasswordModel user)
{
if (ModelState.IsValid)
{
if (user.Id == Guid.Empty)
{
return(View("UserProfile"));
}
var person = Repository.Data.Get <Person>(user.Id);
if (person.Validate(user.OldPassword))
{
person.SetPassword(user.Password);
ActionHelper.TryExecute(() => Repository.Data.Save(person), ModelState);
}
else
{
ModelState.AddModelError("LoginFailed", WebStroreResource.LoginFailed);
}
}
ViewBag.Message = WebStroreResource.PasswordChangedSuccessful;
return(View("ChangePassword"));
}
public async Task <bool> ChangePassword(UserChangePasswordModel model)
{
var client = _httpClientFactory.CreateClient();
client.BaseAddress = new Uri(_configuration["BaseAddress"]);
var sessions = _httpContextAccessor.HttpContext.Session.GetString("Token");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", sessions);
var json = JsonConvert.SerializeObject(model);
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PutAsync($"/api/user/changePassword", httpContent);
var result = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <bool>(result));
}
return(JsonConvert.DeserializeObject <bool>(result));
}
