public async Task <IActionResult> Login([FromBody] LoginRequest request)
{
try
{
var userDto = await _userService.GetByUserName(request.UserName);
var isCorrect = await _userService.CheckPassword(request.Password, userDto.Email);
if (isCorrect)
{
JwtAuthResult jwtResult = await _jwtAuthManager.GenerateToken(userDto, DateTime.Now);
return(Ok(jwtResult.AccessToken));
}
return(BadRequest("Password is not correct"));
}
catch (UserNotFoundException e)
{
Log.Error(e.Message);
return(BadRequest(e.Message));
}
catch (Exception e)
{
Log.Error(e.Message);
return(BadRequest());
}
}
public async Task <ActionResult <JwtAuthResult> > SignUp([FromBody] SignUpRequest request)
{
UserResponse userResult = await m_userService.SignUp(request);
JwtAuthResult authResult = await m_authManager.GenerateToken(userResult.UserName, userResult.Claims);
return(Ok(authResult));
}
public async Task <IAuthorizeResult <Model> > Handle(Query request, CancellationToken cancellationToken)
{
_httpContextAccessor.HttpContext !.Request.Headers.TryGetValue("Origin", out var origin);
_logger.LogInformation("Site Login Request Initialized from Url: {Origin}", origin);
var discordUser = await _discordAuthManager.GetDiscordUserAsync(request.Bearer);
if (discordUser is null)
{
_logger.LogWarning("Site Login Request Denied: Invalid Token");
return(AuthorizeResult <Model> .Forbidden());
}
_logger.LogInformation("Site Login Request Accepted");
var claims = new List <Claim>
{
new(Claims.DiscordBearer, request.Bearer),
new(Claims.DiscordUserId, discordUser.User.Id)
};
_logger.LogInformation("Generating JWT Access Token");
var token = _jwtAuthManager.GenerateToken(claims, DateTime.UtcNow.AddHours(4));
_logger.LogInformation("JWT Access Token Successfully Generated");
return(AuthorizeResult <Model> .Success(new Model { Token = token }));
}
public async Task <IActionResult> Login([FromBody] LoginAuthRequest loginRequest)
{
GoogleApiTokenInfo tokenInfo = await ValidateGoogleTokenAsync(loginRequest.AccessToken);
if (tokenInfo.UserId is null)
{
return(BadRequest("The access token was invalid"));
}
var user = await _context.AppUser
.SingleOrDefaultAsync(x => x.AuthId == tokenInfo.UserId);
if (user is null)
{
return(BadRequest("User does not exist"));
}
await _signInManager.SignInAsync(user, false);
var claims = await _userManager.GetClaimsAsync(user);
var token = _jwtAuthManager.GenerateToken(claims, DateTime.Now);
return(Ok(new{ token }));
}
public Task <Result <Model, AuthorizeStatus> > Handle(Query request,
CancellationToken cancellationToken)
{
_httpContextAccessor.HttpContext !.Request.Headers.TryGetValue("Origin", out var origin);
_logger.LogInformation($"Bot Authorize Request Initialized from Url: {origin.ToString()}");
if (request.Key != _apiKey.Key)
{
_logger.LogInformation("Bot Authorize Request Denied: Invalid Key");
return(Task.FromResult(AuthorizeResult <Model> .Forbidden()));
}
_logger.LogInformation("Bot Authorize Request Accepted");
_logger.LogInformation($"Generating Claim: {Claims.BotApiKey}");
var claims = new[]
{
new Claim(Claims.BotApiKey, request.Key)
};
_logger.LogInformation("Generating JWT Access Token");
var token = _jwtAuthManager.GenerateToken(claims, DateTime.Now);
_logger.LogInformation("JWT Access Token Successfully Generated");
return(Task.FromResult(AuthorizeResult <Model> .Success(new Model()
{
Token = token
})));
}
public async Task <IActionResult> Rgister([FromBody] RegisterRequest request)
{
try
{
JwtAuthResult jwtAuthResult = null;
if ((await _userService.GetByEmail(request.Email)) == null)
{
var passwHash = Text.EncryptSHA256(request.Password);
var defaultRole = (await _roleService.GetRoles())
.FirstOrDefault(r => r.Name.Equals("User"));
var userDto = new UserDto()
{
Id = Guid.NewGuid(),
Email = request.Email,
FirstName = request.FirstName,
LastName = request.LastName,
PasswordHash = passwHash,
RoleId = defaultRole.Id,
RoleName = defaultRole.Name
};
var userRegistered = await _userService.Register(userDto);
if (userRegistered)
{
jwtAuthResult = await _jwtAuthManager.GenerateToken(userDto);
}
else
{
return(BadRequest("User with such email already exists."));
}
}
return(Ok(jwtAuthResult));
}
catch (Exception e)
{
Log.Error(e.Message);
return(StatusCode(500, "Unsuccessful registration."));
}
}
public IActionResult Login([FromForm, FromBody] LoginRequest request)
{
if (!_userService.IsValidUserCredentials(request.UserName, request.Password))
{
return(Unauthorized());
}
var claims = new[] { new Claim(ClaimTypes.Name, request.UserName) };
var token = _jwtAuthManager.GenerateToken(request.UserName, claims, DateTime.UtcNow);
_logger.LogInformation($"User [{request.UserName}] logged in the system.");
return(Ok(new LoginResponse
{
UserName = request.UserName,
AccessToken = token
}));
}
