public RouteQueryModule(ISettingsProvider settingsProvider)
            : base("/query")
        {
            _settingsProvider = settingsProvider;
            this.EnableCors();

            Get["/stations"] =
                parameters =>
                    {
                        IEnumerable<IStation> stations = GetStations();
                        return stations != null
                                   ? Response.AsJson(stations).WithContentType(@"application/json; charset=utf-8")
                                   : new Response().WithStatusCode(HttpStatusCode.InternalServerError);
                    };
            Get["/station/{StationId}"] =
                parameters =>
                    {
                        IEnumerable<IRoute> stationRoutes = GetStationRoutes(parameters.StationId);
                        return stationRoutes != null
                                   ? Response.AsJson(stationRoutes)
                                   : new Response().WithStatusCode(HttpStatusCode.InternalServerError);
                    };
            Get["/date/{Date}/route/{TrainNo}/from/{FromId}/to/{ToId}"] =
                parameters =>
                    {
                        DateTime date = DateTime.ParseExact(parameters.Date, "yyyyMMdd", CultureInfo.InvariantCulture);
                        IEnumerable<ITrainRoute> trainRoutes = GetTrainRoutes(date, parameters.TrainNo, parameters.FromId, parameters.ToId);
                        return trainRoutes != null
                                   ? Response.AsJson(trainRoutes)
                                   : new Response().WithStatusCode(HttpStatusCode.InternalServerError);
                    };
        }

 public ProjectSyncConfiguration(ISettingsProvider provider)
 {
     var ignored = provider.GetSettings("IgnoreDirectories");
     IgnoredDirectories = string.IsNullOrEmpty(ignored)
         ? new string[] {}
         : ignored.Split(',').Select(x => x.Trim()).ToArray();
 }

 public AssemblyBusServiceConfigurator(IEnumerable<IEndpointSpecification> endpointSpecifications, IServiceSpecification serviceSpecification,
     ISettingsProvider settingsProvider)
 {
     _serviceSpecification = serviceSpecification;
     _settingsProvider = settingsProvider;
     _endpointSpecifications = endpointSpecifications.ToArray();
 }

		public TestableSolutionPackageRepository (
			ISolution solution,
			IMonoDevelopPackageRepositoryFactory repositoryFactory,
			ISettingsProvider settingsProvider)
			: base (solution, repositoryFactory, settingsProvider)
		{
		}

        public DeploymentSettingsPrioritiesTests()
        {
            var settingsPriority1 = new Dictionary<string, string>();
            settingsPriority1["key1"] = "settingsPriority1_value1";
            settingsPriority1["key2"] = "settingsPriority1_value2";
            settingsPriority1["key3"] = "settingsPriority1_value3";
            settingsPriority1["key4"] = "settingsPriority1_value4";

            var settingsPriority2 = new Dictionary<string, string>();
            settingsPriority1["key2"] = "settingsPriority2_value2";
            settingsPriority1["key3"] = "settingsPriority2_value3";
            settingsPriority1["key5"] = "settingsPriority2_value5";
            settingsPriority1["key6"] = "settingsPriority2_value6";

            var settingsPriority50 = new Dictionary<string, string>();
            settingsPriority1["key1"] = "settingsPriority50_value1";
            settingsPriority1["key2"] = "settingsPriority50_value2";
            settingsPriority1["key5"] = "settingsPriority50_value5";
            settingsPriority1["key7"] = "settingsPriority50_value7";

            var testProvider1 = new BasicSettingsProvider(settingsPriority1, (SettingsProvidersPriority)1);
            var testProvider2 = new BasicSettingsProvider(settingsPriority2, (SettingsProvidersPriority)2);
            var testProvider50 = new BasicSettingsProvider(settingsPriority50, (SettingsProvidersPriority)50);
            var settingsProviders = new ISettingsProvider[] { testProvider1, testProvider50, testProvider2 };

            PerSiteSettingsProvider perSiteSettings = null;
            deploymentSettingsManager = new DeploymentSettingsManager(perSiteSettings, settingsProviders);
        }

 // ReSharper restore UnusedAutoPropertyAccessor.Global
 //public InstallController(Func<IProviderInfo<IDatabaseProvider>> databaseProvidersInfo)
 public InstallController(IDatabaseProvider databaseProvider, Func<IProviderInfo<IDatabaseProvider>> databaseProvidersInfo, ISettingsProvider settingsProvider, IFederatedAuthenticationService federatedAuthenticationService)
 {
     this.databaseProvider = databaseProvider;
     this.databaseProvidersInfo = databaseProvidersInfo;
     this.settingsProvider = settingsProvider;
     this.federatedAuthenticationService = federatedAuthenticationService;
 }

 public TestIndicesUtilCustomization(
     IRequestConfiguration requestConfig,
     ISettingsProvider settings = null)
 {
     this.settings = settings;
     this.requestConfig = requestConfig;
 }

 public SubActivityDao(ISession session, 
     ISettingsProvider<SubSettings> subSettings,
     ICache cache)
     : base(session, subSettings)
 {
     _cache = cache;
 }

        public TagConverter(ISettingsProvider settingsProvider)
        {
            using (var reader = new StreamReader(settingsProvider.Get<string>(SettingsKeys.TagMappingFile)))
            {
                normalizedTags = reader
                    .ReadAllLines()
                    .Where(x => !string.IsNullOrWhiteSpace(x))
                    .Select(ParseTagDescription)
                    .ToDictionary(x => x.Name, x => x.RawTags);

                rawTagsMapping = normalizedTags
                    .SelectMany(normalizedTag => normalizedTag.Value.Select(rawTag => new { Normalized = normalizedTag.Key, Raw = rawTag }))
                    .ToDictionary(x => x.Raw, x => x.Normalized);
            }

            using (var reader = new StreamReader(settingsProvider.Get<string>(SettingsKeys.CorrectionsFile)))
            {
                correctionsByProblemUrl = reader
                    .ReadAllLines()
                    .Where(x => !string.IsNullOrWhiteSpace(x))
                    .SelectMany(ParseCorrections)
                    .GroupBy(x => x.ProblemUrl)
                    .ToDictionary(x => x.Key, x => x.ToArray());
            }
        }

        protected override void Context()
        {
            _sendEmailRequest = new SendMailRequest
                                    {
                                        To = "[email protected]",
                                        Subject = "important message for you bob",
                                        Message = "hi bob, this is not really that important. Just wanted to say hello."
                                    };

            _smtpClient = MockRepository.GenerateStub<ISmtpWrapper>();

            _smtpClient.Stub(x => x.Send(Arg<MailMessage>.Is.Anything))
                .WhenCalled(x => _mailMessagePassedToSmtpWrapper = x.Arguments[0] as MailMessage);

            _settingsProvider = MockRepository.GenerateStub<ISettingsProvider>();
            _settingsProvider.Stub(x => x.GetEmailSettings())
                .Return(new EmailSettings{AdminEmailAddress = AdminEmailAddress});

            _expectedMailMessage = new MailMessage();
            _expectedMailMessage.To.Add(_sendEmailRequest.To);
            _expectedMailMessage.From = new MailAddress(AdminEmailAddress);
            _expectedMailMessage.Subject = _sendEmailRequest.Subject;
            _expectedMailMessage.Body = _sendEmailRequest.Message;
            _expectedMailMessage.IsBodyHtml = true;

            _emailService = new EmailService(_smtpClient, _settingsProvider);
        }

        public BrowserStarter(ISettingsProvider settingsProvider)
        {
            var settings = settingsProvider.Load();

            this.ExecutablePath = settings.BrowserExecutablePath;
            this.ExecutableArguments = settings.BrowserExecutableArguments;
        }

        public SettingsViewModel(
            IScreen screen,
            ISettingsProvider settingsProvider,
            IFolderHelper folderHelper, 
            IAppContext appContext)
        {
            HostScreen = screen;

            BackCommand = new ReactiveAsyncCommand();
            BackCommand.RegisterAsyncAction(_ => HostScreen.Router.NavigateBack.Execute(null));

            SelectFolder = new ReactiveAsyncCommand();
            SelectFolder.RegisterAsyncAction(_ =>
            {
                var result = folderHelper.SelectFolder();
                if (result.Result == true) {
                    UpdateLocation = result.Folder;
                }
            }, appContext.DispatcherScheduler);

            UpdateLocation = settingsProvider.UpdateLocation;

            _IsError = this.WhenAny(vm => vm.UpdateLocation, vm => vm.Value)
                           .DistinctUntilChanged()
                           .Throttle(TimeSpan.FromMilliseconds(500))
                           .ObserveOn(appContext.DispatcherScheduler)
                           .Select(text => !IsUrlOrFolder(text))
                           .Do(error => {
                                if (!error) {
                                    settingsProvider.UpdateLocation = UpdateLocation;
                                }
                            })
                            .ToProperty(this, vm => vm.IsError, setViaReflection: false);
        }

		public SolutionPackageRepositoryPath (
			ISolution solution,
			ISettingsProvider settingsProvider)
		{
			this.solution = solution;
			PackageRepositoryPath = GetSolutionPackageRepositoryPath (settingsProvider);
		}

 public EventLogFilterRepo(ISettingsProvider settingsProvider, IEventRecordTimeSpanSearcher eventRecordTimeSpanSearcher, ICacheLayer sweetCacheLayer)
 {
     EventLogCache = sweetCacheLayer;
     ListOfServersToQuery = settingsProvider.ServersToQuery;
     SearchTermsList = settingsProvider.FilterTerm;
     EventRTimeSearcher = eventRecordTimeSpanSearcher;
 }

        public TagsController(ITagRepository tagRepository, ISettingsProvider settingsProvider)
        {
            _tagRepository = tagRepository;
            _settingsProvider = settingsProvider;

            PageSize = _settingsProvider.GetSettings().PageSize;
        }

        public DocumentViewModel(
            IDialogService dialogService,
            IWindowManager windowManager,
            ISiteContextGenerator siteContextGenerator,
            Func<string, IMetaWeblogService> getMetaWeblog,
            ISettingsProvider settingsProvider,
            IDocumentParser documentParser)
        {
            this.dialogService = dialogService;
            this.windowManager = windowManager;
            this.siteContextGenerator = siteContextGenerator;
            this.getMetaWeblog = getMetaWeblog;
            this.settingsProvider = settingsProvider;
            this.documentParser = documentParser;

            FontSize = GetFontSize();

            title = "New Document";
            Original = "";
            Document = new TextDocument();
            Post = new Post();
            timer = new DispatcherTimer();
            timer.Tick += TimerTick;
            timer.Interval = delay;
        }

 /// <summary>
 ///     Constructor.
 /// </summary>
 /// <param name="project">Project.</param>
 /// <param name="pathResolver">File path resolver.</param>
 /// <param name="settings">Settings.</param>
 public NodeLauncher(NodeProjectNode project, IPathResolver pathResolver, ISettingsProvider settings)
 {
     Utilities.ArgumentNotNull("project", project);
     _project = project;
     _pathResolver = pathResolver;
     _settings = settings;
 }

        public MongoContext()
        {
            this.settingsProvider = ServiceProvider.Current.GetService<ISettingsProvider>();
            var settings = this.settingsProvider.Get<MongoSettings>();

            GetDatabase(settings);
        }

        public void Initialize(string registrySettingsPath, IContentEditorLogger logger, IContentTarget contentTarget, ISettingsProvider settingsProvider)
        {
            try
            {
                GlobalEditorOptions.Init(contentTarget, settingsProvider);
                HtmlEditorControl.AllowCachedEditor();

                Assembly assembly = Assembly.GetExecutingAssembly();
                ApplicationEnvironment.Initialize(assembly, Path.GetDirectoryName(assembly.Location), registrySettingsPath, contentTarget.ProductName);
                ContentSourceManager.Initialize(false);

                Trace.Listeners.Clear();
                if (logger != null)
                {
                    _logger = new RedirectionLogger(logger);

                    Trace.Listeners.Add(_logger);
                }

#if DEBUG
                Trace.Listeners.Add(new DefaultTraceListener());
#endif
            }
            catch (Exception e)
            {
                Trace.Fail("Failed to initialize Shared Canvas: " + e);
                Trace.Flush();
                throw;
            }
        }

        public PreferencesViewModel(ISettingsProvider settingsProvider, IScreenManager screenManager)
        {
            this.settingsProvider = settingsProvider;
            
            Screens = new ObservableCollection<DetailedScreen>(screenManager.GetScreens());

            Settings = settingsProvider.GetSettings<PopupSettings>();

            PlaceScreen();

            AvailableColors = new ObservableCollection<AvailableColor>();
            var properties = typeof(Colors).GetProperties(BindingFlags.Static | BindingFlags.Public);
            foreach (var prop in properties)
            {
                var name = prop.Name;
                var value = (Color)prop.GetValue(null, null);

                var availableColor = new AvailableColor(name, value);
                if (Settings.FontColor == name)
                    FontColor = availableColor;
                if (Settings.ItemBackgroundColor == name)
                    ItemBackgroundColor = availableColor;

                AvailableColors.Add(availableColor);
            }

            SaveCommand = new DelegateCommand(SaveSettings);
            ResetToDefaultsCommand = new DelegateCommand(() => settingsProvider.ResetToDefaults<PopupSettings>());
            VisitCommand = new DelegateCommand(Visit);
        }