public async Task <IActionResult> GenerateForgotPasswordEmail(ForgotPasswordRequestModel model)
{
try
{
await _commonManager.GenerateForgotPasswordEmail(model);
return(Ok(new JObject
{
["status"] = "Success"
}.ToString()));
}
catch (GenericException ex)
{
return(Ok(new JObject
{
["error"] = ex.Code
}.ToString()));
}
catch (Exception ex)
{
return(Ok(new JObject
{
["error"] = ex.Message,
["stackTrace"] = ex.StackTrace
}.ToString()));
}
}
public async Task <AuthenticationResponseModel> SendResetPasswordLinkAsync(ForgotPasswordRequestModel forgotPasswordRequestModel)
{
if (forgotPasswordRequestModel == null)
{
throw new EShopperException("Please provide required information!");
}
EShopperUser getUserDetails = await _eShopperUserManager.FindByEmailAsync(forgotPasswordRequestModel.Email);
if (getUserDetails == null)
{
throw new EShopperException("User not found!");
}
string userResetToken = await _eShopperUserManager.GeneratePasswordResetTokenAsync(getUserDetails);
try
{
await _emailSender.SendResetPasswordLinkAsync(forgotPasswordRequestModel.Email, userResetToken);
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
throw new EShopperException();
}
return(new AuthenticationResponseModel
{
Message = "Reset Password Link has successfuly sent to your Mail address! Please check your inbox!"
});
}
public async Task <IActionResult> ForgotUserPassword([FromBody] ForgotPasswordRequestModel model)
{
try
{
var user = await _userManager.FindByEmailAsync(model.Email);
var token = await _userManager.GeneratePasswordResetTokenAsync(user);
byte[] tokenBytes = Encoding.UTF8.GetBytes(token);
var tokenEncoded = WebEncoders.Base64UrlEncode(tokenBytes);
var clientAddress = Configuration.GetSection("ApplicationSettings").GetValue <string>("ClientAddress");
var passwordResetLink = $"{clientAddress}/user/reset-password?email={user.Email}&token={tokenEncoded}";
var newEmail = new Email()
{
To = user.Email,
Subject = "reset password",
Body = $"Reset password here: {passwordResetLink}"
};
SendMail.Execute(newEmail);
return(Ok(new { message = $"A link to reset your password has been sent to your email address: {maskEmail(user.Email)}" }));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <ForgotPasswordResponseModel> ForgotPassword(ForgotPasswordRequestModel forgotPasswordRequestModel)
{
ForgotPasswordRequestContract forgotPasswordRequestContract = _mapper.Map <ForgotPasswordRequestContract>(forgotPasswordRequestModel);
ForgotPasswordResponseContract forgotPasswordResponseContract = await _LoginRepository.ForgotPassword(forgotPasswordRequestContract);
return(_mapper.Map <ForgotPasswordResponseModel>(forgotPasswordResponseContract));
}
public async Task <string> GenerateForgotPasswordEmail(ForgotPasswordRequestModel model)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user != null)
{
var hash = GenericHelper.GenerateForgotPasswordToken(user);
_dbContext.ForgotPasswordToken.Add(new ForgotPasswordValidationKey
{
ValidationKey = hash,
UserId = user.Id
});
await _dbContext.SaveChangesAsync();
model.UserId = user.Id;
string body = await GetForgotPasswordEmailBody(model, hash);
await _emailService.SendEmail(user.Email, body, "Password Reset");
return("");
}
else
{
throw new GenericException(ErrorCodes.GetCode("UserNotFound"));
}
}
public async Task <IActionResult> ForgotPassword([FromBody] ForgotPasswordRequestModel request)
{
var user = await this.userManager.FindByNameAsync(request.Email);
if (user == null)
{
return(BadRequest(localizer.GetString("errors.user_not_found")));
}
var recover = new IPCS.Entities.RecoverPassword
{
RecoverDate = DateTime.Now.Add(TimeSpan.FromDays(1)),
Hash = Guid.NewGuid().ToString(),
Used = false,
UserId = user.Id
};
this.recoverPasswordService.Insert(recover);
string callBack = $"{this.generalOptions.BaseWebAppUrl}resetPassword/{recover.Hash}";
string emailFile = localizer.GetString("emails.forgotpassword_src");
string path = $"{Directory.GetCurrentDirectory()}{emailFile}";
this.emailSender.SendEmail(user.Email, "Reset Password", path, new Dictionary <string, string> {
{ "callback", callBack }, { "username", $"{user.FirstName}" }, { "host", this.generalOptions.BaseEmailsImage }
});
return(Ok());
}
public async Task <ActionResult> forgotPassword(ForgotPasswordRequestModel user)
{
/* Get the user record to change.*/
Users userToChange = await userGymMovesRepository.getUser(user.username);
/* No such user exists.*/
if (userToChange == null)
{
return(NotFound("This username does not exist! Are you sure you typed the correct one?"));
}
/*Get code from code table to see if it matches.*/
PasswordReset userInCodeTabe = await resetPasswordRepository.getUser(user.username);
/* No such user exists.*/
if (userInCodeTabe == null)
{
return(NotFound("This user does not have a code! Are you sure you received one?"));
}
DateTime dateTime = DateTime.Now;
if ((dateTime.Subtract(userInCodeTabe.Expiry)).TotalMinutes > 60)
{
await resetPasswordRepository.deleteUser(await resetPasswordRepository.getUser(user.username));
return(Unauthorized("Your code is expired. Please get a new one."));
}
if (userInCodeTabe.Code.Equals((user.code).Trim()))
{
/* Hash new password.*/
string hash = getHash(SHA256.Create(), user.password + userToChange.Salt);
/* Try change password in db.*/
bool changed = await userGymMovesRepository.changePassword(userToChange.Username, hash);
if (changed)
{
await resetPasswordRepository.deleteUser(userInCodeTabe);
return(Ok("Successfully changed! You can log in with your new password now."));
}
else
{
await resetPasswordRepository.deleteUser(userInCodeTabe);
return(StatusCode(500, "This is already your existing password."));
}
}
else
{
return(Unauthorized("This code is incorrect."));
}
}
public async Task SendForgotPassword(string username)
{
var request = new ForgotPasswordRequestModel()
{
Username = username
};
var responce = await service.RequestPasswordResetCodePassword(request);
Success = responce.Status == true;
ResponceMessage = responce.GetMessage();
}
public async Task <BaseRespond> RequestPasswordResetCodePassword(ForgotPasswordRequestModel requestModel)
{
var responce = new BaseRespond();
try
{
responce = await Post <BaseRespond, ForgotPasswordRequestModel>(ForgotPasswordUserAPI, requestModel);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.Message);
}
return(responce);
}
public async Task <IActionResult> ForgotPassword([FromBody] ForgotPasswordRequestModel model)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(NotFound(new ErrorResponseModel(ErrorCode.UserNotFound, UserNotFoundException)));
}
if (_userStatusErrors.ContainsKey(user.StatusId))
{
return(Conflict(_userStatusErrors[user.StatusId]));
}
await _userService.SendResetPasswordEmailAsync(user);
return(Ok());
}
public void ForgotPassword(ForgotPasswordRequestModel model, string origin)
{
var user = _context.Users.SingleOrDefault(x => x.Email == model.Email);
if (user == null)
{
return;
}
user.ResetToken = randomTokenString();
user.ResetTokenExpires = DateTime.Now.AddHours(1);
_context.Users.Update(user);
_context.SaveChanges();
sendPasswordResetEmail(user, origin);
}
public async Task <ApiBaseResponse> ForgatPasswordAsync(ForgotPasswordRequestModel requestModel)
{
var user = await _userService.FindByEmailAsync(requestModel.Email);
if (user == null)
{
return(new ApiBaseResponse(System.Net.HttpStatusCode.BadRequest, ApplicationStatusCode.AnErrorHasOccured, null, "The user is not found."));
}
if (!user.IsActive || user.IsDeleted)
{
return(new ApiBaseResponse(System.Net.HttpStatusCode.BadRequest, ApplicationStatusCode.AnErrorHasOccured, null, "The user is not found."));
}
var oldPasswordRequests = _userPasswordService.FindBy(user.Id).Where(c => c.IsActive == true);
foreach (var oldPasswordRequest in oldPasswordRequests)
{
oldPasswordRequest.IsActive = false;
oldPasswordRequest.UpdatedDate = DateTime.Now;
oldPasswordRequest.UpdatedBy = user.Id;
_userPasswordService.UpdateUserPassword(oldPasswordRequest);
}
Guid activationCode = Guid.NewGuid();
DateTime now = DateTime.UtcNow;
var userRequest = await _userPasswordService.AddUserRequestAsync(new UserPasswordRequest
{
UserId = user.Id,
ActivationCode = activationCode,
ExpiredDate = now.AddHours(_identitySettings.ActivationLinkLifeTime),
CreatedBy = user.Id,
CreatedDate = now,
IsActive = true,
});
_logger.LogInformation($"{user.Username} - Forgot Password Event is starting");
var @event = new ForgotPasswordIntegrationEvent(activationCode, user.Username, user.Email);
_identityIntegrationService.PublishEventBusAsync(@event);
_logger.LogInformation($"{user.Username} - After Publish Forgot Password Event is starting");
return(new ApiBaseResponse(HttpStatusCode.OK, ApplicationStatusCode.Success, null, "The mail succesfully is sent."));
}
public async Task <IActionResult> ForgotPassword([FromBody] ForgotPasswordRequestModel requestModel)
{
if (ModelState.IsValid)
{
ForgotPasswordResponseModel responseModel = await _accountService.ForgotPasswordAsync(requestModel);
if (!responseModel.IsPossibleToUseCurrentEmail)
{
ModelState.AddModelError(string.Empty, "It's impossible to use email that you provided");
return(BadRequest(ModelState));
}
string callbackUrl = CreateCallbackUrl("ResetPassword", new { userId = responseModel.Id, code = responseModel.Code, redirectUrl = requestModel.RedirectUrl, email = requestModel.Email });
await _emailHelper.SendEmailAsync(requestModel.Email, "Reset Password", $"Для сброса пароля пройдите по ссылке: <a href='{callbackUrl}'>link</a>");
return(Ok());
}
return(BadRequest(ModelState));
}
public async Task <ResponseModelBase> SendForgotPasswordMessage([FromBody] ForgotPasswordRequestModel model)
{
if (!ModelState.IsValid)
{
return(ErrorModel.Of("invalid_request"));
}
//Find them
var user = await ldb.FindByEmailAddress(model.EmailAddress);
if (user == null)
{
return(ErrorModel.Of("user_not_found"));
}
await EmailSender.SendEmail(user, EmailSender.ForgotPasswordTemplate);
return(Models.OkModel.Of("forgot_password_request_sent"));
}
public async Task ForgotPassword(ForgotPasswordModel forgotPasswordModel)
{
var requestModel = new ForgotPasswordRequestModel(forgotPasswordModel);
try
{
await PostAsync(Resources.ForgotPasswordAction, requestModel);
}
catch (BadRequestException e)
{
ThrowNewIfDelayException(e);
if (e.Message.StartsWith("Unconfirmed Email"))
{
throw new UnconfirmedEmailException();
}
throw;
}
}
public ResponseModel RequestResetPassword(ForgotPasswordRequestModel usermodel)
{
if (usermodel == null || string.IsNullOrEmpty(usermodel.PhoneNumber))
{
return(new ResponseModel
{
Success = false,
Messages = new List <string> {
"Data not mapped"
},
});
}
var user = UserManager.FindByName(usermodel.PhoneNumber);
if (user == null)
{
return(new ResponseModel
{
Success = false,
Messages = new List <string> {
"User does not exists with given phone number"
},
});
}
GeneratePhoneCodeApiMethod(user.Id, user.PhoneNumber);
var model = new ChnageUserPasswordResponseModel
{
UserId = user.Id,
PhoneNumber = usermodel.PhoneNumber
};
return(new ResponseModel
{
Success = true,
Data = model,
Messages = new List <string> {
"Verification code has been sent at mobile number"
},
});
}
public async Task <string> GetForgotPasswordEmailBody(ForgotPasswordRequestModel model, string ValidationKey)
{
var user = await _userManager.FindByIdAsync(model.UserId);
var theme = await _dbContext.AppThemes.Where(item => item.HostName == model.HostName || item.HostName == "default").FirstOrDefaultAsync();
var themeElements = await _dbContext.ThemeElement.Where(item => item.ThemeId == theme.Id).ToListAsync();
var mainBg = themeElements.Where(item => item.Type == ThemeContentType.MainBackgroundColor).FirstOrDefault();
var themeColor2 = themeElements.Where(item => item.Type == ThemeContentType.ThemeSubColor2).FirstOrDefault();
var themeColor1 = themeElements.Where(item => item.Type == ThemeContentType.ThemeSubColor1).FirstOrDefault();
var borderColor = "#d4d6d5";
var logo = themeElements.Where(item => item.Type == ThemeContentType.Logo).FirstOrDefault();
var logoPath = $"{ConfigurationManager.AppSetting.ServiceEndpoint}{logo.Content}";
var link = $"{ConfigurationManager.AppSetting.WebEndpoint}/changepassword/{ValidationKey}";
var template = await _dbContext.EmailTemplate.Where(item => item.TemplateType == "ForgotPassword").FirstOrDefaultAsync();
var forgotPasswordLink = $"{ConfigurationManager.AppSetting.WebEndpoint}/forgotpassword";
return(String.Format(template.TemplateContent, mainBg.Content, themeColor2.Content, borderColor, logoPath, $"{user.FirstName} {user.LastName}", link, themeColor1.Content, forgotPasswordLink));
}
public async Task <ForgotPasswordResponseModel> ForgotPasswordAsync(ForgotPasswordRequestModel requestModel)
{
ApplicationUser user = await _userManager.FindByEmailAsync(requestModel.Email);
ForgotPasswordResponseModel responseModel = new ForgotPasswordResponseModel();
bool isEmailConfirmed = await _userManager.IsEmailConfirmedAsync(user);
if (user is null || !isEmailConfirmed)
{
responseModel.IsPossibleToUseCurrentEmail = false;
return(responseModel);
}
responseModel.Id = user.Id;
responseModel.IsPossibleToUseCurrentEmail = true;
string code = await _userManager.GeneratePasswordResetTokenAsync(user);
responseModel.Code = Base64UrlEncoder.Encode(code);
return(responseModel);
}
public virtual async Task <IActionResult> ForgotPassword(
[FromBody] ForgotPasswordRequestModel model,
[FromHeader(Name = "X-Auth-Path-Prefix")][Required]
string pathPrefix)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await UserManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(BadRequest(new[]
{
new ErrorResponseModel
{
Code = "OperationFailed", Description = "This email is not associated with an account."
}
}));
}
try
{
var resetToken = await UserManager.GeneratePasswordResetTokenAsync(user);
resetToken = HttpUtility.UrlEncode(resetToken);
await EmailHelper.SendResetPasswordEmail(user, resetToken, pathPrefix);
return(Ok("Email has been sent successfully. Please check your email."));
}
catch (Exception exc)
{
Console.WriteLine(exc);
throw new KnownException("We couldn't send the forgot password email. Please contact us.", 500, exc);
}
}
public async void ConfirmTap()
{
if (!this.IsEnabled)
{
return;
}
this.IsEnabled = false;
this.IsRunning = true;
if (string.IsNullOrEmpty(this.User))
{
await _messageService.ShowErrorMessage(Application.Current.Resources["TitleValidForgotPasswordPage"].ToString(), Application.Current.Resources["AllTextValidation"].ToString());
this.IsEnabled = true;
this.IsRunning = false;
return;
}
var forgotPasswordRequestModel = new ForgotPasswordRequestModel()
{
usuario = this.User
};
try
{
_forgotPasswordResponseModel = await _loginService.ForgotPassword(forgotPasswordRequestModel);
await DestroyThisModalAsync();
await _messageService.ShowSuccessMessage(_forgotPasswordResponseModel.Descripcion);
}
catch (Exception ex)
{
await _messageService.HandleException(ex);
}finally{
this.IsEnabled = true;
this.IsRunning = false;
}
}
public async Task <IActionResult> ForgotPassword(ForgotPasswordRequestModel forgotPasswordRequestModel)
{
var mail = await context.Users.FirstOrDefaultAsync(a => a.Email == forgotPasswordRequestModel.Email);
if (mail is null)
{
return(BadRequest("Mail Bulunamadı"));
}
mail.Password = GeneratePassword(6);
context.Users.Update(mail);
await context.SaveChangesAsync();
SmtpClient client = new SmtpClient("smtp.gmail.com");
client.EnableSsl = true;
client.Port = 587;
client.UseDefaultCredentials = false;
client.Credentials = new NetworkCredential("*****@*****.**", "No052959");
MailAddress mailAddress = new MailAddress("*****@*****.**"); // gönderiyorum
MailAddress to = new MailAddress(forgotPasswordRequestModel.Email); // gönderiliyor
MailMessage message = new MailMessage(mailAddress, to);
message.Body = "Your New Password:"******"Test Message";
client.SendAsync(message, userState);
Console.WriteLine("Sending message");
return(Ok(mail));
}
public async Task <ActionResult> ForgotPassword(ForgotPasswordRequestModel model)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindByNameAsync(model.Email);
if (user == null || !(await UserManager.IsEmailConfirmedAsync(user.Id)))
{
// Don't reveal that the user does not exist or is not confirmed
return(Json("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 = await UserManager.GeneratePasswordResetTokenAsync(user.Id);
var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
await UserManager.SendEmailAsync(user.Id, "Reset Password", "Please reset your password by clicking <a href=\"" + callbackUrl + "\">here</a>");
//return RedirectToAction("ForgotPasswordConfirmation", "Account");
}
return(Json(new { Success = false, Model = model }));
}
public async Task <IActionResult> ForgotPassword([FromBody] ForgotPasswordRequestModel forgotPasswordRequestModel)
{
var response = await _authenticationService.SendResetPasswordLinkAsync(forgotPasswordRequestModel);
return(Ok(response));
}
public async Task <ActionResult <ForgotPasswordResponseModel> > ForgotPasswordAsync(ForgotPasswordRequestModel request)
{
// TODO: Implement ForgotPasswordAsync Action
throw new System.NotImplementedException();
}
public ActionResult ForgetPasswordRequest(ForgotPasswordRequestModel model)
{
if (ModelState.IsValid)
{
UserProfile profile = _userProfileService.GetUser(model.UserName);
if (profile != null && !profile.LockedInInd)
{
ForgetPasswordRequest req = new ForgetPasswordRequest()
{
Completed = false,
ExpieryDate = DateTime.Now.AddMonths(2),
GeneratedDate = DateTime.Now,
RequestKey = MD5Hashing.MD5Hash(Guid.NewGuid().ToString()),
UserProfileID = profile.UserProfileID
};
if (_forgetPasswordRequestService.AddForgetPasswordRequest(req))
{
string to = profile.Email;
string subject = "Password Change Request";
string link = Request.Url.Host + "/Account/ForgetPassword/?key=" + req.RequestKey;
string body = string.Format(@"Dear {1}
<br /><br />
A password reset request has been submitted for your DRMFSS - CTS account. If you submitted this password reset request, please follow the following link.
<br /><br />
<a href='{0}'>Please Follow this Link</a> <br />
<br /><br />
Please ignore this message if the password request was not submitted by you. This request will expire in 24 hours.
<br /><br />
Thank you,<br />
Administrator.
", link, profile.GetFullName());
try
{
// Read the configuration table for smtp settings.
string from = _settingService.GetSettingValue("SMTP_EMAIL_FROM");
string smtp = _settingService.GetSettingValue("SMTP_ADDRESS");
int port = Convert.ToInt32(_settingService.GetSettingValue("SMTP_PORT"));
string userName = _settingService.GetSettingValue("SMTP_USER_NAME");
string password = _settingService.GetSettingValue("SMTP_PASSWORD");
// send the email using the utilty method in the shared dll.
SendMail mail = new SendMail(from, to, subject, body, null, true, smtp, userName, password, port);
return(RedirectToAction("ConfirmPasswordChange"));
}
catch (Exception e)
{
ViewBag.ErrorMessage = "The user name or email address you provided is not correct. Please try again.";
}
}
else
{
ViewBag.ErrorMessage = "The user name or email address you provided is not correct. Please try again.";
}
}
else
{
ViewBag.ErrorMessage = "The user name or email address you provided is not correct. Please try again.";
}
}
return(View("ForgetPasswordRequest", model));
}
/// <summary>
/// Shows the Forget password page for the first time.
/// </summary>
/// <returns></returns>
public ActionResult ForgetPasswordRequest()
{
ForgotPasswordRequestModel model = new ForgotPasswordRequestModel();
return(View("ForgetPasswordRequest", model));
}
public IActionResult ForgotPassword(ForgotPasswordRequestModel model)
{
_userService.ForgotPassword(model, Request.Headers["origin"]);
return(Ok(new { meesage = "Please check your email for password reset instructions" }));
}
public async Task <string> GenerateForgotPasswordEmail(ForgotPasswordRequestModel model)
{
return(await _repo.GenerateForgotPasswordEmail(model));
}
public async Task <IActionResult> ForgotPassword([FromBody] ForgotPasswordRequestModel requestViewModel) => Ok(await _identityService.ForgatPasswordAsync(requestViewModel));
