/// <inheritdoc />
/// <summary>
/// Send a message <b>Permissions Needed:</b> ANY
/// </summary>
/// <param name="chatMessageResource">The chat message resource</param>
public void SendMessage(ChatMessageResource chatMessageResource)
{
mWebCallEvent.WebPath = "/chat/messages";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
mWebCallEvent.PostBody = KnetikClient.Serialize(chatMessageResource); // http body (model) parameter
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mSendMessageStartTime = DateTime.Now;
mWebCallEvent.Context = mSendMessageResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.POST;
KnetikLogger.LogRequest(mSendMessageStartTime, "SendMessage", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
// Send message to all the client in same class on a message received
public async Task SendMessage(string classId, string text)
{
var userId = Context.User.Claims.First(c => c.Type == "sub").Value;
var user = await _dbContext.Users.FindAsync(userId);
var chatMessage = new ChatMessageResource
{
UserId = userId,
User = user.NameAndFamily ?? user.Email,
Text = text
};
await Clients.Group(classId).SendAsync("OnReceiveMessage", chatMessage);
}
private void OnSendMessageResponse(KnetikRestResponse response)
{
if (!string.IsNullOrEmpty(response.Error))
{
throw new KnetikException("Error calling SendMessage: " + response.Error);
}
SendMessageData = (ChatMessageResource)KnetikClient.Deserialize(response.Content, typeof(ChatMessageResource), response.Headers);
KnetikLogger.LogResponse(mSendMessageStartTime, "SendMessage", string.Format("Response received successfully:\n{0}", SendMessageData));
if (SendMessageComplete != null)
{
SendMessageComplete(response.ResponseCode, SendMessageData);
}
}
/// <inheritdoc />
/// <summary>
/// Edit your message <b>Permissions Needed:</b> owner
/// </summary>
/// <param name="id">The message id</param>
/// <param name="chatMessageResource">The chat message resource</param>
public void EditChatMessage(string id, ChatMessageResource chatMessageResource)
{
// verify the required parameter 'id' is set
if (id == null)
{
throw new KnetikException(400, "Missing required parameter 'id' when calling EditChatMessage");
}
mWebCallEvent.WebPath = "/chat/messages/{id}";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{" + "id" + "}", KnetikClient.ParameterToString(id));
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
mWebCallEvent.PostBody = KnetikClient.Serialize(chatMessageResource); // http body (model) parameter
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mEditChatMessageStartTime = DateTime.Now;
mWebCallEvent.Context = mEditChatMessageResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.PUT;
KnetikLogger.LogRequest(mEditChatMessageStartTime, "EditChatMessage", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
public async Task <ActionResult <ChatMessageResource> > SendMessage([FromBody] SendMessageBody body, CancellationToken cancellationToken = default)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Check if recipient exists
RecipientExistsQuery recipientExistsQuery = new RecipientExistsQuery {
RecipientId = body.RecipientId
};
bool recipientExists = await _mediator.Send(recipientExistsQuery, cancellationToken);
if (!recipientExists)
{
return(NotFound(new ErrorResource
{
StatusCode = StatusCodes.Status404NotFound,
Message = $"Recipient with ID '{body.RecipientId}' does not exist"
}));
}
// Check if the the user wants to message himself
IsOwnRecipientQuery isOwnRecipientQuery = new IsOwnRecipientQuery {
RecipientId = body.RecipientId
};
bool isOwnRecipient = await _mediator.Send(isOwnRecipientQuery, cancellationToken);
if (isOwnRecipient)
{
return(StatusCode(StatusCodes.Status403Forbidden, new ErrorResource
{
StatusCode = StatusCodes.Status403Forbidden,
Message = "You cannot write messages to yourself"
}));
}
if (body.ParentId != null)
{
// Check if parent message exists
MessageExistsQuery parentMessageExistsQuery = new MessageExistsQuery {
MessageId = body.ParentId.Value
};
bool parentMessageExists = await _mediator.Send(parentMessageExistsQuery, cancellationToken);
if (!parentMessageExists)
{
return(NotFound(new ErrorResource
{
StatusCode = StatusCodes.Status404NotFound,
Message = $"Parent message with ID '{body.ParentId}' does not exist"
}));
}
// Check if the user should have access to the parent message
CanAccessMessageQuery canAccessParentMessageQuery = new CanAccessMessageQuery {
MessageId = body.ParentId.Value
};
bool canAccessParentMessage = await _mediator.Send(canAccessParentMessageQuery, cancellationToken);
if (!canAccessParentMessage)
{
return(StatusCode(StatusCodes.Status403Forbidden, new ErrorResource
{
StatusCode = StatusCodes.Status403Forbidden,
Message = "You cannot answer messages from a foreign chat"
}));
}
}
// Send message to their recipients
SendMessageCommand sendMessageCommand = _mapper.Map <SendMessageBody, SendMessageCommand>(body);
ChatMessageResource message = await _mediator.Send(sendMessageCommand, cancellationToken);
return(CreatedAtAction(nameof(GetMessageById), new { messageId = message.MessageId }, message));
}
public async Task SendMessageCommandHandler_ShouldAddMessage_IncludingOneRecipient_WhenMessageIsSentToPrivateChatUser()
{
// Arrange
SendMessageCommand request = new SendMessageCommand
{
RecipientId = 2,
ParentId = 1,
HtmlContent = "<p>hello world</p>"
};
IQueryable <Recipient> databaseRecipient = new[]
{
new Recipient
{
RecipientId = request.RecipientId,
UserId = 2,
}
}
.AsQueryable()
.BuildMock()
.Object;
IQueryable <User> databaseUser = new[]
{
new User
{
UserId = 1,
Recipient = new Recipient {
RecipientId = 2
}
}
}
.AsQueryable()
.BuildMock()
.Object;
_unitOfWorkMock
.Setup(m => m.Users.GetById(1))
.Returns(databaseUser);
_unitOfWorkMock
.Setup(m => m.Recipients.GetById(2))
.Returns(databaseRecipient);
Message passedMessage = null;
MessageRecipient passedMessageRecipient = null;
_unitOfWorkMock
.Setup(m => m.Messages.Add(It.IsAny <Message>(), It.IsAny <CancellationToken>()))
.Callback <Message, CancellationToken>((m, _) =>
{
passedMessage = m;
m.MessageId = 1;
})
.Returns(Task.CompletedTask);
_unitOfWorkMock
.Setup(m => m.MessageRecipients.Add(It.IsAny <MessageRecipient>(), It.IsAny <CancellationToken>()))
.Callback <MessageRecipient, CancellationToken>((mr, _) =>
{
passedMessageRecipient = mr;
passedMessageRecipient.RecipientId = 1;
})
.Returns(Task.CompletedTask);
_unitOfWorkMock
.Setup(m => m.CommitAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(1);
SendMessageCommand.Handler handler = new SendMessageCommand.Handler(_unitOfWorkMock.Object, _dateProviderMock.Object, _userProviderMock.Object, _hubContextMock.Object);
// Act
ChatMessageResource result = await handler.Handle(request);
// Assert
_unitOfWorkMock.Verify(m => m.Messages.Add(It.IsAny <Message>(), It.IsAny <CancellationToken>()), Times.Once);
Assert.NotNull(passedMessage);
Assert.Equal(1, passedMessage.AuthorId);
Assert.Equal(request.ParentId, passedMessage.ParentId);
_unitOfWorkMock.Verify(m => m.MessageRecipients.Add(It.IsAny <MessageRecipient>(), It.IsAny <CancellationToken>()), Times.Once);
Assert.NotNull(passedMessageRecipient);
Assert.Equal(1, passedMessageRecipient.RecipientId);
_unitOfWorkMock.Verify(m => m.CommitAsync(It.IsAny <CancellationToken>()), Times.AtLeastOnce);
_hubContextMock.Verify(m => m.Clients.User("1").ReceiveMessage(It.IsAny <ReceiveMessagePayload>()), Times.Once);
Assert.NotNull(result);
Assert.Equal(1, result.MessageId);
}
public async Task SendMessageCommandHandler_ShouldAddMessage_IncludingMultipleRecipients_WhenMessageIsSentToGroupChat()
{
// Arrange
SendMessageCommand request = new SendMessageCommand
{
RecipientId = 1,
ParentId = 1,
HtmlContent = "<p>hello world</p>"
};
IQueryable <Recipient> databaseRecipient = new[]
{
new Recipient
{
RecipientId = request.RecipientId,
GroupMembership = new GroupMembership
{
Group = new Group
{
Memberships = new HashSet <GroupMembership>
{
new GroupMembership
{
UserId = 1,
Recipient = new Recipient
{
RecipientId = 1,
GroupMembership = new GroupMembership {
UserId = 1
}
},
},
new GroupMembership
{
UserId = 2,
Recipient = new Recipient
{
RecipientId = 2,
GroupMembership = new GroupMembership {
UserId = 2
}
},
}
}
}
},
}
}
.AsQueryable()
.BuildMock()
.Object;
IQueryable <User> databaseUser = new[]
{
new User
{
UserId = 1,
Recipient = new Recipient {
RecipientId = 2
}
}
}
.AsQueryable()
.BuildMock()
.Object;
_unitOfWorkMock
.Setup(m => m.Recipients.GetById(1))
.Returns(databaseRecipient);
_unitOfWorkMock
.Setup(m => m.Users.GetById(1))
.Returns(databaseUser);
Message passedMessage = null;
IEnumerable <MessageRecipient> passedMessageRecipients = null;
_unitOfWorkMock
.Setup(m => m.Messages.Add(It.IsAny <Message>(), It.IsAny <CancellationToken>()))
.Callback <Message, CancellationToken>((m, _) =>
{
passedMessage = m;
m.MessageId = 1;
})
.Returns(Task.CompletedTask);
_unitOfWorkMock
.Setup(m => m.MessageRecipients.AddRange(It.IsAny <IEnumerable <MessageRecipient> >(), It.IsAny <CancellationToken>()))
.Callback <IEnumerable <MessageRecipient>, CancellationToken>((mrs, _) => passedMessageRecipients = mrs)
.Returns(Task.CompletedTask);
_unitOfWorkMock
.Setup(m => m.CommitAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(1);
SendMessageCommand.Handler handler = new SendMessageCommand.Handler(_unitOfWorkMock.Object, _dateProviderMock.Object, _userProviderMock.Object, _hubContextMock.Object);
// Act
ChatMessageResource result = await handler.Handle(request);
// Assert
_unitOfWorkMock.Verify(m => m.Messages.Add(It.IsAny <Message>(), It.IsAny <CancellationToken>()), Times.Once);
Assert.NotNull(passedMessage);
Assert.Equal(1, passedMessage.AuthorId);
Assert.Equal(request.ParentId, passedMessage.ParentId);
_unitOfWorkMock.Verify(m => m.MessageRecipients.AddRange(It.IsAny <IEnumerable <MessageRecipient> >(), It.IsAny <CancellationToken>()), Times.Once);
Assert.NotEmpty(passedMessageRecipients);
Assert.Equal(2, passedMessageRecipients.Count());
_unitOfWorkMock.Verify(m => m.CommitAsync(It.IsAny <CancellationToken>()), Times.AtLeastOnce);
_hubContextMock.Verify(m => m.Clients.User("1").ReceiveMessage(It.IsAny <ReceiveMessagePayload>()), Times.Exactly(1));
Assert.NotNull(result);
Assert.Equal(1, result.MessageId);
}
