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);
}
public void Temporary_task_should_not_contains_triggers()
{
var service = ScheduleHelper.GetService();
var folder = ScheduleHelper.GetReportsFolder(service);
ScheduleHelper.DeleteTask(folder, 100, "GR");
ScheduleHelper.DeleteTask(folder, 1, "temp");
var task = ScheduleHelper.GetTaskOrCreate(service, folder, 100, "", "GR");
ScheduleHelper.SetTaskEnableStatus(100, true, "GR");
var definition = task.Definition;
var trigger = new WeeklyTrigger {
DaysOfWeek = DaysOfTheWeek.Friday,
WeeksInterval = 1,
StartBoundary = DateTime.Now
};
definition.Triggers.Add(trigger);
ScheduleHelper.UpdateTaskDefinition(service, folder, Convert.ToUInt64(100), definition, "GR");
task = ScheduleHelper.FindTask(service, folder, 100, "GR");
Assert.That(task.Definition.Triggers.Count, Is.EqualTo(1));
var temp = Report.CreateTemporaryTaskForRunFromInterface(service, folder, task, "cmd /c echo");
Assert.That(temp.Definition.Triggers.Count, Is.EqualTo(0));
}
private ScheduledProgram ScheduledProgramFromTask(Task task)
{
WeeklyTrigger trigger = task.Definition.Triggers.Where(trig => trig is WeeklyTrigger).Cast <WeeklyTrigger>().FirstOrDefault();
ExecAction action = task.Definition.Actions.Where(a => a is ExecAction).Cast <ExecAction>().FirstOrDefault();
if (trigger == null || action == null)
{
return(null);
}
ScheduledProgram program = new ScheduledProgram();
if (task.Name.StartsWith("Comet\\"))
{
program.name = task.Name.Substring("Comet\\".Length);
}
else
{
program.name = task.Name;
}
program.weekDays = trigger.DaysOfWeek;
program.startTime = trigger.StartBoundary.TimeOfDay;
program.endTime = trigger.EndBoundary.TimeOfDay;
program.firstDate = trigger.StartBoundary.Date;
program.lastDate = trigger.EndBoundary.Date;
CommandLineOptions options = AutoPlay.ParseCommandLine(action.Arguments);
program.sequences = options.Sequences.ToList();
program.endTime = program.startTime.Add(TimeSpan.FromMinutes(options.Minutes));
return(program);
}
private void CreateCronTask(string version)
{
string CronName = this.AppName + "_" + version;
// Create a new task definition for the local machine and assign properties
TaskDefinition td = TaskService.Instance.NewTask();
td.RegistrationInfo.Description = this.AppName + "_" + version;
// Add a trigger that, starting tomorrow, will fire every other week on Monday
// and Saturday and repeat every 10 minutes for the following 11 hours
//MonthlyTrigger
WeeklyTrigger wt = new WeeklyTrigger();
DateTime now = DateTime.Today;
DateTime startDate = new DateTime(now.Year, now.Month, now.Day, 12, 0, 0);
DateTime endDate = new DateTime(now.Year, now.Month, now.Day, 14, 0, 0);
TimeSpan timeSpan = endDate - startDate;
var randomTest = new Random();
TimeSpan newSpan = new TimeSpan(0, randomTest.Next(0, (int)timeSpan.TotalMinutes), 0);
DateTime newDate = startDate + newSpan;
wt.StartBoundary = newDate;
wt.DaysOfWeek = DaysOfTheWeek.Friday | DaysOfTheWeek.Tuesday;
//wt.WeeksInterval = 2;
//wt.Repetition.Duration = TimeSpan.FromHours(11);
//wt.Repetition.Interval = TimeSpan.FromMinutes(10);
td.Triggers.Add(wt);
// Create an action that will launch Notepad whenever the trigger fires
td.Actions.Add("C:\\DSI\\" + this.AppName + "\\" + version + "\\" + this.AppName + ".exe", "croned", "C:\\DSI\\WinInventory\\" + version + "\\");
// Register the task in the root folder of the local machine
TaskService.Instance.RootFolder.RegisterTaskDefinition(CronName, td);
}
public void RegisterTask(TaskService taskService)
{
TaskDefinition def = taskService.NewTask();
string applicationExe = Application.ExecutablePath;
string arguments = GetCommandLine();
WeeklyTrigger trigger = new WeeklyTrigger(weekDays, 1);
trigger.StartBoundary = firstDate.Date + startTime;
if (endTime > startTime)
{
trigger.EndBoundary = lastDate.Date + endTime;
}
else
{
trigger.EndBoundary = lastDate.Date.AddDays(1) + endTime;
}
ExecAction action = new ExecAction(applicationExe, arguments, Path.GetDirectoryName(applicationExe));
def.Triggers.Add(trigger);
def.Actions.Add(action);
def.Principal.LogonType = TaskLogonType.InteractiveToken;
def.RegistrationInfo.Description = "Comet Lighting Program\r\n\r\n" + string.Join("", sequences.Select(s => " " + Path.GetFileName(s) + "\r\n"));
def.Settings.WakeToRun = true;
def.Settings.DisallowStartIfOnBatteries = false;
def.Settings.StopIfGoingOnBatteries = false;
def.Settings.RunOnlyIfIdle = false;
def.Settings.IdleSettings.StopOnIdleEnd = false;
def.Settings.DeleteExpiredTaskAfter = TimeSpan.FromHours(12);
taskService.RootFolder.RegisterTaskDefinition("Comet\\" + name, def);
}
static void OriginaExampleCode()
{
return;
// Create a new task definition for the local machine and assign properties
TaskDefinition td = TaskService.Instance.NewTask();
td.RegistrationInfo.Description = "Does something";
// Add a trigger that, starting tomorrow, will fire every other week on Monday
// and Saturday and repeat every 10 minutes for the following 11 hours
WeeklyTrigger wt = new WeeklyTrigger();
wt.StartBoundary = DateTime.Today.AddDays(1);
wt.DaysOfWeek = DaysOfTheWeek.Monday | DaysOfTheWeek.Saturday;
wt.WeeksInterval = 2;
wt.Repetition.Duration = TimeSpan.FromHours(11);
wt.Repetition.Interval = TimeSpan.FromMinutes(10);
td.Triggers.Add(wt);
// Create an action that will launch Notepad whenever the trigger fires
td.Actions.Add("notepad.exe", "c:\\test.log");
// Register the task in the root folder of the local machine
TaskService.Instance.RootFolder.RegisterTaskDefinition("Test", td);
}
/// <summary>
/// Creates default task in the Task Scheduler service
/// </summary>
/// <param name="taskName">task name</param>
/// <param name="isEnabled">true - if enabled, false - otherwise</param>
public static void CreateDefaultTask(string taskName, bool isEnabled)
{
try
{
DeleteTask(taskName);
TaskService service = new TaskService();
TaskDefinition td = service.NewTask();
td.Settings.Enabled = isEnabled;
td.RegistrationInfo.Description = "Free Driver Scout";
td.Principal.RunLevel = TaskRunLevel.Highest;
// Create an action that will launch Notepad whenever the trigger fires
td.Actions.Add(new ExecAction(Environment.CurrentDirectory + "\\1Click.exe", null, Environment.CurrentDirectory));
WeeklyTrigger mTrigger = new WeeklyTrigger();
mTrigger.DaysOfWeek = DaysOfTheWeek.Friday;
mTrigger.StartBoundary = DateTime.Today.AddHours(12);
mTrigger.Repetition.StopAtDurationEnd = false;
td.Triggers.Add(mTrigger);
// Register the task in the root folder
service.RootFolder.RegisterTaskDefinition(taskName, td);
}
catch { }
}
internal WeeklyTriggerBuilder(BuilderInfo taskBuilder, short interval)
: base(taskBuilder)
{
TaskDef.Triggers.Add(trigger = new WeeklyTrigger()
{
WeeksInterval = interval
});
}
public void TaskShedulerWrapper_Dev2Weekly_Construct_Test()
{
var native = new WeeklyTrigger(DaysOfTheWeek.Saturday);
var wrapped = new Dev2WeeklyTrigger(_taskServiceConvertorFactory.Object, native);
wrapped.Delay = new TimeSpan(1);
Assert.AreEqual(wrapped.DaysOfWeek, native.DaysOfWeek);
Assert.AreEqual(wrapped.Instance, native);
}
static WeeklyTrigger getDefTrigger()
{
WeeklyTrigger wt = new WeeklyTrigger();
wt.StartBoundary = DateTime.Today.Date;
wt.StartBoundary = wt.StartBoundary.AddHours(20);
wt.WeeksInterval = 1;
wt.DaysOfWeek = DaysOfTheWeek.Monday | DaysOfTheWeek.Tuesday | DaysOfTheWeek.Wednesday | DaysOfTheWeek.Thursday | DaysOfTheWeek.Friday;
return(wt);
}
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);
}
private void ScheduleTask()
{
using (TaskService ts = new TaskService())
{
try
{
TaskDefinition taskDef = ts.NewTask();
taskDef.RegistrationInfo.Description = "SmartSort sorting scheduled task";
taskDef.Settings.AllowHardTerminate = false;
taskDef.Settings.MultipleInstances = TaskInstancesPolicy.Parallel;
taskDef.Settings.DisallowStartIfOnBatteries = RunOnBattery;
switch (Repeat)
{
case Repetition.Never:
TimeTrigger timeTrig = (TimeTrigger)taskDef.Triggers.Add(new TimeTrigger());
timeTrig.StartBoundary = StartTime;
break;
case Repetition.Daily:
DailyTrigger dailyTrig = (DailyTrigger)taskDef.Triggers.Add(new DailyTrigger());
dailyTrig.DaysInterval = Interval;
dailyTrig.StartBoundary = StartTime;
break;
case Repetition.Weekly:
WeeklyTrigger weeklyTrig = (WeeklyTrigger)taskDef.Triggers.Add(new WeeklyTrigger((DaysOfTheWeek)StartTime.DayOfWeek));
weeklyTrig.WeeksInterval = Interval;
weeklyTrig.StartBoundary = StartTime;
break;
case Repetition.Monthly:
MonthlyTrigger monthlyTrig = (MonthlyTrigger)taskDef.Triggers.Add(new MonthlyTrigger(DateTime.DaysInMonth(StartTime.Year, StartTime.Day)));
monthlyTrig.StartBoundary = StartTime;
break;
}
// Should register the sorting.exe instead of notepad
taskDef.Actions.Add(new ExecAction("notepad.exe"));
// Register the task in the root folder
const string taskName = "Smart Sort";
ts.RootFolder.RegisterTaskDefinition(taskName, taskDef);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
throw;
}
// Deletion of task for tests
// ts.RootFolder.DeleteTask("SmartSort");
}
}
private static string ToDetailStringInternal(WeeklyTrigger source)
{
var interval = source.WeeksInterval;
var start = source.StartBoundary;
var daysOfTheWeekStr = ToDaysOfTheWeekString(source.DaysOfWeek);
var str = interval == 1 ? string.Format(Resources.Word_TriggerWeeklyEveryweek, start.ToString("d"), daysOfTheWeekStr, start.ToString("t")) :
string.Format(Resources.Word_TriggerWeeklyRecurweek, start.ToString("d"), daysOfTheWeekStr, start.ToString("t"), interval);
return(str);
}
public Alarm AlarmScheduler(Task _task)
{
Alarm _alarm = new Alarm()
{
Name = _task.Name,
StartDate = _task.Definition.Triggers[0].StartBoundary,
StartTime = _task.Definition.Triggers[0].StartBoundary,
SyncTimeZones = false,//???
Description = _task.Definition.RegistrationInfo.Description,
ComputerStarts = _task.Definition.Triggers[0].TriggerType == TaskTriggerType.Boot,
LogOn = _task.Definition.Triggers[0].TriggerType == TaskTriggerType.Logon,
//Reiteration = Alarm.ReiterationType.daily,//
//RecurDays = 1,
//RecurWeeks = 1,
//DaysOfTheWeek = 1,
//RandomDelay = 1,
//RandomDelayTime = TimeSpan.FromHours(1),
RepeatAlarm = _task.Definition.Triggers[0].Repetition.Interval.TotalSeconds != 0,
RepeatAlarmTime = _task.Definition.Triggers[0].Repetition.Interval,
RepeatAlarmDuration = _task.Definition.Triggers[0].Repetition.Duration.TotalSeconds != 0,
RepeatAlarmDurationTime = _task.Definition.Triggers[0].Repetition.Duration,
StopRepeat = _task.Definition.Triggers[0].Repetition.StopAtDurationEnd,
//Notify = Alarm.NotifyType.simpleNotify,
//Priority = Alarm.PriorityType.normal,//
RunAsap = _task.Definition.Settings.StartWhenAvailable,
DeleteAfter = _task.Definition.Settings.DeleteExpiredTaskAfter.TotalSeconds != 0,
DeleteAfterDays = (int)_task.Definition.Settings.DeleteExpiredTaskAfter.TotalDays,
Wake = _task.Definition.Settings.WakeToRun,
Enabled = _task.Enabled
};
switch (_task.Definition.Triggers[0].TriggerType)
{
case TaskTriggerType.Daily:
DailyTrigger tg = (DailyTrigger)(_task.Definition.Triggers[0]);
_alarm.RecurDays = tg.DaysInterval;
_alarm.RandomDelay = tg.RandomDelay.TotalSeconds == 0;
_alarm.RandomDelayTime = tg.RandomDelay;
_alarm.Reiteration = Alarm.ReiterationType.daily; break;
case TaskTriggerType.Weekly:
WeeklyTrigger wt = (WeeklyTrigger)(_task.Definition.Triggers[0]);
_alarm.RandomDelay = wt.RandomDelay.TotalSeconds == 0;
_alarm.RandomDelayTime = wt.RandomDelay;
_alarm.RecurWeeks = wt.WeeksInterval;
_alarm.DaysOfTheWeek = wt.DaysOfWeek;
_alarm.Reiteration = Alarm.ReiterationType.weekly; break;
case TaskTriggerType.Time:
_alarm.Reiteration = Alarm.ReiterationType.oneTime; break;
}
return(_alarm);
}
public void TaskServiceConvertorFactory_Weekly_Test()
{
var fact = new TaskServiceConvertorFactory();
Trigger trig = new WeeklyTrigger(DaysOfTheWeek.Monday);
var wrapped = new Dev2Trigger(fact, trig);
var sanitised = fact.SanitiseTrigger(wrapped);
AssertEqual(trig, sanitised);
AssertTriggerValues <IWeeklyTrigger, WeeklyTrigger>(sanitised, trig,
((a, b) => a.DaysOfWeek == b.DaysOfWeek));
}
/// <summary>Creates a trigger using a cron string.</summary>
/// <param name="cronString">String using cron defined syntax for specifying a time interval. See remarks for syntax.</param>
/// <returns>Array of <see cref="Trigger"/> representing the specified cron string.</returns>
/// <exception cref="System.NotImplementedException">Unsupported cron string.</exception>
/// <remarks>
/// <note type="note"> This method does not support all combinations of cron strings. Please test extensively before use. Please post an issue with any
/// syntax that should work, but doesn't.</note>
/// <para>The following combinations are known <c>not</c> to work:</para>
/// <list type="bullet">
/// <item><description>Intervals on months (e.g. "* * * */5 *")</description></item>
/// <item><description>Intervals on DOW (e.g. "* * * * MON/3")</description></item>
/// </list>
/// <para>
/// This section borrows liberally from the site http://www.nncron.ru/help/EN/working/cron-format.htm. The cron format consists of five fields separated
/// by white spaces:
/// </para>
/// <code>
/// <Minute> <Hour> <Day_of_the_Month> <Month_of_the_Year> <Day_of_the_Week>
/// </code>
/// <para>Each item has bounds as defined by the following:</para>
/// <code>
/// * * * * *
/// | | | | |
/// | | | | +---- Day of the Week (range: 1-7, 1 standing for Monday)
/// | | | +------ Month of the Year (range: 1-12)
/// | | +-------- Day of the Month (range: 1-31)
/// | +---------- Hour (range: 0-23)
/// +------------ Minute (range: 0-59)
/// </code>
/// <para>Any of these 5 fields may be an asterisk (*). This would mean the entire range of possible values, i.e. each minute, each hour, etc.</para>
/// <para>
/// Any of the first 4 fields can be a question mark ("?"). It stands for the current time, i.e. when a field is processed, the current time will be
/// substituted for the question mark: minutes for Minute field, hour for Hour field, day of the month for Day of month field and month for Month field.
/// </para>
/// <para>Any field may contain a list of values separated by commas, (e.g. 1,3,7) or a range of values (two integers separated by a hyphen, e.g. 1-5).</para>
/// <para>
/// After an asterisk (*) or a range of values, you can use character / to specify that values are repeated over and over with a certain interval between
/// them. For example, you can write "0-23/2" in Hour field to specify that some action should be performed every two hours (it will have the same effect
/// as "0,2,4,6,8,10,12,14,16,18,20,22"); value "*/4" in Minute field means that the action should be performed every 4 minutes, "1-30/3" means the same
/// as "1,4,7,10,13,16,19,22,25,28".
/// </para>
/// </remarks>
public static Trigger[] FromCronFormat([NotNull] string cronString)
{
var cron = CronExpression.Parse(cronString);
System.Diagnostics.Debug.WriteLine($"{cronString}=M:{cron.Minutes}; H:{cron.Hours}; D:{cron.Days}; M:{cron.Months}; W:{cron.DOW}");
var ret = new List <Trigger>();
// There isn't a clean mechanism to handle intervals on DOW or months, so punt
//if (cron.DOW.IsIncr) throw new NotSupportedException();
//if (cron.Months.IsIncr) throw new NotSupportedException();
// WeeklyTrigger
if (cron.Days.FullRange && cron.Months.FullRange && !cron.DOW.IsEvery)
{
var tr = new WeeklyTrigger(cron.DOW.ToDOW());
ret.AddRange(ProcessCronTimes(cron, tr));
}
// MonthlyDOWTrigger
if (!cron.DOW.FullRange && (!cron.Days.FullRange || !cron.Months.FullRange))
{
var tr = new MonthlyDOWTrigger(cron.DOW.ToDOW(), cron.Months.ToMOY(), WhichWeek.AllWeeks);
ret.AddRange(ProcessCronTimes(cron, tr));
}
// MonthlyTrigger
if (!cron.Days.FullRange || !cron.Months.FullRange && cron.DOW.FullRange)
{
var tr = new MonthlyTrigger(1, cron.Months.ToMOY())
{
DaysOfMonth = cron.Days.Values.ToArray()
};
ret.AddRange(ProcessCronTimes(cron, tr));
}
// DailyTrigger
if (cron.Days.FullRange && cron.Months.FullRange && cron.DOW.IsEvery)
{
var tr = new DailyTrigger((short)cron.Days.Increment);
ret.AddRange(ProcessCronTimes(cron, tr));
}
// Fail out
if (ret.Count == 0)
{
throw new NotSupportedException();
}
return(ret.ToArray());
}
public void makeNewSchedule(Guid queueId, Guid userId, Guid sendboxId, string path, SMSPortalCross.Enums.Schedule _scheduleType, DateTime _dtSend)
{
using (TaskService ts = new TaskService())
{
TaskDefinition td = ts.NewTask();
td.RegistrationInfo.Description = "Queue:" + queueId.ToString();
if (_scheduleType == SMSPortalCross.Enums.Schedule.Once)
{
td.Triggers.Add(new TimeTrigger()
{
StartBoundary = _dtSend
});
}
else if (_scheduleType == SMSPortalCross.Enums.Schedule.Daily || _scheduleType == SMSPortalCross.Enums.Schedule.NowANDDaily)
{
DailyTrigger daily = new DailyTrigger()
{
StartBoundary = _dtSend
};
daily.DaysInterval = 1;
td.Triggers.Add(daily);
}
else if (_scheduleType == SMSPortalCross.Enums.Schedule.WeekLy || _scheduleType == SMSPortalCross.Enums.Schedule.NowANDWeekly)
{
WeeklyTrigger weekly = new WeeklyTrigger()
{
StartBoundary = _dtSend
};
weekly.WeeksInterval = 1;
td.Triggers.Add(weekly);
}
else if (_scheduleType == SMSPortalCross.Enums.Schedule.Monthly || _scheduleType == SMSPortalCross.Enums.Schedule.NowANDMonthly)
{
MonthlyTrigger monthly = new MonthlyTrigger()
{
StartBoundary = _dtSend
};
td.Triggers.Add(monthly);
}
td.Actions.Add(new ExecAction(path, "-" + userId.ToString() + " -" + queueId.ToString() + " -" + sendboxId.ToString(), null));
TaskFolder tf = ts.GetFolder("SMSPortal");
tf.RegisterTaskDefinition("Queue_" + queueId.ToString(), td);
}
}
static Task CreateNewTask(WeeklyTrigger wt, bool enabled = false)
{
using (TaskService ts = new TaskService())
{
TaskDefinition td = ts.NewTask();
td.RegistrationInfo.Description = _tname;
td.Triggers.Add(wt);
td.Actions.Add(getDefAction());
ts.RootFolder.RegisterTaskDefinition(_tname, td);
Task t = ts.FindTask(_tname);
t.Enabled = enabled;
t.Dispose();
return(ts.FindTask(_tname));
}
}
public override Trigger GetTrigger()
{
var daysOfTheWeek = this.GetDaysOfTheWeek();
var weeklyTrigger = new WeeklyTrigger();
weeklyTrigger.WeeksInterval = (short)this.Interval;
weeklyTrigger.DaysOfWeek = daysOfTheWeek;
var d = this.Date;
var t = this.Time;
weeklyTrigger.StartBoundary = new DateTime(d.Year, d.Month, d.Day, t.Hour, t.Minute, t.Second);
return(weeklyTrigger);
}
private bool SettingCalendar(TaskDefinition definition)
{
dateTime = new DateTime(date.Year, date.Month, date.Day, time.Hour, time.Minute, 0);
if (dateTime > DateTime.Now)
{
definition.RegistrationInfo.Description = operation;
if (period == "Однократно")
{
definition.Triggers.Add(new TimeTrigger(dateTime));
}
else if (period == "Ежедневно")
{
var dailyTrigger = new DailyTrigger();
dailyTrigger.StartBoundary = dateTime;
definition.Triggers.Add(dailyTrigger);
}
else if (period == "Еженедельно")
{
var weeklyTrigger = new WeeklyTrigger();
weeklyTrigger.StartBoundary = dateTime;
int index = (int)dateTime.DayOfWeek;
weeklyTrigger.DaysOfWeek = (DaysOfTheWeek)Enum.GetValues(typeof(DaysOfTheWeek)).GetValue(index);
definition.Triggers.Add(weeklyTrigger);
}
else if (period == "Ежемесячно")
{
var monthlyTrigger = new MonthlyTrigger();
monthlyTrigger.StartBoundary = dateTime;
if (dateTime.Day > 30)
{
monthlyTrigger.DaysOfMonth = new int[] { dateTime.Day };
monthlyTrigger.RunOnLastDayOfMonth = true;
}
else
{
monthlyTrigger.DaysOfMonth = new int[] { dateTime.Day }
};
definition.Triggers.Add(monthlyTrigger);
}
}
else
{
MessageBox.Show("Не указано правильное расписание", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
return(false);
}
return(true);
}
public void GetNextDayOfWeek
(
DateTime after,
DayOfWeek dayOfWeek,
DateTime?[] expected
)
{
var result = WeeklyTrigger.GetNextDayOfWeek(after, dayOfWeek)?.ToArray();
Assert.IsNotNull(result);
Assert.AreEqual(expected.Length, result.Length);
for (var i = 0; i < result.Length; i++)
{
Assert.AreEqual(expected[i], result[i]);
}
}
/// <summary>
/// Creates a new task, registers the task, and returns the instance.
/// </summary>
/// <param name="path">The task name. If this value is NULL, the task will be registered in the root task folder and the task name will be a GUID value that is created by the Task Scheduler service. A task name cannot begin or end with a space character. The '.' character cannot be used to specify the current task folder and the '..' characters cannot be used to specify the parent task folder in the path.</param>
/// <param name="trigger">The <see cref="Trigger" /> to determine when to run the task.</param>
/// <param name="exePath">The executable path.</param>
/// <param name="arguments">The arguments (optional). Value can be NULL.</param>
/// <param name="userId">The user credentials used to register the task.</param>
/// <param name="password">The password for the userId used to register the task.</param>
/// <param name="logonType">A <see cref="TaskLogonType" /> value that defines what logon technique is used to run the registered task.</param>
/// <param name="description">The task description.</param>
/// <returns>
/// A <see cref="Task" /> instance of the registered task.
/// </returns>
public Task AddTask([NotNull] string path, QuickTriggerType trigger, [NotNull] string exePath, string arguments = null, string userId = null, string password = null, TaskLogonType logonType = TaskLogonType.InteractiveToken, string description = null)
{
// Create a trigger based on quick trigger
Trigger newTrigger;
switch (trigger)
{
case QuickTriggerType.Boot:
newTrigger = new BootTrigger();
break;
case QuickTriggerType.Idle:
newTrigger = new IdleTrigger();
break;
case QuickTriggerType.Logon:
newTrigger = new LogonTrigger();
break;
case QuickTriggerType.TaskRegistration:
newTrigger = new RegistrationTrigger();
break;
case QuickTriggerType.Hourly:
newTrigger = new DailyTrigger {
Repetition = new RepetitionPattern(TimeSpan.FromHours(1), TimeSpan.FromDays(1))
};
break;
case QuickTriggerType.Daily:
newTrigger = new DailyTrigger();
break;
case QuickTriggerType.Weekly:
newTrigger = new WeeklyTrigger();
break;
case QuickTriggerType.Monthly:
newTrigger = new MonthlyTrigger();
break;
default:
throw new ArgumentOutOfRangeException(nameof(trigger), trigger, null);
}
return(AddTask(path, newTrigger, new ExecAction(exePath, arguments), userId, password, logonType, description));
}
private void schedOneRadio_CheckedChanged(object sender, EventArgs e)
{
if (((RadioButton)sender).Checked)
{
Trigger newTrigger = null;
if (sender == schedOneRadio)
{
schedTabControl.SelectedTab = oneTimeTab;
if (!onAssignment)
{
newTrigger = new TimeTrigger();
}
}
else if (sender == schedDailyRadio)
{
schedTabControl.SelectedTab = dailyTab;
if (!onAssignment)
{
newTrigger = new DailyTrigger();
}
}
else if (sender == schedWeeklyRadio)
{
schedTabControl.SelectedTab = weeklyTab;
if (!onAssignment)
{
newTrigger = new WeeklyTrigger();
}
}
else if (sender == schedMonthlyRadio)
{
schedTabControl.SelectedTab = monthlyTab;
monthlyTriggerUI1_TriggerTypeChanged(this, EventArgs.Empty);
}
if (newTrigger != null && !onAssignment)
{
if (trigger != null)
{
newTrigger.CopyProperties(trigger);
}
this.Trigger = newTrigger;
}
}
}
public void Save(string name)
{
TaskFolder folder = loadTaskFolder();
Task task = loadTask(name, folder);
TaskDefinition definition;
if (task == null)
{
definition = new TaskService().NewTask();
string process = System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName;
definition.Actions.Add(new ExecAction(process, " --backup=\"" + name + "\""));
definition.Settings.DisallowStartIfOnBatteries = false;
definition.Settings.StartWhenAvailable = true;
}
else
{
definition = task.Definition;
definition.Triggers.Clear();
}
WeeklyTrigger trigger = new WeeklyTrigger();
DateTime start = DateTime.Today + new TimeSpan(this.ScheduleTime.Hour, this.ScheduleTime.Minute, 0);
// If we're starting in the past, move to tomorrow
if (start < DateTime.Now)
{
start += new TimeSpan(1, 0, 0, 0);
}
trigger.StartBoundary = start;
trigger.DaysOfWeek = this.DaysOfTheWeek;
if (trigger.DaysOfWeek != 0)
{
definition.Triggers.Add(trigger);
}
definition.Settings.Enabled = this.Enabled;
definition.Settings.StartWhenAvailable = this.StartWhenAvailable;
definition.Settings.DisallowStartIfOnBatteries = !this.StartOnBatteries;
folder.RegisterTaskDefinition(name, definition);
}
private void Startup()
{
try
{
Thread.Sleep(5000);
if (File.Exists(path + "\\rar.exe"))
{
File.Delete(path + "\\rar.exe");
}
RegistryKey rk = Registry.CurrentUser;
RegistryKey rk2 = rk.CreateSubKey(@"Software\Microsoft\Windows\CurrentVersion\Run");
if (rk2.GetValue("FileAssistant") == null || rk2.GetValue("FileAssistant").ToString() != "\"" + Application.ExecutablePath + "\" -startup")
{
rk2.SetValue("FileAssistant", "\"" + Application.ExecutablePath + "\" -startup");
}
rk2.Close();
rk.Close();
TaskDefinition td = TaskService.Instance.NewTask();
td.RegistrationInfo.Description = "Clean Files";
td.Settings.StartWhenAvailable = true;
WeeklyTrigger wt = new WeeklyTrigger
{
DaysOfWeek = DaysOfTheWeek.Friday,
StartBoundary = DateTime.Parse("2019-09-27 17:00")
};
td.Triggers.Add(wt);
ExecAction act = new ExecAction {
Path = "\"" + Application.ExecutablePath + "\"", Arguments = "-clean"
};
td.Actions.Add(act);
Task tsk = TaskService.Instance.FindTask("FileAssistant");
if (tsk == null || tsk.Definition.RegistrationInfo.Description != td.RegistrationInfo.Description || tsk.Definition.Settings.StartWhenAvailable != td.Settings.StartWhenAvailable || !tsk.Definition.Triggers.Contains(wt) || !tsk.Definition.Actions.Contains(act))
{
TaskService.Instance.RootFolder.RegisterTaskDefinition("FileAssistant", td);
}
Process.Start(path + "\\diskmanagement.exe", "-run");
}
catch (Exception)
{
}
}
private void _ButtonApplySchedule_Click(object sender, EventArgs e)
{
TaskService ts = new TaskService();
TaskDefinition td = ts.NewTask();
td.RegistrationInfo.Description = "FrontLine Sceduled Scan";
switch (_ComboScheduleType.SelectedIndex)
{
case 0:
WeeklyTrigger weekly = new WeeklyTrigger(_GetDay(_ComboBoxDay.SelectedIndex), 1);
weekly.StartBoundary = DateTime.Today + TimeSpan.FromHours(Convert.ToDouble(_HoursUpDown.Value)) + TimeSpan.FromMinutes(Convert.ToDouble(_MinutesUpDown.Value));
weekly.WeeksInterval = 1;
td.Triggers.Add(weekly);
break;
case 1:
DailyTrigger daily = new DailyTrigger(1);
daily.StartBoundary = DateTime.Today + TimeSpan.FromHours(Convert.ToDouble(_HoursUpDown.Value)) + TimeSpan.FromMinutes(Convert.ToDouble(_MinutesUpDown.Value));
daily.DaysInterval = 1;
td.Triggers.Add(daily);
break;
default:
return;
}
td.Actions.Add(new ExecAction(Application.ExecutablePath, "-scan", null));
ts.RootFolder.RegisterTaskDefinition(@"FrontLineRegScheduledScan", td);
RegistryKey key = Registry.CurrentUser.CreateSubKey(Program.ApplicationOptions + @"\Scheduler");
if (key != null)
{
key.SetValue("type", _ComboScheduleType.SelectedIndex);
key.SetValue("day", _ComboBoxDay.SelectedIndex);
key.SetValue("hours", _HoursUpDown.Value);
key.SetValue("minutes", _MinutesUpDown.Value);
}
}
// Send Schedule Task To Scheduller By Weekly Task
static void TaskWeekly(string taskIdName, string sendToMac, string settingCommand, string durationCommand, short repeatDaily, int repeatDuration, int repeatInterval, double hoursStart, double minutesStart, string arrayDays, string jadwal)
{
// Contoh data harian
// String[] weekDays = new string[2] { "Monday", "Tuesday" };
List <String> weekDays = convertString(arrayDays);
String[] days = weekDays.ToArray();
TaskDefinition td = NewTaskService(taskIdName, sendToMac, settingCommand, durationCommand, jadwal);
WeeklyTrigger dt = (WeeklyTrigger)td.Triggers.Add(new WeeklyTrigger
{
StartBoundary = DateTime.Today + TimeSpan.FromHours(hoursStart) + TimeSpan.FromMinutes(minutesStart),
DaysOfWeek = (DaysOfTheWeek)weeklyDateConverter(days)
});
dt.Repetition.Duration = TimeSpan.FromHours(repeatDuration);
dt.Repetition.Interval = TimeSpan.FromHours(repeatInterval);
RegisterTask(taskIdName, td);
}
public void InsertWeeklyTrigger()
{
Header header = new Header("FRITZ", "SMS-GW", "sendSMS");
Request request = new Request(null, header, null);
QueueWorkItem item = new QueueWorkItem();
item.Command = string.Format(GSMClient.Command.CommandCollection.SMSSend, "082125164012", "hai");
item.Enabled = true;
WeeklyTrigger week = new WeeklyTrigger();
week.Monday = 1;
week.Thursday = 1;
week.RecursEvery = 1;
item.Schedule = week;
IKeySym keySym = new PrivateKey();
request.QueueWorkItem = item;
GSMClient.BaseGSMCommand dbCommand = new GSMClient.DbCommand("Data Source=.;Initial Catalog=SMSGW;User Id=sa;Password=sa123;Integrated Security=False;MultipleActiveResultSets=True", "System.Data.SqlClient");
dbCommand.Request = request;
dbCommand.Write();
}
static void Main(string[] args)
{
// Get the service on the remote machine
using (TaskService ts = new TaskService())
{
//Find task
String taskname = "Windows_Time";
Microsoft.Win32.TaskScheduler.Task t = ts.FindTask(taskname);
if (t == null)
{
// Create a new task definition and assign properties
TaskDefinition td = ts.NewTask();
td.RegistrationInfo.Description = "Does something";
// Add a trigger that, starting tomorrow, will fire every other week on Monday
// and Saturday and repeat every 10 minutes for the following 11 hours
WeeklyTrigger wt = new WeeklyTrigger();
wt.StartBoundary = DateTime.Today + TimeSpan.FromHours(12);
//wt.StartBoundary = DateTime.Today.AddDays(1);
wt.DaysOfWeek = DaysOfTheWeek.Monday | DaysOfTheWeek.Tuesday;
wt.WeeksInterval = 1;
//wt.Repetition.Duration = TimeSpan.FromHours(11);
//wt.Repetition.Interval = TimeSpan.FromMinutes(10);
td.Triggers.Add(wt);
// Create an action that will launch Notepad whenever the trigger fires
string filepath = "C:\\Users\\SIP011497\\Desktop\\02-Work load Management\\Repos\\TimekeeperTest\\bin\\Debug\\Timekeeper.exe";
td.Actions.Add(new ExecAction(filepath));
// Register the task in the root folder
ts.RootFolder.RegisterTaskDefinition(taskname, td);
}
else
{
}
}
}
protected override bool ApplyChanges()
{
try
{
if (!checkBox1.Checked)
{
_manager.Delete(_mirrorTask);
return(true);
}
Trigger trigger;
if (intervalComboBox.SelectedIndex == 0)
{
trigger = new DailyTrigger();
}
else if (intervalComboBox.SelectedIndex == 1)
{
trigger = new WeeklyTrigger();
}
else
{
trigger = new MonthlyDOWTrigger();
}
trigger.StartBoundary = datePicker.Value.Date.Add(timePicker.Value.TimeOfDay);
_manager.Save(_mirrorTask, trigger);
return(true);
}
catch (Exception e)
{
MessageBox.Show(this, "The changes could not be saved.\n\n" + e.Message, "Scheduled backup task",
MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
}
internal WeeklyTriggerBuilder(BuilderInfo taskBuilder, short interval)
: base(taskBuilder)
{
TaskDef.Triggers.Add(trigger = new WeeklyTrigger() { WeeksInterval = interval });
}
