public EncounterPlayerStatistics(ILogger logger, IEncounterRepository encounterRepository, IScheduledTaskRepository taskRepository, IBossFightSingleTargetDetail bossFightSingleTargetDetailRepository)
{
_logger = logger;
_encounterRepository = encounterRepository;
_taskRepository = taskRepository;
_bossFightSingleTargetDetailRepository = bossFightSingleTargetDetailRepository;
}
public TaskManager(IScheduledTaskRepository scheduledTaskRepository, IConfigService configService, IConfigFileProvider configFileProvider, Logger logger)
{
_scheduledTaskRepository = scheduledTaskRepository;
_configService = configService;
_configFileProvider = configFileProvider;
_logger = logger;
}
public TaskManager(IScheduledTaskRepository scheduledTaskRepository, IConfigService configService, ICacheManager cacheManager, Logger logger)
{
_scheduledTaskRepository = scheduledTaskRepository;
_configService = configService;
_cache = cacheManager.GetCache <ScheduledTask>(GetType());
_logger = logger;
}
public AddMissingEncounterPlayerRoles(ILogger logger, IEncounterRepository encounterRepository,
IScheduledTaskRepository taskRepository)
{
_logger = logger;
_encounterRepository = encounterRepository;
_taskRepository = taskRepository;
}
public ScheduledTaskRunner(
IDateCalculator dateCalculator,
IScheduledTaskRepository scheduledTaskRepository,
IEnumerable <IScheduledTask> scheduledTasks)
{
this.dateCalculator = dateCalculator;
this.scheduledTaskRepository = scheduledTaskRepository;
this.scheduledTasks = scheduledTasks;
}
public AllocationNotifier(
IDateCalculator dateCalculator,
IEmailRepository emailRepository,
IScheduledTaskRepository scheduledTaskRepository)
{
this.dateCalculator = dateCalculator;
this.emailRepository = emailRepository;
this.scheduledTaskRepository = scheduledTaskRepository;
}
public SyncronizationController(IScheduledTaskRepository scheduledTaskRepo
, INotificationService notificationService
, IMapper mapper
, ILogger <SyncronizationController> logger)
{
_scheduledTaskRepo = scheduledTaskRepo;
_notificationService = notificationService;
_mapper = mapper;
_logger = logger;
}
public ScheduledTaskController(IScheduledTaskRepository scheduledTaskRepo
, IUnitOfWork unitOfWork
, IMapper mapper
, INotificationService notificationService
, ILogger <ScheduledTaskController> logger)
{
_scheduledTaskRepo = scheduledTaskRepo;
_unitOfWork = unitOfWork;
_mapper = mapper;
_notificationService = notificationService;
_logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="TaskProcessorRepository"/> class.
/// </summary>
/// <param name="tasksRepository">The tasks repository.</param>
/// <param name="taskRuntimeInfoRepository">The task runtime information repository.</param>
/// <param name="taskProcessorsRepository">The task processor runtime information repository.</param>
/// <param name="taskSummaryRepository">The task summary repository.</param>
/// <param name="taskJobSettingsRepository">The task job settings repository.</param>
/// <param name="scheduledTasksRepository">The scheduled tasks repository.</param>
/// <exception cref="ArgumentNullException">Parameter <paramref name="tasksRepository"/>,
/// <paramref name="taskRuntimeInfoRepository"/>, <paramref name="taskProcessorsRepository"/>, <paramref name="taskProcessorsRepository"/>
/// <paramref name="taskJobSettingsRepository"/> or <paramref name="scheduledTasksRepository"/> is null.</exception>
protected TaskProcessorRepository(
ITaskRepository tasksRepository,
ITaskRuntimeInfoRepository taskRuntimeInfoRepository,
ITaskProcessorRuntimeInfoRepository taskProcessorsRepository,
ITaskSummaryRepository taskSummaryRepository,
ITaskJobSettingsRepository taskJobSettingsRepository,
IScheduledTaskRepository scheduledTasksRepository)
{
Trace.WriteLine("ENTER: Constructing '{0}' ...".FormatInvariant(this.GetType().Name));
if (tasksRepository == null)
{
throw new ArgumentNullException("tasksRepository");
}
if (taskRuntimeInfoRepository == null)
{
throw new ArgumentNullException("taskRuntimeInfoRepository");
}
if (taskProcessorsRepository == null)
{
throw new ArgumentNullException("taskProcessorsRepository");
}
if (taskSummaryRepository == null)
{
throw new ArgumentNullException("taskSummaryRepository");
}
if (taskJobSettingsRepository == null)
{
throw new ArgumentNullException("taskJobSettingsRepository");
}
if (scheduledTasksRepository == null)
{
throw new ArgumentNullException("scheduledTasksRepository");
}
this.tasks = tasksRepository;
this.taskRuntimeInfo = taskRuntimeInfoRepository;
this.taskProcessors = taskProcessorsRepository;
this.taskSummary = taskSummaryRepository;
this.taskJobSettings = taskJobSettingsRepository;
this.scheduledTasks = scheduledTasksRepository;
Trace.WriteLine("ENTER: Constructing '{0}' ...".FormatInvariant(this.GetType().Name));
}
public App(IScheduledTaskRepository scheduledTaskRepository, IScheduledTaskBuilderFactory scheduledTaskBuilderFactory, ILogger <App> logger, IDueTaskJobQueue dueTaskJobQueue)
{
_taskRepository = scheduledTaskRepository; // where the scheduled tasks are stored
_taskBuilderFactory = scheduledTaskBuilderFactory; // a handy builder for scheduled tasks
_logger = logger; // gather evidence that a task has been executed
// Setup a task handler for all tasks
dueTaskJobQueue.RegisterHandlerForAllTasks((scheduledTask) =>
{
_logger.LogInformation($"{scheduledTask.JobData} {scheduledTask.Id}");
});
// Setup a specific task handler for tasks which have a SpecificTaskPayload as their jobdata
dueTaskJobQueue.RegisterHandlerWhen((scheduledTask) =>
{
var payload = JsonSerializer.Deserialize <SpecificTaskPayload>(scheduledTask.JobData);
_logger.LogInformation($"SpecificTaskPayload {payload.Run()} {scheduledTask.Id}");
}, task => task.JobDataTypeName == nameof(SpecificTaskPayload));
}
public TimerService(IConfiguration config, ILogger <TimerService> logger, IClock clock, IScheduledTaskRepository schedulerState, IDueTaskJobQueue dueTaskJobQueue)
{
_config = config;
_logger = logger;
_clock = clock;
_schedulerState = schedulerState;
_dueTaskJobQueue = dueTaskJobQueue;
if (_config["timerInitialDelay"] != null)
{
_initialDelay = int.Parse(_config["timerInitialDelay"]);
}
if (_config["timerPeriod"] != null)
{
_period = int.Parse(_config["timerPeriod"]);
}
_logger.LogInformation($"TimerService initialised with initial delay of {_initialDelay}ms and period of {_period}ms");
}
public RemoveOrphanedPlayerRecords(ILogger logger, IPlayerRepository playerRepository, IScheduledTaskRepository taskRepository)
{
_logger = logger;
_playerRepository = playerRepository;
_taskRepository = taskRepository;
}
public ZeroDurationEncounters(ILogger logger, IScheduledTaskRepository taskRepository, IEncounterRepository encounterRepository)
{
_logger = logger;
_taskRepository = taskRepository;
_encounterRepository = encounterRepository;
}
public UpdatePlayerNames(ILogger logger, IPlayerRepository playerRepository, IScheduledTaskRepository taskRepository)
{
_logger = logger;
_playerRepository = playerRepository;
_taskRepository = taskRepository;
}
public MarkOldWipesForDeletion(ILogger logger, IScheduledTaskRepository taskRepository, IEncounterRepository encounterRepository)
{
_logger = logger;
_taskRepository = taskRepository;
_encounterRepository = encounterRepository;
}
