public async Task changing_existing_user_password_with_token_should_return_nocontent() { var email = "*****@*****.**"; var password = "******"; var user = await GetUserAsync(email); var token = await GetTokenAsync(email, password); var newPassword = "******"; var command = new ChangeUserPassword { UserId = user.Id, CurrentPassword = user.Password, NewPassword = newPassword }; var payload = GetPayload(command); var request = CreateRequest("http://localhost:5000/users/password", payload, new Dictionary <string, string> { { "Authorization", $"Bearer {token}" }, { "Content-type", $"application/json" } } ); var response = await request.SendAsync("PUT"); response.StatusCode.ShouldBeEquivalentTo(HttpStatusCode.NoContent); }
public async Task <IActionResult> PutAsync(ChangeUserPassword command) { await CommandDispatcher.DispatchAsync(command); // Http status code 204: NoContent // Request successfully processed by the server; no returning content. return(NoContent()); }
public IHttpActionResult Put([FromBody] ChangeUserPassword changeUserPassword) { var script = _powershellScriptLoader.LoadScript(PowershellScripts.ChangeUserPassword); _powerShellManager.AttachParameters(changeUserPassword.MapPropertiesToActiveDirectoryParameters()); _powerShellManager.ExecuteScript(script); return(Ok()); }
public ReturnValues ChangePassword(ChangeUserPassword obj) { try { ReturnValues result = null; if (obj != null) { using (RepsistoryEF <UserRegister> _o = new RepsistoryEF <UserRegister>()) { var resultValue = _o.GetListBySelector(z => z.RegistrationID == obj.RegistrationID).FirstOrDefault(); if (resultValue != null) { if (resultValue.Password == obj.OldPassword) { resultValue.Password = obj.NewPassword; _o.Update(resultValue); result = new ReturnValues { Success = "Password Changed Successfully", Source = resultValue.RegistrationID.ToString(), }; } else { result = new ReturnValues { Success = "Old password is not correct.<br/>Please try again.", Source = resultValue.RegistrationID.ToString(), }; } } else { result = new ReturnValues { Success = "Password could not be changed.", Source = "0", }; } } } return(result); } catch (Exception ex) { ReturnValues objex = new ReturnValues { Failure = ex.Message, }; throw ex; } finally { } }
public virtual JsonResult ChangeUserPassword(ChangeUserPassword model) { ModelState.Remove("U"); ModelState.Remove("C"); if (!ModelState.IsValid) { return(Json(new { Message = LocalMessage.ValidationFailed, IsSuccessful = false })); } return(Json(_userBusiness.ChangeUserPassword(model.UserId, model.Password))); }
public async Task <IActionResult> ChangePassword([FromBody] ChangeUserPassword changePassword) { if (!ModelState.IsValid) { return(BadRequest()); } await _userService.ChangePassword(GetCurrentUserId(), changePassword.OldPassword, changePassword.NewPassword); return(Ok()); }
public async Task <IActionResult> ChangePassword([FromBody] ChangeUserPassword command) { var response = await _mediator.Send(command); if (response.HasMessages) { return(BadRequest(response.Messages)); } return(Ok(response.Value)); }
public async Task given_valid_current_and_new_password_it_should_change() { var command = new ChangeUserPassword { CurrentPassword = "******", NewPassword = "******" }; var payload = GetPayload(command); var response = await Client.PutAsync("account/password", payload); response.StatusCode.Should().BeEquivalentTo(HttpStatusCode.NoContent); }
public async Task ChangeUserPassword_ValidCurrentPassword_Changed() { var command = new ChangeUserPassword() { CurrentPassword = "******", NewPassword = "******" }; var payload = GetPayload(command); var response = await Client.PutAsync("account/password", payload); Assert.AreEqual(System.Net.HttpStatusCode.NoContent, response.StatusCode); }
public async Task Given_valid_current_and_new_password_it_should_be_changed() { var command = new ChangeUserPassword { CurrentPassword = "******", NewPassword = "******", }; var payload = GetPayload(command); var response = await Client.PutAsync("account/password", payload); response.StatusCode.CompareTo(HttpStatusCode.NoContent); }
public async Task given_valid_current_and_new_password_it_should_be_changed() { var command = new ChangeUserPassword { CurrentPassword = "******", NewPassword = "******" }; var payload = GetPayload(command); var response = await client.PostAsync("accounts/password", payload); Assert.Equal(HttpStatusCode.NoContent, response.StatusCode); }
/// <summary> /// Перегруженный метод заменяет пароль в xml. /// </summary> /// <param name="password"></param> public void SaveUserPasswordToXml(ChangeUserPassword password) { XDocument xDocPassword = new XDocument(); XElement root = new XElement("password"); root.Add(new XElement("pass", new XAttribute("value", password.Password), new XElement("secret", password.NewSecretWord))); xDocPassword.Add(root); xDocPassword.Save("UserPassword.xml"); xmlPasswordDb = xDocPassword; }
public async Task GivenValidCurrentAndNewPasswordItShouldBeChanged() { var command = new ChangeUserPassword { OldPassword = "******", NewPassword = "******" }; var payload = Payload(command); var response = await Client.PutAsync("useraccount/password", payload); response.StatusCode.ShouldBeEquivalentTo(HttpStatusCode.NoContent); }
public async Task GivenValidCurrentAndNewPasswordItShouldBeChanged() { var command = new ChangeUserPassword { CurrentPassword = "******", NewPassword = "******" }; var payload = GetPayload(command); var response = await Client.PutAsync("account/password", payload); Assert.AreEqual(HttpStatusCode.NoContent, response.StatusCode); }
public async Task given_Valid_password_should_be_change() { var request = new ChangeUserPassword { CurrentPassword = "******", NewPassword = "******" }; var payload = GetPayLoad(request); var response = await Client.PutAsync("password", payload); response.StatusCode.Equals(HttpStatusCode.NoContent); }
public int ChangeUserPassword(ChangeUserPassword changeUserPassword) { Query = "UPDATE UserAccounts SET Password = @newPassword WHERE UserId = @userId AND Password = @oldPassword"; Command = new SqlCommand(Query, Connection); Command.Parameters.AddWithValue("newPassword", changeUserPassword.NewPassword); Command.Parameters.AddWithValue("userId", changeUserPassword.UserId); Command.Parameters.AddWithValue("oldPassword", changeUserPassword.OldPassword); Connection.Open(); int rowAffected = Command.ExecuteNonQuery(); Connection.Close(); return(rowAffected); }
public async Task given_valid_current_and_new_password_it_should_be_changed() { var request = new ChangeUserPassword { CurrentPassword = "******", NewPassword = "******" }; var payload = GetPayload(request); // Act var response = await Client.PutAsync("account/password", payload); response.StatusCode.ShouldBeEquivalentTo(HttpStatusCode.NoContent); }
protected async Task given_valid_current_and_new_password_id_should_be_changed() { // act var command = new ChangeUserPassword() { CurrentPassword = "******", NewPassword = "******" }; var payload = GetPayload(command); var response = await Client.PutAsync($"account/password", payload); // Assert response.StatusCode.ShouldBeEquivalentTo(HttpStatusCode.NoContent); }
public async Task <IActionResult> ChangePassword([FromBody] ChangeUserPassword model) { if (!ModelState.IsValid) { return(NotFound()); } var result = await _identityService.ChangePasswordAsync(model); if (result.Succeeded) { return(Ok(result)); } return(BadRequest(result)); }
public async Task changing_existing_user_password_without_token_should_return_unauthorized() { var user = await GetUserAsync("*****@*****.**"); var newPassword = "******"; var command = new ChangeUserPassword { UserId = user.Id, CurrentPassword = user.Password, NewPassword = newPassword }; var payload = GetPayload(command); var response = await Client.PutAsync($"users/password", payload); response.StatusCode.ShouldBeEquivalentTo(HttpStatusCode.Unauthorized); }
public async Task <Result> ChangePasswordAsync(ChangeUserPassword model) { if (model.OldPassword == model.NewPassword) { return(Result.GeneralFailure("Your New Password Can't Be The Same As The Old Password")); } var user = await _userManager.FindByIdAsync(model.userId); var result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword); if (result.Succeeded) { return(Result.Success("Password Changed Successfully")); } return(Result.Failure(result.Errors.Select(x => x.Description))); }
public async Task successful_change_of_user_password() { // Arrange ChangeUserPassword command = new ChangeUserPassword() { CurrentPassword = "******", NewPassword = "******" }; // Act HttpContent payload = GetSerializedPayload(command); HttpResponseMessage response = await Client.PutAsync("account/password", payload); // Assert //response.EnsureSuccessStatusCode(); response.StatusCode.Should().BeEquivalentTo(HttpStatusCode.NoContent); }
public async Task given_valid_current_password_and_new_password_it_should_be_changed() { var command = new ChangeUserPassword { CurrentPassword = "******", NewPassword = "******" }; Client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", AuthToken); var payload = GetPayload(command); payload.Headers.TryAddWithoutValidation("Authorization", "Bearer " + AuthToken); var response = await Client.PutAsync("account/password", payload); response.Headers.Add("Authorization", "Bearer " + AuthToken); response.StatusCode.Should().BeEquivalentTo(HttpStatusCode.NoContent); }
public async Task given_nonexistent_email_current_password_should_not_be_changed_and_user_should_not_exist() { var email = "*****@*****.**"; var request = new ChangeUserPassword() { Email = email, NewPassword = "******" }; var payload = GetPayload(request); var response = await Client.PutAsync("api/account", payload); response.StatusCode.Should().BeEquivalentTo(HttpStatusCode.NoContent); response = await Client.GetAsync($"api/users/{email}"); response.StatusCode.Should().BeEquivalentTo(HttpStatusCode.NotFound); }
public ActionResult ChangePassword(ChangeUserPassword changeUserPassword) { if (User.IsInRole("User")) { changeUserPassword.UserId = GetUserData().UserId; changeUserPassword.NewPassword = Crypto.Hash(changeUserPassword.NewPassword); changeUserPassword.OldPassword = Crypto.Hash(changeUserPassword.OldPassword); string message = aUserManager.ChangeUserPassword(changeUserPassword); if (message == "Success") { ViewBag.Message = "Your password has changed successfully"; } else { ViewBag.ErrorMessage = message; } } ViewBag.GetName = GetUserData().Name; return(View()); }
public async Task <IActionResult> EditUserPassword(ChangeUserPassword userPassword) { if (!ModelState.IsValid) { ModelState.AddModelError(string.Empty, "Please fill all fields."); return(View(userPassword)); } if (userPassword.OldPassword == userPassword.NewPassword) { ModelState.AddModelError(userPassword.OldPassword, "Unexpected error occurred: The new and old password cannot match."); return(View(userPassword)); } var user = await _userManager.FindByIdAsync(userPassword.UserId); if (user == null) { ModelState.AddModelError(string.Empty, $"Unexpected error occurred: Could not find user with ID: {userPassword.UserId}."); return(NotFound(ModelState)); } var result = await _userManager.ChangePasswordAsync(user, userPassword.OldPassword, userPassword.NewPassword); if (result.Succeeded) { return(RedirectToAction(nameof(Profile), "Account", new { email = user.Email })); } else { foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } return(View(userPassword)); } }
public string ChangeUserPassword(ChangeUserPassword changeUserPassword) { bool validOldPassword = aUserGateway.IsUserOldPasswordValid(changeUserPassword.UserId, changeUserPassword.OldPassword); if (validOldPassword) { int rowAffected = aUserGateway.ChangeUserPassword(changeUserPassword); if (rowAffected > 0) { return("Success"); } else { return("Your password changing failed."); } } else { return("Your given old password is wrong. Please try again!"); } }
public ActionResult ChangePassword(ChangeUserPassword model) { if (!ModelState.IsValid) { return(View(model)); } var result = actions.ChangePassowrd(User.Identity.GetUserId(), model.OldPassword, model.NewPassword); if (result.Succeeded) { TempData["PasswordChanged"] = true; return(RedirectToAction("Index", "User")); } else { foreach (var error in result.Errors) { ModelState.AddModelError("", error); } return(View(model)); } }
public async Task <IActionResult> Put([FromBody] ChangeUserPassword command) { await CommandDispather.DispathAsync(command); return(NoContent()); }
public async Task <IActionResult> Put(ChangeUserPassword command) { await DispatchAsync(command); return(NoContent()); }