OpenAB::PIMItem::Revision EDSCalendarStorage::getRevision(const OpenAB::PIMItem::ID& id) { OpenAB::PIMItem::Revision revision; GError* gerror = NULL; GSList* events = NULL; std::vector<icalcomponent*> iCalComponents; if (!e_cal_client_get_objects_for_uid_sync(client, id.c_str(), &events, NULL, &gerror)) { LOG_ERROR() << "Error e_cal_client_get_objects_for_uid_sync result: " << GERROR_MESSAGE(gerror) << std::endl; GERROR_FREE(gerror); return ""; } GSList* current = events; //in case of recurring event, create revision as concatnation of single revision of all event instances, //so even if only on instance will be modified then we will be able to detect that whole event needs to be updated. while(current) { ECalComponent* component = (ECalComponent*)current->data; icalcomponent* iCalComponent = e_cal_component_get_icalcomponent(component); revision += icaltime_as_ical_string(icalcomponent_get_dtstamp(iCalComponent)); current = current->next; } e_cal_client_free_ecalcomp_slist(events); return revision; }
/** * get ICalendar VTIMEZONE block from ECalComponentWithTZ * * @param ectz * An evolution event/task/note type which may contain a time zone. * * @return the ICalendar VTIMEZONE block */ static gchar* get_vtimezone (const ECalComponentWithTZ *ectz) { icalcomponent *icc = NULL; icalcomponent *cloned_icc = NULL; icalproperty *dtstamp = NULL; icalproperty *uid = NULL; gchar *ical_str = NULL; if (ectz == NULL || ectz->maincomp == NULL || ectz->timezone == NULL) return NULL; icc = e_cal_component_get_icalcomponent (ectz->timezone); cloned_icc = icalcomponent_new_clone (icc); /* uid and dtstamp are not needed (nor wanted) in timezone block */ uid = icalcomponent_get_first_property(cloned_icc, ICAL_UID_PROPERTY); icalcomponent_remove_property (cloned_icc, uid); free(uid); dtstamp = icalcomponent_get_first_property(cloned_icc, ICAL_DTSTAMP_PROPERTY); icalcomponent_remove_property (cloned_icc, dtstamp); free(dtstamp); /* memory returned by *_as_ical_string() is owned by libical */ ical_str = g_strdup (icalcomponent_as_ical_string (cloned_icc)); icalcomponent_free (cloned_icc); return ical_str; }
gboolean scalix_appointment_get (ScalixAppointment * comp, const char *key, char **value) { icalcomponent *icomp; icalproperty *icalprop; const char *x_val; icomp = e_cal_component_get_icalcomponent (E_CAL_COMPONENT (comp)); icalprop = icalcomponent_get_first_property (icomp, ICAL_X_PROPERTY); while (icalprop) { const char *x_name; x_name = icalproperty_get_x_name (icalprop); x_val = icalproperty_get_x (icalprop); if (!strcmp (x_name, key)) { break; } icalprop = icalcomponent_get_next_property (icomp, ICAL_X_PROPERTY); } if (icalprop) { *value = g_strdup (x_val); return TRUE; } *value = NULL; return FALSE; }
static gint add_record (GnomePilotConduitSyncAbs *conduit, GnomePilotRecord *remote, EMemoConduitContext *ctxt) { ECalComponent *comp; char *uid; int retval = 0; g_return_val_if_fail (remote != NULL, -1); LOG (g_message ( "add_record: adding %s to desktop\n", print_remote (remote) )); comp = comp_from_remote_record (conduit, remote, ctxt->default_comp, ctxt->timezone, &(ctxt->ai)); /* Give it a new UID otherwise it will be the uid of the default comp */ uid = e_cal_component_gen_uid (); e_cal_component_set_uid (comp, uid); if (!e_cal_create_object (ctxt->client, e_cal_component_get_icalcomponent (comp), NULL, NULL)) return -1; e_pilot_map_insert (ctxt->map, remote->ID, uid, FALSE); g_object_unref (comp); return retval; }
enum OpenAB_Storage::Storage::eGetItem EDSCalendarStorage::getEvent(const OpenAB::PIMItem::ID & id, OpenAB::SmartPtr<OpenAB::PIMCalendarEventItem> & item) { if (getItemType() != OpenAB::eEvent) { return eGetItemFail; } GError* gerror = NULL; GSList* events = NULL; std::vector<icalcomponent*> iCalComponents; if (!e_cal_client_get_objects_for_uid_sync(client, id.c_str(), &events, NULL, &gerror)) { LOG_ERROR() << "Error e_cal_client_get_objects_for_uid_sync result: " << GERROR_MESSAGE(gerror) << std::endl; GERROR_FREE(gerror); return eGetItemFail; } GSList* current = events; while(current) { ECalComponent* component = (ECalComponent*)current->data; iCalComponents.push_back(icalcomponent_new_clone(e_cal_component_get_icalcomponent(component))); current = current->next; } item = (OpenAB::PIMCalendarEventItem*)EDSCalendarStorageCommon::processObject(iCalComponents); e_cal_client_free_ecalcomp_slist(events); return eGetItemOk; }
static gboolean check_first_instance_cb (ECalComponent *comp, time_t instance_start, time_t instance_end, gpointer user_data) { CheckFirstInstanceData *ifs = user_data; icalcomponent *icalcomp; struct icaltimetype rid; g_return_val_if_fail (ifs != NULL, FALSE); icalcomp = e_cal_component_get_icalcomponent (comp); if (icalcomponent_get_first_property (icalcomp, ICAL_RECURRENCEID_PROPERTY) != NULL) { rid = icalcomponent_get_recurrenceid (icalcomp); } else { struct icaltimetype dtstart; dtstart = icalcomponent_get_dtstart (icalcomp); if (dtstart.zone) { rid = icaltime_from_timet_with_zone (instance_start, dtstart.is_date, dtstart.zone); } else { rid = icaltime_from_timet (instance_start, dtstart.is_date); } } ifs->matches = icaltime_compare (ifs->rid, rid) == 0; return FALSE; }
/** * e_cal_util_is_first_instance: * @comp: an #ECalComponent instance * @rid: a recurrence ID * @tz_cb: (closure tz_cb_data) (scope call): The #ECalRecurResolveTimezoneFn to call * @tz_cb_data: (closure): User data to be passed to the @tz_cb callback * * Returns whether the given @rid is the first instance of * the recurrence defined in the @comp. * * Return: Whether the @rid identifies the first instance of @comp. * * Since: 3.16 **/ gboolean e_cal_util_is_first_instance (ECalComponent *comp, struct icaltimetype rid, ECalRecurResolveTimezoneFn tz_cb, gpointer tz_cb_data) { CheckFirstInstanceData ifs; icalcomponent *icalcomp; time_t start, end; g_return_val_if_fail (E_IS_CAL_COMPONENT (comp), FALSE); g_return_val_if_fail (!icaltime_is_null_time (rid), FALSE); ifs.rid = rid; ifs.matches = FALSE; icalcomp = e_cal_component_get_icalcomponent (comp); start = icaltime_as_timet (icalcomponent_get_dtstart (icalcomp)) - 24 * 60 * 60; end = icaltime_as_timet (icalcomponent_get_dtend (icalcomp)) + 24 * 60 * 60; e_cal_recur_generate_instances (comp, start, end, check_first_instance_cb, &ifs, tz_cb, tz_cb_data, icaltimezone_get_utc_timezone ()); return ifs.matches; }
void scalix_appointment_unset (ScalixAppointment * comp, const char *key) { icalcomponent *icomp; icalproperty *icalprop; const char *x_val; GSList *list, *iter; list = NULL; icomp = e_cal_component_get_icalcomponent (E_CAL_COMPONENT (comp)); icalprop = icalcomponent_get_first_property (icomp, ICAL_X_PROPERTY); while (icalprop) { const char *x_name; x_name = icalproperty_get_x_name (icalprop); x_val = icalproperty_get_x (icalprop); if (!strcmp (x_name, key)) { list = g_slist_prepend (list, icalprop); } icalprop = icalcomponent_get_next_property (icomp, ICAL_X_PROPERTY); } for (iter = list; iter; iter = iter->next) { icalprop = iter->data; icalcomponent_remove_property (icomp, icalprop); icalproperty_free (icalprop); } return; }
void dates_calendar_combo_changed_cb (GtkComboBox *widget, DatesData *d) { ECal *c; ECalComponent *comp = d->comp; GtkTreeIter iter; if (!gtk_combo_box_get_active_iter (widget, &iter)) return; gtk_tree_model_get (gtk_combo_box_get_model (widget), &iter, COL_CALPTR, &c, -1); if (c != d->cal) { /* Move event between calendars */ const char *uid = NULL; g_object_ref (comp); if (!d->waiting) d->waiting = PENDING_CAL_CHANGE; e_cal_component_get_uid (comp, &uid); e_cal_remove_object (d->cal, uid, NULL); /* TODO: Error checking */ e_cal_create_object (c, e_cal_component_get_icalcomponent (comp), (char **)&uid, NULL); g_object_unref (comp); d->uri_uid = g_strconcat (e_cal_get_uri (c), uid, NULL); d->widgets = contacts_set_widgets_desensitive (d->details_dialog); g_idle_add (dates_select_event_idle_cb, d); } }
gint main (gint argc, gchar **argv) { ECal *cal; gchar *uri = NULL; ECalComponent *e_component = NULL; icalcomponent *component = NULL; gchar *uid = NULL; g_type_init (); cal = ecal_test_utils_cal_new_temp (&uri, E_CAL_SOURCE_TYPE_EVENT); ecal_test_utils_cal_open (cal, FALSE); ecal_test_utils_create_component (cal, "20040109T090000Z", "UTC", "20040109T103000", "UTC", "meeting request", &e_component, &uid); component = e_cal_component_get_icalcomponent (e_component); ecal_test_utils_cal_receive_objects (cal, component); ecal_test_utils_cal_remove (cal); g_object_unref (e_component); g_free (uid); return 0; }
gboolean evo_cal_source_update_object(ECal *ecal, ECalComponent *obj) { if (!e_cal_modify_object (ecal, e_cal_component_get_icalcomponent(obj), CALOBJ_MOD_ALL, NULL)) return FALSE; return TRUE; }
static ECompEditor * get_component_editor (EShell *shell, ECalClient *client, ECalComponent *comp, gboolean is_new, GError **error) { ECompEditorFlags flags = 0; ECompEditor *comp_editor = NULL; ESourceRegistry *registry; g_return_val_if_fail (E_IS_SHELL (shell), NULL); g_return_val_if_fail (E_IS_CAL_CLIENT (client), NULL); g_return_val_if_fail (E_IS_CAL_COMPONENT (comp), NULL); registry = e_shell_get_registry (shell); if (is_new) { flags |= E_COMP_EDITOR_FLAG_IS_NEW; } else { comp_editor = e_comp_editor_find_existing_for ( e_client_get_source (E_CLIENT (client)), e_cal_component_get_icalcomponent (comp)); } if (!comp_editor) { if (itip_organizer_is_user (registry, comp, client)) flags |= E_COMP_EDITOR_FLAG_ORGANIZER_IS_USER; if (e_cal_component_has_attendees (comp)) flags |= E_COMP_EDITOR_FLAG_WITH_ATTENDEES; comp_editor = e_comp_editor_open_for_component (NULL, shell, e_client_get_source (E_CLIENT (client)), e_cal_component_get_icalcomponent (comp), flags); if (comp_editor) { /* request save for new events */ e_comp_editor_set_changed (comp_editor, is_new); } } return comp_editor; }
gint main (gint argc, gchar **argv) { ECal *cal; gchar *uri = NULL; ECalComponent *e_component; ECalComponent *e_component_final; icalcomponent *component; icalcomponent *component_final; struct icaltimetype icaltime; gchar *uid; g_type_init (); cal = ecal_test_utils_cal_new_temp (&uri, E_CAL_SOURCE_TYPE_EVENT); ecal_test_utils_cal_open (cal, FALSE); ecal_test_utils_create_component (cal, INITIAL_BEGIN_TIME, INITIAL_BEGIN_TIMEZONE, INITIAL_END_TIME, INITIAL_END_TIMEZONE, EVENT_SUMMARY, &e_component, &uid); component = e_cal_component_get_icalcomponent (e_component); component_final = ecal_test_utils_cal_get_object (cal, uid); ecal_test_utils_cal_assert_objects_equal_shallow (component, component_final); icalcomponent_free (component_final); /* make and commit changes */ icaltime = icaltime_from_string (FINAL_BEGIN_TIME); icalcomponent_set_dtstart (component, icaltime); ecal_test_utils_cal_component_set_icalcomponent (e_component, component); ecal_test_utils_cal_modify_object (cal, component, CALOBJ_MOD_ALL); /* verify */ component_final = ecal_test_utils_cal_get_object (cal, uid); e_component_final = e_cal_component_new (); ecal_test_utils_cal_component_set_icalcomponent (e_component_final, component_final); ecal_test_utils_cal_assert_e_cal_components_equal (e_component, e_component_final); /* Clean-up */ ecal_test_utils_cal_remove (cal); g_object_unref (e_component_final); g_free (uid); icalcomponent_free (component); return 0; }
void dates_commit_event_cb (GtkWidget *source, DatesData *data, CalObjModType type) { /* Commit changes */ #ifdef DEBUG if (data->debug & DATES_DEBUG_EDIT) g_debug ("Committing event (%p) changes", data->comp); #endif e_cal_component_commit_sequence (data->comp); e_cal_modify_object (data->cal, e_cal_component_get_icalcomponent (data->comp), type, NULL); }
char * evo_cal_source_add_object(ECal *ecal, ECalComponent *obj) { char *uid; GError *error = NULL; //uid = e_cal_component_gen_uid (); //e_cal_component_set_uid (comp, uid); if (!e_cal_create_object (ecal, e_cal_component_get_icalcomponent (obj), &uid, &error)) { g_warning("error adding object: %s\n", error ? error->message : "None"); g_clear_error (&error); } return uid; }
void scalix_appointment_set (ScalixAppointment * comp, const char *key, const char *value) { icalcomponent *icomp; icalproperty *icalprop; e_cal_component_commit_sequence (E_CAL_COMPONENT (comp)); icomp = e_cal_component_get_icalcomponent (E_CAL_COMPONENT (comp)); icalprop = icalproperty_new_x (value); icalproperty_set_x_name (icalprop, key); icalcomponent_add_property (icomp, icalprop); }
static char * serialize (ScalixObject * object) { ScalixAppointmentPrivate *priv; icalcomponent *icomp, *toplevel_comp; ECalComponent *comp; GSList *iter; char *result = NULL; priv = SCALIX_APPOINTMENT_GET_PRIVATE (SCALIX_APPOINTMENT (object)); scalix_appointment_unset (SCALIX_APPOINTMENT (object), "X-SCALIX-DESCRIPTION-CHANGED"); comp = E_CAL_COMPONENT (object); e_cal_component_commit_sequence (comp); icomp = e_cal_component_get_icalcomponent (comp); if (icomp) { toplevel_comp = e_cal_util_new_top_level (); /* add timezone if one exists */ if (priv->timezone) { icalcomponent_add_component (toplevel_comp, icalcomponent_new_clone (icaltimezone_get_component (priv->timezone))); } /* add the main vevent */ icalcomponent_add_component (toplevel_comp, icalcomponent_new_clone (icomp)); /* add exceptions if they exist */ for (iter = priv->exceptions; iter; iter = iter->next) { icalcomponent_add_component (toplevel_comp, icalcomponent_new_clone ((icalcomponent*) iter->data)); } result = icalcomponent_as_ical_string (toplevel_comp); if (result != NULL) { result = g_strdup (result); } icalcomponent_free (toplevel_comp); } return result; }
static void test_modify_object (ETestServerFixture *fixture, gconstpointer user_data) { ECal *cal; ECalComponent *e_component; ECalComponent *e_component_final; icalcomponent *component; icalcomponent *component_final; struct icaltimetype icaltime; gchar *uid; cal = E_TEST_SERVER_UTILS_SERVICE (fixture, ECal); ecal_test_utils_create_component ( cal, INITIAL_BEGIN_TIME, INITIAL_BEGIN_TIMEZONE, INITIAL_END_TIME, INITIAL_END_TIMEZONE, EVENT_SUMMARY, &e_component, &uid); component = e_cal_component_get_icalcomponent (e_component); component_final = ecal_test_utils_cal_get_object (cal, uid); ecal_test_utils_cal_assert_objects_equal_shallow ( component, component_final); icalcomponent_free (component_final); /* make and commit changes */ icaltime = icaltime_from_string (FINAL_BEGIN_TIME); icalcomponent_set_dtstart (component, icaltime); ecal_test_utils_cal_component_set_icalcomponent ( e_component, component); ecal_test_utils_cal_modify_object (cal, component, CALOBJ_MOD_ALL); /* verify */ component_final = ecal_test_utils_cal_get_object (cal, uid); e_component_final = e_cal_component_new (); ecal_test_utils_cal_component_set_icalcomponent ( e_component_final, component_final); ecal_test_utils_cal_assert_e_cal_components_equal ( e_component, e_component_final); g_object_unref (e_component_final); g_free (uid); icalcomponent_free (component); }
static icalcomponent * toplevel_with_zones (SunOneInvitationList *list, ECalComponent *comp) { icalcomponent *top_level, *icomp; icalproperty *prop; icalvalue *value; top_level = e_cal_util_new_top_level (); prop = icalproperty_new (ICAL_METHOD_PROPERTY); value = icalvalue_new_method (ICAL_METHOD_REQUEST); icalproperty_set_value (prop, value); icalcomponent_add_property (top_level, prop); icomp = e_cal_component_get_icalcomponent (comp); icomp = icalcomponent_new_clone (icomp); icalcomponent_add_component (top_level, icomp); return top_level; }
static gchar * test_object_removal (ECal *client) { gchar *uid; ECalComponent *comp; icalcomponent *icalcomp; gboolean compare = 1; GError *error = NULL; comp = e_cal_component_new (); e_cal_component_commit_sequence (comp); icalcomp = e_cal_component_get_icalcomponent (comp); if (!e_cal_create_object (client, icalcomp, &uid, &error)) { cl_printf (client, "Test object removal - Object creation: %s\n", error->message); g_object_unref (comp); g_object_unref (icalcomp); return "Test Object Removal failed\n"; } if (!e_cal_remove_object (client, uid, &error)) { cl_printf (client, "Test object removal - Could not remove the object\n"); g_free (uid); g_object_unref (comp); g_object_unref (icalcomp); return "Test Object Removal failed\n"; } compare = e_cal_get_object (client, uid, NULL, &icalcomp, &error); g_free (uid); g_object_unref (comp); g_object_unref (icalcomp); mu_assert ("Test object removal - Failed\n", compare); return NULL; }
static void test_receive_objects (ETestServerFixture *fixture, gconstpointer user_data) { ECal *cal; ECalComponent *e_component = NULL; icalcomponent *component = NULL; gchar *uid = NULL; cal = E_TEST_SERVER_UTILS_SERVICE (fixture, ECal); ecal_test_utils_create_component ( cal, "20040109T090000Z", "UTC", "20040109T103000", "UTC", "meeting request", &e_component, &uid); component = e_cal_component_get_icalcomponent (e_component); ecal_test_utils_cal_receive_objects (cal, component); g_object_unref (e_component); g_free (uid); }
static gint replace_record (GnomePilotConduitSyncAbs *conduit, EMemoLocalRecord *local, GnomePilotRecord *remote, EMemoConduitContext *ctxt) { ECalComponent *new_comp; int retval = 0; g_return_val_if_fail (remote != NULL, -1); LOG (g_message ("replace_record: replace %s with %s\n", print_local (local), print_remote (remote))); new_comp = comp_from_remote_record (conduit, remote, local->comp, ctxt->timezone, &(ctxt->ai)); g_object_unref (local->comp); local->comp = new_comp; if (!e_cal_modify_object (ctxt->client, e_cal_component_get_icalcomponent (new_comp), CALOBJ_MOD_ALL, NULL)) return -1; return retval; }
static gboolean write_calendar (gchar *uid, ESourceList *source_list, GOutputStream *stream) { ESource *source; ECal *client = NULL; GError *error = NULL; GList *objects; icaltimezone *utc; time_t start = time(NULL), end; icalcomponent *top_level; char *email = NULL; GList *users = NULL; gboolean res = FALSE; utc = icaltimezone_get_utc_timezone (); start = time_day_begin_with_zone (start, utc); end = time_add_week_with_zone (start, 6, utc); source = e_source_list_peek_source_by_uid (source_list, uid); if (source) client = auth_new_cal_from_source (source, E_CAL_SOURCE_TYPE_EVENT); if (!client) { g_warning (G_STRLOC ": Could not publish calendar: Calendar backend no longer exists"); return FALSE; } if (!e_cal_open (client, TRUE, &error)) { if (error) { g_warning ("%s", error->message); g_error_free (error); } g_object_unref (client); return FALSE; } if (e_cal_get_cal_address (client, &email, &error)) { if (email && *email) users = g_list_append (users, email); } top_level = e_cal_util_new_top_level (); error = NULL; if (e_cal_get_free_busy (client, users, start, end, &objects, &error)) { char *ical_string; while (objects) { ECalComponent *comp = objects->data; icalcomponent *icalcomp = e_cal_component_get_icalcomponent (comp); icalcomponent_add_component (top_level, icalcomp); objects = g_list_remove (objects, comp); } ical_string = icalcomponent_as_ical_string (top_level); res = g_output_stream_write_all (stream, ical_string, strlen (ical_string), NULL, NULL, &error); g_free (ical_string); } if (users) g_list_free (users); g_free (email); g_object_unref (client); if (error) { g_warning ("%s", error->message); g_error_free (error); } return res; }
/** Get iCal component's X-EEE-CACHE-STATE property value. * * @param comp ECalComponent object. * * @return Property value (ECalComponentCacheState). */ ECalComponentCacheState e_cal_component_get_cache_state(ECalComponent *comp) { return icalcomponent_get_cache_state(e_cal_component_get_icalcomponent(comp)); }
/** * Get common fields from ECalComponentWithTZ and set them in I_common */ void conv_common_e_to_i (const ECalComponentWithTZ *ectz, I_common *i_common) { GSList *descr_list = NULL; const gchar *uid = NULL; const gchar *categories = NULL; struct icaltimetype *lastModifiedDate; struct icaltimetype *createdDate; icalcomponent *icomp = NULL; icalproperty *prop = NULL; i_common->vtimezone = get_vtimezone(ectz); sensitivity_e_to_i(ectz->maincomp, i_common); link_attachments_e_to_i(ectz->maincomp, i_common); /* handle description/body */ e_cal_component_get_description_list ((ECalComponent*) ectz->maincomp, &descr_list); if (descr_list != NULL) { ECalComponentText *text = (ECalComponentText*) descr_list->data; i_common->body = g_string_new (text->value); e_cal_component_free_text_list(descr_list); } /* ******************************************SET UID************************************ */ e_cal_component_get_uid (ectz->maincomp, &uid); if (uid) i_common->uid = g_string_new (uid); /* ******************************************SET CATEGORIES************************************ */ e_cal_component_get_categories (ectz->maincomp, &categories); if (categories) i_common->categories = g_string_new (categories); /* ******************************************SET DATES (CREATION, LASTMODIFICATION, START, END etc.)************************************ */ e_cal_component_get_last_modified (ectz->maincomp, &lastModifiedDate); i_common->last_modified_datetime = new_date_or_datetime(); if (lastModifiedDate) /* log_debug("ICalDate %d-%d-%d-%d-%d-%d", lastModifiedDate->year, lastModifiedDate->month, lastModifiedDate->day, lastModifiedDate->hour, lastModifiedDate->minute, lastModifiedDate->second); */ date_or_datetime_e_to_i (lastModifiedDate, i_common->last_modified_datetime); else { /* Set lastModifiedDate to current system time */ i_common->last_modified_datetime->date_time = g_new0(time_t, 1); *(i_common->last_modified_datetime->date_time) = time(NULL); } g_free(lastModifiedDate); i_common->creation_datetime = new_date_or_datetime(); e_cal_component_get_created (ectz->maincomp, &createdDate); if (createdDate) date_or_datetime_e_to_i (createdDate, i_common->creation_datetime); else { /* Set createdDate to current system time */ i_common->creation_datetime->date_time = g_new0(time_t, 1); *(i_common->creation_datetime->date_time) = time(NULL); } g_free(createdDate); /* ******************************************SET ATTACHMENT LIST******************************************************************************* */ /* iterate over all ical properties */ icomp = e_cal_component_get_icalcomponent (ectz->maincomp); prop = icalcomponent_get_first_property(icomp, ICAL_ANY_PROPERTY); while (prop != NULL) { icalproperty_kind kind = icalproperty_isa(prop); gchar *pname = (gchar*) icalproperty_get_x_name(prop); if (ICAL_ATTACH_PROPERTY == kind) /* found kolab inline or link attachment */ add_e_attachment_parameters(prop, i_common, TRUE); else if (pname && strcmp(pname, ICONTACT_KOLAB_STORE_ATTACHMENT) == 0) /* found hidden kolab attachment */ add_e_attachment_parameters(prop, i_common, FALSE); prop = icalcomponent_get_next_property(icomp, ICAL_ANY_PROPERTY); } i_common->is_html_richtext = FALSE; }
CamelMimeMessage * scalix_appointment_to_mime_message (ScalixObject * object) { CamelMimeMessage *message; CamelMultipart *multipart; CamelMimePart *part; CamelMedium *medium; CamelStream *stream; CamelDataWrapper *wrapper; ECalComponentDateTime dtstart, dtend; ECalComponent *comp; ECalComponentText text; icalcomponent_kind kind; icalcomponent *icalcomp, *toplevel_comp; icaltimezone *zone = NULL; GSList *attachment_list = NULL; GSList *attachment_list_new = NULL; GSList *siter = NULL; GList *part_list = NULL; GList *iter = NULL; char *msgid; char *str, *meeting_status; const char *ouid = NULL; char *file_contents = NULL; char *full_path, *filename, *mime_filename; char *cid; int size; g_object_get (SCALIX_APPOINTMENT (object), "timezone", &zone, NULL); comp = E_CAL_COMPONENT (scalix_object_clone (object)); message = camel_mime_message_new (); medium = CAMEL_MEDIUM (message); camel_medium_add_header (medium, "X-Scalix-Class", "IPM.Appointment"); /* Preserve msg id if there is already one */ if (scalix_appointment_get (SCALIX_APPOINTMENT (comp), X_SCALIX_MSG_ID, &msgid)) { scalix_appointment_unset (SCALIX_APPOINTMENT (comp), X_SCALIX_MSG_ID); } else { msgid = camel_header_msgid_generate (); } camel_mime_message_set_message_id (message, msgid); /* subject */ e_cal_component_get_summary (comp, &text); if (text.value != NULL) { camel_mime_message_set_subject (message, text.value); } /* start day */ e_cal_component_get_dtstart (comp, &dtstart); if (!icaltime_get_timezone (*dtstart.value)) icaltime_set_timezone (dtstart.value, icaltimezone_get_builtin_timezone_from_tzid (dtstart.tzid)); /* end day */ e_cal_component_get_dtend (comp, &dtend); if (!icaltime_get_timezone (*dtend.value)) icaltime_set_timezone (dtend.value, icaltimezone_get_builtin_timezone_from_tzid (dtend.tzid)); /* set From: and Sender: */ if (e_cal_component_has_organizer (comp)) { ECalComponentOrganizer organizer; e_cal_component_get_organizer (comp, &organizer); if (!strncasecmp (organizer.value, "MAILTO:", 7)) { camel_medium_add_header (medium, "Sender", organizer.value + 7); camel_medium_add_header (medium, "From", organizer.value + 7); } } /* set the appropriate recipient headers from the recipient table */ if (e_cal_component_has_attendees (comp) && e_cal_component_has_organizer (comp)) { GSList *iter, *attendees = NULL; CamelInternetAddress *recipients_to = NULL; CamelInternetAddress *recipients_cc = NULL; meeting_status = "1"; e_cal_component_get_attendee_list (comp, &attendees); for (iter = attendees; iter; iter = iter->next) { ECalComponentAttendee *attendee = iter->data; const char *mail = NULL; /* attendee entries must start with MAILTO: */ if (strncasecmp (attendee->value, "MAILTO:", 7)) { continue; } mail = attendee->value + 7; if (attendee->role == ICAL_ROLE_REQPARTICIPANT) { if (recipients_to == NULL) { recipients_to = camel_internet_address_new (); } camel_internet_address_add (recipients_to, attendee->cn, mail); } else if (attendee->role == ICAL_ROLE_OPTPARTICIPANT) { if (recipients_cc == NULL) { recipients_cc = camel_internet_address_new (); } camel_internet_address_add (recipients_cc, attendee->cn, mail); } else { continue; } } if (recipients_to != NULL) { camel_mime_message_set_recipients (message, "To", recipients_to); camel_object_unref (recipients_to); } if (recipients_cc != NULL) { camel_mime_message_set_recipients (message, "Cc", recipients_cc); camel_object_unref (recipients_cc); } } else { meeting_status = "0"; } /* Clear properties */ scalix_appointment_unset (SCALIX_APPOINTMENT (comp), X_SCALIX_IMAP_UID); /* Render the text/calendar */ e_cal_component_commit_sequence (comp); icalcomp = e_cal_component_get_icalcomponent (comp); kind = icalcomponent_isa (icalcomp); if (kind != ICAL_VCALENDAR_COMPONENT) { /* If its not a VCALENDAR, make it one to simplify below */ toplevel_comp = e_cal_util_new_top_level (); icalcomponent_add_component (toplevel_comp, icalcomp); icalcomp = toplevel_comp; } /* set METHOD to PUSBLISH */ icalcomponent_set_method (icalcomp, ICAL_METHOD_PUBLISH); /* Add the VTIMEZONE components for start- and/or end-times */ if (zone) { icalcomponent_add_component (icalcomp, icaltimezone_get_component (zone)); } else if (dtstart.tzid) { icalcomponent_add_component (icalcomp, icaltimezone_get_component (icaltimezone_get_builtin_timezone_from_tzid (dtstart.tzid))); } if (dtstart.tzid && dtend.tzid && strcmp (dtstart.tzid, dtend.tzid) != 0) { icalcomponent_add_component (icalcomp, icaltimezone_get_component (icaltimezone_get_builtin_timezone_from_tzid (dtend.tzid))); } /* FIXME: do we leek icalcomponents here? */ if (e_cal_component_has_attachments (comp)) { multipart = camel_multipart_new (); camel_multipart_set_boundary (multipart, NULL); e_cal_component_get_uid (comp, &ouid); e_cal_component_get_attachment_list (comp, &attachment_list); for (siter = attachment_list; siter; siter = siter->next) { if (siter->data == NULL) continue; if (strstr (siter->data, "file://") != siter->data) continue; full_path = ((char *) siter->data) + strlen ("file://"); filename = g_strrstr (full_path, "/") + 1; mime_filename = filename + strlen (ouid) + 1; size = 0; file_contents = get_file_contents (full_path, &size); if (file_contents == NULL) continue; stream = camel_stream_mem_new_with_buffer (file_contents, size); wrapper = camel_data_wrapper_new (); camel_data_wrapper_construct_from_stream (wrapper, stream); camel_object_unref (stream); part = camel_mime_part_new (); camel_medium_set_content_object (CAMEL_MEDIUM (part), wrapper); camel_mime_part_set_filename (part, mime_filename); camel_mime_part_set_encoding (part, CAMEL_TRANSFER_ENCODING_BASE64); cid = camel_header_msgid_generate (); camel_mime_part_set_content_id (part, cid); camel_mime_part_set_description (part, mime_filename); camel_mime_part_set_disposition (part, "attachment"); part_list = g_list_append (part_list, part); attachment_list_new = g_slist_append (attachment_list_new, g_strdup_printf ("CID:%s", cid)); g_free (cid); } e_cal_component_set_attachment_list (comp, attachment_list_new); str = icalcomponent_as_ical_string (icalcomp); part = camel_mime_part_new (); camel_mime_part_set_content (part, str, strlen (str), "text/calendar; method=PUBLISH; charset=UTF-8"); part_list = g_list_prepend (part_list, part); for (iter = part_list; iter; iter = iter->next) { part = (CamelMimePart *) iter->data; camel_multipart_add_part (multipart, part); camel_object_unref (part); } camel_medium_set_content_object (CAMEL_MEDIUM (message), CAMEL_DATA_WRAPPER (multipart)); camel_object_unref (multipart); g_slist_free (attachment_list); g_slist_free (attachment_list_new); g_list_free (part_list); } else { str = icalcomponent_as_ical_string (icalcomp); camel_mime_part_set_content (CAMEL_MIME_PART (message), str, strlen (str), "text/calendar; method=PUBLISH; charset=UTF-8"); } scalix_appointment_set (SCALIX_APPOINTMENT (object), X_SCALIX_MSG_ID, msgid); return message; }
static gboolean do_mail_to_event (AsyncData *data) { EClient *client; CamelFolder *folder = data->folder; GPtrArray *uids = data->uids; GError *error = NULL; client = e_client_cache_get_client_sync (data->client_cache, data->source, data->extension_name, 30, NULL, &error); /* Sanity check. */ g_return_val_if_fail ( ((client != NULL) && (error == NULL)) || ((client == NULL) && (error != NULL)), TRUE); if (error != NULL) { report_error_idle (_("Cannot open calendar. %s"), error->message); } else if (e_client_is_readonly (E_CLIENT (client))) { switch (data->source_type) { case E_CAL_CLIENT_SOURCE_TYPE_EVENTS: report_error_idle (_("Selected calendar is read only, thus cannot create event there. Select other calendar, please."), NULL); break; case E_CAL_CLIENT_SOURCE_TYPE_TASKS: report_error_idle (_("Selected task list is read only, thus cannot create task there. Select other task list, please."), NULL); break; case E_CAL_CLIENT_SOURCE_TYPE_MEMOS: report_error_idle (_("Selected memo list is read only, thus cannot create memo there. Select other memo list, please."), NULL); break; default: g_warn_if_reached (); break; } } else { gint i; ECalComponentDateTime dt, dt2; struct icaltimetype tt, tt2; struct _manage_comp *oldmc = NULL; #define cache_backend_prop(prop) { \ gchar *val = NULL; \ e_client_get_backend_property_sync (E_CLIENT (client), prop, &val, NULL, NULL); \ g_free (val); \ } /* precache backend properties, thus editor have them ready when needed */ cache_backend_prop (CAL_BACKEND_PROPERTY_CAL_EMAIL_ADDRESS); cache_backend_prop (CAL_BACKEND_PROPERTY_ALARM_EMAIL_ADDRESS); cache_backend_prop (CAL_BACKEND_PROPERTY_DEFAULT_OBJECT); e_client_get_capabilities (E_CLIENT (client)); #undef cache_backend_prop /* set start day of the event as today, without time - easier than looking for a calendar's time zone */ tt = icaltime_today (); dt.value = &tt; dt.tzid = NULL; tt2 = tt; icaltime_adjust (&tt2, 1, 0, 0, 0); dt2.value = &tt2; dt2.tzid = NULL; for (i = 0; i < (uids ? uids->len : 0); i++) { CamelMimeMessage *message; ECalComponent *comp; ECalComponentText text; icalproperty *icalprop; icalcomponent *icalcomp; struct _manage_comp *mc; /* retrieve the message from the CamelFolder */ /* FIXME Not passing a GCancellable or GError. */ message = camel_folder_get_message_sync ( folder, g_ptr_array_index (uids, i), NULL, NULL); if (!message) { continue; } comp = e_cal_component_new (); switch (data->source_type) { case E_CAL_CLIENT_SOURCE_TYPE_EVENTS: e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_EVENT); break; case E_CAL_CLIENT_SOURCE_TYPE_TASKS: e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_TODO); break; case E_CAL_CLIENT_SOURCE_TYPE_MEMOS: e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_JOURNAL); break; default: g_warn_if_reached (); break; } e_cal_component_set_uid (comp, camel_mime_message_get_message_id (message)); e_cal_component_set_dtstart (comp, &dt); if (data->source_type == E_CAL_CLIENT_SOURCE_TYPE_EVENTS) { /* make it an all-day event */ e_cal_component_set_dtend (comp, &dt2); } /* set the summary */ text.value = camel_mime_message_get_subject (message); text.altrep = NULL; e_cal_component_set_summary (comp, &text); /* set all fields */ if (data->selected_text) { GSList sl; text.value = data->selected_text; text.altrep = NULL; sl.next = NULL; sl.data = &text; e_cal_component_set_description_list (comp, &sl); } else set_description (comp, message); if (data->with_attendees) { gchar *organizer; /* set actual user as organizer, to be able to change event's properties */ organizer = set_organizer (comp, data->folder); set_attendees (comp, message, organizer); g_free (organizer); } /* set attachment files */ set_attachments (E_CAL_CLIENT (client), comp, message); /* priority */ set_priority (comp, CAMEL_MIME_PART (message)); /* no need to increment a sequence number, this is a new component */ e_cal_component_abort_sequence (comp); icalcomp = e_cal_component_get_icalcomponent (comp); icalprop = icalproperty_new_x ("1"); icalproperty_set_x_name (icalprop, "X-EVOLUTION-MOVE-CALENDAR"); icalcomponent_add_property (icalcomp, icalprop); mc = g_new0 (struct _manage_comp, 1); mc->client = g_object_ref (client); mc->comp = g_object_ref (comp); g_mutex_init (&mc->mutex); g_cond_init (&mc->cond); mc->mails_count = uids->len; mc->mails_done = i + 1; /* Current task */ mc->editor_title = NULL; mc->can_continue = TRUE; if (oldmc) { /* Wait for user to quit the editor created in previous iteration * before displaying next one */ gboolean can_continue; g_mutex_lock (&oldmc->mutex); g_cond_wait (&oldmc->cond, &oldmc->mutex); g_mutex_unlock (&oldmc->mutex); can_continue = oldmc->can_continue; free_manage_comp_struct (oldmc); oldmc = NULL; if (!can_continue) break; } e_cal_client_get_object_sync ( E_CAL_CLIENT (client), icalcomponent_get_uid (icalcomp), NULL, &mc->stored_comp, NULL, NULL); /* Prioritize ahead of GTK+ redraws. */ g_idle_add_full ( G_PRIORITY_HIGH_IDLE, (GSourceFunc) do_manage_comp_idle, mc, NULL); oldmc = mc; g_object_unref (comp); g_object_unref (message); } /* Wait for the last editor and then clean up */ if (oldmc) { g_mutex_lock (&oldmc->mutex); g_cond_wait (&oldmc->cond, &oldmc->mutex); g_mutex_unlock (&oldmc->mutex); free_manage_comp_struct (oldmc); } } /* free memory */ if (client != NULL) g_object_unref (client); g_ptr_array_unref (uids); g_object_unref (folder); g_object_unref (data->client_cache); g_object_unref (data->source); g_free (data->selected_text); g_free (data); data = NULL; if (error != NULL) g_error_free (error); return TRUE; }
static void cal_component_preview_write_html (ECalComponentPreview *preview, GString *buffer) { ECalClient *client; ECalComponent *comp; icaltimezone *default_zone; ECalComponentText text; ECalComponentDateTime dt; gchar *str; GString *string; GSList *list, *iter; icalcomponent *icalcomp; icalproperty *icalprop; icalproperty_status status; const gchar *location; gint *priority_value; client = preview->priv->client; comp = preview->priv->comp; default_zone = preview->priv->timezone; /* write document header */ e_cal_component_get_summary (comp, &text); g_string_append (buffer, HTML_HEADER); g_string_append (buffer, "<body class=\"-e-web-view-background-color -e-web-view-text-color\">"); if (text.value) g_string_append_printf (buffer, "<h2>%s</h2>", text.value); else g_string_append_printf (buffer, "<h2><i>%s</i></h2>",_("Untitled")); g_string_append (buffer, "<table border=\"0\" cellspacing=\"5\">"); /* write icons for the categories */ string = g_string_new (NULL); e_cal_component_get_categories_list (comp, &list); if (list != NULL) g_string_append_printf (buffer, "<tr><th>%s</th><td>", _("Categories:")); for (iter = list; iter != NULL; iter = iter->next) { const gchar *category = iter->data; gchar *icon_file; icon_file = e_categories_dup_icon_file_for (category); if (icon_file && g_file_test (icon_file, G_FILE_TEST_EXISTS)) { gchar *uri; uri = g_filename_to_uri (icon_file, NULL, NULL); g_string_append_printf ( buffer, "<img alt=\"%s\" src=\"evo-%s\">", category, uri); g_free (uri); } else { if (iter != list) g_string_append_len (string, ", ", 2); g_string_append (string, category); } g_free (icon_file); } if (string->len > 0) g_string_append_printf (buffer, "%s", string->str); if (list != NULL) g_string_append (buffer, "</td></tr>"); e_cal_component_free_categories_list (list); g_string_free (string, TRUE); /* write location */ e_cal_component_get_location (comp, &location); if (location) g_string_append_printf ( buffer, "<tr><th>%s</th><td>%s</td></tr>", _("Summary:"), text.value); /* write start date */ e_cal_component_get_dtstart (comp, &dt); if (dt.value != NULL) { str = timet_to_str_with_zone (&dt, client, default_zone); g_string_append_printf ( buffer, "<tr><th>%s</th><td>%s</td></tr>", _("Start Date:"), str); g_free (str); } e_cal_component_free_datetime (&dt); /* write end date */ e_cal_component_get_dtend (comp, &dt); if (dt.value != NULL) { str = timet_to_str_with_zone (&dt, client, default_zone); g_string_append_printf ( buffer,"<tr><th>%s</th><td>%s</td></tr>", _("End Date:"), str); g_free (str); } e_cal_component_free_datetime (&dt); /* write Due Date */ e_cal_component_get_due (comp, &dt); if (dt.value != NULL) { str = timet_to_str_with_zone (&dt, client, default_zone); g_string_append_printf ( buffer, "<tr><th>%s</th><td>%s</td></tr>", _("Due Date:"), str); g_free (str); } e_cal_component_free_datetime (&dt); /* write status */ icalcomp = e_cal_component_get_icalcomponent (comp); icalprop = icalcomponent_get_first_property ( icalcomp, ICAL_STATUS_PROPERTY); if (icalprop != NULL) { g_string_append_printf ( buffer, "<tr><th>%s</th>", _("Status:")); e_cal_component_get_status (comp, &status); switch (status) { case ICAL_STATUS_INPROCESS : str = g_strdup (_("In Progress")); break; case ICAL_STATUS_COMPLETED : str = g_strdup (_("Completed")); break; case ICAL_STATUS_CANCELLED : str = g_strdup (_("Cancelled")); break; case ICAL_STATUS_NONE : default : str = g_strdup (_("Not Started")); break; } g_string_append_printf (buffer, "<td>%s</td></tr>", str); g_free (str); } /* write priority */ e_cal_component_get_priority (comp, &priority_value); if (priority_value && *priority_value != 0) { g_string_append_printf ( buffer, "<tr><th>%s</th>", _("Priority:")); if (*priority_value <= 4) str = g_strdup (_("High")); else if (*priority_value == 5) str = g_strdup (_("Normal")); else str = g_strdup (_("Low")); g_string_append_printf (buffer, "<td>%s</td></tr>", str); g_free (str); } if (priority_value) e_cal_component_free_priority (priority_value); /* write description and URL */ g_string_append (buffer, "<tr><td colspan=\"2\"><hr></td></tr>"); e_cal_component_get_description_list (comp, &list); if (list) { GSList *node; g_string_append_printf ( buffer, "<tr><th>%s</th>", _("Description:")); g_string_append (buffer, "<td class=\"description\">"); for (node = list; node != NULL; node = node->next) { gchar *html; text = * (ECalComponentText *) node->data; html = camel_text_to_html ( text.value ? text.value : "", CAMEL_MIME_FILTER_TOHTML_CONVERT_NL | CAMEL_MIME_FILTER_TOHTML_CONVERT_SPACES | CAMEL_MIME_FILTER_TOHTML_CONVERT_URLS | CAMEL_MIME_FILTER_TOHTML_CONVERT_ADDRESSES, 0); if (html) g_string_append_printf (buffer, "%s", html); g_free (html); } g_string_append (buffer, "</td></tr>"); e_cal_component_free_text_list (list); } /* URL */ e_cal_component_get_url (comp, (const gchar **) &str); if (str) { g_string_append_printf ( buffer, "<tr><th>%s</th><td><a href=\"%s\">%s</a></td></tr>", _("Web Page:"), str, str); } g_string_append (buffer, "</table>"); /* close document */ g_string_append (buffer, "</body></html>"); }
static void test_time_zones_sync (gconstpointer user_data) { gboolean retval = FALSE; gint i; GError *error = NULL; UhmServer *local_server; EwsTestData *etd = (gpointer) user_data; EwsCalendarConvertData convert_data; EwsFolderId *calendar_fid = NULL; gboolean includes_last_folder = FALSE; gchar *old_sync_state = NULL; gchar **tokens; GSList *zone_location_errors = NULL; local_server = ews_test_get_mock_server (); ews_test_server_set_trace_directory (local_server, etd->version, "calendar/timezones"); ews_test_server_start_trace (local_server, etd, "get_server_time_zones_sync", &error); if (error != NULL) { g_printerr ("\n%s\n", error->message); goto exit; } while (!includes_last_folder) { GSList *folders_created = NULL; GSList *folders_updated = NULL; GSList *folders_deleted = NULL; GSList *l; gchar *new_sync_state = NULL; gboolean found = FALSE; old_sync_state = new_sync_state; e_ews_connection_sync_folder_hierarchy_sync ( etd->connection, EWS_PRIORITY_MEDIUM, old_sync_state, &new_sync_state, &includes_last_folder, &folders_created, &folders_updated, &folders_deleted, NULL, &error); if (error != NULL) { g_free (old_sync_state); g_printerr ("\n%s\n", error->message); goto exit; } for (l = folders_created; l != NULL; l = l->next) { EEwsFolder *folder = l->data; if (e_ews_folder_get_folder_type (folder) == E_EWS_FOLDER_TYPE_CALENDAR) { const EwsFolderId *fid; fid = e_ews_folder_get_id (folder); calendar_fid = g_new0 (EwsFolderId, 1); calendar_fid->id = g_strdup (fid->id); calendar_fid->change_key = g_strdup (fid->change_key); found = TRUE; break; } } g_slist_free_full (folders_created, g_object_unref); g_slist_free_full (folders_updated, g_object_unref); g_slist_free_full (folders_deleted, g_free); g_free (old_sync_state); old_sync_state = NULL; if (found) { g_free (new_sync_state); break; } } if (!calendar_fid) { g_printerr ("No calendar folder found\n"); goto exit; } convert_data.connection = etd->connection; convert_data.default_zone = icaltimezone_get_utc_timezone (); tokens = g_strsplit (str_comp, "ICAL_TIMEZONE", 0); for (i = 0; i < builtin_timezones->num_elements; i++) { GSList *ll; GSList *ids = NULL; icaltimezone *zone; ECalComponent *comp; const gchar *zone_location; gchar *str; zone = icalarray_element_at (builtin_timezones, i); zone_location = icaltimezone_get_location (zone); if (is_a_known_unknown_timezone (zone_location)) continue; str = g_strdup_printf ("%s%s%s%s%s", tokens[0], zone_location, tokens[1], zone_location, tokens[2]); comp = e_cal_component_new_from_string (str); g_free (str); convert_data.icalcomp = e_cal_component_get_icalcomponent (comp); e_ews_connection_create_items_sync ( etd->connection, EWS_PRIORITY_MEDIUM, "SaveOnly", "SendToNone", calendar_fid, convert_calcomp_to_xml, &convert_data, &ids, NULL, &error); g_object_unref (comp); if (error != NULL) { g_printerr ("\n%s\n", error->message); g_clear_error (&error); zone_location_errors = g_slist_append (zone_location_errors, g_strdup (zone_location)); continue; } for (ll = ids; ll != NULL; ll = ll->next) { EEwsItem *item = ll->data; if (e_ews_item_get_item_type (item) == E_EWS_ITEM_TYPE_ERROR) { const GError *item_error = e_ews_item_get_error (item); g_printerr ("\n%s\n", item_error->message); g_clear_error (&error); zone_location_errors = g_slist_append (zone_location_errors, g_strdup (zone_location)); continue; } } g_slist_free_full (ids, g_object_unref); } retval = zone_location_errors == NULL; exit: if (zone_location_errors != NULL) { GSList *l; g_printerr ("Errors found in: \n"); for (l = zone_location_errors; l != NULL; l = l->next) g_printerr (" - %s\n", (gchar *) l->data); g_slist_free_full (zone_location_errors, g_free); } uhm_server_end_trace (local_server); g_clear_error (&error); g_assert (retval == TRUE); }
static gboolean write_calendar (const gchar *uid, GOutputStream *stream, gint dur_type, gint dur_value, GError **error) { EShell *shell; ESource *source; ESourceRegistry *registry; EClient *client = NULL; GSList *objects = NULL; icaltimezone *utc; time_t start = time (NULL), end; icalcomponent *top_level; gchar *email = NULL; GSList *users = NULL; gulong handler_id; gboolean success = FALSE; utc = icaltimezone_get_utc_timezone (); start = time_day_begin_with_zone (start, utc); switch (dur_type) { case FB_DURATION_DAYS: end = time_add_day_with_zone (start, dur_value, utc); break; default: case FB_DURATION_WEEKS: end = time_add_week_with_zone (start, dur_value, utc); break; case FB_DURATION_MONTHS: end = time_add_month_with_zone (start, dur_value, utc); break; } shell = e_shell_get_default (); registry = e_shell_get_registry (shell); source = e_source_registry_ref_source (registry, uid); if (source != NULL) { EClientCache *client_cache; client_cache = e_shell_get_client_cache (shell); client = e_client_cache_get_client_sync (client_cache, source, E_SOURCE_EXTENSION_CALENDAR, 30, NULL, error); g_object_unref (source); } else { g_set_error ( error, E_CAL_CLIENT_ERROR, E_CAL_CLIENT_ERROR_NO_SUCH_CALENDAR, _("Invalid source UID '%s'"), uid); } if (client == NULL) return FALSE; if (e_client_get_backend_property_sync (client, CAL_BACKEND_PROPERTY_CAL_EMAIL_ADDRESS, &email, NULL, NULL)) { if (email && *email) users = g_slist_append (users, email); } top_level = e_cal_util_new_top_level (); handler_id = g_signal_connect ( client, "free-busy-data", G_CALLBACK (free_busy_data_cb), &objects); success = e_cal_client_get_free_busy_sync ( E_CAL_CLIENT (client), start, end, users, NULL, error); if (handler_id > 0) g_signal_handler_disconnect (client, handler_id); if (success) { gchar *ical_string; GSList *iter; gboolean done = FALSE; /* This is to workaround broken dispatch of "free-busy-data" signal, * introduced in 3.8.0. This code can be removed once the below bug is * properly fixed: https://bugzilla.gnome.org/show_bug.cgi?id=692361 */ while (!done) { g_usleep (G_USEC_PER_SEC / 10); done = !g_main_context_iteration (NULL, FALSE); } for (iter = objects; iter; iter = iter->next) { ECalComponent *comp = iter->data; icalcomponent *icalcomp = icalcomponent_new_clone (e_cal_component_get_icalcomponent (comp)); icalcomponent_add_component (top_level, icalcomp); } ical_string = icalcomponent_as_ical_string_r (top_level); success = g_output_stream_write_all ( stream, ical_string, strlen (ical_string), NULL, NULL, error); e_cal_client_free_ecalcomp_slist (objects); g_free (ical_string); } if (users) g_slist_free (users); g_free (email); g_object_unref (client); icalcomponent_free (top_level); return success; }