public void Post([FromBody] Message message, int channelId)
{
message.ChannelId = channelId;
var model = _mapper.Map <Message, Contract.DTO.Chat.Message>(message);
_chatService.AddMessage(model);
}
public bool Send(ClientMessage message)
{
bool outOfSync = OutOfSync;
SetVersion();
// Sanitize the content (strip and bad html out)
message.Content = HttpUtility.HtmlEncode(message.Content);
// See if this is a valid command (starts with /)
if (TryHandleCommand(message.Content, message.Room))
{
return(outOfSync);
}
string id = GetUserId();
ChatUser user = _repository.VerifyUserId(id);
ChatRoom room = _repository.VerifyUserRoom(_cache, user, message.Room);
// REVIEW: Is it better to use _repository.VerifyRoom(message.Room, mustBeOpen: false)
// here?
if (room.Closed)
{
throw new InvalidOperationException(String.Format("You cannot post messages to '{0}'. The room is closed.", message.Room));
}
// Update activity *after* ensuring the user, this forces them to be active
UpdateActivity(user, room);
HashSet <string> links;
var messageText = ParseChatMessageText(message.Content, out links);
ChatMessage chatMessage = _service.AddMessage(user, room, message.Id, messageText);
var messageViewModel = new MessageViewModel(chatMessage);
Clients.Group(room.Name).addMessage(messageViewModel, room.Name);
_repository.CommitChanges();
string clientMessageId = chatMessage.Id;
// Update the id on the message
chatMessage.Id = Guid.NewGuid().ToString("d");
_repository.CommitChanges();
if (!links.Any())
{
return(outOfSync);
}
ProcessUrls(links, room.Name, clientMessageId, chatMessage.Id);
return(outOfSync);
}
public async Task SendMessage(int chatRoomId, string message)
{
//await Groups.AddToGroupAsync(Context.ConnectionId, "SignalR Users");
//await base.OnConnectedAsync();
var msg = await _chatService.AddMessage(chatRoomId, message, Context.User.GetUserId());
await this.Clients.Group(chatRoomId.ToString()).SendAsync("Message", msg);
}
public async Task SendMessage(string message)
{
ChatUser sender = await ChatService.GetUser(Context.ConnectionId);
await SendToGroup(sender.CurrentRoom, sender.FullName, message);
var newMessage = new Message {
Body = message, Timestamp = DateTime.Now, Sender = sender.FullName, IsAdminMessage = sender.IsAdmin
};
await ChatService.AddMessage(newMessage, sender.CurrentRoom);
}
public async System.Threading.Tasks.Task Send(MessageViewModel model)
{
// find corresponding chat
Chat chat = _chatService.GetChat(model.CurrentUserId, model.OpositeUserId);
// create message and save it to db
await _chatService.AddMessage(chat, model);
// resend to oposite (receivering) user
await this.Clients.User(model.OpositeUserId).SendAsync("Send", model);
}
public async Task <IActionResult> SendMessage(Message message)
{
try
{
var result = await chatService.AddMessage(message);
return(Ok(result));
}
catch (Exception e)
{
return(BadRequest(e));
}
}
public async Task SendMessage(NewChatMessageModel model)
{
var userId = Context.User.GetUserId();
await _chatService.AddMessage(model);
var newChatMessage = new ChatMessageModel
{
Message = model.Message,
UserId = userId,
Sent = DateTime.Now
};
await Clients.All.SendAsync("ReceiveMessage", newChatMessage);
}
public bool Send(ClientMessage message)
{
bool outOfSync = OutOfSync;
SetVersion();
// Sanitize the content (strip and bad html out)
message.Content = HttpUtility.HtmlEncode(message.Content);
// See if this is a valid command (starts with /)
if (TryHandleCommand(message.Content, message.Room))
{
return(outOfSync);
}
string id = Caller.id;
ChatUser user = _repository.VerifyUserId(id);
ChatRoom room = _repository.VerifyUserRoom(_cache, user, message.Room);
// Update activity *after* ensuring the user, this forces them to be active
UpdateActivity(user, room);
HashSet <string> links;
var messageText = ParseChatMessageText(message.Content, out links);
ChatMessage chatMessage = _service.AddMessage(user, room, message.Id, messageText);
var messageViewModel = new MessageViewModel(chatMessage);
Clients[room.Name].addMessage(messageViewModel, room.Name);
_repository.CommitChanges();
string clientMessageId = chatMessage.Id;
// Update the id on the message
chatMessage.Id = Guid.NewGuid().ToString("d");
_repository.CommitChanges();
if (!links.Any())
{
return(outOfSync);
}
ProcessUrls(links, room.Name, clientMessageId, chatMessage.Id);
return(outOfSync);
}
public bool Send(ClientMessage message)
{
bool outOfSync = OutOfSync;
SetVersion();
// See if this is a valid command (starts with /)
if (TryHandleCommand(message.Content, message.Room))
{
return(outOfSync);
}
var userId = Context.User.Identity.Name;
ChatUser user = _repository.VerifyUserId(userId);
ChatRoom room = _repository.VerifyUserRoom(_cache, user, message.Room);
// REVIEW: Is it better to use _repository.VerifyRoom(message.Room, mustBeOpen: false)
// here?
if (room.Closed)
{
throw new InvalidOperationException(String.Format("You cannot post messages to '{0}'. The room is closed.", message.Room));
}
// Update activity *after* ensuring the user, this forces them to be active
UpdateActivity(user, room);
ChatMessage chatMessage = _service.AddMessage(user, room, message.Id, message.Content);
var messageViewModel = new MessageViewModel(chatMessage);
Clients.Group(room.Name).addMessage(messageViewModel, room.Name);
_repository.CommitChanges();
string clientMessageId = chatMessage.Id;
// Update the id on the message
chatMessage.Id = Guid.NewGuid().ToString("d");
_repository.CommitChanges();
var urls = UrlExtractor.ExtractUrls(chatMessage.Content);
if (urls.Count > 0)
{
ProcessUrls(urls, room.Name, clientMessageId, message.Id);
}
return(outOfSync);
}
public async Task <IActionResult> Post([FromBody] Message message, int channelId)
{
message.ChannelId = channelId;
var model = _mapper.Map <Message, Contract.DTO.Chat.Message>(message);
TryAsync <Unit> svcResult = async() => await _chatService.AddMessage(model);
var result = svcResult.Match <Unit, IActionResult>(
Succ: unit => NoContent(),
Fail: ex => StatusCode(500, ex)
);
return(await result);
}
public async Task Upload(string userId,
string connectionId,
string roomName,
string file,
string contentType,
Stream stream)
{
UploadResult result;
ChatMessage message;
try
{
result = await _processor.HandleUpload(file, contentType, stream, stream.Length);
if (result == null)
{
string messageContent = String.Format(LanguageResources.UploadFailed, Path.GetFileName(file));
_hubContext.Clients.Client(connectionId).postMessage(messageContent, "error", roomName);
return;
}
else if (result.UploadTooLarge)
{
string messageContent = String.Format(LanguageResources.UploadTooLarge, Path.GetFileName(file), (result.MaxUploadSize / 1048576f).ToString("0.00"));
_hubContext.Clients.Client(connectionId).postMessage(messageContent, "error", roomName);
return;
}
// Add the message to the persistent chat
message = _service.AddMessage(userId, roomName, result.Url);
// Keep track of this attachment
_service.AddAttachment(message, file, contentType, stream.Length, result);
}
catch (Exception ex)
{
string messageContent = String.Format(LanguageResources.UploadFailedException, Path.GetFileName(file), ex.Message);
_hubContext.Clients.Client(connectionId).postMessage(messageContent, "error", roomName);
return;
}
var messageViewModel = new MessageViewModel(message);
// Notify all clients for the uploaded url
_hubContext.Clients.Group(roomName).addMessage(messageViewModel, roomName);
_resourceProcessor.ProcessUrls(new[] { result.Url }, _hubContext.Clients, roomName, message.Id);
}
public async Task SendMessage(int recipient, string text, List <string> files)
{
int userId = _auth.GetCurrentUserId();
try
{
List <string> urls = null;
if (files != null)
{
List <string> uploadResponses = _filesService.UploadMultipleV2(files);
if (urls == null)
{
urls = new List <string>();
}
uploadResponses.ForEach(url => urls.Add(url));
}
MessageAddRequest message = new MessageAddRequest();
message.Recipient = recipient;
message.Text = text;
Message newMessage = _chatService.AddMessage(userId, message, urls);
if (newMessage == null)
{
await Clients.Users($"{userId}", $"{recipient}").SendAsync("ReceiveMessage", null);
}
else
{
newMessage.FileData = new List <string>();
newMessage.FileData = files;
if (newMessage.SenderInfo != null)
{
await Clients.User($"{recipient}").SendAsync("ReceiveSingleContact", newMessage.SenderInfo);
await Clients.Users($"{userId}", $"{recipient}").SendAsync("ReceiveMessage", newMessage, 3);
}
else
{
await Clients.Users($"{userId}", $"{recipient}").SendAsync("ReceiveMessage", newMessage, 1);
}
}
}
catch (Exception ex)
{
await Clients.User($"{userId}").SendAsync("ReceiveMessage", null, null, ex);
}
}
public IActionResult SendMessage([FromQuery] string receiverId, [FromBody] MessageDetail message)
{
var identity = (ClaimsIdentity)User.Identity;
var userId = identity.FindFirst("user_id").Value;
message.Id = ObjectId.GenerateNewId().ToString();
message.Time = DateTime.Now;
message.FromUserId = userId;
var result = _chatService.AddMessage(userId, receiverId, message);
if (result == null)
{
return(BadRequest());
}
return(Ok(result));
}
public async Task <bool> SendPrivateMessage(string recipientName, string message)
{
string identityName = Context.User.Identity.Name;
if (recipientName != identityName && !String.IsNullOrEmpty(recipientName))
{
if (message.Length > _settings.MaxMessageLength)
{
throw new HubException(String.Format("Message is too long", _settings.MaxMessageLength));
}
if (message.Length <= 0)
{
throw new HubException(String.Format("Message is too low", _settings.MaxMessageLength));
}
User currentUser = _chatRepo.GetUserByName(identityName);
User recipient = _chatRepo.GetUserByName(recipientName);
if (recipient != null)
{
Dialog dialog = _chatRepo.HasDialog(identityName, recipientName);
if (dialog == null)
{
dialog = await _chatService.CreateDialog(currentUser, recipient, message);
}
if (currentUser.Status != UserStatus.Online)
{
await SendStatus(UserStatus.Online);
}
await Clients.User(recipientName).SendAsync("RecieveMessage", Context.User.Identity.FullName(), identityName, message);
await _chatService.AddMessage(currentUser, dialog, message);
return(true);
}
return(false);
}
return(false);
}
public async Task Upload(string userId,
string connectionId,
string roomName,
string file,
string contentType,
Stream stream)
{
if (stream.Length > _settings.MaxFileUploadBytes)
{
_hubContext.Clients.Client(connectionId).postMessage("Unable to upload " + Path.GetFileName(file) + " because it exceeded the maximum size allowed.", "error", roomName);
return;
}
UploadResult result;
ChatMessage message;
try
{
result = await _processor.HandleUpload(file, contentType, stream);
if (result == null)
{
_hubContext.Clients.Client(connectionId).postMessage("Failed to upload " + Path.GetFileName(file) + ".", "error", roomName);
return;
}
// Add the message to the persistent chat
message = _service.AddMessage(userId, roomName, result.Url);
// Keep track of this attachment
_service.AddAttachment(message, file, contentType, stream.Length, result);
}
catch (Exception ex)
{
_hubContext.Clients.Client(connectionId).postMessage("Failed to upload " + Path.GetFileName(file) + ". " + ex.Message, "error", roomName);
return;
}
var messageViewModel = new MessageViewModel(message);
// Notify all clients for the uploaded url
_hubContext.Clients.Group(roomName).addMessage(messageViewModel, roomName);
_resourceProcessor.ProcessUrls(new[] { result.Url }, _hubContext.Clients, roomName, message.Id);
}
public ActionResult AddMessage(AddMessageRequest mess)
{
try{
CheckId(mess.IdSender);
bool check = _service.AddMessage(mess);
if (check != false)
{
return(Ok());
}
else
{
return(BadRequest());
}
}catch (Exception e) {
Console.WriteLine(e.ToString() + "\n add message err");
return(BadRequest(e.Message));
}
}
public void Send(string content)
{
// If the client and server are out of sync then tell the client to refresh
if (OutOfSync)
{
throw new InvalidOperationException("Chat was just updated, please refresh you browser");
}
// Sanitize the content (strip and bad html out)
content = HttpUtility.HtmlEncode(content);
// See if this is a valid command (starts with /)
if (TryHandleCommand(content))
{
return;
}
string roomName = Caller.activeRoom;
string id = Caller.id;
ChatUser user = _repository.VerifyUserId(id);
ChatRoom room = _repository.VerifyUserRoom(user, roomName);
// Update activity *after* ensuring the user, this forces them to be active
UpdateActivity(user, room);
HashSet <string> links;
var messageText = ParseChatMessageText(content, out links);
ChatMessage chatMessage = _service.AddMessage(user, room, messageText);
var messageViewModel = new MessageViewModel(chatMessage);
Clients[room.Name].addMessage(messageViewModel, room.Name);
_repository.CommitChanges();
if (!links.Any())
{
return;
}
ProcessUrls(links, room, chatMessage);
}
public void LetsChat(string name, string message)
{
var user = _userRepository.UserIsExist(name);
if (user != null)
{
var newMessage = new Entity.MessageLog
{
UserId = user.UserId,
Content = message.Trim(),
MessageDate = DateTime.Now
};
Clients.All.SendAsync(user.FullName, message, newMessage.MessageDate);
if (newMessage.Content.Trim() == "")
{
return;
}
_chatRepository.AddMessage(newMessage);
}
}
public async Task SendMessage(int chatroomId, string message)
{
try
{
var chatroomMessage = await chatService.AddMessage(Context.User, message, chatroomId);
if (!chatroomMessage.ResultType.Equals(ResultType.Ok))
{
await Clients.Caller.SendAsync("receiveMessage", "Chatroom message was not sent");
return;
}
chatroomMessage.Data.MessageType = MessageType.Message;
await Clients.Group(chatroomId.ToString()).SendAsync("receiveChatMessage", chatroomMessage.Data);
}
catch (Exception ex)
{
logger.LogError($"SendMessage: {chatroomId} with message {message}", ex);
throw new HubException("Something went wrong");
}
}
public async Task <IActionResult> AddMessage([FromBody] ChatMessageVm chatMessageVm) => Ok(await _chatService.AddMessage(chatMessageVm));
public void AddMessage(Message message)
{
_client.AddMessage(message);
}
public void Send(string name, string message)
{
chatService.AddMessage(name, message);
Clients.All.addMessage(name, message);
}
public IActionResult AddMessage(string messageInput, int chatRoomId)
{
_chatService.AddMessage(messageInput, chatRoomId);
return(RedirectToAction("Overview", "Chat", new { chatRoomId }));
}
public void AddMessage(ChatDto chatDto)
{
ChatModel chatModel = new ChatModel(chatDto.UserId, chatDto.Message);
_chatService.AddMessage(chatModel);
}
public bool Send(ClientMessage clientMessage)
{
CheckStatus();
// See if this is a valid command (starts with /)
if (TryHandleCommand(clientMessage.Content, clientMessage.Room))
{
return(true);
}
var userId = Context.User.Identity.Name;
ChatUser user = _repository.VerifyUserId(userId);
ChatRoom room = _repository.VerifyUserRoom(_cache, user, clientMessage.Room);
if (room == null || (room.Private && !user.AllowedRooms.Contains(room)))
{
return(false);
}
// REVIEW: Is it better to use _repository.VerifyRoom(message.Room, mustBeOpen: false)
// here?
if (room.Closed)
{
throw new InvalidOperationException(String.Format("You cannot post messages to '{0}'. The room is closed.", clientMessage.Room));
}
// Update activity *after* ensuring the user, this forces them to be active
UpdateActivity(user, room);
// Create a true unique id and save the message to the db
string id = Guid.NewGuid().ToString("d");
ChatMessage chatMessage = _service.AddMessage(user, room, id, clientMessage.Content);
_repository.CommitChanges();
var messageViewModel = new MessageViewModel(chatMessage);
if (clientMessage.Id == null)
{
// If the client didn't generate an id for the message then just
// send it to everyone. The assumption is that the client has some ui
// that it wanted to update immediately showing the message and
// then when the actual message is roundtripped it would "solidify it".
Clients.Group(room.Name).addMessage(messageViewModel, room.Name);
}
else
{
// If the client did set an id then we need to give everyone the real id first
Clients.OthersInGroup(room.Name).addMessage(messageViewModel, room.Name);
// Now tell the caller to replace the message
Clients.Caller.replaceMessage(clientMessage.Id, messageViewModel, room.Name);
}
// Add mentions
AddMentions(chatMessage);
var urls = UrlExtractor.ExtractUrls(chatMessage.Content);
if (urls.Count > 0)
{
_resourceProcessor.ProcessUrls(urls, Clients, room.Name, chatMessage.Id);
}
return(true);
}
public bool Send(ClientMessage clientMessage)
{
//Commented out for resting purposes
// TODO: set env variable
//CheckStatus();
//reject it if it's too long
if (_settings.MaxMessageLength > 0 && clientMessage.Content.Length > _settings.MaxMessageLength)
{
throw new HubException(String.Format(LanguageResources.SendMessageTooLong, _settings.MaxMessageLength));
}
//See if this is a valid command (starts with /)
if (TryHandleCommand(clientMessage.Content, clientMessage.Room))
{
return(true);
}
var userId = Context.User.GetUserId();
ChatUser user = _repository.VerifyUserId(userId);
// this line breaks when we message in a new room
ChatRoom room = _repository.VerifyUserRoom(_cache, user, clientMessage.Room);
if (room == null || (room.Private && user.AllowedRooms.Select(r => r.ChatRoomKeyNavigation).ToList().Contains(room)))
{
return(false);
}
// REVIEW: Is it better to use the extension method room.EnsureOpen here?
if (room.Closed)
{
throw new HubException(String.Format(LanguageResources.SendMessageRoomClosed, clientMessage.Room));
}
// Update activity *after* ensuring the user, this forces them to be active
UpdateActivity(user, room);
// Create a true unique id and save the message to the db
string id = Guid.NewGuid().ToString("d");
// Ensure the message is logged
ChatMessage chatMessage = _chatService.AddMessage(user, room, id, clientMessage.Content);
room.ChatMessages.Add(chatMessage);
// Save changes
_repository.CommitChanges();
var messageViewModel = new MessageViewModel(chatMessage);
if (clientMessage.Id == null)
{
// If the client didn't generate an id for the message then just
// send it to everyone. The assumption is that the client has some ui
// that it wanted to update immediately showing the message and
// then when the actual message is roundtripped it would "solidify it".
Clients.Group(room.Name).addMessage(messageViewModel, room.Name);
}
else
{
// If the client did set an id then we need to give everyone the real id first
Clients.OthersInGroup(room.Name).addMessage(messageViewModel, room.Name);
// Now tell the caller to replace the message
Clients.Caller.replaceMessage(clientMessage.Id, messageViewModel, room.Name);
}
// Add mentions
//AddMentions(chatMessage);
//var urls = UrlExtractor.ExtractUrls(chatMessage.Content);
//if (urls.Count > 0)
//{
// _resourceProcessor.ProcessUrls(urls, Clients, room.Name, chatMessage.Id);
//}
return(true);
}
