private async Task <MessageDto> SendMessageInternalAsync(string chatId, MessageDataModel messageData) { var principal = _contextAccessor.HttpContext.User; var ownerUser = await _userManager.GetUserAsync(principal); var chat = await _unitOfWork.Chats.GetByIdAsync(chatId); if (messageData.ReplyToId != null) { var reply = await _unitOfWork.Messages.GetByIdAsync(messageData.ReplyToId); if (reply == null || reply.ChatId.ToString() != chatId) { throw new ItemNotFoundException("Message reply target was not found in this chat"); } } var message = new Message { AuthorId = ownerUser.Id, ChatId = chat.Id, TimePublished = DateTime.UtcNow, ReplyToId = messageData.ReplyToId == null ? null : new Guid?(new Guid(messageData.ReplyToId)), Text = messageData.Text }; await _unitOfWork.Messages.CreateAsync(message); return(message.ToDto()); }
public async Task SendPersonalMessageAsync_Success_ReturnsExpectedMessage() { var userId = Guid.NewGuid(); var messageData = new MessageDataModel() { Text = "This is a test message!" }; var chat = new Chat { Type = ChatType.Personal }; var otherUser = new User { Id = userId }; _unitOfWork.Setup(u => u.Chats.GetByIdAsync(It.IsAny <string>())).ReturnsAsync(chat); _unitOfWork.Setup(u => u.Messages .CreateAsync(It.Is <Message>(m => m.Text == messageData.Text))); _unitOfWork.Setup(u => u.Users.GetByIdAsync(It.IsAny <string>())).ReturnsAsync(otherUser); _unitOfWork.Setup(u => u.Chats.QueryAsync(It.IsAny <Func <Chat, bool> >())) .ReturnsAsync(new[] { chat }); var message = await _messagesService.SendPersonalMessageAsync(userId.ToString(), messageData); message.Text.Should().Be(messageData.Text); message.TimePublished.Should().BeCloseTo(DateTime.UtcNow, TimeSpan.FromSeconds(1)); }
public async Task <IActionResult> SendGroupMessage([Required][ValidateGuid][FromRoute] string chatId, [Required][FromBody] MessageDataModel messageData) { var chat = await _chatsService.GetByIdAsync(chatId); var authResult = await _authorizationService.AuthorizeAsync(User, chat, "ChatParticipant"); if (!authResult.Succeeded) { return(BadRequest(new ApiError("Chat not found", HttpStatusCode.BadRequest))); } try { var message = await _messagesService.SendGroupMessageAsync(chatId, messageData); return(CreatedAtAction(nameof(GetMessageById), new { messageId = message.Id, chatId }, message)); } catch (ItemNotFoundException e) { return(BadRequest(new ApiError(e.Message, HttpStatusCode.BadRequest))); } catch (InvalidOperationException e) { return(BadRequest(new ApiError(e.Message, HttpStatusCode.BadRequest))); } }
public void SendGroupMessageAsync_ReplyToUnknownMessage_ThrowsInvalidOperationException() { var chatId = Guid.NewGuid().ToString(); var replyId = Guid.NewGuid(); var messageData = new MessageDataModel() { Text = "This is a test message!", ReplyToId = replyId.ToString() }; var replyMessage = new Message() { Id = replyId, Text = "This is a message in another chat", TimePublished = DateTime.UtcNow, ChatId = Guid.NewGuid() }; var chat = new Chat { Type = ChatType.Group, }; _unitOfWork.Setup(u => u.Chats.GetByIdAsync(It.IsAny <string>())).ReturnsAsync(chat); _unitOfWork.Setup(u => u.Messages.GetByIdAsync(It.IsAny <string>())).ReturnsAsync(replyMessage); _messagesService.Awaiting(s => s.SendGroupMessageAsync(chatId, messageData)) .Should().Throw <ItemNotFoundException>(); }
public async Task <MessageDto> EditMessageAsync(string messageId, MessageDataModel messageData) { var message = await _unitOfWork.Messages.GetByIdAsync(messageId); if (message == null) { throw new ItemNotFoundException("Message not found"); } if (messageData.ReplyToId != null) { var reply = await _unitOfWork.Messages.GetByIdAsync(messageData.ReplyToId); if (reply == null || reply.ChatId != message.ChatId) { throw new ItemNotFoundException("Message reply target was not found in this chat"); } if (reply.TimePublished > message.TimePublished) { throw new InvalidOperationException("Message reply target must be published before this message"); } } message.Update(messageData); await _unitOfWork.Messages.UpdateAsync(message); return(message.ToDto()); }
public async Task <MessageDataModel> AddAttachmentMessage(Message message, int groupId, string senderId) { var whoSent = await usersRepository.GetByIdAsync(senderId); if (whoSent == null) { throw new InvalidDataException( $"Failed to retrieve user with id {senderId} from database: no such user exists"); } var attachmentKind = await attachmentKindsRepository.GetById(message.AttachmentInfo.AttachmentKind); var attachment = await attachmentRepository.AddAsync( MessageAttachmentDataModel.Create(attachmentKind, message)); var model = MessageDataModel .Create(whoSent, groupId) .AsAttachment(attachment); var result = await messagesRepository.AddAsync(model); await unitOfWork.Commit(); await SetLastMessage(senderId, groupId, result.MessageID); return(result); }
public async Task <IActionResult> CreateMessage(int userId, MessageDataModel message) { var sender = await _userRepo.GetUser(userId); if (sender.Id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value)) { return(Unauthorized()); } message.SenderId = userId; var recipient = await _userRepo.GetUser(message.RecipientId); if (recipient == null) { return(BadRequest("Could not find user")); } var newMessage = _mapper.Map <Message>(message); _messageRepo.Add(newMessage); if (await _messageRepo.SaveAll()) { var response = _mapper.Map <MessageViewModel>(newMessage); return(CreatedAtRoute("GetMessage", new { messageId = newMessage.Id }, response)); } throw new Exception("Creating the message failed on save"); }
public async Task SendPersonalMessageAsync_ChatWithUserDoesNotExist_CreatesPersonalChat() { var userId = Guid.NewGuid(); var messageData = new MessageDataModel() { Text = "This is a test message!" }; var chat = new Chat { Id = Guid.NewGuid(), Type = ChatType.Personal }; var otherUser = new User { Id = userId }; _unitOfWork.Setup(u => u.Chats.QueryAsync(It.IsAny <Func <Chat, bool> >())) .ReturnsAsync(new List <Chat>()); _unitOfWork.Setup(u => u.Messages .CreateAsync(It.Is <Message>(m => m.Text == messageData.Text))); _unitOfWork.Setup(u => u.Users.GetByIdAsync(It.IsAny <string>())).ReturnsAsync(otherUser); _chatsService.Setup(s => s.CreatePersonalAsync(It.IsAny <string>())) .ReturnsAsync(chat.ToDto()); _unitOfWork.Setup(u => u.Chats.GetByIdAsync(It.IsAny <string>())).ReturnsAsync(chat); await _messagesService.SendPersonalMessageAsync(userId.ToString(), messageData); _chatsService.VerifyAll(); }
public async Task <MessageModel> SendMessageToChatAsync(int chatId, MessageDataModel messageData) { var message = await _chatService.SendMessageToChatAsync(_currentUserInfoProvider.Id, chatId, messageData.ContentType, messageData.Content); await _chatHubContext.Clients.Group(message.ChatId.ToString()).Message(message); return(message); }
protected MessageDataModel CreateMessageData(string route, params KeyValuePair <string, string>[] parameters) { var message = new MessageDataModel { Api = $"{route}", Parameters = parameters?.ToList() }; return(message); }
public int AddMessage(MessageDataModel newMessage) { using (var connection = new SqlConnection(ConnectionString)) { connection.Open(); return(connection.QueryFirst <int>( @"EXEC dbo.Message_Add @UserId = @UserId, @ContactId = @ContactId, @SendTime = @SendTime, @DeliveryTime = @DeliveryTime, @Content = @Content", newMessage)); } }
protected HttpResponseMessage CreateBadRequestErrorResponse(MessageDataModel messageData, string errorMessage) { var status = HttpStatusCode.BadRequest; var errorResponse = new ErrorResponseModel { StatusCode = (int)status, StatusDescription = status.ToString(), Message = errorMessage, }; return(CreateResponse <string>(status, errorResponse, messageData)); }
public void SendPersonalMessageAsync_UserNotFound_ThrowsItemNotFoundException() { var userId = Guid.NewGuid().ToString(); var messageData = new MessageDataModel() { Text = "This is a test message!" }; _unitOfWork.Setup(u => u.Users.GetByIdAsync(It.IsAny <string>())).ReturnsAsync((User)null); _messagesService.Awaiting(s => s.SendPersonalMessageAsync(userId, messageData)) .Should().Throw <ItemNotFoundException>(); }
protected HttpResponseMessage CreateValidationErrorResponse(MessageDataModel messageData, ValidationResult validationResult) { var status = HttpStatusCode.OK; var errorResponse = new ErrorResponseModel { StatusCode = (int)status, StatusDescription = status.ToString(), Message = "Validation Error", Validation = validationResult }; return(CreateResponse <string>(status, errorResponse, messageData)); }
public async Task <string> AddMessageAsync(MessageDataModel message) { await PrepareCosmos(); await PrepareMessageContainer(); string msg = ""; await this.container.CreateItemAsync <MessageDataModel>(message, new PartitionKey(message.GroupName)); msg = "message is sent to group"; return(msg); }
public void SendGroupMessageAsync_GroupDoesNotExists_ThrowsItemNotFoundException() { var chatId = Guid.NewGuid().ToString(); var messageData = new MessageDataModel() { Text = "This is a test message!" }; _unitOfWork.Setup(u => u.Chats.GetByIdAsync(It.IsAny <string>())).ReturnsAsync((Chat)null); _messagesService.Awaiting(s => s.SendGroupMessageAsync(chatId, messageData)) .Should().Throw <ItemNotFoundException>(); }
protected HttpResponseMessage CreateSystemErrorResponse(MessageDataModel messageData) { var status = HttpStatusCode.InternalServerError; var errorResponse = new ErrorResponseModel { StatusCode = (int)status, StatusDescription = status.ToString(), Message = "Server error", Validation = null, }; return(CreateResponse <string>(status, errorResponse, messageData)); }
protected HttpResponseMessage CreateNotFoundResponse(MessageDataModel messageData, string message) { var status = HttpStatusCode.NotFound; var errorResponse = new ErrorResponseModel { StatusCode = (int)status, StatusDescription = status.ToString(), Message = message, Validation = null }; return(CreateResponse <string>(status, errorResponse, messageData)); }
public async Task <MessageDto> SendPersonalMessageAsync(string userId, MessageDataModel messageData) { var otherUser = await _unitOfWork.Users.GetByIdAsync(userId); if (otherUser == null) { throw new ItemNotFoundException("User not found"); } // Find chat with user, or create new one var chatWithUser = await GetChatWithUser(userId) ?? await _chatsService.CreatePersonalAsync(userId); return(await SendMessageInternalAsync(chatWithUser.Id, messageData)); }
public async Task <MessageDto> SendGroupMessageAsync(string chatId, MessageDataModel messageData) { var chat = await _unitOfWork.Chats.GetByIdAsync(chatId); if (chat == null) { throw new ItemNotFoundException("Specified chat was not found"); } if (chat.Type != ChatType.Group) { throw new InvalidOperationException("Specified chat is not a group"); } return(await SendMessageInternalAsync(chatId, messageData)); }
public static Message ToMessage(this MessageDataModel value) { return(new Message { Id = value.MessageID, ConversationID = value.ConversationID, MessageContent = value.MessageContent, TimeReceived = value.TimeReceived.ToUTCString(), User = value.User?.ToAppUserDto(), AttachmentInfo = value.AttachmentInfo?.ToMessageAttachment(), Type = value.Type, ForwardedMessage = value.ForwardedMessage?.ToMessage(), State = value.State, EncryptedPayload = value.EncryptedPayload, Event = value.Event?.ToChatEvent() }); }
public void SendGroupMessageAsync_NotGroupChat_ThrowsInvalidOperationException() { var chatId = Guid.NewGuid().ToString(); var messageData = new MessageDataModel() { Text = "This is a test message!" }; var chat = new Chat { Type = ChatType.Personal }; _unitOfWork.Setup(u => u.Chats.GetByIdAsync(It.IsAny <string>())).ReturnsAsync(chat); _messagesService.Awaiting(s => s.SendGroupMessageAsync(chatId, messageData)) .Should().Throw <InvalidOperationException>(); }
public async Task <IActionResult> SendPersonalMessage([Required][ValidateGuid][FromRoute] string userId, [Required][FromBody] MessageDataModel messageData) { try { var message = await _messagesService.SendPersonalMessageAsync(userId, messageData); return(CreatedAtAction(nameof(GetMessageById), new { messageId = message.Id, userId }, message)); } catch (ItemNotFoundException e) { return(BadRequest(new ApiError(e.Message, HttpStatusCode.BadRequest))); } catch (InvalidOperationException e) { return(BadRequest(new ApiError(e.Message, HttpStatusCode.BadRequest))); } }
/// <summary> /// Adds a messages and updates client lastMessageId /// </summary> /// <param name="message"></param> /// <param name="chatId"></param> /// <param name="senderId"></param> /// <returns></returns> /// <exception cref="InvalidDataException"></exception> public async Task <MessageDataModel> AddMessage(Message message, int chatId, string senderId) { var whoSent = await usersRepository.GetByIdAsync(senderId); if (whoSent == null) { throw new InvalidDataException( $"Failed to retrieve user with id {senderId} from database: no such user exists"); } MessageDataModel forwardedMessage = null; if (message.Type == MessageType.Forwarded) { if (!await usersConversationsRepository.Exists(senderId, message.ForwardedMessage.ConversationID)) { throw new UnauthorizedAccessException("Forwarded message id is incorrect."); } var foundMessage = await messagesRepository.GetByIdAsync(message.ForwardedMessage.Id); forwardedMessage = foundMessage ?? throw new InvalidDataException("Forwarded message was not found."); } MessageDataModel model = MessageDataModel.Create(whoSent, chatId); if (forwardedMessage != null) { model.AsForwarded(forwardedMessage); } else { model.AsText(message.MessageContent); } var result = await messagesRepository.AddAsync(model); await unitOfWork.Commit(); await SetLastMessage(senderId, chatId, result.MessageID); return(result); }
public async Task <IActionResult> EditMessage([Required][ValidateGuid][FromRoute] string messageId, [Required][FromBody] MessageDataModel messageData) { var message = await _messagesService.GetMessageByIdAsync(messageId); if (message == null) { return(NotFound(new ApiError("Message with specified Id was not found", HttpStatusCode.NotFound))); } var chat = await _chatsService.GetByIdAsync(message.ChatId); var isChatParticipant = await _authorizationService.AuthorizeAsync(User, chat, "ChatParticipant"); if (!isChatParticipant.Succeeded) { return(NotFound(new ApiError("Message with specified Id was not found", HttpStatusCode.NotFound))); } var authResult = await _authorizationService.AuthorizeAsync(User, message, "SameUser"); if (!authResult.Succeeded) { var authError = new ApiError("You are not message author", HttpStatusCode.Unauthorized); return(StatusCode(StatusCodes.Status403Forbidden, authError)); } try { await _messagesService.EditMessageAsync(messageId, messageData); } catch (ItemNotFoundException e) { return(BadRequest(new ApiError(e.Message, HttpStatusCode.BadRequest))); } catch (InvalidOperationException e) { return(BadRequest(new ApiError(e.Message, HttpStatusCode.BadRequest))); } return(Ok(message)); }
public async Task SendGroupMessageAsync_Success_AddsMessageToRepository() { var chatId = Guid.NewGuid().ToString(); var messageData = new MessageDataModel() { Text = "This is a test message!" }; var chat = new Chat { Type = ChatType.Group }; _unitOfWork.Setup(u => u.Chats.GetByIdAsync(It.IsAny <string>())).ReturnsAsync(chat); _unitOfWork.Setup(u => u.Messages .CreateAsync(It.Is <Message>(m => m.Text == messageData.Text))); await _messagesService.SendGroupMessageAsync(chatId, messageData); _unitOfWork.VerifyAll(); }
public async Task <MessageDataModel> AddEncryptedMessage(string message, int groupId, string senderId) { var whoSent = await usersRepository.GetByIdAsync(senderId); if (whoSent == null) { throw new InvalidDataException( $"Failed to retrieve user with id {senderId} from database: no such user exists"); } var model = MessageDataModel .Create(whoSent, groupId) .AsSecure(message); var result = await messagesRepository.AddAsync(model); await unitOfWork.Commit(); await SetLastMessage(senderId, groupId, result.MessageID); return(result); }
public NumberVerifierMessageData(MessageDataModel messageDataModel) { SourceIssues = messageDataModel.SourceIssues; InitialSourceIssues = messageDataModel.InitialSourceIssues; InitialTargetIssues = messageDataModel.InitialTargetIssues; TargetIssues = messageDataModel.TargetIssues; ReplacementSuggestion = messageDataModel.ReplacementSuggestion; //Identifier for this custom message type if (messageDataModel.ErrorMessage.Equals(Constants.AlphanumericMessage)) { MessageType = Constants.AlphanumericIssue; } else if (messageDataModel.IsHindiVerification) { MessageType = Constants.HindiIssue; } else { MessageType = Constants.NumberIssue; } }
public async Task <MessageDataModel> AddChatEvent(ChatEventType type, string actorId, string userInvolvedId, int chatId) { try { var newEvent = await chatEventsRepository.AddAsync(ChatEventDataModel.Create(actorId, userInvolvedId, type)); var model = MessageDataModel .Create(null, chatId) .AsEvent(newEvent); var result = await messagesRepository.AddAsync(model); await unitOfWork.Commit(); return(result); } catch (Exception e) { throw new InvalidDataException("Wrong actorId or userId", e); } }
public IHttpActionResult PostMessage(Message message) { if (ModelState.IsValid) { message.PostOn = DateTime.Now; message.UserId = this.UserProvider.GetUserId(); this.Data.Messages.Add(message); this.Data.SaveChanges(); } var notification = PubNubNotificationManager.Instance; notification.PublishMessage("global", "new message"); var messageData = new MessageDataModel() { Body = message.Body, PostOn = message.PostOn }; return(this.Ok(messageData)); }