private static void EnsureTask(ISiteInfo site) { var currentServerName = WebFarmHelper.ServerName; var taskServerName = CoreServices.WebFarm.GetEnabledServerNames().First(serverName => !currentServerName.Equals(serverName, StringComparison.Ordinal)); TaskInterval interval = new TaskInterval { StartTime = DateTime.Now, Period = SchedulingHelper.PERIOD_ONCE }; var task = new TaskInfo { TaskAssemblyName = "CMS.DancingGoat.Samples", TaskClass = "CMS.DancingGoat.Samples.EnableDataProtectionSampleTask", TaskEnabled = true, TaskLastResult = string.Empty, TaskData = string.Empty, TaskDisplayName = "Data protection sample", TaskName = "EnableDataProtectionSampleTask", TaskType = ScheduledTaskTypeEnum.System, TaskInterval = SchedulingHelper.EncodeInterval(interval), TaskNextRunTime = SchedulingHelper.GetFirstRunTime(interval), TaskDeleteAfterLastRun = true, TaskRunInSeparateThread = true, TaskSiteID = site.SiteID, TaskServerName = taskServerName }; TaskInfoProvider.SetTaskInfo(task); }
private string GetWaitingToSelectWinnerInfoMessage(IssueInfo issue, ABTestWinnerSelectionEnum winnerOption) { // Get current planned winner selection task var taskToSelectWinner = TaskInfoProvider.GetTaskInfo(mABTest.TestWinnerScheduledTaskID); var plannedWinnerSelectionTime = taskToSelectWinner?.TaskNextRunTime ?? DateTimeHelper.ZERO_TIME; switch (winnerOption) { case ABTestWinnerSelectionEnum.Manual: if (issue.IssueMailoutTime > DateTime.Now) { return(String.Format(GetString("newsletterinfo.issuesentwaitingtosentwinner"), GetTimeOrNA(issue.IssueMailoutTime), GetWinnerSelectionTime())); } return(String.Format(GetString("newsletterinfo.issuesentwaitingtoselwinnermanually"), GetTimeOrNA(issue.IssueMailoutTime))); case ABTestWinnerSelectionEnum.OpenRate: return(String.Format(GetString("newsletterinfo.issuesentwaitingtoselwinneropen"), GetTimeOrNA(issue.IssueMailoutTime), GetTimeOrNA(plannedWinnerSelectionTime))); case ABTestWinnerSelectionEnum.TotalUniqueClicks: return(String.Format(GetString("newsletterinfo.issuesentwaitingtoselwinnerclicks"), GetTimeOrNA(issue.IssueMailoutTime), GetTimeOrNA(plannedWinnerSelectionTime))); default: return(null); } }
/// <summary> /// Closing the campaign /// </summary> /// <param name="sender"></param> /// <param name="e"></param> public static void ProcessOrders(int campaignID) { try { Campaign campaign = CampaignProvider.GetCampaigns() .WhereEquals("NodeSiteID", SiteContext.CurrentSiteID) .WhereEquals("CampaignID", campaignID) .FirstObject; if (campaign != null) { var _failedOrders = DIContainer.Resolve <IFailedOrderStatusProvider>(); _failedOrders.UpdateCampaignOrderStatus(campaign.CampaignID); TaskInfo runTask = TaskInfoProvider.GetTaskInfo(ScheduledTaskNames.PrebuyOrderCreation, SiteContext.CurrentSiteID); if (runTask != null) { runTask.TaskRunInSeparateThread = true; runTask.TaskEnabled = true; runTask.TaskData = $"{campaign.CampaignID}|{SiteContext.CurrentSiteID}"; SchedulingExecutor.ExecuteTask(runTask); } var users = UserInfoProvider.GetUsers(); if (users != null) { foreach (var user in users) { ProductEmailNotifications.CampaignEmail(campaign.DocumentName, user.Email, "CampaignCloseEmail"); } } } } catch (Exception ex) { EventLogProvider.LogException("Kadena_CMSWebParts_Kadena_Cart_FailedOrdersCheckout", "ProcessOrders", ex, SiteContext.CurrentSiteID, ex.Message); } }
/// <summary> /// Create schedule task. /// </summary> private void CreateTask() { try { var editedObject = TypedEditedObject; TaskInfo task = new TaskInfo(); task.TaskAssemblyName = "CMS.Newsletters"; task.TaskClass = "CMS.Newsletters.DynamicNewsletterSender"; task.TaskDisplayName = GetString("DynamicNewsletter.TaskName") + editedObject.NewsletterDisplayName; task.TaskEnabled = true; task.TaskInterval = ScheduleInterval.ScheduleInterval; task.TaskLastResult = string.Empty; task.TaskName = "DynamicNewsletter." + ValidationHelper.GetCodeName(editedObject.NewsletterName, "_"); task.TaskSiteID = SiteContext.CurrentSiteID; task.TaskNextRunTime = SchedulingHelper.GetNextTime(task.TaskInterval, new DateTime(), new DateTime()); task.TaskData = editedObject.NewsletterGUID.ToString(); // Set task for processing in external service task.TaskAllowExternalService = true; task.TaskUseExternalService = (SchedulingHelper.UseExternalService && NewsletterHelper.UseExternalServiceForDynamicNewsletters(SiteContext.CurrentSiteName)); task.TaskType = ScheduledTaskTypeEnum.System; TaskInfoProvider.SetTaskInfo(task); editedObject.NewsletterDynamicScheduledTaskID = task.TaskID; NewsletterInfoProvider.SetNewsletterInfo(editedObject); Redirect(); } catch (Exception ex) { ShowError(GetString(ex.Message)); } }
/// <summary> /// Deletes selected tasks. /// </summary> protected void DeleteSelected(object parameter) { if (parameter == null) { return; } eventCode = "DELETESELECTEDDATA"; ArrayList list = (ArrayList)parameter; CanceledString = GetString("Tasks.DeletionCanceled"); try { AddLog(GetString("Synchronization.DeletingTasks")); foreach (string taskIdString in list) { int taskId = ValidationHelper.GetInteger(taskIdString, 0); if (taskId > 0) { TaskInfo task = TaskInfoProvider.GetTaskInfo(taskId); if (task != null) { AddLog(string.Format(ResHelper.GetAPIString("deletion.running", "Deleting '{0}' task"), HTMLHelper.HTMLEncode(task.TaskTitle))); // Delete synchronization SynchronizationInfoProvider.DeleteSynchronizationInfo(task, serverId, currentSiteId); } } } CurrentInfo = GetString("Tasks.DeleteOK"); AddLog(CurrentInfo); } catch (ThreadAbortException ex) { string state = ValidationHelper.GetString(ex.ExceptionState, string.Empty); if (state == CMSThread.ABORT_REASON_STOP) { // Canceled by user CurrentInfo = CanceledString; AddLog(CurrentInfo); } else { CurrentError = GetString("Tasks.DeletionFailed"); AddErrorLog(CurrentError); } } catch (Exception ex) { CurrentError = GetString("Tasks.DeletionFailed") + ": " + ex.Message; AddErrorLog(CurrentError); } finally { // Finalize log context FinalizeContext(); } }
protected override void OnPreRender(EventArgs e) { // Get task data if (taskId > 0) { TaskInfo ti = TaskInfoProvider.GetTaskInfo(taskId); if (ti != null) { lblInfo.Text += String.Format(GetString("Task.LogTaskInfo"), HTMLHelper.HTMLEncode(ti.TaskTitle)); } } // Get server data if (serverId > 0) { ServerInfo si = ServerInfoProvider.GetServerInfo(serverId); if (si != null) { if (lblInfo.Text != "") { lblInfo.Text += "<br /><br />"; } lblInfo.Text += String.Format(GetString("Task.LogServerInfo"), si.ServerDisplayName); } } lblInfo.Visible = (lblInfo.Text != ""); base.OnPreRender(e); }
/// <summary> /// Registers the web farm server cleaner scheduled task /// </summary> public override void Init() { // Don't create task if it already exists if (TaskInfoProvider.GetTasks().WhereEquals("TaskName", "AzureStorageCacheCleaner").HasResults()) { return; } // Set the interval for every hour var interval = new TaskInterval { Every = 1, Period = SchedulingHelper.PERIOD_HOUR, StartTime = DateTime.Now, BetweenEnd = DateTime.Today.AddMinutes(-1), Days = new ArrayList(Enum.GetNames(typeof(DayOfWeek))) }; // Register the scheduled task var task = new TaskInfo { TaskAssemblyName = Assembly.GetExecutingAssembly().GetName().Name, TaskClass = "AzureStorageCacheCleaner", TaskDisplayName = "Azure storage cache cleaner", TaskInterval = SchedulingHelper.EncodeInterval(interval), TaskName = "AzureStorageCacheCleaner", TaskNextRunTime = DateTime.Now, TaskEnabled = true, TaskData = String.Empty }; TaskInfoProvider.SetTaskInfo(task); }
/// <summary> /// Gets and bulk updates scheduled tasks. Called when the "Get and bulk update tasks" button is pressed. /// Expects the CreateScheduledTask method to be run first. /// </summary> private bool GetAndBulkUpdateScheduledTasks() { // Get the data DataSet tasks = TaskInfoProvider.GetAllTasks(); if (!DataHelper.DataSourceIsEmpty(tasks)) { // Loop through the individual items foreach (DataRow taskDr in tasks.Tables[0].Rows) { // Create object from DataRow TaskInfo modifyTask = new TaskInfo(taskDr); // Update the properties modifyTask.TaskDisplayName = modifyTask.TaskDisplayName.ToUpper(); // Save the changes TaskInfoProvider.SetTaskInfo(modifyTask); } return(true); } return(false); }
/// <summary> /// Deletes staging tasks. Called when the "Delete tasks" button is pressed. /// Expects the CreateStagingServer method to be run first. /// </summary> private bool DeleteTasks() { // Get server ServerInfo server = ServerInfoProvider.GetServerInfo("MyNewServer", CMSContext.CurrentSiteID); if (server != null) { // Get tasks for the server DataSet tasks = TaskInfoProvider.SelectTaskList(CMSContext.CurrentSiteID, server.ServerID, null, null); if (!DataHelper.DataSourceIsEmpty(tasks)) { foreach (DataRow taskDr in tasks.Tables[0].Rows) { // Create task info object from data row TaskInfo deleteTask = new TaskInfo(taskDr); // Delete the task TaskInfoProvider.DeleteTaskInfo(deleteTask); } return(true); } apiDeleteTasks.ErrorMessage = "No tasks found."; } return(false); }
/// <summary> /// Synchronizes all tasks. Called when the "Get and synchronize tasks" button is pressed. /// Expects the CreateStagingServer method to be run first and that there are tasks logged /// for the server. /// </summary> private bool GetAndSynchronizeTasks() { // Get server ServerInfo server = ServerInfoProvider.GetServerInfo("MyNewServer", CMSContext.CurrentSiteID); if (server != null) { // Get tasks for the server DataSet tasks = TaskInfoProvider.SelectTaskList(CMSContext.CurrentSiteID, server.ServerID, null, null); if (!DataHelper.DataSourceIsEmpty(tasks)) { foreach (DataRow taskDr in tasks.Tables[0].Rows) { // Create task info object from data row TaskInfo task = new TaskInfo(taskDr); // Synchronize the task if (!string.IsNullOrEmpty(StagingHelper.RunSynchronization(task.TaskID, server.ServerID))) { apiGetAndSynchronizeTasks.ErrorMessage = "Synchronization failed."; return(false); } } return(true); } apiGetAndSynchronizeTasks.ErrorMessage = "No tasks found."; } return(false); }
protected void Page_Load(object sender, EventArgs e) { TaskInfo ti = TaskInfoProvider.GetTaskInfo(TaskId); // Set edited object EditedObject = ti; if (ti != null) { ((CMSDeskPage)Page).CurrentMaster.Title.TitleText += " (" + HTMLHelper.HTMLEncode(ti.TaskTitle) + ")"; // Prepare task description StringBuilder sbTaskInfo = new StringBuilder(); sbTaskInfo.Append("<table>"); sbTaskInfo.Append("<tr><td class=\"Title Grid\" style=\"width:135px\">" + GetString("staging.tasktype") + "</td><td>" + ti.TaskType.ToString() + "</td></tr>"); sbTaskInfo.Append("<tr><td class=\"Title Grid\">" + GetString("staging.tasktime") + "</td><td>" + ti.TaskTime.ToString() + "</td></tr>"); sbTaskInfo.Append("<tr><td class=\"Title Grid\">" + GetString("staging.taskprocessedby") + "</td><td>" + DataHelper.GetNotEmpty(ti.TaskServers.Trim(';').Replace(";", ", "), "-") + "</td></tr>"); sbTaskInfo.Append("</table>"); string objectType = ti.TaskObjectType; if (ti.TaskNodeID > 0) { objectType = PredefinedObjectType.DOCUMENT; } viewDataSet.ObjectType = objectType; viewDataSet.DataSet = GetDataSet(ti.TaskData, ti.TaskType, ti.TaskObjectType); viewDataSet.AdditionalContent = sbTaskInfo.ToString(); } }
protected DataSet gridTasks_OnDataReload(string completeWhere, string currentOrder, int currentTopN, string columns, int currentOffset, int currentPageSize, ref int totalRecords) { // Get the tasks DataSet ds = TaskInfoProvider.SelectTaskList(currentSiteId, serverId, completeWhere, currentOrder, 0, columns, currentOffset, currentPageSize, ref totalRecords); pnlFooter.Visible = (totalRecords > 0); return(ds); }
/// <summary> /// Returns information message according to current state, issue and A/B test. /// </summary> /// <param name="currState">Current state</param> /// <param name="issue">Issue</param> /// <param name="winnerOption">Winner option</param> /// <param name="plannedMailoutTime">Planned mailout time</param> private string GetInfoMessage(int currState, IssueInfo issue, ABTestWinnerSelectionEnum winnerOption, DateTime plannedMailoutTime) { if (issue == null) { return(null); } switch (currState) { case STATE_WAITING_TO_SEND_WIZARD: return(null); case STATE_WAITING_TO_SEND_PAGE: return(GetString("Newsletter_Issue_Header.NotSentYet")); case STATE_TEST_WAITING_TO_SEL_WINNER: // Get current planned winner selection task var taskToSelectWinner = TaskInfoProvider.GetTaskInfo(mABTest.TestWinnerScheduledTaskID); var plannedWinnerSelectionTime = (taskToSelectWinner == null) ? DateTimeHelper.ZERO_TIME : taskToSelectWinner.TaskNextRunTime; switch (winnerOption) { case ABTestWinnerSelectionEnum.Manual: if (issue.IssueMailoutTime > DateTime.Now) { return(String.Format(GetString("newsletterinfo.issuesentwaitingtosentwinner"), GetTimeOrNA(issue.IssueMailoutTime), GetWinnerSelectionTime())); } return(String.Format(GetString("newsletterinfo.issuesentwaitingtoselwinnermanually"), GetTimeOrNA(issue.IssueMailoutTime))); case ABTestWinnerSelectionEnum.OpenRate: return(String.Format(GetString("newsletterinfo.issuesentwaitingtoselwinneropen"), GetTimeOrNA(issue.IssueMailoutTime), GetTimeOrNA(plannedWinnerSelectionTime))); case ABTestWinnerSelectionEnum.TotalUniqueClicks: return(String.Format(GetString("newsletterinfo.issuesentwaitingtoselwinnerclicks"), GetTimeOrNA(issue.IssueMailoutTime), GetTimeOrNA(plannedWinnerSelectionTime))); } break; case STATE_TEST_READY_FOR_SENDING: return(String.Format(GetString("newsletter_issue_header.issuesending"), GetTimeOrNA(plannedMailoutTime))); case STATE_TEST_FINISHED: switch (winnerOption) { case ABTestWinnerSelectionEnum.Manual: return(String.Format(GetString("newsletterinfo.issuesentwinnerselmanually"), GetTimeOrNA(issue.IssueMailoutTime), GetWinnerSelectionTime())); case ABTestWinnerSelectionEnum.OpenRate: return(String.Format(GetString("newsletterinfo.issuesentwinnerselopen"), GetWinnerSelectionTime())); case ABTestWinnerSelectionEnum.TotalUniqueClicks: return(String.Format(GetString("newsletterinfo.issuesentwinnerselclicks"), GetWinnerSelectionTime())); } break; } return(null); }
/// <summary> /// All items synchronization. /// </summary> protected void SynchronizeAll(object parameter) { string result = string.Empty; eventCode = "SYNCALLOBJECTS"; CanceledString = GetString("Tasks.SynchronizationCanceled"); try { AddLog(GetString("Synchronization.RunningTasks")); // Get the tasks string where = GetWhere(); DataSet ds = TaskInfoProvider.SelectObjectTaskList(currentSiteId, serverId, objectType, where, "TaskID", -1, "TaskID, TaskTitle"); // Run the synchronization result = StagingHelper.RunSynchronization(ds, serverId, true, currentSiteId, AddLog); // Log possible errors if (result != string.Empty) { CurrentError = GetString("Tasks.SynchronizationFailed"); AddErrorLog(CurrentError, null); } else { CurrentInfo = GetString("Tasks.SynchronizationOK"); AddLog(CurrentInfo); } } catch (ThreadAbortException ex) { string state = ValidationHelper.GetString(ex.ExceptionState, string.Empty); if (state == CMSThread.ABORT_REASON_STOP) { // Canceled by user CurrentInfo = CanceledString; AddLog(CurrentInfo); } else { CurrentError = GetString("Tasks.SynchronizationFailed"); AddErrorLog(CurrentError, result); } } catch (Exception ex) { CurrentError = GetString("Tasks.SynchronizationFailed") + ": " + ex.Message; AddErrorLog(CurrentError); } finally { // Finalize log context FinalizeContext(); } }
/// <summary> /// Deletes scheduled task. Called when the "Delete task" button is pressed. /// Expects the CreateScheduledTask method to be run first. /// </summary> private bool DeleteScheduledTask() { // Get the scheduled task TaskInfo deleteTask = TaskInfoProvider.GetTaskInfo("MyNewTask", CMSContext.CurrentSiteID); // Delete the scheduled task TaskInfoProvider.DeleteTaskInfo(deleteTask); return(deleteTask != null); }
private DateTime GetMailoutTimeFromScheduledTask(DataRowView rowView) { var taskId = ValidationHelper.GetInteger(rowView["IssueScheduledTaskID"], 0); var task = TaskInfoProvider.GetTaskInfo(taskId); if (task != null && task.TaskNextRunTime > DateTimeHelper.ZERO_TIME) { return task.TaskNextRunTime; } return DateTimeHelper.ZERO_TIME; }
/// <summary> /// All items synchronization. /// </summary> public void SynchronizeAll(object parameter) { string result = string.Empty; eventCode = "SYNCALLDOCS"; CanceledString = GetString("Tasks.SynchronizationCanceled"); try { AddLog(GetString("Synchronization.RunningTasks")); // Process all records DataSet ds = TaskInfoProvider.SelectDocumentTaskList(currentSiteId, serverId, aliasPath, null, "TaskID", -1, "TaskID, TaskTitle"); // Run the synchronization result = StagingHelper.RunSynchronization(ds, serverId, true, currentSiteId, AddLog); // Log possible error if (!String.IsNullOrEmpty(result)) { CurrentError = GetString("Tasks.SynchronizationFailed"); AddErrorLog(CurrentError, null); } else { CurrentInfo = GetString("Tasks.SynchronizationOK"); AddLog(CurrentInfo); } } catch (ThreadAbortException ex) { string state = ValidationHelper.GetString(ex.ExceptionState, string.Empty); if (state == CMSThread.ABORT_REASON_STOP) { // Canceled by user CurrentInfo = CanceledString; AddLog(CurrentInfo); } else { CurrentError = GetString("Tasks.SynchronizationFailed"); AddErrorLog(CurrentError, result); } } catch (Exception ex) { CurrentError = GetString("Tasks.SynchronizationFailed") + ": " + ex.Message; AddErrorLog(CurrentError); } finally { // Finalize log context FinalizeContext(); } }
protected void gridTasks_OnAction(string actionName, object actionArgument) { // Parse action argument int taskId = ValidationHelper.GetInteger(actionArgument, 0); eventType = EventLogProvider.EVENT_TYPE_INFORMATION; if (taskId > 0) { TaskInfo task = TaskInfoProvider.GetTaskInfo(taskId); if (task != null) { switch (actionName.ToLower()) { case "delete": // Delete task eventCode = "DELETESELECTEDDATA"; AddEventLog(string.Format(ResHelper.GetAPIString("deletion.running", "Deleting '{0}' task"), HTMLHelper.HTMLEncode(task.TaskTitle))); SynchronizationInfoProvider.DeleteSynchronizationInfo(taskId, serverId, currentSiteId); break; case "synchronize": string result = null; try { // Run task synchronization eventCode = "SYNCSELECTEDDATA"; result = StagingHelper.RunSynchronization(taskId, serverId, true, currentSiteId); if (string.IsNullOrEmpty(result)) { lblInfo.Text = GetString("Tasks.SynchronizationOK"); } else { lblError.Text = GetString("Tasks.SynchronizationFailed"); eventType = EventLogProvider.EVENT_TYPE_ERROR; } } catch (Exception ex) { result = ex.Message; lblError.Text = GetString("Tasks.SynchronizationFailed"); eventType = EventLogProvider.EVENT_TYPE_ERROR; } // Log message AddEventLog(result + string.Format(ResHelper.GetAPIString("synchronization.running", "Processing '{0}' task"), HTMLHelper.HTMLEncode(task.TaskTitle))); break; } } } }
/// <summary> /// Deletes all tasks. /// </summary> protected void DeleteAll(object parameter) { eventCode = "DELETEALLTASKS"; CanceledString = GetString("Tasks.DeletionCanceled"); try { AddLog(GetString("Synchronization.DeletingTasks")); // Get the tasks DataSet ds = TaskInfoProvider.SelectTaskList(currentSiteId, serverId, null, "TaskID", -1, "TaskID, TaskTitle"); if (!DataHelper.DataSourceIsEmpty(ds)) { foreach (DataRow row in ds.Tables[0].Rows) { int taskId = ValidationHelper.GetInteger(row["TaskID"], 0); if (taskId > 0) { string taskTitle = ValidationHelper.GetString(row["TaskTitle"], null); AddLog(string.Format(ResHelper.GetAPIString("deletion.running", "Deleting '{0}' task"), HTMLHelper.HTMLEncode(taskTitle))); // Delete synchronization SynchronizationInfoProvider.DeleteSynchronizationInfo(taskId, serverId, currentSiteId); } } } CurrentInfo = GetString("Tasks.DeleteOK"); AddLog(CurrentInfo); } catch (ThreadAbortException ex) { string state = ValidationHelper.GetString(ex.ExceptionState, string.Empty); if (state == CMSThread.ABORT_REASON_STOP) { // Canceled by user CurrentInfo = CanceledString; AddLog(CurrentInfo); } else { CurrentError = GetString("Tasks.DeletionFailed"); AddErrorLog(CurrentError); } } catch (Exception ex) { CurrentError = GetString("Tasks.DeletionFailed") + ": " + ex.Message; AddErrorLog(CurrentError); } finally { // Finalize log context FinalizeContext(); } }
/// <summary> /// Creates new scheduled task for the given issue and newsletter. /// </summary> /// <param name="issue">Issue</param> private int CreateScheduledTask(IssueInfo issue) { if (issue == null) { throw new ArgumentNullException("issue"); } // Create new scheduled task TaskInfo task = NewsletterTasksManager.CreateMailoutTask(issue, DateTime.Now, false); TaskInfoProvider.SetTaskInfo(task); return(task.TaskID); }
/// <summary> /// Loads controls with values from existing score. /// </summary> /// <param name="score"></param> private void LoadValuesFromExistingScore(ScoreInfo score) { if (score.ScoreScheduledTaskID > 0) { TaskInfo taskInfo = TaskInfoProvider.GetTaskInfo(score.ScoreScheduledTaskID); if ((taskInfo != null) && taskInfo.TaskEnabled) { radLater.Checked = true; calendarControl.Enabled = true; calendarControl.SelectedDateTime = taskInfo.TaskNextRunTime; } } }
/// <summary> /// OnAfterSave event handler. /// </summary> protected void EditForm_OnAfterSave(object sender, EventArgs e) { // Get edited contact group ScoreInfo score = (ScoreInfo)EditForm.EditedObject; // Set info for scheduled task task = GetScheduledTask(score); // Update scheduled task if (chkSchedule.Checked) { if (!schedulerInterval.CheckOneDayMinimum()) { // If problem occurred while setting schedule interval EditForm.ErrorLabel.Text = GetString("Newsletter_Edit.NoDaySelected"); EditForm.ErrorLabel.Visible = true; EditForm.StopProcessing = true; return; } if (!IsValidDate(SchedulingHelper.DecodeInterval(schedulerInterval.ScheduleInterval).StartTime)) { // Start date is not in valid format EditForm.ErrorLabel.Text = GetString("Newsletter.IncorrectDate"); EditForm.ErrorLabel.Visible = true; EditForm.StopProcessing = true; return; } task.TaskInterval = schedulerInterval.ScheduleInterval; task.TaskNextRunTime = SchedulingHelper.GetNextTime(task.TaskInterval, new DateTime(), new DateTime()); task.TaskEnabled = true; } else { task.TaskInterval = schedulerInterval.ScheduleInterval; task.TaskNextRunTime = TaskInfoProvider.NO_TIME; task.TaskEnabled = false; } TaskInfoProvider.SetTaskInfo(task); score.ScoreScheduledTaskID = task.TaskID; pnlInfo.Visible = true; InitInfoPanel(score); // Update score ScoreInfoProvider.SetScoreInfo(score); InitHeaderActions(); ((CMSPage)Page).CurrentMaster.HeaderActions.ReloadData(); }
/// <summary> /// Performs reset of execution counter. /// </summary> protected void btnReset_Click(object sender, EventArgs e) { if (TaskInfo != null) { TaskInfo.TaskExecutions = 0; TaskInfo.TaskLastExecutionReset = DateTime.Now; TaskInfoProvider.SetTaskInfo(TaskInfo); lblFrom.Text += " " + DateTime.Now.ToString("d"); plcResetFrom.Visible = true; ShowConfirmation(GetString("task.executions.reseted")); } }
/// <summary> /// Recalculates score at time that user specified. /// </summary> /// <param name="score">Score to recalculate</param> private void StartRecalculationLater(ScoreInfo score) { // Set info for scheduled task var task = ScoreInfoProvider.EnsureScheduledTask(score, String.Empty, TaskInfoProvider.NO_TIME, false, false); task.TaskNextRunTime = calendarControl.SelectedDateTime; task.TaskDeleteAfterLastRun = true; task.TaskEnabled = true; TaskInfoProvider.SetTaskInfo(task); // Update score score.ScoreScheduledTaskID = task.TaskID; ScoreInfoProvider.SetScoreInfo(score); }
protected void Page_Load(object sender, EventArgs e) { string url = UIContextHelper.GetElementUrl("CMS.OnlineMarketing", "EditContactGroup"); url = URLHelper.AddParameterToUrl(url, "displayTitle", "false"); url = URLHelper.AddParameterToUrl(url, "objectId", "{%EditedObject.ID%}"); url = URLHelper.AddParameterToUrl(url, "saved", "1"); url = URLHelper.AddParameterToUrl(url, "siteid", SiteID.ToString()); if (ContactHelper.IsSiteManager) { url = URLHelper.AddParameterToUrl(url, "issitemanager", "1"); } EditForm.RedirectUrlAfterCreate = url; // Get edited contact group ContactGroupInfo cgi = (ContactGroupInfo)EditForm.EditedObject; // Get scheduled task if (cgi.ContactGroupScheduledTaskID > 0) { task = TaskInfoProvider.GetTaskInfo(cgi.ContactGroupScheduledTaskID); } if (!RequestHelper.IsPostBack()) { // Hide dialog for condition when creating new contact group plcUpdate.Visible = (cgi.ContactGroupID > 0); chkSchedule.Checked = schedulerInterval.Visible = ((task != null) && task.TaskEnabled); if (schedulerInterval.Visible) { // Initialize interval control schedulerInterval.ScheduleInterval = task.TaskInterval; } } // Set proper resolver to condition builder conditionBuilder.ResolverName = "ContactResolver"; if (task != null) { // Display info panel for dynamic contact group pnlInfo.Visible = true; // Display basic info about dynamic contact group InitInfoPanel(cgi, false); } }
public static void SetUp(string accountName, string sharedKey, string endPoint, bool publicContainer, string rootContainer, BlobCacheType blobCacheType, int blobCacheMinutes) { _instance = new AccountInfo { AccountName = accountName, SharedKey = sharedKey, EndPoint = endPoint, PublicContainer = publicContainer, RootContainer = rootContainer, BlobCacheType = blobCacheType, BlobCacheMinutes = blobCacheMinutes }; // set up cache clearing task if (blobCacheType != BlobCacheType.None) { var exists = TaskInfoProvider.GetTasks() .Column(nameof(TaskInfo.TaskID)) .WhereEquals(nameof(TaskInfo.TaskName), typeof(CacheClearingTask).FullName) .TopN(1) .Any(); if (!exists) { var taskInfo = new TaskInfo { TaskName = typeof(CacheClearingTask).FullName, TaskDisplayName = "Clear Azure cached metadata and binary objects", TaskAssemblyName = typeof(CacheClearingTask).Assembly.GetName().Name, TaskClass = typeof(CacheClearingTask).FullName, TaskInterval = SchedulingHelper.EncodeInterval( new TaskInterval { Period = SchedulingHelper.PERIOD_MINUTE, StartTime = DateTime.Now, Every = blobCacheMinutes }), TaskNextRunTime = DateTime.Now, TaskRunInSeparateThread = true, TaskGUID = Guid.NewGuid(), TaskData = string.Empty, TaskAllowExternalService = false, TaskEnabled = true, TaskType = ScheduledTaskTypeEnum.System }; TaskInfoProvider.SetTaskInfo(taskInfo); } } }
/// <summary> /// Returns scheduled task of the contact group or creates new one. /// </summary> /// <param name="cgi">Contact group info</param> private TaskInfo GetScheduledTask(ContactGroupInfo cgi) { if (cgi == null) { return(null); } if (cgi.ContactGroupScheduledTaskID > 0) { return(TaskInfoProvider.GetTaskInfo(ValidationHelper.GetInteger(cgi.ContactGroupScheduledTaskID, 0)) ?? CreateScheduledTask(cgi)); } return(CreateScheduledTask(cgi)); }
/// <summary> /// Runs scheduled task. Called when the "Run task" button is pressed. /// Expects the CreateScheduledTask method to be run first. /// </summary> private bool RunTask() { // Get the scheduled task TaskInfo runTask = TaskInfoProvider.GetTaskInfo("MyNewTask", CMSContext.CurrentSiteID); if (runTask != null) { // Run task SchedulingExecutor.ExecuteTask(runTask); return(true); } return(false); }
/// <summary> /// Actions handler. /// </summary> protected void HeaderActions_ActionPerformed(object sender, CommandEventArgs e) { if (ContactGroupHelper.AuthorizedModifyContactGroup(this.SiteID, true)) { switch (e.CommandName.ToLower()) { case "save": // Save changes in the contact group EditForm.SaveData(null); break; case "evaluate": if (EditForm.EditedObject != null) { ContactGroupInfo cgi = (ContactGroupInfo)EditForm.EditedObject; if (cgi != null) { // Set 'Rebuilding' status cgi.ContactGroupStatus = ContactGroupStatusEnum.Rebuilding; ContactGroupInfoProvider.SetContactGroupInfo(cgi); // Evaluate the membership of the contact group ContactGroupEvaluator evaluator = new ContactGroupEvaluator(); evaluator.ContactGroupID = cgi.ContactGroupID; evaluator.Execute(null); EditForm.InfoLabel.Text = GetString("om.contactgroup.evaluationstarted"); EditForm.InfoLabel.Visible = true; // Get scheduled task and update last run time if (cgi.ContactGroupScheduledTaskID > 0) { task = TaskInfoProvider.GetTaskInfo(cgi.ContactGroupScheduledTaskID); if (task != null) { task.TaskLastRunTime = DateTime.Now; TaskInfoProvider.SetTaskInfo(task); } } // Display basic info about dynamic contact group InitInfoPanel(cgi, false); } } break; } } }
/// <summary> /// Returns scheduled task of the contact group or creates new one. /// </summary> /// <param name="score">Score info</param> private TaskInfo GetScheduledTask(ScoreInfo score) { if (score == null) { return(null); } if (score.ScoreScheduledTaskID > 0) { return(TaskInfoProvider.GetTaskInfo(ValidationHelper.GetInteger(score.ScoreScheduledTaskID, 0)) ?? CreateScheduledTask(score)); } else { return(CreateScheduledTask(score)); } }