public async Task <IActionResult> AddMessage([FromBody] MessageInputModel message, int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var conversation =
await _db.Conversations.SingleOrDefaultAsync(x => x.ConversationId == id);
if (conversation == null)
{
ModelState.AddModelError("MissingConversation", "There is no conversation with this ID");
return(BadRequest(ModelState));
}
var newMessage = new Message
{
ConversationId = id,
Contenu = message.Contenu,
UserId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value
};
await _db.Messages.AddAsync(newMessage);
await _db.SaveChangesAsync();
//send empty json so the app doesn't fail
return(Ok(new {}));
}
public void MessagesController_Should_Return_View_With_Error_If_Message_Content_Empty()
{
var messageService = new Mock <IMessageService>();
var message = new MessageInputModel
{
Message = null,
ReceiverName = "someName",
SenderName = "anotherName",
SendDate = DateTime.Now
};
var httpContext = new DefaultHttpContext();
var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>())
{
[GlobalConstants.Error] = GlobalConstants.EmptyMessage
};
var controller = new MessagesController(messageService.Object)
{
TempData = tempData
};
var result = controller.SendMessage(message);
string action = "Profile";
result.Should().BeOfType <RedirectToActionResult>().Which.ActionName.Should().Be(action);
}
public async Task Send(string messageText, string receiverId)
{
var sender = this.userService.GetUserByUsername(this.Context.User.Identity.Name);
var receiver = this.userService.GetUser(receiverId);
if (sender == null || receiver == null)
{
throw new Exception("The sender or the receiver doesn't exist");
}
var messageInputModel = new MessageInputModel
{
Message = messageText,
SentOn = DateTime.UtcNow,
SenderId = sender.Id,
ReceiverId = receiverId,
};
try
{
var newMessage = await this.contactsChatService.AddMessages(messageInputModel);
messageInputModel.MessageId = newMessage.Id;
await this.Clients.Caller.SendAsync("NewMessage", messageInputModel);
var receiverClientProxy = this.Clients.User(receiverId);
await receiverClientProxy.SendAsync("NewMessage", messageInputModel);
}
catch
{
throw new Exception("Something went wrong with the method internally");
}
}
public IActionResult PostMessage([FromBody] MessageInputModel message)
{
using (var connection = _factory.CreateConnection())
{
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(
queue: QUEUE_NAME,
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
var stringfiedMessage = JsonConvert.SerializeObject(message);
var bytesMessage = Encoding.UTF8.GetBytes(stringfiedMessage);
channel.BasicPublish(
exchange: "",
routingKey: QUEUE_NAME,
basicProperties: null,
body: bytesMessage);
}
}
return(Accepted());
}
public void AddMessage_Return_Error_EmptyMessage()
{
var messageService = new Mock <IMessageService>();
var message = new MessageInputModel
{
Message = null,
ReceiverName = "usertest",
SenderName = "admintest",
SendDate = DateTime.UtcNow
};
var httpContext = new DefaultHttpContext();
var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>())
{
[GlobalConstants.Error] = GlobalConstants.EmptyMessage
};
var controller = new BookCreatorApp.Controllers.MessagesController(messageService.Object, null, null)
{
TempData = tempData
};
var result = controller.SendMessage(message);
string action = "Profile";
result.Should().BeOfType <RedirectToActionResult>().Which.ActionName.Should().Be(action);
}
private async Task <ChatRoom> InitiliazeChatRoom(MessageInputModel model)
{
var userTwo = await this.userRepository.All()
.FirstOrDefaultAsync(u => u.UserName == model.UserTwoUsername);
var userTwoId = userTwo.Id;
var chatRoomExists = await this.chatRoomRepository.All()
.FirstOrDefaultAsync(c =>
(c.UserOneId == model.UserOneId && c.UserTwoId == userTwoId) ||
(c.UserOneId == userTwoId && c.UserTwoId == model.UserOneId));
if (chatRoomExists == null)
{
var chatRoom = new ChatRoom
{
UserOneId = model.UserOneId,
UserTwoId = userTwoId,
};
await this.chatRoomRepository.AddAsync(chatRoom);
await this.chatRoomRepository.SaveChangesAsync();
return(chatRoom);
}
return(chatRoomExists);
}
public void SendMessage_Should_Success()
{
var sender = new BookCreatorUser()
{
UserName = "******",
Name = "Gosho Petkov"
};
var receiver = new BookCreatorUser()
{
UserName = "******",
Name = "Petko Goshov"
};
this.userManager.CreateAsync(sender).GetAwaiter();
this.userManager.CreateAsync(receiver).GetAwaiter();
this.Context.SaveChanges();
var messageInput = new MessageInputModel
{
SenderName = sender.UserName,
ReceiverName = receiver.UserName,
Message = "ko staa we",
SendDate = DateTime.UtcNow
};
var newMessageId = this.messageService.SendMessage(messageInput);
var result = this.Context.Messages.First();
result.Should().NotBeNull()
.And.Subject.As <Message>()
.Id.Should().Be(newMessageId);
}
public async Task CreateAsync_WithValidData_ShouldAddMessageToDatabase()
{
// Arrange
this.InitilaizeMapper();
var context = InMemoryDbContext.Initiliaze();
var messagesRepository = new EfRepository <Message>(context);
var chatRoomsRepository = new EfRepository <ChatRoom>(context);
var usersRepository = new EfRepository <ApplicationUser>(context);
var service = new MessagesService(messagesRepository, chatRoomsRepository, usersRepository);
await this.SeedUsers(context);
await this.SeedChatRooms(context);
var model = new MessageInputModel {
UserOneId = "userId", UserTwoUsername = "******", Text = "test text"
};
// Act
var message = await service.CreateAsync(model);
string expectedMessageText = context.Messages.FirstOrDefault().Text;
string actualMessageText = message.Text;
// Assert
Assert.Equal(expectedMessageText, actualMessageText);
}
public async Task <IActionResult> SendMessage([FromForm] MessageInputModel model)
{
if (!this.ModelState.IsValid)
{
return(this.Problem());
}
if (!await this.conversationsService.IsUserParticipantAsync(model.ConversationId, this.UserId))
{
return(this.Forbid());
}
var messageId =
await this.conversationsService.SendMessageAsync(this.UserId, model.ConversationId, model.Content);
await this.chatHubContext.Clients
.Users(await this.conversationsService.GetParticipantsAsync(model.ConversationId))
.SendAsync(
"ReceiveMessage",
new ReceiveMessageViewModel
{
Id = messageId,
ConversationId = model.ConversationId,
});
return(this.Ok());
}
public async Task CreateAsync_WithValidData_ShouldInitiliazeChatRoom()
{
// Arrange
this.InitilaizeMapper();
var context = InMemoryDbContext.Initiliaze();
var messagesRepository = new EfRepository <Message>(context);
var chatRoomsRepository = new EfRepository <ChatRoom>(context);
var usersRepository = new EfRepository <ApplicationUser>(context);
var service = new MessagesService(messagesRepository, chatRoomsRepository, usersRepository);
await this.SeedUsers(context);
var model = new MessageInputModel {
UserOneId = "userId", UserTwoUsername = "******", Text = "test text"
};
// Act
int expectedCount = context.ChatRooms.Count() + 1;
await service.CreateAsync(model); // The chatroom does not exist, so sending the first message, should initiliaze it.
int actualCount = context.ChatRooms.Count();
// Assert
Assert.Equal(expectedCount, actualCount);
}
public Task UpdateMessageAsync(MessageInputModel inputModel)
{
var messageModel = AutoMapper.Map <Message>(inputModel);
MessagesContext.Messages.Update(messageModel);
return(MessagesContext.SaveChangesAsync());
}
public void NotifyUser(MessageInputModel message)
{
using (var scope = _serviceProvider.CreateScope())
{
var notificationService = scope.ServiceProvider.GetRequiredService <INotificationService>();
notificationService.NotifyUser(message.FromId, message.ToId, message.Content);
}
}
public IActionResult CreateNewMessage([FromBody] MessageInputModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
return(Ok(_messageAppService.SendMessage(model)));
}
public ResponseViewModel SendMessage(MessageInputModel message)
{
message.SenderId = _userService.GetCurrentLoggedOnUserAsync().Result.Id;
var results = _messageRepository
.CreateMessage(_mapper.Map <MessageInputModel, Message>(message));
return(Ok(_mapper.Map <Message, MessageViewModel>(results)));
}
public IActionResult Index(MessageInputModel input)
{
if (!this.ModelState.IsValid)
{
return(this.View(input));
}
this.mailService.SendEmailAsync(input.AuthorEmail, input.Subject, input.Content);
this.TempData["Message"] = "Your message was sent! We will contact you shortly.";
return(this.RedirectToAction(nameof(this.Index)));
}
public IActionResult InboundCPM(MessageInputModel messageInputModel)
{
if (this.messageParser.ParseInboundCPM(messageInputModel.Message))
{
return(this.RedirectToAction("RegisterFuelForm", "Fuel"));
}
else
{
return(this.RedirectToAction("Index", "Home"));
}
}
public IActionResult SendMessage(MessageInputModel inputModel)
{
if (string.IsNullOrWhiteSpace(inputModel.Message))
{
this.TempData[GlobalConstants.Error] = GlobalConstants.EmptyMessage;
return(RedirectToAction("Profile", "Users", new { username = inputModel.ReceiverName }));
}
this.messageService.SendMessage(inputModel);
return(RedirectToAction("Profile", "Users", new { username = inputModel.ReceiverName }));
}
public IActionResult InboundLDM(MessageInputModel messageInputModel)
{
if (this.ModelState.IsValid)
{
this.messageParser.ParseInboundLDM(messageInputModel.Message);
return(this.RedirectToAction("InboundMessages"));
}
else
{
return(this.RedirectToAction("Index", "Home"));
}
}
public async Task <IActionResult> Contacts(MessageInputModel input)
{
if (!this.ModelState.IsValid)
{
return(await this.Contacts());
}
var messageDto = this.mapper.Map <MessageDto>(input);
await this.messageService.Add(messageDto, this.User.Identity.Name);
return(this.Redirect("/Home/MessageReceived"));
}
public async Task <IActionResult> Add([FromQuery] MessageInputModel model)
{
if (string.IsNullOrWhiteSpace(model.Content) || string.IsNullOrEmpty(model.Content))
{
return(this.Content("Invalid message"));
}
string userId = HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
User user = await this.userService.FindUserById(userId);
Message message = await this.messageService.AddMessage(model.Content, model.ClubId, user);
return(this.Content(user.PictureUrl));
}
public void AddingMessageWithInvalidRoomIdShouldFail()
{
var message = new MessageInputModel()
{
Content = "New message"
};
var httpResponse = this.controller.AddMessage(5, message).ExecuteAsync(new CancellationToken()).Result;
var serverResponse = httpResponse.Content.ReadAsStringAsync().Result;
Assert.AreEqual("{\"Message\":\"Invalid room id\"}", serverResponse);
Assert.AreEqual(HttpStatusCode.BadRequest, httpResponse.StatusCode);
}
public async Task <IActionResult> Send(MessageInputModel input)
{
//var players = this.playersService.GetAllPlayers().Select(x => x.PlayerName);
//if (!string.IsNullOrEmpty(input.ReceiverName))
//{
// players = players.Where(x => x.Contains(input.ReceiverName));
//}
var applicationUserId = this.userManager.GetUserId(this.User);
var userId = this.playersService.GetPlayerId(applicationUserId);
await this.messagesService.SendMessage(input, userId);
return(this.RedirectToAction("Send", "Messages"));
}
public async Task SendMessage(MessageInputModel input, string senderId)
{
var message = new Message
{
SenderId = senderId,
ReceiverId = this.playersRepository.AllAsNoTracking().FirstOrDefault(x => x.PlayerName == input.ReceiverName).Id,
Title = input.Title,
Content = input.Content,
IsRead = false,
SentOn = DateTime.UtcNow,
};
await this.messagesRepository.AddAsync(message);
await this.messagesRepository.SaveChangesAsync();
}
public IActionResult OutboundCPM(MessageInputModel messageInputModel)
{
if (this.ModelState.IsValid)
{
if (this.messageParser.ParseOutboundCPM(messageInputModel.Message))
{
return(this.RedirectToAction("Index", "Home"));
}
else
{
return(this.RedirectToAction("OutboundMessages"));
}
}
return(this.RedirectToAction("OutboundMessages", messageInputModel));
}
public ActionResult SendMessage(MessageInputModel input)
{
var userId = this.User.Identity.GetUserId();
var message = new Message
{
SenderId = userId,
RecipientId = input.RecipientId,
Title = input.Title,
Content = input.Content
};
this.messages.Add(message);
this.messages.SaveChanges();
return(this.RedirectToAction("Index", new { id = message.Id, url = "new" }));
}
public async Task <IActionResult> Index(MessageInputModel input, string captcha)
{
if (!await this.captchaValidator.IsCaptchaPassedAsync(captcha))
{
this.ModelState.AddModelError("captcha", "Captcha validation failed");
}
if (!this.ModelState.IsValid)
{
return(this.View(input));
}
var messageId = await this.contactsService.AddMessageAsync(input);
return(this.RedirectToAction("ThankYou"));
}
public async Task <IActionResult> Update(long id, [FromBody] MessageInputModel inputModel)
{
if (inputModel == null || id != inputModel.Id)
{
return(BadRequest());
}
if (!await MessageService.MessageExistsAsync(id).ConfigureAwait(false))
{
return(NotFound());
}
await MessageService.UpdateMessageAsync(inputModel).ConfigureAwait(false);
return(NoContent());
}
public void SendMessage(MessageInputModel inputModel)
{
var sender = this.UserManager.FindByNameAsync(inputModel.SenderName).GetAwaiter().GetResult();
var receiver = this.UserManager.FindByNameAsync(inputModel.ReceiverName).GetAwaiter().GetResult();
var message = new Message
{
IsReaded = false,
SendOn = inputModel.SendDate,
Text = inputModel.Message,
ReceiverId = receiver.Id,
SenderId = sender.Id
};
this.Context.Messages.Add(message);
this.Context.SaveChanges();
}
public async Task <MessageViewModel> CreateAsync(MessageInputModel messageCreateInputModel)
{
var message = new Message
{
UserId = messageCreateInputModel.UserId,
UserName = messageCreateInputModel.UserName,
Content = messageCreateInputModel.Content,
};
await this.messagesRepository.AddAsync(message);
await this.messagesRepository.SaveChangesAsync();
var viewModel = await this.GetViewModelByIdAsync <MessageViewModel>(message.Id);
return(viewModel);
}
public async Task <ContactsChatMessage> AddMessages(MessageInputModel inputModel)
{
var newMessage = new ContactsChatMessage
{
SenderId = inputModel.SenderId,
ReceiverId = inputModel.ReceiverId,
SentOn = inputModel.SentOn,
Text = inputModel.Message,
HasBeenSeen = false
};
await this.context.ContactsChatMessages.AddAsync(newMessage);
await this.context.SaveChangesAsync();
return(newMessage);
}
public async Task <string> AddMessageAsync(MessageInputModel input)
{
var newMessage = new Message
{
FirstName = this.sanitizer.Sanitize(input.FirstName),
LastName = this.sanitizer.Sanitize(input.LastName),
Email = this.sanitizer.Sanitize(input.Email),
About = this.sanitizer.Sanitize(input.About),
Description = this.sanitizer.Sanitize(input.Description),
};
await this.dbMessage.AddAsync(newMessage);
await this.dbMessage.SaveChangesAsync();
return(newMessage.Id);
}
public ActionResult SendMessage(MessageInputModel model)
{
if (this.ModelState.IsValid && this.ModelState != null)
{
var message = new Message()
{
Content = model.Content,
CreatedOn = DateTime.Now,
Reciever = this.Data.Users.All().FirstOrDefault(u=>u.Id==model.RecieverId),
Sender = this.Data.Users.All().FirstOrDefault(u => u.Id == model.SenderId)
};
this.Data.Messages.Add(message);
this.Data.SaveChanges();
}
return View(model);
}
public IHttpActionResult AddMessage(int roomId,
MessageInputModel messageModel)
{
if (!this.ModelState.IsValid)
{
return this.BadRequest("Invalid input model");
}
var room = GetRoomById(roomId) ?? GetPrivateRoomById(roomId);
if (room == null)
{
return this.BadRequest("Invalid room id");
}
var userId = this.userIdProvider.GetUserId();
var sender = this.data.Users.All()
.FirstOrDefault(u => u.Id == userId);
if (sender == null)
{
return this.BadRequest("Invalid sender Id");
}
Message message = new Message()
{
RoomId = roomId,
Room = room,
Content = messageModel.Content,
Date = DateTime.Now,
SenderId = userId
};
this.data.Messages.Add(message);
this.data.SaveChanges();
return this.Ok("Message created successfully");
}
public void AddingMessageShouldAddMessage()
{
var message = new MessageInputModel()
{
Content = "New message"
};
var expectedMessage = new MessageOutputModel()
{
Content = "New message",
Date = DateTime.Now,
Id = 4,
RoomId = 1,
SenderId = MeetyChatDataMock.MockUserId
};
var httpResponse = this.controller.AddMessage(1, message).ExecuteAsync(new CancellationToken()).Result;
var serverResponse = httpResponse.Content.ReadAsStringAsync().Result;
Assert.AreEqual(serverResponse, "\"Message created successfully\"");
Assert.AreEqual(expectedMessage.Content, this.unitOfWorkMock.Messages.All().Last().Content);
}
