// Token: 0x060015DB RID: 5595 RVA: 0x0007B110 File Offset: 0x00079310
protected override void OnObjectModified(IMapiEvent mapiEvent, IMailboxSession itemStore, IStoreObject item, List <KeyValuePair <string, object> > customDataToLog)
{
ExTraceGlobals.GeneralTracer.TraceDebug((long)this.GetHashCode(), "EventTimeBasedInboxReminderProcessor.OnObjectModified");
if (item != null)
{
ExTraceGlobals.GeneralTracer.TraceDebug((long)this.GetHashCode(), "EventTimeBasedInboxReminderProcessor.OnObjectModified - item exists");
if (!(item is ICalendarItem))
{
return;
}
ICalendarItem calendarItem = (ICalendarItem)item;
if (calendarItem.GlobalObjectId == null)
{
base.Log.LogEntry(itemStore, "EventTimeBasedInboxReminder.OnObjectModified - Calendar item missing GOID", new object[0]);
return;
}
base.Log.LogEntry(itemStore, "EventTimeBasedInboxReminder.OnObjectModified - Start Time:{0}, End Time:{1}", new object[]
{
calendarItem.StartTime.UniversalTime,
calendarItem.EndTime.UniversalTime
});
this.DeleteReminderMessages(itemStore, calendarItem, customDataToLog);
this.CreateReminderMessages(itemStore, calendarItem, customDataToLog);
}
}
public ViewCalendarItem(Contents obj)
{
this.InitializeComponent();
ViewModel = obj;
MainGrid.DataContext = ViewModel;
CurrentItem = GetItemType(ViewModel);
InitView();
}
public FormNavigator(ICalendarItem i_Event)
{
InitializeComponent();
gMapControlNavigator.MapProvider = GoogleMapProvider.Instance;
gMapControlNavigator.Position = i_Event.Position;
labelNameOfEvent.Text = i_Event.EventName;
m_End = gMapControlNavigator.Position;
}
public void FromRightToLeftType(ICalendarItemBase left, Event right)
{
ICalendarItem calendarItem = left as ICalendarItem;
if (calendarItem != null && right.IsPropertySet(SchematizedObject <EventSchema> .SchemaInstance.SeriesMasterIdProperty))
{
SeriesMasterIdTranslationRule.NprInstanceAccessor.Set(calendarItem, right.SeriesMasterId);
}
}
public CalendarVm()
{
_staticItemType = new ActivityContainer()
{
Title = Content["CALENDAR_ALL"].ToString()
};
_selectedCalendarItemType = _staticItemType;
InitTutorialUc(PageName.CalendarView);
}
// Token: 0x060015DD RID: 5597 RVA: 0x0007B2B0 File Offset: 0x000794B0
private void DeleteReminderMessages(IMailboxSession itemStore, ICalendarItem calendarItem, List <KeyValuePair <string, object> > customDataToLog)
{
int numRemindersDeleted = 0;
customDataToLog.Add(new KeyValuePair <string, object>("EvtRemDel.Latency", base.ExecuteAndMeasure(delegate
{
numRemindersDeleted = this.ReminderMessageManager.DeleteReminderMessages(itemStore, calendarItem);
}).ToString()));
customDataToLog.Add(new KeyValuePair <string, object>("EvtRemDel.Count", numRemindersDeleted));
}
private void StampRetryProperties(IEvent sourceEntity, ICalendarItemBase calendarItemBase)
{
calendarItemBase.ClientId = this.ClientId;
ICalendarItem calendarItem = calendarItemBase as ICalendarItem;
if (calendarItem != null)
{
calendarItem.InstanceCreationIndex = ((IEventInternal)sourceEntity).InstanceCreationIndex;
}
}
protected virtual void ValidateSeriesMasterId(ICalendarItem storeObject)
{
string b;
bool flag = this.TryGetSeriesMasterId(storeObject, out b);
if (base.Entity.IsPropertySet(base.Entity.Schema.SeriesMasterIdProperty) && (!flag || base.Entity.SeriesMasterId != b))
{
throw new InvalidRequestException(CalendaringStrings.ErrorCallerCantChangeSeriesMasterId);
}
}
public ActivityVm()
{
_staticItemType = new ActivityContainer()
{
Title = Content["CALENDAR_ALL"].ToString()
};
_selectedActivityItemType = _staticItemType;
BottomBarActivity.ButtonDeleteEvent += new EventHandler(DeleteActivity);
InitTutorialUc(PageName.ActivityView);
}
private static void DisplayCalendarItem(ICalendarItem calendarEvent)
{
Console.WriteLine("=======================");
Console.WriteLine("Calendar Item");
Console.WriteLine($"Name: {calendarEvent.Name}");
Console.WriteLine($"Start Time: {calendarEvent.StartTime:s}");
Console.WriteLine($"Type: {calendarEvent.ItemType}");
Console.WriteLine($"Type: {calendarEvent.ItemTypeDescription}");
Console.WriteLine("=======================");
}
protected virtual ICalendarItemBase BindToMasterFromInstance(ICalendarItem instance)
{
ICalendarItemBase result;
if (!this.TryBindToMasterFromSeriesMasterId(instance, out result))
{
result = this.BindToMasterFromSeriesId(instance.SeriesId);
}
return(result);
}
protected virtual bool TryGetSeriesMasterId(ICalendarItem item, out StoreId seriesMasterId)
{
string text;
if (EventTranslator.SeriesMasterIdRule.TryGetValue(item, out text) && !string.IsNullOrEmpty(text))
{
seriesMasterId = base.IdConverter.ToStoreObjectId(text);
return(true);
}
seriesMasterId = null;
return(false);
}
// Token: 0x060015DE RID: 5598 RVA: 0x0007B35C File Offset: 0x0007955C
private void CreateReminderMessages(IMailboxSession itemStore, ICalendarItem calendarItem, List <KeyValuePair <string, object> > customDataToLog)
{
Reminders <EventTimeBasedInboxReminder> reminders = calendarItem.EventTimeBasedInboxReminders;
int numRemindersCreated = 0;
long num = base.ExecuteAndMeasure(delegate
{
numRemindersCreated = this.ReminderMessageManager.CreateReminderMessages(itemStore, calendarItem, reminders, customDataToLog);
});
customDataToLog.Add(new KeyValuePair <string, object>("EvtRemAdd.Latency", num.ToString()));
customDataToLog.Add(new KeyValuePair <string, object>("EvtRemAdd.Count", numRemindersCreated));
}
private void updateMap(ICalendarItem i_Event)
{
if (i_Event != null && i_Event.PlaceName != null)
{
buttonNavigator.Visible = true;
gMapControlMap.Visible = true;
gMapControlMap.Position = i_Event.Position;
}
else
{
buttonNavigator.Visible = false;
gMapControlMap.Visible = false;
}
}
private void listBoxEventsOfSelectedDate_SelectedIndexChanged(object sender, EventArgs e)
{
ICalendarItem selectedEvent = listBoxEventsOfSelectedDate.SelectedItem as ICalendarItem;
updateMap(selectedEvent);
m_EventSelected = selectedEvent;
try
{
imageNormalPictureBox1.Load(selectedEvent.ImageNormal);
}
catch
{
Logger.Instance.WriteMessage("Failed No picture found In the Event");
}
}
public override Event ConvertToEntity(ICalendarItemBase storeObject)
{
ICalendarItem calendarItem = storeObject as ICalendarItem;
if (calendarItem == null || string.IsNullOrEmpty(storeObject.SeriesId))
{
return(base.ConvertToEntity(storeObject));
}
Event result;
using (ICalendarItemBase calendarItemBase = this.BindToMasterFromInstance(calendarItem))
{
result = ((calendarItemBase != null) ? this.Translator.ConvertToEntity(calendarItemBase, storeObject) : base.ConvertToEntity(storeObject));
}
return(result);
}
public SyncResult Synchronize(StoreObjectId folderId, Deadline deadline)
{
this.Tracer.TraceDebug <object, StoreObjectId, string>((long)this.GetHashCode(), "{0}: ConsumerCalendarSharingEngine.Synchronize will try to sync folder {1} for mailbox {2}.", TraceContext.Get(), folderId, this.MailboxSession.DisplayAddress);
ConsumerCalendarSubscription consumerCalendarSubscription = this.TryGetSubscription(folderId);
if (consumerCalendarSubscription == null)
{
return(SyncResult.SubscriptionLost);
}
using (ICalendarItem calendarItem = this.XsoFactory.CreateCalendarItem(this.MailboxSession, folderId))
{
calendarItem.StartTime = ExDateTime.Now;
calendarItem.EndTime = calendarItem.StartTime.AddSeconds(1.0);
calendarItem.Subject = string.Format("Consumer Calendar Sync: OwnerId={0}, CalendarGuid={1}", consumerCalendarSubscription.ConsumerCalendarOwnerId, consumerCalendarSubscription.ConsumerCalendarGuid);
calendarItem.Save(SaveMode.NoConflictResolutionForceSave);
}
return(SyncResult.Completed);
}
public bool TryGetValue(ICalendarItemBase container, out string value)
{
ICalendarItemOccurrence calendarItemOccurrence = container as ICalendarItemOccurrence;
if (calendarItemOccurrence != null)
{
value = this.IdConverter.ToStringId(calendarItemOccurrence.MasterId, calendarItemOccurrence.Session);
return(true);
}
ICalendarItem calendarItem = container as ICalendarItem;
if (calendarItem != null && !string.IsNullOrEmpty(calendarItem.SeriesId))
{
return(SeriesMasterIdTranslationRule.NprInstanceAccessor.TryGetValue(calendarItem, out value));
}
value = null;
return(false);
}
/// <summary>
/// The row at index.
/// </summary>
/// <param name="index">
/// The index.
/// </param>
/// <returns>
/// The <see cref="UPMResultRow"/>.
/// </returns>
public override UPMResultRow RowAtIndex(int index)
{
ICalendarItem item = this.resultRows[index];
UPCRMResultRow crmResultRow = item.CrmResultRow;
if (crmResultRow != null)
{
ResultRowCalendarItem resultRow = (ResultRowCalendarItem)item;
if (this.resultContext != null)
{
var dict = this.resultContext.FieldControl.FunctionNames(crmResultRow);
string startDateString = (string)dict["Date"];
string startTimeString = (string)dict["Time"];
resultRow.StartDate = StringExtensions.DateFromStrings(startDateString, startTimeString);
// .DateFromCrmValueWithCrmTime(startTimeString);
}
resultRow.CrmValue = true;
resultRow.Invalid = true;
resultRow.DataValid = true;
resultRow.RowColor = item.Color;
this.TheDelegate?.ResultRowProviderDidCreateRowFromDataRow(this, resultRow, crmResultRow);
return(resultRow);
}
else
{
// EKEvent localEvent = null;
// if (item.IsKindOfClass(typeof(EKEvent)))
// {
// localEvent = item;
// }
// ResultRowCalendarItem resultRow = new ResultRowCalendarItem(StringIdentifier.IdentifierWithStringId(item.Identification), localEvent);
// this.TheDelegate?.ResultRowProviderDidCreateRowFromDataRow(this, resultRow, crmResultRow);
// return resultRow;
}
return(null);
}
private void OnBeforeStoreObjectSaved(BirthdayEvent birthdayEvent, ICalendarItemBase calendarItemBase)
{
CreateBirthdayEventForContact.CreateBirthdayEventTracer.TraceDebug <BirthdayEvent, ICalendarItemBase>(0L, "CreateBirthdayEventForContact::OnBeforeStoreObjectSaved: The birthday event {0} was created, and the calendar item {1} will be saved", birthdayEvent, calendarItemBase);
calendarItemBase.FreeBusyStatus = BusyType.Free;
calendarItemBase.IsAllDayEvent = true;
ExDateTime exDateTime = birthdayEvent.Birthday.ToUtc();
RecurrencePattern pattern = new YearlyRecurrencePattern(exDateTime.Day, exDateTime.Month);
int year = birthdayEvent.IsBirthYearKnown ? exDateTime.Year : ExDateTime.Today.Year;
ExTimeZone timeZone = this.DetermineRecurrenceStartTimeZone();
ExDateTime startDate = new ExDateTime(timeZone, year, exDateTime.Month, exDateTime.Day);
RecurrenceRange range = new NoEndRecurrenceRange(startDate);
ICalendarItem calendarItem = calendarItemBase as ICalendarItem;
if (calendarItem == null)
{
throw new NotSupportedException("Must be able to cast base to calendar item to specify recurrence.");
}
calendarItem.Recurrence = new Recurrence(pattern, range);
calendarItem.ReminderMinutesBeforeStart = 1080;
CreateBirthdayEventForContact.CreateBirthdayEventTracer.TraceDebug <ExDateTime, ExTimeZone>(0L, "CreateBirthdayEventForContact::OnBeforeStoreObjectSaved: recurrence start date is {0}, read time zone is {1}", calendarItem.Recurrence.Range.StartDate, calendarItem.Recurrence.ReadExTimeZone);
}
protected virtual bool TryBindToMasterFromSeriesMasterId(ICalendarItem instance, out ICalendarItemBase master)
{
master = null;
StoreId id;
if (!this.TryGetSeriesMasterId(instance, out id))
{
return(false);
}
bool result;
try
{
master = this.Bind(id);
result = true;
}
catch (ObjectNotFoundException arg)
{
base.Trace.TraceError <ObjectNotFoundException>((long)this.GetHashCode(), "Error while binding master based on SeriesMasterId. {0}", arg);
result = false;
}
return(result);
}
public ObservableCollection <ICalendarItem> GetDateItems(ObservableCollection <KeyValuePair <DateTime, ICalendarItem> > list, DateTime date, ICalendarItem item = null)
{
ObservableCollection <ICalendarItem> tempList = new ObservableCollection <ICalendarItem>();
foreach (KeyValuePair <DateTime, ICalendarItem> obj in list)
{
if (obj.Key.Date == date.Date)
{
if (item != null)
{
if (item.GetType() == typeof(ActivityContainer))
{
tempList.Add(obj.Value);
continue;
}
if (item.GetType() == obj.Value.GetType() && item.GetType() != typeof(Activity))
{
tempList.Add(obj.Value);
continue;
}
if (item.GetType() == typeof(Activity) && obj.Value.GetType() == typeof(Activity))
{
if (((Activity)item).Id == ((Activity)obj.Value).Id)
{
tempList.Add(obj.Value);
}
}
}
else
{
tempList.Add(obj.Value);
}
}
}
return(tempList);
}
private void RemoveCalendarItem(ICalendarItem item) => this.RemoveRange(this.Where(i => i.Item == item).ToList());
/// <summary>
/// Compares the value of this instance to a specified <see cref="ICalendarItem"/> object, and returns an integer that indicates whether this instance is earlier than, the same as, or later than the specified object.
/// </summary>
/// <param name="obj">An <see cref="ICalendarItem"/> to compare, or null.</param>
/// <returns>A signed number indicating the relative values of this instance and <paramref name="obj"/>.
/// <list type="bullet">
/// <item>Less than zero if this instance is earlier than <paramref name="obj"/>.</item>
/// <item>Zero if this instance coincides with <paramref name="obj"/>.</item>
/// <item>Greater than zero if this instance is later than <paramref name="obj"/>, or <paramref name="obj"/> is null.</item>
/// </list>
/// </returns>
public int CompareTo(object obj)
{
ICalendarItem item = obj as ICalendarItem;
return(item != null?this.StartDate.CompareTo(item.StartDate) : 1);
}
public CalendarBar(ICalendarItem item, DateTime baseDate)
{
Item = item;
BaseDate = baseDate;
}
private IEnumerable <CalendarBar> AllBarsForItem(ICalendarItem coverage) => new CalendarBar(coverage, coverage.Begin.Date) .BarsForAllWeeks() .Where(i => IsVisibleDate(i, i.BaseDate));
/// <summary>
/// The sender needs calendar item details.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="item">The item.</param>
public void SenderNeedsCalendarItemDetails(/*UPCalendarViewController*/ object sender, ICalendarItem item)
{
if (item.CrmResultRow == null && item.ResultRow != null)
{
return;
}
UPMResultRow resultRow = new UPMResultRow(new RecordIdentifier(item.CrmResultRow.RootRecordIdentification));
item.ResultRow = resultRow;
resultRow.Invalid = true;
resultRow.DataValid = true;
UPMCalendarPopoverGroup popoverGroup = new UPMCalendarPopoverGroup(item.ResultRow.Identifier)
{
Invalid = true,
Context = item
};
resultRow.AddDetailGroup(popoverGroup);
}
/// <summary>
/// The add value.
/// </summary>
/// <param name="calendarResult">
/// The calendar result.
/// </param>
public void AddValue(ICalendarItem calendarResult)
{
this.resultRows.Add(calendarResult);
}
public Dictionary <TimeSpan, ICalendarItem> GetHourItems(ObservableCollection <KeyValuePair <DateTime, ICalendarItem> > list, DateTime date, int from, ICalendarItem item = null)
{
Dictionary <TimeSpan, ICalendarItem> tempList = new Dictionary <TimeSpan, ICalendarItem>();
foreach (KeyValuePair <DateTime, ICalendarItem> obj in list)
{
if (date.Date == obj.Key.Date && obj.Key.Hour == from)
{
TimeSpan ProperTime = ExistsInDictionary(tempList, obj.Key.TimeOfDay);
if (item != null)
{
if (item.GetType() == typeof(ActivityContainer))
{
tempList.Add(ProperTime, obj.Value);
continue;
}
if (item.GetType() == obj.Value.GetType() && item.GetType() != typeof(Activity))
{
tempList.Add(ProperTime, obj.Value);
continue;
}
if (item.GetType() == typeof(Activity) && obj.Value.GetType() == typeof(Activity))
{
if (((Activity)item).Id == ((Activity)obj.Value).Id)
{
tempList.Add(ProperTime, obj.Value);
}
}
}
else
{
tempList.Add(ProperTime, obj.Value);
}
}
}
return(tempList);
}
private void AddToDictionary(DateTime date, ICalendarItem item)
{
CalendarDictionary.Add(new KeyValuePair <DateTime, ICalendarItem>(date, item));
}
