protected ProjectBaseController(ICurtinUserService lookupService, IProjectRepository projectRepository, IFieldOfResearchRepository fieldOfResearchRepository, ISocioEconomicObjectiveRepository socioEconomicObjectiveRepository) 
     : base(lookupService)
 {
     ProjectRepository = projectRepository;
     FieldOfResearchRepository = fieldOfResearchRepository;
     SocioEconomicObjectiveRepository = socioEconomicObjectiveRepository;
 }

 static ProjectService()
 {
     ProjectService.unitOfWork = new UnitOfWork();
     ProjectService.repository =
         RepositoryFactory.GetRepository<IProjectRepository,
         Project>(ProjectService.unitOfWork);
 }

 public ProjectController(
     IProjectView projectView, 
     INewProjectView newProjectView, 
     IProjectRepository projectRepository, 
     IDealRepository dealRepository,
     INewProjectSupplyView newProjectSupplyView,
     INewProjectHardwareView newProjectHardwareView,
     IEditProjectSupplyView editProjectSupplyView,
     IEditProjectHardwareView editProjectHardwareView,
     INewProjectFrameView newProjectFrameView,
     IEditProjectHardwareSupplyView editProjectHardwareSupplyView,
     ILoadingView loadingView,
     ICatalogRepository catalogRepository,
     ITaskRepository taskRepository)
 {
     this.projectView = projectView;
     this.newProjectView = newProjectView;
     this.projectRepository = projectRepository;
     this.dealRepository = dealRepository;
     this.newProjectSupplyView = newProjectSupplyView;
     this.newProjectHardwareView = newProjectHardwareView;
     this.editProjectHardwareView = editProjectHardwareView;
     this.editProjectSupplyView = editProjectSupplyView;
     this.newProjectFrameView = newProjectFrameView;
     this.editProjectHardwareSupplyView = editProjectHardwareSupplyView;
     this.loadingView = loadingView;
     this.catalogRepository = catalogRepository;
     this.taskRepository = taskRepository;
 }

 /// <summary>
 /// Initializes a new instance of the ConfirmController class.
 /// </summary>
 public ConfirmController(IProjectRepository projectRepository, IDataCollectionRepository dataCollectionRepository, ICurtinUserService lookupService, IBus bus)
     : base(lookupService)
 {
     _projectRepository = projectRepository;
     _dataCollectionRepository = dataCollectionRepository;
     _bus = bus;
 }

 public BuildPurgeRuleManager(IBuildPurgeRuleRepository buildPurgeRuleRepository, IProjectRepository projectRepository, ISystemSettings systemSettings, IDIFactory diFactory)
 {
     _buildPurgeRuleRepository = DIHelper.VerifyParameter(buildPurgeRuleRepository);
     _projectRepository = DIHelper.VerifyParameter(projectRepository);
     _systemSettings = DIHelper.VerifyParameter(systemSettings);
     _diFactory = DIHelper.VerifyParameter(diFactory);
 }

 public ProjectLogic(IProjectRepository projectRepository, IUserProjectAssignmentRepository userProjectAssignmentRepository,
     IProjectSerialize serializer)
 {
     ProjectRepository = projectRepository;
     UserProjectAssignmentRepository = userProjectAssignmentRepository;
     Serializer = serializer;
 }

 public MasterController(ITicketService ticketService, IUserRepository userRepo, IProjectRepository projectRepo, ITicketRepository ticketRepo)
 {
     _ticketService = ticketService;
     _userRepo = userRepo;
     _projectRepo = projectRepo;
     _ticketRepo = ticketRepo;
 }

 public ConnectionController(IConnectionRepository dbConnectionRepository, IProjectRepository dbProjectRepository,
     IConnectionProviderRepository dbConnectionProviderRepository)
 {
     _dbConnectionRepository = dbConnectionRepository;
     _dbProjectRepository = dbProjectRepository;
     _dbConnectionProviderRepository = dbConnectionProviderRepository;
 }

    public static void GenerateDemoData(
      IIssueRepository issueRepository, 
      IProjectRepository projectRepository, 
      IAttachmentRepository attachmentRepository)
    {
      Project p = new Project("SHOP", "Webshop", "All issues related to the webshop.");
      projectRepository.Add(p);

      Issue i = new Issue(p, "Crash after payment", @"I have justed paid for two pairs of shoes - or rather I tried to. When I clicked 'Pay' all I got was a yellow error screen.", 3);

      issueRepository.Add(i);

      string errorReport = "This is an error report ...";
      Attachment att = new Attachment(i, "Error report", "Error report from end user", Encoding.UTF8.GetBytes(errorReport), "text/plain");
      attachmentRepository.Add(att);

      string logFile = "DEBUG 2014-01-22 15:45:07,610 166033ms  [9] Log4NetTraceListener   WriteLine          - Executing OperationResult OperationResult: type=OK, statusCode=200.";
      att = new Attachment(i, "Logfile", "Logfile with server stack trace", Encoding.UTF8.GetBytes(logFile), "text/plain");
      attachmentRepository.Add(att);

      i = new Issue(p, "Not calculating VAT correctly", @"When I add both shoes and socks it fails to calculate the VAT correctly.", 3);

      issueRepository.Add(i);

      i = new Issue(p, "General Failure?", @"When I press ctrl-P it says 'General failure reading harddisk'! Who is that General and why is he reading my hard disk?", 5);

      issueRepository.Add(i);
    }

        private void AssertCreatedEnvironment(DeployEnvironment result, DeployProject project, string environmentName, List<DeployEnvironmentConfiguration> environmentComponentList, List<DeployEnvironmentConfiguration> environmentConfigurationList, IProjectRepository sut)
        {
            Assert.IsNotNull(result);
            Assert.IsNotNullOrEmpty(result.Id);
            Assert.AreEqual(project.Id, result.ProjectId);
            Assert.AreEqual(environmentName, result.EnvironmentName);
            AssertHelpers.AssertCreatedBaseDto(result, this.UserName);
            
            environmentComponentList = environmentComponentList ?? new List<DeployEnvironmentConfiguration>();
            Assert.AreEqual(environmentComponentList.Count(), result.ComponentList.Count);
            foreach(var item in environmentComponentList)
            {
                var createdItem = result.ComponentList.SingleOrDefault(i=>i.ParentId == item.ParentId);
                AssertCreatedEnvironmentConfiguration(item, createdItem, project, result, EnumDeployStepParentType.Component);
            }
            environmentConfigurationList = environmentConfigurationList ?? new List<DeployEnvironmentConfiguration>();
            Assert.AreEqual(environmentConfigurationList.Count(), result.ConfigurationList.Count);
            foreach (var item in environmentConfigurationList)
            {
                var createdItem = result.ConfigurationList.SingleOrDefault(i => i.ParentId == item.ParentId);
                AssertCreatedEnvironmentConfiguration(item, createdItem, project, result, EnumDeployStepParentType.Configuration);
            }

            var dbItem = sut.GetEnvironment(result.Id, result.ProjectId);
            AssertEnvironment(result, dbItem);

            var dbProject = sut.GetProject(project.Id);
            var dbProjectEnvironment = dbProject.EnvironmentList.SingleOrDefault(i => i.Id == result.Id);
            Assert.IsNotNull(dbProjectEnvironment);
            AssertEnvironment(result, dbProjectEnvironment);
        }

        public static Stack ToProjectLocalTime(this Stack stack, IProjectRepository repository)
        {
            if (stack == null)
                return null;

            return stack.ToProjectLocalTime(repository.GetById(stack.ProjectId, true));
        }

		public TaskController(IUnitOfWork unitOfWork, ITaskRepository taskRepository, IProjectRepository projectRepository, IDisposableCollection disposables)
			: base(disposables)
		{
			_taskRepository = taskRepository;
			_projectRepository = projectRepository;
			_unitOfWork = unitOfWork;
		}

 public void Init()
 {
     _taskRepository = Substitute.For<TaskRepository>();
     _projectRepository = Substitute.For<IProjectRepository>();
     _console = Substitute.For<IConsole>();
     _addTaskCommand = new AddTaskCommand(_console, _taskRepository, _projectRepository, "secrets Eat more donuts.");
 }

 public RemoveProjectWorkItemHandler(IProjectRepository projectRepository, IEventRepository eventRepository, IStackRepository stackRepository, ITokenRepository tokenRepository, IWebHookRepository webHookRepository) {
     _projectRepository = projectRepository;
     _eventRepository = eventRepository;
     _stackRepository = stackRepository;
     _tokenRepository = tokenRepository;
     _webHookRepository = webHookRepository;
 }

        public StatusReportController(IStatusReportRepository repository, ITopicRepository topicRepository, IProjectRepository projectRepository, IResourceRepository resourceRepository, IStatusReportManager statusReportManager, ITagRepository tagRepository)
        {
            _repository = repository;
            _topicRepository = topicRepository;
            _projectRepository = projectRepository;
            _resourceRepository = resourceRepository;
            _tagRepository = tagRepository;
            _statusReportManager = statusReportManager;
            Mapper.CreateMap<StatusReport, StatusReportViewModel>()
                .ForMember(m => m.NumberOfStatusItems, opt => opt.ResolveUsing<NumberOfStatusItemsFormatter>());
            Mapper.CreateMap<StatusItem, StatusReportItemViewModel>()
                .ForMember(m => m.TagsString, opt =>
                {
                    opt.MapFrom(src =>
                        String.Join(",", (from tag in src.Tags
                                          select tag.Name)));
                    opt.NullSubstitute(String.Empty);
                }
                                      );

            Mapper.CreateMap<StatusReportItemViewModel, StatusItem>();

            Mapper.CreateMap<Project, ProjectViewModel>();

            Mapper.CreateMap<Tag, TagViewModel>();
            //.ForMember(m => m.StatusReportId, opt => opt.M);
            //.ForMember(dest => dest.ProjectLeadFullName, opt => opt.MapFrom(src => src.Project.Lead.FullName))
            //.ForMember(dest => dest.ProjectTeamLeadFullName, opt => opt.MapFrom(src => src.Project.Team.Lead.FullName));
        }

 public UserProjectRoleRelationLogic(IUserRepository userRepository,  IUserProjectRoleRelationRepository userProjectRoleRelationRepository, IRoleRepository roleRepository, IProjectRepository projectRepository)
 {
     _userRepository = userRepository;
     _userProjectRoleRelationRepository = userProjectRoleRelationRepository;
     _roleRepository = roleRepository;
     _projectRepository = projectRepository;
 }

 public ProjectScreenshotService(IProjectRepository projectRepository, IMapper mapper, IFileUriProvider uriProvider, IFileSystem fileSystem)
 {
     _projectRepository = projectRepository;
     _uriProvider = uriProvider;
     _fileSystem = fileSystem;
     _mapper = mapper;
 }

 public ProjectServices(IDbContextScopeFactory dbContextScopeFactory, IProjectRepository projectRepository)
 {
     if (dbContextScopeFactory == null) throw new ArgumentNullException("dbContextScopeFactory");
     if (projectRepository == null) throw new ArgumentNullException("projectRepository");
     _dbContextScopeFactory = dbContextScopeFactory;
     _projectRepository = projectRepository;
 }

		public ProjectListViewModel( IViewServiceRepository viewServices = null, ISettingsRepository settingsRepo = null, IProjectRepository projectRepo = null, IMessenger messenger = null )
			: base( viewServices, settingsRepo, messenger )
		{
			ProjectRepo = projectRepo ?? new ProjectRepository( Session );

			Projects = new ObservableCollection<ProjectViewModel>( ProjectRepo.GetAll().OrderBy( p => p.Name ).Select( p => new ProjectViewModel( p ) ) );

			var last = Settings.GetById( SettingKeys.LastProject );
			CurrentProject = Projects.FirstOrDefault( p => p.Model.Id == last.Get<int>() ) ?? Projects.FirstOrDefault();

			foreach( var proj in Projects )
			{
				proj.CurrentChanged += Proj_CurrentChanged;
			}

			if( CurrentProject != null )
			{
				CurrentProject.IsCurrent = true;
			}

			ProjectNames = new List<string>();

			Validate( nameof( NewProjectName ) ).Check( () => !string.IsNullOrWhiteSpace( NewProjectName ) ).Message( Strings.ProjectMustHaveName );
			Validate( nameof( NewProjectName ) ).Check( () => !ProjectNames.Contains( NewProjectName ) ).Message( Strings.ThisNameIsAlreadyUsed );
			Reset();
		}

 public CompanyBusinessLogic(ICompanyRepository repository, IEmployeeRepository empRepository, IProjectRepository projectRepository, IPersonRepository personRepository)
 {
     _repository = repository;
     _empRepository = empRepository;
     _projectRepository = projectRepository;
     _personRepository = personRepository;
 }