void *phonebook_pull(const char *name, const struct apparam_field *params,
phonebook_cb cb, void *user_data, int *err)
{
struct query_context *data;
if (g_strcmp0(PB_CONTACTS, name) != 0) {
if (err)
*err = -ENOENT;
return NULL;
}
data = g_new0(struct query_context, 1);
data->contacts_cb = cb;
data->params = params;
data->user_data = user_data;
data->buf = g_string_new("");
data->query = e_book_query_any_field_contains("");
data->ebooks = open_ebooks();
if (err)
*err = data->ebooks == NULL ? -EIO : 0;
return data;
}
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);
}
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;
}
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);
}
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);
}
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 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;
}
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 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 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_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);
}
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;
GSList *l;
EContact *me;
EVCard *evcard;
GError *gerr = NULL;
EBook *eb;
EVCardAttribute *attrib;
char *uid, *tel, *cname;
if (g_strcmp0(PB_CONTACTS_FOLDER, name) != 0) {
if (err)
*err = -ENOENT;
return NULL;
}
DBG("");
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;
data->query = query;
data->ebooks = open_ebooks();
/* Add 0.vcf */
if (e_book_get_self(&me, &eb, &gerr) == FALSE) {
g_error_free(gerr);
goto next;
}
evcard = E_VCARD(me);
cname = evcard_name_attribute_to_string(evcard);
if (!cname)
cname = g_strdup("");
attrib = e_vcard_get_attribute(evcard, EVC_UID);
uid = e_vcard_attribute_get_value(attrib);
if (!uid)
uid = g_strdup("");
attrib = e_vcard_get_attribute(evcard, EVC_TEL);
if (attrib)
tel = e_vcard_attribute_get_value(attrib);
else
tel = g_strdup("");
data->entry_cb(uid, 0, cname, NULL, tel, data->user_data);
data->count++;
g_free(cname);
g_free(uid);
g_free(tel);
g_object_unref(eb);
next:
for (l = data->ebooks; l != NULL; l = g_slist_next(l)) {
EBook *ebook = l->data;
if (e_book_is_opened(ebook) == FALSE)
continue;
if (e_book_get_contacts_async(ebook, query,
cache_cb, data) == TRUE)
data->queued_calls++;
}
if (err)
*err = (data->queued_calls == 0 ? -ENOENT : 0);
return data;
}
/* 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 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;
}
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
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);
}
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);
}
int
main (int argc, char **argv) {
GError *error = NULL;
GtkWidget *window;
GtkWidget *tabs, *hbox, *vbox, *query_entry, *query_button;
EBook *book;
EBookView *view = NULL;
EBookQuery *query;
gtk_init (&argc, &argv);
book = e_book_new_system_addressbook (&error);
if (!book) {
g_warning ("Cannot get book: %s", error->message);
g_error_free (error);
return 1;
}
if (!e_book_open (book, FALSE, &error)) {
g_warning ("Cannot get book: %s", error->message);
g_error_free (error);
return 1;
}
query = e_book_query_any_field_contains ("");
if (!e_book_get_book_view (book, query, NULL, 0, &view, &error)) {
g_warning ("Cannot get book view: %s", error->message);
g_error_free (error);
return 1;
}
e_book_query_unref (query);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Contact Trace");
gtk_window_set_default_size (GTK_WINDOW (window), 600, 400);
g_signal_connect (window, "delete-event", gtk_main_quit, NULL);
gtk_widget_show (window);
tabs = gtk_notebook_new ();
gtk_container_add (GTK_CONTAINER (window), tabs);
/* The Contacts tab */
contacts_view = eds_contact_view_new ();
eds_contact_view_set_book (EDS_CONTACT_VIEW (contacts_view), book);
eds_contact_view_set_book_view (EDS_CONTACT_VIEW (contacts_view), view);
gtk_notebook_append_page (GTK_NOTEBOOK (tabs),
contacts_view,
gtk_label_new_with_mnemonic ("_Contacts"));
/* Events Tab */
event_view = eds_event_view_new ();
eds_event_view_set_book_view (EDS_EVENT_VIEW (event_view), view);
gtk_notebook_append_page (GTK_NOTEBOOK (tabs),
event_view,
gtk_label_new_with_mnemonic ("_Events"));
/* The Query tab */
vbox = gtk_vbox_new (FALSE, 8);
query_view = eds_contact_view_new ();
eds_contact_view_set_book (EDS_CONTACT_VIEW (query_view), book);
hbox = gtk_hbox_new (FALSE, 8);
query_entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), query_entry, TRUE, TRUE, 0);
query_button = gtk_button_new_with_label ("Run");
g_signal_connect (query_button, "clicked", G_CALLBACK (on_query_button_clicked), query_entry);
gtk_box_pack_start (GTK_BOX (hbox), query_button, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), query_view, TRUE, TRUE, 0);
gtk_notebook_append_page (GTK_NOTEBOOK (tabs),
vbox,
gtk_label_new_with_mnemonic ("_Queries"));
e_book_view_start (view);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
