public virtual async Task <bool> IsLinkedAsync(IdentityLinkUserInfo sourceLinkUser, IdentityLinkUserInfo targetLinkUser)
{
using (CurrentTenant.Change(null))
{
return(await IdentityLinkUserRepository.FindAsync(sourceLinkUser, targetLinkUser) != null);
}
}
public async Task GetListAsync_Indirect_Test()
{
var a = Guid.NewGuid();
var b = Guid.NewGuid();
var c = Guid.NewGuid();
var d = Guid.NewGuid();
var e = Guid.NewGuid();
var f = Guid.NewGuid();
var g = Guid.NewGuid();
var h = Guid.NewGuid();
var i = Guid.NewGuid();
await IdentityLinkUserRepository.InsertAsync(new IdentityLinkUser(
Guid.NewGuid(),
new IdentityLinkUserInfo(a, null),
new IdentityLinkUserInfo(b, null)), true);
await IdentityLinkUserRepository.InsertAsync(new IdentityLinkUser(
Guid.NewGuid(),
new IdentityLinkUserInfo(c, null),
new IdentityLinkUserInfo(a, null)), true);
await IdentityLinkUserRepository.InsertAsync(new IdentityLinkUser(
Guid.NewGuid(),
new IdentityLinkUserInfo(d, null),
new IdentityLinkUserInfo(c, null)), true);
await IdentityLinkUserRepository.InsertAsync(new IdentityLinkUser(
Guid.NewGuid(),
new IdentityLinkUserInfo(e, null),
new IdentityLinkUserInfo(c, null)), true);
await IdentityLinkUserRepository.InsertAsync(new IdentityLinkUser(
Guid.NewGuid(),
new IdentityLinkUserInfo(f, null),
new IdentityLinkUserInfo(e, null)), true);
await IdentityLinkUserRepository.InsertAsync(new IdentityLinkUser(
Guid.NewGuid(),
new IdentityLinkUserInfo(g, null),
new IdentityLinkUserInfo(h, null)), true);
await IdentityLinkUserRepository.InsertAsync(new IdentityLinkUser(
Guid.NewGuid(),
new IdentityLinkUserInfo(i, null),
new IdentityLinkUserInfo(h, null)), true);
var linkUsers = await IdentityLinkUserManager.GetListAsync(new IdentityLinkUserInfo(a, null), includeIndirect : true);
linkUsers.Count.ShouldBe(5);
linkUsers = await IdentityLinkUserManager.GetListAsync(new IdentityLinkUserInfo(f, null), includeIndirect : true);
linkUsers.Count.ShouldBe(5);
linkUsers = await IdentityLinkUserManager.GetListAsync(new IdentityLinkUserInfo(g, null), includeIndirect : true);
linkUsers.Count.ShouldBe(2);
}
public virtual async Task <bool> IsLinkedAsync(IdentityLinkUserInfo sourceLinkUser, IdentityLinkUserInfo targetLinkUser, bool includeIndirect = false, CancellationToken cancellationToken = default)
{
using (CurrentTenant.Change(null))
{
if (includeIndirect)
{
return((await GetListAsync(sourceLinkUser, true, cancellationToken: cancellationToken))
.Any(x => x.SourceTenantId == targetLinkUser.TenantId && x.SourceUserId == targetLinkUser.UserId ||
x.TargetTenantId == targetLinkUser.TenantId && x.TargetUserId == targetLinkUser.UserId));
}
return(await IdentityLinkUserRepository.FindAsync(sourceLinkUser, targetLinkUser, cancellationToken) != null);
}
}
public virtual async Task UnlinkAsync(IdentityLinkUserInfo sourceLinkUser, IdentityLinkUserInfo targetLinkUser)
{
if (!await IsLinkedAsync(sourceLinkUser, targetLinkUser))
{
return;
}
var linkedUser = await IdentityLinkUserRepository.FindAsync(sourceLinkUser, targetLinkUser);
if (linkedUser != null)
{
await IdentityLinkUserRepository.DeleteAsync(linkedUser);
}
}
public virtual async Task UnlinkAsync()
{
var john = await UserRepository.GetAsync(TestData.UserJohnId);
var david = await UserRepository.GetAsync(TestData.UserDavidId);
(await IdentityLinkUserRepository.FindAsync(new IdentityLinkUserInfo(john.Id, john.TenantId),
new IdentityLinkUserInfo(david.Id, david.TenantId))).ShouldNotBeNull();
await IdentityLinkUserManager.UnlinkAsync(new IdentityLinkUserInfo(john.Id, john.TenantId),
new IdentityLinkUserInfo(david.Id, david.TenantId));
(await IdentityLinkUserRepository.FindAsync(new IdentityLinkUserInfo(john.Id, john.TenantId),
new IdentityLinkUserInfo(david.Id, david.TenantId))).ShouldBeNull();
}
public async Task GetListAsync()
{
var john = await UserRepository.GetAsync(TestData.UserJohnId);
var david = await UserRepository.GetAsync(TestData.UserDavidId);
var neo = await UserRepository.GetAsync(TestData.UserNeoId);
var davidLinkUsers = await IdentityLinkUserRepository.GetListAsync(new IdentityLinkUserInfo(david.Id, david.TenantId));
davidLinkUsers.ShouldNotBeNull();
davidLinkUsers.ShouldContain(x => x.SourceUserId == john.Id && x.SourceTenantId == john.TenantId);
davidLinkUsers.ShouldContain(x => x.TargetUserId == neo.Id && x.TargetTenantId == neo.TenantId);
}
public async Task <List <IdentityLinkUser> > GetListAsync(IdentityLinkUserInfo linkUserInfo, bool includeIndirect = false, CancellationToken cancellationToken = default)
{
using (CurrentTenant.Change(null))
{
var users = await IdentityLinkUserRepository.GetListAsync(linkUserInfo, cancellationToken : cancellationToken);
if (includeIndirect == false)
{
return(users);
}
var userInfos = new List <IdentityLinkUserInfo>()
{
linkUserInfo
};
var allUsers = new List <IdentityLinkUser>();
allUsers.AddRange(users);
do
{
var nextUsers = new List <IdentityLinkUserInfo>();
foreach (var user in users)
{
if (userInfos.Any(x => x.TenantId != user.SourceTenantId || x.UserId != user.SourceUserId))
{
nextUsers.Add(new IdentityLinkUserInfo(user.SourceUserId, user.SourceTenantId));
}
if (userInfos.Any(x => x.TenantId != user.TargetTenantId || x.UserId != user.TargetUserId))
{
nextUsers.Add(new IdentityLinkUserInfo(user.TargetUserId, user.TargetTenantId));
}
}
users = new List <IdentityLinkUser>();
foreach (var next in nextUsers)
{
users.AddRange(await IdentityLinkUserRepository.GetListAsync(next, userInfos, cancellationToken));
}
userInfos.AddRange(nextUsers);
allUsers.AddRange(users);
} while (users.Any());
return(allUsers);
}
}
public virtual async Task UnlinkAsync(IdentityLinkUserInfo sourceLinkUser, IdentityLinkUserInfo targetLinkUser, CancellationToken cancellationToken = default)
{
using (CurrentTenant.Change(null))
{
if (!await IsLinkedAsync(sourceLinkUser, targetLinkUser, cancellationToken: cancellationToken))
{
return;
}
var linkedUser = await IdentityLinkUserRepository.FindAsync(sourceLinkUser, targetLinkUser, cancellationToken);
if (linkedUser != null)
{
await IdentityLinkUserRepository.DeleteAsync(linkedUser, cancellationToken : cancellationToken);
}
}
}
public virtual async Task LinkAsync(IdentityLinkUserInfo sourceLinkUser, IdentityLinkUserInfo targetLinkUser)
{
if (sourceLinkUser.UserId == targetLinkUser.UserId && sourceLinkUser.TenantId == targetLinkUser.TenantId)
{
return;
}
if (await IsLinkedAsync(sourceLinkUser, targetLinkUser))
{
return;
}
var userLink = new IdentityLinkUser(
GuidGenerator.Create(),
sourceLinkUser,
targetLinkUser);
await IdentityLinkUserRepository.InsertAsync(userLink, true);
}
public virtual async Task LinkAsync(IdentityLinkUserInfo sourceLinkUser, IdentityLinkUserInfo targetLinkUser, CancellationToken cancellationToken = default)
{
using (CurrentTenant.Change(null))
{
if (sourceLinkUser.UserId == targetLinkUser.UserId && sourceLinkUser.TenantId == targetLinkUser.TenantId)
{
return;
}
if (await IsLinkedAsync(sourceLinkUser, targetLinkUser, cancellationToken: cancellationToken))
{
return;
}
var userLink = new IdentityLinkUser(
GuidGenerator.Create(),
sourceLinkUser,
targetLinkUser);
await IdentityLinkUserRepository.InsertAsync(userLink, true, cancellationToken);
}
}
public virtual async Task LinkAsync()
{
var john = await UserRepository.GetAsync(TestData.UserJohnId);
var neo = await UserRepository.GetAsync(TestData.UserNeoId);
(await IdentityLinkUserRepository.FindAsync(new IdentityLinkUserInfo(john.Id, john.TenantId),
new IdentityLinkUserInfo(neo.Id, neo.TenantId))).ShouldBeNull();
await IdentityLinkUserManager.LinkAsync(new IdentityLinkUserInfo(john.Id, john.TenantId),
new IdentityLinkUserInfo(neo.Id, neo.TenantId));
var linkUser = await IdentityLinkUserRepository.FindAsync(new IdentityLinkUserInfo(john.Id, john.TenantId),
new IdentityLinkUserInfo(neo.Id, neo.TenantId));
linkUser.ShouldNotBeNull();
linkUser.SourceUserId.ShouldBe(john.Id);
linkUser.SourceTenantId.ShouldBe(john.TenantId);
linkUser.TargetUserId.ShouldBe(neo.Id);
linkUser.TargetTenantId.ShouldBe(neo.TenantId);
}
public async Task FindAsync()
{
var john = await UserRepository.GetAsync(TestData.UserJohnId);
var david = await UserRepository.GetAsync(TestData.UserDavidId);
var neo = await UserRepository.GetAsync(TestData.UserNeoId);
var johnAndDavidLinkUser = await IdentityLinkUserRepository.FindAsync(
new IdentityLinkUserInfo(john.Id, john.TenantId),
new IdentityLinkUserInfo(david.Id, david.TenantId));
johnAndDavidLinkUser.ShouldNotBeNull();
johnAndDavidLinkUser.SourceUserId.ShouldBe(john.Id);
johnAndDavidLinkUser.SourceTenantId.ShouldBe(john.TenantId);
johnAndDavidLinkUser.TargetUserId.ShouldBe(david.Id);
johnAndDavidLinkUser.TargetTenantId.ShouldBe(david.TenantId);
(await IdentityLinkUserRepository.FindAsync(
new IdentityLinkUserInfo(john.Id, john.TenantId),
new IdentityLinkUserInfo(neo.Id, neo.TenantId))).ShouldBeNull();
}
public virtual async Task <bool> IsLinkedAsync(IdentityLinkUserInfo sourceLinkUser, IdentityLinkUserInfo targetLinkUser)
{
return(await IdentityLinkUserRepository.FindAsync(sourceLinkUser, targetLinkUser) != null);
}
