public Chat(IApplicationSettings settings, IResourceProcessor resourceProcessor, IChatService service, IJabbrRepository repository)
 {
     _settings = settings;
     _resourceProcessor = resourceProcessor;
     _service = service;
     _repository = repository;
 }

 public Chat(IResourceProcessor resourceProcessor, IChatService service, IJabbrRepository repository, ICache cache)
 {
     _resourceProcessor = resourceProcessor;
     _service = service;
     _repository = repository;
     _cache = cache;
 }

 public TestableChat(Mock<ContentProviderProcessor> mockedResourceProcessor, Mock<IChatService> mockedChatService, IJabbrRepository repository, Mock<IConnection> connection)
     : base(mockedResourceProcessor.Object, mockedChatService.Object, repository, new Mock<ICache>().Object, new Mock<ILogger>().Object)
 {
     MockedResourceProcessor = mockedResourceProcessor;
     MockedChatService = mockedChatService;
     Repository = repository;
     MockedConnection = connection;
 }

        public static string TransformAndParseUrls(IJabbrRepository repository, string text)
        {
            HashSet<string> urls;
            var transform = new TextTransform(repository);
            var parsedText = transform.Parse(text);

            return TextTransform.TransformAndExtractUrls(parsedText, out urls);
        }

 public JabbRAuthenticationCallbackProvider(IAuthenticationTokenService authenticationTokenService,
                                            IMembershipService membershipService,
                                            IJabbrRepository repository)
 {
     _authenticationTokenService = authenticationTokenService;
     _membershipService = membershipService;
     _repository = repository;
 }

 public TestableChat(Mock<IApplicationSettings> mockSettings, Mock<IResourceProcessor> mockedResourceProcessor, Mock<IChatService> mockedChatService, IJabbrRepository repository, Mock<IConnection> connection)
     : base(mockedResourceProcessor.Object, mockedChatService.Object, repository, new Mock<ICache>().Object)
 {
     MockedResourceProcessor = mockedResourceProcessor;
     MockedChatService = mockedChatService;
     Repository = repository;
     MockedConnection = connection;
 }

 public CommandManager(string clientId,
                       string userId,
                       string roomName,
                       IChatService service,
                       IJabbrRepository repository,
                       INotificationService notificationService)
     : this(clientId, null, userId, roomName, service, repository, notificationService)
 {
 }

 public Chat(ContentProviderProcessor resourceProcessor,
             IChatService service,
             IJabbrRepository repository,
             ICache cache,
             ILogger logger)
 {
     _resourceProcessor = resourceProcessor;
     _service = service;
     _repository = repository;
     _cache = cache;
     _logger = logger;
 }

 private static void ClearConnectedClients(IJabbrRepository repository)
 {
     try
     {
         repository.RemoveAllClients();
         repository.CommitChanges();
     }
     catch (Exception ex)
     {
         Elmah.ErrorLog.GetDefault(null).Log(new Error(ex));
     }
 }

        private static void RemoveZombies(ILogger logger, IJabbrRepository repo)
        {
            // Remove all zombie clients
            var zombies = repo.Clients.Where(c =>
                SqlFunctions.DateDiff("mi", c.LastActivity, DateTimeOffset.UtcNow) > 3);

            // We're doing to list since there's no MARS support on azure
            foreach (var client in zombies.ToList())
            {
                logger.Log("Removed zombie connection {0}", client.Id);

                repo.Remove(client);
            }
        }

 public CommandManager(string clientId,
                       string userId,
                       string roomName,
                       IChatService service,
                       IJabbrRepository repository,
                       INotificationService notificationService)
 {
     _clientId = clientId;
     _userId = userId;
     _roomName = roomName;
     _chatService = service;
     _repository = repository;
     _notificationService = notificationService;
 }

 public TestableChat(Mock<ContentProviderProcessor> mockedResourceProcessor, Mock<IChatService> mockedChatService, IJabbrRepository repository, Mock<IConnection> connection, ApplicationSettings settings)
     : base(mockedResourceProcessor.Object,
            mockedChatService.Object,
            new Mock<IRecentMessageCache>().Object, 
            repository, 
            new Mock<ICache>().Object, 
            new Mock<ILogger>().Object,
            settings)
 {
     MockedResourceProcessor = mockedResourceProcessor;
     MockedChatService = mockedChatService;
     Repository = repository;
     MockedConnection = connection;
     Settings = settings;
 }

 public Chat(ContentProviderProcessor resourceProcessor,
             IChatService service,
             IRecentMessageCache recentMessageCache,
             IJabbrRepository repository,
             ICache cache,
             ILogger logger,
             ApplicationSettings settings)
 {
     _resourceProcessor = resourceProcessor;
     _service = service;
     _recentMessageCache = recentMessageCache;
     _repository = repository;
     _cache = cache;
     _logger = logger;
     _settings = settings;
 }

        private static void ClearConnectedClients(IJabbrRepository repository)
        {
            try
            {
                foreach (var u in repository.Users)
                {
                    u.Status = (int)UserStatus.Offline;
                }

                repository.RemoveAllClients();
                repository.CommitChanges();
            }
            catch (Exception ex)
            {
                Elmah.ErrorLog.GetDefault(null).Log(new Error(ex));
            }
        }

        private static void CheckUserStatus(IJabbrRepository repo, IHubContext hubContext)
        {
            var inactiveUsers = new List<ChatUser>();
            var offlineUsers = new List<ChatUser>();

            IQueryable<ChatUser> users = repo.GetOnlineUsers();

            foreach (var user in users)
            {
                var status = (UserStatus)user.Status;
                var elapsed = DateTime.UtcNow - user.LastActivity;

                if (user.ConnectedClients.Count == 0)
                {
                    // Fix users that are marked as inactive but have no clients
                    user.Status = (int)UserStatus.Offline;
                    offlineUsers.Add(user);
                }
                else if (elapsed.TotalMinutes > 5)
                {
                    user.Status = (int)UserStatus.Inactive;
                    inactiveUsers.Add(user);
                }
            }

            if (inactiveUsers.Count > 0)
            {
                PerformRoomAction(inactiveUsers, roomGroup =>
                {
                    hubContext.Clients.Group(roomGroup.Room.Name).markInactive(roomGroup.Users);
                });
            }

            // TODO: Only remove users relevant to this server.
            //if (offlineUsers.Count > 0)
            //{
            //    PerformRoomAction(offlineUsers, roomGroup =>
            //    {
            //        foreach (var user in roomGroup.Users)
            //        {
            //            hubContext.Clients.Group(roomGroup.Room.Name).leave(user, roomGroup.Room.Name);
            //        }
            //    });
            //}
        }

        private static void MarkInactiveUsers(IJabbrRepository repo, IHubContext hubContext)
        {
            var inactiveUsers = new List<ChatUser>();

            IQueryable<ChatUser> users = repo.GetOnlineUsers();

            foreach (var user in users)
            {
                var status = (UserStatus)user.Status;
                var elapsed = DateTime.UtcNow - user.LastActivity;

                if (user.ConnectedClients.Count == 0)
                {
                    // Fix users that are marked as inactive but have no clients
                    user.Status = (int)UserStatus.Offline;
                }
                else if (elapsed.TotalMinutes > 15)
                {
                    user.Status = (int)UserStatus.Inactive;
                    inactiveUsers.Add(user);
                }
            }

            if (inactiveUsers.Count > 0)
            {
                var roomGroups = from u in inactiveUsers
                                 from r in u.Rooms
                                 select new { User = u, Room = r } into tuple
                                 group tuple by tuple.Room into g
                                 select new
                                 {
                                     Room = g.Key,
                                     Users = g.Select(t => new UserViewModel(t.User))
                                 };

                foreach (var roomGroup in roomGroups)
                {
                    hubContext.Clients.Group(roomGroup.Room.Name).markInactive(roomGroup.Users).Wait();
                }
            }
        }

 public ChatService(IJabbrRepository repository, ICryptoService crypto)
 {
     _repository = repository;
     _crypto = crypto;
 }

 public JabbRAuthenticationCallbackProvider(IJabbrRepository repository)
 {
     _repository = repository;
 }

 public TestableChat(Mock<IResourceProcessor> mockedResourceProcessor, Mock<IChatService> mockedChatService, IJabbrRepository repository, Mock<IConnection> connection)
     : base(mockedResourceProcessor.Object, mockedChatService.Object, repository)
 {
     MockedResourceProcessor = mockedResourceProcessor;
     MockedChatService = mockedChatService;
     Repository = repository;
     MockedConnection = connection;
 }

        private void UpdatePresence(ILogger logger, IJabbrRepository repo)
        {
            // Get all connections on this node and update the activity
            foreach (var connection in _heartbeat.GetConnections())
            {
                if (!connection.IsAlive)
                {
                    continue;
                }

                ChatClient client = repo.GetClientById(connection.ConnectionId);

                if (client != null)
                {
                    client.LastActivity = DateTimeOffset.UtcNow;
                }
                else
                {
                    EnsureClientConnected(logger, repo, connection);
                }
            }

            repo.CommitChanges();
        }