public async Task SetTokenAsync(TUser user, string loginProvider, string name, string value,
CancellationToken cancellationToken)
{
var dbUser = await _userCollection.FindByIdAsync(user.Id);
if (dbUser == null)
{
return;
}
if (dbUser.Tokens == null)
{
dbUser.Tokens = new List <IdentityUserToken>();
}
var token = dbUser.Tokens.FirstOrDefault(x => x.LoginProvider == loginProvider && x.Name == name);
if (token == null)
{
token = new IdentityUserToken {
LoginProvider = loginProvider, Name = name, Value = value
};
dbUser.Tokens.Add(token);
}
else
{
token.Value = value;
}
await _userCollection.UpdateAsync(dbUser);
}
public async Task SetTokenAsync(IdentityUserEntity user, string loginProvider, string name, string value, CancellationToken cancellationToken)
{
if (user.Tokens == null)
{
user.Tokens = new List <IdentityUserToken <string> >();
}
var token = user.Tokens.FirstOrDefault(x => x.LoginProvider == loginProvider && x.Name == name);
if (token == null)
{
token = new IdentityUserToken <string> {
LoginProvider = loginProvider, Name = name, Value = value
};
user.Tokens.Add(token);
}
else
{
token.Value = value;
}
var updatedUser = await _userRepository.UpdateField(_ => _.Id == user.Id, entity => entity.Tokens, user.Tokens, cancellationToken);
user.Tokens = updatedUser?.Tokens ?? user.Tokens;
}
public IdentityResult ResetAuthenticatorKeyAsync(ApplicationUser user)
{
try
{
var usertoken = Context.UserTokens.SingleOrDefault(ut => ut.UserId == user.Id);
if (usertoken != null)
{
Context.UserTokens.Remove(Context.UserTokens.SingleOrDefault(ut => ut.UserId == user.Id));
}
byte[] authenticatorKey = KeyGeneration.GenerateRandomKey(20);
var identityUserToken = new IdentityUserToken();
identityUserToken.UserId = user.Id;
identityUserToken.LoginProvider = "AspNetUserStore";
identityUserToken.Name = "AuthenticatorKey";
identityUserToken.Value = Base32Encoder.Encode(authenticatorKey);
Context.UserTokens.Add(identityUserToken);
Context.SaveChanges();
return(IdentityResult.Success);
}
catch (Exception exception)
{
return(new IdentityResult(exception.ToString()));
}
}
public async Task SetTokenAsync(TUser user, string loginProvider, string name, string value, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (user.Tokens == null)
{
user.Tokens = new List <IdentityUserToken <string> >();
}
var token = user.Tokens.FirstOrDefault(x => x.LoginProvider == loginProvider && x.Name == name);
if (token == null)
{
token = new IdentityUserToken <string> {
LoginProvider = loginProvider, Name = name, Value = value
};
user.Tokens.Add(token);
}
else
{
token.Value = value;
}
await _userCollection.UpdateAsync(user);
}
public async Task SetTokenAsync(TUser user, string loginProvider, string name, string value, CancellationToken cancellationToken)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
cancellationToken.ThrowIfCancellationRequested();
if (user.Tokens == null)
{
user.Tokens = new List <IdentityUserToken <string> >();
}
var token = user.Tokens.FirstOrDefault(x => x.LoginProvider == loginProvider && x.Name == name);
if (token == null)
{
token = new IdentityUserToken <string>
{
LoginProvider = loginProvider,
Name = name,
Value = value
};
await AddAsync(user, x => x.Tokens, token, cancellationToken).ConfigureAwait(false);
user.Tokens.Add(token);
}
else
{
token.Value = value;
await UpdateAsync(user, x => x.Tokens, user.Tokens, cancellationToken).ConfigureAwait(false);
}
}
public async Task <IActionResult> OnGetAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
}
if (!user.TwoFactorEnabled)
{
//throw new ApplicationException($"Cannot show recovery codes for user with ID '{user.Id}' as they do not have 2FA enabled.");
TempData["StatusMessage"] = $"Cannot show recovery codes for user with ID '{user.UserName}' as they do not have 2FA enabled.";
return(RedirectToPage("./Config"));
}
//var recoveryCodes = await _userManager.GenerateNewTwoFactorRecoveryCodesAsync(user, 10);
//RecoveryCodes = recoveryCodes.ToArray();
IdentityUserToken <string> userToken = _dbContext.UserTokens
.Where(token => token.UserId == _userManager.GetUserId(User) &&
token.Name == "RecoveryCodes" &&
token.LoginProvider == "[AspNetUserStore]")
.FirstOrDefault();
RecoveryCodes = userToken.Value.Split(";");
return(Page());
}
private async Task <EnableAuthenticatorViewModel> LoadSharedKeyAndQrCodeUriAsync(string userid)
{
// Load the authenticator key & QR code URI to display on the form
var user = await _userManager.FindByIdAsync(userid);
var unformattedKey = await _context.UserTokens
.Where(x => x.UserId == new Guid(userid)).Select(x => x.Value).FirstOrDefaultAsync() ?? null;
if (string.IsNullOrEmpty(unformattedKey))
{
unformattedKey = _userManager.GenerateNewAuthenticatorKey();
var userToken = new IdentityUserToken <Guid>()
{
LoginProvider = SystemConstants.UserTokenConstants.AspNetUserStore,
Value = unformattedKey,
Name = SystemConstants.UserTokenConstants.AuthenticatorKey,
UserId = user.Id
};
await _context.UserTokens.AddAsync(userToken);
await _context.SaveChangesAsync();
}
var result = new EnableAuthenticatorViewModel();
result.SharedKey = FormatKey(unformattedKey);
var email = await _userManager.GetEmailAsync(user);
result.AuthenticatorUri = GenerateQrCodeUri(email, unformattedKey);
return(result);
}
public static IIdentityUserToken BuildEntity(ExternalLoginTokenDto dto)
{
var entity = new IdentityUserToken(dto.Id, dto.ExternalLoginDto.LoginProvider, dto.Name, dto.Value, dto.ExternalLoginDto.UserOrMemberKey.ToString(), dto.CreateDate);
// reset dirty initial properties (U4-1946)
entity.ResetDirtyProperties(false);
return(entity);
}
public static Dictionary <string, object> ToDictionary(this IdentityUserToken token)
{
return(new Dictionary <string, object> {
{ nameof(token.LoginProvider), token.LoginProvider },
{ nameof(token.Name), token.Name },
{ nameof(token.Value), token.Value },
{ "Unique", $"{token.LoginProvider}-<>-{token.Name}-<>-{token.Value}" }
});
}
protected override async Task AddUserTokenAsync(IdentityUserToken token)
{
ThrowIfDisposed();
if (token == null)
{
throw new ArgumentNullException(nameof(token));
}
await Session.SaveAsync(token);
}
/// <summary>
/// Add a new user token.
/// </summary>
/// <param name="token">The token to be added.</param>
protected override Task AddUserTokenAsync(IdentityUserToken <Guid> token)
{
ThrowIfDisposed();
if (token == null)
{
throw new ArgumentNullException(nameof(token));
}
return(UserGrain(token.UserId).AddToken(token));
}
public Task AddToken(IdentityUserToken <Guid> token)
{
if (Exists && token != null)
{
_data.State.Tokens.Add(token);
return(_data.WriteStateAsync());
}
return(Task.CompletedTask);
}
public static UserToken ToEntity(this IdentityUserToken <string> token)
{
return(new UserToken
{
Id = $"{token.UserId}@{token.LoginProvider}@{token.Name}",
LoginProvider = token.LoginProvider,
Name = token.Name,
UserId = token.UserId,
Value = token.Value
});
}
public async Task <int> RemoveUserTokenAsync(IdentityUserToken <T> token)
{
var sqlCommand = $"DELETE FROM \"{_tableName}\" WHERE \"UserId\" = @UserId AND \"LoginProvider\" = @LoginProvider AND \"Name\" = @Name ";
var sqlParams = new Dictionary <string, object>();
sqlParams.Add("UserId", token.UserId);
sqlParams.Add("LoginProvider", token.LoginProvider);
sqlParams.Add("Name", token.Name);
return(await _database.ExecuteSQLAsync(sqlCommand, sqlParams));
}
public async Task <int> AddUserTokenAsync(IdentityUserToken <T> token)
{
var sqlCommand = $"INSERT INTO \"{_tableName}\" (\"UserId\", \"LoginProvider\", \"Name\", \"Value\") VALUES (@UserId, @LoginProvider, @Name, @Value)";
var sqlParams = new Dictionary <string, object>();
sqlParams.Add("UserId", token.UserId);
sqlParams.Add("LoginProvider", token.LoginProvider);
sqlParams.Add("Name", token.Name);
sqlParams.Add("Value", token.Value);
return(await _database.ExecuteSQLAsync(sqlCommand, sqlParams));
}
/// <inheritdoc />
protected override Task RemoveUserTokenAsync(IdentityUserToken <TKey> token)
{
//throw new NotImplementedException();
var t = Tokens.FirstOrDefault(o => o.UserId.ToString() == token.UserId.ToString() && o.LoginProvider == token.LoginProvider && o.Name == token.Name);
if (t != null)
{
Tokens.Remove(t);
}
return(Task.CompletedTask);
}
protected override async Task RemoveUserTokenAsync(
IdentityUserToken token
)
{
ThrowIfDisposed();
if (token == null)
{
throw new ArgumentNullException(nameof(token));
}
await _session.DeleteAsync(token);
await FlushChangesAsync();
}
public static IdentityUserToken ToToken(this INode node)
{
IdentityUserToken result;
result = new IdentityUserToken
{
LoginProvider = node.GetFromInode <string>(nameof(result.LoginProvider)),
Name = node.GetFromInode <string>(nameof(result.Name)),
Value = node.GetFromInode <string>(nameof(result.Value))
};
return(result);
}
protected override async Task RemoveUserTokenAsync(IdentityUserToken <int> token)
{
string baseErrMsg = "DomainUserStore.RemoveUserTokenAsync failed with {Code}: {Description}";
try {
_dbContext.Set <IdentityUserToken <int> >().Remove(token);
await _dbContext.SaveChangesAsync();
} catch (DbUpdateException ex) {
var err = ErrorDescriber.DbUpdateException(ex);
_logger.LogError(baseErrMsg, err.Code, err.Description);
throw new ApplicationException(err.Description, ex);
}
}
private async Task UpdateDbAsync(SpotifyUserToken userToken)
{
await _dbSignal.WaitAsync();
var accessTokenRecord = await _db.UserTokens
.FirstOrDefaultAsync(t => t.UserId == userToken.SynthbotUserId && t.Name == "access_token");
if (accessTokenRecord != null)
{
accessTokenRecord.Value = userToken.SpotifyAccessToken;
_db.Update(accessTokenRecord);
}
else
{
accessTokenRecord = new IdentityUserToken <string>()
{
LoginProvider = "Spotify",
Name = "access_token",
UserId = userToken.SynthbotUserId,
Value = userToken.SpotifyAccessToken
};
await _db.UserTokens.AddAsync(accessTokenRecord);
}
var expiresAtRecord = await _db.UserTokens.FirstOrDefaultAsync(t => t.UserId == userToken.SynthbotUserId && t.Name == "expires_at");
if (expiresAtRecord != null)
{
expiresAtRecord.Value = userToken.SpotifyAccessTokenExpiry.ToString("O");
_db.Update(expiresAtRecord);
}
else
{
expiresAtRecord = new IdentityUserToken <string>()
{
LoginProvider = "Spotify",
Name = "expires_at",
UserId = userToken.SynthbotUserId,
Value = userToken.SpotifyAccessTokenExpiry.ToString("O")
};
await _db.AddAsync(expiresAtRecord);
}
try
{
await _db.SaveChangesAsync();
}
finally
{
_dbSignal.Release();
}
}
public Task RemoveToken(IdentityUserToken <Guid> token)
{
if (Exists)
{
var tokensToRemove = _data.State.Tokens.Find(t => t.LoginProvider == token.LoginProvider && t.Name == token.Name);
if (tokensToRemove != null)
{
_data.State.Tokens.Remove(tokensToRemove);
return(_data.WriteStateAsync());
}
}
return(Task.CompletedTask);
}
protected override Task RemoveUserTokenAsync(IdentityUserToken <string> token)
{
ThrowIfDisposed();
try
{
identityDocumentStore.IdentitySession(session => session.Delete <IdentityUserToken <string> >(token));
return(Task.CompletedTask);
}
catch (Exception e)
{
logger.LogError(e, $"error FindTokenAsync token:{token} ");
throw;
}
}
protected override IdentityUserToken <string> CreateUserToken(
ApplicationUser user,
string loginProvider,
string name,
string value)
{
var token = new IdentityUserToken <string>
{
UserId = user.Id,
LoginProvider = loginProvider,
Name = name,
Value = value,
};
return(token);
}
public async Task <IdentityResult> DeleteAsync(IdentityUserToken <TKey> token)
{
string sqlQuery = "DELETE FROM [dbo].[UserTokens] WHERE UserId = @UserId, " +
"LoginProvider = @LoginProvider, Name = @Name";
var rows = await _connection.ExecuteAsync(sqlQuery, token);
if (rows > 0)
{
return(IdentityResult.Success);
}
else
{
return(IdentityResult.Failed(new IdentityError {
Description = $"Could not delete user token {token.Name}"
}));
}
}
public async Task <VOption <bool> > SaveTokenToDb(OAuthToken token)
{
try {
List <IdentityUserToken <string> > l = new List <IdentityUserToken <string> >();
IdentityUserToken <string> at = new IdentityUserToken <string>()
{
LoginProvider = token.Provider,
Name = "access_token",
UserId = token.AspNetUserId,
Value = token.AccessToken
};
IdentityUserToken <string> rt = new IdentityUserToken <string>()
{
LoginProvider = token.Provider,
Name = "refresh_token",
UserId = token.AspNetUserId,
Value = token.RefreshToken
};
IdentityUserToken <string> ea = new IdentityUserToken <string>()
{
LoginProvider = token.Provider,
Name = "expires_at",
UserId = token.AspNetUserId,
Value = token.ExpiresAt.ToString("YYYY-MM-ddTHH:mm:ss.fffffffzzz")
};
l.Add(at);
l.Add(rt);
l.Add(ea);
await _context.UserTokens.AddRangeAsync(l);
await _context.SaveChangesAsync();
return(new VOption <bool>());
}
catch (Exception e) {
logger.Error(e, $"Failed to save user tokens to database for user {token.AspNetUserId}");
return(new VOption <bool>(ErrorCodes.DatabaseWriteError, "Failed to save tokens to db"));
}
}
public async Task <ActionResult> Register(SignInModel model)
{
var newUser = new CustomUser
{
Email = model.Email,
UserName = model.UserName
};
var res = await _userMng.CreateAsync(newUser, model.Password);
if (res.Succeeded)
{
//Create a Claim
IdentityUserClaim <string> emailClaim = new IdentityUserClaim <string>
{
ClaimType = "Email",
ClaimValue = newUser.Email,
UserId = newUser.Id
};
//Create a token
IdentityUserToken <string> userToken = new IdentityUserToken <string>
{
LoginProvider = "test",
UserId = newUser.Id,
Value = GenerateJwtToken(newUser.Email, newUser),
Name = "RegistrationToken"
};
//TO DO Create a default User Role
_context.UserTokens.Add(userToken);
_context.UserClaims.Add(emailClaim);
await _context.SaveChangesAsync();
return(Created(newUser.Id, newUser));
}
;
return(Unauthorized());
}
/// <summary>
/// Use the below code to generate symmetric Secret Key
/// var hmac = new HMACSHA256();
/// var key = Convert.ToBase64String(hmac.Key);
/// </summary>
public string GenerateToken(IdentityUserToken <Guid> tobject, DateTime now)
{
var tokenHandler = new JwtSecurityTokenHandler();
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new[]
{
new Claim(ClaimTypes.Name, tobject.Name)
}),
Expires = now.AddMinutes(ExpireMinutes),
SigningCredentials = new SigningCredentials(symmetricKey, SecurityAlgorithms.HmacSha256Signature)
};
SecurityToken securityToken = tokenHandler.CreateToken(tokenDescriptor);
var token = tokenHandler.WriteToken(securityToken);
return(token);
}
private async Task <TokenWith <T> > TokenWith <T>(T data, ApplicationUser user)
{
DateTime now = DateTime.UtcNow;
IdentityUserToken <Guid> token = new IdentityUserToken <Guid>()
{
UserId = user.Id,
Name = user.Email,
Value = now.ToString()
};
//Task t = new Task(()=>user.Tokens.RemoveAll(t => now.AddMinutes(JwtManager.ExpireMinutes) < now));
//t.Start();
//user.AddUserToken<IdentityUserToken<Guid>>(token);
//user.AddUserToken(token);
//t.Wait();
//await userManager.UpdateAsync(user);
TokenWith <T> result = new TokenWith <T>(data, jwtManager.GenerateToken(token, now));
return(await Task <TokenWith <T> > .FromResult(result));
}
protected async Task <IdentityUserToken <string> > EnsureTokenAsync(IdentityUserToken <string> token, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
try
{
var iut = await identityDocumentStore.IdentitySession <IdentityUserToken <string> >(async session => await session.LoadAsync <IdentityUserToken <string> >(token.UserId, cancellationToken));
if (iut == null)
{
await identityDocumentStore.IdentitySession(async session => await session.StoreAsync(token, token.UserId, cancellationToken));
return(await EnsureTokenAsync(token, cancellationToken));
}
return(iut);
}
catch (Exception e)
{
logger.LogError(e, $"error EnsureTokenAsync token:{token} ");
throw;
}
}
public async Task SetTokenAsync(TUser user, string loginProvider, string name, string value, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
List <IdentityUserToken <string> > userTokens = user.Tokens ?? new List <IdentityUserToken <string> >();
IdentityUserToken <string> token = userTokens.FirstOrDefault(x => x.LoginProvider == loginProvider && x.Name == name);
if (token == null)
{
await Add(user, x => x.Tokens, new IdentityUserToken <string>
{
LoginProvider = loginProvider,
Name = name,
Value = value
});
}
else
{
token.Value = value;
await Update(user, x => x.Tokens, userTokens);
}
}
