public void MessageReadStateChanged(ChatUser mentionedUser, ChatMessage message, Notification notification)
 {
     foreach (var client in mentionedUser.ConnectedClients)
     {
         HubContext.Clients.Client(client.Id).messageReadStateChanged(message.Id, notification.Read);
     }
 }

        private async void NotifyMyAndroid(ChatUser user, ChatMessage message)
        {
            var preferences = user.Preferences.PushNotifications.NMA;

            // Check preferences validity
            if (preferences == null || !preferences.Enabled || preferences.APIKey == null)
                return;

            var apikey = preferences.APIKey.Replace(" ", "");
            if (apikey.Length != 48)
                return;

            // Create event and description content values and add ellipsis if over limits

            var descriptionContent = message.Content;
            if (descriptionContent.Length > 10000)
                descriptionContent = descriptionContent.Substring(0, 10000 - 3) + "...";

            var request = new Dictionary<string, string>
            {
                {"apikey", apikey},
                {"application", "vox"},
                {"event", GetTitle(message, 100)},
                {"description", descriptionContent}
            };

            var result = await _httpClient.PostAsync("https://www.notifymyandroid.com/publicapi/notify", new FormUrlEncodedContent(request));

            _logger.Log("Send NotifyMyAndroid: {0}", result.StatusCode);
        }

 public MessageViewModel(ChatMessage message)
 {
     Id = message.Id;
     Content = message.Content;
     User = new UserViewModel(message.User);
     When = message.When;
 }

 public void Add(ChatMessage message)
 {
     RoomCache roomCache;
     if (_cache.TryGetValue(message.Room.Name, out roomCache))
     {
         // Only cache if there's been a store created for this room already
         roomCache.Add(message);
     }
 }

        private string GetTitle(ChatMessage message, int lengthLimit = 0)
        {
            var title = string.Format("Message from {0} in #{1}", message.User.Name, message.Room.Name);

            if (lengthLimit > 0 && title.Length > lengthLimit)
                title = title.Substring(0, lengthLimit - 3) + "...";

            return title;
        }

 public MessageViewModel(ChatMessage message)
 {
     Id = message.Id;
     Content = message.Content;
     HtmlContent = message.HtmlContent;
     User = new UserViewModel(message.User);
     When = message.When;
     HtmlEncoded = message.HtmlEncoded;
     MessageType = message.MessageType;
     Source = message.Source;
     ImageUrl = message.ImageUrl;
 }

 public MessageViewModel(ChatMessage message)
 {
     Id = message.Id;
     Content = message.Content;
     HtmlContent = message.HtmlContent;
     User = new UserViewModel(message.User);
     UserRoomPresence = ChatService.GetUserRoomPresence(message.User, message.Room);
     When = message.When;
     HtmlEncoded = message.HtmlEncoded;
     MessageType = message.MessageType;
     Source = message.Source;
     ImageUrl = message.ImageUrl;
 }

        public ChatMessage AddMessage(ChatUser user, ChatRoom room, string content)
        {
            var chatMessage = new ChatMessage
            {
                Id = Guid.NewGuid().ToString("d"),
                User = user,
                Content = content,
                When = DateTimeOffset.UtcNow,
                Room = room
            };

            _repository.Add(chatMessage);

            return chatMessage;
        }

        public void Send(ChatUser user, ChatMessage message)
        {
            if (user.Preferences == null || user.Preferences.PushNotifications == null)
                return;

            _logger.Log("Send user: {0}, message: {1}", user.Id, message.Id);

            try
            {
                NotifyMyAndroid(user, message);
                Pushover(user, message);
                Pushbullet(user, message);
            }
            catch (Exception ex)
            {
                _logger.Log("Send error: {0}", ex.ToString());
            }
        }

        private async void Pushover(ChatUser user, ChatMessage message)
        {
            if (_settings.PushoverAPIKey.IsNullOrWhiteSpace())
                return;

            // Check preferences validity
            var preferences = user.Preferences.PushNotifications.Pushover;

            if (preferences == null || !preferences.Enabled || preferences.UserKey.IsNullOrWhiteSpace())
                return;

            var request = new Dictionary<string, string>
            {
                {"token", _settings.PushoverAPIKey},
                {"user", preferences.UserKey},
                {"title", GetTitle(message)},
                {"message", message.Content}
            };

            if (!preferences.DeviceName.IsNullOrWhiteSpace())
                request["device"] = preferences.DeviceName;

            var result = await _httpClient.PostAsync("https://api.pushover.net/1/messages.json", new FormUrlEncodedContent(request));

            _logger.Log("Send Pushover: {0}", result.StatusCode);
        }

        public void PostNotification(ClientNotification notification, bool executeContentProviders)
        {
            string userId = Context.User.GetUserId();

            ChatUser user = _repository.GetUserById(userId);
            ChatRoom room = _repository.VerifyUserRoom(_cache, user, notification.Room);

            // User must be an owner
            if (room == null ||
                !room.Owners.Contains(user) ||
                (room.Private && !user.AllowedRooms.Contains(room)))
            {
                throw new HubException(LanguageResources.PostNotification_NotAllowed);
            }

            var chatMessage = new ChatMessage
            {
                Id = Guid.NewGuid().ToString("d"),
                Content = notification.Content,
                User = user,
                Room = room,
                HtmlEncoded = false,
                ImageUrl = notification.ImageUrl,
                Source = notification.Source,
                When = DateTimeOffset.UtcNow,
                MessageType = (int)MessageType.Notification
            };

            _repository.Add(chatMessage);
            _repository.CommitChanges();

            Clients.Group(room.Name).addMessage(new MessageViewModel(chatMessage), room.Name);

            if (executeContentProviders)
            {
                var urls = UrlExtractor.ExtractUrls(chatMessage.Content);
                if (urls.Count > 0)
                {
                    _resourceProcessor.ProcessUrls(urls, Clients, room.Name, chatMessage.Id);
                }
            }
        }

        private void AddMentions(ChatMessage message)
        {
            var mentionedUsers = new List<ChatUser>();
            foreach (var userName in MentionExtractor.ExtractMentions(message.Content))
            {
                ChatUser mentionedUser = _repository.GetUserByName(userName);

                // Don't create a mention if
                // 1. If the mentioned user doesn't exist.
                // 2. If you mention yourself
                // 3. If you're mentioned in a private room that you don't have access to
                // 4. You've already been mentioned in this message
                if (mentionedUser == null ||
                    mentionedUser == message.User ||
                    (message.Room.Private && !mentionedUser.AllowedRooms.Contains(message.Room)) ||
                    mentionedUsers.Contains(mentionedUser))
                {
                    continue;
                }

                // mark as read if ALL of the following
                // 1. user is not offline
                // 2. user is not AFK
                // 3. user has been active within the last 10 minutes
                // 4. user is currently in the room
                bool markAsRead = mentionedUser.Status != (int)UserStatus.Offline
                                  && !mentionedUser.IsAfk
                                  && (DateTimeOffset.UtcNow - mentionedUser.LastActivity) < TimeSpan.FromMinutes(10)
                                  && _repository.IsUserInRoom(_cache, mentionedUser, message.Room);

                _service.AddNotification(mentionedUser, message, message.Room, markAsRead);

                mentionedUsers.Add(mentionedUser);
            }

            if (mentionedUsers.Count > 0)
            {
                _repository.CommitChanges();
            }

            foreach (var user in mentionedUsers)
            {
                UpdateUnreadMentions(user);
            }
        }

        public void Update(ChatMessage message)
        {
            ChatMessage updateMessage = _db.Messages.Where(p => p.Id == message.Id).FirstOrDefault();

            if (updateMessage != null)
            {
                _db.Entry(updateMessage).CurrentValues.SetValues(message);
            }

            _db.SaveChanges();
        }

 public Notification GetNotificationByMessage(ChatMessage message, ChatUser user)
 {
     return _db.Notifications.SingleOrDefault(n => n.MessageKey == message.Key && n.UserKey == user.Key);
 }

        public void Update(ChatMessage message)
        {
            var room = _rooms.First(r => r == message.Room);
            var updateMessage = room.Messages.Where(p => p.Id == message.Id).FirstOrDefault();

            if (updateMessage != null)
            {
                room.Messages.Remove(updateMessage);
                room.Messages.Add(message);
            }
        }

        private void ProcessUrls(IEnumerable<string> links, ChatRoom room, ChatMessage chatMessage)
        {
            // REVIEW: is this safe to do? We're holding on to this instance
            // when this should really be a fire and forget.
            var contentTasks = links.Select(_resourceProcessor.ExtractResource).ToArray();
            Task.Factory.ContinueWhenAll(contentTasks, tasks =>
            {
                foreach (var task in tasks)
                {
                    if (task.IsFaulted)
                    {
                        Trace.TraceError(task.Exception.GetBaseException().Message);
                        continue;
                    }

                    if (task.Result == null || String.IsNullOrEmpty(task.Result.Content))
                    {
                        continue;
                    }

                    // Try to get content from each url we're resolved in the query
                    string extractedContent = "<p>" + task.Result.Content + "</p>";

                    // If we did get something, update the message and notify all clients
                    chatMessage.Content += extractedContent;

                    // Notify the room
                    Clients[room.Name].addMessageContent(chatMessage.Id, extractedContent, room.Name);

                    // Commit the changes
                    _repository.CommitChanges();
                }
            });
        }

        public ChatMessage AddMessage(ChatUser user, ChatRoom room, string id, string content)
        {
            var chatMessage = new ChatMessage
            {
                Id = id,
                User = user,
                Content = content,
                When = DateTimeOffset.UtcNow,
                Room = room,
                HtmlEncoded = false
            };

            _recentMessageCache.Add(chatMessage);

            _repository.Add(chatMessage);

            return chatMessage;
        }

 public void Add(ChatMessage message)
 {
     // There's no need to keep a collection of messages outside of a room
     var room = _rooms.First(r => r == message.Room);
     room.Messages.Add(message);
 }

        private void AddMentions(ChatMessage message)
        {
            foreach (var userName in MentionExtractor.ExtractMentions(message.Content))
            {
                ChatUser mentionedUser = _repository.GetUserByName(userName);

                if (mentionedUser == null || mentionedUser == message.User)
                {
                    continue;
                }

                _service.AddNotification(mentionedUser, message);
            }
        }

        private async void Pushbullet(ChatUser user, ChatMessage message)
        {
            // Check preferences validity
            var preferences = user.Preferences.PushNotifications.Pushbullet;

            if (preferences == null || !preferences.Enabled || preferences.APIKey.IsNullOrWhiteSpace())
                return;

            // Get a list of all devices for user from pushbullet
            var devices = await PushbulletRequest(preferences.APIKey, "devices", HttpMethod.Get);

            if (devices.Item1.StatusCode != HttpStatusCode.OK)
            {
                _logger.Log("Pushbullet /api/devices request failed, StatusCode: {0}", devices.Item1.StatusCode);
                return;
            }

            var deviceIdentifiers = devices.Item2["devices"]
                .Select(d =>
                {
                    var name = d["extras"]["nickname"].Value<string>();

                    if (name.Length < 1)
                        name = d["extras"]["model"].Value<string>();

                    return new Tuple<string, string>(d["id"].Value<string>(), name);
                })
                .ToList();

            // Filter devices from stored names
            if (!preferences.Devices.IsNullOrWhiteSpace())
            {
                // Parse devices from input
                var names = PushbulletParseDevices(preferences.Devices).ToList();

                // Filter devices based on names
                deviceIdentifiers = deviceIdentifiers.Where(d => names.Contains(d.Item2)).ToList();
            }

            foreach (var device in deviceIdentifiers)
            {
                var request = new Dictionary<string, string>
                {
                    {"device_id", device.Item1},
                    {"type", "note"},
                    {"title", GetTitle(message)},
                    {"body", message.Content}
                };

                var result = await PushbulletRequest(preferences.APIKey, "pushes", HttpMethod.Post, request);

                _logger.Log("Send Pushbullet: {0}", result.Item1.StatusCode);
            }
        }