private async Task <dynamic> DeleteRolesFromGroup(dynamic parameters)
{
try
{
this.RequiresClaims(AuthorizationWriteClaim);
var roleIds = this.Bind <List <RoleIdentifierApiRequest> >();
if (roleIds == null || roleIds.Count == 0)
{
return(CreateFailureResponse("At least 1 role ID is required.", HttpStatusCode.BadRequest));
}
var identityProvider = GetQueryParameter("identityProvider");
var tenantId = GetQueryParameter("tenantId");
GroupIdentifier groupIdentifier = CreateGroupIdentifier(SetIdentityProvider(identityProvider), tenantId, parameters.groupName.ToString());
var group = await _groupService.DeleteRolesFromGroup(groupIdentifier, roleIds.Select(r => r.RoleId));
return(CreateSuccessfulPostResponse(group.ToGroupRoleApiModel(), HttpStatusCode.OK));
}
catch (NotFoundException <Group> ex)
{
return(CreateFailureResponse(ex.Message, HttpStatusCode.NotFound));
}
catch (NotFoundException <Role> ex)
{
return(CreateFailureResponse(ex.Message, HttpStatusCode.NotFound));
}
}
private async Task <dynamic> RemoveChildGroups(dynamic parameters)
{
try
{
var identityProvider = GetQueryParameter("identityProvider");
var tenantId = GetQueryParameter("tenantId");
GroupIdentifier groupIdentifier = CreateGroupIdentifier(SetIdentityProvider(identityProvider), tenantId, parameters.groupName.ToString());
var group = await _groupService.GetGroup(groupIdentifier);
await CheckWriteAccess(group);
var childGroupIdentifierApiRequests = this.Bind <List <GroupIdentifierApiRequest> >();
var childGroupIdentifiers =
childGroupIdentifierApiRequests.Select(g => CreateGroupIdentifier(g.ToGroupIdentifierDomainModel()));
group = await _groupService.RemoveChildGroups(group, childGroupIdentifiers);
return(CreateSuccessfulPostResponse(group.Name, group.ToGroupRoleApiModel(), HttpStatusCode.OK));
}
catch (NotFoundException <Group> ex)
{
return(CreateFailureResponse(ex.Message, HttpStatusCode.NotFound));
}
}
public GroupModule(IGroupRepository groups)
{
For <StartGroup>()
.Validate(new StartGroupValidator())
.Handle(async(envelope, ct) =>
{
var groupId = new GroupIdentifier(envelope.Command.GroupId);
var group = await groups.TryLoadById(groupId, ct);
if (group == null)
{
group = Group.Start(
groupId,
new GroupName(envelope.Command.Name),
new GroupAdministratorIdentifier(envelope.Command.AdministratorId));
await groups.Save(group, envelope.CommandId, envelope.CorrelationId, envelope.Metadata, ct);
}
});
For <StopGroup>()
.Validate(new StopGroupValidator())
.Handle(async(envelope, ct) =>
{
var group = await groups.LoadById(new GroupIdentifier(envelope.Command.GroupId), ct);
group.Stop(new GroupAdministratorIdentifier(envelope.Command.AdministratorId));
await groups.Save(group, envelope.CommandId, envelope.CorrelationId, envelope.Metadata, ct);
});
}
public async Task <Group> AddRolesToGroup(IList <Role> rolesToAdd, GroupIdentifier groupIdentifier)
{
var group = await _groupStore.Get(groupIdentifier);
var grainSecurableItems = rolesToAdd.Select(r => new Tuple <string, string>(r.Grain, r.SecurableItem))
.Distinct();
var existingRoles = new List <Role>();
foreach (var tuple in grainSecurableItems)
{
existingRoles.AddRange(await _roleStore.GetRoles(tuple.Item1, tuple.Item2));
}
var exceptions = new List <Exception>();
foreach (var role in rolesToAdd)
{
if (existingRoles.All(r => r.Id != role.Id))
{
exceptions.Add(new NotFoundException <Role>($"The role: {role} with Id: {role.Id} could not be found to add to the group."));
}
if (group.Roles.Any(r => r.Id == role.Id))
{
exceptions.Add(
new AlreadyExistsException <Role>(
$"The role: {role} with Id: {role.Id} already exists for group {groupIdentifier.GroupName}."));
}
}
if (exceptions.Count > 0)
{
throw new AggregateException("There was an issue adding roles to the group. Please see the inner exception(s) for details.", exceptions);
}
return(await _groupStore.AddRolesToGroup(group, rolesToAdd));
}
private async Task <dynamic> AddRolesToGroup(dynamic parameters)
{
var apiRoles = this.Bind <List <RoleApiModel> >();
var errorResponse = await ValidateRoles(apiRoles);
if (errorResponse != null)
{
return(errorResponse);
}
var domainRoles = apiRoles.Select(r => r.ToRoleDomainModel()).ToList();
await CheckWriteAccess(domainRoles);
try
{
var identityProvider = GetQueryParameter("identityProvider");
var tenantId = GetQueryParameter("tenantId");
GroupIdentifier groupIdentifier = CreateGroupIdentifier(SetIdentityProvider(identityProvider), tenantId, parameters.groupName.ToString());
var group = await _groupService.AddRolesToGroup(domainRoles, groupIdentifier);
return(CreateSuccessfulPostResponse(group.Name, group.ToGroupRoleApiModel(), HttpStatusCode.OK));
}
catch (NotFoundException <Group> )
{
return(CreateFailureResponse(
$"Group with name {parameters.groupName} was not found",
HttpStatusCode.NotFound));
}
catch (AggregateException ex)
{
return(CreateFailureResponse(ex, HttpStatusCode.BadRequest));
}
}
private async Task <dynamic> UpdateGroup(dynamic parameters)
{
this.RequiresClaims(AuthorizationWriteClaim);
try
{
var groupPatchApiRequest = this.Bind <GroupPatchApiRequest>();
var identityProvider = GetQueryParameter("identityProvider");
var tenantId = GetQueryParameter("tenantId");
GroupIdentifier groupIdentifier = CreateGroupIdentifier(SetIdentityProvider(identityProvider), tenantId, parameters.groupName.ToString());
var existingGroup = await _groupService.GetGroup(groupIdentifier);
existingGroup.DisplayName = groupPatchApiRequest.DisplayName;
existingGroup.Description = groupPatchApiRequest.Description;
var group = await _groupService.UpdateGroup(existingGroup);
return(CreateSuccessfulPatchResponse(group.ToGroupRoleApiModel()));
}
catch (NotFoundException <Group> ex)
{
Logger.Error(ex, ex.Message, parameters.groupName);
return(CreateFailureResponse(ex.Message, HttpStatusCode.NotFound));
}
}
public async Task <Group> GetGroup(GroupIdentifier groupIdentifier, string clientId)
{
var group = await _groupStore.Get(groupIdentifier);
var clientRoles = (await _roleService.GetRoles(clientId)).ToList();
group.Roles = clientRoles.Intersect(group.Roles).ToList();
return(group);
}
public Task <bool> Exists(GroupIdentifier groupIdentifier)
{
var groups = AuthorizationDbContext.Groups
.Where(g => !g.IsDeleted &&
g.Name == groupIdentifier.GroupName).Select(e => e.ToModel()).ToList();
return(Task.FromResult(groups.Any(g => g.SourceEquals(GroupConstants.CustomSource) ||
(g.SourceEquals(GroupConstants.DirectorySource) &&
g.IdentityProviderEquals(groupIdentifier.IdentityProvider) &&
g.TenantIdEquals(groupIdentifier.TenantId)))));
}
public async Task <Group> AddUsersToGroup(GroupIdentifier groupIdentifier, IList <User> usersToAdd)
{
var group = await _groupStore.Get(groupIdentifier);
var customGroupChildUserWithSameName = (await _groupStore.Get(
usersToAdd.Select(u => new GroupIdentifier {
GroupName = u.IdentityProviderUserPrincipalName
}), true)).ToList();
if (customGroupChildUserWithSameName.Any())
{
throw new AlreadyExistsException <Group>(
$"The associated user or group name should not be the same as an existing custom group: {string.Join(", ", customGroupChildUserWithSameName.Select(g => g.Name))}");
}
// only add users to a custom group
if (!string.Equals(group.Source, GroupConstants.CustomSource, StringComparison.OrdinalIgnoreCase))
{
throw new BadRequestException <Group>("The group to which you are attempting to add a user is not specified as a 'Custom' group. Only 'Custom' groups allow associations with users.");
}
var exceptions = new List <Exception>();
foreach (var user in usersToAdd)
{
if (!group.Users.Any(u =>
string.Equals(u.SubjectId, user.SubjectId, StringComparison.OrdinalIgnoreCase) &&
string.Equals(u.IdentityProvider, user.IdentityProvider, StringComparison.OrdinalIgnoreCase)))
{
try
{
// check if the user exists in the DB - if not, create it
await _userStore.Get($"{user.SubjectId}:{user.IdentityProvider}");
}
catch (NotFoundException <User> )
{
await _userStore.Add(new User(user.SubjectId, user.IdentityProvider)
{ IdentityProviderUserPrincipalName = user.IdentityProviderUserPrincipalName });
}
}
else
{
exceptions.Add(new AlreadyExistsException <User>($"The user {user.IdentityProvider}:{user.SubjectId} has already been added to the group {groupIdentifier}."));
}
}
if (exceptions.Count > 0)
{
throw new AggregateException("There was an issue adding users to the group. Please see the inner exception(s) for details.", exceptions);
}
return(await _groupStore.AddUsersToGroup(group, usersToAdd));
}
public async Task <Group> GetGroup(GroupIdentifier groupIdentifier, string clientId)
{
var group = await _groupStore.Get(groupIdentifier);
if (!string.Equals(clientId, AccessControl.ClientId, StringComparison.OrdinalIgnoreCase))
{
var clientRoles = (await _roleService.GetRoles(clientId)).ToList();
group.Roles = clientRoles.Intersect(group.Roles).ToList();
}
return(group);
}
public async Task <Group> DeleteUserFromGroup(GroupIdentifier groupIdentifier, string subjectId, string identityProvider)
{
var group = await _groupStore.Get(groupIdentifier);
var user = await _userStore.Get($"{subjectId}:{identityProvider}");
var groupUser = group.Users.FirstOrDefault(u => u.Id == user.Id);
if (groupUser != null)
{
group.Users.Remove(groupUser);
}
return(await _groupStore.DeleteUserFromGroup(group, user));
}
private async Task <dynamic> AddUsersToGroup(dynamic parameters)
{
try
{
var identityProvider = GetQueryParameter("identityProvider");
var tenantId = GetQueryParameter("tenantId");
GroupIdentifier groupIdentifier = CreateGroupIdentifier(SetIdentityProvider(identityProvider), tenantId, parameters.groupName.ToString());
var group = await _groupService.GetGroup(groupIdentifier);
await CheckWriteAccess(group);
var userApiRequests = this.Bind <List <UserApiRequest> >();
var validationResult = await ValidateGroupUserRequests(userApiRequests);
if (validationResult != null)
{
return(validationResult);
}
group = await _groupService.AddUsersToGroup(groupIdentifier, userApiRequests.Select(u => u.ToUserDomainModel()).ToList());
return(CreateSuccessfulPostResponse(group.Name, group.ToGroupUserApiModel(), HttpStatusCode.OK));
}
catch (NotFoundException <Group> ex)
{
return(CreateFailureResponse(ex.Message, HttpStatusCode.NotFound));
}
catch (NotFoundException <User> ex)
{
return(CreateFailureResponse(ex.Message, HttpStatusCode.NotFound));
}
catch (BadRequestException <Group> ex)
{
return(CreateFailureResponse(ex.Message, HttpStatusCode.BadRequest));
}
catch (AggregateException ex)
{
return(CreateFailureResponse(ex, HttpStatusCode.BadRequest));
}
catch (AlreadyExistsException <Group> ex)
{
return(CreateFailureResponse(ex.Message, HttpStatusCode.Conflict));
}
}
private async Task <dynamic> GetChildGroups(dynamic parameters)
{
try
{
this.RequiresClaims(AuthorizationReadClaim);
var identityProvider = GetQueryParameter("identityProvider");
var tenantId = GetQueryParameter("tenantId");
GroupIdentifier groupIdentifier = CreateGroupIdentifier(SetIdentityProvider(identityProvider), tenantId, parameters.groupName.ToString());
var group = await _groupService.GetGroup(groupIdentifier, ClientId);
return(group.Children.Select(g => g.ToGroupRoleApiModel()));
}
catch (NotFoundException <Group> ex)
{
return(CreateFailureResponse(ex.Message, HttpStatusCode.NotFound));
}
}
private async Task <dynamic> DeleteGroup(dynamic parameters)
{
try
{
this.RequiresClaims(AuthorizationWriteClaim);
var identityProvider = GetQueryParameter("identityProvider");
var tenantId = GetQueryParameter("tenantId");
GroupIdentifier groupIdentifier = CreateGroupIdentifier(SetIdentityProvider(identityProvider), tenantId, parameters.groupName.ToString());
var group = await _groupService.GetGroup(groupIdentifier, ClientId);
await _groupService.DeleteGroup(group);
return(HttpStatusCode.NoContent);
}
catch (NotFoundException <Group> ex)
{
return(CreateFailureResponse(ex.Message, HttpStatusCode.NotFound));
}
}
private async Task <dynamic> SyncGroupIdentityRoles(dynamic param)
{
CheckInternalAccess();
var identityProvider = GetQueryParameter("identityProvider");
var tenantId = GetQueryParameter("tenantId");
GroupIdentifier groupIdentifier = CreateGroupIdentifier(SetIdentityProvider(identityProvider), tenantId, param.groupName.ToString());
try
{
var group = await _groupService.GetGroup(groupIdentifier);
foreach (var groupUser in group.Users)
{
if (groupUser.IdentityProvider.Equals(IdentityConstants.ActiveDirectory, StringComparison.OrdinalIgnoreCase))
{
try
{
var user = await _userService.GetUser(groupUser.SubjectId, groupUser.IdentityProvider);
await _syncService.RefreshDosAdminRolesAsync(user);
}
catch (NotFoundException <User> )
{
return(CreateFailureResponse(
$"The user: {groupUser.SubjectId} for identity provider: {groupUser.IdentityProvider} was not found.",
HttpStatusCode.NotFound));
}
}
}
return(HttpStatusCode.NoContent);
}
catch (NotFoundException <Group> )
{
return(CreateFailureResponse($"The group: {groupIdentifier} was not found",
HttpStatusCode.NotFound));
}
}
public Int32 Decode(Byte[] buf, Int32 ptr, out String s)
{
String r = "";
formatID = (FormatIdentifier)buf[ptr++];
groupID = (GroupIdentifier)buf[ptr++];
PLVLen = (buf[ptr++] << 8) | buf[ptr++];
s = "|" + formatID.ToString() +
"|" + groupID.ToString() +
"|len:" + PLVLen.ToString();
while (PLVLen > 0)
{
PLV tmpPLV = new PLV();
ptr = tmpPLV.Decode(buf, ptr, out r);
s += r;
PLVList.Add(tmpPLV);
PLVLen -= (tmpPLV.PL + 2);
}
return(ptr);
}
public override IDeepCopyable CopyTo(IDeepCopyable other)
{
var dest = other as DeviceRequest;
if (dest == null)
{
throw new ArgumentException("Can only copy to an object of the same type", "other");
}
base.CopyTo(dest);
if (Identifier != null)
{
dest.Identifier = new List <Hl7.Fhir.Model.Identifier>(Identifier.DeepCopy());
}
if (InstantiatesCanonicalElement != null)
{
dest.InstantiatesCanonicalElement = new List <Hl7.Fhir.Model.Canonical>(InstantiatesCanonicalElement.DeepCopy());
}
if (InstantiatesUriElement != null)
{
dest.InstantiatesUriElement = new List <Hl7.Fhir.Model.FhirUri>(InstantiatesUriElement.DeepCopy());
}
if (BasedOn != null)
{
dest.BasedOn = new List <Hl7.Fhir.Model.ResourceReference>(BasedOn.DeepCopy());
}
if (PriorRequest != null)
{
dest.PriorRequest = new List <Hl7.Fhir.Model.ResourceReference>(PriorRequest.DeepCopy());
}
if (GroupIdentifier != null)
{
dest.GroupIdentifier = (Hl7.Fhir.Model.Identifier)GroupIdentifier.DeepCopy();
}
if (StatusElement != null)
{
dest.StatusElement = (Code <Hl7.Fhir.Model.RequestStatus>)StatusElement.DeepCopy();
}
if (IntentElement != null)
{
dest.IntentElement = (Code <Hl7.Fhir.Model.RequestIntent>)IntentElement.DeepCopy();
}
if (PriorityElement != null)
{
dest.PriorityElement = (Code <Hl7.Fhir.Model.RequestPriority>)PriorityElement.DeepCopy();
}
if (Code != null)
{
dest.Code = (Hl7.Fhir.Model.CodeableReference)Code.DeepCopy();
}
if (Parameter != null)
{
dest.Parameter = new List <Hl7.Fhir.Model.DeviceRequest.ParameterComponent>(Parameter.DeepCopy());
}
if (Subject != null)
{
dest.Subject = (Hl7.Fhir.Model.ResourceReference)Subject.DeepCopy();
}
if (Encounter != null)
{
dest.Encounter = (Hl7.Fhir.Model.ResourceReference)Encounter.DeepCopy();
}
if (Occurrence != null)
{
dest.Occurrence = (Hl7.Fhir.Model.Element)Occurrence.DeepCopy();
}
if (AuthoredOnElement != null)
{
dest.AuthoredOnElement = (Hl7.Fhir.Model.FhirDateTime)AuthoredOnElement.DeepCopy();
}
if (Requester != null)
{
dest.Requester = (Hl7.Fhir.Model.ResourceReference)Requester.DeepCopy();
}
if (PerformerType != null)
{
dest.PerformerType = (Hl7.Fhir.Model.CodeableConcept)PerformerType.DeepCopy();
}
if (Performer != null)
{
dest.Performer = (Hl7.Fhir.Model.ResourceReference)Performer.DeepCopy();
}
if (Reason != null)
{
dest.Reason = new List <Hl7.Fhir.Model.CodeableReference>(Reason.DeepCopy());
}
if (Insurance != null)
{
dest.Insurance = new List <Hl7.Fhir.Model.ResourceReference>(Insurance.DeepCopy());
}
if (SupportingInfo != null)
{
dest.SupportingInfo = new List <Hl7.Fhir.Model.ResourceReference>(SupportingInfo.DeepCopy());
}
if (Note != null)
{
dest.Note = new List <Hl7.Fhir.Model.Annotation>(Note.DeepCopy());
}
if (RelevantHistory != null)
{
dest.RelevantHistory = new List <Hl7.Fhir.Model.ResourceReference>(RelevantHistory.DeepCopy());
}
return(dest);
}
public async Task <Group> GetGroup(GroupIdentifier groupIdentifier)
{
return(await _groupStore.Get(groupIdentifier));
}
public override IDeepCopyable CopyTo(IDeepCopyable other)
{
var dest = other as CommunicationRequest;
if (dest == null)
{
throw new ArgumentException("Can only copy to an object of the same type", "other");
}
base.CopyTo(dest);
if (Identifier != null)
{
dest.Identifier = new List <Hl7.Fhir.Model.Identifier>(Identifier.DeepCopy());
}
if (BasedOn != null)
{
dest.BasedOn = new List <Hl7.Fhir.Model.ResourceReference>(BasedOn.DeepCopy());
}
if (Replaces != null)
{
dest.Replaces = new List <Hl7.Fhir.Model.ResourceReference>(Replaces.DeepCopy());
}
if (GroupIdentifier != null)
{
dest.GroupIdentifier = (Hl7.Fhir.Model.Identifier)GroupIdentifier.DeepCopy();
}
if (StatusElement != null)
{
dest.StatusElement = (Code <Hl7.Fhir.Model.RequestStatus>)StatusElement.DeepCopy();
}
if (Category != null)
{
dest.Category = new List <Hl7.Fhir.Model.CodeableConcept>(Category.DeepCopy());
}
if (PriorityElement != null)
{
dest.PriorityElement = (Code <Hl7.Fhir.Model.RequestPriority>)PriorityElement.DeepCopy();
}
if (Medium != null)
{
dest.Medium = new List <Hl7.Fhir.Model.CodeableConcept>(Medium.DeepCopy());
}
if (Subject != null)
{
dest.Subject = (Hl7.Fhir.Model.ResourceReference)Subject.DeepCopy();
}
if (Recipient != null)
{
dest.Recipient = new List <Hl7.Fhir.Model.ResourceReference>(Recipient.DeepCopy());
}
if (Topic != null)
{
dest.Topic = new List <Hl7.Fhir.Model.ResourceReference>(Topic.DeepCopy());
}
if (Context != null)
{
dest.Context = (Hl7.Fhir.Model.ResourceReference)Context.DeepCopy();
}
if (Payload != null)
{
dest.Payload = new List <Hl7.Fhir.Model.CommunicationRequest.PayloadComponent>(Payload.DeepCopy());
}
if (Occurrence != null)
{
dest.Occurrence = (Hl7.Fhir.Model.Element)Occurrence.DeepCopy();
}
if (AuthoredOnElement != null)
{
dest.AuthoredOnElement = (Hl7.Fhir.Model.FhirDateTime)AuthoredOnElement.DeepCopy();
}
if (Sender != null)
{
dest.Sender = (Hl7.Fhir.Model.ResourceReference)Sender.DeepCopy();
}
if (Requester != null)
{
dest.Requester = (Hl7.Fhir.Model.CommunicationRequest.RequesterComponent)Requester.DeepCopy();
}
if (ReasonCode != null)
{
dest.ReasonCode = new List <Hl7.Fhir.Model.CodeableConcept>(ReasonCode.DeepCopy());
}
if (ReasonReference != null)
{
dest.ReasonReference = new List <Hl7.Fhir.Model.ResourceReference>(ReasonReference.DeepCopy());
}
if (Note != null)
{
dest.Note = new List <Hl7.Fhir.Model.Annotation>(Note.DeepCopy());
}
return(dest);
}
public async Task <Group> Get(GroupIdentifier groupIdentifier)
{
var groupEntities = AuthorizationDbContext.Groups
.Include(g => g.GroupRoles)
.ThenInclude(gr => gr.Role)
.ThenInclude(r => r.RolePermissions)
.ThenInclude(rp => rp.Permission)
.ThenInclude(p => p.SecurableItem)
.Include(g => g.GroupUsers)
.ThenInclude(gu => gu.User)
.ThenInclude(u => u.UserPermissions)
.ThenInclude(up => up.Permission)
.Include(g => g.GroupRoles)
.ThenInclude(gr => gr.Role)
.ThenInclude(r => r.SecurableItem)
.Include(g => g.ParentGroups)
.ThenInclude(cg => cg.Parent)
.Include(g => g.ChildGroups)
.ThenInclude(cg => cg.Child)
.ThenInclude(cg => cg.GroupRoles)
.ThenInclude(gr => gr.Role)
.AsNoTracking()
.Where(g => !g.IsDeleted && g.Name == groupIdentifier.GroupName)
.ToList();
EntityModels.Group groupEntity = null;
if (groupEntities.Count == 0)
{
throw new NotFoundException <Group>($"Could not find {typeof(Group).Name} entity with Identifier {groupIdentifier}");
}
if (groupEntities.Count == 1)
{
if (string.Equals(groupEntities[0].Source, GroupConstants.CustomSource, StringComparison.OrdinalIgnoreCase))
{
groupEntity = groupEntities[0];
}
else
{
groupEntity = groupEntities.FirstOrDefault(g =>
string.Equals(g.IdentityProvider, groupIdentifier.IdentityProvider, StringComparison.OrdinalIgnoreCase) &&
string.Equals(g.TenantId, groupIdentifier.TenantId, StringComparison.OrdinalIgnoreCase));
}
}
else
{
if (!string.IsNullOrWhiteSpace(groupIdentifier.TenantId))
{
groupEntity = groupEntities.FirstOrDefault(g =>
string.Equals(g.IdentityProvider, groupIdentifier.IdentityProvider, StringComparison.OrdinalIgnoreCase) &&
string.Equals(g.TenantId, groupIdentifier.TenantId, StringComparison.OrdinalIgnoreCase));
}
else
{
groupEntity = groupEntities.FirstOrDefault(g =>
string.Equals(g.Source, GroupConstants.CustomSource, StringComparison.OrdinalIgnoreCase) ||
(string.Equals(g.IdentityProvider, groupIdentifier.IdentityProvider, StringComparison.OrdinalIgnoreCase) &&
string.Equals(g.TenantId, groupIdentifier.TenantId, StringComparison.OrdinalIgnoreCase)));
}
}
if (groupEntity == null)
{
throw new NotFoundException <Group>($"Could not find {typeof(Group).Name} entity with Identifier {groupIdentifier}");
}
groupEntity.GroupRoles = groupEntity.GroupRoles.Where(gr => !gr.IsDeleted).ToList();
foreach (var groupRole in groupEntity.GroupRoles)
{
groupRole.Role.RolePermissions = groupRole.Role.RolePermissions.Where(rp => !rp.IsDeleted).ToList();
}
groupEntity.GroupUsers = groupEntity.GroupUsers.Where(gu => !gu.IsDeleted).ToList();
foreach (var groupUser in groupEntity.GroupUsers)
{
groupUser.User.UserPermissions = groupUser.User.UserPermissions.Where(up => !up.IsDeleted).ToList();
}
groupEntity.ChildGroups = groupEntity.ChildGroups.Where(cg => !cg.IsDeleted).ToList();
groupEntity.ParentGroups = groupEntity.ParentGroups.Where(pg => !pg.IsDeleted).ToList();
return(groupEntity.ToModel());
}
public async Task <Group> DeleteRolesFromGroup(GroupIdentifier groupIdentifier, IEnumerable <Guid> roleIdsToDelete)
{
var group = await _groupStore.Get(groupIdentifier);
return(await _groupStore.DeleteRolesFromGroup(group, roleIdsToDelete));
}
public override IDeepCopyable CopyTo(IDeepCopyable other)
{
var dest = other as ReferralRequest;
if (dest == null)
{
throw new ArgumentException("Can only copy to an object of the same type", "other");
}
base.CopyTo(dest);
if (Identifier != null)
{
dest.Identifier = new List <Hl7.Fhir.Model.Identifier>(Identifier.DeepCopy());
}
if (Definition != null)
{
dest.Definition = new List <Hl7.Fhir.Model.ResourceReference>(Definition.DeepCopy());
}
if (BasedOn != null)
{
dest.BasedOn = new List <Hl7.Fhir.Model.ResourceReference>(BasedOn.DeepCopy());
}
if (Replaces != null)
{
dest.Replaces = new List <Hl7.Fhir.Model.ResourceReference>(Replaces.DeepCopy());
}
if (GroupIdentifier != null)
{
dest.GroupIdentifier = (Hl7.Fhir.Model.Identifier)GroupIdentifier.DeepCopy();
}
if (StatusElement != null)
{
dest.StatusElement = (Code <Hl7.Fhir.Model.RequestStatus>)StatusElement.DeepCopy();
}
if (IntentElement != null)
{
dest.IntentElement = (Code <Hl7.Fhir.Model.RequestIntent>)IntentElement.DeepCopy();
}
if (Type != null)
{
dest.Type = (Hl7.Fhir.Model.CodeableConcept)Type.DeepCopy();
}
if (PriorityElement != null)
{
dest.PriorityElement = (Code <Hl7.Fhir.Model.RequestPriority>)PriorityElement.DeepCopy();
}
if (ServiceRequested != null)
{
dest.ServiceRequested = new List <Hl7.Fhir.Model.CodeableConcept>(ServiceRequested.DeepCopy());
}
if (Subject != null)
{
dest.Subject = (Hl7.Fhir.Model.ResourceReference)Subject.DeepCopy();
}
if (Context != null)
{
dest.Context = (Hl7.Fhir.Model.ResourceReference)Context.DeepCopy();
}
if (Occurrence != null)
{
dest.Occurrence = (Hl7.Fhir.Model.Element)Occurrence.DeepCopy();
}
if (AuthoredOnElement != null)
{
dest.AuthoredOnElement = (Hl7.Fhir.Model.FhirDateTime)AuthoredOnElement.DeepCopy();
}
if (Requester != null)
{
dest.Requester = (Hl7.Fhir.Model.ReferralRequest.RequesterComponent)Requester.DeepCopy();
}
if (Specialty != null)
{
dest.Specialty = (Hl7.Fhir.Model.CodeableConcept)Specialty.DeepCopy();
}
if (Recipient != null)
{
dest.Recipient = new List <Hl7.Fhir.Model.ResourceReference>(Recipient.DeepCopy());
}
if (ReasonCode != null)
{
dest.ReasonCode = new List <Hl7.Fhir.Model.CodeableConcept>(ReasonCode.DeepCopy());
}
if (ReasonReference != null)
{
dest.ReasonReference = new List <Hl7.Fhir.Model.ResourceReference>(ReasonReference.DeepCopy());
}
if (DescriptionElement != null)
{
dest.DescriptionElement = (Hl7.Fhir.Model.FhirString)DescriptionElement.DeepCopy();
}
if (SupportingInfo != null)
{
dest.SupportingInfo = new List <Hl7.Fhir.Model.ResourceReference>(SupportingInfo.DeepCopy());
}
if (Note != null)
{
dest.Note = new List <Hl7.Fhir.Model.Annotation>(Note.DeepCopy());
}
if (RelevantHistory != null)
{
dest.RelevantHistory = new List <Hl7.Fhir.Model.ResourceReference>(RelevantHistory.DeepCopy());
}
return(dest);
}
/// <summary>
/// Serialize to a JSON object
/// </summary>
public new void SerializeJson(Utf8JsonWriter writer, JsonSerializerOptions options, bool includeStartObject = true)
{
if (includeStartObject)
{
writer.WriteStartObject();
}
if (!string.IsNullOrEmpty(ResourceType))
{
writer.WriteString("resourceType", (string)ResourceType !);
}
((Fhir.R4.Models.DomainResource) this).SerializeJson(writer, options, false);
if ((Identifier != null) && (Identifier.Count != 0))
{
writer.WritePropertyName("identifier");
writer.WriteStartArray();
foreach (Identifier valIdentifier in Identifier)
{
valIdentifier.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if ((BasedOn != null) && (BasedOn.Count != 0))
{
writer.WritePropertyName("basedOn");
writer.WriteStartArray();
foreach (Reference valBasedOn in BasedOn)
{
valBasedOn.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if ((Replaces != null) && (Replaces.Count != 0))
{
writer.WritePropertyName("replaces");
writer.WriteStartArray();
foreach (Reference valReplaces in Replaces)
{
valReplaces.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if (GroupIdentifier != null)
{
writer.WritePropertyName("groupIdentifier");
GroupIdentifier.SerializeJson(writer, options);
}
if (!string.IsNullOrEmpty(Status))
{
writer.WriteString("status", (string)Status !);
}
if (_Status != null)
{
writer.WritePropertyName("_status");
_Status.SerializeJson(writer, options);
}
if (StatusReason != null)
{
writer.WritePropertyName("statusReason");
StatusReason.SerializeJson(writer, options);
}
if ((Category != null) && (Category.Count != 0))
{
writer.WritePropertyName("category");
writer.WriteStartArray();
foreach (CodeableConcept valCategory in Category)
{
valCategory.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if (!string.IsNullOrEmpty(Priority))
{
writer.WriteString("priority", (string)Priority !);
}
if (_Priority != null)
{
writer.WritePropertyName("_priority");
_Priority.SerializeJson(writer, options);
}
if (DoNotPerform != null)
{
writer.WriteBoolean("doNotPerform", (bool)DoNotPerform !);
}
if ((Medium != null) && (Medium.Count != 0))
{
writer.WritePropertyName("medium");
writer.WriteStartArray();
foreach (CodeableConcept valMedium in Medium)
{
valMedium.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if (Subject != null)
{
writer.WritePropertyName("subject");
Subject.SerializeJson(writer, options);
}
if ((About != null) && (About.Count != 0))
{
writer.WritePropertyName("about");
writer.WriteStartArray();
foreach (Reference valAbout in About)
{
valAbout.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if (Encounter != null)
{
writer.WritePropertyName("encounter");
Encounter.SerializeJson(writer, options);
}
if ((Payload != null) && (Payload.Count != 0))
{
writer.WritePropertyName("payload");
writer.WriteStartArray();
foreach (CommunicationRequestPayload valPayload in Payload)
{
valPayload.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if (!string.IsNullOrEmpty(OccurrenceDateTime))
{
writer.WriteString("occurrenceDateTime", (string)OccurrenceDateTime !);
}
if (_OccurrenceDateTime != null)
{
writer.WritePropertyName("_occurrenceDateTime");
_OccurrenceDateTime.SerializeJson(writer, options);
}
if (OccurrencePeriod != null)
{
writer.WritePropertyName("occurrencePeriod");
OccurrencePeriod.SerializeJson(writer, options);
}
if (!string.IsNullOrEmpty(AuthoredOn))
{
writer.WriteString("authoredOn", (string)AuthoredOn !);
}
if (_AuthoredOn != null)
{
writer.WritePropertyName("_authoredOn");
_AuthoredOn.SerializeJson(writer, options);
}
if (Requester != null)
{
writer.WritePropertyName("requester");
Requester.SerializeJson(writer, options);
}
if ((Recipient != null) && (Recipient.Count != 0))
{
writer.WritePropertyName("recipient");
writer.WriteStartArray();
foreach (Reference valRecipient in Recipient)
{
valRecipient.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if (Sender != null)
{
writer.WritePropertyName("sender");
Sender.SerializeJson(writer, options);
}
if ((ReasonCode != null) && (ReasonCode.Count != 0))
{
writer.WritePropertyName("reasonCode");
writer.WriteStartArray();
foreach (CodeableConcept valReasonCode in ReasonCode)
{
valReasonCode.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if ((ReasonReference != null) && (ReasonReference.Count != 0))
{
writer.WritePropertyName("reasonReference");
writer.WriteStartArray();
foreach (Reference valReasonReference in ReasonReference)
{
valReasonReference.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if ((Note != null) && (Note.Count != 0))
{
writer.WritePropertyName("note");
writer.WriteStartArray();
foreach (Annotation valNote in Note)
{
valNote.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if (includeStartObject)
{
writer.WriteEndObject();
}
}
/// <summary>
/// Serialize to a JSON object
/// </summary>
public new void SerializeJson(Utf8JsonWriter writer, JsonSerializerOptions options, bool includeStartObject = true)
{
if (includeStartObject)
{
writer.WriteStartObject();
}
if (!string.IsNullOrEmpty(ResourceType))
{
writer.WriteString("resourceType", (string)ResourceType !);
}
((fhirCsR4.Models.DomainResource) this).SerializeJson(writer, options, false);
if ((Identifier != null) && (Identifier.Count != 0))
{
writer.WritePropertyName("identifier");
writer.WriteStartArray();
foreach (Identifier valIdentifier in Identifier)
{
valIdentifier.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if ((InstantiatesCanonical != null) && (InstantiatesCanonical.Count != 0))
{
writer.WritePropertyName("instantiatesCanonical");
writer.WriteStartArray();
foreach (string valInstantiatesCanonical in InstantiatesCanonical)
{
writer.WriteStringValue(valInstantiatesCanonical);
}
writer.WriteEndArray();
}
if ((_InstantiatesCanonical != null) && (_InstantiatesCanonical.Count != 0))
{
writer.WritePropertyName("_instantiatesCanonical");
writer.WriteStartArray();
foreach (Element val_InstantiatesCanonical in _InstantiatesCanonical)
{
val_InstantiatesCanonical.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if ((InstantiatesUri != null) && (InstantiatesUri.Count != 0))
{
writer.WritePropertyName("instantiatesUri");
writer.WriteStartArray();
foreach (string valInstantiatesUri in InstantiatesUri)
{
writer.WriteStringValue(valInstantiatesUri);
}
writer.WriteEndArray();
}
if ((_InstantiatesUri != null) && (_InstantiatesUri.Count != 0))
{
writer.WritePropertyName("_instantiatesUri");
writer.WriteStartArray();
foreach (Element val_InstantiatesUri in _InstantiatesUri)
{
val_InstantiatesUri.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if ((BasedOn != null) && (BasedOn.Count != 0))
{
writer.WritePropertyName("basedOn");
writer.WriteStartArray();
foreach (Reference valBasedOn in BasedOn)
{
valBasedOn.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if ((PriorRequest != null) && (PriorRequest.Count != 0))
{
writer.WritePropertyName("priorRequest");
writer.WriteStartArray();
foreach (Reference valPriorRequest in PriorRequest)
{
valPriorRequest.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if (GroupIdentifier != null)
{
writer.WritePropertyName("groupIdentifier");
GroupIdentifier.SerializeJson(writer, options);
}
if (!string.IsNullOrEmpty(Status))
{
writer.WriteString("status", (string)Status !);
}
if (_Status != null)
{
writer.WritePropertyName("_status");
_Status.SerializeJson(writer, options);
}
if (!string.IsNullOrEmpty(Intent))
{
writer.WriteString("intent", (string)Intent !);
}
if (_Intent != null)
{
writer.WritePropertyName("_intent");
_Intent.SerializeJson(writer, options);
}
if (!string.IsNullOrEmpty(Priority))
{
writer.WriteString("priority", (string)Priority !);
}
if (_Priority != null)
{
writer.WritePropertyName("_priority");
_Priority.SerializeJson(writer, options);
}
if (CodeReference != null)
{
writer.WritePropertyName("codeReference");
CodeReference.SerializeJson(writer, options);
}
if (CodeCodeableConcept != null)
{
writer.WritePropertyName("codeCodeableConcept");
CodeCodeableConcept.SerializeJson(writer, options);
}
if ((Parameter != null) && (Parameter.Count != 0))
{
writer.WritePropertyName("parameter");
writer.WriteStartArray();
foreach (DeviceRequestParameter valParameter in Parameter)
{
valParameter.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if (Subject != null)
{
writer.WritePropertyName("subject");
Subject.SerializeJson(writer, options);
}
if (Encounter != null)
{
writer.WritePropertyName("encounter");
Encounter.SerializeJson(writer, options);
}
if (!string.IsNullOrEmpty(OccurrenceDateTime))
{
writer.WriteString("occurrenceDateTime", (string)OccurrenceDateTime !);
}
if (_OccurrenceDateTime != null)
{
writer.WritePropertyName("_occurrenceDateTime");
_OccurrenceDateTime.SerializeJson(writer, options);
}
if (OccurrencePeriod != null)
{
writer.WritePropertyName("occurrencePeriod");
OccurrencePeriod.SerializeJson(writer, options);
}
if (OccurrenceTiming != null)
{
writer.WritePropertyName("occurrenceTiming");
OccurrenceTiming.SerializeJson(writer, options);
}
if (!string.IsNullOrEmpty(AuthoredOn))
{
writer.WriteString("authoredOn", (string)AuthoredOn !);
}
if (_AuthoredOn != null)
{
writer.WritePropertyName("_authoredOn");
_AuthoredOn.SerializeJson(writer, options);
}
if (Requester != null)
{
writer.WritePropertyName("requester");
Requester.SerializeJson(writer, options);
}
if (PerformerType != null)
{
writer.WritePropertyName("performerType");
PerformerType.SerializeJson(writer, options);
}
if (Performer != null)
{
writer.WritePropertyName("performer");
Performer.SerializeJson(writer, options);
}
if ((ReasonCode != null) && (ReasonCode.Count != 0))
{
writer.WritePropertyName("reasonCode");
writer.WriteStartArray();
foreach (CodeableConcept valReasonCode in ReasonCode)
{
valReasonCode.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if ((ReasonReference != null) && (ReasonReference.Count != 0))
{
writer.WritePropertyName("reasonReference");
writer.WriteStartArray();
foreach (Reference valReasonReference in ReasonReference)
{
valReasonReference.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if ((Insurance != null) && (Insurance.Count != 0))
{
writer.WritePropertyName("insurance");
writer.WriteStartArray();
foreach (Reference valInsurance in Insurance)
{
valInsurance.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if ((SupportingInfo != null) && (SupportingInfo.Count != 0))
{
writer.WritePropertyName("supportingInfo");
writer.WriteStartArray();
foreach (Reference valSupportingInfo in SupportingInfo)
{
valSupportingInfo.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if ((Note != null) && (Note.Count != 0))
{
writer.WritePropertyName("note");
writer.WriteStartArray();
foreach (Annotation valNote in Note)
{
valNote.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if ((RelevantHistory != null) && (RelevantHistory.Count != 0))
{
writer.WritePropertyName("relevantHistory");
writer.WriteStartArray();
foreach (Reference valRelevantHistory in RelevantHistory)
{
valRelevantHistory.SerializeJson(writer, options, true);
}
writer.WriteEndArray();
}
if (includeStartObject)
{
writer.WriteEndObject();
}
}
/// <summary>
/// Returns the number of items in the list adjusted for the group items.
/// This method will also create a bit array of types <seealso cref="_positionTypes"/>
/// </summary>
/// <returns></returns>
private int CalculateListItems()
{
using( new EnforceLazyLayout( this ) )
{
if( _rowInformation == null )
{
PositionedRowIdentifier[] trackableItems = new PositionedRowIdentifier[3];
trackableItems[0] = _focusedItem;
if( _lastCalculatedRowInformation != null )
{
if( FocusedItem != null )
{
if( LineStart < _lastCalculatedRowInformation.Count )
{
trackableItems[1] = new PositionedRowIdentifier( _lastCalculatedRowInformation[LineStart], LineStart );
}
RowIdentifier nextValidRow = locateNearestRowThatsStillValid( FocusedItem, ItemList, _lastCalculatedRowInformation );
if( nextValidRow != null )
{
trackableItems[2] = new PositionedRowIdentifier( nextValidRow, 0 );
}
}
}
Column[] groupColumns = ListControl.Columns.GroupedItems.ToArray();
object lastItem = null;
_lastCalculatedRowInformation = _rowInformation = new List<RowIdentifier>( ItemList.Count );
int hideRowGroupIndex = -1;
List<PositionedRowIdentifier> newSelection = new List<PositionedRowIdentifier>();
GroupIdentifier[] activeGroups = new GroupIdentifier[groupColumns.Length];
object[] listItems = ItemList.ToArray();
for( int i = 0; i < ItemList.Count; i++ )
{
object item = ItemList[i];
int groupIndex = ItemInNewGroup( groupColumns, item, lastItem );
if( groupIndex != -1 )
{
for( int iGroup = groupIndex; iGroup < groupColumns.Length; iGroup++ )
{
GroupIdentifier gi = new GroupIdentifier( i, listItems, Columns, iGroup, item );
int hideGroupIndex = hideRowGroupIndex;
if( hideRowGroupIndex == -1 || iGroup <= hideRowGroupIndex )
{
if( GetGroupState( gi ) == GroupState.Collapsed )
{
hideGroupIndex = iGroup;
if( groupIndex <= hideRowGroupIndex )
{
hideRowGroupIndex = -1;
}
}
else
{
hideRowGroupIndex = hideGroupIndex = -1;
}
}
if( hideRowGroupIndex == -1 )
{
HandleSyncing( gi, _rowInformation.Count, trackableItems, newSelection );
_rowInformation.Add( gi );
}
if( activeGroups[iGroup] != null )
{
activeGroups[iGroup].End = i;
}
activeGroups[iGroup] = gi;
hideRowGroupIndex = hideGroupIndex;
}
}
if( hideRowGroupIndex == -1 )
{
RowIdentifier ri = new NonGroupRow( item );
HandleSyncing( ri, _rowInformation.Count, trackableItems, newSelection );
_rowInformation.Add( ri );
}
lastItem = item;
}
foreach( GroupIdentifier gi in activeGroups )
{
if( gi != null )
{
gi.End = ItemList.Count;
}
}
if( VerticalScrollbarVisible )
{
int newMax = _rowInformation.Count == 0 ? 0 : _rowInformation.Count - 1;
if( VScrollbar.Value >= newMax )
{
VScrollbar.Value = newMax;
}
VScrollbar.Maximum = newMax;
}
if( trackableItems[1] != null )
{
LineStart = trackableItems[1].Position;
}
if( _focusedItem != null && !IsSelectedItemValid( _focusedItem ) )
{
if( trackableItems[2] != null && IsSelectedItemValid( trackableItems[2] ) )
{
PositionedRowIdentifier oldFocusedItem = _focusedItem;
if( _focusedItem != trackableItems[2] )
{
_focusedItem = trackableItems[2];
ListControl.FireFocusChanged( oldFocusedItem == null ? null : oldFocusedItem.RowIdentifier,
_focusedItem == null ? null : _focusedItem.RowIdentifier );
}
newSelection.Add( _focusedItem );
}
else
{
int newPosition;
if( _focusedItem.Position >= _rowInformation.Count )
{
newPosition = _rowInformation.Count - 1;
}
else
{
newPosition = _focusedItem.Position;
}
if( newPosition >= 0 )
{
PositionedRowIdentifier si = new PositionedRowIdentifier( _rowInformation[newPosition], newPosition );
FocusedItem = si;
newSelection.Add( _focusedItem );
}
else
{
FocusedItem = null;
}
}
}
RowIdentifier[] rowItemsToSelect = new RowIdentifier[newSelection.Count];
int j = 0;
foreach( PositionedRowIdentifier pri in newSelection )
{
rowItemsToSelect[j++] = pri.RowIdentifier;
}
SelectedItems.ClearAndAdd( rowItemsToSelect );
if( SelectedItems.Count == 0 && FocusedItem == null && VScrollbar != null && VScrollbar.Visible )
{
VScrollbar.Value = 0;
}
}
_mapOfPositions = null;
}
ListControl.OnCalculatedGroupRows( EventArgs.Empty );
return _rowInformation.Count;
}
protected GroupIdentifier CreateGroupIdentifier(GroupIdentifier groupIdentifier)
{
groupIdentifier.IdentityProvider = SetIdentityProvider(groupIdentifier.IdentityProvider);
return(groupIdentifier);
}
