static void on_objects_added (ECalClientView *view, GSList *objects, gpointer user_data) { App *app = user_data; GSList *l; print_debug ("%s for calendar", G_STRFUNC); for (l = objects; l != NULL; l = l->next) { icalcomponent *ical = l->data; const char *uid; uid = icalcomponent_get_uid (ical); if (g_hash_table_lookup (app->appointments, uid) == NULL) { /* new appointment we don't know about => changed signal */ invalidate_cache (app); app_schedule_changed (app); } } }
static void memo_shell_content_model_row_changed_cb (EMemoShellContent *memo_shell_content, gint row, ETableModel *model) { ECalModelComponent *comp_data; EMemoTable *memo_table; const gchar *current_uid; const gchar *uid; current_uid = memo_shell_content->priv->current_uid; if (current_uid == NULL) return; comp_data = e_cal_model_get_component_at (E_CAL_MODEL (model), row); if (comp_data == NULL) return; uid = icalcomponent_get_uid (comp_data->icalcomp); if (g_strcmp0 (uid, current_uid) != 0) return; memo_table = e_memo_shell_content_get_memo_table (memo_shell_content); memo_shell_content_cursor_change_cb ( memo_shell_content, 0, E_TABLE (memo_table)); }
void MainWindow::loadFromIcsFile() { char* line; icalcomponent *c; icalparser *parser = icalparser_new(); FILE* stream = fopen("/home/quentin/Public/test.ics", "r"); icalparser_set_gen_data(parser, stream); do { line = icalparser_get_line(parser, read_stream); c = icalparser_add_line(parser, line); if (c != 0) { icalcomponent *inner = icalcomponent_get_first_component(c, ICAL_ANY_COMPONENT); while (inner != NULL) { if (icalcomponent_isa(inner) == ICAL_VTODO_COMPONENT) { const char* name = icalcomponent_get_summary(inner); const char* uid = icalcomponent_get_uid(inner); icalproperty *p = icalcomponent_get_first_property(inner, ICAL_RELATEDTO_PROPERTY); const char* parent = icalproperty_get_relatedto(p); addTask(name, uid, parent); } if (icalcomponent_isa(inner) == ICAL_VEVENT_COMPONENT) { const char* name = icalcomponent_get_summary(inner); const char* uid = icalcomponent_get_uid(inner); icalproperty *p = icalcomponent_get_first_property(inner, ICAL_RELATEDTO_PROPERTY); const char* parent = icalproperty_get_relatedto(p); p = icalcomponent_get_first_property(inner, ICAL_DTSTART_PROPERTY); icaltimetype start = icalproperty_get_dtstart(p); p = icalcomponent_get_first_property(inner, ICAL_DTEND_PROPERTY); icaltimetype end = icalproperty_get_dtend(p); Task* task = findTask(parent); addEvent(task, uid, name, start, end); } inner = icalcomponent_get_next_component(c, ICAL_ANY_COMPONENT); } } } while (line != 0); }
void e_task_shell_view_open_task (ETaskShellView *task_shell_view, ECalModelComponent *comp_data) { EShell *shell; EShellView *shell_view; EShellWindow *shell_window; ESourceRegistry *registry; CompEditor *editor; CompEditorFlags flags = 0; ECalComponent *comp; icalcomponent *clone; icalproperty *prop; const gchar *uid; g_return_if_fail (E_IS_TASK_SHELL_VIEW (task_shell_view)); g_return_if_fail (E_IS_CAL_MODEL_COMPONENT (comp_data)); shell_view = E_SHELL_VIEW (task_shell_view); shell_window = e_shell_view_get_shell_window (shell_view); shell = e_shell_window_get_shell (shell_window); registry = e_shell_get_registry (shell); uid = icalcomponent_get_uid (comp_data->icalcomp); editor = comp_editor_find_instance (uid); if (editor != NULL) goto exit; comp = e_cal_component_new (); clone = icalcomponent_new_clone (comp_data->icalcomp); e_cal_component_set_icalcomponent (comp, clone); prop = icalcomponent_get_first_property ( comp_data->icalcomp, ICAL_ATTENDEE_PROPERTY); if (prop != NULL) flags |= COMP_EDITOR_IS_ASSIGNED; if (itip_organizer_is_user (registry, comp, comp_data->client)) flags |= COMP_EDITOR_USER_ORG; if (!e_cal_component_has_attendees (comp)) flags |= COMP_EDITOR_USER_ORG; editor = task_editor_new (comp_data->client, shell, flags); comp_editor_edit_comp (editor, comp); g_object_unref (comp); if (flags & COMP_EDITOR_IS_ASSIGNED) task_editor_show_assignment (TASK_EDITOR (editor)); exit: gtk_window_present (GTK_WINDOW (editor)); }
static void objects_removed_cb (GObject *object, GList *objects, gpointer data) { GList *l; for (l = objects; l; l = l->next) cl_printf (data, "Object removed %s\n", icalcomponent_get_uid (l->data)); }
static void ecal_objects_changed (ECalView * cview, GList *objects, DatesNavigatorModel * nav) { ECal *ecal = e_cal_view_get_client (cview); GtkListStore * store = GTK_LIST_STORE (gtk_tree_model_filter_get_model ( GTK_TREE_MODEL_FILTER (nav))); for (; objects; objects = objects->next) { const char *uid = icalcomponent_get_uid (objects->data); gchar *uri_uid; GtkTreeIter iter; const gchar * summary; gchar * s = NULL; gchar time[100]; gchar * folded = NULL; if (!uid) continue; uri_uid = g_strconcat (e_cal_get_uri (ecal), uid, NULL); if (!find_item (store, uri_uid, &iter)) gtk_list_store_append (store, &iter); summary = icalcomponent_get_summary (objects->data); if (summary) folded = g_utf8_casefold (summary, -1); /* use only first 15 chars of the summary */ if (summary && g_utf8_strlen (summary, -1) > 15) { s = g_strdup (summary); gchar * p = g_utf8_offset_to_pointer (s, 15); *p = 0; summary = s; } event_time (objects->data, (gchar*)&time, sizeof(time), nav->priv->format); gtk_list_store_set (store, &iter, DN_Name, summary, DN_Time, time, DN_Uid, uri_uid, DN_NameFolded, folded, -1); g_free (uri_uid); g_free (s); g_free (folded); } }
static void objects_modified_cb (GObject *object, const GSList *objects, gpointer data) { GMainLoop *loop = (GMainLoop *) data; const GSList *l; for (l = objects; l; l = l->next) g_print ("Object modified %s (%s)\n", icalcomponent_get_uid (l->data), icalcomponent_get_summary (l->data)); subtest_passed (SUBTEST_OBJECTS_MODIFIED, loop); }
static void memo_shell_content_cursor_change_cb (EMemoShellContent *memo_shell_content, gint row, ETable *table) { ECalComponentPreview *memo_preview; ECalModel *memo_model; ECalModelComponent *comp_data; EPreviewPane *preview_pane; EWebView *web_view; const gchar *uid; memo_model = e_memo_shell_content_get_memo_model (memo_shell_content); preview_pane = e_memo_shell_content_get_preview_pane (memo_shell_content); web_view = e_preview_pane_get_web_view (preview_pane); memo_preview = E_CAL_COMPONENT_PREVIEW (web_view); if (e_table_selected_count (table) != 1) { if (memo_shell_content->priv->preview_visible) e_cal_component_preview_clear (memo_preview); return; } row = e_table_get_cursor_row (table); comp_data = e_cal_model_get_component_at (memo_model, row); if (memo_shell_content->priv->preview_visible) { ECalComponent *comp; comp = e_cal_component_new_from_icalcomponent ( icalcomponent_new_clone (comp_data->icalcomp)); e_cal_component_preview_display ( memo_preview, comp_data->client, comp, e_cal_model_get_timezone (memo_model), e_cal_model_get_use_24_hour_format (memo_model)); g_object_unref (comp); } uid = icalcomponent_get_uid (comp_data->icalcomp); g_free (memo_shell_content->priv->current_uid); memo_shell_content->priv->current_uid = g_strdup (uid); }
static gboolean list_uids (ECal *client) { GList *objects = NULL; GList *l; if (!e_cal_get_object_list (client, "(contains? \"any\" \"test\")", &objects, NULL)) return FALSE; cl_printf (client, "UIDS: "); cl_printf (client, "\nGot %d objects\n", g_list_length (objects)); if (!objects) printf ("none\n"); else { for (l = objects; l; l = l->next) { const gchar *uid; uid = icalcomponent_get_uid (l->data); printf ("`%s' ", uid); } printf ("\n"); for (l = objects; l; l = l->next) { gchar *obj = icalcomponent_as_ical_string_r (l->data); printf ("------------------------------\n"); printf ("%s", obj); printf ("------------------------------\n"); free (obj); } } e_cal_free_object_list (objects); return FALSE; }
static void objects_modified_cb (GObject *object, const GSList *objects, gpointer data) { const GSList *l; GMainLoop *loop = (GMainLoop *) data; for (l = objects; l; l = l->next) { icalcomponent *component = l->data; struct icaltimetype recurrence = icalcomponent_get_recurrenceid (component); struct icaltimetype last_modified = get_last_modified (component); g_print ( "Object modified %s (recurrence id:%s, last-modified:%s)\n", icalcomponent_get_uid (component), icaltime_as_ical_string (recurrence), icaltime_as_ical_string (last_modified)); g_assert (icalcomponent_get_summary (component) == NULL); } subtest_passed (SUBTEST_OBJECTS_MODIFIED, loop); }
/** Sync changes from the server to the cache. * * @param cb 3E calendar backend. * * @return TRUE on success. * * @todo Handle UID/RID. * @todo Better server error handling. * @todo Conflict resolution. */ gboolean e_cal_backend_3e_sync_server_to_cache(ECalBackend3e *cb) { GError *local_err = NULL; gboolean update_sync = TRUE; icalcomponent *ical; icalcomponent *icomp; char filter[128]; struct tm tm; time_t stamp = MAX(e_cal_backend_3e_get_sync_timestamp(cb) - 60 * 60 * 24, 0); /*XXX: always add 1 day padding to prevent timezone problems */ /* prepare query filter string */ gmtime_r(&stamp, &tm); strftime(filter, sizeof(filter), "modified_since('%F %T')", &tm); ical = get_server_objects(cb, filter); if (ical == NULL) { return FALSE; } for (icomp = icalcomponent_get_first_component(ical, ICAL_ANY_COMPONENT); icomp; icomp = icalcomponent_get_next_component(ical, ICAL_ANY_COMPONENT)) { icalcomponent_kind kind = icalcomponent_isa(icomp); icalcomponent_set_cache_state(icomp, E_CAL_COMPONENT_CACHE_STATE_NONE); if (kind == ICAL_VEVENT_COMPONENT) { ECalComponent *comp; const char *uid = icalcomponent_get_uid(icomp); gboolean server_deleted = icalcomponent_3e_status_is_deleted(icomp); ECalComponentCacheState comp_state = E_CAL_COMPONENT_CACHE_STATE_NONE; g_static_rw_lock_reader_lock(&cb->priv->cache_lock); comp = e_cal_backend_cache_get_component(cb->priv->cache, uid, NULL); g_static_rw_lock_reader_unlock(&cb->priv->cache_lock); if (comp) { comp_state = e_cal_component_get_cache_state(comp); } if (server_deleted) { /* deleted by the server */ if (comp && e_cal_component_get_cache_state(comp) != E_CAL_COMPONENT_CACHE_STATE_CREATED && e_cal_component_get_cache_state(comp) != E_CAL_COMPONENT_CACHE_STATE_MODIFIED) { char *object = e_cal_component_get_as_string(comp); ECalComponentId *id = e_cal_component_get_id(comp); g_static_rw_lock_writer_lock(&cb->priv->cache_lock); e_cal_backend_cache_remove_component(cb->priv->cache, uid, NULL); g_static_rw_lock_writer_unlock(&cb->priv->cache_lock); e_cal_backend_notify_object_removed(E_CAL_BACKEND(cb), id, object, NULL); e_cal_component_free_id(id); g_free(object); } } else { char *old_object = NULL; char *object; ECalComponent *new_comp = e_cal_component_new(); e_cal_component_set_icalcomponent(new_comp, icalcomponent_new_clone(icomp)); e_cal_component_set_cache_state(new_comp, E_CAL_COMPONENT_CACHE_STATE_NONE); e_cal_backend_3e_convert_attachment_uris_to_local(cb, new_comp); if (comp) { old_object = e_cal_component_get_as_string(comp); } object = e_cal_component_get_as_string(new_comp); if (old_object == NULL) { if (e_cal_backend_3e_download_attachments(cb, new_comp, &local_err)) { /* not in cache yet */ g_static_rw_lock_writer_lock(&cb->priv->cache_lock); e_cal_backend_cache_put_component(cb->priv->cache, new_comp); g_static_rw_lock_writer_unlock(&cb->priv->cache_lock); e_cal_backend_notify_object_created(E_CAL_BACKEND(cb), object); } else { e_cal_backend_notify_gerror_error(E_CAL_BACKEND(cb), "Can't download attachment.", local_err); g_clear_error(&local_err); update_sync = FALSE; } } else if (strcmp(old_object, object)) { /* what is in cache and what is on server differs */ if (comp_state != E_CAL_COMPONENT_CACHE_STATE_NONE) { /* modified in cache, don't do anything */ } else { if (e_cal_backend_3e_download_attachments(cb, new_comp, &local_err)) { /* sync with server */ g_static_rw_lock_writer_lock(&cb->priv->cache_lock); e_cal_backend_cache_put_component(cb->priv->cache, new_comp); g_static_rw_lock_writer_unlock(&cb->priv->cache_lock); e_cal_backend_notify_object_modified(E_CAL_BACKEND(cb), old_object, object); } else { e_cal_backend_notify_gerror_error(E_CAL_BACKEND(cb), "Can't download attachment.", local_err); g_clear_error(&local_err); update_sync = FALSE; } } } g_free(old_object); g_free(object); g_object_unref(new_comp); } if (comp) { g_object_unref(comp); } } else if (kind == ICAL_VTIMEZONE_COMPONENT) { const char *tzid = icalcomponent_get_tzid(icomp); /* import non-existing timezones from the server */ if (!e_cal_backend_cache_get_timezone(cb->priv->cache, tzid)) { icaltimezone *zone = icaltimezone_new(); icalcomponent *zone_comp = icalcomponent_new_clone(icomp); if (icaltimezone_set_component(zone, zone_comp)) { g_static_rw_lock_writer_lock(&cb->priv->cache_lock); e_cal_backend_cache_put_timezone(cb->priv->cache, zone); g_static_rw_lock_writer_unlock(&cb->priv->cache_lock); } else { icalcomponent_free(zone_comp); } icaltimezone_free(zone, 1); } } else { g_warning("Unsupported component kind (%d) found on the 3e server.", kind); } } if (update_sync) { e_cal_backend_3e_set_sync_timestamp(cb, time(NULL)); } icalcomponent_free(ical); return TRUE; }
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; }
icalerrorenum icalbdbset_commit(icalset *set) { DB *dbp; DBC *dbcp; DBT key, data; icalcomponent *c; char *str = NULL; int ret = 0; int reterr = ICAL_NO_ERROR; char keystore[256]; char uidbuf[256]; char datastore[1024]; char *more_mem = NULL; DB_TXN *tid = NULL; icalbdbset *bset = (icalbdbset *) set; int bad_uid_counter = 0; int retry = 0, done = 0, completed = 0, deadlocked = 0; icalerror_check_arg_re((bset != 0), "bset", ICAL_BADARG_ERROR); dbp = bset->dbp; icalerror_check_arg_re((dbp != 0), "dbp is invalid", ICAL_BADARG_ERROR); if (bset->changed == 0) { return ICAL_NO_ERROR; } memset(&key, 0, sizeof(key)); memset(&data, 0, sizeof(data)); key.flags = DB_DBT_USERMEM; key.data = keystore; key.ulen = (u_int32_t) sizeof(keystore); data.flags = DB_DBT_USERMEM; data.data = datastore; data.ulen = (u_int32_t) sizeof(datastore); if (!ICAL_DB_ENV) { if (icalbdbset_init_dbenv(NULL, NULL) != 0) { return ICAL_INTERNAL_ERROR; } } while ((retry < MAX_RETRY) && !done) { if ((ret = ICAL_DB_ENV->txn_begin(ICAL_DB_ENV, NULL, &tid, 0)) != 0) { if (ret == DB_LOCK_DEADLOCK) { retry++; continue; } else if (ret == DB_RUNRECOVERY) { ICAL_DB_ENV->err(ICAL_DB_ENV, ret, "icalbdbset_commit: txn_begin failed"); abort(); } else { ICAL_DB_ENV->err(ICAL_DB_ENV, ret, "icalbdbset_commit"); return ICAL_INTERNAL_ERROR; } } /* first delete everything in the database, because there could be removed components */ if ((ret = dbp->cursor(dbp, tid, &dbcp, DB_DIRTY_READ)) != 0) { tid->abort(tid); if (ret == DB_LOCK_DEADLOCK) { retry++; continue; } else if (ret == DB_RUNRECOVERY) { ICAL_DB_ENV->err(ICAL_DB_ENV, ret, "curor failed"); abort(); } else { ICAL_DB_ENV->err(ICAL_DB_ENV, ret, "curor failed"); /* leave bset->changed set to true */ return ICAL_INTERNAL_ERROR; } } /* fetch the key/data pair, then delete it */ completed = 0; while (!completed && !deadlocked) { ret = dbcp->c_get(dbcp, &key, &data, DB_NEXT); if (ret == DB_NOTFOUND) { completed = 1; } else if (ret == ENOMEM) { if (more_mem) { free(more_mem); } more_mem = malloc(data.ulen + 1024); data.data = more_mem; data.ulen = data.ulen + 1024; } else if (ret == DB_LOCK_DEADLOCK) { deadlocked = 1; } else if (ret == DB_RUNRECOVERY) { tid->abort(tid); ICAL_DB_ENV->err(ICAL_DB_ENV, ret, "c_get failed."); abort(); } else if (ret == 0) { if ((ret = dbcp->c_del(dbcp, 0)) != 0) { dbp->err(dbp, ret, "cursor"); if (ret == DB_KEYEMPTY) { /* never actually created, continue onward.. */ /* do nothing - break; */ } else if (ret == DB_LOCK_DEADLOCK) { deadlocked = 1; } else { /*char *foo = db_strerror(ret); */ abort(); } } } else { /* some other non-fatal error */ dbcp->c_close(dbcp); tid->abort(tid); if (more_mem) { free(more_mem); more_mem = NULL; } return ICAL_INTERNAL_ERROR; } } if (more_mem) { free(more_mem); more_mem = NULL; } if (deadlocked) { dbcp->c_close(dbcp); tid->abort(tid); retry++; continue; /* next retry */ } deadlocked = 0; for (c = icalcomponent_get_first_component(bset->cluster, ICAL_ANY_COMPONENT); c != 0 && !deadlocked; c = icalcomponent_get_next_component(bset->cluster, ICAL_ANY_COMPONENT)) { memset(&key, 0, sizeof(key)); memset(&data, 0, sizeof(data)); /* Note that we're always inserting into a primary index. */ if (icalcomponent_isa(c) != ICAL_VAGENDA_COMPONENT) { char *uidstr = (char *)icalcomponent_get_uid(c); if (!uidstr) { /* this shouldn't happen */ /* no uid string, we need to add one */ snprintf(uidbuf, 256, "baduid%d-%d", getpid(), bad_uid_counter++); key.data = uidbuf; } else { key.data = uidstr; } } else { char *relcalid = NULL; relcalid = (char *)icalcomponent_get_relcalid(c); if (relcalid == NULL) { snprintf(uidbuf, 256, "baduid%d-%d", getpid(), bad_uid_counter++); key.data = uidbuf; } else { key.data = relcalid; } } key.size = (u_int32_t) strlen(key.data); str = icalcomponent_as_ical_string_r(c); data.data = str; data.size = (u_int32_t) strlen(str); if ((ret = dbcp->c_put(dbcp, &key, &data, DB_KEYLAST)) != 0) { if (ret == DB_LOCK_DEADLOCK) { deadlocked = 1; } else if (ret == DB_RUNRECOVERY) { ICAL_DB_ENV->err(ICAL_DB_ENV, ret, "c_put failed."); abort(); } else { ICAL_DB_ENV->err(ICAL_DB_ENV, ret, "c_put failed %s.", str); /* continue to try to put as many icalcomponent as possible */ reterr = ICAL_INTERNAL_ERROR; } } } if (str) { free(str); } if (deadlocked) { dbcp->c_close(dbcp); tid->abort(tid); retry++; continue; } if ((ret = dbcp->c_close(dbcp)) != 0) { tid->abort(tid); if (ret == DB_LOCK_DEADLOCK) { retry++; continue; } else if (ret == DB_RUNRECOVERY) { ICAL_DB_ENV->err(ICAL_DB_ENV, ret, "c_closed failed."); abort(); } else { ICAL_DB_ENV->err(ICAL_DB_ENV, ret, "c_closed failed."); reterr = ICAL_INTERNAL_ERROR; } } if ((ret = tid->commit(tid, 0)) != 0) { tid->abort(tid); if (ret == DB_LOCK_DEADLOCK) { retry++; continue; } else if (ret == DB_RUNRECOVERY) { ICAL_DB_ENV->err(ICAL_DB_ENV, ret, "commit failed."); abort(); } else { ICAL_DB_ENV->err(ICAL_DB_ENV, ret, "commit failed."); reterr = ICAL_INTERNAL_ERROR; } } done = 1; } bset->changed = 0; return reterr; }
static char * get_ical_uid (icalcomponent *ical) { return g_strdup (icalcomponent_get_uid (ical)); }
void e_task_shell_view_delete_completed (ETaskShellView *task_shell_view) { ETaskShellContent *task_shell_content; ECalModel *model; GList *list, *link; const gchar *sexp; g_return_if_fail (E_IS_TASK_SHELL_VIEW (task_shell_view)); sexp = "(is-completed?)"; task_shell_content = task_shell_view->priv->task_shell_content; model = e_task_shell_content_get_task_model (task_shell_content); e_task_shell_view_set_status_message ( task_shell_view, _("Expunging"), -1.0); list = e_cal_model_list_clients (model); for (link = list; link != NULL; link = g_list_next (link)) { ECalClient *client = E_CAL_CLIENT (link->data); GSList *objects, *obj; GError *error = NULL; if (e_client_is_readonly (E_CLIENT (client))) continue; e_cal_client_get_object_list_sync ( client, sexp, &objects, NULL, &error); if (error != NULL) { g_warning ( "%s: Failed to get object list: %s", G_STRFUNC, error->message); g_clear_error (&error); continue; } for (obj = objects; obj != NULL; obj = obj->next) { icalcomponent *component = obj->data; const gchar *uid; uid = icalcomponent_get_uid (component); e_cal_client_remove_object_sync ( client, uid, NULL, CALOBJ_MOD_THIS, NULL, &error); if (error != NULL) { g_warning ( "%s: Failed to remove object: %s", G_STRFUNC, error->message); g_clear_error (&error); } } e_cal_client_free_icalcomp_slist (objects); } g_list_free_full (list, (GDestroyNotify) g_object_unref); e_task_shell_view_set_status_message (task_shell_view, NULL, -1.0); }
static void process_meeting (ECalendarView *cal_view, icalparameter_partstat status) { GList *selected; icalcomponent *clone; selected = e_calendar_view_get_selected_events (cal_view); if (selected) { ECalendarViewEvent *event = (ECalendarViewEvent *) selected->data; ECalComponent *comp = e_cal_component_new (); ReceiveData *r_data = g_new0 (ReceiveData, 1); gboolean recurring = FALSE; GThread *thread = NULL; GError *error = NULL; char *address = NULL; e_cal_component_set_icalcomponent (comp, icalcomponent_new_clone (event->comp_data->icalcomp)); address = itip_get_comp_attendee (comp, event->comp_data->client); if (e_cal_component_has_recurrences (comp) || e_cal_component_is_instance (comp)) recurring = TRUE; /* Free comp */ g_object_unref (comp); comp = NULL; clone = icalcomponent_new_clone (event->comp_data->icalcomp); change_status (clone, address, status); r_data->ecal = g_object_ref (event->comp_data->client); r_data->icalcomp = clone; if (recurring) { gint response; const char *arg; if (status == ICAL_PARTSTAT_ACCEPTED || status == ICAL_PARTSTAT_TENTATIVE) arg = "accept"; else arg = "decline"; response = e_error_run (NULL, "org.gnome.evolution.mail_shared_folder:recurrence", arg, NULL); if (response == GTK_RESPONSE_YES) { icalproperty *prop; const char *uid = icalcomponent_get_uid (r_data->icalcomp); prop = icalproperty_new_x ("All"); icalproperty_set_x_name (prop, "X-GW-RECUR-INSTANCES-MOD-TYPE"); icalcomponent_add_property (r_data->icalcomp, prop); prop = icalproperty_new_x (uid); icalproperty_set_x_name (prop, "X-GW-RECURRENCE-KEY"); icalcomponent_add_property (r_data->icalcomp, prop); } else if (response == GTK_RESPONSE_CANCEL) { finalize_receive_data (r_data); return; } } thread = g_thread_create ((GThreadFunc) receive_objects, r_data , FALSE, &error); if (!thread) { g_warning (G_STRLOC ": %s", error->message); g_error_free (error); } } }
void test_classify(void) { icalcomponent *c, *match; int i = 0; int error_count = 0; /* Open up the two storage files, one for the incomming components, one for the calendar */ icalfileset_options options = { O_RDONLY, 0644, 0, NULL }; icalset *incoming = icalset_new(ICAL_FILE_SET, TEST_DATADIR "/incoming.ics", &options); icalset *cal = icalset_new(ICAL_FILE_SET, TEST_DATADIR "/calendar.ics", &options); icalset *f = icalset_new(ICAL_FILE_SET, TEST_DATADIR "/classify.ics", &options); ok("opening file classify.ics", (f != 0)); ok("opening file calendar.ics", (cal != 0)); ok("opening file incoming.ics", (incoming != 0)); /* some basic tests.. */ if (f) { c = icalset_get_first_component(f); match = icalset_get_next_component(f); ok("test two vcalendars for SEQUENCE with icalclassify()", (icalclassify(c, match, "*****@*****.**") == ICAL_XLICCLASS_REQUESTRESCHEDULE)); icalset_free(f); } assert(incoming != 0); assert(cal != 0); /* Iterate through all of the incoming components */ for (c = icalset_get_first_component(incoming); c != 0; c = icalset_get_next_component(incoming)) { icalproperty_xlicclass class; icalcomponent *match = 0; const char *this_uid; const char *this_note = get_note(c); const char *expected_result = get_expect(c); const char *actual_result; char msg[128]; i++; /* Check this component against the restrictions imposed by iTIP. An errors will be inserted as X-LIC-ERROR properties in the component. The Parser will also insert errors if it cannot parse the component */ icalcomponent_check_restrictions(c); /* If there are any errors, print out the component */ error_count = icalcomponent_count_errors(c); snprintf(msg, sizeof(msg), "%s - parsing", this_note); int_is(msg, error_count, 0); if (error_count != 0) { if (VERBOSE) { printf("----- Component has errors ------- \n%s-----------------\n", icalcomponent_as_ical_string(c)); } } /* Use one of the icalcomponent convenience routines to get the UID. This routine will save you from having to use icalcomponent_get_inner(), icalcomponent_get_first_property(), checking the return value, and then calling icalproperty_get_uid. There are several other convenience routines for DTSTART, DTEND, DURATION, SUMMARY, METHOD, and COMMENT */ this_uid = icalcomponent_get_uid(c); if (this_uid != 0) { /* Look in the calendar for a component with the same UID as the incomming component. We should reall also be checking the RECURRENCE-ID. Another way to do this operation is to us icalset_find_match(), which does use the RECURRENCE-ID. */ match = icalset_fetch(cal, this_uid); } /* Classify the incoming component. The third argument is the calid of the user who owns the calendar. In a real program, you would probably switch() on the class. */ class = icalclassify(c, match, "*****@*****.**"); /** eventually test this too.. **/ (void)get_note(match); actual_result = icalproperty_enum_to_string(class); snprintf(msg, sizeof(msg), "expecting %s", expected_result); str_is(msg, expected_result, actual_result); if (VERBOSE) { printf("Test %d\n" "Incoming: %s\n" "Matched: %s\n" "Classification: %s\n\n", i, this_note, get_note(match), icalproperty_enum_to_string(class)); } } icalset_free(incoming); icalset_free(cal); }