コード例 #1
0
        private static DateTimeOffset CalculateEndDate(Meeting.EventRecurrence recurrence)
        {
            DateTimeOffset date = DateTimeOffset.Parse(recurrence.Range.StartDate);

            int rangeValue = (recurrence.Range.NumberOfOccurrences - 1) * recurrence.Pattern.Interval;

            switch (recurrence.Pattern.Type.ToLower())
            {
            case OData.Daily:
                date = date.AddDays(rangeValue);
                break;

            case OData.Weekly:
                int occurrences = recurrence.Range.NumberOfOccurrences / recurrence.Pattern.DaysOfWeek.Count;
                date = date.AddDays(CalculateDayDiff(date, recurrence.Pattern.DaysOfWeek));
                date = date.AddDays(7 * (occurrences - 1) * recurrence.Pattern.Interval);
                break;

            case OData.AbsoluteMonthly:
            case OData.RelativeMonthly:
                date = date.AddMonths(rangeValue);
                break;

            case OData.AbsoluteYearly:
            case OData.RelativeYearly:
                date = date.AddYears(rangeValue);
                break;
            }

            return(date);
        }
        private void RecurrenceUpdated(Meeting.EventRecurrence recurrence)
        {
            Meeting.Recurrence = recurrence;
            OnPropertyChanged(() => IsSerial);

            BuildRecurrentDate();
        }
コード例 #3
0
        private void RecurrenceUpdated(Meeting.EventRecurrence recurrence)
        {
            _meeting.Recurrence = recurrence;
            OnPropertyChanged(() => IsSerial);

            if (IsSerial)
            {
                RecurrenceDate = DateTimeUtils.BuildRecurrentDate(_meeting.Recurrence);
            }
        }
コード例 #4
0
        protected override void OnNavigatedTo(object parameter)
        {
            _recurrence = JSON.Deserialize <Meeting.EventRecurrence>(parameter);
            PopulatePatternViews();

            switch (_recurrence.Range.Type.ToLower())
            {
            case OData.NoEnd:   SelectedEndOption = OptionNoEnd; break;

            case OData.Numbered: SelectedEndOption = OptionNumbered; break;

            case OData.EndDate: SelectedEndOption = OptionEndDate; break;
            }

            StartDate = DateTime.Parse(_recurrence.Range.StartDate);
            EndDate   = DateTime.Parse(_recurrence.Range.EndDate);
        }
コード例 #5
0
        private void OnInitialize(object parameter)
        {
            GetEvent <InitDialogEvent>().Unsubscribe(OnInitialize);

            _recurrence = Deserialize <Meeting.EventRecurrence>(parameter);
            PopulatePatternViews();

            switch (_recurrence.Range.Type.ToLower())
            {
            case OData.NoEnd: IsNoEnd = true; break;

            case OData.Numbered: IsNumbered = true; break;

            case OData.EndDate: IsEndBy = true; break;
            }

            StartDate = DateTimeOffset.Parse(_recurrence.Range.StartDate);
            EndDate   = DateTime.Parse(_recurrence.Range.EndDate);
        }
        public override void OnNavigatedTo(NavigatedToEventArgs e, Dictionary <string, object> viewModelState)
        {
            base.OnNavigatedTo(e, viewModelState);

            _recurrence = JsonConvert.DeserializeObject <Meeting.EventRecurrence>((string)e.Parameter);

            PopulatePatternViews();

            switch (_recurrence.Range.Type.ToLower())
            {
            case OData.NoEnd:    IsNoEnd = true; break;

            case OData.Numbered: IsNumbered = true; break;

            case OData.EndDate:  IsEndBy = true; break;
            }

            StartDate = DateTimeOffset.Parse(_recurrence.Range.StartDate);
            EndDate   = DateTime.Parse(_recurrence.Range.EndDate);
        }
コード例 #7
0
        public static string BuildRecurrentDate(Meeting.EventRecurrence recurrence)
        {
            var pattern = recurrence.Pattern;

            string date = ResMan.GetString("OccursPart");

            switch (pattern.Type.ToLower())
            {
            case OData.Daily:
                date += string.Format(ResMan.GetString("DailyPart"), pattern.Interval);
                break;

            case OData.Weekly:
                date += ResMan.GetString("EveryPart");
                string dayFmt = ResMan.GetString("WeeklyPartFirst");

                var localDayNames = CultureInfo.CurrentCulture.DateTimeFormat.DayNames;
                var daysOfWeek    = pattern.DaysOfWeek;
                int numDays       = daysOfWeek.Count;

                for (int i = 0; i < numDays; ++i)
                {
                    if (i > 0)
                    {
                        dayFmt = (i == numDays - 1) ?
                                 ResMan.GetString("WeeklyPartLast") :
                                 ResMan.GetString("WeeklyPartNext");
                    }

                    int dayIndex = GetDayOfWeekIndexInternal(daysOfWeek[i]);
                    date += string.Format(dayFmt, localDayNames[dayIndex]);
                }
                break;

            case OData.AbsoluteMonthly:
                date += string.Format(ResMan.GetString("AbsMonthlyPart"),
                                      pattern.DayOfMonth,
                                      pattern.Interval);
                break;

            case OData.RelativeMonthly:
                date += string.Format(ResMan.GetString("RelMonthlyPart"),
                                      ApiOrdinalToLocalOrdinal(pattern.Index),
                                      GetDayOfWeekLocalized(pattern.DaysOfWeek[0]),
                                      pattern.Interval);
                break;

            case OData.AbsoluteYearly:
            {
                var localMonths = CultureInfo.CurrentCulture.DateTimeFormat.MonthNames;

                date += string.Format(ResMan.GetString("AbsYearlyPart"),
                                      pattern.Interval,
                                      localMonths[pattern.Month - 1],
                                      pattern.DayOfMonth);
            }
            break;

            case OData.RelativeYearly:
            {
                var localMonths = CultureInfo.CurrentCulture.DateTimeFormat.MonthNames;

                date += string.Format(ResMan.GetString("RelYearlyPart"),
                                      pattern.Interval,
                                      ApiOrdinalToLocalOrdinal(pattern.Index),
                                      GetDayOfWeekLocalized(pattern.DaysOfWeek[0]),
                                      localMonths[pattern.Month - 1]);
            }
            break;
            }

            date += string.Format(ResMan.GetString("EffectivePart"),
                                  ToDateOnlyString(recurrence.Range.StartDate));

            switch (recurrence.Range.Type.ToLower())
            {
            case OData.NoEnd:
                break;

            case OData.EndDate:

                date += string.Format(ResMan.GetString("UntilPart"),
                                      ToDateOnlyString(recurrence.Range.EndDate));
                break;

            case OData.Numbered:
                DateTimeOffset endDate = CalculateEndDate(recurrence);
                date += string.Format(ResMan.GetString("UntilPart"),
                                      ToDateOnlyString(endDate));
                break;
            }

            return(date);
        }