public Request(IConfigurationRepository configuration, IRelyingPartyRepository relyingPartyRepository,
     IDelegationRepository delegationRepository)
 {
     _configuration = configuration;
     RelyingPartyRepository = relyingPartyRepository;
     DelegationRepository = delegationRepository;
 }

        public UrlController(IConfigurationManager configurationManager,
            IConfigurationRepository configRepository, 
            IFrontMatterRepository frontMatterRepository,
            IMarkupProcessorFactory markupProcessorFactory)
            : base(configurationManager)
        {
            if (configRepository == null)
            {
                throw new ArgumentNullException("configRepository");
            }

            if (frontMatterRepository == null)
            {
                throw new ArgumentNullException("frontMatterRepository");
            }

            if (markupProcessorFactory == null)
            {
                throw new ArgumentNullException("markupProcessorFactory");
            }

            ConfigRepository = configRepository;
            FrontMatterRepository = frontMatterRepository;
            MarkupProcessorFactory = markupProcessorFactory;
        }

        public AdministrationService(
            IUserRepository userRepository,
            IArticleRepository articleRepository,
            IRepository<ReviewTemplate> reviewTemplateRepository,
            IArticleReviewerRepository articleReviewerRepository,
            IRepository<AttributeDataType> dataTypesRepository,
            IRepository<Category> categoryRepository,
            IRepository<Degree> degreeRepository,
            IRepository<Page> pagesRepository,
            IRepository<Language> languageRepository,
            IConfigurationRepository configurationRepository,
            IRepository<ErrorLog> errorLogRepository
            )
        {
            this.userRepository = userRepository;
            this.articleRepository = articleRepository;
            this.reviewTemplateRepository = reviewTemplateRepository;
            this.articleReviewerRepository = articleReviewerRepository;
            this.dataTypesRepository = dataTypesRepository;
            this.categoryRepository = categoryRepository;
            this.degreeRepository = degreeRepository;
            this.pagesRepository = pagesRepository;
            this.languageRepository = languageRepository;
            this.configurationRepository = configurationRepository;
            this.errorLogRepository = errorLogRepository;

            callResult = new CallResult();
        }

 public OAuth2TokenController(IUserRepository userRepository, IConfigurationRepository configurationRepository, IClientsRepository clientsRepository, ICodeTokenRepository refreshTokenRepository)
 {
     UserRepository = userRepository;
     ConfigurationRepository = configurationRepository;
     ClientsRepository = clientsRepository;
     RefreshTokenRepository = refreshTokenRepository;
 }

 public CartController(ICoffeeRepository coffeeRepo, IConfigurationRepository configRepo)
 {
     this.coffeeRepo = coffeeRepo;
     this.configRepo = configRepo;
     this.M = configRepo.Configuration.Where(c => c.Name.Trim() == "m").FirstOrDefault().Value;
     this.X = configRepo.Configuration.Where(c => c.Name.Trim() == "x").FirstOrDefault().Value;
 }

 public MenuViewModel(IConfigurationRepository configuration)
 {
     this.ShowOAuthClients = configuration.OAuth2.Enabled;
     this.ShowOAuthTokens = 
         configuration.OAuth2.Enabled && 
         (configuration.OAuth2.EnableCodeFlow || configuration.OAuth2.EnableResourceOwnerFlow);
 }

 public UploadBotController(ITeamManagementCommands teamCommands, IFormsAuthentication formsAuthentication, IConfigurationRepository configurationRepository, MatchStarter matchStarter)
 {
     _teamCommands = teamCommands;
       _formsAuthentication = formsAuthentication;
       _configurationRepository = configurationRepository;
       _matchStarter = matchStarter;
 }

 public HomeController(ITeamManagementQueries teamManagementQueries, 
                       IConfigurationRepository configurationRepository)
 {
     _teamManagementQueries = teamManagementQueries;
     _configurationRepository = configurationRepository;
     ViewData["inCloud"] = RockPaperAzure.AzureHelper.IsRunningInCloud;
 }

 public SystemNetEmailService(IConfigurationRepository configurationRepository, ILoggingService loggingService)
 {
     if (configurationRepository == null) throw new ArgumentNullException("ConfigurationRepository");
     if (loggingService == null) throw new ArgumentNullException("LoggingService");
     _configurationRepository = configurationRepository;
     _loggingService = loggingService;
 }

 internal NMultifileConfiguration(IConfigurationRepository repository, 
     INSectionMergerRegistry mergerRegistry, IList<string> fileNames)
 {
     this.repository = repository;
     this.mergerRegistry = mergerRegistry;
     this.fileNames = fileNames ?? new List<string>();
 }

 public BotsController(ITeamManagementCommands teamCommands, ITeamRepository teamRepository, IConfigurationRepository configurationRepository, ILeaderboardRepository leaderboardRepository)
 {
     _teamCommands = teamCommands;
     _teamRepository = teamRepository;
     _configurationRepository = configurationRepository;
     _leaderboardRepository = leaderboardRepository;
 }

 public ProfileApiController(IUserManagementRepository userManagementRepository, IConfigurationRepository configurationRepository, IRelyingPartyRepository relyingPartyRepository)
 {
     UserManagementRepository = userManagementRepository;
     //ClientRepository = clientRepository;
     ConfigurationRepository = configurationRepository;
     RelyingPartyRepository = relyingPartyRepository;
 }

        public ProductService(
                            IProductRepository productRepository,
                            ICacheStorage cacheStorage,
                            IConfigurationRepository configurationRepository,
                            ILoggingService loggingService)
        {
            if (productRepository == null)
            {
                throw new ArgumentNullException("ProductRepository");
            }

            if (cacheStorage == null)
            {
                throw new ArgumentNullException("CacheStorage");
            }

            if (configurationRepository == null)
            {
                throw new ArgumentException("Configuration");
            }

            if (loggingService == null)
            {
                throw new ArgumentException("Logging");
            }

            this._productRepository = productRepository;
            this._cacheStorage = cacheStorage;
            this._configurationRepository = configurationRepository;
            this._loggingService = loggingService;
        }

 public OAuth2AuthorizeController(IConfigurationRepository configuration, IClientsRepository client, IRelyingPartyRepository rpRepository, ICodeTokenRepository codeTokenRepository)
 {
     Configuration = configuration;
     Clients = client;
     RPRepository = rpRepository;
     CodeTokenRepository = codeTokenRepository;
 }

 public AuthenticationController(IProtocolDiscovery defaultProtocolDiscovery, IFederationContext federationContext, IConfigurationRepository configuration)
 {
     this.protocolDiscovery = defaultProtocolDiscovery;
     this.federationContext = federationContext;
     this.configuration = configuration;
     this.multiProtocolServiceProperties = this.configuration.RetrieveMultiProtocolIssuer();
 }

        public ConfigurationController(IConfigurationRepository configurationRepository,
				       ILogger<ConfigurationController> logger,
				       IAuthenticationService authenticationService)
        {
            this._configurationRepository = configurationRepository;
            this._logger = logger;
            this._authenticationService = authenticationService;
        }

 public TestController(
     IConfigurationRepository repo,
     Services.IWorkCenterService workCenterService
     )
 {
     this.repo = repo;
     this.workCenterService = workCenterService;
 }

        public InitialSetupController(IConfigurationRepository configurationRepository, ISignin signin, ITeamManagementCommands teamCommands)
        {
            _configurationRepository = configurationRepository;
            _signin = signin;
            _teamCommands = teamCommands;

            ViewData["inCloud"] = RockPaperAzure.AzureHelper.IsRunningInCloud;
        }

 public UserAuthenticationService(IUserRepository userRepository, ISessionStateRepository sessionStateRepository, IFormsAuthenticationService formsAuthenticationService, IConfigurationRepository configurationRepository, IAvatar avatar)
 {
     UserRepository = userRepository;
     SessionStateRepository = sessionStateRepository;
     FormsAuthenticationService = formsAuthenticationService;
     ConfigurationRepository = configurationRepository;
     Avatar = avatar;
 }

 public AppViewModel(IStateMachine<States,Events> stateMachine, CheckEngine engine, IConfigurationRepository repository)
 {
     StateMachine = stateMachine;
     this.repository = repository;
     
     SelectConfigurationCommand = new RelayCommand(SelectConfiguration, () => stateMachine.CanFire(Events.SelectConfigurationSource));
     RunChecksCommand = new RelayCommand(RunChecks, () => stateMachine.CanFire(Events.RunChecks));
 }