/*

* Copyright (C) 2015 Jolla Mobile

* Contact: Chris Adams <chris.adams@jollamobile.com>

*

* You may use this file under the terms of the BSD license as follows:

*

* "Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are

* met:

* * Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* * Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in

* the documentation and/or other materials provided with the

* distribution.

* * Neither the name of Nemo Mobile nor the names of its contributors

* may be used to endorse or promote products derived from this

* software without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."

*/

#include "seasidecontactbuilder.h"

#include "seasidecache.h"

#include "seasidepropertyhandler.h"

#include <QContactDetailFilter>

#include <QContactFetchHint>

#include <QContactManager>

#include <QContactSortOrder>

#include <QContactSyncTarget>

#include <QContactAddress>

#include <QContactAnniversary>

#include <QContactAvatar>

#include <QContactBirthday>

#include <QContactEmailAddress>

#include <QContactFamily>

#include <QContactGeoLocation>

#include <QContactGuid>

#include <QContactHobby>

#include <QContactName>

#include <QContactNickname>

#include <QContactNote>

#include <QContactOnlineAccount>

#include <QContactOrganization>

#include <QContactPhoneNumber>

#include <QContactRingtone>

#include <QContactTag>

#include <QContactUrl>

#include <QContactIdFilter>

#include <QContactExtendedDetail>

#include <QVersitContactExporter>

#include <QVersitContactImporter>

#include <QVersitReader>

#include <QVersitWriter>

#include <QHash>

#include <QString>

#include <QList>

namespace {

QContactFetchHint basicFetchHint()

{

QContactFetchHint fetchHint;

fetchHint.setOptimizationHints(QContactFetchHint::NoRelationships |

QContactFetchHint::NoActionPreferences |

QContactFetchHint::NoBinaryBlobs);

return fetchHint;

}

QContactFilter localContactFilter()

{

// Contacts that are local to the device have sync target 'local' or 'was_local' or 'bluetooth'

QContactDetailFilter filterLocal, filterWasLocal, filterBluetooth;

filterLocal.setDetailType(QContactSyncTarget::Type, QContactSyncTarget::FieldSyncTarget);

filterWasLocal.setDetailType(QContactSyncTarget::Type, QContactSyncTarget::FieldSyncTarget);

filterBluetooth.setDetailType(QContactSyncTarget::Type, QContactSyncTarget::FieldSyncTarget);

filterLocal.setValue(QString::fromLatin1("local"));

filterWasLocal.setValue(QString::fromLatin1("was_local"));

filterBluetooth.setValue(QString::fromLatin1("bluetooth"));

return filterLocal | filterWasLocal | filterBluetooth;

}

bool allCharactersMatchScript(const QString &s, QChar::Script script)

{

for (QString::const_iterator it = s.constBegin(), end = s.constEnd(); it != end; ++it) {

if ((*it).script() != script) {

return false;

}

}

return true;

}

bool applyNameFixes(QContactName *nameDetail)

{

// Chinese names shouldn't have a middle name, so if it is present in a Han-script-only

// name, it is probably wrong and it should be prepended to the first name instead.

QString middleName = nameDetail->middleName();

if (middleName.isEmpty()) {

return false;

}

QString firstName = nameDetail->firstName();

QString lastName = nameDetail->lastName();

if (!allCharactersMatchScript(middleName, QChar::Script_Han)

|| (!firstName.isEmpty() && !allCharactersMatchScript(firstName, QChar::Script_Han))

|| (!lastName.isEmpty() && !allCharactersMatchScript(lastName, QChar::Script_Han))) {

return false;

}

nameDetail->setFirstName(middleName + firstName);

nameDetail->setMiddleName(QString());

return true;

}

bool nameIsEmpty(const QContactName &name)

{

if (name.isEmpty())

return true;

return (name.prefix().isEmpty() &&

name.firstName().isEmpty() &&

name.middleName().isEmpty() &&

name.lastName().isEmpty() &&

name.suffix().isEmpty());

}

QString contactNameString(const QContact &contact)

{

QStringList details;

QContactName name(contact.detail<QContactName>());

if (nameIsEmpty(name))

return QString();

details.append(name.prefix());

details.append(name.firstName());

details.append(name.middleName());

details.append(name.lastName());

details.append(name.suffix());

return details.join(QChar::fromLatin1('|'));

}

void setNickname(QContact &contact, const QString &text)

{

foreach (const QContactNickname &nick, contact.details<QContactNickname>()) {

if (nick.nickname() == text) {

return;

}

}

QContactNickname nick;

nick.setNickname(text);

contact.saveDetail(&nick);

}

template<typename T, typename F>

QVariant detailValue(const T &detail, F field)

{

return detail.value(field);

}

typedef QMap<int, QVariant> DetailMap;

DetailMap detailValues(const QContactDetail &detail)

{

DetailMap rv(detail.values());

return rv;

}

static bool variantEqual(const QVariant &lhs, const QVariant &rhs)

{

// Work around incorrect result from QVariant::operator== when variants contain QList<int>

static const int QListIntType = QMetaType::type("QList<int>");

const int lhsType = lhs.userType();

if (lhsType != rhs.userType()) {

return false;

}

if (lhsType == QListIntType) {

return (lhs.value<QList<int> >() == rhs.value<QList<int> >());

}

return (lhs == rhs);

}

static bool detailValuesSuperset(const QContactDetail &lhs, const QContactDetail &rhs)

{

// True if all values in rhs are present in lhs

const DetailMap lhsValues(detailValues(lhs));

const DetailMap rhsValues(detailValues(rhs));

if (lhsValues.count() < rhsValues.count()) {

return false;

}

foreach (const DetailMap::key_type &key, rhsValues.keys()) {

if (!variantEqual(lhsValues[key], rhsValues[key])) {

return false;

}

}

return true;

}

static void fixupDetail(QContactDetail &)

{

}

// Fixup QContactUrl because importer produces incorrectly typed URL field

static void fixupDetail(QContactUrl &url)

{

QVariant urlField = url.value(QContactUrl::FieldUrl);

if (!urlField.isNull()) {

QString urlString = urlField.toString();

if (!urlString.isEmpty()) {

url.setValue(QContactUrl::FieldUrl, QUrl(urlString));

} else {

url.setValue(QContactUrl::FieldUrl, QVariant());

}

}

}

// Fixup QContactOrganization because importer produces invalid department

static void fixupDetail(QContactOrganization &org)

{

QVariant deptField = org.value(QContactOrganization::FieldDepartment);

if (!deptField.isNull()) {

QStringList deptList = deptField.toStringList();

// Remove any empty elements from the list

QStringList::iterator it = deptList.begin();

while (it != deptList.end()) {

if ((*it).isEmpty()) {

it = deptList.erase(it);

} else {

++it;

}

}

if (!deptList.isEmpty()) {

org.setValue(QContactOrganization::FieldDepartment, deptList);

} else {

org.setValue(QContactOrganization::FieldDepartment, QVariant());

}

}

}

template<typename T>

bool mergeContactDetails(QContact *mergeInto, const QContact &mergeFrom, bool singular = false)

{

bool rv = false;

QList<T> existingDetails(mergeInto->details<T>());

if (singular && !existingDetails.isEmpty())

return rv;

foreach (T detail, mergeFrom.details<T>()) {

// Make any corrections to the input

fixupDetail(detail);

// See if the contact already has a detail which is a superset of this one

bool found = false;

foreach (const T &existing, existingDetails) {

if (detailValuesSuperset(existing, detail)) {

found = true;

break;

}

}

if (!found) {

mergeInto->saveDetail(&detail);

rv = true;

}

}

return rv;

}

bool mergeContacts(QContact *mergeInto, const QContact &mergeFrom)

{

bool rv = false;

// Update the existing contact with any details in the new import

rv |= mergeContactDetails<QContactAddress>(mergeInto, mergeFrom);

rv |= mergeContactDetails<QContactAnniversary>(mergeInto, mergeFrom);

rv |= mergeContactDetails<QContactAvatar>(mergeInto, mergeFrom);

rv |= mergeContactDetails<QContactBirthday>(mergeInto, mergeFrom, true);

rv |= mergeContactDetails<QContactEmailAddress>(mergeInto, mergeFrom);

rv |= mergeContactDetails<QContactFamily>(mergeInto, mergeFrom);

rv |= mergeContactDetails<QContactGeoLocation>(mergeInto, mergeFrom);

rv |= mergeContactDetails<QContactGuid>(mergeInto, mergeFrom);

rv |= mergeContactDetails<QContactHobby>(mergeInto, mergeFrom);

rv |= mergeContactDetails<QContactNickname>(mergeInto, mergeFrom);

rv |= mergeContactDetails<QContactNote>(mergeInto, mergeFrom);

rv |= mergeContactDetails<QContactOnlineAccount>(mergeInto, mergeFrom);

rv |= mergeContactDetails<QContactOrganization>(mergeInto, mergeFrom);

rv |= mergeContactDetails<QContactPhoneNumber>(mergeInto, mergeFrom);

rv |= mergeContactDetails<QContactRingtone>(mergeInto, mergeFrom);

rv |= mergeContactDetails<QContactTag>(mergeInto, mergeFrom);

rv |= mergeContactDetails<QContactUrl>(mergeInto, mergeFrom);

rv |= mergeContactDetails<QContactExtendedDetail>(mergeInto, mergeFrom);

return rv;

}

}

SeasideContactBuilder::SeasideContactBuilder()

: d(new SeasideContactBuilderPrivate)

{

// defaults. override in the ctor of your derived type.

d->manager = 0;

d->propertyHandler = 0;

d->unimportableDetailTypes = (QSet<QContactDetail::DetailType>() << QContactDetail::TypeGlobalPresence << QContactDetail::TypeVersion);

d->importableSyncTargets = (QStringList() << QLatin1String("was_local") << QLatin1String("bluetooth"));

}

SeasideContactBuilder::~SeasideContactBuilder()

{

delete d->propertyHandler;

delete d;

}

/*

* Returns a pointer to a valid QContactManager.

* The default implementation uses the SeasideCache manager.

*/

QContactManager *SeasideContactBuilder::manager()

{

if (!d->manager) {

d->manager = SeasideCache::manager();

}

return d->manager;

}

/*

* Returns a filter which will return the subset of contacts

* in the manager which are potential merge candidates for

* the imported contacts (ie, come from the same sync target).

*

* The default implementation will return a filter which matches

* any local / was_local / Bluetooth contact.

*/

QContactFilter SeasideContactBuilder::mergeSubsetFilter() const

{

return localContactFilter();

}

/*

* Returns a versit property handler which will be used during

* conversion of versit documents into QContact instances.

*

* The default implementation will return a SeasidePropertyHandler.

*/

QVersitContactHandler *SeasideContactBuilder::propertyHandler()

{

if (!d->propertyHandler) {

d->propertyHandler = new SeasidePropertyHandler;

}

return d->propertyHandler;

}

/*

* Merge the given (matching) \a local contact into the given

* \a import contact, so that the \a import contact could be

* later saved in the manager.

*

* Returns \c true if the \a import contact differed significantly

* from the \a local contact (that is, if saving the returned

* \a import contact would result in the \a local contact being

* updated).

*

* The \a erase value will be set to true if the given import

* contact should be erased from the imported contacts list if

* there are no significant differences between it and the local

* contact (that is, if the imported contact should be omitted

* from later possible store operations, due to the fact that such

* a store operation would be a no-op for that contact).

*

* The default implementation performs a non-destructive merge

* and will set \a erase to true, which is the required behaviour

* for an "import" style sync.

*

* Sync implementations which require remote-detail-removal

* semantics, for example, should implement this function

* differently (eg, prefer-local or prefer-remote), and should

* possibly set \a erase to false if they don't wish to prune

* the import list prior to save.

*/

bool SeasideContactBuilder::mergeLocalIntoImport(QContact &import, const QContact &local, bool *erase)

{

// this implementation does a (mostly) non-destructive detail-addition-merge.

// other implementations may choose to prefer-local or prefer-remote.

*erase = true;

QContact temp(import);

import = local;

return mergeContacts(&import, temp);

}

/*

* Merge the given (matching) \a otherImport contact into the given

* \a import contact. This function is set \a erase to true if

* the \a otherImport contact should be erased from the import list.

* The function will return \c true if the \a import contact

* is modified as a result of the merge.

*

* Returns \c true if the \a otherImport contact

* should be erased from the import list, otherwise \c false.

*

* The default implementation performs a non-destructive merge

* into the \a import contact, and then sets \a erase to true, which

* is the required behaviour for an "import" style sync.

*

* Sync implementations which require one-to-one mapping between

* import contacts and device-stored contacts should set \a erase

* to false in this function.

*/

bool SeasideContactBuilder::mergeImportIntoImport(QContact &import, QContact &otherImport, bool *erase)

{

*erase = true;

return mergeContacts(&import, otherImport);

}

/*

* Import the given Versit \a documents as QContacts and return them.

* The default implementation uses a SeasidePropertyHandler during import

*/

QList<QContact> SeasideContactBuilder::importContacts(const QList<QVersitDocument> &documents)

{

QVersitContactHandler *handler = propertyHandler();

QVersitContactImporter importer;

importer.setPropertyHandler(handler);

importer.importDocuments(documents);

return importer.contacts();

}

/*

* Preprocess the given import contact prior to duplicate detection,

* merging, and subsequent storage.

*

* The default implementation performs some fixes for common issues

* encountered in NAME field details, and removes various detail types

* which are not supported by the qtcontacts-sqlite manager engine.

*/

void SeasideContactBuilder::preprocessContact(QContact &contact)

{

// Fix up name (field ordering) if required

QContactName nameDetail = contact.detail<QContactName>();

if (applyNameFixes(&nameDetail)) {

contact.saveDetail(&nameDetail);

}

// Remove any details that our backend can't store, or which

// the client wishes stripped from the imported contacts.

foreach (QContactDetail detail, contact.details()) {

if (d->unimportableDetailTypes.contains(detail.type())) {

qDebug() << " Removing unimportable detail:" << detail;

contact.removeDetail(&detail);

} else if (detail.type() == QContactSyncTarget::Type) {

// We allow some syncTarget values

const QString syncTarget(detail.value<QString>(QContactSyncTarget::FieldSyncTarget));

if (!d->importableSyncTargets.contains(syncTarget)) {

qDebug() << " Removing unimportable syncTarget:" << syncTarget;

contact.removeDetail(&detail);

}

}

}

// Set nickname by default if the name is empty

if (contactNameString(contact).isEmpty()) {

QContactName nameDetail = contact.detail<QContactName>();

contact.removeDetail(&nameDetail);

if (contact.details<QContactNickname>().isEmpty()) {

QString label = contact.detail<QContactDisplayLabel>().label();

if (label.isEmpty()) {

label = SeasideCache::generateDisplayLabelFromNonNameDetails(contact);

}

setNickname(contact, label);

}

}

}

/*

* Returns the index into the \a importedContacts list at which a

* duplicate (merge candidate) of the contact at the given

* \a contactIndex may be found, or \c -1 if no match is found.

*

* The default implementation uses a combination of GUID and

* name / label matching to determine if a contact is duplicated

* within the import list.

*

* The result will be used to merge any duplicated contacts within

* the import list, which is the required behaviour when performing

* an "import" style sync. Any implementation which requires

* a one-to-one mapping between import contacts and stored device

* contacts should instead return -1 from this function.

*/

int SeasideContactBuilder::previousDuplicateIndex(QList<QContact> &importedContacts, int contactIndex)

{

QContact &contact(importedContacts[contactIndex]);

const QString guid = contact.detail<QContactGuid>().guid();

const QString name = contactNameString(contact);

const bool emptyName = name.isEmpty();

const QString label = contact.detail<QContactDisplayLabel>().label().isEmpty()

?SeasideCache::generateDisplayLabelFromNonNameDetails(contact)

: contact.detail<QContactDisplayLabel>().label();

int previousIndex = -1;

QHash<QString, int>::const_iterator git = d->importGuids.find(guid);

if (git != d->importGuids.end()) {

previousIndex = git.value();

if (!emptyName) {

// If we have a GUID match, but names differ, ignore the match

const QContact &previous(importedContacts[previousIndex]);

const QString previousName = contactNameString(previous);

if (!previousName.isEmpty() && (previousName != name)) {

previousIndex = -1;

// Remove the conflicting GUID from this contact

QContactGuid guidDetail = contact.detail<QContactGuid>();

contact.removeDetail(&guidDetail);

}

}

}

if (previousIndex == -1) {

if (!emptyName) {

QHash<QString, int>::const_iterator nit = d->importNames.find(name);

if (nit != d->importNames.end()) {

previousIndex = nit.value();

}

} else if (!label.isEmpty()) {

// Only if name is empty, use displayLabel - probably SIM import

QHash<QString, int>::const_iterator lit = d->importLabels.find(label);

if (lit != d->importLabels.end()) {

previousIndex = lit.value();

}

}

}

if (previousIndex == -1) {

// No previous duplicate detected. This is a new contact.

// Update our identification hashes with this contact's info.

if (!guid.isEmpty()) {

d->importGuids.insert(guid, contactIndex);

}

if (!emptyName) {

d->importNames.insert(name, contactIndex);

} else if (!label.isEmpty()) {

d->importLabels.insert(label, contactIndex);

}

}

return previousIndex;

}

/*

* Build up any indexes of information required to later determine

* whether a given import contact is already represented on the

* device (ie, if the "new" contact is actually a new contact,

* or if it constitutes an update to a previously imported contact).

*

* The default implementation builds up hashes of GUID, name and

* label information to use later during match detection.

*/

void SeasideContactBuilder::buildLocalDeviceContactIndexes()

{

// Find all names and GUIDs for local contacts that might match these contacts

QContactFetchHint fetchHint(basicFetchHint());

fetchHint.setDetailTypesHint(QList<QContactDetail::DetailType>() << QContactName::Type << QContactNickname::Type << QContactGuid::Type);

QContactManager *mgr(manager());

foreach (const QContact &contact, mgr->contacts(mergeSubsetFilter(), QList<QContactSortOrder>(), fetchHint)) {

const QString guid = contact.detail<QContactGuid>().guid();

const QString name = contactNameString(contact);

if (!guid.isEmpty()) {

d->existingGuids.insert(guid, contact.id());

}

if (!name.isEmpty()) {

d->existingNames.insert(name, contact.id());

d->existingContactNames.insert(contact.id(), name);

}

foreach (const QContactNickname &nick, contact.details<QContactNickname>()) {

d->existingNicknames.insert(nick.nickname(), contact.id());

}

}

}

/*

* Returns the id of an existing local device contact which matches

* the given import \a contact. This local device contact is a

* previously-imported version of the "new" import \a contact.

*

* The default implementation uses the previously cached GUID,

* name and label information to perform the match detection.

*/

QContactId SeasideContactBuilder::matchingLocalContactId(QContact &contact)

{

const QString guid = contact.detail<QContactGuid>().guid();

const QString name = contactNameString(contact);

const bool emptyName = name.isEmpty();

QContactId existingId;

QHash<QString, QContactId>::const_iterator git = d->existingGuids.find(guid);

if (git != d->existingGuids.end()) {

existingId = *git;

if (!emptyName) {

// If we have a GUID match, but names differ, ignore the match

QMap<QContactId, QString>::iterator nit = d->existingContactNames.find(existingId);

if (nit != d->existingContactNames.end()) {

const QString &existingName(*nit);

if (!existingName.isEmpty() && (existingName != name)) {

existingId = QContactId();

// Remove the conflicting GUID from this contact

QContactGuid guidDetail = contact.detail<QContactGuid>();

contact.removeDetail(&guidDetail);

}

}

}

}

if (existingId.isNull()) {

if (!emptyName) {

QHash<QString, QContactId>::const_iterator nit = d->existingNames.find(name);

if (nit != d->existingNames.end()) {

existingId = *nit;

}

} else {

foreach (const QContactNickname nick, contact.details<QContactNickname>()) {

const QString nickname(nick.nickname());

if (!nickname.isEmpty()) {

QHash<QString, QContactId>::const_iterator nit = d->existingNicknames.find(nickname);

if (nit != d->existingNicknames.end()) {

existingId = *nit;

break;

}

}

}

}

}

return existingId;

}