public CognateIdentifierOptionsViewModel(SegmentPool segmentPool, IProjectService projectService, EMSoundChangeInducerOptionsViewModel em,
     LexStatOptionsViewModel lexStat)
     : base("Cognacy", "Method", em, lexStat)
 {
     _segmentPool = segmentPool;
     _projectService = projectService;
 }

 public ProjectsController(IProjectService projectService, IDictionaryService dictionaryService, ISprintService spirntService, ApplicationUserManager applicationUserManager)
 {
     _projectService = projectService;
     _dictionaryService = dictionaryService;
     _sprintService = spirntService;
     _applicationUserManager = applicationUserManager;
 }

        public HierarchicalGraphViewModel(IProjectService projectService, IImageExportService exportService, IGraphService graphService)
            : base("Hierarchical Graph")
        {
            _projectService = projectService;
            _exportService = exportService;
            _graphService = graphService;

            _projectService.ProjectOpened += _projectService_ProjectOpened;

            Messenger.Default.Register<ComparisonPerformedMessage>(this, msg =>
            {
                if (_projectService.AreAllVarietiesCompared)
                    Graph = _graphService.GenerateHierarchicalGraph(_graphType, _clusteringMethod, _similarityMetric);
            });
            Messenger.Default.Register<DomainModelChangedMessage>(this, msg =>
            {
                if (msg.AffectsComparison)
                    Graph = null;
            });
            Messenger.Default.Register<PerformingComparisonMessage>(this, msg => Graph = null);

            TaskAreas.Add(new TaskAreaCommandGroupViewModel("Graph type",
                new TaskAreaCommandViewModel("Dendrogram", new RelayCommand(() => GraphType = HierarchicalGraphType.Dendrogram)),
                new TaskAreaCommandViewModel("Tree", new RelayCommand(() => GraphType = HierarchicalGraphType.Tree))));
            TaskAreas.Add(new TaskAreaCommandGroupViewModel("Clustering method",
                new TaskAreaCommandViewModel("UPGMA", new RelayCommand(() => ClusteringMethod = ClusteringMethod.Upgma)),
                new TaskAreaCommandViewModel("Neighbor-joining", new RelayCommand(() => ClusteringMethod = ClusteringMethod.NeighborJoining))));
            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("Export graph", new RelayCommand(Export, CanExport))));
            _graphType = HierarchicalGraphType.Dendrogram;
        }

        public XmlFormatterFeature(IProjectService projectService, FeatureSet featureSet)
            : base(projectService)
        {
            this.none = new FeatureItem(
                "None",
                "None",
                "Removes the XML formatter.",
                featureSet == FeatureSet.Mvc6 ? 1 : 3)
            {
                IsSelected = featureSet == FeatureSet.Mvc6
            };
            this.Items.Add(none);

            this.dataContractSerializer = new FeatureItem(
                "DataContractSerializer",
                "DataContractSerializer",
                "Include an XML input and output formatter using the DataContractSerializer.",
                featureSet == FeatureSet.Mvc6 ? 2 : 1)
            {
                IsSelected = featureSet == FeatureSet.Mvc6Api
            };
            this.Items.Add(dataContractSerializer);

            this.xmlSerializer = new FeatureItem(
                "XmlSerializer",
                "XmlSerializer",
                "Include an XML input and output formatter using the XmlSerializer.",
                featureSet == FeatureSet.Mvc6 ? 3 : 2);
            this.Items.Add(xmlSerializer);
        }

 public ProjectsController(IProjectService projectService,
     ILogger logger)
 {
     _projectService = projectService;
     _projectService.UserManager = UserManager;
     _logger = logger;
 }

 public PoorMansAffixIdentifierViewModel(SpanFactory<ShapeNode> spanFactory, SegmentPool segmentPool, IProjectService projectService)
     : base("Automatic stemmer", "Input-Settings#automatic-stemmer")
 {
     _spanFactory = spanFactory;
     _segmentPool = segmentPool;
     _projectService = projectService;
 }

 //, UserBaseRepository userStore)
 public ProjectController(IProjectService projectService, IUserService userService, IProjectTypeRepository projectTypeService)
 {
     _projectService = projectService;
     _userService = userService;
     _projectTypeService = projectTypeService;
     _logger = LogManager.Instance;
 }

        public NodeDetailsViewModel( IEventAggregator eventAggregator, IProjectService<Project> projectService )
        {
            myProjectService = projectService;

            eventAggregator.GetEvent<NodeSelectedEvent>().Subscribe( node => SetNode( node ) );
            eventAggregator.GetEvent<NodeActivatedEvent>().Subscribe( node => ActivateNode( node ) );
        }

        public WordListsViewModel(IProjectService projectService, IDialogService dialogService, IImportService importService,
			IExportService exportService, IAnalysisService analysisService, WordListsVarietyViewModel.Factory varietyFactory)
            : base("Word lists")
        {
            _projectService = projectService;
            _dialogService = dialogService;
            _importService = importService;
            _exportService = exportService;
            _analysisService = analysisService;
            _varietyFactory = varietyFactory;

            Messenger.Default.Register<SwitchViewMessage>(this, HandleSwitchView);
            Messenger.Default.Register<DomainModelChangedMessage>(this, HandleDomainModelChanged);

            _projectService.ProjectOpened += _projectService_ProjectOpened;

            _findCommand = new RelayCommand(Find);

            TaskAreas.Add(new TaskAreaItemsViewModel("Common tasks",
                    new TaskAreaCommandViewModel("Add a new variety", new RelayCommand(AddNewVariety)),
                    new TaskAreaCommandViewModel("Add a new meaning", new RelayCommand(AddNewMeaning)),
                    new TaskAreaCommandViewModel("Find words", _findCommand),
                    new TaskAreaCommandViewModel("Import word lists", new RelayCommand(Import))));

            TaskAreas.Add(new TaskAreaItemsViewModel("Other tasks",
                    new TaskAreaCommandViewModel("Export word lists", new RelayCommand(Export, CanExport)),
                    new TaskAreaCommandViewModel("Remove affixes from words in all varieties", new RelayCommand(RunStemmer, CanRunStemmer))));
            _addNewVarietyCommand = new RelayCommand(AddNewVariety);
            _addNewMeaningCommand = new RelayCommand(AddNewMeaning);
            _importWordListsCommand = new RelayCommand(Import);
            _showGettingStartedCommand = new RelayCommand(ShowGettingStarted);
            _isEmpty = true;
        }

        public static ProjectTermPredefinedTermsViewModel Create(SquareContext db, IProjectService projectService, int projectStepId, int projectId, string loginId)
        {
            Check.Require(db != null, "Square Entities is required.");
            Check.Require(projectService != null, "projectService is required.");
            Check.Require(loginId != null, "loginId is required.");

            var viewModel = new ProjectTermPredefinedTermsViewModel()
                                {
                                    ProjectStep = db.ProjectSteps.Include("Step").Include("Step.SquareType").Where(a => a.Id == projectStepId).Single(),
                                    Project = db.Projects.Where(a => a.Id == projectId).Single()
                                };

            // load the project step
            var projectStep = viewModel.ProjectStep;

            // load all terms used in project
            var projectTerms = db.ProjectTerms.Where(a => a.Project.Id == projectId && a.SquareType.Id == projectStep.Step.SquareType.Id).ToList();

            // load all terms
            var pt = projectTerms.Select(a => a.Term).ToList();

            // terms that have not been used
            var predefinedTerms = db.Terms.Include("Definitions").Where(a => !pt.Contains(a.Name) && a.IsActive && a.SquareType.Id == projectStep.Step.SquareType.Id).ToList();

            viewModel.PredefinedTerms = predefinedTerms;

            return viewModel;
        }

        public JsonFormatterFeature(IProjectService projectService)
            : base(projectService)
        {
            this.camelCase = new FeatureItem(
                "CamelCase",
                "Camel-Case (e.g. camelCase)",
                "The first character of the variable starts with a lower-case. Each word in the variable name after that starts with an upper-case character.",
                1)
            {
                IsSelected = true
            };
            this.Items.Add(this.camelCase);

            this.titleCase = new FeatureItem(
                "TitleCase",
                "Title Case (e.g. TitleCase)",
                "Each word in the variable name starts with an upper-case character.",
                2);
            this.Items.Add(this.titleCase);

            this.none = new FeatureItem(
                "None",
                "None",
                "Removes the JSON formatter.",
                3);
            this.Items.Add(none);
        }

        public VarietiesViewModel(IProjectService projectService, IDialogService dialogService, IAnalysisService analysisService, VarietiesVarietyViewModel.Factory varietyFactory)
            : base("Varieties")
        {
            _projectService = projectService;
            _dialogService = dialogService;
            _analysisService = analysisService;
            _varietyFactory = varietyFactory;

            _projectService.ProjectOpened += _projectService_ProjectOpened;

            _sortPropertyName = "Meaning.Gloss";
            _sortDirection = ListSortDirection.Ascending;

            Messenger.Default.Register<SwitchViewMessage>(this, HandleSwitchView);

            _findCommand = new RelayCommand(Find);

            TaskAreas.Add(new TaskAreaItemsViewModel("Common tasks",
                    new TaskAreaCommandViewModel("Add a new variety", new RelayCommand(AddNewVariety)),
                    new TaskAreaCommandViewModel("Rename variety", new RelayCommand(RenameSelectedVariety, CanRenameSelectedVariety)),
                    new TaskAreaCommandViewModel("Remove variety", new RelayCommand(RemoveSelectedVariety, CanRemoveSelectedVariety)),
                    new TaskAreaCommandViewModel("Find words", _findCommand),
                    new TaskAreaItemsViewModel("Sort words by", new TaskAreaCommandGroupViewModel(
                        new TaskAreaCommandViewModel("Gloss", new RelayCommand(() => SortWordsBy("Meaning.Gloss", ListSortDirection.Ascending))),
                        new TaskAreaCommandViewModel("Form", new RelayCommand(() => SortWordsBy("StrRep", ListSortDirection.Ascending)))))));

            TaskAreas.Add(new TaskAreaItemsViewModel("Other tasks",
                new TaskAreaCommandViewModel("Remove affixes from words", new RelayCommand(RunStemmer, CanRunStemmer))));
        }

 public ExpenditureController(IOutTypeService OutTypeService, IOutAccountService OutAccountService, IProjectService ProjectService, ICustomerService CustomerService)
 {
     _OutTypeService = OutTypeService;
     _OutAccountService = OutAccountService;
     _ProjectService = ProjectService;
     _CustomerService = CustomerService;
 }

 public SetRandomPortsFeature(
     IPortService portService,
     IProjectService projectService)
     : base(projectService)
 {
     this.portService = portService;
 }

 public FrontEndFrameworkFeature(IProjectService projectService)
     : base(projectService, 
           new IFeatureItem[] 
           {
               new FeatureItem(
                   "Bootstrap",
                   "Bootstrap is the most popular HTML, CSS, and JS framework for developing responsive, mobile first projects on the web.",
                   1,
                   "/Boilerplate.Wizard;component/Assets/Bootstrap.png")
               {
                   IsSelected = true
               },
               new FeatureItem(
                   "Zurb Foundation",
                   "The most advanced responsive front-end framework in the world.",
                   2,
                   "/Boilerplate.Wizard;component/Assets/Zurb Foundation.png",
                   true),
               new FeatureItem(
                   "Semantic UI", 
                   "Semantic is a development framework that helps create beautiful, responsive layouts using human-friendly HTML.", 
                   3,
                   "/Boilerplate.Wizard;component/Assets/Semantic UI.png",
                   true)
           })
 {
 }

        public static ChangeStatusViewModel Create(Project project, IProjectService projectService)
        {
            var viewModel = new ChangeStatusViewModel() {
                Project = project,
                Status = new List<KeyValuePair<int, string>>(),
                ChangeStatusProjectSteps = new List<ChangeStatusProjectStep>(),
                SquareTypes = project.ProjectSteps.Select(a => a.Step.SquareType).Distinct().ToList()
            };

            // add the 3 status'
            viewModel.Status.Add(new KeyValuePair<int, string>((int)ProjectStepStatus.Pending, ProjectStepStatus.Pending.ToString()));
            viewModel.Status.Add(new KeyValuePair<int, string>((int)ProjectStepStatus.Working, ProjectStepStatus.Working.ToString()));
            viewModel.Status.Add(new KeyValuePair<int, string>((int)ProjectStepStatus.Complete, ProjectStepStatus.Complete.ToString()));

            // populate the list of change status project steps
            viewModel.ChangeStatusProjectSteps = project.ProjectSteps.Select(a => new ChangeStatusProjectStep()
                                                            {
                                                                ProjectStepId = a.Id,
                                                                Order = a.Step.Order,
                                                                SquareType = a.Step.SquareType.Id,
                                                                Name = a.Step.Name,
                                                                CurrentStepStatus = projectService.GetStepStatus(projectStep:a),
                                                                CanEdit = true
                                                            }).ToList();

            return viewModel;
        }

        public WordPairViewModel(IProjectService projectService, IAnalysisService analysisService, WordPair wordPair, bool areVarietiesInOrder)
        {
            _projectService = projectService;
            _analysisService = analysisService;
            _wordPair = wordPair;
            _areVarietiesInOrder = areVarietiesInOrder;
            _meaning = new MeaningViewModel(_wordPair.Word1.Meaning);
            _variety1 = new VarietyViewModel(_wordPair.VarietyPair.Variety1);
            _variety2 = new VarietyViewModel(_wordPair.VarietyPair.Variety2);

            IWordAlignerResult results = _projectService.Project.WordAligners[ComponentIdentifiers.PrimaryWordAligner].Compute(_wordPair);
            _alignment = results.GetAlignments().First();
            _prefixNode = new AlignedNodeViewModel(_alignment.Prefixes[0], _alignment.Prefixes[1]);
            var nodes = new List<AlignedNodeViewModel>();
            int i = 0;
            for (int column = 0; column < _alignment.ColumnCount; column++)
            {
                string note = null;
                if (i < _wordPair.AlignmentNotes.Count)
                    note = _wordPair.AlignmentNotes[i];
                nodes.Add(new AlignedNodeViewModel(column, _alignment[0, column], _alignment[1, column], note));
                i++;
            }
            _suffixNode = new AlignedNodeViewModel(_alignment.Suffixes[0], _alignment.Suffixes[1]);

            _alignedNodes = new ReadOnlyCollection<AlignedNodeViewModel>(nodes);

            _showInMultipleWordAlignmentCommand = new RelayCommand(ShowInMultipleWordAlignment);
            _pinUnpinCommand = new RelayCommand(PinUnpin);
        }

        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 ShellViewModel( IProjectService<Project> projectService, IEventAggregator eventAggregator, IPersistenceService<Project> persistenceService )
        {
            myProjectService = projectService;
            myPersistenceService = persistenceService;

            eventAggregator.GetEvent<ApplicationReadyEvent>().Subscribe( x => OnApplicationReady() );
        }

        public JavaScriptTestFrameworkFeature(IProjectService projectService)
            : base(projectService)
        {
            this.mocha = new FeatureItem(
                "Mocha",
                "Mocha",
                "Mocha is a feature-rich JavaScript test framework running on Node.js and the browser, making asynchronous testing simple and fun. The Chai assertion framework and Sinon stub/mocking library are also included.",
                1,
                "/Boilerplate.Wizard;component/Assets/Mocha.png")
            {
                IsSelected = true
            };
            this.Items.Add(this.mocha);

            this.jasmine = new FeatureItem(
                "Jasmine",
                "Jasmine",
                "Mocha is a feature-rich JavaScript test framework running on Node.js and the browser, making asynchronous testing simple and fun. The Sinon stub/mocking library is also included.",
                2,
                "/Boilerplate.Wizard;component/Assets/Jasmine.png",
                true);
            this.Items.Add(this.jasmine);

            this.none = new FeatureItem(
                "None",
                "None",
                "No JavaScript testing framework.",
                3);
            this.Items.Add(this.none);
        }