[gnome-shell/wip/mcrha/eds-libical-glib: 3/3] calendar-server: Port to libecal-2.0

[Florian Müllner <fmuellner src gnome org>]

commit bd4aac8f498d0012b9498839ff1e7d1943720552
Author: Milan Crha <mcrha redhat com>
Date:   Thu Apr 18 16:21:43 2019 +0200

    calendar-server: Port to libecal-2.0
    
    https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/501

 .gitlab-ci.yml                                    |   8 +-
 meson.build                                       |   4 +-
 src/calendar-server/calendar-sources.c            |   6 +-
 src/calendar-server/gnome-shell-calendar-server.c | 219 ++++++++++++----------
 4 files changed, 129 insertions(+), 108 deletions(-)
---
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 4b97799a3..8dfb00190 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -15,7 +15,7 @@ variables:
         - merge_requests
 
 check_commit_log:
-    image: registry.gitlab.gnome.org/gnome/mutter/master:v1
+    image: registry.gitlab.gnome.org/gnome/mutter/master:v2
     stage: review
     variables:
         GIT_DEPTH: "100"
@@ -40,7 +40,7 @@ js_check:
         when: on_failure
 
 build:
-    image: registry.gitlab.gnome.org/gnome/mutter/master:v1
+    image: registry.gitlab.gnome.org/gnome/mutter/master:v2
     stage: build
     before_script:
         - .gitlab-ci/checkout-mutter.sh
@@ -58,7 +58,7 @@ build:
             - build
 
 test:
-    image: registry.gitlab.gnome.org/gnome/mutter/master:v1
+    image: registry.gitlab.gnome.org/gnome/mutter/master:v2
     stage: test
     before_script:
         - ninja -C mutter/build install
@@ -72,7 +72,7 @@ test:
         when: on_failure
 
 test-pot:
-    image: registry.gitlab.gnome.org/gnome/mutter/master:v1
+    image: registry.gitlab.gnome.org/gnome/mutter/master:v2
     stage: test
     before_script:
         - ninja -C mutter/build install
diff --git a/meson.build b/meson.build
index 1801d5413..e57e1928f 100644
--- a/meson.build
+++ b/meson.build
@@ -14,7 +14,7 @@ cogl_pango_pc = 'mutter-cogl-pango-' + mutter_api_version
 libmutter_pc = 'libmutter-' + mutter_api_version
 
 croco_req = '>= 0.6.8'
-ecal_req = '>= 3.5.3'
+ecal_req = '>= 3.33.1'
 eds_req = '>= 3.17.2'
 gcr_req = '>= 3.7.5'
 gdesktop_req = '>= 3.7.90'
@@ -73,7 +73,7 @@ else
 endif
 
 atk_bridge_dep = dependency('atk-bridge-2.0')
-ecal_dep = dependency('libecal-1.2', version: ecal_req)
+ecal_dep = dependency('libecal-2.0', version: ecal_req)
 eds_dep = dependency('libedataserver-1.2', version: eds_req)
 gcr_dep = dependency('gcr-base-3', version: gcr_req)
 gdk_x11_dep = dependency('gdk-x11-3.0')
diff --git a/src/calendar-server/calendar-sources.c b/src/calendar-server/calendar-sources.c
index 628f89b07..38b765ecc 100644
--- a/src/calendar-server/calendar-sources.c
+++ b/src/calendar-server/calendar-sources.c
@@ -295,13 +295,13 @@ create_client_for_source (ESource              *source,
                          CalendarSourceData   *source_data)
 {
   ClientData *data;
-  ECalClient *client;
+  EClient *client;
   GError *error = NULL;
 
   client = g_hash_table_lookup (source_data->clients, source);
   g_return_if_fail (client == NULL);
 
-  client = e_cal_client_new (source, source_type, &error);
+  client = e_cal_client_connect_sync (source, source_type, -1, NULL, &error);
   if (!client)
     {
       g_warning ("Could not load source '%s': %s",
@@ -312,7 +312,7 @@ create_client_for_source (ESource              *source,
     }
 
   data = g_slice_new0 (ClientData);
-  data->client = client;  /* takes ownership */
+  data->client = E_CAL_CLIENT (client);  /* takes ownership */
   data->backend_died_id = g_signal_connect (client,
                                             "backend-died",
                                             G_CALLBACK (backend_died_cb),
diff --git a/src/calendar-server/gnome-shell-calendar-server.c 
b/src/calendar-server/gnome-shell-calendar-server.c
index 2ad8fb99e..d5b6e01f7 100644
--- a/src/calendar-server/gnome-shell-calendar-server.c
+++ b/src/calendar-server/gnome-shell-calendar-server.c
@@ -102,97 +102,120 @@ typedef struct
 } CollectAppointmentsData;
 
 static time_t
-get_time_from_property (icalcomponent         *ical,
-                        icalproperty_kind      prop_kind,
-                        struct icaltimetype (* get_prop_func) (const icalproperty *prop),
-                        icaltimezone          *default_zone)
+get_time_from_property (ICalComponent         *icomp,
+                        ICalPropertyKind       prop_kind,
+                        ICalTime * (* get_prop_func) (ICalProperty *prop),
+                        ICalTimezone          *default_zone)
 {
-  icalproperty        *prop;
-  struct icaltimetype  ical_time;
-  icalparameter       *param;
-  icaltimezone        *timezone = NULL;
+  ICalProperty  *prop;
+  ICalTime      *itt;
+  ICalParameter *param;
+  ICalTimezone  *timezone = NULL;
+  time_t         retval;
 
-  prop = icalcomponent_get_first_property (ical, prop_kind);
+  prop = i_cal_component_get_first_property (icomp, prop_kind);
   if (!prop)
     return 0;
 
-  ical_time = get_prop_func (prop);
+  itt = get_prop_func (prop);
 
-  param = icalproperty_get_first_parameter (prop, ICAL_TZID_PARAMETER);
+  param = i_cal_property_get_first_parameter (prop, I_CAL_TZID_PARAMETER);
   if (param)
-    timezone = icaltimezone_get_builtin_timezone_from_tzid (icalparameter_get_tzid (param));
-  else if (icaltime_is_utc (ical_time))
-    timezone = icaltimezone_get_utc_timezone ();
+    timezone = i_cal_timezone_get_builtin_timezone_from_tzid (i_cal_parameter_get_tzid (param));
+  else if (i_cal_time_is_utc (itt))
+    timezone = i_cal_timezone_get_utc_timezone ();
   else
     timezone = default_zone;
 
-  return icaltime_as_timet_with_zone (ical_time, timezone);
+  retval = i_cal_time_as_timet_with_zone (itt, timezone);
+
+  g_clear_object (&param);
+  g_clear_object (&prop);
+  g_clear_object (&itt);
+
+  return retval;
 }
 
 static char *
-get_ical_uid (icalcomponent *ical)
+get_ical_uid (ICalComponent *icomp)
 {
-  return g_strdup (icalcomponent_get_uid (ical));
+  return g_strdup (i_cal_component_get_uid (icomp));
 }
 
 static char *
-get_ical_summary (icalcomponent *ical)
+get_ical_summary (ICalComponent *icomp)
 {
-  icalproperty *prop;
+  ICalProperty *prop;
+  char         *retval;
 
-  prop = icalcomponent_get_first_property (ical, ICAL_SUMMARY_PROPERTY);
+  prop = i_cal_component_get_first_property (icomp, I_CAL_SUMMARY_PROPERTY);
   if (!prop)
     return NULL;
 
-  return g_strdup (icalproperty_get_summary (prop));
+  retval = g_strdup (i_cal_property_get_summary (prop));
+
+  g_object_unref (prop);
+
+  return retval;
 }
 
 static char *
-get_ical_description (icalcomponent *ical)
+get_ical_description (ICalComponent *icomp)
 {
-  icalproperty *prop;
+  ICalProperty *prop;
+  char         *retval;
 
-  prop = icalcomponent_get_first_property (ical, ICAL_DESCRIPTION_PROPERTY);
+  prop = i_cal_component_get_first_property (icomp, I_CAL_DESCRIPTION_PROPERTY);
   if (!prop)
     return NULL;
 
-  return g_strdup (icalproperty_get_description (prop));
+  retval = g_strdup (i_cal_property_get_description (prop));
+
+  g_object_unref (prop);
+
+  return retval;
 }
 
 static inline time_t
-get_ical_start_time (icalcomponent *ical,
-                     icaltimezone  *default_zone)
+get_ical_start_time (ICalComponent *icomp,
+                     ICalTimezone  *default_zone)
 {
-  return get_time_from_property (ical,
-                                 ICAL_DTSTART_PROPERTY,
-                                 icalproperty_get_dtstart,
+  return get_time_from_property (icomp,
+                                 I_CAL_DTSTART_PROPERTY,
+                                 i_cal_property_get_dtstart,
                                  default_zone);
 }
 
 static inline time_t
-get_ical_end_time (icalcomponent *ical,
-                   icaltimezone  *default_zone)
+get_ical_end_time (ICalComponent *icomp,
+                   ICalTimezone  *default_zone)
 {
-  return get_time_from_property (ical,
-                                 ICAL_DTEND_PROPERTY,
-                                 icalproperty_get_dtend,
+  return get_time_from_property (icomp,
+                                 I_CAL_DTEND_PROPERTY,
+                                 i_cal_property_get_dtend,
                                  default_zone);
 }
 
 static gboolean
-get_ical_is_all_day (icalcomponent *ical,
+get_ical_is_all_day (ICalComponent *icomp,
                      time_t         start_time,
-                     icaltimezone  *default_zone)
+                     ICalTimezone  *default_zone)
 {
-  icalproperty            *prop;
-  struct tm               *start_tm;
-  time_t                   end_time;
-  struct icaldurationtype  duration;
-  struct icaltimetype      start_icaltime;
+  ICalProperty *prop;
+  ICalDuration *duration;
+  ICalTime     *dtstart;
+  struct tm    *start_tm;
+  time_t        end_time;
+  gboolean      retval;
+
+  dtstart = i_cal_component_get_dtstart (icomp);
+  if (dtstart && i_cal_time_is_date (dtstart))
+    {
+      g_clear_object (&dtstart);
+      return TRUE;
+    }
 
-  start_icaltime = icalcomponent_get_dtstart (ical);
-  if (start_icaltime.is_date)
-    return TRUE;
+  g_clear_object (&dtstart);
 
   start_tm = gmtime (&start_time);
   if (start_tm->tm_sec  != 0 ||
@@ -200,35 +223,40 @@ get_ical_is_all_day (icalcomponent *ical,
       start_tm->tm_hour != 0)
     return FALSE;
 
-  if ((end_time = get_ical_end_time (ical, default_zone)))
+  if ((end_time = get_ical_end_time (icomp, default_zone)))
     return (end_time - start_time) % 86400 == 0;
 
-  prop = icalcomponent_get_first_property (ical, ICAL_DURATION_PROPERTY);
+  prop = i_cal_component_get_first_property (icomp, I_CAL_DURATION_PROPERTY);
   if (!prop)
     return FALSE;
 
-  duration = icalproperty_get_duration (prop);
+  duration = i_cal_property_get_duration (prop);
+
+  retval = duration && (i_cal_duration_as_int (duration) % 86400) == 0;
 
-  return icaldurationtype_as_int (duration) % 86400 == 0;
+  g_clear_object (&duration);
+  g_clear_object (&prop);
+
+  return retval;
 }
 
 static inline time_t
-get_ical_due_time (icalcomponent *ical,
-                   icaltimezone  *default_zone)
+get_ical_due_time (ICalComponent *icomp,
+                   ICalTimezone  *default_zone)
 {
-  return get_time_from_property (ical,
-                                 ICAL_DUE_PROPERTY,
-                                 icalproperty_get_due,
+  return get_time_from_property (icomp,
+                                 I_CAL_DUE_PROPERTY,
+                                 i_cal_property_get_due,
                                  default_zone);
 }
 
 static inline time_t
-get_ical_completed_time (icalcomponent *ical,
-                         icaltimezone  *default_zone)
+get_ical_completed_time (ICalComponent *icomp,
+                         ICalTimezone  *default_zone)
 {
-  return get_time_from_property (ical,
-                                 ICAL_COMPLETED_PROPERTY,
-                                 icalproperty_get_completed,
+  return get_time_from_property (icomp,
+                                 I_CAL_COMPLETED_PROPERTY,
+                                 i_cal_property_get_completed,
                                  default_zone);
 }
 
@@ -365,67 +393,69 @@ calendar_appointment_free (CalendarAppointment *appointment)
 
 static void
 calendar_appointment_init (CalendarAppointment  *appointment,
-                           icalcomponent        *ical,
+                           ICalComponent        *icomp,
                            ECalClient           *cal)
 {
-  icaltimezone *default_zone;
+  ICalTimezone *default_zone;
   const char *source_id;
 
   source_id = e_source_get_uid (e_client_get_source (E_CLIENT (cal)));
   default_zone = e_cal_client_get_default_timezone (cal);
 
-  appointment->uid          = get_ical_uid (ical);
+  appointment->uid          = get_ical_uid (icomp);
   appointment->source_id    = g_strdup (source_id);
   appointment->backend_name = get_source_backend_name (cal);
-  appointment->summary      = get_ical_summary (ical);
-  appointment->description  = get_ical_description (ical);
+  appointment->summary      = get_ical_summary (icomp);
+  appointment->description  = get_ical_description (icomp);
   appointment->color_string = get_source_color (cal);
-  appointment->start_time   = get_ical_start_time (ical, default_zone);
-  appointment->end_time     = get_ical_end_time (ical, default_zone);
-  appointment->is_all_day   = get_ical_is_all_day (ical,
+  appointment->start_time   = get_ical_start_time (icomp, default_zone);
+  appointment->end_time     = get_ical_end_time (icomp, default_zone);
+  appointment->is_all_day   = get_ical_is_all_day (icomp,
                                                    appointment->start_time,
                                                    default_zone);
 }
 
 static CalendarAppointment *
-calendar_appointment_new (icalcomponent        *ical,
+calendar_appointment_new (ICalComponent        *icomp,
                           ECalClient           *cal)
 {
   CalendarAppointment *appointment;
 
   appointment = g_new0 (CalendarAppointment, 1);
 
-  calendar_appointment_init (appointment, ical, cal);
+  calendar_appointment_init (appointment, icomp, cal);
   return appointment;
 }
 
 static gboolean
-generate_instances_cb (ECalComponent *comp,
-                       time_t         start,
-                       time_t         end,
-                       gpointer       data)
+generate_instances_cb (ICalComponent *icomp,
+                       ICalTime *instance_start,
+                       ICalTime *instance_end,
+                       gpointer user_data,
+                       GCancellable *cancellable,
+                       GError **error)
 {
-  ECalClient *cal = ((CollectAppointmentsData *)data)->client;
-  GHashTable *appointments = ((CollectAppointmentsData *)data)->appointments;
+  ECalClient *cal = ((CollectAppointmentsData *)user_data)->client;
+  GHashTable *appointments = ((CollectAppointmentsData *)user_data)->appointments;
   CalendarAppointment *appointment;
   CalendarOccurrence *occurrence;
-  const char *uid;
+  ICalTimezone *default_zone;
+  const gchar *uid;
 
-  e_cal_component_get_uid (comp, &uid);
+  default_zone = e_cal_client_get_default_timezone (cal);
+  uid = i_cal_component_get_uid (icomp);
   appointment = g_hash_table_lookup (appointments, uid);
 
   if (appointment == NULL)
     {
-      icalcomponent *ical = e_cal_component_get_icalcomponent (comp);
-
-      appointment = calendar_appointment_new (ical, cal);
+      appointment = calendar_appointment_new (icomp, cal);
       g_hash_table_insert (appointments, g_strdup (uid), appointment);
     }
 
   occurrence             = g_new0 (CalendarOccurrence, 1);
-  occurrence->start_time = start;
-  occurrence->end_time   = end;
-  occurrence->rid        = e_cal_component_get_recurid_as_string (comp);
+  occurrence->start_time = i_cal_time_as_timet_with_zone (instance_start, default_zone);
+  occurrence->end_time   = i_cal_time_as_timet_with_zone (instance_end, default_zone);
+  occurrence->rid        = e_cal_util_component_get_recurid_as_string (icomp);
 
   appointment->occurrences = g_slist_append (appointment->occurrences, occurrence);
 
@@ -442,7 +472,7 @@ struct _App
   time_t since;
   time_t until;
 
-  icaltimezone *zone;
+  ICalTimezone *zone;
 
   CalendarSources *sources;
   gulong sources_signal_id;
@@ -468,9 +498,9 @@ app_update_timezone (App *app)
   if (g_strcmp0 (location, app->timezone_location) != 0)
     {
       if (location == NULL)
-        app->zone = icaltimezone_get_utc_timezone ();
+        app->zone = i_cal_timezone_get_utc_timezone ();
       else
-        app->zone = icaltimezone_get_builtin_timezone (location);
+        app->zone = i_cal_timezone_get_builtin_timezone (location);
       g_free (app->timezone_location);
       app->timezone_location = location;
       print_debug ("Using timezone %s", app->timezone_location);
@@ -528,10 +558,10 @@ on_objects_added (ECalClientView *view,
 
   for (l = objects; l != NULL; l = l->next)
     {
-      icalcomponent *ical = l->data;
+      ICalComponent *icomp = l->data;
       const char *uid;
 
-      uid = icalcomponent_get_uid (ical);
+      uid = i_cal_component_get_uid (icomp);
 
       if (g_hash_table_lookup (app->appointments, uid) == NULL)
         {
@@ -600,7 +630,7 @@ app_load_events (App *app)
 
   since_iso8601 = isodate_from_time_t (app->since);
   until_iso8601 = isodate_from_time_t (app->until);
-  tz_location = icaltimezone_get_location (app->zone);
+  tz_location = i_cal_timezone_get_location (app->zone);
 
   print_debug ("Loading events since %s until %s",
                since_iso8601,
@@ -622,21 +652,12 @@ app_load_events (App *app)
 
       e_cal_client_set_default_timezone (cal, app->zone);
 
-      error = NULL;
-      if (!e_client_open_sync (E_CLIENT (cal), TRUE, NULL, &error))
-        {
-          ESource *source = e_client_get_source (E_CLIENT (cal));
-          g_warning ("Error opening calendar %s: %s\n",
-                    e_source_get_uid (source), error->message);
-          g_error_free (error);
-          continue;
-        }
-
       data.client = cal;
       data.appointments = app->appointments;
       e_cal_client_generate_instances_sync (cal,
                                             app->since,
                                             app->until,
+                                            NULL,
                                             generate_instances_cb,
                                             &data);