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;
}
/**
* 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;
}
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;
}
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 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;
}
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 char *evcard_to_string(EVCard *evcard, unsigned int format,
uint64_t filter)
{
EVCard *evcard2;
GList *l;
char *vcard;
if (!filter)
return e_vcard_to_string(evcard, EVC_FORMAT_VCARD_30);
/* XXX There is no support for VCARD 2.1 at this time */
/*
* Mandatory attributes for vCard 2.1 are VERSION ,N and TEL.
* Mandatory attributes for vCard 3.0 are VERSION, N, FN and TEL
*/
filter = format == EVC_FORMAT_VCARD_30 ? filter | 0x87: filter | 0x85;
l = e_vcard_get_attributes(evcard);
evcard2 = e_vcard_new();
for (; l; l = g_list_next(l)) {
EVCardAttribute *attrib = l->data;
const char *name;
int i;
if (!attrib)
continue;
name = e_vcard_attribute_get_name(attrib);
for (i = 0; attribute_mask[i] != NULL; i++) {
if (!(filter & (1 << i)))
continue;
if (g_strcmp0(name, attribute_mask[i]) != 0)
continue;
e_vcard_add_attribute(evcard2,
e_vcard_attribute_copy(attrib));
}
}
vcard = e_vcard_to_string(evcard2, format);
g_object_unref(evcard2);
return vcard;
}
gint
main (gint argc,
gchar **argv)
{
FILE *fp;
EVCard *vcard;
GString *str = g_string_new ("");
gchar *parsed_vcard;
if (argc < 2) {
g_warning ("Requires one parameter, a vCard file\n");
return 1;
}
fp = fopen (argv[1], "r");
if (fp == NULL) {
g_warning ("Faile to open vCard file '%s'", argv[1]);
return 1;
}
while (!feof (fp)) {
gchar buf[1024];
if (fgets (buf, sizeof (buf), fp))
str = g_string_append (str, buf);
}
fclose (fp);
vcard = e_vcard_new_from_string (str->str);
g_string_free (str, TRUE);
e_vcard_dump_structure (vcard);
parsed_vcard = e_vcard_to_string (vcard, EVC_FORMAT_VCARD_21);
printf ("\nvCard 2.1: %s\n", parsed_vcard);
g_free (parsed_vcard);
parsed_vcard = e_vcard_to_string (vcard, EVC_FORMAT_VCARD_30);
printf ("\nvCard 3.0: %s\n", parsed_vcard);
g_free (parsed_vcard);
g_object_unref (vcard);
return 0;
}
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
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
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;
}
/**
* 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);
}
gint
main (gint argc, gchar **argv)
{
FILE *fp;
EVCard *vcard;
GString *str = g_string_new ("");
gchar *parsed_vcard;
if (argc < 2)
return 0;
g_type_init_with_debug_flags (G_TYPE_DEBUG_OBJECTS);
fp = fopen (argv[1], "r");
while (!feof (fp)) {
gchar buf[1024];
if (fgets (buf, sizeof (buf), fp))
str = g_string_append (str, buf);
}
fclose (fp);
vcard = e_vcard_new_from_string (str->str);
e_vcard_dump_structure (vcard);
parsed_vcard = e_vcard_to_string (vcard, EVC_FORMAT_VCARD_30);
printf ("\nvcard: %s\n", parsed_vcard);
g_object_unref (vcard);
g_free (parsed_vcard);
return 0;
}
static gboolean
test_vcard (const gchar *vcard_str)
{
EVCard *vc1, *vc2;
gchar *str;
/* Do not parse */
vc1 = e_vcard_new_from_string (vcard_str);
str = e_vcard_to_string (vc1, 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 (vc1) == FALSE, FALSE);
g_free (str);
/* parse */
e_vcard_get_attribute (vc1, "UID");
g_return_val_if_fail (e_vcard_is_parsed (vc1) == TRUE, FALSE);
str = e_vcard_to_string (vc1, 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_vcard_get_attribute (vc1, "FN");
g_return_val_if_fail (e_vcard_is_parsed (vc1) == TRUE, FALSE);
str = e_vcard_to_string (vc1, 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 (vc1);
/* do not parse */
vc1 = e_vcard_new_from_string (vcard_str);
/* Setting the UID does not cause vCard parsing */
e_vcard_append_attribute_with_value (vc1, e_vcard_attribute_new (NULL, "UID"), "other-uid");
g_return_val_if_fail (e_vcard_is_parsed (vc1) == FALSE, FALSE);
/* Retrieving the UID should not cause vCard parsing either */
g_return_val_if_fail (compare_single_value (vc1, "UID", "other-uid"), FALSE);
g_return_val_if_fail (e_vcard_is_parsed (vc1) == FALSE, FALSE);
/* Getting FN attribute WILL cause parsing */
e_vcard_get_attribute (vc1, "FN");
g_return_val_if_fail (e_vcard_is_parsed (vc1) == TRUE, FALSE);
g_object_unref (vc1);
/* parse */
vc1 = e_vcard_new_from_string (vcard_str);
g_return_val_if_fail (e_vcard_is_parsed (vc1) == FALSE, FALSE);
e_vcard_remove_attributes (vc1, NULL, "UID");
g_return_val_if_fail (e_vcard_is_parsed (vc1) == TRUE, FALSE);
e_vcard_append_attribute_with_value (vc1, e_vcard_attribute_new (NULL, "UID"), "other-uid");
g_return_val_if_fail (compare_single_value (vc1, "UID", "other-uid"), FALSE);
str = e_vcard_to_string (vc1, EVC_FORMAT_VCARD_30);
vc2 = e_vcard_new_from_string (str);
g_free (str);
g_return_val_if_fail (compare_single_value (vc2, "UID", "other-uid"), FALSE);
g_object_unref (vc2);
/* parse */
e_vcard_get_attribute (vc1, "FN");
g_return_val_if_fail (e_vcard_is_parsed (vc1) == TRUE, FALSE);
g_return_val_if_fail (compare_single_value (vc1, "UID", "other-uid"), FALSE);
str = e_vcard_to_string (vc1, EVC_FORMAT_VCARD_30);
vc2 = e_vcard_new_from_string (str);
g_return_val_if_fail (e_vcard_is_parsed (vc2) == FALSE, FALSE);
g_free (str);
g_return_val_if_fail (compare_single_value (vc2, "UID", "other-uid"), FALSE);
g_return_val_if_fail (has_only_one (vc1, "UID"), FALSE);
g_return_val_if_fail (has_only_one (vc2, "UID"), FALSE);
g_object_unref (vc2);
g_object_unref (vc1);
return TRUE;
}
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;
}
static guint
upload_contact (EBookBackendWebdav *webdav,
EContact *contact,
gchar **reason,
GCancellable *cancellable)
{
ESource *source;
ESourceWebdav *webdav_extension;
SoupMessage *message;
gchar *uri;
gchar *etag;
const gchar *new_etag, *redir_uri;
gchar *request;
guint status;
gboolean avoid_ifmatch;
const gchar *extension_name;
source = e_backend_get_source (E_BACKEND (webdav));
extension_name = E_SOURCE_EXTENSION_WEBDAV_BACKEND;
webdav_extension = e_source_get_extension (source, extension_name);
source = e_backend_get_source (E_BACKEND (webdav));
uri = e_contact_get (contact, E_CONTACT_UID);
if (uri == NULL) {
g_warning ("can't upload contact without UID");
return 400;
}
message = soup_message_new (SOUP_METHOD_PUT, uri);
soup_message_headers_append (message->request_headers, "User-Agent", USERAGENT);
soup_message_headers_append (message->request_headers, "Connection", "close");
avoid_ifmatch = e_source_webdav_get_avoid_ifmatch (webdav_extension);
/* some servers (like apache < 2.2.8) don't handle If-Match, correctly so
* we can leave it out */
if (!avoid_ifmatch) {
/* only override if etag is still the same on the server */
etag = e_contact_get (contact, E_CONTACT_REV);
if (etag == NULL) {
soup_message_headers_append (
message->request_headers,
"If-None-Match", "*");
} else if (etag[0] == 'W' && etag[1] == '/') {
g_warning ("we only have a weak ETag, don't use If-Match synchronisation");
} else {
soup_message_headers_append (
message->request_headers,
"If-Match", etag);
g_free (etag);
}
}
request = e_vcard_to_string (E_VCARD (contact), EVC_FORMAT_VCARD_30);
soup_message_set_request (
message, "text/vcard", SOUP_MEMORY_TEMPORARY,
request, strlen (request));
status = send_and_handle_ssl (webdav, message, cancellable);
new_etag = soup_message_headers_get_list (message->response_headers, "ETag");
redir_uri = soup_message_headers_get_list (message->response_headers, "Location");
/* set UID and REV fields */
e_contact_set (contact, E_CONTACT_REV, (gconstpointer) new_etag);
if (redir_uri && *redir_uri) {
if (!strstr (redir_uri, "://")) {
/* it's a relative URI */
SoupURI *suri = soup_uri_new (uri);
gchar *full_uri;
soup_uri_set_path (suri, redir_uri);
full_uri = soup_uri_to_string (suri, TRUE);
e_contact_set (contact, E_CONTACT_UID, full_uri);
g_free (full_uri);
soup_uri_free (suri);
} else {
e_contact_set (contact, E_CONTACT_UID, redir_uri);
}
} else {
e_contact_set (contact, E_CONTACT_UID, uri);
}
if (reason) {
*reason = g_strdup (message->reason_phrase && *message->reason_phrase ? message->reason_phrase :
(soup_status_get_phrase (message->status_code) ? soup_status_get_phrase (message->status_code) : _("Unknown error")));
}
g_object_unref (message);
g_free (request);
g_free (uri);
return status;
}
static void
ebbm_contacts_get_contact (EBookBackendMAPI *ebma, GCancellable *cancellable, const gchar *id, gchar **vcard, GError **error)
{
EBookBackendMAPIContacts *ebmac;
EBookBackendMAPIContactsPrivate *priv;
EMapiConnection *conn;
mapi_id_t mid;
mapi_object_t obj_folder;
struct TransferContactData tc = { 0 };
gboolean status, has_obj_folder;
GError *mapi_error = NULL;
e_mapi_return_data_book_error_if_fail (ebma != NULL, E_DATA_BOOK_STATUS_INVALID_ARG);
e_mapi_return_data_book_error_if_fail (E_IS_BOOK_BACKEND_MAPI_CONTACTS (ebma), E_DATA_BOOK_STATUS_INVALID_ARG);
e_mapi_return_data_book_error_if_fail (id != NULL, E_DATA_BOOK_STATUS_INVALID_ARG);
e_mapi_return_data_book_error_if_fail (vcard != NULL, E_DATA_BOOK_STATUS_INVALID_ARG);
ebmac = E_BOOK_BACKEND_MAPI_CONTACTS (ebma);
e_mapi_return_data_book_error_if_fail (ebmac != NULL, E_DATA_BOOK_STATUS_INVALID_ARG);
priv = ebmac->priv;
e_mapi_return_data_book_error_if_fail (priv != NULL, E_DATA_BOOK_STATUS_INVALID_ARG);
if (E_BOOK_BACKEND_MAPI_CLASS (e_book_backend_mapi_contacts_parent_class)->op_get_contact)
E_BOOK_BACKEND_MAPI_CLASS (e_book_backend_mapi_contacts_parent_class)->op_get_contact (ebma, cancellable, id, vcard, &mapi_error);
if (mapi_error) {
g_propagate_error (error, mapi_error);
return;
}
/* found in a cache */
if (*vcard)
return;
e_book_backend_mapi_lock_connection (ebma);
conn = e_book_backend_mapi_get_connection (ebma, cancellable, &mapi_error);
if (!conn) {
e_book_backend_mapi_unlock_connection (ebma);
if (!mapi_error)
g_propagate_error (error, EDB_ERROR (REPOSITORY_OFFLINE));
else
mapi_error_to_edb_error (error, mapi_error, E_DATA_BOOK_STATUS_REPOSITORY_OFFLINE, NULL);
g_clear_error (&mapi_error);
return;
}
status = ebbm_contacts_open_folder (ebmac, conn, &obj_folder, cancellable, &mapi_error);
has_obj_folder = status;
if (status) {
status = e_mapi_util_mapi_id_from_string (id, &mid);
if (!status) {
g_debug ("%s: Failed to decode MID from '%s'", G_STRFUNC, id);
}
}
if (status) {
tc.ebma = ebma;
tc.contact = NULL;
e_mapi_connection_transfer_object (conn, &obj_folder, mid, transfer_contact_cb, &tc, cancellable, &mapi_error);
}
if (has_obj_folder)
e_mapi_connection_close_folder (conn, &obj_folder, cancellable, &mapi_error);
if (tc.contact) {
*vcard = e_vcard_to_string (E_VCARD (tc.contact), EVC_FORMAT_VCARD_30);
g_object_unref (tc.contact);
} else {
e_book_backend_mapi_maybe_disconnect (ebma, mapi_error);
if (!mapi_error || mapi_error->code == MAPI_E_NOT_FOUND) {
g_propagate_error (error, EDB_ERROR (CONTACT_NOT_FOUND));
} else {
mapi_error_to_edb_error (error, mapi_error, E_DATA_BOOK_STATUS_CONTACT_NOT_FOUND, NULL);
}
if (mapi_error)
g_error_free (mapi_error);
}
e_book_backend_mapi_unlock_connection (ebma);
}