public GamePartDriver(IOrchardServices orchardServices, IDateLocalization dateLocalization,
IScheduledTaskManager taskManager, IDateLocalizationServices dateServices,
IQuestionnairesServices questionnairesServices)
{
_orchardServices = orchardServices;
_dateLocalization = dateLocalization;
}
public DefaultTelemetryServicesProvider()
{
IServiceManager serviceManager = ServiceManager.GetInstance();
coreServer = serviceManager.GetService <ICoreServerService>();
taskManager = serviceManager.GetService <IScheduledTaskManager>();
}
public IMAPClientTaskHandler(
IRepository <UserPartRecord> userRepository,
IWorkflowManager workflowManager,
IIMAPHostRecordService imapHostRecordService,
IOrchardServices orchardServices,
ITransactionManager transactionManager,
IIMapProviderFactory imapProviderFactory,
IScheduledTaskManager taskManager)
{
this.userRepository = userRepository;
this.transactionManager = transactionManager;
this.workflowManager = workflowManager;
this.imapHostRecordService = imapHostRecordService;
this.orchardServices = orchardServices;
this.imapProviderFactory = imapProviderFactory;
_taskManager = taskManager;
Logger = NullLogger.Instance;
this.T = NullLocalizer.Instance;
try
{
DateTime firstDate = DateTime.UtcNow.AddMinutes(PeriodInMinutes);
ScheduleNextTask(firstDate);
}
catch (Exception e)
{
this.Logger.Error(e, e.Message);
}
}
public ArchiveLaterService(
IOrchardServices services,
IScheduledTaskManager scheduledTaskManager) {
Services = services;
_scheduledTaskManager = scheduledTaskManager;
T = NullLocalizer.Instance;
}
public GITClientTaskHandler(
ShellSettings settings,
IRepository <UserPartRecord> userRepository,
IRepository <GITServerRecord> svnServerRepository,
IRepository <GITServerBranchRecord> gitServerBranchRepository,
IAppDataFolder appDataFolder,
IWorkflowManager workflowManager,
IOrchardServices orchardServices,
ITransactionManager transactionManager,
IScheduledTaskManager taskManager)
{
this.gitServerBranchRepository = gitServerBranchRepository;
this.svnServerRepository = svnServerRepository;
this.userRepository = userRepository;
this.appDataFolder = appDataFolder;
this.transactionManager = transactionManager;
this.workflowManager = workflowManager;
this.orchardServices = orchardServices;
this.shellSettings = settings;
_taskManager = taskManager;
Logger = NullLogger.Instance;
this.T = NullLocalizer.Instance;
try
{
DateTime firstDate = DateTime.UtcNow.AddMinutes(PeriodInMinutes);
ScheduleNextTask(firstDate);
}
catch (Exception e)
{
this.Logger.Error(e, e.Message);
}
}
public UsersService(
IContentManager contentManager,
IOrchardServices orchardServices,
IRoleService roleService,
IMessageManager messageManager,
IScheduledTaskManager taskManager,
IRepository<EmailPartRecord> emailRepository,
ShellSettings shellSettings,
IRepository<UserRolesPartRecord> userRolesRepository,
ICacheManager cache,
IClock clock,
ISignals signals)
{
_signals = signals;
_clock = clock;
_cache = cache;
_emailRepository = emailRepository;
_orchardServices = orchardServices;
_contentManager = contentManager;
_roleService = roleService;
_messageManager = messageManager;
_taskManager = taskManager;
_shellSettings = shellSettings;
_userRolesRepository = userRolesRepository;
T = NullLocalizer.Instance;
Logger = NullLogger.Instance;
}
public UserHandler(IWebStoreServices webStoreServices, IScheduledTaskManager scheduledTaskManager, IClock clock, IEnumerable <ICustomerEventHandler> customerEventHandlers)
{
this._clock = clock;
this._webStoreServices = webStoreServices;
this._scheduledTaskManager = scheduledTaskManager;
this._customerEventHandlers = customerEventHandlers;
}
public EmailServiceTaskHandeler(IScheduledTaskManager taskManager, IMailChimpSettingsService settingsService, IRepository <Outbox> mailOutBox, IRepository <OrderRecord> orders)
{
_settingsService = settingsService;
_mailOutBox = mailOutBox;
_taskManager = taskManager;
_orders = orders;
//foreach (var item in _taskManager.GetTasks(TASK_TYPE))
//{
// _taskManager.DeleteTasks(item.ContentItem);
//}
Logger = NullLogger.Instance;
try
{
var firstDate = DateTime.UtcNow.AddMinutes(3);
//firstDate = TimeZoneInfo.ConvertTimeToUtc(firstDate, TimeZoneInfo.Local);
ScheduleNextTask(firstDate);
}
catch (Exception e)
{
this.Logger.Error(e, e.Message);
}
}
public ExternalPushController(IPushGatewayService pushGatewayService, IOrchardServices orchardServices, IScheduledTaskManager taskManager)
{
_pushGatewayService = pushGatewayService;
_orchardServices = orchardServices;
_taskManager = taskManager;
Logger = NullLogger.Instance;
}
public ArchiveLaterService(
IOrchardServices services,
IScheduledTaskManager scheduledTaskManager)
{
Services = services;
_scheduledTaskManager = scheduledTaskManager;
T = NullLocalizer.Instance;
}
public override void Init() {
_mockServices = new Mock<IOrchardServices>();
base.Init();
_repository = _container.Resolve<IRepository<ScheduledTaskRecord>>();
_scheduledTaskManager = _container.Resolve<IScheduledTaskManager>();
_contentManager = _container.Resolve<IContentManager>();
_mockServices.SetupGet(x => x.ContentManager).Returns(_contentManager);
}
public PushScheduledTaskHandler(IPushGatewayService pushGatewayService, ICommunicationService communicationService, IScheduledTaskManager taskManager, IOrchardServices orchardServices)
{
_pushGatewayService = pushGatewayService;
_communicationService = communicationService;
_taskManager = taskManager;
_orchardServices = orchardServices;
Logger = NullLogger.Instance;
}
public DynamicButtonToWorkflowsPartHandler(
INotifier notifier,
IScheduledTaskManager scheduledTaskManager,
IWorkflowManager workflowManager)
{
_notifier = notifier;
_scheduledTaskManager = scheduledTaskManager;
T = NullLocalizer.Instance;
_workflowManager = workflowManager;
OnUpdated <DynamicButtonToWorkflowsPart>((context, part) => {
try {
if (!string.IsNullOrWhiteSpace(part.ButtonName))
{
var content = context.ContentItem;
if (part.ActionAsync)
{
// the task will need to use part.ButtonName to invoke the correct
// process. We generate a task that contains that in its type. Then
// we will parse that out when processing the task.
_scheduledTaskManager
.CreateTask(
DynamicButtonToWorflowsScheduledTaskHandler.TaskType(part.ButtonName),
DateTime.UtcNow.AddMinutes(1),
part.ContentItem);
if (!string.IsNullOrEmpty(part.MessageToWrite))
{
_notifier.Add(NotifyType.Information, T(part.MessageToWrite));
}
}
else
{
_workflowManager
.TriggerEvent("DynamicButtonEvent",
content,
() => new Dictionary <string, object> {
{ "ButtonName", part.ButtonName },
{ "Content", content }
});
if (!string.IsNullOrEmpty(part.MessageToWrite))
{
_notifier.Add(NotifyType.Information, T(part.MessageToWrite));
}
}
part.ButtonName = "";
part.MessageToWrite = "";
}
} catch (Exception ex) {
Logger.Error(ex, "Error in DynamicButtonToWorkflowsPartHandler. ContentItem: {0}", context.ContentItem);
part.ButtonName = "";
part.MessageToWrite = "";
}
});
}
public static void EmailAsync(this IScheduledTaskManager _taskManager, ContentItem contentItem)
{
var tasks = _taskManager.GetTasks(Services.EmailScheduledTaskHandler.TASK_TYPE_EMAIL);
if (tasks == null || tasks.Count() < 100)
{
_taskManager.CreateTask(Services.EmailScheduledTaskHandler.TASK_TYPE_EMAIL, DateTime.UtcNow, contentItem);
}
}
public override void Init()
{
_mockServices = new Mock <IOrchardServices>();
base.Init();
_repository = _container.Resolve <IRepository <ScheduledTaskRecord> >();
_scheduledTaskManager = _container.Resolve <IScheduledTaskManager>();
_contentManager = _container.Resolve <IContentManager>();
_mockServices.SetupGet(x => x.ContentManager).Returns(_contentManager);
}
public QuestionnaireStatsController(IOrchardServices orchardServices, IQuestionnairesServices questionnairesServices, IScheduledTaskManager taskManager, INotifier notifier, ShellSettings shellSettings)
{
_orchardServices = orchardServices;
_questionnairesServices = questionnairesServices;
_taskManager = taskManager;
_notifier = notifier;
_shellSettings = shellSettings;
T = NullLocalizer.Instance;
}
public LockFileCleaner(
IScheduledTaskManager scheduledTaskManager,
IClock clock,
IStorageProvider storageProvider)
{
_scheduledTaskManager = scheduledTaskManager;
_clock = clock;
_storageProvider = storageProvider;
}
public static void AppendModelAsync(this IScheduledTaskManager _taskManager, ContentItem contentItem)
{
var tasks = _taskManager.GetTasks(Services.AppendModelScheduledTaskHandler.TASK_TYPE_APPEND_MODEL);
if (tasks == null || tasks.Count() < 100)
{
_taskManager.CreateTask(Services.AppendModelScheduledTaskHandler.TASK_TYPE_APPEND_MODEL, DateTime.UtcNow, contentItem);
}
}
public MarkdownContentUpdaterScheduledTask(IGitHubRepoService gitHubRepoService, IContentManager contentManager, IClock clock, IScheduledTaskManager scheduledTaskManager)
{
_gitHubRepoService = gitHubRepoService;
_contentManager = contentManager;
_clock = clock;
_scheduledTaskManager = scheduledTaskManager;
Logger = NullLogger.Instance;
}
public LockFileCleaner(
IScheduledTaskManager scheduledTaskManager,
IClock clock,
IStorageProvider storageProvider)
{
_scheduledTaskManager = scheduledTaskManager;
_clock = clock;
_storageProvider = storageProvider;
}
public FeaturedProductService(IContentManager contentManager, IBidService bidService, IMessageService messageService, IShapeFactory shapeFactory, IScheduledTaskManager scheduledTaskManager, IWorkContextAccessor workContextAccessor) {
_contentManager = contentManager;
_bidService = bidService;
_messageService = messageService;
Shape = shapeFactory;
_scheduledTaskManager = scheduledTaskManager;
_workContextAccessor = workContextAccessor;
T = NullLocalizer.Instance;
}
public ProductSettingsPartHandler(IScheduledTaskManager scheduledTaskManager, IContentManager contentManager) {
_scheduledTaskManager = scheduledTaskManager;
_contentManager = contentManager;
T = NullLocalizer.Instance;
Filters.Add(new ActivatingFilter<ProductSettingsPart>("Site"));
Filters.Add(new TemplateFilterForPart<ProductSettingsPart>("ProductSettings", "Parts.Product.SiteSettings", "Sellit"));
OnUpdated<ProductSettingsPart>(RescheduleExistingProducts);
}
public MailApiService(
IContentManager contentManager,
IScheduledTaskManager taskManager,
IConcurrentTaskService concurrentTasks)
{
_contentManager = contentManager;
_taskManager = taskManager;
T = NullLocalizer.Instance;
Logger = NullLogger.Instance;
_concurrentTasks = concurrentTasks;
}
public SiteResetTask(IScheduledTaskManager scheduledTaskManager,
IClock clock,
IRepository<ScheduledTaskRecord> repository,
IThemeService themeService,
ISiteThemeService siteThemeService){
_scheduledTaskManager = scheduledTaskManager;
_clock = clock;
_repository = repository;
_themeService = themeService;
_siteThemeService = siteThemeService;
}
public HiddenStringFieldsSettingsEvents(
IContentDefinitionManager contentDefinitionManager,
IScheduledTaskManager scheduledTaskManager,
IClock clock)
{
_contentDefinitionManager = contentDefinitionManager;
_scheduledTaskManager = scheduledTaskManager;
_clock = clock;
T = NullLocalizer.Instance;
}
public NotificationsService(
IContentManager contentManager,
IClock clock,
IAuthorizer authorizer,
IScheduledTaskManager scheduledTaskManager) {
_contentManager = contentManager;
_clock = clock;
_authorizer = authorizer;
_scheduledTaskManager = scheduledTaskManager;
}
public MobilePushPartHandler(IRepository <MobilePushPartRecord> repository, INotifier notifier, IScheduledTaskManager taskManager, IOrchardServices orchardServices, IPushGatewayService pushGatewayService)
{
Logger = NullLogger.Instance;
T = NullLocalizer.Instance;
_notifier = notifier;
_orchardServices = orchardServices;
_pushGatewayService = pushGatewayService;
_taskManager = taskManager;
Filters.Add(StorageFilter.For(repository));
OnUpdated <MobilePushPart>((context, part) => {
if (_orchardServices.WorkContext.HttpContext.Request.Form["submit.Save"] == "submit.PushTest")
{
// Invio Push di Test
_pushGatewayService.PublishedPushEventTest(part.ContentItem);
}
if (_orchardServices.WorkContext.HttpContext.Request.Form["submit.Save"] == "submit.PushContact")
{
// invia la push al contact selezionato
string contactTitle = "";
string aux = _orchardServices.WorkContext.HttpContext.Request.Form["contact-to-push"];
// rimuove il numero di device racchiuso tra parentesi per ricavare il nome del contact
int idx = aux.LastIndexOf(" (");
if (idx > 0)
{
contactTitle = aux.Substring(0, idx);
}
else
{
contactTitle = aux;
}
// invia la push
if ((string.IsNullOrWhiteSpace(contactTitle) == false) && (string.IsNullOrWhiteSpace(part.TextPush) == false))
{
_pushGatewayService.SendPushToContact(part.ContentItem, contactTitle);
_notifier.Information(T("Push message will be sent to contact {0} in a minute.", contactTitle));
}
}
});
OnPublished <MobilePushPart>((context, part) => {
try {
if ((part.ToPush == true) && (part.PushSent == false))
{
_taskManager.CreateTask("Laser.Orchard.PushNotification.Task", DateTime.UtcNow.AddMinutes(-1), part.ContentItem);
part.PushSent = true;
}
}
catch (Exception ex) {
Logger.Error(ex, "Error starting asynchronous thread to send push notifications.");
}
});
}
public NotificationsService(
IContentManager contentManager,
IClock clock,
IAuthorizer authorizer,
IScheduledTaskManager scheduledTaskManager)
{
_contentManager = contentManager;
_clock = clock;
_authorizer = authorizer;
_scheduledTaskManager = scheduledTaskManager;
}
public MailApiService(
IContentManager contentManager,
IScheduledTaskManager taskManager,
IConcurrentTaskService concurrentTasks)
{
_contentManager = contentManager;
_taskManager = taskManager;
T = NullLocalizer.Instance;
Logger = NullLogger.Instance;
_concurrentTasks = concurrentTasks;
}
public void Initialize()
{
IServiceManager manager = ServiceManager.GetInstance();
manager.Bind <ITelemetryServicesProvider>(provider, true);
manager.Bind <ITelemetryDataCollector>(typeof(TelemetryDataCollectorImpl), true);
IScheduledTaskManager taskManager = manager.GetService <IScheduledTaskManager>();
taskManager.AddScheduledTask(new HWUsageCollectorTask());
taskManager.AddScheduledTask(new TelemetryProcessorTask());
}
public ProductPartHandler(IRepository<ProductPartRecord> repository,
ITaxonomyService taxonomyService, IScheduledTaskManager scheduledTaskManager, IWorkContextAccessor workContextAccessor) {
_taxonomyService = taxonomyService;
_scheduledTaskManager = scheduledTaskManager;
_workContextAccessor = workContextAccessor;
Filters.Add(StorageFilter.For(repository));
OnCreated<ProductPart>(SetCategory);
OnPublished<ProductPart>(ScheduleUnpublish);
}
public CleanupSnapshotsTaskHandler(IRepository <SnapshotRecord> repository,
IEnumerable <ISnapshotRetentionPolicy> retentionPolicies,
IScheduledTaskManager scheduledTaskManager,
IClock clock)
{
_repository = repository;
_retentionPolicies = retentionPolicies;
_scheduledTaskManager = scheduledTaskManager;
_clock = clock;
Logger = NullLogger.Instance;
}
public SiteResetTask(IScheduledTaskManager scheduledTaskManager,
IClock clock,
IRepository <ScheduledTaskRecord> repository,
IThemeService themeService,
ISiteThemeService siteThemeService)
{
_scheduledTaskManager = scheduledTaskManager;
_clock = clock;
_repository = repository;
_themeService = themeService;
_siteThemeService = siteThemeService;
}
/*
* as this is now, the task does not get eliminated after being completed becacuse we recreate it
* */
public ScheduledTaskHandler(IScheduledTaskManager taskManager, IQuestionnairesServices questionnairesServices)
{
_questionnairesServices = questionnairesServices;
_taskManager = taskManager;
Logger = NullLogger.Instance;
try {
//DateTime firstDate = DateTime.UtcNow.AddHours(6);//DateTime.UtcNow.AddSeconds(30);//new DateTime().AddMinutes(5);
//ScheduleNextTask(firstDate);
} catch (Exception e) {
this.Logger.Error(e, e.Message);
}
}
public static void CreateTaskIfNew(this IScheduledTaskManager taskManager, string taskType, DateTime scheduledUtc, ContentItem contentItem)
{
var outdatedTaskCount = taskManager.GetTasks(taskType, DateTime.UtcNow).Count();
var taskCount = taskManager.GetTasks(taskType).Count();
if (taskCount != 0 && taskCount - outdatedTaskCount > 0)
{
return;
}
taskManager.CreateTask(taskType, scheduledUtc, contentItem);
}
public TagNodeUpdater(
IContentManager contentManager,
IAssociativyServices associativyServices,
ITagGraphManager tagGraphManager,
IScheduledTaskManager scheduledTaskManager,
IClock clock)
{
_contentManager = contentManager;
_associativyServices = associativyServices;
_tagGraphManager = tagGraphManager;
_scheduledTaskManager = scheduledTaskManager;
_clock = clock;
}
public MailerScheduledTaskHandler(IOrchardServices orchardServices, IMailCommunicationService mailCommunicationService,
ShellSettings shellSettings, ICommunicationService communicationService, ITemplateService templateService,
IScheduledTaskManager taskManager, IClock clock, ICommonsServices commonServices)
{
_orchardServices = orchardServices;
_mailCommunicationService = mailCommunicationService;
_shellSettings = shellSettings;
_communicationService = communicationService;
_templateService = templateService;
_taskManager = taskManager;
_commonServices = commonServices;
_clock = clock;
Logger = NullLogger.Instance;
}
public ToolScheduledTaskHandler(
IOrchardServices orchardServices,
IScheduledTaskManager scheduledTaskManager,
ShellSettings shellSettings,
IFieldExternalService fieldExternalService,
IWorkContextAccessor workContextAccessor)
{
_workContextAccessor = workContextAccessor;
_orchardServices = orchardServices;
_scheduledTaskManager = scheduledTaskManager;
_fieldExternalService = fieldExternalService;
Logger = NullLogger.Instance;
_shellSettings = shellSettings;
}
public ScheduledTaskService(IRepository <LaserTaskSchedulerRecord> repoLaserTaskScheduler,
IOrchardServices orchardServices,
IScheduledTaskManager taskManager,
IRepository <ScheduledTaskRecord> repoTasks,
IDateLocalizationServices dateServices,
IDateLocalization dateLocalization)
{
_repoLaserTaskScheduler = repoLaserTaskScheduler;
_orchardServices = orchardServices;
_taskManager = taskManager;
_repoTasks = repoTasks;
_dateServices = dateServices;
_dateLocalization = dateLocalization;
}
public PushTask(
IOrchardServices orchardServices,
IPushGatewayService pushGatewayService,
IRepository <UserDeviceRecord> userDeviceRecord,
IScheduledTaskManager taskManager
)
{
_pushGatewayService = pushGatewayService;
_orchardServices = orchardServices;
_userDeviceRecord = userDeviceRecord;
_taskManager = taskManager;
T = NullLocalizer.Instance;
Logger = NullLogger.Instance;
}
public PushNotificationController(
IOrchardServices orchardServices
, IPushNotificationService pushNotificationService
, INotifier notifier
, IPushGatewayService pushGatewayService
, IScheduledTaskManager taskManager
)
{
_orchardServices = orchardServices;
_pushNotificationService = pushNotificationService;
_notifier = notifier;
_pushGatewayService = pushGatewayService;
_taskManager = taskManager;
}
public BitbucketChangesetUpdater(
IBitbucketService bitbucketService,
IResolve<IDistributedLock> lockResolve,
IScheduledTaskManager scheduledTaskManager,
IClock clock,
ISiteService siteService)
{
_bitbucketService = bitbucketService;
_lockResolve = lockResolve;
_scheduledTaskManager = scheduledTaskManager;
_clock = clock;
_siteService = siteService;
Logger = NullLogger.Instance;
}
public DistributedEventService(
IDistributedEventHandler eventHandler,
IRepository<DistributedEventRecord> repository,
IEventCursor eventCursor,
IEnvironmentIdentifierProvider environmentIdentifierProvider,
IScheduledTaskManager scheduledTaskManager,
IClock clock)
{
_eventHandler = eventHandler;
_repository = repository;
_eventCursor = eventCursor;
_environmentIdentifierProvider = environmentIdentifierProvider;
_scheduledTaskManager = scheduledTaskManager;
_clock = clock;
}
public ScheduleActions(
IContentManager contentManager,
IScheduledTaskManager scheduledTaskManager,
IRepository<RuleRecord> repository,
IRepository<ActionRecord> actionRecordRepository,
IRepository<ScheduledActionRecord> scheduledActionRecordRepository,
IClock clock,
ITokenizer tokenizer) {
_contentManager = contentManager;
_scheduledTaskManager = scheduledTaskManager;
_repository = repository;
_actionRecordRepository = actionRecordRepository;
_scheduledActionRecordRepository = scheduledActionRecordRepository;
_clock = clock;
_tokenizer = tokenizer;
}
public ADTaskHandler(IScheduledTaskManager taskManager,
ILdapDirectoryCache ldapDirectoryCache, IADUpdaterService myService, IContentManager contentManager)
{
_myService = myService;
_contentManager = contentManager;
this.ldapDirectoryCache = ldapDirectoryCache;
_taskManager = taskManager;
Logger = NullLogger.Instance;
try
{
DateTime firstDate = DateTime.UtcNow.AddHours(1);
ScheduleNextTask(firstDate);
}
catch (Exception e)
{
this.Logger.Error(e, e.Message);
}
}
public CheckExpiredPromotionsTaskHandler(IScheduledTaskManager taskManager, IPromotionService promotionService)
{
_taskManager = taskManager;
_promotionService = promotionService;
Logger = NullLogger.Instance;
try
{
var firstDate = DateTime.Today.Date.AddDays(1).AddMinutes(1);
firstDate = TimeZoneInfo.ConvertTimeToUtc(firstDate, TimeZoneInfo.Local);
ScheduleNextTask(firstDate);
}
catch (Exception e)
{
this.Logger.Error(e, e.Message);
}
}
public SendShippedOrderAfter3DayToBuyerTaskHandler(IScheduledTaskManager taskManager, ICampaignService campaignService, ITeeyootMessagingService teeyootMessagingService)
{
_taskManager = taskManager;
_teeyootMessagingService = teeyootMessagingService;
Logger = NullLogger.Instance;
try
{
var firstDate = DateTime.Today.Date.AddDays(1).AddMinutes(1);
firstDate = TimeZoneInfo.ConvertTimeToUtc(firstDate, TimeZoneInfo.Local);
ScheduleNextTask(firstDate);
}
catch (Exception e)
{
this.Logger.Error(e, e.Message);
}
}
public InternalLinksExtractor(
IGraphManager graphManager,
IContentManager contentManager,
ISiteService siteService,
IJobManager jobManager,
IAliasService aliasService,
IScheduledTaskManager scheduledTaskManager,
IClock clock,
IGraphSettingsService settingsService)
{
_graphManager = graphManager;
_contentManager = contentManager;
_siteService = siteService;
_jobManager = jobManager;
_aliasService = aliasService;
_scheduledTaskManager = scheduledTaskManager;
_clock = clock;
_settingsService = settingsService;
}
public ScheduledTaskHandler(IScheduledTaskManager taskManager, IWorkContextAccessor workContextAccessor)
{
_workContextAccessor = workContextAccessor;
//, IRepository<EncodedMediaRecord> encodedMediaRepository, IConfig config, ISessionLocator sessionLocato
_taskManager = taskManager;
//_encodedMediaRepository = encodedMediaRepository;
//_config = config;
//_sessionLocator = sessionLocator;
Logger = NullLogger.Instance;
Logger.Debug(DateTime.UtcNow + "> Starting 'ScheduledTaskHandler'");
try
{
ScheduleNextTask(DateTime.UtcNow.AddSeconds(30));
}
catch (Exception e)
{
Logger.Error(e, e.Message);
}
}
public DisqusUpdateTaskHandler(
IOrchardServices orchardServices,
IScheduledTaskManager taskManager,
IDisqusCommentUpdateService updateService)
{
this.Logger = NullLogger.Instance;
this.taskManager = taskManager;
this.updateService = updateService;
this.orchardServices = orchardServices;
try
{
var settings = this.orchardServices.WorkContext.CurrentSite.As<DisqusSettingsPart>();
if (settings.SyncComments)
this.ScheduleNextTask(settings.SyncInterval);
}
catch (Exception e)
{
this.Logger.Error(e, e.Message);
}
}
public PurgeLastReadRepositoryTask(
IScheduledTaskManager taskManager,
IThreadLastReadService threadLastReadService
)
{
_taskManager = taskManager;
_threadLastReadService = threadLastReadService;
Logger = NullLogger.Instance;
try
{
//set the first run a bit in the future so the system doesn't run the task immediately on startup
DateTime firstDate = DateTime.UtcNow.AddHours(1);
//for testing
//DateTime firstDate = DateTime.UtcNow.AddMinutes(2);
ScheduleNextTask(firstDate);
}
catch(Exception e)
{
this.Logger.Error(e,e.Message);
}
}
public UserHandler(IWebStoreServices webStoreServices, IScheduledTaskManager scheduledTaskManager, IClock clock)
{
this._clock = clock;
this._webStoreServices = webStoreServices;
this._scheduledTaskManager = scheduledTaskManager;
}
public TransformalizeTaskManager(IScheduledTaskManager manager) {
_manager = manager;
}
public PublishingTaskManager(IScheduledTaskManager scheduledTaskManager) {
_scheduledTaskManager = scheduledTaskManager;
}
public UiActions(IKernel kernel, ITaskManager taskManager, ITaskExecutor taskExecutor, IScheduledTaskManager scheduledTaskManager)
: base(kernel, taskManager, taskExecutor, scheduledTaskManager)
{
}
public ScheduledTask(IBackgroundEventHandler eventHandler, IScheduledTaskManager taskManager, IClock clock)
{
_eventHandler = eventHandler;
_taskManager = taskManager;
_clock = clock;
}
public override void ExtraSetup()
{
_scheduledTaskManager = DroneResolve<IScheduledTaskManager>();
}
public SchedulingService(IOrchardServices orchardServices, IProjectionManager projectionManager, IScheduledTaskManager scheduledTaskManager) {
_orchardServices = orchardServices;
_projectionManager = projectionManager;
_scheduledTaskManager = scheduledTaskManager;
}