private async Task AttemptRoleAdditionAsync(SeriesUser user, string role)
{
try
{
await _userManager.AddToRoleAsync(user, role);
} catch (Exception)
{
await _roleManager.CreateAsync(new IdentityRole(role));
await _userManager.AddToRoleAsync(user, role);
}
}
public async Task <IActionResult> CheckEmail(string email)
{
if (!ModelState.IsValid)
{
return(NotFound());
}
SeriesUser isEmailTaken = await _userManager.FindByEmailAsync(email);
return(Ok(new BasicResponse {
Success = isEmailTaken == null
}));
}
public async Task <IActionResult> CheckUsername(string name)
{
if (!ModelState.IsValid)
{
return(NotFound());
}
SeriesUser isNameTaken = await _userManager.FindByNameAsync(name);
return(Ok(new BasicResponse {
Success = isNameTaken == null
}));
}
public async Task <IActionResult> RefreshTokens(RefreshTokenRequest response)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Console.WriteLine("Refreshing Token");
SeriesUser user = await _userManager.FindByEmailAsync(response.Email);
if (user == null)
{
return(Unauthorized());
}
RefreshToken refreshToken = _context.RefreshTokens.SingleOrDefault(m => m.Token == response.RefreshToken);
if (refreshToken == null || !refreshToken.IsValid() || refreshToken.Email != user.Email)
{
if (refreshToken == null)
{
return(Unauthorized());
}
_context.RefreshTokens.Remove(refreshToken);
await _context.SaveChangesAsync();
return(Unauthorized());
}
refreshToken.Token = Guid.NewGuid().ToString();
refreshToken.Provided = DateTime.UtcNow;
_context.RefreshTokens.Update(refreshToken);
await _context.SaveChangesAsync();
string token = _jwtGenerator.GenerateEncodedToken(user.Id);
Console.WriteLine("Sending new token!");
return(Ok(new TokensResponse {
Token = token, RefreshToken = refreshToken.Token, Success = true
}));
}
public async Task <IActionResult> GoogleResponse()
{
ExternalLoginInfo info = await _signInManager.GetExternalLoginInfoAsync();
/*if (info == null)
* return RedirectToAction("Login");*/
var isUserSignedIn = await _signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, false);
if (isUserSignedIn.Succeeded)
{
//return RedirectToAction("Index", "User");
}
else
{
SeriesUser user = new SeriesUser
{
Email = info.Principal.FindFirst(ClaimTypes.Email).Value,
UserName = info.Principal.FindFirst(ClaimTypes.Email).Value,
FirstName = info.Principal.FindFirst(ClaimTypes.GivenName).Value,
LastName = info.Principal.FindFirst(ClaimTypes.Surname).Value
};
var isUserCreated = await _userManager.CreateAsync(user);
if (isUserCreated.Succeeded)
{
var addExternalToUser = await _userManager.AddLoginAsync(user, info);
if (addExternalToUser.Succeeded)
{
await _userManager.AddToRoleAsync(user, "User");
await _signInManager.SignInAsync(user, false);
//return RedirectToAction("Index", "User");
}
}
}
return(null);
/*return RedirectToAction("Login");*/
}
public override async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
var userId = context.HttpContext.User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.Name);
if (String.IsNullOrEmpty(Permissions) || userId == null)
{
SetErrorCode(context, 401);
return;
}
string[] roles = Permissions.Split(",");
UserManager <SeriesUser> _userManager =
(UserManager <SeriesUser>)context.HttpContext.RequestServices.GetService(typeof(UserManager <SeriesUser>));
SeriesUser user = await _userManager.FindByIdAsync(userId.Value);
if (user == null)
{
SetErrorCode(context, 401);
return;
}
var userRoles = await _userManager.GetRolesAsync(user);
foreach (string role in roles)
{
if (userRoles.Where(user => role.Contains(user, StringComparison.OrdinalIgnoreCase)).Any())
{
await next();
return;
}
}
SetErrorCode(context, 403);
return;
}
public async Task <IActionResult> Login(LoginRequest request)
{
if (!ModelState.IsValid)
{
return(NotFound());
}
SeriesUser user = await _userManager.FindByEmailAsync(request.Email);
if (user == null)
{
return(Ok(new LoginResponse {
Success = false, Error = "Invalid email or password."
}));
}
SignInResult loginResult = await _signInManager.CheckPasswordSignInAsync(user, request.Password, false);
if (!loginResult.Succeeded)
{
return(Ok(new LoginResponse {
Success = false, Error = "Invalid email or password."
}));
}
string token = _jwtGenerator.GenerateEncodedToken(user.Id);
string refreshToken = await GenerateRefreshToken(user.Email);
return(Ok(new LoginResponse
{
Email = user.Email,
Username = user.UserName,
RefreshToken = refreshToken,
Token = token,
Success = true
}));
}
public async Task <IActionResult> Register(RegistrationRequest request)
{
if (!ModelState.IsValid)
{
return(NotFound());
}
if (request.DisplayName.Length < 4)
{
return(Ok(new RegisterResponse {
Success = false, DisplayNameError = "Display name has to be 4 characters or longer"
}));
}
else if (request.DisplayName.Length > 16)
{
return(Ok(new RegisterResponse {
Success = false, DisplayNameError = "Display name has to be 4 to 16 characters long"
}));
}
if (request.Password.Length > 32)
{
return(Ok(new RegisterResponse {
Success = false, PasswordError = "Password has to be 8 to 32 characters long"
}));
}
SeriesUser newUser = new SeriesUser()
{
UserName = request.DisplayName,
Email = request.Email
};
IdentityResult addUserTask = await _userManager.CreateAsync(newUser, request.Password);
if (addUserTask.Succeeded)
{
if (newUser.Email.Equals("*****@*****.**"))
{
await AttemptRoleAdditionAsync(newUser, "Admin");
}
else
{
await AttemptRoleAdditionAsync(newUser, "User");
}
return(Ok(new RegisterResponse {
Success = true
}));
}
StringBuilder errors = new StringBuilder();
foreach (IdentityError error in addUserTask.Errors)
{
errors.Append(error.Description);
errors.Append(" : ");
}
return(Ok(new RegisterResponse {
Success = false, Error = errors.ToString(0, errors.Length - 3)
}));
}
