static gboolean
setup_book (EBookClient **book_out)
{
GError *error = NULL;
gint i;
g_return_val_if_fail (book_out != NULL, FALSE);
*book_out = new_temp_client (NULL);
g_return_val_if_fail (*book_out != NULL, FALSE);
if (!e_client_open_sync (E_CLIENT (*book_out), FALSE, NULL, &error)) {
report_error ("client open sync", &error);
g_object_unref (*book_out);
return FALSE;
}
for (i = 0; i < N_TEST_CONTACTS; i++)
{
EContact *contact = e_contact_new ();
gchar *name = g_strdup_printf ("Contact #%d", i + 1);
e_contact_set (contact, E_CONTACT_FULL_NAME, name);
e_contact_set (contact, E_CONTACT_NICKNAME, name);
/* verify the contact was added "successfully" (not thorough) */
if (!add_contact_verify (*book_out, contact))
g_error ("Failed to add contact");
g_free (name);
g_object_unref (contact);
}
return TRUE;
}
static void
add_contact_inline (EBookClient *book)
{
EContact *contact;
EContactPhoto *photo;
guchar *data;
gsize length = 0;
contact = e_contact_new ();
data = g_base64_decode (photo_data, &length);
photo = g_new (EContactPhoto, 1);
photo->type = E_CONTACT_PHOTO_TYPE_INLINED;
photo->data.inlined.mime_type = NULL;
photo->data.inlined.data = data;
photo->data.inlined.length = length;
/* set the photo */
e_contact_set (contact, E_CONTACT_PHOTO, photo);
e_contact_set (contact, E_CONTACT_FULL_NAME, "Micheal Jackson");
if (!add_contact_verify (book, contact))
g_error ("Failed to add contact");
micheal_jackson_uid = e_contact_get (contact, E_CONTACT_UID);
}
static EContact *
getNextLDIFEntry (GHashTable *dn_contact_hash,
FILE *f)
{
EContact *contact;
EContactAddress *work_address, *home_address;
GString *str;
gchar line[1024];
gchar *buf;
str = g_string_new ("");
/* read from the file until we get to a blank line (or eof) */
while (!feof (f)) {
if (!fgets (line, sizeof (line), f))
break;
if (line[0] == '\n' || (line[0] == '\r' && line[1] == '\n'))
break;
str = g_string_append (str, line);
}
if (strlen (str->str) == 0) {
g_string_free (str, TRUE);
return NULL;
}
/* now parse that entry */
contact = e_contact_new ();
work_address = g_new0 (EContactAddress, 1);
home_address = g_new0 (EContactAddress, 1);
buf = str->str;
while (buf) {
if (!parseLine (dn_contact_hash, contact, work_address, home_address, &buf)) {
/* parsing error */
g_string_free (str, TRUE);
e_contact_address_free (work_address);
e_contact_address_free (home_address);
g_object_unref (contact);
return NULL;
}
}
/* fill in the address */
if (work_address->locality || work_address->country || work_address->ext ||
work_address->code || work_address->region || work_address->street) {
e_contact_set (contact, E_CONTACT_ADDRESS_WORK, work_address);
}
if (home_address->locality || home_address->country || home_address->ext ||
home_address->code || home_address->region || home_address->street) {
e_contact_set (contact, E_CONTACT_ADDRESS_HOME, home_address);
}
e_contact_address_free (work_address);
e_contact_address_free (home_address);
g_string_free (str, TRUE);
return contact;
}
static gboolean
bbdb_merge_buddy_to_contact (EBook *book, GaimBuddy *b, EContact *c)
{
EContactField field;
GList *ims, *l;
gboolean dirty = FALSE;
EContactPhoto *photo = NULL;
GError *error = NULL;
/* Set the IM account */
field = proto_to_contact_field (b->proto);
ims = e_contact_get (c, field);
if (! im_list_contains_buddy (ims, b)) {
ims = g_list_append (ims, (gpointer) b->account_name);
e_contact_set (c, field, (gpointer) ims);
dirty = TRUE;
}
/* Set the photo if it's not set */
if (b->icon != NULL) {
photo = e_contact_get (c, E_CONTACT_PHOTO);
if (photo == NULL) {
gchar *contents = NULL;
photo = g_new0 (EContactPhoto, 1);
photo->type = E_CONTACT_PHOTO_TYPE_INLINED;
if (! g_file_get_contents (b->icon, &contents, &photo->data.inlined.length, &error)) {
g_warning ("bbdb: Could not read buddy icon: %s\n", error->message);
g_error_free (error);
for (l = ims; l != NULL; l = l->next)
g_free ((char *) l->data);
g_list_free (ims);
return dirty;
}
photo->data.inlined.data = (unsigned char *)contents;
e_contact_set (c, E_CONTACT_PHOTO, (gpointer) photo);
dirty = TRUE;
}
}
/* Clean up */
if (photo != NULL)
e_contact_photo_free (photo);
for (l = ims; l != NULL; l = l->next)
g_free ((char *) l->data);
g_list_free (ims);
return dirty;
}
static void
dropdown_changed (GtkWidget *dropdown,
dropdown_data *data)
{
gchar *str = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (dropdown));
if (str && *str)
e_contact_set (data->match, data->field, str);
else
e_contact_set (data->match, data->field, NULL);
g_free (str);
}
/* This provokes the backend to handle a cross-referenced photo
* between contacts, how the backend handles this is it's choice,
* we should test that when deleting one of the contacts, the other
* contact does not lose it's photo on disk as a result.
*/
static void
give_james_brown_micheal_jacksons_face (EBookClient *book)
{
EContact *micheal = NULL, *james = NULL;
EContactPhoto *micheal_face;
EContactPhoto *james_face;
GError *error = NULL;
if (!e_book_client_get_contact_sync (book, micheal_jackson_uid, &micheal, NULL, &error))
g_error ("Unable to get micheal jackson's contact information: %s", error->message);
if (!e_book_client_get_contact_sync (book, james_brown_uid, &james, NULL, &error))
g_error ("Unable to get james brown's contact information: %s", error->message);
g_assert (micheal);
g_assert (james);
micheal_face = e_contact_get (micheal, E_CONTACT_PHOTO);
g_assert (micheal_face->type == E_CONTACT_PHOTO_TYPE_URI);
james_face = g_new (EContactPhoto, 1);
james_face->type = E_CONTACT_PHOTO_TYPE_URI;
james_face->data.uri = g_strdup (micheal_face->data.uri);
e_contact_set (james, E_CONTACT_PHOTO, james_face);
g_print ("Giving james brown micheal jacksons face: %s\n", micheal_face->data.uri);
if (!e_book_client_modify_contact_sync (book, james, NULL, &error))
g_error ("Failed to modify contact with cross referenced photo: %s", error->message);
}
static void
contact_list_editor_list_added_cb (EBook *book,
EBookStatus status,
const gchar *id,
EditorCloseStruct *ecs)
{
EContactListEditor *editor = ecs->editor;
EContactListEditorPrivate *priv = editor->priv;
gboolean should_close = ecs->should_close;
gtk_widget_set_sensitive (WIDGET (DIALOG), TRUE);
priv->in_async_call = FALSE;
e_contact_set (priv->contact, E_CONTACT_UID, (gchar *) id);
eab_editor_contact_added (
EAB_EDITOR (editor), status, priv->contact);
if (status == E_BOOK_ERROR_OK) {
priv->is_new_list = FALSE;
if (should_close)
eab_editor_close (EAB_EDITOR (editor));
else
contact_list_editor_update (editor);
}
g_object_unref (editor);
g_free (ecs);
}
static gboolean
csv_import_contacts (gpointer d)
{
CSVImporter *gci = d;
EContact *contact = NULL;
while ((contact = getNextCSVEntry (gci, gci->file))) {
gchar *uid = NULL;
e_book_client_add_contact_sync (
gci->book_client, contact, &uid, NULL, NULL);
if (uid != NULL) {
e_contact_set (contact, E_CONTACT_UID, uid);
g_free (uid);
}
gci->contacts = g_slist_prepend (gci->contacts, contact);
}
if (contact == NULL) {
gci->state = 1;
}
if (gci->state == 1) {
csv_import_done (gci);
return FALSE;
}
else {
e_import_status (
gci->import, gci->target, _("Importing..."),
ftell (gci->file) * 100 / gci->size);
return TRUE;
}
}
static void
add_to_notes (EContact *contact,
EContactField field)
{
const gchar *old_text;
const gchar *field_text;
gchar *new_text;
old_text = e_contact_get_const (contact, E_CONTACT_NOTE);
if (old_text && strstr (old_text, e_contact_pretty_name (field)))
return;
field_text = e_contact_get_const (contact, field);
if (!field_text || !*field_text)
return;
new_text = g_strdup_printf (
"%s%s%s: %s",
old_text ? old_text : "",
old_text && *old_text &&
*(old_text + strlen (old_text) - 1) != '\n' ? "\n" : "",
e_contact_pretty_name (field), field_text);
e_contact_set (contact, E_CONTACT_NOTE, new_text);
g_free (new_text);
}
static void
local_record_from_uid (EAddrLocalRecord *local,
const char *uid,
EAddrConduitContext *ctxt)
{
EContact *contact = NULL;
const char *cuid;
GList *l;
g_assert (local != NULL);
for (l = ctxt->cards; l != NULL; l = l->next) {
contact = l->data;
/* FIXME Do we need to check for the empty string? */
if ((cuid = e_contact_get_const (contact, E_CONTACT_UID)) && !strcmp (cuid, uid))
break;
contact = NULL;
}
if (contact != NULL) {
local_record_from_ecard (local, contact, ctxt);
} else {
contact = e_contact_new ();
e_contact_set (contact, E_CONTACT_UID, (gpointer) uid);
local_record_from_ecard (local, contact, ctxt);
g_object_unref (contact);
}
}
static void
update_contact_inline (EBookClient *book,
const gchar *uid)
{
EContact *contact = NULL;
EContactPhoto *photo;
guchar *data;
gsize length = 0;
GError *error = NULL;
if (!e_book_client_get_contact_sync (book, uid, &contact, NULL, &error))
g_error ("Unable to get contact: %s", error->message);
g_assert (contact);
data = g_base64_decode (photo_data, &length);
photo = g_new (EContactPhoto, 1);
photo->type = E_CONTACT_PHOTO_TYPE_INLINED;
photo->data.inlined.mime_type = NULL;
photo->data.inlined.data = data;
photo->data.inlined.length = length;
/* set the photo */
e_contact_set (contact, E_CONTACT_PHOTO, photo);
if (!e_book_client_modify_contact_sync (book, contact, NULL, &error))
g_error ("Failed to modify contact with inline photo data: %s", error->message);
}
gboolean
add_contact_from_test_case_verify (EBookClient *book_client,
const gchar *case_name,
EContact **contact)
{
gchar *vcard;
EContact *contact_orig;
EContact *contact_final;
gchar *uid;
GError *error = NULL;
vcard = new_vcard_from_test_case (case_name);
contact_orig = e_contact_new_from_vcard (vcard);
g_free (vcard);
if (!e_book_client_add_contact_sync (book_client, contact_orig, &uid, NULL, &error))
g_error ("add contact sync: %s", error->message);
e_contact_set (contact_orig, E_CONTACT_UID, uid);
if (!e_book_client_get_contact_sync (book_client, uid, &contact_final, NULL, &error))
g_error ("get contact sync: %s", error->message);
/* verify the contact was added "successfully" (not thorough) */
g_assert (contacts_are_equal_shallow (contact_orig, contact_final));
if (contact)
*contact = contact_final;
else
g_object_unref (contact_final);
g_object_unref (contact_orig);
g_free (uid);
return TRUE;
}
/****************************************************************
* Modify/Setup the EBook *
****************************************************************/
static void
add_contact (EBookClient *client)
{
EContact *contact = e_contact_new ();
e_contact_set (contact, E_CONTACT_FULL_NAME, "Micheal Jackson");
if (!add_contact_verify (client, contact))
g_error ("Failed to add Micheal Jackson");
g_object_unref (contact);
}
/****************************************************************
* Modify/Setup the EBook *
****************************************************************/
static void
add_contact (EBookClient *client)
{
EContact *contact = e_contact_new ();
e_contact_set (contact, E_CONTACT_FULL_NAME, "Micheal Jackson");
if (!add_contact_verify (client, contact))
stop_main_loop (1);
g_object_unref (contact);
}
static void
add_contact_uri (EBookClient *book)
{
EContact *contact;
EContactPhoto *photo;
contact = e_contact_new ();
photo = g_new (EContactPhoto, 1);
photo->type = E_CONTACT_PHOTO_TYPE_URI;
photo->data.uri = g_strdup ("http://en.wikipedia.org/wiki/File:Jamesbrown4.jpg");
/* set the photo */
e_contact_set (contact, E_CONTACT_PHOTO, photo);
e_contact_set (contact, E_CONTACT_FULL_NAME, "James Brown");
if (!add_contact_verify (book, contact))
g_error ("Failed to add contact");
james_brown_uid = e_contact_get (contact, E_CONTACT_UID);
}
static void
setup_book (EBookClient *book_client)
{
gint i;
for (i = 0; i < N_TEST_CONTACTS; i++)
{
EContact *contact = e_contact_new ();
gchar *name = g_strdup_printf ("Contact #%d", i + 1);
e_contact_set (contact, E_CONTACT_FULL_NAME, name);
e_contact_set (contact, E_CONTACT_NICKNAME, name);
/* verify the contact was added "successfully" (not thorough) */
if (!add_contact_verify (book_client, contact))
g_error ("Failed to add contact");
g_free (name);
g_object_unref (contact);
}
}
static void
set_contact_text (EContact *contact, EContactField field, struct Address address, int entry)
{
char *text = NULL;
if (address.entry[entry])
text = e_pilot_utf8_from_pchar (address.entry[entry]);
e_contact_set (contact, field, text);
g_free (text);
}
static void
set_revision (EContact *contact)
{
gchar time_string[100] = {0};
const struct tm *tm = NULL;
time_t t;
t = time (NULL);
tm = gmtime (&t);
if (tm)
strftime (time_string, 100, "%Y-%m-%dT%H:%M:%SZ", tm);
e_contact_set (contact, E_CONTACT_REV, time_string);
}
static EContact *
download_contact (EBookBackendWebdav *webdav,
const gchar *uri,
GCancellable *cancellable)
{
SoupMessage *message;
const gchar *etag;
EContact *contact;
guint status;
message = soup_message_new (SOUP_METHOD_GET, uri);
soup_message_headers_append (message->request_headers, "User-Agent", USERAGENT);
soup_message_headers_append (message->request_headers, "Connection", "close");
status = send_and_handle_ssl (webdav, message, cancellable);
if (status != 200) {
g_warning ("Couldn't load '%s' (http status %d)", uri, status);
g_object_unref (message);
return NULL;
}
if (message->response_body == NULL) {
g_message ("no response body after requesting '%s'", uri);
g_object_unref (message);
return NULL;
}
if (message->response_body->length <= 11 || 0 != g_ascii_strncasecmp ((const gchar *) message->response_body->data, "BEGIN:VCARD", 11)) {
g_object_unref (message);
return NULL;
}
etag = soup_message_headers_get_list (message->response_headers, "ETag");
/* we use our URI as UID */
contact = e_contact_new_from_vcard_with_uid (message->response_body->data, uri);
if (contact == NULL) {
g_warning ("Invalid vcard at '%s'", uri);
g_object_unref (message);
return NULL;
}
/* the etag is remembered in the revision field */
if (etag != NULL) {
e_contact_set (contact, E_CONTACT_REV, (gconstpointer) etag);
}
g_object_unref (message);
return contact;
}
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);
}
void
kolab_util_backend_modtime_set_on_econtact (EContact *econtact)
{
time_t rawtime;
struct tm *ts = NULL;
gchar *buf = NULL;
g_assert (E_IS_CONTACT (econtact));
time (&rawtime);
ts = gmtime (&rawtime);
buf = g_new0 (gchar, 21);
strftime (buf, 21, "%Y-%m-%dT%H:%M:%SZ", ts); /* same as in contact-i-to-e.c */
e_contact_set (econtact, E_CONTACT_REV, buf);
g_free (buf);
} /* kolab_util_backend_modtime_set_on_econtact () */
static void
resolve_list_card (LDIFImporter *gci,
EContact *contact)
{
GList *email, *l;
GList *email_attrs = NULL;
gchar *full_name;
/* set file_as to full_name so we don't later try and figure
* out a first/last name for the list. */
full_name = e_contact_get (contact, E_CONTACT_FULL_NAME);
if (full_name)
e_contact_set (contact, E_CONTACT_FILE_AS, full_name);
g_free (full_name);
/* FIMXE getting might not be implemented in ebook */
email = e_contact_get (contact, E_CONTACT_EMAIL);
for (l = email; l; l = l->next) {
/* mozilla stuffs dn's in the EMAIL list for contact lists */
gchar *dn = l->data;
EContact *dn_contact = g_hash_table_lookup (gci->dn_contact_hash, dn);
/* break list chains here, since we don't support them just yet */
if (dn_contact && !e_contact_get (dn_contact, E_CONTACT_IS_LIST)) {
EDestination *dest;
EVCardAttribute *attr = e_vcard_attribute_new (NULL, EVC_EMAIL);
/* Hard-wired for default e-mail, since
* netscape only exports 1 email address. */
dest = e_destination_new ();
e_destination_set_contact (dest, dn_contact, 0);
e_destination_export_to_vcard_attribute (dest, attr);
g_object_unref (dest);
email_attrs = g_list_append (email_attrs, attr);
}
}
e_contact_set_attributes (contact, E_CONTACT_EMAIL, email_attrs);
g_list_foreach (email, (GFunc) g_free, NULL);
g_list_free (email);
g_list_foreach (email_attrs, (GFunc) e_vcard_attribute_free, NULL);
g_list_free (email_attrs);
}
gint
main (gint argc,
gchar **argv)
{
EContact *contact;
g_type_init ();
contact = e_contact_new ();
e_contact_set (contact, E_CONTACT_UID, TEST_ID);
if (!strcmp (e_contact_get_const (contact, E_CONTACT_UID), TEST_ID))
printf ("passed\n");
else
printf ("failed\n");
return 0;
}
static void
add_to_notes (EContact *contact,
const gchar *field_text,
gchar *val)
{
GString *new_text;
if (!field_text || !val || !*val)
return;
new_text = g_string_new (e_contact_get_const (contact, E_CONTACT_NOTE));
if (strlen (new_text->str) != 0)
new_text = g_string_append_c (new_text, '\n');
new_text = g_string_append (new_text, field_text);
new_text = g_string_append_c (new_text, ':');
new_text = g_string_append (new_text, val);
e_contact_set (contact, E_CONTACT_NOTE, new_text->str);
g_string_free (new_text, TRUE);
}
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;
}
gboolean
add_contact_verify (EBookClient *book_client,
EContact *contact)
{
EContact *contact_final;
gchar *uid;
GError *error = NULL;
if (!e_book_client_add_contact_sync (book_client, contact, &uid, NULL, &error))
g_error ("add contact sync: %s", error->message);
e_contact_set (contact, E_CONTACT_UID, uid);
if (!e_book_client_get_contact_sync (book_client, uid, &contact_final, NULL, &error))
g_error ("get contact sync: %s", error->message);
/* verify the contact was added "successfully" (not thorough) */
g_assert (contacts_are_equal_shallow (contact, contact_final));
g_object_unref (contact_final);
g_free (uid);
return TRUE;
}
static gboolean
test_bulk_modify (EBookClient *client,
const gchar *vcard_str,
gint batch_size)
{
gint i;
EContact *contact;
GSList *contacts = NULL;
GSList *added_uids = NULL;
const GSList *l, *ll;
const gchar *old_first_name = "xyz mix";
const gchar *new_first_name = "abc mix";
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);
g_print (" * Bulk modification of %d contacts...\n", batch_size);
ll = added_uids;
for (l = contacts; l != NULL; l = l->next) {
const gchar * uid = ll->data;
contact = E_CONTACT (l->data);
/* Set contact UID */
e_contact_set (contact, E_CONTACT_UID, uid);
/* Change contact first name */
e_contact_set (contact, E_CONTACT_GIVEN_NAME, new_first_name);
ll = ll->next;
}
g_return_val_if_fail (e_book_client_modify_contacts_sync (client, contacts, NULL, NULL), FALSE);
/* Validate */
for (ll = added_uids; ll != NULL; ll = ll->next) {
const gchar *first_name;
const gchar *uid = ll->data;
contact = NULL;
g_return_val_if_fail (e_book_client_get_contact_sync (client, uid, &contact, NULL, NULL), FALSE);
/* Check contact first name */
first_name = e_contact_get_const (contact, E_CONTACT_GIVEN_NAME);
g_return_val_if_fail (g_strcmp0 (first_name, new_first_name) == 0, FALSE);
g_object_unref (contact);
}
/* Test failure case */
g_print (" * Bulk modification of %d contacts (expected failure)...\n", batch_size);
contact = E_CONTACT (g_slist_nth_data (contacts, g_slist_length (contacts) - 2));
g_return_val_if_fail (e_book_client_remove_contact_sync (client, contact, NULL, NULL), FALSE);
for (l = contacts; l != NULL; l = l->next) {
contact = E_CONTACT (l->data);
/* Change contact first name */
e_contact_set (contact, E_CONTACT_GIVEN_NAME, old_first_name);
}
g_return_val_if_fail (!e_book_client_modify_contacts_sync (client, contacts, NULL, NULL), FALSE);
/* Remove the UID that no longer exists from the added_uid list */
added_uids = g_slist_delete_link (added_uids, g_slist_nth (added_uids, g_slist_length (added_uids) - 2));
/* Validate */
for (ll = added_uids; ll != NULL; ll = ll->next) {
const gchar *first_name;
const gchar *uid = ll->data;
contact = NULL;
g_return_val_if_fail (e_book_client_get_contact_sync (client, uid, &contact, NULL, NULL), FALSE);
/* Check contact first name */
first_name = e_contact_get_const (contact, E_CONTACT_GIVEN_NAME);
g_return_val_if_fail (g_strcmp0 (first_name, new_first_name) == 0, FALSE);
g_object_unref (contact);
}
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);
g_slist_free_full (added_uids, g_free);
g_slist_free_full (contacts, g_object_unref);
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 gboolean
parseLine (CSVImporter *gci,
EContact *contact,
gchar *buf)
{
const gchar *pptr = buf, *field_text;
gchar *do_free = NULL;
GString *value;
gint ii = 0, idx;
gint flags = 0;
gint contact_field;
EContactAddress *home_address = NULL, *work_address = NULL, *other_address = NULL;
EContactDate *bday = NULL;
GString *home_street, *work_street, *other_street;
home_street = g_string_new ("");
work_street = g_string_new ("");
other_street = g_string_new ("");
home_address = e_contact_address_new ();
work_address = e_contact_address_new ();
other_address = e_contact_address_new ();
bday = e_contact_date_new ();
if (!g_utf8_validate (pptr, -1, NULL)) {
do_free = g_convert (pptr, -1, "UTF-8", "ISO-8859-1", NULL, NULL, NULL);
pptr = do_free;
}
while (value = parseNextValue (&pptr), value != NULL) {
contact_field = NOMAP;
flags = FLAG_INVALID;
field_text = NULL;
idx = ii;
if (gci->fields_map) {
gpointer found;
found = g_hash_table_lookup (
gci->fields_map, GINT_TO_POINTER (idx));
if (found == NULL) {
g_warning ("%s: No map for index %d, skipping it", G_STRFUNC, idx);
idx = -1;
} else {
idx = GPOINTER_TO_INT (found) - 1;
}
}
if (importer == OUTLOOK_IMPORTER) {
if (idx >= 0 && idx < G_N_ELEMENTS (csv_fields_outlook)) {
contact_field = csv_fields_outlook[idx].contact_field;
flags = csv_fields_outlook[idx].flags;
field_text = csv_fields_outlook[idx].csv_attribute;
}
}
else if (importer == MOZILLA_IMPORTER) {
if (idx >= 0 && idx < G_N_ELEMENTS (csv_fields_mozilla)) {
contact_field = csv_fields_mozilla[idx].contact_field;
flags = csv_fields_mozilla[idx].flags;
field_text = csv_fields_mozilla[idx].csv_attribute;
}
}
else {
if (idx >= 0 && idx < G_N_ELEMENTS (csv_fields_evolution)) {
contact_field = csv_fields_evolution[idx].contact_field;
flags = csv_fields_evolution[idx].flags;
field_text = csv_fields_evolution[idx].csv_attribute;
}
}
if (*value->str) {
if (contact_field != NOMAP) {
if (importer == OUTLOOK_IMPORTER || importer == MOZILLA_IMPORTER) {
e_contact_set (contact, contact_field, value->str);
} else {
if (contact_field == E_CONTACT_WANTS_HTML)
e_contact_set (
contact, contact_field,
GINT_TO_POINTER (
g_ascii_strcasecmp (
value->str, "TRUE") == 0));
else
e_contact_set (contact, contact_field, value->str);
}
}
else {
switch (flags) {
case FLAG_HOME_ADDRESS | FLAG_STREET:
if (strlen (home_street->str) != 0) {
home_street = g_string_append (home_street, ",\n");
}
home_street = g_string_append (home_street, value->str);
break;
case FLAG_HOME_ADDRESS | FLAG_CITY:
home_address->locality = g_strdup (value->str);
break;
case FLAG_HOME_ADDRESS | FLAG_STATE:
home_address->region = g_strdup (value->str);
break;
case FLAG_HOME_ADDRESS | FLAG_POSTAL_CODE:
home_address->code = g_strdup (value->str);
break;
case FLAG_HOME_ADDRESS | FLAG_POBOX:
home_address->po = g_strdup (value->str);
break;
case FLAG_HOME_ADDRESS | FLAG_COUNTRY:
home_address->country = g_strdup (value->str);
break;
case FLAG_WORK_ADDRESS | FLAG_STREET:
if (strlen (work_street->str) != 0) {
work_street = g_string_append (work_street, ",\n");
}
work_street = g_string_append (work_street, value->str);
break;
case FLAG_WORK_ADDRESS | FLAG_CITY:
work_address->locality = g_strdup (value->str);
break;
case FLAG_WORK_ADDRESS | FLAG_STATE:
work_address->region = g_strdup (value->str);
break;
case FLAG_WORK_ADDRESS | FLAG_POSTAL_CODE:
work_address->code = g_strdup (value->str);
break;
case FLAG_WORK_ADDRESS | FLAG_POBOX:
work_address->po = g_strdup (value->str);
break;
case FLAG_WORK_ADDRESS | FLAG_COUNTRY:
work_address->country = g_strdup (value->str);
break;
case FLAG_OTHER_ADDRESS | FLAG_STREET:
if (strlen (other_street->str) != 0) {
other_street = g_string_append (other_street, ",\n");
}
other_street = g_string_append (other_street, value->str);
break;
case FLAG_OTHER_ADDRESS | FLAG_CITY:
other_address->locality = g_strdup (value->str);
break;
case FLAG_OTHER_ADDRESS | FLAG_STATE:
other_address->region = g_strdup (value->str);
break;
case FLAG_OTHER_ADDRESS | FLAG_POSTAL_CODE:
other_address->code = g_strdup (value->str);
break;
case FLAG_OTHER_ADDRESS | FLAG_POBOX:
other_address->po = g_strdup (value->str);
break;
case FLAG_OTHER_ADDRESS | FLAG_COUNTRY:
other_address->country = g_strdup (value->str);
break;
case FLAG_DATE_BDAY:
e_contact_set (
contact,
E_CONTACT_BIRTH_DATE,
date_from_string (value->str));
break;
case FLAG_DATE_ANNIVERSARY:
e_contact_set (
contact,
E_CONTACT_ANNIVERSARY,
date_from_string (value->str));
break;
case FLAG_BIRTH_DAY:
bday->day = atoi (value->str);
break;
case FLAG_BIRTH_YEAR:
bday->year = atoi (value->str);
break;
case FLAG_BIRTH_MONTH:
bday->month = atoi (value->str);
break;
case FLAG_INVALID:
break;
default:
add_to_notes (contact, field_text, value->str);
}
}
}
ii++;
g_string_free (value, TRUE);
}
if (strlen (home_street->str) != 0)
home_address->street = g_strdup (home_street->str);
if (strlen (work_street->str) != 0)
work_address->street = g_strdup (work_street->str);
if (strlen (other_street->str) != 0)
other_address->street = g_strdup (other_street->str);
g_string_free (home_street, TRUE);
g_string_free (work_street, TRUE);
g_string_free (other_street, TRUE);
if (home_address->locality || home_address->country ||
home_address->code || home_address->region || home_address->street)
e_contact_set (contact, E_CONTACT_ADDRESS_HOME, home_address);
if (work_address->locality || work_address->country ||
work_address->code || work_address->region || work_address->street)
e_contact_set (contact, E_CONTACT_ADDRESS_WORK, work_address);
if (other_address->locality || other_address->country ||
other_address->code || other_address->region || other_address->street)
e_contact_set (contact, E_CONTACT_ADDRESS_OTHER, other_address);
if (importer != OUTLOOK_IMPORTER) {
if (bday->day || bday->year || bday->month)
e_contact_set (contact, E_CONTACT_BIRTH_DATE, bday);
}
e_contact_address_free (home_address);
e_contact_address_free (work_address);
e_contact_address_free (other_address);
e_contact_date_free (bday);
g_free (do_free);
return TRUE;
}
static void
import_contact (EBookClient *book_client,
gchar *line)
{
gchar **strings, *addr, **addrs;
gint i;
GList *list;
/*EContactName *name;*/
EContact *card;
gsize len;
GError *error = NULL;
card = e_contact_new ();
strings = g_strsplit (line, "\t", 5);
if (strings[0] && strings[1] && strings[2]) {
gchar *new_uid = NULL;
e_contact_set (card, E_CONTACT_NICKNAME, strings[0]);
e_contact_set (card, E_CONTACT_FULL_NAME, strings[1]);
addr = strings[2];
len = strlen (addr);
if (addr[0] == '(' && addr[len - 1] == ')') {
addr[0] = 0;
addr[len - 1] = 0;
addrs = g_strsplit (addr + 1, ",", 0);
list = NULL;
/* XXX So ... this api is just insane ... we set
* plain strings as the contact email if it
* is a normal contact, but need to do this
* XML crap for mailing lists. */
for (i = 0; addrs[i]; i++) {
EDestination *d;
EVCardAttribute *attr;
d = e_destination_new ();
e_destination_set_email (d, addrs[i]);
attr = e_vcard_attribute_new (NULL, EVC_EMAIL);
e_destination_export_to_vcard_attribute (d, attr);
list = g_list_append (list, attr);
g_object_unref (d);
}
e_contact_set_attributes (card, E_CONTACT_EMAIL, list);
g_list_foreach (list, (GFunc) e_vcard_attribute_free, NULL);
g_list_free (list);
g_strfreev (addrs);
e_contact_set (card, E_CONTACT_IS_LIST, GINT_TO_POINTER (TRUE));
} else {
e_contact_set (card, E_CONTACT_EMAIL_1, strings[2]);
}
/*name = e_contact_name_from_string(strings[1]);*/
if (strings[3] && strings[4])
e_contact_set (card, E_CONTACT_NOTE, strings[4]);
e_book_client_add_contact_sync (
book_client, card, &new_uid, NULL, &error);
if (error != NULL) {
g_warning (
"%s: Failed to add contact: %s",
G_STRFUNC, error->message);
g_error_free (error);
} else {
g_free (new_uid);
}
g_object_unref (card);
}
g_strfreev (strings);
}
