public Collection <ScheduledJobTrigger> GetJobTriggers(string taskId)
{
if (!string.IsNullOrEmpty(taskId))
{
ITaskDefinition variable = this.FindTask(taskId);
Collection <ScheduledJobTrigger> scheduledJobTriggers = new Collection <ScheduledJobTrigger>();
ITriggerCollection triggers = variable.Triggers;
if (triggers != null)
{
foreach (ITrigger trigger in triggers)
{
ScheduledJobTrigger scheduledJobTrigger = this.CreateJobTrigger(trigger);
if (scheduledJobTrigger != null)
{
scheduledJobTriggers.Add(scheduledJobTrigger);
}
else
{
object[] id = new object[2];
id[0] = taskId;
id[1] = trigger.Id;
string str = StringUtil.Format(ScheduledJobErrorStrings.UnknownTriggerType, id);
throw new ScheduledJobException(str);
}
}
}
return(scheduledJobTriggers);
}
else
{
throw new PSArgumentException("taskId");
}
}
public void CreateTask(ScheduledJobDefinition definition)
{
if (definition != null)
{
ITaskDefinition variable = this._taskScheduler.NewTask(0);
this.AddTaskOptions(variable, definition.Options);
foreach (ScheduledJobTrigger jobTrigger in definition.JobTriggers)
{
this.AddTaskTrigger(variable, jobTrigger);
}
this.AddTaskAction(variable, definition);
string str = "D:P(A;;GA;;;SY)(A;;GA;;;BA)";
SecurityIdentifier user = WindowsIdentity.GetCurrent().User;
CommonSecurityDescriptor commonSecurityDescriptor = new CommonSecurityDescriptor(false, false, str);
commonSecurityDescriptor.DiscretionaryAcl.AddAccess(AccessControlType.Allow, user, 0x10000000, InheritanceFlags.None, PropagationFlags.None);
string sddlForm = commonSecurityDescriptor.GetSddlForm(AccessControlSections.All);
if (definition.Credential != null)
{
this._iRootFolder.RegisterTaskDefinition(definition.Name, variable, 2, definition.Credential.UserName, this.GetCredentialPassword(definition.Credential), _TASK_LOGON_TYPE.TASK_LOGON_PASSWORD, sddlForm);
return;
}
else
{
this._iRootFolder.RegisterTaskDefinition(definition.Name, variable, 2, null, null, _TASK_LOGON_TYPE.TASK_LOGON_S4U, sddlForm);
return;
}
}
else
{
throw new PSArgumentNullException("definition");
}
}
/// <summary>
/// Retrieves job triggers from WTS with provided task Id.
/// </summary>
/// <param name="taskId">Task Id</param>
/// <exception cref="ScheduledJobException">Task not found.</exception>
/// <returns>ScheduledJobTriggers</returns>
public Collection <ScheduledJobTrigger> GetJobTriggers(
string taskId)
{
if (string.IsNullOrEmpty(taskId))
{
throw new PSArgumentException("taskId");
}
ITaskDefinition iTaskDefinition = FindTask(taskId);
Collection <ScheduledJobTrigger> jobTriggers = new Collection <ScheduledJobTrigger>();
ITriggerCollection iTriggerCollection = iTaskDefinition.Triggers;
if (iTriggerCollection != null)
{
foreach (ITrigger iTrigger in iTriggerCollection)
{
ScheduledJobTrigger jobTrigger = CreateJobTrigger(iTrigger);
if (jobTrigger == null)
{
string msg = StringUtil.Format(ScheduledJobErrorStrings.UnknownTriggerType, taskId, iTrigger.Id);
throw new ScheduledJobException(msg);
}
jobTriggers.Add(jobTrigger);
}
}
return(jobTriggers);
}
static void Main()
{
String instDir = Environment.GetEnvironmentVariable("PROGRAMFILES") + "\\win7bel\\";
try
{
TaskSchedulerClass ts = new TaskSchedulerClass();
ts.Connect(null, null, null, null);
ITaskFolder root = ts.GetFolder("\\");
ITaskDefinition task = ts.NewTask(0);
task.Settings.RunOnlyIfNetworkAvailable = true;
task.Settings.StartWhenAvailable = true;
IDailyTrigger trigger = (IDailyTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_DAILY);
trigger.StartBoundary = "2011-01-01T15:00:00";
IExecAction exec = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
exec.Id = "win7bel-updater";
exec.Path = instDir + "win7bel-updater.exe";
IRegisteredTask regTask = root.RegisterTaskDefinition("win7bel-updater", task, (int)_TASK_CREATION.TASK_CREATE_OR_UPDATE, null, null, _TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN, "");
}
catch (Exception ex)
{
MessageBox.Show("Памылка ўсталёўкі спраўджвання абнаўленняў перакладу Windows 7\nПаведаміце, калі ласка, на [email protected] :\n" + ex.Message, "Памылка", MessageBoxButtons.OK, MessageBoxIcon.Error);
Environment.Exit(1);
}
Environment.Exit(0);
}
private void AddTaskOptions(ITaskDefinition iTaskDefinition, ScheduledJobOptions jobOptions)
{
_TASK_RUNLEVEL variable;
iTaskDefinition.Settings.DisallowStartIfOnBatteries = !jobOptions.StartIfOnBatteries;
iTaskDefinition.Settings.StopIfGoingOnBatteries = jobOptions.StopIfGoingOnBatteries;
iTaskDefinition.Settings.WakeToRun = jobOptions.WakeToRun;
iTaskDefinition.Settings.RunOnlyIfIdle = !jobOptions.StartIfNotIdle;
iTaskDefinition.Settings.IdleSettings.StopOnIdleEnd = jobOptions.StopIfGoingOffIdle;
iTaskDefinition.Settings.IdleSettings.RestartOnIdle = jobOptions.RestartOnIdleResume;
iTaskDefinition.Settings.IdleSettings.IdleDuration = ScheduledJobWTS.ConvertTimeSpanToWTSString(jobOptions.IdleDuration);
iTaskDefinition.Settings.IdleSettings.WaitTimeout = ScheduledJobWTS.ConvertTimeSpanToWTSString(jobOptions.IdleTimeout);
iTaskDefinition.Settings.Hidden = !jobOptions.ShowInTaskScheduler;
iTaskDefinition.Settings.RunOnlyIfNetworkAvailable = !jobOptions.RunWithoutNetwork;
iTaskDefinition.Settings.AllowDemandStart = !jobOptions.DoNotAllowDemandStart;
iTaskDefinition.Settings.MultipleInstances = this.ConvertFromMultiInstances(jobOptions.MultipleInstancePolicy);
TaskScheduler.IPrincipal principal = iTaskDefinition.Principal;
if (jobOptions.RunElevated)
{
variable = _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST;
}
else
{
variable = _TASK_RUNLEVEL.TASK_RUNLEVEL_LUA;
}
principal.RunLevel = variable;
}
private void AddTaskAction(ITaskDefinition iTaskDefinition, ScheduledJobDefinition definition)
{
IExecAction pSExecutionPath = iTaskDefinition.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC) as IExecAction;
pSExecutionPath.Id = "StartPowerShellJob";
pSExecutionPath.Path = definition.PSExecutionPath;
pSExecutionPath.Arguments = definition.PSExecutionArgs;
}
/// <summary>
/// Creates a new task in WTS with information from ScheduledJobDefinition.
/// </summary>
/// <param name="definition">ScheduledJobDefinition</param>
public void CreateTask(
ScheduledJobDefinition definition)
{
if (definition == null)
{
throw new PSArgumentNullException("definition");
}
// Create task definition
ITaskDefinition iTaskDefinition = _taskScheduler.NewTask(0);
// Add task options.
AddTaskOptions(iTaskDefinition, definition.Options);
// Add task triggers.
foreach (ScheduledJobTrigger jobTrigger in definition.JobTriggers)
{
AddTaskTrigger(iTaskDefinition, jobTrigger);
}
// Add task action.
AddTaskAction(iTaskDefinition, definition);
// Create a security descriptor for the current user so that only the user
// (and Local System account) can see/access the registered task.
string startSddl = "D:P(A;;GA;;;SY)(A;;GA;;;BA)"; // DACL Allow Generic Access to System and BUILTIN\Administrators.
System.Security.Principal.SecurityIdentifier userSid =
System.Security.Principal.WindowsIdentity.GetCurrent().User;
CommonSecurityDescriptor SDesc = new CommonSecurityDescriptor(false, false, startSddl);
SDesc.DiscretionaryAcl.AddAccess(AccessControlType.Allow, userSid, 0x10000000, InheritanceFlags.None, PropagationFlags.None);
string sddl = SDesc.GetSddlForm(AccessControlSections.All);
// Register this new task with the Task Scheduler.
if (definition.Credential == null)
{
// Register task to run as currently logged on user.
_iRootFolder.RegisterTaskDefinition(
definition.Name,
iTaskDefinition,
(int)_TASK_CREATION.TASK_CREATE,
null, // User name
null, // Password
_TASK_LOGON_TYPE.TASK_LOGON_S4U,
sddl);
}
else
{
// Register task to run under provided user account/credentials.
_iRootFolder.RegisterTaskDefinition(
definition.Name,
iTaskDefinition,
(int)_TASK_CREATION.TASK_CREATE,
definition.Credential.UserName,
GetCredentialPassword(definition.Credential),
_TASK_LOGON_TYPE.TASK_LOGON_PASSWORD,
sddl);
}
}
public void UpdateTask(ScheduledJobDefinition definition)
{
if (definition != null)
{
ITaskDefinition enabled = this.FindTask(definition.Name);
this.AddTaskOptions(enabled, definition.Options);
enabled.Settings.Enabled = definition.Enabled;
enabled.Triggers.Clear();
foreach (ScheduledJobTrigger jobTrigger in definition.JobTriggers)
{
this.AddTaskTrigger(enabled, jobTrigger);
}
enabled.Actions.Clear();
this.AddTaskAction(enabled, definition);
if (definition.Credential != null)
{
this._iRootFolder.RegisterTaskDefinition(definition.Name, enabled, 4, definition.Credential.UserName, this.GetCredentialPassword(definition.Credential), _TASK_LOGON_TYPE.TASK_LOGON_PASSWORD, null);
return;
}
else
{
this._iRootFolder.RegisterTaskDefinition(definition.Name, enabled, 4, null, null, _TASK_LOGON_TYPE.TASK_LOGON_S4U, null);
return;
}
}
else
{
throw new PSArgumentNullException("definition");
}
}
static void Main(string[] args)
{
var scheduler = new TaskSchedulerClass();
scheduler.Connect(null, null, null, null);
ITaskDefinition task = scheduler.NewTask(0);
task.RegistrationInfo.Author = "DCOM Productions";
task.RegistrationInfo.Description = "Demo";
ILogonTrigger trigger = (ILogonTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_LOGON);
trigger.Id = "Logon Demo";
IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
action.Id = "Delete";
action.Path = "c:\\delete.exe"; // Or similar path
action.WorkingDirectory = "c:\\"; // Working path
action.Arguments = "c:\\killme.txt"; // Path to your file
ITaskFolder root = scheduler.GetFolder("\\");
IRegisteredTask regTask = root.RegisterTaskDefinition("Demo", task, (int)_TASK_CREATION.TASK_CREATE_OR_UPDATE, null, null, _TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN, "");
//Force run task
//IRunningTask runTask = regTask.Run(null);
}
private void AddTaskOptions(ITaskDefinition iTaskDefinition, ScheduledJobOptions jobOptions)
{
_TASK_RUNLEVEL variable;
iTaskDefinition.Settings.DisallowStartIfOnBatteries = !jobOptions.StartIfOnBatteries;
iTaskDefinition.Settings.StopIfGoingOnBatteries = jobOptions.StopIfGoingOnBatteries;
iTaskDefinition.Settings.WakeToRun = jobOptions.WakeToRun;
iTaskDefinition.Settings.RunOnlyIfIdle = !jobOptions.StartIfNotIdle;
iTaskDefinition.Settings.IdleSettings.StopOnIdleEnd = jobOptions.StopIfGoingOffIdle;
iTaskDefinition.Settings.IdleSettings.RestartOnIdle = jobOptions.RestartOnIdleResume;
iTaskDefinition.Settings.IdleSettings.IdleDuration = ScheduledJobWTS.ConvertTimeSpanToWTSString(jobOptions.IdleDuration);
iTaskDefinition.Settings.IdleSettings.WaitTimeout = ScheduledJobWTS.ConvertTimeSpanToWTSString(jobOptions.IdleTimeout);
iTaskDefinition.Settings.Hidden = !jobOptions.ShowInTaskScheduler;
iTaskDefinition.Settings.RunOnlyIfNetworkAvailable = !jobOptions.RunWithoutNetwork;
iTaskDefinition.Settings.AllowDemandStart = !jobOptions.DoNotAllowDemandStart;
iTaskDefinition.Settings.MultipleInstances = this.ConvertFromMultiInstances(jobOptions.MultipleInstancePolicy);
TaskScheduler.IPrincipal principal = iTaskDefinition.Principal;
if (jobOptions.RunElevated)
{
variable = _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST;
}
else
{
variable = _TASK_RUNLEVEL.TASK_RUNLEVEL_LUA;
}
principal.RunLevel = variable;
}
//Setting Task Definition
private void SetTaskDefinition()
{
try
{
objTaskDef = objScheduler.NewTask(0);
//Registration Info for task
//Name of the task Author
objTaskDef.RegistrationInfo.Author = "AuthorName";
//Description of the task
objTaskDef.RegistrationInfo.Description = "CreatBackupBase1C";
//Registration date of the task
objTaskDef.RegistrationInfo.Date = DateTime.Today.ToString("yyyy-MM-ddTHH:mm:ss"); //Date format
//Settings for task
//Thread Priority
objTaskDef.Settings.Priority = 7;
//Enabling the task
objTaskDef.Settings.Enabled = true;
//To hide/show the task
objTaskDef.Settings.Hidden = false;
//Execution Time Lmit for task
objTaskDef.Settings.ExecutionTimeLimit = "PT10M"; //10 minutes
//Specifying no need of network connection
objTaskDef.Settings.RunOnlyIfNetworkAvailable = false;
}
catch (Exception ex)
{
throw ex;
}
}
private void CreateSchedulerTask()
{
ITaskDefinition definition = scheduler.NewTask(0);
definition.RegistrationInfo.Description =
"This task starts the Open Hardware Monitor on Windows startup.";
definition.Principal.RunLevel =
TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST;
definition.Settings.DisallowStartIfOnBatteries = false;
definition.Settings.StopIfGoingOnBatteries = false;
definition.Settings.ExecutionTimeLimit = "PT0S";
ILogonTrigger trigger = (ILogonTrigger)definition.Triggers.Create(
TASK_TRIGGER_TYPE2.TASK_TRIGGER_LOGON);
IExecAction action = (IExecAction)definition.Actions.Create(
TASK_ACTION_TYPE.TASK_ACTION_EXEC);
action.Path = Application.ExecutablePath;
action.WorkingDirectory =
Path.GetDirectoryName(Application.ExecutablePath);
ITaskFolder root = scheduler.GetFolder("\\");
ITaskFolder folder;
try {
folder = root.GetFolder("Open Hardware Monitor");
} catch (FileNotFoundException) {
folder = root.CreateFolder("Open Hardware Monitor", "");
}
folder.RegisterTaskDefinition("Startup", definition,
(int)TASK_CREATION.TASK_CREATE_OR_UPDATE, null, null,
TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN, "");
}
private void GetItemsFromTaskDefenition(ITaskDefinition defenition)
{
var actions = defenition.Actions;
_comObjects.Push(actions);
foreach (IAction action in actions)
{
_comObjects.Push(action);
if (action.Type == _TASK_ACTION_TYPE.TASK_ACTION_EXEC)
{
IExecAction execaction = (IExecAction)action;
if (!string.IsNullOrEmpty(execaction.Path))
{
var linfo = _pathResolver.ResolvePath(
execaction.Path,
execaction.WorkingDirectory,
execaction.Arguments,
LaunchInfoSource.TaskSheduler);
_items.Add(linfo);
}
}
}
}
/// <summary>
/// Converts the Business Entity to COM Representation of ScheduledTask
/// </summary>
/// <param name="task">Scheduled task Business Entity</param>
/// <returns>COM entity of a scheduled Task</returns>
private ITaskDefinition TransformToRegisteredTask(ScheduledTask task)
{
ITaskDefinition taskDefinition = this.taskService.NewTask(0);
taskDefinition.RegistrationInfo.Description = task.Description;
taskDefinition.RegistrationInfo.Author = task.Author;
taskDefinition.Settings.Enabled = task.Settings.Enabled;
taskDefinition.Settings.Hidden = task.Settings.Hidden;
taskDefinition.Settings.Compatibility = _TASK_COMPATIBILITY.TASK_COMPATIBILITY_V2_1;
if (task.Settings.StopTaskWhenRunsLonger)
{
// this is the format needed by COM
taskDefinition.Settings.ExecutionTimeLimit = ConvertToCOMTimeSpanRepresentation(task.Settings.ExecutionTimeLimit);
}
if (task.Conditions.RunOnlyIfIdle)
{
taskDefinition.Settings.RunOnlyIfIdle = task.Conditions.RunOnlyIfIdle;
// this is the format needed by COM
taskDefinition.Settings.IdleSettings.IdleDuration = ConvertToCOMTimeSpanRepresentation(task.Conditions.IdleDurationToStartTaskWhenSystemIsIdle);
}
// ADD Triggers
ConfigureTriggers(taskDefinition, task);
// ADD Actions
ConfigureActions(taskDefinition, task);
return(taskDefinition);
}
/// <summary>
/// Creates a scheduled task
/// </summary>
/// <param name="task">Scheduled Task object containing all configured iformation</param>
/// <returns>True if task gets created successfully</returns>
/// <exception cref="TaskScheduler.Exceptions.InvalidTaskNameException">Thrown when task name has invalid/illegal characters</exception>
public bool CreateTask(ScheduledTask task)
{
if (task.Name.Contains(Constants.TaskPathSeparator))
{
throw new InvalidTaskNameException();
}
try
{
this.ConnectTaskSchedulerService();
ITaskDefinition definition = this.TransformToRegisteredTask(task);
// creating this task in the root Folder
// you may choose to create in sub-folders.
// Create SubFolder under RootFolder, if you require
ITaskFolder rootFolder = this.taskService.GetFolder(Constants.TaskPathSeparator);
// 6 as flags (3rd argument) means this task can be created or updated ["CreateOrUpdate" flag]
// Add the task to the RootFolder
// if Name id empty or null, System will create a task with name as GUID
rootFolder.RegisterTaskDefinition(task.Name, definition, 6, null, null, _TASK_LOGON_TYPE.TASK_LOGON_NONE, null);
}
catch (Exception exception)
{
Logger.LogError(Constants.TaskCreateError, exception);
throw;
}
return(true);
}
/// <summary>
/// Converts the Scheduled Task COM representation to Business Entity
/// </summary>
/// <param name="task">COM Scheduled Task</param>
/// <returns>An instance of Scheduled Task</returns>
private static ScheduledTask TransformToTask(IRegisteredTask task)
{
ScheduledTask scheduledTask = new ScheduledTask();
scheduledTask.Name = task.Name;
scheduledTask.CurrentState = task.State.ToString();
scheduledTask.TaskPath = task.Path;
scheduledTask.NextRunTime = task.NextRunTime;
scheduledTask.LastRunTime = task.LastRunTime;
scheduledTask.LastRunResults = task.LastTaskResult.ToString();
ITaskDefinition definition = task.Definition;
ITaskSettings settings = definition.Settings;
scheduledTask.Priority = settings.Priority;
scheduledTask.Settings = new Settings();
scheduledTask.Settings.Enabled = settings.Enabled;
scheduledTask.Settings.Hidden = settings.Hidden;
IRegistrationInfo registrationInfo = definition.RegistrationInfo;
scheduledTask.Description = registrationInfo.Description;
scheduledTask.Author = registrationInfo.Author;
return(scheduledTask);
}
/// <summary>
/// Creates Actions
/// </summary>
/// <param name="taskDefinition">Task Definition to which triggers should be added</param>
/// <param name="task">Task containing trigger information</param>
private static void ConfigureActions(ITaskDefinition taskDefinition, ScheduledTask task)
{
IActionCollection actions = taskDefinition.Actions;
if (task.Actions != null)
{
foreach (Entities.Action actionInfo in task.Actions)
{
_TASK_ACTION_TYPE actionType = MapActionType(actionInfo.Type);
IAction action = actions.Create(actionType);
switch (actionType)
{
case _TASK_ACTION_TYPE.TASK_ACTION_EXEC:
ConfigureExecAction(action, actionInfo);
break;
case _TASK_ACTION_TYPE.TASK_ACTION_SEND_EMAIL:
ConfigureEmailAction(action, actionInfo);
break;
case _TASK_ACTION_TYPE.TASK_ACTION_SHOW_MESSAGE:
ConfigureShowMessageAction(action, actionInfo);
break;
}
}
}
}
// Install the UAC bypass CosmosTask. This must be performed while the program is running under
// administrator credentials with elevation.
void InstallScheduledTask()
{
ITaskService xService = new TaskScheduler.TaskScheduler();
xService.Connect();
ITaskFolder xFolder = xService.GetFolder(@"\");
IRegisteredTask xTask = TryGetInstallScheduledTask(xFolder);
if (null != xTask)
{
// The first parameter MUST NOT be prefixed with the folder path.
xFolder.DeleteTask(InstallScheduledTaskName, 0);
}
ITaskDefinition xTaskDef = xService.NewTask(0);
xTaskDef.RegistrationInfo.Description = "Cosmos DevKit UAC Bypass";
xTaskDef.RegistrationInfo.Author = "Cosmos Group";
xTaskDef.Settings.Compatibility = _TASK_COMPATIBILITY.TASK_COMPATIBILITY_V2_1;
xTaskDef.Settings.DisallowStartIfOnBatteries = false;
xTaskDef.Principal.RunLevel = _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST;
IActionCollection xActions = xTaskDef.Actions;
IAction xAction = xActions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
IExecAction xExecAction = xAction as IExecAction;
xExecAction.Path = mSetupPath;
xExecAction.Arguments = @"/SILENT";
// 6 = task can be created or updated ["CreateOrUpdate" flag]
// if Name id empty or null, System will create a task with name as GUID
xTask = xFolder.RegisterTaskDefinition(InstallScheduledTaskName, xTaskDef, 6, null, null, _TASK_LOGON_TYPE.TASK_LOGON_NONE, null);
}
private ScheduledJobOptions CreateJobOptions(ITaskDefinition iTaskDefinition)
{
ITaskSettings settings = iTaskDefinition.Settings;
TaskScheduler.IPrincipal principal = iTaskDefinition.Principal;
return(new ScheduledJobOptions(!settings.DisallowStartIfOnBatteries, settings.StopIfGoingOnBatteries, settings.WakeToRun, !settings.RunOnlyIfIdle, settings.IdleSettings.StopOnIdleEnd, settings.IdleSettings.RestartOnIdle, this.ParseWTSTime(settings.IdleSettings.IdleDuration), this.ParseWTSTime(settings.IdleSettings.WaitTimeout), !settings.Hidden, principal.RunLevel == _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST, !settings.RunOnlyIfNetworkAvailable, !settings.AllowDemandStart, this.ConvertToMultiInstances(settings)));
}
static public bool SkipUacEnable(string taskName, bool is_enable)
{
try
{
TaskScheduler.TaskScheduler service = new TaskScheduler.TaskScheduler();
service.Connect();
ITaskFolder folder = service.GetFolder(@"\"); // root
if (is_enable)
{
string exePath = System.Reflection.Assembly.GetExecutingAssembly().Location;
string appPath = Path.GetDirectoryName(exePath);
ITaskDefinition task = service.NewTask(0);
task.RegistrationInfo.Author = "WuMgr";
task.Principal.RunLevel = _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST;
task.Settings.AllowHardTerminate = false;
task.Settings.StartWhenAvailable = false;
task.Settings.DisallowStartIfOnBatteries = false;
task.Settings.StopIfGoingOnBatteries = false;
task.Settings.MultipleInstances = _TASK_INSTANCES_POLICY.TASK_INSTANCES_PARALLEL;
task.Settings.ExecutionTimeLimit = "PT0S";
IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
action.Path = exePath;
action.WorkingDirectory = appPath;
action.Arguments = "-NoUAC $(Arg0)";
IRegisteredTask registered_task = folder.RegisterTaskDefinition(taskName, task, (int)_TASK_CREATION.TASK_CREATE_OR_UPDATE, null, null, _TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN);
if (registered_task == null)
{
return(false);
}
// Note: if we run as UWP we need to adjust the file permissions for this workaround to work
if (UwpFunc.IsRunningAsUwp())
{
if (!FileOps.TakeOwn(exePath))
{
return(false);
}
FileSecurity ac = File.GetAccessControl(exePath);
ac.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(FileOps.SID_Worls), FileSystemRights.ReadAndExecute, AccessControlType.Allow));
File.SetAccessControl(exePath, ac);
}
}
else
{
folder.DeleteTask(taskName, 0);
}
}
catch (Exception err)
{
AppLog.Line("Enable SkipUAC Error {0}", err.ToString());
return(false);
}
return(true);
}
/// <summary>
/// 创建计划任务
/// </summary>
/// <param name="creator">创建人</param>
/// <param name="taskName">计划任务名称</param>
/// <param name="path">执行文件的路径</param>
/// <param name="intervalMintue">计划任务执行的频率(分钟)</param>
/// <param name="startBoundary">开始时间(默认是DateTime.MinValue)</param>
/// <param name="endBoundary">结束时间(默认是DateTime.MinValue)</param>
/// <param name="description">备注</param>
/// <param name="runOnlyIfIdle">仅当计算机空闲下才执行</param>
/// <returns></returns>
public static _TASK_STATE CreateTaskScheduler(string creator, string taskName,
string path, int intervalMintue, DateTime startBoundary, DateTime endBoundary, bool runOnlyIfIdle = false, string description = "")
{
try
{
if (IsExists(taskName))
{
DeleteTask(taskName);
}
//new scheduler
TaskSchedulerClass scheduler = new TaskSchedulerClass();
//pc-name/ip,username,domain,password
scheduler.Connect(null, null, null, null);
//get scheduler folder
ITaskFolder folder = scheduler.GetFolder("\\");
//set base attr
ITaskDefinition task = scheduler.NewTask(0);
task.RegistrationInfo.Author = creator; //creator
task.RegistrationInfo.Description = description; //description
//set trigger (IDailyTrigger ITimeTrigger)
ITimeTrigger tt = (ITimeTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_TIME);
tt.Repetition.Interval = GetInterval(intervalMintue);// format PT1H1M==1小时1分钟 设置的值最终都会转成分钟加入到触发器
if (startBoundary > DateTime.MinValue)
{
tt.StartBoundary = startBoundary.ToString("yyyy-MM-ddTHH:mm:ss");//start time
}
else
{
tt.StartBoundary = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ss");//start time
}
if (startBoundary > DateTime.MinValue)
{
tt.EndBoundary = startBoundary.ToString("yyyy-MM-ddTHH:mm:ss");;
}
//set action
IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
action.Path = path; //计划任务调用的程序路径
task.Settings.ExecutionTimeLimit = "PT0S"; //运行任务时间超时停止任务吗? PTOS 不开启超时
task.Settings.DisallowStartIfOnBatteries = false; //只有在交流电源下才执行
task.Settings.RunOnlyIfIdle = false; //仅当计算机空闲下才执行
IRegisteredTask regTask = folder.RegisterTaskDefinition(taskName, task,
(int)_TASK_CREATION.TASK_CREATE, null, //user
null, // password
_TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN,
"");
IRunningTask runTask = regTask.Run(null);
return(runTask.State);
}
catch (Exception ex)
{
throw ex;
}
}
internal override void Bind(ITaskDefinition iTaskDef)
{
base.Bind(iTaskDef);
if (_nvc != null)
{
_nvc.Bind(((IEventTrigger)base._v2Trigger).ValueQueries);
}
}
private void AddTaskAction(ITaskDefinition iTaskDefinition, ScheduledJobDefinition definition)
{
IExecAction pSExecutionPath = iTaskDefinition.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC) as IExecAction;
pSExecutionPath.Id = "StartPowerShellJob";
pSExecutionPath.Path = definition.PSExecutionPath;
pSExecutionPath.Arguments = definition.PSExecutionArgs;
}
internal override void Bind(ITaskDefinition iTaskDef)
{
base.Bind(iTaskDef);
if (nvc != null)
{
nvc.Bind(((IEmailAction)iAction).HeaderFields);
}
}
/// <summary>
/// 创建任务
/// </summary>
void CreateTask()
{
try
{
string creator = "HST";
string taskName = TaskName;
string path = Process.GetCurrentProcess().MainModule.FileName;
string interval = "PT24H0M";
//new scheduler
TaskSchedulerClass scheduler = new TaskSchedulerClass();
//pc-name/ip,username,domain,password
scheduler.Connect(null, null, null, null);
//get scheduler folder
ITaskFolder folder = scheduler.GetFolder("\\");
//set base attr
ITaskDefinition task = scheduler.NewTask(0);
task.RegistrationInfo.Author = creator; //creator
task.RegistrationInfo.Description = "Boot BudSSH"; //description
task.RegistrationInfo.Date = DateTimeUtil.GetTaskFormatTime(DateTime.Now);
//set trigger (IDailyTrigger ITimeTrigger)
ITimeTrigger tt = (ITimeTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_TIME);
tt.Repetition.Interval = interval;// format PT1H1M==1小时1分钟 设置的值最终都会转成分钟加入到触发器
Config config = ConfigManager.GetCurrentConfig();
var date = DateTime.Parse(config.SSHBootTime);
tt.StartBoundary = DateTimeUtil.GetTaskFormatTime(date);// "2015-04-09T14:27:25";//start time
//set action
IExecAction action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
action.Path = path;
task.Settings.ExecutionTimeLimit = "PT0S"; //运行任务时间超时停止任务吗? PTOS 不开启超时
task.Settings.DisallowStartIfOnBatteries = false; //只有在交流电源下才执行
task.Settings.RunOnlyIfIdle = false; //仅当计算机空闲下才执行
IRegisteredTask regTask = folder.RegisterTaskDefinition(taskName, task,
(int)_TASK_CREATION.TASK_CREATE, null, //user
null, // password
_TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN,
"");
if (regTask.State != _TASK_STATE.TASK_STATE_READY && regTask.State != _TASK_STATE.TASK_STATE_RUNNING)
{
IRunningTask runTask = regTask.Run(null);
}
logger.Info("regTask.State: " + regTask.State);
}
catch (System.Exception ex)
{
logger.Error("Create Task Error");
throw ex;
}
}
internal override void AddToTask(ITaskDefinition taskDefinition)
{
IWeeklyTrigger variable = base.Create <IWeeklyTrigger>(taskDefinition);
variable.WeeksInterval = this._weeksInterval;
variable.DaysOfWeek = (
from x in this._recurDays.Distinct <DayOfWeek>()
select this._bitsForWeekDays[x]).Aggregate <short>((short x, short y) => (short)(x | y));
}
/// <summary>
/// Releases all resources used by this class.
/// </summary>
public void Dispose()
{
if (v2Coll != null)
{
Marshal.ReleaseComObject(v2Coll);
}
v2Def = null;
v1Task = null;
}
public async Task HandleAsync(ITaskDefinition <TIdentifier> taskDefinition, Exception exception)
{
var taskDefinitionState = await GetTaskDefinitionState(taskDefinition.Id);
taskDefinitionState.Disabled = true;
await taskDefinitionStateWriter.WriteAsync(taskDefinitionState);
await faultReporter.ReportAsync(taskDefinition, exception, true);
}
/// <summary>
/// Updates an existing task in WTS with information from
/// ScheduledJobDefinition.
/// </summary>
/// <param name="definition">ScheduledJobDefinition</param>
public void UpdateTask(
ScheduledJobDefinition definition)
{
if (definition == null)
{
throw new PSArgumentNullException("definition");
}
// Get task to update.
ITaskDefinition iTaskDefinition = FindTask(definition.Name);
// Replace options.
AddTaskOptions(iTaskDefinition, definition.Options);
// Set enabled state.
iTaskDefinition.Settings.Enabled = definition.Enabled;
// Replace triggers.
iTaskDefinition.Triggers.Clear();
foreach (ScheduledJobTrigger jobTrigger in definition.JobTriggers)
{
AddTaskTrigger(iTaskDefinition, jobTrigger);
}
// Replace action.
iTaskDefinition.Actions.Clear();
AddTaskAction(iTaskDefinition, definition);
// Register updated task.
if (definition.Credential == null)
{
// Register task to run as currently logged on user.
_iRootFolder.RegisterTaskDefinition(
definition.Name,
iTaskDefinition,
(int)_TASK_CREATION.TASK_UPDATE,
null, // User name
null, // Password
_TASK_LOGON_TYPE.TASK_LOGON_S4U,
null);
}
else
{
// Register task to run under provided user account/credentials.
_iRootFolder.RegisterTaskDefinition(
definition.Name,
iTaskDefinition,
(int)_TASK_CREATION.TASK_UPDATE,
definition.Credential.UserName,
GetCredentialPassword(definition.Credential),
_TASK_LOGON_TYPE.TASK_LOGON_PASSWORD,
null);
}
}
/// <summary>
/// Returns a boolean indicating whether the job/task is enabled
/// in the Task Scheduler.
/// </summary>
/// <param name="taskId"></param>
/// <returns></returns>
public bool GetTaskEnabled(
string taskId)
{
if (string.IsNullOrEmpty(taskId))
{
throw new PSArgumentException("taskId");
}
ITaskDefinition iTaskDefinition = FindTask(taskId);
return(iTaskDefinition.Settings.Enabled);
}
private void AddTaskAction(
ITaskDefinition iTaskDefinition,
ScheduledJobDefinition definition)
{
IExecAction iExecAction = iTaskDefinition.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC) as IExecAction;
Debug.Assert(iExecAction != null);
iExecAction.Id = ScheduledJobTaskActionId;
iExecAction.Path = definition.PSExecutionPath;
iExecAction.Arguments = definition.PSExecutionArgs;
}
/// <summary>
/// Retrieves options for the provided task Id.
/// </summary>
/// <param name="taskId">Task Id</param>
/// <exception cref="ScheduledJobException">Task not found.</exception>
/// <returns>ScheduledJobOptions</returns>
public ScheduledJobOptions GetJobOptions(
string taskId)
{
if (string.IsNullOrEmpty(taskId))
{
throw new PSArgumentException("taskId");
}
ITaskDefinition iTaskDefinition = FindTask(taskId);
return(CreateJobOptions(iTaskDefinition));
}
public void addWakeUpTask(int sT)
{
//rootFolder.CreateFolder("", &newFolder);
task = scheduler.NewTask(0);
task.Settings.Enabled = true;
task.Settings.WakeToRun = true;
task.Settings.StopIfGoingOnBatteries = false;
task.Settings.RunOnlyIfIdle = false;
task.Settings.DisallowStartIfOnBatteries = false;
task.Settings.IdleSettings.StopOnIdleEnd = false;
task.Settings.RestartCount = 5;
task.Settings.RestartInterval = "PT1M";
task.Settings.StartWhenAvailable = true;
task.Settings.Priority = 0;
task.Settings.MultipleInstances = _TASK_INSTANCES_POLICY.TASK_INSTANCES_PARALLEL;
task.Principal.RunLevel = _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST;
task.Principal.LogonType = _TASK_LOGON_TYPE.TASK_LOGON_SERVICE_ACCOUNT;
task.Principal.UserId = "System";
action = (IExecAction)task.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC);
//action.Path = typeof(SayHello.Form1).Assembly.Location;
action.Path = @"c:\windows\notepad.exe";
//action.Path = @"C:\Users\sagatsum\Documents\Visual Studio 2010\Projects\FakeISCTConsole\FakeISCTConsole\bin\Release\FakeISCTConsole.exe";
//action.WorkingDirectory = Path.GetDirectoryName(typeof(SayHello.Form1).Assembly.Location);
//action.WorkingDirectory = @"C:\Users\sagatsum\Documents\Visual Studio 2010\Projects\FakeISCTConsole\FakeISCTConsole\bin\Release";
trigger = (ITimeTrigger)task.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_TIME);
//trigger.StateChange = _TASK_SESSION_STATE_CHANGE_TYPE.TASK_SESSION_UNLOCK;
trigger.Enabled = true;
trigger.StartBoundary = (DateTime.Now.AddSeconds(sT)).ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss");
task.RegistrationInfo.Author = "Shintaro Agatsuma";
task.RegistrationInfo.Description = "Fake iSCT Task.";
try
{
IRegisteredTask ticket = rootFolder.RegisterTaskDefinition("Fake iSCT Wake Up", task,
(int)_TASK_CREATION.TASK_CREATE_OR_UPDATE, null, null, _TASK_LOGON_TYPE.TASK_LOGON_S4U, null);
eventLog.WriteEntry("Task Successfully added");
}
catch (Exception e)
{
eventLog.WriteEntry("Failed to add a task: " + e.Message);
}
}
internal virtual void Bind(ITaskDefinition iTaskDef)
{
var o = iTaskDef.Triggers;
_v2Trigger = o.Create(_ttype);
Marshal.ReleaseComObject(o);
foreach (string str in unboundValues.Keys)
{
try
{
var obj2 = unboundValues[str];
CheckBindValue(str, ref obj2);
_v2Trigger.GetType().InvokeMember(str, BindingFlags.SetProperty, null, _v2Trigger, new object[] { obj2 });
}
catch (TargetInvocationException ex) { throw ex.InnerException; }
catch { }
}
unboundValues.Clear();
unboundValues = null;
_repititionPattern = new RepetitionPattern(this);
_repititionPattern.Bind();
}
internal override void Bind(ITaskDefinition iTaskDef)
{
base.Bind(iTaskDef);
if (nvc != null) {
nvc.Bind(((IEventTrigger)v2Trigger).ValueQueries);
}
}
internal TaskDefinition(ITaskDefinition iDef)
{
_v1Name = string.Empty;
_v2Def = iDef;
}
internal virtual void Bind(ITaskDefinition iTaskDef) {
var iActions = iTaskDef.Actions;
switch (GetType().Name) {
case "ComHandlerAction":
iAction = iActions.Create(TaskActionType.ComHandler);
break;
case "ExecAction":
iAction = iActions.Create(TaskActionType.Execute);
break;
case "EmailAction":
iAction = iActions.Create(TaskActionType.SendEmail);
break;
case "ShowMessageAction":
iAction = iActions.Create(TaskActionType.ShowMessage);
break;
default:
throw new ArgumentException();
}
Marshal.ReleaseComObject(iActions);
foreach (var key in unboundValues.Keys) {
try {
iAction.GetType().InvokeMember(key, BindingFlags.SetProperty, null, iAction, new[] {
unboundValues[key]
});
} catch (TargetInvocationException tie) {
throw tie.InnerException;
} catch {
}
}
unboundValues.Clear();
}
internal override void Bind(ITaskDefinition iTaskDef) {
base.Bind(iTaskDef);
if (nvc != null) {
nvc.Bind(((IEmailAction)iAction).HeaderFields);
}
}
/// <summary>
/// Creates a new WTS trigger based on the provided ScheduledJobTrigger object
/// and adds it to the provided ITaskDefinition object.
/// </summary>
/// <param name="iTaskDefinition">ITaskDefinition</param>
/// <param name="jobTrigger">ScheduledJobTrigger</param>
private void AddTaskTrigger(
ITaskDefinition iTaskDefinition,
ScheduledJobTrigger jobTrigger)
{
ITrigger iTrigger = null;
switch (jobTrigger.Frequency)
{
case TriggerFrequency.AtStartup:
{
iTrigger = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_BOOT);
IBootTrigger iBootTrigger = iTrigger as IBootTrigger;
Debug.Assert(iBootTrigger != null);
iBootTrigger.Delay = ConvertTimeSpanToWTSString(jobTrigger.RandomDelay);
iTrigger.Id = jobTrigger.Id.ToString(CultureInfo.InvariantCulture);
iTrigger.Enabled = jobTrigger.Enabled;
}
break;
case TriggerFrequency.AtLogon:
{
iTrigger = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_LOGON);
ILogonTrigger iLogonTrigger = iTrigger as ILogonTrigger;
Debug.Assert(iLogonTrigger != null);
iLogonTrigger.UserId = ScheduledJobTrigger.IsAllUsers(jobTrigger.User) ? null : jobTrigger.User;
iLogonTrigger.Delay = ConvertTimeSpanToWTSString(jobTrigger.RandomDelay);
iTrigger.Id = jobTrigger.Id.ToString(CultureInfo.InvariantCulture);
iTrigger.Enabled = jobTrigger.Enabled;
}
break;
case TriggerFrequency.Once:
{
iTrigger = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_TIME);
ITimeTrigger iTimeTrigger = iTrigger as ITimeTrigger;
Debug.Assert(iTimeTrigger != null);
iTimeTrigger.RandomDelay = ConvertTimeSpanToWTSString(jobTrigger.RandomDelay);
// Time trigger repetition.
if (jobTrigger.RepetitionInterval != null &&
jobTrigger.RepetitionDuration != null)
{
iTimeTrigger.Repetition.Interval = ConvertTimeSpanToWTSString(jobTrigger.RepetitionInterval.Value);
if (jobTrigger.RepetitionDuration.Value == TimeSpan.MaxValue)
{
iTimeTrigger.Repetition.StopAtDurationEnd = false;
}
else
{
iTimeTrigger.Repetition.StopAtDurationEnd = true;
iTimeTrigger.Repetition.Duration = ConvertTimeSpanToWTSString(jobTrigger.RepetitionDuration.Value);
}
}
iTrigger.StartBoundary = ConvertDateTimeToString(jobTrigger.At);
iTrigger.Id = jobTrigger.Id.ToString(CultureInfo.InvariantCulture);
iTrigger.Enabled = jobTrigger.Enabled;
}
break;
case TriggerFrequency.Daily:
{
iTrigger = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_DAILY);
IDailyTrigger iDailyTrigger = iTrigger as IDailyTrigger;
Debug.Assert(iDailyTrigger != null);
iDailyTrigger.RandomDelay = ConvertTimeSpanToWTSString(jobTrigger.RandomDelay);
iDailyTrigger.DaysInterval = (short)jobTrigger.Interval;
iTrigger.StartBoundary = ConvertDateTimeToString(jobTrigger.At);
iTrigger.Id = jobTrigger.Id.ToString(CultureInfo.InvariantCulture);
iTrigger.Enabled = jobTrigger.Enabled;
}
break;
case TriggerFrequency.Weekly:
{
iTrigger = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_WEEKLY);
IWeeklyTrigger iWeeklyTrigger = iTrigger as IWeeklyTrigger;
Debug.Assert(iWeeklyTrigger != null);
iWeeklyTrigger.RandomDelay = ConvertTimeSpanToWTSString(jobTrigger.RandomDelay);
iWeeklyTrigger.WeeksInterval = (short)jobTrigger.Interval;
iWeeklyTrigger.DaysOfWeek = ConvertDaysOfWeekToMask(jobTrigger.DaysOfWeek);
iTrigger.StartBoundary = ConvertDateTimeToString(jobTrigger.At);
iTrigger.Id = jobTrigger.Id.ToString(CultureInfo.InvariantCulture);
iTrigger.Enabled = jobTrigger.Enabled;
}
break;
}
}
private void AddTaskTrigger(ITaskDefinition iTaskDefinition, ScheduledJobTrigger jobTrigger)
{
ITrigger str;
string user;
TriggerFrequency frequency = jobTrigger.Frequency;
switch (frequency)
{
case TriggerFrequency.Once:
{
str = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_TIME);
ITimeTrigger wTSString = str as ITimeTrigger;
wTSString.RandomDelay = ScheduledJobWTS.ConvertTimeSpanToWTSString(jobTrigger.RandomDelay);
TimeSpan? repetitionInterval = jobTrigger.RepetitionInterval;
if (repetitionInterval.HasValue)
{
TimeSpan? repetitionDuration = jobTrigger.RepetitionDuration;
if (repetitionDuration.HasValue)
{
TimeSpan? nullable = jobTrigger.RepetitionInterval;
wTSString.Repetition.Interval = ScheduledJobWTS.ConvertTimeSpanToWTSString(nullable.Value);
TimeSpan? repetitionDuration1 = jobTrigger.RepetitionDuration;
if (repetitionDuration1.Value != TimeSpan.MaxValue)
{
wTSString.Repetition.StopAtDurationEnd = true;
TimeSpan? nullable1 = jobTrigger.RepetitionDuration;
wTSString.Repetition.Duration = ScheduledJobWTS.ConvertTimeSpanToWTSString(nullable1.Value);
}
else
{
wTSString.Repetition.StopAtDurationEnd = false;
}
}
}
str.StartBoundary = ScheduledJobWTS.ConvertDateTimeToString(jobTrigger.At);
int id = jobTrigger.Id;
str.Id = id.ToString(CultureInfo.InvariantCulture);
str.Enabled = jobTrigger.Enabled;
return;
}
case TriggerFrequency.Daily:
{
str = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_DAILY);
IDailyTrigger interval = str as IDailyTrigger;
interval.RandomDelay = ScheduledJobWTS.ConvertTimeSpanToWTSString(jobTrigger.RandomDelay);
interval.DaysInterval = (short)jobTrigger.Interval;
str.StartBoundary = ScheduledJobWTS.ConvertDateTimeToString(jobTrigger.At);
int num = jobTrigger.Id;
str.Id = num.ToString(CultureInfo.InvariantCulture);
str.Enabled = jobTrigger.Enabled;
return;
}
case TriggerFrequency.Weekly:
{
str = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_WEEKLY);
IWeeklyTrigger mask = str as IWeeklyTrigger;
mask.RandomDelay = ScheduledJobWTS.ConvertTimeSpanToWTSString(jobTrigger.RandomDelay);
mask.WeeksInterval = (short)jobTrigger.Interval;
mask.DaysOfWeek = ScheduledJobWTS.ConvertDaysOfWeekToMask(jobTrigger.DaysOfWeek);
str.StartBoundary = ScheduledJobWTS.ConvertDateTimeToString(jobTrigger.At);
int id1 = jobTrigger.Id;
str.Id = id1.ToString(CultureInfo.InvariantCulture);
str.Enabled = jobTrigger.Enabled;
return;
}
case TriggerFrequency.AtLogon:
{
str = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_LOGON);
ILogonTrigger variable = str as ILogonTrigger;
ILogonTrigger variable1 = variable;
if (ScheduledJobTrigger.IsAllUsers(jobTrigger.User))
{
user = null;
}
else
{
user = jobTrigger.User;
}
variable1.UserId = user;
variable.Delay = ScheduledJobWTS.ConvertTimeSpanToWTSString(jobTrigger.RandomDelay);
int num1 = jobTrigger.Id;
str.Id = num1.ToString(CultureInfo.InvariantCulture);
str.Enabled = jobTrigger.Enabled;
return;
}
case TriggerFrequency.AtStartup:
{
str = iTaskDefinition.Triggers.Create(_TASK_TRIGGER_TYPE2.TASK_TRIGGER_BOOT);
IBootTrigger wTSString1 = str as IBootTrigger;
wTSString1.Delay = ScheduledJobWTS.ConvertTimeSpanToWTSString(jobTrigger.RandomDelay);
int id2 = jobTrigger.Id;
str.Id = id2.ToString(CultureInfo.InvariantCulture);
str.Enabled = jobTrigger.Enabled;
return;
}
default:
{
return;
}
}
}
internal virtual void Bind(ITaskDefinition iTaskDef)
{
var iTriggers = iTaskDef.Triggers;
v2Trigger = iTriggers.Create(ttype);
Marshal.ReleaseComObject(iTriggers);
foreach (var key in unboundValues.Keys) {
try {
var o = unboundValues[key];
CheckBindValue(key, ref o);
v2Trigger.GetType().InvokeMember(key, BindingFlags.SetProperty, null, v2Trigger, new[] {o});
} catch (TargetInvocationException tie) {
throw tie.InnerException;
} catch {
}
}
unboundValues.Clear();
unboundValues = null;
repititionPattern = new RepetitionPattern(this);
repititionPattern.Bind();
}
public IRegisteredTask RegisterTaskDefinition (string Path, ITaskDefinition pDefinition, int flags, object UserId, object password, _TASK_LOGON_TYPE LogonType, object sddl)
{
throw new NotImplementedException ();
}
private ScheduledJobOptions CreateJobOptions(
ITaskDefinition iTaskDefinition)
{
ITaskSettings iTaskSettings = iTaskDefinition.Settings;
IPrincipal iPrincipal = iTaskDefinition.Principal;
return new ScheduledJobOptions(
!iTaskSettings.DisallowStartIfOnBatteries,
iTaskSettings.StopIfGoingOnBatteries,
iTaskSettings.WakeToRun,
!iTaskSettings.RunOnlyIfIdle,
iTaskSettings.IdleSettings.StopOnIdleEnd,
iTaskSettings.IdleSettings.RestartOnIdle,
ParseWTSTime(iTaskSettings.IdleSettings.IdleDuration),
ParseWTSTime(iTaskSettings.IdleSettings.WaitTimeout),
!iTaskSettings.Hidden,
iPrincipal.RunLevel == _TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST,
!iTaskSettings.RunOnlyIfNetworkAvailable,
!iTaskSettings.AllowDemandStart,
ConvertToMultiInstances(iTaskSettings));
}
private void AddTaskAction(
ITaskDefinition iTaskDefinition,
ScheduledJobDefinition definition)
{
IExecAction iExecAction = iTaskDefinition.Actions.Create(_TASK_ACTION_TYPE.TASK_ACTION_EXEC) as IExecAction;
Debug.Assert(iExecAction != null);
iExecAction.Id = ScheduledJobTaskActionId;
iExecAction.Path = definition.PSExecutionPath;
iExecAction.Arguments = definition.PSExecutionArgs;
}
