/// <summary>
/// Returns the first time the <see cref="NthIncludedDayTrigger" /> will fire
/// after the specified date.
/// </summary>
/// <remarks>
/// <p>
/// Because of the conceptual design of <see cref="NthIncludedDayTrigger" />,
/// it is not always possible to decide with certainty that the trigger
/// will <i>never</i> fire again. Therefore, it will search for the next
/// fire time up to a given cutoff. These cutoffs can be changed by using the
/// <see cref="NextFireCutoffInterval" /> property. The default cutoff is 12
/// of the intervals specified by <see cref="IntervalType" /> intervalType.
/// </p>
/// <p>
/// Therefore, for triggers with intervalType =
/// <see cref="IntervalTypeWeekly" />, if the trigger
/// will not fire within 12
/// weeks after the given date/time, <see langword="null" /> will be returned. For
/// triggers with intervalType =
/// <see cref="IntervalTypeMonthly" />
/// , if the trigger will not fire within 12
/// months after the given date/time, <see langword="null" /> will be returned.
/// For triggers with intervalType =
/// <see cref="IntervalTypeYearly" />
/// , if the trigger will not fire within 12
/// years after the given date/time, <see langword="null" /> will be returned. In
/// all cases, if the trigger will not fire before <see field="endTime" />,
/// <see langword="null" /> will be returned.
/// </p>
/// </remarks>
/// <param name="afterTimeUtc">The time after which to find the nearest fire time.
/// This argument is treated as exclusive 舒 that is,
/// if afterTime is a valid fire time for the trigger, it
/// will not be returned as the next fire time.
/// </param>
/// <returns>
/// the first time the trigger will fire following the specified date
/// </returns>
public override NullableDateTime GetFireTimeAfter(NullableDateTime afterTimeUtc)
{
afterTimeUtc = DateTimeUtil.AssumeUniversalTime(afterTimeUtc);
if (!afterTimeUtc.HasValue)
{
afterTimeUtc = DateTime.UtcNow;
}
if ((afterTimeUtc.Value < StartTimeUtc))
{
afterTimeUtc = StartTimeUtc.AddMilliseconds(-1 * 1000);
}
if (intervalType == IntervalTypeWeekly)
{
return(GetWeeklyFireTimeAfter(afterTimeUtc.Value));
}
else if (intervalType == IntervalTypeMonthly)
{
return(GetMonthlyFireTimeAfter(afterTimeUtc.Value));
}
else if (intervalType == IntervalTypeYearly)
{
return(GetYearlyFireTimeAfter(afterTimeUtc.Value));
}
else
{
return(null);
}
}
/// <summary>
/// Computes the number of times fired between the two UTC date times.
/// </summary>
/// <param name="startTimeUtc">The UTC start date and time.</param>
/// <param name="endTimeUtc">The UTC end date and time.</param>
/// <returns></returns>
public virtual int ComputeNumTimesFiredBetween(DateTime?startTimeUtc, DateTime?endTimeUtc)
{
startTimeUtc = ComputeNextZmanTime(DateTimeUtil.AssumeUniversalTime(startTimeUtc));
endTimeUtc = ComputePreviousZmanTime(DateTimeUtil.AssumeUniversalTime(endTimeUtc));
long time = (long)(endTimeUtc.Value - startTimeUtc.Value).TotalMilliseconds;
return((int)(time / repeatInterval.TotalMilliseconds));
}
/// <summary>
/// Returns the next UTC time at which the <see cref="ZmanimTrigger" /> will
/// fire, after the given UTC time. If the trigger will not fire after the given
/// time, <see langword="null" /> will be returned.
/// </summary>
public override DateTime?GetFireTimeAfter(DateTime?afterTimeUtc)
{
afterTimeUtc = ComputeNextZmanTime(DateTimeUtil.AssumeUniversalTime(afterTimeUtc));
if (complete)
{
return(null);
}
if ((timesTriggered > repeatCount) && (repeatCount != RepeatIndefinitely))
{
return(null);
}
if (!afterTimeUtc.HasValue)
{
afterTimeUtc = DateTime.UtcNow;
}
if (repeatCount == 0 && afterTimeUtc.Value.CompareTo(StartTimeUtc) >= 0)
{
return(null);
}
DateTime startMillis = StartTimeUtc;
DateTime afterMillis = afterTimeUtc.Value;
DateTime endMillis = !EndTimeUtc.HasValue ? DateTime.MaxValue : EndTimeUtc.Value;
if (endMillis <= afterMillis)
{
return(null);
}
if (afterMillis < startMillis)
{
return(startMillis);
}
long numberOfTimesExecuted = (long)(((long)(afterMillis - startMillis).TotalMilliseconds / repeatInterval.TotalMilliseconds) + 1);
if ((numberOfTimesExecuted > repeatCount) &&
(repeatCount != RepeatIndefinitely))
{
return(null);
}
DateTime time = startMillis.AddMilliseconds(numberOfTimesExecuted * repeatInterval.TotalMilliseconds);
if (endMillis <= time)
{
return(null);
}
return(time);
}
/// <summary>
/// 计算在指定时间之间的触发次数
/// Computes the number of times fired between the two UTC date times.
/// </summary>
/// <param name="startTimeUtc">The UTC start date and time.</param>
/// <param name="endTimeUtc">The UTC end date and time.</param>
/// <returns></returns>
public virtual int ComputeNumTimesFiredBetween(NullableDateTime startTimeUtc, NullableDateTime endTimeUtc)
{
startTimeUtc = DateTimeUtil.AssumeUniversalTime(startTimeUtc);
endTimeUtc = DateTimeUtil.AssumeUniversalTime(endTimeUtc);
long time = (long)(endTimeUtc.Value - startTimeUtc.Value).TotalMilliseconds;
return((int)(time / repeatInterval.TotalMilliseconds));
}
/// <summary>
/// Returns the last UTC time at which the <see cref="ZmanimTrigger" /> will
/// fire, before the given time. If the trigger will not fire before the
/// given time, <see langword="null" /> will be returned.
/// </summary>
public virtual DateTime?GetFireTimeBefore(DateTime?endUtc)
{
endUtc = ComputePreviousZmanTime(DateTimeUtil.AssumeUniversalTime(endUtc));
if (endUtc.Value < StartTimeUtc)
{
return(null);
}
int numFires = ComputeNumTimesFiredBetween(StartTimeUtc, endUtc);
return(StartTimeUtc.AddMilliseconds(numFires * repeatInterval.TotalMilliseconds));
}
/// <summary>
/// Returns the last UTC time at which the <see cref="SimpleTrigger" /> will
/// fire, before the given time. If the trigger will not fire before the
/// given time, <see langword="null" /> will be returned.
/// </summary>
public virtual NullableDateTime GetFireTimeBefore(NullableDateTime endUtc)
{
endUtc = DateTimeUtil.AssumeUniversalTime(endUtc);
if (endUtc.Value < StartTimeUtc)
{
return(null);
}
var numFires = ComputeNumTimesFiredBetween(StartTimeUtc, endUtc);
return(StartTimeUtc.AddMilliseconds(numFires * repeatInterval.TotalMilliseconds));
}
/// <summary>
/// Initializes a new instance of the <see cref="TriggerFiredBundle"/> class.
/// </summary>
/// <param name="job">The job.</param>
/// <param name="trigger">The trigger.</param>
/// <param name="cal">The calendar.</param>
/// <param name="jobIsRecovering">if set to <c>true</c> [job is recovering].</param>
/// <param name="fireTimeUtc">The fire time.</param>
/// <param name="scheduledFireTimeUtc">The scheduled fire time.</param>
/// <param name="prevFireTimeUtc">The previous fire time.</param>
/// <param name="nextFireTimeUtc">The next fire time.</param>
public TriggerFiredBundle(JobDetail job, Trigger trigger, ICalendar cal, bool jobIsRecovering,
NullableDateTime fireTimeUtc,
NullableDateTime scheduledFireTimeUtc,
NullableDateTime prevFireTimeUtc,
NullableDateTime nextFireTimeUtc)
{
this.job = job;
this.trigger = trigger;
this.cal = cal;
this.jobIsRecovering = jobIsRecovering;
this.fireTimeUtc = DateTimeUtil.AssumeUniversalTime(fireTimeUtc);
this.scheduledFireTimeUtc = DateTimeUtil.AssumeUniversalTime(scheduledFireTimeUtc);
this.prevFireTimeUtc = DateTimeUtil.AssumeUniversalTime(prevFireTimeUtc);
this.nextFireTimeUtc = DateTimeUtil.AssumeUniversalTime(nextFireTimeUtc);
}
/// <summary>
/// Set the previous UTC time at which the <see cref="ZmanimTrigger" /> fired.
/// <strong>This method should not be invoked by client code.</strong>
/// </summary>
public virtual void SetPreviousFireTime(DateTime?fireTimeUtc)
{
previousFireTimeUtc = DateTimeUtil.AssumeUniversalTime(fireTimeUtc);
}
/// <summary>
/// Set the next UTC time at which the <see cref="ZmanimTrigger" /> should fire.
/// <strong>This method should not be invoked by client code.</strong>
/// </summary>
public void SetNextFireTime(DateTime?fireTimeUtc)
{
nextFireTimeUtc = DateTimeUtil.AssumeUniversalTime(fireTimeUtc);
}
/// <summary>
/// 设置下一次触发时间
/// Set the next UTC time at which the <see cref="SimpleTrigger" /> should fire.
/// <strong>This method should not be invoked by client code.</strong>
/// </summary>
public void SetNextFireTime(NullableDateTime fireTimeUtc)
{
nextFireTimeUtc = DateTimeUtil.AssumeUniversalTime(fireTimeUtc);
}