public Task AddLoginAsync(CustomUser user, UserLoginInfo login)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
if (login == null)
{
throw new ArgumentNullException("user");
}
if (!user.Logins.Any(x => x.LoginProvider == login.LoginProvider && x.ProviderKey == login.ProviderKey))
{
IdentityUserLogin iul = new IdentityUserLogin
{
LoginProvider = login.LoginProvider,
ProviderKey = login.ProviderKey
};
user.Logins.Add(iul);
var record = new UserLogingInfoToUserIdRecord()
{
Key = GetLoginId(login),
Id = user.Id
};
this.UserLoginInfoToIdDb.Add(record);
return(UpdateAsync(user));
}
return(Task.FromResult(true));
}
public async Task AddLoginAsync(TUserEntity user, UserLoginInfo login, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (login == null)
{
throw new ArgumentNullException(nameof(login));
}
try
{
IdentityUserLogin <string> loginEntity = new IdentityUserLogin <string>
{
UserId = user.Id,
LoginProvider = login.LoginProvider,
ProviderKey = login.ProviderKey,
ProviderDisplayName = login.ProviderDisplayName
};
_repo.Add(loginEntity);
await _repo.SaveChangesAsync();
}
catch { }
}
public Task AddLoginAsync(TUser user, UserLoginInfo login, CancellationToken cancellationToken)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (login == null)
{
throw new ArgumentNullException(nameof(login));
}
cancellationToken.ThrowIfCancellationRequested();
var iul = new IdentityUserLogin <string>
{
UserId = user.Id.ToString(),
LoginProvider = login.LoginProvider,
ProviderDisplayName = login.ProviderDisplayName,
ProviderKey = login.ProviderKey
};
user.Logins.Add(iul);
return(AddAsync(user, x => x.Logins, iul, cancellationToken));
}
public virtual Task RemoveLoginAsync(TUser user, UserLoginInfo login)
{
this.ThrowIfDisposed();
if (user == null)
{
throw new ArgumentNullException("user");
}
if (login == null)
{
throw new ArgumentNullException("login");
}
IdentityUserLogin entity = user.Logins.Where(
l =>
{
if (l.LoginProvider == login.LoginProvider && Equals(l.User, user))
{
return(l.ProviderKey == login.ProviderKey);
}
return(false);
}).SingleOrDefault();
if (entity == null)
{
return(Task.FromResult(0));
}
user.Logins.Remove(entity);
this.loginRepository.Delete(entity);
return(Task.FromResult(0));
}
/// <summary>
/// Implemented IUserLoginStore FindByLoginAsync Method
/// </summary>
/// <param name="loginProvider">string</param>
/// <param name="providerKey">string</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>Task<ApplicationUser></returns>
/// <method>FindByLoginAsync(string loginProvider, string providerKey, CancellationToken cancellationToken)</method>
public async Task <ApplicationUser> FindByLoginAsync(string loginProvider, string providerKey, CancellationToken cancellationToken)
{
try
{
IdentityUserLogin <string> input = new IdentityUserLogin <string>();
input.LoginProvider = loginProvider.Clean();
input.ProviderKey = providerKey.Clean();
string accessToken = await GetAccessToken();
string jsonString = JsonConvert.SerializeObject(input);
string encryptString = AESGCM.Encrypt(jsonString, accessToken);
JsonClient jsonClient = new JsonClient(_apiBaseUrl, accessToken);
HttpStatusCode statusCode = await jsonClient.SendRequest(HttpMethod.Post, "User/FindByLogin", encryptString);
if (!jsonClient.IsResponseSuccess)
{
_logger.Exception(new Exception(jsonClient.GetResponseString()));
throw new Exception(jsonClient.GetResponseString());
}
jsonString = AESGCM.Decrypt(jsonClient.GetResponseObject <string>(), accessToken);
ApplicationUser user = JsonConvert.DeserializeObject <ApplicationUser>(jsonString);
return(user);
}
catch (Exception exception)
{
_logger.Exception(exception);
throw;
}
}
public IdentityUserTests()
{
User = new IdentityUser("John Doe");
Role1 = new IdentityRole {
Name = "Role1"
};
Role2 = new IdentityRole {
Name = "Role2"
};
Claim1 = new IdentityClaim {
ClaimType = "Claim1", ClaimValue = "Some value"
};
Claim2 = new IdentityClaim {
ClaimType = "Claim2", ClaimValue = "Some other value"
};
Claim3 = new IdentityClaim {
ClaimType = "Claim3", ClaimValue = "Yet another value"
};
Claim4 = new IdentityClaim {
ClaimType = "Claim4", ClaimValue = "Many many claims"
};
Claim1Alt = new IdentityClaim {
ClaimType = "Claim1", ClaimValue = "Some alternate value"
};
Login1 = new IdentityUserLogin {
LoginProvider = "Form", ProviderDisplayName = "Bob", ProviderKey = "password"
};
}
private void UpdateUserLoginNT(Models.ApplicationUser user)
{
var loginNT = _context.UserLogins.SingleOrDefault(u => u.LoginProvider == WINDOWS_LOGIN_PROVIDER && u.UserId == user.Id);
if (loginNT != null)
{
_context.UserLogins.Remove(loginNT);
}
// if LoginNT is empty, get out
if (String.IsNullOrWhiteSpace(user.LoginNT))
{
return;
}
// create the new one
var newLoginNT = new IdentityUserLogin <string>();
newLoginNT.LoginProvider = WINDOWS_LOGIN_PROVIDER;
newLoginNT.UserId = user.Id;
newLoginNT.ProviderDisplayName = "Windows";
newLoginNT.ProviderKey = user.LoginNT;
// add the new one
_context.UserLogins.Add(newLoginNT);
}
public void Can_Deserialize_IdentityUser()
{
using (var store = GetDocumentStore())
{
store.Conventions.CustomizeJsonSerializer += serializer => serializer.ObjectCreationHandling = ObjectCreationHandling.Auto;
using (IDocumentSession session = store.OpenSession())
{
var user = new IdentityUser {
UserName = "******"
};
session.Store(user);
var l = new IdentityUserLogin <string>
{
UserId = user.Id,
ProviderKey = null,
LoginProvider = "Twitter",
ProviderDisplayName = "Twitter"
};
user.Logins.Add(l);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var result = session.Query <IdentityUser>()
.Customize(customization => customization.WaitForNonStaleResultsAsOfNow())
.FirstOrDefault();
Assert.Equal("Marcus", result.UserName);
Assert.Equal(1, result.Logins.Count());
}
}
}
public static void Equal(IdentityUserLogin expected, IdentityUserLogin actual)
{
Assert.True((expected == null && actual == null) || (expected != null && actual != null));
Assert.Equal(expected.LoginProvider, actual.LoginProvider);
Assert.Equal(expected.ProviderKey, actual.ProviderKey);
Assert.Equal(expected.ProviderDisplayName, actual.ProviderDisplayName);
}
internal static string GetId(this IdentityUserLogin <string> iulin)
{
if (iulin == null)
{
return(null);
}
return($"{iulin.LoginProvider}/{iulin.ProviderKey}/{iulin.UserId}");
}
public static IIdentityUserLogin BuildEntity(ExternalLoginDto dto)
{
var entity = new IdentityUserLogin(dto.Id, dto.LoginProvider, dto.ProviderKey, dto.UserId, dto.CreateDate);
// reset dirty initial properties (U4-1946)
entity.ResetDirtyProperties(false);
return(entity);
}
public Task <ApplicationUser> FindAsync(IdentityUserLogin login)
{
if (_logins.ContainsKey(login))
{
return(Task.FromResult(_logins[login]));
}
return(Task.FromResult <ApplicationUser>(null));
}
public static void Equal(IdentityUserLogin expected, IdentityUserLogin actual)
{
Assert.True((expected == null && actual == null) || (expected != null && actual != null));
Assert.Equal(expected.LoginProvider, actual.LoginProvider);
Assert.Equal(expected.ProviderKey, actual.ProviderKey);
Assert.Equal(expected.ProviderDisplayName, actual.ProviderDisplayName);
}
public IdentityUserLogin Convert()
{
var login = new IdentityUserLogin();
login.UserId = this.UserId;
login.LoginProvider = this.LoginProvider;
login.ProviderKey = this.ProviderKey;
return login;
}
public IIdentityUserLogin BuildEntity(ExternalLoginDto dto)
{
var entity = new IdentityUserLogin(dto.Id, dto.LoginProvider, dto.ProviderKey, dto.UserId, dto.CreateDate);
//on initial construction we don't want to have dirty properties tracked
// http://issues.umbraco.org/issue/U4-1946
entity.ResetDirtyProperties(false);
return(entity);
}
public async Task AddLogin(IdentityUserLogin <Guid> login)
{
if (Exists && login != null)
{
_data.State.Logins.Add(login);
await GrainFactory.AddOrUpdateToLookup(login.LoginProvider, login.ProviderKey, _id);
await _data.WriteStateAsync();
}
}
public IdentityUserLogin Convert()
{
var login = new IdentityUserLogin();
login.UserId = this.UserId;
login.LoginProvider = this.LoginProvider;
login.ProviderKey = this.ProviderKey;
return(login);
}
public Task RemoveLoginAsync(ApplicationUser user, IdentityUserLogin login)
{
var logs = user.Logins.Where(l => l.ProviderKey == login.ProviderKey && l.LoginProvider == login.LoginProvider).ToList();
foreach (var l in logs)
{
user.Logins.Remove(l);
_logins[l] = null;
}
return(Task.FromResult(0));
}
public static IIdentityUserLogin BuildEntity(ExternalLoginDto dto)
{
var entity = new IdentityUserLogin(dto.Id, dto.LoginProvider, dto.ProviderKey, dto.UserId.ToString(CultureInfo.InvariantCulture), dto.CreateDate)
{
UserData = dto.UserData
};
// reset dirty initial properties (U4-1946)
entity.ResetDirtyProperties(false);
return(entity);
}
public Task AddLoginAsync(IdentityUserLogin login)
{
if (login == null)
{
throw new ArgumentNullException(IdentityConstants.Login);
}
_userLoginTable.Insert(login);
return(Task.FromResult <object>(null));
}
public Task RemoveLoginAsync(IdentityUserLogin login)
{
if (login == null)
{
throw new ArgumentNullException(IdentityConstants.Login);
}
_userLoginTable.Delete(login);
return(Task.FromResult <Object>(null));
}
public static Entity.UserLogin ToEntity(this IdentityUserLogin <string> login)
{
return(new Entity.UserLogin
{
Id = $"{login.UserId}@{login.LoginProvider}@{login.ProviderKey}",
UserId = login.UserId,
LoginProvider = login.LoginProvider,
ProviderKey = login.ProviderKey,
ProviderDisplayName = login.ProviderDisplayName
});
}
/// <summary>
/// Implemented IUserLoginStore AddLoginAsync Method
/// </summary>
/// <param name="user">ApplicationUser</param>
/// <param name="login">UserLoginInfo</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>Task</returns>
/// <method>AddLoginAsync(ApplicationUser user, UserLoginInfo login, CancellationToken cancellationToken)</method>
public Task AddLoginAsync(ApplicationUser user, UserLoginInfo login, CancellationToken cancellationToken)
{
IdentityUserLogin <string> input = new IdentityUserLogin <string>();
input.ProviderKey = login.ProviderKey.Clean();
input.LoginProvider = login.LoginProvider.Clean();
input.ProviderDisplayName = login.ProviderDisplayName.Clean();
input.UserId = user.Id;
user.Logins.Add(input);
return(Task.FromResult(0));
}
public Task AddLoginAsync(User user, UserLoginInfo login)
{
IdentityUserLogin identityUserLogin = new IdentityUserLogin
{
LoginProvider = login.LoginProvider,
ProviderKey = login.ProviderKey,
UserId = user.Id,
ProviderDisplayName = login.LoginProvider
};
var result = repository.Create(identityUserLogin);
return(Task.FromResult(result));
}
public Task AddLoginAsync(IdentityUser user, UserLoginInfo login, CancellationToken cancellationToken)
{
var loginInfo = new IdentityUserLogin <string>();
loginInfo.LoginProvider = login.LoginProvider;
loginInfo.ProviderDisplayName = login.ProviderDisplayName;
loginInfo.ProviderKey = login.ProviderKey;
loginInfo.UserId = user.Id;
_dbContext.UserLogins.Add(loginInfo);
_dbContext.SaveChanges();
return(Task.CompletedTask);
}
public static IIdentityUserLogin BuildEntity(ExternalLoginDto dto)
{
//If there exists a UserId - this means the database is still not migrated. E.g on the upgrade state.
//At this point we have to manually set the key, to ensure external logins can be used to upgrade
var key = dto.UserId.HasValue ? dto.UserId.Value.ToGuid().ToString() : dto.UserOrMemberKey.ToString();
var entity = new IdentityUserLogin(dto.Id, dto.LoginProvider, dto.ProviderKey, key, dto.CreateDate)
{
UserData = dto.UserData
};
// reset dirty initial properties (U4-1946)
entity.ResetDirtyProperties(false);
return(entity);
}
public static UserLoginContainer Create(string loginProvider, string providerKey)
{
var payload = new IdentityUserLogin <string>
{
ProviderKey = providerKey,
LoginProvider = loginProvider,
ProviderDisplayName = $"{loginProvider}:{providerKey}"
};
return(new UserLoginContainer
{
id = payload.GetId(),
Payload = payload,
Refs = Enumerable.Empty <string>(),
});
}
public Task <User> FindAsync(UserLoginInfo login)
{
IQueryConstraints <IdentityUserLogin> constraints = new QueryConstraints <IdentityUserLogin>()
.Where(x => x.ProviderKey == login.ProviderKey);
IdentityUserLogin info = queryRepository.SingleOrDefault(constraints);
if (info == null)
{
return(Task.FromResult <User>(null));
}
User user = FindById(info.UserId);
return(Task.FromResult(user));
}
public async Task AddLoginAsync(IdentityUser user, UserLoginInfo login)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
var db = IdentityDatabase.Init(conn, 2);
var instance = new IdentityUserLogin
{
UserId = user.Id,
LoginProvider = login.LoginProvider,
ProviderKey = login.ProviderKey,
};
await db.UserLogins.InsertAsync(instance);
}
}
public Task AddLoginAsync(TUser user, UserLoginInfo login, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var iul = new IdentityUserLogin <string>
{
UserId = user.Id.ToString(),
LoginProvider = login.LoginProvider,
ProviderDisplayName = login.ProviderDisplayName,
ProviderKey = login.ProviderKey
};
user.Logins.Add(iul);
return(Add(user, x => x.Logins, iul));
}
public static UserLoginContainer Create(string userId, string loginProvider, string providerKey)
{
var payload = new IdentityUserLogin <string>
{
UserId = userId,
ProviderKey = providerKey,
LoginProvider = loginProvider,
ProviderDisplayName = $"{loginProvider}:{providerKey}:{userId}"
};
return(new UserLoginContainer
{
id = payload.GetId(),
Payload = payload,
Refs = new[] { userId },
});
}
public IActionResult Post(object encryptObject)
{
try
{
IHeaderDictionary headers = _httpContextAccessor.HttpContext.Request.Headers;
string accessToken = headers.Where(x => x.Key == "Authorization").Select(x => x.Value).FirstOrDefault();
if (string.IsNullOrEmpty(accessToken))
{
return(BadRequest("Invalid Authorization"));
}
accessToken = accessToken.Substring(7);
string jsonString = AESGCM.Decrypt(encryptObject.ToString(), accessToken);
IdentityUserLogin <string> input = JsonConvert.DeserializeObject <IdentityUserLogin <string> >(jsonString);
ApplicationUser user = _dbContext.Users
.Join(_dbContext.UserLogins, Users => Users.Id, UserLogins => UserLogins.UserId, (Users, UserLogins) => new { Users, UserLogins })
.Where(x => x.UserLogins.ProviderKey == input.ProviderKey)
.Where(x => x.UserLogins.LoginProvider == input.LoginProvider)
.Select(x => x.Users)
.Include("Claims")
.Include("Logins")
.Include("Tokens")
.Include("RoleClaims")
//.Include("RoleClaims.User")
.Include("RoleClaims.Role")
.Include("RoleClaims.RoleClaim")
.Include("RoleClaims.History")
.Include("RoleClaims.History.ActionBy")
//.Include("RoleClaims.History.UserRoleClaim")
.FirstOrDefault();
jsonString = JsonConvert.SerializeObject(user, new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
string encryptString = AESGCM.Encrypt(jsonString, accessToken);
return(new JsonResult(encryptString));
}
catch (Exception exception)
{
_logger.Exception(exception);
return(BadRequest(exception));
}
}
public IdentityUserTests()
{
User = new IdentityUser("John Doe");
Role1 = new IdentityRole { Name = "Role1" };
Role2 = new IdentityRole { Name = "Role2" };
Claim1 = new IdentityClaim { ClaimType = "Claim1", ClaimValue = "Some value" };
Claim2 = new IdentityClaim { ClaimType = "Claim2", ClaimValue = "Some other value" };
Claim3 = new IdentityClaim { ClaimType = "Claim3", ClaimValue = "Yet another value" };
Claim4 = new IdentityClaim { ClaimType = "Claim4", ClaimValue = "Many many claims" };
Claim1Alt = new IdentityClaim { ClaimType = "Claim1", ClaimValue = "Some alternate value" };
Login1 = new IdentityUserLogin { LoginProvider = "Form", ProviderDisplayName = "Bob", ProviderKey = "password"};
}
private static void ProcessUser(ref TempUser temp)
{
lock (ObjectLock)
{
Console.WriteLine(migrateOption ? "Processing User: {0}" : "Analyzing User: {0}", temp.User.Id);
Console.WriteLine("Roles: {0}, Claims: {1}, Logins: {2}", temp.Roles.Count, temp.Claims.Count, temp.Logins.Count);
if (temp.Roles.Count > 0)
{
var newRoles = temp.Roles.Select(r =>
{
var item = new IdentityUserRole();
JsonConvert.PopulateObject(r.ToString(), item);
return item;
}).ToList();
var eRoles = temp.User.GetPropertyValue<List<IdentityUserRole>>("Roles");
if (eRoles != null)
{
eRoles.AddRange(newRoles.Where(n => !eRoles.Any(er => er.Id == n.Id)));
temp.User.SetPropertyValue("Roles", eRoles.ToArray());
}
else
{
temp.User.SetPropertyValue("Roles", newRoles.ToArray());
}
}
if (temp.Claims.Count > 0)
{
var newClaims = temp.Claims.Select(r =>
{
var item = new IdentityUserClaim();
JsonConvert.PopulateObject(r.ToString(), item);
return item;
}).ToList();
var eClaims = temp.User.GetPropertyValue<List<IdentityUserClaim>>("Claims");
if (eClaims != null)
{
eClaims.AddRange(newClaims.Where(n => !eClaims.Any(er => er.Id == n.Id)));
temp.User.SetPropertyValue("Claims", eClaims.ToArray());
}
else
{
temp.User.SetPropertyValue("Claims", newClaims.ToArray());
}
}
if (temp.Logins.Count > 0)
{
var newLogins = temp.Logins.Select(r =>
{
var item = new IdentityUserLogin();
JsonConvert.PopulateObject(r.ToString(), item);
return item;
}).ToList();
var eLogins = temp.User.GetPropertyValue<List<IdentityUserLogin>>("Logins");
if (eLogins != null)
{
eLogins.AddRange(newLogins.Where(n => !eLogins.Any(er => er.Id == n.Id)));
temp.User.SetPropertyValue("Logins", eLogins.ToArray());
}
else
{
temp.User.SetPropertyValue("Logins", newLogins.ToArray());
}
}
}
}
private async Task RefreshGamesForLoginAsync(GGCharityUser user, IdentityUserLogin login)
{
if (login.LoginProvider == "BattleNet")
{
IdentityUserClaim battleNetAccessTokenClaim = user.Claims.Where(c => c.ClaimType == @"urn:battlenet:accesstoken").SingleOrDefault();
if (battleNetAccessTokenClaim == null)
{
Trace.TraceEvent(TraceEventType.Critical, 0, "User {0} has a BattleNet login but no access token claim", user.Id);
return;
}
string battleNetAccessToken = battleNetAccessTokenClaim.ClaimValue;
await LoadBattleNetUserDataAsync(user, battleNetAccessToken);
}
}
public IdentityUserLoginWrapper(IdentityUserLogin login)
{
this.UserId = login.UserId;
this.LoginProvider = login.LoginProvider;
this.ProviderKey = login.ProviderKey;
}
