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());
}
