public async Task <AuthenticationResult> RegisterAsync(string email, string password)
{
var existingUserWithEmail = await _userManager.FindByEmailAsync(email).ConfigureAwait(false);
if (existingUserWithEmail != null)
{
return(new AuthenticationResult
{
Errors = new[] { "User with this email address already exists" }
});
}
var newUserId = Guid.NewGuid();
var newUser = new DragonflyUser
{
Id = newUserId,
Email = email,
UserName = email
};
var createdUser = await _userManager.CreateAsync(newUser, password).ConfigureAwait(false);
if (!createdUser.Succeeded)
{
return(new AuthenticationResult
{
Errors = createdUser.Errors.Select(x => x.Description)
});
}
return(await GenerateAuthenticationResultForUserAsync(newUser).ConfigureAwait(false));
}
public async Task <bool> UpdateEmailAsync(DragonflyUser userToUpdate, string oldEmail, string newEmail)
{
var token = await _userManager.GenerateChangeEmailTokenAsync(userToUpdate, newEmail).ConfigureAwait(false);
var result = await _userManager.ChangeEmailAsync(userToUpdate, newEmail, token).ConfigureAwait(false);
return(result.Succeeded);
}
public async Task <AuthenticationResult> ConfirmEmailAsync(DragonflyUser user, string token)
{
var confirmResult = await _userManager.ConfirmEmailAsync(user, token).ConfigureAwait(false);
return(new AuthenticationResult
{
Success = confirmResult.Succeeded,
Errors = confirmResult.Errors.Select(x => x.Description)
});
}
public async Task <AuthenticationResult> ResetPasswordAsync(DragonflyUser user, string token, string newPassword)
{
var passChangeResult = await _userManager.ResetPasswordAsync(user, token, newPassword).ConfigureAwait(false);
return(new AuthenticationResult
{
Success = passChangeResult.Succeeded,
Errors = passChangeResult.Errors.Select(x => x.Description)
});
}
public async Task <bool> DeleteUserAsync(Guid userId)
{
var user = new DragonflyUser {
Id = userId
};
var result = await _userManager.DeleteAsync(user).ConfigureAwait(false);
var deleted = result.Succeeded;
return(deleted);
}
public async Task <bool> UpdateUserAsync(DragonflyUser userToUpdate)
{
if (userToUpdate == null)
{
return(false);
}
var result = await _userManager.UpdateAsync(userToUpdate).ConfigureAwait(false);
var updated = result.Succeeded;
return(updated);
}
public async Task <AuthenticationResult> CheckUserPasswordAsync(DragonflyUser user, string password)
{
var result = await _userManager.CheckPasswordAsync(user, password).ConfigureAwait(false);
return(new AuthenticationResult
{
Success = result,
Errors = new List <string>()
{
"Failed password check."
}
});
}
public async Task <AuthenticationResult> SendConfirmationEmailAsync(DragonflyUser user)
{
var emailConfirmationCode = await _userManager.GenerateEmailConfirmationTokenAsync(user).ConfigureAwait(false);
var sent = await _mailService.SendAccountVerificationEmailAsync(user, emailConfirmationCode).ConfigureAwait(false);
return(new AuthenticationResult
{
Success = sent,
Errors = new List <string>()
{
"Failed to send Email."
}
});
}
public async Task <AuthenticationResult> ResetPasswordEmailAsync(DragonflyUser user)
{
var token = await _userManager.GeneratePasswordResetTokenAsync(user).ConfigureAwait(false);
var result = await _mailService.SendPasswordResetEmailAsync(user, token).ConfigureAwait(false);
return(new AuthenticationResult
{
Success = result,
Errors = new List <string>()
{
"Failed to send Email."
}
});
}
public async Task <bool> SendPasswordChangedEmailAsync(DragonflyUser user)
{
if (user == null)
{
return(false);
}
var model = new HelloWorldViewModel("https://www.google.com");
var name = "HelloWorld";
var htmlBody = await _renderer.RenderViewToStringAsync($"{templateBaseDir}/{name}/{name}Html.cshtml", model).ConfigureAwait(false);
var textBody = await _renderer.RenderViewToStringAsync($"{templateBaseDir}/{name}/{name}Text.cshtml", model).ConfigureAwait(false);
var result = await SendEmailAsync(new List <string> {
user.Email
}, _fromAddress, "Your Dragonfly Password was changed", textBody, htmlBody).ConfigureAwait(false);
return(result);
}
public async Task <bool> SendPasswordResetEmailAsync(DragonflyUser user, string token)
{
if (user == null)
{
return(false);
}
var host = "http://dragonflytracker.com/";
var resetLink = $"{host}password-reset?reset_password_token={Uri.EscapeDataString(token)}&user_name={user.UserName}";
var model = new PasswordResetViewModel(resetLink, user.UserName);
var name = "PasswordReset";
var htmlBody = await _renderer.RenderViewToStringAsync($"{templateBaseDir}/{name}/{name}Html.cshtml", model).ConfigureAwait(false);
var textBody = await _renderer.RenderViewToStringAsync($"{templateBaseDir}/{name}/{name}Text.cshtml", model).ConfigureAwait(false);
var result = await SendEmailAsync(new List <string> {
user.Email
}, _fromAddress, "Dragonfly Password Reset Requested", textBody, htmlBody).ConfigureAwait(false);
return(result);
}
public async Task <bool> SendAccountVerificationEmailAsync(DragonflyUser user, string token)
{
if (user == null)
{
return(false);
}
var host = "http://dragonflytracker.com/";
var verificationLink = $"{host}verify-email?email_confirm_token={Uri.EscapeDataString(token)}&user_name={user.UserName}";
var model = new AccountVerificationViewModel(verificationLink, user.UserName);
var name = "AccountVerification";
var htmlBody = await _renderer.RenderViewToStringAsync($"{templateBaseDir}/{name}/{name}Html.cshtml", model).ConfigureAwait(false);
var textBody = await _renderer.RenderViewToStringAsync($"{templateBaseDir}/{name}/{name}Text.cshtml", model).ConfigureAwait(false);
var result = await SendEmailAsync(new List <string> {
user.Email
}, _fromAddress, "Verify your Dragonfly Account's Email", textBody, htmlBody).ConfigureAwait(false);
return(result);
}
private async Task <AuthenticationResult> GenerateAuthenticationResultForUserAsync(DragonflyUser user)
{
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_jwtSettings.Secret);
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Sub, user.UserName),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Email, user.Email),
new Claim("id", user.Id.ToString())
};
var userClaims = await _userManager.GetClaimsAsync(user).ConfigureAwait(false);
claims.AddRange(userClaims);
var userRoles = await _userManager.GetRolesAsync(user).ConfigureAwait(false);
foreach (var userRole in userRoles)
{
claims.Add(new Claim(ClaimTypes.Role, userRole));
var role = await _roleManager.FindByNameAsync(userRole).ConfigureAwait(false);
if (role == null)
{
continue;
}
var roleClaims = await _roleManager.GetClaimsAsync(role).ConfigureAwait(false);
foreach (var roleClaim in roleClaims)
{
if (claims.Contains(roleClaim))
{
continue;
}
claims.Add(roleClaim);
}
}
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.UtcNow.Add(_jwtSettings.TokenLifetime),
SigningCredentials =
new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var refreshToken = new RefreshToken
{
JwtId = token.Id,
UserId = user.Id,
CreationDate = DateTime.UtcNow,
ExpiryDate = DateTime.UtcNow.AddMonths(6)
};
await _pgMainDataContext.RefreshTokens.AddAsync(refreshToken).ConfigureAwait(false);
await _pgMainDataContext.SaveChangesAsync().ConfigureAwait(false);
return(new AuthenticationResult
{
Success = true,
Token = tokenHandler.WriteToken(token),
RefreshToken = refreshToken.Token
});
}
