public MainPageViewModel(IDataRepository citiesRepository, INavigationService navigation, IEventAggregator eventAggregator)
        {
            _citiesRepository = citiesRepository;
            _navigation = navigation;
            _eventAggregator = eventAggregator;
            var clocks = _citiesRepository.GetUsersCities();
            Clocks = new ObservableCollection<CityInfo>(clocks);
            _eventAggregator.GetEvent<AddCityMessage>().Subscribe(HandleAddCity, true);
            _eventAggregator.GetEvent<DeleteCityMessage>().Subscribe(HandleDeleteCity, true);

            Add = new RelayCommand(() =>
            {
                _navigation.Navigate(Experiences.CitySelector.ToString(), null);
            });
            Donate = new RelayCommand(() => Launcher.LaunchUriAsync(new Uri("https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=UFS2JX3EJGU3N")));
            GoToDetails = new DelegateCommand<CityInfo>(HandleGotoDetails);
            SetShowMenu = new RelayCommand(() =>
            {
                MenuActive = !MenuActive;
            });
            GoToSettings = new RelayCommand(() =>
            {
                _navigation.Navigate(Experiences.Settings.ToString(), null);
            });
        }

        protected ConfigurableController(IDataRepository repository)
        {
            _repository = repository;

            PageConfigurations = GetCurrentPageConfigurations().ToList();

        }

 public DataRepositoryObjectViewModel( IDataRepository dataRepository, IRegionManager regionManager, IInteractionService interactionService, ILoggerFacade logger )
     : base(regionManager, interactionService, logger)
 {
     Model = null;
      InTransaction = false;
      this.DataRepository = dataRepository;
 }

 public data_generator(IDataRepository db, int key)
 {
     this._key = key;
     this.CalulatedKey = new Hashtable();
     initialize_data_list(key);
     this.LoginData = get_random_data(db);
 }

        public GeoRegionMaintenanceViewModel(IModuleController moduleController, IDataRepository repository, IEventAggregator eventAggregator)
        {
            _moduleController = moduleController;
            _repository = repository;
            _eventAggregator = eventAggregator;

            ShowView = _moduleController.ShowViewCommand;
            NavigationDetails = _moduleController.NavigationDetails;

            ChangeMetaPanel = new DelegateCommand<bool?>(ChangeMetaViewPanel);
            ChangeGeoPanel = new DelegateCommand<bool?>(ChangeGeoViewPanel);

            DeleteMetaRegionCommand = new DelegateCommand(DeleteMetaRegion);
            EditMetaRegionCommand = new DelegateCommand(EditMetaRegion);
            AddNewMetaRegionCommand = new DelegateCommand(AddNewMetaRegion);
            DeleteMetaRegionMappingCommand = new DelegateCommand(DeleteMetaRegionMapping);
            AddMetaRegionMappingCommand = new DelegateCommand(AddMetaRegionMapping);
            DeleteGeoRegionCommand = new DelegateCommand(DeleteGeoRegion);
            EditGeoRegionCommand = new DelegateCommand(EditGeoRegion);
            CreateNewGeoRegionCommand = new DelegateCommand(CreateNewGeoRegion);

            _metaRegions = new ObservableCollection<t033_meta_region>();
            _metaRegionMappings = new ObservableCollection<t031_geo_code>();
            _geoRegions = new ObservableCollection<GeoRegionViewModel>();

            _moduleController.SwitchPanel(MaintenanceRegionNames.MetaRegionRegion, MaintenanceViewNames.MetaRegionView);
            _moduleController.SwitchPanel(MaintenanceRegionNames.GeoRegionRegion, MaintenanceViewNames.GeoRegionView);
            _moduleController.SwitchPanel(MaintenanceRegionNames.MetaRegionMappingRegion, MaintenanceViewNames.MetaRegionMappingView);

            _eventAggregator.GetEvent<RefreshRegionsEvent>().Subscribe(InitializeData);
        }

 public FoodItemViewModel( IDataRepository dataRepository, IRegionManager regionManager, IInteractionService interactionService, ILoggerFacade logger )
     : base(dataRepository, regionManager, interactionService, logger)
 {
     FoodGroupsPerServing = new ObservableCollection<ServingViewModel<FoodGroup>>();
      ValidFoodGroups = new AllFoodGroupsViewModel( dataRepository );
      Title = DisplayStrings.NewFoodItemTitle;
 }

 public SessionData(IUnityContainer container)
 {
     this.container = container;
     Customer = container.Resolve<ICustomerVM>();
     repository = container.Resolve<IDataRepository>();
     repository.DataChanged += OnCustomerChanged;
 }

        public static EventSetViewModel ReadEventSet(IDataRepository repository, bool fullLoad)
        {
            var eventSet = new EventSetViewModel(EventSetName);

            var events = repository.GetItems<t00002_event_set>();
            foreach (var ev in events)
            {
                // We want to group them by simulation id but they won't be in order
                if (!eventSet.EventSimulations.Any(e => e.Id == ev.event_simulation))
                    eventSet.EventSimulations.Add(new EventSimulationViewModel(ev.event_simulation));

                // Have option of just returning the root level tree to save time
                if (fullLoad)
                {
                    var eventViewModel = new EventViewModel(ev.event_id, ev.event_day, ev.t010_peril);

                    foreach (var footprintViewModel in ev.t00002_event_loss_footprint.Select(footprint =>
                                                                                             new EventLossFootprintViewModel
                                                                                                 (footprint.id,
                                                                                                  footprint.loss_amount,
                                                                                                  footprint.
                                                                                                      t031_geo_code)))
                    {
                        eventViewModel.EventLossFootprints.Add(footprintViewModel);
                    }

                    // We have constructed the event structure, so now add it to the relevant simulation model
                    var simulation = eventSet.EventSimulations.FirstOrDefault(e => e.Id == ev.event_simulation);
                    if (simulation != null)
                        simulation.Events.Add(eventViewModel);
                }
            }

            return eventSet;
        }

 public RssPlugin(IBitTorrentEngine torrentEngine, IDataRepository dataRepository, ITimerFactory timerFactory, IWebClient webClient)
 {
     _torrentEngine = torrentEngine;
     _dataRepository = dataRepository;
     _timer = timerFactory.CreateTimer();
     _webClient = webClient;
 }

        public ServerController(IDataRepository dataRepository, 
								IFileRepository fileRepository,
								IJsonDataParser jsonDataParser)
        {
            _dataRepository = dataRepository;
            _fileRepository = fileRepository;
            _jsonDataParser = jsonDataParser;
        }

 public JobManager(IDataRepository database)
 {
     this.db = database;
     _jobTimer = new Timer();
     _jobTimer.Interval = 500;
     _jobTimer.Elapsed += new ElapsedEventHandler(OnElapsed);
     _jobTimer.Start();
 }

 public DefaultPluginEngine(IFileSystem fs, IDataRepository repo, IMessageBus mbus, IMigrationRunner runner, IPluginLoader[] loaders)
 {
     _fs = fs;
     _repo = repo;
     _mbus = mbus;
     _runner = runner;
     _loaders = loaders;
 }

        public IterationService(IDataRepository data, DiffService diff)
        {
            Requires.NotNull(data, "data");
            Requires.NotNull(diff, "diff");

            Data = data;
            Diff = diff;
        }

        public SelectTestViewModel(
            INavigationService navigationService,IDataRepository dataRepository,IDialogService dialogService)
        {
            _navigationService = navigationService;
            _dataRepository = dataRepository;
            _dialogService = dialogService;

        }

 public DataController(IDataRepository repository)
 {
     if(repository==null)
     {
         throw new ArgumentException("Server data is empty");
     }
     dataRepository = repository;
 }

 public ReportService(IDataRepository dataRepository, AppActs.Client.Repository.Interface.IApplicationRepository applicationRepository, 
     AppActs.Client.Repository.Interface.IPlatformRepository platformRepository, 
     IReportRepository reportRepository)
 {
     this.dataRepository = dataRepository;
     this.applicationRepository = applicationRepository;
     this.platformRepository = platformRepository;
     this.reportRepository = reportRepository;
 }

		public CustomerVM(IDataRepository repository) {
			this.repository = repository;
			if (repository == null) throw new ArgumentNullException(ExceptionMessages.RepositoryNull, (Exception)null);
			currentCustomer = new CustomerData();
			cleanCustomer = new CustomerData();
			currentCustomer.AddressChanged += UpdateIsDirty;
			BackingCustomer = new Customer();
			saveHelper = new SaveHelper(repository, currentCustomer);
		}

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="name">Name of the collection</param>
        /// <param name="dataRepository">The data repository</param>
        /// <param name="childClickCommand">The command that should be executed if a child is clicked on.</param>
        public DataObjectCollectionNodeViewModel( String name, IDataRepository dataRepository, ICommand childClickCommand )
            : base(name)
        {
            dataRepository.ItemAdded += this.OnItemAdded;
             dataRepository.ItemDeleted += this.OnItemRemoved;
             dataRepository.ItemModified += this.OnItemModified;

             _childClickCommand = childClickCommand;
        }

 public FoodGroupNodeViewModel( IDataRepository dataRepository, ICommand childClickCommand )
     : base(DisplayStrings.AdminFoodGroupsTitle, dataRepository, childClickCommand)
 {
     _children =
     new ObservableCollection<TreeNodeViewModel>(
        (from foodGroup in dataRepository.GetAllFoodGroups()
         select new ClickableTreeNodeViewModel( foodGroup.Name, childClickCommand, foodGroup.ID )).ToList() );
      Children = new ReadOnlyObservableCollection<TreeNodeViewModel>( _children );
 }

 public MealTemplateNodeViewModel( IDataRepository dataRepository, ICommand childClickCommand )
     : base(DisplayStrings.AdminMealTemplatesTitle, dataRepository, childClickCommand)
 {
     _children =
     new ObservableCollection<TreeNodeViewModel>(
     (from mealTemplate in dataRepository.GetAllMealTemplates()
      select new ClickableTreeNodeViewModel( mealTemplate.Name, childClickCommand, mealTemplate.ID )).ToList() );
      Children = new ReadOnlyObservableCollection<TreeNodeViewModel>( _children );
 }