protected async Task FinishWriteAsync(DomainGroup group, OperationKind operationKind, CancellationToken cancellationToken)
{
if (operationKind == OperationKind.CreateResource)
{
var message = OutgoingMessage.CreateFromContent(new GroupCreatedContent
{
GroupId = group.Id,
GroupName = group.Name
});
await FlushMessageAsync(message, cancellationToken);
}
else if (operationKind == OperationKind.UpdateResource)
{
if (_beforeGroupName != group.Name)
{
var message = OutgoingMessage.CreateFromContent(new GroupRenamedContent
{
GroupId = group.Id,
BeforeGroupName = _beforeGroupName,
AfterGroupName = group.Name
});
await FlushMessageAsync(message, cancellationToken);
}
}
else if (operationKind == OperationKind.DeleteResource)
{
DomainGroup groupToDelete = await GetGroupToDeleteAsync(group.Id, cancellationToken);
if (groupToDelete != null)
{
foreach (DomainUser user in groupToDelete.Users)
{
var removeMessage = OutgoingMessage.CreateFromContent(new UserRemovedFromGroupContent
{
UserId = user.Id,
GroupId = group.Id
});
await FlushMessageAsync(removeMessage, cancellationToken);
}
}
var deleteMessage = OutgoingMessage.CreateFromContent(new GroupDeletedContent
{
GroupId = group.Id
});
await FlushMessageAsync(deleteMessage, cancellationToken);
}
foreach (OutgoingMessage nextMessage in _pendingMessages)
{
await FlushMessageAsync(nextMessage, cancellationToken);
}
}
public override async Task OnSetToManyRelationshipAsync(DomainGroup group, HasManyAttribute hasManyRelationship, ISet <IIdentifiable> rightResourceIds,
OperationKind operationKind, CancellationToken cancellationToken)
{
_hitCounter.TrackInvocation <DomainGroup>(ResourceDefinitionHitCounter.ExtensibilityPoint.OnSetToManyRelationshipAsync);
if (hasManyRelationship.Property.Name == nameof(DomainGroup.Users))
{
HashSet <Guid> rightUserIds = rightResourceIds.Select(resource => (Guid)resource.GetTypedId()).ToHashSet();
List <DomainUser> beforeUsers = await _userSet.Include(user => user.Group).Where(user => rightUserIds.Contains(user.Id))
.ToListAsync(cancellationToken);
foreach (DomainUser beforeUser in beforeUsers)
{
IMessageContent content = null;
if (beforeUser.Group == null)
{
content = new UserAddedToGroupContent
{
UserId = beforeUser.Id,
GroupId = group.Id
};
}
else if (beforeUser.Group != null && beforeUser.Group.Id != group.Id)
{
content = new UserMovedToGroupContent
{
UserId = beforeUser.Id,
BeforeGroupId = beforeUser.Group.Id,
AfterGroupId = group.Id
};
}
if (content != null)
{
_pendingMessages.Add(OutgoingMessage.CreateFromContent(content));
}
}
if (group.Users != null)
{
foreach (DomainUser userToRemoveFromGroup in group.Users.Where(user => !rightUserIds.Contains(user.Id)))
{
var message = OutgoingMessage.CreateFromContent(new UserRemovedFromGroupContent
{
UserId = userToRemoveFromGroup.Id,
GroupId = group.Id
});
_pendingMessages.Add(message);
}
}
}
}
public override Task <IIdentifiable> OnSetToOneRelationshipAsync(DomainUser user, HasOneAttribute hasOneRelationship, IIdentifiable rightResourceId,
OperationKind operationKind, CancellationToken cancellationToken)
{
_hitCounter.TrackInvocation <DomainUser>(ResourceDefinitionHitCounter.ExtensibilityPoint.OnSetToOneRelationshipAsync);
if (hasOneRelationship.Property.Name == nameof(DomainUser.Group))
{
var afterGroupId = (Guid?)rightResourceId?.GetTypedId();
IMessageContent content = null;
if (user.Group != null && afterGroupId == null)
{
content = new UserRemovedFromGroupContent
{
UserId = user.Id,
GroupId = user.Group.Id
};
}
else if (user.Group == null && afterGroupId != null)
{
content = new UserAddedToGroupContent
{
UserId = user.Id,
GroupId = afterGroupId.Value
};
}
else if (user.Group != null && afterGroupId != null && user.Group.Id != afterGroupId)
{
content = new UserMovedToGroupContent
{
UserId = user.Id,
BeforeGroupId = user.Group.Id,
AfterGroupId = afterGroupId.Value
};
}
if (content != null)
{
var message = OutgoingMessage.CreateFromContent(content);
_pendingMessages.Add(message);
}
}
return(Task.FromResult(rightResourceId));
}
public override Task OnRemoveFromRelationshipAsync(DomainGroup group, HasManyAttribute hasManyRelationship, ISet <IIdentifiable> rightResourceIds,
CancellationToken cancellationToken)
{
if (hasManyRelationship.Property.Name == nameof(DomainGroup.Users))
{
HashSet <Guid> rightUserIds = rightResourceIds.Select(resource => (Guid)resource.GetTypedId()).ToHashSet();
foreach (DomainUser userToRemoveFromGroup in group.Users.Where(user => rightUserIds.Contains(user.Id)))
{
var message = OutgoingMessage.CreateFromContent(new UserRemovedFromGroupContent
{
UserId = userToRemoveFromGroup.Id,
GroupId = group.Id
});
_pendingMessages.Add(message);
}
}
return(Task.CompletedTask);
}
public override async Task OnAddToRelationshipAsync(Guid groupId, HasManyAttribute hasManyRelationship, ISet <IIdentifiable> rightResourceIds,
CancellationToken cancellationToken)
{
if (hasManyRelationship.Property.Name == nameof(DomainGroup.Users))
{
HashSet <Guid> rightUserIds = rightResourceIds.Select(resource => (Guid)resource.GetTypedId()).ToHashSet();
List <DomainUser> beforeUsers = await _userSet.Include(user => user.Group).Where(user => rightUserIds.Contains(user.Id))
.ToListAsync(cancellationToken);
foreach (DomainUser beforeUser in beforeUsers)
{
IMessageContent content = null;
if (beforeUser.Group == null)
{
content = new UserAddedToGroupContent
{
UserId = beforeUser.Id,
GroupId = groupId
};
}
else if (beforeUser.Group != null && beforeUser.Group.Id != groupId)
{
content = new UserMovedToGroupContent
{
UserId = beforeUser.Id,
BeforeGroupId = beforeUser.Group.Id,
AfterGroupId = groupId
};
}
if (content != null)
{
_pendingMessages.Add(OutgoingMessage.CreateFromContent(content));
}
}
}
}
protected async Task FinishWriteAsync(DomainUser user, OperationKind operationKind, CancellationToken cancellationToken)
{
if (operationKind == OperationKind.CreateResource)
{
var message = OutgoingMessage.CreateFromContent(new UserCreatedContent
{
UserId = user.Id,
UserLoginName = user.LoginName,
UserDisplayName = user.DisplayName
});
await FlushMessageAsync(message, cancellationToken);
}
else if (operationKind == OperationKind.UpdateResource)
{
if (_beforeLoginName != user.LoginName)
{
var message = OutgoingMessage.CreateFromContent(new UserLoginNameChangedContent
{
UserId = user.Id,
BeforeUserLoginName = _beforeLoginName,
AfterUserLoginName = user.LoginName
});
await FlushMessageAsync(message, cancellationToken);
}
if (_beforeDisplayName != user.DisplayName)
{
var message = OutgoingMessage.CreateFromContent(new UserDisplayNameChangedContent
{
UserId = user.Id,
BeforeUserDisplayName = _beforeDisplayName,
AfterUserDisplayName = user.DisplayName
});
await FlushMessageAsync(message, cancellationToken);
}
}
else if (operationKind == OperationKind.DeleteResource)
{
DomainUser userToDelete = await GetUserToDeleteAsync(user.Id, cancellationToken);
if (userToDelete?.Group != null)
{
var removeMessage = OutgoingMessage.CreateFromContent(new UserRemovedFromGroupContent
{
UserId = user.Id,
GroupId = userToDelete.Group.Id
});
await FlushMessageAsync(removeMessage, cancellationToken);
}
var deleteMessage = OutgoingMessage.CreateFromContent(new UserDeletedContent
{
UserId = user.Id
});
await FlushMessageAsync(deleteMessage, cancellationToken);
}
foreach (OutgoingMessage nextMessage in _pendingMessages)
{
await FlushMessageAsync(nextMessage, cancellationToken);
}
}