public async Task <IActionResult> ResetPasswordConfirm(PasswordVM model)
{
string token = TempData["token"].ToString();
string id = TempData["userid"].ToString();
AppUser user = await Usermanager.FindByIdAsync(id);
if (user != null)
{
IdentityResult result = await Usermanager.ResetPasswordAsync(user, token, model.Password);
if (result.Succeeded)
{
await Usermanager.UpdateSecurityStampAsync(user);
TempData["passwordResetInfo"] = "sifreniz basariyla yenilendi";
}
else
{
AddErrors(result);
}
}
else
{
ModelState.AddModelError("", "boyle biri yok");
}
return(View());
}
public Password(PasswordVM passwordVM, string userId)
{
ModifyTo(passwordVM);
CreateDate = DateTime.Now;
NumOfVisits = 1;
UserId = userId;
}
//GET: User/UpdatePassword
public ActionResult UpdatePassword(int editId)
{
PasswordVM pass = new PasswordVM();
pass.Id = editId;
return(View(pass));
}
public ActionResult ModifyPassword(PasswordVM model)
{
if (ModelState.IsValid)
{
var db = new userEntities();
var currentUserEmail = Session["TEMP"];
var v = db.users.Where(u => u.email == currentUserEmail).FirstOrDefault();
if (v != null)
{
var hash = Crypto.HashPassword(model.password);
v.password = hash;
db.SaveChanges();
Session.Remove("TEMP");
return(RedirectToAction("Login", "User"));
}
else
{
ViewData["Message"] = "User doesnt exist";
}
}
return(View(model));
}
public async Task <IActionResult> ChangePassword(PasswordVM passwordVM)
{
passwordVM.Token = HttpContext.Request.Headers["Authorization"].FirstOrDefault().Split(' ').ElementAt(1);
var result = await _userService.ChangePassword(passwordVM);
return(Ok(result));
}
public async Task <IActionResult> ResetPassword([FromForm] PasswordVM passwordVM)
{
if (passwordVM.Token == null)
{
return(BadRequest(new
{
message = "can't access like that !",
is_erro = true
}));
}
var result = await _emailService.ResetPassword(passwordVM);
if (result)
{
return(Ok(new
{
message = "Your password has reset !",
is_erro = false
}));
}
else
{
return(BadRequest(new
{
message = "can't reset password, something wrong !",
is_erro = true
}));
}
}
public JsonResult UpdateAdminPassword(PasswordVM passvm)
{
if (Session["Admin"] != null)
{
int userId = (int)Session["AdminId"];
Models.Admin xdb = db.Admin.Find(userId);
if (Crypto.VerifyHashedPassword(xdb.Password, passvm.oldpass) == true)
{
xdb.Password = Crypto.HashPassword(passvm.newpass);
db.Entry(xdb).State = EntityState.Modified;
db.SaveChanges();
return(Json("true", JsonRequestBehavior.AllowGet));
}
else
{
return(Json("false", JsonRequestBehavior.AllowGet));
}
}
return(Json("sessionerror", JsonRequestBehavior.AllowGet));
}
public IActionResult ChangePassword([FromBody] PasswordVM password)
{
//get the user id from the JWT token
var userid = httpContext?.HttpContext?.User?.FindFirst(JwtRegisteredClaimNames.Sub).Value;
if (userid != null)
{
User user = context.Users.Where(u => u.userId == Guid.Parse(userid)).FirstOrDefault();
//is the old password correct?
if (user.password != HashString.HashThat(password.oldPassword, config["salt"]))
{
return(Json(new JSONResponseVM {
success = false, message = "Old password is incorrect"
}));
}
//change the password
user.password = HashString.HashThat(password.password, config["salt"]);
context.SaveChanges();
return(Json(new JSONResponseVM {
success = true, message = "New password created!"
}));
}
return(Json(new JSONResponseVM {
success = false, message = "This user doesn't exist"
}));
}
public IActionResult ResetPassword(string userID, string code)
{
PasswordVM recover = new PasswordVM();
recover.UserID = userID;
recover.BaseCode = code;
return(Ok(recover));
}
public void ModifyTo(PasswordVM passwordVM)
{
Name = passwordVM.Name;
Username = passwordVM.Username;
PasswordEncrypted = passwordVM.PasswordEncrypted;
Url = passwordVM.Url;
Notes = passwordVM.Notes;
LastModified = DateTime.Now;
}
public ActionResult DoChangePassword(PasswordVM passwordVm)
{
passwordVm.UserId = AppContext.UserId;
var result = BS.ChangePassword(passwordVm);
return(new JsonNetResult()
{
Data = result
});
}
public async Task <ApiResultVM <string> > ChangePassword(PasswordVM passwordVM)
{
var client = _httpClientFactory.CreateClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + passwordVM.Token);
client.BaseAddress = new Uri(_configuration["UrlApi"]);
var response = await client.PutAsJsonAsync("/api/users/password", passwordVM);
var body = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <ApiResultVM <string> >(body));
}
public async Task <IActionResult> ChangePassword()
{
PasswordVM model = new PasswordVM();
var user = await userManager.GetUserAsync(HttpContext.User);
var token = await userManager.GeneratePasswordResetTokenAsync(user);
model.UserID = user.Id;
model.Email = user.Email;
model.BaseCode = token;
return(Ok(model));
}
public async Task <IActionResult> ResetPasswordConfirm(PasswordVM model)
{
var user = await userManager.FindByIdAsync(model.UserID);
var result = await userManager.ResetPasswordAsync(user, model.BaseCode, model.Password);
if (result.Succeeded)
{
return(Ok(new UserManagerResponse {
Message = "Successfuly reset password", IsSuccess = true
}));
}
return(BadRequest("Somethin went wrong"));
}
public async Task <IActionResult> ResetPasswordConfirm(PasswordVM model)
{
if (ModelState.IsValid)
{
var user = await userManager.FindByIdAsync(model.UserID);
var result = await userManager.ResetPasswordAsync(user, model.BaseCode, model.Password);
if (result.Succeeded)
{
await signInManager.PasswordSignInAsync(user, model.Password, false, false);
}
return(RedirectToAction(nameof(Profile)));
}
return(View());
}
public async Task <ActionResult <AccountVM> > ChangePassword(int id, PasswordVM password)
{
var accountInDb = await _context.Accounts.Where(u => u.Id == id).FirstAsync();
var r = _userManager.ChangePasswordAsync(accountInDb, password.CurrentPassword, password.NewPassword);
if (r.Result.Succeeded)
{
return(Content("Success"));
}
else
{
var message = string.Join(", ", r.Result.Errors.Select(x => "Code " + x.Code + " Description" + x.Description));
return(Content(message));
}
}
public async Task <ApiResultVM <string> > ChangePassword(PasswordVM passwordVM)
{
var handler = new JwtSecurityTokenHandler();
var token = handler.ReadJwtToken(passwordVM.Token);
var username = token.Claims.Where(x => x.Type.Equals("UserName")).FirstOrDefault().ToString().Split(' ').ElementAt(1);
var passwordHash = new PasswordHash();
var password = passwordHash.HashPassword(passwordVM.NewPassword);
var userDTO = await dbset.Where(x => x.UserName.Equals(username)).AsNoTracking().SingleOrDefaultAsync();
userDTO.PassWord = password;
userDTO.UpdateAt = DateTime.Now;
dbset.Update(userDTO);
await _dbContextDTO.SaveChangesAsync();
return(new ApiSuccessResultVM <string>("Password has changed"));
}
public bool ChangePassword(PasswordVM vm)
{
var changed = false;
using (var uow = GetUnitOfWork())
{
var user = uow.Repository <T_S_User>().Query().Filter(x => x.UserId == vm.UserId).Get().FirstOrDefault();
if (user != null && user.Password.Equals(vm.OldPassword))
{
user.Password = vm.NewPassword;
uow.Repository <T_S_User>().Update(user);
uow.Save();
changed = true;
}
}
return(changed);
}
public async Task <IActionResult> ChangePasswordConfirm(PasswordVM model)
{
var user = await userManager.FindByIdAsync(model.UserID);
var result = await userManager.ChangePasswordAsync(user, model.OldPassword, model.Password);
if (result.Succeeded)
{
return(Ok(new UserManagerResponse {
Message = "Succesfully Change", IsSuccess = true
}));
}
else
{
return(Ok(new UserManagerResponse {
Message = "Something went wrong", IsSuccess = false, Errors = result.Errors.Select(e => e.Description)
}));
}
}
public async Task <IActionResult> ChangePasswordConfirm(PasswordVM model)
{
if (ModelState.IsValid)
{
var user = await userManager.FindByIdAsync(model.UserID);
var result = await userManager.ChangePasswordAsync(user, model.OldPassword, model.Password);
if (result.Succeeded)
{
return(RedirectToAction(nameof(Profile)));
}
else
{
model.Errormessage = "Password did not match";
return(View("ChangePassword", model));
}
}
return(View("ChangePassword", model));
}
public async Task <IActionResult> ActualizarPassword([FromBody] PasswordVM vmodel, int id)
{
// validar password vacios
if (vmodel.PasswordActual.Trim() == string.Empty || vmodel.PasswordNuevo.Trim() == string.Empty)
{
return(StatusCode(StatusCodes.Status406NotAcceptable, new { ok = false, mensaje = "No debe enviar password vacios" }));
}
// Es el mismo password ?
if (vmodel.PasswordActual.Trim() == vmodel.PasswordNuevo.Trim())
{
return(StatusCode(StatusCodes.Status406NotAcceptable, new { ok = false, mensaje = "Los password son iguales" }));
}
//buscar la Usuario
var itemEncontrado = await this.Repositorio.Usuarios.GetByIdAsync(id);
// Verfivar password actual
var valid = Crypto.VerifyHashedPassword(itemEncontrado.Password, vmodel.PasswordActual.Trim());
if (!valid)
{
return(StatusCode(StatusCodes.Status406NotAcceptable, new { ok = false, mensaje = "El password actual no es correcto." }));
}
//Hacer el cambio de password
var hashNuevoPassword = Crypto.HashPassword(vmodel.PasswordNuevo);
//Actualizar en BD
itemEncontrado.FechaMod = DateTime.Now;
itemEncontrado.Password = hashNuevoPassword;
var r = this.Repositorio.Usuarios.Update(itemEncontrado);
await this.Repositorio.CompleteAsync();
return(Ok(new { ok = true, mensaje = "El password se cambio correctamente." }));
}
public async Task <IActionResult> ChangePasswordAction(PasswordVM passwordVM)
{
if (ModelState.IsValid)
{
passwordVM.Token = HttpContext.Session.GetString("token_access");
var result = await _userApiClient.ChangePassword(passwordVM);
if (result.IsSuccessed == true)
{
await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
HttpContext.Session.Remove("token_access");
TempData["SuccessResult"] = result.Entity;
return(RedirectToAction("Login", "User"));
}
else
{
ModelState.AddModelError("", result.Message);
return(View("ChangePassword", passwordVM));
}
}
return(View("ChangePassword", passwordVM));
}
public async Task <bool> ResetPassword(PasswordVM passwordVM)
{
var handler = new JwtSecurityTokenHandler();
var token = handler.ReadJwtToken(passwordVM.Token);
var email = token.Claims.Where(x => x.Type.Equals("Email")).FirstOrDefault().ToString().Split(' ').ElementAt(1);
if (passwordVM.NewPassword != passwordVM.ConfirmNewPassword || passwordVM.NewPassword == null)
{
_dbContextDTO.Dispose();
return(false);
}
var passwordHash = new PasswordHash();
var password = passwordHash.HashPassword(passwordVM.NewPassword);
var userVM = await _userService.GetUser(email);
var userDTO = _mapper.Map <AppUserDTO>(userVM);
userDTO.PassWord = password;
userDTO.UpdateAt = DateTime.Now;
dbset.Update(userDTO);
await _dbContextDTO.SaveChangesAsync();
return(true);
}
public ActionResult ForgotPassword(MailVM mailView)
{
string[] mailTo;
MailDTO mail;
bool isMailSent = false;;
bool isResetPassword = false;
int UserMasterId;
string newPassword = null;
string newPasswordEncrypted = null;
if (mailView != null)
{
UserMasterId = _mail.CheckMail(mailView.To);
if (UserMasterId != 0)
{
PasswordGenerator.PasswordGenerator passGen = new PasswordGenerator.PasswordGenerator();
passGen.InitializePasswordArrays();
PasswordVM passVM = new PasswordVM();
passVM.CapitalLettersLength = 1;
passVM.DigitsLength = 1;
passVM.SmallLettersLength = 3;
passVM.SpecialCharactersLength = 1;
passVM.PasswordLength = 6;
newPassword = passGen.GeneratePassword(passVM); // get password
if (!string.IsNullOrEmpty(newPassword))
{
newPasswordEncrypted = encrypt.encryption(newPassword);//Encrypt Password
isResetPassword = _resetPassSvc.ResetPassword(newPasswordEncrypted, UserMasterId);
if (isResetPassword)
{
mail = new MailDTO();
mail.From = "*****@*****.**";
mail.IsBodyHtml = false;
mail.MailSubject = "Reset Password";
mail.MailBody = "Your new password which is reset is: " + newPassword;
mail.SmtpPort = 587;
mail.SmtpServer = "smtp.gmail.com";
mail.EnableSSL = true;
mail.UseDefaultCredentials = true;
//split the ';' separated string To a List
mailTo = mailView.To.Split(';');
mail.ToList = new List <string>();
for (int i = 0; i < mailTo.Length; i++)
{
mail.ToList.Add(mailTo[i]);
}
//instantiate CC and Bcc List if possible
isMailSent = _mail.SendMail(mail);// call SendMail method to send the mail
if (isMailSent)
{
mailView.SuccessOrFailureMessage = "Your new password: "******" is sent to mail";
mailView.MessageColor = "green";
}
else
{
mailView.SuccessOrFailureMessage = "Your password was not reset in a proper manner";
mailView.MessageColor = "red";
}
}
}
}
else
{
mailView.SuccessOrFailureMessage = "Sorry your email was incorect. Please enter again";
mailView.MessageColor = "red";
}
}
return(View(mailView));
}
