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