/// <summary>
/// This method should not be used by the Quartz client.
/// </summary>
/// <remarks>
/// <para>
/// Called by the scheduler at the time a <see cref="ITrigger" /> is first
/// added to the scheduler, in order to have the <see cref="ITrigger" />
/// compute its first fire time, based on any associated calendar.
/// </para>
///
/// <para>
/// After this method has been called, <see cref="ITrigger.GetNextFireTimeUtc" />
/// should return a valid answer.
/// </para>
/// </remarks>
/// <returns>
/// The first time at which the <see cref="ITrigger" /> will be fired
/// by the scheduler, which is also the same value <see cref="ITrigger.GetNextFireTimeUtc" />
/// will return (until after the first firing of the <see cref="ITrigger" />).
/// </returns>
public override DateTimeOffset?ComputeFirstFireTimeUtc(ICalendar calendar)
{
DateTimeOffset startTime = StartTimeUtc.ToLocalTime();
DateTimeOffset?startTimeOfDayDate = StartTimeOfDay.GetTimeOfDayForDate(startTime);
// If startTime is after the timeOfDay, then use starTime
if (startTime > startTimeOfDayDate)
{
nextFireTimeUtc = GetFireTimeAfter(startTime);
}
else
{
nextFireTimeUtc = AdvanceToNextDayOfWeek(startTimeOfDayDate.Value, false);
}
// Check calendar for date-time exclusion
while (nextFireTimeUtc != null && calendar != null &&
!calendar.IsTimeIncluded(nextFireTimeUtc.Value))
{
nextFireTimeUtc = GetFireTimeAfter(nextFireTimeUtc);
if (nextFireTimeUtc == null)
{
break;
}
//avoid infinite loop
if (nextFireTimeUtc.Value.Year > YearToGiveupSchedulingAt)
{
return(null);
}
}
return(nextFireTimeUtc);
}
/// <summary>
/// Returns the first time the <see cref="NthIncludedDayTrigger" /> will fire
/// after the specified date.
/// </summary>
/// <remarks>
/// <para>
/// 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.
/// </para>
/// <para>
/// 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.
/// </para>
/// </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 DateTimeOffset?GetFireTimeAfter(DateTimeOffset?afterTimeUtc)
{
if (!afterTimeUtc.HasValue)
{
afterTimeUtc = SystemTime.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>
/// 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>
/// Called by the scheduler at the time a <see cref="ITrigger" /> is first
/// added to the scheduler, in order to have the <see cref="ITrigger" />
/// compute its first fire time, based on any associated calendar.
/// <para>
/// After this method has been called, <see cref="GetNextFireTimeUtc" />
/// should return a valid answer.
/// </para>
///
/// </summary>
/// <returns> the first time at which the <see cref="ITrigger" /> will be fired
/// by the scheduler, which is also the same value
/// <see cref="GetNextFireTimeUtc" /> will return (until after the first
/// firing of the <see cref="ITrigger" />).
/// </returns>
public override DateTimeOffset?ComputeFirstFireTimeUtc(ICalendar cal)
{
calendar = cal;
DateTimeOffset dt = StartTimeUtc.AddMilliseconds(-1 * 1000);
nextFireTimeUtc = GetFireTimeAfter(dt);
return(nextFireTimeUtc);
}
/// <summary>
/// Returns the last UTC time at which the <see cref="ISimpleTrigger" /> 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 DateTimeOffset?GetFireTimeBefore(DateTimeOffset?endUtc)
{
if (endUtc.Value < StartTimeUtc)
{
return(null);
}
int numFires = ComputeNumTimesFiredBetween(StartTimeUtc, endUtc);
return(StartTimeUtc.AddMilliseconds(numFires * repeatInterval.TotalMilliseconds));
}
public string BuildDescription()
{
StringBuilder sb = new StringBuilder();
zBuildDescription(sb);
sb.AppendFormat(" effective {0}", StartTimeUtc.ToLocalTime());
if (EndTimeUtc.HasValue)
{
sb.AppendFormat(" until {0}", EndTimeUtc.Value.ToLocalTime());
}
return(sb.ToString());
}
/// <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="Trigger" /> 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 = DateTimeUtils.AssumeUniversalTime(endUtc);
if (endUtc.Value < StartTimeUtc)
{
return(null);
}
int numFires = ComputeNumTimesFiredBetween(StartTimeUtc, endUtc);
return(StartTimeUtc.AddMilliseconds(numFires * _repeatInterval));
}
protected override void zBuildDescription(StringBuilder sb)
{
if (RepeatsDailyOnInterval)
{
sb.AppendFormat("repeating {0} between {1} and {2}",
DescriptionUtils.GetIntervalDescription(DailyRepetitionInterval),
DailyRepetitionStartTimeUtc.ToLocalTime().ToLongTimeString(),
DailyRepetitionEndTimeUtc.ToLocalTime().ToLongTimeString());
}
else
{
sb.AppendFormat("at {0}", StartTimeUtc.ToLocalTime().ToLongTimeString());
}
}
public Dictionary <string, string> ToProperties()
{
Dictionary <string, string> properties = new Dictionary <string, string>();
properties.Add("Id", Id);
properties.Add("FileName", FileName);
properties.Add("UploadEndPoint", UploadEndPoint);
properties.Add("StartTimeUtc", StartTimeUtc.ToString());
properties.Add("EndTimeUtc", EndTimeUtc.ToString());
properties.Add("FileCreationTimeUtc", FileCreationTimeUtc.ToString());
properties.Add("Status", Status.ToString());
properties.Add("IsRetake", IsRetake.ToString());
properties.Add("SourceMachineName", SourceMachineName);
properties.Add("ErrorMessage", ErrorMessage);
return(properties);
}
/// <summary>
/// Initializes a new instance of the <see cref="SubscriptionRequest"/> class
/// </summary>
public SubscriptionRequest(bool isUniverseSubscription,
Universe universe,
Security security,
SubscriptionDataConfig configuration,
DateTime startTimeUtc,
DateTime endTimeUtc)
: base(startTimeUtc, endTimeUtc, security.Exchange.Hours, configuration.TickType)
{
IsUniverseSubscription = isUniverseSubscription;
Universe = universe;
Security = security;
Configuration = configuration;
// open interest data comes in once a day before market open,
// make the subscription start from midnight and use always open exchange
if (Configuration.TickType == TickType.OpenInterest)
{
StartTimeUtc = StartTimeUtc.ConvertFromUtc(ExchangeHours.TimeZone).Date.ConvertToUtc(ExchangeHours.TimeZone);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SubscriptionRequest"/> class
/// </summary>
public SubscriptionRequest(bool isUniverseSubscription,
Universe universe,
Security security,
SubscriptionDataConfig configuration,
DateTime startTimeUtc,
DateTime endTimeUtc)
{
IsUniverseSubscription = isUniverseSubscription;
Universe = universe;
Security = security;
Configuration = configuration;
// open interest data comes in once a day before market open,
// make the subscription start from midnight
StartTimeUtc = configuration.TickType == TickType.OpenInterest ?
startTimeUtc.ConvertFromUtc(Configuration.ExchangeTimeZone).Date.ConvertToUtc(Configuration.ExchangeTimeZone) :
startTimeUtc;
EndTimeUtc = endTimeUtc;
_localStartTime = new Lazy <DateTime>(() => StartTimeUtc.ConvertFromUtc(Configuration.ExchangeTimeZone));
_localEndTime = new Lazy <DateTime>(() => EndTimeUtc.ConvertFromUtc(Configuration.ExchangeTimeZone));
}
/// <summary>
/// This method should not be used by the Quartz client.
/// </summary>
/// <remarks>
/// <para>
/// Called by the scheduler at the time a <see cref="ITrigger" /> is first
/// added to the scheduler, in order to have the <see cref="ITrigger" />
/// compute its first fire time, based on any associated calendar.
/// </para>
///
/// <para>
/// After this method has been called, <see cref="ITrigger.GetNextFireTimeUtc" />
/// should return a valid answer.
/// </para>
/// </remarks>
/// <returns>
/// The first time at which the <see cref="ITrigger" /> will be fired
/// by the scheduler, which is also the same value <see cref="ITrigger.GetNextFireTimeUtc" />
/// will return (until after the first firing of the <see cref="ITrigger" />).
/// </returns>
public override DateTimeOffset?ComputeFirstFireTimeUtc(ICalendar calendar)
{
nextFireTimeUtc = GetFireTimeAfter(StartTimeUtc.AddSeconds(-1));
// Check calendar for date-time exclusion
while (nextFireTimeUtc != null && calendar != null &&
!calendar.IsTimeIncluded(nextFireTimeUtc.Value))
{
nextFireTimeUtc = GetFireTimeAfter(nextFireTimeUtc);
if (nextFireTimeUtc == null)
{
break;
}
//avoid infinite loop
if (nextFireTimeUtc.Value.Year > YearToGiveupSchedulingAt)
{
return(null);
}
}
return(nextFireTimeUtc);
}
public override int GetHashCode()
{
unchecked {
return((StartTimeUtc.GetHashCode() * 397) ^ (Duration.GetHashCode() * 397) ^ (Name?.GetHashCode() ?? 0));
}
}
