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