/* * Send the message via the hub */ public async Task SendMessage(CreateMessageDto createMessageDto) { // get username var username = Context.User.GetUsername(); if (username == createMessageDto.RecipientUsername.ToLower()) { throw new HubException("You cannot send messages to yourself"); } // get hold of both of our users var sender = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username); var recipient = await _unitOfWork.UserRepository.GetUserByUsernameAsync(createMessageDto.RecipientUsername); if (recipient == null) { throw new HubException("User not found"); } // create the new message var message = new Message { Sender = sender, Recipient = recipient, SenderUsername = sender.UserName, RecipientUsername = recipient.UserName, Content = createMessageDto.Content }; // get the group name 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 { var connections = await _tracker.GetConnectionsForUser(recipient.UserName); if (connections != null) { // so the user is online but not inside the particular message thread await _presenceHub.Clients .Clients(connections) .SendAsync("NewMessageReceived", new { username = sender.UserName, knownAs = sender.KnownAs }); } } _unitOfWork.MessageRepository.AddMessage(message); if (await _unitOfWork.Complete()) { // send the message as new message await Clients.Group(groupName).SendAsync("NewMessage", _mapper.Map <MessageDto>(message)); } }
/// <summary> /// Primary method for sending a message using the Signal R Hub. /// Invoked client-side with 'this.hubConnection.invoke('SendMessage', {recipientUsername: username, content})' /// </summary> 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.GetUserByUsernameAsync(username); var recipient = await _unitOfWork.UserRepository.GetUserByUsernameAsync(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 }; // get the signal r group name var groupName = GetGroupName(sender.UserName, recipient.UserName); // get the group from the group name. var group = await _unitOfWork.MessageRepository.GetMessageGroup(groupName); // if there are any connections in the group where the username is the same as the recipient name // (aka, the recipient of the message is connected to the app and logged in, // update the DateRead for that message as well, since they are actively accessing the message) if (group.Connections.Any(x => x.Username == recipient.UserName)) { message.DateRead = DateTime.UtcNow; } else { // if the user is online but not connected to the same message group hub (somewhere else in the app), // then we want this to eventually send them a notification. var connections = await _tracker.GetConnectionsForUser(recipient.UserName); if (connections != null) { await _presenceHub.Clients.Clients(connections).SendAsync("NewMessageReceived", new { username = sender.UserName, firstName = sender.FirstName }); } } _unitOfWork.MessageRepository.AddMessage(message); // after done saving to the db, send the new message asynchronously to the group 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 can't create messsage to yourself."); } var sender = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username); var recipient = await _unitOfWork.UserRepository.GetUserByUsernameAsync(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 users are in the same group 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 } ); } } _unitOfWork.MessageRepository.AddMessage(message); if (await _unitOfWork.Complete()) { // send new message from hub to client 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 messsages to yourself"); } var sender = await _userRepository.GetUserByUsername(username); var recipient = await _userRepository.GetUserByUsername(createMessageDto.RecipientUsername); if (recipient == null) { throw new HubException("User not found"); } 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 _messageRepository.GetMessageGroup(groupName); if (group.Connection.Any(x => x.Username == recipient.UserName)) { message.DateRead = DateTime.UtcNow; } else { var connections = await _presenceTracker.GetConnectionsForUser(recipient.UserName); if (connections != null) { await _presenceHub.Clients.Clients(connections).SendAsync("NewMessageReceived", new { username = sender.UserName, knownAs = sender.KnownAs }); } // var connections = await _presenceTracker.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()) { 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"); } //return BadRequest("You cannot send messages to yourself"); var sender = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username); var recipient = await _unitOfWork.UserRepository.GetUserByUsernameAsync(createMessageDto.RecipientUsername); if (recipient == null) { throw new HubException("Not found user"); } //return NotFound(); 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 { var connections = await _tracker.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.Completed()) { await Clients.Group(groupName).SendAsync("NewMessage", _mapper.Map <MessageDto>(message)); //return Ok(_mapper.Map<MessageDto>(message)); } // return BadRequest("Failed to send message"); }
public async Task SendMessage(CreateMessageDto createMessageDto) { string username = Context.User.GetUsername(); if (username == createMessageDto.ReceiverUsername.ToLower()) { throw new HubException("You cannot send messages to yourself"); } var sender = await _unitOfWork.UserRepository.GetUserAsync(username); var receiver = await _unitOfWork.UserRepository .GetUserAsync(createMessageDto.ReceiverUsername); if (receiver == null) { throw new HubException("User Not Found"); } var message = new Message { Sender = sender, Receiver = receiver, SenderUsername = sender.UserName, ReceiverUsername = receiver.UserName, Content = createMessageDto.Content }; var groupName = GetGroupName(sender.UserName, receiver.UserName); var group = await _unitOfWork.MessageRepository.GetMessageGroup(groupName); if (group.Connections.Any(x => x.Username == receiver.UserName)) { message.DateRead = DateTime.UtcNow; } else { var connections = await _tracker.GetConnectionsForUser(receiver.UserName); if (connections != null) { string messagePreview = message.Content.Length < 21 ? message.Content : $"{message.Content.Substring(0, 21).Trim()}..."; await _presenceHub.Clients.Clients(connections).SendAsync("NewMessageReceived", new { username = sender.UserName, knownAs = sender.KnownAs, messagePreview = messagePreview }); } } _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()) { //we cannot send bad request because its a hub and not an http request. throw new HubException("You cannot send messages to yourself"); } var sender = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username); var recipient = await _unitOfWork.UserRepository.GetUserByUsernameAsync(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); //mark messages as read if the message recipient username = username if (group.Connections.Any(x => x.Username == recipient.UserName)) { message.DateRead = DateTime.UtcNow; } else { //if we have unread messages the get the connected devices of user (onnections from hub) ans send to all the NewMessageReceived hub message and //an anonymous object that contains the sender username and known as var connections = await _tracker.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 _unitOfWork.UserRepository.GetUserByUserNameAsync(username); var recipient = await _unitOfWork.UserRepository.GetUserByUserNameAsync(createMessageDto.RecipientUserName); if (recipient == null) { throw new HubException("User not found"); } 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.GetGroup(groupName); if (group.Connections.Any(c => c.UserName == recipient.UserName)) { message.DateRead = DateTime.UtcNow; } // push a notification if receiving user is not in chat room: else { 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 cann't send a message to yourself"); } var sender = await _unitOfWork.UserRepository.GetUserByUserNameAsync(username); var recipient = await _unitOfWork.UserRepository.GetUserByUserNameAsync(createMessageDto.RecipientUsername.ToLower()); if (recipient == null) { throw new HubException("Recipient not found"); } 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(a => a.Username == createMessageDto.RecipientUsername)) { 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 }); } } message.DateRead = null; _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("Você não pode enviar mensagens para si mesmo"); } var sender = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username); //remetente var recipient = await _unitOfWork.UserRepository.GetUserByUsernameAsync(createMessageDto.RecipientUserName); //destinatario if (recipient == null) { throw new HubException("Usuário não encontrado"); } 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 { var connections = await _tracker.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 void SendMessage(CreateMessageDto createMessageDto) { var userId = Context.User.GetUserId(); if (userId == createMessageDto.RecipientId) { throw new HubException("You cannot send messages to yourself"); } var sender = await _unitOfWork.MemberRepository.GetUserByIdAsync(userId); var recipient = await _unitOfWork.MemberRepository.GetUserByIdAsync(createMessageDto.RecipientId); if (recipient == null) { throw new HubException("Not found user"); } var message = new MemberMessage { Sender = sender, Recipient = recipient, SenderId = sender.Id, RecipientId = recipient.Id, Content = createMessageDto.Content }; var groupName = GetGroupName(sender.Id, recipient.Id); var group = await _unitOfWork.MemberMessageRepository.GetMessageGroupAsync(groupName); if (group.Connections.Any(x => x.RecipientId == recipient.Id)) { message.DateRead = DateTime.UtcNow; } else { var connections = await _tracker.GetConnectionsForUser(recipient.Id); if (connections != null) { await _presenceHub.Clients.Clients(connections).SendAsync("NewMessageReceived", new { memberId = sender.Id, firstName = sender.FirstName }); } } _unitOfWork.MemberMessageRepository.AddMessage(message); if (await _unitOfWork.CompleteAsync()) { await Clients.Group(groupName).SendAsync("NewMessage", _mapper.Map <MemberMessageDto>(message)); } }
public async Task SendMessage(CreateMessageDto createMessageDto) { string username = Context.User.GetUsername(); if (username.ToLower() == createMessageDto.RecipientUsername.ToLower()) { throw new HubException("You cannot send messages to yourself"); } AppUser sender = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username); AppUser recipient = await _unitOfWork.UserRepository.GetUserByUsernameAsync(createMessageDto.RecipientUsername); if (recipient == null) { throw new HubException("User not found"); } Message message = new Message { Sender = sender, Recipient = recipient, SenderUsername = sender.UserName, RecipientUsername = recipient.UserName, Content = createMessageDto.Content }; string groupName = GetGroupName(sender.UserName, recipient.UserName); Group group = await _unitOfWork.MessageRepository.GetMessageGroup(groupName); if (group.Connections.Any(user => user.Username == recipient.UserName)) { message.DateRead = DateTime.UtcNow; } else { List <string> connections = await _tracker.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)); } }
// sending message via hub public async Task SendMessage(CreateMessageDto createMessageDto) { var username = Context.User.GetUsername(); if (username == createMessageDto.RecipientUsername.ToLower()) { throw new HubException("You cannot send message to yourself"); } var sender = await _unitOfWork.UserRepository.GetUserByUserName(username); var recipient = await _unitOfWork.UserRepository.GetUserByUserName(createMessageDto.RecipientUsername); if (recipient == null) { throw new HubException("Not found user"); } var message = new Message { Sender = sender, Recipent = recipient, SenderUsername = sender.UserName, RecipentUsername = recipient.UserName, Content = createMessageDto.Content }; var groupName = GetGroupName(sender.UserName, recipient.UserName); var group = await _unitOfWork.MessageRepository.GetMessageGroup(groupName); // to update the date read to now if the user is connected to this specific hub so it wont be marked as "Unread" if (group.Connections.Any(x => x.Username == recipient.UserName)) { message.DateRead = DateTime.UtcNow; } else { var connections = await _presenceTracker.GetConnectionsForUser(recipient.UserName); // if there are any connections, we know the recipient is online but not in the same message group 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) // this code block copied over from MessagesController.cs { var username = Context.User.GetUsername(); if (username == createMessageDto.RecipientUsername.ToLower()) { throw new HubException("You cannot send messages to yourself"); } var sender = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username); // sender // next we get hold of users in sender and recipient // we need to populate the message when we create it and go the other way when we return a DTO from this var recipient = await _unitOfWork.UserRepository.GetUserByUsernameAsync(createMessageDto.RecipientUsername); if (recipient == null) { throw new HubException("Not Found User"); } var message = new Message // at this stage we know we are redy to create a 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 { var connections = await _tracker.GetConnectionsForUser(recipient.UserName); if (connections != null) { // if the user is online and not connected to the same group ¬ await _presenceHub.Clients.Clients(connections).SendAsync("NewMessageReceived", new { username = sender.UserName, knownAs = sender.KnownAs }); // { } represents an anonymous object } } _unitOfWork.MessageRepository.AddMessage(message); // method that adds our message if (await _unitOfWork.Complete()) { // var group = GetGroupName(sender.UserName, recipient.UserName); await Clients.Group(groupName).SendAsync("NewMessage", _mapper.Map <MessageDto>(message)); // maps from the message we have created // we receive a message from our client // we need to update our message hub thread variable to update when a message is received // return BadRequest("Failed to send message"); // not required as we are not returning from this } }
public async Task SendMessage(CreateMessageDTO createMessageDTO) { var userName = Context.User.GetUserName(); if (userName.Equals(createMessageDTO.RecipientUserName.ToLower())) { throw new HubException("You can't send a message to yourself"); } var sender = await _userRepository.GetUserByUserNameAsync(userName); var recipient = await _userRepository.GetUserByUserNameAsync(createMessageDTO.RecipientUserName.ToLower()); if (recipient == null) { throw new HubException("User not found"); } var message = new Message { Content = createMessageDTO.Content, Recipient = recipient, RecipientUserName = recipient.UserName, Sender = sender, SenderUserName = sender.UserName }; var groupName = GetGroupName(sender.UserName, recipient.UserName); var group = await _messageRepository.GetMessageGroup(groupName); if (group.Connections.Any(c => c.UserName.Equals(recipient.UserName))) { message.MessageRead = 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()) { 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 _context.Users .Include(c => c.Doctor) .Include(c => c.Pacient) .FirstOrDefaultAsync(c => c.UserName == username); var recipient = await _context.Users .Include(c => c.Doctor) .Include(c => c.Pacient) .FirstOrDefaultAsync(c => c.UserName == createMessageDto.RecipientUsername); if (recipient == null) { throw new HubException("User Not Found!"); } var message = new Message { Sender = sender, Recipient = recipient, SenderUsername = sender.UserName, RecipientUsername = recipient.UserName, Content = createMessageDto.Content, MessageSent = DateTime.UtcNow }; var groupName = GetGroupName(sender.UserName, recipient.UserName); var group = await _messageRepository.GetMessageGroup(groupName); if (group.Connections.Any(c => c.Username == recipient.UserName)) { message.DateRead = DateTime.UtcNow; } else { var connections = await _presenceTracker.GetConnectionsForUser(recipient.UserName); if (connections != null) { await _presenceHub.Clients.Clients(connections).SendAsync("NewMessageNotification", new { username = sender.UserName, name = sender.Doctor != null ? "Dr. " + sender.Doctor.FirstName + " " + sender.Doctor.SecondName : sender.Pacient.FirstName + " " + sender.Pacient.SecondName }); } } _messageRepository.AddMessage(message); if (await _messageRepository.SaveAllAsync()) { await Clients.Group(groupName).SendAsync("NewMessage", _mapper.Map <MessageDto>(message)); } else { throw new HubException("Failed to send 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 _unitOfWork.UserRepository.GetUserByUsernameAsync(username); var recipient = await _unitOfWork.UserRepository.GetUserByUsernameAsync(createMessageDto.RecipientUsername); if (recipient == null) { throw new HubException("Not found user"); } var message = new Message { Sender = sender, Recipient = recipient, SenderCollege = sender.College, SenderUsername = sender.UserName, SenderFirstName = sender.FirstName, SenderCompany = sender.Company, RecipientUsername = recipient.UserName, RecipientFirstName = recipient.FirstName, RecipientCompany = recipient.Company, RecipientCollege = recipient.College, Content = createMessageDto.Content, SenderAppUserType = sender.AppUserType, RecipientAppUserType = recipient.AppUserType }; 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 { var connections = await _tracker.GetConnectionsForUser(recipient.UserName); if (connections != null) { await _presenceHub.Clients.Clients(connections).SendAsync("NewMessageReceived", new { username = sender.UserName, firstName = sender.FirstName }); } } _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 currentUsername = Context.User.GetUsername(); if (currentUsername == createMessageDto.RecipientUsername.ToLower()) { throw new HubException("You cannot send message to yourself!"); } // 1. transfer CreateMessageDto to Message var currentUser = await _unitOfWork.UserRepository.GetUserByUsernameAsync(currentUsername); var recipientUser = await _unitOfWork.UserRepository.GetUserByUsernameAsync(createMessageDto.RecipientUsername.ToLower()); if (recipientUser == null) { throw new HubException("Not found user"); } var message = new Message { SenderUsername = currentUsername, Sender = currentUser, RecipientUsername = recipientUser.UserName, Recipient = recipientUser, Content = createMessageDto.Content, }; #region if recipient is connected to current group in hub, mark as read var groupName = GetGroupName(currentUser.UserName, recipientUser.UserName); var group = await _unitOfWork.MessageRepository.GetGroupAsync(groupName); if (group.Connections.Any(conn => conn.Username == recipientUser.UserName)) { message.DateTimeRead = DateTime.UtcNow; } else { var connections = await _tracker.GetConnectionsForUser(recipientUser.UserName); if (connections != null) { await _presenceHub.Clients.Clients(connections) .SendAsync( "NewMessageReceived", new { username = currentUser.UserName, knownAs = currentUser.KnownAs } ); } } #endregion // 2. Save transferred Message to MessageRepo _unitOfWork.MessageRepository.AddMessage(message); // 3. Return created MessageDto if (await _unitOfWork.Complete()) { await Clients.Group(groupName).SendAsync("NewMessage", _mapper.Map <MessageDto>(message)); } }
public async Task SendMessage(CreateMessageDto createMessageDto) { var senderUsername = Context.User.FindFirst(ClaimTypes.Name)?.Value; if (senderUsername == createMessageDto.RecipientUsername.ToLower()) { throw new HubException("You cannot send messages to yourself!"); } var senderUser = await unitOfWork.userRepository.GetUserByUsernameAsync(senderUsername); var recipientUser = await unitOfWork.userRepository.GetUserByUsernameAsync(createMessageDto.RecipientUsername); if (recipientUser == null) { throw new HubException("User not found"); } var message = new Message { Sender = senderUser, SenderDeleted = false, SenderId = senderUser.Id, SenderUsername = senderUser.UserName, Recipient = recipientUser, RecipientDeleted = false, RecipientId = recipientUser.Id, RecipientUsername = recipientUser.UserName, Content = createMessageDto.Content, }; var groupName = ConstructGroupName(senderUsername, recipientUser.UserName); var group = await unitOfWork.messageRepository.GetMessageGroup(groupName); // ako postoji konekcija, a ako ne kreiraj je if (group.Connections.Any(x => x.Username == recipientUser.UserName)) { message.DateRead = DateTime.UtcNow; } else { var connections = await tracker.GetConnectionsForUser(recipientUser.UserName); //ako recipient nije konektan na dm hub if (connections != null) { await presenceHub.Clients.Clients(connections).SendAsync("newMessageReceivedNotification", new { Username = senderUsername, KnownAs = senderUser.KnownAs }); } } unitOfWork.messageRepository.AddMessage(message); //await Groups.AddToGroupAsync(Context.ConnectionId, groupName); if (await unitOfWork.Complete()) { await Clients.Group(groupName).SendAsync("newMessageReceived", mapper.Map <MessageDTO>(message)); } }
public async Task SendMessage(CreateMessageDto createMessageDto) { // Get the current user from ClaimPrincipal string username = Context.User.GetUsername(); // Error checking on current user if (username == createMessageDto.RecipientUsername.ToLower()) { throw new HubException("You cannot send a message to yourself."); } // Get both Sender and Recipient AppUsers var sender = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username); var recipient = await _unitOfWork.UserRepository.GetUserByUsernameAsync(createMessageDto.RecipientUsername); // Error checking on Recipient if (recipient == null) { throw new HubException("Recipient with username " + createMessageDto.RecipientUsername + " could not be found."); } // Create the Message entity Message 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 there are any MessageHub connections for the message receiver, set the message.DateRead to now if (group.Connections.Any(x => x.Username == recipient.UserName)) { message.DateRead = DateTime.UtcNow; } else { // Check if the user is online var connections = await _tracker.GetConnectionsForUser(recipient.UserName); if (connections != null) { await _presenceHub.Clients.Clients(connections).SendAsync("NewMessageReceived", new { username = sender.UserName, knownAs = sender.KnownAs }); } } // Add it to the Database, and save _unitOfWork.MessageRepository.AddMessage(message); if (await _unitOfWork.Complete()) { await Clients.Group(groupName).SendAsync("NewMessage", _mapper.Map <MessageDto>(message)); } }