private void StartNew(DateTime startTime, string action, string parameters, string taskName) { using (TaskService ts = new TaskService()) { TaskDefinition td = ts.NewTask(); td.Principal.RunLevel = TaskRunLevel.Highest; td.RegistrationInfo.Description = "instaprinter"; td.Triggers.Add(new TimeTrigger(startTime)); td.Actions.Add(new ExecAction(action, parameters)); // Retrieve the task, change the trigger and re-register it Task t = ts.GetTask(taskName); if (t != null) { td = t.Definition; td.Triggers[0].StartBoundary = startTime; ts.RootFolder.RegisterTaskDefinition(taskName, td); } else { ts.RootFolder.RegisterTaskDefinition(taskName, td); } } }
public void AddTask(int min, int hour, bool restart) { var taskService = new TaskService(); //Create task definition var taskDefinition = taskService.NewTask(); taskDefinition.RegistrationInfo.Description = min + "@" + hour + "@" + ((restart) ? "r" : "s"); taskDefinition.Principal.UserId = "SYSTEM"; var trigger = new DailyTrigger { StartBoundary = DateTime.Today + TimeSpan.FromHours(hour) + TimeSpan.FromMinutes(min) }; taskDefinition.Triggers.Add(trigger); //Create task action var fileName = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + @"Power.exe"); taskDefinition.Actions.Add(restart ? new ExecAction(fileName, "reboot \"This computer is going to reboot.\"") : new ExecAction(fileName, "shutdown \"This computer is going to shutdown to save power.\"")); taskDefinition.Settings.AllowDemandStart = false; taskDefinition.Settings.DisallowStartIfOnBatteries = false; taskDefinition.Settings.DisallowStartOnRemoteAppSession = false; taskDefinition.Settings.StopIfGoingOnBatteries = false; taskService.RootFolder.RegisterTaskDefinition(@"FOG\" + taskDefinition.RegistrationInfo.Description, taskDefinition); taskService.Dispose(); }
internal static void FindTask(TaskService ts, System.IO.TextWriter output, params string[] arg) { try { Task t = ts.FindTask(arg[0]); if (t == null) output.WriteLine(string.Format("Task '{0}' not found.", arg[0])); else { output.WriteLine(string.Format("Task '{0}' found. Created on {1:g} and last run on {2:g}.", t.Name, t.Definition.RegistrationInfo.Date, t.LastRunTime)); if (t.Definition.Triggers.ContainsType(typeof(CustomTrigger))) { foreach (var tr in t.Definition.Triggers) { CustomTrigger ct = tr as CustomTrigger; if (ct != null && ct.Properties.Count > 0) { output.WriteLine("Custom Trigger Properties:"); int i = 0; foreach (var name in ct.Properties.Names) output.WriteLine("{0}. {1} = {2}", ++i, name, ct.Properties[name]); } } } } } catch (Exception ex) { output.WriteLine(ex.ToString()); } }
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 static bool IsAutostart() { using (TaskService ts = new TaskService()) { Microsoft.Win32.TaskScheduler.Task task = ts.GetTask("Touchmote"); return task != null; } }
public void DeleteTask(string name) { using (TaskService ts = new TaskService()) { if (ts.GetTask(name) != null) { ts.RootFolder.DeleteTask(name); } } }
public static void modifyTask(DailyTrigger dt) { using (TaskService ts = new TaskService()) { Task t = ts.GetTask("taxiService"); TaskDefinition td = t.Definition; td.Triggers.Add(dt); ts.RootFolder.RegisterTaskDefinition(@"taxiService", td); } }
public static void RunTask() { using (TaskService ts = new TaskService()) { Task t = ts.GetTask("CudaAdministratorSkipUAC"); if (t != null) { t.Run(); } } }
public void CreateTask(TaskService service) { var path = Application.StartupPath; try { var task = service.AddTask("SP_Field_Monitor", new DailyTrigger() { StartBoundary = DateTime.Parse("10:00:00 AM") }, new ExecAction(path + "\\SPFieldMonitor.exe", "-user [email protected] -password \"!thisisatestitisonlyatest!\"", path), "SYSTEM"); var trigger = new DailyTrigger() { StartBoundary = DateTime.Parse("11:00:00 AM") }; trigger.Repetition.Duration = TimeSpan.FromHours(22); trigger.Repetition.Interval = TimeSpan.FromHours(1); var checkTask = service.AddTask("SP_Field_Monitor_Check", trigger, new ExecAction(path + "\\SPFieldMonitor.exe", "-user [email protected] -password \"!thisisatestitisonlyatest!\" -check", path), "SYSTEM"); MessageBox.Show( "The daily task has been scheduled.\nIf you move any of the Field Monitor executables, you will need to click this button again to reschedule the task.", "Success!", MessageBoxButtons.OK, MessageBoxIcon.Asterisk); } catch (UnauthorizedAccessException) { MessageBox.Show( "You need administrator privileges to schedule this task. Try running the program as an administrator.", "Insufficient Access Rights", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
public void Install(IEnumerable<RepetitiveTask> tasks) { tasks = tasks.ToList(); using (var ts = new TaskService()) { var path = Assembly.GetEntryAssembly().Location; foreach (var t in tasks) { var definition = ts.NewTask(); definition.Settings.Enabled = true; definition.RegistrationInfo.Description = t.Description; AddTrigger(definition, t); definition.Actions.Add(new ExecAction(t.Path ?? path, t.Parameters, Path.GetDirectoryName(path))); ts.RootFolder.RegisterTaskDefinition( t.Name, definition, TaskCreation.CreateOrUpdate, "SYSTEM", null, TaskLogonType.ServiceAccount); OnTaskInstalledEvent(new TaskEventArgs { Task = t }); } } }
/// <summary> /// Initializes a new instance of the <see cref="TaskEditDialog"/> class. /// </summary> /// <param name="service">A <see cref="TaskService"/> instance.</param> /// <param name="td">An optional <see cref="TaskDefinition"/>. Leaving null creates a new task.</param> /// <param name="editable">If set to <c>true</c> the task will be editable in the dialog.</param> /// <param name="registerOnAccept">If set to <c>true</c> the task will be registered when Ok is pressed.</param> public TaskEditDialog(TaskService service, TaskDefinition td = null, bool editable = true, bool registerOnAccept = true) { InitializeComponent(); this.Editable = editable; this.Initialize(service, td); this.RegisterTaskOnAccept = registerOnAccept; }
public void RemoveTask(int min, int hour, bool restart) { var taskService = new TaskService(); var task = min + "@" + hour + "@" + ((restart) ? "r" : "s"); taskService.RootFolder.DeleteTask(@"FOG\" + task); taskService.Dispose(); }
/// <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 { } }
public static void DisableStartupTask() { using (TaskService _taskService = new TaskService()) { _taskService.RootFolder.DeleteTask(_taskName, false); } }
public void TaskShedulerWrapper_Dev2TaskSettings_PassThrough() { var service = new TaskService(); var task =service.NewTask(); var settings = new Dev2TaskSettings(task.Settings); settings.AllowDemandStart = true; settings.DeleteExpiredTaskAfter = new TimeSpan(2); settings.AllowHardTerminate = true; settings.DisallowStartOnRemoteAppSession = true; settings.Enabled = false; settings.ExecutionTimeLimit = new TimeSpan(3); settings.Hidden = true; settings.MultipleInstances = TaskInstancesPolicy.IgnoreNew; settings.Priority = ProcessPriorityClass.High; settings.RestartCount = 3; settings.StartWhenAvailable = false; settings.WakeToRun = true; var native = task.Settings; Assert.AreEqual(settings.AllowDemandStart,native.AllowDemandStart); Assert.AreEqual(settings.AllowHardTerminate,native.AllowHardTerminate); Assert.AreEqual(settings.DeleteExpiredTaskAfter,native.DeleteExpiredTaskAfter); Assert.AreEqual(settings.DisallowStartOnRemoteAppSession,native.DisallowStartIfOnBatteries); Assert.AreEqual(settings.Enabled,settings.Enabled); Assert.AreEqual(settings.ExecutionTimeLimit,native.ExecutionTimeLimit); Assert.AreEqual(settings.ExecutionTimeLimit,native.ExecutionTimeLimit); Assert.AreEqual(settings.Hidden,native.Hidden); Assert.AreEqual(settings.MultipleInstances,native.MultipleInstances); Assert.AreEqual(settings.RestartCount,native.RestartCount); Assert.AreEqual(settings.Priority,native.Priority); Assert.AreEqual(settings.RestartInterval,native.RestartInterval); Assert.AreEqual(settings.StartWhenAvailable,native.StartWhenAvailable); Assert.AreEqual(settings.WakeToRun,native.WakeToRun); }
public void clearSchedules() { string strTaskID = ""; try { // Get the service on the local machine TaskService ts = new TaskService(); // Delete Schedules DataTable dt = this.GetSchedules(1); foreach (DataRow dr in dt.Rows) { strTaskID = dr["TaskID"].ToString(); if (ts.FindTask(strTaskID, true) != null) { // Remove the task we just created ts.RootFolder.DeleteTask(strTaskID); } // Delete schedules follow taskid this.DeleleSchedules(strTaskID); } } catch (Exception ex) { throw ex; } }
public bool CreateOrActivate(String TaskName, String FullExecuteableFileName, TimeSpan RetryIntervall) { //if (!IsAdministrator()) // return false; using (TaskService taskService = new TaskService()) { Task task = taskService.FindTask(TaskName); if (task == null) { TaskDefinition taskDefinition = CreateTask(taskService, TaskName, RetryIntervall); taskDefinition.Actions.Add(new ExecAction(FullExecuteableFileName)); taskDefinition.RegistrationInfo.Description = $"WPMedia created Task for " + $"{Path.GetFileNameWithoutExtension(FullExecuteableFileName)}"; taskDefinition.Settings.MultipleInstances = TaskInstancesPolicy.IgnoreNew; taskDefinition.Settings.AllowDemandStart = true; taskDefinition.Settings.AllowHardTerminate = false; taskDefinition.Settings.DisallowStartIfOnBatteries = false; taskDefinition.RegistrationInfo.Author = "WPMediaAutoRegistration"; if (taskDefinition.Validate()) task = taskService.RootFolder.RegisterTaskDefinition(TaskName, taskDefinition); else throw new Exception($"{TaskName} Scheduling for {FullExecuteableFileName} failed"); } task.Enabled = true; } return true; }
public static bool StartupTaskExists() { using (TaskService _taskService = new TaskService()) { return _taskService.FindTask(_taskName) != null; } }
public void SaveTask(string name, string time, string day, string route, int posicion, string accion) { using (TaskService ts = new TaskService()) { TaskDefinition td = ts.NewTask(); td.RegistrationInfo.Description = accion; WeeklyTrigger week = new WeeklyTrigger(); week.StartBoundary = Convert.ToDateTime(DateTime.Today.ToShortDateString() + " " + time); week.WeeksInterval = 1; switch (day) { case "Monday": week.DaysOfWeek = Microsoft.Win32.TaskScheduler.DaysOfTheWeek.Monday; break; case "Tuesday": week.DaysOfWeek = Microsoft.Win32.TaskScheduler.DaysOfTheWeek.Tuesday; break; case "Wednesday": week.DaysOfWeek = Microsoft.Win32.TaskScheduler.DaysOfTheWeek.Wednesday; break; case "Thursday": week.DaysOfWeek = Microsoft.Win32.TaskScheduler.DaysOfTheWeek.Thursday; break; case "Friday": week.DaysOfWeek = Microsoft.Win32.TaskScheduler.DaysOfTheWeek.Friday; break; case "Saturday": week.DaysOfWeek = Microsoft.Win32.TaskScheduler.DaysOfTheWeek.Saturday; break; case "Sunday": week.DaysOfWeek = Microsoft.Win32.TaskScheduler.DaysOfTheWeek.Sunday; break; default: break; } td.Triggers.Add(week); string turn_on; if (chkTurnOn.Checked) { turn_on = " T"; } else { turn_on = " F"; } if (posicion != -1) { td.Actions.Add(new ExecAction(route, posicion.ToString() + turn_on, null)); } else { td.Actions.Add(new ExecAction(route, posicion.ToString() + turn_on, null)); } ts.RootFolder.RegisterTaskDefinition(name, td); } }
public List <ComputerProgram> GetScheduledTasks() { using (WinTaskScheduler.TaskService ts = new WinTaskScheduler.TaskService()) { EnumFolderTasks(ts.RootFolder); } return(Tasks); }
public void Init() { _service = new TaskService(); _folder = _service.RootFolder.SubFolders.Any(a => a.Name == "WarewolfTestFolder") ? _service.GetFolder("WarewolfTestFolder") : _service.RootFolder.CreateFolder("WarewolfTestFolder"); var task = _service.NewTask(); task.Actions.Add(new ExecAction("Notepad.exe")); _folder.RegisterTaskDefinition("TestTask", task); }
private void CheckTaskTimer() { using (var ts = new TaskService()) { DateTime taskRuntime = ts.RootFolder.Tasks.Single(t => t.Name.Equals("GitUpdater")).NextRunTime; LoggingSection.Items.Add("Next scheduled update: " + taskRuntime.ToString()); } }
public void Init() { _taskServiceConvertorFactory = new Mock<ITaskServiceConvertorFactory>(); _nativeService = new TaskService();//localhost _nativeTask = _nativeService.NewTask();//actually a definition , not an actual task _nativeInstance = _nativeTask.Actions; }
public static bool PersistTask(bool startAtLogon, bool startForAllUsers) { WinTasks.TaskService ts = new WinTasks.TaskService(); try { WindowsIdentity currentIdentity = WindowsIdentity.GetCurrent(); bool isElevated = (new WindowsPrincipal(currentIdentity).IsInRole(WindowsBuiltInRole.Administrator)); WinTasks.Task task = ts.FindTask(Application.ProductName, false); if (startAtLogon) { if (startForAllUsers && !isElevated) { return PersistTaskElevated(startAtLogon, startForAllUsers); } else { WinTasks.LogonTrigger trigger = (WinTasks.LogonTrigger)WinTasks.LogonTrigger.CreateTrigger(WinTasks.TaskTriggerType.Logon); trigger.Enabled = true; trigger.StartBoundary = DateTime.Today; if (startForAllUsers) trigger.UserId = null; else trigger.UserId = currentIdentity.Name; WinTasks.ExecAction action = (WinTasks.ExecAction)WinTasks.ExecAction.CreateAction(WinTasks.TaskActionType.Execute); action.Path = Application.ExecutablePath; action.WorkingDirectory = System.IO.Path.GetDirectoryName(Application.ExecutablePath); if (task == null) { task = ts.AddTask(Application.ProductName, trigger, action, currentIdentity.Name); } else { task.Definition.Triggers.Clear(); task.Definition.Triggers.Add(trigger); task.Definition.Actions.Clear(); task.Definition.Actions.Add(action); task.RegisterChanges(); } } } else if (task != null) { ts.GetFolder("\\").DeleteTask(task.Name); } } catch { return false; } finally { ts.Dispose(); } return true; }
private void btnInput_Click(object sender, EventArgs e) { string strTaskID = ""; string appPath = System.Configuration.ConfigurationManager.AppSettings["AutoGetOdds"]; Application.DoEvents(); Cursor.Current = Cursors.WaitCursor; try { // Get the service on the local machine TaskService ts = new TaskService(); // Delete Schedules DataTable dt = oddBO.GetSchedules(1); foreach (DataRow dr in dt.Rows) { strTaskID = dr["TaskID"].ToString(); if (ts.FindTask(strTaskID, true) != null) { // Remove the task we just created ts.RootFolder.DeleteTask(strTaskID); } // Delete schedules follow taskid oddBO.DeleleSchedules(strTaskID); } DateTime currDate = dtpDate.Value; // Create Schedules dt = oddBO.GetSchedules(0, currDate); foreach (DataRow dr in dt.Rows) { strTaskID = dr["TaskID"].ToString(); // Create a new task definition and assign properties TaskDefinition td = ts.NewTask(); Trigger t = new TimeTrigger(); t.StartBoundary = Convert.ToDateTime(dr["RunTime"].ToString()); td.RegistrationInfo.Description = "Get odd at " + dr["RunTime"].ToString(); // Create a trigger that will fire the task at this time every other day td.Triggers.Add(t); // Create an action that will launch Notepad whenever the trigger fires td.Actions.Add(new ExecAction(appPath, "\"" + strTaskID + "\"", null)); // Register the task in the root folder ts.RootFolder.RegisterTaskDefinition(strTaskID, td); } MessageBox.Show("Schedules have inputed successfully!", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information); } catch (Exception ex) { MessageBox.Show(ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } finally { Cursor.Current = Cursors.WaitCursor; } }
public static bool UnsetAutostart() { // Get the service on the local machine using (TaskService ts = new TaskService()) { ts.RootFolder.DeleteTask("Touchmote"); return true; } }
public void TaskShedulerWrapper_TaskFolder_Construct() { var service = new TaskService(); TaskFolder folder = service.RootFolder; var df = new Dev2TaskFolder(new TaskServiceConvertorFactory(),folder); Assert.AreEqual(df.Instance,folder); Assert.AreEqual(df.Name,folder.Name); Assert.AreEqual(df.Path,folder.Path); Assert.AreEqual(df.Tasks.Count(),folder.Tasks.Count); }
public static void Uninstall(string name) { if (!IsTaskInstalled(name)) { return; } using (var ts = new Scheduler.TaskService()) ts.RootFolder.DeleteTask(name); }
public static void DisableLaunchOnStartup() { using (var taskService = new TaskService()) { var lastTaskName = ApplicationSettings.LaunchOnLoginTask; if (!string.IsNullOrWhiteSpace(lastTaskName)) taskService.RootFolder.DeleteTask(lastTaskName); ApplicationSettings.LaunchOnLoginTask = null; } }
public void Init() { _taskService = new TaskService(); var newTask = _taskService.NewTask(); var action = new ExecAction("bob.exe"); newTask.Actions.Add(action); newTask.Triggers.Add(new DailyTrigger()); _taskService.RootFolder.RegisterTaskDefinition("UnitTestTask",newTask); _factory = new Mock<ITaskServiceConvertorFactory>(); }
private bool checkTaskIsScheduled() { TaskIsScheduled = false; using (Scheduler.TaskService tsrv = new Scheduler.TaskService()) { if (tsrv.AllTasks.Any(t => t.Name == _taskName)) { TaskIsScheduled = true; } } return(TaskIsScheduled); }
public ScheduledTask(string taskName, string taskDescription) { this.taskName = taskName; this.taskDescription = taskDescription; task = new TaskService(); taskDef = task.NewTask(); this.serialActions = new List<SerialAction>(); this.serialTriggers = new List<SerialTrigger>(); this.triggers = new List<Trigger>(); this.actions = new List<ExecAction>(); }
private static TaskFolder loadTaskFolder() { TaskService ts = new TaskService(); TaskFolder folder; try { folder = ts.GetFolder(@"\"+Constants.TASK_SCHEDULER_FOLDER); } catch (FileNotFoundException) { folder = ts.RootFolder.CreateFolder(@"\"+Constants.TASK_SCHEDULER_FOLDER); } return folder; }
private void RemoveStartupTask() { try { using (Microsoft.Win32.TaskScheduler.TaskService tastService = new Microsoft.Win32.TaskScheduler.TaskService()) { tastService.RootFolder.DeleteTask(BrandName, false); return; } } catch (Exception ex) { _logger.Debug(ex, "Unable to remove the startup task "); } }
public bool IsExist(string name) { try { using (var ts = new Microsoft.Win32.TaskScheduler.TaskService()) { return(EnumTasks(ts.RootFolder). FirstOrDefault(task => task.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase)) != null); } } catch (Exception e) { this._LogService.Error(e.Message); throw; } }
/// <summary> /// Runs the actual checks, sets the Problem count and string /// </summary> /// <returns></returns> public int Check() { // check for the correct setup, if one of the checks fails, exit right away. // with the new wrapper, it seems to work without being an admin // if (!IsAdmin()) return SetProblem(AppName + " does not run as an administrator. This is required"); if (Environment.OSVersion.Version.Major < 6) { return(SetProblem("Windows Vista or newer is required")); } if (!IsServiceRunning()) { return(SetProblem("The Task Scheduler service is not running")); } if (RootFolderPattern == "") { return(SetProblem("No RootFolderPattern set, check your config file.")); } try { using (wts.TaskService ts = new wts.TaskService()) { wts.TaskFolder root = ts.RootFolder; if (CheckRootTasks) { CheckTasks(root); } ProcessFolder(root, RootFolderPattern); } } catch (Exception ex) { Exceptions.Log(ex); Failures.Add(new Failure { Name = "Application Exception", Path = ex.Message, LastRun = DateTime.Now, Result = _appErrorId, }); } // return the number of problems found return(Failures.Count); }
public bool Delete(TaskSchedulerItem item) { try { using (var ts = new Microsoft.Win32.TaskScheduler.TaskService()) { ts.RootFolder.DeleteTask(item.Name, true); } return(true); } catch (Exception e) { this._LogService.Error(e.Message); return(false); } }
public static void TrySetLaunchAtStartup(bool enabled, string username = null, string userpassword = null) { string name = Application.ProductName; using (MW32TS.TaskService service = new MW32TS.TaskService()) { TryDeleteTasksByName(name); if (!enabled) { return; } MW32TS.LogonTrigger trigger = new MW32TS.LogonTrigger(); // MW32TS.BootTrigger trigger = new MW32TS.BootTrigger(); // trigger.Delay = new TimeSpan(0, 0, 5); //trigger.Enabled = true; MW32TS.ExecAction action = new MW32TS.ExecAction(Application.ExecutablePath, null, null); action.WorkingDirectory = Application.StartupPath; MW32TS.TaskDefinition definition = service.NewTask(); definition.RegistrationInfo.Description = "Launches App At Startup"; definition.Triggers.Add(trigger); definition.Actions.Add(action); definition.Principal.RunLevel = MW32TS.TaskRunLevel.Highest; //definition.Principal. if (!username.IsNullOrEmpty()) { service.UserName = username; } if (!userpassword.IsNullOrEmpty()) { service.UserPassword = userpassword; } service.RootFolder.RegisterTaskDefinition(name, definition); } }
private static bool CheckTaskName(string taskName) { bool result = false; using (Microsoft.Win32.TaskScheduler.TaskService ts = new Microsoft.Win32.TaskScheduler.TaskService()) { using (Microsoft.Win32.TaskScheduler.TaskFolder taskFolder = ts.GetFolder(@"\")) { foreach (Task t in taskFolder.Tasks) { if (t.Name.Contains(taskName)) { result = true; } } } } return(result); }
public static void DeleteScheduledTasks() { try { using (TS.TaskService ts = new TS.TaskService()) { foreach (TS.Task t in ts.RootFolder.Tasks) { if (t.Name.StartsWith("WinCertes")) { ts.RootFolder.DeleteTask(t.Name, false); } } } } catch (Exception e) { logger.Error("Unable to read Scheduled Task status" + e.Message); } }
/// <summary> /// Creates the windows scheduled task /// </summary> /// <param name="domains"></param> /// <param name="taskName"></param> public static void CreateScheduledTask(string taskName, List <string> domains, int extra) { if (taskName == null) { return; } try { using (TS.TaskService ts = new TS.TaskService()) { // Create a new task definition and assign properties TS.TaskDefinition td = ts.NewTask(); td.RegistrationInfo.Description = "Manages certificate using ACME"; // We need to run as SYSTEM user td.Principal.UserId = @"NT AUTHORITY\SYSTEM"; // Create a trigger that will fire the task at this time every other day td.Triggers.Add(new TS.DailyTrigger { DaysInterval = 2 }); String extraOpt = ""; if (extra > -1) { extraOpt = "--extra=" + extra.ToString() + " "; } // Create an action that will launch Notepad whenever the trigger fires td.Actions.Add(new TS.ExecAction("WinCertes.exe", extraOpt + "-d " + String.Join(" -d ", domains), Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location))); // Register the task in the root folder ts.RootFolder.RegisterTaskDefinition($"WinCertes - {taskName}", td); } logger.Info($"Scheduled Task \"WinCertes - {taskName}\" created successfully"); } catch (Exception e) { logger.Error("Unable to create Scheduled Task" + e.Message); } }
public bool ScheduleTask(string exeLocation) { try { using (Scheduler.TaskService tsrv = new Scheduler.TaskService()) { //task for interval tsrv.Execute(exeLocation) .InWorkingDirectory(Path.GetDirectoryName(exeLocation)) .WithArguments(_taskArgs) .Once() .Starting(DateTime.Now) .RepeatingEvery(TimeSpan.FromSeconds(_taskIntervalSeconds)) .AsTask(_taskName); setupTask(_taskName); } } catch (Exception e) { MessageBox.Show($"Error scheduling task. Try changing <AdminsSytemUserGroup> or <TaskInterval> in Settings.xml.\nOriginal mesage: {e.Message}", "Task scheduling error", MessageBoxButton.OK, MessageBoxImage.Error); UnScheduleTask(); } return(checkTaskIsScheduled()); }
public static bool IsScheduledTaskCreated() { try { using (TS.TaskService ts = new TS.TaskService()) { foreach (TS.Task t in ts.RootFolder.Tasks) { if (t.Name.StartsWith("WinCertes")) { return(true); } } } return(false); } catch (Exception e) { logger.Error("Unable to read Scheduled Task status" + e.Message); return(false); } }
private void RefreshTasks() { DGV_taskBackumsoutlook.Rows.Clear(); using (Microsoft.Win32.TaskScheduler.TaskService ts = new Microsoft.Win32.TaskScheduler.TaskService()) { using (Microsoft.Win32.TaskScheduler.TaskFolder taskFolder = ts.GetFolder(@"\")) { foreach (Task t in taskFolder.Tasks) { if (t.Name.Contains("backupmsoutlook_")) { TaskDefinition td = t.Definition; string lastRun = t.LastRunTime.ToString(); if (lastRun.Contains("1899")) { lastRun = string.Empty; } string actions = td.Actions[0].ToString(); if (actions.Contains("\t")) { actions = actions.Replace("\t", " -> "); } string[] row = new string[] { t.Name, t.State.ToString(), actions, t.NextRunTime.ToString(), lastRun, "0x" + t.LastTaskResult, td.RegistrationInfo.Author, td.RegistrationInfo.Date.ToString() }; DGV_taskBackumsoutlook.Rows.Add(row); DGV_taskBackumsoutlook.Rows[DGV_taskBackumsoutlook.Rows.Count - 1].Selected = true; } } } } if (DGV_taskBackumsoutlook.Rows.Count > 0) { DGV_taskBackumsoutlook.Rows[0].Cells[0].Selected = false; DGV_taskBackumsoutlook.Rows[DGV_taskBackumsoutlook.Rows.Count - 1].Selected = true; } }
internal TaskEventArgs([NotNull] TaskEvent evt, TaskService ts = null) { TaskEvent = evt; TaskPath = evt.TaskPath; taskService = ts; }
internal RunningTaskEnumerator(TaskService svc, V2Interop.IRunningTaskCollection iTaskColl) { this.svc = svc; v2Svc = svc.v2TaskService; iEnum = iTaskColl.GetEnumerator(); }
/// <summary> /// Initializes a new instance of the <see cref="TaskOptionsEditor"/> class. /// </summary> /// <param name="service">A <see cref="TaskService"/> instance.</param> /// <param name="td">An optional <see cref="TaskDefinition"/>. Leaving null creates a new task.</param> /// <param name="editable">If set to <c>true</c> the task will be editable in the dialog.</param> /// <param name="registerOnAccept">If set to <c>true</c> the task will be registered when Ok is pressed.</param> public TaskOptionsEditor(TaskService service, TaskDefinition td = null, bool editable = true, bool registerOnAccept = true) : this() { this.Editable = editable; this.Initialize(service, td); this.RegisterTaskOnAccept = registerOnAccept; }
internal V1RunningTaskEnumerator(TaskService svc) { this.svc = svc; tEnum = new TaskCollection.V1TaskEnumerator(svc); }
internal RunningTaskCollection(TaskService svc, V2Interop.IRunningTaskCollection iTaskColl) { this.svc = svc; v2Svc = svc.v2TaskService; v2Coll = iTaskColl; }
internal RunningTaskCollection(TaskService svc) { this.svc = svc; v1TS = svc.v1TaskScheduler; }
internal TaskFolder(TaskService svc) { this.TaskService = svc; v1List = svc.v1TaskScheduler; }
internal RunningTaskCollection([NotNull] TaskService svc) => this.svc = svc;
/// <summary> /// Initializes a new instance of the <see cref="TaskEventWatcher" /> class watching only /// those events for the task with the provided path on the local machine. /// </summary> /// <param name="taskPath">The full path (folders and name) of the task to watch.</param> /// <param name="taskService">The task service.</param> /// <exception cref="System.ArgumentException">$Invalid task name: {taskPath}</exception> public TaskEventWatcher(string taskPath, TaskService taskService = null) : this(taskService ?? TaskService.Instance) { InitTask(taskPath); }
internal TaskCollection(TaskService svc, Regex filter = null) { this.svc = svc; this.Filter = filter; v1TS = svc.v1TaskScheduler; }
private void ResetTaskService() { ts = TaskService.Instance; }
internal TaskFolder(TaskService svc, V2Interop.ITaskFolder iFldr) { this.TaskService = svc; v2Folder = iFldr; }
/// <summary> /// Initializes a new instance of the <see cref="TaskEventWatcher" /> class. /// </summary> /// <param name="folder">The task folder to watch.</param> /// <param name="taskFilter">The filter for task names using standard file system wildcards. Use "*" to include all tasks.</param> /// <param name="includeSubfolders">if set to <c>true</c> include events from tasks subfolders.</param> /// <param name="taskService">The task service.</param> public TaskEventWatcher(string folder, string taskFilter, bool includeSubfolders, TaskService taskService = null) : this(taskService ?? TaskService.Instance) { InitTask(folder, taskFilter, includeSubfolders); }
public static bool IsTaskInstalled(string name) { using (var ts = new Scheduler.TaskService()) return(ts.FindTask(name) != null); }
private TaskEventWatcher(TaskService ts) { TaskService = ts; Filter = new EventFilter(this); }