private void TryToLogIn()
{
ColorEngine.Yellow();
Console.WriteLine();
Console.WriteLine(new string('*', 10) + "Login:"******"This account already exists.");
Again(TryToLogIn);
}
else
{
ColorEngine.Yellow();
Console.Write($"Welcome {CurrentUserAccount.Name}...");
Console.WriteLine("\tLet's start to play");
Console.WriteLine();
}
}
else
{
Again(TryToLogIn);
}
}
public async Task <ResponseDto <int> > UpdateUser(ClaimsPrincipal loggedInUser, AddUserDto userToUpdate)
{
var userFromDb = await _usersRepository.GetUserByLogin(userToUpdate.Login);
ResponseDto <int> response = UsersValidator.ValidateUpdateUser(loggedInUser, userToUpdate, userFromDb);
if (response.HasErrors)
{
return(response);
}
var mappedUser = Mapper.Map <User>(userToUpdate);
mappedUser.Id = userFromDb.Id;
if (!userFromDb.Password.IsEqualTo(userToUpdate.Password.GenerateSaltedHash(userFromDb.Salt)))
{
mappedUser.Salt = SaltCreator.CreateSalt();
mappedUser.Password = userToUpdate.Password.GenerateSaltedHash(mappedUser.Salt);
}
var result = await _usersRepository.UpdateUser(mappedUser);
response.Value = result;
return(response);
}
private void TryToLogUp()
{
ColorEngine.Yellow();
Console.WriteLine();
Console.WriteLine(new string('*', 10) + "Create account:" + new string('*', 10));
CurrentUserAccount = GetAccountWithData();
Validator = new UsersValidator(CurrentUserAccount);
if (Validator.IsValid())
{
bool ifCreationIsSuccessfully = DataBase.CreateNewUserAccount(CurrentUserAccount);
if (ifCreationIsSuccessfully)
{
ColorEngine.Yellow();
Console.Write($"Welcome {CurrentUserAccount.Name}...");
Console.WriteLine("\tLet's start to play");
Console.WriteLine();
}
else
{
ColorEngine.Red();
Console.WriteLine("This account already exists.");
Again(TryToLogUp);
}
}
else
{
Again(TryToLogUp);
}
}
public IActionResult Register(UsersValidator userV)
{
Users newUser = new Users();
newUser.Username = userV.Username;
newUser.Email = userV.Email;
newUser.Password = userV.Password;
if (ModelState.IsValid)
{
newUser.created_at = DateTime.Now;
newUser.updated_at = DateTime.Now;
newUser.Employment = null;
newUser.Education = null;
newUser.Experience = null;
newUser.Bio = null;
PasswordHasher <Users> Hasher = new PasswordHasher <Users>();
newUser.Password = Hasher.HashPassword(newUser, newUser.Password);
_context.Add(newUser);
_context.SaveChanges();
HttpContext.Session.SetInt32("user_id", newUser.usersId);
return(RedirectToAction("Dashboard"));
}
else
{
return(View("Index"));
}
}
/// <summary>
///异步验证
/// </summary>
public static async Task DoValidationAsync(IUsersRespository usersRespository, Users users, string validatorType)
{
var usersValidator = new UsersValidator(usersRespository);
var validatorReresult = await usersValidator.DoValidateAsync(users, validatorType);
if (!validatorReresult.IsValid)
{
throw new DomainException(validatorReresult);
}
}
public async Task <ResponseDto <bool> > ChangeRole(int id, string role)
{
var userFromDb = await _usersRepository.GetUserById(id);
ResponseDto <bool> response = UsersValidator.ValidateChangeRole(userFromDb, role);
if (response.HasErrors)
{
return(response);
}
response.Value = await _usersRepository.ChangeRole(id, role);
return(response);
}
public async Task <ResponseDto <bool> > DeleteUser(ClaimsPrincipal userIdentity, int id)
{
var userFromDb = await _usersRepository.GetUserById(id);
ResponseDto <bool> response = UsersValidator.ValidateDeleteUser(userIdentity, userFromDb);
if (response.HasErrors)
{
return(response);
}
var result = await _usersRepository.DeleteUser(id);
response.Value = result;
return(response);
}
public async Task <ResponseDto <GetUserDto> > GetUserById(int id)
{
var userFromDb = await _usersRepository.GetUserById(id);
ResponseDto <GetUserDto> response = UsersValidator.ValidateGetUserById(userFromDb);
if (response.HasErrors)
{
return(response);
}
var mappedUser = Mapper.Map <GetUserDto>(userFromDb);
response.Value = mappedUser;
return(response);
}
public async Task <ResponseDto <int> > ChangePassword(ClaimsPrincipal userIdentity, ChangePasswordDto changePasswordDto)
{
var userFromDb = await _usersRepository.GetUserByLogin(userIdentity.Identity.Name);
ResponseDto <int> response = UsersValidator.ValidateChangePassword(userFromDb, changePasswordDto);
if (response.HasErrors)
{
return(response);
}
userFromDb.Salt = SaltCreator.CreateSalt();
userFromDb.Password = changePasswordDto.NewPassword.GenerateSaltedHash(userFromDb.Salt);
var result = await _usersRepository.UpdateUser(userFromDb);
response.Value = result;
return(response);
}
public IActionResult EditProfile(UsersValidator updateUser, int edituserEmp)
{
var allUsers = _context.users.SingleOrDefault(name => name.usersId == edituserEmp);
ViewBag.user = allUsers;
Users RetrievedUser = _context.users.SingleOrDefault(user => user.usersId == edituserEmp);
ViewBag.grabUser = RetrievedUser;
RetrievedUser.Employment = updateUser.Employment;
RetrievedUser.Education = updateUser.Education;
RetrievedUser.Bio = updateUser.Bio;
RetrievedUser.Experience = updateUser.Experience;
RetrievedUser.updated_at = DateTime.Now;
_context.SaveChanges();
return(RedirectToAction("Profile", new { id = edituserEmp }));
}
/// <summary>
///异步验证
/// </summary>
public static async Task DoValidationAsync(IUsersRespository usersRespository, IEnumerable <Users> userss, string validatorType)
{
var usersValidator = new UsersValidator(usersRespository);
var domainException = new DomainException();
foreach (var users in userss)
{
var validatorReresult = await usersValidator.DoValidateAsync(users, validatorType);
if (!validatorReresult.IsValid)
{
domainException.AddErrors(validatorReresult);
}
}
if (domainException.ValidationErrors.ErrorItems.Any())
{
throw domainException;
}
}
public async Task <ResponseDto <int> > AddUser(AddUserDto userToAdd)
{
var userFromDb = await _usersRepository.GetUserByLogin(userToAdd.Login);
var response = UsersValidator.ValidateAddUser(userToAdd, userFromDb);
if (response.HasErrors)
{
return(response);
}
var userToDb = Mapper.Map <User>(userToAdd);
userToDb.Salt = SaltCreator.CreateSalt();
userToDb.Password = userToAdd.Password.GenerateSaltedHash(userToDb.Salt);
var result = await _usersRepository.AddUser(userToDb);
response.Value = result;
return(response);
}
public async Task <ResponseDto <bool> > ResetPassword(string mail)
{
var userFromDb = await _usersRepository.GetUserByMail(mail);
var response = UsersValidator.ValidateResetPassword(userFromDb, mail);
if (response.HasErrors)
{
return(response);
}
var newPassword = CreateRandomPassword(10);
userFromDb.Salt = SaltCreator.CreateSalt();
userFromDb.Password = newPassword.GenerateSaltedHash(userFromDb.Salt);
var result = await _usersRepository.UpdateUser(userFromDb);
await MailHelper.ResetPasswordMail(_appSettings.Value, mail, newPassword);
response.Value = true;
return(response);
}
public async Task <ResponseDto <LoggedInUserDto> > Authenticate(LoginUserDto loginUserDto)
{
var user = await _usersRepository.GetUserByLogin(loginUserDto.Login);
ResponseDto <LoggedInUserDto> response = UsersValidator.ValidateAuthenticate(user, loginUserDto);
if (response.HasErrors)
{
return(response);
}
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Value.Secret);
var subject = new ClaimsIdentity(
new[] { new Claim(ClaimTypes.Name, user.Login), new Claim(ClaimTypes.Role, user.Role) });
var signingCredentials = new SigningCredentials(
new SymmetricSecurityKey(key),
SecurityAlgorithms.HmacSha256Signature);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = subject,
Expires = DateTime.UtcNow.AddHours(1),
SigningCredentials = signingCredentials
};
var token = tokenHandler.CreateToken(tokenDescriptor);
response.Value = new LoggedInUserDto()
{
Id = user.Id,
Login = user.Login,
Token = tokenHandler.WriteToken(token)
};
return(response);
}
public ActionResult Login(Users model)
{
var validator = new UsersValidator().Validate(model);
if (validator.IsValid)
{
var result = _uow.GetRepo <Users>().Where(x => x.Email == model.Email && x.Password == model.Password).FirstOrDefault();
if (result != null)
{
FormsAuthentication.SetAuthCookie(result.Email, false);
return(Redirect("/Dashboard"));
}
else
{
ViewBag.msg = "Böyle bir kullanıcı mevcut değildir.";
return(View());
}
}
else
{
validator.Errors.ToList().ForEach(x => ModelState.AddModelError(x.PropertyName, x.ErrorMessage));
}
return(View());
}
