public async Task <IActionResult> Authenticate(UserAuthenticateDto userAuthenticateDto)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(userAuthenticateDto.Email);
var result =
await _signInManager.PasswordSignInAsync(user, userAuthenticateDto.Password, userAuthenticateDto.RememberMe, false);
if (result.Succeeded)
{
// проверяем, принадлежит ли URL приложению
if (!string.IsNullOrEmpty(userAuthenticateDto.ReturnUrl) && Url.IsLocalUrl(userAuthenticateDto.ReturnUrl))
{
return(Redirect(userAuthenticateDto.ReturnUrl));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
else
{
ModelState.AddModelError("", "Неправильный логин и (или) пароль");
}
}
return(View(userAuthenticateDto));
}
public IActionResult Authenticate(UserAuthenticateDto userAuthenticateDto)
{
var user = _accountService.Authenticate(userAuthenticateDto);
if (user == null)
{
return(NotFound(new { message = "Usuário ou senha inválidos" }));
}
return(Ok(new { token = TokenService.GenerateToken(user) }));
}
public IActionResult Authenticate([FromBody] UserAuthenticateDto userDto)
{
var authenticatedUser = _userService.Authenticate(userDto.Email, userDto.Password);
if (authenticatedUser == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
return(Ok(authenticatedUser));
}
public async Task <IActionResult> Authenticate(UserAuthenticateDto model)
{
try
{
var user = await userService.GetUserByUsernameAsync(model.Username);
if (user == null)
{
return(BadRequest(new { message = "Username is incorrect" }));
}
if (!passwordHasher.VerifyHashedPassword(model.Password, user.PasswordHash))
{
return(BadRequest(new { message = "Password is incorrect" }));
}
var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtConfig.Key));
var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(ClaimTypes.Name, user.Username),
new Claim("username", user.Username),
new Claim("displayName", user.DisplayName),
new Claim("id", user.Id.ToString()),
new Claim(ClaimTypes.Role, user.Role)
};
var token = new JwtSecurityToken(
jwtConfig.Issuer,
jwtConfig.Audience,
claims,
expires: DateTime.Now.AddDays(7),
signingCredentials: credentials);
var tokenString = new JwtSecurityTokenHandler().WriteToken(token);
return(Ok(new
{
user.Created,
user.Id,
user.Username,
user.DisplayName,
Token = tokenString
}));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public IActionResult GenerateToken([FromBody] UserAuthenticateDto model)
{
var userFromRepo = _articleLibraryRepository.Authenticate(model.Email, model.Password);
if (userFromRepo == null)
{
return(BadRequest("Username or password is invalid"));
}
//Console.WriteLine(userFromRepo.Token);
return(Ok(userFromRepo));
}
public User Authenticate(UserAuthenticateDto userDto)
{
var userModel = _repository.FindByEmail(userDto.Email);
if (userModel != null && BCrypt.Net.BCrypt.Verify(userDto.Password, userModel.PasswordHash))
{
return(userModel);
}
else
{
return(null);
}
}
public IActionResult Register([FromBody] UserAuthenticateDto userDto)
{
try
{
_userService.Create(userDto);
return(Ok());
}
catch (UserException ex)
{
return(BadRequest(new { message = ex.Message }));
}
catch (Exception)
{
return(BadRequest());
}
}
public async Task <ActionResult <UserDto> > Authenticate(UserAuthenticateDto userAuthenticateDto)
{
if (userAuthenticateDto == null)
{
throw new ArgumentNullException(nameof(userAuthenticateDto));
}
var userResult = await _userService.Authenticate(userAuthenticateDto.UserName, userAuthenticateDto.Password).ConfigureAwait(false);
if (userResult == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
return(CreatedAtAction("Get", new { id = userResult.Id }, userResult));
}
public void Create(UserAuthenticateDto userDto)
{
var user = _mapper.Map <User>(userDto);
user.IsActive = true;
user.IsVirtual = false;
if (_context.Users.Any(x => x.Email == user.Email))
{
throw new UserException("Username \"" + user.Email + "\" is already taken");
}
byte[] passwordHash, passwordSalt;
AuthHelper.CreatePasswordHash(userDto.Password, out passwordHash, out passwordSalt);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
_context.Users.Add(user);
_context.SaveChanges();
}
public async Task <IActionResult> Authenticate([FromBody] UserAuthenticateDto userDto)
{
var user = await _userService.AuthenticateAsync(userDto.Email, userDto.Password);
if (user == null)
{
return(BadRequest(new { message = "К сожалению, логин или пароль неверны" }));
}
else if (user.Status == Entities.Enums.State.NOT_ACTIVE)
{
return(BadRequest(new { message = "К сожалению, ваш аккаунт заблокирован. Пожалуйста, обратитесь в службу поддержки" }));
}
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.FullName),
new Claim(ClaimTypes.Email, user.Email),
new Claim(ClaimTypes.Role, user.Role.Name)
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
return(Ok(new
{
Id = user.Id,
Email = user.Email,
FullName = user.FullName,
RoleId = user.RoleId,
Token = tokenString
}));
}
public async Task <ActionResult <UserDto> > Create(UserCreateDto userPostDto)
{
if (await _userRepository.UserAlreadyExists(userPostDto))
{
return(BadRequest(new { message = "A user with the provided email address and/or username already exists." }));
}
var userResult = await _userRepository.Create(userPostDto).ConfigureAwait(false);
if (userResult == null)
{
return(BadRequest(new { message = "Registration failed" }));
}
var userAuthenticateDto = new UserAuthenticateDto
{
UserName = userPostDto.UserName,
Password = userPostDto.Password
};
return(await Authenticate(userAuthenticateDto).ConfigureAwait(false));
}
public async Task <IActionResult> Login([FromBody] UserAuthenticateDto user)
{
try
{
return(Json(
await _accountService.LoginAsync(user.Email, user.Password)
));
}
catch (InstagramException ex)
{
// _logger.LogError(ex, ex.Message);
return(BadRequest(new {
Error = ex.Message
}));
}
catch (Exception ex)
{
// _logger.LogError(ex, ex.Message);
return(BadRequest(new {
Error = ex.Message
}));
}
}
public async Task <IActionResult> Authenticate([FromBody] UserAuthenticateDto model)
{
// call user service to authenticate the user
var user = await _userService.Authenticate(model.Username, model.Password);
// if user is null
if (user == null)
{
// returns bad request 400
return(BadRequest(new { message = "Username or password is not valid." }));
}
// to generate the token for the JWT
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.Id.ToString())
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
// returns the user and adds the generated JWT token 200ok
return(Ok(new
{
Id = user.Id,
Username = user.Username,
FirstName = user.FirstName,
LastName = user.LastName,
Token = tokenString
}));
}
public IActionResult Authenticate([FromBody] UserAuthenticateDto model)
{
var user = _userService.Authenticate(model.UserName, model.Password);
if (user == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, user.UserId.ToString()),
new Claim("Role", user.Role.RoleName)
}),
// TODO make expiration time a Param
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
// return basic user info and authentication token
return(Ok(new
{
UserId = user.UserId,
Username = user.UserName,
FirstName = user.FirstName,
LastName = user.LastName,
Role = user.Role,
Token = tokenString,
returnUrl = user.Role.RoleId == 2 ? "admin" : "/"
}));
}
public BaseResponse <string> Login([FromBody] UserAuthenticateDto userAuthenticate)
{
var response = _userService.Login(userAuthenticate.Email, userAuthenticate.Password);
return(FormatResponse(response));
}
