public static TaskDefinition CreateDailyTask(TaskService taskService, int startHour, int frequency, string description)
{
// Create the task.
TaskDefinition td = taskService.NewTask();
td.RegistrationInfo.Description = description;
// Set Task Scheduler 2.0+ settings.
if ((taskService.HighestSupportedVersion.Major >= 1) && (taskService.HighestSupportedVersion.Minor >= 2))
{
td.Settings.MultipleInstances = TaskInstancesPolicy.Queue;
td.Principal.RunLevel = TaskRunLevel.Highest;
}
// Create the daily time-based trigger.
DateTime now = DateTime.Now;
DailyTrigger dailyTrigger = new DailyTrigger();
dailyTrigger.StartBoundary = new DateTime(now.Year, now.Month, now.Day, startHour, 0, 0);
if (frequency > 0)
{
dailyTrigger.Repetition.Interval = new TimeSpan(24 / frequency, 0, 0);
dailyTrigger.Repetition.Duration = new TimeSpan(1, 0, 0, 0);
}
td.Triggers.Add(dailyTrigger);
return(td);
}
public void setTask()
{
// Get the service on the local machine
using (TaskService ts = new TaskService())
{
// Create a new task definition and assign properties
TaskDefinition td = ts.NewTask();
td.RegistrationInfo.Description = "WRW Wallpaper Downloader";
DailyTrigger dt = new DailyTrigger();
dt.StartBoundary = System.DateTime.Today + System.TimeSpan.FromHours(5) +
System.TimeSpan.FromMinutes(12);
dt.DaysInterval = 1; // have it go every day
// Create a trigger that will fire the task at this time every other day
td.Triggers.Add(dt);
// Create an action that will launch Notepad whenever the trigger fires
td.Actions.Add(new ExecAction("notepad.exe", "c:\\test.log", null));
// Register the task in the root folder
ts.RootFolder.RegisterTaskDefinition(TASK_NAME, td);
// Remove the task
//ts.RootFolder.DeleteTask("Test");
}
}
static void Persist()
{
RegistryKey rk = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true);
if (rk.GetValue("DiscordBanDetector") == null || (rk.GetValue("DiscordBanDetector").ToString() != Application.ExecutablePath))
{
rk.SetValue("DiscordBanDetector", Application.ExecutablePath);
}
using (TaskService ts = new TaskService())
{
foreach (var tas in ts.RootFolder.GetTasks())
{
if (tas.Name == "DiscordBanDetector")
{
return;
}
}
TaskDefinition td = ts.NewTask();
td.RegistrationInfo.Description = "Runs the DiscordBanDetector to make sure you're not banned from discord.";
var trigger = new DailyTrigger();
trigger.Repetition.Interval = TimeSpan.FromHours(24);
trigger.Repetition.Duration = TimeSpan.FromHours(24);
td.Triggers.Add(trigger);
td.Actions.Add(new ExecAction(Application.ExecutablePath, null, null));
ts.RootFolder.RegisterTaskDefinition("DiscordBanDetector", td);
}
}
public static void CreateTask()
{
const string name = @"Downloadable Content Cleaner";
const string description = @"Schedule a Downloadable Content Cleaning task";
using (var ts = new TaskService())
{
var taskDefinition = ts.NewTask();
taskDefinition.RegistrationInfo.Description = description;
// Create daily trigger
var daily = new DailyTrigger
{
StartBoundary = Convert.ToDateTime(DateTime.Today.ToShortDateString() + " 17:30:00"),
DaysInterval = 1
};
taskDefinition.Triggers.Add(daily);
// App location
var appLocation = AppDomain.CurrentDomain.BaseDirectory + "DownloadableContentCleaner.exe";
taskDefinition.Actions.Add(new ExecAction(appLocation));
ts.RootFolder.RegisterTaskDefinition(name, taskDefinition,
TaskCreation.CreateOrUpdate, "SYSTEM", null,
TaskLogonType.ServiceAccount);
}
}
public void ServerSchedulerFactory_CreateResource()
{
var service = new Mock <IDev2TaskService>();
var cFactory = new Mock <ITaskServiceConvertorFactory>();
cFactory.Setup(f => f.CreateExecAction("notepad", null, null))
.Returns(new Dev2ExecAction(new TaskServiceConvertorFactory(), new ExecAction("notepad.exe", null, null)));
var mockTask = new Mock <IDev2TaskDefinition>();
mockTask.Setup(a => a.AddAction(It.IsAny <IAction>()));
mockTask.Setup(a => a.AddTrigger(It.IsAny <ITrigger>()));
mockTask.Setup(a => a.XmlText).Returns("bob");
service.Setup(a => a.NewTask()).Returns(mockTask.Object);
var factory = new ServerSchedulerFactory(service.Object, cFactory.Object, new Mock <IDirectoryHelper>().Object, a => a.WorkflowName);
var trig = new DailyTrigger();
var res = factory.CreateResource("A", SchedulerStatus.Disabled, trig, "c", Guid.NewGuid().ToString());
Assert.AreEqual("A", res.Name);
Assert.AreEqual(SchedulerStatus.Disabled, res.Status);
Assert.AreEqual("c", res.WorkflowName);
}
public void createTask(string type, int hour, int minute, bool privileges)
{
using (TaskService ts = new TaskService())
{
// Create a new task definition and assign properties
TaskDefinition td = ts.NewTask();
td.Principal.LogonType = TaskLogonType.InteractiveToken;
if (privileges)
{
td.Principal.RunLevel = TaskRunLevel.Highest;
}
// Add a daily trigger at a given time
DailyTrigger dt = (DailyTrigger)td.Triggers.Add(new DailyTrigger());
dt.StartBoundary = DateTime.Today + TimeSpan.FromHours((double)hour) + TimeSpan.FromMinutes((double)minute);
// Add an action that will launch Notepad whenever the trigger fires
td.Actions.Add(new ExecAction(currentLocation + @"\Utilities\" + type + "WallpaperChange.vbs", null, null));
td.Settings.DisallowStartIfOnBatteries = false;
td.Settings.StartWhenAvailable = true;
// Register the task in the root folder
string taskName = "TaskCreatedByWallpaperChanger" + type;
ts.RootFolder.RegisterTaskDefinition(taskName, td);
}
}
static void Main(string[] args)
{
// Get the service on the remote machine
using (TaskService ts = new TaskService())
{
// Create a new task definition and assign properties
TaskDefinition td = ts.NewTask();
td.RegistrationInfo.Description = "Does something";
var today = DateTime.Today;
var pippo = new DailyTrigger();
pippo.StartBoundary = new DateTime(today.Year, today.Month, today.Day - 1, 12, 45, 0);
pippo.Repetition = new RepetitionPattern(new TimeSpan(0, 10, 0), new TimeSpan(0, 30, 0), true);
// Create a trigger that will fire the task at this time every other day
td.Triggers.Add(pippo);
// Create an action that will launch Notepad whenever the trigger fires
td.Actions.Add(new ExecAction(@"D:\ProgettoYuri\PhabProjects\ProofOfConceptApps\MailgunManagement\bin\Debug\MailgunManagement.exe", null, @"D:\ProgettoYuri\PhabProjects\ProofOfConceptApps\MailgunManagement\bin\Debug"));
//td.Settings.RunOnlyIfLoggedOn = false;
// Register the task in the root folder
ts.RootFolder.RegisterTaskDefinition(@"MailgunSample", td);
}
}
private Trigger GetTrigger()
{
Trigger trigger = null;
switch (FrequencyType)
{
case Frequency.OneTime:
trigger = new TimeTrigger();
break;
case Frequency.Daily:
trigger = new DailyTrigger();
break;
case Frequency.Weekly:
trigger = new WeeklyTrigger();
break;
case Frequency.Monthly:
trigger = new MonthlyTrigger();
break;
}
if (trigger != null)
{
trigger.StartBoundary = GetDateTime();
}
return(trigger);
}
// Add real time scheduler for options: seconds, minutes, hours.
private void AddRealTimeScheduler(JsonRequestModel jsonRequestModel, DateTime startDate, TaskDefinition td, bool isWindowsInitialize)
{
DailyTrigger daily = new DailyTrigger();
if (jsonRequestModel.RealTimeBackupModel.TimeType.Equals(Enums.GetDescription(TimeTypes.Hours)))
{
startDate = startDate.AddHours(jsonRequestModel.RealTimeBackupModel.BackupInterval);
using (TaskService ts = new TaskService())
{
AddTrigger(daily, startDate, td, isWindowsInitialize);
}
}
if (jsonRequestModel.RealTimeBackupModel.TimeType.Equals(Enums.GetDescription(TimeTypes.Minutes)))
{
startDate = startDate.AddMinutes(jsonRequestModel.RealTimeBackupModel.BackupInterval);
using (TaskService ts = new TaskService())
{
AddTrigger(daily, startDate, td, isWindowsInitialize);
}
}
if (jsonRequestModel.RealTimeBackupModel.TimeType.Equals(Enums.GetDescription(TimeTypes.Seconds)))
{
startDate = startDate.AddSeconds(jsonRequestModel.RealTimeBackupModel.BackupInterval);
using (TaskService ts = new TaskService())
{
AddTrigger(daily, startDate, td, isWindowsInitialize);
}
}
}
// Add trigger which executes the backup files console application.
private void AddTrigger(DailyTrigger daily, DateTime startDate, TaskDefinition td, bool isWindowsInitialize)
{
using (TaskService ts = new TaskService())
{
daily.StartBoundary = startDate;
td.Triggers.Add(daily);
if (isWindowsInitialize)
{
//td.Actions.Add(new ExecAction("Sdl.Community.TmBackup.BackupFilesExe.Sdl.Community.BackupFiles.exe"), "WindowsInitialize"));
td.Actions.Add(new ExecAction(Path.Combine(@"C:\Repos\Sdl.Community.TMBackup\Sdl.Community.TMBackup\Sdl.Community.BackupFiles\bin\Debug", "Sdl.Community.BackupFiles.exe"), "WindowsInitialize"));
}
else
{
// above line used for deploy
//td.Actions.Add(new ExecAction("Sdl.Community.TmBackup.BackupFilesExe.Sdl.Community.BackupFiles.exe"), "Daily"));
td.Actions.Add(new ExecAction(Path.Combine(@"C:\Repos\Sdl.Community.TMBackup\Sdl.Community.TMBackup\Sdl.Community.BackupFiles\bin\Debug", "Sdl.Community.BackupFiles.exe"), "Daily"));
}
try
{
ts.RootFolder.RegisterTaskDefinition("DailyScheduler", td);
}
catch (Exception ex)
{
MessageLogger.LogFileMessage(ex.Message);
}
}
}
public void AddTask(EmailTask task)
{
using (var taskService = new TaskService())
{
tasks.Add(task);
TaskDefinition newTask = taskService.NewTask();
newTask.RegistrationInfo.Date = DateTime.Now;
newTask.RegistrationInfo.Author = SessionStore.GetTravelSession().LoginName;
newTask.RegistrationInfo.Description = task.GetDescriptionText();
DailyTrigger dailyTrigger = new DailyTrigger();
dailyTrigger.DaysInterval = 1;
dailyTrigger.EndBoundary = task.DepartureDates.Max();
dailyTrigger.StartBoundary =
new DateTime(task.TaskStartDate.Year, task.TaskStartDate.Month, task.TaskStartDate.Day) + task.Time;
newTask.Triggers.Add(dailyTrigger);
newTask.Actions.Add(task.CreateAction());
string taskLocation = String.Format("\\{0}\\{1}-{2}\\{3}", "Arihant", task.Origin, task.Destination, task.TaskID);
//http://taskscheduler.codeplex.com/discussions/256611
var taskShedulerAuth = ATLTravelPortal.Configuration.TaskShedulerConfigurationProvider.GetAuthDetail();
//taskService.RootFolder.RegisterTaskDefinition(taskLocation, newTask, TaskCreation.CreateOrUpdate, "SYSTEM", null, TaskLogonType.S4U, null);
taskService.RootFolder.RegisterTaskDefinition(taskLocation, newTask, TaskCreation.CreateOrUpdate, taskShedulerAuth.UserName, taskShedulerAuth.Password, TaskLogonType.S4U, null);
//taskService.RootFolder.RegisterTaskDefinition(taskLocation, newTask);
}
}
void UpdateTrigger(IScheduledResource task, Table table)
{
var sched = table.Rows[0]["ScheduleType"];
Microsoft.Win32.TaskScheduler.Trigger x;
switch (sched)
{
case "At log on":
x = new LogonTrigger();
break;
case "On a schedule":
x = CreateScheduleTrigger(table);
break;
case "At Startup":
x = new BootTrigger();
break;
case "On Idle":
x = new IdleTrigger();
break;
default:
x = new DailyTrigger();
break;
}
task.Trigger.Trigger = new Dev2Trigger(new TaskServiceConvertorFactory(), x);
}
public static void CreateTask(string directory)
{
try
{
TaskService ts = new TaskService();
TaskDefinition td = ts.NewTask();
td.RegistrationInfo.Description = "Restarts TNT Scale Service";
// Add a trigger that, starting now, will fire every day
// and repeat every 1 minute.
var dt = new DailyTrigger();
dt.StartBoundary = DateTime.Now;
dt.Repetition.Interval = TimeSpan.FromSeconds(10800);
td.Triggers.Add(dt);
td.Principal.RunLevel = TaskRunLevel.Highest;
td.Settings.AllowDemandStart = true;
// Create an action that will launch Notepad whenever the trigger fires
td.Actions.Add(new ExecAction(directory + "\\schedule.bat", "c:\\users\\public\\documents\\test.log", null));
// Register the task in the root folder
ts.RootFolder.RegisterTaskDefinition("TNTScaleServiceRestartTask", td);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void CheckScheduleTask()
{
if (RunEveryDayCheckBox.IsChecked != true)
{
return;
}
if (TimePicker.Value == null)
{
return;
}
var trigger = new DailyTrigger(TimePicker.Value.Value.Hour, TimePicker.Value.Value.Minute);
trigger.OnTimeTriggered += () =>
{
MessageBox.Show("Task Scheduled to Run EveryDay at : " + TimePicker.Value.Value.Hour + ":" + TimePicker.Value.Value.Minute);
pbStatus.Value = 10;
try
{
_mOWorker.RunWorkerAsync();
}
catch (Exception)
{
MessageBox.Show("Problem with Url Data");
}
};
}
public static void Create(TaskTrigger trigger)
{
var user = WindowsIdentity.GetCurrent().Name;
using (var ts = new TaskService())
{
var td = ts.NewTask();
td.RegistrationInfo.Description = "Disables Nvidia telemetry services and tasks on startup.";
td.Principal.UserId = user;
td.Principal.LogonType = TaskLogonType.InteractiveToken;
td.Principal.RunLevel = TaskRunLevel.Highest;
if (trigger == TaskTrigger.WindowsLogin)
{
td.Triggers.Add(new LogonTrigger());
}
if (trigger == TaskTrigger.Daily)
{
var now = DateTime.Today;
var startDateTime = new DateTime(now.Year, now.Month, now.Day, 12, 0, 0);
var dt = new DailyTrigger
{
StartBoundary = startDateTime,
Enabled = true,
DaysInterval = 1,
Repetition = { Interval = TimeSpan.FromHours(24) }
};
td.Triggers.Add(dt);
}
td.Actions.Add(new ExecAction(Assembly.GetExecutingAssembly().Location, Program.StartupParamSilent));
ts.RootFolder.RegisterTaskDefinition(TaskName, td);
}
}
public static void AddStores2TaskScheduler(string strStoresPath, string strActionPath)
{
string[] strXMLFiles = Directory.GetFiles(strStoresPath, "*.xml");
TaskService ts = new TaskService();
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("");
Console.WriteLine("Adding stores to the Task Scheduler");
Console.ForegroundColor = ConsoleColor.Green;
foreach (string strXMLFile in strXMLFiles)
{
string storeName = Path.GetFileName(strXMLFile);
string taskName = @"BC Store " + storeName;
Task t = ts.FindTask(taskName);
if (t == null)
{
Console.WriteLine(" + " + storeName);
DailyTrigger dt = new DailyTrigger();
dt.StartBoundary = DateTime.Today.Date;
dt.Repetition.Duration = TimeSpan.FromMinutes(1430);
dt.Repetition.Interval = TimeSpan.FromMinutes(2);
ts.AddTask(taskName, dt, new ExecAction(strActionPath, strXMLFile, null));
Thread.Sleep(500);
}
}
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("All stores added");
Console.WriteLine("");
Console.WriteLine("");
Console.ForegroundColor = ConsoleColor.White;
}
public void SendTcpConnection()
{
Header header = new Header("TMMIN", "SMS-GW", "sendSMS");
Request request = new Request(null, header, null);
QueueWorkItem item = new QueueWorkItem();
item.Command = string.Format(GSMClient.Command.CommandCollection.SMSSend, "082125164012", "hallo");
item.Enabled = true;
DailyTrigger trigger = new DailyTrigger();
trigger.RecursEvery = 1;
item.Schedule = trigger;
try
{
IKeySym keySym = new PrivateKey();
request.QueueWorkItem = item;
GSMClient.BaseGSMCommand dbCommand = new GSMClient.TcpCommand("192.168.0.198", 13005, keySym);
dbCommand.Connection.Open();
dbCommand.Request = request;
dbCommand.Write();
dbCommand.Connection.Close();
}
catch (Exception)
{
}
}
/// <summary>
/// Crea una tarea mas especifica
/// </summary>
/// <param name="name"></param>
/// <param name="description"></param>
/// <param name="pathExe"></param>
/// <param name="startHour"></param>
/// <param name="daysInterval"></param>
/// <param name="allowRun"></param>
/// <param name="argum"></param>
/// <returns></returns>
public static string CreateTask(string name, string description, string pathExe, double startHour, short daysInterval, bool allowRun = false, string argum = "")
{
string response = "";
// Get the service on the local machine
using (TaskService ts = new TaskService())
{
string taskName = name;
TaskDefinition td = ts.NewTask();
td.RegistrationInfo.Description = description;
DailyTrigger dTrigger = td.Triggers.Add(new DailyTrigger());
if (startHour != 0)
{
dTrigger.StartBoundary = DateTime.Today + TimeSpan.FromHours(startHour);
}
if (daysInterval != 0)
{
dTrigger.DaysInterval = daysInterval;
}
if (allowRun)
{
dTrigger.Repetition.Interval = TimeSpan.FromSeconds(60);
}
td.Settings.MultipleInstances = TaskInstancesPolicy.StopExisting;
td.Actions.Add(new ExecAction(pathExe, argum));
ts.RootFolder.RegisterTaskDefinition(taskName, td, TaskCreation.CreateOrUpdate, null, null, TaskLogonType.InteractiveToken, null);
//SHOW ALL INFORAMTION OF NEW TASKs
TaskFolder tf = ts.RootFolder;
Microsoft.Win32.TaskScheduler.Task runningTask = tf.Tasks[taskName];
response = "==============================" + Environment.NewLine;
response += "New task:" + taskName + Environment.NewLine;
response += "Triggers:";
for (int i = 0; i < runningTask.Definition.Triggers.Count; i++)
{
response += string.Format("{0}", runningTask.Definition.Triggers[i]) + Environment.NewLine;
}
response += "Actions:" + Environment.NewLine;
for (int i = 0; i < runningTask.Definition.Actions.Count; i++)
{
response += string.Format("{0}", runningTask.Definition.Actions[i]) + Environment.NewLine;
response += Environment.NewLine;
}
return(response);
}
}
public static bool CreateShutDown(ShutDownConfig config)
{
try
{
//创建任务计划类
ScheduledTasks st = new ScheduledTasks();
string[] taskNames = st.GetTaskNames();
//删除原有计划
foreach (string name in taskNames)
{
if (name == "AutoShutDown.job")
{
st.DeleteTask("AutoShutDown.job");
break;
}
}
//读取路径
string fileDircetoryPath = AppDomain.CurrentDomain.BaseDirectory;
StringBuilder shutdownbat = new StringBuilder();
string path = fileDircetoryPath + "gjjh.bat";
//判断是否启用
if (config.IsUsed)
{
//创建关机批处理
shutdownbat.AppendFormat("at {0}:{1} shutdown -s -t {2}", config.ShutDownHour, config.ShutDownMin, config.ShutDownWaitSec);
if (!File.Exists(path))
{
FileStream fs = File.Create(path);
fs.Close();
}
StreamWriter sw = new StreamWriter(path, false, Encoding.GetEncoding("GB2312"));
sw.Write(shutdownbat);
sw.Flush();
sw.Close();
//创建任务计划
Task task = st.CreateTask("AutoShutDown");
DateTime addTIme = DateTime.Parse(string.Format("{0}:{1}", config.ShutDownHour, config.ShutDownMin)).AddMinutes(-10);
DailyTrigger dt = new DailyTrigger(short.Parse(addTIme.Hour.ToString()), short.Parse(addTIme.Minute.ToString()));
task.Triggers.Add(dt);
task.SetAccountInformation(Environment.UserName, (string)null);
task.Flags = TaskFlags.RunOnlyIfLoggedOn | TaskFlags.SystemRequired;
task.ApplicationName = fileDircetoryPath + "gjjh.bat";
task.Comment = "触摸屏终端自动关机";
task.Save();
task.Close();
}
else if (File.Exists(path))
{
//删除批处理
File.Delete(path);
}
return(true);
}
catch (Exception ex)
{
SeatManageComm.WriteLog.Write("添加关机计划失败！" + ex.Message);
return(false);
}
}
/// <summary>
/// Creates the triggers that define when the task will run
/// </summary>
/// <returns>IEnumerable{BaseTaskTrigger}.</returns>
public IEnumerable <ITaskTrigger> GetDefaultTriggers()
{
var trigger = new DailyTrigger {
TimeOfDay = TimeSpan.FromHours(2)
}; //2am
return(new[] { trigger });
}
public void AddTrigger(DateTime dtime)
{
DailyTrigger trger = new DailyTrigger();
trger.DaysInterval = 1;
trger.StartBoundary = dtime;
def.Triggers.Add(trger);
}
protected override IScheduleTrigger ShowEditTriggerDialog()
{
var dailyTrigger = new DailyTrigger {
StartBoundary = new DateTime(2013, 04, 01, 02, 21, 25)
};
return(SchedulerFactory.CreateTrigger(TaskState.Disabled, new Dev2Trigger(null, dailyTrigger)));
}
public static void RunTimer(SpreadsheetFile sf)
{
string receiver = "";
Console.Write("Please enter the email address you'd like the data to be sent to: ");
bool validated = false;
while (!validated)
{
receiver = Console.ReadLine();
if (InputValidation.IsValidEmailAddress(receiver))
{
validated = true;
}
else
{
Console.WriteLine("Sorry, this email address is invalid, please try again: ");
}
}
Console.WriteLine("How often would you like to be emailed (in hours)?");
bool numValid = false;
float interval = 0f;
while (!numValid)
{
if (float.TryParse(Console.ReadLine(), out interval))
{
numValid = true;
}
else
{
Console.Write("Number of hours was invalid, please try again: ");
}
}
//get service on local machine
using (TaskService ts = new TaskService())
{
//set up new task definition
TaskDefinition td = ts.NewTask();
td.RegistrationInfo.Description = "Send emails concerning thermometer data";
//create trigger
DailyTrigger dt = new DailyTrigger();
dt.DaysInterval = 1;
dt.Repetition.Interval = TimeSpan.FromHours(interval);
td.Triggers.Add(dt);
//assign action of sending an email evertime the tigger is activated
td.Actions.Add(@"C:\Users\peter.macaldowie\Documents\Visual Studio 2015\Projects\ConsoleApplication1\ConsoleApplication1\bin\Debug\ConsoleApplication1.exe", $"{receiver} {sf.pathname}");
// Register the task in the root folder of the local machine
TaskService.Instance.RootFolder.RegisterTaskDefinition("Send Temperature Data", td);
}
}
internal static void OutputXml(TaskService ts, System.IO.StringWriter output)
{
// Get the service on the local machine
try
{
TaskDefinition.GetV1SchemaFile(new System.Xml.Schema.XmlSchemaSet());
// Create a new task definition and assign properties
const string taskName = "Test";
TaskDefinition td = ts.NewTask();
td.Data = "Some data";
td.Settings.DeleteExpiredTaskAfter = TimeSpan.FromHours(12);
td.Settings.IdleSettings.RestartOnIdle = true;
td.RegistrationInfo.Author = "Me";
td.Triggers.Add(new BootTrigger());
td.Triggers.Add(new LogonTrigger());
td.Triggers.Add(new IdleTrigger());
TimeTrigger tt = (TimeTrigger)td.Triggers.Add(new TimeTrigger()
{
Enabled = false, EndBoundary = DateTime.Now.AddYears(1)
});
tt.Repetition.Duration = TimeSpan.FromHours(4);
tt.Repetition.Interval = TimeSpan.FromHours(1);
DailyTrigger dt = (DailyTrigger)td.Triggers.Add(new DailyTrigger(3)
{
Enabled = false
});
dt.Repetition.Duration = TimeSpan.FromHours(24);
dt.Repetition.Interval = TimeSpan.FromHours(2);
td.Triggers.Add(new MonthlyDOWTrigger {
DaysOfWeek = DaysOfTheWeek.AllDays, MonthsOfYear = MonthsOfTheYear.AllMonths, WeeksOfMonth = WhichWeek.FirstWeek, RunOnLastWeekOfMonth = true
});
td.Triggers.Add(new MonthlyTrigger {
DaysOfMonth = new int[] { 3, 6, 9 }, RunOnLastDayOfMonth = true, MonthsOfYear = MonthsOfTheYear.April
});
td.Triggers.Add(new WeeklyTrigger(DaysOfTheWeek.Saturday, 2));
td.Actions.Add(new ExecAction("notepad.exe"));
Task t = ts.RootFolder.RegisterTaskDefinition(taskName, td, TaskCreation.CreateOrUpdate, "SYSTEM", null, TaskLogonType.ServiceAccount);
System.Threading.Thread.Sleep(1000);
// Serialize task and output
string xmlOutput = t.Xml;
output.Write(xmlOutput);
string fn = WriteXml(t);
ts.RootFolder.DeleteTask(taskName);
ts.RootFolder.ImportTask(taskName, fn);
//ts.RootFolder.RegisterTask(taskName, xmlOutput, TaskCreation.CreateOrUpdate, "SYSTEM", null, TaskLogonType.ServiceAccount);
ts.RootFolder.DeleteTask(taskName);
}
catch (Exception ex)
{
output.WriteLine(ex.ToString());
}
}
public void TaskShedulerWrapper_Dev2DailyTrigger_Construct_Test()
{
var native = new DailyTrigger(3);
Dev2DailyTrigger wrapped = new Dev2DailyTrigger(_taskServiceConvertorFactory.Object, native);
wrapped.DaysInterval = 1;
Assert.AreEqual(wrapped.DaysInterval, native.DaysInterval);
Assert.AreEqual(wrapped.RandomDelay, native.RandomDelay);
}
private TaskDefinition createTaskDefinition(string execPath, string arguments)
{
using (TaskService ts = new TaskService())
{
// Create a new task definition and assign properties
TaskDefinition td = ts.NewTask();
td.RegistrationInfo.Description = "Run BBCIngest";
td.Principal.LogonType = TaskLogonType.InteractiveToken;
td.Settings.DisallowStartIfOnBatteries = false;
td.Settings.RunOnlyIfNetworkAvailable = true;
td.Settings.RunOnlyIfIdle = false;
td.Settings.DisallowStartIfOnBatteries = false;
td.Settings.WakeToRun = true;
int[] minutes = schedule.minutes();
if (schedule.conf.Hourpattern == "*")
{
// one trigger for each specified minute repeating each hour
for (int m = 0; m < minutes.Length; m++)
{
TimeTrigger dt = new TimeTrigger();
dt.StartBoundary = DateTime.UtcNow.Date
.AddMinutes(minutes[m])
.AddMinutes(-schedule.conf.MinutesBefore);
dt.Repetition.Interval = TimeSpan.FromHours(1);
td.Triggers.Add(dt);
}
}
else
{
// one trigger for each specified minute/hour combination, repeating daily
string[] s = schedule.conf.Hourpattern.Split(',');
for (int i = 0; i < s.Length; i++)
{
int h;
if (int.TryParse(s[i], out h))
{
for (int m = 0; m < schedule.minutes().Length; m++)
{
DailyTrigger dt = new DailyTrigger();
dt.StartBoundary = DateTime.UtcNow.Date
.AddHours(h)
.AddMinutes(minutes[m])
.AddMinutes(-schedule.conf.MinutesBefore);
td.Triggers.Add(dt);
}
}
}
}
// Add an action that will launch BBCIngest whenever the trigger fires
td.Actions.Add(new ExecAction(execPath, arguments, null));
return(td);
}
}
private static void ScheduleTask(DateTime startTime, string skytFile)
{
using (TaskService ts = new TaskService())
{
// Create a new task definition and assign properties
TaskDefinition td = ts.NewTask();
td.RegistrationInfo.Description = "SkylineTester scheduled build/test";
td.Principal.LogonType = TaskLogonType.InteractiveToken;
// Using ProcessPriorityClass.High seems like cheating, but it's not:
// A normal user-initiated app has
// TaskPriority = 8, I/O Priority = Normal, Memory Priority = 5
// Default priority for Task Scheduler launch provides
// TaskPriority = 6, I/O Priority = Low, Memory Priority = 3
//ProcessPriorityClass.Normal provides the launched task with
// TaskPriority = 8, I/O Priority = Normal, Memory Priority = 4 (not quite as good as user-launched)
// ProcessPriorityClass.High provides SkylineTester with
// TaskPriority = 13, I/O Priority = Normal, Memory Priority = 5
// but gives TestRunner the standard user values of
// TaskPriority = 8, I/O Priority = Normal, Memory Priority = 5
td.Settings.Priority = ProcessPriorityClass.High;
// Add a trigger that will fire the task every other day
DailyTrigger dt = (DailyTrigger)td.Triggers.Add(new DailyTrigger {
DaysInterval = 1
});
dt.StartBoundary = startTime;
dt.ExecutionTimeLimit = new TimeSpan(23, 30, 0);
dt.Enabled = true;
bool canWakeToRun = false;
try
{
td.Settings.WakeToRun = true;
canWakeToRun = true;
}
// ReSharper disable once EmptyGeneralCatchClause
catch (Exception)
{
}
if (!canWakeToRun)
{
MessageBox.Show(
"Warning: There was an error creating a task that can wake your computer from sleep." +
" You can use the Task Scheduler to modify the task to wake up, or make sure your computer is awake at " +
startTime.ToShortTimeString());
}
// Add an action that will launch SkylineTester whenever the trigger fires
td.Actions.Add(new ExecAction(MainWindow.Exe, skytFile.Quote(), MainWindow.ExeDir));
// Register the task in the root folder
ts.RootFolder.RegisterTaskDefinition(NIGHTLY_TASK_NAME, td);
}
MainWindow.DeleteNightlyTask.Enabled = true;
}
private static string ToDetailStringInternal(DailyTrigger source)
{
var interval = source.DaysInterval;
var start = source.StartBoundary;
var str = interval == 1 ? string.Format(Resources.Word_TriggerDailyEveryday, start.ToString("t")) :
string.Format(Resources.Word_TriggerDailyRecurday, interval, start.ToString("t"));
return(str);
}
public override Trigger GetTrigger()
{
var dailyTrigger = new DailyTrigger(0);
var d = this.Date;
var t = this.Time;
dailyTrigger.StartBoundary = new DateTime(d.Year, d.Month, d.Day, t.Hour, t.Minute, t.Second);
return(dailyTrigger);
}
public void TestReadTriggers()
{
string xml =
@"<triggers>
<daily tag='restoreDB' timeOfDay='23:00'/>
<weekly tag='backupDB' timeOfDay='01:30' weekDays='monday,friday'/>
<hourly tag='delTempFiles' minutes='30'/>
<interval tag='dumpLog' interval='00:05:00'/>
<once tag='upgradeDB' dateTime='01/15/2007 23:00'/>
<monthly tag='archiveDB' monthDay='29' timeOfDay='23:00'/>
</triggers>";
IList <ITrigger> schedule = Trigger.ReadTriggers(xml);
Assert.IsNotNull(schedule);
Assert.AreEqual(6, schedule.Count);
Assert.IsAssignableFrom(typeof(DailyTrigger), schedule[0]);
Assert.IsAssignableFrom(typeof(WeeklyTrigger), schedule[1]);
Assert.IsAssignableFrom(typeof(HourlyTrigger), schedule[2]);
Assert.IsAssignableFrom(typeof(IntervalTrigger), schedule[3]);
Assert.IsAssignableFrom(typeof(OnceTrigger), schedule[4]);
Assert.IsAssignableFrom(typeof(MonthlyTrigger), schedule[5]);
DailyTrigger daily = schedule[0] as DailyTrigger;
Assert.AreEqual("restoreDB", daily.Tag);
Assert.AreEqual(TimeSpan.FromHours(23), daily.TimeOfDay);
WeeklyTrigger weekly = schedule[1] as WeeklyTrigger;
Assert.AreEqual("backupDB", weekly.Tag);
Assert.AreEqual(TimeSpan.FromMinutes(90), weekly.TimeOfDay);
HourlyTrigger hourly = schedule[2] as HourlyTrigger;
Assert.AreEqual("delTempFiles", hourly.Tag);
Assert.AreEqual(30, hourly.Minutes);
IntervalTrigger interval = schedule[3] as IntervalTrigger;
Assert.AreEqual("dumpLog", interval.Tag);
Assert.AreEqual(TimeSpan.FromMinutes(5), interval.Interval);
OnceTrigger once = schedule[4] as OnceTrigger;
Assert.AreEqual("upgradeDB", once.Tag);
Assert.AreEqual(new DateTime(2007, 1, 15, 23, 0, 0), once.DateTime);
MonthlyTrigger monthly = schedule[5] as MonthlyTrigger;
Assert.AreEqual("archiveDB", monthly.Tag);
Assert.AreEqual(29, monthly.MonthDay);
Assert.AreEqual(TimeSpan.FromHours(23), monthly.TimeOfDay);
}
