public ActionResult ResetPassword(UserResetPassword urp)
{
bool UserResetPassword = Services.UserService.ResetPassword(urp);
TempData["Success"] = "Data Deleted Successfully!";
return(RedirectToAction("Index", "User"));
}
} // SetTemplateAndVariables
private string GetFromDB()
{
var oNewPassGenerator = new UserResetPassword(CustomerId);
oNewPassGenerator.Execute();
if (!oNewPassGenerator.Success)
{
throw new StrategyAlert(
this,
"Failed to generate a new password for customer " + CustomerId
);
} // if
var sp = new InitCreatePasswordTokenByUserID(CustomerId, DB, Log);
sp.Execute();
if (sp.Token == Guid.Empty)
{
throw new StrategyAlert(
this,
"Failed to generate a change password token for customer " + CustomerId
);
} // if
return(CustomerData.OriginSite + "/Account/CreatePassword?token=" + sp.Token.ToString("N"));
} // GetFromDB
} // Name
protected override void SetTemplateAndVariables()
{
var oNewPassGenerator = new UserResetPassword(CustomerId);
oNewPassGenerator.Execute();
if (!oNewPassGenerator.Success)
{
throw new StrategyAlert(this, "Failed to generate a new password for customer " + CustomerData.Mail);
}
TemplateName = "Mandrill - Temporary password";
var sp = new InitCreatePasswordTokenByUserID(CustomerId, DB, Log);
sp.Execute();
if (sp.Token == Guid.Empty)
{
throw new StrategyAlert(
this,
"Failed to generate a change password token for customer " + CustomerId
);
} // if
Variables = new Dictionary <string, string> {
{ "FirstName", string.IsNullOrEmpty(CustomerData.FirstName) ? "customer" : CustomerData.FirstName },
{ "Link", CustomerData.OriginSite + "/Account/CreatePassword?token=" + sp.Token.ToString("N") }
};
} // SetTemplateAndVariables
public bool ResetPassword(UserResetPassword userModel)
{
var body = JsonConvert.SerializeObject(userModel);
bool UserResetPassword = ServerResponse.Invoke <bool>("api/user/resetPassword?id=" + userModel.Id, body, "Post");
return(UserResetPassword);
}
public async Task <IActionResult> ResetPassword(UserResetPassword userResetPassword)
{
var userId = new Guid(_httpContextAccessor.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier));
var responseCode = await _repo.ChangePassword(userId, userResetPassword.OldPassword, userResetPassword.NewPassword);
return(StatusCode(responseCode));
}
public async Task <string> ResetPassword(string userMail)
{
var hasUser = await _dbUser.Get(userMail);
var retorno = "";
if (hasUser)
{
UserResetPassword resetPassword = new UserResetPassword();
resetPassword.Email = userMail;
resetPassword.Token = CreateHash(userMail, CreateSalt());
_dbResetPassword.Post(resetPassword);
string subject = "Reset de Senha";
string body = " Olá!<br/>Segue abaixo link para troca de senha conforme solicitado: https://lalalala/" + resetPassword.Token;
try
{
_smtpInfra.SendMail(userMail, subject, body);
}
catch (Exception e)
{
return("Houve um erro ao enviar o e-mail...");
}
return("Solicitação de troca de senha enviada para o e - mail informado");
}
else
{
retorno = "E-mail não localizado no cadastro!";
}
return(retorno);
}
public void ChangePassword(UserResetPassword model, int Userid, int OrganizationId)
{
User user = base.GetByID(Userid);
user.Password = AES.Encrypt(model.Password);
Update(user);
StringBuilder emailBody = new StringBuilder(System.IO.File.ReadAllText(HttpContext.Current.Server.MapPath("~/HtmlTemplates/ChangePasswordEmailTemplate.html")));
emailBody.Replace("$$UserName$$", user.UserName).Replace("$$Password$$", model.Password);
new EmailManagement().SendMailToUserWithCCANdAttachment(emailBody.ToString(), "Change Password", null, user.EmailID, null, new List <byte[]>(), new List <string>());
}
public void ResetPassword(string userName, string url)
{
UserResetPassword resetPass = new UserResetPassword(userName);
using (_uow)
{
_userResetPasswordRepository.Insert(resetPass);
_uow.Commit();
}
_emailService.NotifyResetPassword(userName, resetPass.RequestToken, url);
}
/// <summary>
/// Function to convert a Client UserResetPassword to DAL Users
/// </summary>
/// <param name="userResetPassword">UserResetPassword</param>
/// <returns>DAL Users</returns>
public static DAL.Entities.Users ToDal(this UserResetPassword userResetPassword)
{
if (userResetPassword == null)
{
return(null);
}
return(new DAL.Entities.Users
{
Email = userResetPassword.Email,
Password = userResetPassword.Password,
Id = userResetPassword.Id
});
}
public IHttpActionResult ResetPassword(UserResetPassword data)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
_userService.ResetPassword(data.UserName, data.Password);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public ActionResult ResetPassword(UserResetPassword model)
{
try
{
if (!ModelState.IsValid)
{
return(View(model));
}
var userId = Session["UserId"].ToString();
var code = UserManager.GeneratePasswordResetToken(userId);
var user = UserManager.FindById(userId);
if (user == null)
{
// Don't reveal that the user does not exist
return(RedirectToAction("ResetPasswordConfirmation", "Acoount"));
}
var result = UserManager.ResetPassword(user.Id, code, model.Password);
if (result.Succeeded)
{
if (Session["AdminFirstTimeLogin"] != null && Session["AdminFirstTimeLogin"].ToString() != "true")
{
var userDetail = _userDetailRepository.GetUserDetailUserId(userId);
if (userDetail != null)
{
userDetail.IsFirstTimeLogin = true;
_userDetailRepository.UpdateUserDetail(userDetail);
}
}
_userDetailRepository.UpdateUserPassword(user.Id);
AuthenticationManager.SignOut();
return(RedirectToAction("ResetPasswordConfirmation", "Account"));
}
AddErrors(result);
foreach (var error in result.Errors)
{
ViewBag.Message = error;
ModelState.AddModelError("", error);
}
return(View());
}
catch (Exception ex)
{
_errorLog.LogException(ex);
throw;
}
}
public async Task <IActionResult> ResetPassword([FromBody] UserResetPassword model)
{
var user = await _repository.FindUserById(model.Id);
var results = false;
if (user != null)
{
results = await _repository.ResetPassword(user, model.Code, model.Password) == IdentityResult.Success;
if (results)
{
return(Json(new { result = results, message = "The password has been resetted successful." }));
}
}
return(Json(new { result = results, message = "The password cannot reset, invalid user!" }));
}
public ActionResult UserResetPassword(UserResetPassword model)
{
try
{
if (!ModelState.IsValid)
{
return(View(model));
}
var userId = Session["UserId"].ToString();
var code = UserManager.GeneratePasswordResetToken(userId);
var user = UserManager.FindById(userId);
if (user == null)
{
// Don't reveal that the user does not exist
return(RedirectToAction("ResetPasswordConfirmation", "Login"));
}
var result = UserManager.ResetPassword(user.Id, code, model.Password);
if (result.Succeeded)
{
if (Convert.ToBoolean(Session["FirstTimeLogin"]))
{
var userDetail = _userDataRepository.FirstOrDefault(x => x.UserId == userId);
if (userDetail != null)
{
userDetail.IsFirstTimeLogin = true;
userDetail.ModifiedDateTime = DateTime.UtcNow;
_userDataRepository.Update(userDetail);
_userDataRepository.SaveChanges();
}
}
_userDetailRepository.UpdateUserPassword(user.Id);
AuthenticationManager.SignOut();
return(RedirectToAction("ResetPasswordConfirmation", "Login"));
}
AddErrors(result);
ViewBag.Message = "Invalid Tocken";
return(View());
}
catch (Exception ex)
{
_errorLog.LogException(ex);
throw;
}
}
public async Task <bool> ResetPassword(UserResetPassword model)
{
var user = await _userManager.FindByIdAsync(model.Id.ToString());
if (user == null)
{
return(false);
}
try
{
var result = await _userManager.ResetPasswordAsync(user, model.Code.Replace(" ", "+"), model.Password);
return(result.Succeeded);
}
catch (Exception)
{
throw new Exception("Không thể khôi phục mật khẩu");
}
}
public ActionResult ResetPassword(int id, UserResetPassword form)
{
var user = Database.Session.Load <User>(id);
if (user == null)
{
return(HttpNotFound());
}
form.Username = user.Username;
if (!ModelState.IsValid)
{
return(View(form));
}
user.SetPassword(form.Password);
Database.Session.Update(user);
return(RedirectToAction("index"));
}
public async Task <IActionResult> ResetPassword([FromRoute] string id, [FromBody] UserResetPassword user)
{
if (string.IsNullOrEmpty(id))
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
throw new Exception(Contants.UNVALID);
}
var objDB = userService.UserExistById(id, _context);
if (objDB == null)
{
throw new Exception(Contants.NOTFOUND);
}
objDB.Password = user.Password;
await userService.Update(objDB, _context);
return(NoContent());
}
public async Task <ActionResult> ResetPassword(UserResetPassword form, string action)
{
if (action == "Reset")
{
if (!ModelState.IsValid)
{
return(View(form));
}
var user = await _userManager.FindByEmailAsync(form.Email);
if (user == null)
{
// Don't reveal that the user does not exist
ModelState.AddModelError("", "User to reset password not found!");
return(View());
}
string code = await _userManager.GeneratePasswordResetTokenAsync(user);
var result = await _userManager.ResetPasswordAsync(user, code, form.Password);
if (result.Succeeded)
{
return(RedirectToAction("index", "user"));
}
else
{
ModelState.AddModelError("", "Reset Password failed: ");
}
}
else
{
return(RedirectToAction("index", "user"));
}
return(View());
}
/// <summary>
/// Request reset password token
/// </summary>
/// <param name="email"></param>
/// <returns></returns>
public async Task <ApiOkResult> ResetPasswordRequest(string email)
{
var user = await _appUserManager.FindByEmailAsync(email);
if (user == null)
{
throw new EntityNotFoundException(email, typeof(AppUser));
}
var token = UserInviteCodeGenerator.Generate();
var entity = new UserResetPassword
{
Code = token,
UserId = user.Id
};
entity = await _userResetPasswordRepository.Insert(entity);
var model = new ResetPasswordModel
{
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
Token = token,
Url = _urlRedirectSettings.ResetPasswordWithToken(user.Email, token)
};
var mailBody = await _templateParser.Render(EmailTemplateCollection.USER_RESET_PASSWORD, model);
var to = user.Email;
await _emailSendTaskRepository.InsertEmail(to, "Reset password", mailBody, Infrastructure.Entities.Tasks.EmailTaskBot.MadRatBot);
return(new ApiOkResult(true));
}
public async Task <string> Post(UserResetPassword userEmail)
{
return(await _service.ResetPassword(userEmail.Email));
}
public JsonResult ResetPassword(RegisterViewModel request)
{
request.Password = request.Password ?? "";
var requiredFields = new List <Tuple <string, string, DataType> >
{
Tuple.Create("username", request.RegNumber, DataType.Default),
};
var validUserInputs = _validateService.Validate(requiredFields);
if (!validUserInputs.Valid)
{
return(Json(new ReturnData <string>
{
Message = validUserInputs.Errors,
Success = validUserInputs.Valid
}));
}
try
{
var registeredUser = _context.Users.FirstOrDefault(u => (u.UserName.ToUpper().Equals(request.RegNumber.ToUpper())) || (u.Code.ToString() == request.RegNumber) || (u.Id.ToString() == request.RegNumber));
if (registeredUser == null)
{
return(Json(new ReturnData <string>
{
Success = false,
Message = "Username not found"
}));
}
if (string.IsNullOrEmpty(registeredUser.UserName))
{
return(Json(new ReturnData <string>
{
Success = false,
Message = "Username not found"
}));
}
registeredUser.PasswordHash = registeredUser.PasswordHash ?? "";
var hashedNewPassword = SecurePasswordHasher.Hash(request.Password);
if (hashedNewPassword.ToUpper().Equals(registeredUser.PasswordHash.ToUpper()))
{
return(Json(new ReturnData <string>
{
Success = false,
Message = "Kindly use a different password from the previous"
}));
}
var userResetPassword = new UserResetPassword();
if ((request.Role == Role.Admin) || (request.Role == Role.All))
{
userResetPassword = _context.UserResetPasswords.FirstOrDefault(u => u.UserId == registeredUser.Id && u.Status == false);
registeredUser.PasswordHash = SecurePasswordHasher.Hash(request.Password);
registeredUser.EmailConfirmed = true;
registeredUser.Status = true;
if (userResetPassword != null)
{
userResetPassword.Status = true;
_context.Update(userResetPassword);
}
_context.Update(registeredUser);
_context.SaveChanges();
return(Json(new ReturnData <string>
{
Success = true,
Message = "Password reset successful"
}));
}
userResetPassword = new UserResetPassword
{
UserId = registeredUser.Id,
ResetCode = Guid.NewGuid().ToString(),
DateCreated = DateTime.Now,
Status = false
};
var success = false;
var userGroup = _context.UserGroups.FirstOrDefault(u => u.Id == registeredUser.UserGroupsId);
mailMethod = MailSendMethod.PasswordReset;
var subject = "Reset Account Password";
if (userGroup?.Role == Role.Student)
{
var classStatus = _context.Settings.FirstOrDefault()?.ClassStatus;
var result = _unisolApiProxy.CheckStudentExists(request.RegNumber, classStatus).Result;
var jdata = new ProcessJsonReturnResults <UserDetails>(result).UnisolApiData;
var emailContent = new MailsViewModel {
UserCode = request.RegNumber,
Firstname = jdata.Data.Names,
Code = userResetPassword.ResetCode,
Email = registeredUser.Email,
MailMethod = mailMethod,
PortalUrl = request.PortalUrl,
Subject = subject
};
success = emailSender.SendEmail(emailContent);
}
if (userGroup?.Role == Role.Staff)
{
var result = _unisolApiProxy.CheckEmployeeExists(request.RegNumber).Result;
var jdata = JsonConvert.DeserializeObject <ReturnData <HrpEmployee> >(result);
var emailContent = new MailsViewModel
{
UserCode = request.RegNumber,
Firstname = jdata.Data.Names,
PortalUrl = request.PortalUrl,
Code = userResetPassword.ResetCode,
Email = registeredUser.Email,
MailMethod = mailMethod,
Subject = subject
};
success = emailSender.SendEmail(emailContent);
}
if (success)
{
registeredUser.Code = userResetPassword.ResetCode;
_context.SaveChanges();
var email = registeredUser.Email.Split('@');
return(Json(new ReturnData <bool>
{
Success = true,
Message = $"We have sent a link to reset your password, please check your email ({email[0].Substring(0, 1)}*****{email[0].Substring(email[0].Length - 2)}@{email[1]})."
}));
}
return(Json(new ReturnData <bool>
{
Success = false,
Message = "There was a problem while trying reset your password, please contact admin"
}));
}
catch (Exception ex)
{
return(Json(new ReturnData <string>
{
Success = false,
Message = "Something went wrong, please try again after sometime.",
Error = new Error(ex)
}));
}
}
/// <summary>
/// Function to reset password
/// </summary>
/// <param name="userResetPassword">UserResetPassword</param>
/// <returns>bool:true if success</returns>
public bool ResetPaswword(UserResetPassword userResetPassword)
{
return(Repository.ResetPassword(userResetPassword.ToDal()));
}
public void Insert(UserResetPassword resetData)
{
_databaseContext.UserResetPasswords.Add(resetData);
}
public ActionResult <OperateResult <Auth_User> > ResetPwd([FromBody] UserResetPassword param)
{
return(Json(_service.ResetPassword(param)));
}
public string ChangePassword(UserResetPassword model)
{
this._IUserRepository.ChangePassword(model, base.UserId, base.OrganizationId);
return("done");
}
