public async Task <MessageDto> SendMessageToUser(NewMessageDto message)
{
var room = await _context.Rooms
.FirstOrDefaultAsync(c => c.Id == message.RoomId);
var sender = await _context.Users
.FirstOrDefaultAsync(u => u.ExternalId == message.SenderExternalId);
var reciver = await _context.Users
.FirstOrDefaultAsync(u => u.Id == message.ReceiverId);
if (room == null)
{
room = CreateRoom(sender, reciver);
}
var messageInDb = CreateMessage(message, sender, room);
_context.SaveChanges();
var result = _mapper.Map <Message, MessageDto>(messageInDb);
result.UserId = sender.ExternalId;
result.Login = message.SenderLogin;
result.ChatRoomId = room.Id;
return(result);
}
public async Task SendMessage(NewMessageDto message)
{
_logger.LogInformation($"Sending message to user: {message.ReceiverId} in room : {message.RoomId}");
try
{
message.SenderExternalId = Context.GetLoggedUserExternalId();
message.SenderLogin = Context.GetLoggedUserLogin();
var result = await _roomService.SendMessageToUser(message);
var connections = new List <string>
{
Context.ConnectionId
};
if (_connectionsMapping.ContainsKey(message.ReceiverId))
{
connections.Add(_connectionsMapping[message.ReceiverId]);
}
await Clients.Clients(connections).ReceiveMessage(result);
}
catch (Exception e)
{
_logger.LogInformation($"Error was thrown during sending messege. Exception message {e.Message}. Inner error message {e.InnerException?.Message}");
throw e;
}
}
public async Task AddNewMessageSuccess()
{
//Arrange
var message = new Message {
Id = 1, Content = "test"
};
var newMessage = new NewMessageDto {
Content = "test"
};
var issueMessage = new GetIssueMessageDto {
Content = "test"
};
unitOfWork.Setup(x => x.Mapper().Map <Message>(newMessage)).Returns(message);
unitOfWork.Setup(x => x.Repository <Message>().Add(message)).Verifiable();
unitOfWork.Setup(x => x.SaveAllAsync()).Returns(Task.FromResult(true));
unitOfWork.Setup(x => x.Repository <Message>()
.GetByConditionWithIncludeFirst(It.IsAny <Expression <Func <Message, bool> > >(), y => y.Sender))
.Returns(Task.FromResult(message));
unitOfWork.Setup(x => x.Mapper().Map <GetIssueMessageDto>(message)).Returns(issueMessage);
var service = new MessageService(unitOfWork.Object);
//Act
var action = await service.AddNewMessage(newMessage);
//Assert
Assert.NotNull(action);
Assert.Equal("test", action.Content);
}
public async Task <int> SaveMessage(NewMessageDto messageDto)
{
var ans = messageDto.fillMessage();
_messages.Add(ans);
await _context.SaveChangesAsync();
return(ans.Id);
}
public async Task <IActionResult> Create([FromBody] NewMessageDto newMessage)
{
// save the message to the DB
var message = _messageServices.AddMessage(newMessage);
// send message to the clients
await _messageHub.Clients.All.SendMessageToClients(message);
return(Ok(message));
}
public async Task<ActionResult<Message>> SendNewMessage(NewMessageDto newMessageDto)
{
Message message = await _logic.CreateNewMessage(newMessageDto);
Message sent = await _logic.SendMessage(message);
if (sent == null)
{
//_logger.LogInformation("Bad Request");
return BadRequest("Message was not sent");
}
return sent;
}
public async Task <IActionResult> PostMessage([FromBody] NewMessageDto message, CancellationToken token)
{
if (message == null || message.IsEmpty)
{
return(BadRequest());
}
var newMessage = await messagesService.SaveMessage(message.User, message.MessageText, token);
await hubContext.Clients.All.Notify(newMessage);
return(Ok(newMessage));
}
private Message CreateMessage(NewMessageDto message, User sender, Room room)
{
var messageInDb = _mapper.Map <NewMessageDto, Message>(message);
messageInDb.CreatedAt = DateTime.Now;
messageInDb.User = sender;
messageInDb.Room = room;
room.Messeges.Add(messageInDb);
return(messageInDb);
}
public MessageDto AddMessage(NewMessageDto newMessage)
{
var message = _mapper.Map <Message>(newMessage);
_messageRepository.Add(message);
_messageRepository.Save();
var response = _mapper.Map <MessageDto>(message);
response.SenderName = _userRepository.Find(response.SenderId).FirstName + " " + _userRepository.Find(response.SenderId).LastName;
return(response);
}
public async Task AddNewMessageModelStateIsNotValid()
{
//Arrange
var newMessage = new NewMessageDto();
var controller = new MessageController(messageService.Object);
//Act
var action = await controller.AddNewMessage(newMessage) as BadRequestObjectResult;
//Assert
Assert.Equal(400, action.StatusCode);
Assert.NotNull(action.Value);
}
public async Task Send(NewMessageDto dto)
{
var currentUser = await GetCurrentUserAsync();
var recipients = conversationRepository.GetConversationUsersAsync(currentUser.Id, dto.ConversationId);
if (recipients.Length == 0)
{
return;
}
var message = messageRepository.CreateAsync(dto.ConversationId, currentUser.Id, dto.Text);
Broastcast("message.sent", message.ToDto(), recipients);
}
public async Task <GetIssueMessageDto> AddNewMessage(NewMessageDto newMessage)
{
var messageToAdd = unitOfWork.Mapper().Map <Message>(newMessage);
unitOfWork.Repository <Message>().Add(messageToAdd);
if (await unitOfWork.SaveAllAsync())
{
var messageToReturn = await unitOfWork.Repository <Message>()
.GetByConditionWithIncludeFirst(x => x.Id == messageToAdd.Id, y => y.Sender);
return(unitOfWork.Mapper().Map <GetIssueMessageDto>(messageToReturn));
}
return(null);
}
public async Task <IActionResult> AddNewMessage(NewMessageDto newMessage)
{
if (ModelState.IsValid)
{
GetIssueMessageDto message = await messageService.AddNewMessage(newMessage);
if (message != null)
{
return(CreatedAtAction("GetIssueMessage", new { messageId = message.Id }, message));
}
return(BadRequest("Something goes wrong"));
}
return(BadRequest("Model state is valid"));
}
public async Task AddNewMessageFailed()
{
//Arrange
var newMessage = new NewMessageDto {
Content = "test", IssueId = 1, SenderId = "test"
};
var controller = new MessageController(messageService.Object);
messageService.Setup(x => x.AddNewMessage(newMessage)).Returns(Task.FromResult((GetIssueMessageDto)null));
//Act
var action = await controller.AddNewMessage(newMessage) as BadRequestObjectResult;
//Assert
Assert.Equal(400, action.StatusCode);
Assert.NotNull(action.Value);
}
/// <summary>
/// Create a new Message
/// </summary>
/// <param name="newMessageDto">Message from user</param>
/// <returns>Message</returns>
public async Task <Message> CreateNewMessage(NewMessageDto newMessageDto)
{
Message newMessage = new Message()
{
MessageID = Guid.NewGuid(),
SenderID = newMessageDto.SenderID,
RecipientListID = Guid.NewGuid(),
MessageText = newMessageDto.MessageText,
SentDate = DateTime.Now
};
foreach (string id in newMessageDto.RecipientList)
{
await BuildRecipientList(newMessage.RecipientListID, id);
}
//await _repo.messages.AddAsync(newMessage);
await _repo.CommitSave();
return(newMessage);
}
public async void TestSendNewMessage()
{
var options = new DbContextOptionsBuilder <MessageContext>()
.UseInMemoryDatabase(databaseName: "p3LeagueService")
.Options;
using (var context = new MessageContext(options))
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
Repo r = new Repo(context, new NullLogger <Repo>());
Mapper map = new Mapper();
Logic logic = new Logic(r, map, new NullLogger <Repo>());
MessageController messageController = new MessageController(logic, null);
var newMessageDto = new NewMessageDto
{
SenderID = "12343214",
RecipientList = new List <string>(),
MessageText = "Hi I am a message test!"
};
var message = new Message
{
MessageID = Guid.NewGuid(),
SenderID = newMessageDto.SenderID,
RecipientListID = Guid.NewGuid(),
SentDate = DateTime.Now,
MessageText = newMessageDto.MessageText
};
r.Messages.Add(message);
await r.CommitSave();
var sendNewMessage = await messageController.SendNewMessage(newMessageDto);
Assert.NotNull(sendNewMessage);
}
}
public async Task AddNewMessageModelSuccess()
{
//Arrange
var newMessage = new NewMessageDto {
Content = "test", IssueId = 1, SenderId = "test"
};
var issueMessage = new GetIssueMessageDto {
Content = "test"
};
var controller = new MessageController(messageService.Object);
messageService.Setup(x => x.AddNewMessage(newMessage)).Returns(Task.FromResult(issueMessage));
//Act
var action = await controller.AddNewMessage(newMessage) as CreatedAtActionResult;
//Assert
Assert.Equal(201, action.StatusCode);
Assert.Equal("GetIssueMessage", action.ActionName);
}
public async void TestCreateNewMessage()
{
var options = new DbContextOptionsBuilder <MessageContext>()
.UseInMemoryDatabase(databaseName: "p3MessageService")
.Options;
using (var context = new MessageContext(options))
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
Repo r = new Repo(context, new NullLogger <Repo>());
Mapper map = new Mapper();
Logic logic = new Logic(r, map, new NullLogger <Repo>());
var newMessageDto = new NewMessageDto
{
SenderID = "38675634",
RecipientList = new List <string>(),
MessageText = "Hello I am a message"
};
var message = new Message
{
MessageID = Guid.NewGuid(),
SenderID = newMessageDto.SenderID,
RecipientListID = Guid.NewGuid(),
SentDate = DateTime.Now,
MessageText = newMessageDto.MessageText
};
r.Messages.Add(message);
await r.CommitSave();
var createNewMessage = await logic.CreateNewMessage(newMessageDto);
Assert.Equal(message.MessageText, newMessageDto.MessageText);
Assert.Equal(message.SenderID, newMessageDto.SenderID);
}
}
public async Task <ActionResult> NewMessage(NewMessageDto newMessageDto)
{
var sender = await _unitOfWork.UserRepository.GetUserByIdAsync(User.GetUserId());
if (sender.Id == newMessageDto.ReceiverId)
{
return(BadRequest("You cannot send messages to yourself"));
}
var receiver = await _unitOfWork.UserRepository.GetUserByIdAsync(newMessageDto.ReceiverId);
if (receiver == null)
{
return(NotFound());
}
var message = new Message
{
Sender = sender,
Receiver = receiver,
Content = newMessageDto.Content,
SendDate = DateTime.UtcNow,
IsRead = false
};
_unitOfWork.MessageRepository.AddMessage(message);
if (_unitOfWork.hasChanges())
{
if (await _unitOfWork.Complete())
{
await _unitOfHub.MessageService.SendMessage(message, receiver, sender);
return(Ok());
}
}
return(BadRequest("Failed to send message"));
}
public async Task AddNewMessageFailed()
{
//Arrange
var message = new Message {
Id = 1, Content = "test"
};
var newMessage = new NewMessageDto {
Content = "test"
};
unitOfWork.Setup(x => x.Mapper().Map <Message>(newMessage)).Returns(message);
unitOfWork.Setup(x => x.Repository <Message>().Add(message)).Verifiable();
unitOfWork.Setup(x => x.SaveAllAsync()).Returns(Task.FromResult(false));
var service = new MessageService(unitOfWork.Object);
//Act
var action = await service.AddNewMessage(newMessage);
//Assert
Assert.Null(action);
}
