//-------------------------------------------------------------------------------------------------
public Result ForgetPassword(ForgetPasswordDto user)
{
Result res = new Result();
using (_db = new IdeaManagmentDatabaseEntities())
{
var findUser = _db.USERS.FirstOrDefault(x =>
x.EMAIL == user.Email.Trim() &&
x.FIRST_NAME == user.FirstName.Trim() &&
x.LAST_NAME == user.LastName.Trim() &&
x.USERNAME == user.Username.Trim());
if (findUser != null)
{
res.Value = true;
res.Content = "" + findUser.PASSWORD;
}
else
{
res.Value = false;
res.Content = "عدم وجود یا عدم مطابقت اطلاعات";
}
}
return(res);
}
public async Task <ResponseDto> ResetPassword(ForgetPasswordDto model)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
response.Message = MessageConstant.User.UserNotFound;
response.IsSuccess = false;
return(response);
}
var decodedToken = WebEncoders.Base64UrlDecode(model.Token);
model.Token = Encoding.UTF8.GetString(decodedToken);
var result = await _userManager.ResetPasswordAsync(user, model.Token, model.NewPassword);
if (result.Succeeded)
{
response.Message = MessageConstant.User.PasswordChanged;
return(response);
}
response.Message = MessageConstant.User.PasswordChangedFailed;
response.IsSuccess = false;
return(response);
}
public async Task <IActionResult> ForgetPassword([FromBody] ForgetPasswordDto forgetPasswordDto)
{
return(await Do(() =>
{
//await _userService.ForgetPassword(forgetPasswordDto.Email);
throw new ArgumentException("This feature is currently unsupported due to insecure domain");
}));
}
public IActionResult SendLink(ForgetPasswordDto forgetPasswordDto)
{
var id = _roleService.GetUserIdByEmail(forgetPasswordDto.Email);
var url = Request.Host.Value;
var sendEmail = new EmailOptions();
sendEmail.SendPasswordResetEmail(forgetPasswordDto.Email, "Reset Your Password", id, url);
return(RedirectToAction("Sign", "Home"));
}
public async Task <IActionResult> ForgetPassword([FromBody] ForgetPasswordDto dto)
{
ForgetPasswordDtoValidator validator = new ForgetPasswordDtoValidator();
ValidationResult result = await validator.ValidateAsync(dto);
if (result.IsValid)
{
var user = await _userManager.FindByEmailAsync(dto.Email);
if (user == null)
{
result.Errors.Add(new ValidationFailure("email", "此電子郵件尚未被註冊"));
return(BadRequest(result.Errors));
}
#region UpdateSecurity
await using (var transaction = await _dbContext.Database.BeginTransactionAsync())
{
try
{
var oldSecurityStamp = user.SecurityStamp;
if (await _userManager.UpdateSecurityStampAsync(user) != IdentityResult.Success)
{
throw new DbUpdateException();
}
if (await _userManager.ReplaceClaimAsync(user, new Claim(ClaimTypes.Sid, oldSecurityStamp), new Claim(ClaimTypes.Sid, user.SecurityStamp)) != IdentityResult.Success)
{
throw new DbUpdateException();
}
await transaction.CommitAsync();
}
catch (DbUpdateException)
{
await transaction.RollbackAsync();
throw;
}
}
#endregion
#region 寄信
var link = $"{_configuration["FrontendUrl"]}/account/password/reset" +
$"?userId={Uri.EscapeDataString(user.Id)}" +
$"&token={Uri.EscapeDataString(await _userManager.GeneratePasswordResetTokenAsync(user))}";
await _mailService.SendResetPasswordAsync(user.Email, user.Email, link);
#endregion
return(NoContent());
}
return(BadRequest(result.Errors));
}
public async Task <Message> ForgetPassword(ForgetPasswordDto input)
{
string returnUrl = null;
returnUrl = returnUrl ?? Url.Content("~/");
bool isSuccess = false;
string message = string.Empty;
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(input.Email);
if (user != null && (await _userManager.IsEmailConfirmedAsync(user)))
{
// Don't reveal that the user does not exist or is not confirmed
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
if (!string.IsNullOrEmpty(code))
{
string physicalUrl = _config.GetValue <string>("CommonProperty:ClientPhysicalUrl");
string emailBody = SocialEcommerce.Shared.Utilities.Utility.ReadEmailTemplate(_webHostEnvironment.WebRootPath, EmailConstant.TemplateName.ForgotPassword, physicalUrl);
var logoUrl = _config.GetValue <string>("App:ServerRootAddress") + SocialEcommerce.Shared.Constants.MailLogoURL.LogoURL; //Arti
var callbackUrl = physicalUrl + "/#/auth/reset-password/" + code;
//var callbackUrl = "http://*****:*****@"Forget password recovery mail from Divide & conquer Social Ecommerce", emailBody, user.Email);
isSuccess = true;
}
else
{
isSuccess = false;
message = message + "Invalid User ";
}
}
else
{
isSuccess = false;
message = message + "User not Found ";
}
}
return(new Message()
{
isSuccess = isSuccess,
message = message,
});
}
public HttpResponseMessage ForgetPassword([FromBody] ForgetPasswordDto user)
{
Result res = _business.ForgetPassword(user);
if (res.Value)
{
return(Request.CreateResponse(HttpStatusCode.OK,
res.Content));
}
else
{
return(Request.CreateResponse(HttpStatusCode.PreconditionFailed,
res.Content));
}
}
public async Task <IActionResult> ForgetPassword(ForgetPasswordDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newPassword = await _service.NewPassword(model);
if (newPassword == "")
{
return(BadRequest("資枓比對不一致,請重新輸入"));
}
return(Ok(newPassword));
}
public async Task <IActionResult> ResetPasswordAsync([FromBody] ForgetPasswordDto model)
{
if (!ModelState.IsValid)
{
SetErrorMessage();
return(BadRequest(response));
}
var result = await _userService.ResetPassword(model);
if (result.IsSuccess)
{
return(Ok(result));
}
return(BadRequest(result));
}
public async Task <IActionResult> ForgetPassword(ForgetPasswordDto model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await _userManager.FindByEmailAsync(model.EmailAddress);
if (user == null)
{
TempData["clientMessage"] =
Helper.PrepareClientMessage("Invalid email address.", DataEnum.ClientMessageType.Error);
return(View(model));
}
var token = await _userManager.GeneratePasswordResetTokenAsync(user);
var message = "Dear: " + model.EmailAddress;
message += "<br/>Please follow the link below to reset your password<br>";
message += _configuration["WebsiteUrl"] + "/home/resetpassword?token=" + token + "&email=" + model.EmailAddress;
var messageParams = new SendMailParamsDto
{
ToList = new List <string> {
model.EmailAddress
},
IsHtml = true,
MessageBody = message,
MessageTitle = _configuration["WebsiteName"] + ": Reset password"
};
var result = await _emailServices.SendMailAsync(messageParams);
if (result)
{
TempData["clientMessage"] =
Helper.PrepareClientMessage("Reset password link sent to your email address.",
DataEnum.ClientMessageType.Success);
return(View());
}
TempData["clientMessage"] = Helper.PrepareClientMessage("An error occured while sending the email.",
DataEnum.ClientMessageType.Error);
return(View());
}
public async Task <IActionResult> ForgetPassword([FromBody] ForgetPasswordDto modelDto)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values.SelectMany(v => v.Errors).Select(modelError => modelError.ErrorMessage).ToList()));
}
await _authService.SendEmailForgetPassword(modelDto, Url);
return(Ok(new { message = "Por favior siga as instruções enviadas para o seu email.\n Obrigado!" }));
}
catch (AppException ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public async Task <ActionResult> ForgetPassword(ForgetPasswordDto model)
{
var user = await userManager.FindByEmailAsync(model.Email);
if (user != null)
{
var token = userManager.GeneratePasswordResetTokenAsync(user);
Random random = new Random();
int code = random.Next(1000, 2000);
var message = new Message(new string[] { model.Email },
"Reset Password",
$" Dear {user.UserName} welcome \n This is your code to add new password : "******"{code}");
emailSender.SendEmail(message);
return(Ok(new { email = model.Email, token = token.Result, code = code }));
}
return(BadRequest("Something is wrong..Try again"));
}
public async Task <IActionResult> ForgetPassword(ForgetPasswordDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.ValidationState));
}
var member = await _service.GetMember(model.Email, model.Phone);
if (member.Email != model.Email || member.Phone != model.Phone || member.BirthYear != model.BirthYear)
{
return(BadRequest("資枓比對不一致,請重新輸入"));
}
var newPassword = await _service.NewPassword(member);
return(Ok(newPassword));
}
public BaseApiResult Execute(ForgetPasswordDto dto)
{
BaseApiResult result = new BaseApiResult {
Message = Messages.UserNotExist
};
User user = unit.User.GetByEmail(dto.Email);
if (user != null)
{
var password = Agent.GenerateRandomNo(8);
user.SetPassword(password, encrypter);
unit.Complete();
Task myTask = Task.Run(() => notification.SendAsync(password, dto.Email));
myTask.Wait();
result.Message = Messages.PasswordSentBySms;
result.Status = true;
}
return(result);
}
public async Task SendEmailForgetPassword(ForgetPasswordDto forgetPasswordDto, IUrlHelper url)
{
if (forgetPasswordDto.Email == null)
{
throw new AppException("O Email é de preenchimento obrigatorio!");
}
var userEntity = await _userManager.FindByEmailAsync(forgetPasswordDto.Email);
if (userEntity == null)
{
throw new AppException("Email [ " + forgetPasswordDto.Email + " ] dont exist!");
}
var token = await _userManager.GeneratePasswordResetTokenAsync(userEntity);
if (token == null)
{
throw new AppException("Erro ao gerar password reset token!");
}
var forgetPasswordLink = url.Action("NewPasswordFromForgetPassword", "Auth",
new { token = token, id = userEntity.Id }, protocol: _httpContext.HttpContext.Request.Scheme);
if (forgetPasswordLink == null)
{
throw new AppException("Erro ao gerar link para confirmacao de email!");
}
Helpers.SendGrid sendEmail = new Helpers.SendGrid(_configuration);
var resulsendEmail = await sendEmail.PostMessageForgetPassword(userEntity.Email, forgetPasswordLink);
if (resulsendEmail.StatusCode != System.Net.HttpStatusCode.Accepted)
{
throw new AppException("Foi impossivel enviar o email para o reset a password! Por favor contactar um administrador");
}
}
public IActionResult ForgetPassword()
{
var model = new ForgetPasswordDto();
return(View("ForgetPassword", model));
}
public async Task <ActionResult <BaseApiResult> > ForgetPassword([FromBody] ForgetPasswordDto dto)
{
return(forgetPassword.Execute(dto));
}
//-------------------------------------------------------------------------------------------------
public Result ForgetPassword(ForgetPasswordDto user)
{
return(_repository.ForgetPassword(user));
}