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