public RemoveProjectWorkItemHandler(IProjectRepository projectRepository, IEventRepository eventRepository, IStackRepository stackRepository, ITokenRepository tokenRepository, IWebHookRepository webHookRepository) {
     _projectRepository = projectRepository;
     _eventRepository = eventRepository;
     _stackRepository = stackRepository;
     _tokenRepository = tokenRepository;
     _webHookRepository = webHookRepository;
 }

 public ContactsEventSink(
     IDistributionPolicyFactory distributionPolicyFactory, 
     IEventRepository eventRepository, 
     IMailer mailer, IUserPresentationProvider userPresentationProvider)
     : base(distributionPolicyFactory, eventRepository, mailer, userPresentationProvider)
 {
 }

 public ThrottleBotsPlugin(ICacheClient cacheClient, IEventRepository eventRepository, IProjectRepository projectRepository, IMetricsClient metricsClient, IQueue<WorkItemData> workItemQueue) {
     _cacheClient = cacheClient;
     _metricsClient = metricsClient;
     _eventRepository = eventRepository;
     _projectRepository = projectRepository;
     _workItemQueue = workItemQueue;
 }

        public DevicesController(
            IDeviceCommunicationService deviceCommunicationService,
            DeviceCommunicationExtJsWeb.GpsCommunicationService.IGpsCommunicationContract gpsCommunicationContract,
            
            IDeviceRepository deviceRepository,
            IPacketRepository packetRepository,
            IEventRepository eventRepository,
            ICurrentEventRepository currentEventRepository,
            IRequstAckCommandRepository requstAckCommandRepository,
            ICacheDataRepository cacheDataRepository,
            
            IDeviceStateDocuments deviceStateDocuments,
            
            IDailyMileageRepository dailyMileageRepository,
            IGeoPointRepository geoPointRepository,
            ILogDocuments logDocuments)
        {
            DeviceCommunicationService = deviceCommunicationService;

            DeviceRepository = deviceRepository;
            PacketRepository = packetRepository;
            EventRepository = eventRepository;
            CurrentEventRepository = currentEventRepository;
            RequstAckCommandRepository = requstAckCommandRepository;
            CacheDataRepository = cacheDataRepository;

            DeviceStateDocuments = deviceStateDocuments;

            GpsCommunicationContract = gpsCommunicationContract;

            DailyMileageRepository = dailyMileageRepository;
            GeoPointRepository = geoPointRepository;

            LogDocuments = logDocuments;
        }

 public SetLocationFromGeoWorkItemHandler(ICacheClient cacheClient, IEventRepository eventRepository, IGeocodeService geocodeService, IMetricsClient metricsClient, IMessageBus messageBus, ILoggerFactory loggerFactory = null) : base(loggerFactory) {
     _cacheClient = new ScopedCacheClient(cacheClient, "geo");
     _eventRepository = eventRepository;
     _geocodeService = geocodeService;
     _metricsClient = metricsClient;
     _lockProvider = new CacheLockProvider(cacheClient, messageBus);
 }

 public EventLogic(IEventRepository eventRepository, IClientRepository clientRepository, IClientLogic clientLogic, ILog log)
 {
     _eventRepository = eventRepository;
     _clientRepository = clientRepository;
     _clientLogic = clientLogic;
     _log = log;
 }

 public AutoSessionPlugin(ICacheClient cacheClient, IEventRepository eventRepository, AssignToStackAction assignToStack, UpdateStatsAction updateStats, LocationPlugin locationPlugin) {
     _cacheClient = new ScopedCacheClient(cacheClient, "session");
     _eventRepository = eventRepository;
     _assignToStack = assignToStack;
     _updateStats = updateStats;
     _locationPlugin = locationPlugin;
 }

        public DrillCreationViewModel(IDrillsRepository drillsRepository, IEventRepository eventRepository, ISessonStateService sessonStateService, INavigationService navigationService)
        {
            _drillsRepository = drillsRepository;
            _eventRepository = eventRepository;
            _sessonStateService = sessonStateService;
            _navigationService = navigationService;

            PageTitle = "New Practice Drill";

            Sports = _eventRepository.Sports();

            var defaultDuration = new DrillDuration {Minutes = 15, Name = "15 Minutes"};
            Durations = new List<DrillDuration>
                            {
                                new DrillDuration{Minutes = 5, Name = "5 Minutes"},
                                new DrillDuration{Minutes = 10, Name = "10 Minutes"},
                                defaultDuration,
                                new DrillDuration{Minutes = 20, Name = "20 Minutes"},
                                new DrillDuration{Minutes = 25, Name = "25 Minutes"},
                                new DrillDuration{Minutes = 30, Name = "30 Minutes"},
                                new DrillDuration{Minutes = 45, Name = "45 Minutes"},
                                new DrillDuration{Minutes = 60, Name = "60 Minutes"},
                            };

            SelectedDuration = defaultDuration;
        }

 public GameProcessor(IImporterRepository importerRepository, IEventRepository eventRepository, IGamePlayFactory gamePlayFactory, IGameEventsFactory gameEventsFactory)
 {
     _importerRepository = importerRepository;
     _eventRepository = eventRepository;
     _gamePlayFactory = gamePlayFactory;
     _gameEventsFactory = gameEventsFactory;
 }

 public SessionPlugin(ICacheClient cacheClient, IEventRepository eventRepository, AssignToStackAction assignToStack, UpdateStatsAction updateStats, LocationPlugin locationPlugin, ILoggerFactory loggerFactory = null) : base(loggerFactory) {
     _cacheClient = new ScopedCacheClient(cacheClient, "session");
     _eventRepository = eventRepository;
     _assignToStack = assignToStack;
     _updateStats = updateStats;
     _locationPlugin = locationPlugin;
 }

 public HomeController(IRepository<Post> repo, IRepository<Category> category, IEventRepository Event, IRepository<PopularCourse> popularCourses)
 {
     _eventRepo = Event;
     _postRepo = repo;
     _categoryRepo = category;
     _popularCoursesRepo = popularCourses;
 }

        public static Event GetLastQueueEvent(IEventRepository eventRepository, Monitors monitor, Pmta pmta, string queue)
        {
            var events = eventRepository.GetAll().Where(e => e.Monitor == monitor && !e.ResetEventId.HasValue && e.EventName != EventNames.ResetTime 
                                                             && e.EventActions.Any(ed => ed.PmtaId == pmta.PmtaId && ed.PmtaQueue.ToLower() == queue.ToLower()));

            return events.Any() ? events.OrderByDescending(e=>e.DateCreated).First() : null;
        }

        public ListingViewModel( INavigationService navigationService, IEventRepository eventRepository)
        {
            _navigationService = navigationService;
            _eventRepository = eventRepository;

            PageTitle = "Teams Listing";
        }

        public PlayerCreationViewModel(INavigationService navigationService, IEventRepository eventRepository)
        {
            _navigationService = navigationService;
            _eventRepository = eventRepository;

            PageTitle = "Player Maintenance";
        }

 public GameEventLandingViewModel(IEventRepository eventRepository, IDrillsRepository drillsRepository,
     INavigationService navigationService, ITileService tileService)
 {
     _eventRepository = eventRepository;
     _drillsRepository = drillsRepository;
     _navigationService = navigationService;
     _tileService = tileService;
 }

        public BlogRepository(ISpeakerRepository speakerRepository, IEventRepository eventRepository, IOptions<AppSettings> appSettings)
        {
            this.speakerRepository = speakerRepository;
            this.appSettings = appSettings;
            this.eventRepository = eventRepository;

            loadData().Wait();
        }

        public EventService(IEventRepository eventRepository, IReferenceGenerator referenceGenerator)
        {
            Check.If(eventRepository).IsNotNull();
            Check.If(referenceGenerator).IsNotNull();

            _eventRepository = eventRepository;
            _referenceGenerator = referenceGenerator;
        }

 public ReportingTicketsController(IEventRepository eventRepo, 
     IEventSeriesRepository seriesRepo, 
     ITicketRepository ticketsRepo)
 {
     eventRepository = eventRepo;
     seriesRepository = seriesRepo;
     ticketsRepository = ticketsRepo;
 }

 public PostController(IRepository<Post> repo, IRepository<Category>
     category, IEventRepository Event, IRepository<Image> image)
 {
     _eventRepo = Event;
     _postRepo = repo; _postRepo.Model = _eventRepo.Model;
     _categoryRepo = category; _categoryRepo.Model = _eventRepo.Model;
     _imgRepo = image; _imgRepo.Model = _eventRepo.Model;
 }

 public RemoveProjectWorkItemHandler(IProjectRepository projectRepository, IEventRepository eventRepository, IStackRepository stackRepository, ITokenRepository tokenRepository, IWebHookRepository webHookRepository, ICacheClient cacheClient, IMessageBus messageBus, ILoggerFactory loggerFactory = null) : base(loggerFactory) {
     _projectRepository = projectRepository;
     _eventRepository = eventRepository;
     _stackRepository = stackRepository;
     _tokenRepository = tokenRepository;
     _webHookRepository = webHookRepository;
     _lockProvider = new CacheLockProvider(cacheClient, messageBus);
 }