public RemoteDataService(IDataSource dataSource, IAppSettings appSettings)
        {
            _appSettings = appSettings;
            _dataSource = dataSource;

            _httpClient = new HttpClient();
        }

 public GroupDetailsViewModel(IAppSettings appSettings, IDataServiceFactory dataServiceFactory, IMvxResourceLoader resourceLoader)
     : base(appSettings)
 {
     _dataServiceFactory = new DataServiceFactory(appSettings, _resourceLoader);
     _resourceLoader = resourceLoader;
     _groupedItems = new ObservableCollection<Group<Item>>();
 }

        public FourSquareOAuth2Provider(IAppSettings appSettings)
            : base(appSettings, Realm, Name)
        {
            this.AuthorizeUrl = this.AuthorizeUrl ?? Realm;
            this.AccessTokenUrl = this.AccessTokenUrl ?? "https://foursquare.com/oauth2/access_token";
            this.UserProfileUrl = this.UserProfileUrl ?? "https://api.foursquare.com/v2/users/self";

            // https://developer.foursquare.com/overview/versioning
            DateTime versionDate;
            if (!DateTime.TryParse(appSettings.GetString("oauth.{0}.Version".Fmt(Name)), out versionDate)) 
                versionDate = DateTime.UtcNow;

            // version dates before June 9, 2012 will automatically be rejected
            if (versionDate < new DateTime(2012, 6, 9))
                versionDate = DateTime.UtcNow;
            
            this.Version = versionDate;

            // Profile Image URL requires dimensions (Width x height) in the URL (default = 64x64 and minimum = 16x16)
            int profileImageWidth;
            if (!int.TryParse(appSettings.GetString("oauth.{0}.ProfileImageWidth".Fmt(Name)), out profileImageWidth))
                profileImageWidth = 64;

            this.ProfileImageWidth = Math.Max(profileImageWidth, 16);

            int profileImageHeight;
            if (!int.TryParse(appSettings.GetString("oauth.{0}.ProfileImageHeight".Fmt(Name)), out profileImageHeight))
                profileImageHeight = 64;

            this.ProfileImageHeight = Math.Max(profileImageHeight, 16);

            Scopes = appSettings.Get("oauth.{0}.Scopes".Fmt(Name), new[] { "basic" });
        }

        public Nemesis(IAppSettings appSettings)
        {
            if (appSettings == null)
                throw new ArgumentNullException("appSettings");

            _value = appSettings.ServiceCallNemesis;
        }

        public LimitProviderBaseTests()
        {
            keyGenerator = A.Fake<ILimitKeyGenerator>();
            appSetting = A.Fake<IAppSettings>();

            limitProvider = new LimitProviderBase(keyGenerator, appSetting);
        }

        public SamlAuthProvider(IAppSettings appSettings, string authRealm, string provider, X509Certificate2 signingCert)            
        {
            Logger.Info("SamlAuthProvider Starting up for Realm: {0}, Provider: {1}".Fmt(authRealm, provider));
            this.AuthRealm = appSettings != null ? appSettings.Get("SamlRealm", authRealm) : authRealm;
            this.Provider = provider;
            this.SamlSigningCert = signingCert;
            if(appSettings != null)
            {
                this.CallbackUrl = appSettings.GetString("saml.{0}.CallbackUrl".Fmt(provider)) ?? this.FallbackConfig(appSettings.GetString("saml.CallbackUrl"));
                this.IdpInitiatedRedirect = appSettings.GetString("saml.{0}.IdpInitiatedRedirect".Fmt(provider)) ?? this.FallbackConfig(appSettings.GetString("saml.IdpInitiatedRedirect"));
                this.RedirectUrl = appSettings.GetString("saml.{0}.RedirectUrl".Fmt(provider)) ?? this.FallbackConfig(appSettings.GetString("saml.RedirectUrl"));
                this.LogoutUrl = appSettings.GetString("saml.{0}.LogoutUrl".Fmt(provider)) ?? this.FallbackConfig(appSettings.GetString("saml.LogoutUrl"));
                this.Issuer = appSettings.GetString("saml.{0}.Issuer".Fmt(provider)) ?? this.FallbackConfig(appSettings.GetString("saml.Issuer"));
                this.AuthorizeUrl = appSettings.GetString("saml.{0}.AuthorizeUrl".Fmt(provider)) ?? this.FallbackConfig(appSettings.GetString("saml.AuthorizeUrl"));
                this.SamlResponseFormKey = appSettings.GetString("saml.{0}.ResponseFormKey".Fmt(provider)) ?? this.FallbackConfig(appSettings.GetString("saml.ResponseFormKey"));
                Logger.Info("Obtained the following settings from appSettings");
                Logger.Info(new
                {
                    this.CallbackUrl,
                    this.RedirectUrl,
                    this.LogoutUrl,
                    this.Issuer,
                    this.AuthorizeUrl,
                    this.SamlResponseFormKey
                }.ToJson());
            }

            
        }

		public AccountSettingsViewModel(
			INavigation navigation,
			IAppSettings appSettings)
			: base(navigation)
		{
			this.appSettings = appSettings;
		}

 public HomeController(IMessageCounter messageCounter, IDataService dataService, IConfiguration configuration, IAppSettings appSettings)
 {
     _messageCounter = messageCounter;
     _dataService = dataService;
     _configuration = configuration;
     _appSettings = appSettings;
 }

 public MailRuAuthProvider(IAppSettings appSettings)
     : base(appSettings, Realm, Name)
 {
     this.AuthorizeUrl = this.AuthorizeUrl ?? Realm;
     this.AccessTokenUrl = this.AccessTokenUrl ?? "https://connect.mail.ru/oauth/token";
     this.UserProfileUrl = this.UserProfileUrl ?? "https://www.appsmail.ru/platform/api";
 }

        protected virtual void Init(IAppSettings appSettings = null)
        {
            InitSchema = true;
            RequireSecureConnection = true;
            Environments = DefaultEnvironments;
            KeyTypes = DefaultTypes;
            KeySizeBytes = DefaultKeySizeBytes;
            CreateApiKeyFn = CreateApiKey;

            if (appSettings != null)
            {
                InitSchema = appSettings.Get("apikey.InitSchema", true);
                RequireSecureConnection = appSettings.Get("apikey.RequireSecureConnection", true);

                var env = appSettings.GetString("apikey.Environments");
                if (env != null)
                    Environments = env.Split(ConfigUtils.ItemSeperator);

                var type = appSettings.GetString("apikey.KeyTypes");
                if (type != null)
                    KeyTypes = type.Split(ConfigUtils.ItemSeperator);

                var keySize = appSettings.GetString("apikey.KeySizeBytes");
                if (keySize != null)
                    KeySizeBytes = int.Parse(keySize);
            }

            ServiceRoutes = new Dictionary<Type, string[]>
            {
                { typeof(GetApiKeysService), new[] { "/apikeys", "/apikeys/{Environment}" } },
                { typeof(RegenrateApiKeysService), new [] { "/apikeys/regenerate", "/apikeys/regenerate/{Environment}" } },
            };
        }

 public AppConfig(IAppSettings appSettings)
 {
     this.Env = appSettings.Get("Env", Env.Local);
     this.EnableCdn = appSettings.Get("EnableCdn", false);
     this.CdnPrefix = appSettings.Get("CdnPrefix", "");
     this.AdminUserNames = appSettings.Get("AdminUserNames", new List<string>());
 }

 public FacebookAuthProvider(IAppSettings appSettings)
     : base(appSettings, Realm, Name, "AppId", "AppSecret")
 {
     this.AppId = appSettings.GetString("oauth.facebook.AppId");
     this.AppSecret = appSettings.GetString("oauth.facebook.AppSecret");
     this.Permissions = appSettings.Get("oauth.facebook.Permissions", new string[0]);
 }

 public static FluentConfiguration ConfigureDatabase(this FluentConfiguration config, IAppSettings appSettings)
 {
     #if DEBUG
         return config.DebugDatabase();
     #endif
         return config.ProductionDatabase();
 }

 public AdministrationViewModel(ICustomAppearanceManager appearanceManager, IAppSettings appSettings)
 {
     this.appearanceManager = appearanceManager;
     this.appSettings = appSettings;
     selectedAccentColor = appearanceManager.AccentColor;
     selectedTextColor = appearanceManager.TextColor;
 }

 public GithubAuthProvider(IAppSettings appSettings)
     : base(appSettings, Realm, Name, "ClientId", "ClientSecret")
 {
     ClientId = appSettings.GetString("oauth.github.ClientId");
     ClientSecret = appSettings.GetString("oauth.github.ClientSecret");
     Scopes = appSettings.Get("oauth.github.Scopes", new[] { "user" });
 }

		public void Setup()
		{
			var tcb = new TestControllerBuilder();
			context = new AuthorizationContext {HttpContext = tcb.HttpContext};
			appSettings = MockRepository.GenerateStub<IAppSettings>();
			filter = new EnsureSsl(appSettings);
		}

        public TodoModule(IAppSettings appSettings, ITodoService todoService, IServiceBus bus)
        {
            _todoService = todoService;
            _bus = bus;

            Post["/todo"] = _ =>
            {
                var slashCommand = this.Bind<SlashCommand>();
                if (slashCommand == null ||
                    slashCommand.command.Missing())
                {
                    Log.Info("Rejected an incoming slash command (unable to parse request body).");
                    return HttpStatusCode.BadRequest.WithReason("Unable to parse slash command.");
                }
                if (!appSettings.Get("todo:slackSlashCommandToken").Equals(slashCommand.token))
                {
                    Log.Info("Blocked an unauthorized slash command.");
                    return HttpStatusCode.Unauthorized.WithReason("Missing or invalid token.");
                }
                if (!slashCommand.command.Equals("/todo", StringComparison.InvariantCultureIgnoreCase))
                {
                    Log.Info("Rejected an incoming slash command ({0} is not handled by this module).", slashCommand.command);
                    return HttpStatusCode.BadRequest.WithReason("Unsupported slash command.");
                }

                var responseText = HandleTodo(slashCommand);
                if (responseText.Missing())
                {
                    return HttpStatusCode.OK;
                }
                return responseText;
            };
        }

 public LoginViewModel(IAuthenticationService authenticationService, IAppSettings appSettings, IDialogService dialogService, IStatisticsService statisticsService)
 {
     _authenticationService = authenticationService;
     _appSettings = appSettings;
     _dialogService = dialogService;
     _statisticsService = statisticsService;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="YammerAuthProvider"/> class.
 /// </summary>
 /// <param name="appSettings">
 /// The application settings (in web.config).
 /// </param>
 public YammerAuthProvider(IAppSettings appSettings)
     : base(appSettings, appSettings.GetString("oauth.yammer.Realm"), Name, "ClientId", "AppSecret")
 {
     this.ClientId = appSettings.GetString("oauth.yammer.ClientId");
     this.ClientSecret = appSettings.GetString("oauth.yammer.ClientSecret");
     this.PreAuthUrl = appSettings.GetString("oauth.yammer.PreAuthUrl");
 }

		HexBoxFileTabContentCreator(Lazy<IHexDocumentManager> hexDocumentManager, IMenuManager menuManager, IHexEditorSettings hexEditorSettings, IAppSettings appSettings, Lazy<IHexBoxUndoManager> hexBoxUndoManager) {
			this.hexDocumentManager = hexDocumentManager;
			this.menuManager = menuManager;
			this.hexEditorSettings = hexEditorSettings;
			this.appSettings = appSettings;
			this.hexBoxUndoManager = hexBoxUndoManager;
		}