public IActionResult ForgotPassword(ForgotPasswordDTO model) { try { var result = ChangeForgottenPassword(model); if (result != HttpStatusCode.OK) { if (result == HttpStatusCode.NotFound) { _logger.LogInformation("No existe una cuenta de usuario asociada al e-mail {0}", model.Email); SetTempData("No existe una cuenta de usuario asociada al e-mail ingresado. ", "warning"); return(View("ForgotPassword", model)); } else { _logger.LogError("Ocurrio un error al recuperar contraseña para el e-mail {0}", model.Email); SetTempData("No fue posible procesar su solicitud. Intente de nuevo más tarde.", "danger"); return(View("ForgotPassword", model)); } } else { _logger.LogInformation("El Usuario Existe, Token Creado"); return(View("ForgotPasswordConfirmation", model)); } } catch (Exception ex) { _logger.LogErrorException(ex, "Ocurrió un error al recuperar contraseña para el email {0}.", model.Email); SetTempData("No fue posible procesar su solicitud. Intente de nuevo más tarde.", "danger"); return(View("ForgotPassword", model)); } }
public async Task <IActionResult> ForgotPassword(ForgotPasswordDTO forgotPassword) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = await _userManager.FindByEmailAsync(forgotPassword.Email); if (user == null) { return(NotFound($"Usuário '{forgotPassword.Email}' não encontrado.")); } else { var code = await _userManager.GeneratePasswordResetTokenAsync(user); var resetPassword = new ResetPasswordDTO(); resetPassword.Code = code; resetPassword.Email = user.Email; resetPassword.UserId = user.Id; return(Ok(resetPassword)); // Comentando o trecho de codigo de envio de email //var forgot = await ForgotMainPassword(user); //if (forgot.Enviado) //return Ok(); //return Unauthorized(forgot.error); } }
public async Task <IActionResult> ForgotPassword( [FromBody] ForgotPasswordDTO forgotPasswordDTO) { //Return bad request not "email not found". Could be used to work out which emails exists in the database. var user = await _userManager.FindByEmailAsync(forgotPasswordDTO.Email); if (user == null) { return(BadRequest("Invalid Request")); } var token = await _userManager.GeneratePasswordResetTokenAsync(user); var param = new Dictionary <string, string> { { "token", token }, { "email", forgotPasswordDTO.Email } }; var callback = QueryHelpers.AddQueryString(forgotPasswordDTO.ClientURI, param); //builds the string for the reset password email var message = new Message(new string[] { user.Email }, "Reset password token", callback, null); await _emailSender.SendEmailAsync(message); return(Ok()); }
public async Task <ResultDTO> ForgotPassword(ForgotPasswordDTO forgotPasswordDTO) { var user = await _userManager.FindByEmailAsync(forgotPasswordDTO.Email); if (user == null) { return(new ResultDTO(false, "User not found", user)); } var token = await _userManager.GeneratePasswordResetTokenAsync(user); var result = await ResetPassword(user, token).ConfigureAwait(false); if (result.Success == false) { return(result); } //TODO await _mailService.SendEmailAsync( forgotPasswordDTO.Email, "Forgot password.", "<h1>Acess with your new password and change. </h1>" + $"<p>Your new password is: {result.Data} </p>"); return(new ResultDTO(true, $"A new password has been sent to the email: {forgotPasswordDTO.Email}", null)); }
public async Task <IActionResult> ForgotPasswordAsync([FromBody] ForgotPasswordDTO ForgotPasswordDTO) { Guard.Against.NullItem(ForgotPasswordDTO); ApplicationUser applicationUser = await _userManager.FindByNameAsync(ForgotPasswordDTO.UserName); if (applicationUser == null) { return(NotFound(new { message = "No user found with such email, provide a valid email" })); } IList <UserLoginInfo> externalUserList = await _userManager.GetLoginsAsync(applicationUser); if (externalUserList.Count > 0) { return(StatusCode(401, new { message = "External users not authorized to change password, change password with the login-provider" })); } await _userManager.RemovePasswordAsync(applicationUser); IdentityResult changePasswordResult = await _userManager.AddPasswordAsync(applicationUser, ForgotPasswordDTO.NewPassword); if (!changePasswordResult.Succeeded) { return(BadRequest(new { message = changePasswordResult.GetIdentityResultErrorMessage() })); } return(Ok(new { message = "Password changed successfully" })); }
public string SaveOTP(ForgotPasswordDTO forgotPassword) { var forgotPasswordItem = _dbContext.ForgotPasswords.FirstOrDefault(x => x.UserId == forgotPassword.UserId); if (forgotPasswordItem == null) { var newforgotPasswordItem = new ForgotPassword(); newforgotPasswordItem.CreatedDate = forgotPassword.TokenCreationDate; newforgotPasswordItem.OTP = forgotPassword.OTP; newforgotPasswordItem.UserId = forgotPassword.UserId; _dbContext.ForgotPasswords.Add(newforgotPasswordItem); return(forgotPassword.OTP); } else { if (forgotPasswordItem.CreatedDate.AddMinutes(30) > DateTime.Now) { return(forgotPasswordItem.OTP); } else { forgotPasswordItem.OTP = forgotPassword.OTP; forgotPasswordItem.CreatedDate = forgotPassword.TokenCreationDate; return(forgotPassword.OTP); } } }
public async Task <IActionResult> ForgotPassword(ForgotPasswordDTO forgotPassword) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = await _userManager.FindByNameAsync(forgotPassword.Email); if (user == null) { return(NotFound($"Usuário '{forgotPassword}' não encontrado.")); } else { var forgotMail = await ForgotMainPassword(user); if (forgotMail.Enviado) { return(Ok()); } return(Unauthorized(forgotMail.error)); } }
public async Task <ActionResult> ForgotPassword(FormCollection collection) { try { var forgotPasswordViewModel = new ForgotPasswordViewModel(); if (TryUpdateModel(forgotPasswordViewModel)) { var forgotPasswordDTO = new ForgotPasswordDTO { Email = forgotPasswordViewModel.Email, }; var response = _accountService.RequestPasswordReset(forgotPasswordDTO).Result; if (response) { return(RedirectToAction("ForgotPasswordConfirmation")); } else { ModelState.AddModelError("", "There is a problem with this operation."); return(View()); } } else { return(View()); } } catch (Exception) { ModelState.AddModelError("", "This operation could not be completed, please try again."); return(View()); } }
public void Email_Deve_Ser_Um_testeArrobaTestePontoCom(string email) { var forgotPasswordDto = new ForgotPasswordDTO { Email = email }; Assert.AreEqual(email, forgotPasswordDto.Email); }
public async Task ForgotPassword(ForgotPasswordDTO model) { var user = await _userManager.FindByEmailAsync(model.Email); var token = _userManager.GeneratePasswordResetTokenAsync(user); // send email with generate token and email }
public void Check_Email_Is_Valid(string email) { var forgotPasswordDto = new ForgotPasswordDTO { Email = email }; forgotPasswordDto.Validate(); Assert.IsTrue(forgotPasswordDto.Valid); }
//HTTP methods for calling the API POST, PUT, GET etc public async Task <HttpStatusCode> ForgotPassword(ForgotPasswordDTO forgotPasswordDTO) { forgotPasswordDTO.ClientURI = Path.Combine(_navManager.BaseUri, "resetPassword"); var result = await _client.PostAsJsonAsync("account/forgotpassword", forgotPasswordDTO); return(result.StatusCode); }
public async Task <IActionResult> ForgotPassword(ForgotPasswordDTO data) { if (ModelState.IsValid) { await personalCabinetService.ForgotPassword(data, "link to form with ResetPasswordDTO"); await unitOfWork.SaveChanges(); return(NoContent()); } return(Conflict(ModelState)); }
public async Task <bool> ForgotPassword([FromBody] ForgotPasswordDTO forgotPasswordDTO) { UserFilter userFilter = new UserFilter() { Username = forgotPasswordDTO.Username, Email = forgotPasswordDTO.Email }; await this.userService.ForgotPassword(userFilter); return(true); }
public bool VerifyUser(ForgotPasswordDTO forgotPasswordDTO) { bool isValid = false; var userProfile = db.UserProfiles.FirstOrDefault(Usr => Usr.Email == forgotPasswordDTO.Email); if (userProfile != null && userProfile.Membership.IsConfirmed.GetValueOrDefault(false)) { isValid = true; } return(isValid); }
public void Check_Email(string email) { var forgotPasswordDto = new ForgotPasswordDTO(); Assert.IsNull(forgotPasswordDto.Email); forgotPasswordDto.Email = email; Assert.AreEqual(email, forgotPasswordDto.Email); forgotPasswordDto.Validate(); Assert.IsTrue(forgotPasswordDto.Invalid); }
public async Task <ActionResult> ForgotPassword([FromBody] ForgotPasswordDTO model) { var user = await _userManager.FindByEmailAsync(model.Email); if (user != null) { string resetToken = await _userManager.GeneratePasswordResetTokenAsync(user); SendForgotPasswordEmail(user, resetToken); } return(Ok()); }
public IHttpActionResult ForgotPassword([FromBody] ForgotPasswordDTO forgotPasswordDTO) { try { if (forgotPasswordDTO == null) { throw new ArgumentNullException("NULL"); } return(Ok(_loginService.ForgotPassword(forgotPasswordDTO))); } catch (PlatformModuleException exception) { return(Ok(ResponseHelper.CreateResponseDTOForException(exception.Message))); } }
public async Task <bool> RequestPasswordReset(ForgotPasswordDTO forgotPassword) { var content = JsonConvert.SerializeObject(forgotPassword); string uri = $"{_baseUrl}/ExpectingEndPoint/"; var res = await _httpClient.PostAsync(uri, new StringContent(content, Encoding.UTF8, "application/json")).ConfigureAwait(false); var textData = await res.Content.ReadAsStringAsync(); if (res.IsSuccessStatusCode) { return(JsonConvert.DeserializeObject <bool>(textData)); } var errorMessage = ParseErrorResponse(textData); throw new Exception(errorMessage); }
public ActionResult ForgotPassword(ForgotPasswordDTO model) { if (!ModelState.IsValid) { return(View(model)); } string errorMsg = string.Empty; bool resetUserPasswordStatus = UserDetailsFacade.ResetUserPassword(model.Email, out errorMsg); model.FPStatusMessage = resetUserPasswordStatus ? "An email has been sent to your registered email with new code" : "The server encountered an error processing password reset. Please try again later."; model.FPStatus = true; return(View("~/Views/Account/ForgotPassword.cshtml", model)); }
public ResponseDTO ForgotPassword(ForgotPasswordDTO forgotPasswordDTO) { ResponseDTO responseDTO = new ResponseDTO(); if (forgotPasswordDTO.LoginType == LoginType.VLC) { VLC vLC = unitOfWork.VLCRepository.GetByUserName(forgotPasswordDTO.UserName); if (vLC != null) { string otp = OTPGenerator.GetSixDigitOTP(); vLC.Pin = otp; this.SendOTP(otp, vLC.Contact, NatrajComponent.VLC); unitOfWork.VLCRepository.Update(vLC); unitOfWork.SaveChanges(); responseDTO.Status = true; responseDTO.Message = string.Format("A OTP has been sent to registered mobile number - {0} OTP -{1}", vLC.Contact, vLC.Pin); responseDTO.Data = new object(); } else { throw new PlatformModuleException("The User Name Does Not Exist"); } } else if (forgotPasswordDTO.LoginType == LoginType.DistributionCenter) { DistributionCenter distributionCenter = unitOfWork.DistributionCenterRepository.GetDistributionCenterByMobileNumber(forgotPasswordDTO.UserName); if (distributionCenter != null) { string otp = OTPGenerator.GetSixDigitOTP(); distributionCenter.Pin = otp; this.SendOTP(otp, distributionCenter.Contact, NatrajComponent.DC); unitOfWork.DistributionCenterRepository.Update(distributionCenter); unitOfWork.SaveChanges(); responseDTO.Status = true; responseDTO.Message = string.Format("A OTP has been sent to registered mobile number - {0},OTP-{1}", distributionCenter.Contact, distributionCenter.Pin); responseDTO.Data = new object(); } else { throw new PlatformModuleException("The User Name Does Not Exist"); } } return(responseDTO); }
public bool ChangeForgottenPassword(ForgotPasswordDTO model) { var user = _uow.UsuarioRepository.Find(x => x.Email == model.Email); if (user != null) { //Envío mail pass temporal y link para cambio... try { var tokenGuid = Guid.NewGuid().ToString(); var token = new UsuarioToken() { UsuarioId = user.UsuarioId, FechaExpiracion = DateTime.Now.AddMinutes(Convert.ToDouble(Helper.Parametro.GetValue("TiempoExpiracionTokenMail"))), Usado = false, Token = tokenGuid }; var mailModel = new MailUsuarioModel() { TokenUrl = tokenGuid, UsuarioApellido = user.Apellido, UsuarioNombre = user.Nombre, Email = user.Email }; //Envio mail de contraseña olvidada... sender.SendMailForgotPassword(mailModel); _uow.UsuarioTokenRepository.Create(token); _uow.UsuarioTokenRepository.Save(); _logger.LogInformation("Envio de email correctamente"); return(true); } catch (Exception ex) { _logger.LogErrorException(ex, "[Token-Mail] - Ocurrió un error al intentar enviar EMAIL para restablecer contraseña olvidada."); throw; } } else { return(false); } }
public IHttpActionResult Forgotpassword(ForgotPasswordDTO dto) { var customer = new CustomerBO().GetCustomer(new Customer { MobileNo = dto.MobileNo }); if (customer != null && customer.OTP == dto.OTP) { customer.Password = dto.NewPassword; new CustomerBO().SaveCustomer(customer); return(Ok("Password updated...!")); } else { return(NotFound()); } }
public IHttpActionResult Forgotpassword(ForgotPasswordDTO forgot) { var customer = new CustomerBO().GetCustomer(new Customer { MobileNo = forgot.MobileNo }); if (customer != null && customer.OTP == forgot.OTP) { customer.Password = forgot.NewPassword; new CustomerBO().SaveCustomer(customer); return(Ok("Password updated...!")); } else { return(Ok(UTILITY.FAILURESTATUS)); } }
public ActionResult ForgotPassword(ForgotPasswordDTO model) { if (ModelState.IsValid) { using (HttpClientWrapper httpClient = new HttpClientWrapper(Session)) { //Call confirm account API method var responseMessage = httpClient.PostAsJsonAsync("/api/AccountAPI/VerifyUser", model).Result; if (responseMessage.IsSuccessStatusCode) { var isValid = JsonConvert.DeserializeObject <bool>(responseMessage.Content.ReadAsStringAsync().Result); if (!isValid) { // Don't reveal that the user does not exist or is not confirmed return(View("ForgotPasswordConfirmation")); } else { //Generate and send a reset password token to the users email. var responseMessage2 = httpClient.PostAsJsonAsync("/api/AccountAPI/ResetPasswordToken", model).Result; //If registration worked, then need to send email confirmation if (responseMessage2.IsSuccessStatusCode) { var confirmationToken = JsonConvert.DeserializeObject <string>(responseMessage2.Content.ReadAsStringAsync().Result); var confURL = WebUI.Common.Common.GetDomainFromRequest(HttpContext.Request) + "/Account/ResetPassword/" + confirmationToken.ToString(); MessagingService.PasswordReset(model.Email, confURL); return(RedirectToAction("ForgotPasswordConfirmation", "Account")); } else { var error = JsonConvert.DeserializeObject <System.Web.Http.HttpError>(responseMessage2.Content.ReadAsStringAsync().Result); ModelState.AddModelError(String.Empty, error.Message); } } } } } // If we got this far, something failed, redisplay form return(View(model)); }
public ActionResult ForgotPassword(ForgotPasswordViewModel model) { if (!string.IsNullOrEmpty(model.Email)) { var ASPUser = UserManager.FindByName(model.Email); //bool confirm = UserManager.IsEmailConfirmed(user.Id); //if (user == null || !confirm) //{ // // Don't reveal that the user does not exist or is not confirmed // return View("ForgotPasswordConfirmation"); //} var user = db.Users.Where(c => c.Email == model.Email).FirstOrDefault(); if (user == null || ASPUser == null) { // Don't reveal that the user does not exist or is not confirmed return(View("ForgotPasswordConfirmation")); } // For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771 // Send an email with this link string code = UserManager.GeneratePasswordResetToken(ASPUser.Id); var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme); ForgotPasswordDTO forgotPasswordDTO = new ForgotPasswordDTO() { FName = user.FName, LName = user.LName, MName = user.MName, callbackUrl = callbackUrl }; EmailTemplate Email = new EmailTemplate(); string path = @"~/Common/ForgotPasswordEmailTemplate.html"; var emailHtml = Email.ReadTemplateEmail(forgotPasswordDTO, path); GmailSender.SendEmail("*****@*****.**", "Serious!1", new List <string>() { model.Email }, "Reset Password", emailHtml, null); UserManager.SendEmailAsync(ASPUser.Id, "Reset Password", "Please reset your password by clicking <a href=\"" + callbackUrl + "\">here</a>"); return(RedirectToAction("ForgotPasswordConfirmation", "Account")); } // If we got this far, something failed, redisplay form return(View(model)); }
public HttpStatusCode ChangeForgottenPassword([FromBody] ForgotPasswordDTO model) { try { var result = _pass.ChangeForgottenPassword(model); if (result) { return(HttpStatusCode.OK); } else { return(HttpStatusCode.NotFound); } } catch (Exception ex) { return(HttpStatusCode.BadRequest); } }
public async Task <IActionResult> ForgotPassword( [FromServices] IAuthenticationService _services, [FromBody] ForgotPasswordDTO forgotPasswordDTO) { forgotPasswordDTO.Validate(); if (forgotPasswordDTO.Invalid) { return(BadRequest(new ResultDTO(false, "Wrong email, please verify and try again.", forgotPasswordDTO.Notifications))); } var result = await _services.ForgotPassword(forgotPasswordDTO); if (result.Success == false) { return(BadRequest(result)); } return(Ok(result)); }
public async Task <IActionResult> ForgotPassword([FromBody] ForgotPasswordDTO model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } AppUser user = await _userManager.FindByEmailAsync(model.Email); if (user == null) { return(BadRequest(Errors.AddErrorToModelState("user_not_found", "Invalid email address", ModelState))); } var emailConfirmationToken = await _userManager.GeneratePasswordResetTokenAsync(user); var tokenVerificationUrl = Url.Action("ResetPassword", "Accounts", new { id = user.Id, token = emailConfirmationToken }, Request.Scheme); await _messageService.Send(user.Email, "Reset Password", $"Please reset your password by using this: \"{ emailConfirmationToken}\""); return(Ok("Check your email!")); }
public async Task <bool> ForgotPassword(ForgotPasswordDTO forgotPasswordDTO) { if (forgotPasswordDTO?.Username != null && forgotPasswordDTO?.NewPassword != null) { var user = await GetBy(f => f.Username == forgotPasswordDTO.Username); if (user?.Id > 0) { user.Password = forgotPasswordDTO.NewPassword; var isUpdated = await Update(user); if (isUpdated > 0) { return(true); } } } return(false); }