static void test_get_view_sync (ETestServerFixture *fixture, gconstpointer user_data) { EBookClient *book_client; EBookQuery *query; EBookClientView *view; gchar *sexp; GError *error = NULL; UIDOnlyClosure *closure = (UIDOnlyClosure *) user_data; uids_only = closure->uids_only; book_client = E_TEST_SERVER_UTILS_SERVICE (fixture, EBookClient); setup_book (book_client); query = e_book_query_any_field_contains (""); sexp = e_book_query_to_string (query); e_book_query_unref (query); if (!e_book_client_get_view_sync (book_client, sexp, &view, NULL, &error)) { g_error ("get book view sync: %s", error->message); g_free (sexp); g_object_unref (book_client); } g_free (sexp); setup_and_start_view (view, fixture->loop); g_main_loop_run (fixture->loop); }
static void print_all_emails (EBook *book) { EBookQuery *query; gboolean status; GList *cards, *c; query = e_book_query_field_exists (E_CONTACT_FULL_NAME); status = e_book_get_contacts (book, query, &cards, NULL); e_book_query_unref (query); if (status == FALSE) { printf ("error %d getting card list\n", status); exit (0); } for (c = cards; c; c = c->next) { EContact *contact = E_CONTACT (c->data); print_email (contact); g_object_unref (contact); } g_list_free (cards); }
void *phonebook_create_cache(const char *name, phonebook_entry_cb entry_cb, phonebook_cache_ready_cb ready_cb, void *user_data, int *err) { struct query_context *data; EBookQuery *query; gboolean ret; if (g_strcmp0("/telecom/pb", name) != 0) { if (err) *err = -ENOENT; return NULL; } query = e_book_query_any_field_contains(""); data = g_new0(struct query_context, 1); data->entry_cb = entry_cb; data->ready_cb = ready_cb; data->user_data = user_data; ret = e_book_async_get_contacts(ebook, query, cache_cb, data); e_book_query_unref(query); if (ret != FALSE) { g_free(data); if (err) *err = -EFAULT; return NULL; } if (err) *err = 0; return data; }
gint main (gint argc, gchar **argv) { EBookClient *book_client; const gchar *query_string; EBookQuery *query; gchar *sexp; GSList *c, *contacts; GError *error = NULL; main_initialize (); if (argc != 2) { query_string = "contains \"full_name\" \"a\""; printf ("usage: test-search <query>\n"); printf (" using default query \"%s\"\n", query_string); } else { query_string = argv[1]; } query = e_book_query_from_string (query_string); if (!query) { fprintf (stderr, " * Failed to parse query string '%s'\n", query_string); return 1; } sexp = e_book_query_to_string (query); e_book_query_unref (query); book_client = open_system_book (FALSE); if (!book_client) { g_free (sexp); return 1; } if (!e_book_client_get_contacts_sync (book_client, sexp, &contacts, NULL, &error)) { report_error ("get contacts sync", &error); g_free (sexp); g_object_unref (book_client); return 1; } for (c = contacts; c; c = c->next) { EContact *contact = E_CONTACT (c->data); gchar *vcard = e_vcard_to_string (E_VCARD (contact), EVC_FORMAT_VCARD_30); printf ("%s\n\n", vcard); g_free (vcard); } g_slist_foreach (contacts, (GFunc) g_object_unref, NULL); g_slist_free (contacts); g_free (sexp); g_object_unref (book_client); return 0; }
static void moko_contacts_init (MokoContacts *contacts) { MokoContactsPrivate *priv; EBook *book; EBookView *view; EBookQuery *query; GList *contact, *c; priv = contacts->priv = MOKO_CONTACTS_GET_PRIVATE (contacts); priv->contacts = NULL; priv->entries = NULL; priv->start = NULL; priv->prefixes = g_hash_table_new ((GHashFunc)g_str_hash, (GEqualFunc)g_str_equal); priv->uids = g_hash_table_new ((GHashFunc)g_str_hash, (GEqualFunc)g_str_equal); query = e_book_query_any_field_contains (""); /* Open the system book and check that it is valid */ book = priv->book = e_book_new_system_addressbook (NULL); if (!book) { g_warning ("Failed to create system book\n"); return; } if (!e_book_open (book, FALSE, NULL)) { g_warning ("Failed to open system book\n"); return; } if (!e_book_get_contacts (book, query, &contact, NULL)) { g_warning ("Failed to get contacts from system book\n"); return; } /* Go through the contacts, creating the contact structs, and entry structs*/ for (c = contact; c != NULL; c = c->next) { moko_contacts_add_contact (contacts, E_CONTACT (c->data)); } /* Connect to the ebookviews signals */ if (e_book_get_book_view (book, query, NULL, 0, &view, NULL)) { g_signal_connect (G_OBJECT (view), "contacts-added", G_CALLBACK (on_ebook_contacts_added), (gpointer)contacts); g_signal_connect (G_OBJECT (view), "contacts-changed", G_CALLBACK (on_ebook_contacts_changed), (gpointer)contacts); g_signal_connect (G_OBJECT (view), "contacts-removed", G_CALLBACK (on_ebook_contacts_removed), (gpointer)contacts); e_book_view_start (view); } e_book_query_unref(query); }
static void test_photo_is_uri (ETestServerFixture *fixture, gconstpointer user_data) { EBookClient *book_client; EBookClientView *view; EBookQuery *query; GError *error = NULL; gchar *sexp; book_client = E_TEST_SERVER_UTILS_SERVICE (fixture, EBookClient); add_contact_inline (book_client); add_contact_uri (book_client); query = e_book_query_any_field_contains (""); sexp = e_book_query_to_string (query); e_book_query_unref (query); if (!e_book_client_get_view_sync (book_client, sexp, &view, NULL, &error)) g_error ("get book view sync: %s", error->message); g_free (sexp); setup_and_start_view (view); loop = fixture->loop; g_main_loop_run (loop); }
gint main (gint argc, gchar **argv) { #if 0 /* ACCOUNT_MGMT */ EBook *book; gboolean status; EBookQuery *query; EBookView *view = NULL; EBookView *new_view; gint i; g_type_init (); /* ** the actual ebook foo */ printf ("loading addressbook\n"); book = e_book_new_system_addressbook (NULL); if (!book) { printf ("failed to create ebook\n"); exit (0); } status = e_book_open (book, FALSE, NULL); if (status == FALSE) { printf ("failed to open local addressbook\n"); exit (0); } query = e_book_query_any_field_contains (""); for (i = 0; i < 500; i++) { status = e_book_get_book_view (book, query, NULL, -1, &new_view, NULL); g_signal_connect (new_view, "contacts_added", G_CALLBACK (contacts_added), NULL); g_signal_connect (new_view, "contacts_removed", G_CALLBACK (contacts_removed), NULL); g_signal_connect (new_view, "view_complete", G_CALLBACK (view_complete), NULL); e_book_view_start (new_view); if (view) { e_book_view_stop (view); g_object_unref (view); } view = new_view; } e_book_view_stop (view); g_object_unref (view); e_book_query_unref (query); g_object_unref (book); #endif /* ACCOUNT_MGMT */ return 0; }
static void eds_receive_book_cb (EBook *client, EBookStatus status, gpointer user_data) { PlannerPlugin *plugin; EBookQuery *query; AsyncQuery *async_query; const gchar *search; const gchar *uid; const gchar *book_uri; GtkListStore *model; async_query = user_data; plugin = async_query->plugin; search = async_query->search; uid = async_query->uid; model = GTK_LIST_STORE (plugin->priv->resources_model); gtk_list_store_clear (model); g_free (async_query); book_uri = e_book_get_uri (client); if (eds_query_cancelled (plugin, uid)) { g_message ("Open book query cancelled: %s (%s)", book_uri, uid); gtk_widget_set_sensitive (glade_xml_get_widget (plugin->priv->glade, "search_box"), TRUE); eds_plugin_busy (plugin, FALSE); return; } if (status != E_BOOK_ERROR_OK) { g_warning ("Problems opening: %s", book_uri); gtk_widget_set_sensitive (glade_xml_get_widget (plugin->priv->glade, "search_box"), TRUE); eds_plugin_busy (plugin, FALSE); return; } g_message ("Looking the book: %s", book_uri); plugin->priv->books = g_list_append (plugin->priv->books, client); async_query = g_new0 (AsyncQuery, 1); g_free (plugin->priv->current_query_id); plugin->priv->current_query_id = e_uid_new (); async_query->uid = plugin->priv->current_query_id; async_query->plugin = plugin; query = e_book_query_any_field_contains (search); e_book_async_get_contacts (client, query, eds_receive_contacts_cb, (gpointer) async_query); eds_plugin_busy (plugin, TRUE); e_book_query_unref (query); }
/* retrieve a list of contacts from the address book */ static int addrbook_libebook_retrieve(ship_list_t *list) { int ret = -1; contact_t *ct = 0; GError *error = 0; GList *contacts = 0, *loop; EBookQuery *query = 0; ship_lock(addrbook_lock); ASSERT_TRUE(query = e_book_query_any_field_contains(""), err); ASSERT_TRUE(e_book_get_contacts(book, query, &contacts, &error), err); ASSERT_ZERO(error, err); for (loop = contacts; loop; loop = g_list_next(loop)) { EContact *c = loop->data; char *name = 0; name = e_contact_get(c, E_CONTACT_OSSO_CONTACT_STATE); if (!name || strcmp(name, "DELETED")) { char **arrs = 0; ASSERT_TRUE(ct = ident_contact_new(), cerr); ASSERT_TRUE(ct->name = e_contact_get(c, E_CONTACT_FULL_NAME), cerr); ASSERT_TRUE(arrs = e_contact_get(c, E_CONTACT_SIP), cerr); ASSERT_TRUE(ct->sip_aor = addrbook_normalize_aor(arrs[0]), cerr); /* apparently arrs doesn't need to be free'd afterwards */ g_list_foreach((GList*)arrs, (GFunc)g_free, NULL); ship_list_add(list, ct); ct = 0; cerr: ident_contact_free(ct); } if (name) g_free(name); } ret = 0; err: if (contacts) { g_list_free(contacts); } if (query) { e_book_query_unref(query); } if (error) { LOG_ERROR("Error getting contacts: %s\n", error->message); g_error_free(error); } ship_unlock(addrbook_lock); return ret; }
gint main (gint argc, gchar **argv) { EBook *book; EBookQuery *query; EBookView *view; g_type_init (); /* * Sync version */ setup_book (&book); query = e_book_query_any_field_contains (""); ebook_test_utils_book_get_book_view (book, query, &view); setup_and_start_view (view); test_print ("successfully set up the book view\n"); loop = g_main_loop_new (NULL, TRUE); g_main_loop_run (loop); e_book_query_unref (query); ebook_test_utils_book_remove (book); /* * Async version */ setup_book (&book); query = e_book_query_any_field_contains (""); loop = g_main_loop_new (NULL, TRUE); ebook_test_utils_book_async_get_book_view (book, query, (GSourceFunc) get_book_view_cb, loop); g_main_loop_run (loop); e_book_query_unref (query); ebook_test_utils_book_remove (book); return 0; }
static void print_all_emails (EBook *book) { EBookQuery *query; query = e_book_query_field_exists (E_CONTACT_FULL_NAME); e_book_get_contacts_async (book, query, print_all_emails_cb, NULL); e_book_query_unref (query); }
static gboolean test_bulk_add_remove (EBookClient *client, const gchar *vcard_str, gint batch_size) { gint i; GSList *contacts = NULL; GSList *added_uids = NULL; GSList *book_uids = NULL; EBookQuery *query = NULL; gchar *sexp = NULL; const GSList *l; query = e_book_query_any_field_contains (""); sexp = e_book_query_to_string (query); e_book_query_unref (query); for (i = 0; i < batch_size; ++i) { EContact *contact = e_contact_new_from_vcard (vcard_str); contacts = g_slist_append (contacts, contact); } g_print (" * Bulk addition of %d contacts...\n", batch_size); /* Bulk addition */ g_return_val_if_fail (e_book_client_add_contacts_sync (client, contacts, &added_uids, NULL, NULL), FALSE); g_return_val_if_fail (added_uids != NULL, FALSE); g_return_val_if_fail (added_uids->data != NULL, FALSE); g_return_val_if_fail (g_slist_length (added_uids) == batch_size, FALSE); /* Make sure the uids are in the address book */ g_return_val_if_fail (e_book_client_get_contacts_uids_sync (client, sexp, &book_uids, NULL, NULL), FALSE); for (l = added_uids; l != NULL; l = l->next) { g_return_val_if_fail (check_string_in_slist (book_uids, (const gchar *) l->data), FALSE); } g_slist_free_full (book_uids, g_free); g_print (" * Bulk removal of %d contacts...\n", batch_size); /* Bulk removal */ g_return_val_if_fail (e_book_client_remove_contacts_sync (client, added_uids, NULL, NULL), FALSE); /* Make sure the uids are no longer in the address book */ book_uids = NULL; g_return_val_if_fail (e_book_client_get_contacts_uids_sync (client, sexp, &book_uids, NULL, NULL), FALSE); for (l = added_uids; l != NULL; l = l->next) { g_return_val_if_fail (!check_string_in_slist (book_uids, (const gchar *) l->data), FALSE); } g_slist_free_full (book_uids, g_free); g_free (sexp); g_slist_free_full (added_uids, g_free); g_slist_free_full (contacts, g_object_unref); return TRUE; }
static void free_query_context(struct query_context *data) { g_free(data->id); if (data->buf != NULL) g_string_free(data->buf, TRUE); if (data->query != NULL) e_book_query_unref(data->query); close_ebooks(data->ebooks); g_free(data); }
int phonebook_pull_read(void *request) { struct query_context *data = request; EBookQuery *query; if (!data) return -ENOENT; query = e_book_query_any_field_contains(""); e_book_async_get_contacts(ebook, query, ebookpull_cb, data); e_book_query_unref(query); return 0; }
gint main (gint argc, gchar **argv) { EBookClient *book; EBookClientView *view; EBookQuery *query; GError *error = NULL; gchar *sexp; g_type_init (); setup_book (&book); query = e_book_query_any_field_contains (""); sexp = e_book_query_to_string (query); e_book_query_unref (query); if (!e_book_client_get_view_sync (book, sexp, &view, NULL, &error)) { report_error ("get book view sync", &error); g_free (sexp); g_object_unref (book); return 1; } g_free (sexp); setup_and_start_view (view); loop = g_main_loop_new (NULL, TRUE); g_main_loop_run (loop); if (!e_client_remove_sync (E_CLIENT (book), NULL, &error)) { report_error ("client remove sync", &error); g_object_unref (book); return 1; } g_object_unref (book); return 0; }
static gpointer call_get_view (gpointer user_data) { EBookQuery *query; EBookClient *book_client = user_data; gchar *sexp; g_return_val_if_fail (book_client != NULL, NULL); g_return_val_if_fail (E_IS_BOOK_CLIENT (book_client), NULL); query = e_book_query_any_field_contains (""); sexp = e_book_query_to_string (query); e_book_query_unref (query); e_book_client_get_view (book_client, sexp, NULL, get_view_cb, NULL); g_free (sexp); return NULL; }
static void test_get_view_async (ETestServerFixture *fixture, gconstpointer user_data) { EBookClient *book_client; EBookQuery *query; gchar *sexp; book_client = E_TEST_SERVER_UTILS_SERVICE (fixture, EBookClient); setup_book (book_client); query = e_book_query_any_field_contains (""); sexp = e_book_query_to_string (query); e_book_query_unref (query); e_book_client_get_view (book_client, sexp, NULL, get_view_cb, fixture->loop); g_free (sexp); g_main_loop_run (fixture->loop); }
static void test_get_book_view_async (ETestServerFixture *fixture, gconstpointer user_data) { EBook *book; EBookQuery *query; book = E_TEST_SERVER_UTILS_SERVICE (fixture, EBook); setup_book (book); query = e_book_query_any_field_contains (""); ebook_test_utils_book_async_get_book_view ( book, query, (GSourceFunc) get_book_view_cb, fixture->loop); g_timeout_add_seconds (5, (GSourceFunc) main_loop_fail_timeout, NULL); g_main_loop_run (fixture->loop); e_book_query_unref (query); }
static void test_get_book_view_sync (ETestServerFixture *fixture, gconstpointer user_data) { EBook *book; EBookQuery *query; EBookView *view; book = E_TEST_SERVER_UTILS_SERVICE (fixture, EBook); setup_book (book); query = e_book_query_any_field_contains (""); ebook_test_utils_book_get_book_view (book, query, &view); setup_and_start_view (view, fixture->loop); test_print ("successfully set up the book view\n"); g_main_loop_run (fixture->loop); e_book_query_unref (query); }
static void on_query_button_clicked (GtkButton *button, GtkEntry *entry) { const char *s; EBookQuery *query; g_return_if_fail (GTK_ENTRY (entry)); s = gtk_entry_get_text (entry); if (s[0] == '\0') { query = e_book_query_any_field_contains (""); } else { query = e_book_query_from_string (s); } if (!query) { /* TODO: display error dialog */ return; } eds_contact_view_show_query (EDS_CONTACT_VIEW (query_view), query); e_book_query_unref (query); }
/* Pilot syncing callbacks */ static gint pre_sync (GnomePilotConduit *conduit, GnomePilotDBInfo *dbi, EAddrConduitContext *ctxt) { GnomePilotConduitSyncAbs *abs_conduit; EBookQuery *query; GList *l; int len; char *filename; char *change_id; char *auth; gint num_records, add_records = 0, mod_records = 0, del_records = 0; #ifdef PILOT_LINK_0_12 pi_buffer_t *buffer; #else unsigned char *buf; #endif abs_conduit = GNOME_PILOT_CONDUIT_SYNC_ABS (conduit); LOG (g_message ( "---------------------------------------------------------\n" )); LOG (g_message ( "pre_sync: Addressbook Conduit v.%s", CONDUIT_VERSION )); /* g_message ("Addressbook Conduit v.%s", CONDUIT_VERSION); */ ctxt->dbi = dbi; if (ctxt->cfg->source) { ctxt->ebook = e_book_new (ctxt->cfg->source, NULL); } else { ctxt->ebook = e_book_new_default_addressbook (NULL); } auth = (gchar *)e_source_get_property (ctxt->cfg->source, "auth"); if (auth) { LOG (g_message ("contacts needs authentication\n")); g_signal_connect (ctxt->ebook, "auth_required", G_CALLBACK (addressbook_authenticate), ctxt->cfg->source); } if (!ctxt->ebook || !e_book_open (ctxt->ebook, TRUE, NULL)) { WARN(_("Could not load addressbook")); gnome_pilot_conduit_error (conduit, _("Could not load addressbook")); return -1; } /* Load the uid <--> pilot id mappings */ filename = map_name (ctxt); e_pilot_map_read (filename, &ctxt->map); g_free (filename); /* Get a list of all contacts */ if (!(query = e_book_query_any_field_contains (""))) { LOG (g_warning ("Failed to get EBookQuery")); return -1; } if (!e_book_get_contacts (ctxt->ebook, query, &ctxt->cards, NULL)) { LOG (g_warning ("Failed to get Contacts")); e_book_query_unref (query); return -1; } e_book_query_unref (query); /* Count and hash the changes */ change_id = g_strdup_printf ("pilot-sync-evolution-addressbook-%d", ctxt->cfg->pilot_id); if (!e_book_get_changes (ctxt->ebook, change_id, &ctxt->changed, NULL)) return -1; ctxt->changed_hash = g_hash_table_new (g_str_hash, g_str_equal); g_free (change_id); for (l = ctxt->changed; l != NULL; l = l->next) { EBookChange *ebc = l->data; const char *uid; uid = e_contact_get_const (ebc->contact, E_CONTACT_UID); if (!e_pilot_map_uid_is_archived (ctxt->map, uid)) { g_hash_table_insert (ctxt->changed_hash, g_strdup (uid), ebc); switch (ebc->change_type) { case E_BOOK_CHANGE_CARD_ADDED: add_records++; break; case E_BOOK_CHANGE_CARD_MODIFIED: mod_records++; break; case E_BOOK_CHANGE_CARD_DELETED: del_records++; break; } } else if (ebc->change_type == E_BOOK_CHANGE_CARD_DELETED) { e_pilot_map_remove_by_uid (ctxt->map, uid); } } /* Set the count information */ num_records = g_list_length (ctxt->cards); gnome_pilot_conduit_sync_abs_set_num_local_records(abs_conduit, num_records); gnome_pilot_conduit_sync_abs_set_num_new_local_records (abs_conduit, add_records); gnome_pilot_conduit_sync_abs_set_num_updated_local_records (abs_conduit, mod_records); gnome_pilot_conduit_sync_abs_set_num_deleted_local_records(abs_conduit, del_records); #ifdef PILOT_LINK_0_12 buffer = pi_buffer_new(DLP_BUF_SIZE); if(buffer == NULL){ return pi_set_error(dbi->pilot_socket, PI_ERR_GENERIC_MEMORY); } len = dlp_ReadAppBlock (dbi->pilot_socket, dbi->db_handle, 0, DLP_BUF_SIZE, buffer); #else buf = (unsigned char*)g_malloc (0xffff); len = dlp_ReadAppBlock (dbi->pilot_socket, dbi->db_handle, 0, (unsigned char *)buf, 0xffff); #endif if (len < 0) { WARN (_("Could not read pilot's Address application block")); WARN ("dlp_ReadAppBlock(...) = %d", len); gnome_pilot_conduit_error (conduit, _("Could not read pilot's Address application block")); return -1; } #ifdef PILOT_LINK_0_12 unpack_AddressAppInfo (&(ctxt->ai), buffer->data, len); pi_buffer_free (buffer); #else unpack_AddressAppInfo (&(ctxt->ai), buf, len); g_free (buf); #endif check_for_slow_setting (conduit, ctxt); if (ctxt->cfg->sync_type == GnomePilotConduitSyncTypeCopyToPilot || ctxt->cfg->sync_type == GnomePilotConduitSyncTypeCopyFromPilot) ctxt->map->write_touched_only = TRUE; return 0; }
static void populate_treeview(GevoAddBuddyDialog *dialog, const gchar *uri) { EBookQuery *query; EBook *book; gboolean status; GList *cards, *c; GError *err = NULL; if (dialog->book != NULL) { g_object_unref(dialog->book); dialog->book = NULL; } if (dialog->contacts != NULL) { g_list_foreach(dialog->contacts, (GFunc)g_object_unref, NULL); g_list_free(dialog->contacts); dialog->contacts = NULL; } gtk_list_store_clear(dialog->model); if (!gevo_load_addressbook(uri, &book, &err)) { purple_debug_error("evolution", "Error retrieving default addressbook: %s\n", err->message); g_error_free(err); return; } query = e_book_query_field_exists(E_CONTACT_FULL_NAME); if (query == NULL) { purple_debug_error("evolution", "Error in creating query\n"); g_object_unref(book); return; } status = e_book_get_contacts(book, query, &cards, NULL); e_book_query_unref(query); if (!status) { purple_debug_error("evolution", "Error %d in getting card list\n", status); g_object_unref(book); return; } for (c = cards; c != NULL; c = c->next) { EContact *contact = E_CONTACT(c->data); const char *name; GList *aims, *jabbers, *yahoos, *msns, *icqs, *novells; name = e_contact_get_const(contact, E_CONTACT_FULL_NAME); aims = e_contact_get(contact, E_CONTACT_IM_AIM); jabbers = e_contact_get(contact, E_CONTACT_IM_JABBER); yahoos = e_contact_get(contact, E_CONTACT_IM_YAHOO); msns = e_contact_get(contact, E_CONTACT_IM_MSN); icqs = e_contact_get(contact, E_CONTACT_IM_ICQ); novells = e_contact_get(contact, E_CONTACT_IM_GROUPWISE); if (aims == NULL && jabbers == NULL && yahoos == NULL && msns == NULL && icqs == NULL && novells == NULL) { GtkTreeIter iter; gtk_list_store_append(dialog->model, &iter); gtk_list_store_set(dialog->model, &iter, COLUMN_NAME, name, COLUMN_DATA, contact, -1); } else { add_ims(dialog, contact, name, aims, "prpl-aim"); add_ims(dialog, contact, name, jabbers, "prpl-jabber"); add_ims(dialog, contact, name, yahoos, "prpl-yahoo"); add_ims(dialog, contact, name, msns, "prpl-msn"); add_ims(dialog, contact, name, icqs, "prpl-icq"); add_ims(dialog, contact, name, novells, "prpl-novell"); } } dialog->contacts = cards; dialog->book = book; }
gint main (gint argc, gchar **argv) { EBookClient *book_client; EBookQuery *query; EBookClientView *view; gchar *sexp; GError *error = NULL; main_initialize (); /* * Sync version */ if (!setup_book (&book_client)) return 1; query = e_book_query_any_field_contains (""); sexp = e_book_query_to_string (query); e_book_query_unref (query); if (!e_book_client_get_view_sync (book_client, sexp, &view, NULL, &error)) { report_error ("get book view sync", &error); g_free (sexp); g_object_unref (book_client); return 1; } g_free (sexp); setup_and_start_view (view); start_main_loop (NULL, NULL); if (!e_client_remove_sync (E_CLIENT (book_client), NULL, &error)) { report_error ("client remove sync", &error); g_object_unref (book_client); return 1; } g_object_unref (book_client); /* * Async version uids only */ if (!setup_book (&book_client)) return 1; start_in_idle_with_main_loop (call_get_view, book_client); if (!e_client_remove_sync (E_CLIENT (book_client), NULL, &error)) { report_error ("client remove sync", &error); g_object_unref (book_client); return 1; } g_object_unref (book_client); return get_main_loop_stop_result (); }
static void use_common_book_client (EBookClient *book_client, MatchSearchInfo *info) { EContact *contact = info->contact; EContactName *contact_name; GList *contact_email; gchar *query_parts[MAX_QUERY_PARTS + 1]; gint p = 0; gchar *contact_file_as, *qj; EBookQuery *query = NULL; gint i; if (book_client == NULL) { info->cb (info->contact, NULL, EAB_CONTACT_MATCH_NONE, info->closure); match_search_info_free (info); return; } contact_file_as = e_contact_get (contact, E_CONTACT_FILE_AS); if (contact_file_as) { query_parts[p++] = g_strdup_printf ("(contains \"file_as\" \"%s\")", contact_file_as); g_free (contact_file_as); } if (!e_contact_get (contact, E_CONTACT_IS_LIST)) { contact_name = e_contact_get (contact, E_CONTACT_NAME); if (contact_name) { if (contact_name->given && *contact_name->given) query_parts[p++] = g_strdup_printf ("(contains \"full_name\" \"%s\")", contact_name->given); if (contact_name->additional && *contact_name->additional) query_parts[p++] = g_strdup_printf ("(contains \"full_name\" \"%s\")", contact_name->additional); if (contact_name->family && *contact_name->family) query_parts[p++] = g_strdup_printf ("(contains \"full_name\" \"%s\")", contact_name->family); e_contact_name_free (contact_name); } contact_email = e_contact_get (contact, E_CONTACT_EMAIL); if (contact_email) { GList *iter; for (iter = contact_email; iter && p < MAX_QUERY_PARTS; iter = iter->next) { gchar *addr = g_strdup (iter->data); if (addr && *addr) { gchar *s = addr; while (*s) { if (*s == '@') { *s = '\0'; break; } ++s; } query_parts[p++] = g_strdup_printf ("(beginswith \"email\" \"%s\")", addr); g_free (addr); } } } g_list_foreach (contact_email, (GFunc) g_free, NULL); g_list_free (contact_email); } /* Build up our full query from the parts. */ query_parts[p] = NULL; qj = g_strjoinv (" ", query_parts); for (i = 0; query_parts[i] != NULL; i++) g_free (query_parts[i]); if (p > 1) { gchar *s; s = g_strdup_printf ("(or %s)", qj); query = e_book_query_from_string (s); g_free (s); } else if (p == 1) { query = e_book_query_from_string (qj); } else { query = NULL; } if (query) { gchar *query_str = e_book_query_to_string (query); e_book_client_get_contacts (book_client, query_str, NULL, query_cb, info); g_free (query_str); } else query_cb (G_OBJECT (book_client), NULL, info); g_free (qj); if (query) e_book_query_unref (query); }
static void add_number_to_contact (gchar *number) { EBook *book; EBookQuery *query; EBookView *view; GtkWidget *window, *contacts_treeview, *scroll, *groups_combo; GtkTreeModel *store, *group_store, *contact_filter; GError *err = NULL; window = gtk_dialog_new_with_buttons ("Add to Contact", NULL, 0, "Cancel", GTK_RESPONSE_CANCEL, "Add", GTK_RESPONSE_OK, NULL); gtk_dialog_set_has_separator (GTK_DIALOG (window), FALSE); book = e_book_new_system_addressbook (&err); if (err) return; e_book_open (book, FALSE, &err); if (err) return; query = e_book_query_any_field_contains (NULL); e_book_get_book_view (book, query, NULL, 0, &view, &err); if (err) return; e_book_query_unref (query); e_book_view_start (view); store = hito_contact_store_new (view); group_store = hito_group_store_new (); hito_group_store_set_view (HITO_GROUP_STORE (group_store), view); hito_group_store_add_group (HITO_GROUP_STORE (group_store), hito_all_group_new ()); hito_group_store_add_group (HITO_GROUP_STORE (group_store), hito_separator_group_new (-99)); hito_group_store_add_group (HITO_GROUP_STORE (group_store), hito_separator_group_new (99)); hito_group_store_add_group (HITO_GROUP_STORE (group_store), hito_no_category_group_new ()); contact_filter = hito_contact_model_filter_new (HITO_CONTACT_STORE (store)); groups_combo = hito_group_combo_new (HITO_GROUP_STORE (group_store)); hito_group_combo_connect_filter (HITO_GROUP_COMBO (groups_combo), HITO_CONTACT_MODEL_FILTER (contact_filter)); gtk_box_pack_start_defaults (GTK_BOX (GTK_DIALOG (window)->vbox), groups_combo); gtk_combo_box_set_active (GTK_COMBO_BOX (groups_combo), 0); contacts_treeview = hito_contact_view_new (HITO_CONTACT_STORE (store), HITO_CONTACT_MODEL_FILTER (contact_filter)); scroll = moko_finger_scroll_new (); gtk_widget_set_size_request (scroll, -1, 300); gtk_box_pack_start_defaults (GTK_BOX (GTK_DIALOG (window)->vbox), scroll); gtk_container_add (GTK_CONTAINER (scroll), contacts_treeview); gtk_widget_show_all (scroll); gtk_widget_show_all (groups_combo); if (gtk_dialog_run (GTK_DIALOG (window)) == GTK_RESPONSE_OK) { GtkTreeIter iter; EContact *contact; EVCardAttribute *attr; GtkTreeModel *model; GtkTreeSelection *selection; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (contacts_treeview)); if (gtk_tree_selection_get_selected (selection, &model, &iter)) { gtk_tree_model_get (model, &iter, COLUMN_CONTACT, &contact, -1); if (contact) { attr = e_vcard_attribute_new ("", EVC_TEL); e_vcard_add_attribute_with_value (E_VCARD (contact), attr, number); hito_vcard_attribute_set_type (attr, "Other"); e_book_async_commit_contact (book, contact, NULL, NULL); g_object_unref (contact); } } } gtk_widget_destroy (window); g_object_unref (book); }
void bbdb_sync_buddy_list (void) { GList *blist, *l; EBook *book = NULL; /* Get the Gaim buddy list */ blist = bbdb_get_gaim_buddy_list (); if (blist == NULL) return; /* Open the addressbook */ book = bbdb_open_addressbook (GAIM_ADDRESSBOOK); if (book == NULL) { free_buddy_list (blist); return; } printf ("bbdb: Synchronizing buddy list to contacts...\n"); /* Walk the buddy list */ for (l = blist; l != NULL; l = l->next) { GaimBuddy *b = l->data; EBookQuery *query; GList *contacts; GError *error = NULL; EContact *c; if (b->alias == NULL || strlen (b->alias) == 0) b->alias = b->account_name; /* Look for an exact match full name == buddy alias */ query = e_book_query_field_test (E_CONTACT_FULL_NAME, E_BOOK_QUERY_IS, b->alias); e_book_get_contacts (book, query, &contacts, NULL); e_book_query_unref (query); if (contacts != NULL) { /* FIXME: If there's more than one contact with this name, just give up; we're not smart enough for this. */ if (contacts->next != NULL) continue; c = E_CONTACT (contacts->data); if (! bbdb_merge_buddy_to_contact (book, b, c)) continue; /* Write it out to the addressbook */ if (! e_book_commit_contact (book, c, &error)) { g_warning ("bbdb: Could not modify contact: %s\n", error->message); g_error_free (error); } continue; } /* Otherwise, create a new contact. */ c = e_contact_new (); e_contact_set (c, E_CONTACT_FULL_NAME, (gpointer) b->alias); if (! bbdb_merge_buddy_to_contact (book, b, c)) { g_object_unref (G_OBJECT (c)); continue; } if (! e_book_add_contact (book, c, &error)) { g_warning ("bbdb: Failed to add new contact: %s\n", error->message); g_error_free (error); return; } g_object_unref (G_OBJECT (c)); } /* Update the last-sync'd time */ { GConfClient *gconf; time_t last_sync; char *last_sync_str; gconf = gconf_client_get_default (); time (&last_sync); last_sync_str = g_strdup_printf ("%ld", (glong) last_sync); gconf_client_set_string (gconf, GCONF_KEY_GAIM_LAST_SYNC, last_sync_str, NULL); g_free (last_sync_str); g_object_unref (G_OBJECT (gconf)); } printf ("bbdb: Done syncing buddy list to contacts.\n"); }
static void add_gnome_addressbook(GList **address_list) { ESourceRegistry * registry = NULL; GError *error = NULL; GList *a; registry = e_source_registry_new_sync (NULL, &error); if (!registry || error) { debug_print("Error: Failed to get access to source registry: %s\n", error->message); g_error_free(error); return; } // create book accessor if necessary if(!eds_books) { GList *list_sources = e_source_registry_list_sources (registry, E_SOURCE_EXTENSION_ADDRESS_BOOK); for (a = list_sources; a; a = a->next) { ESource *source = E_SOURCE (a->data); if (e_source_get_enabled(source)) { EBook *eds_book = e_book_new(source, &error); if(!eds_book) { g_list_free_full(list_sources, g_object_unref); debug_print("Error: Could not get eds addressbook: %s\n", error->message); g_error_free(error); return; } eds_books = g_list_append (eds_books, eds_book); } } g_list_free_full(list_sources, g_object_unref); } for (a = eds_books; a; a = a->next) { EBook *eds_book = a->data; EBookQuery *query; EBookView *view; // open book if necessary if(!e_book_is_opened(eds_book) && !e_book_open(eds_book, TRUE, &error)) { debug_print("Error: Could not open eds addressbook: %s\n", error->message); g_error_free(error); return; } // query book query = e_book_query_field_exists(E_CONTACT_EMAIL); if(!e_book_get_book_view(eds_book, query, NULL, 0, &view, &error)) { debug_print("Error: Could not get eds addressbook view: %s\n", error->message); g_error_free(error); } e_book_query_unref(query); g_signal_connect(G_OBJECT(view), "contacts-added", G_CALLBACK(eds_contacts_added_cb), address_list); g_signal_connect(G_OBJECT(view), "sequence-complete", G_CALLBACK(eds_sequence_complete_cb), NULL); eds_waiting = TRUE; e_book_view_start(view); while(eds_waiting) gtk_main_iteration(); e_book_view_stop(view); g_object_unref(view); } }
static gboolean start_tests (gpointer data) { EwsBookBackendSqliteDB *ebsdb; gboolean populated = FALSE; gchar *vcard_str = NULL, *sexp; EBookQuery *q; GSList *uids = NULL; gboolean store_vcard = FALSE; g_print ("Creating the sqlitedb \n"); op = "create sqlitedb"; ebsdb = ews_book_backend_sqlitedb_new (cache_path, email, folderid, folder_name, store_vcard, &error); if (error) goto exit; add_contacts (ebsdb); if (error) goto exit; g_print ("Getting is_populated \n"); op = "set is_populated"; ews_book_backend_sqlitedb_set_is_populated (ebsdb, folderid, TRUE, &error); if (error) goto exit; g_print ("Setting is_populated \n"); op = "set is_populated"; populated = ews_book_backend_sqlitedb_get_is_populated (ebsdb, folderid, &error); if (error) goto exit; g_print ("Populated: %d \n", populated); g_print ("Setting key value \n"); op = "set key/value"; ews_book_backend_sqlitedb_set_key_value (ebsdb, folderid, "customkey", "stored", &error); if (error) goto exit; g_print ("Get Vcard string \n"); op = "get vcard string"; vcard_str = ews_book_backend_sqlitedb_get_vcard_string (ebsdb, folderid, uid, NULL, NULL, &error); if (error) goto exit; g_print ("VCard: %s \n", vcard_str); g_free (vcard_str); q = e_book_query_field_test (E_CONTACT_FULL_NAME, E_BOOK_QUERY_CONTAINS, "test"); sexp = e_book_query_to_string (q); search_db (ebsdb, "summary query", sexp); e_book_query_unref (q); g_free (sexp); if (error) goto exit; if (store_vcard) { q = e_book_query_any_field_contains ("word"); sexp = e_book_query_to_string (q); search_db (ebsdb, "full_search query", sexp); e_book_query_unref (q); g_free (sexp); if (error) goto exit; } g_print ("Delete contact \n"); op = "delete contact"; uids = g_slist_append (uids, (gchar *) uid); ews_book_backend_sqlitedb_remove_contacts (ebsdb, folderid, uids, &error); g_slist_free (uids); if (error) goto exit; g_print ("Delete addressbook \n"); op = "delete addressbook"; ews_book_backend_sqlitedb_delete_addressbook (ebsdb, folderid, &error); exit: g_object_unref (ebsdb); quit_tests (); return FALSE; }
static void action_address_book_save_as_cb (GtkAction *action, EBookShellView *book_shell_view) { EShell *shell; EShellView *shell_view; EShellWindow *shell_window; EShellBackend *shell_backend; EBookShellContent *book_shell_content; EAddressbookModel *model; EAddressbookView *view; EActivity *activity; EBookQuery *query; EBookClient *book; GSList *list = NULL; GFile *file; gchar *string; shell_view = E_SHELL_VIEW (book_shell_view); shell_window = e_shell_view_get_shell_window (shell_view); shell_backend = e_shell_view_get_shell_backend (shell_view); shell = e_shell_window_get_shell (shell_window); book_shell_content = book_shell_view->priv->book_shell_content; view = e_book_shell_content_get_current_view (book_shell_content); g_return_if_fail (view != NULL); model = e_addressbook_view_get_model (view); book = e_addressbook_model_get_client (model); query = e_book_query_any_field_contains (""); string = e_book_query_to_string (query); e_book_query_unref (query); e_book_client_get_contacts_sync (book, string, &list, NULL, NULL); g_free (string); if (list == NULL) goto exit; string = eab_suggest_filename (list); file = e_shell_run_save_dialog ( /* Translators: This is a save dialog title */ shell, _("Save as vCard"), string, "*.vcf:text/x-vcard,text/directory", NULL, NULL); g_free (string); if (file == NULL) goto exit; string = eab_contact_list_to_string (list); if (string == NULL) { g_warning ("Could not convert contact list to a string"); g_object_unref (file); goto exit; } /* XXX No callback means errors are discarded. * * There's an EAlert for this which I'm not using * until I figure out a better way to display errors: * * "addressbook:save-error" */ activity = e_file_replace_contents_async ( file, string, strlen (string), NULL, FALSE, G_FILE_CREATE_NONE, (GAsyncReadyCallback) NULL, NULL); e_shell_backend_add_activity (shell_backend, activity); /* Free the string when the activity is finalized. */ g_object_set_data_full ( G_OBJECT (activity), "file-content", string, (GDestroyNotify) g_free); g_object_unref (file); exit: e_client_util_free_object_slist (list); }
/* * Search for a buddy in the Evolution contacts. * * @param buddy The buddy to search for. * @param query An optional query. This function takes ownership of @a query, * so callers must e_book_query_ref() it in advance (to obtain a * second reference) if they want to reuse @a query. */ EContact * gevo_search_buddy_in_contacts(PurpleBuddy *buddy, EBookQuery *query) { ESourceList *addressbooks; GError *err = NULL; EBookQuery *full_query; GSList *groups, *g; EContact *result; EContactField protocol_field = gevo_prpl_get_field(buddy->account, buddy); if (protocol_field == 0) return NULL; if (query != NULL) { EBookQuery *queries[2]; queries[0] = query; queries[1] = e_book_query_field_test(protocol_field, E_BOOK_QUERY_IS, buddy->name); if (queries[1] == NULL) { purple_debug_error("evolution", "Error in creating protocol query\n"); e_book_query_unref(query); return NULL; } full_query = e_book_query_and(2, queries, TRUE); } else { full_query = e_book_query_field_test(protocol_field, E_BOOK_QUERY_IS, buddy->name); if (full_query == NULL) { purple_debug_error("evolution", "Error in creating protocol query\n"); return NULL; } } if (!e_book_get_addressbooks(&addressbooks, &err)) { purple_debug_error("evolution", "Unable to fetch list of address books.\n"); e_book_query_unref(full_query); if (err != NULL) g_error_free(err); return NULL; } groups = e_source_list_peek_groups(addressbooks); if (groups == NULL) { g_object_unref(addressbooks); e_book_query_unref(full_query); return NULL; } for (g = groups; g != NULL; g = g->next) { GSList *sources, *s; sources = e_source_group_peek_sources(g->data); for (s = sources; s != NULL; s = s->next) { result = gevo_run_query_in_uri(e_source_get_uri(E_SOURCE(s->data)), full_query); if (result != NULL) { g_object_unref(addressbooks); e_book_query_unref(full_query); return result; } } } g_object_unref(addressbooks); e_book_query_unref(full_query); return NULL; }