Ejemplo n.º 1
0
        public void RecurringComponentAttachmentTests(RecurringComponent noAttachment, RecurringComponent withAttachment)
        {
            var attachments = GetAttachments();

            Assert.AreNotEqual(noAttachment, withAttachment);
            Assert.AreNotEqual(noAttachment.GetHashCode(), withAttachment.GetHashCode());

            noAttachment.Attachments.Add(new Attachment(attachments.Item2 /*copy*/));

            Assert.AreEqual(noAttachment, withAttachment);
            Assert.AreEqual(noAttachment.GetHashCode(), withAttachment.GetHashCode());
        }
 /// <summary>
 /// Adds all exceptions defined in the EXDATE property of the specified Recurring Component in
 /// the list of Exceptions of the Scheduler Recurrence Rule.
 /// </summary>
 /// <param name="schedulerRRule"><seealso cref="RecurrenceRule"/> as the Scheduler Recurrence Rule.</param>
 /// <param name="recurringComponent">The <seealso cref="RecurringComponent"/> object.</param>
 private static void AddRecurrenceExceptions(RecurrenceRule schedulerRRule, RecurringComponent recurringComponent)
 {
     if (recurringComponent.ExceptionDates != null)
     {
         foreach (IPeriodList exceptionDates in recurringComponent.ExceptionDates)
         {
             foreach (Period period in exceptionDates)
             {
                 if (period.StartTime != null)
                 {
                     schedulerRRule.Exceptions.Add(period.StartTime.Local);
                 }
             }
         }
     }
 }
Ejemplo n.º 3
0
        /// <summary>
        /// Evaluates <see cref="Alarm"/>s for the given recurring component, <paramref name="rc"/>.
        /// This evaluation is based on the evaluation period for the <see cref="RecurringComponent"/>.        
        /// </summary>
        /// <param name="rc">The </param>
        /// <returns></returns>
        virtual public List<AlarmOccurrence> Evaluate(RecurringComponent rc)
        {
            Occurrences = new List<AlarmOccurrence>();

            // If the trigger is relative, it can recur right along with
            // the recurring items, otherwise, it happens once and
            // only once (at a precise time).
            if (Trigger.IsRelative)
            {                
                foreach (Date_Time dt in rc.DateTimes)
                    Occurrences.Add(new AlarmOccurrence(this, dt + Trigger.Duration, rc));                
            }
            else Occurrences.Add(new AlarmOccurrence(this, Trigger.DateTime.Copy(), rc));

            // If a REPEAT and DURATION value were specified,
            // then handle those repetitions here.
            AddRepeatedItems();

            return Occurrences;
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Evaluates <see cref="Alarm"/>s for the given recurring component, <paramref name="rc"/>.
        /// This evaluation is based on the evaluation period for the <see cref="RecurringComponent"/>.        
        /// </summary>
        /// <param name="rc">The </param>
        /// <returns></returns>
        virtual public List<AlarmOccurrence> Evaluate(RecurringComponent rc)
        {
            Occurrences.Clear();

            // If the trigger is relative, it can recur right along with
            // the recurring items, otherwise, it happens once and
            // only once (at a precise time).            
            if (Trigger.IsRelative)
            {
                Duration d = null;
                foreach (Period p in rc.Periods)
                {
                    Date_Time dt = p.StartTime;
                    if (Trigger.Related == Trigger.TriggerRelation.END)
                    {
                        if (p.EndTime != null)
                        {
                            dt = p.EndTime;
                            if (d == null)
                                d = p.Duration;
                        }
                        // Use the "last-found" duration as a reference point
                        else if (d != null)
                            dt = p.StartTime + d;
                        else throw new ArgumentException("Alarm trigger is relative to the END of the occurrence; however, the occurence has no discernible end.");                                                
                    }

                    Occurrences.Add(new AlarmOccurrence(this, dt + Trigger.Duration, rc));
                }
            }
            else Occurrences.Add(new AlarmOccurrence(this, Trigger.DateTime.Copy(), rc));

            // If a REPEAT and DURATION value were specified,
            // then handle those repetitions here.
            AddRepeatedItems();

            return Occurrences;
        }
Ejemplo n.º 5
0
 static public Alarm Create(RecurringComponent rc)
 {
     Alarm alarm = (Alarm)rc.iCalendar.Create(rc, "VALARM");
     return alarm;
 }
Ejemplo n.º 6
0
 public AlarmOccurrence(Alarm a, Date_Time dt, RecurringComponent rc)
 {
     this.Alarm = a;
     this.DateTime = dt;
     this.Component = rc;
 }
Ejemplo n.º 7
0
 public AlarmOccurrence(AlarmOccurrence ao)
 {
     this.Alarm = ao.Alarm;
     this.DateTime = ao.DateTime.Copy();
     this.Component = ao.Component;
 }
 public RecurringComponentSerializer(RecurringComponent rc) : base(rc)
 {
 }
 /// <summary>
 /// Adds all exceptions defined in the EXDATE property of the specified Recurring Component in
 /// the list of Exceptions of the Scheduler Recurrence Rule.
 /// </summary>
 /// <param name="schedulerRRule"><seealso cref="RecurrenceRule"/> as the Scheduler Recurrence Rule.</param>
 /// <param name="recurringComponent">The <seealso cref="RecurringComponent"/> object.</param>
 private static void AddRecurrenceExceptions(RecurrenceRule schedulerRRule, RecurringComponent recurringComponent)
 {
     if (recurringComponent.ExceptionDates != null)
     {
         foreach (IPeriodList exceptionDates in recurringComponent.ExceptionDates)
         {
             foreach (Period period in exceptionDates)
             {
                 if (period.StartTime != null)
                 {
                     schedulerRRule.Exceptions.Add(period.StartTime.Local);
                 }
             }
         }
     }
 }
 /// <summary>
 /// Creates a Recurrence Rule in RadScheduler-friendly format from the RRule of the specified Recurring component.
 /// </summary>
 /// <param name="startDate">The Start Date of the Recurring component.</param>
 /// <param name="endDate">The End Date of the Recurring component.</param>
 /// <param name="recurringComponent">The Recurring component.</param>
 /// <returns>A <see cref="string"/> representation of the RRule in RadScheduler-friendly format.</returns>
 private static string GetSchedulerRecurrenceRule(DateTime startDate, DateTime endDate, RecurringComponent recurringComponent)
 {
     string recurrenceRuleString = String.Empty;
     if ((recurringComponent.RecurrenceRules != null) &&
         (recurringComponent.RecurrenceRules[0] != null))
     {
         RecurrenceRange schedulerRange = new RecurrenceRange();
         schedulerRange.Start = startDate;
         schedulerRange.EventDuration = endDate - startDate;
         DDay.iCal.RecurrencePattern iCalPattern = (DDay.iCal.RecurrencePattern)recurringComponent.RecurrenceRules[0];
         if (iCalPattern.Count > 0)
         {
             schedulerRange.MaxOccurrences = iCalPattern.Count;
         }
         else if ((iCalPattern.Until != null))//&&   (iCalPattern.IsValidDate(iCalPattern.Until))
         {
             schedulerRange.RecursUntil = iCalPattern.Until.ToLocalTime();
         }
         RecurrenceRule schedulerRRule = null;
         int iCallPatternInterval = iCalPattern.Interval;
         RecurrenceDay schedulerRecurrenceDay = GetSchedulerRecurrenceDay(iCalPattern.ByDay);
         switch (iCalPattern.Frequency)
         {
             case FrequencyType.Hourly:
                 schedulerRRule =
                     new HourlyRecurrenceRule(iCallPatternInterval, schedulerRange);
                 break;
             case FrequencyType.Daily:
                 if (schedulerRecurrenceDay == RecurrenceDay.None)
                 {
                     schedulerRRule =
                         new DailyRecurrenceRule(iCallPatternInterval, schedulerRange);
                 }
                 else
                 {
                     schedulerRRule =
                         new DailyRecurrenceRule(schedulerRecurrenceDay, schedulerRange);
                 }
                 break;
             case FrequencyType.Weekly:
                 if (schedulerRecurrenceDay == RecurrenceDay.None)
                 {
                     schedulerRRule =
                         new WeeklyRecurrenceRule(
                             iCallPatternInterval,
                             (RecurrenceDay)startDate.DayOfWeek,
                             schedulerRange,
                             iCalPattern.FirstDayOfWeek);
                 }
                 else
                 {
                     schedulerRRule =
                         new WeeklyRecurrenceRule(
                             iCallPatternInterval,
                             schedulerRecurrenceDay,
                             schedulerRange,
                             iCalPattern.FirstDayOfWeek);
                 }
                 break;
             case FrequencyType.Monthly:
                 if (iCalPattern.ByMonthDay.Count > 0)
                 {
                     schedulerRRule = new MonthlyRecurrenceRule(
                         iCalPattern.ByMonthDay[0],
                         iCallPatternInterval,
                         schedulerRange);
                 }
                 else if (iCalPattern.BySetPosition.Count > 0)
                 {
                     schedulerRRule = new MonthlyRecurrenceRule(
                         iCalPattern.BySetPosition[0],
                         schedulerRecurrenceDay,
                         iCallPatternInterval,
                         schedulerRange);
                 }
                 else
                 {
                     schedulerRRule = new MonthlyRecurrenceRule(
                         startDate.Day,
                         iCallPatternInterval,
                         schedulerRange);
                 }
                 break;
             case FrequencyType.Yearly:
                 if (iCalPattern.ByMonth.Count > 0)
                 {
                     if (iCalPattern.ByMonthDay.Count > 0)
                     {
                         schedulerRRule = new YearlyRecurrenceRule(
                             (RecurrenceMonth)iCalPattern.ByMonth[0],
                             iCalPattern.ByMonthDay[0],
                             schedulerRange);
                     }
                     else if (iCalPattern.BySetPosition.Count > 0)
                     {
                         schedulerRRule = new YearlyRecurrenceRule(
                             iCalPattern.BySetPosition[0],
                             (RecurrenceMonth)iCalPattern.ByMonth[0],
                             schedulerRecurrenceDay,
                             schedulerRange);
                     }
                     else
                     {
                         schedulerRRule = new YearlyRecurrenceRule(
                             (RecurrenceMonth)iCalPattern.ByMonth[0],
                             startDate.Day,
                             schedulerRange);
                     }
                 }
                 else
                 {
                     schedulerRRule = new YearlyRecurrenceRule(
                             (RecurrenceMonth)startDate.Month,
                             startDate.Day,
                             schedulerRange);
                 }
                 break;
             default:
                 break;
         }
         if (schedulerRRule != null)
         {
             AddRecurrenceExceptions(schedulerRRule, recurringComponent);
             recurrenceRuleString = schedulerRRule.ToString();
         }
     }
     return recurrenceRuleString;
 }
Ejemplo n.º 11
0
        /// <summary>
        /// Function is called to create the course ics file
        /// Function is called everytime the course calendar needs to be updated
        /// </summary>
        /// <param name="id"></param>
        public void CreateCourseCalendar(int id)
        {
            //Get the Course
            var course = (from d in db.Courses
                          where d.ID == id
                          select new
            {
                d.StartDate,
                d.EndDate,
                d.Prefix,
                d.Number,
                d.Semester,
                d.Year,
                d.CourseMeetings,
                d.CourseBreaks,
                d.ID
            }).FirstOrDefault();


            //get course events
            var events = (from e in db.Events
                          where e.Poster.AbstractCourseID == ActiveCourseUser.AbstractCourseID &&
                          e.StartDate >= course.StartDate &&
                          e.StartDate <= course.EndDate &&
                          e.Approved
                          select new
            {
                e.StartDate,
                e.EndDate,
                e.Title,
                e.Description
            }).ToList();

            //Create the calendar object
            iCalendar courseCalendar = new iCalendar();

            //initalize the Calendar object
            courseCalendar.AddTimeZone(DateTimeExtensions.GetTimeZone(((Course)ActiveCourseUser.AbstractCourse).TimeZoneOffset));
            courseCalendar.Method    = "PUBLISH";
            courseCalendar.Name      = "VCALENDAR";
            courseCalendar.Version   = "2.0";
            courseCalendar.ProductID = "-//Washington State University//PLUS.OSBLE.org//EN";
            courseCalendar.Scale     = "GREGORIAN";
            courseCalendar.AddProperty("X-WR-CALNAME", course.Prefix + "-" + course.Number + "-" + course.Semester + "-" + course.Year);

            //get course breaks
            if (ActiveCourseUser.AbstractCourse is Course && ((ActiveCourseUser.AbstractCourse as Course).ShowMeetings == true))
            {
                foreach (CourseMeeting cm in course.CourseMeetings)
                {
                    StringBuilder rpPattern = new StringBuilder("FREQ=WEEKLY;UNTIL=");
                    rpPattern.Append(new iCalDateTime(course.EndDate.UTCToCourse(ActiveCourseUser.AbstractCourseID)).ToString(@"yyyyMMdd\THHmmss\Z"));
                    rpPattern.Append(";WKST=SU;BYDAY=");
                    if (cm.Sunday)
                    {
                        rpPattern.Append("SU,");
                    }
                    if (cm.Monday)
                    {
                        rpPattern.Append("MO,");
                    }
                    if (cm.Tuesday)
                    {
                        rpPattern.Append("TU,");
                    }
                    if (cm.Wednesday)
                    {
                        rpPattern.Append("WE,");
                    }
                    if (cm.Thursday)
                    {
                        rpPattern.Append("TH,");
                    }
                    if (cm.Friday)
                    {
                        rpPattern.Append("FR,");
                    }
                    if (cm.Saturday)
                    {
                        rpPattern.Append("SA");
                    }

                    //trim trailing comma if it is there
                    if (rpPattern[rpPattern.Length - 1] == ',')
                    {
                        rpPattern.Remove(rpPattern.Length - 1, 1);
                    }

                    RecurringComponent recurringComponent = new RecurringComponent();
                    RecurrencePattern  pattern            = new RecurrencePattern(rpPattern.ToString());

                    DDay.iCal.Event evt = courseCalendar.Create <DDay.iCal.Event>();
                    //may cause issues
                    DateTime evtStart = DateTime.SpecifyKind(course.StartDate, DateTimeKind.Utc);
                    evtStart = evtStart.Add(cm.StartTime.TimeOfDay);
                    DateTime evtEnd = DateTime.SpecifyKind(course.StartDate, DateTimeKind.Utc);
                    evtEnd = evtEnd.Add(cm.EndTime.TimeOfDay);

                    //we need to test if right NOW is in DST.
                    //case: course starts during DST, and it's now after DST, result: after DST event is now wrong.
                    DateTime currentTime = new DateTime(DateTime.UtcNow.Year, DateTime.UtcNow.Month, DateTime.UtcNow.Day,
                                                        evtStart.Hour, evtStart.Minute, evtStart.Second, DateTimeKind.Utc);
                    bool isDaylight = TimeZoneInfo.Local.IsDaylightSavingTime(currentTime.UTCToCourse(ActiveCourseUser.AbstractCourseID));

                    if (isDaylight)
                    {
                        evt.Start        = new iCalDateTime(evtStart.UTCToCourse(ActiveCourseUser.AbstractCourseID));
                        evt.End          = new iCalDateTime(evtEnd.UTCToCourse(ActiveCourseUser.AbstractCourseID));
                        evt.LastModified = new iCalDateTime(DateTime.Now);
                        evt.Summary      = cm.Name;
                        evt.Location     = cm.Location;
                        evt.RecurrenceRules.Add(pattern);
                    }
                    else //no longer DST
                    {
                        bool matchingStartDay = false;

                        /*
                         * if there happens to be a "meeting times" in the database without a day of the week associated with
                         * the meeting, we need to skip the while and switch case, otherwise it's an infinite loop!
                         */
                        bool meetingTimeWithoutDaysOfWeek = cm.Sunday || cm.Monday || cm.Tuesday || cm.Wednesday ||
                                                            cm.Thursday || cm.Friday || cm.Saturday ? false : true;

                        int count = 0; //infinite loop protection x2!

                        //WHILE matchingStartDay is false (default false) AND the meeting time has at least one day of the week
                        //AND if we've hit a count of 7, that means we've already checked each day of the week and will never find one!
                        //exit while if we fail either of these conditions!
                        while ((!matchingStartDay && !meetingTimeWithoutDaysOfWeek) && count < 7)
                        {
                            switch (currentTime.DayOfWeek) //find which day of the week for this meeting
                            {
                            case DayOfWeek.Monday:
                                if (cm.Monday)
                                {
                                    matchingStartDay = true;
                                }
                                break;

                            case DayOfWeek.Tuesday:
                                if (cm.Tuesday)
                                {
                                    matchingStartDay = true;
                                }
                                break;

                            case DayOfWeek.Wednesday:
                                if (cm.Wednesday)
                                {
                                    matchingStartDay = true;
                                }
                                break;

                            case DayOfWeek.Thursday:
                                if (cm.Thursday)
                                {
                                    matchingStartDay = true;
                                }
                                break;

                            case DayOfWeek.Friday:
                                if (cm.Friday)
                                {
                                    matchingStartDay = true;
                                }
                                break;

                            case DayOfWeek.Saturday:
                                if (cm.Saturday)
                                {
                                    matchingStartDay = true;
                                }
                                break;

                            case DayOfWeek.Sunday:
                                if (cm.Sunday)
                                {
                                    matchingStartDay = true;
                                }
                                break;

                            default:
                                matchingStartDay = false;
                                break;
                            }

                            if (!matchingStartDay)
                            {
                                currentTime = new DateTime(currentTime.Year, currentTime.Month, currentTime.AddDays(1).Day,
                                                           evtStart.Hour, evtStart.Minute, evtStart.Second, DateTimeKind.Utc);
                            }
                            count++; //infinite loop protection x2! if we've reached 7 we've cycled all weekdays, so get us out of here!
                        }

                        //proceed only if there was a day of the week found for this course meeting time
                        if (!meetingTimeWithoutDaysOfWeek && matchingStartDay)
                        {
                            evt.Start        = new iCalDateTime(currentTime.UTCToCourse(ActiveCourseUser.AbstractCourseID));
                            evt.End          = new iCalDateTime(evtEnd.UTCToCourse(ActiveCourseUser.AbstractCourseID));
                            evt.LastModified = new iCalDateTime(DateTime.Now);
                            evt.Summary      = cm.Name;
                            evt.Location     = cm.Location;
                            evt.RecurrenceRules.Add(pattern);
                        }
                    }
                }

                //create the course breaks
                foreach (CourseBreak cb in course.CourseBreaks)
                {
                    DDay.iCal.Event evt      = courseCalendar.Create <DDay.iCal.Event>();
                    DateTime        evtStart = cb.StartDate.Date;
                    DateTime        evtEnd   = cb.EndDate.Date.AddDays(1);

                    evt.Summary      = cb.Name;
                    evt.Start        = new iCalDateTime(evtStart);
                    evt.End          = new iCalDateTime(evtEnd);
                    evt.LastModified = new iCalDateTime(DateTime.Now);
                }
            }//end if

            //add all the events to the calendar
            foreach (var e in events)
            {
                DDay.iCal.Event evt = courseCalendar.Create <DDay.iCal.Event>();

                evt.Start = new iCalDateTime(e.StartDate.UTCToCourse(ActiveCourseUser.AbstractCourseID));
                if (e.EndDate == null)
                {
                    evt.End = new iCalDateTime(e.StartDate.UTCToCourse(ActiveCourseUser.AbstractCourseID));
                    evt.End.AddMinutes(1);
                }
                else
                {
                    evt.End = new iCalDateTime(((DateTime)e.EndDate).UTCToCourse(ActiveCourseUser.AbstractCourseID));
                }

                evt.Summary = e.Title;
                if (e.Description != null)
                {
                    evt.Description = e.Description;
                }
            }

            // Create a serialization context and serializer factory.
            // These will be used to build the serializer for our object.
            ISerializationContext ctx     = new SerializationContext();
            ISerializerFactory    factory = new DDay.iCal.Serialization.iCalendar.SerializerFactory();
            // Get a serializer for our object
            IStringSerializer serializer = factory.Build(courseCalendar.GetType(), ctx) as IStringSerializer;

            string output = serializer.SerializeToString(courseCalendar);
            var    bytes  = Encoding.UTF8.GetBytes(output);

            SaveCourseCalendar(bytes, course.ID);
        }
    /// <summary>
    /// Creates a Recurrence Rule in RadScheduler-friendly format from the RRule of the specified Recurring component.
    /// </summary>
    /// <param name="startDate">The Start Date of the Recurring component.</param>
    /// <param name="endDate">The End Date of the Recurring component.</param>
    /// <param name="recurringComponent">The Recurring component.</param>
    /// <returns>A <see cref="string"/> representation of the RRule in RadScheduler-friendly format.</returns>
    private static string GetSchedulerRecurrenceRule(DateTime startDate, DateTime endDate, RecurringComponent recurringComponent)
    {
        string recurrenceRuleString = String.Empty;

        if ((recurringComponent.RecurrenceRules != null) &&
            (recurringComponent.RecurrenceRules[0] != null))
        {
            RecurrenceRange schedulerRange = new RecurrenceRange();
            schedulerRange.Start         = startDate;
            schedulerRange.EventDuration = endDate - startDate;
            DDay.iCal.RecurrencePattern iCalPattern = (DDay.iCal.RecurrencePattern)recurringComponent.RecurrenceRules[0];
            if (iCalPattern.Count > 0)
            {
                schedulerRange.MaxOccurrences = iCalPattern.Count;
            }
            else if ((iCalPattern.Until != null))//&&   (iCalPattern.IsValidDate(iCalPattern.Until))
            {
                schedulerRange.RecursUntil = iCalPattern.Until.ToLocalTime();
            }
            RecurrenceRule schedulerRRule         = null;
            int            iCallPatternInterval   = iCalPattern.Interval;
            RecurrenceDay  schedulerRecurrenceDay = GetSchedulerRecurrenceDay(iCalPattern.ByDay);
            switch (iCalPattern.Frequency)
            {
            case FrequencyType.Hourly:
                schedulerRRule =
                    new HourlyRecurrenceRule(iCallPatternInterval, schedulerRange);
                break;

            case FrequencyType.Daily:
                if (schedulerRecurrenceDay == RecurrenceDay.None)
                {
                    schedulerRRule =
                        new DailyRecurrenceRule(iCallPatternInterval, schedulerRange);
                }
                else
                {
                    schedulerRRule =
                        new DailyRecurrenceRule(schedulerRecurrenceDay, schedulerRange);
                }
                break;

            case FrequencyType.Weekly:
                if (schedulerRecurrenceDay == RecurrenceDay.None)
                {
                    schedulerRRule =
                        new WeeklyRecurrenceRule(
                            iCallPatternInterval,
                            (RecurrenceDay)startDate.DayOfWeek,
                            schedulerRange,
                            iCalPattern.FirstDayOfWeek);
                }
                else
                {
                    schedulerRRule =
                        new WeeklyRecurrenceRule(
                            iCallPatternInterval,
                            schedulerRecurrenceDay,
                            schedulerRange,
                            iCalPattern.FirstDayOfWeek);
                }
                break;

            case FrequencyType.Monthly:
                if (iCalPattern.ByMonthDay.Count > 0)
                {
                    schedulerRRule = new MonthlyRecurrenceRule(
                        iCalPattern.ByMonthDay[0],
                        iCallPatternInterval,
                        schedulerRange);
                }
                else if (iCalPattern.BySetPosition.Count > 0)
                {
                    schedulerRRule = new MonthlyRecurrenceRule(
                        iCalPattern.BySetPosition[0],
                        schedulerRecurrenceDay,
                        iCallPatternInterval,
                        schedulerRange);
                }
                else
                {
                    schedulerRRule = new MonthlyRecurrenceRule(
                        startDate.Day,
                        iCallPatternInterval,
                        schedulerRange);
                }
                break;

            case FrequencyType.Yearly:
                if (iCalPattern.ByMonth.Count > 0)
                {
                    if (iCalPattern.ByMonthDay.Count > 0)
                    {
                        schedulerRRule = new YearlyRecurrenceRule(
                            (RecurrenceMonth)iCalPattern.ByMonth[0],
                            iCalPattern.ByMonthDay[0],
                            schedulerRange);
                    }
                    else if (iCalPattern.BySetPosition.Count > 0)
                    {
                        schedulerRRule = new YearlyRecurrenceRule(
                            iCalPattern.BySetPosition[0],
                            (RecurrenceMonth)iCalPattern.ByMonth[0],
                            schedulerRecurrenceDay,
                            schedulerRange);
                    }
                    else
                    {
                        schedulerRRule = new YearlyRecurrenceRule(
                            (RecurrenceMonth)iCalPattern.ByMonth[0],
                            startDate.Day,
                            schedulerRange);
                    }
                }
                else
                {
                    schedulerRRule = new YearlyRecurrenceRule(
                        (RecurrenceMonth)startDate.Month,
                        startDate.Day,
                        schedulerRange);
                }
                break;

            default:
                break;
            }
            if (schedulerRRule != null)
            {
                AddRecurrenceExceptions(schedulerRRule, recurringComponent);
                recurrenceRuleString = schedulerRRule.ToString();
            }
        }
        return(recurrenceRuleString);
    }