public void UpdatePassword(UserResetPasswordRequest model)
{
Action <SqlParameterCollection> inputMapper = delegate(SqlParameterCollection parameters)
{
string salt;
string passwordHash;
PasswordHasher(model.Password, out salt, out passwordHash);
parameters.AddWithValue("@Password", passwordHash);
parameters.AddWithValue("@Id", model.Id);
parameters.AddWithValue("@Salt", salt);
};
Action <SqlParameterCollection> returnMapper = delegate(SqlParameterCollection parameters)
{
};
DataProvider.ExecuteNonQuery(
GetConnection,
"dbo.Users_UpdatePasswordSalt",
inputMapper,
returnMapper);
}
public async Task <IWrappedResponse> ResetPassword(UserResetPasswordRequest request)
{
var cmd = ServiceCommand <User, Rules.User.ResetPassword.MainRule>
.Create(_serviceProvider)
.When(new Rules.User.ResetPassword.MainRule(request))
.Then(ResetPasswordAction);
return(await cmd.Execute());
}
public async Task <ActionResult <UserResetPasswordResult> > PostResetPassword([FromRoute] int id)
{
var request = new UserResetPasswordRequest()
{
UserId = id
};
return(await this._userService.ResetPassword(request).Convert <UserResetPasswordResult>(this));
}
public async Task <Response> ResetPassword(UserResetPasswordRequest request)
{
var user = await _uow.Users.GetUser(request.Email);
if (user == null)
{
return(new Response <UserResponse>(ResponseStatus.NotFound, null, ResponseMessagesConstans.NotFound));
}
var emailResult = await _mailingLibrary.SendResetPasswordEmail(user);
if (!emailResult)
{
return(new Response <UserResponse>(ResponseStatus.InternalError, null, ResponseMessagesConstans.EmailCannotBeSend));
}
return(new Response(ResponseStatus.Ok));
}
public async Task <IActionResult> ResetPassword([FromBody] UserResetPasswordRequest request)
{
var authenticationResult = await _identityService.ResetPasswordAsync(request.Email, request.NewPassword, request.Code);
if (!authenticationResult.IsSuccessful)
{
return(BadRequest(new AuthFailedResponse
{
Errors = authenticationResult.Errors
}));
}
// UNDONE: send mail with token here
return(Ok(new AuthSuccessfulResponse
{
Token = authenticationResult.Token,
Message = "New password successfully accepted." // UNDONE: RazorViewEngine + SendGrid
}));
}
public async Task <IActionResult> RequestResetPassword([FromBody] UserResetPasswordRequest userResetPassword)
{
var user = await _userManager.FindByIdAsync(userResetPassword.UserId);
var resToken = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(userResetPassword.ResetToken));
var res = await _userManager.ResetPasswordAsync(user,
resToken, userResetPassword.NewPassword);
if (!res.Succeeded)
{
return(BadRequest(new ActionResponse
{
Errors = res.Errors.Select(x => x.Description).ToList(),
Success = false
}));
}
return(Ok());
}
public async Task <ActionResult <int> > ResetPassword(int id, [FromBody] UserResetPasswordRequest request)
{
var user = await _context
.Users
.AsNoTracking()
.FirstOrDefaultAsync(u => u.UserId == id);
if (user != null)
{
var salt = SaltGenerator.MakeSalty();
var newHash = await HashService.HashPassword(request.Password, salt);
var newUser = user with {
Password = newHash, Salt = salt
};
_context.Users.Update(newUser);
await _context.SaveChangesAsync();
return(new OkResult());
}
return(new BadRequestResult());
}
public async Task <IHttpActionResult> ResetPassword([FromBody] UserResetPasswordRequest request)
{
var response = await _userService.ResetPassword(request);
return(new CreateResult(response));
}
public MainRule(UserResetPasswordRequest request, IRule parentRule = null)
{
// Create Context
Context = new ContextModel(request, this);
ParentRule = parentRule;
}
