public override void Configure(Funq.Container container)
        {
            //Set JSON web services to return idiomatic JSON camelCase properties
            ServiceStack.Text.JsConfig.EmitCamelCaseNames = true;
            ControllerBuilder.Current.SetControllerFactory(new FunqControllerFactory(container));
            var appSettings = new AppSettings();
            var connString = appSettings.Get("SQLSERVER_CONNECTION_STRING",
                                             ConfigUtils.GetConnectionString("UserAuth"));
            container.Register<IDbConnectionFactory>(
                new OrmLiteConnectionFactory(connString, SqlServerDialect.Provider));

            //Using an in-memory cache
            container.Register<ICacheClient>(new MemoryCacheClient());
            ConfigureAuth(container);
            var dbFactory = container.Resolve<IDbConnectionFactory>();
            dbFactory.Run(d => d.CreateTableIfNotExists<UserAuth>());
            dbFactory.Run(db => db.CreateTableIfNotExists<Message>());
            dbFactory.Run(d => d.CreateTableIfNotExists<Device>());

            SetConfig(new EndpointHostConfig
            {
                DefaultContentType = ContentType.Json,
                EnableFeatures = Feature.All.Remove(Feature.Html).Remove(Feature.Xml),
                AppendUtf8CharsetOnContentTypes = new HashSet<string> { ContentType.Json }
            });
            //Or if Haz Redis
            //container.Register<ICacheClient>(new PooledRedisClientManager());
        }

        public void And_settings_file_does_not_exist_it_should_be_created()
        {
            var fileName = Guid.NewGuid() + ".config";
            var fullPathToConfigurationFile = TestHelpers.GetFullPathToConfigurationFile(fileName);

            try
            {
                Assert.IsFalse(System.IO.File.Exists(fullPathToConfigurationFile));

                var settings = new AppSettings(fullPathToConfigurationFile, FileOption.None);

                settings.SetValue("string", "a");
                settings.SetValue<int>("int", 1);
                settings.SetValue<int?>("nullableint", null);

                settings.Save();

                Assert.IsTrue(System.IO.File.Exists(fullPathToConfigurationFile));
                Assert.IsTrue(settings.FileExists);
            }
            finally
            {
                TestHelpers.DeleteIfExists(fullPathToConfigurationFile);
            }
        }

    public WindowMain()
    {
      InitializeComponent();

      fAppSettings = new AppSettings();
      fLastScanned = PageTypeEnum.Letter;

      fScanner = new Scanner();
      fPrinter = new Printer();
      fPdfExporter = new PdfExporter();
      fPdfImporter = new PdfImporter();
      fImageLoader = new ImageLoader();
      fImageSaver = new ImageSaver();

      fDocument = new Document();
      fDocument.OnPageAdded += fDocument_OnPageAdded;
      fDocument.OnPageRemoved += fDocument_OnPageRemoved;
      fDocument.OnPageUpdated += fDocument_OnPageUpdated;
      fDocument.OnPageMoved += fDocument_OnPageMoved;
       
      fInsertionMark = new InsertionMark();
      fDragStartItem = null;
      fScrollTimer = new System.Timers.Timer(150);
      fScrollTimer.Elapsed += fScrollTimer_Elapsed;
      fScrollTimer.AutoReset = false;

      this.KeyUp += WindowMain_KeyUp;

      fClosing = false;
      fDeleting = false;
    }

        public static void Main(string[] args)
        {
            try
            {
                // Open the default app.config file which in this case is SimpleExample.exe.config
                // and it is located in the same folder as the SimpleExample.exe.
                settings = AppSettings.CreateForAssembly(Assembly.GetEntryAssembly(), FileOption.FileMustExist);

                // If you want to know the full path to the configuration file, use the FullPath property
                Console.WriteLine("Full path to configuration file is: {0}", settings.FullPath);

                ReadStringValues();
                ReadStandardDataTypes();
                ReadEnumerations();
                ReadNullableValues();
                ReadUsingCustomFormatProvider();
                ReadOptionalValues();
                ReadUsingCustomConversionFunction();
                ReadConnectionString();
                ReadingCustomConfigurationFile();

                UpdatingValues();
                CreatingAppSettings();
            }
            catch (Exception exp)
            {
                Console.Error.WriteLine(exp.Message);
                throw;
            }
        }

    public FormMain()
    {
      InitializeComponent();
      this.Text = AppInfo.GetApplicationName();

      // Create PictureBoxPreview from special component;
      this.PictureBoxPreview = new Cyotek.Windows.Forms.ImageBox();
      this.PictureBoxPreview.Dock = System.Windows.Forms.DockStyle.Fill;
      this.PictureBoxPreview.TabStop = false;
      this.PictureBoxPreview.BorderStyle = BorderStyle.None;
      this.PictureBoxPreview.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
      this.PanelPreview.Controls.Add(this.PictureBoxPreview);

      fAppSettings = new AppSettings();

      fScanner = new Scanner();
      fPrinter = new Printer();
      fPdfExporter = new PdfExporter();
      fPdfImporter = new PdfImporter();
      fImageLoader = new ImageLoader();
      fImageSaver = new ImageSaver();

      fDocument = new Document();
      fDocument.OnPageAdded += fDocument_OnPageAdded;
      fDocument.OnPageRemoved += fDocument_OnPageRemoved;
      fDocument.OnPageUpdated += fDocument_OnPageUpdated;
      fDocument.OnPageMoved += fDocument_OnPageMoved;

      fClosing = false;
      fDeleting = false;

      MenuSettingsPrinterUsePreview.Checked = true;
    }

        public void SaveReportSettings(AgrimanagrReportSettingViewModel setting)
        {
            var reporturl = _settingsRepository.GetByKey(SettingsKeys.ReportServerUrl);
            if (reporturl == null) reporturl = new AppSettings(Guid.NewGuid());
            reporturl.Key = SettingsKeys.ReportServerUrl;
            reporturl.Value = setting.Server;
            _settingsRepository.Save(reporturl);

            var reportusername = _settingsRepository.GetByKey(SettingsKeys.ReportServerUsername);
            if (reportusername == null) reportusername = new AppSettings(Guid.NewGuid());
            reportusername.Key = SettingsKeys.ReportServerUsername;
            reportusername.Value = setting.ReportUsername;
            _settingsRepository.Save(reportusername);

            var reportpassword = _settingsRepository.GetByKey(SettingsKeys.ReportServerPassword);
            if (reportpassword == null) reportpassword = new AppSettings(Guid.NewGuid());
            reportpassword.Key = SettingsKeys.ReportServerPassword;
            reportpassword.Value = VCEncryption.EncryptString(setting.ReportPassword);
            _settingsRepository.Save(reportpassword);

            var reportfolder = _settingsRepository.GetByKey(SettingsKeys.ReportServerFolder);
            if (reportfolder == null) reportfolder = new AppSettings(Guid.NewGuid());
            reportfolder.Key = SettingsKeys.ReportServerFolder;
            reportfolder.Value = setting.ReportFolder;
            _settingsRepository.Save(reportfolder);
        }

        public AppSettings GetAppSettings()
        {
            var _appConfig = new AppSettings()
            {
                TenantAdminUrl = ConfigurationHelper.Get(TENANT_ADMIN_URL_KEY),
                SPHostUrl = ConfigurationHelper.Get(SPHOSTURL_KEY),
                ClientID = ConfigurationHelper.Get(CLIENTID_KEY),
                ClientSecret = ConfigurationHelper.Get(CLIENTSECRET_KEY),
                SupportEmailNotification = ConfigurationHelper.Get(SUPPORTTEAMNOTIFICATION_KEY),
            };

            ////TODO ENCRYPTION
            //_appConfig.TenantAdminAccount = ConfigurationHelper.Get(TENANTADMINACCOUNT_KEY);
            //_appConfig.TenantAdminAccountPwd = ConfigurationHelper.Get(TENANTADMINACCOUNTPWD_KEY);

            // we need to handle the boolean checks
            var _autoApprove = ConfigurationHelper.Get(AUTOAPPROVESITES_KEY);

            bool _result = false;
            if(Boolean.TryParse(_autoApprove, out _result)) {
                _appConfig.AutoApprove = _result;
            }
         
            return _appConfig;
        }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddSingleton<AppSettings>(s =>
            {
                var appSettings = new AppSettings();
                Configuration.GetSection("AppSettings").Bind(appSettings);
                return appSettings;
            });

            services.AddSingleton<Client>(s =>
            {
                var appEnv = s.GetService<IApplicationEnvironment>();
                var settings = s.GetService<AppSettings>();

                var markdownCache = new SqliteMarkdownCache(
                    Path.Combine(
                        appEnv.ApplicationBasePath,
                        "releases-db.sqlite"));

                return new Client(
                    settings.AccessToken,
                    markdownCache,
                    s.GetService<ILogger<Client>>(),
                    string.IsNullOrEmpty(settings.Company) ? Client.DefaultUserAgent : settings.Company
                );
            });

            services.AddLogging();

            // Add framework services.
            services.AddMvc();
        }

 public ProfileLoader(IFileSystem fileSystem, IDirectorySystem directorySystem, IAppDirectoriesBuilder appDirBuilder, AppSettings settings)
 {
     _fileSystem = fileSystem;
     _directorySystem = directorySystem;
     _appDirBuilder = appDirBuilder;
     _settings = settings;
 }

        private void ListBoxItem_Tap(object sender, System.Windows.Input.GestureEventArgs e)
        {
            AppSettings settings = new AppSettings();

            ListBoxItem item = sender as ListBoxItem;
            settings.SearchItem = (item.Content.ToString());
        }

 public MainPage()
 {
     this.InitializeComponent();
     this.NavigationCacheMode = NavigationCacheMode.Required;
     _settings = new AppSettings();
     UIHelper.ShowSystemTrayAsync(Color.FromArgb(255, 48, 169, 62), Colors.White);
 }

        public SettingsPage()
        {
            InitializeComponent();
            settings = new AppSettings();

            if (settings.GPSModeSetting == GPSMode.Automatic)
            {
                GPSModeSwitch.IsChecked = true;
                LatitudeTextBox.IsEnabled = false;
                LongitudeTextBox.IsEnabled = false;
            }
            else
            {
                GPSModeSwitch.IsChecked = false;
                LatitudeTextBox.IsEnabled = true;
                LongitudeTextBox.IsEnabled = true;
            }

            LatitudeTextBox.Text = settings.GPSLatitudeSetting.ToString("0.000").Replace(",", ".");
            LongitudeTextBox.Text = settings.GPSLongitudeSetting.ToString("0.000").Replace(",", ".");

            if (settings.TemperatureUnitSetting == TemperatureUnit.C)
            {
                CelciusRadioButton.IsChecked = true;
            }
            else if (settings.TemperatureUnitSetting == TemperatureUnit.F)
            {
                FahrenheitRadioButton.IsChecked = true;
            }

        }

        public VibrateListBoxPage()
        {
            InitializeComponent();

            mainSettings = new AppSettings();

            // Vibrate Device
            MainVibrateController = VibrateController.Default;

            // Events
            TrillVibrate.Tap += TrillVibrate_Tap;
            TrillVibrateButton.Tap += TrillVibrateButton_Tap;
            SpicatoVibrate.Tap += SpicatoVibrate_Tap;
            SpicatoVibrateButton.Tap += SpicatoVibrateButton_Tap;
            PizzicatoVibrate.Tap += PizzicatoVibrate_Tap;
            PizzicatoVibrateButton.Tap += PizzicatoVibrateButton_Tap;
            StaccatoVibrate.Tap += StaccatoVibrate_Tap;
            StaccatoVibrateButton.Tap += StaccatoVibrateButton_Tap;
            TenutoVibrate.Tap += TenutoVibrate_Tap;
            TenutoVibrateButton.Tap += TenutoVibrateButton_Tap;
            FermataVibrate.Tap += FermataVibrate_Tap;
            FermataVibrateButton.Tap += FermataVibrateButton_Tap;
            SnakeVibrate.Tap += SnakeVibrate_Tap;
            SnakeVibrateButton.Tap += SnakeVibrateButton_Tap;
            ZigZagVibrate.Tap += ZigZagVibrate_Tap;
            ZigZagVibrateButton.Tap += ZigZagVibrateButton_Tap;
            RandomVibrate.Tap += RandomVibrate_Tap;
            RandomVibrateButton.Tap += RandomVibrateButton_Tap;
        }

 public TeamReportRound()
 {
     var appSettings = new AppSettings();
     Name = appSettings.ReportRoundName;
     StartTime = appSettings.ReportStartTime;
     EndTime = appSettings.ReportEndTime;
 }

 public GravatarProvider(
     IOptions<AppSettings> appSettings
     , ApplicationUserManager userManager)
 {
     _appSettings = appSettings.Value;
     _userManager = userManager;
 }

        public override void Configure(Funq.Container container)
        {
            //Set JSON web services to return idiomatic JSON camelCase properties
            ServiceStack.Text.JsConfig.EmitCamelCaseNames = true;

            var connectionString = ConfigurationManager.ConnectionStrings["conString"].ToString();
            Register<IDbConnectionFactory>(new OrmLiteConnectionFactory(connectionString, SqlServerDialect.Provider));

            var appSettings = new AppSettings();
            Plugins.Add(new AuthFeature(() => new AuthUserSession(), new IAuthProvider[]
                {
                    new CredentialsAuthProvider(),
                    new FacebookAuthProvider(appSettings),
                    new GoogleOpenIdOAuthProvider(appSettings),
                }));

            Plugins.Add(new RegistrationFeature());

            var userRep = new OrmLiteAuthRepository(container.Resolve<IDbConnectionFactory>());
            container.Register<IUserAuthRepository>(userRep);
            var redisCon = ConfigurationManager.AppSettings["redisUrl"].ToString();
            container.Register<IRedisClientsManager>(new PooledRedisClientManager(20, 60, redisCon));
            container.Register<ICacheClient>(c => (ICacheClient)c.Resolve<IRedisClientsManager>().GetCacheClient());

            userRep.CreateMissingTables();
            //Set MVC to use the same Funq IOC as ServiceStack
            ControllerBuilder.Current.SetControllerFactory(new FunqControllerFactory(container));
        }

		public App()
		{
			this.InitializeComponent();

			// Note that the constructor does not run on the UI thread.

#if DEBUG
			Log.Default.RegisterListener(new DebugLogListener());
#endif

			// AutoFlush means it can be a bit slow, unfortunately... do not use like this in real production scenario.
			var logFileStream = File.Open(LogFilePath, FileMode.Create, FileAccess.ReadWrite, FileShare.Read);
			Log.Default.RegisterListener(new StreamWriterLogListener(new StreamWriter(logFileStream, Encoding.UTF8)
			{
				AutoFlush = true
			}));

			Settings = new AppSettings();

			_log.Debug(Helpers.Debug.ToDebugString(Settings));

			Suspending += OnSuspending;
			Resuming += OnResuming;
			UnhandledException += OnUnhandledException;
		}

        public void And_connection_string_does_not_exist_Then_connection_string_should_be_stored()
        {
            var settings = new AppSettings("NonExistingFile", FileOption.None);
            settings.SetConnectionString("cs", "a");

            Assert.AreEqual("a", settings.GetConnectionString("cs"));
        }

        /* Uncomment to enable ServiceStack Authentication and CustomUserSession */
        private void ConfigureAuth(Funq.Container container)
        {
            var appSettings = new AppSettings();

            //Default route: /auth/{provider}
            Plugins.Add(new AuthFeature(() => new CustomUserSession(),
                new IAuthProvider[] {
                    new CredentialsAuthProvider(appSettings),
                    new FacebookAuthProvider(appSettings),
                    new TwitterAuthProvider(appSettings),
                    new BasicAuthProvider(appSettings),
                }));

            //Default route: /register
            Plugins.Add(new RegistrationFeature());

            //Requires ConnectionString configured in Web.Config
            var connectionString = ConfigurationManager.ConnectionStrings["AppDb"].ConnectionString;
            container.Register<IDbConnectionFactory>(c =>
                new OrmLiteConnectionFactory(connectionString, SqlServerDialect.Provider));

            container.Register<IUserAuthRepository>(c =>
                new OrmLiteAuthRepository(c.Resolve<IDbConnectionFactory>()));

            container.Resolve<IUserAuthRepository>().InitSchema();
        }

 public VkontakteLoginViewModel(
     INavigationService navigationService,
     AppSettings appSettings,
     UsersRestService usersRestService)
     : base(navigationService, appSettings, usersRestService)
 {
 }