public StoredToken UseToken(string TokenValue)
{
StoredToken token = _context.StoredToken.FirstOrDefault(e => e.TokenValue == TokenValue);
_context.StoredToken.Remove(token);
_context.SaveChanges();
return(token);
}
public async Task <IActionResult> Register([FromBody] RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
StoredToken Token = null;
if (!string.IsNullOrEmpty(model.token))
{
//Grab the token and verify that this token is valid (Then grab the Role)
Token = _StoredToken.UseToken(model.token);
}
var user = new ApplicationUser {
UserName = model.dod_id.ToString(), Email = model.email
};
var result = await _userManager.CreateAsync(user, model.password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
await _emailSender.SendEmailConfirmationAsync(model.email, callbackUrl);
//Each user is a marine
await _userManager.AddToRoleAsync(user, ApplicationPermissions.ROLE_MARINE);
if (Token != null) // Verify which other roles the user is in
{
if (Token.TokenData == ApplicationPermissions.ROLE_SUPERVISOR)
{
await _userManager.AddToRoleAsync(user, ApplicationPermissions.ROLE_SUPERVISOR);
}
if (Token.TokenData == ApplicationPermissions.ROLE_DOD_ADMIN)
{
await _userManager.AddToRoleAsync(user, ApplicationPermissions.ROLE_SUPERVISOR);
await _userManager.AddToRoleAsync(user, ApplicationPermissions.ROLE_DOD_ADMIN);
}
}
await _signInManager.SignInAsync(user, isPersistent : true);
return(Json(new Result(reason: returnUrl)));
}
else
{
string result_error = "";
result.Errors.Select(e => e.Description).ToList().ForEach(e => result_error += e + "; ");
return(Json(new Result("Failure", $"User Could Not Be Created: {result_error}", 406)));
}
}
// If we got this far, something failed, redisplay form
return(Json(new Result("Failure", "Received Json Object did not meet required format.", 406)));
}
string ITokenStore.CreateToken(string tokenType, IEnumerable <string> purpose, string identity)
{
var token = new StoredToken
{
Value = Guid.NewGuid().ToString("N"),
TokenType = tokenType,
Purpose = purpose == null ? new List <string>() : purpose.Where(p => !string.IsNullOrEmpty(p)).ToList(),
Identity = identity
};
_tokens.Add(token.Value, token);
return(token.Value);
}
/// <summary>
/// Checks to verify the user is either in the same role or a higher role.
/// </summary>
/// <param name="role"></param>
/// <returns></returns>
private string GenerateRegistrationToken(string role)
{
///Verify the user is in the role they are trying to assign
if (true)//User.IsInRole(role))
{
StoredToken RegisterToken = _StoredToken.GenerateNewToken("Manual Registration", TOKEN_TYPE.REGISTER, role);
return(Url.Action("Register", new { token = RegisterToken.TokenValue }));
}
else
{
return(null);
}
}
public StoredToken GenerateNewToken(string TokenReason, TOKEN_TYPE type, string TokenData = null, DateTime?ExpirationDate = null)
{
StoredToken tk = new StoredToken();
tk.ExpirationDate = ExpirationDate ?? DateTime.Now.AddDays(1);
tk.TokenData = TokenData;
tk.TokenReason = TokenReason;
tk.TokenType = type;
tk.TokenValue = HelperFunctions.GenerateRandomString(15);
try
{
tk = _context.StoredToken.Add(tk).Entity;
_context.SaveChanges();
return(tk);
}
catch
{
return(null);
}
}
public Token(Totp totp, StoredToken token)
{
this._totp = totp;
this._storedToken = token;
}
public Token(StoredToken token)
{
this._storedToken = token;
this._totp = new Totp(SecretAsBytes);
}
public static int StoreToken(StoredToken token)
{
return(_db.Insert(token));
}
