public Period(Date_Time start, Date_Time end) : this() { StartTime = start.Copy(); EndTime = end.Copy(); Duration = new Duration(end.Value - start.Value); }
public Period(Date_Time start, TimeSpan duration) : this() { StartTime = start.Copy(); Duration = new Duration(duration); EndTime = start + duration; }
protected List <Date_Time> GetOccurrences(Date_Time StartDate, Date_Time EndDate, int Count) { List <Date_Time> DateTimes = new List <Date_Time>(); while (StartDate <= EndDate && (Count == int.MinValue || DateTimes.Count <= Count)) { // Retrieve occurrences that occur on our interval period if (BySetPos.Count == 0 && CheckValidDate(StartDate) && !DateTimes.Contains(StartDate.Value)) { DateTimes.Add(StartDate.Copy()); } // Retrieve "extra" occurrences that happen within our interval period if (Frequency > FrequencyType.SECONDLY) { foreach (Date_Time dt in GetExtraOccurrences(StartDate, EndDate)) { // Don't add duplicates if (!DateTimes.Contains(dt)) { DateTimes.Add(dt.Copy()); } } } IncrementDate(StartDate); } return(DateTimes); }
public Period(Date_Time start, TimeSpan duration) : this() { StartTime = start.Copy(); if (duration != TimeSpan.MinValue) { Duration = new Duration(duration); EndTime = start + duration; } }
public Date_TimeUTCSerializer(Date_Time dt) : base(dt) { // Make a copy of the Date_Time object, so we don't alter // the original DateTime = dt.Copy(); // Set the Date_Time object to UTC time DateTime.SetKind(DateTimeKind.Utc); }
public static long DateDiff(Recur.FrequencyType frequency, Date_Time dt1, Date_Time dt2, DayOfWeek firstDayOfWeek) { if (frequency == Recur.FrequencyType.YEARLY) { return(dt2.Year - dt1.Year); } if (frequency == Recur.FrequencyType.MONTHLY) { return((dt2.Month - dt1.Month) + (12 * (dt2.Year - dt1.Year))); } if (frequency == Recur.FrequencyType.WEEKLY) { // Get the week of year of the time frame we want to calculate int firstEvalWeek = _Calendar.GetWeekOfYear(dt2.Value, System.Globalization.CalendarWeekRule.FirstFourDayWeek, firstDayOfWeek); // Count backwards in years, calculating how many weeks' difference we have between // first and second dates Date_Time evalDate = dt2.Copy(); while (evalDate.Year > dt1.Year) { firstEvalWeek += _Calendar.GetWeekOfYear(new DateTime(evalDate.Year - 1, 12, 31), System.Globalization.CalendarWeekRule.FirstFourDayWeek, firstDayOfWeek); evalDate = evalDate.AddYears(-1); } // Determine the difference, in weeks, between the start date and the evaluation period. int startWeek = _Calendar.GetWeekOfYear(dt1.Value, System.Globalization.CalendarWeekRule.FirstFourDayWeek, firstDayOfWeek); return(firstEvalWeek - startWeek); } TimeSpan ts = dt2 - dt1; if (frequency == Recur.FrequencyType.DAILY) { return(Round(ts.TotalDays)); } if (frequency == Recur.FrequencyType.HOURLY) { return(Round(ts.TotalHours)); } if (frequency == Recur.FrequencyType.MINUTELY) { return(Round(ts.TotalMinutes)); } if (frequency == Recur.FrequencyType.SECONDLY) { return(Round(ts.TotalSeconds)); } return(0); }
public Date_TimeUTCSerializer(Date_Time dt) : base(dt) { // Make a copy of the Date_Time object, so we don't alter // the original DateTime = dt.Copy(); // Set the Date_Time object to UTC time DateTime = DateTime.UTC; // Ensure time is serialized DateTime.HasTime = true; }
public Date_TimeUTCSerializer(Date_Time dt) : base(dt) { // Make a copy of the Date_Time object, so we don't alter // the original DateTime = dt.Copy(); // Set the Date_Time object to UTC time DateTime = DateTime.UTC; // FIXME: this is the old way we did it; remove when verified //DateTime.SetKind(DateTimeKind.Utc); }
public static long DateDiff(Recur.FrequencyType frequency, Date_Time dt1, Date_Time dt2, DayOfWeek firstDayOfWeek) { if (frequency == Recur.FrequencyType.YEARLY) return dt2.Year - dt1.Year; if (frequency == Recur.FrequencyType.MONTHLY) return (dt2.Month - dt1.Month) + (12 * (dt2.Year - dt1.Year)); if (frequency == Recur.FrequencyType.WEEKLY) { // Get the week of year of the time frame we want to calculate int firstEvalWeek = _Calendar.GetWeekOfYear(dt2.Value, System.Globalization.CalendarWeekRule.FirstFourDayWeek, firstDayOfWeek); // Count backwards in years, calculating how many weeks' difference we have between // first and second dates Date_Time evalDate = dt2.Copy(); while (evalDate.Year > dt1.Year) { firstEvalWeek += _Calendar.GetWeekOfYear(new DateTime(evalDate.Year - 1, 12, 31), System.Globalization.CalendarWeekRule.FirstFourDayWeek, firstDayOfWeek); evalDate = evalDate.AddYears(-1); } // Determine the difference, in weeks, between the start date and the evaluation period. int startWeek = _Calendar.GetWeekOfYear(dt1.Value, System.Globalization.CalendarWeekRule.FirstFourDayWeek, firstDayOfWeek); return firstEvalWeek - startWeek; } TimeSpan ts = dt2 - dt1; if (frequency == Recur.FrequencyType.DAILY) return Round(ts.TotalDays); if (frequency == Recur.FrequencyType.HOURLY) return Round(ts.TotalHours); if (frequency == Recur.FrequencyType.MINUTELY) return Round(ts.TotalMinutes); if (frequency == Recur.FrequencyType.SECONDLY) return Round(ts.TotalSeconds); return 0; }
/// <summary> /// Evaluates this item to determine the dates and times for which it occurs/recurs. /// This method only evaluates items which occur/recur between <paramref name="FromDate"/> /// and <paramref name="ToDate"/>; therefore, if you require a list of items which /// occur outside of this range, you must specify a <paramref name="FromDate"/> and /// <paramref name="ToDate"/> which encapsulate the date(s) of interest. /// <note type="caution"> /// For events with very complex recurrence rules, this method may be a bottleneck /// during processing time, especially when this method in called for a large number /// of todos, in sequence, or for a very large time span. /// </summary> /// <param name="FromDate">The beginning date of the range to evaluate.</param> /// <param name="ToDate">The end date of the range to evaluate.</param> /// <returns></returns> virtual public ArrayList Evaluate(Date_Time FromDate, Date_Time ToDate) { // Evaluate extra time periods, without re-evaluating ones that were already evaluated if ((EvalStart == null && EvalEnd == null) || (ToDate == EvalStart) || (FromDate == EvalEnd)) { EvaluateRRule(FromDate, ToDate); EvaluateRDate(FromDate, ToDate); EvaluateExRule(FromDate, ToDate); EvaluateExDate(FromDate, ToDate); if (EvalStart == null || EvalStart > FromDate) EvalStart = FromDate.Copy(); if (EvalEnd == null || EvalEnd < ToDate) EvalEnd = ToDate.Copy(); } if (EvalStart != null && FromDate < EvalStart) Evaluate(FromDate, EvalStart); if (EvalEnd != null && ToDate > EvalEnd) Evaluate(EvalEnd, ToDate); return DateTimes; }
public override void CreateInitialize() { base.CreateInitialize(); // Create a new UID for the component UID = UniqueComponent.NewUID(); // Here, we don't simply set to DateTime.Now because DateTime.Now contains milliseconds, and // the iCalendar standard doesn't care at all about milliseconds. Therefore, when comparing // two calendars, one generated, and one loaded from file, they may be functionally identical, // but be determined to be different due to millisecond differences. Created = new Date_Time(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second); DTStamp = Created.Copy(); }
/// <summary> /// Evaluates this item to determine the dates and times for which it occurs/recurs. /// This method only evaluates items which occur/recur between <paramref name="FromDate"/> /// and <paramref name="ToDate"/>; therefore, if you require a list of items which /// occur outside of this range, you must specify a <paramref name="FromDate"/> and /// <paramref name="ToDate"/> which encapsulate the date(s) of interest. /// <note type="caution"> /// For events with very complex recurrence rules, this method may be a bottleneck /// during processing time, especially when this method is called for a large number /// of items, in sequence, or for a very large time span. /// </note> /// </summary> /// <param name="FromDate">The beginning date of the range to evaluate.</param> /// <param name="ToDate">The end date of the range to evaluate.</param> /// <returns> /// An <see cref="ArrayList"/> containing a <see cref="Date_Time"/> object for /// each date/time this item occurs/recurs. /// </returns> virtual public List<Period> Evaluate(Date_Time FromDate, Date_Time ToDate) { // Evaluate extra time periods, without re-evaluating ones that were already evaluated if ((EvalStart == null && EvalEnd == null) || (ToDate == EvalStart) || (FromDate == EvalEnd)) { EvaluateRRule(FromDate, ToDate); EvaluateRDate(FromDate, ToDate); EvaluateExRule(FromDate, ToDate); EvaluateExDate(FromDate, ToDate); if (EvalStart == null || EvalStart > FromDate) EvalStart = FromDate.Copy(); if (EvalEnd == null || EvalEnd < ToDate) EvalEnd = ToDate.Copy(); } if (EvalStart != null && FromDate < EvalStart) Evaluate(FromDate, EvalStart); if (EvalEnd != null && ToDate > EvalEnd) Evaluate(EvalEnd, ToDate); Periods.Sort(); // Ensure the Kind of time is consistent with DTStart foreach (Period p in Periods) { if (p.StartTime.Kind != DTStart.Kind) { p.StartTime.Value = new DateTime(p.StartTime.Year, p.StartTime.Month, p.StartTime.Day, p.StartTime.Hour, p.StartTime.Minute, p.StartTime.Second, DTStart.Kind); } } // Evaluate all Alarms for this component. foreach (Alarm alarm in Alarms) alarm.Evaluate(this); return Periods; }
public void IncrementDate(ref Date_Time dt, int Interval) { Date_Time old = dt.Copy(); switch (Frequency) { case FrequencyType.SECONDLY: dt = old.AddSeconds(Interval); break; case FrequencyType.MINUTELY: dt = old.AddMinutes(Interval); break; case FrequencyType.HOURLY: dt = old.AddHours(Interval); break; case FrequencyType.DAILY: dt = old.AddDays(Interval); break; case FrequencyType.WEEKLY: // How the week increments depends on the WKST indicated (defaults to Monday) // So, basically, we determine the week of year using the necessary rules, // and we increment the day until the week number matches our "goal" week number. // So, if the current week number is 36, and our Interval is 2, then our goal // week number is 38. // NOTE: fixes RRULE12 eval. int current = _Calendar.GetWeekOfYear(old.Value, System.Globalization.CalendarWeekRule.FirstFourDayWeek, Wkst), lastLastYear = _Calendar.GetWeekOfYear(new DateTime(old.Year-1, 12, 31, 0, 0, 0, DateTimeKind.Local), System.Globalization.CalendarWeekRule.FirstFourDayWeek, Wkst), last = _Calendar.GetWeekOfYear(new DateTime(old.Year, 12, 31, 0, 0, 0, DateTimeKind.Local), System.Globalization.CalendarWeekRule.FirstFourDayWeek, Wkst), goal = current + Interval; // If the goal week is greater than the last week of the year, wrap it! if (goal > last) goal = goal - last; else if (goal <= 0) goal = lastLastYear + goal; int interval = Interval > 0 ? 1 : -1; while (current != goal) { old = old.AddDays(interval); current = _Calendar.GetWeekOfYear(old.Value, System.Globalization.CalendarWeekRule.FirstFourDayWeek, Wkst); } dt = old; break; case FrequencyType.MONTHLY: dt = old.AddDays(-old.Day + 1).AddMonths(Interval); break; case FrequencyType.YEARLY: dt = old.AddDays(-old.DayOfYear + 1).AddYears(Interval); break; default: throw new Exception("FrequencyType.NONE cannot be evaluated. Please specify a FrequencyType before evaluating the recurrence."); } }
public List<Date_Time> Evaluate(Date_Time StartDate, Date_Time FromDate, Date_Time ToDate) { List<Date_Time> DateTimes = new List<Date_Time>(); DateTimes.AddRange(StaticOccurrences); // Create a temporary recurrence for populating // missing information using the 'StartDate'. Recur r = new Recur(); r.CopyFrom(this); // Enforce evaluation engine rules r.EnforceEvaluationRestrictions(); // Fill in missing, necessary ByXXX values r.EnsureByXXXValues(StartDate); // Get the occurrences foreach (Date_Time occurrence in r.GetOccurrences(StartDate, FromDate.Copy(), ToDate.Copy(), r.Count)) { // NOTE: // Used to be DateTimes.AddRange(r.GetOccurrences(FromDate.Copy(), ToDate, r.Count)) // By doing it this way, fixes bug #19. if (!DateTimes.Contains(occurrence)) DateTimes.Add(occurrence); } // Limit the count of returned recurrences if (Count != int.MinValue && DateTimes.Count > Count) DateTimes.RemoveRange(Count, DateTimes.Count - Count); // Process the UNTIL, and make sure the DateTimes // occur between FromDate and ToDate for (int i = DateTimes.Count - 1; i >= 0; i--) { Date_Time dt = (Date_Time)DateTimes[i]; if (dt > ToDate || dt < FromDate) DateTimes.RemoveAt(i); } // Assign missing values foreach (Date_Time dt in DateTimes) dt.MergeWith(StartDate); // Ensure that DateTimes have an assigned time if they occur less than daily foreach (Date_Time dt in DateTimes) { if (Frequency < FrequencyType.DAILY) dt.HasTime = true; } return DateTimes; }
protected ArrayList GetOccurrences(Date_Time StartDate, Date_Time EndDate, int Count) { ArrayList DateTimes = new ArrayList(); while (StartDate <= EndDate && (Count == int.MinValue || DateTimes.Count <= Count)) { // Retrieve occurrences that occur on our interval period if (BySetPos.Count == 0 && CheckValidDate(StartDate) && !DateTimes.Contains(StartDate.Value)) DateTimes.Add(StartDate.Copy()); // Retrieve "extra" occurrences that happen within our interval period if (Frequency > FrequencyType.SECONDLY) { foreach (Date_Time dt in GetExtraOccurrences(StartDate, EndDate)) { // Don't add duplicates if (!DateTimes.Contains(dt)) DateTimes.Add(dt.Copy()); } } IncrementDate(StartDate); } return DateTimes; }
private void EvaluateToPreviousOccurrence(Date_Time completedDate, Date_Time currDt) { Date_Time beginningDate = completedDate.Copy(); if (RRule != null) foreach (Recur rrule in RRule) DetermineStartingRecurrence(rrule, ref beginningDate); if (RDate != null) foreach (RDate rdate in RDate) DetermineStartingRecurrence(rdate, ref beginningDate); if (ExRule != null) foreach (Recur exrule in ExRule) DetermineStartingRecurrence(exrule, ref beginningDate); if (ExDate != null) foreach (RDate exdate in ExDate) DetermineStartingRecurrence(exdate, ref beginningDate); Evaluate(beginningDate, currDt); }
/// <summary> /// Evaluates this item to determine the dates and times for which it occurs/recurs. /// This method only evaluates items which occur/recur between <paramref name="FromDate"/> /// and <paramref name="ToDate"/>; therefore, if you require a list of items which /// occur outside of this range, you must specify a <paramref name="FromDate"/> and /// <paramref name="ToDate"/> which encapsulate the date(s) of interest. /// <note type="caution"> /// For events with very complex recurrence rules, this method may be a bottleneck /// during processing time, especially when this method is called for a large number /// of items, in sequence, or for a very large time span. /// </note> /// </summary> /// <param name="FromDate">The beginning date of the range to evaluate.</param> /// <param name="ToDate">The end date of the range to evaluate.</param> /// <returns> /// An <see cref="ArrayList"/> containing a <see cref="Date_Time"/> object for /// each date/time this item occurs/recurs. /// </returns> virtual public List<Period> Evaluate(Date_Time FromDate, Date_Time ToDate) { // Evaluate extra time periods, without re-evaluating ones that were already evaluated if ((EvalStart == null && EvalEnd == null) || (ToDate == EvalStart) || (FromDate == EvalEnd)) { EvaluateRRule(FromDate, ToDate); EvaluateRDate(FromDate, ToDate); EvaluateExRule(FromDate, ToDate); EvaluateExDate(FromDate, ToDate); if (EvalStart == null || EvalStart > FromDate) EvalStart = FromDate.Copy(); if (EvalEnd == null || EvalEnd < ToDate) EvalEnd = ToDate.Copy(); } if (EvalStart != null && FromDate < EvalStart) Evaluate(FromDate, EvalStart); if (EvalEnd != null && ToDate > EvalEnd) Evaluate(EvalEnd, ToDate); Periods.Sort(); // Evaluate all Alarms for this component. foreach (Alarm alarm in Alarms) alarm.Evaluate(this); return Periods; }