public ProjectsService(ILogger <ProjectsService> logger, IProjectsRepository projectsRepository,
ITasksRepository tasksRepository)
{
_logger = logger;
_projectsRepository = projectsRepository;
_tasksRepository = tasksRepository;
}
public TasksService(ITasksRepository taskRepository, IProjectsService projectsService, IApplicationUserService applicationUserService, IEmployeeTaskRepository employeeTaskRepository)
{
this.taskRepository = taskRepository;
this.projectsService = projectsService;
this.applicationUserService = applicationUserService;
this.employeeTaskRepository = employeeTaskRepository;
}
public void Get_TaskById()
{
repo = new TaskRepository <ITask>();
repo.InsertTask(task_1);
Assert.IsNotNull(repo.GetTaskById(task_1.Id));
}
public InfrastructureEventHandler(ITasksRepository tasksRepository, IRabbitDeploymentManager rabbitDeploymentManager, IModuleRepository moduleRepository, IModuleManager moduleManager)
{
_tasksRepository = tasksRepository;
_rabbitDeploymentManager = rabbitDeploymentManager;
_moduleRepository = moduleRepository;
_moduleManager = moduleManager;
}
public ApiV11Controller(IApiService auth, ITasksRepository repository, IDateTimeProviderService date, IShareService shareService)
{
_apiService = auth;
_tasksRepository = repository;
_dateTimeService = date;
_shareService = shareService;
}
public ModulesEventHandler(IModuleRepository moduleRepository, ITasksRepository tasksRepository, IModuleManager moduleManager, IEventPublisher eventPublisher, IKubectlHelper kubectlHelper)
{
_moduleRepository = moduleRepository;
_tasksRepository = tasksRepository;
_moduleManager = moduleManager;
_eventPublisher = eventPublisher;
_kubectlHelper = kubectlHelper;
}
public MongoBackup(IMongoSettings settings, ITasksRepository repository)
{
_repository = repository;
var client = new MongoClient(settings.MongoConnectionString);
var database = client.GetDatabase(settings.MongoDbName);
_tasksCollection = database.GetCollection <Models.Task>(TASK_COLLECTION);
}
public ResourceAndStateCleanEventHandler(ITasksRepository tasksRepository, IKubectlHelper kubectlHelper, IEventPublisher eventPublisher, IModuleRepository moduleRepository, IArchiveRepository archiveRepository)
{
_tasksRepository = tasksRepository;
_kubectlHelper = kubectlHelper;
_eventPublisher = eventPublisher;
_moduleRepository = moduleRepository;
_archiveRepository = archiveRepository;
}
public TasksService(
ILogger <TasksService> logger,
IOptionsMonitor <AppOptions> appOptions,
ITasksRepository tasksRepository) : base(logger, appOptions)
{
Guard.Against.Null(tasksRepository, nameof(tasksRepository));
_tasksRepository = tasksRepository;
}
public void Initialize()
{
var repository = new Mock <ITasksRepository>();
_tasks = new List <TaskEntity>()
{
new TaskEntity {
TaskId = 1, TaskName = "Project Task", ParentId = 0, ParentName = "", Priority = 1, ActiveInd = "Y", StartDate = new DateTime(2018, 04, 18), EndDate = new DateTime(2018, 08, 24)
},
new TaskEntity {
TaskId = 2, TaskName = "Coding", ParentId = 1, ParentName = "Project Task", Priority = 2, ActiveInd = "Y", StartDate = new DateTime(2018, 04, 21), EndDate = new DateTime(2018, 08, 26)
},
new TaskEntity {
TaskId = 3, TaskName = "Analysis", ParentId = 1, ParentName = "Project Task", Priority = 3, ActiveInd = "N", StartDate = new DateTime(2018, 04, 18), EndDate = new DateTime(2018, 08, 20)
}
};
// Get All
repository.Setup(r => r.GetAllTasks()).Returns(_tasks);
// Get Task by Id
repository.Setup(r => r.GetTaskById(It.IsAny <int>()))
.Returns((int i) => _tasks.Where(t => t.TaskId == i).SingleOrDefault());
// Insert task
repository.Setup(r => r.AddTask(It.IsAny <TaskEntity>()))
.Callback((TaskEntity t) => _tasks.Add(t));
// Update Task
repository.Setup(r => r.UpdateTask(It.IsAny <TaskEntity>())).Callback(
(TaskEntity target) =>
{
DateTime now = DateTime.Now;
var original = _tasks.Where(
q => q.TaskId == target.TaskId).Single();
original.TaskName = target.TaskName;
original.ParentId = target.ParentId;
original.Priority = target.Priority;
original.StartDate = target.StartDate;
original.EndDate = target.EndDate;
});
// End Task
repository.Setup(r => r.EndTask(It.IsAny <int>(), It.IsAny <string>())).Callback(
(int taskId, string userId) =>
{
DateTime now = DateTime.Now;
var original = _tasks.Where(
q => q.TaskId == taskId).Single();
original.EndDate = DateTime.Now;
original.UpdatedBy = userId;
original.ActiveInd = "N";
});
_mockRepository = repository.Object;
}
public TaskService(
ITasksRepository tasksRepository,
IListService listService,
IMapper mapper)
{
_tasksRepository = tasksRepository;
_listService = listService;
_mapper = mapper;
}
public TasksService(IDbHelper helper, IProjectRepository projectRepo, IGenericRepository genericRepo, IMemberRepository memberRepo, ITasksRepository taskRepo, INotificationsService notificationService)
{
_helper = helper;
_projectRepo = projectRepo;
_genericRepo = genericRepo;
_memberRepo = memberRepo;
_taskRepo = taskRepo;
_notificationService = notificationService;
}
public void Add_InvalidTask()
{
repo = new TaskRepository <ITask>();
repo.InsertTask(task_1);
SimpleTask invalidTask = new SimpleTask(task_1.Id, 9);
Assert.IsFalse(repo.InsertTask(invalidTask));
}
public TaskEditViewModel(
IRegionManager regionManager,
ITasksRepository tasksRepository,
IEmployeesRepository employeesRepository) : base(regionManager, typeof(TaskEdit), typeof(TaskEditRibbonTab))
{
this.tasksRepository = tasksRepository;
this.employeesRepository = employeesRepository;
RegisterCommands();
}
public TasksDataService(
ILogger <TasksDataService> logger,
ITasksRepository tasksRepository,
IUsersRepository usersRepository)
{
_logger = logger;
_tasksRepository = tasksRepository;
_usersRepository = usersRepository;
}
public HomeController(UserManager <AppUser> userManager, ITasksRepository tasksRepo, ISuggestionRepository suggestionRepo, IUnitOfWork _unitOfWork, ISendEmail emailSender, IHttpContextAccessor httpContextAccessor)
{
unitOfWork = _unitOfWork;
tasksRepository = tasksRepo;
suggestionRepository = suggestionRepo;
_userManager = userManager;
_emailSender = emailSender;
_httpContextAccessor = httpContextAccessor;
}
public TasksService(IOptions<SourceControlRestApiConfiguration> sourceControlRestApiConfiguration, ITasksRepository tasksRepository, IGroupsRepository groupsRepository, IUserService userService, IWebClientFactory webClientFactory)
{
_sourceControlRestApiConfiguration = sourceControlRestApiConfiguration;
_tasksRepository = tasksRepository;
_groupsRepository = groupsRepository;
_userService = userService;
_webClientFactory = webClientFactory;
_sourceControlUrl = "http://it-learning-source-control.azurewebsites.net/";// _sourceControlRestApiConfiguration.Value.Url;
}
public TasksController(
UserContext userContext,
IUnitOfWork unitOfWork,
ITasksRepository tasksRepository,
IDbContextAccessor dbContextAccessor)
{
this.userContext = userContext;
this.unitOfWork = unitOfWork;
this.tasksRepository = tasksRepository;
this.dbContextAccessor = dbContextAccessor;
}
public UserService(
ICdnService cdnService,
IUsersRepository usersRepository,
ITasksRepository tasksRepository,
IMapper mapper)
{
_cdnService = cdnService;
_usersRepository = usersRepository;
_tasksRepository = tasksRepository;
_mapper = mapper;
}
public ActionService(IActionRepository actionRepository, IUserForAuditingRepository userRepository,
IEmployeeRepository employeeRepository, ISiteRepository siteRepository,
ITaskCategoryRepository taskCategoryRepository, IPeninsulaLog log, IBus bus, ITasksRepository tasksRepository, IDocumentParameterHelper documentParameterHelper)
{
_actionRepository = actionRepository;
_userForAuditingRepository = userRepository;
_employeeRepository = employeeRepository;
_siteRepository = siteRepository;
_taskCategoryRepository = taskCategoryRepository;
_log = log;
_bus = bus;
_tasksRepository = tasksRepository;
_documentParameterHelper = documentParameterHelper;
}
public EmployeeNotificationsService(
ITasksRepository tasksRepository
, IBus bus
, IUserForAuditingRepository userForAuditingRepository
, IGetOverdueMultiHazardRiskAssessmentTasksForEmployeeQuery<GeneralRiskAssessment> overdueGraTaskQuery
, IGetOverdueMultiHazardRiskAssessmentTasksForEmployeeQuery<PersonalRiskAssessment> overduePraTaskQuery
, IGetOverdueFireRiskAssessmentFurtherControlMeasureTasksForEmployeeQuery overdueFraTasksQuery
, IGetOverdueHazardousSubstanceRiskAssessmentFurtherControlMeasureTasksForEmployeeQuery overdueHsraTasksQuery
, IGetOverdueRiskAssessmentReviewTasksForEmployeeQuery overdueRaReviewTasksQuery
, IGetOverdueResponsibilitiesTasksForEmployeeQuery overdueResponsibilitiesTasksForEmployee
, IGetOverdueActionTasksForEmployeeQuery overdueActionTasksForEmployeeQuery
, IGetCompletedHazardousSubstanceRiskAssessmentFurtherControlMeasureTasksForEmployeeQuery completedHSRATasksQuery
, IGetCompletedFireRiskAssessmentFurtherControlMeasureTasksForEmployeeQuery completedFraTasksQuery
, IGetCompletedMultiHazardRiskAssessmentTasksForEmployeeQuery<GeneralRiskAssessment> completedGraTaskQuery
, IGetCompletedMultiHazardRiskAssessmentTasksForEmployeeQuery<PersonalRiskAssessment> completedPraTaskQuery
, IGetCompletedRiskAssessmentReviewTasksForEmployeeQuery completedRAReviewTasksQuery
, IGetDueMultiHazardRiskAssessmentTasksForEmployeeQuery<GeneralRiskAssessment> dueGraTasksQuery
, IGetDueMultiHazardRiskAssessmentTasksForEmployeeQuery<PersonalRiskAssessment> duePraTasksQuery
, IGetDueFireRiskAssessmentFurtherControlMeasureTasksForEmployeeQuery dueFraTasksQuery
, IGetDueHazardousSubstanceRiskAssessmentFurtherControlMeasureTasksForEmployeeQuery dueTomorrowHsraTasksQuery
, IGetDueRiskAssessmentReviewTasksForEmployeeQuery dueRiskAssessmentReviewTasksForEmployeeQuery
, IGetDueResponsibilityTasksForEmployeeQuery dueResponsibilityTasksForEmployeeQuery
, IGetDueActionTasksForEmployeeQuery dueActionTasksForEmployee)
{
_tasksRepository = tasksRepository;
_bus = bus;
_userForAuditingRepository = userForAuditingRepository;
_overdueGRATasksQuery = overdueGraTaskQuery;
_overduePRATasksQuery = overduePraTaskQuery;
_overdueFRATasksQuery = overdueFraTasksQuery;
_overdueHSRATasksQuery = overdueHsraTasksQuery;
_overdueRAReviewTasksQuery = overdueRaReviewTasksQuery;
_overdueResponsibilitiesTasksForEmployee = overdueResponsibilitiesTasksForEmployee;
_overdueActionTasksForEmployeeQuery = overdueActionTasksForEmployeeQuery;
_completedHSRATasksQuery = completedHSRATasksQuery;
_completedFRATasksQuery = completedFraTasksQuery;
_completedGRATasksQuery = completedGraTaskQuery;
_completedPRATasksQuery = completedPraTaskQuery;
_completedRAReviewTasksQuery = completedRAReviewTasksQuery;
_dueGraTasksQuery = dueGraTasksQuery;
_duePraTasksQuery = duePraTasksQuery;
_dueFraTasksQuery = dueFraTasksQuery;
_dueTomorrowHSRATasksQuery = dueTomorrowHsraTasksQuery;
_dueRiskAssessmentReviewTasksForEmployeeQuery = dueRiskAssessmentReviewTasksForEmployeeQuery;
_dueResponsibilityTasksForEmployeeQuery = dueResponsibilityTasksForEmployeeQuery;
_dueActionTasksForEmployee = dueActionTasksForEmployee;
}
public TaskService(
ITaskCategoryRepository responsibilityTaskCategoryRepository,
IPeninsulaLog log,
ITasksRepository taskRepository,
IUserForAuditingRepository userForAuditingRepository,
IEmployeeRepository employeeRepository,
ISiteGroupRepository siteGroupRepository)
{
_responsibilityTaskCategoryRepository = responsibilityTaskCategoryRepository;
_log = log;
_taskRepository = taskRepository;
_userForAuditingRepository = userForAuditingRepository;
_employeeRepository = employeeRepository;
_siteGroupRepository = siteGroupRepository;
}
public CalendarViewModel(
IRegionManager regionManager,
ITasksRepository tasksRepository,
IEmployeesRepository employeesRepository,
IEventAggregator eventAggregator) : base(regionManager, typeof(Calendar), typeof(CalendarRibbonTab))
{
this.tasksRepository = tasksRepository;
this.employeesRepository = employeesRepository;
this.eventAggregator = eventAggregator;
this.eventAggregator.GetEvent <TaskAddedEvent>().Subscribe(OnTaskAdded);
this.eventAggregator.GetEvent <TaskDeletedEvent>().Subscribe(OnTaskDeleted);
this.eventAggregator.GetEvent <TaskUpdatedEvent>().Subscribe(OnTaskUpdated);
Title = "Kalendarz";
RegisterCommands();
}
public UnitOfWork(ITimer timer,
ICommitsRepository commitsRepo,
IEmployeeRepository employeeRepo,
ITasksRepository tasksRepo,
IDailyRepo dailyReportRepo,
ISprintRepo sprintReportRepo,
ITeamLeaderRepo teamLeaderReportRepo)
{
Timer = timer;
CommitsRepo = commitsRepo;
EmployeeRepo = employeeRepo;
TasksRepo = tasksRepo;
DailyReportRepo = dailyReportRepo;
SprintReportRepo = sprintReportRepo;
TeamLeaderReportRepo = teamLeaderReportRepo;
}
public static string GetOptimalConfiguration(int capacity, ITasksRepository <ITask> groupA, ITasksRepository <ITask> groupB)
{
if (capacity < 1 || groupA == null || groupA.GetTasks().Count < 1 || groupB == null || groupB.GetTasks().Count < 1)
{
throw new Exception("LoadBalancer.GetOptimalConfiguration: Invalid input values");
}
var result = new OptimalCombinations(0);
foreach (var taskA in groupA.GetTasks())
{
if (taskA.Consumption > capacity)
{
continue;
}
var groupBTasks = groupB.FindByConsumption(capacity - taskA.Consumption);
if (groupBTasks == null || groupBTasks.Count < 1)
{
continue;
}
foreach (var taskB in groupBTasks)
{
int tmpConsumption = taskA.Consumption + taskB.Consumption;
if (tmpConsumption < result.OptimalConsumption)
{
break;
}
if (tmpConsumption > result.OptimalConsumption)
{
result = new OptimalCombinations(tmpConsumption);
}
result.AddCombination(new Combination {
taskA = taskA.Id, taskB = taskB.Id
});
}
}
return(result.ToString());
}
static void ReadInputFile()
{
StringBuilder sbResults = new StringBuilder();
var fileLines = System.IO.File.ReadAllLines(@"challenge.in");
int lineIdx = 0;
foreach (var line in fileLines)
{
if (string.IsNullOrWhiteSpace(line))
{
continue;
}
switch (lineIdx)
{
case 0:
GetResourceCapacity(line);
lineIdx++;
break;
case 1:
AreValidTasks(line);
foregroundTasks = Parse(line);
lineIdx++;
break;
case 2:
default:
AreValidTasks(line);
backgroundTasks = Parse(line);
sbResults.AppendLine(LoadBalancer.GetOptimalConfiguration(resourceCapacity, foregroundTasks, backgroundTasks));
lineIdx = 0;
InitValues();
break;
}
}
CreateOutputFile(sbResults);
}
public TasksListViewModel(
IRegionManager regionManager,
IEventAggregator eventAggregator,
ITasksRepository tasksRepository,
IEmployeesRepository employeesRepository) : base(regionManager, typeof(TasksList), typeof(TasksListRibbonTab))
{
this.eventAggregator = eventAggregator;
this.tasksRepository = tasksRepository;
this.employeesRepository = employeesRepository;
var tasks = this.tasksRepository.Tasks;
foreach (var task in tasks)
{
var employee = this.employeesRepository.Employees.FirstOrDefault(x => x.Id == task.EmployeeId);
task.Employee = $"{employee.FirstName} {employee.LastName}";
}
Tasks = new ObservableCollection <Task>(tasks.OrderByDescending(x => x.TaskDate));
this.eventAggregator.GetEvent <TaskAddedEvent>().Subscribe(OnTaskAddedEvent);
this.eventAggregator.GetEvent <TaskDeletedEvent>().Subscribe(OnTaskDeletedEvent);
this.eventAggregator.GetEvent <TaskUpdatedEvent>().Subscribe(OnTaskUpdatedEvent);
this.eventAggregator.GetEvent <TaskSucceededEvent>().Subscribe(OnTaskSucceededEvent);
this.eventAggregator.GetEvent <TaskFailedEvent>().Subscribe(OnTaskFailedEvent);
RegisterCommands();
}
public AdminService(IGenericRepository genericRepo, ITasksRepository taskRepo, IAdminRepository adminRepo)
{
_genericRepo = genericRepo;
_tasksRepo = taskRepo;
_adminRepo = adminRepo;
}
public ShareController(IShareService shareService, ITasksRepository tasks, IUsersRepository users)
{
_shareService = shareService;
_tasksRepository = tasks;
_usersRepository = users;
}
public UsersRepository(ITasksRepository tasksRepository, RedisClient redisClient)
{
_redisClient = redisClient;
_tasksRepository = tasksRepository;
}
public TasksController()
{
this.repository = new FakeTasksRepository();
}
public CurrenciesController(ITasksRepository tasks)
{
this.tasks = tasks;
}
public MySendActionTaskCompletedEmailHandler(IEmailSender emailSender, IBusinessSafeEmailLinkBaseUrlConfiguration urlConfiguration, ITasksRepository taskRepository,
IUserRepository userRepository)
: base(emailSender, urlConfiguration, taskRepository, userRepository)
{
}
public AccountController()
{
this.tasks = new TasksRepository();
}
public TasksController(ITasksRepository tasksRepository)
{
this.repository = tasksRepository;
}
private TasksService(ITasksRepository tasksRepo, IConfigService configService)
{
_tasksRepo = tasksRepo;
_configService = configService;
}
public TasksController()
{
repository = new TasksRepository();
}
public TimerController()
{
repository = new FakeTasksRepository();
}
public TaskManagementController(ITasksRepository tasksRepository)
{
_tasksRepository = tasksRepository;
}
public TimerController(ITasksRepository repository)
{
this.repository = repository;
}
public MyTaskService(ITaskCategoryRepository responsibilityTaskCategoryRepository, IPeninsulaLog log, ITasksRepository taskRepository, IUserForAuditingRepository userRepository, IEmployeeRepository employeeRepository, ISiteGroupRepository siteGroupRepository, IBus bus)
: base(responsibilityTaskCategoryRepository, log, taskRepository, userRepository, employeeRepository, siteGroupRepository)
{
}
public TasksController(ITasksRepository repository)
{
_repository = repository;
}
public BusinessTripController(ITasksRepository tasks)
{
this.tasks = tasks;
}
public TasksService(IMapper autoMapper, ITasksRepository taskRepo)
{
_autoMapper = autoMapper;
_taskRepo = taskRepo;
}
public TasksController(ITasksRepository Repository)
{
repository = Repository;
}
public EverythingService(ITasksRepository tasksRepo, IProjectRepository projectRepo, IGenericRepository genericRepo)
{
_tasksRepo = tasksRepo;
_projectRepo = projectRepo;
_genericRepo = genericRepo;
}
public TasksController()
{
this.repository = new FakeTasksRepository();
}
public DictionariesController(ITasksRepository tasks)
{
this.tasks = tasks;
}
public TaskLoadController(IxmlProcessor proc, ITasksRepository repo)
{
this.processor = proc;
this.repository = repo;
}
public TasksController(ITasksRepository tasksRepository)
{
this.repository = tasksRepository;
}
public TaskController(ITasksRepository tasksRepository)
{
_tasksRepository = tasksRepository;
}
public TasksService(ITasksRepository tasksRepository)
{
_tasksRepository = tasksRepository;
}
