public User Authenticate(UserSignInDto model)
{
var user = _db.Users.SingleOrDefault(x => x.Username == model.Username);
bool isValidPassword = BCrypt.Net.BCrypt.Verify(model.Password, user.Password);
if (isValidPassword)
{
//generate Token
var tokenHandler = new JwtSecurityTokenHandler();
var secretBytes = Encoding.UTF8.GetBytes(Utilities.SecretKey);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.Username)
}),
Expires = DateTime.Now.AddMinutes(30),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(secretBytes), SecurityAlgorithms.HmacSha256)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
user.Token = tokenHandler.WriteToken(token);
return(user);
}
return(null);
}
public async Task <IActionResult> LogIn(UserSignInDto model)
{
var user = await userManager.FindByNameAsync(model.UserName);
if (user != null)
{
var result = await _signInManager.PasswordSignInAsync(user.UserName, model.Password, model.RememberMe, false);
if (result.Succeeded)
{
var roles = await userManager.GetRolesAsync(user);
if (roles.Contains("Admin"))
{
return(RedirectToAction("Index", "Home", new { area = "Admin" }));
}
else
{
return(RedirectToAction("Index", "Home", new { area = "Member" }));
}
}
else
{
ModelState.AddModelError("", "Kullanıcı Adı veya Şifre Bulunamadı");
}
}
return(View());
}
public async Task <IActionResult> LogIn(UserSignInDto model)
{
var user = await userManager.FindByNameAsync(model.UserName);
if (user != null)
{
var result = await signInManager.PasswordSignInAsync(user.UserName, model.Password, model.RememberMe, false);
if (result.Succeeded)
{
var roles = await userManager.GetRolesAsync(user);
if (roles.Contains("Secretary"))
{
return(RedirectToAction("Index", "Profile"));
}
else
{
return(RedirectToAction("Index", "Profile"));
}
}
}
else
{
ModelState.AddModelError("", "Kullanıcı Adı veya Şifre Hatalı");
}
return(View(model));
}
public User Map(UserSignInDto source)
{
var target = new User();
target.Email = source.Email;
target.Password = source.Password;
return(target);
}
public IActionResult Authenticate(UserSignInDto model)
{
if (ModelState.IsValid)
{
var user = userRepo.Authenticate(model);
return(Ok(user));
}
return(BadRequest(new { message = "NotValid" }));
}
public async Task <IActionResult> SignIn(UserSignInDto userSignInDto)
{
User user = await GetUser(userSignInDto.Email, userSignInDto.Password).ConfigureAwait(false);
if (user == null)
{
return(NotFound());
}
await Authorize(user).ConfigureAwait(false);
return(RedirectToRoute(nameof(UsersController.GetUser), new { id = user.UserId }));
}
public async Task <ActionResult <IResponse <object> > > SignInAsync(UserSignInDto dto)
{
var validationResponse = UserValidator.Validate(dto);
if (!validationResponse.IsValid)
{
return(BadRequest(validationResponse));
}
var attemptCredentialsResponse = UserLogic.SignIn(UserMapper.Map(dto));
if (!attemptCredentialsResponse.IsValid)
{
return(BadRequest(attemptCredentialsResponse));
}
if (attemptCredentialsResponse != null)
{
var claims = new List <Claim>
{
new Claim(nameof(RequestContext.Email), attemptCredentialsResponse.Data.Email),
new Claim(nameof(RequestContext.UserId), attemptCredentialsResponse.Data.Id.ToString()),
};
var claimsIdentity = new ClaimsIdentity(
claims, CookieAuthenticationDefaults.AuthenticationScheme);
var authProperties = new AuthenticationProperties
{
AllowRefresh = true,
ExpiresUtc = DateTimeOffset.UtcNow.AddMinutes(30),
IsPersistent = true,
IssuedUtc = DateTimeOffset.Now,
RedirectUri = "User/SignIn"
};
await HttpContext.SignInAsync(
CookieAuthenticationDefaults.AuthenticationScheme,
new ClaimsPrincipal(claimsIdentity),
authProperties);
HttpContext.Response.Cookies.Append("account", JsonSerializer.Serialize(new { id = attemptCredentialsResponse.Data.Id, email = dto.Email }), new Microsoft.AspNetCore.Http.CookieOptions
{
HttpOnly = false
});
}
return(Ok(attemptCredentialsResponse.Data));
}
private void ValidateSignInModel(UserSignInDto model, User user)
{
byte[] md5Hash = _md5.ComputeHash(Encoding.ASCII.GetBytes(model.Password));
string hashedPassword = Encoding.ASCII.GetString(md5Hash);
if (user == null)
{
throw new Exception("User does not exists");
}
if (user.Password != hashedPassword)
{
throw new Exception("Wrong Password");
}
}
public async Task <LoginResultDto> LogInAsync(UserSignInDto userDto)
{
try
{
userDto.PasswordHash = GetPasswordHash(userDto.Password);
var user = await _userAuthDalFacade.FindByEmailAsync(userDto.Email);
if (user == null)
{
return new LoginResultDto {
Success = false, Message = $"Пользователь {userDto.Email} не найден"
}
}
;
var passwordValid = userDto.PasswordHash == user.PasswordHash;
if (!passwordValid)
{
return new LoginResultDto {
Success = false, Message = $"Неправильный пароль"
}
}
;
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim("UserId", user.Id),
new Claim("ExpDate", DateTime.UtcNow.AddDays(7).ToString())
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_appsettings.SecretKey)), SecurityAlgorithms.HmacSha256Signature)
};
var tokenHandler = new JwtSecurityTokenHandler();
var secureToken = tokenHandler.CreateToken(tokenDescriptor);
var token = tokenHandler.WriteToken(secureToken);
return(new LoginResultDto {
Success = true, UserId = user.Id, Token = token
});
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public IResponse <string> Validate(UserSignInDto dto)
{
var response = new Response <string>();
if (string.IsNullOrWhiteSpace(dto.Email))
{
response.Errors.Add("Email is required");
}
if (string.IsNullOrWhiteSpace(dto.Password))
{
response.Errors.Add("Password is required");
}
return(response);
}
private void Arrange()
{
_userValidator = new UserValidator();
_userSignUpDto = new UserSignUpDto
{
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******",
};
_userSignInDto = new UserSignInDto
{
Email = "*****@*****.**",
Password = "******"
};
}
public async Task <IActionResult> SignIn([FromBody] UserSignInDto userCredentials)
{
if (userCredentials == null)
{
return(BadRequest("Invalid client request"));
}
var response = await _authenticationService.Authenticate(userCredentials);
if (response == null)
{
return(Unauthorized());
}
else
{
return(Ok(response));
}
}
public async Task <AuthenticationResponse> Authenticate(UserSignInDto userCredentials)
{
var user = await _repository.User.FindUser(userCredentials.Login);
if (user == null || !BCrypt.Net.BCrypt.Verify(userCredentials.Password, user.Password) || user.Status == UserStatus.Inactive)
{
return(null);
}
var token = GenerateToken(user);
var response = new AuthenticationResponse
{
UserId = user.UserId,
Token = token
};
return(response);
}
public async Task <bool> AddSignInAsync(UserSignInDto user)
{
try
{
var appUser = new ApplicationUser
{
Id = user.UserId,
UserName = user.UserName,
Email = user.UserEmail
};
await SignInManager.SignInAsync(appUser, user.IsPersistence, user.RememberBrowser);
return(true);
}
catch (Exception)
{
return(false);
}
}
public async Task <IActionResult> Login([FromBody] UserSignInDto userSignInDto)
{
var endPointDiscovery = await _discoveryCache.GetAsync();
if (endPointDiscovery.IsError)
{
_logger.Log(LogLevel.Error, $"ErrorType: {endPointDiscovery.ErrorType} Error: {endPointDiscovery.Error}");
throw new Exception("Something went wrong while connecting to the AuthServer Token Endpoint.");
}
var tokenResponse = await _httpClient.RequestPasswordTokenAsync(new PasswordTokenRequest
{
Address = endPointDiscovery.TokenEndpoint,
ClientId = _configuration["Self:Id"],
ClientSecret = _configuration["Self:Secret"],
Scope = "app.expensetracker.api.full openid profile offline_access",
GrantType = GrantTypes.Password,
UserName = userSignInDto.UserName,
Password = userSignInDto.Password
});
return(Ok(new { access_token = tokenResponse.AccessToken, refresh_token = tokenResponse.RefreshToken, expires_in = tokenResponse.ExpiresIn }));
}
public async Task <ActionResult> UserSignIn([FromBody] UserSignInDto userData)
{
var user = await _userManager.FindByEmailAsync(userData.email);
if (user is null)
{
return(BadRequest($"User with e-mail address {userData.email} doesn't exist"));
}
var passwordValid = await _userManager.CheckPasswordAsync(user, userData.password);
if (passwordValid)
{
var roles = await _userManager.GetRolesAsync(user);
var jwtToken = GenerateJwt(user, roles);
return(Ok(jwtToken));
}
else
{
return(BadRequest("Wrong password"));
}
}
public UserWithTokenDto Authenticate(UserSignInDto model)
{
try
{
User user = _userRepository.GetByUsername(model.Username);
ValidateSignInModel(model, user);
byte[] key = Encoding.ASCII.GetBytes(_tokenConfig.SecretKey);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new[]
{
new Claim(ClaimTypes.Name, $"{user.FirstName} {user.LastName}"),
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString())
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = _tokenHandler.CreateToken(tokenDescriptor);
return(new UserWithTokenDto
{
Id = user.Id,
Username = user.Username,
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
Age = user.Age,
Token = _tokenHandler.WriteToken(token)
});
}
catch (Exception ex)
{
throw ex;
}
}
public UserWithTokenDto Authenticate([FromBody] UserSignInDto model)
{
return(_userService.Authenticate(model));
}
public async Task <AppHttpResponseMessageWrapper> SignInMemberAsync(UserSignInDto userInfo)
{
var response = await _httpClient.PostAsJsonAsync("api/account/signin/user", userInfo);
return(new AppHttpResponseMessageWrapper(response));
}
public async Task <IActionResult> Login([FromBody] UserSignInDto userDto)
{
var result = await _userAuthService.LogInAsync(userDto);
return(Json(result));
}
