public MainViewModel(IDialogService dialogService, IErrorService errorService)
 {
     _dialogService = dialogService;
     _errorService = errorService;
     OpenFileCommand = new RelayCommand(OpenFile);
     _showScoreInfoCommand = new RelayCommand(ShowScoreInfo, () => _score != null);
 }

        public MainWindowViewModel(IDialogService dialogService)
        {
            this.dialogService = dialogService;

            ImplicitShowDialogCommand = new RelayCommand(ImplicitShowDialog);
            ExplicitShowDialogCommand = new RelayCommand(ExplicitShowDialog);
        }

 public ImportService(IProjectService projectService, IDialogService dialogService, IBusyService busyService, IAnalysisService analysisService)
 {
     _projectService = projectService;
     _dialogService = dialogService;
     _busyService = busyService;
     _analysisService = analysisService;
 }

 public OpenFileTabContentViewModel(IDialogService dialogService)
 {
     this.dialogService = dialogService;
     
     openFileCommand = ReactiveCommand.Create();
     openFileCommand.Subscribe(_ => OpenFile());
 }

        public ProposalsListViewModel(
            [Import]IBackgroundExecutor executor,
            [Import]IEventAggregator eventAggregator,
            [Import]IDialogService dialogs,
            [Import]IAuthorizationService authorizator,
            [Import]IBacklogService backlogService,
            [Import]IProposalsService proposalsService)
        {
            this.executor = executor;
                this.dialogs = dialogs;
                this.aggregator = eventAggregator;

                this.authorizator = authorizator;
                this.proposalsService = proposalsService;
                this.backlogService = backlogService;

                this.aggregator.Subscribe<Project>(ScrumFactoryEvent.ViewProjectDetails, OnViewProjectDetails);

                this.aggregator.Subscribe(ScrumFactoryEvent.RoleHourCostsChanged, LoadProposals);
                this.aggregator.Subscribe<MemberProfile>(ScrumFactoryEvent.SignedMemberChanged, OnSignedMemberChanged);

                this.aggregator.Subscribe(ScrumFactoryEvent.ApplicationWhentBackground, () => { ShowValues = false; });

                OnLoadCommand = new DelegateCommand(CanSeeProposals, () => {
                    ShowValues = false;
                    if (NeedRefresh) LoadProposals();
                });
                AddProposalCommand = new DelegateCommand(CanSeeProposals, AddProposal);
                ShowDetailCommand = new DelegateCommand<Proposal>(CanSeeProposals, ShowDetail);
                ShowHourCostsCommand = new DelegateCommand(CanSeeProposals, ShowHourCosts);
        }

        public AuthenticateDialogViewModel(ICrunchFacade crunchFacade, IDialogService dialogService)
        {
            _crunchFacade = crunchFacade;
            _dialogService = dialogService;

            Title = "Connect to Crunch";
        }

        public AppSettingEdit_ViewModel_WPF(
            ILogger Logger_, 
            INavigationService NavigationService_, 
            IDialogService DialogService_,
            EFDbConnect EFDbConnect_)
        {

            if (!IsInDesignModeNet())
            {
                Logger = Logger_;
                NavigationService = NavigationService_;
                DialogService = DialogService_;
                EFDbConnect = EFDbConnect_;

                Languages = new ObservableCollection<Language>(EFDbConnect.Table<Language>().ToList()); 
                LearningWordStrategies = new ObservableCollection<LearningWordStrategy>(EFDbConnect.Table<LearningWordStrategy>().ToList());

                CommandDispatcher = new MvxCommand<string>(CmdDispatcher);
            }

            if (IsInDesignModeNet())
            {
                Languages = new ObservableCollection<Language>();
                Languages.Add(new Language() {Code="en",Name="English"});
                Languages.Add(new Language() {Code="ru",Name="Русский"});
                Languages.Add(new Language() {Code="ua",Name="Українська мова"});

                Languages[0].DictionariesCollection.Add(new Dictionary {Name="First dictionary" });
                Languages[0].DictionariesCollection.Add(new Dictionary {Name="Ordinary dict" });
                Languages[0].DictionariesCollection.Add(new Dictionary {Name="My dictionary" });

                CurrentLanguage = Languages[0];
            }

        }

        public AppSettingEdit_ViewModel(ILogger Logger_, INavigationService NavigationService_, IDialogService DialogService_, ITranslate TranslateService_)
        {

            if (!IsInDesignMode)
            {
                Logger = Logger_;
                NavigationService = NavigationService_;
                DialogService = DialogService_;

                Languages = ViewModelLocator.Instance.Languages;
                LearningWordStrategies = new ObservableCollection<LearningWordStrategy>(ViewModelLocator.Instance.DataBase.Set<LearningWordStrategy>().ToList());
            }
            
            CommandDispatcher = new RelayCommand<string>(CmdDispatcher);

            if (IsInDesignMode)
            {
                Languages = new ObservableCollection<Language>();
                Languages.Add(new Language() {Code="en",Name="English"});
                Languages.Add(new Language() {Code="ru",Name="Русский"});
                Languages.Add(new Language() {Code="ua",Name="Українська мова"});

                Languages[0].DictionariesCollection.Add(new Dictionary {name="First dictionary" });
                Languages[0].DictionariesCollection.Add(new Dictionary {name="Ordinary dict" });
                Languages[0].DictionariesCollection.Add(new Dictionary {name="My dictionary" });

                CurrentLanguage = Languages[0];
            }

        }

        public OpenDatabaseViewModel(
            INavigationService navigationService,
            IDatabaseInfoRepository databaseInfoRepository,
            ICanSHA256Hash hasher,
            IDialogService dialogService,
            IPWDatabaseDataSource databaseSource,
            ICache cache)
        {
            _cache = cache;
            _databaseSource = databaseSource;
            _dialogService = dialogService;
            _databaseInfoRepository = databaseInfoRepository;
            _hasher = hasher;
            _navigationService = navigationService;
            var canHitOpen = this.WhenAny(
                vm => vm.Password, 
                vm => vm.KeyFileName,
                (p, k) => !string.IsNullOrEmpty(p.Value) || !string.IsNullOrEmpty(k.Value));

            OpenCommand = new ReactiveCommand(canHitOpen);
            OpenCommand.Subscribe(OpenDatabase);

            GetKeyFileCommand = new ReactiveCommand();
            GetKeyFileCommand.Subscribe(GetKeyFile); 
            
            ClearKeyFileCommand = new ReactiveCommand();
            ClearKeyFileCommand.Subscribe(ClearKeyFile);

            IObservable<string> keyFileNameChanged = this.WhenAny(vm => vm.KeyFileName, kf => kf.Value);
            keyFileNameChanged.Subscribe(v => ClearKeyFileButtonIsVisible = !string.IsNullOrWhiteSpace(v));
            keyFileNameChanged.Subscribe(v => GetKeyFileButtonIsVisible = string.IsNullOrWhiteSpace(v));
        }

 /// <summary>
 /// Initializes a new instance of the TaskViewModel class.
 /// </summary>
 public TaskViewModel(Task model, string listId, IDataService dataService, INavigationService navigationService, IDialogService dialogService)
     : base(dataService, navigationService, dialogService)
 {
     _model = model;
     _listId = listId;
     update();
 }

 public BackupViewModel(IBackupManager backupManager,
     IDialogService dialogService, IConnectivity connectivity)
 {
     this.backupManager = backupManager;
     this.dialogService = dialogService;
     this.connectivity = connectivity;
 }

        public OwnersListViewModel(
            [Import]IEventAggregator eventAggregator,
            [Import]ITeamService teamServices,
            [Import]IBackgroundExecutor backgroundExecutor,
            [Import] IDialogService dialogs,
            [Import]IAuthorizationService authorizationService)
        {
            this.aggregator = eventAggregator;

            this.teamServices = teamServices;
            this.executor = backgroundExecutor;
            this.authorizator = authorizationService;
            this.dialogs = dialogs;

            aggregator.Subscribe(ScrumFactoryEvent.ShowOwnersList, Show);

            CloseWindowCommand = new DelegateCommand(CloseWindow);
            OnLoadCommand = new DelegateCommand(LoadOwners);

            ChangeFactoryOwnerCommand = new DelegateCommand<string>(ChangeFactoryOwner);
            ChangeCanSeeProposalsCommand = new DelegateCommand<string>(ChangeCanSeeProposals);

            AddNewMemberCommand = new DelegateCommand(AddNewMember);

            RefreshMemberFilter = LoadMembers;
        }

        public GeographicalViewModel(IProjectService projectService, IDialogService dialogService, IImportService importService, IImageExportService imageExportService,
			GeographicalVarietyViewModel.Factory varietyFactory)
            : base("Geographical")
        {
            _projectService = projectService;
            _dialogService = dialogService;
            _importService = importService;
            _imageExportService = imageExportService;
            _varietyFactory = varietyFactory;

            _newRegionCommand = new RelayCommand<IEnumerable<Tuple<double, double>>>(AddNewRegion);
            _currentClusters = new List<Cluster<Variety>>();

            _projectService.ProjectOpened += _projectService_ProjectOpened;

            Messenger.Default.Register<ComparisonPerformedMessage>(this, msg => ClusterVarieties());
            Messenger.Default.Register<DomainModelChangedMessage>(this, msg =>
                {
                    if (msg.AffectsComparison)
                        ResetClusters();
                    if (_selectedRegion != null && (!_varieties.Contains(_selectedRegion.Variety) || !_selectedRegion.Variety.Regions.Contains(_selectedRegion)))
                        SelectedRegion = null;
                });
            Messenger.Default.Register<PerformingComparisonMessage>(this, msg => ResetClusters());

            _similarityScoreThreshold = 0.7;

            TaskAreas.Add(new TaskAreaCommandGroupViewModel("Similarity metric",
                new TaskAreaCommandViewModel("Lexical", new RelayCommand(() => SimilarityMetric = SimilarityMetric.Lexical)),
                new TaskAreaCommandViewModel("Phonetic", new RelayCommand(() => SimilarityMetric = SimilarityMetric.Phonetic))));
            TaskAreas.Add(new TaskAreaItemsViewModel("Other tasks",
                new TaskAreaCommandViewModel("Import regions", new RelayCommand(ImportRegions)),
                new TaskAreaCommandViewModel("Export this map", new RelayCommand(Export))));
        }

		public PersonDirectoryViewModel(IPersonService personService, IDispatcher dispatcher, IEventAggregator aggregator, IDialogService dialogService) 
			: base(personService, dispatcher, aggregator, dialogService)
		{
			personDirectory = new RangeEnabledObservableCollection<Person>();
			aggregator.GetEvent<PersonDirectoryUpdatedEvent>().Subscribe(OnPersonDirectoryUpdated, ThreadOption.BackgroundThread);
			aggregator.GetEvent<PersonDeletedEvent>().Subscribe(OnPersonDeleted, ThreadOption.UIThread);
		}

        public MemberViewModel(
            [Import(typeof(IAuthorizationService))] IAuthorizationService authorizator,
            [Import(typeof(IBackgroundExecutor))] IBackgroundExecutor executor,
            [Import(typeof(IEventAggregator))] IEventAggregator aggregator,
            [Import] IDialogService dialogs,
            [Import(typeof(ITasksService))] ITasksService taskService,
            [Import(typeof(ITeamService))] ITeamService teamService)
        {
            this.taskService = taskService;
            this.authorizator = authorizator;
            this.executor = executor;
            this.aggregator = aggregator;
            this.teamService = teamService;
            this.dialogs = dialogs;

            aggregator.Subscribe(ScrumFactoryEvent.ShowProfile, Show);
            aggregator.Subscribe<MemberProfile>(ScrumFactoryEvent.SignedMemberChanged, OnSignedMemberChanged);

            ChangeAvatarCommand = new DelegateCommand(ChangeMemberImage);
            RemoveAvatarCommand = new DelegateCommand(RemoveMemberImage);
            CloseWindowCommand = new DelegateCommand(Close);
            CreateAvatarCommand = new DelegateCommand(CreateAvatar);

            UpdateAvatarCommand = new DelegateCommand(() => {
                executor.StartBackgroundTask(
                () => {
                    teamService.UpdateMember(authorizator.SignedMemberProfile.MemberUId, MemberProfile);
                }, () => {
                    myProfileNocache = new Random().Next().ToString();
                    DefineMemberAvatarUrl();
                });
            });
        }

 public CategoryDialogViewModel(IRepository<Category> categoryRepository, IDialogService dialogService,
     SettingsCategoryListViewModel categoryListViewModel)
 {
     this.categoryRepository = categoryRepository;
     this.dialogService = dialogService;
     this.categoryListViewModel = categoryListViewModel;
 }

 public FolderBrowserTabContentViewModel(IDialogService dialogService)
 {
     this.dialogService = dialogService;
     
     browseFolderCommand = ReactiveCommand.Create();
     browseFolderCommand.Subscribe(_ => BrowseFolder());
 }

        public ClientViewModel(
            IAsyncRequestDispatcherFactory asyncRequestDispatcherFactory,
            IDialogService dialogService,
            IAddClientViewModel addClientViewModel,
            IAddPositionViewModel addPositionViewModel,
            IAddIndustryViewModel addIndustryViewModel)
        {
            _asyncRequestDispatcherFactory = asyncRequestDispatcherFactory;
            _dialogService = dialogService;
            _addClientViewModel = addClientViewModel;
            _addPositionViewModel = addPositionViewModel;
            _addIndustryViewModel = addIndustryViewModel;

            _addClientRequest = new InteractionRequest<ResponseNotification>();
            _addPositionRequest = new InteractionRequest<ResponseNotification>();
            _addIndustryRequest = new InteractionRequest<ResponseNotification>();

            AddClientCommand = new DelegateCommand(AddClient);
            RemoveClientCommand = new DelegateCommand(RemoveClient);
            AddPositionCommand = new DelegateCommand(AddPosition);
            RemovePositionCommand = new DelegateCommand(RemovePosition);
            AddIndustryCommand = new DelegateCommand(AddIndustry);
            RemoveIndustryCommand = new DelegateCommand(RemoveIndustry);
            EditClientCommand = new DelegateCommand<ClientModel>(EditClient);
        }

 public BasePlaylistableViewModel(IDataService dataService, IAccountService accountService, IDialogService dialogService, IResourceService resourceService)
 {
     this.DataService = dataService;
     this.AccountService = accountService;
     this.DialogService = dialogService;
     this.ResourceService = resourceService;
 }

        public ViewModelBase(IPersonService personService, IDispatcher dispatcher, IEventAggregator aggregator, IDialogService dialogService)
        {
            if (personService == null)
            {
                throw new ArgumentNullException("personService");
            }

            if (dispatcher == null)
            {
                throw new ArgumentNullException("dispatcher");
            }

            if (aggregator == null)
            {
                throw new ArgumentNullException("aggregator");
            }

            if (dialogService == null)
            {
                throw new ArgumentNullException("dialogService");
            }

            this.personService = personService;
            this.dispatcher = dispatcher;
            this.aggregator = aggregator;
            this.dialogService = dialogService;

            isBusy = false;
        }