static void
verify_premodify_and_prepare_contact (EContact *contact)
{
EVCardAttribute *attr;
/* ensure there is no email address to begin with, then add one */
g_assert (!e_vcard_get_attribute (E_VCARD (contact), EVC_EMAIL));
attr = e_vcard_attribute_new (NULL, EVC_EMAIL);
e_vcard_add_attribute_with_value (E_VCARD (contact), attr, EMAIL_ADD);
}
static gboolean
transfer_contacts_cb (EMapiConnection *conn,
TALLOC_CTX *mem_ctx,
/* const */ EMapiObject *object,
guint32 obj_index,
guint32 obj_total,
gpointer user_data,
GCancellable *cancellable,
GError **perror)
{
struct TransferContactsData *tcd = user_data;
EContact *contact;
g_return_val_if_fail (tcd != NULL, FALSE);
g_return_val_if_fail (object != NULL, FALSE);
g_return_val_if_fail (tcd->ebma != NULL, FALSE);
contact = e_mapi_book_utils_contact_from_object (conn, object, e_book_backend_mapi_get_book_uid (tcd->ebma));
if (contact) {
if (tcd->cards)
*tcd->cards = g_slist_prepend (*tcd->cards, e_vcard_to_string (E_VCARD (contact), EVC_FORMAT_VCARD_30));
if (!e_book_backend_mapi_notify_contact_update (tcd->ebma, tcd->book_view, contact, obj_index, obj_total, FALSE, tcd->notify_contact_data)) {
g_object_unref (contact);
return FALSE;
}
g_object_unref (contact);
} else {
g_debug ("%s: [%d/%d] Failed to transform to contact", G_STRFUNC, obj_index, obj_total);
}
return TRUE;
}
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;
}
int
main (int argc, char **argv)
{
EBook *book;
EContact *contact;
GError *error = NULL;
char *vcard;
g_type_init ();
printf ("getting the self contact\n");
if (!e_book_get_self (&contact, &book, &error)) {
printf ("error %d getting self: %s\n", error->code, error->message);
g_clear_error (&error);
return -1;
}
vcard = e_vcard_to_string (E_VCARD (contact), EVC_FORMAT_VCARD_30);
printf ("self contact = \n%s\n", vcard);
g_free (vcard);
g_object_unref (contact);
g_object_unref (book);
return 0;
}
static void
scan_objects (gpointer data, gpointer user_data)
{
ScanContext *context;
ScalixContact *contact;
EBookBackendSExp *sexp;
char *ostr;
gboolean is_search;
context = (ScanContext *) user_data;
contact = SCALIX_CONTACT (data);
sexp = context->sexp;
is_search = context->search_needed;
if (!is_search
|| e_book_backend_sexp_match_contact (sexp, E_CONTACT (contact))) {
if (context->return_objects == TRUE) {
context->obj_list =
g_list_prepend (context->obj_list, g_object_ref (contact));
} else {
ostr = e_vcard_to_string (E_VCARD (contact), EVC_FORMAT_VCARD_30);
context->obj_list = g_list_prepend (context->obj_list, ostr);
}
}
}
static ESExpResult *
func_exists_vcard (struct _ESExp *f,
gint argc,
struct _ESExpResult **argv,
gpointer data)
{
SearchContext *ctx = data;
ESExpResult *r;
gint truth = FALSE;
if (argc == 1 && argv[0]->type == ESEXP_RES_STRING) {
const gchar *attr_name;
EVCardAttribute *attr;
GList *values;
gchar *s;
attr_name = argv[0]->value.string;
attr = e_vcard_get_attribute (E_VCARD (ctx->contact), attr_name);
if (attr) {
values = e_vcard_attribute_get_values (attr);
if (g_list_length (values) > 0) {
s = values->data;
if (s[0] != '\0') {
truth = TRUE;
}
}
}
}
r = e_sexp_result_new (f, ESEXP_RES_BOOL);
r->value.boolean = truth;
return r;
}
OpenAB_Storage::StorageItem* EDSContactsStorageItemIterator::next()
{
GError * gerror = NULL;
static GSList * cont = NULL;
if (NULL == cont)
{
if (eFetchContactsOK != fetchContacts(1000))
{
return NULL;
}
cont = contacts;
}
EContact *data = static_cast<EContact *>(cont->data);
char * vcard = e_vcard_to_string (E_VCARD (data), EVC_FORMAT_VCARD_30);
const char * id = (const char *)e_contact_get_const(data,E_CONTACT_UID);
const char * rev = (const char *)e_contact_get_const(data,E_CONTACT_REV);
elem.id = id;
OpenAB::PIMContactItem* newItem = new OpenAB::PIMContactItem();
newItem->parse(vcard);
newItem->setId(id);
newItem->setRevision(rev);
elem.item = newItem;
g_free(vcard);
cont = cont->next;
GERROR_FREE(gerror);
return &elem;
}
/**
* e_book_backend_db_cache_add_contact:
* @db: DB Handle
* @contact: an #EContact
*
* Adds @contact to @cache.
*
* Returns: %TRUE if the contact was cached successfully, %FALSE otherwise.
**/
gboolean
e_book_backend_db_cache_add_contact (DB *db,
EContact *contact)
{
DBT uid_dbt, vcard_dbt;
gint db_error;
gchar *vcard_str;
const gchar *uid;
uid = e_contact_get_const (contact, E_CONTACT_UID);
if (!uid) {
printf ("no uid\n");
printf (
"name:%s, email:%s\n",
(gchar *) e_contact_get (contact, E_CONTACT_GIVEN_NAME),
(gchar *) e_contact_get (contact, E_CONTACT_EMAIL_1));
return FALSE;
}
string_to_dbt (uid, &uid_dbt);
vcard_str = e_vcard_to_string (E_VCARD (contact), EVC_FORMAT_VCARD_30);
string_to_dbt (vcard_str, &vcard_dbt);
/* db_error = db->del (db, NULL, &uid_dbt, 0); */
db_error = db->put (db, NULL, &uid_dbt, &vcard_dbt, 0);
g_free (vcard_str);
if (db_error != 0) {
g_warning ("db->put failed with %d", db_error);
return FALSE;
}
else
return TRUE;
}
static void ebookpull_cb(EBook *book, EBookStatus estatus, GList *contacts,
void *user_data)
{
struct query_context *data = user_data;
GString *string = g_string_new("");
unsigned int count = 0, maxcount;
GList *l;
if (estatus == E_BOOK_ERROR_CANCELLED) {
error("E-Book operation was cancelled: status %d", estatus);
goto fail;
}
if (estatus != E_BOOK_ERROR_OK) {
error("E-Book query failed: status %d", estatus);
goto done;
}
/*
* When MaxListCount is zero, PCE wants to know the number of used
* indexes in the phonebook of interest. All other parameters that
* may be present in the request shall be ignored.
*/
maxcount = data->params->maxlistcount;
if (maxcount == 0) {
count = g_list_length(contacts);
goto done;
}
l = g_list_nth(contacts, data->params->liststartoffset);
/* FIXME: Missing 0.vcf */
for (; l && count < maxcount; l = g_list_next(l), count++) {
EContact *contact = E_CONTACT(l->data);
EVCard *evcard = E_VCARD(contact);
char *vcard;
vcard = evcard_to_string(evcard, data->params->format,
data->params->filter);
string = g_string_append(string, vcard);
string = g_string_append(string, "\r\n");
g_free(vcard);
}
DBG("collected %d vcards", count);
done:
data->completed = TRUE;
data->contacts_cb(string->str, string->len, count, 0, TRUE,
data->user_data);
fail:
g_string_free(string, TRUE);
if (data->completed)
g_free(data);
}
gint
main (gint argc,
gchar **argv)
{
#if 0 /* ACCOUNT_MGMT */
EBook *book;
gboolean status;
EBookQuery *query;
GList *c, *contacts;
g_type_init ();
if (argc < 3) {
printf ("usage: test-search <addressbook uri> <query>\n");
exit (0);
}
query = e_book_query_from_string (argv[2]);
if (!query) {
printf ("failed to parse query string '%s'\n", argv[2]);
exit (0);
}
book = e_book_new_system_addressbook (NULL);
if (!book) {
printf ("failed to create ebook\n");
exit (0);
}
status = e_book_open (book, TRUE, NULL);
if (status == FALSE) {
printf ("failed to open addressbook\n");
exit (0);
}
status = e_book_get_contacts (book, query, &contacts, NULL);
if (status == FALSE) {
printf ("failed to get contacts\n");
exit (0);
}
for (c = contacts; c; c = c->next) {
EContact *contact = E_CONTACT (c->data);
printf ("%s\n", e_vcard_to_string (E_VCARD (contact), EVC_FORMAT_VCARD_30));
g_object_unref (contact);
}
g_list_free (contacts);
g_object_unref (book);
#endif /* ACCOUNT_MGMT */
return 0;
}
static void cache_cb(EBook *book, EBookStatus estatus, GList *contacts,
void *user_data)
{
struct query_context *data = user_data;
GList *l;
if (estatus == E_BOOK_ERROR_CANCELLED) {
error("E-Book operation was cancelled: status %d", estatus);
goto fail;
}
data->completed = TRUE;
if (estatus != E_BOOK_ERROR_OK) {
error("E-Book query failed: status %d", estatus);
goto done;
}
for (l = contacts; l; l = g_list_next(l)) {
EContact *contact = E_CONTACT(l->data);
EVCard *evcard = E_VCARD(contact);
EVCardAttribute *attrib;
char *uid, *tel, *name;
name = evcard_name_attribute_to_string(evcard);
if (!name)
continue;
attrib = e_vcard_get_attribute(evcard, EVC_UID);
if (!attrib)
continue;
uid = e_vcard_attribute_get_value(attrib);
if (!uid)
continue;
attrib = e_vcard_get_attribute(evcard, EVC_TEL);
if (!attrib)
continue;
tel = e_vcard_attribute_get_value(attrib);
data->entry_cb(uid, PHONEBOOK_INVALID_HANDLE, name, NULL,
tel, data->user_data);
g_free(name);
g_free(uid);
g_free(tel);
}
done:
data->ready_cb(data->user_data);
fail:
if (data->completed)
g_free(data);
}
static void
verify_commit (EContact *contact)
{
EVCardAttribute *attr;
gchar *email_value;
g_assert ((attr = e_vcard_get_attribute (E_VCARD (contact), EVC_EMAIL)));
g_assert (e_vcard_attribute_is_single_valued (attr));
email_value = e_vcard_attribute_get_value (attr);
g_assert (!g_strcmp0 (email_value, EMAIL_ADD));
}
static void
create_new_contact_from_number (gchar *number)
{
GtkWidget *dialog, *name, *label;
dialog = gtk_dialog_new_with_buttons ("Save as Contact",
NULL, GTK_DIALOG_MODAL, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
label = gtk_label_new ("Enter a name for the contact");
name = gtk_entry_new ();
gtk_box_pack_start_defaults (GTK_BOX (GTK_DIALOG(dialog)->vbox), label);
gtk_box_pack_start_defaults (GTK_BOX (GTK_DIALOG(dialog)->vbox), name);
gtk_widget_show (label);
gtk_widget_show (name);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
EContact *contact;
EBook *book;
EVCardAttribute *attr;
/* create contact */
contact = e_contact_new ();
/* add name */
e_contact_set (contact, E_CONTACT_FULL_NAME, (const gpointer)gtk_entry_get_text (GTK_ENTRY (name))); /* (const gpointer) removes a useless warning) */
/* add number */
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");
/* open address book */
/* TODO: check GErrors */
book = e_book_new_system_addressbook (NULL);
e_book_open (book, FALSE, NULL);
/* add contact to address book, and close */
e_book_add_contact (book, contact, NULL);
g_object_unref (book);
g_object_unref (contact);
}
gtk_widget_destroy (dialog);
}
static void
e_vcard_dispose (GObject *object)
{
EVCard *evc = E_VCARD (object);
if (evc->priv) {
g_list_foreach (evc->priv->attributes, (GFunc)e_vcard_attribute_free, NULL);
g_list_free (evc->priv->attributes);
g_free (evc->priv);
evc->priv = NULL;
}
if (G_OBJECT_CLASS (parent_class)->dispose)
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
insert_contact (EBookBackendVCF *vcf, gchar *vcard)
{
EContact *contact = e_contact_new_from_vcard (vcard);
gchar *id;
id = e_contact_get (contact, E_CONTACT_UID);
if (id) {
gchar *vcard = e_vcard_to_string (E_VCARD (contact), EVC_FORMAT_VCARD_30);
vcf->priv->contact_list = g_list_prepend (vcf->priv->contact_list, vcard);
g_hash_table_insert (vcf->priv->contacts,
id,
vcf->priv->contact_list);
}
}
static void ebook_entry_cb(EBook *book, const GError *gerr,
EContact *contact, void *user_data)
{
struct query_context *data = user_data;
EVCard *evcard;
char *vcard;
size_t len;
data->queued_calls--;
if (data->canceled)
goto done;
if (gerr != NULL) {
error("E-Book query failed: %s", gerr->message);
goto done;
}
DBG("");
evcard = E_VCARD(contact);
vcard = evcard_to_string(evcard, EVC_FORMAT_VCARD_30,
data->params->filter);
len = vcard ? strlen(vcard) : 0;
data->count++;
data->contacts_cb(vcard, len, 1, 0, TRUE, data->user_data);
g_free(vcard);
g_object_unref(contact);
return;
done:
if (data->queued_calls == 0) {
if (data->count == 0)
data->contacts_cb(NULL, 0, 1, 0, TRUE,
data->user_data);
else if (data->canceled)
free_query_context(data);
}
}
static void
e_book_backend_webdav_get_contact_list (EBookBackend *backend,
EDataBook *book,
guint32 opid,
GCancellable *cancellable,
const gchar *query)
{
EBookBackendWebdav *webdav = E_BOOK_BACKEND_WEBDAV (backend);
EBookBackendWebdavPrivate *priv = webdav->priv;
GList *contact_list;
GSList *vcard_list;
GList *c;
if (e_backend_get_online (E_BACKEND (backend))) {
/* make sure the cache is up to date */
GError *error = download_contacts (webdav, NULL, NULL, cancellable);
if (error) {
e_data_book_respond_get_contact_list (book, opid, error, NULL);
return;
}
}
/* answer query from cache */
g_mutex_lock (&priv->cache_lock);
contact_list = e_book_backend_cache_get_contacts (priv->cache, query);
g_mutex_unlock (&priv->cache_lock);
vcard_list = NULL;
for (c = contact_list; c != NULL; c = g_list_next (c)) {
EContact *contact = c->data;
gchar *vcard
= e_vcard_to_string (E_VCARD (contact), EVC_FORMAT_VCARD_30);
vcard_list = g_slist_append (vcard_list, vcard);
g_object_unref (contact);
}
g_list_free (contact_list);
e_data_book_respond_get_contact_list (book, opid, EDB_ERROR (SUCCESS), vcard_list);
g_slist_foreach (vcard_list, (GFunc) g_free, NULL);
g_slist_free (vcard_list);
}
gchar *
eab_contact_list_to_string (const GSList *contacts)
{
GString *str = g_string_new ("");
const GSList *l;
for (l = contacts; l; l = l->next) {
EContact *contact = l->data;
gchar *vcard_str;
e_contact_inline_local_photos (contact, NULL);
vcard_str = e_vcard_to_string (
E_VCARD (contact), EVC_FORMAT_VCARD_30);
g_string_append (str, vcard_str);
if (l->next)
g_string_append (str, "\r\n\r\n");
}
return g_string_free (str, FALSE);
}
static EContact *
do_create (EBookBackendVCF *bvcf,
const gchar *vcard_req,
gboolean dirty_the_file)
{
gchar *id;
EContact *contact;
gchar *vcard;
const gchar *rev;
/* at the very least we need the unique_id generation to be
protected by the lock, even if the actual vcard parsing
isn't. */
g_mutex_lock (bvcf->priv->mutex);
id = e_book_backend_vcf_create_unique_id ();
contact = e_contact_new_from_vcard (vcard_req);
e_contact_set (contact, E_CONTACT_UID, id);
g_free (id);
rev = e_contact_get_const (contact, E_CONTACT_REV);
if (!(rev && *rev))
set_revision (contact);
vcard = e_vcard_to_string (E_VCARD (contact), EVC_FORMAT_VCARD_30);
insert_contact (bvcf, vcard);
if (dirty_the_file) {
bvcf->priv->dirty = TRUE;
if (!bvcf->priv->flush_timeout_tag)
bvcf->priv->flush_timeout_tag = g_timeout_add (FILE_FLUSH_TIMEOUT,
vcf_flush_file, bvcf);
}
g_mutex_unlock (bvcf->priv->mutex);
return contact;
}
/* Get a list of the specified attributes from a contact */
GList *
hito_vcard_get_named_attributes (EVCard *contact, const char *name)
{
GList *attrs = NULL, *l;
g_return_val_if_fail (E_IS_VCARD (contact), NULL);
g_return_val_if_fail (name != NULL, NULL);
for (l = e_vcard_get_attributes (E_VCARD (contact)); l; l = l->next)
{
EVCardAttribute *attr;
const char *n;
attr = (EVCardAttribute *) l->data;
n = e_vcard_attribute_get_name (attr);
if (strcmp (n, name) == 0)
attrs = g_list_prepend (attrs, attr);
}
return g_list_reverse (attrs);
}
/**
* e_data_book_view_notify_update:
* @book_view: an #EDataBookView
* @contact: an #EContact
*
* Notify listeners that @contact has changed. This can
* trigger an add, change or removal event depending on
* whether the change causes the contact to start matching,
* no longer match, or stay matching the query specified
* by @book_view.
**/
void
e_data_book_view_notify_update (EDataBookView *book_view,
EContact *contact)
{
EDataBookViewPrivate *priv = book_view->priv;
gboolean currently_in_view, want_in_view;
const gchar *id;
gchar *vcard;
if (!priv->running)
return;
g_mutex_lock (priv->pending_mutex);
id = e_contact_get_const (contact, E_CONTACT_UID);
currently_in_view = id_is_in_view (book_view, id);
want_in_view =
e_book_backend_sexp_match_contact (priv->card_sexp, contact);
if (want_in_view) {
vcard = e_vcard_to_string (E_VCARD (contact),
EVC_FORMAT_VCARD_30);
if (currently_in_view)
notify_change (book_view, vcard);
else
notify_add (book_view, id, vcard);
g_free (vcard);
} else {
if (currently_in_view)
notify_remove (book_view, id);
/* else nothing; we're removing a card that wasn't there */
}
g_mutex_unlock (priv->pending_mutex);
}
static EBookBackendSyncStatus
e_book_backend_scalix_get_contact (EBookBackendSync * backend,
EDataBook * book,
guint32 opid, const char *uid, char **vcard)
{
EBookBackendScalix *bs;
EBookBackendScalixPrivate *priv;
ScalixObject *object;
bs = E_BOOK_BACKEND_SCALIX (backend);
priv = E_BOOK_BACKEND_SCALIX_GET_PRIVATE (bs);
object = scalix_container_get_object (priv->container, uid);
if (object == NULL || !E_IS_VCARD (object)) {
return GNOME_Evolution_Addressbook_ContactNotFound;
}
*vcard = e_vcard_to_string (E_VCARD (object), EVC_FORMAT_VCARD_30);
g_object_unref (object);
return GNOME_Evolution_Addressbook_Success;
}
static void
e_book_backend_webdav_get_contact (EBookBackend *backend,
EDataBook *book,
guint32 opid,
GCancellable *cancellable,
const gchar *uid)
{
EBookBackendWebdav *webdav = E_BOOK_BACKEND_WEBDAV (backend);
EBookBackendWebdavPrivate *priv = webdav->priv;
EContact *contact;
gchar *vcard;
if (!e_backend_get_online (E_BACKEND (backend))) {
g_mutex_lock (&priv->cache_lock);
contact = e_book_backend_cache_get_contact (priv->cache, uid);
g_mutex_unlock (&priv->cache_lock);
} else {
contact = download_contact (webdav, uid, cancellable);
/* update cache as we possibly have changes */
if (contact != NULL) {
g_mutex_lock (&priv->cache_lock);
e_book_backend_cache_remove_contact (priv->cache, uid);
e_book_backend_cache_add_contact (priv->cache, contact);
g_mutex_unlock (&priv->cache_lock);
}
}
if (contact == NULL) {
e_data_book_respond_get_contact (book, opid, EDB_ERROR (CONTACT_NOT_FOUND), NULL);
return;
}
vcard = e_vcard_to_string (E_VCARD (contact), EVC_FORMAT_VCARD_30);
e_data_book_respond_get_contact (book, opid, EDB_ERROR (SUCCESS), vcard);
g_free (vcard);
g_object_unref (contact);
}
static void ebook_entry_cb(EBook *book, EBookStatus estatus,
EContact *contact, void *user_data)
{
struct query_context *data = user_data;
EVCard *evcard;
char *vcard;
size_t len;
if (estatus == E_BOOK_ERROR_CANCELLED) {
error("E-Book operation was cancelled: status %d", estatus);
goto fail;
}
data->completed = TRUE;
if (estatus != E_BOOK_ERROR_OK) {
error("E-Book query failed: status %d", estatus);
data->contacts_cb(NULL, 0, 1, 0, TRUE, data->user_data);
goto fail;
}
evcard = E_VCARD(contact);
vcard = evcard_to_string(evcard, data->params->format,
data->params->filter);
len = vcard ? strlen(vcard) : 0;
data->contacts_cb(vcard, len, 1, 0, TRUE, data->user_data);
g_free(vcard);
fail:
if (data->completed)
g_free(data);
}
static gboolean
test_econtact (const gchar *vcard_str)
{
EContact *c1, *c2;
gchar *str;
/* do not parse */
c1 = e_contact_new_from_vcard (vcard_str);
str = e_vcard_to_string (E_VCARD (c1), EVC_FORMAT_VCARD_30);
g_return_val_if_fail (str != NULL, FALSE);
g_return_val_if_fail (g_ascii_strcasecmp (str, vcard_str) == 0, FALSE);
g_return_val_if_fail (e_vcard_is_parsed (E_VCARD (c1)) == FALSE, FALSE);
g_free (str);
/* parse */
e_contact_get_const (c1, E_CONTACT_UID);
g_return_val_if_fail (e_vcard_is_parsed (E_VCARD (c1)) == TRUE, FALSE);
str = e_vcard_to_string (E_VCARD (c1), EVC_FORMAT_VCARD_30);
g_return_val_if_fail (str != NULL, FALSE);
g_return_val_if_fail (g_ascii_strcasecmp (str, vcard_str) == 0, FALSE);
g_free (str);
/* parse */
e_contact_get_const (c1, E_CONTACT_FULL_NAME);
str = e_vcard_to_string (E_VCARD (c1), EVC_FORMAT_VCARD_30);
g_return_val_if_fail (str != NULL, FALSE);
g_return_val_if_fail (g_ascii_strcasecmp (str, vcard_str) == 0, FALSE);
g_free (str);
g_object_unref (c1);
/* not parsed again */
c1 = e_contact_new_from_vcard (vcard_str);
e_contact_set (c1, E_CONTACT_UID, "other-uid");
g_return_val_if_fail (e_vcard_is_parsed (E_VCARD (c1)) == FALSE, FALSE);
g_return_val_if_fail (compare_single_value (E_VCARD (c1), "UID", "other-uid"), FALSE);
g_return_val_if_fail (e_vcard_is_parsed (E_VCARD (c1)) == FALSE, FALSE);
str = e_vcard_to_string (E_VCARD (c1), EVC_FORMAT_VCARD_30);
c2 = e_contact_new_from_vcard (str);
g_return_val_if_fail (e_vcard_is_parsed (E_VCARD (c2)) == FALSE, FALSE);
g_free (str);
g_return_val_if_fail (compare_single_value (E_VCARD (c2), "UID", "other-uid"), FALSE);
g_object_unref (c2);
/* parse */
e_contact_get_const (c1, E_CONTACT_FULL_NAME);
g_return_val_if_fail (e_vcard_is_parsed (E_VCARD (c1)) == TRUE, FALSE);
g_return_val_if_fail (compare_single_value (E_VCARD (c1), "UID", "other-uid"), FALSE);
str = e_vcard_to_string (E_VCARD (c1), EVC_FORMAT_VCARD_30);
c2 = e_contact_new_from_vcard (str);
g_free (str);
g_return_val_if_fail (compare_single_value (E_VCARD (c2), "UID", "other-uid"), FALSE);
g_return_val_if_fail (has_only_one (E_VCARD (c1), "UID"), FALSE);
g_return_val_if_fail (has_only_one (E_VCARD (c2), "UID"), FALSE);
g_object_unref (c2);
g_object_unref (c1);
/* do not parse */
c1 = e_contact_new_from_vcard_with_uid (vcard_str, "other-uid");
g_return_val_if_fail (e_vcard_is_parsed (E_VCARD (c1)) == FALSE, FALSE);
g_return_val_if_fail (compare_single_value (E_VCARD (c1), "UID", "other-uid"), FALSE);
g_return_val_if_fail (e_vcard_is_parsed (E_VCARD (c1)) == FALSE, FALSE);
str = e_vcard_to_string (E_VCARD (c1), EVC_FORMAT_VCARD_30);
c2 = e_contact_new_from_vcard (str);
g_free (str);
g_return_val_if_fail (compare_single_value (E_VCARD (c2), "UID", "other-uid"), FALSE);
g_object_unref (c2);
/* parse */
e_contact_get_const (c1, E_CONTACT_FULL_NAME);
g_return_val_if_fail (compare_single_value (E_VCARD (c1), "UID", "other-uid"), FALSE);
g_return_val_if_fail (e_vcard_is_parsed (E_VCARD (c1)) == TRUE, FALSE);
str = e_vcard_to_string (E_VCARD (c1), EVC_FORMAT_VCARD_30);
c2 = e_contact_new_from_vcard (str);
g_free (str);
g_return_val_if_fail (compare_single_value (E_VCARD (c2), "UID", "other-uid"), FALSE);
g_return_val_if_fail (has_only_one (E_VCARD (c1), "UID"), FALSE);
g_return_val_if_fail (has_only_one (E_VCARD (c2), "UID"), FALSE);
g_object_unref (c2);
g_object_unref (c1);
return TRUE;
}
/* Calbacks */
static void
moko_contacts_add_contact (MokoContacts *contacts, EContact *e_contact)
{
MokoContactsPrivate *priv;
MokoContact *m_contact = NULL;
const gchar *name, *uid;
GList *attributes, *params, *numbers;
g_return_if_fail (MOKO_IS_CONTACTS (contacts));
g_return_if_fail (E_IS_CONTACT (e_contact));
priv = contacts->priv;
uid = e_contact_get_const (e_contact, E_CONTACT_UID);
if (g_hash_table_lookup (priv->uids, uid))
return;
name = e_contact_get_const (e_contact, E_CONTACT_FULL_NAME);
if (!name || (g_utf8_strlen (name, -1) <= 0))
name = "Unknown";
/* Create the contact & append to the list */
m_contact = g_new0 (MokoContact, 1);
m_contact->name = g_strdup (name);
m_contact->uid = g_strdup (uid);
m_contact->photo = NULL;
priv->contacts = g_list_append (priv->contacts, m_contact);
g_hash_table_insert (priv->uids,
g_strdup (uid),
m_contact);
/* Now go through the numbers,creating MokoNumber for them */
for (attributes = e_vcard_get_attributes (E_VCARD(e_contact)); attributes; attributes = attributes->next)
{
MokoContactEntry *entry;
const gchar *phone;
const char *attr;
attr = e_vcard_attribute_get_name (attributes->data);
if (!strcmp (attr, EVC_TEL))
{
for (numbers = e_vcard_attribute_get_values (attributes->data); numbers; numbers = numbers->next)
{
phone = numbers->data;
if (phone)
{
entry = g_new0 (MokoContactEntry, 1);
params = e_vcard_attribute_get_param (attributes->data, "TYPE");
if (params)
entry->desc = g_strdup (params->data);
entry->number = normalize (phone);
entry->contact = m_contact;
priv->entries = g_list_append (priv->entries, (gpointer)entry);
g_hash_table_insert (priv->prefixes,
g_strdup (entry->number),
(gpointer)entry);
add_number (&priv->start, entry);
}
}
}
}
}
static ESExpResult *
func_exists (struct _ESExp *f,
gint argc,
struct _ESExpResult **argv,
gpointer data)
{
SearchContext *ctx = data;
ESExpResult *r;
gint truth = FALSE;
if (argc == 1
&& argv[0]->type == ESEXP_RES_STRING) {
const gchar *propname;
struct prop_info *info = NULL;
gint i;
gboolean saw_any = FALSE;
propname = argv[0]->value.string;
for (i = 0; i < G_N_ELEMENTS (prop_info_table); i++) {
if (!strcmp (prop_info_table[i].query_prop, propname)) {
saw_any = TRUE;
info = &prop_info_table[i];
if (info->prop_type == PROP_TYPE_NORMAL) {
const gchar *prop = NULL;
/* searches where the query's property
* maps directly to an ecard property */
prop = e_contact_get_const (ctx->contact, info->field_id);
if (prop && *prop)
truth = TRUE;
}
else if (info->prop_type == PROP_TYPE_LIST) {
/* the special searches that match any of the list elements */
truth = info->list_compare (ctx->contact, "", NULL, exists_helper);
}
else if (info->prop_type == PROP_TYPE_DATE) {
EContactDate *date;
date = e_contact_get (ctx->contact, info->field_id);
if (date) {
truth = TRUE;
e_contact_date_free (date);
}
} else {
g_warn_if_reached ();
saw_any = FALSE;
}
break;
}
}
if (!saw_any) {
/* propname didn't match to any of our known "special" properties,
* so try to find if it isn't a real field and if so, then check
* against value in this field only */
EContactField fid = e_contact_field_id (propname);
if (fid >= E_CONTACT_FIELD_FIRST && fid < E_CONTACT_FIELD_LAST &&
e_contact_field_is_string (fid)) {
const gchar *prop = e_contact_get_const (ctx->contact, fid);
if (prop && *prop)
truth = TRUE;
} else {
/* is is not a known EContact field, try with EVCard attributes */
EVCardAttribute *attr;
GList *l, *values;
if (fid >= E_CONTACT_FIELD_FIRST && fid < E_CONTACT_FIELD_LAST)
propname = e_contact_vcard_attribute (fid);
attr = e_vcard_get_attribute (E_VCARD (ctx->contact), propname);
values = attr ? e_vcard_attribute_get_values (attr) : NULL;
for (l = values; l && !truth; l = l->next) {
const gchar *value = l->data;
if (value && *value)
truth = TRUE;
}
}
}
}
r = e_sexp_result_new (f, ESEXP_RES_BOOL);
r->value.boolean = truth;
return r;
}
static ESExpResult *
entry_compare (SearchContext *ctx,
struct _ESExp *f,
gint argc,
struct _ESExpResult **argv,
CompareFunc compare)
{
ESExpResult *r;
gint truth = FALSE;
if ((argc == 2
&& argv[0]->type == ESEXP_RES_STRING
&& argv[1]->type == ESEXP_RES_STRING) ||
(argc == 3
&& argv[0]->type == ESEXP_RES_STRING
&& argv[1]->type == ESEXP_RES_STRING
&& argv[2]->type == ESEXP_RES_STRING)) {
gchar *propname;
struct prop_info *info = NULL;
const gchar *region = NULL;
gint i;
gboolean any_field;
gboolean saw_any = FALSE;
if (argc > 2)
region = argv[2]->value.string;
propname = argv[0]->value.string;
any_field = !strcmp (propname, "x-evolution-any-field");
for (i = 0; i < G_N_ELEMENTS (prop_info_table); i++) {
if (any_field
|| !strcmp (prop_info_table[i].query_prop, propname)) {
saw_any = TRUE;
info = &prop_info_table[i];
if (any_field && info->field_id == E_CONTACT_UID) {
/* We need to skip UID from any field contains search
* any-field search should be supported for the
* visible fields only.
*/
truth = FALSE;
}
else if (info->prop_type == PROP_TYPE_NORMAL) {
const gchar *prop = NULL;
/* straight string property matches */
prop = e_contact_get_const (ctx->contact, info->field_id);
if (prop && compare (prop, argv[1]->value.string, region)) {
truth = TRUE;
}
if ((!prop) && compare ("", argv[1]->value.string, region)) {
truth = TRUE;
}
}
else if (info->prop_type == PROP_TYPE_LIST) {
/* the special searches that match any of the list elements */
truth = info->list_compare (ctx->contact, argv[1]->value.string, region, compare);
}
else if (info->prop_type == PROP_TYPE_DATE) {
/* the special searches that match dates */
EContactDate *date;
date = e_contact_get (ctx->contact, info->field_id);
if (date) {
truth = compare_date (date, argv[1]->value.string, region, compare);
e_contact_date_free (date);
}
} else {
g_warn_if_reached ();
saw_any = FALSE;
break;
}
/* if we're looking at all fields and find a match,
* or if we're just looking at this one field,
* break. */
if ((any_field && truth)
|| !any_field)
break;
}
}
if (!saw_any) {
/* propname didn't match to any of our known "special" properties,
* so try to find if it isn't a real field and if so, then compare
* against value in this field only */
EContactField fid = e_contact_field_id (propname);
if (fid >= E_CONTACT_FIELD_FIRST && fid < E_CONTACT_FIELD_LAST) {
const gchar *prop = e_contact_get_const (ctx->contact, fid);
if (prop && compare (prop, argv[1]->value.string, region)) {
truth = TRUE;
}
if ((!prop) && compare ("", argv[1]->value.string, region)) {
truth = TRUE;
}
} else {
/* it is not direct EContact known field, so try to find
* it in EVCard attributes */
GList *a, *attrs = e_vcard_get_attributes (E_VCARD (ctx->contact));
for (a = attrs; a && !truth; a = a->next) {
EVCardAttribute *attr = (EVCardAttribute *) a->data;
if (g_ascii_strcasecmp (e_vcard_attribute_get_name (attr), propname) == 0) {
GList *l, *values = e_vcard_attribute_get_values (attr);
for (l = values; l && !truth; l = l->next) {
const gchar *value = l->data;
if (value && compare (value, argv[1]->value.string, region)) {
truth = TRUE;
} else if ((!value) && compare ("", argv[1]->value.string, region)) {
truth = TRUE;
}
}
}
}
}
}
}
r = e_sexp_result_new (f, ESEXP_RES_BOOL);
r->value.boolean = truth;
return r;
}
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;
}
static void cache_cb(EBook *book, const GError *gerr, GList *contacts,
void *user_data)
{
struct query_context *data = user_data;
GList *l;
data->queued_calls--;
if (data->canceled)
goto canceled;
if (gerr != NULL) {
error("E-Book operation failed: %s", gerr->message);
goto done;
}
DBG("");
for (l = contacts; l; l = g_list_next(l)) {
EContact *contact = E_CONTACT(l->data);
EVCard *evcard = E_VCARD(contact);
EVCardAttribute *attrib;
char *uid, *tel, *name;
name = evcard_name_attribute_to_string(evcard);
if (!name)
continue;
attrib = e_vcard_get_attribute(evcard, EVC_UID);
if (!attrib)
continue;
uid = e_vcard_attribute_get_value(attrib);
if (!uid)
continue;
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, PHONEBOOK_INVALID_HANDLE, name, NULL,
tel, data->user_data);
g_free(name);
g_free(uid);
g_free(tel);
}
g_list_free_full(contacts, g_object_unref);
done:
if (data->queued_calls == 0)
data->ready_cb(data->user_data);
return;
canceled:
if (data->queued_calls == 0)
free_query_context(data);
}
