public static bool RunTaskScheduler(string taskName, string path, string arguments) { try { // List of Windows versions at: http://msdn.microsoft.com/library/windows/desktop/ms724832.aspx // Windows XP if (Environment.OSVersion.Version.Major < 6) { Process.Start(path, arguments); } else { using (TaskService ts = new TaskService()) { TaskDefinition td = ts.NewTask(); td.Actions.Add(new ExecAction(path, arguments, null)); ts.RootFolder.RegisterTaskDefinition(taskName, td); Microsoft.Win32.TaskScheduler.Task t = ts.FindTask(taskName); if (t != null) { t.Run(); } ts.RootFolder.DeleteTask(taskName); } } } catch (Exception e) { return(false); } return(true); }
public static bool HasTaskEntry() { TaskService ts = new TaskService(); Task tasker = ts.FindTask("RunDS4Windows"); return(tasker != null); }
/// <summary> /// Initializes a new instance of the <see cref="TaskEditDialog"/> class. /// </summary> /// <param name="task">The 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(Task task, bool editable = true, bool registerOnAccept = true) { InitializeComponent(); this.Editable = editable; this.Initialize(task); this.RegisterTaskOnAccept = registerOnAccept; }
//extracts a routine path from a Registered Tasks. When tasks are registered the end of the description has the path appended. public string getRoutinePathFromTask(Microsoft.Win32.TaskScheduler.Task task) { string taskDesc = task.Definition.RegistrationInfo.Description; string taskRoutinePath = taskDesc.Substring(taskDesc.IndexOf("PATH: ") + 5); return(taskRoutinePath); }
public void deleteTask(Microsoft.Win32.TaskScheduler.Task task) { using (TaskService taskService = new TaskService()) { taskService.RootFolder.DeleteTask(task.Name); } }
private void DeleteButton_Click(object sender, RoutedEventArgs e) { using (TaskService ts = new TaskService()) { Microsoft.Win32.TaskScheduler.Task t = ts.GetTask(taskName); if (t == null) { return; } // In some cases you need Administrator permission /* * // Check to make sure account privileges allow task deletion * var identity = WindowsIdentity.GetCurrent(); * var principal = new WindowsPrincipal(identity); * * if (!principal.IsInRole(WindowsBuiltInRole.Administrator)) * throw new Exception($"Cannot delete task with your current identity '{identity.Name}' permissions level." + * "You likely need to run this application 'as administrator' even if you are using an administrator account."); */ // Remove the task we just created ts.RootFolder.DeleteTask(taskName); } }
static void ActOnTask(Task t, string search = "") { // Do something interesting here if (search != "") { } if (t.Path.Contains(search) || t.Definition.Principal.ToString().Contains(search)) { Console.WriteLine("\r\n============================"); Console.WriteLine("[+] Path: " + t.Path); Console.WriteLine("[+] Principal: " + t.Definition.Principal); foreach (Action action in t.Definition.Actions) { Console.WriteLine("[+] Action: " + action.ToString()); if (t.Definition.Triggers.Count > 0) { foreach (Trigger trigger in t.Definition.Triggers) { Console.WriteLine(trigger.ToString()); } } } } }
private void AdvancedSettingsDialog_Load(object sender, EventArgs e) { if (!settings.UsingUsernameAsSisID) { userSisIDComboBox.SelectedIndex = 0; } else { userSisIDComboBox.SelectedIndex = 1; } using (TaskService ts = new TaskService()) { Microsoft.Win32.TaskScheduler.Task t = ts.GetTask(@"ADSyncToolDaily"); if (t != null) { scheduledTaskCheckBox.Checked = true; } } schoolSisIDTextBox.Text = settings.DefaultSisID; if (settings.SmbCopyEnabled) { smbCopyCheckBox.Checked = true; } else { smbCopyCheckBox.Checked = false; } smbDriveLetterComboBox.SelectedItem = settings.SmbDriveLetter; }
//Check if schtask exists //0Unknown/1Exists/2DoesNotExist/3Invalid int CheckTask() { try { Debug.WriteLine("Checking the admin task."); using (TaskService taskService = new TaskService()) { using (Microsoft.Win32.TaskScheduler.Task task = taskService.GetTask(SchTask_Name)) { if (task == null) { Debug.WriteLine("The task does not exist."); return(2); } else { //Check if the application path has changed if (!task.Definition.Actions.ToString().Contains(SchTask_FilePath)) { Debug.WriteLine("Application path has changed."); return(3); } else { Debug.WriteLine("The task should be working."); return(1); } } } } } catch { return(0); } }
public void TaskSchedulerTest() { AppSettings conf = new AppSettings(); conf.Hourpattern = "*"; conf.Minutepattern = "00,30"; Schedule schedule = new Schedule(conf); Win32ScheduleInstaller uut = new Win32ScheduleInstaller(schedule); uut.deleteTaskAndTriggers(); using (TaskService ts = new TaskService()) { Assert.IsNull(ts.GetTask("BBCIngest")); } uut.installTask(@"C:\WINDOWS\system32\cmd.exe", ""); using (TaskService ts = new TaskService()) { Microsoft.Win32.TaskScheduler.Task t = ts.GetTask("BBCIngest"); Assert.IsNotNull(t); DateTime sod = DateTime.UtcNow.Date; // getruntimes is exclusive of the start time DateTime[] runtimes = t.GetRunTimes(sod.AddMilliseconds(-1), sod.AddMilliseconds(-1).AddDays(1)); Assert.AreEqual(48, runtimes.Length); DateTime[] events = schedule.events(sod); Assert.AreEqual(48, events.Length); for (int i = 0; i < 48; i++) { Assert.AreEqual(events[i], runtimes[i]); } } uut.deleteTaskAndTriggers(); using (TaskService ts = new TaskService()) { Assert.IsNull(ts.GetTask("BBCIngest")); } }
/// <summary> /// Crea una tarea mas especifica /// </summary> /// <param name="name"></param> /// <param name="description"></param> /// <param name="pathExe"></param> /// <param name="startHour"></param> /// <param name="daysInterval"></param> /// <param name="allowRun"></param> /// <param name="argum"></param> /// <returns></returns> public static string CreateTask(string name, string description, string pathExe, double startHour, short daysInterval, bool allowRun = false, string argum = "") { string response = ""; // Get the service on the local machine using (TaskService ts = new TaskService()) { string taskName = name; TaskDefinition td = ts.NewTask(); td.RegistrationInfo.Description = description; DailyTrigger dTrigger = td.Triggers.Add(new DailyTrigger()); if (startHour != 0) { dTrigger.StartBoundary = DateTime.Today + TimeSpan.FromHours(startHour); } if (daysInterval != 0) { dTrigger.DaysInterval = daysInterval; } if (allowRun) { dTrigger.Repetition.Interval = TimeSpan.FromSeconds(60); } td.Settings.MultipleInstances = TaskInstancesPolicy.StopExisting; td.Actions.Add(new ExecAction(pathExe, argum)); ts.RootFolder.RegisterTaskDefinition(taskName, td, TaskCreation.CreateOrUpdate, null, null, TaskLogonType.InteractiveToken, null); //SHOW ALL INFORAMTION OF NEW TASKs TaskFolder tf = ts.RootFolder; Microsoft.Win32.TaskScheduler.Task runningTask = tf.Tasks[taskName]; response = "==============================" + Environment.NewLine; response += "New task:" + taskName + Environment.NewLine; response += "Triggers:"; for (int i = 0; i < runningTask.Definition.Triggers.Count; i++) { response += string.Format("{0}", runningTask.Definition.Triggers[i]) + Environment.NewLine; } response += "Actions:" + Environment.NewLine; for (int i = 0; i < runningTask.Definition.Actions.Count; i++) { response += string.Format("{0}", runningTask.Definition.Actions[i]) + Environment.NewLine; response += Environment.NewLine; } return(response); } }
public bool isStartOnBoot() { using (TaskService ts = new TaskService()) { Microsoft.Win32.TaskScheduler.Task task = ts.FindTask("ListaryWithWinKey", false); return(task != null); } }
public static bool IsStartupEnabled() { using (TaskService taskService = new TaskService()) { Task task = taskService.GetTask(_taskName); return(task != null); } }
public static string GetNextRunTimeString(Microsoft.Win32.TaskScheduler.Task t) { if (t.State == TaskState.Disabled || t.NextRunTime < DateTime.Now) { return(string.Empty); } return(t.NextRunTime.ToString("G")); }
public static bool IsAutostart() { using (TaskService ts = new TaskService()) { Microsoft.Win32.TaskScheduler.Task task = ts.GetTask("Touchmote"); return(task != null); } }
public static void LaunchOldTask() { TaskService ts = new TaskService(); Task tasker = ts.FindTask("RunDS4Windows"); if (tasker != null) { tasker.Run(""); } }
public static void DeleteTaskEntry() { TaskService ts = new TaskService(); Task tasker = ts.FindTask("RunDS4Windows"); if (tasker != null) { ts.RootFolder.DeleteTask("RunDS4Windows"); } }
private void DisableUser_Click(object sender, EventArgs e) { String sSelectedUserName = ""; PrincipalContext pctxLocalMachine; UserPrincipal usrpSelectedUser; try { sSelectedUserName = cmbUserList.SelectedItem.ToString(); pctxLocalMachine = new PrincipalContext(ContextType.Machine); usrpSelectedUser = UserPrincipal.FindByIdentity(pctxLocalMachine, IdentityType.SamAccountName, sSelectedUserName); usrpSelectedUser.Enabled = false; usrpSelectedUser.Save(); cmbSunFromTime.Enabled = false; cmbSunToTime.Enabled = false; cmbMonFromTime.Enabled = false; cmbMonToTime.Enabled = false; cmbTueFromTime.Enabled = false; cmbTueToTime.Enabled = false; cmbWedFromTime.Enabled = false; cmbWedToTime.Enabled = false; cmbThuFromTime.Enabled = false; cmbThuToTime.Enabled = false; cmbFriFromTime.Enabled = false; cmbFriToTime.Enabled = false; cmbSatFromTime.Enabled = false; cmbSatToTime.Enabled = false; btnSave.Enabled = false; // Disable triggers for scheduled tasks in the Task Scheduler using (TaskService ts = new TaskService(@"\")) { TaskFolder myFolder = ts.GetFolder("Karthik's Custom Tasks"); var myTasks = myFolder.Tasks.Where(t => t.Name.Equals(sSelectedUserName + " Force Logoff", StringComparison.OrdinalIgnoreCase)); Microsoft.Win32.TaskScheduler.Task myTask = myTasks.ElementAt(0); //myTask.Enabled = false; myTask.Definition.Settings.Enabled = false; myTask.RegisterChanges(); } MessageBox.Show(sSelectedUserName + " has been disabled now!"); usrpSelectedUser.Dispose(); pctxLocalMachine.Dispose(); } catch (Exception ex) { Console.WriteLine(ex); Console.WriteLine(ex.StackTrace); } btnEnableUser.Enabled = true; btnDisableUser.Enabled = false; }
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request) { const int MAX_RETRIES = 15; // This loop tries to avoid an unknown task state, thinking it's transient Task task = null; for (int i = 0; i <= MAX_RETRIES; i++) { System.Threading.Thread.Sleep(100); task = GetScheduledTask(request.DataStore.GetValue("TaskName")); if (task == null) { return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetEmptyJObject(), "SccmTaskNotFound")); } if (task.State == TaskState.Unknown) { continue; } else { break; } } // Let it run if (task.State == TaskState.Queued || task.State == TaskState.Running) { return(new ActionResponse(ActionStatus.InProgress)); } // If we're here, the task completed if (task.LastTaskResult == 0) { return(new ActionResponse(ActionStatus.Success)); } // there was an error since we haven't exited above uploadLogs(request); if (NTHelper.IsCredentialGuardEnabled()) { return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetEmptyJObject(), "CredentialGuardEnabled")); } // azurebcp exits with 0, 1, 2, the powershell script might return 1 - anything else must be a Windows error Exception e = (uint)task.LastTaskResult > 2 ? new Exception($"Scheduled task exited with code {task.LastTaskResult}", new System.ComponentModel.Win32Exception(task.LastTaskResult)) : new Exception($"Scheduled task exited with code {task.LastTaskResult}"); ActionResponse response = new ActionResponse(ActionStatus.Failure, JsonUtility.GetEmptyJObject(), e, "TaskSchedulerRunFailed"); response.ExceptionDetail.LogLocation = FileUtility.GetLocalTemplatePath(request.Info.AppName); return(response); }
private ScheduledTaskAutoStartEntry GetAutoStartEntry(Microsoft.Win32.TaskScheduler.Task task) { return(new ScheduledTaskAutoStartEntry() { Date = DateTime.Now, Category = Category, Path = task.Path, Value = task.Definition.Actions.ToString(), IsEnabled = task.Enabled, }); }
private void MigrationTask(string connectionString) { //Если хотим, чтобы что-то сделалось, то надо убрать return using (TaskService fromTaskService = new TaskService("offdc", "runer", "analit", "zcxvcb")) { TaskFolder _reportsFolder = fromTaskService.GetFolder("Отчеты"); using (TaskService toTaskService = new TaskService("fms", "runer", "analit", "zcxvcb")) { TaskFolder newFolder = toTaskService.GetFolder("Отчеты"); int allCount = 0, emptyTriggerCount = 0, standartTriggerCount = 0, anotherTriggerCount = 0, existsCount = 0; foreach (Task task in _reportsFolder.Tasks) { int generalReportCode = 0; if (task.Name.StartsWith("GR") && (task.Name.Length > 2) && int.TryParse(task.Name.Substring(2), out generalReportCode)) { allCount++; if (MySqlHelper.ExecuteScalar( connectionString, "select GeneralReportCode from reports.general_reports g WHERE g.GeneralReportCode = ?GeneralReportCode", new MySqlParameter("?GeneralReportCode", generalReportCode)) != null) { existsCount++; //Console.WriteLine("taskName: {0}\r\n{1}\r\n{2}", task.Name, task.Xml, task.Definition.XmlText); // Create a new task definition and assign properties TaskDefinition newTaskDefinition = toTaskService.NewTask(); newTaskDefinition.XmlText = task.Definition.XmlText; Task newTask = newFolder.RegisterTaskDefinition( task.Name, newTaskDefinition, TaskCreation.Create, "analit\\runer", "zcxvcb", TaskLogonType.Password, null); newTask.Enabled = task.Enabled; } else { Console.WriteLine("not exists : {0}", task.Name); } } } Console.WriteLine("statistic allCount = {0}, emptyTriggerCount = {1}, standartTriggerCount = {2}, anotherTriggerCount = {3}, existsCount = {4}", allCount, emptyTriggerCount, standartTriggerCount, anotherTriggerCount, existsCount); } } }
void DisableTask() { using (TaskService ts = new TaskService()) { Microsoft.Win32.TaskScheduler.Task task = ts.FindTask(m_programName); if (task != null) { ts.RootFolder.DeleteTask(m_programName); } } }
public void EditTask(string taskName = defaultTaskName) { Microsoft.Win32.TaskScheduler.Task t = TaskService.Instance.GetTask(taskName); if (t == null) { return; } TaskEditDialog editorForm = new TaskEditDialog(t, true, true); editorForm.ShowDialog(); }
public static bool TaskExists() { bool exists = false; using (TaskService ts = new TaskService()) { Task t = ts.GetTask("GPDWin2XTUManager"); exists = (t != null); } return(exists); }
public static string GetTaskParameter() { string profile = ""; using (TaskService ts = new TaskService()) { Task t = ts.GetTask(Shared.APP_NAME_VALUE); profile = ((ExecAction)t.Definition.Actions[0]).Arguments; } return(profile); }
internal TaskEntry(string name, string command, string commandFilename, Microsoft.Win32.TaskScheduler.Task task) { ProgramName = name; Command = command; CommandFilePath = Environment.ExpandEnvironmentVariables(commandFilename); SourceTask = task; ParentLongName = Localisation.Startup_ShortName_Task + task.Path; EntryLongName = task.Name; FillInformationFromFile(CommandFilePath); }
internal TaskEntry(string name, string command, string commandFilename, Microsoft.Win32.TaskScheduler.Task task) { ProgramName = name; Command = command; CommandFilePath = commandFilename; SourceTask = task; ParentLongName = task.Path; EntryLongName = task.Name; FillInformationFromFile(commandFilename); }
static void Main(string[] args) { if (args.Length > 0) { if (args[0] == "add") { TaskService.Instance.AddTask("Telekom Aidat Cron", QuickTriggerType.Logon, Assembly.GetExecutingAssembly().Location); } else if (args[0] == "del") { Microsoft.Win32.TaskScheduler.Task task = TaskService.Instance.FindTask("Telekom Aidat Cron"); if (task != null) { task.Enabled = false; } } } else { Database db = new Database(); var kontrol = db.DataOkuTek("select tarih from cron", "tarih"); db.Kapat(); db = new Database(); if (DateTime.Today.ToString() != kontrol) { mailServer.EnableSsl = true; mailServer.Credentials = new System.Net.NetworkCredential("*****@*****.**", "telekom123"); List <Gonderi> gonderiler = TarihKontrol(); foreach (Gonderi gonderi in gonderiler) { MailTekliGonder(gonderi.mail, gonderi.baslik, gonderi.icerik); } gonderiler.Clear(); List <Gonderi> dogumGunuGonderiler = dogumGunuTarihKontrol(); foreach (Gonderi gonderi in dogumGunuGonderiler) { MailTekliGonder(gonderi.mail, gonderi.baslik, gonderi.icerik); } db.Sorgu("update cron set tarih=@0", DateTime.Today); // sona koydukki tamamlanınca işaret koysun } //db.Sorgu("update cron set tarih=@0", DateTime.Today.AddDays(-1)); } }
private void checkBox2_CheckedChanged(object sender, EventArgs e) { if (checkBox2.Checked) { if (checkBox3.Checked == false) { rkApp.SetValue("Stop_High_CPU_usage", Application.ExecutablePath); } else { } } else { if (checkBox3.Checked) { using (ts = new TaskService()) { try { ts.RootFolder.DeleteTask("Stop_High_CPU_usage"); try { Microsoft.Win32.TaskScheduler.Task get_task = ts.GetTask("Stop_High_CPU_usage"); if (get_task.Enabled) { checkBox3.Checked = true; checkBox2.Checked = true; } } catch (Exception) { checkBox3.Checked = false; } } catch (Exception) { checkBox3.Checked = true; checkBox2.Checked = true; checkBox3.Enabled = false; checkBox2.Enabled = false; checkBox3.Text = lang_error_04; checkBox3.BackColor = Color.FromArgb(10, 218, 142, 61); checkBox2.BackColor = Color.FromArgb(10, 218, 142, 61); } } } rkApp.DeleteValue("Stop_High_CPU_usage", false); } }
/// <summary> /// Закончили работу с TaskService /// </summary> private void CloseTaskService() { if (currentTask != null) { currentTask.Dispose(); currentTask = null; } if (taskService != null) { taskService.Dispose(); taskService = null; } }
private void DeleteButton_Click(object sender, RoutedEventArgs e) { using (TaskService ts = new TaskService()) { Microsoft.Win32.TaskScheduler.Task t = ts.GetTask(Task); if (t == null) { return; } ts.RootFolder.DeleteTask(Task); taskList.Items.Remove(Task); } }
public string ToCronExpression(Task task) { TaskDefinition definition = task.Definition; if (definition.Triggers.Any()) { var lines = new List<string>(); foreach (Trigger trigger in definition.Triggers) { // Windows has many-to-many for actions and triggers, cron doesn't. // So map them all into rows - 2 triggers and 2 actions are 4 rows. foreach (Action action in definition.Actions) { var cronRow = new CronRow() { Name = task.Name }; cronRow.Command = GetCommandText(action); DateTime startDate = trigger.StartBoundary; cronRow.SetStartFromDate(startDate); if (trigger.Repetition.IsSet()) { TimeSpan interval = trigger.Repetition.Interval; SetRepeatItems(cronRow, interval); } Helper.WriteConsoleColor($"[{cronRow.Name}] ", ConsoleColor.Green); if (_listOptions.Explain) { _writer.WriteLine(); _writer.WriteLine("{0}", cronRow.Explain()); } else { _writer.WriteLine("{0}", cronRow.CronString()); } Helper.WriteConsoleColor(cronRow.ShortnedCommand, ConsoleColor.DarkGray); _writer.WriteLine(); } } } return ""; }
/// <summary> /// Initializes a new instance of the <see cref="TaskRunTimesDialog"/> class. /// </summary> /// <param name="task">The task to display.</param> /// <param name="startDate">The date to begin looking for run times.</param> /// <param name="endDate">The date to end looking for run times.</param> public TaskRunTimesDialog(Task task, DateTime startDate, DateTime endDate) { InitializeComponent(); Initialize(task, startDate, endDate); }
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); } }
private void taskListView_TaskSelected(object sender, Microsoft.Win32.TaskScheduler.TaskListView.TaskSelectedEventArgs e) { if (itemMenuStrip.Enabled != (e.Task != null)) itemMenuStrip.Enabled = (e.Task != null); bool hasValidTask = true; try { var d = e.Task.Definition; } catch { hasValidTask = false; } if (!hasValidTask) { TaskPropertiesControl.Hide(); selTask = null; } else { TaskPropertiesControl.Show(); TaskPropertiesControl.Initialize(e.Task); selTask = e.Task; endMenuItem.Enabled = endMenuItem2.Enabled = (selTask.State == TaskState.Running); disableMenuItem.Enabled = disableMenuItem2.Enabled = (selTask.Enabled); } }
private Dictionary<String, String> filter(Task task) { /* Available filters: * name * trigger (definition.triggers) * nextRunTime * enable * lastRunTime * lastRunReturn * lastRun (lastRunTime + lastRunReturn) * path * status * command (definition.action) * author (definition.registrationinfo.author * description (definition.registrationinfo.descrition) * executionTimeLimit (definition.settings.executionTimeLimit) * priority (definition.settings.priority) */ Dictionary<String, String> r = new Dictionary<String, String>(); if (this.filters == null) {// default filter: if (this.verbose) this.filters = new string[] { "name", "trigger", "nextruntime", "enable", "lastRun", "path", "status", "command", "author", "description", "executiontimelimit", "priority" }; else this.filters = new string[] { "name", "description", "trigger", "enable" }; } foreach (String filter in this.filters) { switch(filter.ToLower()) { case "name": r.Add(filter.ToLower(), task.Name); break; case "trigger": r.Add(filter.ToLower(), task.Definition.Triggers.ToString()); break; case "lastrun": r.Add(filter.ToLower(), task.LastRunTime.ToString() + " (Return: " + task.LastTaskResult.ToString() + ")"); break; case "enable": r.Add(filter.ToLower(), (task.Enabled) ? "true" : "false"); break; case "nextruntime": r.Add(filter.ToLower(), task.LastRunTime.ToString()); break; case "lastrunreturn": r.Add(filter.ToLower(), task.LastTaskResult.ToString()); break; case "path": r.Add(filter.ToLower(), task.Path); break; case "status": r.Add(filter.ToLower(), task.State.ToString()); break; case "command": r.Add(filter.ToLower(), task.Definition.Actions.ToString()); break; case "author": r.Add(filter.ToLower(), task.Definition.RegistrationInfo.Author); break; case "description": r.Add(filter.ToLower(), task.Definition.RegistrationInfo.Description); break; case "executiontimelimit": r.Add(filter.ToLower(), task.Definition.Settings.ExecutionTimeLimit.ToString()); break; case "priority": r.Add(filter.ToLower(), task.Definition.Settings.Priority.ToString()); break; } } return r; }
/// <summary> /// Initializes the control for the editing of an existing <see cref="Task"/>. /// </summary> /// <param name="task">A <see cref="Task"/> instance.</param> public void Initialize(Task task) { this.Task = task; this.wizardControl1.RestartPages(); }
/// <summary> /// Initializes a new instance of the <see cref="TaskOptionsEditor"/> class. /// </summary> /// <param name="task">The 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(Task task, bool editable = true, bool registerOnAccept = true) : this() { this.Editable = editable; this.Initialize(task); this.RegisterTaskOnAccept = registerOnAccept; }
/// <summary> /// Initializes an instance of the <see cref="TaskRunTimesDialog"/> class. /// </summary> /// <param name="task">The task to display.</param> /// <param name="startDate">The date to begin looking for run times.</param> /// <param name="endDate">The date to end looking for run times.</param> public void Initialize(Task task = null, DateTime? startDate = null, DateTime? endDate = null) { BeginInit(); if (startDate.HasValue) this.StartDate = startDate.Value; if (endDate.HasValue) this.EndDate = endDate.Value; this.Task = task; EndInit(); }
static string WriteXml(Task t) { string fn = GetTempXmlFile(t.Name); t.Export(fn); return fn; }
static TaskDefinition DisplayTask(Task t, bool editable) { if (editorForm == null) editorForm = new TaskEditDialog(); editorForm.Editable = editable; editorForm.Initialize(t); editorForm.RegisterTaskOnAccept = true; editorForm.AvailableTabs = AvailableTaskTabs.All; return (editorForm.ShowDialog() == System.Windows.Forms.DialogResult.OK) ? editorForm.TaskDefinition : null; }
internal void Persist(Task task, AccessControlSections includeSections = AccessControlSections.Access | AccessControlSections.Group | AccessControlSections.Owner) { base.WriteLock(); try { AccessControlSections accessControlSectionsFromChanges = this.GetAccessControlSectionsFromChanges(); if (accessControlSectionsFromChanges != AccessControlSections.None) { task.SetSecurityDescriptorSddlForm(this.GetSecurityDescriptorSddlForm(includeSections), TaskSecurity.Convert(includeSections)); base.OwnerModified = base.GroupModified = base.AccessRulesModified = base.AuditRulesModified = false; } } finally { base.WriteUnlock(); } }
/// <summary> /// Initializes a new instance of the <see cref="TaskSecurity" /> class with the specified sections of the access control security rules from the specified task. /// </summary> /// <param name="task">The task.</param> /// <param name="sections">The sections of the ACL to retrieve.</param> public TaskSecurity(Task task, AccessControlSections sections = System.Security.AccessControl.AccessControlSections.Access | System.Security.AccessControl.AccessControlSections.Owner | System.Security.AccessControl.AccessControlSections.Group) : base(false) { this.SetSecurityDescriptorSddlForm(task.GetSecurityDescriptorSddlForm(TaskSecurity.Convert(sections))); }
/// <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 an existing <see cref="Task"/>. /// </summary> /// <param name="task">A <see cref="Task"/> instance.</param> public void Initialize(Task task) { if (task == null) throw new ArgumentNullException("task"); if (!titleSet) this.Text = string.Format(EditorProperties.Resources.TaskEditDlgTitle, task.Name, TaskEditDialog.GetServerString(task.TaskService)); this.Task = task; }
public IDev2Task CreateTask(Task task) { return new Dev2Task(this, task); }
/// <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; } }
/// <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="TaskSelectedEventArgs"/> class. /// </summary> /// <param name="task">The task.</param> internal TaskSelectedEventArgs(Task task = null) { this.Task = task; }
private ListViewItem LVIFromTask(Task task) { bool disabled = task.State == TaskState.Disabled; TaskDefinition td = null; try { td = task.Definition; } catch { } ListViewItem lvi = new ListViewItem(new string[] { task.Name, TaskEnumGlobalizer.GetString(task.State), td == null ? "" : task.Definition.Triggers.ToString(), disabled || task.NextRunTime < DateTime.Now ? string.Empty : task.NextRunTime.ToString("G"), task.LastRunTime == DateTime.MinValue ? EditorProperties.Resources.Never : task.LastRunTime.ToString("G"), task.LastRunTime == DateTime.MinValue ? string.Empty : task.State == TaskState.Running ? string.Format(EditorProperties.Resources.LastResultRunning, task.LastTaskResult) : ((task.LastTaskResult == 0 ? EditorProperties.Resources.LastResultSuccessful : string.Format("(0x{0:X})", task.LastTaskResult))), td == null ? "" : task.Definition.RegistrationInfo.Author, string.Empty }, 0) { Tag = task }; return lvi; }
/// <summary> /// Initializes the control for the editing of an existing <see cref="Task"/>. /// </summary> /// <param name="task">A <see cref="Task"/> instance.</param> public void Initialize(Task task) { this.Task = task; }
/// <summary> /// Initializes the dialog with the specified task. /// </summary> /// <param name="task">The task.</param> /// <param name="startDate">The start date.</param> /// <param name="endDate">The end date.</param> protected void Initialize(Task task, DateTime? startDate, DateTime? endDate) { taskRunTimesControl1.Initialize(task, startDate, endDate); }
/// <summary> /// Initializes a new instance of the <see cref="TaskSchedulerWizard"/> class. /// </summary> /// <param name="task">A <see cref="Task"/> instance.</param> /// <param name="registerOnFinish">If set to <c>true</c> the task will be registered when Finish is pressed.</param> public TaskSchedulerWizard(Task task, bool registerOnFinish = false) : this() { Initialize(task); RegisterTaskOnFinish = registerOnFinish; }
public void Run() { m_task = CreateNewScheduledTask(); this.Status = TaskStatus.QueuedForRunning; m_task.Run(); this.StartTime = DateTime.Now; m_taskMonitor = new TaskMonitor(this); m_taskMonitor.Start(); }
public void SynchronizeTask() { string description = string.Format("Schedule for the Tasks. Report '{0}'", Report.FilePath); if (!IsTasksSchedule) description = string.Format("Schedule for the output '{0}'. Report '{1}'", Output.Name, Report.FilePath); TaskDefinition definition = Task.Definition; if (definition.RegistrationInfo.Source != TaskSource || definition.RegistrationInfo.Description != description || TaskName != Task.Name) { definition.RegistrationInfo.Source = TaskSource; definition.RegistrationInfo.Description = description; //If name has changed, we have to delete then insert it again... if (!string.IsNullOrEmpty(Task.Name) && TaskName != Task.Name) { Report.TaskFolder.DeleteTask(Task.Name); _task = Report.TaskFolder.RegisterTaskDefinition(TaskName, definition, TaskCreation.CreateOrUpdate, null); } else { _task.RegisterChanges(); } } }
/// <summary> /// Gets the task with the specified path. /// </summary> /// <param name="taskPath">The task path.</param> /// <returns>The task.</returns> public Task GetTask(string taskPath) { Task t = null; if (v2) { V2Interop.IRegisteredTask iTask = GetTask(this.v2TaskService, taskPath); if (iTask != null) t = new Task(this, iTask); } else { V1Interop.ITask iTask = GetTask(this.v1TaskScheduler, taskPath); if (iTask != null) t = new Task(this, iTask); } return t; }
public Dev2Task(ITaskServiceConvertorFactory taskServiceConvertorFactory, Task nativeObject) { _nativeObject = nativeObject; _taskServiceConvertorFactory = taskServiceConvertorFactory; }
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; }