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;
 }

 public CharcoalStoryProvider(string apiKey, IStoryRepository storyRepository = null, ITaskRepository taskRepository = null, IUserRepository userRepo = null)
 {
     m_apiKey = apiKey;
     m_userRepo = userRepo ?? new UserRepository();
     m_taskRepository = taskRepository ?? new TaskRepository();
     m_storyRepository = storyRepository ?? new StoryRepository();
 }

 public CatalogController(
     ICatalogRepository repository,
     ITaskRepository taskRepository,
     ICatalogView catalogView,
     INewCatalogView newCatalogView,
     INewSupplyView newSupplyView,
     INewHardwareView newHardwareView,
     IEditSupplyView editSupplyView,
     IEditHardwareView editHardwareView,
     INewHardwareSupplyView newHardwareSupplyView,
     IEditHardwareSupplyView editHardwareSupplyView,
     IImportHardwareView importHardwareView,
     ILoadingView loadingView)
 {
     this.catalogView = catalogView;
     this.newCatalogView = newCatalogView;
     this.newSupplyView = newSupplyView;
     this.newHardwareView = newHardwareView;
     this.editSupplyView = editSupplyView;
     this.editHardwareView = editHardwareView;
     this.newHardwareSupplyView = newHardwareSupplyView;
     this.editHardwareSupplyView = editHardwareSupplyView;
     this.importHardwareView = importHardwareView;
     this.loadingView = loadingView;
     this.repository = repository;
     this.taskRepository = taskRepository;
 }

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

 public TaskBrowser(ITaskRepository taskRepository, ISourceRepository sourceRepository, IShelvesetRepository shelvesetRepository, IBuildRepository buildRepository)
     : base(taskRepository, sourceRepository, shelvesetRepository, buildRepository)
 {
     InitializeComponent();
     taskGrid.Grid.MultiSelect = false;
     this.ExecuteLater(10, () => SwitchCurrentTab(true));
 }

        public TaskModule(ITaskRepository taskRepository)
            : base("/tasks")
        {
            Get["/"] = _ => { return Response.AsJson(taskRepository.Find()); };

            Get["/status/{Status}"] = param =>
                                          {
                                              string status = param.Status;
                                              return Response.AsJson(taskRepository.FindByStatus(status));
                                          };

            Post["/"] = task =>
                            {
                                var newTask = this.Bind<Task>();
                                var t = taskRepository.Save(newTask);
                                return Response.AsJson(t).WithStatusCode(HttpStatusCode.Created);
                            };

            Put["/{Id}"] = task =>
                               {
                                   var updatedTask = this.Bind<Task>();
                                   taskRepository.Update(updatedTask);
                                   return HttpStatusCode.OK;
                               };

            Delete["/{Id}"] = param =>
                                {
                                    taskRepository.Delete(param.Id);
                                    return HttpStatusCode.OK;
                                };
        }

        public MainViewModel(IMessageBus messageBus, ITaskRepository taskRepository)
            : base(messageBus)
        {
            TaskRepository = taskRepository;

            ResetNewTask();
        }

        public TaskService(ITaskRepository taskRepository_)
        {
            if (taskRepository_ == null)
                throw new Exception("Task Repository must be defined.");

            this._taskRepository = taskRepository_;
        }

 public TaskController(ITaskRepository repository, 
     ICategoryRepository categoryRepositoryitory,
     IAnswersRepository answersRepository)
 {
     this.taskRepository = repository;
     this.categoryRepositoryitory = categoryRepositoryitory;
     this.answersRepository = answersRepository;
 }

 public DeviceRepository(DbSet<DeviceModel> devices, DbSet<NetworkModel> networks, Action save, IScriptRepository scripts, ITaskRepository tasks)
 {
     _devices = devices;
     _networks = networks;
     _save = save;
     _scripts = scripts;
     _tasks = tasks;
 }

 public TaskExecutionRepository(ITaskRepository taskRepository,
     IExecutionTokenRepository executionTokenRepository,
     IEventsRepository eventsRepository)
 {
     _taskRepository = taskRepository;
     _executionTokenRepository = executionTokenRepository;
     _eventsRepository = eventsRepository;
 }

 public TaskLogic(ITaskRepository taskRepository, IUserTaskAssignmentRepository userTaskAssignmentRepository,
     ITaskSerialize serializer, IProjectRepository projectRepository)
 {
     TaskRepository = taskRepository;
     UserTaskAssignmentRepository = userTaskAssignmentRepository;
     Serializer = serializer;
     ProjectRepository = projectRepository;
 }

 public BuildInspector(ITaskRepository taskRepository, ISourceRepository sourceRepository, IShelvesetRepository shelvesetRepository, IBuildRepository buildRepository)
     : base(taskRepository, sourceRepository, shelvesetRepository, buildRepository)
 {
     InitializeComponent();
     logViewer.InitializeDefaults();
     logViewer.IsReadOnly = true;
     logViewer.LongLines.EdgeMode = EdgeMode.None;
 }

        public RevisionBrowser(ITaskRepository taskRepository, ISourceRepository sourceRepository, IShelvesetRepository shelvesetRepository, IBuildRepository buildRepository)
            : base(taskRepository, sourceRepository, shelvesetRepository, buildRepository)
        {
            _revisionInspector = new RevisionInspector(taskRepository, sourceRepository, shelvesetRepository, buildRepository);

            InitializeComponent();
            activityRevisions.Grid.MultiSelect = false;
        }

 public TaskController(ITaskRepository repository)
 {
     if (repository == null)
     {
     throw new ArgumentNullException("repository");
     }
     _repository = repository;
 }

 public DealController(IDealRepository dealRepository, ITaskRepository taskRepository, IDealView dealView, INewDealView newDealView, ILoadingView loadingView)
 {
     this.dealView = dealView;
     this.newDealView = newDealView;
     this.loadingView = loadingView;
     this.taskRepository = taskRepository;
     this.dealRepository = dealRepository;
 }

 public TaskService(
     IEventBroker eventBroker,
     ITaskRepository repository,
     ICatalogRepository catalogRepository)
 {
     this.repository = repository;
     this.catalogRepository = catalogRepository;
     this.eventBroker = eventBroker;
 }

        public TaskFacadeService(ITaskService taskService, ITaskSyncService taskSyncService,
            ITaskRepository taskRepository,ITaskCategoryRepository taskCategoryRepository)
        {
            this.taskService = taskService;
            this.taskSyncService = taskSyncService;
            this.taskRepository = taskRepository;

            this.taskCategoryRepository = taskCategoryRepository;
        }

        protected AbstractHistoryComponent(ITaskRepository taskRepository, ISourceRepository sourceRepository, IShelvesetRepository shelvesetRepository, IBuildRepository buildRepository)
        {
            _taskRepository = taskRepository;
            _sourceRepository = sourceRepository;
            _shelvesetRepository = shelvesetRepository;
            _buildRepository = buildRepository;

            this.GotFocus += AbstractHistoryComponent_GotFocus;
        }

 public TestController(ITaskRepository taskRepository, ICodeRepository codeRepository,
     IResultRepository resultRepository, IUserRepository userRepository, IAllCodeRepository allCodeRepository)
 {
     _taskRepository = taskRepository;
     _codeRepository = codeRepository;
     _resultRepository = resultRepository;
     _userRepository = userRepository;
     _allCodeRepository = allCodeRepository;
 }