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