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 TasksController()
{
var contextRepository = new ContextRepository();
_userRepository = new UserRepository(contextRepository);
_taskRepository = new TaskRepository(contextRepository, _userRepository);
_workflowStepRepository = new WorkflowStepRepository(contextRepository);
}
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 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 TaskController(IUnitOfWork unitOfWork, ITaskRepository taskRepository, IProjectRepository projectRepository, IDisposableCollection disposables)
: base(disposables)
{
_taskRepository = taskRepository;
_projectRepository = projectRepository;
_unitOfWork = unitOfWork;
}
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 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 BoardController()
{
_boardRepository = new BoardRepository();
_columnRepository = new ColumnRepository();
_colorRepository = new ColorRepository();
_taskRepository = new TaskRepository();
}
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 TaskController(ITaskRepository repository)
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
_repository = repository;
}
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 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 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;
}
private void InitializeRepositories()
{
_userRepository = new UserEntityRepository();
_sectorRepository = new IndustrialSectorEntityRepository();
_taskRepository = new TaskEntityRepository();
_contactRepository = new ContactEntityRepository();
_accountRepository = new AccountEntityRepository();
_opportunityRepository = new OpportunityEntityRepository();
}
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;
}
public TaskFacadeService(ITaskService taskService, ITaskSyncService taskSyncService,
ITaskRepository taskRepository,ITaskCategoryRepository taskCategoryRepository)
{
this.taskService = taskService;
this.taskSyncService = taskSyncService;
this.taskRepository = taskRepository;
this.taskCategoryRepository = taskCategoryRepository;
}
public TaskService(
IEventBroker eventBroker,
ITaskRepository repository,
ICatalogRepository catalogRepository)
{
this.repository = repository;
this.catalogRepository = catalogRepository;
this.eventBroker = eventBroker;
}
/// <summary>
/// setup code
/// </summary>
private void before_each()
{
_tasks = new List<TaskItem>();
_taskRepository = Substitute.For<ITaskRepository>();
_collectionSource = Substitute.For<ICollectionViewSourceFactory>();
var wrappedCollectionViewSource = new WrappedCollectionViewSource<TaskItem>();
_collectionSource.CreateTaskListViewSource().Returns(wrappedCollectionViewSource);
_taskListViewModel = null;
}
public BranchBrowser(ITaskRepository taskRepository, ISourceRepository sourceRepository, IShelvesetRepository shelvesetRepository, IBuildRepository buildRepository)
: base(taskRepository, sourceRepository, shelvesetRepository, buildRepository)
{
_revisionBrowser = new RevisionBrowser(_taskRepository, _sourceRepository, _shelvesetRepository, _buildRepository);
_changeCommitter = new ChangeCommitter(_taskRepository, _sourceRepository, _shelvesetRepository, _buildRepository);
InitializeComponent();
branchGrid.Grid.MultiSelect = false;
this.ExecuteLater(10, () => SwitchCurrentTab(true));
}
public TasqueObjectFactory(ITaskListRepository taskListRepo,
ITaskRepository taskRepo, INoteRepository noteRepo = null)
{
if (taskListRepo == null)
throw new ArgumentNullException ("taskListRepo");
if (taskRepo == null)
throw new ArgumentNullException ("taskRepo");
this.taskListRepo = taskListRepo;
this.taskRepo = taskRepo;
this.noteRepo = noteRepo;
}
public TaskAppService(
ITaskPolicy taskPolicy,
ITaskRepository taskRepository,
ITaskeverUserRepository userRepository,
IEventBus eventBus)
{
_taskRepository = taskRepository;
_userRepository = userRepository;
_eventBus = eventBus;
_taskPolicy = taskPolicy;
}
public NewTaskViewModel(ITaskRepository taskRepository)
{
this.taskRepository = taskRepository;
CreateTaskCommand = new DelegateCommand(CreateTask, () => !Saving);
CancelCommand = new DelegateCommand(()=>
{
Owner.DialogResult = false;
Owner.Close();
}, ()=>!Saving);
TodoItem = new TodoItem();
}
public TasksController(ITaskRepository taskRepository, IUserRepository userRepository, IRepository<Tip> tipsRepository, IRepository<Code> codesRepository)
: base(userRepository)
{
Check.Require(taskRepository != null, "taskRepository may not be null");
Check.Require(tipsRepository != null, "tipsRepository may not be null");
Check.Require(codesRepository != null, "codesRepository may not be null");
this.taskRepository = taskRepository;
this.tipsRepository = tipsRepository;
this.codesRepository = codesRepository;
}
private static TasksController SetupControllerForTest(ITaskRepository repository)
{
var config = new HttpConfiguration();
var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/tasks");
var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}");
var routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", "tasks" } });
var controller = new TasksController(repository);
controller.ControllerContext = new HttpControllerContext(config, routeData, request);
controller.Request = request;
controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
return controller;
}
public TaskService(ITaskRepository taskRepository)
{
_taskRepository = taskRepository;
}
/// <summary>
///In constructor, we can get needed classes/interfaces.
///They are sent here by dependency injection system automatically.
/// </summary>
public TaskAppService(ITaskRepository taskRepository, IRepository <Person> personRepository)
{
_taskRepository = taskRepository;
_personRepository = personRepository;
}
public TaskController(ITaskRepository taskRepository)
{
_taskRepository = taskRepository;
}
public TaskManagerHandler(ITaskRepository taskRepo)
{
this.taskRepo = taskRepo;
}
public TaskController(ITaskRepository repository, ILogger logger)
{
_repository = repository;
_logger = logger;
}
public UserService(IUserRepository userRepository, ITaskRepository taskRepository)
{
_userRepository = userRepository;
_taskRepository = taskRepository;
}
public HomeController(ITaskRepository repository)
{
_repository = repository;
}
public TaskBusinessLogic(ITaskRepository taskRepository)
{
TaskRepository = taskRepository;
}
public UnitOfWork(ITaskRepository taskRepository)
{
Tasks = taskRepository;
}
public DeleteTaskById(ITaskRepository taskRepository)
{
_taskRepository = taskRepository;
}
public AddEditTaskViewModel(ITaskRepository repository)
{
_repository = repository;
AddTaskCommand = new RelayCommand(SaveTask, CanSave);
CancelTaskCommand = new RelayCommand(CancelProject);
}
public TaskService(ITaskRepository taskRepository, IUnitOfWork unitOfWork)
{
_taskRepository = taskRepository;
_unitOfWork = unitOfWork;
}
public TaskTests(ITestOutputHelper output, DynamicsWebAppFixture fixture) : base(output, fixture)
{
taskRepository = Services.GetRequiredService <ITaskRepository>();
}
public TaskService(IMapper mapper, ITaskRepository taskRepsitory)
{
_mapper = mapper;
_taskRepository = taskRepsitory;
}
public BoardService(IColumnRepository columnRepository, ITaskRepository taskRepository)
{
_columnRepository = columnRepository;
_taskRepository = taskRepository;
}
public BoardsController(IBoardRepository boardRepository, ICompanyRepository companyRepository, ITaskRepository taskRepository, ILogger <BoardsController> logger,
UserManager <ApplicationUser> userManager)
{
_boardRepository = boardRepository;
_companyRepository = companyRepository;
_taskRepository = taskRepository;
_logger = logger;
_userManager = userManager;
}
public TasksController(ILogger <TasksController> logger, ITaskRepository taskRepository)
{
_logger = logger;
_taskRepository = taskRepository;
}
public WebAppAdminController(ISubscriptionRepository SubscriptionRepo, IBusinessRepository businessRepo, IUserRepository userRepo, ITaskRepository taskRepo)
{
_subscriptionRepo = SubscriptionRepo;
_businessRepo = businessRepo;
_userRepo = userRepo;
}
/// <summary>
/// Constructor to iject resources, context, and task service.
/// </summary>
public TaskService(ITaskRepository _taskRepository)
{
this.taskRepository = _taskRepository;
}
public static bool LevelExists(this ITaskRepository taskRepository, Guid topicId, Guid levelId) => taskRepository.FindLevel(topicId, levelId) != null;
public TaskController(ITaskRepository repo, UserManager <AppUser> usrMgr)
{
repository = repo;
userManager = usrMgr;
}
public TaskRegister(ITaskRepository taskRepository)
{
_taskRepository = taskRepository;
}
public AddTaskCommandHandler(ITaskRepository taskRepository, IMapper mapper)
{
_taskRepository = taskRepository ?? throw new ArgumentNullException(nameof(taskRepository));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
}
public TaskAccessService(
ITaskRepository taskRepository)
{
this.taskRepository = taskRepository;
}
public TaskController(ITaskRepository taskRepository, TaskService taskService)
{
_taskRepository = taskRepository;
_taskService = taskService;
}
/// <summary>
/// Initializes a new instance of the <see cref="TaskQueryInteractor"/> class.
/// </summary>
/// <param name="taskRepository">The task repository.</param>
/// <param name="logger">The logger.</param>
public TaskQueryInteractor(ITaskRepository taskRepository, ILoggingService logger) : base(logger)
{
Validate.IsNotNull(taskRepository, nameof(taskRepository));
this.taskRepository = taskRepository;
}
public void Cleanup(BenchmarkContext context)
{
taskRepository = null;
}
public TaskService(ITaskRepository taskRepository, ILogger <TaskService> logger)
{
this.taskRepository = taskRepository;
this.logger = logger;
}
public ToDoController(IToDoRepository _toDorepository, ITaskRepository _taskRepository, IReminderRepository _reminderRepository)
{
toDoRepository = _toDorepository;
taskRepository = _taskRepository;
reminderRepository = _reminderRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="TaskService"/> class.
/// </summary>
/// <param name="repository">The repository.</param>
public TaskService(ITaskRepository repository)
{
_repository = repository;
}
