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;
}
