public LogEntryCounter(ObservableCollection<LogEntry> entries)
 {
     this.Entries = entries;
     Entries.CollectionChanged += Entries_CollectionChanged;
     Count = new Observable<LogEntryLevelCount>();
     Count.Value = GetCount(Entries);
 }

        private void LoadIndex(Observable<IndexDefinitionModel> observable)
        {
            var serverModel = ApplicationModel.Current.Server.Value;
            if (serverModel == null)
            {
                ApplicationModel.Current.Server.RegisterOnce(() => LoadIndex(observable));
                return;
            }

            ApplicationModel.Current.RegisterOnceForNavigation(() => LoadIndex(observable));

            var asyncDatabaseCommands = serverModel.SelectedDatabase.Value.AsyncDatabaseCommands;
            var name = ApplicationModel.Current.GetQueryParam("name");
            if (name == null)
                return;

            asyncDatabaseCommands.GetIndexAsync(name)
                .ContinueOnSuccess(index =>
                                   {
                                   	if (index == null)
                                   	{
                                   		ApplicationModel.Current.Navigate(new Uri("/DocumentNotFound?id=" + name, UriKind.Relative));
                                   		return;
                                   	}
                                   	observable.Value = new IndexDefinitionModel(index, asyncDatabaseCommands);
                                   }
                )
                .Catch();
        }

		public NewDatabase()
		{
			LicensingStatus = new Observable<LicensingStatus>();
			InitializeComponent();
			var req = ApplicationModel.DatabaseCommands.ForDefaultDatabase().CreateRequest("/license/status", "GET");

			req.ReadResponseJsonAsync().ContinueOnSuccessInTheUIThread(doc =>
			{
				LicensingStatus.Value = ((RavenJObject)doc).Deserialize<LicensingStatus>(new DocumentConvention());
				var hasPeriodic =(bool) new BundleNameToActiveConverter().Convert(LicensingStatus.Value, typeof (bool), "PeriodicBackup",
				                                                            CultureInfo.InvariantCulture);
				if (hasPeriodic)
				{
					Bundles.Add("PeriodicBackup");
				}
			});

			
			Bundles = new List<string>();
			KeyDown += (sender, args) =>
			{
				if (args.Key == Key.Escape)
					DialogResult = false;
			};
		}

		public AlertsModel()
		{
			Alerts = new ObservableCollection<AlertProxy>();
			UnobservedAlerts = new ObservableCollection<AlertProxy>();
			ServerAlerts = new ObservableCollection<Alert>();
			ShowObserved = new Observable<bool>();

			AlertsToSee = Alerts;

			ShowObserved.PropertyChanged += (sender, args) =>
			{
				AlertsToSee = ShowObserved.Value ? Alerts : UnobservedAlerts;
				OnPropertyChanged(() => AlertsToSee);
			};

			ServerAlerts.CollectionChanged += (sender, args) =>
			{
				Alerts.Clear();
				foreach (var serverAlert in ServerAlerts)
				{
					Alerts.Add(new AlertProxy(serverAlert));
				}
			};

			ShowObserved.Value = false;

			Alerts.CollectionChanged += (sender, args) => UpdateUnobserved();

			GetAlertsFromServer();

			OnPropertyChanged(() => Alerts);
		}

		static AllDocumentsModel()
		{
			Documents = new Observable<DocumentsModel>();
			Documents.Value = new DocumentsModel();
			SetTotalResults();
			ApplicationModel.Database.PropertyChanged += (sender, args) => SetTotalResults();
		}

        protected override void OnBeforeClientInit(Observable sender)
        {
            base.OnBeforeClientInit(sender);

            string apiKey = HttpContext.Current.Items["GMapApiKey"] as string;
            this.ScriptManager.RegisterClientScriptInclude("GMapApiKey", string.Format(this.APIBaseUrl, apiKey ?? this.APIKey));
        }

 public MainWindowViewModel()
 {
     Directories = new Observable<string>(string.Empty);
     IsExecuting = new Observable<bool>();
     Candidates = new Observable<IEnumerable<DuplicateCandidateGroup>>();
     ExecuteCommand = new RelayCommand(Execute, CanExecute);
 }

        public void CanHaveManyComputeds()
        {
            var prefix = new Observable<string>("Before");

            var contacts = new ObservableList<Contact>(
                Enumerable.Range(0, 10000)
                    .Select(i => new Contact()
                    {
                        FirstName = "FirstName" + i,
                        LastName = "LastName" + i
                    }));

            var projections = new ComputedList<Projection>(() =>
                from c in contacts
                select new Projection(prefix, c));
            string dummy;
            foreach (var projection in projections)
                dummy = projection.Name;
            Assert.AreEqual("BeforeFirstName3LastName3", projections.ElementAt(3).Name);

            prefix.Value = "After";
            foreach (var projection in projections)
                dummy = projection.Name;
            Assert.AreEqual("AfterFirstName3LastName3", projections.ElementAt(3).Name);
        }

 protected override void CreateBindings()
 {
     checkboxBinder = AddBinding<bool>(ObservableBoolName, value => checkbox.isChecked = value);
     if (!String.IsNullOrEmpty(ObservableStringLabel)) {
         AddBinding<string>(ObservableStringLabel, value => checkboxLabel.text = value);
     }
 }

    public SettingsMenu(IEventAggregator eventAggregator)
    {
        _eventAggregator = eventAggregator;

        DisplayName = Observable("DisplayName", "Settings");
        Volume = Observable("Volume", .25f);
    }

		static CollectionsModel()
		{
			Collections = new BindableCollection<CollectionModel>(model => model.Name, new KeysComparer<CollectionModel>(model => model.Count));
			SelectedCollection = new Observable<CollectionModel>();

			SelectedCollection.PropertyChanged += (sender, args) => PutCollectionNameInTheUrl();
		}

		private ApplicationModel()
		{
			Notifications = new BindableCollection<Notification>(x=>x.Message);
			LastNotification = new Observable<string>();
			Server = new Observable<ServerModel> {Value = new ServerModel()};
		    State = new ApplicationState();
		}

		public WindowsAuthSettingsSectionModel()
		{
			SectionName = "Windows Authentication";
			Document = new Observable<WindowsAuthDocument>();
			RequiredUsers = new ObservableCollection<WindowsAuthData>();
			RequiredGroups = new ObservableCollection<WindowsAuthData>();
			SelectedList = new ObservableCollection<WindowsAuthData>();
			DatabaseSuggestionProvider = new DatabaseSuggestionProvider();
			WindowsAuthName = new WindowsAuthName();

			ApplicationModel.DatabaseCommands.ForSystemDatabase()
				.GetAsync("Raven/Authorization/WindowsSettings")
				.ContinueOnSuccessInTheUIThread(doc =>
				{
					if (doc == null)
					{
						Document.Value = new WindowsAuthDocument();
						return;
					}
					Document.Value = doc.DataAsJson.JsonDeserialization<WindowsAuthDocument>();
					RequiredUsers = new ObservableCollection<WindowsAuthData>(Document.Value.RequiredUsers);
					RequiredGroups = new ObservableCollection<WindowsAuthData>(Document.Value.RequiredGroups);
					SelectedList = RequiredUsers;
					
					OnPropertyChanged(() => Document);
					OnPropertyChanged(() => RequiredUsers);
					OnPropertyChanged(() => RequiredGroups);
				});
		}

        public ContactsEditorViewModel()
        {
            SelectedContact = (Observable<ObservableContact>)ValidatedObservableFactory.ValidatedObservable(new ObservableContact());

            Contacts = new EntityDataViewModel(10, typeof(Contact),true);

            Contacts.OnSelectedRowsChanged += OnSelectedRowsChanged;
            Contacts.FetchXml = @"<fetch version='1.0' output-format='xml-platform' mapping='logical' returntotalrecordcount='true' no-lock='true' distinct='false' count='{0}' paging-cookie='{1}' page='{2}'>
                <entity name='contact'>
                    <attribute name='firstname' />
                    <attribute name='lastname' />
                    <attribute name='telephone1' />
                    <attribute name='birthdate' />
                    <attribute name='accountrolecode' />
                    <attribute name='parentcustomerid'/>
                    <attribute name='transactioncurrencyid'/>
                    <attribute name='creditlimit'/>
                    <attribute name='numberofchildren'/>
                    <attribute name='contactid' />{3}
                  </entity>
                </fetch>";

            // Register validation
            ContactValidation.Register(Contacts.ValidationBinder);
            ContactValidation.Register(new ObservableValidationBinder(this.SelectedContact));
        }

        public void ValidValueShouldNotResultInAnyValidationErrors()
        {
            var observable = new Observable<int>();

            observable.Error.ShouldBe(string.Empty);
            observable["Value"].ShouldBe(string.Empty);
        }

        public PersonViewModel()
        {
            this.FirstName = Knockout.Observable("Matthew");
            this.LastName = Knockout.Observable("Leibowitz");
            this.FullName = Knockout.Computed(() => this.FirstName.Value + " " + this.LastName.Value);

            // AND, there is way to perform the updates to the computed object

            //var options = new DependentObservableOptions<string>();
            //options.GetValueFunction = () => self.FirstName.Value + " " + self.LastName.Value;
            //options.SetValueFunction = s =>
            //{
            //    s = s.Trim();
            //    var index = s.IndexOf(" ");
            //    if (index == -1)
            //    {
            //        self.FirstName.Value = s;
            //        self.LastName.Value = string.Empty;
            //    }
            //    else
            //    {
            //        self.FirstName.Value = s.Substring(0, index);
            //        self.LastName.Value = s.Substring(index + 1, s.Length);
            //    }
            //};
            //this.FullName = Knockout.Computed(options);
        }

        private void LoadDocument(Observable<EditableDocumentModel> observable)
        {
            var serverModel = ApplicationModel.Current.Server.Value;
            if (serverModel == null)
            {
                ApplicationModel.Current.Server.RegisterOnce(() => LoadDocument(observable));
                return;
            }

            ApplicationModel.Current.RegisterOnceForNavigation(() => LoadDocument(observable));

            var asyncDatabaseCommands = serverModel.SelectedDatabase.Value.AsyncDatabaseCommands;
            var docId = ApplicationModel.Current.GetQueryParam("id");

            if (docId == null)
                return;

            asyncDatabaseCommands.GetAsync(docId)
                .ContinueOnSuccess(document =>
                                   {
                                   	if (document == null)
                                   	{
                                   		ApplicationModel.Current.Navigate(new Uri("/DocumentNotFound?id=" + docId, UriKind.Relative));
                                   		return;
                                   	}
                                   	observable.Value = new EditableDocumentModel(document, asyncDatabaseCommands);
                                   }
                )
                .Catch();
        }

        public void ShouldBeAbleToChangeUnderlyingItemsAfterConstruction()
        {
            var item1 = new Observable<int>(1);
            var item2 = new Observable<int>(2);
            var observable = ReadOnlyObservable.Create(new[] { item1 }, x => x.Sum(y => y.Value));

            var propertyChangedCount = 0;
            observable.PropertyChanged += delegate { propertyChangedCount++; };
            observable.Configure(x =>
            {
                x.Items.Remove(item1);
                x.Items.Add(item2);
            });

            propertyChangedCount.ShouldBe(1);
            observable.Value.ShouldBe(2);

            item1.Value = 1;
            propertyChangedCount.ShouldBe(1);
            observable.Value.ShouldBe(2);

            item2.Value = 1;
            propertyChangedCount.ShouldBe(2);
            observable.Value.ShouldBe(1);
        }

		public PeriodicBackupSettingsSectionModel()
		{
			SectionName = "Periodic Backup";
			SelectedOption = new Observable<int>();
			ShowPeriodicBackup = new Observable<bool>();

			var req = ApplicationModel.DatabaseCommands.ForSystemDatabase().CreateRequest("/license/status".NoCache(), "GET");

			req.ReadResponseJsonAsync().ContinueOnSuccessInTheUIThread(doc =>
			{
				var licensingStatus = ((RavenJObject)doc).Deserialize<LicensingStatus>(new DocumentConvention());
				if (licensingStatus != null && licensingStatus.Attributes != null)
				{
					string active;
					if (licensingStatus.Attributes.TryGetValue("PeriodicBackup", out active) == false)
						ShowPeriodicBackup.Value = true;
					else
					{
						bool result;
						bool.TryParse(active, out result);
						ShowPeriodicBackup.Value = result;
					}

					OnPropertyChanged(() => ShowPeriodicBackup);
				}
			});
		}

 public LogEntryCounter(ObservableCollection<LogEntryViewModel> entries)
 {
     this.Entries = entries;
     Count = new Observable<LogEntryLevelCount>();
     Count.Value = GetCount(Entries.ToArray());
     Entries.CollectionChanged += EntriesCollectionChanged;
 }