public void Init()
 {
     var mock = MockRepository.GenerateMock(typeof(IWebDriver), new[] { typeof(IJavaScriptExecutor) });
     this.webDriver = (IWebDriver)mock;
     this.javaScriptExecutor = (IJavaScriptExecutor)mock;
     this.navigation = MockRepository.GenerateStub<INavigation>();
 }

		public ExpenseViewModel(INavigation navigation)
		{
			_navigation = navigation;
			_expenseService = DependencyService.Get<IExpenseService>();

			SelectedDate = DateTime.Now;
			LoadData();

			MessagingCenter.Subscribe<AddViewModel, Expense>(this, "AddExpense", async (sender, arg) =>
				{
					try
					{
						await _expenseService.AddExpenseAsync(arg).ConfigureAwait(false);
					}
					catch (Exception ex)
					{
						Debug.WriteLine("Error occured during insertion : "+ex.Message);
					}
					LoadData();
				});
			MessagingCenter.Subscribe<ExpenseItemViewModel, int>(this, "DeleteExpense", async (sender, arg) =>
				{
					try
					{
						await _expenseService.DeleteExpenseAsync(arg).ConfigureAwait(false);
					}
					catch (Exception ex)
					{
						Debug.WriteLine("Error occured during delete of expense : "+ex.Message);
					}
					LoadData();
				});
		}

        public CustomerTabbedPage(INavigation navigation, Account account)
        {
            // since we're modally presented this tabbed view (because Android doesn't natively support nested tabs),
            // this tool bar item provides a way to get back to the Customers list
            ToolbarItems.Add(new ToolbarItem(TextResources.Customers_Orders_CustomerTabbedPage_BackToCustomers, null, async () => await navigation.PopModalAsync()));

            CustomerDetailPage customerDetailPage = new CustomerDetailPage()
            {
                BindingContext = new CustomerDetailViewModel(account) { Navigation = this.Navigation },
                Title = TextResources.Customers_Detail_Tab_Title,
                Icon = new FileImageSource() { File = "CustomersTab" } // only used  on iOS
            };

            CustomerOrdersPage customerOrdersPage = new CustomerOrdersPage()
            {
                BindingContext = new OrdersViewModel(account) { Navigation = this.Navigation },
                Title = TextResources.Customers_Orders_Tab_Title,
                Icon = new FileImageSource() { File = "ProductsTab" } // only used  on iOS
            };

            CustomerSalesPage customerSalesPage = new CustomerSalesPage()
            {
                BindingContext = new CustomerSalesViewModel(account) { Navigation = this.Navigation },
                Title = TextResources.Customers_Sales_Tab_Title,
                Icon = new FileImageSource() { File = "SalesTab" } // only used  on iOS
            };

            Children.Add(customerDetailPage);
            Children.Add(customerOrdersPage);
            Children.Add(customerSalesPage);
        }

        public SearchViewModel(INavigation navigation)
        {
            if (navigation != null)
                _navigation = navigation;
            FindCommand = new Command<String>(searchText =>
            {
                this.SearchPattern = searchText;
                TwitterClient client = TwitterClient.GetInstance();
                IEnumerable<ITweet> tweets = client.SearchTweets(SearchPattern);
                TweetsFoundCollection = new ObservableCollection<ITweet>(tweets);
            }
                );

            ToMainCommand = new Command(async () =>
            {
                if (_navigation != null)
                    await _navigation.PopAsync();
            });

            SignupCommand = new Command<Object>(signup =>
            {
                TwitterClient client = TwitterClient.GetInstance();
                var tweet = signup as ITweet;
                if (tweet != null)
                {
                    Int64 id = tweet.CreatedBy.Id;
                    client.FollowUser(id);
                }
            },
                value => { return TweetsFoundCollection != null; });
        }

        public MainViewModel(INavigation navigation)

        {

            _navigation = navigation;        
            
        }

        public ContactListViewModel(INavigation navigation)
        {
            _navigation = navigation;
            _contactsService = ServiceLocator.ContactsService;

            Contacts = new ObservableCollection<Contact>();
        }

 public EventDetailsViewModel(INavigation navigation, FeaturedEvent e) : base(navigation)
 {
     Event = e;
     Sponsors = new ObservableRangeCollection<Sponsor>();
     if (e.Sponsor != null)
         Sponsors.Add(e.Sponsor);
 }

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

        private object TryFindPrincipal(StateManager stateManager, INavigation navigation, object dependentEntity)
        {
            if (navigation.PointsToPrincipal)
            {
                return _getterSource.GetAccessor(navigation).GetClrValue(dependentEntity);
            }

            // TODO: Perf
            foreach (var principalEntry in stateManager.StateEntries
                .Where(e => e.EntityType == navigation.ForeignKey.ReferencedEntityType))
            {
                if (navigation.IsCollection())
                {
                    if (_collectionAccessorSource.GetAccessor(navigation).Contains(principalEntry.Entity, dependentEntity))
                    {
                        return principalEntry.Entity;
                    }
                }
                else if (_getterSource.GetAccessor(navigation).GetClrValue(principalEntry.Entity) == dependentEntity)
                {
                    return principalEntry.Entity;
                }
            }

            return null;
        }

 public ContactViewModel(INavigation navigation, Contact contact)
 {
     _navigation = navigation;
     _contactData = new ContactDataService();
     FillingCurrentContact(contact);
     AddContactCommand = new Command(() => NewContact(contact));
 }

		public FindBleViewModel (INavigation navigation, bool selMeuSkey)
		{
			fim = false;
			this.selMeuSkey = selMeuSkey;
			App.gateSkey = null;  //sKey selecionada se for scan para gateDevice
			keySelecionada = null; //resultado da acao de click em item da lista de sKeys encontrados
			if (selMeuSkey || App.gateSkeys == null)
				devices = new ObservableCollection<BleDevice> ();
			else
				devices = new ObservableCollection<BleDevice> (App.gateSkeys);  //Skeys do ultimo scan

			if (selMeuSkey && MySafetyDll.MySafety.isScanning)
				((App)Application.Current).mysafetyDll.cancelScan ();

			((App)Application.Current).mysafetyDll.Scan += mysafetyDll_Scan;
			_navigation = navigation;

			FindCommand = new Command ((key) => {
				findBleButton = (Button)key;
				scanSkeys ();
			});

			//
			if (devices.Count () == 0)
				scanSkeys ();
		}

 public NewsViewModel(INavigation navigation) : base(navigation)
 {
     Items = new ObservableCollection<NewsItem>();
     Items.Add(new NewsItem() { Header = "Leksand till SHL", Text = "Leksand spelar i SHL 16/17! :)" });
     Items.Add(new NewsItem() { Header = "Microsoft köper Xamarin", Text = "Xamarin är nu gratis för alla!!" });
     Items.Add(new NewsItem() { Header = "Sogeti + Xamarin", Text = "Sogeti utbildar nya Xamarinutvecklare!" });
 }

        public ChooseViewModel(INavigation navi)
        {
            this.navigation = navi;

            this.likeMealCommand = new Command(async () =>
            {
                likedMeals.Add(Meal);
                if (!LoadNewMeal())
                {
					await this.LoadOverviewPage();
				}
            });

            this.dislikeMealCommand = new Command(async () =>
            {
                dislikedMeals.Add(Meal);
                if (!LoadNewMeal())
                {
					await this.LoadOverviewPage();
                }
            });

            this.enoughMealsCommand = new Command(async () =>
            {
				await this.LoadOverviewPage();
            });

            this.likedMeals = new List<Meal>();
            this.dislikedMeals = new List<Meal>();

			this.LoadNewMeal ();
        }

        public SalesDashboardLeadsViewModel(Command pushTabbedLeadPageCommand, INavigation navigation = null)
            : base(navigation)
        {
            _PushTabbedLeadPageCommand = pushTabbedLeadPageCommand;

            _DataClient = DependencyService.Get<IDataClient>();

            Leads = new ObservableCollection<Account>();

            MessagingCenter.Subscribe<Account>(this, MessagingServiceConstants.SAVE_ACCOUNT, (account) =>
                {
                    var index = Leads.IndexOf(account);
                    if (index >= 0)
                    {
                        Leads[index] = account;
                    }
                    else
                    {
                        Leads.Add(account);
                    }
                    Leads = new ObservableCollection<Account>(Leads.OrderBy(l => l.Company));
                });

            IsInitialized = false;
        }

        public LeadDetailViewModel(INavigation navigation, Account lead = null)
        {
            if (navigation == null)
            {
                throw new ArgumentNullException("navigation", "An instance of INavigation must be passed to the LeadDetailViewModel constructor.");
            }

            Navigation = navigation;

            if (lead == null)
            {
                Lead = new Account();
                this.Title = TextResources.Leads_NewLead;
            }
            else
            {
                Lead = lead;
                this.Title = lead.Company;
            }

            this.Icon = "contact.png";

            _DataClient = DependencyService.Get<IDataClient>();

            _GeoCodingService = DependencyService.Get<IGeoCodingService>();
        }

		public PollResultsPageViewModel(
			INavigation navigation,
			IObjectFactory<IPollResults> objectFactory,
			IObjectFactory<IPoll> pollFactory,
			IObjectFactory<IPollComment> pollCommentFactory,
			IMessageBox messageBox
#if NETFX_CORE
			, IShareManager shareManager,
			ISecondaryPinner secondaryPinner
#endif // NETFX_CORE
			)
			: base(navigation)
		{
			this.objectFactory = objectFactory;
			this.pollFactory = pollFactory;
			this.pollCommentFactory = pollCommentFactory;
			this.messageBox = messageBox;

			this.PollComments = new ObservableCollection<PollCommentViewModel>();

#if NETFX_CORE
			this.shareManager = shareManager;
			this.secondaryPinner = secondaryPinner;
#endif // NETFX_CORE
		}

		public FundsTransferViewModel (INavigation navigation, Page currentPage)
		{
			Navigation = navigation;
			CancelCommand = new Command(async () => await Navigation.PopAsync());
			TransferCommand = new Command(async () => await currentPage.DisplayAlert("Transfer", "Success", "Ok"));

		}

 public MainViewModel(INavigation navigation)
 {
     _navigation = navigation;
     _database = new Database();
     Contacts = new ObservableCollection<Contact>(_database.SearchContacts(""));
     AddCommand = new Command(ShowAddWindow);
 }

 public ContactListViewModel (INavigation navigation)
 {
     _navigation = navigation;
     _contactData = new ContactDataService();
     OpenContactPageCommand = new Command(OpenContactPage);
     DeleteCommand = new Command<int>(Delete);
     ReloadDataCommand = new Command(ReloadData);
  }

 public NewUserViewModel(INavigation nav)
 {
     SendEmail = new Command (async () => {
         if(String.IsNullOrEmpty(Email)) return;
         //send email
         await nav.PopAsync();
     });
 }