private static int GetRecurrencePatternInteger(ExchangeRecurrencePattern recurrencyType)
        {
            /*
             * Value Meaning
             * 0 Recurs daily.
             * 1 Recurs weekly.
             * 2 Recurs monthly.
             * 3 Recurs monthly on the nth day.
             * 5 Recurs yearly.
             * 6 Recurs yearly on the nth day.
             */
            switch (recurrencyType)
            {
            case ExchangeRecurrencePattern.None:
                return(-1);

            case ExchangeRecurrencePattern.DailyRegeneration:
            case ExchangeRecurrencePattern.Daily:
                return(0);

            case ExchangeRecurrencePattern.Weekly:
            case ExchangeRecurrencePattern.WeeklyRegeneration:
                return(1);

            case ExchangeRecurrencePattern.Monthly:
            case ExchangeRecurrencePattern.MonthlyRegeneration:
                return(2);

            case ExchangeRecurrencePattern.MonthlyRelative:
                return(3);

            case ExchangeRecurrencePattern.Yearly:
            case ExchangeRecurrencePattern.YearlyRegeneration:
                return(5);

            case ExchangeRecurrencePattern.YearlyRelative:
                return(6);

            default:
                throw new ArgumentOutOfRangeException("recurrencyType");
            }
        }
Beispiel #2
0
        private async Task Recurrence_interval(ExchangeRecurrencePattern type, ExchangeDayOfWeek?days = ExchangeDayOfWeek.None, ExchangeDayOfWeekIndex?dayOfWeekIndex = null, int?dayOfMonth = null, int?month = null)
        {
            int[] intervals = new[] { 1, 2, 4 };
            if (type == ExchangeRecurrencePattern.Yearly || type == ExchangeRecurrencePattern.YearlyRelative)
            {
                intervals = new[] { 1 }
            }
            ;

            foreach (int interval in intervals)
            {
                var ewsTask       = CreateSampleEwsTask(titleOnly: true);
                var ewsRecurrence = new EwsRecurrence
                {
                    StartDate      = DateTime.Now.Date.AddDays(-DateTime.Now.Day + 1).AddHours(8), // use 8AM to prevent weird issue depending on when the test run
                    RecurrenceType = type,
                    Interval       = interval,
                };

                // set a valid start date
                if (dayOfWeekIndex != null)
                {
                    if (month != null)
                    {
                        ewsRecurrence.StartDate = ewsRecurrence.StartDate.AddMonths(month.Value - ewsRecurrence.StartDate.Month);
                    }

                    string day       = days.ToString();
                    int    occurence = (int)dayOfWeekIndex.Value + 1;
                    int    count     = 0;
                    if (ewsRecurrence.StartDate.DayOfWeek.ToString() == day)
                    {
                        count = 1;
                    }

                    while (ewsRecurrence.StartDate.DayOfWeek.ToString() != day || count != occurence)
                    {
                        ewsRecurrence.StartDate = ewsRecurrence.StartDate.AddDays(1);
                        if (ewsRecurrence.StartDate.DayOfWeek.ToString() == day)
                        {
                            count++;
                        }
                    }
                }
                else if (days != null && days != ExchangeDayOfWeek.None)
                {
                    string day = days.ToString();
                    if (day.Contains(","))
                    {
                        day = day.Split(new [] { ',' })[0];
                    }

                    while (ewsRecurrence.StartDate.DayOfWeek.ToString() != day)
                    {
                        ewsRecurrence.StartDate = ewsRecurrence.StartDate.AddDays(1);
                    }
                }
                else if (dayOfMonth != null)
                {
                    if (month != null)
                    {
                        ewsRecurrence.StartDate = ewsRecurrence.StartDate.AddMonths(month.Value - ewsRecurrence.StartDate.Month);
                    }

                    ewsRecurrence.StartDate = ewsRecurrence.StartDate.AddDays(dayOfMonth.Value - ewsRecurrence.StartDate.Day);
                }

                if (days != null)
                {
                    ewsRecurrence.DaysOfWeek = days.Value;
                }

                if (dayOfWeekIndex != null)
                {
                    ewsRecurrence.DayOfWeekIndex = dayOfWeekIndex.Value;
                }

                if (dayOfMonth != null)
                {
                    ewsRecurrence.DayOfMonth = dayOfMonth.Value;
                }

                if (month != null)
                {
                    ewsRecurrence.Month = month.Value;
                }

                ewsTask.Recurrence  = ewsRecurrence;
                ewsTask.IsRecurring = true;

                await this.server.CreateItemAsync(ewsTask);

                var task = await this.server.GetTask(ewsTask.Subject, this.folderIdentifiers.TaskFolderIdentifier);

                Assert.IsTrue(task.IsRecurring);
                Assert.IsNotNull(task.Recurrence);
                Assert.AreEqual(ewsRecurrence, task.Recurrence);
            }
        }
    }