public static async Task <Calendar?> GetCalendarAsync() { if (!await RequestPermissionsAsync()) { return(null); } IList <Calendar> calendars = await GetAllCalendarsAsync(); Calendar?defaultCalendar = calendars.SingleOrDefault(c => c.ExternalID == SettingsRepository.Settings.DefaultCalendarId); if (defaultCalendar != null) { return(defaultCalendar); } if (calendars.Count == 1) { return(calendars.First()); } string targetCalendarName = await Shell.Current.DisplayActionSheet(LN.ChooseCalendar, LN.Cancel, null, calendars.Select(c => c.Name).ToArray()); if (targetCalendarName == null || targetCalendarName == LN.Cancel) { return(null); } Calendar selectedCalendar = calendars.First(c => c.Name == targetCalendarName); return(selectedCalendar); }
/// <summary> /// Gets a single calendar by platform-specific ID. /// </summary> /// <param name="externalId">Platform-specific calendar identifier</param> /// <returns>The corresponding calendar, or null if not found</returns> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="Calendars.Plugin.Abstractions.PlatformException">Unexpected platform-specific error</exception> public Task <Calendar> GetCalendarByIdAsync(string externalId) { long calendarId = -1; if (!long.TryParse(externalId, out calendarId)) { return(null); } return(Task.Run <Calendar>(() => { Calendar calendar = null; var cursor = Query( ContentUris.WithAppendedId(_calendarsUri, calendarId), _calendarsProjection); try { if (cursor.MoveToFirst()) { calendar = GetCalendar(cursor); } } catch (Java.Lang.Exception ex) { throw new PlatformException(ex.Message, ex); } finally { cursor.Close(); } return calendar; })); }
public static async Task <IList <Calendar> > GetAllCalendars() { if (!await RequestPermissions()) { return(null); } // Getting Calendar list IList <Calendar> calendars = await CrossCalendars.Current.GetCalendarsAsync(); calendars = calendars .Where(c => c.Name.ToLower() == c.AccountName.ToLower() || c.AccountName.ToLower() == CustomCalendarName.ToLower()) .ToList(); // Getting our custom calendar Calendar customCalendar = calendars.FirstOrDefault(c => c.AccountName.ToLower() == CustomCalendarName.ToLower()); if (customCalendar == null) { customCalendar = new Calendar { Name = CustomCalendarName, Color = "#56a5de" }; await CrossCalendars.Current.AddOrUpdateCalendarAsync(customCalendar); calendars.Add(customCalendar); } else if (calendars.Count(c => c.AccountName == customCalendar.AccountName) > 1) { MessagingCenter.Send(Application.Current, MessageTypes.ExceptionOccurred, new IndexOutOfRangeException($"There are {calendars.Count(c => c.AccountName == customCalendar.AccountName)} calendars with AccountName {customCalendar.AccountName}")); } return(calendars); }
public static async Task <bool> AddOrUpdateEventAsync(Calendar calendar, CalendarEvent calendarEvent) { if (!await RequestPermissionsAsync()) { return(false); } Analytics.TrackEvent("Add to calendar");
/// <summary> /// Gets all events for a calendar within the specified time range. /// </summary> /// <param name="calendar">Calendar containing events</param> /// <param name="start">Start of event range</param> /// <param name="end">End of event range</param> /// <returns>Calendar events</returns> /// <exception cref="System.ArgumentException">Calendar does not exist on device</exception> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="Plugin.Calendars.Abstractions.PlatformException">Unexpected platform-specific error</exception> public async Task <IList <CalendarEvent> > GetEventsAsync(Calendar calendar, DateTime start, DateTime end) { var deviceCalendar = await GetCalendarByIdAsync(calendar.ExternalID).ConfigureAwait(false); if (deviceCalendar == null) { throw new ArgumentException("Specified calendar not found on device"); } var eventsUriBuilder = CalendarContract.Instances.ContentUri.BuildUpon(); // Note that this is slightly different from the GetEventById projection // due to the Instances API vs. Event API (specifically, IDs and start/end times) // string[] eventsProjection = { CalendarContract.Events.InterfaceConsts.Title, CalendarContract.Events.InterfaceConsts.Description, CalendarContract.Instances.Begin, CalendarContract.Instances.End, CalendarContract.Events.InterfaceConsts.AllDay, CalendarContract.Events.InterfaceConsts.EventLocation, CalendarContract.Instances.EventId }; ContentUris.AppendId(eventsUriBuilder, DateConversions.GetDateAsAndroidMS(start)); ContentUris.AppendId(eventsUriBuilder, DateConversions.GetDateAsAndroidMS(end)); var eventsUri = eventsUriBuilder.Build(); return(await Task.Run(() => { var cursor = Query(eventsUri, eventsProjection, string.Format("{0} = {1}", CalendarContract.Events.InterfaceConsts.CalendarId, calendar.ExternalID), null, CalendarContract.Events.InterfaceConsts.Dtstart + " ASC"); var events = IterateCursor(cursor, () => { bool allDay = cursor.GetBoolean(CalendarContract.Events.InterfaceConsts.AllDay); var calendarEvent = new CalendarEvent { Name = cursor.GetString(CalendarContract.Events.InterfaceConsts.Title), ExternalID = cursor.GetString(CalendarContract.Instances.EventId), Description = cursor.GetString(CalendarContract.Events.InterfaceConsts.Description), Start = cursor.GetDateTime(CalendarContract.Instances.Begin, allDay), End = cursor.GetDateTime(CalendarContract.Instances.End, allDay), Location = cursor.GetString(CalendarContract.Events.InterfaceConsts.EventLocation), AllDay = allDay }; calendarEvent.Reminders = GetEventReminders(calendarEvent.ExternalID); return calendarEvent; }); return events; }).ConfigureAwait(false)); }
/// <summary> /// Creates a new calendar with the specified name and optional color. /// (just a convenience wrapper around AddOrUpdateCalendarAsync) /// </summary> /// <param name="api">ICalendars instance to extend</param> /// <param name="calendarName">Calendar name</param> /// <param name="color">Preferred color, or null to accept default</param> /// <returns>The created calendar</returns> public static async Task<Calendar> CreateCalendarAsync(this ICalendars api, string calendarName, string color = null) { var calendar = new Calendar { Name = calendarName, Color = color, CanEditCalendar = true, CanEditEvents = true }; await api.AddOrUpdateCalendarAsync(calendar).ConfigureAwait(false); return calendar; }
/// <summary> /// Removes a calendar and all its events from the system. /// </summary> /// <param name="calendar">Calendar to delete</param> /// <returns>True if successfully removed</returns> /// <exception cref="System.ArgumentException">Calendar is read-only</exception> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="Calendars.Plugin.Abstractions.PlatformException">Unexpected platform-specific error</exception> public async Task <bool> DeleteCalendarAsync(Calendar calendar) { var existing = await GetCalendarByIdAsync(calendar.ExternalID).ConfigureAwait(false); if (existing == null) { return(false); } else if (!existing.CanEditCalendar) { throw new ArgumentException("Cannot delete calendar (probably because it's non-local)", "calendar"); } return(await Task.Run(() => Delete(_calendarsUri, long.Parse(calendar.ExternalID))).ConfigureAwait(false)); }
/// <summary> /// Removes an event from the specified calendar. /// </summary> /// <param name="calendar">Calendar to remove event from</param> /// <param name="calendarEvent">Event to remove</param> /// <returns>True if successfully removed</returns> /// <exception cref="System.ArgumentException">Calendar is read-only</exception> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="System.InvalidOperationException">Editing recurring events is not supported</exception> /// <exception cref="Plugin.Calendars.Abstractions.PlatformException">Unexpected platform-specific error</exception> public async Task <bool> DeleteEventAsync(Calendar calendar, CalendarEvent calendarEvent) { long existingId = -1; // Even though a Calendar was passed-in, we get this to both verify // that the calendar exists and to make sure we have accurate permissions // (rather than trusting the permissions that were passed to us...) // var existingCal = await GetCalendarByIdAsync(calendar.ExternalID).ConfigureAwait(false); if (existingCal == null) { return(false); } else if (!existingCal.CanEditEvents) { throw new ArgumentException("Cannot delete event from readonly calendar", "calendar"); } if (long.TryParse(calendarEvent.ExternalID, out existingId)) { return(await Task.Run <bool>(() => { if (IsEventRecurring(calendarEvent.ExternalID)) { throw new InvalidOperationException("Editing recurring events is not supported"); } var calendarId = GetCalendarIdForEventId(calendarEvent.ExternalID); if (calendarId.HasValue && calendarId.Value.ToString() == calendar.ExternalID) { var eventsUri = CalendarContract.Events.ContentUri; return Delete(eventsUri, existingId); } return false; }).ConfigureAwait(false)); } return(false); }
public static async Task <IList <Calendar> > GetAllCalendarsAsync() { if (!await RequestPermissionsAsync()) { return(new List <Calendar>()); } // Getting Calendar list IList <Calendar> calendars = await CrossCalendars.Current.GetCalendarsAsync(); calendars = calendars .Where(c => string.Equals(c.Name, c.AccountName, StringComparison.OrdinalIgnoreCase) || string.Equals(c.AccountName, CustomCalendarName, StringComparison.OrdinalIgnoreCase)) .ToList(); // Getting our custom calendar Calendar?customCalendar = calendars.FirstOrDefault(c => string.Equals(c.AccountName, CustomCalendarName, StringComparison.OrdinalIgnoreCase)); if (customCalendar == null) { customCalendar = new Calendar { Name = CustomCalendarName, Color = "#56a5de" }; await CrossCalendars.Current.AddOrUpdateCalendarAsync(customCalendar); calendars.Add(customCalendar); } else if (calendars.Count(c => c.AccountName == customCalendar.AccountName) > 1) { ExceptionService.LogException(new IndexOutOfRangeException($"There are {calendars.Count(c => c.AccountName == customCalendar.AccountName)} calendars with AccountName {customCalendar.AccountName}")); } return(calendars); }
public async void Calendars_AddOrUpdateEvents_StartAfterEndThrows() { var calendarEvent = new CalendarEvent { Name = "Bob", Start = DateTime.Today, End = DateTime.Today.AddDays(-1) }; var calendar = new Calendar { Name = _calendarName }; await _service.AddOrUpdateCalendarAsync(calendar); Assert.IsTrue(await _service.AddOrUpdateEventAsync(calendar, calendarEvent).ThrowsAsync<ArgumentException>(), "Exception wasn't thrown"); }
public async Task Calendars_AddOrUpdateEvents_CopiesEventsBetweenCalendars() { var calendarEvent = new CalendarEvent { Name = "Bob", Start = DateTime.Today.AddDays(5), End = DateTime.Today.AddDays(5).AddHours(2), AllDay = false }; var calendarSource = new Calendar { Name = _calendarName }; var calendarTarget = new Calendar { Name = _calendarName + " copy destination" }; await _service.AddOrUpdateCalendarAsync(calendarSource); await _service.AddOrUpdateCalendarAsync(calendarTarget); await _service.AddOrUpdateEventAsync(calendarSource, calendarEvent); var sourceEvents = await _service.GetEventsAsync(calendarSource, DateTime.Today, DateTime.Today.AddDays(30)); await _service.AddOrUpdateEventAsync(calendarTarget, calendarEvent); var targetEvents = await _service.GetEventsAsync(calendarTarget, DateTime.Today, DateTime.Today.AddDays(30)); // Requery source events, just to be extra sure sourceEvents = await _service.GetEventsAsync(calendarSource, DateTime.Today, DateTime.Today.AddDays(30)); // Make sure the events are the same... CollectionAssert.AreEqual((ICollection)sourceEvents, (ICollection)targetEvents, _eventComparer); // ...except for their IDs! (i.e., they are actually unique copies) CollectionAssert.AreNotEqual(sourceEvents.Select(e => e.ExternalID).ToList(), targetEvents.Select(e => e.ExternalID).ToList()); }
/// <summary> /// Removes an event from the specified calendar. /// </summary> /// <param name="calendar">Calendar to remove event from</param> /// <param name="calendarEvent">Event to remove</param> /// <returns>True if successfully removed</returns> /// <exception cref="System.ArgumentException">Calendar is read-only</exception> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="Calendars.Plugin.Abstractions.PlatformException">Unexpected platform-specific error</exception> public async Task<bool> DeleteEventAsync(Calendar calendar, CalendarEvent calendarEvent) { if (string.IsNullOrEmpty(calendar.ExternalID) || string.IsNullOrEmpty(calendarEvent.ExternalID)) { return false; } await EnsureInitializedAsync().ConfigureAwait(false); bool deleted = false; //var appCalendar = await _localApptStore.GetAppointmentCalendarAsync(calendar.ExternalID).ConfigureAwait(false); var appCalendar = await GetLocalCalendarAsync(calendar.ExternalID).ConfigureAwait(false); if (appCalendar != null) { // Verify that event actually exists on calendar // var appt = await appCalendar.GetAppointmentAsync(calendarEvent.ExternalID).ConfigureAwait(false); // The second check is because AppointmentCalendar.GetAppointmentAsync will apparently still // return events if they are associated with a different calendar... // if (appt != null && appt.CalendarId == appCalendar.LocalId) { // Sometimes DeleteAppointmentAsync throws UnauthorizedException if the event doesn't exist? // And sometimes it just fails silently? // Well, hopefully the above check will help avoid either case... // await appCalendar.DeleteAppointmentAsync(calendarEvent.ExternalID).ConfigureAwait(false); deleted = true; } } else { // Check for calendar from non-local appt store // If we get it from there, then error that it's not writeable // else, it just doesn't exist, so return false appCalendar = await _apptStore.GetAppointmentCalendarAsync(calendar.ExternalID).ConfigureAwait(false); if (appCalendar != null) { throw new ArgumentException("Cannot delete event from readonly calendar", "calendar"); } } return deleted; }
/// <summary> /// Removes a calendar and all its events from the system. /// </summary> /// <param name="calendar">Calendar to delete</param> /// <returns>True if successfully removed</returns> /// <exception cref="System.ArgumentException">Calendar is read-only</exception> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="Calendars.Plugin.Abstractions.PlatformException">Unexpected platform-specific error</exception> public async Task<bool> DeleteCalendarAsync(Calendar calendar) { if (string.IsNullOrEmpty(calendar.ExternalID)) { return false; } await RequestCalendarAccess().ConfigureAwait(false); var deviceCalendar = _eventStore.GetCalendar(calendar.ExternalID); if (deviceCalendar == null) { return false; } NSError error = null; if (!_eventStore.RemoveCalendar(deviceCalendar, true, out error)) { // Without this, the eventStore may act like the remove succeeded. // (this obviously also resets any other changes, but since we own the eventStore // we can be pretty confident that won't be an issue) // _eventStore.Reset(); throw new ArgumentException(error.LocalizedDescription, "calendar", new NSErrorException(error)); } return true; }
/// <summary> /// Not supported for Windows Store apps /// </summary> public Task<bool> DeleteCalendarAsync(Calendar calendar) { throw new NotSupportedException(); }
public async void Calendars_AddOrUpdateEvents_UpdatesEvents() { // TODO: Test description var originalEvents = new List<CalendarEvent> { new CalendarEvent { Name = "Bob", Description = "Bob's event", Start = DateTime.Today.AddDays(5), End = DateTime.Today.AddDays(5).AddHours(2), AllDay = false }, new CalendarEvent { Name = "Steve", Description = "Steve's event", Start = DateTime.Today.AddDays(7), End = DateTime.Today.AddDays(8), AllDay = true }, new CalendarEvent { Name = "Wheeee", Description = "Fun times", Start = DateTime.Today.AddDays(13), End = DateTime.Today.AddDays(15), AllDay = true } }; var editedEvents = new List<CalendarEvent> { new CalendarEvent { Name = "Bob (edited)", Description = "Bob's edited event", Start = DateTime.Today.AddDays(5).AddHours(-2), End = DateTime.Today.AddDays(5).AddHours(1), AllDay = false }, new CalendarEvent { Name = "Steve (edited)", Description = "Steve's edited event", Start = DateTime.Today.AddDays(6), End = DateTime.Today.AddDays(7).AddHours(-1), AllDay = false }, new CalendarEvent { Name = "Yay (edited)", Description = "Edited fun times", Start = DateTime.Today.AddDays(12), End = DateTime.Today.AddDays(13), AllDay = true } }; var calendar = new Calendar { Name = _calendarName }; var queryStartDate = DateTime.Today; var queryEndDate = queryStartDate.AddDays(30); await _service.AddOrUpdateCalendarAsync(calendar); //await _service.AddOrUpdateEventsAsync(calendar, originalEvents); foreach (var cev in originalEvents) { await _service.AddOrUpdateEventAsync(calendar, cev); } var eventResults = await _service.GetEventsAsync(calendar, queryStartDate, queryEndDate); Assert.That(eventResults, Is.EqualTo(originalEvents).Using<CalendarEvent>(_eventComparer)); for (int i = 0; i < eventResults.Count; i++) { editedEvents.ElementAt(i).ExternalID = eventResults.ElementAt(i).ExternalID; } //await _service.AddOrUpdateEventsAsync(calendar, editedEvents); foreach (var cev in editedEvents) { await _service.AddOrUpdateEventAsync(calendar, cev); } var editedEventResults = await _service.GetEventsAsync(calendar, queryStartDate, queryEndDate); Assert.That(editedEventResults, Is.EqualTo(editedEvents).Using<CalendarEvent>(_eventComparer)); }
public async void Calendars_AddOrUpdateEvent_UnspecifiedCalendarThrows() { var calendarEvent = new CalendarEvent { Name = "Bob", Start = DateTime.Today, End = DateTime.Today.AddHours(1) }; var calendar = new Calendar { Name = _calendarName }; Assert.IsTrue(await _service.AddOrUpdateEventAsync(calendar, calendarEvent).ThrowsAsync<ArgumentException>(), "Exception wasn't thrown"); }
static async Task<Calendar> GetOrCreateEvolveCalendarAsync() { var id = Settings.Current.EvolveCalendarId; if (!string.IsNullOrWhiteSpace(id)) { try { var calendar = await CrossCalendars.Current.GetCalendarByIdAsync(id); if(calendar != null) return calendar; } catch(Exception ex) { Debug.WriteLine("Unable to get calendar.. odd as we created it already: " + ex); } } //if for some reason the calendar does not exist then simply create a enw one. if (Device.OS == TargetPlatform.Android) { //On android it is really hard to delete a calendar made by an app, so just add to default calendar. try { var calendars = await CrossCalendars.Current.GetCalendarsAsync(); foreach (var calendar in calendars) { //find first calendar we can add stuff to if (!calendar.CanEditEvents) continue; Settings.Current.EvolveCalendarId = calendar.ExternalID; return calendar; } } catch (Exception ex) { Debug.WriteLine("Unable to get calendars.. " + ex); } } else { //try to find evolve app if already uninstalled for some reason try { var calendars = await CrossCalendars.Current.GetCalendarsAsync(); foreach(var calendar in calendars) { //find first calendar we can add stuff to if(calendar.CanEditEvents && calendar.Name == "Xamarin Evolve") { Settings.Current.EvolveCalendarId = calendar.ExternalID; return calendar; } } } catch(Exception ex) { Debug.WriteLine("Unable to get calendars.. " + ex); } } var evolveCalendar = new Calendar(); evolveCalendar.Color = "#7635EB"; evolveCalendar.Name = "Xamarin Evolve"; try { await CrossCalendars.Current.AddOrUpdateCalendarAsync(evolveCalendar); Settings.Current.EvolveCalendarId = evolveCalendar.ExternalID; return evolveCalendar; } catch(Exception ex) { Debug.WriteLine("Unable to create calendar.. " + ex); } return null; }
public async void Calendars_GetEvents_NonexistentCalendarThrows() { var calendar = new Calendar { Name = "Bob", ExternalID = "42" }; Assert.IsTrue(await _service.GetEventsAsync(calendar, DateTime.Today, DateTime.Today.AddDays(30)).ThrowsAsync<ArgumentException>(), "Exception wasn't thrown"); }
/// <summary> /// Add new event to a calendar or update an existing event. /// If a new event was added, the ExternalID property will be set on the CalendarEvent object, /// to support future queries/updates. /// </summary> /// <param name="calendar">Destination calendar</param> /// <param name="calendarEvent">Event to add or update</param> /// <exception cref="System.ArgumentException">Calendar is not specified, does not exist on device, or is read-only</exception> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="System.InvalidOperationException">Editing recurring events is not supported</exception> /// <exception cref="Plugin.Calendars.Abstractions.PlatformException">Unexpected platform-specific error</exception> public async Task AddOrUpdateEventAsync(Calendar calendar, CalendarEvent calendarEvent) { if (string.IsNullOrEmpty(calendar.ExternalID)) { throw new ArgumentException("Missing calendar identifier", "calendar"); } else { // Verify calendar exists (Android actually allows using a nonexistent calendar ID...) // var deviceCalendar = await GetCalendarByIdAsync(calendar.ExternalID).ConfigureAwait(false); if (deviceCalendar == null) { throw new ArgumentException("Specified calendar not found on device"); } } // Validate times if (calendarEvent.End < calendarEvent.Start) { throw new ArgumentException("End time may not precede start time", "calendarEvent"); } bool updateExisting = false; long existingId = -1; CalendarEvent existingEvent = null; await Task.Run(() => { if (long.TryParse(calendarEvent.ExternalID, out existingId)) { if (IsEventRecurring(calendarEvent.ExternalID)) { throw new InvalidOperationException("Editing recurring events is not supported"); } var calendarId = GetCalendarIdForEventId(calendarEvent.ExternalID); if (calendarId.HasValue && calendarId.Value.ToString() == calendar.ExternalID) { updateExisting = true; existingEvent = GetEventById(calendarEvent.ExternalID); } } var eventValues = new ContentValues(); bool allDay = calendarEvent.AllDay; var start = allDay ? DateTime.SpecifyKind(calendarEvent.Start.Date, DateTimeKind.Utc) : calendarEvent.Start; var end = allDay ? DateTime.SpecifyKind(calendarEvent.End.Date, DateTimeKind.Utc) : calendarEvent.End; eventValues.Put(CalendarContract.Events.InterfaceConsts.CalendarId, calendar.ExternalID); eventValues.Put(CalendarContract.Events.InterfaceConsts.Title, calendarEvent.Name); eventValues.Put(CalendarContract.Events.InterfaceConsts.Description, calendarEvent.Description); eventValues.Put(CalendarContract.Events.InterfaceConsts.Dtstart, DateConversions.GetDateAsAndroidMS(start)); eventValues.Put(CalendarContract.Events.InterfaceConsts.Dtend, DateConversions.GetDateAsAndroidMS(end)); eventValues.Put(CalendarContract.Events.InterfaceConsts.AllDay, allDay); eventValues.Put(CalendarContract.Events.InterfaceConsts.EventLocation, calendarEvent.Location ?? string.Empty); // If we're updating an existing event, don't mess with the existing // time zone (since we don't support explicitly setting it yet). // *Unless* we're toggling the "all day" setting // (because that would mean the time zone is UTC rather than local...). // if (!updateExisting || allDay != existingEvent?.AllDay) { eventValues.Put(CalendarContract.Events.InterfaceConsts.EventTimezone, allDay ? Java.Util.TimeZone.GetTimeZone("UTC")?.ID ?? string.Empty : Java.Util.TimeZone.Default.ID); } if (!updateExisting) { calendarEvent.ExternalID = Insert(_eventsUri, eventValues); } else { Update(_eventsUri, existingId, eventValues); } }).ConfigureAwait(false); }
/// <summary> /// Not supported for Windows Store apps /// </summary> public Task<IList<CalendarEvent>> GetEventsAsync(Calendar calendar, DateTime start, DateTime end) { throw new NotSupportedException(); }
/// <summary> /// Not supported for Windows Store apps /// </summary> public Task AddOrUpdateCalendarAsync(Calendar calendar) { throw new NotSupportedException(); }
/// <summary> /// Not supported for Windows Store apps /// </summary> public Task AddOrUpdateEventAsync(Calendar calendar, CalendarEvent calendarEvent) { throw new NotSupportedException(); }
public async void Calendars_AddOrUpdateEvents_AddsEvents() { var events = new List<CalendarEvent> { new CalendarEvent { Name = "Bob", Description = "Bob's event", Start = DateTime.Today.AddDays(5), End = DateTime.Today.AddDays(5).AddHours(2), AllDay = false }, new CalendarEvent { Name = "Steve", Description = "Steve's event", Start = DateTime.Today.AddDays(7), End = DateTime.Today.AddDays(8), AllDay = true }, new CalendarEvent { Name = "Wheeee", Description = "Fun times", Start = DateTime.Today.AddDays(13), End = DateTime.Today.AddDays(15), AllDay = true } }; var calendar = new Calendar { Name = _calendarName }; await _service.AddOrUpdateCalendarAsync(calendar); //await _service.AddOrUpdateEventsAsync(calendar, events); foreach (var cev in events) { await _service.AddOrUpdateEventAsync(calendar, cev); } var eventResults = await _service.GetEventsAsync(calendar, DateTime.Today, DateTime.Today.AddDays(30)); Assert.That(eventResults, Is.EqualTo(events).Using<CalendarEvent>(_eventComparer)); // Extra check that DateTime.Kinds are local Assert.AreEqual(DateTimeKind.Local, eventResults.Select(e => e.Start.Kind).Distinct().Single()); Assert.AreEqual(DateTimeKind.Local, eventResults.Select(e => e.End.Kind).Distinct().Single()); }
/// <summary> /// Creates a new calendar or updates the name and color of an existing one. /// </summary> /// <param name="calendar">The calendar to create/update</param> /// <exception cref="System.ArgumentException">Calendar does not exist on device or is read-only</exception> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="Calendars.Plugin.Abstractions.PlatformException">Unexpected platform-specific error</exception> public async Task AddOrUpdateCalendarAsync(Calendar calendar) { bool updateExisting = false; long existingId = -1; if (long.TryParse(calendar.ExternalID, out existingId)) { var existingCalendar = await GetCalendarByIdAsync(calendar.ExternalID).ConfigureAwait(false); if (existingCalendar != null) { if (!existingCalendar.CanEditCalendar) { throw new ArgumentException("Destination calendar is not writeable"); } updateExisting = true; } else { throw new ArgumentException("Specified calendar does not exist on device", "calendar"); } } var values = new ContentValues(); values.Put(CalendarContract.Calendars.InterfaceConsts.CalendarDisplayName, calendar.Name); values.Put(CalendarContract.Calendars.Name, calendar.Name); // Unlike iOS/WinPhone, Android does not automatically assign a color for us, // so we use our own default of blue. // int colorInt = unchecked ((int)0xFF0000FF); if (!string.IsNullOrEmpty(calendar.Color)) { int.TryParse(calendar.Color.Trim('#'), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out colorInt); } values.Put(CalendarContract.Calendars.InterfaceConsts.CalendarColor, colorInt); if (!updateExisting) { values.Put(CalendarContract.Calendars.InterfaceConsts.CalendarAccessLevel, (int)CalendarAccess.AccessOwner); values.Put(CalendarContract.Calendars.InterfaceConsts.AccountName, AccountName); values.Put(CalendarContract.Calendars.InterfaceConsts.OwnerAccount, OwnerAccount); values.Put(CalendarContract.Calendars.InterfaceConsts.Visible, true); values.Put(CalendarContract.Calendars.InterfaceConsts.SyncEvents, true); values.Put(CalendarContract.Calendars.InterfaceConsts.AccountType, CalendarContract.AccountTypeLocal); } await Task.Run(() => { if (updateExisting) { Update(_calendarsUri, existingId, values); } else { var uri = _calendarsUri.BuildUpon() .AppendQueryParameter(CalendarContract.CallerIsSyncadapter, "true") .AppendQueryParameter(CalendarContract.Calendars.InterfaceConsts.AccountName, AccountName) .AppendQueryParameter(CalendarContract.Calendars.InterfaceConsts.AccountType, CalendarContract.AccountTypeLocal) .Build(); calendar.ExternalID = Insert(uri, values); calendar.CanEditCalendar = true; calendar.CanEditEvents = true; calendar.Color = "#" + colorInt.ToString("x8"); } }).ConfigureAwait(false); }
public async void Calendars_AddOrUpdateEvents_StartAfterEndThrows() { var calendarEvent = new CalendarEvent { Name = "Bob", Start = DateTime.Today, End = DateTime.Today.AddDays(-1) }; var calendar = new Calendar { Name = _calendarName }; await _service.AddOrUpdateCalendarAsync(calendar); Assert.IsTrue(await _service.AddOrUpdateEventAsync(calendar, calendarEvent).ThrowsAsync<ArgumentException>(), "Exception wasn't thrown"); // Ensure that calendar still has no events Assert.That(await _service.GetEventsAsync(calendar, DateTime.Today.AddMonths(-1), DateTime.Today.AddMonths(1)), Is.Empty, "Calendar has event, even after throwing"); }
/// <summary> /// Gets all events for a calendar within the specified time range. /// </summary> /// <param name="calendar">Calendar containing events</param> /// <param name="start">Start of event range</param> /// <param name="end">End of event range</param> /// <returns>Calendar events</returns> /// <exception cref="System.ArgumentException">Calendar does not exist on device</exception> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="Calendars.Plugin.Abstractions.PlatformException">Unexpected platform-specific error</exception> public async Task<IList<CalendarEvent>> GetEventsAsync(Calendar calendar, DateTime start, DateTime end) { await EnsureInitializedAsync().ConfigureAwait(false); AppointmentCalendar deviceCalendar = null; try { deviceCalendar = await _apptStore.GetAppointmentCalendarAsync(calendar.ExternalID).ConfigureAwait(false); } catch (ArgumentException ex) { throw new ArgumentException("Specified calendar not found on device", ex); } // Not all properties are populated by default // var options = new FindAppointmentsOptions { IncludeHidden = false }; options.FetchProperties.Add(AppointmentProperties.Subject); options.FetchProperties.Add(AppointmentProperties.Details); options.FetchProperties.Add(AppointmentProperties.StartTime); options.FetchProperties.Add(AppointmentProperties.Duration); options.FetchProperties.Add(AppointmentProperties.AllDay); options.FetchProperties.Add(AppointmentProperties.Location); var appointments = await deviceCalendar.FindAppointmentsAsync(start, end - start, options).ConfigureAwait(false); var events = appointments.Select(a => a.ToCalendarEvent()).ToList(); return events; }
public async void Calendars_AddOrUpdateEvent_NonexistentCalendarThrows() { var calendarEvent = new CalendarEvent { Name = "Bob", Start = DateTime.Today, End = DateTime.Today.AddHours(1) }; var calendar = new Calendar { Name = _calendarName }; // Create/delete calendar so we have a valid ID for a nonexistent calendar // await _service.AddOrUpdateCalendarAsync(calendar); await _service.DeleteCalendarAsync(calendar); Assert.IsTrue(await _service.AddOrUpdateEventAsync(calendar, calendarEvent).ThrowsAsync<ArgumentException>(), "Exception wasn't thrown"); }
/// <summary> /// Creates a new calendar or updates the name and color of an existing one. /// </summary> /// <param name="calendar">The calendar to create/update</param> /// <exception cref="System.ArgumentException">Calendar does not exist on device or is read-only</exception> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="Calendars.Plugin.Abstractions.PlatformException">Unexpected platform-specific error</exception> public async Task AddOrUpdateCalendarAsync(Calendar calendar) { await RequestCalendarAccess().ConfigureAwait(false); EKCalendar deviceCalendar = null; if (!string.IsNullOrEmpty(calendar.ExternalID)) { deviceCalendar = _eventStore.GetCalendar(calendar.ExternalID); if (deviceCalendar == null) { throw new ArgumentException("Specified calendar does not exist on device", "calendar"); } } if (deviceCalendar == null) { deviceCalendar = CreateEKCalendar(calendar.Name, calendar.Color); calendar.ExternalID = deviceCalendar.CalendarIdentifier; // Update color in case iOS assigned one if(deviceCalendar?.CGColor != null) calendar.Color = ColorConversion.ToHexColor(deviceCalendar.CGColor); } else { deviceCalendar.Title = calendar.Name; if (!string.IsNullOrEmpty(calendar.Color)) { deviceCalendar.CGColor = ColorConversion.ToCGColor(calendar.Color); } NSError error = null; if (!_eventStore.SaveCalendar(deviceCalendar, true, out error)) { // Without this, the eventStore will continue to return the "updated" // calendar even though the save failed! // (this obviously also resets any other changes, but since we own the eventStore // we can be pretty confident that won't be an issue) // _eventStore.Reset(); if (error.Domain == _ekErrorDomain && error.Code == (int)EKErrorCode.CalendarIsImmutable) { throw new ArgumentException(error.LocalizedDescription, new NSErrorException(error)); } else { throw new PlatformException(error.LocalizedDescription, new NSErrorException(error)); } } } }
public async void Calendars_AddOrUpdateEvents_CopiesEventsBetweenCalendars() { var calendarEvent = new CalendarEvent { Name = "Bob", Start = DateTime.Today.AddDays(5), End = DateTime.Today.AddDays(5).AddHours(2), AllDay = false }; var calendarSource = new Calendar { Name = _calendarName }; var calendarTarget = new Calendar { Name = _calendarName + " copy destination" }; await _service.AddOrUpdateCalendarAsync(calendarSource); await _service.AddOrUpdateCalendarAsync(calendarTarget); await _service.AddOrUpdateEventAsync(calendarSource, calendarEvent); var sourceEvents = await _service.GetEventsAsync(calendarSource, DateTime.Today, DateTime.Today.AddDays(30)); //await _service.AddOrUpdateEventsAsync(calendarTarget, sourceEvents); foreach (var cev in sourceEvents) { await _service.AddOrUpdateEventAsync(calendarTarget, cev); } var targetEvents = await _service.GetEventsAsync(calendarTarget, DateTime.Today, DateTime.Today.AddDays(30)); // Requery source events, just to be extra sure sourceEvents = await _service.GetEventsAsync(calendarSource, DateTime.Today, DateTime.Today.AddDays(30)); // Make sure the events are the same... Assert.That(targetEvents, Is.EqualTo(sourceEvents).Using<CalendarEvent>(_eventComparer)); // ...except for their IDs! (i.e., they are actually unique copies) Assert.That(targetEvents.Select(e => e.ExternalID).ToList(), Is.Not.EqualTo(sourceEvents.Select(e => e.ExternalID).ToList())); }
/// <summary> /// Not supported for Windows Store apps /// </summary> public Task<bool> DeleteEventAsync(Calendar calendar, CalendarEvent cev) { throw new NotSupportedException(); }
/// <summary> /// Gets all events for a calendar within the specified time range. /// </summary> /// <param name="calendar">Calendar containing events</param> /// <param name="start">Start of event range</param> /// <param name="end">End of event range</param> /// <returns>Calendar events</returns> /// <exception cref="System.ArgumentException">Calendar does not exist on device</exception> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="Calendars.Plugin.Abstractions.PlatformException">Unexpected platform-specific error</exception> public async Task<IList<CalendarEvent>> GetEventsAsync(Calendar calendar, DateTime start, DateTime end) { var deviceCalendar = await GetCalendarByIdAsync(calendar.ExternalID).ConfigureAwait(false); if (deviceCalendar == null) { throw new ArgumentException("Specified calendar not found on device"); } var eventsUriBuilder = CalendarContract.Instances.ContentUri.BuildUpon(); // Note that this is slightly different from the GetEventById projection // due to the Instances API vs. Event API (specifically, IDs) // string[] eventsProjection = { // CalendarContract.Events.InterfaceConsts.Id, CalendarContract.Events.InterfaceConsts.Title, CalendarContract.Events.InterfaceConsts.Description, CalendarContract.Events.InterfaceConsts.Dtstart, CalendarContract.Events.InterfaceConsts.Dtend, CalendarContract.Events.InterfaceConsts.AllDay, CalendarContract.Events.InterfaceConsts.EventLocation, CalendarContract.Instances.EventId }; ContentUris.AppendId(eventsUriBuilder, DateConversions.GetDateAsAndroidMS(start)); ContentUris.AppendId(eventsUriBuilder, DateConversions.GetDateAsAndroidMS(end)); var eventsUri = eventsUriBuilder.Build(); var events = new List<CalendarEvent>(); await Task.Run(() => { var cursor = Query(eventsUri, eventsProjection, string.Format("{0} = {1}", CalendarContract.Events.InterfaceConsts.CalendarId, calendar.ExternalID), null, CalendarContract.Events.InterfaceConsts.Dtstart + " ASC"); try { if (cursor.MoveToFirst()) { do { events.Add(new CalendarEvent { Name = cursor.GetString(CalendarContract.Events.InterfaceConsts.Title), ExternalID = cursor.GetString(CalendarContract.Instances.EventId), Description = cursor.GetString(CalendarContract.Events.InterfaceConsts.Description), Start = cursor.GetDateTime(CalendarContract.Events.InterfaceConsts.Dtstart), End = cursor.GetDateTime(CalendarContract.Events.InterfaceConsts.Dtend), Location = cursor.GetString(CalendarContract.Events.InterfaceConsts.EventLocation), AllDay = cursor.GetBoolean(CalendarContract.Events.InterfaceConsts.AllDay) }); } while (cursor.MoveToNext()); } } catch (Java.Lang.Exception ex) { throw new PlatformException(ex.Message, ex); } finally { cursor.Close(); } }); return events; }
/// <summary> /// Creates a new calendar or updates the name and color of an existing one. /// </summary> /// <param name="calendar">The calendar to create/update</param> /// <exception cref="System.ArgumentException">Calendar does not exist on device or is read-only</exception> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="Calendars.Plugin.Abstractions.PlatformException">Unexpected platform-specific error</exception> public async Task AddOrUpdateCalendarAsync(Calendar calendar) { bool updateExisting = false; long existingId = -1; if (long.TryParse(calendar.ExternalID, out existingId)) { var existingCalendar = await GetCalendarByIdAsync(calendar.ExternalID).ConfigureAwait(false); if (existingCalendar != null) { if (!existingCalendar.CanEditCalendar) { throw new ArgumentException("Destination calendar is not writeable"); } updateExisting = true; } else { throw new ArgumentException("Specified calendar does not exist on device", "calendar"); } } var values = new ContentValues(); values.Put(CalendarContract.Calendars.InterfaceConsts.CalendarDisplayName, calendar.Name); values.Put(CalendarContract.Calendars.Name, calendar.Name); // Unlike iOS/WinPhone, Android does not automatically assign a color for us, // so we use our own default of blue. // int colorInt = unchecked((int)0xFF0000FF); if (!string.IsNullOrEmpty(calendar.Color)) { int.TryParse(calendar.Color.Trim('#'), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out colorInt); } values.Put(CalendarContract.Calendars.InterfaceConsts.CalendarColor, colorInt); if (!updateExisting) { values.Put(CalendarContract.Calendars.InterfaceConsts.CalendarAccessLevel, (int)CalendarAccess.AccessOwner); values.Put(CalendarContract.Calendars.InterfaceConsts.AccountName, AccountName); values.Put(CalendarContract.Calendars.InterfaceConsts.OwnerAccount, OwnerAccount); values.Put(CalendarContract.Calendars.InterfaceConsts.Visible, true); values.Put(CalendarContract.Calendars.InterfaceConsts.SyncEvents, true); values.Put(CalendarContract.Calendars.InterfaceConsts.AccountType, CalendarContract.AccountTypeLocal); } await Task.Run(() => { if (updateExisting) { Update(_calendarsUri, existingId, values); } else { var uri = _calendarsUri.BuildUpon() .AppendQueryParameter(CalendarContract.CallerIsSyncadapter, "true") .AppendQueryParameter(CalendarContract.Calendars.InterfaceConsts.AccountName, AccountName) .AppendQueryParameter(CalendarContract.Calendars.InterfaceConsts.AccountType, CalendarContract.AccountTypeLocal) .Build(); calendar.ExternalID = Insert(uri, values); calendar.CanEditCalendar = true; calendar.CanEditEvents = true; calendar.Color = "#" + colorInt.ToString("x8"); } }).ConfigureAwait(false); }
/// <summary> /// Gets all events for a calendar within the specified time range. /// </summary> /// <param name="calendar">Calendar containing events</param> /// <param name="start">Start of event range</param> /// <param name="end">End of event range</param> /// <returns>Calendar events</returns> /// <exception cref="System.ArgumentException">Calendar does not exist on device</exception> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="Calendars.Plugin.Abstractions.PlatformException">Unexpected platform-specific error</exception> public async Task <IList <CalendarEvent> > GetEventsAsync(Calendar calendar, DateTime start, DateTime end) { var deviceCalendar = await GetCalendarByIdAsync(calendar.ExternalID).ConfigureAwait(false); if (deviceCalendar == null) { throw new ArgumentException("Specified calendar not found on device"); } var eventsUriBuilder = CalendarContract.Instances.ContentUri.BuildUpon(); // Note that this is slightly different from the GetEventById projection // due to the Instances API vs. Event API (specifically, IDs) // string[] eventsProjection = { // CalendarContract.Events.InterfaceConsts.Id, CalendarContract.Events.InterfaceConsts.Title, CalendarContract.Events.InterfaceConsts.Description, CalendarContract.Events.InterfaceConsts.Dtstart, CalendarContract.Events.InterfaceConsts.Dtend, CalendarContract.Events.InterfaceConsts.AllDay, CalendarContract.Events.InterfaceConsts.EventLocation, CalendarContract.Instances.EventId }; ContentUris.AppendId(eventsUriBuilder, DateConversions.GetDateAsAndroidMS(start)); ContentUris.AppendId(eventsUriBuilder, DateConversions.GetDateAsAndroidMS(end)); var eventsUri = eventsUriBuilder.Build(); var events = new List <CalendarEvent>(); await Task.Run(() => { var cursor = Query(eventsUri, eventsProjection, string.Format("{0} = {1}", CalendarContract.Events.InterfaceConsts.CalendarId, calendar.ExternalID), null, CalendarContract.Events.InterfaceConsts.Dtstart + " ASC"); try { if (cursor.MoveToFirst()) { do { events.Add(new CalendarEvent { Name = cursor.GetString(CalendarContract.Events.InterfaceConsts.Title), ExternalID = cursor.GetString(CalendarContract.Instances.EventId), Description = cursor.GetString(CalendarContract.Events.InterfaceConsts.Description), Start = cursor.GetDateTime(CalendarContract.Events.InterfaceConsts.Dtstart), End = cursor.GetDateTime(CalendarContract.Events.InterfaceConsts.Dtend), Location = cursor.GetString(CalendarContract.Events.InterfaceConsts.EventLocation), AllDay = cursor.GetBoolean(CalendarContract.Events.InterfaceConsts.AllDay) }); } while (cursor.MoveToNext()); } } catch (Java.Lang.Exception ex) { throw new PlatformException(ex.Message, ex); } finally { cursor.Close(); } }); return(events); }
/// <summary> /// Add new event to a calendar or update an existing event. /// </summary> /// <param name="calendar">Destination calendar</param> /// <param name="calendarEvent">Event to add or update</param> /// <exception cref="System.ArgumentException">Calendar is not specified, does not exist on device, or is read-only</exception> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="Calendars.Plugin.Abstractions.PlatformException">Unexpected platform-specific error</exception> public async Task AddOrUpdateEventAsync(Calendar calendar, CalendarEvent calendarEvent) { if (string.IsNullOrEmpty(calendar.ExternalID)) { throw new ArgumentException("Missing calendar identifier", "calendar"); } else { // Verify calendar exists (Android actually allows using a nonexistent calendar ID...) // var deviceCalendar = await GetCalendarByIdAsync(calendar.ExternalID).ConfigureAwait(false); if (deviceCalendar == null) { throw new ArgumentException("Specified calendar not found on device"); } } // Validate times if (calendarEvent.End < calendarEvent.Start) { throw new ArgumentException("End time may not precede start time", "calendarEvent"); } bool updateExisting = false; long existingId = -1; await Task.Run(() => { if (long.TryParse(calendarEvent.ExternalID, out existingId)) { var calendarId = GetCalendarIdForEventId(calendarEvent.ExternalID); if (calendarId.HasValue && calendarId.Value.ToString() == calendar.ExternalID) { updateExisting = true; } } var eventValues = new ContentValues(); eventValues.Put(CalendarContract.Events.InterfaceConsts.CalendarId, calendar.ExternalID); eventValues.Put(CalendarContract.Events.InterfaceConsts.Title, calendarEvent.Name); eventValues.Put(CalendarContract.Events.InterfaceConsts.Description, calendarEvent.Description); eventValues.Put(CalendarContract.Events.InterfaceConsts.Dtstart, DateConversions.GetDateAsAndroidMS(calendarEvent.Start)); eventValues.Put(CalendarContract.Events.InterfaceConsts.Dtend, DateConversions.GetDateAsAndroidMS(calendarEvent.End)); eventValues.Put(CalendarContract.Events.InterfaceConsts.AllDay, calendarEvent.AllDay); eventValues.Put(CalendarContract.Events.InterfaceConsts.EventLocation, calendarEvent.Location ?? string.Empty); eventValues.Put(CalendarContract.Events.InterfaceConsts.EventTimezone, Java.Util.TimeZone.Default.ID); if (!updateExisting) { calendarEvent.ExternalID = Insert(_eventsUri, eventValues); } else { Update(_eventsUri, existingId, eventValues); } }); }
/// <summary> /// Removes a calendar and all its events from the system. /// </summary> /// <param name="calendar">Calendar to delete</param> /// <returns>True if successfully removed</returns> /// <exception cref="System.ArgumentException">Calendar is read-only</exception> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="Calendars.Plugin.Abstractions.PlatformException">Unexpected platform-specific error</exception> public async Task<bool> DeleteCalendarAsync(Calendar calendar) { var existing = await GetCalendarByIdAsync(calendar.ExternalID).ConfigureAwait(false); if (existing == null) { return false; } else if (!existing.CanEditCalendar) { throw new ArgumentException("Cannot delete calendar (probably because it's non-local)", "calendar"); } return await Task.Run(() => Delete(_calendarsUri, long.Parse(calendar.ExternalID))).ConfigureAwait(false); }
/// <summary> /// Gets all events for a calendar within the specified time range. /// </summary> /// <param name="calendar">Calendar containing events</param> /// <param name="start">Start of event range</param> /// <param name="end">End of event range</param> /// <returns>Calendar events</returns> /// <exception cref="System.ArgumentException">Calendar does not exist on device</exception> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="Calendars.Plugin.Abstractions.PlatformException">Unexpected platform-specific error</exception> public async Task<IList<CalendarEvent>> GetEventsAsync(Calendar calendar, DateTime start, DateTime end) { await RequestCalendarAccess().ConfigureAwait(false); var deviceCalendar = _eventStore.GetCalendar(calendar.ExternalID); if (deviceCalendar == null) { throw new ArgumentException("Specified calendar not found on device"); } var query = _eventStore.PredicateForEvents(start.ToNSDate(), end.ToNSDate(), new EKCalendar[] { deviceCalendar }); var events = await Task.Run(() => { var iosEvents = _eventStore.EventsMatching(query); return iosEvents == null ? new List<CalendarEvent>() : iosEvents.Select(e => e.ToCalendarEvent()).ToList(); }).ConfigureAwait(false); return events; }
/// <summary> /// Removes an event from the specified calendar. /// </summary> /// <param name="calendar">Calendar to remove event from</param> /// <param name="calendarEvent">Event to remove</param> /// <returns>True if successfully removed</returns> /// <exception cref="System.ArgumentException">Calendar is read-only</exception> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="Calendars.Plugin.Abstractions.PlatformException">Unexpected platform-specific error</exception> public async Task<bool> DeleteEventAsync(Calendar calendar, CalendarEvent calendarEvent) { long existingId = -1; // Even though a Calendar was passed-in, we get this to both verify // that the calendar exists and to make sure we have accurate permissions // (rather than trusting the permissions that were passed to us...) // var existingCal = await GetCalendarByIdAsync(calendar.ExternalID).ConfigureAwait(false); if (existingCal == null) { return false; } else if (!existingCal.CanEditEvents) { throw new ArgumentException("Cannot delete event from readonly calendar", "calendar"); } if (long.TryParse(calendarEvent.ExternalID, out existingId)) { return await Task.Run<bool>(() => { var calendarId = GetCalendarIdForEventId(calendarEvent.ExternalID); if (calendarId.HasValue && calendarId.Value.ToString() == calendar.ExternalID) { var eventsUri = CalendarContract.Events.ContentUri; return Delete(eventsUri, existingId); } return false; }); } return false; }
/// <summary> /// Add new event to a calendar or update an existing event. /// Throws if Calendar ID is empty, calendar does not exist, or calendar is read-only. /// </summary> /// <param name="calendar">Destination calendar</param> /// <param name="calendarEvent">Event to add or update</param> /// <exception cref="System.ArgumentException">Calendar is not specified, does not exist on device, or is read-only</exception> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="Calendars.Plugin.Abstractions.PlatformException">Unexpected platform-specific error</exception> public async Task AddOrUpdateEventAsync(Calendar calendar, CalendarEvent calendarEvent) { await RequestCalendarAccess().ConfigureAwait(false); EKCalendar deviceCalendar = null; if (string.IsNullOrEmpty(calendar.ExternalID)) { throw new ArgumentException("Missing calendar identifier", "calendar"); } else { deviceCalendar = _eventStore.GetCalendar(calendar.ExternalID); if (deviceCalendar == null) { throw new ArgumentException("Specified calendar not found on device"); } } EKEvent iosEvent = null; // If Event already corresponds to an existing EKEvent in the target // Calendar, then edit that instead of creating a new one. // if (!string.IsNullOrEmpty(calendarEvent.ExternalID)) { var existingEvent = _eventStore.EventFromIdentifier(calendarEvent.ExternalID); if (existingEvent.Calendar.CalendarIdentifier == deviceCalendar.CalendarIdentifier) { iosEvent = existingEvent; } } if (iosEvent == null) { iosEvent = EKEvent.FromStore(_eventStore); } iosEvent.Title = calendarEvent.Name; iosEvent.Notes = calendarEvent.Description; iosEvent.AllDay = calendarEvent.AllDay; iosEvent.Location = calendarEvent.Location ?? string.Empty; iosEvent.StartDate = calendarEvent.Start.ToNSDate(); // If set to AllDay and given an EndDate of 12am the next day, EventKit // assumes that the event consumes two full days. // (whereas WinPhone/Android consider that one day, and thus so do we) // iosEvent.EndDate = calendarEvent.AllDay ? calendarEvent.End.AddMilliseconds(-1).ToNSDate() : calendarEvent.End.ToNSDate(); iosEvent.Calendar = deviceCalendar; NSError error = null; if (!_eventStore.SaveEvent(iosEvent, EKSpan.ThisEvent, out error)) { // Without this, the eventStore will continue to return the "updated" // event even though the save failed! // (this obviously also resets any other changes, but since we own the eventStore // we can be pretty confident that won't be an issue) // _eventStore.Reset(); // Technically, probably any ekerrordomain error would be an ArgumentException? // - but we don't necessarily know *which* argument (at least not without the code) // - for now, just focusing on the start > end scenario and translating the rest to PlatformException. Can always add more later. if (error.Domain == _ekErrorDomain && error.Code == (int)EKErrorCode.DatesInverted) { throw new ArgumentException(error.LocalizedDescription, new NSErrorException(error)); } else { throw new PlatformException(error.LocalizedDescription, new NSErrorException(error)); } } calendarEvent.ExternalID = iosEvent.EventIdentifier; }
public async Task Calendars_AddOrUpdateEvents_UpdatesEvents() { var originalEvents = new List<CalendarEvent> { new CalendarEvent { Name = "Bob", Description = "Bob's event", Start = DateTime.Today.AddDays(5), End = DateTime.Today.AddDays(5).AddHours(2), AllDay = false }, new CalendarEvent { Name = "Steve", Description = "Steve's event", Start = DateTime.Today.AddDays(7), End = DateTime.Today.AddDays(8), AllDay = true }, new CalendarEvent { Name = "Wheeee", Description = "Fun times", Start = DateTime.Today.AddDays(13), End = DateTime.Today.AddDays(15), AllDay = true } }; var editedEvents = new List<CalendarEvent> { new CalendarEvent { Name = "Bob (edited)", Description = "Bob's edited event", Start = DateTime.Today.AddDays(5).AddHours(-2), End = DateTime.Today.AddDays(5).AddHours(1), AllDay = false }, new CalendarEvent { Name = "Steve (edited)", Description = "Steve's edited event", Start = DateTime.Today.AddDays(6), End = DateTime.Today.AddDays(7).AddHours(-1), AllDay = false }, new CalendarEvent { Name = "Yay (edited)", Description = "Edited fun times", Start = DateTime.Today.AddDays(12), End = DateTime.Today.AddDays(13), AllDay = true } }; var calendar = new Calendar { Name = _calendarName }; var queryStartDate = DateTime.Today; var queryEndDate = queryStartDate.AddDays(30); await _service.AddOrUpdateCalendarAsync(calendar); foreach (var cev in originalEvents) { await _service.AddOrUpdateEventAsync(calendar, cev); } var eventResults = await _service.GetEventsAsync(calendar, queryStartDate, queryEndDate); Assert.IsNotNull(eventResults); CollectionAssert.AreEqual((ICollection)originalEvents, (ICollection)eventResults, _eventComparer); for (int i = 0; i < eventResults.Count; i++) { editedEvents.ElementAt(i).ExternalID = eventResults.ElementAt(i).ExternalID; } foreach (var cev in editedEvents) { await _service.AddOrUpdateEventAsync(calendar, cev); } var editedEventResults = await _service.GetEventsAsync(calendar, queryStartDate, queryEndDate); Assert.IsNotNull(editedEventResults); CollectionAssert.AreEqual((ICollection)editedEvents, (ICollection)editedEventResults, _eventComparer); }
/// <summary> /// Removes an event from the specified calendar. /// </summary> /// <param name="calendar">Calendar to remove event from</param> /// <param name="calendarEvent">Event to remove</param> /// <returns>True if successfully removed</returns> /// <exception cref="System.ArgumentException">Calendar is read-only</exception> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="Calendars.Plugin.Abstractions.PlatformException">Unexpected platform-specific error</exception> public async Task<bool> DeleteEventAsync(Calendar calendar, CalendarEvent calendarEvent) { if (string.IsNullOrEmpty(calendar.ExternalID) || string.IsNullOrEmpty(calendarEvent.ExternalID)) { return false; } await RequestCalendarAccess().ConfigureAwait(false); var deviceCalendar = _eventStore.GetCalendar(calendar.ExternalID); if (deviceCalendar == null) { return false; } var iosEvent = _eventStore.EventFromIdentifier(calendarEvent.ExternalID); if (iosEvent == null || iosEvent.Calendar.CalendarIdentifier != deviceCalendar.CalendarIdentifier) { return false; } NSError error = null; if (!_eventStore.RemoveEvent(iosEvent, EKSpan.ThisEvent, true, out error)) { // Without this, the eventStore may act like the remove succeeded. // (this obviously also resets any other changes, but since we own the eventStore // we can be pretty confident that won't be an issue) // _eventStore.Reset(); if (error.Domain == _ekErrorDomain && error.Code == (int)EKErrorCode.CalendarReadOnly) { throw new ArgumentException(error.LocalizedDescription, "calendar", new NSErrorException(error)); } else { throw new PlatformException(error.LocalizedDescription, new NSErrorException(error)); } } return true; }
/// <summary> /// Removes a calendar and all its events from the system. /// </summary> /// <param name="calendar">Calendar to delete</param> /// <returns>True if successfully removed</returns> /// <exception cref="System.ArgumentException">Calendar is read-only</exception> /// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception> /// <exception cref="Calendars.Plugin.Abstractions.PlatformException">Unexpected platform-specific error</exception> public async Task<bool> DeleteCalendarAsync(Calendar calendar) { if (string.IsNullOrEmpty(calendar.ExternalID)) { return false; } await EnsureInitializedAsync().ConfigureAwait(false); bool deleted = false; //var appCalendar = await _localApptStore.GetAppointmentCalendarAsync(calendar.ExternalID).ConfigureAwait(false); var appCalendar = await GetLocalCalendarAsync(calendar.ExternalID).ConfigureAwait(false); if (appCalendar != null) { // Perform the delete and return true await appCalendar.DeleteAsync().ConfigureAwait(false); deleted = true; } else { // Check for calendar from non-local appt store // If we get it from there, then error that it's not writeable // else, it just doesn't exist, so return false appCalendar = await _apptStore.GetAppointmentCalendarAsync(calendar.ExternalID).ConfigureAwait(false); if (appCalendar != null) { throw new ArgumentException("Cannot delete read-only calendar", "calendar"); } } return deleted; }