/// <summary> /// Delete an existing relationship between actors /// </summary> /// <param name="relationship"></param> public void Delete(ActorRelationship relationship) { //todo Check if user is only group admin _relationshipDbController.Delete(relationship); //todo Remove ActorRole for group if user has permissions _logger.LogInformation($"{relationship?.RequestorId} -> {relationship?.AcceptorId}"); }
/// <summary> /// Immediately creates a new relationship between 2 actors /// </summary> /// <param name="newRelation">Relationship to create</param> /// <param name="context">Optional DbContext to perform opperations on. If ommitted a DbContext will be created.</param> public void CreateRelationship(ActorRelationship newRelation, SUGARContext context = null) { var didCreateContext = false; if (context == null) { context = ContextFactory.Create(); didCreateContext = true; } if (newRelation.AcceptorId == newRelation.RequestorId) { throw new InvalidRelationshipException("Two different users are needed to create a relationship."); } var hasConflicts = context.Relationships .Any(r => AreRelated(r, newRelation)); if (!hasConflicts) { hasConflicts = context.RelationshipRequests .Any(r => AreRelated(r, newRelation)); } if (hasConflicts) { throw new DuplicateRelationshipException("A relationship with these users already exists."); } var requestorExists = context.Actors.Any(u => u.Id == newRelation.RequestorId); if (!requestorExists) { throw new InvalidRelationshipException("The requesting user does not exist."); } var acceptorExists = context.Actors.Any(u => u.Id == newRelation.AcceptorId); if (!acceptorExists) { throw new InvalidRelationshipException("The targeted user does not exist."); } var relation = new ActorRelationship { RequestorId = newRelation.RequestorId, AcceptorId = newRelation.AcceptorId }; context.Relationships.Add(relation); if (didCreateContext) { context.SaveChanges(); context.Dispose(); } }
private void CreateMembership(int requestor, int acceptor, SUGARContext context) { var relationship = new ActorRelationship { RequestorId = requestor, AcceptorId = acceptor, }; _relationshipController.CreateRequest(relationship, true, context); }
private ActorRelationship CreateRelationship(int requestor, int acceptor) { var actorRelationship = new ActorRelationship { RequestorId = requestor, AcceptorId = acceptor }; _relationshipController.CreateRelationship(actorRelationship); return(actorRelationship); }
public void Delete(ActorRelationship newRelation) { using (var context = ContextFactory.Create()) { var relation = context.Relationships .Single(r => AreRelated(r, newRelation)); context.Relationships.Remove(relation); context.SaveChanges(); } }
public static RelationshipResponse ToContract(this ActorRelationship relationshipModel) { if (relationshipModel == null) { return(null); } return(new RelationshipResponse { RequestorId = relationshipModel.RequestorId, AcceptorId = relationshipModel.AcceptorId }); }
// TODO This is assigning new users default claims to the group, to be moved to its own table /// <summary> /// Assign the user claims to resources for a newly created relationship with a group /// </summary> /// <param name="relation">the user/group relationship</param> private void AssignUserResourceClaims(ActorRelationship relation) { relation.Requestor = _actorController.Get(relation.RequestorId); relation.Acceptor = _actorController.Get(relation.AcceptorId); // Group to user relationship if (relation.Requestor.ActorType == ActorType.Group && relation.Acceptor.ActorType == ActorType.User || relation.Acceptor.ActorType == ActorType.Group && relation.Requestor.ActorType == ActorType.User) { // Get user var user = relation.Requestor.ActorType == ActorType.User ? relation.Requestor : relation.Acceptor; var group = relation.Requestor.ActorType == ActorType.Group ? relation.Requestor : relation.Acceptor; var GetClaim = _claimController.Get(ClaimScope.Group, "Get-Resource"); var CreateClaim = _claimController.Get(ClaimScope.Group, "Create-Resource"); var UpdateClaim = _claimController.Get(ClaimScope.Group, "Update-Resource"); if (GetClaim != null) { var getActorClaim = new ActorClaim { ActorId = user.Id, ClaimId = GetClaim.Id, EntityId = group.Id, }; _actorClaimController.Create(getActorClaim); } if (UpdateClaim != null) { var updateActorClaim = new ActorClaim { ActorId = user.Id, ClaimId = UpdateClaim.Id, EntityId = group.Id, }; _actorClaimController.Create(updateActorClaim); } if (CreateClaim != null) { var createActorClaim = new ActorClaim { ActorId = user.Id, ClaimId = CreateClaim.Id, EntityId = group.Id, }; _actorClaimController.Create(createActorClaim); } } }
public void UpdateNonExistingGroupMember() { var groupMemberName = "UpdateNonExistingGroupMember"; var requestor = CreateGroup(groupMemberName + " Requestor"); var acceptor = CreateGroup(groupMemberName + " Acceptor"); var newMember = new ActorRelationship { RequestorId = requestor.Id, AcceptorId = acceptor.Id }; Assert.Throws <InvalidOperationException>(() => _relationshipController.UpdateRequest(newMember, true)); }
public void UpdateNonExistingUserFriend() { var userFriendName = "UpdateNonExistingUserFriend"; var requestor = Helpers.CreateUser(userFriendName + " Requestor"); var acceptor = Helpers.CreateUser(userFriendName + " Acceptor"); var newFriend = new ActorRelationship { RequestorId = requestor.Id, AcceptorId = acceptor.Id }; Assert.Throws <InvalidOperationException>(() => _relationshipController.Delete(newFriend)); }
/// <summary> /// Create a new relationship between actores /// </summary> /// <param name="newRelationship"></param> /// <param name="autoAccept">If the relationship is accepted immediately</param> /// <param name="context">Optional DbContext to perform opperations on. If ommitted a DbContext will be created.</param> public void CreateRequest(ActorRelationship newRelationship, bool autoAccept, SUGARContext context = null) { // HACK auto accept default to false when using SUGAR Unity 1.0.2 or prior, not the expected behaviour // autoAccept = true; // END HACK if (autoAccept) { _relationshipDbController.CreateRelationship(newRelationship, context); // Assign users claims to the group that they do not get by default AssignUserResourceClaims(newRelationship); } else { _relationshipDbController.CreateRelationshipRequest(newRelationship, context); } _logger.LogInformation($"{newRelationship?.RequestorId} -> {newRelationship?.AcceptorId}, Auto Accept: {autoAccept}"); }
public void UpdateRequest(ActorRelationship newRelation, bool accepted) { using (var context = ContextFactory.Create()) { var relation = context.RelationshipRequests .Single(r => r.RequestorId == newRelation.RequestorId && r.AcceptorId == newRelation.AcceptorId); if (accepted) { var acceptedRelation = new ActorRelationship { RequestorId = relation.RequestorId, AcceptorId = relation.AcceptorId }; context.Relationships.Add(acceptedRelation); } context.RelationshipRequests.Remove(relation); context.SaveChanges(); } }
public void DoesDeleteRelationshipRequestWhenUserDeleted() { // Arrange var requestor = Helpers.CreateUser($"{nameof(DoesDeleteRelationshipRequestWhenUserDeleted)} Requestor"); var acceptor = Helpers.CreateUser($"{nameof(DoesDeleteRelationshipRequestWhenUserDeleted)} Acceptor"); var relationship = new ActorRelationship { RequestorId = requestor.Id, AcceptorId = acceptor.Id }; _relationshipController.CreateRelationshipRequest(relationship); // Act _userController.Delete(requestor.Id); // Assert var relationships = _relationshipController.GetRelationAcceptorActors(requestor.Id, ActorType.User); Assert.Empty(relationships); }
/// <summary> /// Update an existing relationship request between actors /// </summary> /// <param name="newRelationship"></param> /// <param name="accepted">If the relationship has been accepted by one of the actors</param> public void UpdateRequest(ActorRelationship relationship, bool accepted) { _relationshipDbController.UpdateRequest(relationship, accepted); _logger.LogInformation($"{relationship?.RequestorId} -> {relationship?.AcceptorId}, Accepted: {accepted}"); }