Merge lp:~renatofilho/address-book-service/create-source into lp:address-book-service

[Renato Araujo Oliveira Filho]

Implemented createSource functionality.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:99
http://jenkins.qa.ubuntu.com/job/address-book-service-ci/152/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/address-book-service-trusty-amd64-ci/59
    SUCCESS: http://jenkins.qa.ubuntu.com/job/address-book-service-trusty-armhf-ci/59
        deb: http://jenkins.qa.ubuntu.com/job/address-book-service-trusty-armhf-ci/59/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/address-book-service-trusty-i386-ci/60

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/address-book-service-ci/152/rebuild

review: Approve (continuous-integration)

[lp:~renatofilho/address-book-service/create-source]

100. By Renato Araujo Oliveira Filho on 2014-02-23

Merged parent branch.

101. By Renato Araujo Oliveira Filho on 2014-02-24

Merged parent branch.

102. By Renato Araujo Oliveira Filho on 2014-02-28

Merged mainline.

103. By Renato Araujo Oliveira Filho on 2014-03-18

Attempt to fix power pc build

104. By Renato Araujo Oliveira Filho on 2014-03-18

Attempt to fix powerpc tests.

105. By Renato Araujo Oliveira Filho on 2014-03-18

Attempt to fix powerpc tests.

106. By Renato Araujo Oliveira Filho on 2014-03-18

Moved DirtyContactsNotify class to a individual file and make it a QObject.

107. By Renato Araujo Oliveira Filho on 2014-03-18

Make sure that the temporary directory is created.

108. By Renato Araujo Oliveira Filho on 2014-03-18

Make the dummy backend start async in an attempt to fix powerPC tests.

109. By Renato Araujo Oliveira Filho on 2014-03-18

Added debug messages.

110. By Renato Araujo Oliveira Filho on 2014-03-18

Skip tests when running on PPC machines.

Unmerged revisions

=== modified file '3rd_party/folks/dummy/lib/dummy-full-persona.vala'
--- 3rd_party/folks/dummy/lib/dummy-full-persona.vala	2013-12-13 14:24:51 +0000
+++ 3rd_party/folks/dummy/lib/dummy-full-persona.vala	2014-02-18 00:13:04 +0000
@@ -72,6 +72,15 @@
     PostalAddressDetails,
     WebServiceDetails
 {
+  private const string[] _default_linkable_properties =
+    {
+      "im-addresses",
+      "email-addresses",
+      "local-ids",
+      "web-service-addresses"
+    };
+
+
   /**
    * Create a new ‘full’ persona.
    *
@@ -88,7 +97,8 @@
    * @since UNRELEASED
    */
   public FullPersona (PersonaStore store, string contact_id,
-      bool is_user = false, string[] linkable_properties = {})
+      bool is_user = false,
+      string[] linkable_properties = {})
     {
       base (store, contact_id, is_user, linkable_properties);
     }
@@ -104,6 +114,7 @@
       this._groups_ro = this._groups.read_only_view;
       this._roles_ro = this._roles.read_only_view;
       this._anti_links_ro = this._anti_links.read_only_view;
+      this.update_linkable_properties(FullPersona._default_linkable_properties);
     }
 
   private HashMultiMap<string, WebServiceFieldDetails> _web_service_addresses =

=== modified file '3rd_party/folks/dummy/lib/dummy-persona.vala'
--- 3rd_party/folks/dummy/lib/dummy-persona.vala	2013-12-13 14:24:51 +0000
+++ 3rd_party/folks/dummy/lib/dummy-persona.vala	2014-02-18 00:13:04 +0000
@@ -53,7 +53,6 @@
 public class FolksDummy.Persona : Folks.Persona
 {
   private string[] _linkable_properties = new string[0];
-
   /**
    * {@inheritDoc}
    *
@@ -96,8 +95,8 @@
    *
    * @since UNRELEASED
    */
-  public Persona (PersonaStore store, string contact_id, bool is_user = false,
-      string[] linkable_properties = {})
+  public Persona (PersonaStore store, string contact_id,
+      bool is_user = false, string[] linkable_properties = {})
     {
       var uid = Folks.Persona.build_uid (BACKEND_NAME, store.id, contact_id);
       var iid = store.id + ":" + contact_id;
@@ -233,6 +232,37 @@
         }
     }
 
+  public void update_linkable_properties (string[] linkable_properties)
+    {
+      var new_linkable_properties = new HashSet<string> ();
+      new_linkable_properties.add_all_array(linkable_properties);
+
+      /* Check for changes. */
+      var changed = false;
+      
+
+      if (this._linkable_properties.length != new_linkable_properties.size)
+        {
+          changed = true;
+        }
+      else
+        {
+          foreach (var p in this._linkable_properties)
+            {
+              if (new_linkable_properties.contains (p) == false)
+                {
+                  changed = true;
+                  break;
+                }
+            }
+        }
+      if (changed == true)
+        {
+          this._linkable_properties = new_linkable_properties.to_array ();
+          this.notify_property ("linkable-properties");
+        }
+    }
+
   /**
    * Delay between property changes and notifications.
    *

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-11-06 14:42:23 +0000
+++ CMakeLists.txt	2014-02-18 00:13:04 +0000
@@ -14,6 +14,7 @@
 pkg_check_modules(GLIB REQUIRED glib-2.0>=2.32)
 pkg_check_modules(GIO REQUIRED gio-2.0>=2.32)
 pkg_check_modules(FOLKS REQUIRED folks>=0.9.0)
+pkg_check_modules(FOLKS_EDS REQUIRED folks-eds)
 
 if(FOLKS_VERSION VERSION_LESS "0.9.5")
     set(FOLKS_VERSION_LESS_THAN_0_9_5 "1")

=== modified file 'debian/changelog'
--- debian/changelog	2014-02-13 16:49:03 +0000
+++ debian/changelog	2014-02-18 00:13:04 +0000
@@ -1,3 +1,19 @@
+address-book-service (0.1.1) UNRELEASED; urgency=medium
+
+  * Avoid the persona to get linked automatically during the contact create or
+    edit.
+  * Create test to remove contacts functionality.
+  * Updated dummy backend code.
+  * Created test for add contacts.
+  * Rewrite unit test to work in a server/client way.
+  * Moved static address-book-service-lib to a different directory.
+  * Fork dummy backend from folks tree as a temporary solution before its get
+    release on folks.
+  * Check if query was destroyed on client side before delete it on the server
+    side.
+
+ -- Renato Araujo Oliveira Filho <renato@ubuntu>  Fri, 24 Jan 2014 08:04:56 -0300
+
 address-book-service (0.1.0+14.04.20140213-0ubuntu1) trusty; urgency=low
 
   [ Renato Araujo Oliveira Filho ]

=== modified file 'debian/control'
--- debian/control	2013-10-30 00:19:00 +0000
+++ debian/control	2014-02-18 00:13:04 +0000
@@ -7,6 +7,7 @@
                debhelper (>= 9),
                gobject-introspection (>= 1.31.0-2~),
                libfolks-dev,
+               libfolks-eds-dev,
                libgee-0.8-dev (>= 0.8.4),
                qt5-default,
                qt5-qmake,

=== modified file 'lib/CMakeLists.txt'
--- lib/CMakeLists.txt	2013-10-30 19:07:49 +0000
+++ lib/CMakeLists.txt	2014-02-18 00:13:04 +0000
@@ -38,6 +38,7 @@
     ${GLIB_LIBRARIES}
     ${GIO_LIBRARIES}
     ${FOLKS_LIBRARIES}
+    ${FOLKS_EDS_LIBRARIES}
 )
 
 qt5_use_modules(${CONTACTS_SERVICE_LIB} Core Contacts DBus Versit)
@@ -48,4 +49,5 @@
     ${GLIB_INCLUDE_DIRS}
     ${GIO_INCLUDE_DIRS}
     ${FOLKS_INCLUDE_DIRS}
+    ${FOLKS_EDS_INCLUDE_DIRS}
 )

=== modified file 'lib/addressbook-adaptor.cpp'
--- lib/addressbook-adaptor.cpp	2013-11-04 18:34:43 +0000
+++ lib/addressbook-adaptor.cpp	2014-02-18 00:13:04 +0000
@@ -54,6 +54,16 @@
     return Source();
 }
 
+Source AddressBookAdaptor::createSource(const QString &sourceName, const QDBusMessage &message)
+{
+    message.setDelayedReply(true);
+    QMetaObject::invokeMethod(m_addressBook, "createSource",
+                              Qt::QueuedConnection,
+                              Q_ARG(const QString&, sourceName),
+                              Q_ARG(const QDBusMessage&, message));
+    return Source();
+}
+
 QString AddressBookAdaptor::createContact(const QString &contact, const QString &source, const QDBusMessage &message)
 {
     message.setDelayedReply(true);

=== modified file 'lib/addressbook-adaptor.h'
--- lib/addressbook-adaptor.h	2013-11-01 01:10:12 +0000
+++ lib/addressbook-adaptor.h	2014-02-18 00:13:04 +0000
@@ -62,6 +62,11 @@
 "      <arg direction=\"out\" type=\"(sb)\"/>\n"
 "      <annotation value=\"Source\" name=\"com.trolltech.QtDBus.QtTypeName.Out0\"/>\n"
 "    </method>\n"
+"    <method name=\"createSource\">\n"
+"      <arg direction=\"in\" type=\"s\"/>\n"
+"      <arg direction=\"out\" type=\"(sb)\"/>\n"
+"      <annotation value=\"Source\" name=\"com.trolltech.QtDBus.QtTypeName.Out0\"/>\n"
+"    </method>\n"
 "    <method name=\"sortFields\">\n"
 "      <arg direction=\"out\" type=\"as\"/>\n"
 "    </method>\n"
@@ -103,6 +108,7 @@
 public Q_SLOTS:
     SourceList availableSources(const QDBusMessage &message);
     Source source(const QDBusMessage &message);
+    Source createSource(const QString &sourceName, const QDBusMessage &message);
     QStringList sortFields();
     QDBusObjectPath query(const QString &clause, const QString &sort, const QStringList &sources);
     int removeContacts(const QStringList &contactIds, const QDBusMessage &message);

=== modified file 'lib/addressbook.cpp'
--- lib/addressbook.cpp	2013-11-05 19:26:25 +0000
+++ lib/addressbook.cpp	2014-02-18 00:13:04 +0000
@@ -31,6 +31,8 @@
 #include <signal.h>
 #include <sys/socket.h>
 
+#include <folks/folks-eds.h>
+
 //this timeout represents how long the server will wait for changes on the contact before notify the client
 #define NOTIFY_CONTACTS_TIMEOUT 500
 
@@ -38,6 +40,14 @@
 
 namespace
 {
+
+class CreateContactData
+{
+public:
+    QDBusMessage m_message;
+    galera::AddressBook *m_addressbook;
+};
+
 class UpdateContactsData
 {
 public:
@@ -58,6 +68,14 @@
     int m_sucessCount;
 };
 
+class CreateSourceData
+{
+public:
+    QString sourceName;
+    galera::AddressBook *m_addressbook;
+    QDBusMessage m_message;
+};
+
 }
 
 namespace galera
@@ -242,6 +260,37 @@
     return Source();
 }
 
+Source AddressBook::createSource(const QString &sourceId, const QDBusMessage &message)
+{
+    CreateSourceData *data = new CreateSourceData;
+    data->m_addressbook = this;
+    data->m_message = message;
+    data->sourceName = sourceId;
+    edsf_persona_store_create_address_book(sourceId.toUtf8().data(),
+                                           (GAsyncReadyCallback) AddressBook::createSourceDone,
+                                           data);
+    return Source();
+}
+
+void AddressBook::createSourceDone(GObject *source,
+                                   GAsyncResult *res,
+                                   void *data)
+{
+    CreateSourceData *cData = static_cast<CreateSourceData*>(data);
+    GError *error = 0;
+    Source src;
+    edsf_persona_store_create_address_book_finish(res, &error);
+    if (error) {
+        qWarning() << "Fail to create source" << error->message;
+        g_error_free(error);
+    } else {
+        src = Source(cData->sourceName, false);
+    }
+    QDBusMessage reply = cData->m_message.createReply(QVariant::fromValue<Source>(src));
+    QDBusConnection::sessionBus().send(reply);
+    delete cData;
+}
+
 void AddressBook::getSource(const QDBusMessage &message, bool onlyTheDefault)
 {
     FolksBackendStore *backendStore = folks_backend_store_dup();
@@ -338,13 +387,15 @@
             if (!qcontact.isEmpty()) {
                 GHashTable *details = QIndividual::parseDetails(qcontact);
                 //TOOD: lookup for source and use the correct store
-                QDBusMessage *cpy = new QDBusMessage(message);
+                CreateContactData *data = new CreateContactData;
+                data->m_message = message;
+                data->m_addressbook = this;
                 folks_individual_aggregator_add_persona_from_details(m_individualAggregator,
                                                                      NULL, //parent
                                                                      folks_individual_aggregator_get_primary_store(m_individualAggregator),
                                                                      details,
                                                                      (GAsyncReadyCallback) createContactDone,
-                                                                     (void*) cpy);
+                                                                     (void*) data);
                 g_hash_table_destroy(details);
                 return "";
             }
@@ -429,6 +480,28 @@
     }
 }
 
+void AddressBook::addAntiLinksDone(FolksAntiLinkable *antilinkable,
+                                   GAsyncResult *result,
+                                   void *data)
+{
+    CreateContactData *createData = static_cast<CreateContactData*>(data);
+    QDBusMessage reply;
+
+    GError *error = 0;
+    folks_anti_linkable_change_anti_links_finish(antilinkable, result, &error);
+    if (error) {
+        qWarning() << "Fail to anti link pesona" << folks_persona_get_display_id(FOLKS_PERSONA(antilinkable)) << error->message;
+        reply = createData->m_message.createErrorReply("Fail to anti link pesona:", error->message);
+        g_error_free(error);
+    } else {
+        FolksIndividual *individual = folks_persona_get_individual(FOLKS_PERSONA(antilinkable));
+        // return the result/contactId to the client
+        reply = createData->m_message.createReply(QString::fromUtf8(folks_individual_get_id(individual)));
+    }
+    QDBusConnection::sessionBus().send(reply);
+    delete createData;
+}
+
 QStringList AddressBook::sortFields()
 {
     return SortClause::supportedFields();
@@ -455,25 +528,26 @@
     m_updateCommandResult = contacts;
     m_updateCommandPendingContacts << VCardParser::vcardToContact(contacts);
 
-    updateContactsDone(0, QString());
-
+    updateContactsDone("", "");
     return QStringList();
 }
 
-void AddressBook::updateContactsDone(galera::QIndividual *individual, const QString &error)
+void AddressBook::updateContactsDone(const QString &contactId,
+                                     const QString &error)
 {
-    Q_UNUSED(individual);
     qDebug() << Q_FUNC_INFO;
-
     int currentContactIndex = m_updateCommandResult.size() - m_updateCommandPendingContacts.size() - 1;
 
     if (!error.isEmpty()) {
         // update the result with the error
         m_updateCommandResult[currentContactIndex] = error;
-    } else if (individual){
+    } else if (!contactId.isEmpty()){
         // update the result with the new contact info
-        m_updatedIds << individual->id();
-        QStringList newContacts = VCardParser::contactToVcard(QList<QContact>() << individual->contact());
+        m_updatedIds << contactId;
+        ContactEntry *entry = m_contacts->value(contactId);
+        Q_ASSERT(entry);
+        QContact contact = entry->individual()->contact();
+        QStringList newContacts = VCardParser::contactToVcard(QList<QContact>() << contact);
         if (newContacts.length() == 1) {
             m_updateCommandResult[currentContactIndex] = newContacts[0];
         } else {
@@ -485,12 +559,13 @@
         QContact newContact = m_updateCommandPendingContacts.takeFirst();
         ContactEntry *entry = m_contacts->value(newContact.detail<QContactGuid>().guid());
         if (entry) {
-            entry->individual()->update(newContact, this, SLOT(updateContactsDone(galera::QIndividual*,QString)));
+            entry->individual()->update(newContact, this,
+                                        SLOT(updateContactsDone(QString,QString)));
         } else {
-            updateContactsDone(0, "Contact not found!");
+            updateContactsDone("", "Contact not found!");
         }
     } else {
-        folks_persona_store_flush(folks_individual_aggregator_get_primary_store(m_individualAggregator), 0, 0);
+
         QDBusMessage reply = m_updateCommandReplyMessage.createReply(m_updateCommandResult);
         QDBusConnection::sessionBus().send(reply);
 
@@ -504,17 +579,13 @@
     }
 }
 
-
 QString AddressBook::removeContact(FolksIndividual *individual)
 {
-    if (m_contacts->contains(individual)) {
-        ContactEntry *ci = m_contacts->take(individual);
-        if (ci) {
-            QString id = QString::fromUtf8(folks_individual_get_id(individual));
-            qDebug() << "Remove contact" << id;
-            delete ci;
-            return id;
-        }
+    QString contactId = QString::fromUtf8(folks_individual_get_id(individual));
+    ContactEntry *ci = m_contacts->take(contactId);
+    if (ci) {
+        delete ci;
+        return contactId;
     }
     return QString();
 }
@@ -526,7 +597,6 @@
     if (entry) {
         entry->individual()->setIndividual(individual);
     } else {
-        Q_ASSERT(!m_contacts->contains(individual));
         QIndividual *i = new QIndividual(individual, m_individualAggregator);
         i->addListener(this, SLOT(individualChanged(QIndividual*)));
         m_contacts->insert(new ContactEntry(i));
@@ -540,51 +610,72 @@
                                        AddressBook *self)
 {
     qDebug() << Q_FUNC_INFO;
-    QStringList removedIds;
-    QStringList addedIds;
-
-    GeeIterator *iter;
-    GeeSet *removed = gee_multi_map_get_keys(changes);
-    GeeCollection *added = gee_multi_map_get_values(changes);
-
-    iter = gee_iterable_iterator(GEE_ITERABLE(added));
-    while(gee_iterator_next(iter)) {
-        FolksIndividual *individual = FOLKS_INDIVIDUAL(gee_iterator_get(iter));
-        if (individual) {
-            // add contact to the map
-            addedIds << self->addContact(individual);
-            g_object_unref(individual);
-        }
-    }
-    g_object_unref (iter);
-
-
-    iter = gee_iterable_iterator(GEE_ITERABLE(removed));
-    while(gee_iterator_next(iter)) {
-        FolksIndividual *individual = FOLKS_INDIVIDUAL(gee_iterator_get(iter));
-        if (individual) {
-            QString id = QString::fromUtf8(folks_individual_get_id(individual));
-            if (!addedIds.contains(id)) {
-                // delete from contact map
-                removedIds << self->removeContact(individual);
-            }
-            g_object_unref(individual);
-        }
-    }
-    g_object_unref (iter);
-
-    //TODO: check for linked and unliked contacts
+    Q_UNUSED(individualAggregator);
+
+    QSet<QString> removedIds;
+    QSet<QString> addedIds;
+    QSet<QString> updatedIds;
+
+    GeeSet *keys = gee_multi_map_get_keys(changes);
+    GeeIterator *iter = gee_iterable_iterator(GEE_ITERABLE(keys));
+
+    while(gee_iterator_next(iter)) {
+        FolksIndividual *individualKey = FOLKS_INDIVIDUAL(gee_iterator_get(iter));
+        GeeCollection *values = gee_multi_map_get(changes, individualKey);
+        GeeIterator *iterV;
+
+        iterV = gee_iterable_iterator(GEE_ITERABLE(values));
+        while(gee_iterator_next(iterV)) {
+            FolksIndividual *individualValue = FOLKS_INDIVIDUAL(gee_iterator_get(iterV));
+
+            // contact added
+            if (individualKey == 0) {
+                addedIds << self->addContact(individualValue);
+            } else if (individualValue != 0){
+                qDebug() << "Link changes";
+                QString idValue = QString::fromUtf8(folks_individual_get_id(individualValue));
+                if (self->m_contacts->value(idValue)) {
+                    updatedIds << self->addContact(individualValue);
+                } else {
+                    addedIds << self->addContact(individualValue);
+                }
+            }
+
+            if (individualValue) {
+                g_object_unref(individualValue);
+            }
+        }
+
+        g_object_unref(iterV);
+        g_object_unref(values);
+
+        if (individualKey) {
+            QString id = QString::fromUtf8(folks_individual_get_id(individualKey));
+            if (!addedIds.contains(id) &&
+                !updatedIds.contains(id)) {
+                removedIds << self->removeContact(individualKey);
+            }
+            g_object_unref(individualKey);
+        }
+    }
+
+    g_object_unref(keys);
+
     if (!removedIds.isEmpty() && self->m_ready) {
-        Q_EMIT self->m_adaptor->contactsRemoved(removedIds);
+        Q_EMIT self->m_adaptor->contactsRemoved(removedIds.toList());
     }
 
     if (!addedIds.isEmpty() && self->m_ready) {
-        Q_EMIT self->m_adaptor->contactsAdded(addedIds);
-    }
-
-    g_object_unref(added);
-    g_object_unref(removed);
+        Q_EMIT self->m_adaptor->contactsAdded(addedIds.toList());
+    }
+
+    if (!updatedIds.isEmpty() && self->m_ready) {
+        Q_EMIT self->m_adaptor->contactsUpdated(updatedIds.toList());
+    }
+
     qDebug() << "Added" << addedIds;
+    qDebug() << "Removed" << removedIds;
+    qDebug() << "Changed" << updatedIds;
 }
 
 void AddressBook::prepareFolksDone(GObject *source,
@@ -598,29 +689,41 @@
 
 void AddressBook::createContactDone(FolksIndividualAggregator *individualAggregator,
                                     GAsyncResult *res,
-                                    QDBusMessage *msg)
+                                    void *data)
 {
-    qDebug() << "Create Contact Done" << msg;
+    CreateContactData *createData = static_cast<CreateContactData*>(data);
+
     FolksPersona *persona;
     GError *error = NULL;
     QDBusMessage reply;
     persona = folks_individual_aggregator_add_persona_from_details_finish(individualAggregator, res, &error);
     if (error != NULL) {
         qWarning() << "Failed to create individual from contact:" << error->message;
-        reply = msg->createErrorReply("Failed to create individual from contact", error->message);
+        reply = createData->m_message.createErrorReply("Failed to create individual from contact", error->message);
         g_clear_error(&error);
     } else if (persona == NULL) {
         qWarning() << "Failed to create individual from contact: Persona already exists";
-        reply = msg->createErrorReply("Failed to create individual from contact", "Contact already exists");
+        reply = createData->m_message.createErrorReply("Failed to create individual from contact", "Contact already exists");
+    } else if (QIndividual::autoLinkEnabled()){
+        FolksIndividual *individual = folks_persona_get_individual(persona);
+        reply = createData->m_message.createReply(QString::fromUtf8(folks_individual_get_id(individual)));
     } else {
-        qDebug() << "Persona created:" << persona;
-        FolksIndividual *individual;
-        individual = folks_persona_get_individual(persona);
-        reply = msg->createReply(QString::fromUtf8(folks_individual_get_id(individual)));
+        // avoid the new persona get linked
+        GeeHashSet *antiLinks = gee_hash_set_new(G_TYPE_STRING,
+                                                 (GBoxedCopyFunc) g_strdup,
+                                                 g_free,
+                                                 NULL, NULL, NULL, NULL, NULL, NULL);
+        gee_collection_add(GEE_COLLECTION(antiLinks), "*");
+        folks_anti_linkable_change_anti_links(FOLKS_ANTI_LINKABLE(persona),
+                                              GEE_SET(antiLinks),
+                                              (GAsyncReadyCallback) addAntiLinksDone,
+                                              data);
+        g_object_unref(antiLinks);
+        return;
     }
     //TODO: use dbus connection
     QDBusConnection::sessionBus().send(reply);
-    delete msg;
+    delete createData;
 }
 
 void AddressBook::isQuiescentChanged(GObject *source, GParamSpec *param, AddressBook *self)

=== modified file 'lib/addressbook.h'
--- lib/addressbook.h	2013-11-01 13:15:51 +0000
+++ lib/addressbook.h	2014-02-18 00:13:04 +0000
@@ -69,10 +69,11 @@
     void shutdown();
     SourceList availableSources(const QDBusMessage &message);
     Source source(const QDBusMessage &message);
+    Source createSource(const QString &sourceId, const QDBusMessage &message);
     QString createContact(const QString &contact, const QString &source, const QDBusMessage &message);
     int removeContacts(const QStringList &contactIds, const QDBusMessage &message);
     QStringList updateContacts(const QStringList &contacts, const QDBusMessage &message);
-    void updateContactsDone(galera::QIndividual *individual, const QString &error);
+    void updateContactsDone(const QString &contactId, const QString &error);
 
 private Q_SLOTS:
     void viewClosed();
@@ -139,11 +140,16 @@
                                  AddressBook *self);
     static void createContactDone(FolksIndividualAggregator *individualAggregator,
                                   GAsyncResult *res,
-                                  QDBusMessage *msg);
+                                  void *data);
     static void removeContactDone(FolksIndividualAggregator *individualAggregator,
                                   GAsyncResult *result,
                                   void *data);
-
+    static void addAntiLinksDone(FolksAntiLinkable *antilinkable,
+                                  GAsyncResult *result,
+                                  void *data);
+    static void createSourceDone(GObject *source,
+                                 GAsyncResult *res,
+                                 void *data);
     friend class DirtyContactsNotify;
 };
 

=== modified file 'lib/contacts-map.cpp'
--- lib/contacts-map.cpp	2013-11-06 18:49:59 +0000
+++ lib/contacts-map.cpp	2014-02-18 00:13:04 +0000
@@ -33,7 +33,7 @@
 
 ContactEntry::~ContactEntry()
 {
-     delete m_individual;
+    delete m_individual;
 }
 
 QIndividual *ContactEntry::individual() const
@@ -52,11 +52,6 @@
     clear();
 }
 
-ContactEntry *ContactsMap::value(FolksIndividual *individual) const
-{
-    return m_individualsToEntry[individual];
-}
-
 ContactEntry *ContactsMap::value(const QString &id) const
 {
     return m_idToEntry[id];
@@ -64,32 +59,33 @@
 
 ContactEntry *ContactsMap::take(FolksIndividual *individual)
 {
-    if (m_individualsToEntry.remove(individual)) {
-        return m_idToEntry.take(folks_individual_get_id(individual));
-    }
-    return 0;
+    QString contactId = QString::fromUtf8(folks_individual_get_id(individual));
+    return take(contactId);
+}
+
+ContactEntry *ContactsMap::take(const QString &id)
+{
+    QMutexLocker locker(&m_mutex);
+    return m_idToEntry.take(id);
 }
 
 void ContactsMap::remove(const QString &id)
 {
-    ContactEntry *entry = m_idToEntry[id];
+    QMutexLocker locker(&m_mutex);
+    ContactEntry *entry = m_idToEntry.value(id,0);
     if (entry) {
-        m_individualsToEntry.remove(entry->individual()->individual());
         m_idToEntry.remove(id);
         delete entry;
     }
 }
 
-bool ContactsMap::contains(FolksIndividual *individual) const
-{
-    return m_individualsToEntry.contains(individual);
-}
-
 void ContactsMap::insert(ContactEntry *entry)
 {
+    QMutexLocker locker(&m_mutex);
     FolksIndividual *fIndividual = entry->individual()->individual();
-    m_idToEntry.insert(folks_individual_get_id(fIndividual), entry);
-    m_individualsToEntry.insert(fIndividual, entry);
+    if (fIndividual) {
+        m_idToEntry.insert(folks_individual_get_id(fIndividual), entry);
+    }
 }
 
 int ContactsMap::size() const
@@ -99,16 +95,25 @@
 
 void ContactsMap::clear()
 {
+    QMutexLocker locker(&m_mutex);
     QList<ContactEntry*> entries = m_idToEntry.values();
     m_idToEntry.clear();
-    m_individualsToEntry.clear();
-
     qDeleteAll(entries);
 }
 
+void ContactsMap::lock()
+{
+    m_mutex.lock();
+}
+
+void ContactsMap::unlock()
+{
+    m_mutex.unlock();
+}
+
 QList<ContactEntry*> ContactsMap::values() const
 {
-    return m_individualsToEntry.values();
+    return m_idToEntry.values();
 }
 
 ContactEntry *ContactsMap::valueFromVCard(const QString &vcard) const
@@ -125,4 +130,21 @@
     return 0;
 }
 
+bool ContactsMap::contains(FolksIndividual *individual) const
+{
+    QString contactId = QString::fromUtf8(folks_individual_get_id(individual));
+    return contains(contactId);
+}
+
+bool ContactsMap::contains(const QString &id) const
+{
+    return m_idToEntry.contains(id);
+}
+
+ContactEntry *ContactsMap::value(FolksIndividual *individual) const
+{
+    QString contactId = QString::fromUtf8(folks_individual_get_id(individual));
+    return m_idToEntry.value(contactId, 0);
+}
+
 } //namespace

=== modified file 'lib/contacts-map.h'
--- lib/contacts-map.h	2013-11-05 00:25:03 +0000
+++ lib/contacts-map.h	2014-02-18 00:13:04 +0000
@@ -22,6 +22,7 @@
 #include <QtCore/QString>
 #include <QtCore/QStringList>
 #include <QtCore/QHash>
+#include <QtCore/QMutex>
 
 #include <folks/folks.h>
 #include <glib.h>
@@ -57,20 +58,25 @@
     ContactEntry *valueFromVCard(const QString &vcard) const;
 
     bool contains(FolksIndividual *individual) const;
+    bool contains(const QString &id) const;
+
     ContactEntry *value(FolksIndividual *individual) const;
     ContactEntry *value(const QString &id) const;
+
     ContactEntry *take(FolksIndividual *individual);
+    ContactEntry *take(const QString &id);
+
     void remove(const QString &id);
     void insert(ContactEntry *entry);
     int size() const;
     void clear();
-
-
+    void lock();
+    void unlock();
     QList<ContactEntry*> values() const;
 
 private:
-    QHash<FolksIndividual *, ContactEntry*> m_individualsToEntry;
     QHash<QString, ContactEntry*> m_idToEntry;
+    QMutex m_mutex;
 };
 
 } //namespace

=== modified file 'lib/qindividual.cpp'
--- lib/qindividual.cpp	2013-11-05 00:25:03 +0000
+++ lib/qindividual.cpp	2014-02-18 00:13:04 +0000
@@ -118,15 +118,15 @@
 
 namespace galera
 {
+bool QIndividual::m_autoLink = false;
 
 QIndividual::QIndividual(FolksIndividual *individual, FolksIndividualAggregator *aggregator)
-    : m_individual(individual),
-      m_primaryPersona(0),
+    : m_individual(0),
       m_aggregator(aggregator),
-      m_contact(0)
+      m_contact(0),
+      m_currentUpdate(0)
 {
-    g_object_ref(m_individual);
-    updateContact();
+    setIndividual(individual);
 }
 
 void QIndividual::notifyUpdate()
@@ -139,20 +139,20 @@
 
 QIndividual::~QIndividual()
 {
-    if (m_contact) {
-        delete m_contact;
+    if (m_currentUpdate) {
+        m_currentUpdate->disconnect(m_updateConnection);
+        // this will leave the update object to destroy itself
+        // this is necessary because the individual can be destroyed during a update
+        // Eg. If the individual get linked
+        m_currentUpdate->deatach();
+        m_currentUpdate = 0;
     }
-    Q_ASSERT(m_individual);
-    g_object_unref(m_individual);
+    clear();
 }
 
 QString QIndividual::id() const
 {
-    if (m_individual) {
-        return QString::fromUtf8(folks_individual_get_id(m_individual));
-    } else {
-        return "";
-    }
+    return m_id;
 }
 
 QtContacts::QContactDetail QIndividual::getUid() const
@@ -167,25 +167,17 @@
 
 QList<QtContacts::QContactDetail> QIndividual::getClientPidMap() const
 {
-    QList<QtContacts::QContactDetail> details;
     int index = 1;
-    GeeSet *personas = folks_individual_get_personas(m_individual);
-    if (!personas) {
-        return details;
-    }
-    GeeIterator *iter = gee_iterable_iterator(GEE_ITERABLE(personas));
+    QList<QContactDetail> details;
 
-    while(gee_iterator_next(iter)) {
+    Q_FOREACH(const QString id, m_personas.keys()) {
         QContactExtendedDetail detail;
-        FolksPersona *persona = FOLKS_PERSONA(gee_iterator_get(iter));
+
         detail.setName("CLIENTPIDMAP");
         detail.setValue(QContactExtendedDetail::FieldData, index++);
-        detail.setValue(QContactExtendedDetail::FieldData + 1, QString::fromUtf8(folks_persona_get_uid(persona)));
+        detail.setValue(QContactExtendedDetail::FieldData + 1, id);
         details << detail;
-        g_object_unref(persona);
     }
-
-    g_object_unref(iter);
     return details;
 }
 
@@ -360,9 +352,13 @@
             g_free(uri);
             g_object_unref(cache);
         }
+        // Avoid to set a empty url
+        if (url.isEmpty()) {
+            return avatar;
+        }
         avatar.setImageUrl(QUrl(url));
+        avatar.setDetailUri(QString("%1.1").arg(index));
     }
-    avatar.setDetailUri(QString("%1.1").arg(index));
     return avatar;
 }
 
@@ -744,40 +740,64 @@
 
 QtContacts::QContact &QIndividual::contact()
 {
-    if (!m_contact) {
+    if (!m_contact && m_individual) {
+        updatePersonas();
         updateContact();
     }
     return *m_contact;
 }
 
+void QIndividual::updatePersonas()
+{
+    Q_FOREACH(FolksPersona *p, m_personas.values()) {
+        g_object_unref(p);
+    }
+
+    GeeSet *personas = folks_individual_get_personas(m_individual);
+    if (!personas) {
+        return;
+    }
+
+    GeeIterator *iter = gee_iterable_iterator(GEE_ITERABLE(personas));
+    while(gee_iterator_next(iter)) {
+        FolksPersona *persona = FOLKS_PERSONA(gee_iterator_get(iter));
+        g_signal_connect(G_OBJECT(persona), "notify::avatar",
+                         (GCallback) QIndividual::folksPersonaChanged,
+                         const_cast<QIndividual*>(this));
+
+        m_personas.insert(QString::fromUtf8(folks_persona_get_iid(persona)), persona);
+    }
+
+    g_object_unref(iter);
+}
+
 void QIndividual::updateContact()
 {
-    Q_ASSERT(m_individual);
+    // disconnect any previous handler
+    Q_FOREACH(FolksPersona *p, m_notifyConnections.keys()) {
+        Q_FOREACH(int handlerId, m_notifyConnections.value(p)) {
+            g_signal_handler_disconnect(p, handlerId);
+        }
+        m_notifyConnections.remove(p);
+    }
+
+    if (m_contact) {
+        delete m_contact;
+        m_contact = 0;
+    }
 
     m_contact = new QContact();
+    if (!m_individual) {
+        return;
+    }
+
     m_contact->appendDetail(getUid());
     Q_FOREACH(QContactDetail detail, getClientPidMap()) {
         m_contact->appendDetail(detail);
     }
 
     int personaIndex = 1;
-    GeeSet *personas = folks_individual_get_personas(m_individual);
-    Q_ASSERT(personas);
-    GeeIterator *iter = gee_iterable_iterator(GEE_ITERABLE(personas));
-
-    FolksPersona *persona;
-
-    // disconnect any previous handler
-    Q_FOREACH(gpointer persona, m_notifyConnections.keys()) {
-        Q_FOREACH(int handlerId, m_notifyConnections[persona]) {
-            g_signal_handler_disconnect(persona, handlerId);
-        }
-    }
-
-    m_notifyConnections.clear();
-
-    while(gee_iterator_next(iter)) {
-         persona = FOLKS_PERSONA(gee_iterator_get(iter));
+    Q_FOREACH(FolksPersona *persona, m_personas.values()) {
          Q_ASSERT(FOLKS_IS_PERSONA(persona));
 
         int wsize = 0;
@@ -790,25 +810,27 @@
             wPropList << wproperties[i];
         }
 
-        appendDetailsForPersona(m_contact,
-                                getPersonaName(persona, personaIndex),
-                                !wPropList.contains("structured-name"));
-        appendDetailsForPersona(m_contact,
-                                getPersonaFullName(persona, personaIndex),
-                                !wPropList.contains("full-name"));
-        appendDetailsForPersona(m_contact,
-                                getPersonaNickName(persona, personaIndex),
-                                !wPropList.contains("structured-name"));
-        appendDetailsForPersona(m_contact,
-                                getPersonaBirthday(persona, personaIndex),
-                                !wPropList.contains("birthday"));
-        appendDetailsForPersona(m_contact,
-                                getPersonaPhoto(persona, personaIndex),
-                                !wPropList.contains("avatar"));
-        appendDetailsForPersona(m_contact,
-                                getPersonaFavorite(persona, personaIndex),
-                                !wPropList.contains("is-favourite"));
-
+        // vcard only support one of these details by contact
+        if (personaIndex == 1) {
+            appendDetailsForPersona(m_contact,
+                                    getPersonaName(persona, personaIndex),
+                                    !wPropList.contains("structured-name"));
+            appendDetailsForPersona(m_contact,
+                                    getPersonaFullName(persona, personaIndex),
+                                    !wPropList.contains("full-name"));
+            appendDetailsForPersona(m_contact,
+                                    getPersonaNickName(persona, personaIndex),
+                                    !wPropList.contains("structured-name"));
+            appendDetailsForPersona(m_contact,
+                                    getPersonaBirthday(persona, personaIndex),
+                                    !wPropList.contains("birthday"));
+            appendDetailsForPersona(m_contact,
+                                    getPersonaPhoto(persona, personaIndex),
+                                    !wPropList.contains("avatar"));
+            appendDetailsForPersona(m_contact,
+                                    getPersonaFavorite(persona, personaIndex),
+                                    !wPropList.contains("is-favourite"));
+        }
 
         QList<QContactDetail> details;
         QContactDetail prefDetail;
@@ -855,33 +877,34 @@
                                 !wPropList.contains("urls"));
         personaIndex++;
 
+        QList<int> ids = m_notifyConnections.value(persona);
+
         // for now we are getting updated only about avatar changes
-        int handlerId = g_signal_connect(G_OBJECT(persona), "notify::avatar",
-                                         (GCallback) QIndividual::folksPersonaChanged,
-                                         const_cast<QIndividual*>(this));
-        QList<int> ids = m_notifyConnections[persona];
-        ids << handlerId;
+        ids << g_signal_connect(G_OBJECT(persona), "notify::avatar",
+                               (GCallback) QIndividual::folksPersonaChanged,
+                               const_cast<QIndividual*>(this));
         m_notifyConnections[persona] = ids;
-
-        g_object_unref(persona);
     }
-
-    g_object_unref(iter);
 }
 
 bool QIndividual::update(const QtContacts::QContact &newContact, QObject *object, const char *slot)
 {
     QContact &originalContact = contact();
     if (newContact != originalContact) {
-        UpdateContactRequest *request = new UpdateContactRequest(newContact, this, object, slot);
+        // only suppport one update by time
+        Q_ASSERT(m_currentUpdate == 0);
+        m_currentUpdate = new UpdateContactRequest(newContact, this, object, slot);
+        m_updateConnection = QObject::connect(m_currentUpdate,
+                                              &UpdateContactRequest::done,
+                                              [this] (const QString &errorMessage) {
 
-        QObject::connect(request, &UpdateContactRequest::done, [request, this] (const QString &errorMessage) {
             if (errorMessage.isEmpty()) {
                 this->updateContact();
             }
-            request->deleteLater();
+            m_currentUpdate->deleteLater();
+            m_currentUpdate = 0;
         });
-        request->start();
+        m_currentUpdate->start();
         return true;
     } else {
         qDebug() << "Contact is equal";
@@ -895,31 +918,40 @@
     return update(contact, object, slot);
 }
 
-
 FolksIndividual *QIndividual::individual() const
 {
     return m_individual;
 }
 
-FolksPersona *QIndividual::getPersona(int index) const
-{
-    int size = 0;
-    FolksPersona *persona = 0;
-    GeeSet *personas = folks_individual_get_personas(m_individual);
-    gpointer* values = gee_collection_to_array(GEE_COLLECTION(personas), &size);
-
-    if ((index > 0) && (index <= size)) {
-        persona = FOLKS_PERSONA(values[index - 1]);
-    }
-
-    g_free(values);
-    return persona;
-}
-
-int QIndividual::personaCount() const
-{
-    GeeSet *personas = folks_individual_get_personas(m_individual);
-    return gee_collection_get_size(GEE_COLLECTION(personas));
+QList<FolksPersona *> QIndividual::personas() const
+{
+    return m_personas.values();
+}
+
+void QIndividual::clearPersonas()
+{
+    Q_FOREACH(FolksPersona *p, m_personas.values()) {
+        Q_FOREACH(int handlerId, m_notifyConnections.value(p)) {
+            g_signal_handler_disconnect(p, handlerId);
+        }
+        m_notifyConnections.remove(p);
+        g_object_unref(p);
+    }
+    m_personas.clear();
+}
+
+void QIndividual::clear()
+{
+    clearPersonas();
+    if (m_individual) {
+        g_object_unref(m_individual);
+        m_individual = 0;
+    }
+
+    if (m_contact) {
+        delete m_contact;
+        m_contact = 0;
+    }
 }
 
 void QIndividual::addListener(QObject *object, const char *slot)
@@ -932,27 +964,45 @@
     }
 }
 
+bool QIndividual::isValid() const
+{
+    return (m_individual != 0);
+}
+
+void QIndividual::flush()
+{
+    // flush the folks persona store
+    folks_persona_store_flush(folks_individual_aggregator_get_primary_store(m_aggregator), 0, 0);
+
+    // cause the contact info to be reload
+    if (m_contact) {
+        delete m_contact;
+        m_contact = 0;
+    }
+}
+
 void QIndividual::setIndividual(FolksIndividual *individual)
 {
     if (m_individual != individual) {
-        if (m_individual) {
-            g_object_unref(m_individual);
+        clear();
+
+        if (individual) {
+            QString newId = QString::fromUtf8(folks_individual_get_id(individual));
+            if (!m_id.isEmpty()) {
+                // we can only update to individual with the same id
+                Q_ASSERT(newId == m_id);
+            } else {
+                m_id = newId;
+            }
         }
+
         m_individual = individual;
         if (m_individual) {
             g_object_ref(m_individual);
         }
-
-        // initialize qcontact
-        if (m_contact) {
-            delete m_contact;
-            m_contact = 0;
-        }
-        updateContact();
     }
 }
 
-
 GHashTable *QIndividual::parseAddressDetails(GHashTable *details,
                                              const QList<QtContacts::QContactDetail> &cDetails,
                                              const QtContacts::QContactDetail &prefDetail)
@@ -982,13 +1032,15 @@
                 g_value_take_object(value, collection);
             }
 
-            FolksPostalAddressFieldDetails *pafd = folks_postal_address_field_details_new(postalAddress, NULL);
-            DetailContextParser::parseContext(FOLKS_ABSTRACT_FIELD_DETAILS(pafd),
-                                              address,
-                                              detail == prefDetail);
-            gee_collection_add(collection, pafd);
+            if (!folks_postal_address_is_empty(postalAddress)) {
+                FolksPostalAddressFieldDetails *pafd = folks_postal_address_field_details_new(postalAddress, NULL);
+                DetailContextParser::parseContext(FOLKS_ABSTRACT_FIELD_DETAILS(pafd),
+                                                  address,
+                                                  detail == prefDetail);
+                gee_collection_add(collection, pafd);
+                g_object_unref(pafd);
+            }
 
-            g_object_unref(pafd);
             g_object_unref(postalAddress);
         }
         GeeUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_POSTAL_ADDRESSES, value);
@@ -1293,7 +1345,6 @@
     return details;
 }
 
-
 GHashTable *QIndividual::parseDetails(const QtContacts::QContact &contact)
 {
     GHashTable *details = g_hash_table_new_full(g_str_hash,
@@ -1309,7 +1360,6 @@
     parseFullNameDetails(details, contact.details(QContactDisplayLabel::Type));
     parseNicknameDetails(details, contact.details(QContactNickname::Type));
 
-
     parseAddressDetails(details,
                         contact.details(QContactAddress::Type),
                         contact.preferredDetail(VCardParser::PreferredActionNames[QContactAddress::Type]));
@@ -1335,29 +1385,23 @@
     return details;
 }
 
+void QIndividual::enableAutoLink(bool flag)
+{
+    m_autoLink = flag;
+}
+
+bool QIndividual::autoLinkEnabled()
+{
+    return m_autoLink;
+}
+
 FolksPersona* QIndividual::primaryPersona()
 {
-    Q_ASSERT(m_individual);
-
-    if (m_primaryPersona) {
-        return m_primaryPersona;
-    }
-
-    GeeSet *personas = folks_individual_get_personas(m_individual);
-    GeeIterator *iter = gee_iterable_iterator(GEE_ITERABLE(personas));
-    FolksPersonaStore *primaryStore = folks_individual_aggregator_get_primary_store(m_aggregator);
-
-    while(m_primaryPersona == NULL && gee_iterator_next(iter)) {
-        FolksPersona *persona = FOLKS_PERSONA(gee_iterator_get(iter));
-        if(folks_persona_get_store(persona) == primaryStore) {
-            m_primaryPersona = persona;
-            g_object_ref (persona);
-        }
-        g_object_unref(persona);
-    }
-    g_object_unref(iter);
-
-    return m_primaryPersona;
+    if (m_personas.size() > 0) {
+        return m_personas.begin().value();
+    } else {
+        return 0;
+    }
 }
 
 QtContacts::QContactDetail QIndividual::detailFromUri(QtContacts::QContactDetail::DetailType type, const QString &uri) const

=== modified file 'lib/qindividual.h'
--- lib/qindividual.h	2013-10-30 19:07:49 +0000
+++ lib/qindividual.h	2014-02-18 00:13:04 +0000
@@ -33,6 +33,8 @@
 {
 typedef GHashTable* (*ParseDetailsFunc)(GHashTable*, const QList<QtContacts::QContactDetail> &);
 
+class UpdateContactRequest;
+
 class QIndividual
 {
 public:
@@ -46,20 +48,28 @@
     bool update(const QtContacts::QContact &contact, QObject *object, const char *slot);
     void setIndividual(FolksIndividual *individual);
     FolksIndividual *individual() const;
-
-    FolksPersona *getPersona(int index) const;
-    int personaCount() const;
+    QList<FolksPersona*> personas() const;
     void addListener(QObject *object, const char *slot);
+    bool isValid() const;
+    void flush();
 
     static GHashTable *parseDetails(const QtContacts::QContact &contact);
+
+    // enable or disable auto-link
+    static void enableAutoLink(bool flag);
+    static bool autoLinkEnabled();
+
 private:
     FolksIndividual *m_individual;
-    FolksPersona *m_primaryPersona;
     FolksIndividualAggregator *m_aggregator;
     QtContacts::QContact *m_contact;
-    QMap<QString, QPair<QtContacts::QContactDetail, FolksAbstractFieldDetails*> > m_fieldsMap;
+    UpdateContactRequest *m_currentUpdate;
     QList<QPair<QObject*, QMetaMethod> > m_listeners;
-    QMap<gpointer, QList<int> > m_notifyConnections;
+    QMap<QString, FolksPersona*> m_personas;
+    QMap<FolksPersona*, QList<int> > m_notifyConnections;
+    QString m_id;
+    QMetaObject::Connection m_updateConnection;
+    static bool m_autoLink;
 
     QIndividual();
     QIndividual(const QIndividual &);
@@ -68,6 +78,9 @@
 
     QMultiHash<QString, QString> parseDetails(FolksAbstractFieldDetails *details) const;
     void updateContact();
+    void updatePersonas();
+    void clearPersonas();
+    void clear();
 
     FolksPersona *primaryPersona();
     QtContacts::QContactDetail detailFromUri(QtContacts::QContactDetail::DetailType type, const QString &uri) const;

=== modified file 'lib/update-contact-request.cpp'
--- lib/update-contact-request.cpp	2013-10-30 19:07:49 +0000
+++ lib/update-contact-request.cpp	2014-02-18 00:13:04 +0000
@@ -27,19 +27,16 @@
 
 using namespace QtContacts;
 
-namespace {
-
-
-
-}
-
 namespace galera {
 
 UpdateContactRequest::UpdateContactRequest(QtContacts::QContact newContact, QIndividual *parent, QObject *listener, const char *slot)
     : QObject(),
+      m_parent(parent),
+      m_object(listener),
+      m_currentPersona(0),
+      m_eventLoop(0),
       m_newContact(newContact),
-      m_parent(parent),
-      m_object(listener)
+      m_currentPersonaIndex(0)
 {
     int slotIndex = listener->metaObject()->indexOfSlot(++slot);
     if (slotIndex == -1) {
@@ -49,18 +46,67 @@
     }
 }
 
+UpdateContactRequest::~UpdateContactRequest()
+{
+    // check if there is a operation running
+    if (m_currentPersona != 0) {
+        wait();
+    }
+}
+
 void UpdateContactRequest::invokeSlot(const QString &errorMessage)
 {
-    if (m_slot.isValid()) {
-        m_slot.invoke(m_object, Q_ARG(galera::QIndividual*, m_parent), Q_ARG(QString, errorMessage));
-    }
+    if (m_slot.isValid() && m_parent) {
+        m_slot.invoke(m_object, Q_ARG(QString, m_parent->id()),
+                                Q_ARG(QString, errorMessage));
+    } else if (m_parent == 0) {
+        // the object was detached we need to destroy it
+        deleteLater();
+    }
+
+    if (m_eventLoop) {
+        m_eventLoop->quit();
+    }
+
     Q_EMIT done(errorMessage);
 }
 
 void UpdateContactRequest::start()
 {
     m_currentDetailType = QContactDetail::TypeAddress;
-    updatePersona(1);
+    m_personas = m_parent->personas();
+    m_originalContact = m_parent->contact();
+    m_currentPersonaIndex = 0;
+    updatePersona();
+}
+
+void UpdateContactRequest::wait()
+{
+    Q_ASSERT(m_eventLoop == 0);
+    QEventLoop eventLoop;
+    m_eventLoop = &eventLoop;
+    eventLoop.exec();
+    m_eventLoop = 0;
+}
+
+void UpdateContactRequest::deatach()
+{
+    m_parent = 0;
+}
+
+bool UpdateContactRequest::isEqual(const QtContacts::QContactDetail &detailA,
+                                         const QtContacts::QContactDetail &detailB)
+{
+    if (detailA.type() != detailB.type()) {
+        return false;
+    }
+
+    switch(detailA.type()) {
+    case QContactDetail::TypeFavorite:
+        return detailA.value(QContactFavorite::FieldFavorite) == detailB.value(QContactFavorite::FieldFavorite);
+    default:
+        return (detailA == detailB);
+    }
 }
 
 bool UpdateContactRequest::isEqual(QList<QtContacts::QContactDetail> listA,
@@ -71,7 +117,7 @@
     }
 
     for(int i=0; i < listA.size(); i++) {
-        if (listA[i] != listB[i]) {
+        if (!isEqual(listA[i], listB[i])) {
             return false;
         }
     }
@@ -116,7 +162,8 @@
     }
 
     Q_FOREACH(QContactDetail det, contact.details(type)) {
-        if ((includeEmptyPersona && det.detailUri().isEmpty()) || checkPersona(det, persona)) {
+        if ((includeEmptyPersona && det.detailUri().isEmpty()) ||
+            checkPersona(det, persona)) {
             if (!det.isEmpty()) {
                 personaDetails << det;
                 if (pref && det == globalPref) {
@@ -132,19 +179,19 @@
                                                                                    int persona,
                                                                                    QtContacts::QContactDetail *pref) const
 {
-    return detailsFromPersona(m_parent->contact(), type, persona, false, pref);
+    return detailsFromPersona(m_originalContact, type, persona, false, pref);
 }
 
 QList<QtContacts::QContactDetail> UpdateContactRequest::detailsFromPersona(QtContacts::QContactDetail::DetailType type,
                                                                            int persona,
                                                                            QtContacts::QContactDetail *pref) const
 {
-    return detailsFromPersona(m_newContact, type, persona, true, pref);
+    // only return new details for the first persona, this will avoid to create the details for all personas
+    return detailsFromPersona(m_newContact, type, persona, (persona==1), pref);
 }
 
 void UpdateContactRequest::updateAddress()
 {
-    FolksPersona *persona = m_parent->getPersona(m_currentPersonaIndex);
     QContactDetail originalPref;
     QList<QContactDetail> originalDetails = originalDetailsFromPersona(QContactDetail::TypeAddress,
                                                                        m_currentPersonaIndex,
@@ -154,8 +201,8 @@
                                                           m_currentPersonaIndex,
                                                           &prefDetail);
 
-    if (persona &&
-        FOLKS_IS_POSTAL_ADDRESS_DETAILS(persona) &&
+    if (m_currentPersona &&
+        FOLKS_IS_POSTAL_ADDRESS_DETAILS(m_currentPersona) &&
         !isEqual(originalDetails, originalPref, newDetails, prefDetail)) {
         qDebug() << "Adderess diff";
         GeeSet *newSet = SET_AFD_NEW();
@@ -188,7 +235,7 @@
             g_object_unref(pa);
         }
 
-        folks_postal_address_details_change_postal_addresses(FOLKS_POSTAL_ADDRESS_DETAILS(persona),
+        folks_postal_address_details_change_postal_addresses(FOLKS_POSTAL_ADDRESS_DETAILS(m_currentPersona),
                                                              newSet,
                                                              (GAsyncReadyCallback) updateDetailsDone,
                                                              this);
@@ -200,12 +247,15 @@
 
 void UpdateContactRequest::updateAvatar()
 {
-    FolksPersona *persona = m_parent->getPersona(m_currentPersonaIndex);
     QList<QContactDetail> originalDetails = originalDetailsFromPersona(QContactDetail::TypeAvatar, m_currentPersonaIndex, 0);
     QList<QContactDetail> newDetails = detailsFromPersona(QContactDetail::TypeAvatar, m_currentPersonaIndex, 0);
 
-    if (persona && FOLKS_IS_AVATAR_DETAILS(persona) && !isEqual(originalDetails, newDetails)) {
-        qDebug() << "avatar diff";
+    if (m_currentPersona &&
+        FOLKS_IS_AVATAR_DETAILS(m_currentPersona) &&
+        !isEqual(originalDetails, newDetails)) {
+        qDebug() << "avatar diff:"
+                 << "\n\t" << originalDetails.size() << (originalDetails.size() > 0 ? originalDetails[0] : QContactDetail()) << "\n"
+                 << "\n\t" << newDetails.size() << (newDetails.size() > 0 ? newDetails[0] : QContactDetail());
         //Only supports one avatar
         QUrl avatarUri;
         if (newDetails.count()) {
@@ -225,7 +275,7 @@
             }
         }
 
-        folks_avatar_details_change_avatar(FOLKS_AVATAR_DETAILS(persona),
+        folks_avatar_details_change_avatar(FOLKS_AVATAR_DETAILS(m_currentPersona),
                                            G_LOADABLE_ICON(avatarFileIcon),
                                            (GAsyncReadyCallback) updateDetailsDone,
                                            this);
@@ -239,11 +289,12 @@
 
 void UpdateContactRequest::updateBirthday()
 {
-    FolksPersona *persona = m_parent->getPersona(m_currentPersonaIndex);
     QList<QContactDetail> originalDetails = originalDetailsFromPersona(QContactDetail::TypeBirthday, m_currentPersonaIndex, 0);
     QList<QContactDetail> newDetails = detailsFromPersona(QContactDetail::TypeBirthday, m_currentPersonaIndex, 0);
 
-    if (persona && FOLKS_IS_BIRTHDAY_DETAILS(persona) && !isEqual(originalDetails, newDetails)) {
+    if (m_currentPersona &&
+        FOLKS_IS_BIRTHDAY_DETAILS(m_currentPersona) &&
+        !isEqual(originalDetails, newDetails)) {
         qDebug() << "birthday diff";
         //Only supports one birthday
         QDateTime dateTimeBirthday;
@@ -258,7 +309,7 @@
         if (dateTimeBirthday.isValid()) {
             dateTime = g_date_time_new_from_unix_utc(dateTimeBirthday.toMSecsSinceEpoch() / 1000);
         }
-        folks_birthday_details_change_birthday(FOLKS_BIRTHDAY_DETAILS(persona),
+        folks_birthday_details_change_birthday(FOLKS_BIRTHDAY_DETAILS(m_currentPersona),
                                                dateTime,
                                                (GAsyncReadyCallback) updateDetailsDone,
                                                this);
@@ -272,12 +323,15 @@
 
 void UpdateContactRequest::updateFullName()
 {
-    FolksPersona *persona = m_parent->getPersona(m_currentPersonaIndex);
     QList<QContactDetail> originalDetails = originalDetailsFromPersona(QContactDetail::TypeDisplayLabel, m_currentPersonaIndex, 0);
     QList<QContactDetail> newDetails = detailsFromPersona(QContactDetail::TypeDisplayLabel, m_currentPersonaIndex, 0);
 
-    if (persona && FOLKS_IS_NAME_DETAILS(persona) && !isEqual(originalDetails, newDetails)) {
-        qDebug() << "Full Name diff";
+    if (m_currentPersona &&
+        FOLKS_IS_NAME_DETAILS(m_currentPersona) &&
+        !isEqual(originalDetails, newDetails)) {
+        qDebug() << "Full Name diff:"
+                 << "\n\t" << originalDetails.size() << (originalDetails.size() > 0 ? originalDetails[0] : QContactDetail()) << "\n"
+                 << "\n\t" << newDetails.size() << (newDetails.size() > 0 ? newDetails[0] : QContactDetail());
         //Only supports one fullName
         QString fullName;
         if (newDetails.count()) {
@@ -286,7 +340,7 @@
         }
 
         QByteArray fullNameUtf8 = fullName.toUtf8();
-        folks_name_details_change_full_name(FOLKS_NAME_DETAILS(persona),
+        folks_name_details_change_full_name(FOLKS_NAME_DETAILS(m_currentPersona),
                                             fullNameUtf8.constData(),
                                             (GAsyncReadyCallback) updateDetailsDone,
                                             this);
@@ -297,7 +351,6 @@
 
 void UpdateContactRequest::updateEmail()
 {
-    FolksPersona *persona = m_parent->getPersona(m_currentPersonaIndex);
     QContactDetail originalPref;
     QList<QContactDetail> originalDetails = originalDetailsFromPersona(QContactDetail::TypeEmailAddress,
                                                                        m_currentPersonaIndex,
@@ -308,8 +361,8 @@
                                                           m_currentPersonaIndex,
                                                           &prefDetail);
 
-    if (persona &&
-        FOLKS_IS_EMAIL_DETAILS(persona) &&
+    if (m_currentPersona &&
+        FOLKS_IS_EMAIL_DETAILS(m_currentPersona) &&
         !isEqual(originalDetails, originalPref, newDetails, prefDetail)) {
         qDebug() << "email diff";
         GeeSet *newSet = SET_AFD_NEW();
@@ -325,7 +378,7 @@
             g_object_unref(field);
         }
 
-        folks_email_details_change_email_addresses(FOLKS_EMAIL_DETAILS(persona),
+        folks_email_details_change_email_addresses(FOLKS_EMAIL_DETAILS(m_currentPersona),
                                                    newSet,
                                                    (GAsyncReadyCallback) updateDetailsDone,
                                                    this);
@@ -337,11 +390,12 @@
 
 void UpdateContactRequest::updateName()
 {
-    FolksPersona *persona = m_parent->getPersona(m_currentPersonaIndex);
     QList<QContactDetail> originalDetails = originalDetailsFromPersona(QContactDetail::TypeName, m_currentPersonaIndex, 0);
     QList<QContactDetail> newDetails = detailsFromPersona(QContactDetail::TypeName, m_currentPersonaIndex, 0);
 
-    if (persona && FOLKS_IS_NAME_DETAILS(persona) && !isEqual(originalDetails, newDetails)) {
+    if (m_currentPersona &&
+        FOLKS_IS_NAME_DETAILS(m_currentPersona) &&
+        !isEqual(originalDetails, newDetails)) {
         qDebug() << "Name diff";
         //Only supports one fullName
         FolksStructuredName *sn = 0;
@@ -360,7 +414,7 @@
                                            suffix.constData());
         }
 
-        folks_name_details_change_structured_name(FOLKS_NAME_DETAILS(persona),
+        folks_name_details_change_structured_name(FOLKS_NAME_DETAILS(m_currentPersona),
                                                   sn,
                                                   (GAsyncReadyCallback) updateDetailsDone,
                                                   this);
@@ -374,11 +428,12 @@
 
 void UpdateContactRequest::updateNickname()
 {
-    FolksPersona *persona = m_parent->getPersona(m_currentPersonaIndex);
     QList<QContactDetail> originalDetails = originalDetailsFromPersona(QContactDetail::TypeNickname, m_currentPersonaIndex, 0);
     QList<QContactDetail> newDetails = detailsFromPersona(QContactDetail::TypeNickname, m_currentPersonaIndex, 0);
 
-    if (persona && FOLKS_IS_NAME_DETAILS(persona) && !isEqual(originalDetails, newDetails)) {
+    if (m_currentPersona &&
+        FOLKS_IS_NAME_DETAILS(m_currentPersona) &&
+        !isEqual(originalDetails, newDetails)) {
         qDebug() << "Nickname diff";
         //Only supports one fullName
         QString nicknameValue;
@@ -388,7 +443,7 @@
         }
 
         QByteArray nicknameValueUtf8 = nicknameValue.toUtf8();
-        folks_name_details_change_nickname(FOLKS_NAME_DETAILS(persona),
+        folks_name_details_change_nickname(FOLKS_NAME_DETAILS(m_currentPersona),
                                            nicknameValueUtf8.constData(),
                                            (GAsyncReadyCallback) updateDetailsDone,
                                            this);
@@ -399,14 +454,13 @@
 
 void UpdateContactRequest::updateNote()
 {
-    FolksPersona *persona = m_parent->getPersona(m_currentPersonaIndex);
     QContactDetail originalPref;
     QList<QContactDetail> originalDetails = originalDetailsFromPersona(QContactDetail::TypeNote, m_currentPersonaIndex, &originalPref);
     QContactDetail prefDetail;
     QList<QContactDetail> newDetails = detailsFromPersona(QContactDetail::TypeNote, m_currentPersonaIndex, &prefDetail);
 
-    if (persona &&
-        FOLKS_IS_EMAIL_DETAILS(persona) &&
+    if (m_currentPersona &&
+        FOLKS_IS_EMAIL_DETAILS(m_currentPersona) &&
         !isEqual(originalDetails, originalPref, newDetails, prefDetail)) {
         qDebug() << "notes diff";
         GeeSet *newSet = SET_AFD_NEW();
@@ -422,7 +476,7 @@
             g_object_unref(field);
         }
 
-        folks_note_details_change_notes(FOLKS_NOTE_DETAILS(persona),
+        folks_note_details_change_notes(FOLKS_NOTE_DETAILS(m_currentPersona),
                                         newSet,
                                         (GAsyncReadyCallback) updateDetailsDone,
                                         this);
@@ -434,7 +488,6 @@
 
 void UpdateContactRequest::updateOnlineAccount()
 {
-    FolksPersona *persona = m_parent->getPersona(m_currentPersonaIndex);
     QContactDetail originalPref;
     QList<QContactDetail> originalDetails = originalDetailsFromPersona(QContactDetail::TypeOnlineAccount,
                                                                        m_currentPersonaIndex,
@@ -444,8 +497,8 @@
                                                           m_currentPersonaIndex,
                                                           &prefDetail);
 
-    if (persona &&
-        FOLKS_IS_IM_DETAILS(persona) &&
+    if (m_currentPersona &&
+        FOLKS_IS_IM_DETAILS(m_currentPersona) &&
         !isEqual(originalDetails, originalPref, newDetails, prefDetail)) {
         qDebug() << "OnlineAccounts diff";
         GeeMultiMap *imMap = GEE_MULTI_MAP_AFD_NEW(FOLKS_TYPE_IM_FIELD_DETAILS);
@@ -467,7 +520,7 @@
             }
         }
 
-       folks_im_details_change_im_addresses(FOLKS_IM_DETAILS(persona),
+       folks_im_details_change_im_addresses(FOLKS_IM_DETAILS(m_currentPersona),
                                             imMap,
                                             (GAsyncReadyCallback) updateDetailsDone,
                                             this);
@@ -480,7 +533,6 @@
 
 void UpdateContactRequest::updateOrganization()
 {
-    FolksPersona *persona = m_parent->getPersona(m_currentPersonaIndex);
     QContactDetail originalPref;
     QList<QContactDetail> originalDetails = originalDetailsFromPersona(QContactDetail::TypeOrganization,
                                                                        m_currentPersonaIndex,
@@ -490,8 +542,8 @@
                                                           m_currentPersonaIndex,
                                                           &prefDetail);
 
-    if (persona &&
-        FOLKS_IS_ROLE_DETAILS(persona) &&
+    if (m_currentPersona &&
+        FOLKS_IS_ROLE_DETAILS(m_currentPersona) &&
         !isEqual(originalDetails, originalPref, newDetails, prefDetail)) {
         qDebug() << "Organization diff";
         GeeSet *newSet = SET_AFD_NEW();
@@ -515,7 +567,7 @@
             g_object_unref(roleValue);
         }
 
-        folks_role_details_change_roles(FOLKS_ROLE_DETAILS(persona),
+        folks_role_details_change_roles(FOLKS_ROLE_DETAILS(m_currentPersona),
                                         newSet,
                                         (GAsyncReadyCallback) updateDetailsDone,
                                         this);
@@ -528,7 +580,6 @@
 
 void UpdateContactRequest::updatePhone()
 {
-    FolksPersona *persona = m_parent->getPersona(m_currentPersonaIndex);
     QContactDetail originalPref;
     QList<QContactDetail> originalDetails = originalDetailsFromPersona(QContactDetail::TypePhoneNumber,
                                                                        m_currentPersonaIndex,
@@ -538,10 +589,13 @@
                                                           m_currentPersonaIndex,
                                                           &prefDetail);
 
-    if (persona &&
-        FOLKS_IS_PHONE_DETAILS(persona) &&
+    if (m_currentPersona &&
+        FOLKS_IS_PHONE_DETAILS(m_currentPersona) &&
         !isEqual(originalDetails, originalPref, newDetails, prefDetail)) {
-        qDebug() << "Phone diff";
+        qDebug() << "Phone diff:"
+                 << "\n\t" << originalDetails.size() << (originalDetails.size() > 0 ? originalDetails[0] : QContactDetail()) << "\n"
+                 << "\n\t" << newDetails.size() << (newDetails.size() > 0 ? newDetails[0] : QContactDetail());
+
         GeeSet *newSet = SET_AFD_NEW();
 
         Q_FOREACH(QContactDetail newDetail, newDetails) {
@@ -555,7 +609,7 @@
             g_object_unref(field);
         }
 
-        folks_phone_details_change_phone_numbers(FOLKS_PHONE_DETAILS(persona),
+        folks_phone_details_change_phone_numbers(FOLKS_PHONE_DETAILS(m_currentPersona),
                                                  newSet,
                                                  (GAsyncReadyCallback) updateDetailsDone,
                                                  this);
@@ -567,7 +621,6 @@
 
 void UpdateContactRequest::updateUrl()
 {
-    FolksPersona *persona = m_parent->getPersona(m_currentPersonaIndex);
     QContactDetail originalPref;
     QList<QContactDetail> originalDetails = originalDetailsFromPersona(QContactDetail::TypeUrl,
                                                                        m_currentPersonaIndex,
@@ -578,8 +631,8 @@
                                                           m_currentPersonaIndex,
                                                           &prefDetail);
 
-    if (persona &&
-        FOLKS_IS_PHONE_DETAILS(persona) &&
+    if (m_currentPersona &&
+        FOLKS_IS_URL_DETAILS(m_currentPersona) &&
         !isEqual(originalDetails, originalPref, newDetails, prefDetail)) {
         qDebug() << "Url diff";
         GeeSet *newSet = SET_AFD_NEW();
@@ -595,7 +648,7 @@
             g_object_unref(field);
         }
 
-        folks_url_details_change_urls(FOLKS_URL_DETAILS(persona),
+        folks_url_details_change_urls(FOLKS_URL_DETAILS(m_currentPersona),
                                       newSet,
                                       (GAsyncReadyCallback) updateDetailsDone,
                                       this);
@@ -607,19 +660,23 @@
 
 void UpdateContactRequest::updateFavorite()
 {
-    FolksPersona *persona = m_parent->getPersona(m_currentPersonaIndex);
     QList<QContactDetail> originalDetails = originalDetailsFromPersona(QContactDetail::TypeFavorite, m_currentPersonaIndex, 0);
     QList<QContactDetail> newDetails = detailsFromPersona(QContactDetail::TypeFavorite, m_currentPersonaIndex, 0);
 
-    if (persona && FOLKS_IS_FAVOURITE_DETAILS(persona) && !isEqual(originalDetails, newDetails)) {
-        qDebug() << "Favorite diff";
+    if (m_currentPersona &&
+        FOLKS_IS_FAVOURITE_DETAILS(m_currentPersona) &&
+        !isEqual(originalDetails, newDetails)) {
+        qDebug() << "Favorite diff:"
+                 << "\n\t" << originalDetails.size() << (originalDetails.size() > 0 ? originalDetails[0] : QContactDetail()) << "\n"
+                 << "\n\t" << newDetails.size() << (newDetails.size() > 0 ? newDetails[0] : QContactDetail());
+
         //Only supports one fullName
         bool isFavorite = false;
         if (newDetails.count()) {
             QContactFavorite favorite = static_cast<QContactFavorite>(newDetails[0]);
             isFavorite = favorite.isFavorite();
         }
-        folks_favourite_details_change_is_favourite(FOLKS_FAVOURITE_DETAILS(persona),
+        folks_favourite_details_change_is_favourite(FOLKS_FAVOURITE_DETAILS(m_currentPersona),
                                                     isFavorite,
                                                     (GAsyncReadyCallback) updateDetailsDone,
                                                     this);
@@ -628,14 +685,44 @@
     }
 }
 
-void UpdateContactRequest::updatePersona(int index)
+void UpdateContactRequest::updatePersona()
 {
-    if (index > m_parent->personaCount()) {
+    if (m_personas.size() <= m_currentPersonaIndex) {
+        m_currentPersona = 0;
+        if (m_parent) {
+            m_parent->flush();
+        }
         invokeSlot();
     } else {
-        m_currentPersonaIndex = index;
+        m_currentPersona = m_personas[m_currentPersonaIndex];
         m_currentDetailType = QContactDetail::TypeUndefined;
-        updateDetailsDone(0, 0, this);
+        m_currentPersonaIndex++;
+
+        if (QIndividual::autoLinkEnabled()) {
+            updateDetailsDone(0, 0, this);
+        } else {
+            // all personas edited by the user will have the auto link disabled
+            GeeSet *antiLinks;
+            antiLinks = GEE_SET(gee_hash_set_new(G_TYPE_STRING,
+                                                 (GBoxedCopyFunc) g_strdup,
+                                                 g_free,
+                                                 NULL, NULL, NULL, NULL, NULL, NULL));
+
+            GeeSet *oldLinks = folks_anti_linkable_get_anti_links(FOLKS_ANTI_LINKABLE(m_currentPersona));
+            if (oldLinks &&
+                gee_collection_contains(GEE_COLLECTION(antiLinks), "*")) {
+                updateDetailsDone(0, 0, this);
+                return;
+            } else if (oldLinks) {
+                gee_collection_add_all(GEE_COLLECTION(antiLinks), GEE_COLLECTION(oldLinks));
+            }
+            gee_collection_add(GEE_COLLECTION(antiLinks), "*");
+
+            folks_anti_linkable_change_anti_links(FOLKS_ANTI_LINKABLE(m_currentPersona),
+                                                  antiLinks,
+                                                  (GAsyncReadyCallback) folksAddAntiLinksDone,
+                                                  this);
+        }
     }
 }
 
@@ -780,8 +867,9 @@
         updateDetailsDone(0, 0, self);
         break;
     case QContactDetail::TypeVersion:
-        self->m_currentPersonaIndex += 1;
-        self->updatePersona(self->m_currentPersonaIndex);
+        g_object_unref(self->m_currentPersona);
+        self->m_currentPersona = 0;
+        self->updatePersona();
         break;
     default:
         qWarning() << "Update not implemented for" << self->m_currentDetailType;
@@ -790,4 +878,17 @@
     }
 }
 
+void UpdateContactRequest::folksAddAntiLinksDone(FolksAntiLinkable *antilinkable,
+                                                 GAsyncResult *result,
+                                                 UpdateContactRequest *self)
+{
+    GError *error = 0;
+    folks_anti_linkable_change_anti_links_finish(antilinkable, result, &error);
+    if (error) {
+        qWarning() << "Error during the anti link operation:" << error->message;
+        g_error_free(error);
+    }
+    updateDetailsDone(0, 0, self);
 }
+
+} // namespace

=== modified file 'lib/update-contact-request.h'
--- lib/update-contact-request.h	2013-10-30 19:07:49 +0000
+++ lib/update-contact-request.h	2014-02-18 00:13:04 +0000
@@ -23,6 +23,7 @@
 #include <QtCore/QString>
 #include <QtCore/QList>
 #include <QtCore/QMetaMethod>
+#include <QtCore/QEventLoop>
 
 #include <QtContacts/QContact>
 
@@ -38,20 +39,26 @@
 
 public:
     UpdateContactRequest(QtContacts::QContact newContact, QIndividual *parent, QObject *listener, const char *slot);
-
+    ~UpdateContactRequest();
     void start();
+    void wait();
+    void deatach();
 
 Q_SIGNALS:
     void done(const QString &errorMessage);
 
 private:
+    QIndividual *m_parent;
+    QObject *m_object;
+    FolksPersona *m_currentPersona;
+    QEventLoop *m_eventLoop;
+
+    QList<FolksPersona*> m_personas;
+    QtContacts::QContact m_originalContact;
     QtContacts::QContact m_newContact;
     int m_currentDetailType;
+    QMetaMethod m_slot;
     int m_currentPersonaIndex;
-    int m_maxPersona;
-    QIndividual *m_parent;
-    QObject *m_object;
-    QMetaMethod m_slot;
 
     void invokeSlot(const QString &errorMessage = QString());
 
@@ -61,6 +68,8 @@
                         const QtContacts::QContactDetail &prefB);
     static bool isEqual(QList<QtContacts::QContactDetail> listA,
                         QList<QtContacts::QContactDetail> listB);
+    static bool isEqual(const QtContacts::QContactDetail &detailA,
+                        const QtContacts::QContactDetail &detailB);
     static bool checkPersona(QtContacts::QContactDetail &det, int persona);
     static QList<QtContacts::QContactDetail> detailsFromPersona(const QtContacts::QContact &contact,
                                                                 QtContacts::QContactDetail::DetailType type,
@@ -74,7 +83,8 @@
                                                          int persona,
                                                          QtContacts::QContactDetail *pref) const;
 
-    void updatePersona(int index);
+
+    void updatePersona();
     void updateAddress();
     void updateAvatar();
     void updateBirthday();
@@ -94,7 +104,7 @@
                                    GAsyncResult *result);
 
     static void updateDetailsDone(GObject *detail, GAsyncResult *result, gpointer userdata);
-
+    static void folksAddAntiLinksDone(FolksAntiLinkable *antilinkable, GAsyncResult *result, UpdateContactRequest *self);
 };
 
 }

=== modified file 'lib/view.cpp'
--- lib/view.cpp	2013-10-30 19:07:49 +0000
+++ lib/view.cpp	2014-02-18 00:13:04 +0000
@@ -108,11 +108,13 @@
 protected:
     void run()
     {
+        m_allContacts->lock();
         Q_FOREACH(ContactEntry *entry, m_allContacts->values())
         {
             m_stoppedLock.lockForRead();
             if (m_stopped) {
                 m_stoppedLock.unlock();
+                m_allContacts->unlock();
                 return;
             }
             m_stoppedLock.unlock();
@@ -121,8 +123,8 @@
                 m_contacts << entry;
             }
         }
-
         chageSort(m_sortClause);
+        m_allContacts->unlock();
     }
 
 private:

=== modified file 'tests/unittest/CMakeLists.txt'
--- tests/unittest/CMakeLists.txt	2013-11-01 01:10:12 +0000
+++ tests/unittest/CMakeLists.txt	2014-02-18 00:13:04 +0000
@@ -70,6 +70,9 @@
 
     declare_test(addressbook-test True ${BASE_CLIENT_TEST_SRC})
     declare_test(service-life-cycle-test True ${BASE_CLIENT_TEST_SRC})
+    # Disable test until the new folks arrive on jenkins
+    #declare_test(contact-link-test True ${BASE_CLIENT_TEST_SRC})
+
 elseif()
     message(STATUS "DBus test runner not found. Some tests will be disabled")
 endif()

=== modified file 'tests/unittest/addressbook-test.cpp'
--- tests/unittest/addressbook-test.cpp	2013-12-13 19:06:57 +0000
+++ tests/unittest/addressbook-test.cpp	2014-02-18 00:13:04 +0000
@@ -111,7 +111,7 @@
         m_resultBasicVcard = QStringLiteral("BEGIN:VCARD\r\n"
                                        "VERSION:3.0\r\n"
                                        "UID:%1\r\n"
-                                       "CLIENTPIDMAP:1;dummy:dummy-store:0\r\n"
+                                       "CLIENTPIDMAP:1;dummy:dummy-store:%2\r\n"
                                        "N;PID=1.1:Tal;Fulano_;de;;\r\n"
                                        "FN;PID=1.1:Fulano_ Tal\r\n"
                                        "X-QTPROJECT-FAVORITE;PID=1.1:false;0\r\n"
@@ -213,7 +213,7 @@
 
         // user returned id to fill the new vcard
         QString newContactId = reply.value();
-        QString newVcard = m_resultBasicVcard.arg(newContactId);
+        QString newVcard = m_resultBasicVcard.arg(newContactId).arg(0);
 
         // try create a contact with the same id
         QDBusReply<QString> reply2 = m_serverIface->call("createContact", newVcard, "dummy-store");
@@ -267,6 +267,46 @@
         QDBusReply<QStringList> replyList = m_dummyIface->call("listContacts");
         QCOMPARE(replyList.value().count(), 0);
     }
+
+    void testUpdateContact()
+    {
+        // create a basic contact
+        QDBusReply<QString> replyAdd = m_serverIface->call("createContact", m_basicVcard, "dummy-store");
+        QString newContactId = replyAdd.value();
+
+        // update the contact phone number
+        QString vcard = m_resultBasicVcard.arg(newContactId).arg(3);
+        vcard = vcard.replace("8888888", "0000000");
+        QList<QtContacts::QContact> contacts = galera::VCardParser::vcardToContact(QStringList() << vcard);
+        QtContacts::QContact contactUpdated = contacts[0];
+
+        // spy 'contactsUpdated' signal
+        QSignalSpy updateContactSpy(m_serverIface, SIGNAL(contactsUpdated(const QStringList &)));
+        QDBusReply<QStringList> replyUpdate = m_serverIface->call("updateContacts", QStringList() << vcard);
+        QStringList result = replyUpdate.value();
+        QCOMPARE(result.size(), 1);
+
+        // check if contact returned by update function contains the new data
+        contacts = galera::VCardParser::vcardToContact(result);
+        QtContacts::QContact contactUpdatedResult = contacts[0];
+        compareContact(contactUpdatedResult, contactUpdated);
+
+        // check if the 'contactsUpdated' signal was fired with the correct args
+        QTRY_COMPARE(updateContactSpy.count(), 1);
+        QList<QVariant> args = updateContactSpy.takeFirst();
+        QCOMPARE(args.count(), 1);
+        QStringList ids = args[0].toStringList();
+        QCOMPARE(ids[0], newContactId);
+
+        // check if the contact was updated into the backend
+        QDBusReply<QStringList> replyList = m_dummyIface->call("listContacts");
+        result = replyList.value();
+        QCOMPARE(result.count(), 1);
+
+        contacts = galera::VCardParser::vcardToContact(result);
+        contactUpdatedResult = contacts[0];
+        compareContact(contactUpdatedResult, contactUpdated);
+    }
 };
 
 QTEST_MAIN(AddressBookTest)

=== added file 'tests/unittest/contact-link-test.cpp'
--- tests/unittest/contact-link-test.cpp	1970-01-01 00:00:00 +0000
+++ tests/unittest/contact-link-test.cpp	2014-02-18 00:13:04 +0000
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of contact-service-app.
+ *
+ * contact-service-app is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * contact-service-app is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "base-client-test.h"
+#include "lib/source.h"
+#include "lib/qindividual.h"
+#include "common/dbus-service-defs.h"
+#include "common/vcard-parser.h"
+
+#include <QObject>
+#include <QtDBus>
+#include <QtTest>
+#include <QDebug>
+#include <QtVersit>
+
+class ContactLinkTest : public BaseClientTest
+{
+    Q_OBJECT
+private:
+    QString m_vcard;
+
+private Q_SLOTS:
+    void initTestCase()
+    {
+        BaseClientTest::initTestCase();
+        m_vcard = QStringLiteral("BEGIN:VCARD\n"
+                                 "VERSION:3.0\n"
+                                 "N:tal;fulano_;de;;\n"
+                                 "EMAIL:[e-mail]\n"
+                                 "TEL;PID=1.1;TYPE=ISDN:33331410\n"
+                                 "END:VCARD");
+    }
+
+    void testCreateContactWithSameEmail()
+    {
+        // call create contact
+        QDBusReply<QString> reply = m_serverIface->call("createContact", m_vcard, "dummy-store");
+
+        // check if the returned id is valid
+        QString contactAId = reply.value();
+        QVERIFY(!contactAId.isEmpty());
+
+        QString vcardB = m_vcard.replace("fulano", "contact");
+        reply = m_serverIface->call("createContact", vcardB, "dummy-store");
+
+        // check if the returned id is valid
+        QString contactBId = reply.value();
+        QVERIFY(!contactBId.isEmpty());
+
+        QVERIFY(contactAId != contactBId);
+    }
+
+    void testAppendOtherContactEmail()
+    {
+        // call create contact
+        QDBusReply<QString> reply = m_serverIface->call("createContact", m_vcard, "dummy-store");
+
+        // check if the returned id is valid
+        QString contactAId = reply.value();
+        QVERIFY(!contactAId.isEmpty());
+
+        // add a contact with diff email
+        QString vcardB = m_vcard.replace("fulano", "contact").replace("email","email2");
+        reply = m_serverIface->call("createContact", vcardB, "dummy-store");
+
+        // check if the returned id is valid
+        QString contactBId = reply.value();
+        QVERIFY(!contactBId.isEmpty());
+
+        // udate contactB with same email as contactA
+        vcardB = m_vcard.replace("fulano", "contact");
+        reply = m_serverIface->call("createContact", vcardB, "dummy-store");
+
+        // check if the returned id is valid
+        contactBId = reply.value();
+        QVERIFY(!contactBId.isEmpty());
+
+        // check if id still different
+        QVERIFY(contactAId != contactBId);
+    }
+};
+
+QTEST_MAIN(ContactLinkTest)
+
+#include "contact-link-test.moc"

=== modified file 'tests/unittest/dummy-backend.cpp'
--- tests/unittest/dummy-backend.cpp	2013-12-13 19:57:13 +0000
+++ tests/unittest/dummy-backend.cpp	2014-02-18 00:13:04 +0000
@@ -192,6 +192,24 @@
     return QString();
 }
 
+void DummyBackendProxy::contactUpdated(const QString &contactId,
+                                       const QString &errorMsg)
+{
+    m_contactUpdated = true;
+}
+
+QString DummyBackendProxy::updateContact(const QString &contactId,
+                                         const QtContacts::QContact &qcontact)
+{
+    galera::QIndividual *i = m_contacts.value(contactId);
+    Q_ASSERT(i);
+    ScopedEventLoop loop(&m_eventLoop);
+    m_contactUpdated = false;
+    i->update(qcontact, this, SLOT(contactUpdated(QString,QString)));
+    loop.exec();
+    return i->id();
+}
+
 void DummyBackendProxy::configurePrimaryStore()
 {
     static const char* writableProperties[] = {
@@ -205,6 +223,7 @@
                                                           "Dummy personas",
                                                           const_cast<char**>(writableProperties), 4);
     folks_dummy_persona_store_set_persona_type(m_primaryPersonaStore, FOLKS_DUMMY_TYPE_FULL_PERSONA);
+    folks_dummy_persona_store_update_trust_level(m_primaryPersonaStore, FOLKS_PERSONA_STORE_TRUST_FULL);
 
     GeeHashSet *personaStores = gee_hash_set_new(FOLKS_TYPE_PERSONA_STORE,
                                                  (GBoxedCopyFunc) g_object_ref, g_object_unref,
@@ -349,9 +368,12 @@
                                              GeeMultiMap *changes,
                                              DummyBackendProxy *self)
 {
+    Q_UNUSED(individualAggregator);
+
     GeeIterator *iter;
     GeeSet *removed = gee_multi_map_get_keys(changes);
     GeeCollection *added = gee_multi_map_get_values(changes);
+    QStringList addedIds;
 
     iter = gee_iterable_iterator(GEE_ITERABLE(added));
     while(gee_iterator_next(iter)) {
@@ -359,6 +381,7 @@
         if (individual) {
             galera::QIndividual *idv = new galera::QIndividual(individual, self->m_aggregator);
             self->m_contacts.insert(idv->id(), idv);
+            addedIds << idv->id();
             g_object_unref(individual);
         }
     }
@@ -369,7 +392,7 @@
         FolksIndividual *individual = FOLKS_INDIVIDUAL(gee_iterator_get(iter));
         if (individual) {
             QString id = QString::fromUtf8(folks_individual_get_id(individual));
-            if (self->m_contacts.contains(id)) {
+            if (!addedIds.contains(id) && self->m_contacts.contains(id)) {
                 delete self->m_contacts.take(id);
             }
             g_object_unref(individual);
@@ -426,3 +449,15 @@
     QList<QtContacts::QContact> contacts = galera::VCardParser::vcardToContact(QStringList() << vcard);
     return m_proxy->createContact(contacts[0]);
 }
+
+QString DummyBackendAdaptor::updateContact(const QString &contactId, const QString &vcard)
+{
+    QList<QtContacts::QContact> contacts = galera::VCardParser::vcardToContact(QStringList() << vcard);
+    return m_proxy->updateContact(contactId, contacts[0]);
+}
+
+void DummyBackendAdaptor::enableAutoLink(bool flag)
+{
+    galera::QIndividual::enableAutoLink(flag);
+}
+

=== modified file 'tests/unittest/dummy-backend.h'
--- tests/unittest/dummy-backend.h	2013-11-11 14:21:24 +0000
+++ tests/unittest/dummy-backend.h	2014-02-18 00:13:04 +0000
@@ -46,6 +46,7 @@
     bool isReady() const;
 
     QString createContact(const QtContacts::QContact &qcontact);
+    QString updateContact(const QString &contactId, const QtContacts::QContact &qcontact);
     QList<QtContacts::QContact> contacts() const;
     QList<galera::QIndividual*> individuals() const;
 
@@ -55,6 +56,7 @@
     void shutdown();
     QStringList listContacts() const;
     void reset();
+    void contactUpdated(const QString &contactId, const QString &errorMsg);
 
 Q_SIGNALS:
     void ready();
@@ -71,6 +73,7 @@
     bool m_isReady;
     int m_individualsChangedDetailedId;
     QHash<QString, galera::QIndividual*> m_contacts;
+    bool m_contactUpdated;
 
     bool registerObject();
     void initFolks();
@@ -108,10 +111,18 @@
 "      <arg direction=\"out\" type=\"b\"/>\n"
 "    </method>\n"
 "    <method name=\"quit\"/>\n"
+"    <method name=\"enableAutoLink\">\n"
+"      <arg direction=\"in\" type=\"b\"/>\n"
+"    </method>\n"
 "    <method name=\"createContact\">\n"
 "      <arg direction=\"in\" type=\"s\"/>\n"
 "      <arg direction=\"out\" type=\"s\"/>\n"
 "    </method>\n"
+"    <method name=\"updateContact\">\n"
+"      <arg direction=\"in\" type=\"s\"/>\n"
+"      <arg direction=\"in\" type=\"s\"/>\n"
+"      <arg direction=\"out\" type=\"s\"/>\n"
+"    </method>\n"
 "    <method name=\"listContacts\">\n"
 "      <arg direction=\"out\" type=\"as\"/>\n"
 "    </method>\n"
@@ -130,6 +141,8 @@
     void reset();
     QStringList listContacts();
     QString createContact(const QString &vcard);
+    QString updateContact(const QString &contactId, const QString &vcard);
+    void enableAutoLink(bool flag);
 
 Q_SIGNALS:
     void ready();