public async static Task initializeRoutes()
        {
            //var file = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(@"routeconfig.txt");
            Assembly assem = typeof(API).GetTypeInfo().Assembly;
            var names = assem.GetManifestResourceNames();
            var stream = assem.GetManifestResourceStream("NextBusParser.routeconfig.txt");
            StreamReader reader = new StreamReader(stream);
            
            string routedata = await reader.ReadToEndAsync();

            DataSource ds = JsonConvert.DeserializeObject<DataSource>(routedata);
            _ds = ds;
            reader.Dispose();

            foreach (Route r in ds.Routes)
            {
                foreach (Direction d in r.Directions)
                {
                    for (int i = 0; i < d.Stops.Count; i++)
                    {
                        Stop s = d.Stops[i];
                        s = r.Stops.Where(e => e.Tag.Equals(s.Tag)).First();
                        d.Stops[i] = s;
                    }
                }
            }

            _isInitialized = true;
        }

        /// <summary>
        /// Get list of DBs which can be accessed by worker
        /// </summary>
        public static List<WorkerDb> LoadDatabases(DataSource source)
        {
            List<WorkerDb> result = new List<WorkerDb>();

            var csBuilder = new SqlConnectionStringBuilder();
            csBuilder.DataSource = source.Address;
            csBuilder.UserID = source.Username;
            csBuilder.Password = source.Password;

            var conn = new SqlConnection(csBuilder.ConnectionString);
            var cmd = new SqlCommand(GetSuitableDatabases, conn);
            cmd.Parameters.AddWithValue("@pattern", source.SearchPattern);
            conn.Open();

            var reader = cmd.ExecuteReader();
            while (reader.Read())
            {
                var name = reader.GetString(0);
                var id = Regex
                    .Replace(name, source.NameRegex, string.Empty)
                    .ToLower();

                var db = new WorkerDb();
                db.Id = id;
                csBuilder.InitialCatalog = name;
                db.ConnectionString = csBuilder.ConnectionString;

                result.Add(db);
            }

            conn.Close();

            return result;
        }

 public DataSource UpdateDataSource(DataSource dataSource, string accountId)
 {
     var ds = Mapper.Map<DataSource, DynamoDb.DataSource>(dataSource);
     ds.AccountId = accountId;
     this.Context.Save(ds);
     return dataSource;
 }

		public override void ViewDidLoad ()
		{
			base.ViewDidLoad ();
			
			// Perform any additional setup after loading the view, typically from a nib.
			//NavigationItem.LeftBarButtonItem = EditButtonItem;

//			var addButton = new UIBarButtonItem (UIBarButtonSystemItem.Add, AddNewItem);
//			NavigationItem.RightBarButtonItem = addButton;

			MainSearchBar.SearchButtonClicked += (object sender, EventArgs e) => 
			{
				_kunden = BusinessLayer.Kunde.GetKunden(MainSearchBar.Text,ref  AppDelegate._user , false);
				dataSource.SetSource(_kunden);
//					TableView.Source = new SpeakersTableSource (_kunden);
				TableView.ReloadData();
			};




			//TODO: Step 1a: uncomment to set SpeakersTableSource as the TableView Source
			dataSource = new DataSource (this);
			TableView.Source = dataSource;
			//TableView.Source = dataSource ;

		}

        public void Should_be_able_prepare_a_query()
        {
            const string sql = "select @Id";

            var guid = Guid.NewGuid();
            var mc = new MappedColumn<Guid>("Id", DbType.Guid);
            var query = new RawQuery(sql).AddParameterValue(mc, guid);
            var dataParameterCollection = new Mock<IDataParameterCollection>();
            var dataParameterFactory = new Mock<IDbDataParameterFactory>();

            dataParameterFactory.Setup(m => m.Create("@Id", DbType.Guid, guid));

            var dataSource = new DataSource("data-source", dataParameterFactory.Object);

            var command = new Mock<IDbCommand>();

            dataParameterCollection.Setup(m => m.Add(It.IsAny<IDbDataParameter>())).Verifiable();

            command.SetupGet(m => m.Parameters).Returns(dataParameterCollection.Object);
            command.SetupSet(m => m.CommandText = sql).Verifiable();
            command.SetupSet(m => m.CommandType = CommandType.Text).Verifiable();

            query.Prepare(dataSource, command.Object);

            command.VerifyAll();
            dataParameterFactory.VerifyAll();
        }

        private void DefineDatabaseConnectionMenuItem_OnClick(object sender, RoutedEventArgs e)
        {
            // Build the data source, hard-coded to SQL Server
            DataSource sqlDataSource = new DataSource("MicrosoftSqlServer", "Microsoft SQL Server");
            sqlDataSource.Providers.Add(DataProvider.SqlDataProvider);

            // Construct the data connection dialog, add the SQL Server data source, and set to default
            DataConnectionDialog dbConnectionDialog = new DataConnectionDialog();
            dbConnectionDialog.DataSources.Add(sqlDataSource);
            dbConnectionDialog.SelectedDataProvider = DataProvider.SqlDataProvider;
            dbConnectionDialog.SelectedDataSource = sqlDataSource;

            // When user clicks OK, grab the connection string and parse through it
            if (DataConnectionDialog.Show(dbConnectionDialog) == System.Windows.Forms.DialogResult.OK)
            {
                if (_simInstanceDirector.IsConnectionStringValid(dbConnectionDialog.ConnectionString))
                {
                    // Save off the validated connection string for future use on restart
                    Settings.Default.ExperimentDbConnectionString =
                        _simInstanceDirector.GetEntityFormatConnectionString(dbConnectionDialog.ConnectionString);
                    Settings.Default.Save();

                    // Enable the database experiment selection option
                    LoadDatabaseExperimentConfigurationMenuItem.IsEnabled = true;
                }
                else
                {
                    MessageBox.Show("Couldn't connect to the database using the provided connection information.",
                        "Error Connecting to Data Source", MessageBoxButton.OK, MessageBoxImage.Exclamation);

                    // Reset the database experiment selection option
                    LoadDatabaseExperimentConfigurationMenuItem.IsEnabled = false;
                }
            }
        }

 void fillVars()
 {
     UIController = LifetimeService.Instance.Container.Resolve<IUIController>();
     ds = UIController.GetActiveDocument();
     if (ds == null)
     {
         canExecute = false;
         return;
     }
     Variables = new ObservableCollection<DataSourceVariable>(ds.Variables);
     source.ItemsSource = ds.Variables;
     //source.Items.Add("AA");
     //source.Items.Add("BB");
     //source.Items.Add("CC");
     //source.Items.Add("DD");
     //source.Items.Add("EE");
     //source.Items.Add("FF");
     //source.Items.Add("GG");
     //source.Items.Add("HH");
     //source.Items.Add("II");
     //source.Items.Add("JJ");
     //source.Items.Add("KK");
     //source.Items.Add("LL");
     //source.Items.Add("MM");
     //source.Items.Add("NN");
     //source.Items.Add("OO");
     ////////////// Function catagory /////////
     funcat.Items.Add("All");
     funcat.Items.Add("Arithmetic");
     funcat.Items.Add("CDF & Noncentral CDF");
     funcat.Items.Add("Conversion");
     funcat.Items.Add("Current Date/Time");
     funcat.Items.Add("Date Arithmetic");
     funcat.Items.Add("Date Creation");
 }

 public Bars RequestData(DataSource ds, string symbol, DateTime startDate, DateTime endDate, int maxBars, bool includePartialBar)
 {
     Bars bars = new Bars(symbol, ds.Scale, ds.BarInterval);
     //bars.Add(new DateTime(2012, 04, 07), 2, 5, 1, 3, 5);
     //bars.Add(new DateTime(2010, 09, 06), 3, 6, 2, 2, 6);
     return bars;
 }

        public MainWindow()
        {
            InitializeComponent();

               dataSource = new DataSource();
            this.DataContext = dataSource;
        }

        public SqlQueue(Uri uri,
						IScriptProvider scriptProvider,
						IDatabaseConnectionFactory databaseConnectionFactory,
						IDatabaseGateway databaseGateway)
        {
            Guard.AgainstNull(uri, "uri");
            Guard.AgainstNull(scriptProvider, "scriptProvider");
            Guard.AgainstNull(databaseConnectionFactory, "databaseConnectionFactory");
            Guard.AgainstNull(databaseGateway, "databaseGateway");

            _scriptProvider = scriptProvider;
            _databaseConnectionFactory = databaseConnectionFactory;
            _databaseGateway = databaseGateway;

            _log = Log.For(this);

            Uri = uri;

            parser = new SqlUriParser(uri);

            _dataSource = new DataSource(parser.ConnectionName, new SqlDbDataParameterFactory());
            _tableName = parser.TableName;

            BuildQueries();
        }

 public override object authorizedConnect(AbstractCredentials credentials, AbstractPermission permission, DataSource validationDataSource)
 {
     object result = base.authorizedConnect(credentials, permission, validationDataSource);
     //_eventArgs.ConnectionEventType = ConnectionPoolEventArgs.ConnectionChangeEventType.ConnectionAvailable;
     //OnChanged(_eventArgs);
     return result;
 }

 public MediatorServer(SystemConfiguration systemConfig, DataSource dataSource)
 {
     config = systemConfig.Servers.First(kvp => kvp.Value.Type == ServerTypes.Mediator).Value;
     controller = new Controller(dataSource);
     //			bootstrapper = new MediatorBootstrapper(controller);
     bootstrapper = new ApiBootstrapper(controller);
 }

		public async override void ViewDidLoad ()
		{
			base.ViewDidLoad ();

			var query = ParseObject.GetQuery("Item")
				.WhereEqualTo("PurchaserName", PersonDetailViewController.Instance.CurrentPerson.ID);
			
			IEnumerable<ParseObject> results = await query.FindAsync();

			ParseObj = results.ToList ();
			foreach (ParseObject po in ParseObj) {
				string Desc = po.Get<string> ("Description");
				string Value = po.Get<string> ("Value");
				bool Available = po.Get<Boolean> ("Available");
				PurchasedItems.Add (new Items { 
					Description = Desc,
					Value = Value, 
					Available = Available
				});
			}

			this.NavigationItem.SetRightBarButtonItem(
				new UIBarButtonItem(UIBarButtonSystemItem.Add, (sender,args) => {
					// button was clicked
				})
				, true);
			
			TableView.Source = dataSource = new DataSource(this, PurchasedItems);
			TableView.ReloadData ();
			this.Title = "Total=> ";
		}

 public HeaderRecord(DataSource source, ThreeLetterCode code, string text, string value)
     : base(RecordType.H, text)
 {
     DataSource = source;
     ThreeLetterCode = code;
     Value = value ?? string.Empty;
 }

 public void DataSourceConventions(DataSource<string> sut, int expectedCount)
 {
     var collection = sut.Data.ToList();
     collection.Count.ShouldBe(expectedCount);
     collection.Count.ShouldBe(sut.Data.Distinct().ToList().Count);
     collection.ForEach(item => item.ShouldNotBeNullOrEmpty());
 }

        /// <summary>
        /// Invoked when this page is about to be displayed in a Frame.
        /// </summary>
        /// <param name="e">Event data that describes how this page was reached.  The Parameter
        /// property is typically used to configure the page.</param>
        protected async override void OnNavigatedTo(NavigationEventArgs e)
        {
            // Arrange
            var ds = new DataSource();
            await ds.CleanDatabaseAsync();
            await ds.InitializeDbAsync();

            // CRUD Operations Demos
            await CrudOperationsDemo(ds);

            // Tx Demos
            var speakers = await TxInsertDemo(ds);
            await TxDeleteDemo(ds, speakers.First().Id);

            // Reset the database
            await ds.CleanDatabaseAsync();
            await ds.InitializeDbAsync();

            // Querying Demos
            await TxInsertDemo(ds); // re-add data to the database
            await QueryingDemos(ds);

            // Some advanced scenarios
            await AdvancedDemos(ds);
        }

        private DataTable CreateDataSource(DataSource ds, string sql)
        {
            DataTable dt = null;
            try
            {
                using(IDbAccess dataAccess = ds.CreateDbAccess())
                {
                    dt = dataAccess.QueryDataTable(sql.ToQuery());
                }
               
            }
            catch (SqlException ex)
            {
                if (ex.Message.Contains("Must declare the scalar variable"))
                {
                    foreach (string parameterName in FindParameterName(ex.Message))
                    {
                        sql = sql.Replace(parameterName, "NULL");
                    }

                    return CreateDataSource(ds, sql);
                }
                else
                    throw;
            }
            return dt;
        }

 public static Attempt GetAttempt(string id, int attemptN, DataSource source)
 {
     using(var repo = new AttemptRepository()) {
         var attempt = repo.Attempts.Where(att => att.ID == id && att.AttemptNumber == attemptN && att.Source == source);
         return attempt.Single();
     }
 }

        public MainWindow()
        {
            InitializeComponent();
            var ds = new DataSource();
            if (ds != null)
            {
                LayoutPanel panel = new LayoutPanel() { Caption = "Live Report", AllowClose = false };
                AccountDataSheet sheet = new AccountDataSheet() { DataContext = ds };
                panel.Content = sheet;
                documents.Add(panel);
                panel.IsActive = true;
            }

             var bds = new BenchMarkDataSource();

             if (bds != null)
             {
                 LayoutPanel panel = new LayoutPanel() { Caption = "BenchMark Report", AllowClose = false };

                 BenchMarkDataSheet sheet = new BenchMarkDataSheet() { DataContext = bds };
                 panel.Content = sheet;
                 documents.Add(panel);

                 panel = new LayoutPanel() { Caption = "Report", AllowClose = false };
                     NewReportDataSheet Nsheet = new NewReportDataSheet() { DataContext = bds };
                     panel.Content = Nsheet;
                     documents.Add(panel);

                 panel.IsActive = true;
             }
        }

        public override void ViewDidLoad()
        {
            base.ViewDidLoad ();

            _dataSource = new DataSource(this, _facebook);
            TableView.Delegate = new TableDelegate (this, _dataSource);
            TableView.DataSource = _dataSource;
        }