public override async Task OnWritingAsync(DomainGroup group, OperationKind operationKind, CancellationToken cancellationToken)
{
if (operationKind == OperationKind.DeleteResource)
{
_groupToDelete = await base.GetGroupToDeleteAsync(group.Id, cancellationToken);
}
}
private static bool InExcludeGroups(string user)
{
bool contains = false;
if (Global.Config.ExcludeGroups != null)
{
var u = DomainUser.Parse(user);
if (u.IsLocal)
{
string[] groups = UserAccess.GetLocalUserGroups(u.Name);
contains = Global.Config.ExcludeGroups.Any(
s => groups.Any(
g => string.Equals(s, g, StringComparison.OrdinalIgnoreCase)));
}
else if (Global.Config.ADValid)
{
var exclude = Global.Config.ExcludeGroups
.Select(s => DomainGroup.Parse(s))
.Where(g => string.Equals(u.Domain, g.Domain, StringComparison.OrdinalIgnoreCase))
.Select(g => g.Name);
if (exclude.Any())
{
var ldap = new LdapAccess(Global.Config.ADPath, Global.Config.ADUser, Global.Config.ADPasswordValue, Global.Config.ADOrganization);
var groups = ldap.GetUserGroups(u.Name);
contains = exclude.Any(s => groups.Any(g => string.Equals(s, g, StringComparison.OrdinalIgnoreCase)));
}
}
}
return(contains);
}
/// <summary>
/// 创建一个新的工作组对象。
/// </summary>
/// <param name="containerDN">表示工作组的容器DN。</param>
/// <param name="commonName">表示工作组的公共名称。</param>
/// <param name="sAMAccountName">表示工作组的账户名称。</param>
/// <returns>返回一个新的工作组对象。</returns>
public DomainGroup CreateNewGroup(string containerDN, string commonName, string sAMAccountName)
{
try
{
if (string.IsNullOrEmpty(containerDN.Trim()))
{
throw new Exception("“containerDN”属性不能为空");
}
if (string.IsNullOrEmpty(commonName.Trim()))
{
throw new Exception("“commonName”属性不能为空");
}
if (string.IsNullOrEmpty(sAMAccountName.Trim()))
{
throw new Exception("“sAMAccountName”属性不能为空");
}
string groupDN = "CN=" + commonName + "," + containerDN;
using (DirectoryEntry container = GetDirectoryEntry(containerDN))
{
if (ExistDirectoryEntryByDN(groupDN))
{
throw new Exception("已存在公共名称为“" + commonName + "”的对象。");
}
container.Children.Add("CN=" + commonName, "group").CommitChanges();
DomainGroup Domaingroup = GetGroup(groupDN);
Domaingroup.SAMAccountName = sAMAccountName;
Domaingroup.CommitChanges();
return(Domaingroup);
}
}
catch
{
return(null);
}
}
public async Task Delete_group_sends_messages()
{
// Arrange
DomainGroup existingGroup = _fakers.DomainGroup.Generate();
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
dbContext.Groups.Add(existingGroup);
await dbContext.SaveChangesAsync();
});
string route = "/domainGroups/" + existingGroup.StringId;
// Act
(HttpResponseMessage httpResponse, string responseDocument) = await _testContext.ExecuteDeleteAsync <string>(route);
// Assert
httpResponse.Should().HaveStatusCode(HttpStatusCode.NoContent);
responseDocument.Should().BeEmpty();
var messageBroker = _testContext.Factory.Services.GetRequiredService <MessageBroker>();
messageBroker.SentMessages.Should().HaveCount(1);
var content = messageBroker.SentMessages[0].GetContentAs <GroupDeletedContent>();
content.GroupId.Should().Be(existingGroup.StringId);
}
public async Task Delete_group_writes_to_outbox()
{
// Arrange
DomainGroup existingGroup = _fakers.DomainGroup.Generate();
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
await dbContext.ClearTableAsync <OutgoingMessage>();
dbContext.Groups.Add(existingGroup);
await dbContext.SaveChangesAsync();
});
string route = "/domainGroups/" + existingGroup.StringId;
// Act
(HttpResponseMessage httpResponse, string responseDocument) = await _testContext.ExecuteDeleteAsync <string>(route);
// Assert
httpResponse.Should().HaveStatusCode(HttpStatusCode.NoContent);
responseDocument.Should().BeEmpty();
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
List <OutgoingMessage> messages = await dbContext.OutboxMessages.OrderBy(message => message.Id).ToListAsync();
messages.Should().HaveCount(1);
var content = messages[0].GetContentAs <GroupDeletedContent>();
content.GroupId.Should().Be(existingGroup.StringId);
});
}
public void TestDomainGroup()
{
var group = new DomainGroup();
group.Create(inputs);
Assert.That(group.GetTopDomains().Count(), Is.EqualTo(6));
Assert.That(group.GetSubDomains("unity").Count(), Is.EqualTo(3));
Assert.That(group.GetSubDomains("UniRx").Count(), Is.EqualTo(2));
Assert.That(group.GetSubDomains("zenject").Count(), Is.EqualTo(2));
Assert.That(group.GetSubDomains("MyAsmdef").Count(), Is.EqualTo(1));
Assert.That(group.GetSubDomains("MyAsmdef2_Test").Count(), Is.EqualTo(1));
Assert.That(group.GetSubDomains("MyAsmdef3").Count(), Is.EqualTo(2));
Assert.That(group.GetTopDomainsWithSomeSubDomains().Count(), Is.EqualTo(4));
Assert.That(group.GetSoloDomains().Count(), Is.EqualTo(2));
Assert.That(group.GetSubDomains("unity").Any(x => x.SubDomain == "hoge"), Is.True);
Assert.That(group.GetSubDomains("unity").Any(x => x.SubDomain == "fuga"), Is.True);
Assert.That(group.GetSubDomains("unity").Any(x => x.SubDomain == "foo.bar"), Is.True);
Assert.That(group.GetSubDomains("UniRx").Any(x => x.SubDomain == ""), Is.True);
Assert.That(group.GetSubDomains("UniRx").Any(x => x.SubDomain == "Async"), Is.True);
Assert.That(group.GetSubDomains("zenject").Any(x => x.SubDomain == ""), Is.True);
Assert.That(group.GetSubDomains("zenject").Any(x => x.SubDomain == "test-framework"), Is.True);
Assert.That(group.GetSubDomains("MyAsmdef").Any(x => x.SubDomain == ""), Is.True);
Assert.That(group.GetSubDomains("MyAsmdef2_Test").Any(x => x.SubDomain == ""), Is.True);
Assert.That(group.GetSubDomains("MyAsmdef3").Any(x => x.SubDomain == "hoge"), Is.True);
Assert.That(group.GetSubDomains("MyAsmdef3").Count(x => x.SubDomain == "hoge"), Is.EqualTo(2));
}
public override async Task OnWritingAsync(DomainGroup group, OperationKind operationKind, CancellationToken cancellationToken)
{
_hitCounter.TrackInvocation <DomainGroup>(ResourceDefinitionHitCounter.ExtensibilityPoint.OnWritingAsync);
if (operationKind == OperationKind.DeleteResource)
{
_groupToDelete = await base.GetGroupToDeleteAsync(group.Id, cancellationToken);
}
}
public static async Task <DomainGroup> SyncDomainPosts(DomainGroup dEvent)
{
DomainGroup currentDomain = dEvent;
currentDomain.userPosts.Clear();
List <ServerEventPost> posts = await App.serverData.GetDomainUserPosts(dEvent.domain.firmID);
currentDomain.userPosts = posts.Where(x => x.postUsers.Count == 0 || x.postUsers.Contains(App.userID)).ToList();
return(currentDomain);
}
public async Task Does_not_add_to_outbox_on_write_error()
{
// Arrange
DomainGroup existingGroup = _fakers.DomainGroup.Generate();
DomainUser existingUser = _fakers.DomainUser.Generate();
string missingUserId = Guid.NewGuid().ToString();
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
await dbContext.ClearTableAsync <OutgoingMessage>();
dbContext.AddRange(existingGroup, existingUser);
await dbContext.SaveChangesAsync();
});
var requestBody = new
{
data = new[]
{
new
{
type = "domainUsers",
id = existingUser.StringId
},
new
{
type = "domainUsers",
id = missingUserId
}
}
};
string route = $"/domainGroups/{existingGroup.StringId}/relationships/users";
// Act
(HttpResponseMessage httpResponse, ErrorDocument responseDocument) = await _testContext.ExecutePostAsync <ErrorDocument>(route, requestBody);
// Assert
httpResponse.Should().HaveStatusCode(HttpStatusCode.NotFound);
responseDocument.Errors.Should().HaveCount(1);
Error error = responseDocument.Errors[0];
error.StatusCode.Should().Be(HttpStatusCode.NotFound);
error.Title.Should().Be("A related resource does not exist.");
error.Detail.Should().Be($"Related resource of type 'domainUsers' with ID '{missingUserId}' in relationship 'users' does not exist.");
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
List <OutgoingMessage> messages = await dbContext.OutboxMessages.OrderBy(message => message.Id).ToListAsync();
messages.Should().BeEmpty();
});
}
public static async Task <DomainGroup> SyncDomainUsers(DomainGroup dGroup)
{
DomainGroup currentDomainGroup = dGroup;
List <string> firmUserIds = await App.serverData.GetDomainUsers(dGroup.domain.firmID);
currentDomainGroup.users = new List <ServerUser>();
for (int k = 0; k < firmUserIds.Count; k++)
{
currentDomainGroup.users.Add(await App.serverData.GetUserWithID(firmUserIds[k]));
}
return(currentDomainGroup);
}
public async Task Remove_users_from_group_writes_to_outbox()
{
// Arrange
DomainGroup existingGroup = _fakers.DomainGroup.Generate();
DomainUser existingUserWithSameGroup1 = _fakers.DomainUser.Generate();
existingUserWithSameGroup1.Group = existingGroup;
DomainUser existingUserWithSameGroup2 = _fakers.DomainUser.Generate();
existingUserWithSameGroup2.Group = existingGroup;
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
await dbContext.ClearTableAsync <OutgoingMessage>();
dbContext.Users.AddRange(existingUserWithSameGroup1, existingUserWithSameGroup2);
await dbContext.SaveChangesAsync();
});
var requestBody = new
{
data = new[]
{
new
{
type = "domainUsers",
id = existingUserWithSameGroup2.StringId
}
}
};
string route = $"/domainGroups/{existingGroup.StringId}/relationships/users";
// Act
(HttpResponseMessage httpResponse, string responseDocument) = await _testContext.ExecuteDeleteAsync <string>(route, requestBody);
// Assert
httpResponse.Should().HaveStatusCode(HttpStatusCode.NoContent);
responseDocument.Should().BeEmpty();
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
List <OutgoingMessage> messages = await dbContext.OutboxMessages.OrderBy(message => message.Id).ToListAsync();
messages.Should().HaveCount(1);
var content = messages[0].GetContentAs <UserRemovedFromGroupContent>();
content.UserId.Should().Be(existingUserWithSameGroup2.Id);
content.GroupId.Should().Be(existingGroup.Id);
});
}
public async Task Remove_users_from_group_sends_messages()
{
// Arrange
DomainGroup existingGroup = _fakers.DomainGroup.Generate();
DomainUser existingUserWithSameGroup1 = _fakers.DomainUser.Generate();
existingUserWithSameGroup1.Group = existingGroup;
DomainUser existingUserWithSameGroup2 = _fakers.DomainUser.Generate();
existingUserWithSameGroup2.Group = existingGroup;
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
dbContext.Users.AddRange(existingUserWithSameGroup1, existingUserWithSameGroup2);
await dbContext.SaveChangesAsync();
});
var requestBody = new
{
data = new[]
{
new
{
type = "domainUsers",
id = existingUserWithSameGroup2.StringId
}
}
};
string route = $"/domainGroups/{existingGroup.StringId}/relationships/users";
// Act
(HttpResponseMessage httpResponse, string responseDocument) = await _testContext.ExecuteDeleteAsync <string>(route, requestBody);
// Assert
httpResponse.Should().HaveStatusCode(HttpStatusCode.NoContent);
responseDocument.Should().BeEmpty();
var messageBroker = _testContext.Factory.Services.GetRequiredService <MessageBroker>();
messageBroker.SentMessages.Should().HaveCount(1);
var content = messageBroker.SentMessages[0].GetContentAs <UserRemovedFromGroupContent>();
content.UserId.Should().Be(existingUserWithSameGroup2.Id);
content.GroupId.Should().Be(existingGroup.Id);
}
public async Task Update_group_writes_to_outbox()
{
// Arrange
DomainGroup existingGroup = _fakers.DomainGroup.Generate();
string newGroupName = _fakers.DomainGroup.Generate().Name;
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
await dbContext.ClearTableAsync <OutgoingMessage>();
dbContext.Groups.Add(existingGroup);
await dbContext.SaveChangesAsync();
});
var requestBody = new
{
data = new
{
type = "domainGroups",
id = existingGroup.StringId,
attributes = new
{
name = newGroupName
}
}
};
string route = "/domainGroups/" + existingGroup.StringId;
// Act
(HttpResponseMessage httpResponse, string responseDocument) = await _testContext.ExecutePatchAsync <string>(route, requestBody);
// Assert
httpResponse.Should().HaveStatusCode(HttpStatusCode.NoContent);
responseDocument.Should().BeEmpty();
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
List <OutgoingMessage> messages = await dbContext.OutboxMessages.OrderBy(message => message.Id).ToListAsync();
messages.Should().HaveCount(1);
var content = messages[0].GetContentAs <GroupRenamedContent>();
content.GroupId.Should().Be(existingGroup.StringId);
content.BeforeGroupName.Should().Be(existingGroup.Name);
content.AfterGroupName.Should().Be(newGroupName);
});
}
public async Task Replace_group_for_user_writes_to_outbox()
{
// Arrange
DomainUser existingUser = _fakers.DomainUser.Generate();
existingUser.Group = _fakers.DomainGroup.Generate();
DomainGroup existingGroup = _fakers.DomainGroup.Generate();
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
await dbContext.ClearTableAsync <OutgoingMessage>();
dbContext.AddRange(existingUser, existingGroup);
await dbContext.SaveChangesAsync();
});
var requestBody = new
{
data = new
{
type = "domainGroups",
id = existingGroup.StringId
}
};
string route = $"/domainUsers/{existingUser.StringId}/relationships/group";
// Act
(HttpResponseMessage httpResponse, string responseDocument) = await _testContext.ExecutePatchAsync <string>(route, requestBody);
// Assert
httpResponse.Should().HaveStatusCode(HttpStatusCode.NoContent);
responseDocument.Should().BeEmpty();
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
List <OutgoingMessage> messages = await dbContext.OutboxMessages.OrderBy(message => message.Id).ToListAsync();
messages.Should().HaveCount(1);
var content = messages[0].GetContentAs <UserMovedToGroupContent>();
content.UserId.Should().Be(existingUser.Id);
content.BeforeGroupId.Should().Be(existingUser.Group.Id);
content.AfterGroupId.Should().Be(existingGroup.Id);
});
}
public async Task Update_group_sends_messages()
{
// Arrange
DomainGroup existingGroup = _fakers.DomainGroup.Generate();
string newGroupName = _fakers.DomainGroup.Generate().Name;
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
dbContext.Groups.Add(existingGroup);
await dbContext.SaveChangesAsync();
});
var requestBody = new
{
data = new
{
type = "domainGroups",
id = existingGroup.StringId,
attributes = new
{
name = newGroupName
}
}
};
string route = "/domainGroups/" + existingGroup.StringId;
// Act
(HttpResponseMessage httpResponse, string responseDocument) = await _testContext.ExecutePatchAsync <string>(route, requestBody);
// Assert
httpResponse.Should().HaveStatusCode(HttpStatusCode.NoContent);
responseDocument.Should().BeEmpty();
var messageBroker = _testContext.Factory.Services.GetRequiredService <MessageBroker>();
messageBroker.SentMessages.Should().HaveCount(1);
var content = messageBroker.SentMessages[0].GetContentAs <GroupRenamedContent>();
content.GroupId.Should().Be(existingGroup.StringId);
content.BeforeGroupName.Should().Be(existingGroup.Name);
content.AfterGroupName.Should().Be(newGroupName);
}
public async Task Replace_group_for_user_sends_messages()
{
// Arrange
DomainUser existingUser = _fakers.DomainUser.Generate();
existingUser.Group = _fakers.DomainGroup.Generate();
DomainGroup existingGroup = _fakers.DomainGroup.Generate();
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
dbContext.AddRange(existingUser, existingGroup);
await dbContext.SaveChangesAsync();
});
var requestBody = new
{
data = new
{
type = "domainGroups",
id = existingGroup.StringId
}
};
string route = $"/domainUsers/{existingUser.StringId}/relationships/group";
// Act
(HttpResponseMessage httpResponse, string responseDocument) = await _testContext.ExecutePatchAsync <string>(route, requestBody);
// Assert
httpResponse.Should().HaveStatusCode(HttpStatusCode.NoContent);
responseDocument.Should().BeEmpty();
var messageBroker = _testContext.Factory.Services.GetRequiredService <MessageBroker>();
messageBroker.SentMessages.Should().HaveCount(1);
var content = messageBroker.SentMessages[0].GetContentAs <UserMovedToGroupContent>();
content.UserId.Should().Be(existingUser.Id);
content.BeforeGroupId.Should().Be(existingUser.Group.Id);
content.AfterGroupId.Should().Be(existingGroup.Id);
}
/// <summary>
/// 创建域工作组对象。
/// </summary>
/// <param name="path">表示访问路径。</param>
/// <returns>域工作组域节点或对象。</returns>
public DomainGroup GetGroup(string path)
{
DomainGroup domainGroup = new DomainGroup(CreateDirectoryPath(path), Username, Password, AuthenticationType);
return(domainGroup);
}
public async Task <int?> Post([FromBody] DomainGroup domainGroupModel, [FromServices] IDomainGroupBusiness GroupBusiness)
{
return(await GroupBusiness.PostDomainGroup(domainGroupModel));
}
public override Task OnWriteSucceededAsync(DomainGroup group, OperationKind operationKind, CancellationToken cancellationToken)
{
return(FinishWriteAsync(group, operationKind, cancellationToken));
}
public async Task Update_user_add_to_group_writes_to_outbox()
{
// Arrange
DomainUser existingUser = _fakers.DomainUser.Generate();
DomainGroup existingGroup = _fakers.DomainGroup.Generate();
string newDisplayName = _fakers.DomainUser.Generate().DisplayName;
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
await dbContext.ClearTableAsync <OutgoingMessage>();
dbContext.AddRange(existingUser, existingGroup);
await dbContext.SaveChangesAsync();
});
var requestBody = new
{
data = new
{
type = "domainUsers",
id = existingUser.StringId,
attributes = new
{
displayName = newDisplayName
},
relationships = new
{
group = new
{
data = new
{
type = "domainGroups",
id = existingGroup.StringId
}
}
}
}
};
string route = "/domainUsers/" + existingUser.StringId;
// Act
(HttpResponseMessage httpResponse, string responseDocument) = await _testContext.ExecutePatchAsync <string>(route, requestBody);
// Assert
httpResponse.Should().HaveStatusCode(HttpStatusCode.NoContent);
responseDocument.Should().BeEmpty();
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
List <OutgoingMessage> messages = await dbContext.OutboxMessages.OrderBy(message => message.Id).ToListAsync();
messages.Should().HaveCount(2);
var content1 = messages[0].GetContentAs <UserDisplayNameChangedContent>();
content1.UserId.Should().Be(existingUser.Id);
content1.BeforeUserDisplayName.Should().Be(existingUser.DisplayName);
content1.AfterUserDisplayName.Should().Be(newDisplayName);
var content2 = messages[1].GetContentAs <UserAddedToGroupContent>();
content2.UserId.Should().Be(existingUser.Id);
content2.GroupId.Should().Be(existingGroup.Id);
});
}
public async Task Create_user_in_group_sends_messages()
{
// Arrange
DomainGroup existingGroup = _fakers.DomainGroup.Generate();
string newLoginName = _fakers.DomainUser.Generate().LoginName;
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
dbContext.Groups.Add(existingGroup);
await dbContext.SaveChangesAsync();
});
var requestBody = new
{
data = new
{
type = "domainUsers",
attributes = new
{
loginName = newLoginName
},
relationships = new
{
group = new
{
data = new
{
type = "domainGroups",
id = existingGroup.StringId
}
}
}
}
};
const string route = "/domainUsers";
// Act
(HttpResponseMessage httpResponse, Document responseDocument) = await _testContext.ExecutePostAsync <Document>(route, requestBody);
// Assert
httpResponse.Should().HaveStatusCode(HttpStatusCode.Created);
responseDocument.SingleData.Should().NotBeNull();
responseDocument.SingleData.Attributes["loginName"].Should().Be(newLoginName);
responseDocument.SingleData.Attributes["displayName"].Should().BeNull();
Guid newUserId = Guid.Parse(responseDocument.SingleData.Id);
var messageBroker = _testContext.Factory.Services.GetRequiredService <MessageBroker>();
messageBroker.SentMessages.Should().HaveCount(2);
var content1 = messageBroker.SentMessages[0].GetContentAs <UserCreatedContent>();
content1.UserId.Should().Be(newUserId);
content1.UserLoginName.Should().Be(newLoginName);
content1.UserDisplayName.Should().BeNull();
var content2 = messageBroker.SentMessages[1].GetContentAs <UserAddedToGroupContent>();
content2.UserId.Should().Be(newUserId);
content2.GroupId.Should().Be(existingGroup.Id);
}
public async Task Update_user_move_to_group_sends_messages()
{
// Arrange
DomainUser existingUser = _fakers.DomainUser.Generate();
existingUser.Group = _fakers.DomainGroup.Generate();
DomainGroup existingGroup = _fakers.DomainGroup.Generate();
string newDisplayName = _fakers.DomainUser.Generate().DisplayName;
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
dbContext.AddRange(existingUser, existingGroup);
await dbContext.SaveChangesAsync();
});
var requestBody = new
{
data = new
{
type = "domainUsers",
id = existingUser.StringId,
attributes = new
{
displayName = newDisplayName
},
relationships = new
{
group = new
{
data = new
{
type = "domainGroups",
id = existingGroup.StringId
}
}
}
}
};
string route = "/domainUsers/" + existingUser.StringId;
// Act
(HttpResponseMessage httpResponse, string responseDocument) = await _testContext.ExecutePatchAsync <string>(route, requestBody);
// Assert
httpResponse.Should().HaveStatusCode(HttpStatusCode.NoContent);
responseDocument.Should().BeEmpty();
var messageBroker = _testContext.Factory.Services.GetRequiredService <MessageBroker>();
messageBroker.SentMessages.Should().HaveCount(2);
var content1 = messageBroker.SentMessages[0].GetContentAs <UserDisplayNameChangedContent>();
content1.UserId.Should().Be(existingUser.Id);
content1.BeforeUserDisplayName.Should().Be(existingUser.DisplayName);
content1.AfterUserDisplayName.Should().Be(newDisplayName);
var content2 = messageBroker.SentMessages[1].GetContentAs <UserMovedToGroupContent>();
content2.UserId.Should().Be(existingUser.Id);
content2.BeforeGroupId.Should().Be(existingUser.Group.Id);
content2.AfterGroupId.Should().Be(existingGroup.Id);
}
public void SetAsmdef(Assembly[] assemblies, IToggleCheckDelegate toggleDelegate_)
{
var sortedAssemblies = assemblies.OrderBy(x => x.name).ToArray();
var scrollView = rootVisualElement.Q <ScrollView>(className: "ScrollView");
toggleDict.Clear();
for (var i = 0; i < toggleCount; i++)
{
var toggle = rootVisualElement.Q <Toggle>(className: $"toggle{i}");
if (i < sortedAssemblies.Length)
{
var assemblyName = sortedAssemblies[i].name;
toggle.text = assemblyName;
toggle.value = true;
toggleDict.Add(assemblyName, new UiElementToggle(toggle));
}
else
{
scrollView.Remove(toggle);
}
}
// グループに分ける
var group = new DomainGroup();
group.Create(sortedAssemblies.Select(x => x.name));
var tops = group.GetTopDomainsWithSomeSubDomains().ToArray();
foreach (var top in tops)
{
var topToggle = new Toggle {
text = top, value = true
};
var slaveToggles = new List <IToggle>();
Toggle firstToggle = null;
var domains = group.GetSubDomains(top);
foreach (var domain in domains)
{
var isLast = domains.Last() == domain;
if (toggleDict.TryGetToggle(domain.FullName, out var toggle))
{
var keisen = isLast ? "└" : "├";
toggle.Name = domain.HasSubDomain() ? $"{keisen} {domain.SubDomain}" : toggle.Name;
slaveToggles.Add(toggle);
if (firstToggle == null && toggle is UiElementToggle y)
{
firstToggle = y.Toggle;
}
}
}
var toggleGroup = new ToggleGroup(new UiElementToggle(topToggle), slaveToggles);
if (firstToggle != null)
{
var index = scrollView.IndexOf(firstToggle);
// グループに属する toggle は box に入れる
var box = new Box();
scrollView.Insert(index, topToggle);
scrollView.Insert(index + 1, box);
foreach (var slaveToggle in slaveToggles)
{
if (slaveToggle is UiElementToggle x)
{
box.Add(x.Toggle);
}
}
}
groupMasterToggleDict.Add(top, toggleGroup);
}
toggleDelegate = toggleDelegate_;
}
public override Task OnWriteSucceededAsync(DomainGroup group, OperationKind operationKind, CancellationToken cancellationToken)
{
_hitCounter.TrackInvocation <DomainGroup>(ResourceDefinitionHitCounter.ExtensibilityPoint.OnWriteSucceededAsync);
return(FinishWriteAsync(group, operationKind, cancellationToken));
}
public async Task Update_group_with_users_writes_to_outbox()
{
// Arrange
DomainGroup existingGroup = _fakers.DomainGroup.Generate();
DomainUser existingUserWithoutGroup = _fakers.DomainUser.Generate();
DomainUser existingUserWithSameGroup1 = _fakers.DomainUser.Generate();
existingUserWithSameGroup1.Group = existingGroup;
DomainUser existingUserWithSameGroup2 = _fakers.DomainUser.Generate();
existingUserWithSameGroup2.Group = existingGroup;
DomainUser existingUserWithOtherGroup = _fakers.DomainUser.Generate();
existingUserWithOtherGroup.Group = _fakers.DomainGroup.Generate();
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
await dbContext.ClearTableAsync <OutgoingMessage>();
dbContext.Users.AddRange(existingUserWithoutGroup, existingUserWithSameGroup1, existingUserWithSameGroup2, existingUserWithOtherGroup);
await dbContext.SaveChangesAsync();
});
var requestBody = new
{
data = new
{
type = "domainGroups",
id = existingGroup.StringId,
relationships = new
{
users = new
{
data = new[]
{
new
{
type = "domainUsers",
id = existingUserWithoutGroup.StringId
},
new
{
type = "domainUsers",
id = existingUserWithSameGroup1.StringId
},
new
{
type = "domainUsers",
id = existingUserWithOtherGroup.StringId
}
}
}
}
}
};
string route = "/domainGroups/" + existingGroup.StringId;
// Act
(HttpResponseMessage httpResponse, string responseDocument) = await _testContext.ExecutePatchAsync <string>(route, requestBody);
// Assert
httpResponse.Should().HaveStatusCode(HttpStatusCode.NoContent);
responseDocument.Should().BeEmpty();
await _testContext.RunOnDatabaseAsync(async dbContext =>
{
List <OutgoingMessage> messages = await dbContext.OutboxMessages.OrderBy(message => message.Id).ToListAsync();
messages.Should().HaveCount(3);
var content1 = messages[0].GetContentAs <UserAddedToGroupContent>();
content1.UserId.Should().Be(existingUserWithoutGroup.Id);
content1.GroupId.Should().Be(existingGroup.Id);
var content2 = messages[1].GetContentAs <UserMovedToGroupContent>();
content2.UserId.Should().Be(existingUserWithOtherGroup.Id);
content2.BeforeGroupId.Should().Be(existingUserWithOtherGroup.Group.Id);
content2.AfterGroupId.Should().Be(existingGroup.Id);
var content3 = messages[2].GetContentAs <UserRemovedFromGroupContent>();
content3.UserId.Should().Be(existingUserWithSameGroup2.Id);
content3.GroupId.Should().Be(existingGroup.Id);
});
}
