public object Deserialize(JsonValue json, JsonMapper mapper)
{
GroupMembership group = null;
if ( json != null && !json.IsNull )
{
group = new GroupMembership();
group.ID = json.ContainsName("id" ) ? json.GetValue<string>("id" ) : String.Empty;
group.Name = json.ContainsName("name" ) ? json.GetValue<string>("name" ) : String.Empty;
group.Version = json.ContainsName("version" ) ? json.GetValue<int >("version" ) : 0;
group.BookmarkOrder = json.ContainsName("bookmark_order") ? json.GetValue<int >("bookmark_order") : 0;
group.Administrator = json.ContainsName("administrator" ) ? json.GetValue<bool >("administrator" ) : false;
group.Unread = json.ContainsName("unread" ) ? json.GetValue<int >("unread" ) : 0;
}
return group;
}
public async Task <IEnumerable <ImportRecord> > GetImportDataAsync(Guid id)
{
using (var cn = new SqlConnection(dbOptions.ConnectionString))
{
var changed = await cn.QueryAsync <ImportRecord>(
Sql.GetImportData,
new
{
id,
user = user.UUID,
groups = GroupMembership.From(user),
admin = user.IsAdmin
},
commandType : CommandType.StoredProcedure,
commandTimeout : dbOptions.DefaultTimeout
);
return(changed);
}
}
async Task <DatasetCompilerContext> ByDatasetIdQueryUId(DatasetExecutionRequest request)
{
log.LogInformation("Getting DatasetQueryCompilerContext by DatasetId and QueryUId");
var datasetid = request.DatasetRef.Id.Value;
var queryuid = request.QueryRef.UniversalId.ToString();
using (var cn = new SqlConnection(opts.ConnectionString))
{
await cn.OpenAsync();
var grid = await cn.QueryMultipleAsync(
ContextQuery.byDatasetIdQueryUId,
new { datasetid, queryuid, user = user.UUID, groups = GroupMembership.From(user), admin = user.IsAdmin },
commandType : CommandType.StoredProcedure,
commandTimeout : opts.DefaultTimeout
);
return(ReadRequestGrid(grid, request));
}
}
async Task <PanelDatasetCompilerContext> ByQueryUIdConceptId(ConceptDatasetExecutionRequest request, ConceptRef conceptRef)
{
log.LogInformation("Getting ConceptDatasetCompilerContext by QueryUId and ConceptId");
var queryuid = request.QueryRef.UniversalId.ToString();
var conceptid = conceptRef.Id.Value;
using (var cn = new SqlConnection(opts.ConnectionString))
{
await cn.OpenAsync();
var grid = await cn.QueryMultipleAsync(
contextByQueryUIdConceptId,
new { queryuid, conceptid, user = user.UUID, groups = GroupMembership.From(user), admin = user.IsAdmin },
commandType : CommandType.StoredProcedure,
commandTimeout : opts.DefaultTimeout
);
return(ReadContextGrid(request, grid));
}
}
public async Task HandleNewMessage(GroupMembershipMessage body, IMessageSession messageSession)
{
var sessionId = messageSession.SessionId;
_receivedMessages.AddOrUpdate(sessionId, new List <GroupMembershipMessage> {
body
}, (key, messages) => {
messages.Add(body); return(messages);
});
//Console.WriteLine($"Session {sessionId} got {body.Body.SourceMembers.Count} users.");
if (body.Body.IsLastMessage)
{
if (!_receivedMessages.TryRemove(sessionId, out var allReceivedMessages))
{
// someone else got to it first. shouldn't happen, but it's good to be prepared.
return;
}
// remove this message-renewing logic once we can verify that the new, longer message leases work.
var source = new CancellationTokenSource();
var cancellationToken = source.Token;
var renew = RenewMessages(messageSession, allReceivedMessages, cancellationToken);
var received = GroupMembership.Merge(allReceivedMessages.Select(x => x.Body));
try
{
await _graphUpdater.CalculateDifference(received);
// If it succeeded, complete all the messages and close the session
await messageSession.CompleteAsync(allReceivedMessages.Select(x => x.LockToken));
await messageSession.CloseAsync();
}
finally
{
source.Cancel();
}
}
}
public async Task <DataImporter.IImportDataResult> ImportDataAsync(Guid id, IEnumerable <ImportRecord> records)
{
using (var cn = new SqlConnection(dbOptions.ConnectionString))
{
var changed = await cn.QueryFirstOrDefaultAsync <Result>(
Sql.ImportData,
new
{
id,
data = ImportDataTable.From(id, records),
user = user.UUID,
groups = GroupMembership.From(user),
admin = user.IsAdmin
},
commandType : CommandType.StoredProcedure,
commandTimeout : dbOptions.DefaultTimeout
);
return(changed);
}
}
public async Task <ImportMetadata> GetImportMetadataAsync(Guid id)
{
using (var cn = new SqlConnection(dbOptions.ConnectionString))
{
var grid = await cn.QueryMultipleAsync(
Sql.GetMetadataById,
new
{
id,
user = user.UUID,
groups = GroupMembership.From(user),
admin = user.IsAdmin
},
commandType : CommandType.StoredProcedure,
commandTimeout : dbOptions.DefaultTimeout
);
var metadata = DbReader.Read(grid);
return(metadata);
}
}
/// <summary>
/// Adds membership to a group if the membership is not already known.
/// </summary>
/// <param name="groupID">The group ID.</param>
/// <param name="fixTimeUtc">The fix time.</param>
/// <remarks>
/// <note>
/// This implementation assumes that entities will be members of only a handfull
/// of groups (something like 10 or less),
/// </note>
/// </remarks>
private void AddGroup(string groupID, DateTime fixTimeUtc)
{
Assertion.Test(groupID != null);
if (groups == null)
{
groups =
new GroupMembership[] {
new GroupMembership()
{
GroupID = groupID,
FixTimeUtc = fixTimeUtc
}
};
return;
}
if (IsMemberOf(groupID))
{
return;
}
var newGroups = new GroupMembership[groups.Length + 1];
// I'm putting the new group at the front of the list since
// under many circumstances fixes for older groups will tend not
// to be seen anymore and will eventually be flushed from the
// cache. This will improve IsMemberOf() performance for many
// real world cases.
newGroups[0] = new GroupMembership()
{
GroupID = groupID,
FixTimeUtc = fixTimeUtc
};
Array.Copy(groups, 0, newGroups, 1, groups.Length);
groups = newGroups;
}
public async Task <IEnumerable <Concept> > GetAsync(HashSet <string> universalIds)
{
using (var cn = new SqlConnection(opts.ConnectionString))
{
await cn.OpenAsync();
var grid = await cn.QueryMultipleAsync(
queryManyUniversal,
new
{
uids = ResourceUniversalIdTable.From(universalIds),
user = user.UUID,
groups = GroupMembership.From(user),
admin = user.IsAdmin
},
commandTimeout : opts.DefaultTimeout,
commandType : CommandType.StoredProcedure
);
return(HydratedConceptReader.Read(grid));
}
}
public async Task <IEnumerable <Concept> > GetChildrenAsync(Guid parentId)
{
using (var cn = new SqlConnection(opts.ConnectionString))
{
await cn.OpenAsync();
var grid = await cn.QueryMultipleAsync(
queryChildren,
new
{
parentId,
user = user.UUID,
groups = GroupMembership.From(user),
admin = user.IsAdmin
},
commandTimeout : opts.DefaultTimeout,
commandType : CommandType.StoredProcedure
);
return(HydratedConceptReader.Read(grid));
}
}
public void SetupData()
{
_rundId = Guid.NewGuid();
_targetGroupId = Guid.NewGuid();
_partitionKey = "2021-1-1";
_rowKey = Guid.NewGuid().ToString();
_sources = MockGroupMembershipHelper.CreateMockGroups().Take(1).ToArray();
_users = MakeUsers(10, 0);
_membership = new GroupMembership
{
Destination = new AzureADGroup {
ObjectId = _targetGroupId
},
IsLastMessage = true,
RunId = _rundId,
SourceMembers = _users,
SyncJobPartitionKey = _partitionKey,
SyncJobRowKey = _rowKey
};
_job = new SyncJob
{
PartitionKey = _partitionKey,
RowKey = _rowKey,
Status = SyncStatus.Idle.ToString(),
LastRunTime = DateTime.FromFileTimeUtc(0),
Enabled = true,
Query = _sources[0].ObjectId.ToString(),
TargetOfficeGroupId = _targetGroupId,
ThresholdPercentageForAdditions = 50,
ThresholdPercentageForRemovals = 50,
Period = 6,
Requestor = "[email protected],[email protected]",
RunId = _rundId,
StartDate = DateTime.UtcNow.Date.AddDays(-10),
Type = "SecurityGroup"
};
}
public async Task <PreflightConcepts> GetConceptsByUniversalIdsAsync(HashSet <string> conceptUids)
{
using (var cn = new SqlConnection(opts.ConnectionString))
{
await cn.OpenAsync();
var grid = await cn.QueryMultipleAsync(
ConceptPreflightSql.manyUIds,
new {
uids = ResourceUniversalIdTable.From(conceptUids),
user = user.UUID,
groups = GroupMembership.From(user),
admin = user.IsAdmin,
sessionType = user.SessionType
},
commandTimeout : opts.DefaultTimeout,
commandType : CommandType.StoredProcedure
);
return(PreflightReader.ReadConcepts(grid));
}
}
public async Task SendMembership(GroupMembership groupMembership, string sentFrom = "")
{
if (groupMembership.SyncJobPartitionKey == null)
{
throw new ArgumentNullException("SyncJobPartitionKey must be set.");
}
if (groupMembership.SyncJobRowKey == null)
{
throw new ArgumentNullException("SyncJobRowKey must be set.");
}
foreach (var message in groupMembership.Split().Select(x => new Message
{
Body = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(x)),
SessionId = groupMembership.Destination.ObjectId.ToString(),
ContentType = "application/json",
Label = sentFrom
}))
{
await _queueClient.SendAsync(message);
}
}
private void SetSessionTracker(MessageInformation messageDetails, GroupMembership groupMembership)
{
if (_sessionsTracker.ContainsKey(messageDetails.SessionId))
{
var sessionTracker = _sessionsTracker[messageDetails.SessionId];
var lockTokens = sessionTracker.LockTokens;
lockTokens.Add(messageDetails.LockToken);
_sessionsTracker.TryUpdate(messageDetails.SessionId,
new SessionTracker
{
LastAccessTime = DateTime.UtcNow,
LatestMessageId = messageDetails.MessageId,
RunId = groupMembership.RunId,
LockTokens = lockTokens,
JobPartitionKey = groupMembership.SyncJobPartitionKey,
JobRowKey = groupMembership.SyncJobRowKey,
ReceivedLastMessage = groupMembership.IsLastMessage
},
sessionTracker
);
}
else
{
_sessionsTracker.TryAdd(messageDetails.SessionId,
new SessionTracker
{
LastAccessTime = DateTime.UtcNow,
LatestMessageId = messageDetails.MessageId,
RunId = groupMembership.RunId,
LockTokens = new List <string> {
messageDetails.LockToken
},
JobPartitionKey = groupMembership.SyncJobPartitionKey,
JobRowKey = groupMembership.SyncJobRowKey,
ReceivedLastMessage = groupMembership.IsLastMessage
});
}
}
private static void addMedlem(string p_navn, string p_email)
{
Contact newContact = new Contact();
newContact.Title = p_navn;
EMail primaryEmail = new EMail(p_email);
primaryEmail.Primary = true;
primaryEmail.Rel = ContactsRelationships.IsHome;
newContact.Emails.Add(primaryEmail);
GroupMembership gm = new GroupMembership();
gm.HRef = HRefMedlem;
newContact.GroupMembership.Add(gm);
Uri feedUri = new Uri(ContactsQuery.CreateContactsUri("default"));
Contact createdContact = cr.Insert(feedUri, newContact);
}
private void ValidateAddress(string address, string attributeName)
{
if (this.config.MembersAsNonReference)
{
return;
}
if (attributeName.StartsWith("external"))
{
if (GroupMembership.IsAddressInternal(address))
{
throw new UnexpectedDataException($"The value {address} cannot be exported as {attributeName} as it is a known internal domain. It should be exported as {attributeName.Replace("external", string.Empty)}");
}
}
else
{
if (GroupMembership.IsAddressExternal(address))
{
throw new UnexpectedDataException($"The value {address} cannot be exported as {attributeName} as it is not a known internal domain. It should be exported as external{attributeName}");
}
}
}
public async Task <Concept> GetAsync(Guid id)
{
using (var cn = new SqlConnection(opts.ConnectionString))
{
await cn.OpenAsync();
var grid = await cn.QueryMultipleAsync(
querySingle,
new
{
id,
user = user.UUID,
groups = GroupMembership.From(user),
admin = user.IsAdmin
},
commandTimeout : opts.DefaultTimeout,
commandType : CommandType.StoredProcedure
);
return(HydratedConceptReader.Read(grid).FirstOrDefault());
}
}
public async Task UpdateMembershipCommandHandler_ShouldUpdateMembership()
{
// Arrange
UpdateMembershipCommand request = new()
{
GroupMembershipId = 1,
IsAdmin = true
};
GroupMembership expectedMembership = new() { GroupMembershipId = 1, UserId = 1, IsAdmin = false };
_unitOfWorkMock
.Setup(m => m.GroupMemberships.GetByIdAsync(request.GroupMembershipId))
.ReturnsAsync(expectedMembership);
GroupMembership passedMembership = null;
_unitOfWorkMock
.Setup(m => m.GroupMemberships.Update(It.IsAny <GroupMembership>()))
.Callback <GroupMembership>(gm => passedMembership = gm);
_unitOfWorkMock
.Setup(m => m.CommitAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(1);
UpdateMembershipCommand.Handler handler = new(_unitOfWorkMock.Object);
// Act
await handler.Handle(request);
// Assert
Assert.NotNull(passedMembership);
Assert.Equal(request.IsAdmin, passedMembership.IsAdmin);
_unitOfWorkMock.Verify(m => m.GroupMemberships.Update(It.IsAny <GroupMembership>()), Times.AtLeastOnce);
_unitOfWorkMock.Verify(m => m.CommitAsync(It.IsAny <CancellationToken>()), Times.AtLeastOnce);
}
}
public async Task <IEnumerable <Concept> > GetAsync(HashSet <Guid> ids)
{
log.LogInformation("Getting Concepts. Ids:{Ids}", ids);
using (var cn = new SqlConnection(opts.ConnectionString))
{
await cn.OpenAsync();
var grid = await cn.QueryMultipleAsync(
queryMany,
new
{
ids = ResourceIdTable.From(ids),
user = user.UUID,
groups = GroupMembership.From(user),
admin = user.IsAdmin
},
commandTimeout : opts.DefaultTimeout,
commandType : CommandType.StoredProcedure
);
return(HydratedConceptReader.Read(grid));
}
}
public async Task Delete_ShouldDeleteMembershipFromContext()
{
// Arrange
GroupMembership membership = new();
await _context.GroupMemberships.AddAsync(membership);
await _context.SaveChangesAsync();
GroupMembershipRepository repository = new(_context);
membership = await _context.GroupMemberships.FindAsync(membership.GroupMembershipId);
// Act
repository.Delete(membership);
await _context.SaveChangesAsync();
// Assert
GroupMembership deletedMembership = await _context.GroupMemberships.FindAsync(membership.GroupMembershipId);
Assert.Null(deletedMembership);
}
public async Task Update_ShouldUpdateMembership()
{
// Arrange
GroupMembership databaseMembership = new() { GroupMembershipId = 1, UserId = 1 };
GroupMembership membershipToUpdate = new() { GroupMembershipId = 2, UserId = 2 };
await _context.GroupMemberships.AddAsync(databaseMembership);
await _context.SaveChangesAsync();
GroupMembershipRepository repository = new(_context);
// Act
repository.Update(membershipToUpdate);
// Assert
GroupMembership updatedMembership = await _context.GroupMemberships.FindAsync(membershipToUpdate.GroupMembershipId);
Assert.NotNull(updatedMembership);
Assert.Equal(membershipToUpdate.UserId, updatedMembership.UserId);
}
[Fact]
public async Task <IEnumerable <Concept> > GetWithParentsBySearchTermAsync(Guid?rootId, string[] terms)
{
using (var cn = new SqlConnection(opts.ConnectionString))
{
await cn.OpenAsync();
var grid = await cn.QueryMultipleAsync(
queryParentsBySearchTerm,
new
{
terms = SearchTermTable.From(terms),
rootId,
user = user.UUID,
groups = GroupMembership.From(user),
admin = user.IsAdmin
},
commandTimeout : opts.DefaultTimeout,
commandType : CommandType.StoredProcedure
);
return(HydratedConceptReader.Read(grid));
}
}
protected override async Task OnInitializedAsync()
{
try
{
GroupService = ScopedServices.GetRequiredService <IGroupService>();
GroupMembership = await GroupService.GetGroupMembershipAsync(EmployeeId, GroupId);
if (GroupMembership == null)
{
throw new Exception("Group membership not found");
}
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
//await ModalDialogService.CancelAsync();
}
}
public async Task CanCreateMembershipQueryHandler_ShouldReturnTrue_WhenUserIsAnAdministrator()
{
// Arrange
CanCreateMembershipQuery request = new CanCreateMembershipQuery {
GroupId = 1
};
GroupMembership expectedMembership = new GroupMembership {
GroupMembershipId = 1, UserId = 1, IsAdmin = true
};
_unitOfWorkMock
.Setup(m => m.GroupMemberships.GetByCombination(request.GroupId, 1, It.IsAny <CancellationToken>()))
.ReturnsAsync(expectedMembership);
CanCreateMembershipQuery.Handler handler = new CanCreateMembershipQuery.Handler(_unitOfWorkMock.Object, _userProviderMock.Object);
// Act
bool canCreate = await handler.Handle(request);
// Assert
Assert.True(canCreate);
}
/// <summary>
/// Search the concept tree for records matching the provided terms, and stopping at the <paramref name="rootId"/>
/// </summary>
/// <returns>Collection of concepts that match the search terms</returns>
/// <param name="rootId">Root parent identifier.</param>
/// <param name="terms">Search terms.</param>
public async Task <IEnumerable <ConceptHint> > SearchAsync(Guid?rootId, params string[] terms)
{
using (var cn = new SqlConnection(opts.ConnectionString))
{
await cn.OpenAsync();
var records = await cn.QueryAsync <ConceptHintRecord>(
Sql.Query,
new
{
terms = SearchTermTable.From(terms),
rootId,
user = user.UUID,
groups = GroupMembership.From(user),
admin = user.IsAdmin
},
commandTimeout : opts.DefaultTimeout,
commandType : CommandType.StoredProcedure
);
return(records.Select(r => r.ConceptHint()));
}
}
public async Task <Query> GetQuery(QueryUrn uid)
{
logger.LogInformation("Getting query UId:{UId}", uid);
using (var cn = new SqlConnection(dbOpts.ConnectionString))
{
await cn.OpenAsync();
try
{
var r = await cn.QueryFirstOrDefaultAsync <QueryRecord>(
queryQueryByUId,
new { uid = uid.ToString(), user = user.UUID, groups = GroupMembership.From(user) },
commandType : CommandType.StoredProcedure,
commandTimeout : dbOpts.DefaultTimeout
);
return(new Query
{
Id = r.Id,
UniversalId = QueryUrn.From(r.UniversalId),
Name = r.Name,
Category = r.Category,
Owner = r.Owner,
Created = r.Created,
Updated = r.Updated,
Count = r.Count,
Definition = r.Definition
});
}
catch (SqlException se)
{
logger.LogError("Could not get query. UniversalId:{UniversalId} Code:{Code} Error:{Error}", uid, se.ErrorCode, se.Message);
se.MapThrow();
throw;
}
}
}
public async Task Add_ShouldAddGroupMembershipsToTheDbContext()
{
// Arrange
GroupMembership membership = new GroupMembership();
Mock <DbSet <GroupMembership> > membershipDbSetMock = Enumerable
.Empty <GroupMembership>()
.AsQueryable()
.BuildMockDbSet();
Mock <IChatContext> contextMock = new Mock <IChatContext>();
contextMock
.Setup(m => m.GroupMemberships)
.Returns(membershipDbSetMock.Object);
GroupMembershipRepository repository = new GroupMembershipRepository(contextMock.Object);
// Act
await repository.Add(membership);
// Assert
contextMock.Verify(m => m.GroupMemberships.AddAsync(membership, It.IsAny <CancellationToken>()));
}
private void GetMemberChangesFromCSEntryChange(CSEntryChange csentry, out GroupMembership adds, out GroupMembership deletes, out GroupMembership reportedAdds, out GroupMembership reportedDeletes, out IList <Member> roleChanges, bool replacing)
{
adds = new GroupMembership();
deletes = new GroupMembership();
reportedAdds = new GroupMembership();
reportedDeletes = new GroupMembership();
roleChanges = new List <Member>();
GroupMembership existingGroupMembership;
bool hasExistingMembership = false;
if (replacing | this.ExistingMembershipRequiredForUpdate(csentry))
{
existingGroupMembership = this.config.GroupsService.MemberFactory.GetMembership(csentry.DN);
hasExistingMembership = true;
}
else
{
existingGroupMembership = new GroupMembership();
}
this.GetMemberChangesFromCSEntryChange(csentry, adds.Members, deletes.Members, existingGroupMembership.Members, this.config.GroupMemberAttributeName, replacing);
this.GetMemberChangesFromCSEntryChange(csentry, adds.ExternalMembers, deletes.ExternalMembers, existingGroupMembership.ExternalMembers, "externalMember", replacing);
this.GetMemberChangesFromCSEntryChange(csentry, adds.Managers, deletes.Managers, existingGroupMembership.Managers, this.config.GroupManagerAttributeName, replacing);
this.GetMemberChangesFromCSEntryChange(csentry, adds.ExternalManagers, deletes.ExternalManagers, existingGroupMembership.ExternalManagers, "externalManager", replacing);
this.GetMemberChangesFromCSEntryChange(csentry, adds.Owners, deletes.Owners, existingGroupMembership.Owners, this.config.GroupOwnerAttributeName, replacing);
this.GetMemberChangesFromCSEntryChange(csentry, adds.ExternalOwners, deletes.ExternalOwners, existingGroupMembership.ExternalOwners, "externalOwner", replacing);
if (hasExistingMembership && this.config.InheritGroupRoles)
{
this.ApplyRoleChanges(adds, deletes, out reportedAdds, out reportedDeletes, out roleChanges);
}
reportedAdds.MergeMembership(adds);
reportedDeletes.MergeMembership(deletes);
}
public void TestOwnerIsManagerAndMember()
{
Group e = null;
User user = null;
try
{
e = UnitTestControl.CreateGroup();
Thread.Sleep(1000);
user = UserTests.CreateUser();
UnitTestControl.TestParameters.GroupsService.MemberFactory.AddMember(e.Email, new Member()
{
Email = user.PrimaryEmail, Role = "OWNER"
});
Thread.Sleep(5000);
GroupMembership members = UnitTestControl.TestParameters.GroupsService.MemberFactory.GetMembership(e.Email);
ApiInterfaceGroupMembership i = new ApiInterfaceGroupMembership(UnitTestControl.TestParameters);
IList <AttributeChange> changes = i.GetChanges(e.Email, ObjectModificationType.Add, UnitTestControl.MmsSchema.Types["group"], members);
AttributeChange owner = changes.First(t => t.Name == "owner");
AttributeChange manager = changes.First(t => t.Name == "manager");
AttributeChange member = changes.First(t => t.Name == "member");
Assert.AreEqual(owner.ValueChanges.First().Value, user.PrimaryEmail);
Assert.AreEqual(manager.ValueChanges.First().Value, user.PrimaryEmail);
Assert.AreEqual(member.ValueChanges.First().Value, user.PrimaryEmail);
}
finally
{
UnitTestControl.Cleanup(e, user);
}
}
public async Task <ConceptTree> GetTreetopAsync()
{
using (var cn = new SqlConnection(opts.ConnectionString))
{
await cn.OpenAsync();
var grid = await cn.QueryMultipleAsync(
queryRootsPanelFilters,
new { user = user.UUID, groups = GroupMembership.From(user), admin = user.IsAdmin },
commandTimeout : opts.DefaultTimeout,
commandType : CommandType.StoredProcedure
);
var roots = HydratedConceptReader.Read(grid);
var filterRecords = grid.Read <PanelFilterRecord>();
var filters = filterRecords.Select(f => f.ToPanelFilter());
return(new ConceptTree
{
PanelFilters = filters,
Concepts = roots
});
}
}
public static void postSet_Group(GroupMembership obj, PropertyPostSetterEventArgs<Group> e)
{
obj.Recalculate("Description");
}
bool IGroupMembershipsInterface.TryGetValue(UGUI requestingAgent, UGI group, UGUI principal, out GroupMembership gmem)
{
gmem = default(GroupMembership);
GroupsBrokerEntry groupsService;
return(TryGetGroupsService(group, out groupsService) && groupsService.Memberships.TryGetValue(requestingAgent, group, principal, out gmem));
}
public GroupMembershipViewModel(IViewModelDependencies appCtx, IZetboxContext dataCtx, ViewModel parent, GroupMembership obj)
: base(appCtx, dataCtx, parent, obj)
{
this.GroupMembership = obj;
}
