예제 #1
2
		void SaveTask()
		{
			bool isNewTask = true;
			try
			{
				var service = new TaskService();
				TaskDefinition td = service.NewTask();
				Microsoft.Win32.TaskScheduler.TriggerCollection trgCollection;
				var oldTriggerDate = new DateTime();

				Task task = service.FindTask(MainWindowViewModel.FreemiumDriverScanTaskName);

				if (task != null)
				{
					isNewTask = false;
					oldTriggerDate = task.Definition.Triggers.Count > 0 ? task.Definition.Triggers[0].StartBoundary.Date : DateTime.Today;
					task.Definition.Triggers.Clear();
					trgCollection = task.Definition.Triggers;
				}
				else
				{
					td.RegistrationInfo.Description = WPFLocalizeExtensionHelpers.GetUIString("WindowsTaskRegistrationInfo");
					td.Settings.Enabled = true;
					td.Actions.Add(new ExecAction(Environment.CurrentDirectory + @"\1Click.exe"));
					trgCollection = td.Triggers;
				}

				TimeSpan selectedTime = TimeSpan.Parse(((ComboBoxItem)AutoScanTime.SelectedValue).Content.ToString());
				switch (AutoScanPeriod.SelectedIndex)
				{
					case (int)Schedule.Daily:
						{
							var dTrigger = new DailyTrigger {DaysInterval = 1};
							if (isNewTask)
								dTrigger.StartBoundary = DateTime.Today.Date + selectedTime;
							else
								dTrigger.StartBoundary = oldTriggerDate + selectedTime;

							trgCollection.Add(dTrigger);
							break;
						}
					case (int)Schedule.Weekly:
						{
							var wTrigger = new WeeklyTrigger();
							switch (AutoScanDay.SelectedIndex)
							{
								case (int)DayOfWeek.Monday:
									{
										wTrigger.DaysOfWeek = DaysOfTheWeek.Monday;
										break;
									}
								case (int)DayOfWeek.Tuesday:
									{
										wTrigger.DaysOfWeek = DaysOfTheWeek.Tuesday;
										break;
									}
								case (int)DayOfWeek.Wednesday:
									{
										wTrigger.DaysOfWeek = DaysOfTheWeek.Wednesday;
										break;
									}
								case (int)DayOfWeek.Thursday:
									{
										wTrigger.DaysOfWeek = DaysOfTheWeek.Thursday;
										break;
									}
								case (int)DayOfWeek.Friday:
									{
										wTrigger.DaysOfWeek = DaysOfTheWeek.Friday;
										break;
									}
								case (int)DayOfWeek.Saturday:
									{
										wTrigger.DaysOfWeek = DaysOfTheWeek.Saturday;
										break;
									}
								case (int)DayOfWeek.Sunday:
									{
										wTrigger.DaysOfWeek = DaysOfTheWeek.Sunday;
										break;
									}
							}
							trgCollection.Add(wTrigger);
							foreach (WeeklyTrigger trg in trgCollection)
							{
								if (isNewTask)
									trg.StartBoundary = DateTime.Today.Date + selectedTime;
								else
									trg.StartBoundary = oldTriggerDate + selectedTime;
								trg.WeeksInterval = 1;
							}
							break;
						}
					case (int)Schedule.Monthly:
						{
							var mTrigger = new MonthlyTrigger();
							if (isNewTask)
								mTrigger.StartBoundary = DateTime.Today.Date + selectedTime;
							else
								mTrigger.StartBoundary = oldTriggerDate + selectedTime;
							mTrigger.MonthsOfYear = MonthsOfTheYear.AllMonths;
							mTrigger.DaysOfMonth = new int[] { Int16.Parse(((ComboBoxItem)AutoScanDate.SelectedValue).Content.ToString()) };
							trgCollection.Add(mTrigger);
							break;
						}
				}

				// Register the task in the root folder
				if (isNewTask)
					service.RootFolder.RegisterTaskDefinition(MainWindowViewModel.FreemiumDriverScanTaskName, td);
				else
					task.RegisterChanges();

				TaskManager.UpdateTaskStatus(MainWindowViewModel.FreemiumDriverScanTaskName, AutoScan.IsChecked == true);
			}
			catch { }
		}
예제 #2
0
        /// <summary>
        /// Creates default task in the Task Scheduler service
        /// </summary>
        /// <param name="taskName">task name</param>
        /// <param name="isEnabled">true - if enabled, false - otherwise</param>
        public static void CreateDefaultTask(string taskName, bool isEnabled)
        {
            try
            {
                DeleteTask(taskName);

                TaskService service = new TaskService();
                TaskDefinition td = service.NewTask();

                td.Settings.Enabled = isEnabled;
                td.RegistrationInfo.Description = "Free Driver Scout";
                td.Principal.RunLevel = TaskRunLevel.Highest;

                // Create an action that will launch Notepad whenever the trigger fires
                td.Actions.Add(new ExecAction(Environment.CurrentDirectory + "\\1Click.exe", null, Environment.CurrentDirectory));

                WeeklyTrigger mTrigger = new WeeklyTrigger();
                mTrigger.DaysOfWeek = DaysOfTheWeek.Friday;
                mTrigger.StartBoundary = DateTime.Today.AddHours(12);

                mTrigger.Repetition.StopAtDurationEnd = false;
                td.Triggers.Add(mTrigger);
                // Register the task in the root folder
                service.RootFolder.RegisterTaskDefinition(taskName, td);

            }
            catch { }
        }
예제 #3
0
        public void SaveTask(string name, string time, string day, string route, int posicion, string accion)
        {
            using (TaskService ts = new TaskService())
            {
                TaskDefinition td = ts.NewTask();
                td.RegistrationInfo.Description = accion;

                WeeklyTrigger week = new WeeklyTrigger();

                week.StartBoundary = Convert.ToDateTime(DateTime.Today.ToShortDateString() + " " + time);
                week.WeeksInterval = 1;
                switch (day)
                {
                    case "Monday":
                        week.DaysOfWeek = Microsoft.Win32.TaskScheduler.DaysOfTheWeek.Monday;
                        break;
                    case "Tuesday":
                        week.DaysOfWeek = Microsoft.Win32.TaskScheduler.DaysOfTheWeek.Tuesday;
                        break;
                    case "Wednesday":
                        week.DaysOfWeek = Microsoft.Win32.TaskScheduler.DaysOfTheWeek.Wednesday;
                        break;
                    case "Thursday":
                        week.DaysOfWeek = Microsoft.Win32.TaskScheduler.DaysOfTheWeek.Thursday;
                        break;
                    case "Friday":
                        week.DaysOfWeek = Microsoft.Win32.TaskScheduler.DaysOfTheWeek.Friday;
                        break;
                    case "Saturday":
                        week.DaysOfWeek = Microsoft.Win32.TaskScheduler.DaysOfTheWeek.Saturday;
                        break;
                    case "Sunday":
                        week.DaysOfWeek = Microsoft.Win32.TaskScheduler.DaysOfTheWeek.Sunday;
                        break;
                    default:
                        break;

                }
                td.Triggers.Add(week);
                string turn_on;
                if (chkTurnOn.Checked)
                {
                    turn_on = " T";
                }
                else
                {
                    turn_on = " F";
                }

                if (posicion != -1)
                {
                    td.Actions.Add(new ExecAction(route, posicion.ToString() + turn_on, null));
                }
                else {
                    td.Actions.Add(new ExecAction(route, posicion.ToString() + turn_on, null));
                }
                ts.RootFolder.RegisterTaskDefinition(name, td);
            }
        }
예제 #4
0
 public string AddWeeklyTrigger(DateTime startTime)
 {
     WeeklyTrigger wt = new WeeklyTrigger();
     wt.StartBoundary = startTime;
     taskDef.Triggers.Add(wt);
     triggers.Add(wt);
     task.RootFolder.RegisterTaskDefinition(this.taskName, taskDef, TaskCreation.CreateOrUpdate, null, null, TaskLogonType.InteractiveToken, null);
     return "Added";
 }
예제 #5
0
        /// <summary>
        /// Saves all the settings setted in the UI
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void btnOK_Click(object sender, EventArgs e)
        {
            bool isNewTask = true;
            try
            {
                TaskService service = new TaskService();
                TaskDefinition td = service.NewTask();
                TriggerCollection trgCollection;
                DateTime oldTriggerDate = new DateTime();

                Task task = service.FindTask("PCCleaner1ClickMaint");

                if (task != null)
                {
                    isNewTask = false;
                    oldTriggerDate = task.Definition.Triggers.Count > 0
                                        ? task.Definition.Triggers[0].StartBoundary.Date
                                        : DateTime.Today;
                    task.Definition.Triggers.Clear();
                    trgCollection = task.Definition.Triggers;
                }
                else
                {
                    td.RegistrationInfo.Description = "PCCleaner 1 ClickMaint";
                    td.Settings.Enabled = true;
                    td.Actions.Add(new ExecAction(Environment.CurrentDirectory + "\\1Click.exe", System.Diagnostics.Process.GetCurrentProcess().ProcessName, Environment.CurrentDirectory));
                    trgCollection = td.Triggers;
                }

                if (cmbSelectSchedule.SelectedIndex == (int)Schedule.Daily)
                {
                    DailyTrigger dTrigger = new DailyTrigger { DaysInterval = (short)nudDays.Value };

                    if (isNewTask)
                        dTrigger.StartBoundary = DateTime.Today.Date + timePicker.Value.TimeOfDay;
                    else
                        dTrigger.StartBoundary = oldTriggerDate + timePicker.Value.TimeOfDay;

                    trgCollection.Add(dTrigger);
                }
                else if (cmbSelectSchedule.SelectedIndex == (int)Schedule.Weekly)
                {
                    WeeklyTrigger wTrigger = new WeeklyTrigger();

                    if (!chkMon.Checked && !chkTue.Checked && !chkWed.Checked && !chkThu.Checked && !chkFri.Checked && !chkSat.Checked &&
                        !chkSun.Checked)
                    {
                        MessageBox.Show(WPFLocalizeExtensionHelpers.GetUIString("select_day"), System.Windows.Forms.Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                        return;
                    }

                    if (chkMon.Checked && chkTue.Checked && chkWed.Checked && chkThu.Checked && chkFri.Checked && chkSat.Checked &&
                        chkSun.Checked)
                    {
                        wTrigger.DaysOfWeek = DaysOfTheWeek.AllDays;
                        trgCollection.Add(wTrigger);
                        cmbSelectSchedule.SelectedIndex = (int)Schedule.Daily;
                    }
                    else
                    {
                        if (chkMon.Checked)
                        {
                            wTrigger = new WeeklyTrigger { DaysOfWeek = DaysOfTheWeek.Monday };
                            trgCollection.Add(wTrigger);
                        }
                        if (chkTue.Checked)
                        {
                            wTrigger = new WeeklyTrigger { DaysOfWeek = DaysOfTheWeek.Tuesday };
                            trgCollection.Add(wTrigger);
                        }
                        if (chkWed.Checked)
                        {
                            wTrigger = new WeeklyTrigger { DaysOfWeek = DaysOfTheWeek.Wednesday };
                            trgCollection.Add(wTrigger);
                        }
                        if (chkThu.Checked)
                        {
                            wTrigger = new WeeklyTrigger { DaysOfWeek = DaysOfTheWeek.Thursday };
                            trgCollection.Add(wTrigger);
                        }
                        if (chkFri.Checked)
                        {
                            wTrigger = new WeeklyTrigger { DaysOfWeek = DaysOfTheWeek.Friday };
                            trgCollection.Add(wTrigger);
                        }
                        if (chkSat.Checked)
                        {
                            wTrigger = new WeeklyTrigger { DaysOfWeek = DaysOfTheWeek.Saturday };
                            trgCollection.Add(wTrigger);
                        }
                        if (chkSun.Checked)
                        {
                            wTrigger = new WeeklyTrigger { DaysOfWeek = DaysOfTheWeek.Sunday };
                            trgCollection.Add(wTrigger);
                        }
                    }

                    foreach (WeeklyTrigger trg in trgCollection)
                    {
                        if (isNewTask)
                            trg.StartBoundary = DateTime.Today.Date + timePicker.Value.TimeOfDay;
                        else
                            trg.StartBoundary = oldTriggerDate + timePicker.Value.TimeOfDay;

                        trg.WeeksInterval = (short)nudWeeks.Value;
                    }
                }
                else if (cmbSelectSchedule.SelectedIndex == (int)Schedule.Monthly)
                {
                    if (radDay.Checked)
                    {
                        MonthlyTrigger mTrigger = new MonthlyTrigger();

                        if (isNewTask)
                            mTrigger.StartBoundary = DateTime.Today.Date + timePicker.Value.TimeOfDay;
                        else
                            mTrigger.StartBoundary = oldTriggerDate + timePicker.Value.TimeOfDay;

                        mTrigger.MonthsOfYear = MonthsOfTheYear.AllMonths;
                        mTrigger.DaysOfMonth = new[] { (int)nudDayMonth.Value };

                        trgCollection.Add(mTrigger);
                    }
                    else if (radMonth.Checked)
                    {
                        MonthlyDOWTrigger mdTrigger = new MonthlyDOWTrigger();

                        if (cmbday.Text == WPFLocalizeExtensionHelpers.GetUIString("MondayFull"))
                        {
                            mdTrigger.DaysOfWeek = DaysOfTheWeek.Monday;
                        }
                        else if (cmbday.Text == WPFLocalizeExtensionHelpers.GetUIString("TuesdayFull"))
                        {
                            mdTrigger.DaysOfWeek = DaysOfTheWeek.Tuesday;
                        }
                        else if (cmbday.Text == WPFLocalizeExtensionHelpers.GetUIString("WednesdayFull"))
                        {
                            mdTrigger.DaysOfWeek = DaysOfTheWeek.Wednesday;
                        }
                        else if (cmbday.Text == WPFLocalizeExtensionHelpers.GetUIString("ThursdayFull"))
                        {
                            mdTrigger.DaysOfWeek = DaysOfTheWeek.Thursday;
                        }
                        else if (cmbday.Text == WPFLocalizeExtensionHelpers.GetUIString("FridayFull"))
                        {
                            mdTrigger.DaysOfWeek = DaysOfTheWeek.Friday;
                        }
                        else if (cmbday.Text == WPFLocalizeExtensionHelpers.GetUIString("SaturdayFull"))
                        {
                            mdTrigger.DaysOfWeek = DaysOfTheWeek.Saturday;
                        }
                        else if (cmbday.Text == WPFLocalizeExtensionHelpers.GetUIString("SundayFull"))
                        {
                            mdTrigger.DaysOfWeek = DaysOfTheWeek.Sunday;
                        }

                        if (cmbweek.SelectedIndex == 0)
                        {
                            mdTrigger.WeeksOfMonth = WhichWeek.FirstWeek;
                        }
                        else if (cmbweek.SelectedIndex == 1)
                        {
                            mdTrigger.WeeksOfMonth = WhichWeek.SecondWeek;
                        }
                        else if (cmbweek.SelectedIndex == 2)
                        {
                            mdTrigger.WeeksOfMonth = WhichWeek.ThirdWeek;
                        }
                        else if (cmbweek.SelectedIndex == 3)
                        {
                            mdTrigger.WeeksOfMonth = WhichWeek.FourthWeek;
                        }
                        else if (cmbweek.SelectedIndex == 4)
                        {
                            mdTrigger.WeeksOfMonth = WhichWeek.LastWeek;
                        }

                        mdTrigger.MonthsOfYear = MonthsOfTheYear.AllMonths;
                        mdTrigger.StartBoundary = DateTime.Today.Date + timePicker.Value.TimeOfDay;

                        trgCollection.Add(mdTrigger);
                    }
                }
                else if (cmbSelectSchedule.SelectedIndex == (int)Schedule.Once)
                {
                    TimeTrigger tTrigger = new TimeTrigger { StartBoundary = timePickerOnce.Value.Date + timePicker.Value.TimeOfDay };
                    trgCollection.Add(tTrigger);
                }
                else if (cmbSelectSchedule.SelectedIndex == (int)Schedule.AtSystemStartUp)
                {
                    BootTrigger bTrigger = new BootTrigger { Delay = TimeSpan.FromMinutes(2) };
                    trgCollection.Add(bTrigger);
                }
                else if (cmbSelectSchedule.SelectedIndex == (int)Schedule.AtLogon)
                {
                    LogonTrigger lTrigger = new LogonTrigger { Delay = TimeSpan.FromSeconds(1) };
                    trgCollection.Add(lTrigger);
                }
                else if (cmbSelectSchedule.SelectedIndex == (int)Schedule.WhenIdel)
                {
                    IdleTrigger iTrigger = new IdleTrigger();
                    if (isNewTask)
                        iTrigger.StartBoundary = DateTime.Today.Date + TimeSpan.FromMinutes((double)nudMinutes.Value);
                    else
                        iTrigger.StartBoundary = oldTriggerDate + TimeSpan.FromMinutes((double)nudMinutes.Value);

                    trgCollection.Add(iTrigger);
                }

                // Register the task in the root folder
                if (isNewTask)
                    service.RootFolder.RegisterTaskDefinition(@"PCCleaner1ClickMaint", td);
                else
                    task.RegisterChanges();

                ((OneClickAppsViewModel)Application.Current.MainWindow.DataContext).SchedulerText = lblSchedule.Text;

                Close();
            }
            catch
            {
            }
        }
예제 #6
0
 public void TestWeeklySelect()
 {
     var span1 = new WeeklyTrigger(DaysOfTheWeek.Tuesday) { StartBoundary = DateTime.Parse("12/7/2014 6:00 PM") };
     var r = span1.SelectDates(x => x).Take(3).ToArray();
     Debug.Assert(r.Length == 3);
     Debug.Assert(r[0].Date.DayOfWeek == DayOfWeek.Tuesday);
     Debug.Assert(r[0].TimeOfDay == new TimeSpan(18, 0, 0));
     Debug.Assert(r[1].Date == r[0].Date.AddDays(7));
     Debug.Assert(r[1].TimeOfDay == new TimeSpan(18, 0, 0));
     Debug.Assert(r[2].Date == r[1].Date.AddDays(7));
     Debug.Assert(r[2].TimeOfDay == new TimeSpan(18, 0, 0));
     // repeat interval
     span1.Repetition.Interval = new TimeSpan(1, 0, 0);
     span1.Repetition.Duration = new TimeSpan(3, 0, 0);
     r = span1.SelectDates(x => x).Take(6).ToArray();
     Debug.Assert(r.Length == 6);
     Debug.Assert(r[0].Date.DayOfWeek == DayOfWeek.Tuesday);
     Debug.Assert(r[0].TimeOfDay == new TimeSpan(18, 0, 0));
     Debug.Assert(r[1].Date == r[0].Date);
     Debug.Assert(r[1].TimeOfDay == new TimeSpan(19, 0, 0));
     Debug.Assert(r[2].Date == r[1].Date);
     Debug.Assert(r[2].TimeOfDay == new TimeSpan(20, 0, 0));
     Debug.Assert(r[3].Date == r[2].Date.AddDays(7));
     Debug.Assert(r[3].TimeOfDay == new TimeSpan(18, 0, 0));
     Debug.Assert(r[4].Date == r[3].Date);
     Debug.Assert(r[4].TimeOfDay == new TimeSpan(19, 0, 0));
     Debug.Assert(r[5].Date == r[4].Date);
     Debug.Assert(r[5].TimeOfDay == new TimeSpan(20, 0, 0));
     // end boundry
     span1.EndBoundary = DateTime.Today.AddDays(3).AddDays(7).AddHours(19); // move back to a tuesday, then advance
     r = span1.SelectDates(x => x).Take(6).ToArray();
     Debug.Assert(r.Length == 5);
     Debug.Assert(r[0].Date.DayOfWeek == DayOfWeek.Tuesday);
     Debug.Assert(r[0].TimeOfDay == new TimeSpan(18, 0, 0));
     Debug.Assert(r[1].Date == r[0].Date);
     Debug.Assert(r[1].TimeOfDay == new TimeSpan(19, 0, 0));
     Debug.Assert(r[1].Date == r[1].Date);
     Debug.Assert(r[2].TimeOfDay == new TimeSpan(20, 0, 0));
     Debug.Assert(r[3].Date == r[2].Date.AddDays(7));
     Debug.Assert(r[3].TimeOfDay == new TimeSpan(18, 0, 0));
     Debug.Assert(r[4].Date == r[3].Date);
     Debug.Assert(r[4].TimeOfDay == new TimeSpan(19, 0, 0));
     // every other week
     span1.EndBoundary = DateTime.MaxValue;
     span1.WeeksInterval = 2;
     for (var i = 0; i < 2; i++)
     {
         r = span1.SelectDates(x => x, DateTime.Today.AddDays(i * 7)).Take(5).ToArray();
         Debug.Assert(r.Length == 5);
         Debug.Assert(r[0].Date.DayOfWeek == DayOfWeek.Tuesday);
         Debug.Assert(r[0].TimeOfDay == new TimeSpan(18, 0, 0));
         Debug.Assert(r[1].Date == r[0].Date);
         Debug.Assert(r[1].TimeOfDay == new TimeSpan(19, 0, 0));
         Debug.Assert(r[2].Date == r[1].Date);
         Debug.Assert(r[2].TimeOfDay == new TimeSpan(20, 0, 0));
         Debug.Assert(r[3].Date == r[2].Date.AddDays(14));
         Debug.Assert(r[3].TimeOfDay == new TimeSpan(18, 0, 0));
         Debug.Assert(r[4].Date == r[3].Date);
         Debug.Assert(r[4].TimeOfDay == new TimeSpan(19, 0, 0));
     }
 }
		private void schedOneRadio_CheckedChanged(object sender, EventArgs e)
		{
			if (((RadioButton)sender).Checked)
			{
				Trigger newTrigger = null;
				if (sender == schedOneRadio)
				{
					schedTabControl.SelectedTab = oneTimeTab;
					if (!onAssignment) newTrigger = new TimeTrigger();
				}
				else if (sender == schedDailyRadio)
				{
					schedTabControl.SelectedTab = dailyTab;
					if (!onAssignment) newTrigger = new DailyTrigger();
				}
				else if (sender == schedWeeklyRadio)
				{
					schedTabControl.SelectedTab = weeklyTab;
					if (!onAssignment) newTrigger = new WeeklyTrigger();
				}
				else if (sender == schedMonthlyRadio)
				{
					schedTabControl.SelectedTab = monthlyTab;
					monthlyTriggerUI1_TriggerTypeChanged(this, EventArgs.Empty);
				}

				if (newTrigger != null && !onAssignment)
				{
					if (trigger != null)
						newTrigger.CopyProperties(trigger);
					this.Trigger = newTrigger;
				}
			}
		}
예제 #8
0
        public void Save(string name) {
            TaskFolder folder = loadTaskFolder();
            Task task = loadTask(name, folder);
            TaskDefinition definition;

            if (task == null) {
                definition = new TaskService().NewTask();
                string process = System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName;
                definition.Actions.Add(new ExecAction(process, " --backup=\""+name+"\""));
                definition.Settings.DisallowStartIfOnBatteries = false;
                definition.Settings.StartWhenAvailable = true;
            }
            else {
                definition = task.Definition;
                definition.Triggers.Clear();
            }

            WeeklyTrigger trigger = new WeeklyTrigger();
            DateTime start = DateTime.Today + new TimeSpan(this.ScheduleTime.Hour, this.ScheduleTime.Minute, 0);
            // If we're starting in the past, move to tomorrow
            if (start < DateTime.Now)
                start += new TimeSpan(1, 0, 0, 0);
            trigger.StartBoundary = start;

            trigger.DaysOfWeek = this.DaysOfTheWeek;

            if (trigger.DaysOfWeek != 0)
                definition.Triggers.Add(trigger);

            definition.Settings.Enabled = this.Enabled;
            definition.Settings.StartWhenAvailable = this.StartWhenAvailable;
            definition.Settings.DisallowStartIfOnBatteries = !this.StartOnBatteries;

            folder.RegisterTaskDefinition(name, definition);
        }
예제 #9
0
 internal static Trigger CreateTrigger(V1Interop.ITaskTrigger trigger, V1Interop.TaskTriggerType triggerType)
 {
     Trigger t = null;
     switch (triggerType)
     {
         case Microsoft.Win32.TaskScheduler.V1Interop.TaskTriggerType.RunOnce:
             t = new TimeTrigger(trigger);
             break;
         case Microsoft.Win32.TaskScheduler.V1Interop.TaskTriggerType.RunDaily:
             t = new DailyTrigger(trigger);
             break;
         case Microsoft.Win32.TaskScheduler.V1Interop.TaskTriggerType.RunWeekly:
             t = new WeeklyTrigger(trigger);
             break;
         case Microsoft.Win32.TaskScheduler.V1Interop.TaskTriggerType.RunMonthly:
             t = new MonthlyTrigger(trigger);
             break;
         case Microsoft.Win32.TaskScheduler.V1Interop.TaskTriggerType.RunMonthlyDOW:
             t = new MonthlyDOWTrigger(trigger);
             break;
         case Microsoft.Win32.TaskScheduler.V1Interop.TaskTriggerType.OnIdle:
             t = new IdleTrigger(trigger);
             break;
         case Microsoft.Win32.TaskScheduler.V1Interop.TaskTriggerType.OnSystemStart:
             t = new BootTrigger(trigger);
             break;
         case Microsoft.Win32.TaskScheduler.V1Interop.TaskTriggerType.OnLogon:
             t = new LogonTrigger(trigger);
             break;
         default:
             break;
     }
     //if (t != null) t.ttype = triggerType;
     return t;
 }
예제 #10
0
        private void ButtonOkClick(object sender, EventArgs e)
        {
            Settings.Default.Email = textBoxEmail.Text;
            Settings.Default.Save();

            using (var task = new TaskService())
            {
                var foundTask = task.FindTask("AllegroParser");

                if (foundTask != null)
                {
                    task.RootFolder.DeleteTask(foundTask.Name);
                }

                var taskDef = task.NewTask();
                taskDef.RegistrationInfo.Author = "dev4s";
                taskDef.RegistrationInfo.Description = "This is a task for parsing allegro data.";
                taskDef.RegistrationInfo.Date = DateTime.Now;
                taskDef.Principal.LogonType = TaskLogonType.InteractiveToken;

                var file = new FileInfo("APConsole.exe");
                var args = string.Format("-u {0} -p {1} -api {2} -sF {3} -rF {4} -em {5}",
                                         Password.Decrypt(Settings.Default.Login),
                                         Password.Decrypt(Settings.Default.Password),
                                         Password.Decrypt(Settings.Default.WebApiKey),
                                         Settings.Default.SearchFullPath,
                                         Settings.Default.ResultFullPath,
                                         Settings.Default.Email
                    );

                taskDef.Actions.Add(new ExecAction(file.FullName, args));

                if (Settings.Default.RadioButtonDaily)
                {
                    var dailyTrigger = new DailyTrigger
                                        {
                                            StartBoundary = DateTime.Today + TimeSpan.FromHours(8)
                                        };

                    taskDef.Triggers.Add(dailyTrigger);
                }
                else if (Settings.Default.RadioButtonWeekly)
                {
                    var weeklyTrigger = new WeeklyTrigger(DaysOfTheWeek.Monday)
                                        {
                                            StartBoundary = DateTime.Today + TimeSpan.FromHours(8)
                                        };

                    taskDef.Triggers.Add(weeklyTrigger);
                }
                else if (Settings.Default.RadioButtonMonthly)
                {
                    var monthlyTrigger = new MonthlyTrigger()
                                        {
                                            StartBoundary = DateTime.Today + TimeSpan.FromHours(8)
                                        };

                    taskDef.Triggers.Add(monthlyTrigger);
                }
                else if (Settings.Default.RadioButtonAsThe)
                {
                    var counter = int.Parse(comboBoxCounter.SelectedItem.ToString());
                    var daysHoursCounter = comboBoxMinutesHoursDays.SelectedIndex;

                    var asTrigger = new DailyTrigger
                                    {
                                        StartBoundary = DateTime.Now + TimeSpan.FromMinutes(5)
                                    };

                    switch (daysHoursCounter)
                    {
                        //co minutę
                        case 0:
                            asTrigger.Repetition.Interval = TimeSpan.FromMinutes(counter <= 10 ? 10 : counter);
                            break;

                        //co godzinę
                        case 1:
                            asTrigger.Repetition.Interval = TimeSpan.FromHours(counter);
                            break;

                        //co ileś tam dni
                        case 2:
                            asTrigger.Repetition.Interval = TimeSpan.FromDays(counter);
                            break;
                    }

                    taskDef.Triggers.Add(asTrigger);
                }

                task.RootFolder.RegisterTaskDefinition("AllegroParser", taskDef);
            }

            MessageBox.Show("Utworzono zadanie w harmonogramie zadań!");
        }
        public void TaskShedulerWrapper_Dev2Weekly_Construct_Test()
        {

            var native = new WeeklyTrigger(DaysOfTheWeek.Saturday);
            var wrapped = new Dev2WeeklyTrigger(_taskServiceConvertorFactory.Object, native);
            wrapped.Delay = new TimeSpan(1);
  
            Assert.AreEqual(wrapped.DaysOfWeek, native.DaysOfWeek);
            Assert.AreEqual(wrapped.Instance, native);



        }
예제 #12
0
        private static bool SaveTask(string pathToOutputFolder,
                                     string pathToLogFile,
                                     string description,
                                     bool shutdownAfterBackup,
                                     DateTime startTask,
                                     int intervalCout,
                                     string scheduleType,
                                     bool repeatTask,
                                     string fullUserName,
                                     string password,
                                     bool usePermission,
                                     bool addingTimestampToPst,
                                     bool copyMSOutlookRegistrySettings)
        {
            bool result = false;

            string pathToProgram = ConfigurationManager.AppSettings["pathToBackupmsoutlook"];

            if (pathToProgram == "Path.GetDirectoryName(Application.ExecutablePath)")
            {
                pathToProgram = Path.GetDirectoryName(Application.ExecutablePath) + "\\backupmsoutlook.exe";
            }
            else
            {
                pathToProgram = ConfigurationManager.AppSettings["pathToBackupmsoutlook"];
            }
            try
            {
                using (TaskService ts = new TaskService())
                {
                    TaskDefinition td = ts.NewTask();
                    td.RegistrationInfo.Description = description;

                    //permission
                    td.Principal.LogonType = TaskLogonType.InteractiveToken;
                    td.Principal.RunLevel  = TaskRunLevel.Highest;
                    td.Principal.UserId    = System.Security.Principal.WindowsIdentity.GetCurrent().Name;

                    //add action
                    td.Actions.Add(new ExecAction(pathToProgram,
                                                  "\"" + pathToOutputFolder + "\"" + " " +
                                                  "\"" + pathToLogFile + "\"" + " " +
                                                  shutdownAfterBackup + " " +
                                                  addingTimestampToPst + " " +
                                                  copyMSOutlookRegistrySettings,
                                                  null));

                    if (repeatTask)
                    {
                        if (scheduleType == "hour(s)")
                        {
                            using (var tt = new Microsoft.Win32.TaskScheduler.TimeTrigger()
                            {
                                StartBoundary = startTask, Enabled = true
                            })
                            {
                                tt.Repetition.Interval = TimeSpan.FromHours(1);
                                td.Triggers.Add(tt);
                            }
                        }
                        else
                        if (scheduleType == "day(s)")
                        {
                            using (Microsoft.Win32.TaskScheduler.DailyTrigger dt = new Microsoft.Win32.TaskScheduler.DailyTrigger()
                            {
                                StartBoundary = startTask, Enabled = true, DaysInterval = (short)intervalCout
                            })
                            {
                                td.Triggers.Add(dt);
                            }
                        }
                        else
                        if (scheduleType == "week(s)")
                        {
                            using (var wt = new Microsoft.Win32.TaskScheduler.WeeklyTrigger()
                            {
                                StartBoundary = startTask, Enabled = true, WeeksInterval = (short)intervalCout
                            })
                            {
                                td.Triggers.Add(wt);
                            }
                        }
                    }
                    else
                    {
                        var tt = new Microsoft.Win32.TaskScheduler.TimeTrigger()
                        {
                            StartBoundary = startTask,
                            EndBoundary   = startTask.AddHours(12), //12 hours limit execution
                            Enabled       = true
                        };
                        td.Triggers.Add(tt);
                    }

                    //settings
                    td.Settings.Hidden                     = true;
                    td.Settings.MultipleInstances          = Microsoft.Win32.TaskScheduler.TaskInstancesPolicy.IgnoreNew;
                    td.Settings.DisallowStartIfOnBatteries = true;
                    td.Settings.StopIfGoingOnBatteries     = true;
                    td.Settings.AllowHardTerminate         = true;
                    td.Settings.StartWhenAvailable         = false;
                    td.Settings.RunOnlyIfNetworkAvailable  = false;
                    td.Settings.Priority                   = System.Diagnostics.ProcessPriorityClass.High;
                    td.Settings.IdleSettings.StopOnIdleEnd = true;
                    td.Settings.IdleSettings.RestartOnIdle = false;
                    td.Settings.AllowDemandStart           = true;
                    td.Settings.Enabled                    = true;
                    td.Settings.RunOnlyIfIdle              = false;
                    td.Settings.WakeToRun                  = false;
                    td.RegistrationInfo.Date               = DateTime.Now;
                    td.Settings.ExecutionTimeLimit         = new TimeSpan(12, 0, 0);      //12 hours limit execution
                    td.Settings.DeleteExpiredTaskAfter     = new TimeSpan(30 * 24, 0, 0); //delete task
                    //from scheduler
                    //after 30 days

                    //author
                    td.RegistrationInfo.Author = td.Principal.UserId;

                    //register task
                    string taskName = Get_NextTaskName();

                    if (usePermission)
                    {
                        td.Principal.LogonType = Microsoft.Win32.TaskScheduler.TaskLogonType.Password;
                        ts.RootFolder.RegisterTaskDefinition(taskName,
                                                             td,
                                                             Microsoft.Win32.TaskScheduler.TaskCreation.CreateOrUpdate,
                                                             fullUserName,
                                                             password,
                                                             Microsoft.Win32.TaskScheduler.TaskLogonType.Password,
                                                             null);
                    }
                    else
                    {
                        ts.RootFolder.RegisterTaskDefinition(taskName, td);
                    }
                }

                result = true;
            }
            catch (Exception ex)
            {
                MessageBox.Show("Adding task error -> " + ex.Message);
            }

            return(result);
        }
예제 #13
0
        //Scheduled Activities

        public string createScheduleactivities(string daily, int recurdays, string date, string time, string weekdays, string monthdays)
        {
            string schedulerName = "";
            try
            {
                if (ConfigSettings.ClientName.ToUpper() == clientName)
                {
                    schedulerName = "ActiveiPCOptimizationScheduler";
                }
                else
                {
                    schedulerName = "GearHeadConnectPCOptimizationScheduler";
                }
                RegistryKey UninstallRegistryKey = GetUninstallRegistryKeyByProductName(ConfigSettings.ClientName);
                String uninstallPath = UninstallRegistryKey.GetValue("UninstallString").ToString();
                String backupSchedulerPath = Path.Combine(uninstallPath.Replace("\"", "").Substring(0, uninstallPath.LastIndexOf("\\")), ConfigurationManager.AppSettings["PCOptimizationConsole"]);

                TaskService ts = new TaskService();


                TaskCollection taskCollection = ts.RootFolder.GetTasks(new System.Text.RegularExpressions.Regex(schedulerName));
                if (taskCollection != null && taskCollection.Count > 0)
                {
                    ts.RootFolder.DeleteTask(taskCollection[0].Name);
                }
                TaskDefinition td = ts.NewTask();
                td.RegistrationInfo.Description = schedulerName;
                Int16 days = Convert.ToInt16(recurdays);


                //DateTime combinedDate = Convert.ToDateTime(date + " " + time,new CultureInfo("en-US"));
                //DateTime combinedDate1 = Convert.ToDateTime("Apr-30-2015 02:12 PM",new CultureInfo("en-US"));
                //DateTime combinedDate2 = Convert.ToDateTime("04-30-2015 02:12 PM", new CultureInfo("en-US"));
                //DateTime combinedDate = Convert.ToDateTime(date + " " + time, new CultureInfo("en-GB",true));

                //string dateFormat = CultureInfo.CurrentUICulture.DateTimeFormat.LongDatePattern;
                ////string dt = "04/30/2015 02:12:00 PM";
                //string dt = date + " "+time;
                //IFormatProvider culture = new System.Globalization.CultureInfo("en-US", true);
                //DateTime combinedDate = DateTime.Parse(dt, culture, DateTimeStyles.AssumeLocal);


                string dateString = date + " " + time;
                string format = "MM/dd/yyyy h:mm tt";

                DateTime combinedDate = DateTime.ParseExact(dateString, format,CultureInfo.InvariantCulture);
                

                if (daily == "onetime")
                {
                    td.Triggers.Add(new TimeTrigger(combinedDate));
                }

                if (daily == "daily")
                {
                    DailyTrigger dailyTrigger = new DailyTrigger(days);
                    dailyTrigger.StartBoundary = combinedDate;
                    td.Triggers.Add(dailyTrigger);
                }

                if (daily == "weekly")
                {
                    days = Convert.ToInt16(recurdays);

                    string[] strArray = weekdays.Split(',');

                    foreach (string item in strArray)
                    {
                        DaysOfTheWeek daysofWeek = (DaysOfTheWeek)Enum.Parse(typeof(DaysOfTheWeek), item);
                        WeeklyTrigger weekTrigger = new WeeklyTrigger(daysofWeek, days);
                        weekTrigger.StartBoundary = combinedDate;
                        td.Triggers.Add(weekTrigger);
                    }
                }

                if (daily == "monthly")
                {
                    MonthlyTrigger monthlyTrigger = new MonthlyTrigger();
                    //MonthsOfTheYear selectedMonth= ((MonthsOfTheYear)Convert.ToInt32(monthdays));
                    monthlyTrigger.MonthsOfYear = MonthsOfTheYear.AllMonths;

                    //monthlyTrigger.MonthsOfYear = (monthdays == "01") ? MonthsOfTheYear.January : (monthdays == "02") ? MonthsOfTheYear.February : (monthdays == "03") ? MonthsOfTheYear.March : (monthdays == "04") ? MonthsOfTheYear.April : (monthdays == "05") ? MonthsOfTheYear.May : (monthdays == "06") ? MonthsOfTheYear.June : (monthdays == "07") ? MonthsOfTheYear.July : (monthdays == "08") ? MonthsOfTheYear.August : (monthdays == "09") ? MonthsOfTheYear.September : (monthdays == "10") ? MonthsOfTheYear.October : (monthdays == "11") ? MonthsOfTheYear.November : MonthsOfTheYear.December;

                    //monthlyTrigger.MonthsOfYear = (mon == "01") ? MonthsOfTheYear.January : (mon == "02") ? MonthsOfTheYear.February : (mon == "03") ? MonthsOfTheYear.March : (mon == "04") ? MonthsOfTheYear.April : (mon == "05") ? MonthsOfTheYear.May : (mon == "06") ? MonthsOfTheYear.June : (mon == "07") ? MonthsOfTheYear.July : (mon == "08") ? MonthsOfTheYear.August : (mon == "09") ? MonthsOfTheYear.September : (mon == "10") ? MonthsOfTheYear.October : (mon == "11") ? MonthsOfTheYear.November : MonthsOfTheYear.December;

                    // monthlyTrigger.MonthsOfYear = (MonthsOfTheYear)Enum.Parse(typeof(MonthsOfTheYear), monthdays);
                    monthlyTrigger.StartBoundary = combinedDate;

                    //foreach (var day in monthdays)
                    //{
                    //    daysList.Add(Convert.ToInt16(day));
                    //}
                    List<int> daysList = new List<int>();
                    foreach (var mon in monthdays.Split(','))
                    {
                        daysList.Add(Convert.ToInt16(mon));

                    }
                    monthlyTrigger.DaysOfMonth = daysList.ToArray();
                    td.Triggers.Add(monthlyTrigger);

                }

                td.Actions.Add(new ExecAction(backupSchedulerPath, null));
                ts.RootFolder.RegisterTaskDefinition(schedulerName, td);
                return "PC Optimization scheduled successfully !!";
                //GearHeadMessageBox.Instance.Show("PC Optimization scheduled successfully", "Active-I", MessageBoxButtons.OK, MessageBoxIcon.Information, GearHeadMessageBox.ModuleEnum.Router);
            }
            catch (Exception ex)
            {
                ErrorTracker.WriteErrorLog("PCOptimizaton.cs", "createScheduleactivities", "", ex.Message, ex.StackTrace, "ERROR");
                return "Failed";
            }
        }