public async Task <IActionResult> ForgotPassword([FromBody] ForgotPasswordCommand request) { if (this.User.Identity.IsAuthenticated) { return(this.BadRequest()); } try { var requestResult = await this.Mediator.Send(request); if (requestResult.Succeeded) { return(this.Ok()); } else { await this.Logger.LogErrorAsync(new ArgumentException($"Invalid email ({request.Email}) from reset password form.")); return(this.Ok()); } } catch (ValidationException ex) { this.ModelState.ApplyValidationException(ex); } catch (Exception) { this.ModelState.AddModelError(string.Empty, Messages.YourRequestCannotBeExecuted); } return(this.BadRequestWithModelErrors()); }
public async Task <IActionResult> ForgotPassword(ForgotPasswordCommand request) { if (this.User.Identity.IsAuthenticated) { return(this.RedirectToHomeIndex()); } try { var result = await this.Mediator.Send(request); if (!result.Succeeded) { await this.Logger.LogErrorAsync(new ArgumentException($"Invalid email ({request.Email}) from reset password form.")); } return(await this.RedirectToSucceededExecutionResultAsync( Titles.ForgotPasswordSuccess, Messages.ForgotPasswordSuccessMessage, "forgot-password")); } catch (ValidationException ex) { this.ModelState.ApplyValidationException(ex); } catch (Exception) { this.ModelState.AddModelError(string.Empty, Messages.YourPasswordCannotBeReset); } return(this.ForgotPasswordView(request)); }
public ICommandResult Handle(ForgotPasswordCommand command) { // Fail Fast Validation command.Validate(); if (command.Invalid) { return(new GenericCommandResult(false, "Não foi possível lembrar a senha!", command.Notifications)); } var user = _userRepository.GetByEmail(command.Email); if (user == null) { return(new GenericCommandResult(false, "Não foi possível lembrar a senha, e-mail não existente!", command.Notifications)); } var passwordDecrypt = _encryption.Decrypt(user.Password); // Envio do email _email.Send("*****@*****.**", user.Email, "Solicitação de Senha", "sua senha é " + passwordDecrypt); IList <object> objReturnPassword = new List <object>() { new { nome = "FAKE: Senha enviada no email informado.", value = passwordDecrypt } }; return(new GenericCommandResult(true, "Senha recuperada com sucesso", objReturnPassword)); }
public async Task <ICommandResult> Handler(ForgotPasswordCommand command) { try { User user = await _service.GetByEmailAsync(command.Email); if (user == null) { return(new CommandResult(false, Messages.USER_NOT_FOUND, null)); } string token = await _service.ForgotPasswordAsync(user); string message = await _service.CreateMessageForgotPassword(user.Email, token); SmtpStatusCode status = await _service.SendAsync(user.Email, message, "Reset Password"); if (status == SmtpStatusCode.GeneralFailure) { return(new CommandResult(false, Messages.FORGOT_PASSWORD_FAILED, null)); } return(new CommandResult(true, Messages.FORGOT_PASSWORD_SUCCESS, null)); } catch (Exception ex) { throw new Exception(ex.Message); } }
public void ForgotPassword(ForgotPasswordCommand command) { var user = UserRepository.GetByEmail(command.Email); AssertConcern.AssertArgumentNotNull(user, "Usuário não encontrado"); var passwordKey = UserService.GeneratePasswordKey(user); UserRepository.SavePasswordKey(user.UserId, passwordKey); var sB = new StringBuilder(); sB.Append("Olá, <br/>").AppendLine() .Append(" Para recuperar a senha utilize esse código: <br/>").AppendLine() .Append($"<p> <strong>{passwordKey}</strong> </p> ").AppendLine() .Append("<br/>").AppendLine() .Append("Atenciosamente, <br/>").AppendLine() .Append("Equipe SexMove"); var emailService = new EmailService(); emailService.SendEmail(sB.ToString(), "SexMove - Recuperar senha", user.Email); Uow.Commit(); }
public void EmptyOrNullEmail_ShouldHaveError(string email) { var command = new ForgotPasswordCommand { Email = email }; _sut.ShouldHaveValidationErrorFor(x => x.Email, command); }
public async Task WhenISubmitAForgotPasswordRequestWithAnInvalidEmail(string email) { _command = new ForgotPasswordCommand { Email = email }; _response = await _client.PostAsync(BaseUrl, Utilities.GetRequestContent(_command)); }
public async Task WhenISubmitAForgotPasswordRequestWithAnUnknownEmail() { _command = new ForgotPasswordCommand { Email = "*****@*****.**" }; _response = await _client.PostAsync(BaseUrl, Utilities.GetRequestContent(_command)); }
public async Task WhenISubmitAForgotPasswordRequest() { _command = new ForgotPasswordCommand { Email = _user.Email }; _response = await _client.PostAsync(BaseUrl, Utilities.GetRequestContent(_command)); }
public void ValidLoginAndPassword_ShouldNotHaveErrors() { var command = new ForgotPasswordCommand { Email = "*****@*****.**" }; _sut.ShouldNotHaveValidationErrorFor(x => x.Email, command); }
public void InvalidEmail_ShouldHaveError() { var command = new ForgotPasswordCommand { Email = "invalidEmail" }; _sut.ShouldHaveValidationErrorFor(x => x.Email, command); }
public async Task <IActionResult> ForgotPassword(ForgotPasswordRequest request, CancellationToken cancellationToken) { var command = new ForgotPasswordCommand { Email = request.Email }; var result = await _mediator.Send(command, cancellationToken); return(this.GetResponseFromResult(result)); }
public async Task <IActionResult> RequestResetPasswordForTheCurrentUser() { var currentUser = await this.currentUserProvider.GetCurrentUserAsync(); var request = new ForgotPasswordCommand { Email = currentUser.Email, }; return(this.Ok(await this.Mediator.Send(request))); }
public async Task <IActionResult> ForgotPassword([FromBody] ForgotPasswordCommand command) { if (!ModelState.IsValid) { return(BadRequest()); } await _userService.ForgotPasswordAsync(command); return(Ok(ResponseDto.Default)); }
public IActionResult ForgotPassword() { if (this.User.Identity.IsAuthenticated) { return(this.RedirectToHomeIndex()); } var request = new ForgotPasswordCommand(); return(this.ForgotPasswordView(request)); }
public async Task <IActionResult> ForgotPassword(string email) { var command = new ForgotPasswordCommand() { Email = email.ToLower().Trim() }; await _mediator.Send(command); return(Ok()); }
public async Task <IActionResult> ForgotPassword([FromBody] ForgotPasswordCommand forgotPassword) { var result = await Mediator.Send(forgotPassword); if (result.Success) { return(Ok(result)); } return(BadRequest(result)); }
public async Task <IActionResult> ForgotPassword([FromForm] ForgotPasswordCommand command) { var result = await _handler.Handler(command); if (result.Succeeded) { result.Message = _localizer["FORGOT_PASSWORD_SUCCESS"].Value; return(Ok(result)); } result.Message = _localizer["FORGOT_PASSWORD_FAILED"].Value; return(BadRequest(result)); }
public Task <bool> Handle(ForgotPasswordCommand request, CancellationToken cancellationToken) { var user = _context.Users.FirstOrDefault(x => x.Email == request.MailAddress); if (user == null) { throw new UserNotFoundException(); } user.CreateForgotPassword(); return(Task.FromResult(true)); }
public async Task <IActionResult> ForgotPassword([FromBody] ForgotPasswordViewModel viewModel) { var command = new ForgotPasswordCommand(viewModel); var result = await mediator.Send(command); if (!String.IsNullOrEmpty(result)) // to be refactored into command handler { var passwordResetLink = Url.Action("ResetPassword", "Recovery", new { email = viewModel.Email, token = result }, Request.Scheme); } return(Ok(result)); }
public void SetUp() { _service = new Mock <IForgotPasswordService>(); _unitOfWork = new Mock <IUnitOfWork>(); _sut = new ForgotPasswordCommandHandler(_service.Object, _unitOfWork.Object); _command = new ForgotPasswordCommand { Email = "email" }; _user = new User("email", "organizationId"); _service.Setup(x => x.GetUserFromRepo(_command.Email, default)) .ReturnsAsync(_user); }
public async Task <ActionResult> ForgotPassword(ForgotPasswordCommand command) { if (ModelState.IsValid) { var user = await signInManager.UserManager.FindByNameAsync(command.Email); if (user == null || !(await signInManager.UserManager.IsEmailConfirmedAsync(user.Id))) { return(View("ForgotPasswordConfirmation")); } } return(View(command)); }
public async Task <ApiResponse> ForgottenPassword([FromBody] ForgotPasswordCommand command) { var commandResponse = await this._forgotPasswordCommandHandler.Handle(command); if (commandResponse.ValidationResult.IsValid) { var response = ApiResponse.CreateSuccess(null); return(response); } else { return(ApiResponse.CreateError(commandResponse.ValidationResult)); } }
public async Task Handler_ForgotPassword() { var user = DataHelper.GetUser("test"); _userRepository. Setup(x => x.GetAsync(It.IsAny <Expression <Func <User, bool> > >())).Returns(() => Task.FromResult(user)); forgotPasswordCommand = new ForgotPasswordCommand { Email = user.Email, TCKimlikNo = Convert.ToString(user.CitizenId) }; var result = await forgotPasswordCommandHandler.Handle(forgotPasswordCommand, new System.Threading.CancellationToken()); Assert.That(result.Success, Is.True); }
public async Task Handler_ForgotPassword() { var user = DataHelper.GetUser("test"); _userRepository.Setup(x => x.GetAsync(It.IsAny <Expression <Func <User, bool> > >())) .Returns(() => Task.FromResult(user)); _forgotPasswordCommand = new ForgotPasswordCommand { Email = user.Email, TcKimlikNo = Convert.ToString(user.CitizenId) }; var result = await _forgotPasswordCommandHandler.Handle(_forgotPasswordCommand, new CancellationToken()); result.Success.Should().BeTrue(); }
public async Task <IActionResult> ForgotPassword([FromBody] ForgotPasswordCommand command) { if (!ModelState.IsValid) { return(ErrorModelResult()); } try { var result = await _commandDispatcher.DispatchAsync <ForgotPasswordCommand, Result>(command); return(ToResult(result)); } catch (FailureResult reqEx) { return(ErrorResult(reqEx)); } }
public void Handle(ForgotPasswordCommand command) { if (!IsValidEmail(command.Email)) { throw new ServerSideException("Email format is invalid"); } using (var dbContext = new UserAccountDataContext()) { var user = dbContext.Users.SingleOrDefault(u => u.Email == command.Email); if (user == null) { throw new ServerSideException( String.Format("User with email: {0} does not exist", command.Email)); } // TODO Generate new password // TODO Send email with new password } }
/// <summary> /// Request to reset the password in case it is forgotten by the user /// </summary> /// <param name="forgotPasswordCommand"> </param> /// <returns></returns> public string ForgotPassword(ForgotPasswordCommand forgotPasswordCommand) { // Make sure all given credential contains value if (!string.IsNullOrEmpty(forgotPasswordCommand.Email) && (!string.IsNullOrEmpty(forgotPasswordCommand.Username))) { // Get the user tied to this Activation Key User user = _userRepository.GetUserByEmail(forgotPasswordCommand.Email); // If activation key is valid, proceed to verify username and password if (user != null) { if (!user.IsActivationKeyUsed.Value) { throw new InvalidOperationException("Account is not activated yet. In case you have forgotten your " + "password, you can cancel your account activation" + " and then sign up for an account again."); } if (user.Username.Equals(forgotPasswordCommand.Username)) { string newForgotPasswordCode = _passwordCodeGenerationService.CreateNewForgotPasswordCode(); user.AddForgotPasswordCode(newForgotPasswordCode); _persistenceRepository.SaveUpdate(user); return(newForgotPasswordCode); } else { throw new InvalidCredentialException("Wrong username."); } } else { throw new InvalidOperationException(string.Format("{0} {1}", "No user could be found for Email: ", forgotPasswordCommand.Email)); } } // If the user did not provide all the credentials, return with failure else { throw new InvalidCredentialException("Email not provided"); } }
public async Task ForgotPasswordAsync(ForgotPasswordCommand command) { var user = await _userManager.FindByEmailAsync(command.Email); if (user == null) { throw new GfsException(ErrorCode.UserNotFound, _dictionary.UserNotFound); } var token = Guid.NewGuid(); if (token == null) { throw new GfsException(ErrorCode.EmptyToken, _dictionary.EmptyToken); } var msg = _dictionary.ResetMailMessage + " http://localhost:4200/#/auth/reset?token=" + token; user.PasswordResetToken = token.ToString(); await _context.SaveChangesAsync(); await _emailService.SendEmailAsync(user.Email, _dictionary.ResetMailSubject, msg); }
public void OnGet() { Model = new ForgotPasswordCommand(); }
public ActionResult ForgotPassword(ForgotPasswordCommand command) { return RedirectToAction("Login"); }