public RecurrenceRange Convert(RecurrenceRange value)
{
if (value == null)
{
return(null);
}
switch (value.Type)
{
case RecurrenceRangeType.EndDate:
{
EndDateRecurrenceRange endDateRecurrenceRange = (EndDateRecurrenceRange)value;
return(new EndDateRecurrenceRange(endDateRecurrenceRange.StartDate, endDateRecurrenceRange.EndDate));
}
case RecurrenceRangeType.NoEnd:
{
NoEndRecurrenceRange noEndRecurrenceRange = (NoEndRecurrenceRange)value;
return(new NoEndRecurrenceRange(noEndRecurrenceRange.StartDate));
}
case RecurrenceRangeType.Numbered:
{
NumberedRecurrenceRange numberedRecurrenceRange = (NumberedRecurrenceRange)value;
return(new NumberedRecurrenceRange(numberedRecurrenceRange.StartDate, numberedRecurrenceRange.NumberOfOccurrences));
}
default:
throw new ArgumentValueCannotBeParsedException("value", value.Type.ToString(), value.GetType().FullName);
}
}
// Token: 0x06000798 RID: 1944 RVA: 0x00039E40 File Offset: 0x00038040
public static int GetCancelRecurrenceCount(CalendarItem calendarItem, ExDateTime endRange)
{
if (calendarItem == null)
{
throw new ArgumentNullException("calendarItem");
}
if (endRange <= calendarItem.Recurrence.Range.StartDate)
{
return(0);
}
if (!(calendarItem.Recurrence.Range is NoEndRecurrenceRange))
{
OccurrenceInfo lastOccurrence = calendarItem.Recurrence.GetLastOccurrence();
if (lastOccurrence != null && lastOccurrence.EndTime < endRange)
{
return(int.MinValue);
}
}
EndDateRecurrenceRange endDateRecurrenceRange = calendarItem.Recurrence.Range as EndDateRecurrenceRange;
if (endDateRecurrenceRange != null && endDateRecurrenceRange.EndDate < endRange)
{
return(int.MinValue);
}
IList <OccurrenceInfo> occurrenceInfoList = calendarItem.Recurrence.GetOccurrenceInfoList(calendarItem.Recurrence.Range.StartDate, endRange);
if (0 <= occurrenceInfoList.Count && (!(calendarItem.Recurrence.Range is NumberedRecurrenceRange) || occurrenceInfoList.Count < ((NumberedRecurrenceRange)calendarItem.Recurrence.Range).NumberOfOccurrences))
{
return(occurrenceInfoList.Count);
}
return(int.MinValue);
}
public static RecurrenceRange CloneRecurrenceRange(RecurrenceRange range)
{
RecurrenceRange result = null;
if (range == null)
{
return(result);
}
EndDateRecurrenceRange endDateRecurrenceRange = range as EndDateRecurrenceRange;
if (endDateRecurrenceRange != null)
{
return(new EndDateRecurrenceRange(endDateRecurrenceRange.StartDate, endDateRecurrenceRange.EndDate));
}
NoEndRecurrenceRange noEndRecurrenceRange = range as NoEndRecurrenceRange;
if (noEndRecurrenceRange != null)
{
return(new NoEndRecurrenceRange(noEndRecurrenceRange.StartDate));
}
NumberedRecurrenceRange numberedRecurrenceRange = range as NumberedRecurrenceRange;
if (numberedRecurrenceRange != null)
{
return(new NumberedRecurrenceRange(numberedRecurrenceRange.StartDate, numberedRecurrenceRange.NumberOfOccurrences));
}
throw new ArgumentException("Unhandled RecurrenceRange type.");
}
public static bool IsRecurrenceRangeEqual(RecurrenceRange r1, RecurrenceRange r2)
{
if (r1 == null != (r2 == null))
{
return(false);
}
if (r1 != null)
{
if (!r1.GetType().Equals(r2.GetType()))
{
return(false);
}
if (r1.StartDate != r2.StartDate)
{
return(false);
}
EndDateRecurrenceRange endDateRecurrenceRange = r1 as EndDateRecurrenceRange;
if (endDateRecurrenceRange != null)
{
EndDateRecurrenceRange endDateRecurrenceRange2 = r2 as EndDateRecurrenceRange;
return(!(endDateRecurrenceRange.EndDate != endDateRecurrenceRange2.EndDate));
}
NumberedRecurrenceRange numberedRecurrenceRange = r1 as NumberedRecurrenceRange;
if (numberedRecurrenceRange != null)
{
NumberedRecurrenceRange numberedRecurrenceRange2 = r2 as NumberedRecurrenceRange;
return(numberedRecurrenceRange.NumberOfOccurrences == numberedRecurrenceRange2.NumberOfOccurrences);
}
}
return(true);
}
// Token: 0x06001218 RID: 4632 RVA: 0x0006247C File Offset: 0x0006067C
private static RecurrenceRange CreateRecurrenceRange(ExDateTime startDate, RecurrenceData recurrenceData)
{
RecurrenceRange recurrenceRange = null;
try
{
if (recurrenceData.HasOccurences())
{
recurrenceRange = new NumberedRecurrenceRange();
((NumberedRecurrenceRange)recurrenceRange).NumberOfOccurrences = (int)recurrenceData.Occurrences;
}
else if (recurrenceData.HasUntil())
{
recurrenceRange = new EndDateRecurrenceRange();
((EndDateRecurrenceRange)recurrenceRange).EndDate = recurrenceData.Until;
}
else
{
recurrenceRange = new NoEndRecurrenceRange();
}
recurrenceRange.StartDate = startDate;
}
catch (ArgumentException ex)
{
throw new ConversionException(ex.Message);
}
return(recurrenceRange);
}
public void ChangeEndRecurrence()
{
OwaStoreObjectId owaStoreObjectId = (OwaStoreObjectId)base.GetParameter("Id");
string changeKey = (string)base.GetParameter("CK");
ExDateTime endRange = (ExDateTime)base.GetParameter("ET");
CalendarItem calendarItem = null;
try
{
calendarItem = Utilities.GetItem <CalendarItem>(base.UserContext, owaStoreObjectId, changeKey, new PropertyDefinition[]
{
CalendarItemBaseSchema.IsMeeting,
CalendarItemBaseSchema.MeetingRequestWasSent,
StoreObjectSchema.EffectiveRights
});
if (!ItemUtility.UserCanEditItem(calendarItem) || Utilities.IsItemInExternalSharedInFolder(base.UserContext, calendarItem))
{
this.Writer.Write("<div id=divOp _sOp=\"np\"></div>");
}
else
{
int num = MeetingUtilities.CancelRecurrence(calendarItem, endRange);
if (num != -2147483648)
{
if (calendarItem.IsMeeting && calendarItem.MeetingRequestWasSent && calendarItem.IsOrganizer())
{
base.ResponseContentType = OwaEventContentType.Html;
this.Writer.Write("<div id=divOp _sOp=er></div>");
}
else if (0 < num)
{
EndDateRecurrenceRange range = new EndDateRecurrenceRange(calendarItem.Recurrence.Range.StartDate, endRange.IncrementDays(-1));
calendarItem.Recurrence = new Recurrence(calendarItem.Recurrence.Pattern, range);
Utilities.SaveItem(calendarItem);
this.RenderPayload(new OwaStoreObjectId[]
{
(OwaStoreObjectId)base.GetParameter("fId")
});
}
else
{
calendarItem.DeleteMeeting(DeleteItemFlags.MoveToDeletedItems);
this.RenderPayload(new OwaStoreObjectId[]
{
(OwaStoreObjectId)base.GetParameter("fId")
});
}
}
}
}
finally
{
if (calendarItem != null)
{
calendarItem.Dispose();
calendarItem = null;
}
}
}
// Token: 0x0600121A RID: 4634 RVA: 0x00062608 File Offset: 0x00060808
private static void PopulateRecurrenceRange(RecurrenceData recurrenceData, RecurrenceRange range)
{
EndDateRecurrenceRange endDateRecurrenceRange = range as EndDateRecurrenceRange;
NumberedRecurrenceRange numberedRecurrenceRange = range as NumberedRecurrenceRange;
if (endDateRecurrenceRange != null)
{
recurrenceData.Until = endDateRecurrenceRange.EndDate;
return;
}
if (numberedRecurrenceRange != null)
{
recurrenceData.Occurrences = (ushort)numberedRecurrenceRange.NumberOfOccurrences;
}
}
public RecurrenceRange Convert(RecurrenceRange value)
{
if (value == null)
{
return(null);
}
NoEndRecurrenceRange noEndRecurrenceRange = value as NoEndRecurrenceRange;
if (noEndRecurrenceRange != null)
{
return(new NoEndRecurrenceRange
{
StartDate = noEndRecurrenceRange.StartDate
});
}
EndDateRecurrenceRange endDateRecurrenceRange = value as EndDateRecurrenceRange;
if (endDateRecurrenceRange != null)
{
return(new EndDateRecurrenceRange
{
StartDate = endDateRecurrenceRange.StartDate,
EndDate = endDateRecurrenceRange.EndDate
});
}
NumberedRecurrenceRange numberedRecurrenceRange = value as NumberedRecurrenceRange;
if (numberedRecurrenceRange != null)
{
return(new NumberedRecurrenceRange
{
StartDate = numberedRecurrenceRange.StartDate,
NumberOfOccurrences = numberedRecurrenceRange.NumberOfOccurrences
});
}
throw new ArgumentValueCannotBeParsedException("value", value.GetType().FullName, typeof(RecurrenceRange).FullName);
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
this.infobar.SetInfobarClass("infobarEdit");
this.infobar.SetShouldHonorHideByDefault(true);
this.calendarItemBase = base.Initialize <CalendarItemBase>(false, new PropertyDefinition[]
{
CalendarItemBaseSchema.CalendarItemType,
StoreObjectSchema.EffectiveRights
});
if (this.calendarItemBase != null)
{
if (string.Equals(base.OwaContext.FormsRegistryContext.Action, "Open", StringComparison.OrdinalIgnoreCase))
{
this.newItemType = NewItemType.ExplicitDraft;
}
else
{
this.newItemType = NewItemType.ImplicitDraft;
base.DeleteExistingDraft = true;
}
}
else
{
this.calendarItemBase = Utilities.CreateDraftMeetingRequestFromQueryString(base.UserContext, base.Request, new PropertyDefinition[]
{
StoreObjectSchema.EffectiveRights
});
if (this.calendarItemBase != null)
{
this.newItemType = NewItemType.ImplicitDraft;
base.DeleteExistingDraft = true;
base.Item = this.calendarItemBase;
}
}
if (this.calendarItemBase != null)
{
this.isMeeting = this.calendarItemBase.IsMeeting;
this.startTime = this.calendarItemBase.StartTime;
this.endTime = this.calendarItemBase.EndTime;
if (this.calendarItemBase.IsAllDayEvent && !this.IsRecurringMaster)
{
this.endTime = this.endTime.IncrementDays(-1);
}
this.recipientWell = new CalendarItemRecipientWell(this.calendarItemBase);
this.bodyMarkup = BodyConversionUtilities.GetBodyFormatOfEditItem(this.calendarItemBase, this.newItemType, base.UserContext.UserOptions);
this.toolbar = new EditCalendarItemToolbar(this.calendarItemBase, this.isMeeting, this.bodyMarkup, this.IsPublicItem);
this.toolbar.ToolbarType = (base.IsPreviewForm ? ToolbarType.Preview : ToolbarType.Form);
this.isBeingCanceled = (Utilities.GetQueryStringParameter(base.Request, "c", false) != null);
string queryStringParameter = Utilities.GetQueryStringParameter(base.Request, "er", false);
if (queryStringParameter != null)
{
if (this.calendarItemBase.CalendarItemType != CalendarItemType.RecurringMaster || !(this.calendarItemBase is CalendarItem))
{
throw new OwaInvalidRequestException("Invalid calendar item type. Only recurring masters support specifying an end range");
}
this.endRange = ExDateTime.MinValue;
try
{
this.endRange = DateTimeUtilities.ParseIsoDate(queryStringParameter, base.UserContext.TimeZone);
}
catch (OwaParsingErrorException)
{
ExTraceGlobals.CalendarDataTracer.TraceDebug <string>((long)this.GetHashCode(), "Invalid end range provided on URL '{0}'", queryStringParameter);
throw new OwaInvalidRequestException(string.Format("Invalid end range provided on URL '{0}'", queryStringParameter));
}
if (this.endRange != ExDateTime.MinValue)
{
CalendarItem calendarItem = (CalendarItem)this.calendarItemBase;
this.occurrenceCount = MeetingUtilities.CancelRecurrence(calendarItem, this.endRange);
if (this.occurrenceCount == 0)
{
this.isBeingCanceled = true;
}
}
}
string queryStringParameter2 = Utilities.GetQueryStringParameter(base.Request, "od", false);
if (queryStringParameter2 != null)
{
try
{
this.occurrenceDate = DateTimeUtilities.ParseIsoDate(queryStringParameter2, base.UserContext.TimeZone).Date;
goto IL_303;
}
catch (OwaParsingErrorException)
{
ExTraceGlobals.CalendarDataTracer.TraceDebug <string>((long)this.GetHashCode(), "Invalid occurrence date specified on URL '{0}'", queryStringParameter2);
throw new OwaInvalidRequestException(string.Format("Invalid occurrence date provided on URL '{0}'", queryStringParameter2));
}
}
this.occurrenceDate = DateTimeUtilities.GetLocalTime().Date;
IL_303:
CalendarUtilities.AddCalendarInfobarMessages(this.infobar, this.calendarItemBase, null, base.UserContext);
if (this.isBeingCanceled)
{
this.infobar.AddMessage(SanitizedHtmlString.FromStringId(1328030972), InfobarMessageType.Informational);
}
this.disableOccurrenceReminderUI = MeetingUtilities.CheckShouldDisableOccurrenceReminderUI(this.calendarItemBase);
if (this.disableOccurrenceReminderUI && !this.IsPublicItem)
{
this.infobar.AddMessage(SanitizedHtmlString.FromStringId(-891369593), InfobarMessageType.Informational);
}
if (!(this.calendarItemBase is CalendarItem))
{
this.recurrenceUtilities = new RecurrenceUtilities(null, base.SanitizingResponse);
return;
}
if (0 < this.occurrenceCount)
{
EndDateRecurrenceRange range = new EndDateRecurrenceRange(((CalendarItem)this.calendarItemBase).Recurrence.Range.StartDate, this.endRange.IncrementDays(-1));
this.recurrenceUtilities = new RecurrenceUtilities(new Recurrence(((CalendarItem)this.calendarItemBase).Recurrence.Pattern, range), base.SanitizingResponse);
return;
}
this.recurrenceUtilities = new RecurrenceUtilities(((CalendarItem)this.calendarItemBase).Recurrence, base.SanitizingResponse);
return;
}
else
{
this.isMeeting = (Utilities.GetQueryStringParameter(base.Request, "mr", false) != null);
if (this.isMeeting && this.IsPublicItem)
{
throw new OwaInvalidRequestException("Can't create meeting in Owa Public Folders");
}
this.isAllDayEvent = (Utilities.GetQueryStringParameter(base.Request, "evt", false) != null);
bool flag = Utilities.GetQueryStringParameter(base.Request, "tm", false) != null || this.isAllDayEvent;
string queryStringParameter3 = Utilities.GetQueryStringParameter(base.Request, "st", false);
if (queryStringParameter3 != null)
{
try
{
this.startTime = DateTimeUtilities.ParseIsoDate(queryStringParameter3, base.UserContext.TimeZone);
}
catch (OwaParsingErrorException)
{
ExTraceGlobals.CalendarDataTracer.TraceDebug <string>((long)this.GetHashCode(), "Invalid start date provided on URL '{0}'", queryStringParameter3);
throw new OwaInvalidRequestException(string.Format("Invalid start date provided on URL '{0}'", queryStringParameter3));
}
}
if (flag || this.startTime == ExDateTime.MinValue)
{
ExDateTime localTime = DateTimeUtilities.GetLocalTime();
if (this.startTime == ExDateTime.MinValue)
{
this.startTime = new ExDateTime(base.UserContext.TimeZone, localTime.Year, localTime.Month, localTime.Day, localTime.Hour, localTime.Minute, 0);
}
else
{
this.startTime = new ExDateTime(base.UserContext.TimeZone, this.startTime.Year, this.startTime.Month, this.startTime.Day, localTime.Hour, localTime.Minute, 0);
}
if (this.isAllDayEvent && this.startTime.Hour == 23)
{
if (this.startTime.Minute >= 30)
{
this.startTime = this.startTime.Date;
}
else
{
this.startTime = new ExDateTime(base.UserContext.TimeZone, this.startTime.Year, this.startTime.Month, this.startTime.Day, 23, 0, 0);
this.endTime = new ExDateTime(base.UserContext.TimeZone, this.startTime.Year, this.startTime.Month, this.startTime.Day, 23, 30, 0);
}
}
else if (this.startTime.Minute != 0 && this.startTime.Minute != 30)
{
this.startTime = this.startTime.AddMinutes((double)(30 - this.startTime.Minute % 30));
}
}
if (this.endTime == ExDateTime.MinValue)
{
this.endTime = this.startTime.AddMinutes(60.0);
}
this.recipientWell = new CalendarItemRecipientWell();
this.bodyMarkup = base.UserContext.UserOptions.ComposeMarkup;
this.toolbar = new EditCalendarItemToolbar(null, this.isMeeting, this.bodyMarkup, this.IsPublicItem);
this.toolbar.ToolbarType = (base.IsPreviewForm ? ToolbarType.Preview : ToolbarType.Form);
this.recurrenceUtilities = new RecurrenceUtilities(null, base.SanitizingResponse);
return;
}
}
protected Recurrence CreateRecurrenceFromRequest()
{
Recurrence result = null;
if (base.IsParameterSet("RcrT"))
{
OwaRecurrenceType owaRecurrenceType = (OwaRecurrenceType)base.GetParameter("RcrT");
RecurrencePattern recurrencePattern = null;
OwaRecurrenceType owaRecurrenceType2 = owaRecurrenceType;
if (owaRecurrenceType2 <= (OwaRecurrenceType.Monthly | OwaRecurrenceType.MonthlyTh))
{
if (owaRecurrenceType2 <= OwaRecurrenceType.Monthly)
{
switch (owaRecurrenceType2)
{
case OwaRecurrenceType.Daily:
recurrencePattern = new DailyRecurrencePattern((int)base.GetParameter("RcrI"));
break;
case OwaRecurrenceType.None | OwaRecurrenceType.Daily:
break;
case OwaRecurrenceType.Weekly:
recurrencePattern = new WeeklyRecurrencePattern((DaysOfWeek)base.GetParameter("RcrDys"), (int)base.GetParameter("RcrI"));
break;
default:
if (owaRecurrenceType2 == OwaRecurrenceType.Monthly)
{
recurrencePattern = new MonthlyRecurrencePattern((int)base.GetParameter("RcrDy"), (int)base.GetParameter("RcrI"));
}
break;
}
}
else if (owaRecurrenceType2 != OwaRecurrenceType.Yearly)
{
if (owaRecurrenceType2 != (OwaRecurrenceType.Daily | OwaRecurrenceType.DailyEveryWeekday))
{
if (owaRecurrenceType2 == (OwaRecurrenceType.Monthly | OwaRecurrenceType.MonthlyTh))
{
recurrencePattern = new MonthlyThRecurrencePattern((DaysOfWeek)base.GetParameter("RcrDys"), (RecurrenceOrderType)base.GetParameter("RcrO"), (int)base.GetParameter("RcrI"));
}
}
else
{
recurrencePattern = new WeeklyRecurrencePattern(DaysOfWeek.Weekdays);
}
}
else
{
recurrencePattern = new YearlyRecurrencePattern((int)base.GetParameter("RcrDy"), (int)base.GetParameter("RcrM"));
}
}
else if (owaRecurrenceType2 <= (OwaRecurrenceType.Daily | OwaRecurrenceType.DailyRegenerating))
{
if (owaRecurrenceType2 != (OwaRecurrenceType.Yearly | OwaRecurrenceType.YearlyTh))
{
if (owaRecurrenceType2 == (OwaRecurrenceType.Daily | OwaRecurrenceType.DailyRegenerating))
{
recurrencePattern = new DailyRegeneratingPattern((int)base.GetParameter("RgrI"));
}
}
else
{
recurrencePattern = new YearlyThRecurrencePattern((DaysOfWeek)base.GetParameter("RcrDys"), (RecurrenceOrderType)base.GetParameter("RcrO"), (int)base.GetParameter("RcrM"));
}
}
else if (owaRecurrenceType2 != (OwaRecurrenceType.Weekly | OwaRecurrenceType.WeeklyRegenerating))
{
if (owaRecurrenceType2 != (OwaRecurrenceType.Monthly | OwaRecurrenceType.MonthlyRegenerating))
{
if (owaRecurrenceType2 == (OwaRecurrenceType.Yearly | OwaRecurrenceType.YearlyRegenerating))
{
recurrencePattern = new YearlyRegeneratingPattern((int)base.GetParameter("RgrI"));
}
}
else
{
recurrencePattern = new MonthlyRegeneratingPattern((int)base.GetParameter("RgrI"));
}
}
else
{
recurrencePattern = new WeeklyRegeneratingPattern((int)base.GetParameter("RgrI"));
}
if (owaRecurrenceType != OwaRecurrenceType.None)
{
RecurrenceRangeType recurrenceRangeType = (RecurrenceRangeType)base.GetParameter("RcrRngT");
ExDateTime startDate = (ExDateTime)base.GetParameter("RcrRngS");
RecurrenceRange recurrenceRange;
switch (recurrenceRangeType)
{
case RecurrenceRangeType.Numbered:
recurrenceRange = new NumberedRecurrenceRange(startDate, (int)base.GetParameter("RcrRngO"));
goto IL_2C8;
case RecurrenceRangeType.EndDate:
recurrenceRange = new EndDateRecurrenceRange(startDate, (ExDateTime)base.GetParameter("RcrRngE"));
goto IL_2C8;
}
recurrenceRange = new NoEndRecurrenceRange(startDate);
IL_2C8:
if (recurrencePattern != null && recurrenceRange != null)
{
result = new Recurrence(recurrencePattern, recurrenceRange);
}
}
}
return(result);
}
// Token: 0x060001CB RID: 459 RVA: 0x00011324 File Offset: 0x0000F524
private static Recurrence CreateRecurrenceFromRequest(HttpRequest request, ExDateTime startDate, UserContext userContext)
{
OwaRecurrenceType newRecurrenceTypeFromPost = EditRecurrencePreFormAction.GetNewRecurrenceTypeFromPost(request);
RecurrencePattern pattern = null;
Recurrence result = null;
DaysOfWeek defaultDaysOfWeek = CalendarUtilities.ConvertDateTimeToDaysOfWeek(startDate);
int defaultValue = CalendarUtilities.ComputeDayOfMonthOrder(startDate);
OwaRecurrenceType owaRecurrenceType = newRecurrenceTypeFromPost;
if (owaRecurrenceType <= OwaRecurrenceType.Yearly)
{
switch (owaRecurrenceType)
{
case OwaRecurrenceType.Daily:
{
int num = EditRecurrencePreFormAction.GetIntFormParameter(request, "txtinterval", 1);
num = Math.Max(1, num);
pattern = new DailyRecurrencePattern(num);
break;
}
case OwaRecurrenceType.None | OwaRecurrenceType.Daily:
break;
case OwaRecurrenceType.Weekly:
{
int num = EditRecurrencePreFormAction.GetIntFormParameter(request, "txtinterval", 1);
num = Math.Max(1, num);
pattern = new WeeklyRecurrencePattern(EditRecurrencePreFormAction.ParseDayCheckboxes(request, defaultDaysOfWeek), num);
break;
}
default:
if (owaRecurrenceType != OwaRecurrenceType.Monthly)
{
if (owaRecurrenceType == OwaRecurrenceType.Yearly)
{
int num2 = EditRecurrencePreFormAction.GetIntFormParameter(request, "selRcrYD", startDate.Day);
int intFormParameter = EditRecurrencePreFormAction.GetIntFormParameter(request, "selRcrYM", startDate.Month);
num2 = Math.Min(ExDateTime.DaysInMonth(startDate.Year, intFormParameter), num2);
pattern = new YearlyRecurrencePattern(num2, intFormParameter);
}
}
else
{
int num2 = EditRecurrencePreFormAction.GetIntFormParameter(request, "txtRcrMD", startDate.Day);
int num = EditRecurrencePreFormAction.GetIntFormParameter(request, "txtRcrMM", 1);
num = Math.Max(1, num);
pattern = new MonthlyRecurrencePattern(num2, num);
}
break;
}
}
else if (owaRecurrenceType != (OwaRecurrenceType.Daily | OwaRecurrenceType.DailyEveryWeekday))
{
if (owaRecurrenceType != (OwaRecurrenceType.Monthly | OwaRecurrenceType.MonthlyTh))
{
if (owaRecurrenceType == (OwaRecurrenceType.Yearly | OwaRecurrenceType.YearlyTh))
{
int intFormParameter2 = EditRecurrencePreFormAction.GetIntFormParameter(request, "selRcrYTI", defaultValue);
int intFormParameter = EditRecurrencePreFormAction.GetIntFormParameter(request, "selRcrYTM", startDate.Month);
DaysOfWeek daysOfWeek = EditRecurrencePreFormAction.ParseDaysOfWeek(request, "selRcrThD", defaultDaysOfWeek);
pattern = new YearlyThRecurrencePattern(daysOfWeek, (RecurrenceOrderType)intFormParameter2, intFormParameter);
}
}
else
{
int intFormParameter2 = EditRecurrencePreFormAction.GetIntFormParameter(request, "selRcrYTI", defaultValue);
int num = EditRecurrencePreFormAction.GetIntFormParameter(request, "txtRcrMThM", 1);
num = Math.Max(1, num);
DaysOfWeek daysOfWeek = EditRecurrencePreFormAction.ParseDaysOfWeek(request, "selRcrThD", defaultDaysOfWeek);
pattern = new MonthlyThRecurrencePattern(daysOfWeek, (RecurrenceOrderType)intFormParameter2, num);
}
}
else
{
pattern = new WeeklyRecurrencePattern(DaysOfWeek.Weekdays);
}
if (newRecurrenceTypeFromPost != OwaRecurrenceType.None)
{
if (startDate == ExDateTime.MinValue)
{
startDate = CalendarUtilities.ParseDateTimeFromForm(request, "selSY", "selSM", "selSD", null, userContext);
}
RecurrenceRange range;
switch (EditRecurrencePreFormAction.GetRecurrenceRangeTypeFromPost(request))
{
case RecurrenceRangeType.Numbered:
{
int num3 = EditRecurrencePreFormAction.GetIntFormParameter(request, "txtno", 10);
num3 = Math.Max(1, num3);
range = new NumberedRecurrenceRange(startDate, num3);
goto IL_284;
}
case RecurrenceRangeType.EndDate:
{
ExDateTime exDateTime = CalendarUtilities.ParseDateTimeFromForm(request, "selEY", "selEM", "selED", null, userContext);
if (exDateTime < startDate)
{
exDateTime = startDate.IncrementDays(10);
}
range = new EndDateRecurrenceRange(startDate, exDateTime);
goto IL_284;
}
}
range = new NoEndRecurrenceRange(startDate);
IL_284:
result = new Recurrence(pattern, range);
}
return(result);
}
protected override void InternalCopyFromModified(IProperty srcProperty)
{
CalendarItem calendarItem = null;
Task task = null;
if (this.recurrenceType == TypeOfRecurrence.Calendar)
{
calendarItem = (base.XsoItem as CalendarItem);
if (calendarItem == null)
{
throw new UnexpectedTypeException("CalendarItem", base.XsoItem);
}
if (!calendarItem.IsOrganizer())
{
AirSyncDiagnostics.TraceInfo(ExTraceGlobals.CommonTracer, null, "InternalCopyFromModified::Skip Recurrence change in case of attendee.");
return;
}
}
else if (this.recurrenceType == TypeOfRecurrence.Task)
{
task = (base.XsoItem as Task);
if (task == null)
{
throw new UnexpectedTypeException("Task", base.XsoItem);
}
}
INestedProperty nestedProperty = srcProperty as INestedProperty;
if (nestedProperty == null)
{
throw new UnexpectedTypeException("INestedProperty", srcProperty);
}
RecurrenceData recurrenceData = nestedProperty.NestedData as RecurrenceData;
if (recurrenceData == null)
{
throw new UnexpectedTypeException("RecurrenceData", nestedProperty.NestedData);
}
Recurrence recurrence = (this.recurrenceType == TypeOfRecurrence.Calendar) ? calendarItem.Recurrence : task.Recurrence;
RecurrencePattern recurrencePattern = XsoRecurrenceProperty.CreateRecurrencePattern(this.recurrenceType, recurrenceData, recurrence);
ExDateTime startDate = ExDateTime.MinValue;
ExDateTime endDate = ExDateTime.MinValue;
if (this.recurrenceType == TypeOfRecurrence.Calendar)
{
ExDateTime startTime = calendarItem.StartTime;
ExTimeZone exTimeZoneFromItem = TimeZoneHelper.GetExTimeZoneFromItem(calendarItem);
startDate = exTimeZoneFromItem.ConvertDateTime(startTime);
if (recurrenceData.HasUntil())
{
ExDateTime until = recurrenceData.Until;
endDate = exTimeZoneFromItem.ConvertDateTime(until);
}
}
else if (this.recurrenceType == TypeOfRecurrence.Task)
{
startDate = recurrenceData.Start;
if (recurrenceData.HasUntil())
{
endDate = recurrenceData.Until;
}
}
RecurrenceRange range;
try
{
if (recurrenceData.HasOccurences())
{
range = new NumberedRecurrenceRange(startDate, (int)recurrenceData.Occurrences);
}
else if (recurrenceData.HasUntil())
{
range = new EndDateRecurrenceRange(startDate, endDate);
}
else
{
range = new NoEndRecurrenceRange(startDate);
}
}
catch (ArgumentException ex)
{
throw new ConversionException(ex.Message);
}
bool ignoreCalendarTypeAndIsLeapMonth = recurrenceData.ProtocolVersion < 140;
if (recurrence != null && recurrence.Pattern != null && recurrence.Pattern.Equals(recurrencePattern, ignoreCalendarTypeAndIsLeapMonth))
{
recurrencePattern = recurrence.Pattern;
}
try
{
if (this.recurrenceType == TypeOfRecurrence.Calendar)
{
ExTimeZone exTimeZoneFromItem2 = TimeZoneHelper.GetExTimeZoneFromItem(calendarItem);
try
{
calendarItem.Recurrence = new Recurrence(recurrencePattern, range, exTimeZoneFromItem2, null);
goto IL_295;
}
catch (ArgumentOutOfRangeException)
{
if (recurrenceData.CalendarType == CalendarType.Default)
{
recurrenceData.CalendarType = CalendarType.Gregorian;
AirSyncDiagnostics.TraceInfo(ExTraceGlobals.CommonTracer, null, "Replace calendar recurrence calendar type with Gregorian.");
recurrencePattern = XsoRecurrenceProperty.CreateRecurrencePattern(this.recurrenceType, recurrenceData, recurrence);
calendarItem.Recurrence = new Recurrence(recurrencePattern, range, exTimeZoneFromItem2, null);
goto IL_295;
}
throw;
}
}
try
{
task.Recurrence = new Recurrence(recurrencePattern, range);
}
catch (ArgumentOutOfRangeException)
{
if (recurrenceData.CalendarType != CalendarType.Default)
{
throw;
}
recurrenceData.CalendarType = CalendarType.Gregorian;
AirSyncDiagnostics.TraceInfo(ExTraceGlobals.CommonTracer, null, "Replace task recurrence calendar type with Gregorian.");
recurrencePattern = XsoRecurrenceProperty.CreateRecurrencePattern(this.recurrenceType, recurrenceData, recurrence);
task.Recurrence = new Recurrence(recurrencePattern, range);
}
task[TaskSchema.IsOneOff] = recurrenceData.DeadOccur;
IL_295 :;
}
catch (NotSupportedException ex2)
{
throw new ConversionException(ex2.Message);
}
}
public static Microsoft.Exchange.Connections.Eas.Model.Request.Calendar.Recurrence GetRecurrenceData(PatternedRecurrence recurrence)
{
if (recurrence == null)
{
return(null);
}
Microsoft.Exchange.Connections.Eas.Model.Request.Calendar.Recurrence recurrence2 = new Microsoft.Exchange.Connections.Eas.Model.Request.Calendar.Recurrence();
recurrence2.Interval = new ushort?((ushort)recurrence.Pattern.Interval);
RecurrencePatternType type = recurrence.Pattern.Type;
switch (type)
{
case RecurrencePatternType.Daily:
{
DailyRecurrencePattern dailyRecurrencePattern = (DailyRecurrencePattern)recurrence.Pattern;
recurrence2.Type = 0;
break;
}
case RecurrencePatternType.Weekly:
{
WeeklyRecurrencePattern weeklyRecurrencePattern = (WeeklyRecurrencePattern)recurrence.Pattern;
recurrence2.Type = 1;
recurrence2.DayOfWeek = new ushort?(SyncCalendarUtils.GetDayOfWeekValue(weeklyRecurrencePattern.DaysOfWeek));
break;
}
case RecurrencePatternType.AbsoluteMonthly:
{
AbsoluteMonthlyRecurrencePattern absoluteMonthlyRecurrencePattern = (AbsoluteMonthlyRecurrencePattern)recurrence.Pattern;
recurrence2.Type = 2;
recurrence2.DayOfMonth = new byte?((byte)absoluteMonthlyRecurrencePattern.DayOfMonth);
break;
}
case RecurrencePatternType.RelativeMonthly:
{
RelativeMonthlyRecurrencePattern relativeMonthlyRecurrencePattern = (RelativeMonthlyRecurrencePattern)recurrence.Pattern;
recurrence2.Type = 3;
recurrence2.DayOfWeek = new ushort?(SyncCalendarUtils.GetDayOfWeekValue(relativeMonthlyRecurrencePattern.DaysOfWeek));
recurrence2.WeekOfMonth = new byte?((byte)relativeMonthlyRecurrencePattern.Index);
break;
}
case RecurrencePatternType.AbsoluteYearly:
{
AbsoluteYearlyRecurrencePattern absoluteYearlyRecurrencePattern = (AbsoluteYearlyRecurrencePattern)recurrence.Pattern;
recurrence2.Type = 5;
recurrence2.DayOfMonth = new byte?((byte)absoluteYearlyRecurrencePattern.DayOfMonth);
recurrence2.MonthOfYear = new byte?((byte)absoluteYearlyRecurrencePattern.Month);
break;
}
case RecurrencePatternType.RelativeYearly:
{
RelativeYearlyRecurrencePattern relativeYearlyRecurrencePattern = (RelativeYearlyRecurrencePattern)recurrence.Pattern;
recurrence2.Type = 6;
recurrence2.DayOfWeek = new ushort?(SyncCalendarUtils.GetDayOfWeekValue(relativeYearlyRecurrencePattern.DaysOfWeek));
recurrence2.WeekOfMonth = new byte?((byte)relativeYearlyRecurrencePattern.Index);
recurrence2.MonthOfYear = new byte?((byte)relativeYearlyRecurrencePattern.Month);
break;
}
default:
throw new EasSyncFailedPermanentException("Invalid recurrence type: " + type);
}
RecurrenceRangeType type2 = recurrence.Range.Type;
switch (type2)
{
case RecurrenceRangeType.EndDate:
{
EndDateRecurrenceRange endDateRecurrenceRange = (EndDateRecurrenceRange)recurrence.Range;
recurrence2.Until = SyncCalendarUtils.ToStringDateTime(endDateRecurrenceRange.EndDate);
break;
}
case RecurrenceRangeType.NoEnd:
break;
case RecurrenceRangeType.Numbered:
{
NumberedRecurrenceRange numberedRecurrenceRange = (NumberedRecurrenceRange)recurrence.Range;
recurrence2.Occurrences = new ushort?((ushort)numberedRecurrenceRange.NumberOfOccurrences);
break;
}
default:
throw new EasSyncFailedPermanentException("Invalid recurrence range type: {0}" + type2);
}
return(recurrence2);
}
