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));
}
}
