public HttpResponseMessage GetScheduleItemHistory(int scheduleId = -1, int pageIndex = 0, int pageSize = 20)
{
try
{
var arrSchedule = SchedulingProvider.Instance().GetScheduleHistory(scheduleId);
var query = from ScheduleHistoryItem history in arrSchedule
select new
{
history.FriendlyName,
history.LogNotes,
history.Server,
ElapsedTime = Math.Round(history.ElapsedTime, 3),
history.Succeeded,
StartDate = !Null.IsNull(history.StartDate) ? history.StartDate.ToString() : "",
EndDate = !Null.IsNull(history.EndDate) ? history.EndDate.ToString() : "",
NextStart = !Null.IsNull(history.NextStart) ? history.NextStart.ToString() : ""
};
var response = new
{
Success = true,
Results = query.Skip(pageIndex * pageSize).Take(pageSize),
TotalResults = query.Count()
};
return(this.Request.CreateResponse(HttpStatusCode.OK, response));
}
catch (Exception exc)
{
Logger.Error(exc);
return(this.Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exc));
}
}
/// <summary>
/// cmdUpdate_Click runs when the Update Button is clicked
/// </summary>
/// <remarks>
/// </remarks>
/// <history>
/// [cnurse] 9/28/2004 Updated to reflect design changes for Help, 508 support and localisation
/// </history>
protected void OnUpdateClick(Object sender, EventArgs e)
{
if (VerifyValidTimeLapseRetry() == false)
{
return;
}
var objScheduleItem = CreateScheduleItem();
if (ViewState["ScheduleID"] != null)
{
objScheduleItem.ScheduleID = Convert.ToInt32(ViewState["ScheduleID"]);
SchedulingProvider.Instance().UpdateSchedule(objScheduleItem);
}
else
{
SchedulingProvider.Instance().AddSchedule(objScheduleItem);
}
var strMessage = Localization.GetString("UpdateSuccess", LocalResourceFile);
UI.Skins.Skin.AddModuleMessage(this, strMessage, ModuleMessage.ModuleMessageType.GreenSuccess);
if (SchedulingProvider.SchedulerMode == SchedulerMode.TIMER_METHOD)
{
SchedulingProvider.Instance().ReStart("Change made to schedule.");
}
Response.Redirect(Globals.NavigateURL(), true);
}
/// <summary>
/// Returns the last time search indexing was completed successfully.
/// The returned value in local server time (not UTC).
/// Beware that the value stored in teh database is converted to UTC time.
/// </summary>
public DateTime GetLastSuccessfulIndexingDateTime(int scheduleId)
{
var settings = SchedulingProvider.Instance().GetScheduleItemSettings(scheduleId);
var lastValue = settings[Constants.SearchLastSuccessIndexName] as string;
if (string.IsNullOrEmpty(lastValue))
{
// try to fallback to old location where this was stored
var name = string.Format(LastIndexKeyFormat, Constants.SearchLastSuccessIndexName, scheduleId);
lastValue = HostController.Instance.GetString(name, Null.NullString);
}
DateTime lastTime;
if (!string.IsNullOrEmpty(lastValue) &&
DateTime.TryParseExact(lastValue, Constants.ReindexDateTimeFormat, null, DateTimeStyles.None, out lastTime))
{
// retrieves the date as UTC but returns to caller as local
lastTime = FixSqlDateTime(lastTime).ToLocalTime().ToLocalTime();
if (lastTime > DateTime.Now)
{
lastTime = DateTime.Now;
}
}
else
{
lastTime = SqlDateTime.MinValue.Value.AddDays(1);
}
return(lastTime);
}
/// <summary>
/// Gets list of servers to be recommended for the particular scheduler.
/// </summary>
/// <param name="schedulerId">Scheduler Id</param>
/// <returns>List of recommended servers</returns>
public IEnumerable <string> GetRecommendedServers(int schedulerId)
{
var recommendedServers = new List <string>();
var schedulersToRunOnSameWebServer = HostController.Instance.GetString(
"SchedulersToRunOnSameWebServer",
string.Empty);
var schedulers = schedulersToRunOnSameWebServer.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (!schedulers.Any() || !schedulers.Select(x => x.Trim()).Contains(schedulerId.ToString()))
{
return(recommendedServers);
}
foreach (var scheduler in schedulers)
{
if (!int.TryParse(scheduler.Trim(), out int id) || id == schedulerId)
{
continue;
}
var schedule = SchedulingProvider.Instance().GetSchedule(id);
if (schedule != null && schedule.Enabled && !string.IsNullOrWhiteSpace(schedule.Servers))
{
recommendedServers.AddRange(schedule.Servers.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries));
}
}
return(recommendedServers.Distinct().OrderBy(x => x));
}
public override void AddLog(LogInfo logInfo)
{
string configPortalID = logInfo.LogPortalID != Null.NullInteger
? logInfo.LogPortalID.ToString()
: "*";
var logTypeConfigInfo = this.GetLogTypeConfigInfoByKey(logInfo.LogTypeKey, configPortalID);
if (logTypeConfigInfo == null || logTypeConfigInfo.LoggingIsActive == false)
{
return;
}
logInfo.LogConfigID = logTypeConfigInfo.ID;
var logQueueItem = new LogQueueItem {
LogInfo = logInfo, LogTypeConfigInfo = logTypeConfigInfo
};
SchedulingProvider scheduler = SchedulingProvider.Instance();
if (scheduler == null || logInfo.BypassBuffering || SchedulingProvider.Enabled == false ||
scheduler.GetScheduleStatus() == ScheduleStatus.STOPPED || !Host.EventLogBuffer)
{
WriteLog(logQueueItem);
}
else
{
LogQueue.Add(logQueueItem);
}
}
private DateTime GetScheduleItemDateSetting(string settingKey)
{
var colScheduleItemSettings = SchedulingProvider.Instance().GetScheduleItemSettings(ScheduleHistoryItem.ScheduleID);
var dateValue = DateTime.Now;
if (colScheduleItemSettings.Count > 0)
{
if (colScheduleItemSettings.ContainsKey(settingKey))
{
dateValue = Convert.ToDateTime(colScheduleItemSettings[settingKey], CultureInfo.InvariantCulture);
}
}
else
{
SchedulingProvider.Instance().AddScheduleItemSetting(
ScheduleHistoryItem.ScheduleID, SettingLastHourlyRun, dateValue.ToString(CultureInfo.InvariantCulture));
SchedulingProvider.Instance().AddScheduleItemSetting(
ScheduleHistoryItem.ScheduleID, SettingLastDailyRun, dateValue.ToString(CultureInfo.InvariantCulture));
SchedulingProvider.Instance().AddScheduleItemSetting(
ScheduleHistoryItem.ScheduleID, SettingLastWeeklyRun, dateValue.ToString(CultureInfo.InvariantCulture));
SchedulingProvider.Instance().AddScheduleItemSetting(
ScheduleHistoryItem.ScheduleID, SettingLastMonthlyRun, dateValue.ToString(CultureInfo.InvariantCulture));
}
return(dateValue);
}
public override ConsoleResultModel Run()
{
try
{
var taskToUpdate = SchedulingProvider.Instance().GetSchedule(TaskId);
var tasks = new List <TaskModel>();
if (taskToUpdate == null)
{
return(new ConsoleErrorResultModel(string.Format(LocalizeString("Prompt_TaskNotFound"), TaskId)));
}
if (taskToUpdate.Enabled == Enabled)
{
return(new ConsoleErrorResultModel(LocalizeString(Enabled ? "Prompt_TaskAlreadyEnabled" : "Prompt_TaskAlreadyDisabled")));
}
taskToUpdate.Enabled = Enabled;
SchedulingProvider.Instance().UpdateSchedule(taskToUpdate);
tasks.Add(new TaskModel(taskToUpdate));
return(new ConsoleResultModel(LocalizeString("Prompt_TaskUpdated"))
{
Records = tasks.Count,
Data = tasks
});
}
catch (Exception exc)
{
Logger.Error(exc);
return(new ConsoleErrorResultModel(LocalizeString("Prompt_TaskUpdateFailed")));
}
}
private void BindData()
{
lblFreeThreads.Text = SchedulingProvider.Instance().GetFreeThreadCount().ToString();
lblActiveThreads.Text = SchedulingProvider.Instance().GetActiveThreadCount().ToString();
lblMaxThreads.Text = SchedulingProvider.Instance().GetMaxThreadCount().ToString();
Collection arrScheduleQueue = SchedulingProvider.Instance().GetScheduleQueue();
if (arrScheduleQueue.Count == 0)
{
pnlScheduleQueue.Visible = false;
}
else
{
dgScheduleQueue.DataSource = arrScheduleQueue;
dgScheduleQueue.DataBind();
}
Collection arrScheduleProcessing = SchedulingProvider.Instance().GetScheduleProcessing();
if (arrScheduleProcessing.Count == 0)
{
pnlScheduleProcessing.Visible = false;
}
else
{
dgScheduleProcessing.DataSource = arrScheduleProcessing;
dgScheduleProcessing.DataBind();
}
if (arrScheduleProcessing.Count == 0 && arrScheduleQueue.Count == 0)
{
var strMessage = Localization.GetString("NoTasks", LocalResourceFile);
UI.Skins.Skin.AddModuleMessage(this, strMessage, ModuleMessage.ModuleMessageType.YellowWarning);
}
}
private void CreateTempFileScheduledJob()
{
try
{
var scheduledJobs = SchedulingProvider.Instance().GetSchedule(); // retrieves all scheduled jobs
var jobList = ConvertArrayList(scheduledJobs);
var job = jobList.FirstOrDefault(s => s.TypeFullName == SCHEDULED_JOB_TYPE);
if (job == null || job.ScheduleID == Null.NullInteger)
{
// the scheduled job doesn't exist yet
SchedulingProvider.Instance().AddSchedule(new ScheduleItem
{
TypeFullName = SCHEDULED_JOB_TYPE,
TimeLapseMeasurement = "w", // week
TimeLapse = 1,
RetryTimeLapseMeasurement = "m", // minutes
RetryTimeLapse = 30,
RetainHistoryNum = 10,
FriendlyName = SCHEDULED_JOB_NAME,
Enabled = true,
CatchUpEnabled = false
});
Logger.Debug("Created the scheduled job to clear temporary files created by Hotcakes Commerce.");
}
}
catch (Exception ex)
{
Logger.Error(ex.Message, ex);
throw ex;
}
}
public void UpdateRecurringOrdersScheduler()
{
var friendlyName = "Update Recurring Orders";
var typeFullName = "Hotcakes.Modules.Core.UpdateRecurringOrdersJob, Hotcakes.Modules";
var schedules = SchedulingProvider.Instance().GetSchedule().OfType <ScheduleItem>();
if (!schedules.Any(s => s.FriendlyName == friendlyName))
{
var oItem = new ScheduleItem
{
FriendlyName = friendlyName,
TypeFullName = typeFullName,
Enabled = false,
CatchUpEnabled = false,
RetainHistoryNum = 0,
TimeLapse = 8,
TimeLapseMeasurement = "h",
RetryTimeLapse = 8,
RetryTimeLapseMeasurement = "h",
ScheduleSource = ScheduleSource.NOT_SET
};
SchedulingProvider.Instance().AddSchedule(oItem);
}
}
public void CreateAbandonedCartScheduler()
{
var friendlyName = "Send Abandoned Cart Emails";
var typeFullName = "Hotcakes.Modules.Core.AbandonedCartEmailJob, Hotcakes.Modules";
var schedules = SchedulingProvider.Instance().GetSchedule().OfType <ScheduleItem>();
if (!schedules.Any(s => s.FriendlyName == friendlyName))
{
var oItem = new ScheduleItem
{
FriendlyName = friendlyName,
TypeFullName = typeFullName,
Enabled = true,
CatchUpEnabled = false,
RetainHistoryNum = 0,
TimeLapse = 1,
TimeLapseMeasurement = "h",
RetryTimeLapse = 1,
RetryTimeLapseMeasurement = "h",
ScheduleSource = ScheduleSource.NOT_SET
};
SchedulingProvider.Instance().AddSchedule(oItem);
}
}
public HttpResponseMessage CreateScheduleItem(ScheduleDto scheduleDto)
{
try
{
if (scheduleDto.RetryTimeLapse == 0)
{
scheduleDto.RetryTimeLapse = Null.NullInteger;
}
if (!this.VerifyValidTimeLapseRetry(scheduleDto.TimeLapse, scheduleDto.TimeLapseMeasurement, scheduleDto.RetryTimeLapse, scheduleDto.RetryTimeLapseMeasurement))
{
return(this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, Localization.GetString("InvalidFrequencyAndRetry", localResourcesFile)));
}
var scheduleItem = this._controller.CreateScheduleItem(scheduleDto.TypeFullName, scheduleDto.FriendlyName, scheduleDto.TimeLapse, scheduleDto.TimeLapseMeasurement,
scheduleDto.RetryTimeLapse, scheduleDto.RetryTimeLapseMeasurement, scheduleDto.RetainHistoryNum, scheduleDto.AttachToEvent, scheduleDto.CatchUpEnabled,
scheduleDto.Enabled, scheduleDto.ObjectDependencies, scheduleDto.ScheduleStartDate, scheduleDto.Servers);
SchedulingProvider.Instance().AddSchedule(scheduleItem);
return(this.Request.CreateResponse(HttpStatusCode.OK, new { Success = true }));
}
catch (Exception exc)
{
Logger.Error(exc);
return(this.Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exc));
}
}
private void BindData()
{
if (Request.QueryString["ScheduleID"] != null)
{
ViewState["ScheduleID"] = Request.QueryString["ScheduleID"];
ScheduleItem scheduleItem = SchedulingProvider.Instance().GetSchedule(Convert.ToInt32(Request.QueryString["ScheduleID"]));
txtFriendlyName.Text = scheduleItem.FriendlyName;
txtType.Enabled = false;
txtType.Text = scheduleItem.TypeFullName;
chkEnabled.Checked = scheduleItem.Enabled;
if (scheduleItem.TimeLapse == Null.NullInteger)
{
txtTimeLapse.Text = "";
}
else
{
txtTimeLapse.Text = Convert.ToString(scheduleItem.TimeLapse);
}
if (ddlTimeLapseMeasurement.Items.FindByValue(scheduleItem.TimeLapseMeasurement) != null)
{
ddlTimeLapseMeasurement.Items.FindByValue(scheduleItem.TimeLapseMeasurement).Selected = true;
}
if (scheduleItem.RetryTimeLapse == Null.NullInteger)
{
txtRetryTimeLapse.Text = "";
}
else
{
txtRetryTimeLapse.Text = Convert.ToString(scheduleItem.RetryTimeLapse);
}
if (ddlRetryTimeLapseMeasurement.Items.FindByValue(scheduleItem.RetryTimeLapseMeasurement) != null)
{
ddlRetryTimeLapseMeasurement.Items.FindByValue(scheduleItem.RetryTimeLapseMeasurement).Selected = true;
}
if (ddlRetainHistoryNum.Items.FindByValue(Convert.ToString(scheduleItem.RetainHistoryNum)) != null)
{
ddlRetainHistoryNum.Items.FindByValue(Convert.ToString(scheduleItem.RetainHistoryNum)).Selected = true;
}
else
{
ddlRetainHistoryNum.Items.Add(scheduleItem.RetainHistoryNum.ToString());
ddlRetainHistoryNum.Items.FindByValue(Convert.ToString(scheduleItem.RetainHistoryNum)).Selected = true;
}
if (ddlAttachToEvent.Items.FindByValue(scheduleItem.AttachToEvent) != null)
{
ddlAttachToEvent.Items.FindByValue(scheduleItem.AttachToEvent).Selected = true;
}
chkCatchUpEnabled.Checked = scheduleItem.CatchUpEnabled;
txtObjectDependencies.Text = scheduleItem.ObjectDependencies;
BindServers(scheduleItem.Servers);
}
else
{
cmdDelete.Visible = false;
cmdRun.Visible = false;
txtType.Enabled = true;
}
}
/// <summary>
/// This method will actually update the schedule to "Enabled"
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void btnEnableNow_Click(object sender, EventArgs e)
{
var oItem = SchedulingProvider.Instance().GetSchedule(Assembly_Name, "");
oItem.Enabled = true;
SchedulingProvider.Instance().UpdateSchedule(oItem);
pnlNotEnabled.Visible = false;
}
/// <summary>
/// The remove schedule client.
/// </summary>
/// <param name="scheduleId">The schedule id.</param>
private static void RemoveScheduleClient(int scheduleId)
{
// get the item by id
var item = SchedulingProvider.Instance().GetSchedule(scheduleId);
// tell the provider to remove the item
SchedulingProvider.Instance().DeleteSchedule(item);
}
private static void SetLastJobStartTime(int scheduleId, DateTimeOffset time)
{
SchedulingProvider.Instance()
.AddScheduleItemSetting(
scheduleId,
Constants.LastJobStartTimeKey,
time.ToUniversalTime()
.DateTime.ToString(Constants.JobRunDateTimeFormat));
}
public void CmdStopScheduleClick(object sender, EventArgs e)
{
var stopBtn = (LinkButton)sender;
ScheduleItem scheduleItem = SchedulingProvider.Instance().GetSchedule(Convert.ToInt32(stopBtn.CommandArgument));
//Stop from execution
SchedulingProvider.Instance().RemoveFromScheduleInProgress(scheduleItem);
BindData();
BindStatus();
}
public ActionResult UpdateScheduleItem(ScheduleDto scheduleDto)
{
ActionResult ActionResult = new ActionResult();
dynamic Result = new ExpandoObject();
try
{
if (scheduleDto.RetryTimeLapse == 0)
{
scheduleDto.RetryTimeLapse = Null.NullInteger;
}
if (!SchedulerManager.VerifyValidTimeLapseRetry(scheduleDto.TimeLapse, scheduleDto.TimeLapseMeasurement, scheduleDto.RetryTimeLapse, scheduleDto.RetryTimeLapseMeasurement))
{
ActionResult.AddError("InvalidFrequencyAndRetry", Localization.GetString("InvalidFrequencyAndRetry", Components.Constants.TaskSchedulerResourcesFile));
}
else
{
ScheduleItem existingItem = SchedulingProvider.Instance().GetSchedule(scheduleDto.ScheduleID);
ScheduleItem updatedItem = _controller.CreateScheduleItem(scheduleDto.TypeFullName, scheduleDto.FriendlyName, scheduleDto.TimeLapse, scheduleDto.TimeLapseMeasurement,
scheduleDto.RetryTimeLapse, scheduleDto.RetryTimeLapseMeasurement, scheduleDto.RetainHistoryNum, scheduleDto.AttachToEvent, scheduleDto.CatchUpEnabled,
scheduleDto.Enabled, scheduleDto.ObjectDependencies, scheduleDto.ScheduleStartDate, scheduleDto.Servers);
updatedItem.ScheduleID = scheduleDto.ScheduleID;
if (updatedItem.ScheduleStartDate != existingItem.ScheduleStartDate ||
updatedItem.Enabled ||
updatedItem.Enabled != existingItem.Enabled ||
updatedItem.TimeLapse != existingItem.TimeLapse ||
updatedItem.RetryTimeLapse != existingItem.RetryTimeLapse ||
updatedItem.RetryTimeLapseMeasurement != existingItem.RetryTimeLapseMeasurement ||
updatedItem.TimeLapseMeasurement != existingItem.TimeLapseMeasurement)
{
SchedulingProvider.Instance().UpdateSchedule(updatedItem);
ActionResult.Message = Localization.GetString("ScheduleItemUpdateSuccess", Components.Constants.TaskSchedulerResourcesFile);
}
else
{
ActionResult.Message = Localization.GetString("ScheduleItemUpdateSuccess", Components.Constants.TaskSchedulerResourcesFile);
SchedulingProvider.Instance().UpdateScheduleWithoutExecution(updatedItem);
}
Result.Status = "Success";
Result.ScheduleItems = SchedulerManager.GetScheduleItems(0, 14);
ActionResult.Data = Result;
}
}
catch (Exception exc)
{
Exceptions.LogException(exc);
Result.Status = exc.Message.ToString();
ActionResult.AddError("ScheduleItemUpdateError", Localization.GetString("ScheduleItemUpdateError", Components.Constants.TaskSchedulerResourcesFile));
}
return(ActionResult);
}
public static void StartScheduler()
{
if (Services.Scheduling.SchedulingProvider.SchedulerMode == SchedulerMode.TIMER_METHOD)
{
SchedulingProvider scheduler = SchedulingProvider.Instance();
scheduler.RunEventSchedule(CommonLibrary.Services.Scheduling.EventName.APPLICATION_START);
System.Threading.Thread newThread = new System.Threading.Thread(CommonLibrary.Services.Scheduling.SchedulingProvider.Instance().Start);
newThread.IsBackground = true;
newThread.Start();
}
}
/// <summary>
/// 更新调度器
/// </summary>
public void UpdateScheduler(BaseModule baseModule)
{
ScheduleItem objScheduleItem = SchedulingProvider.Instance().GetSchedule("Playngo.Modules.ClientZone.NotificationSchedule,Playngo.Modules.ClientZone", Null.NullString);
if (!(objScheduleItem != null && objScheduleItem.ScheduleID > 0))
{
//这里需要创建新的调度器
Int32 ScheduleID = AddScheduler(true, 10, 10, 100);
objScheduleItem = SchedulingProvider.Instance().GetSchedule(ScheduleID);
}
}
public static void DisableScheduleItem(string fullTypeName)
{
var provider = SchedulingProvider.Instance();
var item = GetScheduleItem(fullTypeName);
if (item != null)
{
item.Enabled = false;
provider.UpdateSchedule(item);
}
}
protected void bScheduleTask_Click(object sender, EventArgs e)
{
var sc = SchedulingProvider.Instance();
var schedule = sc.GetSchedule("Satrabel.OpenFiles.Components.Lucene.SearchEngineScheduler, OpenFiles", "");
if (schedule == null)
{
schedule = CreateScheduleItem();
SchedulingProvider.Instance().AddSchedule(schedule);
}
}
public override void AddLog(LogInfo objLogInfo)
{
string ConfigPortalID;
if (objLogInfo.LogPortalID != Null.NullInteger)
{
ConfigPortalID = objLogInfo.LogPortalID.ToString();
}
else
{
ConfigPortalID = "*";
}
LogTypeConfigInfo objLogTypeConfigInfo;
objLogTypeConfigInfo = GetLogTypeConfigInfoByKey(objLogInfo.LogTypeKey, ConfigPortalID);
if (objLogTypeConfigInfo.LoggingIsActive == false)
{
return;
}
bool UseEventLogBuffer = true;
if (Globals.HostSettings.ContainsKey("EventLogBuffer"))
{
if (Convert.ToString(Globals.HostSettings["EventLogBuffer"]) != "Y")
{
UseEventLogBuffer = false;
}
}
else
{
UseEventLogBuffer = false;
}
objLogInfo.LogConfigID = objLogTypeConfigInfo.ID;
LogQueueItem objLogQueueItem = new LogQueueItem();
objLogQueueItem.LogInfo = objLogInfo;
objLogQueueItem.LogTypeConfigInfo = objLogTypeConfigInfo;
SchedulingProvider scheduler = SchedulingProvider.Instance();
if (objLogInfo.BypassBuffering || SchedulingProvider.Enabled == false || scheduler.GetScheduleStatus() == ScheduleStatus.STOPPED || UseEventLogBuffer == false)
{
WriteLog(objLogQueueItem);
}
else
{
LogQueue.Add(objLogQueueItem);
}
}
/// <summary>
/// cmdDelete_Click runs when the Delete Button is clicked
/// </summary>
/// <remarks>
/// </remarks>
/// <history>
/// [cnurse] 9/28/2004 Updated to reflect design changes for Help, 508 support and localisation
/// </history>
protected void OnDeleteClick(Object sender, EventArgs e)
{
var objScheduleItem = new ScheduleItem {
ScheduleID = Convert.ToInt32(ViewState["ScheduleID"])
};
SchedulingProvider.Instance().DeleteSchedule(objScheduleItem);
var strMessage = Localization.GetString("DeleteSuccess", LocalResourceFile);
UI.Skins.Skin.AddModuleMessage(this, strMessage, ModuleMessage.ModuleMessageType.GreenSuccess);
}
/// <summary>
/// cmdDelete_Click runs when the Delete Button is clicked
/// </summary>
/// <returns></returns>
/// <remarks>
/// </remarks>
/// <history>
/// [cnurse] 9/28/2004 Updated to reflect design changes for Help, 508 support
/// and localisation
/// </history>
protected void cmdDelete_Click(Object sender, EventArgs e)
{
ScheduleItem objScheduleItem = new ScheduleItem();
objScheduleItem.ScheduleID = Convert.ToInt32(ViewState["ScheduleID"]);
SchedulingProvider.Instance().DeleteSchedule(objScheduleItem);
string strMessage;
strMessage = Localization.GetString("DeleteSuccess", this.LocalResourceFile);
UI.Skins.Skin.AddModuleMessage(this, strMessage, ModuleMessageType.GreenSuccess);
pnlScheduleItem.Visible = false;
}
private void BindData()
{
if (Request.QueryString["ScheduleID"] != null)
{
ViewState["ScheduleID"] = Request.QueryString["ScheduleID"];
ScheduleItem scheduleItem = SchedulingProvider.Instance().GetSchedule(Convert.ToInt32(Request.QueryString["ScheduleID"]));
txtFriendlyName.Text = scheduleItem.FriendlyName;
txtType.Enabled = false;
txtType.Text = scheduleItem.TypeFullName;
chkEnabled.Checked = scheduleItem.Enabled;
if (!Null.IsNull(scheduleItem.ScheduleStartDate))
{
startScheduleDatePicker.SelectedDate = scheduleItem.ScheduleStartDate;
}
txtTimeLapse.Text = Convert.ToString(scheduleItem.TimeLapse);
if (ddlTimeLapseMeasurement.FindItemByValue(scheduleItem.TimeLapseMeasurement) != null)
{
ddlTimeLapseMeasurement.FindItemByValue(scheduleItem.TimeLapseMeasurement).Selected = true;
}
txtRetryTimeLapse.Text = Convert.ToString(scheduleItem.RetryTimeLapse);
if (ddlRetryTimeLapseMeasurement.FindItemByValue(scheduleItem.RetryTimeLapseMeasurement) != null)
{
ddlRetryTimeLapseMeasurement.FindItemByValue(scheduleItem.RetryTimeLapseMeasurement).Selected = true;
}
if (ddlRetainHistoryNum.FindItemByValue(Convert.ToString(scheduleItem.RetainHistoryNum)) != null)
{
ddlRetainHistoryNum.FindItemByValue(Convert.ToString(scheduleItem.RetainHistoryNum)).Selected = true;
}
else
{
string scheduleItemRetainHistoryNum = scheduleItem.RetainHistoryNum.ToString();
ddlRetainHistoryNum.AddItem(scheduleItemRetainHistoryNum, scheduleItemRetainHistoryNum);
ddlRetainHistoryNum.FindItemByValue(Convert.ToString(scheduleItem.RetainHistoryNum)).Selected = true;
}
if (ddlAttachToEvent.FindItemByValue(scheduleItem.AttachToEvent) != null)
{
ddlAttachToEvent.FindItemByValue(scheduleItem.AttachToEvent).Selected = true;
}
chkCatchUpEnabled.Checked = scheduleItem.CatchUpEnabled;
txtObjectDependencies.Text = scheduleItem.ObjectDependencies;
txtServers.Text = scheduleItem.Servers.Trim(',');
if (Convert.ToInt32(txtRetryTimeLapse.Text) == 0)
{
ddlRetryTimeLapseMeasurement.Visible = false;
}
}
else
{
cmdDelete.Visible = false;
cmdRun.Visible = false;
txtType.Enabled = true;
}
}
/// <summary>
/// StartScheduler starts the Scheduler
/// </summary>
/// <history>
/// [cnurse] 1/27/2005 Moved back to App_Start from Scheduling Module
/// </history>
public static void StartScheduler()
{
// instantiate APPLICATION_START scheduled jobs
if (SchedulingProvider.SchedulerMode == SchedulerMode.TIMER_METHOD)
{
SchedulingProvider scheduler = SchedulingProvider.Instance();
scheduler.RunEventSchedule(EventName.APPLICATION_START);
Thread newThread = new Thread(new ThreadStart(SchedulingProvider.Instance().Start));
newThread.IsBackground = true;
newThread.Start();
}
}
/// <summary>
/// cmdUpdate_Click runs when the Update Button is clicked
/// </summary>
/// <returns></returns>
/// <remarks>
/// </remarks>
/// <history>
/// [cnurse] 9/28/2004 Updated to reflect design changes for Help, 508 support
/// and localisation
/// </history>
protected void cmdUpdate_Click(Object sender, EventArgs e)
{
ScheduleItem objScheduleItem = new ScheduleItem();
string strMessage;
objScheduleItem.TypeFullName = txtType.Text;
if (txtTimeLapse.Text == "" || txtTimeLapse.Text == "0" || txtTimeLapse.Text == "-1")
{
objScheduleItem.TimeLapse = Null.NullInteger;
}
else
{
objScheduleItem.TimeLapse = Convert.ToInt32(txtTimeLapse.Text);
}
objScheduleItem.TimeLapseMeasurement = ddlTimeLapseMeasurement.SelectedItem.Value;
if (txtRetryTimeLapse.Text == "" || txtRetryTimeLapse.Text == "0" || txtRetryTimeLapse.Text == "-1")
{
objScheduleItem.RetryTimeLapse = Null.NullInteger;
}
else
{
objScheduleItem.RetryTimeLapse = Convert.ToInt32(txtRetryTimeLapse.Text);
}
objScheduleItem.RetryTimeLapseMeasurement = ddlRetryTimeLapseMeasurement.SelectedItem.Value;
objScheduleItem.RetainHistoryNum = Convert.ToInt32(ddlRetainHistoryNum.SelectedItem.Value);
objScheduleItem.AttachToEvent = ddlAttachToEvent.SelectedItem.Value;
objScheduleItem.CatchUpEnabled = chkCatchUpEnabled.Checked;
objScheduleItem.Enabled = chkEnabled.Checked;
objScheduleItem.ObjectDependencies = txtObjectDependencies.Text;
objScheduleItem.Servers = txtServers.Text;
if (ViewState["ScheduleID"] != null)
{
objScheduleItem.ScheduleID = Convert.ToInt32(ViewState["ScheduleID"]);
SchedulingProvider.Instance().UpdateSchedule(objScheduleItem);
}
else
{
SchedulingProvider.Instance().AddSchedule(objScheduleItem);
}
strMessage = Localization.GetString("UpdateSuccess", this.LocalResourceFile);
UI.Skins.Skin.AddModuleMessage(this, strMessage, ModuleMessageType.GreenSuccess);
if (SchedulingProvider.SchedulerMode == SchedulerMode.TIMER_METHOD)
{
SchedulingProvider.Instance().ReStart("Change made to schedule.");
}
BindData();
cmdDelete.Visible = true;
}
/// <summary>
/// Handles the Click event of the btnPhase1 control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
protected void btnPhase1_Click(object sender, EventArgs e)
{
var objScheduleItem = CreateScheduleItem("ICG.Modules.SecureMyInstall.Components.Phase1Job, ICG.Modules.SecureMyInstall");
SchedulingProvider.Instance().RunScheduleItemNow(objScheduleItem);
DotNetNuke.UI.Skins.Skin.AddModuleMessage(this, "Phase 1 Started - Please Monitor Event Log For Progress, as well as the machine key values, once complete you will be logged off.", DotNetNuke.UI.Skins.Controls.ModuleMessage.ModuleMessageType.BlueInfo);
//Add setting
var oController = new ModuleController();
oController.UpdateModuleSetting(ModuleId, "Phase1Complete", "1");
btnPhase1.Enabled = false;
}
public HttpResponseMessage StartSchedule()
{
try
{
SchedulingProvider.Instance().StartAndWaitForResponse();
return(Request.CreateResponse(HttpStatusCode.OK, new { Success = true }));
}
catch (Exception exc)
{
Logger.Error(exc);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exc));
}
}
