public void Process(ScheduledTaskContext context) { // We have a task for each type that requires scheduled processing. We could have done // this differently, by having a task for each ContentItem. The processing for each of // those would have been lighter. However, changes in the configuration for this task // would have been much harder to handle. string taskTypeStr = context.Task.TaskType; if (taskTypeStr.IndexOf(Constants.ScheduledTaskName) == 0) { // by splitting the string we should get a type name. To be safe, we do ElementAtOrDefault var typeName = taskTypeStr .Split(new string[] { "_" }, 2, StringSplitOptions.RemoveEmptyEntries) .ElementAtOrDefault(1); if (!string.IsNullOrWhiteSpace(typeName)) { // get the settings for the type var settings = _contentDefinitionManager.GetTypeDefinition(typeName) .Parts .FirstOrDefault(ctpd => ctpd.PartDefinition.Name == "GDPRPart") ?.Settings ?.GetModel <GDPRPartTypeSchedulingSettings>() ?? new GDPRPartTypeSchedulingSettings(); if (settings.ScheduleAnonymization) { Process( typeName, settings.EventForAnonymization, settings.AnonymizationDaysToWait, _contentGDPRManager.Anonymize, context.Task.ContentItem == null); // this being null means the task was not created here } if (settings.ScheduleErasure) { Process( typeName, settings.EventForErasure, settings.ErasureDaysToWait, _contentGDPRManager.Erase, context.Task.ContentItem == null); } if (settings.ScheduleAnonymization || settings.ScheduleErasure) { // reschedule _taskManager.CreateTask( taskTypeStr, // "same" task _clock.UtcNow + TimeSpan.FromDays(1), // one day from now _siteService.GetSiteSettings().ContentItem // pass a ContentItem. ); // passing a ContentItem there to the new task allows us to discriminate, when we are processing it, // over whether the task being processed was created here or in the other service. This allows us to // better filter over things in the query. } } } }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType != Constants.TakeSnapshotTaskName) { return; } try { //the default export service impl makes an assumption that there is an associated user, so we need to set the owner here var siteOwner = _membershipService.GetUser(_orchardServices.WorkContext.CurrentSite.As <SiteSettingsPart>().SuperUser); _authenticationService.SetAuthenticatedUserForRequest(siteOwner); _snapshotService.TakeSnaphot(); } catch (Exception ex) { Logger.Error(ex, "Failed to generate a scheduled Content Sync Snapshot. An exception was thrown by the task handler."); } //now reschedule the task _scheduledTaskManager.DeleteTasks(null, a => a.TaskType == Constants.TakeSnapshotTaskName); var snapshotFrequency = _orchardServices.WorkContext.CurrentSite.As <ContentSyncSettingsPart>().SnapshotFrequencyMinutes; if (snapshotFrequency == 0) { return; } _scheduledTaskManager.CreateTask(Constants.TakeSnapshotTaskName, _clock.UtcNow.AddMinutes(snapshotFrequency), null); }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType.StartsWith(UPDATEVALUES_TASK + "_")) { _sweepGenerator.Terminate(); try { // Task name is something like HiddenStringFieldValueUpdate_ContentType_PartName_FieldName var partFieldName = context.Task.TaskType.Split('_'); if (partFieldName.Length == 5) { var typeName = partFieldName[1]; var partName = partFieldName[2]; var fieldName = partFieldName[3]; HiddenStringFieldUpdateProcessVariant updateType; var validUpdate = Enum.TryParse(partFieldName[4], out updateType); if (validUpdate) { ProcessInternal(updateType, typeName, partName, fieldName); } } } catch (Exception ex) { Logger.Error(ex, "Update Hidden String Values Error: " + context.Task.TaskType + " - " + ex.Message); } finally { _sweepGenerator.Activate(); } } }
public void Process(ScheduledTaskContext context) { var part = context.Task.ContentItem.As <ConfigurationPart>(); if (part == null) { return; } var name = GetName(part.Title()); if (context.Task.TaskType != name) { return; } Logger.Information("Running {0}", name); if (part.TryCatch) { try { _tfl.Run(new TransformalizeRequest(part, new Dictionary <string, string>(), null, Logger)); } catch (Exception ex) { Logger.Error(ex, ex.Message); } } else { _tfl.Run(new TransformalizeRequest(part, new Dictionary <string, string>(), null, Logger)); } }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType == "SwitchTheme") { _themeService.EnableThemeFeatures("Offline"); _siteThemeService.SetSiteTheme("Offline"); } else if (context.Task.TaskType == "ResetSite") { Logger.Information("start reseting site data at {2} utc", context.Task.ScheduledUtc); var factory = _sessionFactoryHolder.GetSessionFactory(); using (var session = factory.OpenSession()){ var connection = session.Connection; var dialect = Dialect.GetDialect(_sessionFactoryHolder.GetConfiguration().Properties); var meta = dialect.GetDataBaseSchema((DbConnection)connection); var tables = meta.GetTables(null, null, null, null); try{ foreach (DataRow dr in tables.Rows) { _schemaBuilder.DropTable(dr["TABLE_NAME"].ToString()); } ExecuteOutSql("~/Modules/Coevery.SiteReset/Sql/create.sql"); } catch (Exception ex) { Logger.Warning(ex, "reset site error"); } } } }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType.Equals(TASK_NAME, StringComparison.InvariantCultureIgnoreCase)) { _facebookShopService.SyncProducts(); } }
public void Process(ScheduledTaskContext context) { try { var btnName = ButtonName(context.Task.TaskType); if (btnName == null) { return; } if (string.IsNullOrWhiteSpace(btnName)) { btnName = context.Task.ContentItem.As <DynamicButtonToWorkflowsPart>().ButtonName; } if (string.IsNullOrWhiteSpace(btnName)) { // failed to figure out a valid button name return; } _workflowManager.TriggerEvent("DynamicButtonEvent", context.Task.ContentItem, () => new Dictionary <string, object> { { "ButtonName", btnName }, { "Content", context.Task.ContentItem } }); } catch (Exception ex) { Logger.Error(ex, "Error in DynamicButtonToWorflowsScheduledTaskHandler. ContentItem: {0}, ScheduledUtc: {1:yyyy-MM-dd HH.mm.ss}", context.Task.ContentItem, context.Task.ScheduledUtc); } finally { if (context.Task.ContentItem.Has <DynamicButtonToWorkflowsPart>()) { context.Task.ContentItem.As <DynamicButtonToWorkflowsPart>().ButtonName = ""; context.Task.ContentItem.As <DynamicButtonToWorkflowsPart>().MessageToWrite = ""; } } }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType == TASK_TYPE) { try { Logger.Information("----------------------------- Check Order Checker task started --------------------------------"); // _campaignService.CheckExpiredCampaigns(); var _ordersToDelete = _orderService.GetAllOrders().Where(aa => aa.Email == null);//.Where(aa => aa.Created - DateTime.Now.Subtract(new DateTime(0, 0, 0, 0, 31, 0, 0))); foreach (var order in _ordersToDelete) { //System.IO.File.Create("c:\\omid.txt").Write(new byte[] { 1, 5, 7 }, 0, 3); if (order.Created.AddMinutes(15) > DateTime.UtcNow) { continue; } _orderService.DeleteOrder(order.Id); } } catch (Exception e) { this.Logger.Error("Error occured when running Order Checker campaigns task ---------------- >" + e.ToString(), e.Message); var nextTaskDate = DateTime.UtcNow.AddMinutes(10); ScheduleNextTask(nextTaskDate); } finally { Logger.Information("----------------------------- Check Order Checker task finished --------------------------------"); var nextTaskDate = DateTime.UtcNow.AddMinutes(10); ScheduleNextTask(nextTaskDate); } } }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType != Constants.CleanupSnapshots) { return; } try { var idsToRetain = new List <int>(); foreach (var retentionPolicy in _retentionPolicies) { idsToRetain.AddRange(retentionPolicy.GetSnapshotIdsToRetain()); } var recordsToDelete = _repository.Table.Where(r => !idsToRetain.Contains(r.Id)); foreach (var record in recordsToDelete) { _repository.Delete(record); } } catch (Exception ex) { Logger.Error(ex, "Failed to cleanup Content Sync Snapshots. An exception was thrown by the task handler."); } //now reschedule the task _scheduledTaskManager.DeleteTasks(null, a => a.TaskType == Constants.CleanupSnapshots); _scheduledTaskManager.CreateTask(Constants.CleanupSnapshots, _clock.UtcNow.AddMinutes(1), null); }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType == TASK_TYPE) { try { Logger.Information("----------------------------- Update Campaigns --------------------------------"); /*foreach (var campaign in _campaignRepository.Fetch(aa => aa.WhenDeleted == null)) * { * var orders = _orderRepository.Fetch(aa => aa.Campaign.Id == campaign.Id && (aa.OrderStatusRecord.Name == "Approved" || * aa.OrderStatusRecord.Name == "Printing" || * aa.OrderStatusRecord.Name == "Shipped" || * aa.OrderStatusRecord.Name == "Delivered")); * * campaign.ProductCountSold = orders.Select(aa => aa.TotalSold).Sum(); * _campaignRepository.Update(campaign); * * }*/ } catch (Exception e) { this.Logger.Error("Error occured when running Update Campaigns task ---------------- >" + e.ToString(), e.Message); } finally { Logger.Information("----------------------------- Check Update Campaigns task finished --------------------------------"); var nextTaskDate = DateTime.UtcNow.AddMinutes(5); ScheduleNextTask(nextTaskDate); } } }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType != TaskType) { return; } try { string path = HostingEnvironment.MapPath(_contactsImportRelativePath); DirectoryInfo dir = new DirectoryInfo(path); if (dir.Exists == false) { dir.Create(); } FileInfo logFile = null; foreach (var file in dir.GetFiles("*.csv", SearchOption.TopDirectoryOnly)) { try { // avvia una nuova transazione per ogni file da elaborare _transactionManager.RequireNew(); // importa solo i csv che non hanno già un log corrispondente logFile = new FileInfo(file.FullName + ".log"); if (logFile.Exists == false) { byte[] bufferContent = File.ReadAllBytes(file.FullName); string fileContent = Encoding.Unicode.GetString(bufferContent); ImportUtil import = new ImportUtil(_orchardServices); import.ImportCsv(fileContent); string result = string.Format("Import result: Errors: {0}, Mails: {1}, Sms: {2}.", import.Errors.Count, import.TotMail, import.TotSms); string strErrors = FormatErrors(import.Errors); byte[] buffer = Encoding.Unicode.GetBytes(string.Format("{0}{1}{2}", result, Environment.NewLine, strErrors)); File.WriteAllBytes(string.Format("{0}{1}{2}.log", dir.FullName, Path.DirectorySeparatorChar, file.Name), buffer); } } finally { try { // sposta il file in una sottocartella DirectoryInfo archiveDir = new DirectoryInfo(dir.FullName + Path.DirectorySeparatorChar + "history"); if (archiveDir.Exists == false) { archiveDir.Create(); } string archivePath = archiveDir.FullName + Path.DirectorySeparatorChar + file.Name; file.MoveTo(archivePath); } catch { // se non riesce a spostare il file, lo elimina per non dare fastidio agli import successivi file.Delete(); } } } } catch (Exception ex) { string idcontenuto = "nessun id "; try { idcontenuto = context.Task.ContentItem.Id.ToString(); } catch (Exception ex2) { Logger.Error(ex2, ex2.Message); } Logger.Error(ex, "Error on " + TaskType + " for ContentItem id = " + idcontenuto + " : " + ex.Message); } }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType != "DemoTask") { return; } Debugger.Break(); }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType != TaskType) { return; } Renew(true); CleanUp(); }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType == "Unpublish") { Logger.Information("Unpublishing item #{0} version {1} scheduled at {2} utc", context.Task.ContentItem.Id, context.Task.ContentItem.Version, context.Task.ScheduledUtc); _contentManager.Unpublish(context.Task.ContentItem); } }
public void Process(ScheduledTaskContext context) { var taskType = context.Task.TaskType; if (Constants.DefaultEventNames.Contains(taskType)) { var contentItem = context.Task.ContentItem; _workflowManager.TriggerEvent(taskType, contentItem, () => new Dictionary <string, object> { { "Content", contentItem } }); } }
public void Process(ScheduledTaskContext context) { try { if (context.Task.TaskType != TaskType) { return; } // esegue l'allineamento di tutti i contenuti in un task schedulato _reactionsService.NormalizeAllSummaries(); } catch (Exception ex) { Logger.Error(ex, "Error in Laser.Orchard.UserReactionsSettings.Task. ScheduledUtc: {0:yyyy-MM-dd HH.mm.ss}.", context.Task.ScheduledUtc); } }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType == "TriggerRule") { Logger.Information("Triggering Rule item #{0} version {1} scheduled at {2} utc", context.Task.ContentItem.Id, context.Task.ContentItem.Version, context.Task.ScheduledUtc); var scheduledActionTask = context.Task.ContentItem.As <ScheduledActionTaskPart>(); _rulesManager.ExecuteActions(scheduledActionTask.ScheduledActions.Select(x => x.ActionRecord), new Dictionary <string, object>()); } }
public void Process(ScheduledTaskContext context) { try { // this.Logger.Error("sono dentro process"); string taskTypeStr = context.Task.TaskType; string[] taTypeParts = taskTypeStr.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); if (taTypeParts.Length == 2) { if (taTypeParts[0] == TaskType) { bool sent = false; try { int gId = int.Parse(taTypeParts[1]); sent = _questionnairesServices.SendTemplatedEmailRanking(gId); } catch (Exception e) { this.Logger.Error(e, e.Message); throw; } if (!sent) { //reschedule DateTime nextDate = ((DateTime)(context.Task.ScheduledUtc)).AddMinutes(5); _taskManager.CreateTask(taskTypeStr, nextDate, context.Task.ContentItem); } } } } catch (Exception ex) { string idcontenuto = "nessun id "; try { idcontenuto = context.Task.ContentItem.Id.ToString(); } catch (Exception ex2) { Logger.Error(ex2, ex2.Message); } Logger.Error(ex, "Error on " + TaskType + " analized input: " + context.Task.TaskType + " for ContentItem id = " + idcontenuto + " : " + ex.Message); } //if (context.Task.TaskType == TaskType) { // try { // bool sended= _questionnairesServices.SendTemplatedEmailRanking(); // //The following line does not work here, because the task does not contain the ContentItem // //_questionnairesServices.SendTemplatedEmailRanking(context.Task.ContentItem.Id); // } // catch (Exception e) { // this.Logger.Error(e, e.Message); // } // finally { // DateTime nextTaskDate = DateTime.UtcNow.AddHours(6); //DateTime.UtcNow.AddSeconds(30);// // ScheduleNextTask(nextTaskDate); // } //} }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType != TaskType) { return; } try { Logger.Error("SynchronizeContacts task started."); _communicationService.Synchronize(); Logger.Error("SynchronizeContacts task ended."); } catch (Exception ex) { Logger.Error(ex, "SynchronizeContacts task error." + ex.Message); } }
// This method will be called periodically (every minute) with the current task context. Because of this we have to check if the // current task is ours. (BTW this way the same taks handler can handle multiple tasks.) // Remember that although we scheduled the task to be run 3 minutes in the future it won't run in exactly 3 minutes, but practically // in a one minute time frame after the scheduled time, the worst case being one minute after what we scheduled. Also if the Orchard // instance is torn down before that (e.g. by an AppPool recycle) the task may run at an even later date. Don't rely on backgroud tasks // runnin exactly on schedule! void IScheduledTaskHandler.Process(ScheduledTaskContext context) { // Not our task if (context.Task.TaskType != TaskType) { return; } // Check out in the debugger: this should be called every 3 minutes. _eventHandler.ScheduledTaskFired(new ScheduledTaskFiredContext { TaskType = TaskType }); CreateTaskIfNew(true); // Renewing the task }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType == TASK_TYPE) { try { Logger.Information("----------------------------- Email Sender task started --------------------------------"); // _campaignService.CheckExpiredCampaigns(); var api = new MandrillApi( _settingsService.GetSettingByCulture(/*request.BuyerCultureRecord.Culture*/ "en-MY") .List() .First() .ApiKey); var countToSend = 100; var emails = _mailOutBox.Table.Take(countToSend).ToArray(); foreach (Outbox outBox in emails) { if (outBox.EmailType == "Purchase") { if (outBox.OrderId.HasValue && _orders.Get(outBox.OrderId.Value).OrderStatusRecord.Name != OrderStatus.Approved.ToString()) { continue; } } var message = Newtonsoft.Json.JsonConvert.DeserializeObject <Mandrill.Model.MandrillMessage>(outBox.Data); var result = api.Messages.Send(message); _mailOutBox.Delete(outBox); } } catch (Exception e) { this.Logger.Error("Error occured when running Order Checker campaigns task ---------------- >" + e.ToString(), e.Message); var nextTaskDate = DateTime.UtcNow.AddMinutes(1).AddSeconds(4); ScheduleNextTask(nextTaskDate); } finally { Logger.Information("----------------------------- Check Order Checker task finished --------------------------------"); var nextTaskDate = DateTime.UtcNow.AddMinutes(1).AddSeconds(4); ScheduleNextTask(nextTaskDate); } } }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType == TaskType) { try { int id = 0; DateTime?from = null; DateTime?to = null; // ricava i parametri string filters = context.Task.ContentItem.As <TitlePart>().Title; string[] pars = filters.Split('&'); foreach (var parameter in pars) { string[] keyValue = parameter.Split('='); switch (keyValue[0]) { case "id": id = Convert.ToInt32(keyValue[1]); break; case "from": if (string.IsNullOrWhiteSpace(keyValue[1]) == false) { from = DateTime.ParseExact(keyValue[1], "yyyyMMdd", CultureInfo.InvariantCulture); } break; case "to": if (string.IsNullOrWhiteSpace(keyValue[1]) == false) { to = DateTime.ParseExact(keyValue[1], "yyyyMMdd", CultureInfo.InvariantCulture); } break; } } // estrae le statistiche su file _questionnairesServices.SaveQuestionnaireUsersAnswers(id, from, to); } catch (Exception ex) { string idcontenuto = "nessun id "; try { idcontenuto = context.Task.ContentItem.Id.ToString(); } catch (Exception ex2) { Logger.Error(ex2, ex2.Message); } Logger.Error(ex, "Error on " + TaskType + " for ContentItem id = " + idcontenuto + " : " + ex.Message); } } }
public void Sweep() { var taskEntries = _repository.Fetch(x => x.ScheduledUtc <= _clock.UtcNow) .Select(x => new { x.Id, Action = x.TaskType }) .ToArray(); foreach (var taskEntry in taskEntries) { _transactionManager.RequireNew(); try { // fetch the task var taskRecord = _repository.Get(taskEntry.Id); // another server or thread has performed this work before us if (taskRecord == null) { continue; } // removing record first helps avoid concurrent execution _repository.Delete(taskRecord); // persisting the change so it takes effect in the other async operations _repository.Flush(); var context = new ScheduledTaskContext { Task = new Task(_contentManager, taskRecord) }; // dispatch to standard or custom handlers foreach (var handler in _handlers) { handler.Process(context); } } catch (Exception ex) { if (ex.IsFatal()) { throw; } Logger.Warning(ex, "Unable to process scheduled task #{0} of type {1}", taskEntry.Id, taskEntry.Action); _transactionManager.Cancel(); } } }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType == TASK_TYPE_APPEND_MODEL && context.Task.ContentItem != null) { try { _blockModelService.AppendModel(context.Task.ContentItem); } catch (Exception e) { this.Logger.Error(e, e.Message); } finally { } } }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType == TASK_TYPE_EMAIL && context.Task.ContentItem != null) { try { var em = context.Task.ContentItem.As <EmailPart>(); _userService.EmailUsers(em.Recipients.SplitStringArray(), em.Subject, em.Body, em.Retry, em.ForwardSupport, em.FromAddress, em.FromName, em.HideRecipients); } catch (Exception e) { this.Logger.Error(e, e.Message); } finally { } } }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType == TASK_TYPE_MAIL_API && context.Task.ContentItem != null) { try { var p = context.Task.ContentItem.As <MailApiPart>(); _mailApi.ProcessApiRequest(p); } catch (Exception e) { this.Logger.Error(e, e.Message); } finally { } } }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType == "SychronizeUser") { IUser user = context.Task.ContentItem.As <IUser>(); this._webStoreServices.UsingClient( c => { Customer customer = c.CustomerClient.GetCustomer(user.UserName, false); if (customer != null) { c.CustomerClient.UpdateCustomer(customer.CustomerId, user.UserName, user.Email, true); this._customerEventHandlers.Trigger(h => h.Updated(customer)); } }, false ); } }
public void Process(ScheduledTaskContext context) { try { if (context.Task.TaskType != TaskType) { return; } _workflowManager.TriggerEvent(context.Task.ContentItem.As <ButtonToWorkflowsPart>().ActionToExecute, context.Task.ContentItem, () => new Dictionary <string, object> { { "Content", context.Task.ContentItem } }); context.Task.ContentItem.As <ButtonToWorkflowsPart>().MessageToWrite = ""; context.Task.ContentItem.As <ButtonToWorkflowsPart>().ActionToExecute = ""; context.Task.ContentItem.As <ButtonToWorkflowsPart>().ActionAsync = false; context.Task.ContentItem.As <ButtonToWorkflowsPart>().ButtonsDenied = false; } catch (Exception ex) { Logger.Error(ex, "Error in ButtonToWorflowsScheduledTaskHandler. ContentItem: {0}, ScheduledUtc: {1:yyyy-MM-dd HH.mm.ss}", context.Task.ContentItem, context.Task.ScheduledUtc); } }
public void Sweep() { var taskEntries = _repository.Fetch(x => x.ScheduledUtc <= _clock.UtcNow) .Select(x => new { x.Id, Action = x.TaskType }) .ToArray(); foreach (var taskEntry in taskEntries) { //TODO: start a dedicated transaction scope try { // fetch the task var taskRecord = _repository.Get(taskEntry.Id); // another server or thread has performed this work before us if (taskRecord == null) { continue; } // removing record first helps avoid concurrent execution _repository.Delete(taskRecord); var context = new ScheduledTaskContext { Task = new Task(_contentManager, taskRecord) }; // dispatch to standard or custom handlers foreach (var handler in _handlers) { handler.Process(context); } //TODO: commit dedicated scope } catch (Exception ex) { Logger.Warning(ex, "Unable to process scheduled task #{0} of type {1}", taskEntry.Id, taskEntry.Action); //TODO: handle exception to rollback dedicated xact, and re-delete task record. // does this also need some retry logic? } } }
public void Process(ScheduledTaskContext context) { if (context.Task.TaskType != TaskType) { return; } Renew(true); // Clean up old events var cleanUpCount = _repository.Table.Count() - 1000; if (cleanUpCount <= 0) { return; } foreach (var record in _repository.Table.OrderBy(record => record.Id).Take(cleanUpCount)) { _repository.Delete(record); } }
public void ScheduledTaskFailWhenMaxRetriesReached() { var exit = false; var context = new ScheduledTaskContext(0, () => exit, null, () => exit = true); var mockedFailedScheduledTask = new MockedFailedScheduledTask(context); mockedFailedScheduledTask.ScheduledTaskExecute(1, Guid.NewGuid(), 1, "TEST", 3, 3); Assert.AreEqual(ScheduledTaskStatusType.Failed, mockedFailedScheduledTask.StatusResult); }