/// <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}");
}
