public void PasswordsDoNotMatchReturnsAFalse()
{
var mock = new Mock <IUserRepository>();
var valdationModel = new ValidateUserModel
{
emailAddress = "*****@*****.**",
PassWord = PasswordHasher.SetPassword("somepassword"),
UserName = "******"
};
var password = PasswordHasher.SetPassword("someotherpassword");
mock.Setup(e => e.GetSingleUser(valdationModel.UserName)).Returns(
new UserModel
{
Id = 1,
PassWord = password,
UserName = "******",
Active = true,
Created = new DateTime(),
EmailAddress = "*****@*****.**",
Updated = new DateTime()
});
var service = new ValidationLogic(mock.Object);
Assert.False(service.CheckIfPassWordIsCorrect(valdationModel));
}
public void CheckForPasswordFailsWhenEmailAndUserAreNullTest()
{
var mock = new Mock <IUserRepository>();
var valdationModel = new ValidateUserModel
{
emailAddress = null,
PassWord = "******",
UserName = null
};
var service = new ValidationLogic(mock.Object);
Assert.Throws <ArgumentException>(() => service.CheckIfPassWordIsCorrect(valdationModel));
}
public void EmailThatIsNotFoundThrowsARecordNotFoundException()
{
var mock = new Mock <IUserRepository>();
var valdationModel = new ValidateUserModel
{
emailAddress = "*****@*****.**",
PassWord = PasswordHasher.SetPassword("somepassword"),
UserName = null
};
mock.Setup(e => e.GetSingleUserEmail(valdationModel.emailAddress)).Returns((UserModel)null);
var service = new ValidationLogic(mock.Object);
Assert.Throws <RecordNotFoundException>(() => service.CheckIfPassWordIsCorrect(valdationModel));
}
public IActionResult Create(ValidateUserModel vum)
{
if (ModelState.IsValid)
{
User forreview = new User()
{
name = vum.name,
resteraunt = vum.resteraunt,
review = vum.review,
visit = Convert.ToDateTime(vum.visit),
stars = vum.stars
};
_visitsContext.Add(forreview);
_visitsContext.SaveChanges();
return(RedirectToAction("Reviews"));
}
return(View("Index"));
}
private ValidateUserModel GetIdFromEmailOrUsername(ValidateUserModel validate)
{
if (validate.UserName == null && validate.emailAddress == null)
{
throw new ArgumentException("You need to provide a username or email");
}
var user = new UserModel();
if (validate.UserName != null)
{
user = _userRepository.GetSingleUser(validate.UserName.ToLowerInvariant());
if (user == null)
{
throw new RecordNotFoundException($"User with name: {validate.UserName} was not found");
}
var validateModel = new ValidateUserModel
{
emailAddress = user.EmailAddress,
PassWord = user.PassWord,
UserName = user.UserName
};
return(validateModel);
}
else
{
user = _userRepository.GetSingleUserEmail(validate.emailAddress);
if (user == null)
{
throw new RecordNotFoundException($"User with email: {validate.emailAddress} was not found");
}
var validateModel = new ValidateUserModel
{
emailAddress = user.EmailAddress,
PassWord = user.PassWord,
UserName = user.UserName
};
return(validateModel);
}
}
public IActionResult Register(ValidateUserModel validateUserModel)
{
if (ModelState.IsValid)
{
PasswordHasher <ValidateUserModel> temp = new PasswordHasher <ValidateUserModel>();
validateUserModel.password = temp.HashPassword(validateUserModel, validateUserModel.password);
User newUser = new User()
{
firstname = validateUserModel.firstname,
lastname = validateUserModel.lastname,
email = validateUserModel.email,
password = validateUserModel.password
};
_context.Users.Add(newUser);
_context.SaveChanges();
return(RedirectToAction("Index", "Home", new { id = newUser.Userid }));
}
return(View("Index"));
}
public IActionResult Register(ValidateUserModel validateUserModel)
{
if (ModelState.IsValid)
{
PasswordHasher <ValidateUserModel> temp = new PasswordHasher <ValidateUserModel>();
validateUserModel.password = temp.HashPassword(validateUserModel, validateUserModel.password);
User newUser = new User()
{
firstname = validateUserModel.firstname,
lastname = validateUserModel.lastname,
username = validateUserModel.username,
password = validateUserModel.password,
wallet = 1000
};
_context.Users.Add(newUser);
_context.SaveChanges();
HttpContext.Session.SetInt32("loggedID", newUser.Userid);
return(RedirectToAction("Current", "Auction"));
}
return(View("Index"));
}
public bool ValidateUser(ValidateUserModel validateUserModel)
{
UserModel userModel = GetUserByUsername(validateUserModel.Username);
if (userModel != null)
{
return userModel.Password == validateUserModel.Password;
}
else
{
return false;
}
}
public bool CheckIfPassWordIsCorrect(ValidateUserModel validate)
{
var userFromDatabase = GetIdFromEmailOrUsername(validate);
return(PasswordHasher.DoesPasswordMatch(validate.PassWord, userFromDatabase.PassWord));
}
public ActionResult LogOn(LogOnModel model, string returnUrl)
{
if (ModelState.IsValid)
{
ValidateUserModel vum = new ValidateUserModel();
vum.Password = model.Password;
vum.Username = model.UserName.Trim();
if (accountServices.ValidateUser(vum))
{
FormsService.SignIn(model.UserName, model.RememberMe);
if (!String.IsNullOrEmpty(returnUrl))
{
return Redirect(returnUrl);
}
else
{
return RedirectToAction("Index", "Home");
}
}
else
{
ModelState.AddModelError("", "The user name or password provided is incorrect.");
}
}
return View(model);
}
public IActionResult Check([FromBody] ValidateUserModel validate)
{
var valid = _validationLogic.CheckIfPassWordIsCorrect(validate);
return(Ok(valid));
}
