private void AddStartupTask()
{
Task.Factory.StartNew(() =>
{
try
{
using (Microsoft.Win32.TaskScheduler.TaskService tastService = new Microsoft.Win32.TaskScheduler.TaskService())
{
Microsoft.Win32.TaskScheduler.TaskDefinition task = tastService.NewTask();
Microsoft.Win32.TaskScheduler.LogonTrigger trigger = new Microsoft.Win32.TaskScheduler.LogonTrigger()
{
Delay = TimeSpan.FromSeconds(10)
};
task.Principal.RunLevel = Microsoft.Win32.TaskScheduler.TaskRunLevel.Highest;
task.Settings.DisallowStartIfOnBatteries = false;
task.Settings.StopIfGoingOnBatteries = false;
task.Settings.RunOnlyIfNetworkAvailable = false; // Always start up regardless of network availability as the application can handle itself when there is no network connection.
task.Settings.RunOnlyIfIdle = false;
task.Settings.ExecutionTimeLimit = TimeSpan.Zero;
task.Triggers.Add(trigger);
task.Actions.Add(
new ExecAction($"\"{Assembly.GetExecutingAssembly().Location}\"", null, $"{Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)}"));
task.RegistrationInfo.Description = $"{BrandName} automatic startup.";
tastService.RootFolder.RegisterTaskDefinition(BrandName, task);
}
}
catch (Exception ex)
{
_logger.Debug(ex, "Unable to add the startup task ");
}
});
}
/// <summary>
/// Creates the windows scheduled task
/// </summary>
/// <param name="domains"></param>
/// <param name="taskName"></param>
public static void CreateScheduledTask(string taskName, List <string> domains)
{
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
});
// Create an action that will launch Notepad whenever the trigger fires
td.Actions.Add(new TS.ExecAction("WinCertes.exe", "-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);
}
}
private void setupTask(string tskName)
{
using (Scheduler.TaskService tsrv = new Scheduler.TaskService()) {
Scheduler.TaskDefinition tskDef = tsrv.FindTask(tskName).Definition;
tskDef.Settings.DisallowStartIfOnBatteries = false;
tskDef.Settings.RunOnlyIfNetworkAvailable = true;
tskDef.RegistrationInfo.Author = _taskAuthor;
tskDef.RegistrationInfo.Documentation = "TimeSharp time keeper utility";
tskDef.Principal.RunLevel = Scheduler.TaskRunLevel.Highest;
tskDef.Settings.MultipleInstances = Scheduler.TaskInstancesPolicy.IgnoreNew;
tskDef.Settings.WakeToRun = false;
tskDef.Settings.Compatibility = Scheduler.TaskCompatibility.V2_1;
//add auxiliary triggers
Scheduler.SessionStateChangeTrigger unlockSessionTrigger = new Scheduler.SessionStateChangeTrigger(Scheduler.TaskSessionStateChangeType.SessionUnlock)
{
Enabled = true
};
Scheduler.LogonTrigger logonTrigger = new Scheduler.LogonTrigger()
{
Enabled = true,
Delay = TimeSpan.FromMinutes(1),
StartBoundary = DateTime.Now,
ExecutionTimeLimit = TimeSpan.FromMinutes(5)
};
tskDef.Triggers.AddRange(new Scheduler.Trigger[] { unlockSessionTrigger, logonTrigger });
tsrv.RootFolder.RegisterTaskDefinition(tskName, tskDef,
Scheduler.TaskCreation.CreateOrUpdate, _adminsGroupName, null,
Scheduler.TaskLogonType.Group);
}
}
/// <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 Init()
{
_taskServiceConvertorFactory = new Mock<ITaskServiceConvertorFactory>();
_nativeService = new TaskService();//localhost
_nativeTask = _nativeService.NewTask();//actually a definition , not an actual task
_nativeInstance = _nativeTask.Actions;
}
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>();
}
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);
}
}
public static void SetAutorunValue(bool autorun)
{
using (TaskService ts = new TaskService())
{
if (autorun)
{
td = ts.NewTask();
td.RegistrationInfo.Description = "Запуск Alerts";
td.Triggers.Add(new LogonTrigger());
td.Actions.Add(new ExecAction(Application.ExecutablePath));
td.Principal.RunLevel = TaskRunLevel.Highest;
ts.RootFolder.RegisterTaskDefinition("Alerts", td);
}
else
{
ts.RootFolder.DeleteTask("Alerts");
}
}
}
/// <summary>
/// Registers (creates) a task in a specified location using a <see cref="TaskDefinition"/> instance to define a task.
/// </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="definition">The <see cref="TaskDefinition"/> of the registered task.</param>
/// <param name="createType">A union of <see cref="TaskCreation"/> flags.</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="sddl">The security descriptor associated with the registered task. You can specify the access control list (ACL) in the security descriptor for a task in order to allow or deny certain users and groups access to a task.</param>
/// <returns>A <see cref="Task"/> instance that represents the new task.</returns>
public Task RegisterTaskDefinition(string Path, TaskDefinition definition, TaskCreation createType, string UserId, string password, TaskLogonType LogonType, string sddl)
{
if (v2Folder != null)
return new Task(this.TaskService, v2Folder.RegisterTaskDefinition(Path, definition.v2Def, (int)createType, UserId, password, LogonType, sddl));
// Adds ability to set a password for a V1 task. Provided by Arcao.
V1Interop.TaskFlags flags = definition.v1Task.GetFlags();
switch (LogonType)
{
case TaskLogonType.Group:
case TaskLogonType.S4U:
case TaskLogonType.None:
throw new NotV1SupportedException("This LogonType is not supported on Task Scheduler 1.0.");
case TaskLogonType.InteractiveToken:
flags |= (V1Interop.TaskFlags.RunOnlyIfLoggedOn | V1Interop.TaskFlags.Interactive);
if (String.IsNullOrEmpty(UserId))
UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
definition.v1Task.SetAccountInformation(UserId, IntPtr.Zero);
break;
case TaskLogonType.ServiceAccount:
flags &= ~(V1Interop.TaskFlags.Interactive | V1Interop.TaskFlags.RunOnlyIfLoggedOn);
definition.v1Task.SetAccountInformation(String.IsNullOrEmpty(UserId) ? String.Empty : UserId, IntPtr.Zero);
break;
case TaskLogonType.InteractiveTokenOrPassword:
flags |= V1Interop.TaskFlags.Interactive;
using (V1Interop.CoTaskMemString cpwd = new V1Interop.CoTaskMemString(password))
definition.v1Task.SetAccountInformation(UserId, cpwd.DangerousGetHandle());
break;
case TaskLogonType.Password:
using (V1Interop.CoTaskMemString cpwd = new V1Interop.CoTaskMemString(password))
definition.v1Task.SetAccountInformation(UserId, cpwd.DangerousGetHandle());
break;
default:
break;
}
definition.v1Task.SetFlags(flags);
switch (createType)
{
case TaskCreation.Create:
case TaskCreation.CreateOrUpdate:
case TaskCreation.Disable:
case TaskCreation.Update:
if (createType == TaskCreation.Disable)
definition.Settings.Enabled = false;
definition.V1Save(Path);
break;
case TaskCreation.DontAddPrincipalAce:
throw new NotV1SupportedException("Security settings are not available on Task Scheduler 1.0.");
case TaskCreation.IgnoreRegistrationTriggers:
throw new NotV1SupportedException("Registration triggers are not available on Task Scheduler 1.0.");
case TaskCreation.ValidateOnly:
throw new NotV1SupportedException("Xml validation not available on Task Scheduler 1.0.");
default:
break;
}
return new Task(this.TaskService, definition.v1Task);
}
/// <summary>
/// Registers (creates) a task in a specified location using a <see cref="TaskDefinition"/> instance to define a task.
/// </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="definition">The <see cref="TaskDefinition"/> of the registered task.</param>
/// <returns>A <see cref="Task"/> instance that represents the new task.</returns>
public Task RegisterTaskDefinition(string Path, TaskDefinition definition)
{
return RegisterTaskDefinition(Path, definition, TaskCreation.CreateOrUpdate, definition.Principal.UserId, null, definition.Principal.LogonType, null);
}
public IDev2TaskDefinition CreateTaskDefinition(TaskDefinition taskDefinition)
{
return new Dev2TaskDefinition(this, taskDefinition);
}
private static Dev2TaskDefinition Dev2TaskDefinition(TaskDefinition native)
{
var factory = new TaskServiceConvertorFactory();
var defn = new Dev2TaskDefinition(factory, native);
return defn;
}
/// <summary>
/// Adds scheduled trigger(s) to <paramref name="taskDefinition"/> based on
/// <paramref name="intervalMinutes"/>.
/// </summary>
/// <param name="taskDefinition">The task to add the trigger(s) to.</param>
/// <param name="intervalMinutes">This must be a number less than 1 or a whole number (integer) greater than 1.</param>
private void AddSchedule(TaskDefinition taskDefinition, float intervalMinutes)
{
int frequencySeconds = Convert.ToInt32(intervalMinutes * 60.0);
int schedules = frequencySeconds >= 60 ? 1 : 60 / frequencySeconds;
for (int i = 0; i < schedules; i++)
{
int intervalInt;
if (!int.TryParse(intervalMinutes.ToString(CultureInfo.InvariantCulture), out intervalInt))
{
intervalInt = 1;
}
Trigger trigger = taskDefinition.Triggers.AddNew(TaskTriggerType.Daily);
trigger.Repetition.Interval = new TimeSpan(0, intervalInt, 0);
trigger.StartBoundary = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 0, 0, i * frequencySeconds);
}
}
private void wizardControl1_Finished(object sender, System.EventArgs e)
{
bool myTS = false;
if (this.TaskService == null)
{
this.TaskService = new TaskService();
myTS = true;
}
td.Data = TaskName;
td.RegistrationInfo.Description = descText.Text;
td.Triggers.Clear();
td.Triggers.Add(trigger);
td.Actions.Clear();
td.Actions.Add(action);
if (openDlgAfterCheck.Checked)
{
TaskEditDialog dlg = new TaskEditDialog();
dlg.Editable = true;
dlg.Initialize(this.TaskService, td);
dlg.RegisterTaskOnAccept = false;
dlg.TaskName = TaskName;
if (dlg.ShowDialog(this.ParentForm) == System.Windows.Forms.DialogResult.OK)
this.td = dlg.TaskDefinition;
}
if (RegisterTaskOnFinish)
{
TaskFolder fld = this.TaskService.RootFolder;
if (!string.IsNullOrEmpty(this.TaskFolder) && TaskService.HighestSupportedVersion.CompareTo(new Version(1, 1)) != 0)
fld = this.TaskService.GetFolder(this.TaskFolder);
task = fld.RegisterTaskDefinition(TaskName, td, TaskCreation.CreateOrUpdate, td.Principal.ToString(), Password, td.Principal.LogonType);
}
if (myTS)
this.TaskService = null;
}
void RegisterTaskDefinition(TaskDefinition definition)
{
if (!Report.SchedulesWithCurrentUser)
{
definition.Principal.RunLevel = TaskRunLevel.Highest;
_task = Report.TaskFolder.RegisterTaskDefinition(TaskName, definition, TaskCreation.CreateOrUpdate, "SYSTEM", null, TaskLogonType.ServiceAccount);
}
else
{
//default user
_task = Report.TaskFolder.RegisterTaskDefinition(TaskName, definition);
}
}
public Dev2TaskDefinition(ITaskServiceConvertorFactory taskServiceConvertorFactory,
TaskDefinition taskDefinition)
{
_taskServiceConvertorFactory = taskServiceConvertorFactory;
_taskDefinition = taskDefinition;
}
/// <summary>
/// Initializes the control for the editing of a new <see cref="TaskDefinition"/>.
/// </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>
public void Initialize(TaskService service, TaskDefinition td = null)
{
if (service == null)
throw new ArgumentNullException("service");
if (!titleSet)
this.Text = string.Format(EditorProperties.Resources.TaskEditDlgTitle, "New Task", GetServerString(service));
this.okBtn.Enabled = false;
taskPropertiesControl1.Initialize(service, td);
}
static string WriteXml(TaskDefinition td, string name)
{
string fn = GetTempXmlFile(name);
System.IO.File.WriteAllText(fn, td.XmlText, System.Text.Encoding.Unicode);
return fn;
}
static TaskDefinition DisplayTask(TaskService ts, TaskDefinition td, bool editable)
{
if (editorForm == null)
editorForm = new TaskEditDialog();
editorForm.Editable = editable;
editorForm.Initialize(ts, td);
editorForm.RegisterTaskOnAccept = true;
editorForm.AvailableTabs = AvailableTaskTabs.All;
return (editorForm.ShowDialog() == System.Windows.Forms.DialogResult.OK) ? editorForm.TaskDefinition : null;
}
private void AddTrigger(TaskDefinition definition, RepetitiveTask task)
{
switch (task.Type)
{
case RepetitiveTaskType.Daily:
{
var trigger = (DailyTrigger)definition.Triggers.Add(new DailyTrigger());
trigger.StartBoundary = task.StartAt.HasValue ? task.StartAt.Value : DateTime.Now;
}
break;
case RepetitiveTaskType.Weekly:
{
var trigger = (WeeklyTrigger)definition.Triggers.Add(new WeeklyTrigger(task.DaysOfWeek));
trigger.StartBoundary = task.StartAt.HasValue ? task.StartAt.Value : DateTime.Now;
}
break;
case RepetitiveTaskType.Monthly:
{
var trigger = (MonthlyTrigger)definition.Triggers.Add(new MonthlyTrigger(task.DayOfMonth));
trigger.StartBoundary = task.StartAt.HasValue ? task.StartAt.Value : DateTime.Now;
}
break;
case RepetitiveTaskType.Interval:
{
var trigger = (TimeTrigger)definition.Triggers.Add(new TimeTrigger());
trigger.StartBoundary = task.StartAt.HasValue ? task.StartAt.Value : DateTime.Now;
trigger.Repetition.Interval = task.Interval;
}
break;
default:
throw new NotSupportedException("The task type is not supported.");
}
definition.Settings.StopIfGoingOnBatteries = false;
definition.Settings.DisallowStartIfOnBatteries = false;
}
/// <summary>
/// Initializes a new instance of the <see cref="TaskSchedulerWizard"/> class.
/// </summary>
/// <param name="service">A <see cref="TaskService"/> instance.</param>
/// <param name="definition">An optional <see cref="TaskDefinition"/>. Leaving null creates a new task.</param>
/// <param name="registerOnFinish">If set to <c>true</c> the task will be registered when Finish is pressed.</param>
public TaskSchedulerWizard(TaskService service, TaskDefinition definition = null, bool registerOnFinish = false)
: this()
{
Initialize(service, definition);
RegisterTaskOnFinish = registerOnFinish;
}
/// <summary>
/// Initializes the control for the editing of a new <see cref="TaskDefinition"/>.
/// </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>
public void Initialize(TaskService service, TaskDefinition td = null)
{
if (service == null)
throw new ArgumentNullException("service");
if (!titleSet)
this.Text = string.Format(EditorProperties.Resources.TaskEditDlgTitle, "New Task", TaskEditDialog.GetServerString(service));
this.TaskService = service;
this.task = null;
if (!this.IsDesignMode())
{
if (td == null)
this.TaskDefinition = service.NewTask();
else
this.TaskDefinition = td;
}
}
/// <summary>
/// Initializes the control for the editing of a new <see cref="TaskDefinition"/>.
/// </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>
public void Initialize(TaskService service, TaskDefinition td = null)
{
this.TaskService = service;
this.task = null;
if (td == null)
this.TaskDefinition = service.NewTask();
else
{
if (td.Triggers.Count > 1)
throw new ArgumentException("Only tasks with a single trigger can be used to initialize the wizard.");
this.TaskDefinition = td;
}
this.wizardControl1.RestartPages();
}
/// <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;
}
/// <summary>
/// Returns a <see cref="TaskDefinition"/> populated with the properties defined in an XML file.
/// </summary>
/// <param name="xmlFile">The XML file to use as input.</param>
/// <returns>A <see cref="TaskDefinition"/> instance.</returns>
/// <exception cref="NotV1SupportedException">Importing from an XML file is only supported under Task Scheduler 2.0.</exception>
public TaskDefinition NewTaskFromFile(string xmlFile)
{
if (v2TaskService != null)
{
TaskDefinition td = new TaskDefinition(v2TaskService.NewTask(0));
td.XmlText = System.IO.File.ReadAllText(xmlFile);
return td;
}
throw new NotV1SupportedException();
}
/// <summary>
/// Initializes the control for the editing of a new <see cref="TaskDefinition"/>.
/// </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>
public void Initialize(TaskService service, TaskDefinition td = null)
{
this.TaskService = service;
this.task = null;
if (!this.IsDesignMode())
{
if (td == null)
this.TaskDefinition = service.NewTask();
else
this.TaskDefinition = td;
}
}
