private bool UpdateTrigger(ScheduledJobTrigger trigger, TriggerFrequency triggerFrequency)
{
if (triggerFrequency != TriggerFrequency.None)
{
//
// User has specified a specific trigger type.
// Parameters have been validated for this trigger type.
//
if (triggerFrequency != trigger.Frequency)
{
// Changing to a new trigger type.
return(CreateTrigger(trigger, triggerFrequency));
}
else
{
// Modifying existing trigger type.
return(ModifyTrigger(trigger, triggerFrequency));
}
}
else
{
// We are updating an existing trigger. Need to validate params
// against each trigger type we are updating.
return(ModifyTrigger(trigger, trigger.Frequency, true));
}
}
private ScheduledJobTrigger(
SerializationInfo info,
StreamingContext context)
{
if (info == null)
{
throw new PSArgumentNullException("info");
}
DateTime time = info.GetDateTime("Time_Value");
if (time != DateTime.MinValue)
{
_time = time;
}
else
{
_time = null;
}
RepetitionInterval = (TimeSpan?)info.GetValue("RepetitionInterval_Value", typeof(TimeSpan));
RepetitionDuration = (TimeSpan?)info.GetValue("RepetitionDuration_Value", typeof(TimeSpan));
_daysOfWeek = (List <DayOfWeek>)info.GetValue("DaysOfWeek_Value", typeof(List <DayOfWeek>));
_randomDelay = (TimeSpan)info.GetValue("RandomDelay_Value", typeof(TimeSpan));
_interval = info.GetInt32("Interval_Value");
_user = info.GetString("User_Value");
_frequency = (TriggerFrequency)info.GetValue("TriggerFrequency_Value", typeof(TriggerFrequency));
_id = info.GetInt32("ID_Value");
_enabled = info.GetBoolean("Enabled_Value");
// Runtime reference and not saved to store.
_jobDefAssociation = null;
}
private ScheduledJobTrigger(SerializationInfo info, StreamingContext context)
{
this._interval = 1;
this._enabled = true;
if (info != null)
{
DateTime dateTime = info.GetDateTime("Time_Value");
if (dateTime == DateTime.MinValue)
{
this._time = null;
}
else
{
this._time = new DateTime?(dateTime);
}
this.RepetitionInterval = (TimeSpan?)info.GetValue("RepetitionInterval_Value", typeof(TimeSpan));
this.RepetitionDuration = (TimeSpan?)info.GetValue("RepetitionDuration_Value", typeof(TimeSpan));
this._daysOfWeek = (List <DayOfWeek>)info.GetValue("DaysOfWeek_Value", typeof(List <DayOfWeek>));
this._randomDelay = (TimeSpan)info.GetValue("RandomDelay_Value", typeof(TimeSpan));
this._interval = info.GetInt32("Interval_Value");
this._user = info.GetString("User_Value");
this._frequency = (TriggerFrequency)info.GetValue("TriggerFrequency_Value", typeof(TriggerFrequency));
this._id = info.GetInt32("ID_Value");
this._enabled = info.GetBoolean("Enabled_Value");
this._jobDefAssociation = null;
return;
}
else
{
throw new PSArgumentNullException("info");
}
}
private bool CreateTrigger(ScheduledJobTrigger trigger, TriggerFrequency triggerFrequency)
{
TriggerFrequency triggerFrequency1 = triggerFrequency;
switch (triggerFrequency1)
{
case TriggerFrequency.Once:
{
if (trigger.Frequency == triggerFrequency || this.ValidateOnceParams(trigger))
{
this.CreateOnceTrigger(trigger);
break;
}
else
{
return(false);
}
}
case TriggerFrequency.Daily:
{
if (trigger.Frequency == triggerFrequency || this.ValidateDailyParams(trigger))
{
this.CreateDailyTrigger(trigger);
break;
}
else
{
return(false);
}
}
case TriggerFrequency.Weekly:
{
if (trigger.Frequency == triggerFrequency || this.ValidateWeeklyParams(trigger))
{
this.CreateWeeklyTrigger(trigger);
break;
}
else
{
return(false);
}
}
case TriggerFrequency.AtLogon:
{
this.CreateAtLogonTrigger(trigger);
break;
}
case TriggerFrequency.AtStartup:
{
this.CreateAtStartupTrigger(trigger);
break;
}
}
return(true);
}
private bool ModifyTrigger(ScheduledJobTrigger trigger, TriggerFrequency triggerFrequency, bool validate = false)
{
switch (triggerFrequency)
{
case TriggerFrequency.AtStartup:
if (validate &&
!ValidateStartupParams())
{
return(false);
}
ModifyStartupTrigger(trigger);
break;
case TriggerFrequency.AtLogon:
if (validate &&
!ValidateLogonParams())
{
return(false);
}
ModifyLogonTrigger(trigger);
break;
case TriggerFrequency.Once:
if (validate &&
!ValidateOnceParams())
{
return(false);
}
ModifyOnceTrigger(trigger);
break;
case TriggerFrequency.Daily:
if (validate &&
!ValidateDailyParams())
{
return(false);
}
ModifyDailyTrigger(trigger);
break;
case TriggerFrequency.Weekly:
if (validate &&
!ValidateWeeklyParams())
{
return(false);
}
ModifyWeeklyTrigger(trigger);
break;
}
return(true);
}
/// <summary>
/// Process input.
/// </summary>
protected override void ProcessRecord()
{
// Validate the parameter set and write any errors.
TriggerFrequency newTriggerFrequency = TriggerFrequency.None;
if (!ValidateParameterSet(ref newTriggerFrequency))
{
return;
}
// Update each trigger object with the current parameter set.
// The associated scheduled job definition will also be updated.
foreach (ScheduledJobTrigger trigger in _triggers)
{
ScheduledJobTrigger originalTrigger = new ScheduledJobTrigger(trigger);
if (!UpdateTrigger(trigger, newTriggerFrequency))
{
continue;
}
ScheduledJobDefinition definition = trigger.JobDefinition;
if (definition != null)
{
bool jobUpdateFailed = false;
try
{
trigger.UpdateJobDefinition();
}
catch (ScheduledJobException e)
{
jobUpdateFailed = true;
string msg = StringUtil.Format(ScheduledJobErrorStrings.CantUpdateTriggerOnJobDef, definition.Name, trigger.Id);
Exception reason = new RuntimeException(msg, e);
ErrorRecord errorRecord = new ErrorRecord(reason, "CantSetPropertiesOnJobTrigger", ErrorCategory.InvalidOperation, trigger);
WriteError(errorRecord);
}
if (jobUpdateFailed)
{
// Restore trigger to original configuration.
originalTrigger.CopyTo(trigger);
}
}
if (_passThru)
{
WriteObject(trigger);
}
}
}
internal void ClearProperties()
{
_time = null;
_daysOfWeek = null;
_interval = 1;
_randomDelay = TimeSpan.Zero;
_repInterval = null;
_repDuration = null;
_user = null;
_frequency = TriggerFrequency.None;
_enabled = false;
_id = 0;
}
protected override void ProcessRecord()
{
TriggerFrequency triggerFrequency = TriggerFrequency.None;
if (this.ValidateParameterSet(ref triggerFrequency))
{
ScheduledJobTrigger[] scheduledJobTriggerArray = this._triggers;
for (int i = 0; i < (int)scheduledJobTriggerArray.Length; i++)
{
ScheduledJobTrigger scheduledJobTrigger = scheduledJobTriggerArray[i];
ScheduledJobTrigger scheduledJobTrigger1 = new ScheduledJobTrigger(scheduledJobTrigger);
if (this.UpdateTrigger(scheduledJobTrigger, triggerFrequency))
{
ScheduledJobDefinition jobDefinition = scheduledJobTrigger.JobDefinition;
if (jobDefinition != null)
{
bool flag = false;
try
{
scheduledJobTrigger.UpdateJobDefinition();
}
catch (ScheduledJobException scheduledJobException1)
{
ScheduledJobException scheduledJobException = scheduledJobException1;
flag = true;
object[] name = new object[2];
name[0] = jobDefinition.Name;
name[1] = scheduledJobTrigger.Id;
string str = StringUtil.Format(ScheduledJobErrorStrings.CantUpdateTriggerOnJobDef, name);
Exception runtimeException = new RuntimeException(str, scheduledJobException);
ErrorRecord errorRecord = new ErrorRecord(runtimeException, "CantSetPropertiesOnJobTrigger", ErrorCategory.InvalidOperation, scheduledJobTrigger);
base.WriteError(errorRecord);
}
if (flag)
{
scheduledJobTrigger1.CopyTo(scheduledJobTrigger);
}
}
if (this._passThru)
{
base.WriteObject(scheduledJobTrigger);
}
}
}
return;
}
else
{
return;
}
}
private ScheduledJobTrigger(bool enabled, TriggerFrequency frequency, DateTime?time, List <DayOfWeek> daysOfWeek, int interval, TimeSpan randomDelay, TimeSpan?repetitionInterval, TimeSpan?repetitionDuration, string user, int id)
{
this._interval = 1;
this._enabled = true;
this._enabled = enabled;
this._frequency = frequency;
this._time = time;
this._daysOfWeek = daysOfWeek;
this._interval = interval;
this._randomDelay = randomDelay;
this.RepetitionInterval = repetitionInterval;
this.RepetitionDuration = repetitionDuration;
this._user = user;
this._id = id;
}
private bool CreateTrigger(ScheduledJobTrigger trigger, TriggerFrequency triggerFrequency)
{
switch (triggerFrequency)
{
case TriggerFrequency.AtStartup:
CreateAtStartupTrigger(trigger);
break;
case TriggerFrequency.AtLogon:
CreateAtLogonTrigger(trigger);
break;
case TriggerFrequency.Once:
if (trigger.Frequency != triggerFrequency &&
!ValidateOnceParams(trigger))
{
return(false);
}
CreateOnceTrigger(trigger);
break;
case TriggerFrequency.Daily:
if (trigger.Frequency != triggerFrequency &&
!ValidateDailyParams(trigger))
{
return(false);
}
CreateDailyTrigger(trigger);
break;
case TriggerFrequency.Weekly:
if (trigger.Frequency != triggerFrequency &&
!ValidateWeeklyParams(trigger))
{
return(false);
}
CreateWeeklyTrigger(trigger);
break;
}
return(true);
}
private bool UpdateTrigger(ScheduledJobTrigger trigger, TriggerFrequency triggerFrequency)
{
if (triggerFrequency == TriggerFrequency.None)
{
return(this.ModifyTrigger(trigger, trigger.Frequency, true));
}
else
{
if (triggerFrequency == trigger.Frequency)
{
return(this.ModifyTrigger(trigger, triggerFrequency, false));
}
else
{
return(this.CreateTrigger(trigger, triggerFrequency));
}
}
}
/// <summary>
/// Copy constructor.
/// </summary>
/// <param name="copyTrigger">ScheduledJobTrigger</param>
internal ScheduledJobTrigger(ScheduledJobTrigger copyTrigger)
{
if (copyTrigger == null)
{
throw new PSArgumentNullException("copyTrigger");
}
_enabled = copyTrigger.Enabled;
_frequency = copyTrigger.Frequency;
_id = copyTrigger.Id;
_time = copyTrigger.At;
_daysOfWeek = copyTrigger.DaysOfWeek;
_interval = copyTrigger.Interval;
_randomDelay = copyTrigger.RandomDelay;
_repInterval = copyTrigger.RepetitionInterval;
_repDuration = copyTrigger.RepetitionDuration;
_user = copyTrigger.User;
_jobDefAssociation = copyTrigger.JobDefinition;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="enabled">Enabled</param>
/// <param name="frequency">Trigger frequency</param>
/// <param name="time">Trigger time</param>
/// <param name="daysOfWeek">Weekly days of week</param>
/// <param name="interval">Daily or Weekly interval</param>
/// <param name="randomDelay">Random delay</param>
/// <param name="repetitionInterval">Repetition interval</param>
/// <param name="repetitionDuration">Repetition duration</param>
/// <param name="user">Logon user</param>
/// <param name="id">Trigger id</param>
private ScheduledJobTrigger(
bool enabled,
TriggerFrequency frequency,
DateTime?time,
List <DayOfWeek> daysOfWeek,
Int32 interval,
TimeSpan randomDelay,
TimeSpan?repetitionInterval,
TimeSpan?repetitionDuration,
string user,
Int32 id)
{
_enabled = enabled;
_frequency = frequency;
_time = time;
_daysOfWeek = daysOfWeek;
_interval = interval;
_randomDelay = randomDelay;
RepetitionInterval = repetitionInterval;
RepetitionDuration = repetitionDuration;
_user = user;
_id = id;
}
internal ScheduledJobTrigger(ScheduledJobTrigger copyTrigger)
{
this._interval = 1;
this._enabled = true;
if (copyTrigger != null)
{
this._enabled = copyTrigger.Enabled;
this._frequency = copyTrigger.Frequency;
this._id = copyTrigger.Id;
this._time = copyTrigger.At;
this._daysOfWeek = copyTrigger.DaysOfWeek;
this._interval = copyTrigger.Interval;
this._randomDelay = copyTrigger.RandomDelay;
this._repInterval = copyTrigger.RepetitionInterval;
this._repDuration = copyTrigger.RepetitionDuration;
this._user = copyTrigger.User;
this._jobDefAssociation = copyTrigger.JobDefinition;
return;
}
else
{
throw new PSArgumentNullException("copyTrigger");
}
}
private bool CreateTrigger(ScheduledJobTrigger trigger, TriggerFrequency triggerFrequency)
{
TriggerFrequency triggerFrequency1 = triggerFrequency;
switch (triggerFrequency1)
{
case TriggerFrequency.Once:
{
if (trigger.Frequency == triggerFrequency || this.ValidateOnceParams(trigger))
{
this.CreateOnceTrigger(trigger);
break;
}
else
{
return false;
}
}
case TriggerFrequency.Daily:
{
if (trigger.Frequency == triggerFrequency || this.ValidateDailyParams(trigger))
{
this.CreateDailyTrigger(trigger);
break;
}
else
{
return false;
}
}
case TriggerFrequency.Weekly:
{
if (trigger.Frequency == triggerFrequency || this.ValidateWeeklyParams(trigger))
{
this.CreateWeeklyTrigger(trigger);
break;
}
else
{
return false;
}
}
case TriggerFrequency.AtLogon:
{
this.CreateAtLogonTrigger(trigger);
break;
}
case TriggerFrequency.AtStartup:
{
this.CreateAtStartupTrigger(trigger);
break;
}
}
return true;
}
private ScheduledJobTrigger(
SerializationInfo info,
StreamingContext context)
{
if (info == null)
{
throw new PSArgumentNullException("info");
}
DateTime time = info.GetDateTime("Time_Value");
if (time != DateTime.MinValue)
{
_time = time;
}
else
{
_time = null;
}
RepetitionInterval = (TimeSpan?)info.GetValue("RepetitionInterval_Value", typeof(TimeSpan));
RepetitionDuration = (TimeSpan?)info.GetValue("RepetitionDuration_Value", typeof(TimeSpan));
_daysOfWeek = (List<DayOfWeek>)info.GetValue("DaysOfWeek_Value", typeof(List<DayOfWeek>));
_randomDelay = (TimeSpan)info.GetValue("RandomDelay_Value", typeof(TimeSpan));
_interval = info.GetInt32("Interval_Value");
_user = info.GetString("User_Value");
_frequency = (TriggerFrequency)info.GetValue("TriggerFrequency_Value", typeof(TriggerFrequency));
_id = info.GetInt32("ID_Value");
_enabled = info.GetBoolean("Enabled_Value");
// Runtime reference and not saved to store.
_jobDefAssociation = null;
}
internal void ClearProperties()
{
_time = null;
_daysOfWeek = null;
_interval = 1;
_randomDelay = TimeSpan.Zero;
_repInterval = null;
_repDuration = null;
_user = null;
_frequency = TriggerFrequency.None;
_enabled = false;
_id = 0;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="enabled">Enabled</param>
/// <param name="frequency">Trigger frequency</param>
/// <param name="time">Trigger time</param>
/// <param name="daysOfWeek">Weekly days of week</param>
/// <param name="interval">Daily or Weekly interval</param>
/// <param name="randomDelay">Random delay</param>
/// <param name="repetitionInterval">Repetition interval</param>
/// <param name="repetitionDuration">Repetition duration</param>
/// <param name="user">Logon user</param>
/// <param name="id">Trigger id</param>
private ScheduledJobTrigger(
bool enabled,
TriggerFrequency frequency,
DateTime? time,
List<DayOfWeek> daysOfWeek,
Int32 interval,
TimeSpan randomDelay,
TimeSpan? repetitionInterval,
TimeSpan? repetitionDuration,
string user,
Int32 id)
{
_enabled = enabled;
_frequency = frequency;
_time = time;
_daysOfWeek = daysOfWeek;
_interval = interval;
_randomDelay = randomDelay;
RepetitionInterval = repetitionInterval;
RepetitionDuration = repetitionDuration;
_user = user;
_id = id;
}
/// <summary>
/// Copy constructor.
/// </summary>
/// <param name="copyTrigger">ScheduledJobTrigger</param>
internal ScheduledJobTrigger(ScheduledJobTrigger copyTrigger)
{
if (copyTrigger == null)
{
throw new PSArgumentNullException("copyTrigger");
}
_enabled = copyTrigger.Enabled;
_frequency = copyTrigger.Frequency;
_id = copyTrigger.Id;
_time = copyTrigger.At;
_daysOfWeek = copyTrigger.DaysOfWeek;
_interval = copyTrigger.Interval;
_randomDelay = copyTrigger.RandomDelay;
_repInterval = copyTrigger.RepetitionInterval;
_repDuration = copyTrigger.RepetitionDuration;
_user = copyTrigger.User;
_jobDefAssociation = copyTrigger.JobDefinition;
}
internal void Validate()
{
TriggerFrequency triggerFrequency = this._frequency;
switch (triggerFrequency)
{
case TriggerFrequency.None:
{
throw new ScheduledJobException(ScheduledJobErrorStrings.MissingJobTriggerType);
}
case TriggerFrequency.Once:
{
if (this._time.HasValue)
{
if (!this._repInterval.HasValue && !this._repDuration.HasValue)
{
return;
}
ScheduledJobTrigger.ValidateOnceRepetitionParams(this._repInterval, this._repDuration);
return;
}
else
{
string str = StringUtil.Format(ScheduledJobErrorStrings.MissingJobTriggerTime, ScheduledJobErrorStrings.TriggerOnceType);
throw new ScheduledJobException(str);
}
}
case TriggerFrequency.Daily:
{
if (this._time.HasValue)
{
if (this._interval >= 1)
{
return;
}
throw new ScheduledJobException(ScheduledJobErrorStrings.InvalidDaysIntervalParam);
}
else
{
string str1 = StringUtil.Format(ScheduledJobErrorStrings.MissingJobTriggerTime, ScheduledJobErrorStrings.TriggerDailyType);
throw new ScheduledJobException(str1);
}
}
case TriggerFrequency.Weekly:
{
if (this._time.HasValue)
{
if (this._interval >= 1)
{
if (this._daysOfWeek != null && this._daysOfWeek.Count != 0)
{
return;
}
string str2 = StringUtil.Format(ScheduledJobErrorStrings.MissingJobTriggerDaysOfWeek, ScheduledJobErrorStrings.TriggerWeeklyType);
throw new ScheduledJobException(str2);
}
else
{
throw new ScheduledJobException(ScheduledJobErrorStrings.InvalidWeeksIntervalParam);
}
}
else
{
string str3 = StringUtil.Format(ScheduledJobErrorStrings.MissingJobTriggerTime, ScheduledJobErrorStrings.TriggerWeeklyType);
throw new ScheduledJobException(str3);
}
}
case TriggerFrequency.AtLogon:
case TriggerFrequency.AtStartup:
{
return;
}
default:
{
return;
}
}
}
private ScheduledJobTrigger(bool enabled, TriggerFrequency frequency, DateTime? time, List<DayOfWeek> daysOfWeek, int interval, TimeSpan randomDelay, TimeSpan? repetitionInterval, TimeSpan? repetitionDuration, string user, int id)
{
this._interval = 1;
this._enabled = true;
this._enabled = enabled;
this._frequency = frequency;
this._time = time;
this._daysOfWeek = daysOfWeek;
this._interval = interval;
this._randomDelay = randomDelay;
this.RepetitionInterval = repetitionInterval;
this.RepetitionDuration = repetitionDuration;
this._user = user;
this._id = id;
}
private ScheduledJobTrigger(SerializationInfo info, StreamingContext context)
{
this._interval = 1;
this._enabled = true;
if (info != null)
{
DateTime dateTime = info.GetDateTime("Time_Value");
if (dateTime == DateTime.MinValue)
{
this._time = null;
}
else
{
this._time = new DateTime?(dateTime);
}
this.RepetitionInterval = (TimeSpan?)info.GetValue("RepetitionInterval_Value", typeof(TimeSpan));
this.RepetitionDuration = (TimeSpan?)info.GetValue("RepetitionDuration_Value", typeof(TimeSpan));
this._daysOfWeek = (List<DayOfWeek>)info.GetValue("DaysOfWeek_Value", typeof(List<DayOfWeek>));
this._randomDelay = (TimeSpan)info.GetValue("RandomDelay_Value", typeof(TimeSpan));
this._interval = info.GetInt32("Interval_Value");
this._user = info.GetString("User_Value");
this._frequency = (TriggerFrequency)info.GetValue("TriggerFrequency_Value", typeof(TriggerFrequency));
this._id = info.GetInt32("ID_Value");
this._enabled = info.GetBoolean("Enabled_Value");
this._jobDefAssociation = null;
return;
}
else
{
throw new PSArgumentNullException("info");
}
}
internal ScheduledJobTrigger(ScheduledJobTrigger copyTrigger)
{
this._interval = 1;
this._enabled = true;
if (copyTrigger != null)
{
this._enabled = copyTrigger.Enabled;
this._frequency = copyTrigger.Frequency;
this._id = copyTrigger.Id;
this._time = copyTrigger.At;
this._daysOfWeek = copyTrigger.DaysOfWeek;
this._interval = copyTrigger.Interval;
this._randomDelay = copyTrigger.RandomDelay;
this._repInterval = copyTrigger.RepetitionInterval;
this._repDuration = copyTrigger.RepetitionDuration;
this._user = copyTrigger.User;
this._jobDefAssociation = copyTrigger.JobDefinition;
return;
}
else
{
throw new PSArgumentNullException("copyTrigger");
}
}
private bool ValidateParameterSet(ref TriggerFrequency newTriggerFrequency)
{
// First see if a switch parameter was set.
List <TriggerFrequency> switchParamList = new List <TriggerFrequency>();
if (MyInvocation.BoundParameters.ContainsKey(nameof(AtStartup)))
{
switchParamList.Add(TriggerFrequency.AtStartup);
}
if (MyInvocation.BoundParameters.ContainsKey(nameof(AtLogon)))
{
switchParamList.Add(TriggerFrequency.AtLogon);
}
if (MyInvocation.BoundParameters.ContainsKey(nameof(Once)))
{
switchParamList.Add(TriggerFrequency.Once);
}
if (MyInvocation.BoundParameters.ContainsKey(nameof(Daily)))
{
switchParamList.Add(TriggerFrequency.Daily);
}
if (MyInvocation.BoundParameters.ContainsKey(nameof(Weekly)))
{
switchParamList.Add(TriggerFrequency.Weekly);
}
if (switchParamList.Count > 1)
{
WriteValidationError(ScheduledJobErrorStrings.ConflictingTypeParams);
return(false);
}
newTriggerFrequency = (switchParamList.Count == 1) ? switchParamList[0] : TriggerFrequency.None;
// Validate parameters against the new trigger frequency value.
bool rtnValue = false;
switch (newTriggerFrequency)
{
case TriggerFrequency.None:
rtnValue = true;
break;
case TriggerFrequency.AtStartup:
rtnValue = ValidateStartupParams();
break;
case TriggerFrequency.AtLogon:
rtnValue = ValidateLogonParams();
break;
case TriggerFrequency.Once:
rtnValue = ValidateOnceParams();
break;
case TriggerFrequency.Daily:
rtnValue = ValidateDailyParams();
break;
case TriggerFrequency.Weekly:
rtnValue = ValidateWeeklyParams();
break;
default:
Debug.Assert(false, "Invalid trigger frequency value.");
rtnValue = false;
break;
}
return(rtnValue);
}
private bool ValidateParameterSet(ref TriggerFrequency newTriggerFrequency)
{
TriggerFrequency item;
List <TriggerFrequency> triggerFrequencies = new List <TriggerFrequency>();
if (base.MyInvocation.BoundParameters.ContainsKey(this._paramAtStartup))
{
triggerFrequencies.Add(TriggerFrequency.AtStartup);
}
if (base.MyInvocation.BoundParameters.ContainsKey(this._paramAtLogon))
{
triggerFrequencies.Add(TriggerFrequency.AtLogon);
}
if (base.MyInvocation.BoundParameters.ContainsKey(this._paramOnce))
{
triggerFrequencies.Add(TriggerFrequency.Once);
}
if (base.MyInvocation.BoundParameters.ContainsKey(this._paramDaily))
{
triggerFrequencies.Add(TriggerFrequency.Daily);
}
if (base.MyInvocation.BoundParameters.ContainsKey(this._paramWeekly))
{
triggerFrequencies.Add(TriggerFrequency.Weekly);
}
if (triggerFrequencies.Count <= 1)
{
TriggerFrequency triggerFrequencyPointer = (TriggerFrequency)newTriggerFrequency;
if (triggerFrequencies.Count == 1)
{
item = triggerFrequencies[0];
}
else
{
item = TriggerFrequency.None;
}
triggerFrequencyPointer = item;
bool flag = false;
TriggerFrequency triggerFrequency = (TriggerFrequency)((int)newTriggerFrequency);
switch (triggerFrequency)
{
case TriggerFrequency.None:
{
flag = true;
break;
}
case TriggerFrequency.Once:
{
flag = this.ValidateOnceParams(null);
break;
}
case TriggerFrequency.Daily:
{
flag = this.ValidateDailyParams(null);
break;
}
case TriggerFrequency.Weekly:
{
flag = this.ValidateWeeklyParams(null);
break;
}
case TriggerFrequency.AtLogon:
{
flag = this.ValidateLogonParams();
break;
}
case TriggerFrequency.AtStartup:
{
flag = this.ValidateStartupParams();
break;
}
default:
{
flag = false;
break;
}
}
return(flag);
}
else
{
this.WriteValidationError(ScheduledJobErrorStrings.ConflictingTypeParams);
return(false);
}
}
private bool ModifyTrigger(ScheduledJobTrigger trigger, TriggerFrequency triggerFrequency, bool validate = false)
{
TriggerFrequency triggerFrequency1 = triggerFrequency;
switch (triggerFrequency1)
{
case TriggerFrequency.Once:
{
if (!validate || this.ValidateOnceParams(null))
{
this.ModifyOnceTrigger(trigger);
break;
}
else
{
return false;
}
}
case TriggerFrequency.Daily:
{
if (!validate || this.ValidateDailyParams(null))
{
this.ModifyDailyTrigger(trigger);
break;
}
else
{
return false;
}
}
case TriggerFrequency.Weekly:
{
if (!validate || this.ValidateWeeklyParams(null))
{
this.ModifyWeeklyTrigger(trigger);
break;
}
else
{
return false;
}
}
case TriggerFrequency.AtLogon:
{
if (!validate || this.ValidateLogonParams())
{
this.ModifyLogonTrigger(trigger);
break;
}
else
{
return false;
}
}
case TriggerFrequency.AtStartup:
{
if (!validate || this.ValidateStartupParams())
{
this.ModifyStartupTrigger(trigger);
break;
}
else
{
return false;
}
}
}
return true;
}
private bool ModifyTrigger(ScheduledJobTrigger trigger, TriggerFrequency triggerFrequency, bool validate = false)
{
TriggerFrequency triggerFrequency1 = triggerFrequency;
switch (triggerFrequency1)
{
case TriggerFrequency.Once:
{
if (!validate || this.ValidateOnceParams(null))
{
this.ModifyOnceTrigger(trigger);
break;
}
else
{
return(false);
}
}
case TriggerFrequency.Daily:
{
if (!validate || this.ValidateDailyParams(null))
{
this.ModifyDailyTrigger(trigger);
break;
}
else
{
return(false);
}
}
case TriggerFrequency.Weekly:
{
if (!validate || this.ValidateWeeklyParams(null))
{
this.ModifyWeeklyTrigger(trigger);
break;
}
else
{
return(false);
}
}
case TriggerFrequency.AtLogon:
{
if (!validate || this.ValidateLogonParams())
{
this.ModifyLogonTrigger(trigger);
break;
}
else
{
return(false);
}
}
case TriggerFrequency.AtStartup:
{
if (!validate || this.ValidateStartupParams())
{
this.ModifyStartupTrigger(trigger);
break;
}
else
{
return(false);
}
}
}
return(true);
}
private bool UpdateTrigger(ScheduledJobTrigger trigger, TriggerFrequency triggerFrequency)
{
if (triggerFrequency == TriggerFrequency.None)
{
return this.ModifyTrigger(trigger, trigger.Frequency, true);
}
else
{
if (triggerFrequency == trigger.Frequency)
{
return this.ModifyTrigger(trigger, triggerFrequency, false);
}
else
{
return this.CreateTrigger(trigger, triggerFrequency);
}
}
}
/// <summary> /// Converts the <see cref="sourceValue" /> parameter to the <see cref="destinationType" /> parameter using <see cref="formatProvider" /// /> and <see cref="ignoreCase" /> /// </summary> /// <param name="sourceValue">the <see cref="System.Object"/> to convert from</param> /// <param name="destinationType">the <see cref="System.Type" /> to convert to</param> /// <param name="formatProvider">not used by this TypeConverter.</param> /// <param name="ignoreCase">when set to <c>true</c>, will ignore the case when converting.</param> /// <returns> /// an instance of <see cref="TriggerFrequency" />, or <c>null</c> if there is no suitable conversion. /// </returns> public override object ConvertFrom(object sourceValue, global::System.Type destinationType, global::System.IFormatProvider formatProvider, bool ignoreCase) => TriggerFrequency.CreateFrom(sourceValue);
private bool UpdateTrigger(ScheduledJobTrigger trigger, TriggerFrequency triggerFrequency)
{
if (triggerFrequency != TriggerFrequency.None)
{
//
// User has specified a specific trigger type.
// Parameters have been validated for this trigger type.
//
if (triggerFrequency != trigger.Frequency)
{
// Changing to a new trigger type.
return CreateTrigger(trigger, triggerFrequency);
}
else
{
// Modifying existing trigger type.
return ModifyTrigger(trigger, triggerFrequency);
}
}
else
{
// We are updating an existing trigger. Need to validate params
// against each trigger type we are updating.
return ModifyTrigger(trigger, trigger.Frequency, true);
}
}
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;
}
}
}
private bool CreateTrigger(ScheduledJobTrigger trigger, TriggerFrequency triggerFrequency)
{
switch (triggerFrequency)
{
case TriggerFrequency.AtStartup:
CreateAtStartupTrigger(trigger);
break;
case TriggerFrequency.AtLogon:
CreateAtLogonTrigger(trigger);
break;
case TriggerFrequency.Once:
if (trigger.Frequency != triggerFrequency &&
!ValidateOnceParams(trigger))
{
return false;
}
CreateOnceTrigger(trigger);
break;
case TriggerFrequency.Daily:
if (trigger.Frequency != triggerFrequency &&
!ValidateDailyParams(trigger))
{
return false;
}
CreateDailyTrigger(trigger);
break;
case TriggerFrequency.Weekly:
if (trigger.Frequency != triggerFrequency &&
!ValidateWeeklyParams(trigger))
{
return false;
}
CreateWeeklyTrigger(trigger);
break;
}
return true;
}
private bool ModifyTrigger(ScheduledJobTrigger trigger, TriggerFrequency triggerFrequency, bool validate = false)
{
switch (triggerFrequency)
{
case TriggerFrequency.AtStartup:
if (validate &&
!ValidateStartupParams())
{
return false;
}
ModifyStartupTrigger(trigger);
break;
case TriggerFrequency.AtLogon:
if (validate &&
!ValidateLogonParams())
{
return false;
}
ModifyLogonTrigger(trigger);
break;
case TriggerFrequency.Once:
if (validate &&
!ValidateOnceParams())
{
return false;
}
ModifyOnceTrigger(trigger);
break;
case TriggerFrequency.Daily:
if (validate &&
!ValidateDailyParams())
{
return false;
}
ModifyDailyTrigger(trigger);
break;
case TriggerFrequency.Weekly:
if (validate &&
!ValidateWeeklyParams())
{
return false;
}
ModifyWeeklyTrigger(trigger);
break;
}
return true;
}
public override object ConvertFrom(object sourceValue, Type destinationType, IFormatProvider formatProvider, bool ignoreCase)
{
object @default;
if (destinationType != null)
{
if (sourceValue != null)
{
ScheduledJobTrigger scheduledJobTrigger = (ScheduledJobTrigger)sourceValue;
CimSession cimSession = CimSession.Create(null);
using (cimSession)
{
TriggerFrequency frequency = scheduledJobTrigger.Frequency;
switch (frequency)
{
case TriggerFrequency.None:
{
@default = this.ConvertToDefault(scheduledJobTrigger, cimSession);
return(@default);
}
case TriggerFrequency.Once:
{
@default = this.ConvertToOnce(scheduledJobTrigger, cimSession);
return(@default);
}
case TriggerFrequency.Daily:
{
@default = this.ConvertToDaily(scheduledJobTrigger, cimSession);
return(@default);
}
case TriggerFrequency.Weekly:
{
@default = this.ConvertToWeekly(scheduledJobTrigger, cimSession);
return(@default);
}
case TriggerFrequency.AtLogon:
{
@default = this.ConvertToAtLogon(scheduledJobTrigger, cimSession);
return(@default);
}
case TriggerFrequency.AtStartup:
{
@default = this.ConvertToAtStartup(scheduledJobTrigger, cimSession);
return(@default);
}
}
string str = StringUtil.Format(ScheduledJobErrorStrings.UnknownTriggerFrequency, scheduledJobTrigger.Frequency.ToString());
throw new PSInvalidOperationException(str);
}
return(@default);
}
else
{
throw new ArgumentNullException("sourceValue");
}
}
else
{
throw new ArgumentNullException("destinationType");
}
}
private bool ValidateParameterSet(ref TriggerFrequency newTriggerFrequency)
{
// First see if a switch parameter was set.
List<TriggerFrequency> switchParamList = new List<TriggerFrequency>();
if (MyInvocation.BoundParameters.ContainsKey(_paramAtStartup))
{
switchParamList.Add(TriggerFrequency.AtStartup);
}
if (MyInvocation.BoundParameters.ContainsKey(_paramAtLogon))
{
switchParamList.Add(TriggerFrequency.AtLogon);
}
if (MyInvocation.BoundParameters.ContainsKey(_paramOnce))
{
switchParamList.Add(TriggerFrequency.Once);
}
if (MyInvocation.BoundParameters.ContainsKey(_paramDaily))
{
switchParamList.Add(TriggerFrequency.Daily);
}
if (MyInvocation.BoundParameters.ContainsKey(_paramWeekly))
{
switchParamList.Add(TriggerFrequency.Weekly);
}
if (switchParamList.Count > 1)
{
WriteValidationError(ScheduledJobErrorStrings.ConflictingTypeParams);
return false;
}
newTriggerFrequency = (switchParamList.Count == 1) ? switchParamList[0] : TriggerFrequency.None;
// Validate parameters against the new trigger frequency value.
bool rtnValue = false;
switch (newTriggerFrequency)
{
case TriggerFrequency.None:
rtnValue = true;
break;
case TriggerFrequency.AtStartup:
rtnValue = ValidateStartupParams();
break;
case TriggerFrequency.AtLogon:
rtnValue = ValidateLogonParams();
break;
case TriggerFrequency.Once:
rtnValue = ValidateOnceParams();
break;
case TriggerFrequency.Daily:
rtnValue = ValidateDailyParams();
break;
case TriggerFrequency.Weekly:
rtnValue = ValidateWeeklyParams();
break;
default:
Debug.Assert(false, "Invalid trigger frequency value.");
rtnValue = false;
break;
}
return rtnValue;
}
private bool ValidateParameterSet(ref TriggerFrequency newTriggerFrequency)
{
TriggerFrequency item;
List<TriggerFrequency> triggerFrequencies = new List<TriggerFrequency>();
if (base.MyInvocation.BoundParameters.ContainsKey(this._paramAtStartup))
{
triggerFrequencies.Add(TriggerFrequency.AtStartup);
}
if (base.MyInvocation.BoundParameters.ContainsKey(this._paramAtLogon))
{
triggerFrequencies.Add(TriggerFrequency.AtLogon);
}
if (base.MyInvocation.BoundParameters.ContainsKey(this._paramOnce))
{
triggerFrequencies.Add(TriggerFrequency.Once);
}
if (base.MyInvocation.BoundParameters.ContainsKey(this._paramDaily))
{
triggerFrequencies.Add(TriggerFrequency.Daily);
}
if (base.MyInvocation.BoundParameters.ContainsKey(this._paramWeekly))
{
triggerFrequencies.Add(TriggerFrequency.Weekly);
}
if (triggerFrequencies.Count <= 1)
{
TriggerFrequency triggerFrequencyPointer = (TriggerFrequency)newTriggerFrequency;
if (triggerFrequencies.Count == 1)
{
item = triggerFrequencies[0];
}
else
{
item = TriggerFrequency.None;
}
triggerFrequencyPointer = item;
bool flag = false;
TriggerFrequency triggerFrequency = (TriggerFrequency)((int)newTriggerFrequency);
switch (triggerFrequency)
{
case TriggerFrequency.None:
{
flag = true;
break;
}
case TriggerFrequency.Once:
{
flag = this.ValidateOnceParams(null);
break;
}
case TriggerFrequency.Daily:
{
flag = this.ValidateDailyParams(null);
break;
}
case TriggerFrequency.Weekly:
{
flag = this.ValidateWeeklyParams(null);
break;
}
case TriggerFrequency.AtLogon:
{
flag = this.ValidateLogonParams();
break;
}
case TriggerFrequency.AtStartup:
{
flag = this.ValidateStartupParams();
break;
}
default:
{
flag = false;
break;
}
}
return flag;
}
else
{
this.WriteValidationError(ScheduledJobErrorStrings.ConflictingTypeParams);
return false;
}
}
