public async Task <ActionResult <MessageDTO> > CreateMessage(CreateMessageDTO createMessg)
{
var userName = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
if (userName == createMessg.recipientUsername.ToLower())
{
return(BadRequest("Can not send message to yourself"));
}
var sender = await userRepository.GetUserByNameAsync(userName);
var recipient = await userRepository.GetUserByNameAsync(createMessg.recipientUsername);
if (recipient == null)
{
return(NotFound("Could not find the user"));
}
var messg = new Message
{
sender = sender,
recipient = recipient,
content = createMessg.content
};
messageRepository.AddMessage(messg);
if (await messageRepository.SaveAllAsync())
{
return(Ok(this.mapper.Map <MessageDTO>(messg)));
}
return(BadRequest("Could not send the message"));
}
public async Task <ActionResult <MessageDTO> > AddMessage(CreateMessageDTO message)
{
var sendUserName = User.GetUserName();
if (sendUserName == message.RecipientUserName)
{
return(BadRequest("Not allowed to send message to yourself"));
}
var sender = await _mainRespositories.AppUserRespository.GetUserByUserNameAsync(sendUserName);
var recipient = await _mainRespositories.AppUserRespository.GetUserByUserNameAsync(message.RecipientUserName);
if (recipient == null)
{
return(NotFound());
}
var newMsg = new Message
{
SenderId = sender.Id,
SenderUserName = sender.UserName,
RecipientId = recipient.Id,
RecipientUserName = recipient.UserName,
Content = message.Content
};
await _mainRespositories.MessageRepository.AddMessage(newMsg);
if (await _mainRespositories.Complete())
{
return(Ok(_mapper.Map <MessageDTO>(newMsg)));
}
return(BadRequest("Fail to send message"));
}
public async Task <ActionResult <MessageDTO> > AddMessage(CreateMessageDTO createMessageDTO)
{
var senderUsername = User.GetUsername();
var sender = await _userRepository.GetUserByUsernameAsync(senderUsername);
var recipient = await _userRepository.GetUserByUsernameAsync(createMessageDTO.RecipientUsername);
if (senderUsername == createMessageDTO.RecipientUsername)
{
return(BadRequest("You can't send a message to yourself"));
}
if (recipient == null)
{
return(NotFound());
}
var message = new Message()
{
Sender = sender,
SenderUsername = sender.UserName,
Recipient = recipient,
RecipientUsername = recipient.UserName,
Content = createMessageDTO.Content
};
_messageRepository.AddMessage(message);
if (await _messageRepository.SaveAllAsync())
{
return(Ok(_mapper.Map <MessageDTO>(message)));
}
return(BadRequest("An error occurred sending the message"));
}
public async Task <ActionResult <MessageDTO> > CreateMessage(CreateMessageDTO createMessageDTO)
{
var username = User.GetUsername();
if (username == createMessageDTO.ReceiverUsername.ToLower())
{
return(BadRequest("Not able to send message to itself."));
}
var sender = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username);
var receiver = await _unitOfWork.UserRepository.GetUserByUsernameAsync(createMessageDTO.ReceiverUsername);
if (receiver == null)
{
return(NotFound("Recipient not found"));
}
var message = new Message
{
Sender = sender,
SenderUsername = sender.UserName,
Receiver = receiver,
ReceiverUsername = receiver.UserName,
Content = createMessageDTO.Content
};
_unitOfWork.MessageRepository.AddMessage(message);
if (await _unitOfWork.Complete())
{
return(Ok(_mapper.Map <MessageDTO>(message))); // Return mapped MessageDTO from message
}
return(BadRequest("Failed to create the message!"));
}
public async Task <ActionResult <MessageDTO> > CreateMessage(CreateMessageDTO createMessageDTO)
{
var username = User.GetUserName();
if (username == createMessageDTO.RecipientUserName.ToLower())
{
return(BadRequest("You can not send message to yourself"));
}
var sender = await _userRepository.GetUserByUsernameAsync(username);
var recipient = await _userRepository.GetUserByUsernameAsync(createMessageDTO.RecipientUserName);
if (recipient == null)
{
return(NotFound());
}
var message = new Message
{
Sender = sender,
Recipient = recipient,
SenderUserName = sender.UserName,
RecipientUserName = recipient.UserName,
Content = createMessageDTO.Content
};
_messageRepository.AddMessage(message);
if (await _messageRepository.SaveAllAsync())
{
return(Ok(_mapper.Map <MessageDTO>(message)));
}
return(BadRequest("Failed to send message"));
}
public async Task <ActionResult <MessageDTO> > Create(Guid channelId, [FromBody] CreateMessageDTO model)
{
//1)Channel laden via de channelrepository op basis van de channelId
var channel = channelRepository.GetById(channelId);
//2)Valideren currentUser rechten heeft om messages te posten (Utility helper function)
//3)Indien true, message.FromCreateMessageDTO(channel,model);
var message = uMessageAPI.Models.Message.FromCreateMessageDTO(channel, model, await GetCurrentUserAsync());
//message.ChannelId = channelId;
// Check whether the current channel was resolved.
//if ( message.ChannelId == channelId) {
// Create message and assign a name.
await hubContext.Clients.All.BroadcastMessage(message.Text);
messageRepository.Add(message);
messageRepository.SaveChanges();
//}
// Check whether the channel was successfully created.
if (message != null)
{
// Generate the channel response for given channel.
return(Ok(MessageDTO.FromMessage(message)));
}
return(NotFound());
}
public async Task SendMessage(CreateMessageDTO createMessageDTO)
{
var username = Context.User.GetUsername();
if (username == createMessageDTO.RecipientUsername.ToLower())
{
throw new HubException("You cannot message yourself");
}
var sender = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username);
var recipient = await _unitOfWork.UserRepository.GetUserByUsernameAsync(createMessageDTO.RecipientUsername.ToLower());
if (recipient == null)
{
throw new HubException("User not found");
}
var message = new Message
{
SenderId = sender.Id,
SenderUsername = sender.UserName,
RecipientId = recipient.Id,
RecipientUsername = recipient.UserName,
Content = createMessageDTO.Content
};
var groupName = GetGroupName(sender.UserName, recipient.UserName);
var group = await _unitOfWork.MessagesRepository.GetMessageGroup(groupName);
if (group.Connections.Any(connection => connection.Username == recipient.UserName))
{
message.DateRead = DateTime.UtcNow;
}
else
{
var connections = await _presenceTracker.GetConnectionsForUser(recipient.UserName);
if (connections != null)
{
await _presenceHubContext.Clients.Clients(connections).SendAsync("NewMessageReceived", new
{
username = sender.UserName,
knownAs = sender.KnownAs
});
}
}
_unitOfWork.MessagesRepository.AddMessage(message);
if (await _unitOfWork.Complete())
{
await Clients.Group(groupName).SendAsync("NewMessage", _mapper.Map <MessageDTO>(message));
}
else
{
throw new HubException("Failed to save message");
}
}
public async Task <MessageDTO> Create(CreateMessageDTO dto, CancellationToken cancel)
{
var message = await _repository.Create(dto.ToEntity(), cancel);
await _hubContext.Clients.Group(dto.RoomId.ToString()).SendAsync("MessageSent", message);
return(message.ToDTO());
}
public static Message FromCreateMessageDTO(Channel channel, CreateMessageDTO model, User user)
{
var currentTime = DateTime.Now;
// Create a channel object based on the model and current time.
return(new Message {
Channel = channel, Text = model.Text, Created = currentTime, Modified = currentTime, User = user
});
}
public IHttpActionResult CreateMessage(CreateMessageDTO createMessageDTO)
{
try
{
service.CreateMessage(createMessageDTO);
return(Ok());
}
catch (Exception)
{
return(InternalServerError());
}
}
public async Task SendMessage(CreateMessageDTO createMessageDTO)
{
var username = Context.User.GetUserName();
if (username == createMessageDTO.RecipientUserName.ToLower())
{
throw new HubException("You cannot send messages to yourself");
}
var sender = await _unitOfWork.UserRepository.GetUsersByUserNameAsync(username);
var recipient = await _unitOfWork.UserRepository.GetUsersByUserNameAsync(createMessageDTO.RecipientUserName);
if (recipient == null)
{
throw new HubException("Not found User");
}
var message = new Message
{
Sender = sender,
Recipient = recipient,
SenderUserName = sender.UserName,
RecipientUserName = recipient.UserName,
Content = createMessageDTO.Content
};
var groupName = GetGroupName(sender.UserName, recipient.UserName);
var group = await _unitOfWork.MessageRepository.GetMessageGroup(groupName);
if (group.Connections.Any(x => x.Username == recipient.UserName))
{
message.DateRead = DateTime.UtcNow;
}
else
{
//When user is online but not on message screen. it pops new message arrived
var connections = await _presenceTracker.GetConnectionsForUser(recipient.UserName);
if (connections != null)
{
await _presenceHub.Clients.Clients(connections).SendAsync("NewMessageReceived",
new { username = sender.UserName, knownAs = sender.KnownAs });
}
}
_unitOfWork.MessageRepository.AddMessage(message);
if (await _unitOfWork.Complete())
{
await Clients.Group(groupName).SendAsync("NewMessage", _mapper.Map <MessageDTO>(message));
}
}
public async Task SendMessage(CreateMessageDTO createMessageDTO)
{
var username = Context.User.GetUsername();
if (username == createMessageDTO.RecipientUserName.ToLower())
{
throw new HubException("You cannot send messages to yourself");
}
var sender = await _userRepository.GetUserByUsernameAsync(username);
var recipient = await _userRepository.GetUserByUsernameAsync(createMessageDTO.RecipientUserName);
if (recipient == null)
{
throw new Exception("Not Found User");
}
var message = new Message
{
Sender = sender,
Recipient = recipient,
Content = createMessageDTO.Content,
SenderUserName = username,
RecipientUserName = recipient.UserName
};
var groupName = GetGroupName(sender.UserName, recipient.UserName);
var group = await _messageRepository.GetMessageGroup(groupName);
if (group.Connections.Any(x => x.Username == recipient.UserName))
{
message.DateRead = DateTime.UtcNow;
}
else
{
var connections = await _tracker.GetConnectionsForUser(recipient.UserName);
if (connections != null)
{
await _presenceHub.Clients.Clients(connections).SendAsync("NewMessageReceived",
new { username = sender.UserName, knownAs = sender.KnownAs });
}
}
_messageRepository.AddMessage(message);
if (await _messageRepository.SaveAllAsync())
{
//var group = GetGroupName(sender.UserName, recipient.UserName);
await Clients.Group(groupName).SendAsync("NewMessage", _mapper.Map <MessageDTO>(message));
}
}
public async Task AddMessage(CreateMessageDTO message)
{
var sendUserName = Context.User.GetUserName();
if (sendUserName == message.RecipientUserName)
{
throw new HubException("Not allowed to send message to yourself");
}
var sender = await _mainRespositores.AppUserRespository.GetUserByUserNameAsync(sendUserName);
var recipient = await _mainRespositores.AppUserRespository.GetUserByUserNameAsync(message.RecipientUserName);
if (recipient == null)
{
new HubException("Receipient is not found");
}
var groupname = this.GetGroupName(sender.UserName, recipient.UserName);
var msgGroup = await _mainRespositores.MessageRepository.GetMessageGroup(groupname);
var newMsg = new Message
{
SenderId = sender.Id,
SenderUserName = sender.UserName,
RecipientId = recipient.Id,
RecipientUserName = recipient.UserName,
Content = message.Content
};
if (msgGroup.Connections.Any(x => x.Username == message.RecipientUserName))
{
newMsg.DateRead = DateTime.UtcNow;
}
else
{
await NotifyNewMsg(recipient.UserName, sender);
}
await _mainRespositores.MessageRepository.AddMessage(newMsg);
if (await _mainRespositores.Complete())
{
await Clients.Group(groupname).SendAsync("NewMessage", _mapper.Map <MessageDTO>(newMsg));
}
else
{
throw new HubException("Fail to send message");
}
}
public async Task CreateAsync(CreateMessageDTO message)
{
var messageEntity = new Message
{
Topic = message.Topic,
Content = message.Content,
AutopartId = message.AutopartId,
ReceiverId = message.ReceiverId,
SenderId = message.SenderId,
};
await this.messagesRepository.AddAsync(messageEntity);
await this.messagesRepository.SaveChangesAsync();
}
public static Message ToEntity(this CreateMessageDTO dto)
{
if (dto == null)
{
return(null);
}
return(new Message
{
Id = Guid.NewGuid(),
Content = dto.Content,
Date = DateTime.Now,
RoomId = dto.RoomId,
UserId = dto.UserId,
RepliedMessageContent = dto.RepliedMessageContent
});
}
public async Task MessageCreate_HappyPath()
{
var dto = new CreateMessageDTO
{
Content = "Hello",
RoomId = StaticData.PublicRoomId,
UserId = StaticData.TestUserId
};
var message = await _handler.Create(dto, CancellationToken.None);
Assert.IsNotNull(message);
var dataFromDb = await Context.Messages.SingleAsync(x => x.Id == message.Id);
Assert.AreEqual(dataFromDb.Content, dto.Content);
await DeleteDatabase();
}
private ICreateMessageDTO GetPublishMessageBody(IPublishMessageParameters parameters)
{
var createMessageDTO = new CreateMessageDTO
{
MessageEvent = new MessageEventDTO
{
Type = EventType.MessageCreate,
CreatedAt = new DateTimeOffset(2000, 11, 22, 0, 0, 0, TimeSpan.Zero),
MessageCreate = new MessageCreateDTO
{
Target = new MessageCreateTargetDTO
{
RecipientId = parameters.RecipientId
},
MessageData = new MessageDataDTO
{
Text = parameters.Text
}
},
}
};
// If there is media attached, include it
if (parameters.MediaId != null)
{
createMessageDTO.MessageEvent.MessageCreate.MessageData.Attachment = new AttachmentDTO
{
Type = AttachmentType.Media,
Media = new MediaEntity {
Id = parameters.MediaId
}
};
}
// If there are quick reply options, include them
if (parameters.QuickReplyOptions != null && parameters.QuickReplyOptions.Length > 0)
{
createMessageDTO.MessageEvent.MessageCreate.MessageData.QuickReply = new QuickReplyDTO
{
Type = QuickReplyType.Options,
Options = parameters.QuickReplyOptions,
};
}
return(createMessageDTO);
}
public void CreateMessage(CreateMessageDTO createMessageDTO)
{
var updatedDialog = db.Dialogs.FirstOrDefault(d => d.DialogId == createMessageDTO.DialogId);
updatedDialog.LastMessageText = createMessageDTO.Text;
updatedDialog.LastMessageCreatedAt = createMessageDTO.CreatedAt;
var messageToBeAdded = new Message
{
CreatedAt = createMessageDTO.CreatedAt,
AuthorId = createMessageDTO.AuthorId,
DialogId = createMessageDTO.DialogId,
Text = createMessageDTO.Text
};
Db.Messages.Add(messageToBeAdded);
Db.SaveChanges();
}
public async Task MessageDelete_HappyPath()
{
var dto = new CreateMessageDTO
{
Content = "Hello",
RoomId = StaticData.PublicRoomId,
UserId = StaticData.TestUserId
};
var message = await _handler.Create(dto, CancellationToken.None);
await _handler.Delete(new Guid[] { message.Id }, false, CancellationToken.None);
var dataFromDb = await Context.Messages.ToListAsync();
Assert.AreEqual(dataFromDb.Count, 0);
await DeleteDatabase();
}
public async Task NewMessage(CreateMessageDTO request)
{
if (!usersConnectedToChat.TryGetValue(Context.ConnectionId, out int connectedUserId))
{
Context.Abort();
}
if (!string.IsNullOrWhiteSpace(request.Message) || !string.IsNullOrWhiteSpace(request.MediaUrl))
{
using (var scope = _serviceProvider.CreateScope())
{
var handler = scope.ServiceProvider.GetService <IHandlerHub <CreateMessageDTO, ObjectResult> >();
var objectResult = await handler.Handle(request, connectedUserId);
MessageDTO messageAdded = (MessageDTO)objectResult.Value;
await Clients.Group(messageAdded.DiscussionId.ToString()).SendAsync("messageReceived", messageAdded);
}
}
}
public async Task MessageGet()
{
var dto = new CreateMessageDTO
{
Content = "Hello",
RoomId = StaticData.PublicRoomId,
UserId = StaticData.TestUserId
};
var message = await _handler.Create(dto, CancellationToken.None);
var messages = await _handler.GetAllByRoom(message.RoomId, CancellationToken.None);
Assert.AreEqual(1, messages.Count);
messages = await _handler.Get(message.RoomId, DateTime.Now, 20, CancellationToken.None);
Assert.AreEqual(1, messages.Count);
await DeleteDatabase();
}
public async Task <IActionResult> Add(CreateMessageInputModel input)
{
if (!this.ModelState.IsValid)
{
return(this.View(input));
}
var currentUserId = this.User.FindFirst(ClaimTypes.NameIdentifier).Value;
var receiver = this.usersService.GetByUsername <UsersListItemViewModel>(input.ReceiverUsername);
var message = new CreateMessageDTO
{
Topic = input.Topic,
Content = input.Content,
AutopartId = input.AutopartId,
SenderId = currentUserId,
ReceiverId = receiver.Id,
};
await this.messagesService.CreateAsync(message);
return(this.Redirect("/"));
}
public async Task <ActionResult <MessageDTO> > CreateMessage(CreateMessageDTO createMessageDTO)
{
var username = User.GetUsername();
if (username == createMessageDTO.RecipientUsername.ToLower())
{
return(BadRequest("You cannot message yourself"));
}
var sender = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username);
var recipient = await _unitOfWork.UserRepository.GetUserByUsernameAsync(createMessageDTO.RecipientUsername.ToLower());
if (recipient == null)
{
return(NotFound());
}
var message = new Message
{
SenderId = sender.Id,
SenderUsername = sender.UserName,
RecipientId = recipient.Id,
RecipientUsername = recipient.UserName,
Content = createMessageDTO.Content
};
_unitOfWork.MessagesRepository.AddMessage(message);
if (await _unitOfWork.Complete())
{
return(Ok(_mapper.Map <MessageDTO>(message)));
}
return(BadRequest("Failed to save message"));
}
public bool CreateMessage(CreateMessageDTO createMessageDTO)
{
var message = _mapper.Map <CreateMessageDTO, Message>(createMessageDTO);
return(Database.MessageRepository.CreateMessage(message));
}
public async Task <IActionResult> Create([FromBody] CreateMessageDTO dto)
{
var message = await _handler.Create(dto, HttpContext.RequestAborted);
return(Ok(message));
}
public void CreateMessage(CreateMessageDTO createMessageDTO)
{
MessagesLogic.CreateMessage(createMessageDTO);
}
