private static string BuildFromMonthly(IRecurrenceDescriptor recurrenceDescriptor)
        {
            var result = string.Empty;

            if (recurrenceDescriptor.DayOfMonth == 0)
            {
                var occurrenceOrdinal = BuildOccurrenceOrdinal(recurrenceDescriptor);
                result = string.Concat(occurrenceOrdinal, " ", Res.Get <Labels>(recurrenceDescriptor.DaysOfWeek.ToString()), " ", Res.Get <Labels>("OfEvery"));
            }
            else
            {
                result = string.Concat(Res.Get <Labels>("Day"), " ", recurrenceDescriptor.DayOfMonth, " ", Res.Get <Labels>("OfEvery"));
            }

            if (recurrenceDescriptor.Interval == 1)
            {
                result += string.Concat(" ", Res.Get <Labels>("MonthOrMonths").ToLower());
            }
            else
            {
                result += string.Concat(" ", recurrenceDescriptor.Interval, " ", Res.Get <Labels>("MonthOrMonths").ToLower());
            }

            return(result);
        }
Example #2
0
        private static string BuildRecurringEvent(IRecurrenceDescriptor descriptor)
        {
            if (descriptor == null)
            {
                return(string.Empty);
            }

            var result = string.Empty;

            if (descriptor.Occurrences != null)
            {
                var nextOccurrence = descriptor.Occurrences.OrderBy(o => o.Date).FirstOrDefault(o => o >= DateTime.Now);

                if (nextOccurrence != null)
                {
                    var sb = new StringBuilder();
                    sb.Append("Next occurrence is: ");
                    sb.Append(BuildDayMonthYear(nextOccurrence.ToSitefinityUITime()));
                    sb.Append(WhiteSpace);
                    sb.Append(Res.Get <EventResources>().At);
                    sb.Append(WhiteSpace);
                    sb.Append(BuildHourMinute(nextOccurrence.ToSitefinityUITime()));

                    result = sb.ToString();
                }
            }

            return(result);
        }
        private static string BuildRecurringEvent(IRecurrenceDescriptor descriptor)
        {
            if (descriptor == null)
            {
                return(string.Empty);
            }

            var result = string.Empty;

            switch (descriptor.Frequency)
            {
            case RecurrenceFrequency.Daily: result = BuildFromDaily(descriptor);
                break;

            case RecurrenceFrequency.Weekly: result = BuildFromWeekly(descriptor);
                break;

            case RecurrenceFrequency.Monthly: result = BuildFromMonthly(descriptor);
                break;

            case RecurrenceFrequency.Yearly: result = BuildFromYearly(descriptor);
                break;

            default:
                break;
            }

            return(result);
        }
        private static string BuildFromWeekly(IRecurrenceDescriptor recurrenceDescriptor)
        {
            var result = string.Empty;

            if (recurrenceDescriptor.Interval == 1)
            {
                result = Res.Get <Labels>("Every") + " " + Res.Get <EventsResources>("Week").ToLower() + " " + Res.Get <Labels>("On").ToLower();
            }
            else
            {
                result = Res.Get <Labels>("Every") + " " + recurrenceDescriptor.Interval + " " + Res.Get <EventsResources>("Weeks").ToLower() + " " + Res.Get <Labels>("On").ToLower();
            }

            var days = new List <string>()
            {
            };

            if (recurrenceDescriptor.DaysOfWeek.HasFlag(RecurrenceDay.Monday))
            {
                days.Add(Res.Get <Labels>(RecurrenceDay.Monday.ToString()));
            }

            if (recurrenceDescriptor.DaysOfWeek.HasFlag(RecurrenceDay.Tuesday))
            {
                days.Add(Res.Get <Labels>(RecurrenceDay.Tuesday.ToString()));
            }

            if (recurrenceDescriptor.DaysOfWeek.HasFlag(RecurrenceDay.Wednesday))
            {
                days.Add(Res.Get <Labels>(RecurrenceDay.Wednesday.ToString()));
            }

            if (recurrenceDescriptor.DaysOfWeek.HasFlag(RecurrenceDay.Thursday))
            {
                days.Add(Res.Get <Labels>(RecurrenceDay.Thursday.ToString()));
            }

            if (recurrenceDescriptor.DaysOfWeek.HasFlag(RecurrenceDay.Friday))
            {
                days.Add(Res.Get <Labels>(RecurrenceDay.Friday.ToString()));
            }

            if (recurrenceDescriptor.DaysOfWeek.HasFlag(RecurrenceDay.Saturday))
            {
                days.Add(Res.Get <Labels>(RecurrenceDay.Saturday.ToString()));
            }

            if (recurrenceDescriptor.DaysOfWeek.HasFlag(RecurrenceDay.Sunday))
            {
                days.Add(Res.Get <Labels>(RecurrenceDay.Sunday.ToString()));
            }

            result += string.Concat(" ", string.Join(", ", days));

            return(result);
        }
        private static string BuildOccurrenceOrdinal(IRecurrenceDescriptor recurrenceDescriptor)
        {
            switch (recurrenceDescriptor.DayOrdinal)
            {
            case 1: return(char.ToUpper(Res.Get <Labels>("First")[0]) + Res.Get <Labels>("First").Substring(1));

            case 2: return(char.ToUpper(Res.Get <Labels>("Second")[0]) + Res.Get <Labels>("Second").Substring(1));

            case 3: return(char.ToUpper(Res.Get <Labels>("Third")[0]) + Res.Get <Labels>("Third").Substring(1));

            case 4: return(char.ToUpper(Res.Get <Labels>("Fourth")[0]) + Res.Get <Labels>("Fourth").Substring(1));

            default: return(char.ToUpper(Res.Get <Labels>("Last")[0]) + Res.Get <Labels>("Last").Substring(1));
            }
        }
        private static string BuildFromYearly(IRecurrenceDescriptor recurrenceDescriptor)
        {
            var result = string.Empty;

            if (recurrenceDescriptor.DayOrdinal == 0)
            {
                result = string.Concat(Res.Get <Labels>("Every"), " ", recurrenceDescriptor.DayOfMonth, " ", Res.Get <Labels>("Day").ToLower(), " ", Res.Get <Labels>("Of").ToLower(), " ", Res.Get <Labels>(recurrenceDescriptor.Month.ToString()));
            }
            else
            {
                var occurrenceOrdinal = BuildOccurrenceOrdinal(recurrenceDescriptor);
                result  = string.Concat(Res.Get <Labels>("The"), " ", occurrenceOrdinal.ToLower());
                result += string.Concat(" ", Res.Get <Labels>(recurrenceDescriptor.DaysOfWeek.ToString()), " ", Res.Get <Labels>("Of").ToLower(), " ", Res.Get <Labels>(recurrenceDescriptor.Month.ToString()));
            }

            return(result);
        }
        private static string BuildFromDaily(IRecurrenceDescriptor recurrenceDescriptor)
        {
            var result = string.Empty;

            if (recurrenceDescriptor.DaysOfWeek == RecurrenceDay.WeekDays)
            {
                result = Res.Get <Labels>("EveryWeekday");
            }
            else if (recurrenceDescriptor.DaysOfWeek == RecurrenceDay.EveryDay)
            {
                if (recurrenceDescriptor.Interval == 1)
                {
                    result = Res.Get <Labels>("Every") + Res.Get <Labels>("Day").ToLower();
                }
                else
                {
                    result = Res.Get <Labels>("Every") + " " + recurrenceDescriptor.Interval + " " + Res.Get <Labels>("Days").ToLower();
                }
            }

            return(result);
        }