public void EvaluateToPreviousOccurrence(IDateTime completedDate, IDateTime currDt) { IDateTime beginningDate = completedDate.Copy <IDateTime>(); if (Todo.RecurrenceRules != null) { foreach (IRecurrencePattern rrule in Todo.RecurrenceRules) { DetermineStartingRecurrence(rrule, ref beginningDate); } } if (Todo.RecurrenceDates != null) { foreach (IPeriodList rdate in Todo.RecurrenceDates) { DetermineStartingRecurrence(rdate, ref beginningDate); } } if (Todo.ExceptionRules != null) { foreach (IRecurrencePattern exrule in Todo.ExceptionRules) { DetermineStartingRecurrence(exrule, ref beginningDate); } } if (Todo.ExceptionDates != null) { foreach (IPeriodList exdate in Todo.ExceptionDates) { DetermineStartingRecurrence(exdate, ref beginningDate); } } Evaluate(Todo.Start, DateUtil.GetSimpleDateTimeData(beginningDate), DateUtil.GetSimpleDateTimeData(currDt).AddTicks(1), true); }
static public IList <Occurrence> GetOccurrences(IRecurrable recurrable, IDateTime periodStart, IDateTime periodEnd, bool includeReferenceDateInResults) { var occurrences = new List <Occurrence>(); var evaluator = recurrable.GetService(typeof(IEvaluator)) as IEvaluator; if (evaluator == null) { return(occurrences); } // Ensure the start time is associated with the object being queried var start = recurrable.Start.Copy <IDateTime>(); start.AssociatedObject = recurrable as ICalendarObject; // Change the time zone of periodStart/periodEnd as needed // so they can be used during the evaluation process. periodStart = DateUtil.MatchTimeZone(start, periodStart); periodEnd = DateUtil.MatchTimeZone(start, periodEnd); IList <IPeriod> periods = evaluator.Evaluate( start, DateUtil.GetSimpleDateTimeData(periodStart), DateUtil.GetSimpleDateTimeData(periodEnd), includeReferenceDateInResults); foreach (IPeriod p in periods) { // Filter the resulting periods to only contain those // that occur sometime between startTime and endTime. // NOTE: fixes bug #3007244 - GetOccurences not returning long spanning all-day events var endTime = p.EndTime ?? p.StartTime; if (endTime.GreaterThan(periodStart) && p.StartTime.LessThanOrEqual(periodEnd)) { occurrences.Add(new Occurrence(recurrable, p)); } } occurrences.Sort(); return(occurrences); }
public TimeZoneObservance?GetObservance(IDateTime dt) { if (Parent == null) { throw new Exception("Cannot call GetObservance() on a TimeZoneInfo whose Parent property is null."); } if (string.Equals(dt.TZID, TZID)) { // Normalize date/time values within this time zone to a local value. DateTime normalizedDt = dt.Value; // Let's evaluate our time zone observances to find the // observance that applies to this date/time value. IEvaluator parentEval = Parent.GetService(typeof(IEvaluator)) as IEvaluator; if (parentEval != null) { // Evaluate the date/time in question. parentEval.Evaluate(Start, DateUtil.GetSimpleDateTimeData(Start), normalizedDt, true); // NOTE: We avoid using period.Contains here, because we want to avoid // doing an inadvertent time zone lookup with it. var period = m_evaluator .Periods .FirstOrDefault(p => p.StartTime.Value <= normalizedDt && p.EndTime.Value > normalizedDt ); if (period != null) { return(new TimeZoneObservance(period, this)); } } } return(null); }
/** * Returns a list of start dates in the specified period represented by this recur. This method includes a base date * argument, which indicates the start of the fist occurrence of this recurrence. The base date is used to inject * default values to return a set of dates in the correct format. For example, if the search start date (start) is * Wed, Mar 23, 12:19PM, but the recurrence is Mon - Fri, 9:00AM - 5:00PM, the start dates returned should all be at * 9:00AM, and not 12:19PM. */ private List <DateTime> GetDates(IDateTime seed, DateTime periodStart, DateTime periodEnd, int maxCount, IRecurrencePattern pattern, bool includeReferenceDateInResults) { List <DateTime> dates = new List <DateTime>(); DateTime originalDate = DateUtil.GetSimpleDateTimeData(seed); DateTime seedCopy = DateUtil.GetSimpleDateTimeData(seed); if (includeReferenceDateInResults) { dates.Add(seedCopy); } // If the interval is set to zero, or our count prevents us // from getting additional items, then return with the reference // date only. if (pattern.Interval == 0 || (pattern.Count != int.MinValue && pattern.Count <= dates.Count)) { return(dates); } // optimize the start time for selecting candidates // (only applicable where a COUNT is not specified) if (pattern.Count == int.MinValue) { DateTime incremented = seedCopy; // FIXME: we can more aggresively increment here when // the difference between dates is greater. IncrementDate(ref incremented, pattern, pattern.Interval); while (incremented < periodStart) { seedCopy = incremented; IncrementDate(ref incremented, pattern, pattern.Interval); } } bool?[] expandBehavior = RecurrenceUtil.GetExpandBehaviorList(pattern); int invalidCandidateCount = 0; int noCandidateIncrementCount = 0; DateTime candidate = DateTime.MinValue; while ((maxCount < 0) || (dates.Count < maxCount)) { if (pattern.Until != DateTime.MinValue && candidate != DateTime.MinValue && candidate > pattern.Until) { break; } if (periodEnd != null && candidate != DateTime.MinValue && candidate > periodEnd) { break; } if (pattern.Count >= 1 && (dates.Count + invalidCandidateCount) >= pattern.Count) { break; } List <DateTime> candidates = GetCandidates(seedCopy, pattern, expandBehavior); if (candidates.Count > 0) { noCandidateIncrementCount = 0; // sort candidates for identifying when UNTIL date is exceeded.. candidates.Sort(); for (int i = 0; i < candidates.Count; i++) { candidate = candidates[i]; // don't count candidates that occur before the original date.. if (candidate >= originalDate) { // candidates MAY occur before periodStart // For example, FREQ=YEARLY;BYWEEKNO=1 could return dates // from the previous year. // // candidates exclusive of periodEnd.. if (candidate >= periodEnd) { invalidCandidateCount++; } else if (pattern.Count >= 1 && (dates.Count + invalidCandidateCount) >= pattern.Count) { break; } else if (pattern.Until == DateTime.MinValue || candidate <= pattern.Until) { if (!dates.Contains(candidate)) { dates.Add(candidate); } } } } } else { noCandidateIncrementCount++; if ((maxIncrementCount > 0) && (noCandidateIncrementCount > maxIncrementCount)) { break; } } IncrementDate(ref seedCopy, pattern, pattern.Interval); } // sort final list.. dates.Sort(); return(dates); }