public void Get_All_Paged_Users_For_Group_With_Filter()
{
UserGroup userGroup = UserGroupBuilder.CreateUserGroup();
UserService.Save(userGroup);
IUser[] users = UserBuilder.CreateMulipleUsers(10).ToArray();
for (int i = 0; i < 10;)
{
users[i].AddGroup(userGroup.ToReadOnlyGroup());
i = i + 2;
}
for (int i = 0; i < 10;)
{
users[i].Name = "blah" + users[i].Name;
i = i + 3;
}
UserService.Save(users);
long totalRecs;
IEnumerable <IUser> found = UserService.GetAll(0, 2, out totalRecs, "username", Direction.Ascending, userGroups: new[] { userGroup.Alias }, filter: "blah");
Assert.AreEqual(2, found.Count());
Assert.AreEqual(2, totalRecs);
Assert.AreEqual("test0", found.First().Username);
Assert.AreEqual("test6", found.Last().Username);
}
private UserGroup BuildImageGroup()
{
List <User> users = new List <User>();
User imageLeader = new User("Kimi", "Imaging Team");
myWorkflowGraph.AddNode(imageLeader);
Edge newEdge = new As();
myWorkflowGraph.AddEdge(imageLeader, leader, newEdge);
users.Add(new User("Lacy", "Imaging Team"));
users.Add(new User("Michael", "Imaging Team"));
foreach (var curItem in users)
{
myWorkflowGraph.AddNode(curItem);
newEdge = new As();
myWorkflowGraph.AddEdge(curItem, employee, newEdge);
}
UserGroup group = new UserGroup("Imaging", GroupTypeEnum.Executive.ToString(), "Imaging Team");
myWorkflowGraph.AddNode(group);
UserGroupBuilder.BuildUserGroup(myWorkflowGraph, group, imageLeader, users);
return(group);
}
private UserGroup BuildTestGroup()
{
List <User> users = new List <User>();
User testLeader = new User("Nina", "Test Center");
myWorkflowGraph.AddNode(testLeader);
Edge newEdge = new As();
myWorkflowGraph.AddEdge(testLeader, leader, newEdge);
users.Add(new User("Oakley", "Test Center"));
users.Add(new User("Pol", "Test Center"));
users.Add(new User("Queen", "Test Center"));
foreach (var curItem in users)
{
myWorkflowGraph.AddNode(curItem);
newEdge = new As();
myWorkflowGraph.AddEdge(curItem, employee, newEdge);
}
UserGroup group = new UserGroup("Test Center", GroupTypeEnum.Executive.ToString(), "Test Center");
myWorkflowGraph.AddNode(group);
UserGroupBuilder.BuildUserGroup(myWorkflowGraph, group, testLeader, users);
return(group);
}
private UserGroup BuildUIGroup()
{
List <User> users = new List <User>();
User uiLeader = new User("Emilia", "UI Team");
myWorkflowGraph.AddNode(uiLeader);
Edge newEdge = new As();
myWorkflowGraph.AddEdge(uiLeader, leader, newEdge);
users.Add(new User("Florence", "UI Team"));
users.Add(new User("Grant", "UI Team"));
foreach (var curItem in users)
{
myWorkflowGraph.AddNode(curItem);
newEdge = new As();
myWorkflowGraph.AddEdge(curItem, employee, newEdge);
}
UserGroup group = new UserGroup("UI", GroupTypeEnum.Executive.ToString(), "UI Team");
myWorkflowGraph.AddNode(group);
UserGroupBuilder.BuildUserGroup(myWorkflowGraph, group, uiLeader, users);
return(group);
}
private UserGroup BuildExamGroup()
{
List <User> users = new List <User>();
User examLeader = new User("Haden", "Exam Team");
myWorkflowGraph.AddNode(examLeader);
Edge newEdge = new As();
myWorkflowGraph.AddEdge(examLeader, leader, newEdge);
users.Add(new User("Isaac", "Exam Team"));
users.Add(new User("Jackson", "Exam Team"));
foreach (var curItem in users)
{
myWorkflowGraph.AddNode(curItem);
newEdge = new As();
myWorkflowGraph.AddEdge(curItem, employee, newEdge);
}
UserGroup group = new UserGroup("Exam", GroupTypeEnum.Executive.ToString(), "Exam Team");
myWorkflowGraph.AddNode(group);
UserGroupBuilder.BuildUserGroup(myWorkflowGraph, group, examLeader, users);
return(group);
}
public void Can_Perform_Get_On_UserGroupRepository()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
UserGroupRepository repository = CreateRepository(provider);
UserGroup userGroup = UserGroupBuilder.CreateUserGroup();
repository.Save(userGroup);
scope.Complete();
// Act
IUserGroup resolved = repository.Get((int)userGroup.Id);
// Assert
Assert.That(resolved.Id, Is.EqualTo(userGroup.Id));
//// Assert.That(resolved.CreateDate, Is.GreaterThan(DateTime.MinValue));
//// Assert.That(resolved.UpdateDate, Is.GreaterThan(DateTime.MinValue));
Assert.That(resolved.Name, Is.EqualTo(userGroup.Name));
Assert.That(resolved.Alias, Is.EqualTo(userGroup.Alias));
Assert.That(resolved.Permissions, Is.EqualTo(userGroup.Permissions));
}
}
public void Can_Perform_Delete_On_UserGroupRepository()
{
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
UserGroupRepository repository = CreateRepository(provider);
UserGroup userGroup = UserGroupBuilder.CreateUserGroup();
// Act
repository.Save(userGroup);
int id = userGroup.Id;
var repository2 = new UserGroupRepository((IScopeAccessor)provider, global::Umbraco.Cms.Core.Cache.AppCaches.Disabled, LoggerFactory.CreateLogger <UserGroupRepository>(), LoggerFactory, ShortStringHelper);
repository2.Delete(userGroup);
scope.Complete();
IUserGroup resolved = repository2.Get((int)id);
// Assert
Assert.That(resolved, Is.Null);
}
}
private UserGroup BuildCSEGroup()
{
List <User> users = new List <User>();
User cseLeader = new User("Alice", "CSE Department");
myWorkflowGraph.AddNode(cseLeader);
Edge newEdge = new As();
myWorkflowGraph.AddEdge(cseLeader, leader, newEdge);
users.Add(new User("Bob", "CSE Department"));
users.Add(new User("Clare", "CSE Department"));
foreach (var curItem in users)
{
myWorkflowGraph.AddNode(curItem);
newEdge = new As();
myWorkflowGraph.AddEdge(curItem, employee, newEdge);
}
UserGroup cseGroup = new UserGroup("CSE", GroupTypeEnum.Executive.ToString(), "CSE Team");
myWorkflowGraph.AddNode(cseGroup);
UserGroupBuilder.BuildUserGroup(myWorkflowGraph, cseGroup, cseLeader, users);
return(cseGroup);
}
public void Get_Groups_Assigned_To_Section()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
UserGroupRepository repository = CreateRepository(provider);
UserGroup user1 = UserGroupBuilder.CreateUserGroup(suffix: "1", allowedSections: new[] { "test1" });
UserGroup user2 = UserGroupBuilder.CreateUserGroup(suffix: "2", allowedSections: new[] { "test2" });
UserGroup user3 = UserGroupBuilder.CreateUserGroup(suffix: "3", allowedSections: new[] { "test1" });
repository.Save(user1);
repository.Save(user2);
repository.Save(user3);
scope.Complete();
// Act
IEnumerable <IUserGroup> groups = repository.GetGroupsAssignedToSection("test1");
// Assert
Assert.AreEqual(2, groups.Count());
string[] names = groups.Select(x => x.Name).ToArray();
Assert.IsTrue(names.Contains("Test Group1"));
Assert.IsFalse(names.Contains("Test Group2"));
Assert.IsTrue(names.Contains("Test Group3"));
}
}
public void updates_are_batched()
{
using (var session = SessionFactory.OpenStatelessSession())
using (var transaction = session.BeginTransaction())
{
session.SetBatchSize(2);
var builder = new UserGroupBuilder();
var group1 = builder.Build();
var group2 = builder.Build();
var group3 = builder.Build();
var group4 = builder.Build();
session.Insert(group1);
session.Insert(group2);
session.Insert(group3);
session.Insert(group4);
group1.Name = group1.Name + "2";
group2.Name = group2.Name + "2";
group3.Name = group3.Name + "2";
group4.Name = group4.Name + "2";
session.Update(group1);
session.Update(group2);
Logger.Info("the first batch of 2 update statements has been sent to the database");
session.Update(group3);
session.Update(group4);
Logger.Info("the second batch of 2 update statements has been sent to the database, before the session is flushed");
transaction.Commit();
}
}
public void TestEmployeesCanRead()
{
var employeeRole = new Roles(this.Session).Employee;
var employees = new UserGroupBuilder(this.Session)
.WithName("Employees")
.Build();
var john = new PersonBuilder(this.Session).WithFirstName("John").WithLastName("Doe").Build();
employees.AddMember(john);
var invoice = new InvoiceBuilder(this.Session).Build();
var singleton = Singleton.Instance(this.Session);
var defaultSecurityToken = singleton.DefaultSecurityToken;
var accessControl = new AccessControlBuilder(this.Session)
.WithRole(employeeRole)
.WithObject(defaultSecurityToken)
.WithSubjectGroup(employees)
.Build();
var acl = new AccessControlList(invoice, john);
acl.CanRead(Invoice.Meta.Total).ShouldBeTrue();
}
public void Can_Perform_Update_On_UserGroupRepository()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
UserGroupRepository repository = CreateRepository(provider);
UserGroup userGroup = UserGroupBuilder.CreateUserGroup();
repository.Save(userGroup);
// Act
IUserGroup resolved = repository.Get((int)userGroup.Id);
resolved.Name = "New Name";
resolved.Permissions = new[] { "Z", "Y", "X" };
repository.Save(resolved);
scope.Complete();
IUserGroup updatedItem = repository.Get((int)userGroup.Id);
// Assert
Assert.That(updatedItem.Id, Is.EqualTo(resolved.Id));
Assert.That(updatedItem.Name, Is.EqualTo(resolved.Name));
Assert.That(updatedItem.Permissions, Is.EqualTo(resolved.Permissions));
}
}
private UserGroup CreateTestUserGroup(string alias = "testGroup", string name = "Test Group")
{
string[] permissions = "ABCDEFGHIJ1234567".ToCharArray().Select(x => x.ToString()).ToArray();
UserGroup userGroup = UserGroupBuilder.CreateUserGroup(alias, name, permissions: permissions);
UserService.Save(userGroup);
return(userGroup);
}
private IUserGroup[] CreateAndCommitMultipleUserGroups(IUserGroupRepository repository)
{
UserGroup userGroup1 = UserGroupBuilder.CreateUserGroup(suffix: "1");
UserGroup userGroup2 = UserGroupBuilder.CreateUserGroup(suffix: "2");
UserGroup userGroup3 = UserGroupBuilder.CreateUserGroup(suffix: "3");
repository.Save(userGroup1);
repository.Save(userGroup2);
repository.Save(userGroup3);
return(new IUserGroup[] { userGroup1, userGroup2, userGroup3 });
}
private UserGroup BuildInterfaceGroup()
{
List <User> users = new List <User>();
User interLeader = new User("Dave", "Interface");
myWorkflowGraph.AddNode(interLeader);
Edge newEdge = new As();
myWorkflowGraph.AddEdge(interLeader, leader, newEdge);
UserGroup interGroup = new UserGroup("Interface", GroupTypeEnum.Executive.ToString(), "Interface Team");
myWorkflowGraph.AddNode(interGroup);
UserGroupBuilder.BuildUserGroup(myWorkflowGraph, interGroup, interLeader, users);
return(interGroup);
}
public void manipulating_cached_collection_updates_both_database_and_cache()
{
var newGroup = new UserGroupBuilder().Build();
using (var session = CreateSession())
using (var transaction = session.BeginTransaction())
{
var user = session.Get <User>(_user1.Id);
user.AddUserGroup(newGroup);
Logger.Info("this causes 2 insert statements");
transaction.Commit();
}
using (var session = CreateSession())
using (var transaction = session.BeginTransaction())
{
var user = session.Get <User>(_user1.Id);
Logger.Info("this doesn't cause a select statement");
Assert.IsTrue(user.UserGroups.Contains(newGroup));
transaction.Commit();
}
using (var session = CreateSession())
using (var transaction = session.BeginTransaction())
{
Logger.Info("this session should cause 2 delete statements, and one select statement for the usergroup's user collection, which isn't cached");
var user = session.Get <User>(_user1.Id);
var group = session.Get <UserGroup>(newGroup.Id);
user.RemoveUserGroup(group);
session.Delete(group);
transaction.Commit();
}
using (var session = CreateSession())
using (var transaction = session.BeginTransaction())
{
var user = session.Get <User>(_user1.Id);
Logger.Info("this causes a select because the object is no longer in the cache");
Assert.IsNull(session.Get <UserGroup>(newGroup.Id));
Logger.Info("this doesn't cause a select statement");
Assert.AreEqual(0, user.UserGroups.Count(g => g.Id == newGroup.Id));
transaction.Commit();
}
}
public void Can_Perform_Add_On_UserGroupRepository()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
UserGroupRepository repository = CreateRepository(provider);
UserGroup userGroup = UserGroupBuilder.CreateUserGroup();
// Act
repository.Save(userGroup);
scope.Complete();
// Assert
Assert.That(userGroup.HasIdentity, Is.True);
}
}
private void BuildUserGroup()
{
List <UserGroup> userGroups =
new List <UserGroup> {
BuildCSEGroup(), BuildInterfaceGroup(), BuildRDGroup(), BuildTestGroup()
};
User gmLeader = new User("Sanders", "Siemens Healthineer");
myWorkflowGraph.AddNode(gmLeader);
Edge newEdge = new As();
myWorkflowGraph.AddEdge(gmLeader, leader, newEdge);
UserGroup group = new UserGroup("Healthineer", GroupTypeEnum.Executive.ToString(), "Siemens Healthineer");
myWorkflowGraph.AddNode(group);
UserGroupBuilder.BuildUserGroup(myWorkflowGraph, group, gmLeader, new List <User>(), userGroups);
}
private UserGroup BuildRDGroup()
{
List <UserGroup> userGroups = new List <UserGroup> {
BuildUIGroup(), BuildExamGroup(), BuildImageGroup()
};
User rdLeader = new User("Rafael", "RD Department");
myWorkflowGraph.AddNode(rdLeader);
Edge newEdge = new As();
myWorkflowGraph.AddEdge(rdLeader, leader, newEdge);
UserGroup group = new UserGroup("RD", GroupTypeEnum.Executive.ToString(), "RD Department");
myWorkflowGraph.AddNode(group);
UserGroupBuilder.BuildUserGroup(myWorkflowGraph, group, rdLeader, new List <User>(), userGroups);
return(group);
}
public void GivenNoAccessControlWhenCreatingAnAccessControlWithoutARoleThenAccessControlIsInvalid()
{
var userGroup = new UserGroupBuilder(this.Session).WithName("UserGroup").Build();
var securityToken = new SecurityTokenBuilder(this.Session).Build();
securityToken.AddAccessControl(new AccessControlBuilder(this.Session)
.WithSubjectGroup(userGroup)
.Build());
var validation = this.Session.Derive(false);
Assert.True(validation.HasErrors);
Assert.Equal(1, validation.Errors.Length);
var derivationError = validation.Errors[0];
Assert.Equal(1, derivationError.Relations.Length);
Assert.Equal(typeof(DerivationErrorRequired), derivationError.GetType());
Assert.Equal(M.AccessControl.Role, derivationError.Relations[0].RoleType);
}
public void GivenAnotherUserGroupAndAnAccessControlledObjectWhenGettingTheAccessListThenUserHasAccessToThePermissionsInTheRole()
{
var readOrganisationName = this.FindPermission(M.Organisation.Name, Operations.Read);
var databaseRole = new RoleBuilder(this.Session).WithName("Role").WithPermission(readOrganisationName).Build();
var person = new PersonBuilder(this.Session).WithFirstName("John").WithLastName("Doe").Build();
new UserGroupBuilder(this.Session).WithName("Group").WithMember(person).Build();
var anotherUserGroup = new UserGroupBuilder(this.Session).WithName("AnotherGroup").Build();
this.Session.Derive(true);
this.Session.Commit();
new AccessControlBuilder(this.Session).WithSubjectGroup(anotherUserGroup).WithRole(databaseRole).Build();
this.Session.Commit();
var sessions = new ISession[] { this.Session };
foreach (var session in sessions)
{
session.Commit();
var organisation = new OrganisationBuilder(session).WithName("Organisation").Build();
var token = new SecurityTokenBuilder(session).Build();
organisation.AddSecurityToken(token);
var role = (Role)session.Instantiate(new Roles(this.Session).FindBy(M.Role.Name, "Role"));
var accessControl = (AccessControl)session.Instantiate(role.AccessControlsWhereRole.First);
token.AddAccessControl(accessControl);
Assert.IsFalse(this.Session.Derive().HasErrors);
var accessList = new AccessControlList(organisation, person);
Assert.IsFalse(accessList.CanRead(M.Organisation.Name));
session.Rollback();
}
}
public void Can_Verify_Fresh_Entity_Is_Not_Dirty()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
UserGroupRepository repository = CreateRepository(provider);
UserGroup userGroup = UserGroupBuilder.CreateUserGroup();
repository.Save(userGroup);
scope.Complete();
// Act
IUserGroup resolved = repository.Get((int)userGroup.Id);
bool dirty = ((UserGroup)resolved).IsDirty();
// Assert
Assert.That(dirty, Is.False);
}
}
public void GivenNoAccessControlWhenCreatingAAccessControlWithoutARoleThenAccessControlIsInvalid()
{
var userGroup = new UserGroupBuilder(this.DatabaseSession).WithName("UserGroup").Build();
var securityToken = new SecurityTokenBuilder(this.DatabaseSession).Build();
new AccessControlBuilder(this.DatabaseSession)
.WithSubjectGroup(userGroup)
.WithObject(securityToken)
.Build();
var derivationLog = this.DatabaseSession.Derive();
Assert.IsTrue(derivationLog.HasErrors);
Assert.AreEqual(1, derivationLog.Errors.Length);
var derivationError = derivationLog.Errors[0];
Assert.AreEqual(1, derivationError.Relations.Length);
Assert.AreEqual(typeof(DerivationErrorRequired), derivationError.GetType());
Assert.AreEqual((RoleType)AccessControls.Meta.Role, derivationError.Relations[0].RoleType);
}
public void Can_Perform_Multiple_Adds_On_UserGroupRepository()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
UserGroupRepository repository = CreateRepository(provider);
UserGroup userGroup1 = UserGroupBuilder.CreateUserGroup(suffix: "1");
UserGroup userGroup2 = UserGroupBuilder.CreateUserGroup(suffix: "2");
// Act
repository.Save(userGroup1);
repository.Save(userGroup2);
scope.Complete();
// Assert
Assert.That(userGroup1.HasIdentity, Is.True);
Assert.That(userGroup2.HasIdentity, Is.True);
}
}
public void Is_Built_Correctly()
{
// Arrange
const int testId = 10;
const string testAlias = "test";
const string testName = "Test";
const int testUserCount = 11;
const string testIcon = "icon";
const string testPermissions = "abc";
const int testStartContentId = 3;
const int testStartMediaId = 8;
var builder = new UserGroupBuilder();
// Act
var userGroup = builder
.WithId(testId)
.WithAlias(testAlias)
.WithName(testName)
.WithUserCount(testUserCount)
.WithIcon(testIcon)
.WithPermissions(testPermissions)
.WithStartContentId(testStartContentId)
.WithStartMediaId(testStartMediaId)
.Build();
// Assert
Assert.AreEqual(testId, userGroup.Id);
Assert.AreEqual(testAlias, userGroup.Alias);
Assert.AreEqual(testName, userGroup.Name);
Assert.AreEqual(testUserCount, userGroup.UserCount);
Assert.AreEqual(testIcon, userGroup.Icon);
Assert.AreEqual(testPermissions.Length, userGroup.Permissions.Count());
Assert.AreEqual(testStartContentId, userGroup.StartContentId);
Assert.AreEqual(testStartMediaId, userGroup.StartMediaId);
}
public void GivenAnotherUserGroupAndAnAccessControlledObjectWhenGettingTheAccessListThenUserHasAccessToThePermissionsInTheRole()
{
var readOrganisationName = this.FindPermission(Organisations.Meta.Name, Operation.Read);
var databaseRole = new RoleBuilder(this.Session).WithName("Role").WithPermission(readOrganisationName).Build();
var person = new PersonBuilder(this.Session).WithFirstName("John").WithLastName("Doe").Build();
new UserGroupBuilder(this.Session).WithName("Group").WithMember(person).Build();
var anotherUserGroup = new UserGroupBuilder(this.Session).WithName("AnotherGroup").Build();
this.Session.Derive(true);
this.Session.Commit();
new AccessControlBuilder(this.Session).WithSubjectGroup(anotherUserGroup).WithRole(databaseRole).Build();
this.Session.Commit();
var sessions = new ISession[] { this.Session };
foreach (var session in sessions)
{
session.Commit();
var organisation = new OrganisationBuilder(session).WithName("Organisation").Build();
var token = new SecurityTokenBuilder(session).Build();
organisation.AddSecurityToken(token);
var role = (Role)session.Instantiate(new Roles(this.Session).FindBy(Roles.Meta.Name, "Role"));
var accessControl = (AccessControl)session.Instantiate(role.AccessControlsWhereRole.First);
accessControl.AddObject(token);
Assert.IsFalse(this.Session.Derive().HasErrors);
var accessList = new AccessControlList(organisation, person);
Assert.IsFalse(accessList.CanRead(Organisations.Meta.Name));
session.Rollback();
}
}
public void GivenAUserGroupWhenSettingTheTokenInTheWorkspaceAndGettingTheAccessListThenUserHasAccessToThePermissionsInTheRole()
{
var readOrganisationName = this.FindPermission(Organisations.Meta.Name, Operation.Read);
var databaseRole = new RoleBuilder(this.DatabaseSession).WithName("Role").WithPermission(readOrganisationName).Build();
var person = new PersonBuilder(this.DatabaseSession).WithFirstName("John").WithLastName("Doe").Build();
var userGroup = new UserGroupBuilder(this.DatabaseSession).WithName("Group").WithMember(person).Build();
this.DatabaseSession.Derive(true);
this.DatabaseSession.Commit();
new AccessControlBuilder(this.DatabaseSession).WithSubjectGroup(userGroup).WithRole(databaseRole).Build();
this.DatabaseSession.Commit();
var workspaceSession = this.CreateWorkspaceSession();
var organisation = new OrganisationBuilder(workspaceSession).WithName("Organisation").Build();
var token = new SecurityTokenBuilder(workspaceSession).Build();
organisation.AddSecurityToken(token);
var role = (Role)workspaceSession.Instantiate(new Roles(this.DatabaseSession).FindBy(Roles.Meta.Name, "Role"));
var accessControl = (AccessControl)workspaceSession.Instantiate(role.AccessControlsWhereRole.First);
accessControl.AddObject(token);
Assert.IsFalse(this.DatabaseSession.Derive().HasErrors);
var accessList = new AccessControlList(organisation, person);
Assert.IsTrue(accessList.CanRead(Organisations.Meta.Name));
}
public void SetUp() => _builder = new UserGroupBuilder();
public void AppsOnDeriveEmployeeUserGroups(IDerivation derivation)
{
var employeeUserGroupsByName = new Dictionary<string, UserGroup>();
foreach (UserGroup userGroup in this.UserGroupsWhereParty)
{
employeeUserGroupsByName.Add(userGroup.Name, userGroup);
}
foreach (Role role in this.EmployeeRoles)
{
var userGroupName = string.Format("{0} for {1})", role.Name, this.Name);
if (!employeeUserGroupsByName.ContainsKey(userGroupName))
{
var userGroup = new UserGroupBuilder(this.Strategy.Session)
.WithName(userGroupName)
.WithParty(this)
.WithParent(role.UserGroupWhereRole)
.Build();
new AccessControlBuilder(this.Strategy.Session).WithRole(role).WithSubjectGroup(userGroup).WithObject(this.OwnerSecurityToken).Build();
}
}
}
