personsmodel.cpp

/*
    Persons Model
    Copyright (C) 2012  Martin Klapetek <martin.klapetek@gmail.com>
    Copyright (C) 2012  Aleix Pol Gonzalez <aleixpol@blue-systems.com>
    Copyright (C) 2013  David Edmundson <davidedmundson@kde.org>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "personsmodel.h"

#include "personpluginmanager_p.h"
#include "metacontact_p.h"
#include "backends/basepersonsdatasource.h"
#include "personmanager_p.h"
#include "backends/abstractcontact.h"

#include <QStandardPaths>
#include <QPixmap>
#include <QTimer>
#include <QUrl>
#include <QDebug>

namespace KPeople
{
class PersonsModelPrivate : public QObject
{
    Q_OBJECT
public:
    PersonsModelPrivate(PersonsModel *q)
        : q(q)
        , genericAvatarImagePath(QStandardPaths::locate(QStandardPaths::QStandardPaths::GenericDataLocation, QStringLiteral("kpeople/dummy_avatar.png")))
        , initialFetchesDoneCount(0)
        , isInitialized(false)
        , hasError(false)
    {
    }
    PersonsModel *const q;

    //NOTE This is the opposite way round to the return value from contactMapping() for easier lookups
    QHash<QString /*contactUri*/, QString /*PersonUri*/> contactToPersons;

    //hash of person objects indexed by ID
    QHash<QString /*Person ID*/, QPersistentModelIndex /*Row*/> personIndex;

    //a list so we have an order in the model
    QList<MetaContact> metacontacts; //TODO: Make QVector

    QString genericAvatarImagePath;
    QList<AllContactsMonitorPtr> m_sourceMonitors;

    int initialFetchesDoneCount;

    bool isInitialized;
    bool hasError;

    //methods that manipulate the model
    void addPerson(const MetaContact &mc);
    void removePerson(const QString &id);
    void personChanged(const QString &personUri);
    QString personUriForContact(const QString &contactUri) const;
    QVariant dataForContact(const QString &personUri, const AbstractContact::Ptr &contact, int role) const;

//     SLOTS
    void onContactsFetched();
    //update when a resource signals a contact has changed
    void onContactAdded(const QString &contactUri, const AbstractContact::Ptr &contact);
    void onContactChanged(const QString &contactUri, const AbstractContact::Ptr &contact);
    void onContactRemoved(const QString &contactUri);

    //update on metadata changes
    void onAddContactToPerson(const QString &contactUri, const QString &newPersonUri);
    void onRemoveContactsFromPerson(const QString &contactUri);

public Q_SLOTS:
    void onMonitorInitialFetchComplete(bool success = true);
};
}

using namespace KPeople;

PersonsModel::PersonsModel(QObject *parent):
    QAbstractItemModel(parent),
    d_ptr(new PersonsModelPrivate(this))
{
    Q_D(PersonsModel);

    Q_FOREACH (BasePersonsDataSource *dataSource, PersonPluginManager::dataSourcePlugins()) {
        const AllContactsMonitorPtr monitor = dataSource->allContactsMonitor();
        if (monitor->isInitialFetchComplete()) {
            QMetaObject::invokeMethod(d, "onMonitorInitialFetchComplete", Qt::QueuedConnection, Q_ARG(bool, monitor->initialFetchSuccess()));
        } else {
            connect(monitor.data(), &AllContactsMonitor::initialFetchComplete,
                    d, &PersonsModelPrivate::onMonitorInitialFetchComplete);
        }
        d->m_sourceMonitors << monitor;
    }
    d->onContactsFetched();

    connect(PersonManager::instance(), &PersonManager::contactAddedToPerson, d, &PersonsModelPrivate::onAddContactToPerson);
    connect(PersonManager::instance(), &PersonManager::contactRemovedFromPerson, d, &PersonsModelPrivate::onRemoveContactsFromPerson);
}

PersonsModel::~PersonsModel()
{
}

QHash<int, QByteArray> PersonsModel::roleNames() const
{
    QHash<int, QByteArray> roles = QAbstractItemModel::roleNames();
    roles.insert(PersonUriRole, "personUri");
    roles.insert(PersonVCardRole, "personVCard");
    roles.insert(ContactsVCardRole, "contactsVCard");
    return roles;
}

QVariant PersonsModel::data(const QModelIndex &index, int role) const
{
    Q_D(const PersonsModel);

    //optimization - if we don't cover this role, ignore it
    if (role < Qt::UserRole && role != Qt::DisplayRole && role != Qt::DecorationRole) {
        return QVariant();
    }

    if (index.row() < 0 || index.row() >= rowCount(index.parent())) {
        return QVariant();
    }

    if (index.parent().isValid()) {
        if (role == ContactsVCardRole) {
            return QVariant::fromValue<AbstractContact::List>(AbstractContact::List());
        }
        const MetaContact &mc = d->metacontacts.at(index.parent().row());

        return d->dataForContact(mc.id(), mc.contacts().at(index.row()), role);
    } else {
        const MetaContact &mc = d->metacontacts.at(index.row());
        return d->dataForContact(mc.id(), mc.personAddressee(), role);
    }
}

QVariant PersonsModelPrivate::dataForContact(const QString &personUri, const AbstractContact::Ptr &person, int role) const
{
    switch (role) {
    case PersonsModel::FormattedNameRole:
        return person->customProperty(AbstractContact::NameProperty);
    case PersonsModel::PhotoRole: {
        QVariant pic = person->customProperty(AbstractContact::PictureProperty);
        if (pic.canConvert<QImage>()) {
            QImage avatar = pic.value<QImage>();
            if (!avatar.isNull()) {
                return avatar;
            }
        } else if (pic.canConvert<QPixmap>()) {
            QPixmap avatar = pic.value<QPixmap>();
            if (!avatar.isNull()) {
                return avatar;
            }
        } else if (pic.canConvert<QUrl>() && pic.toUrl().isLocalFile()) {
            QPixmap avatar = QPixmap(pic.toUrl().toLocalFile());
            if (!avatar.isNull()) {
                return avatar;
            }
        }

        // If none of the above were valid images,
        // return the generic one
        return QPixmap(genericAvatarImagePath);
    }
    case PersonsModel::PersonUriRole:
        return personUri;
    case PersonsModel::PersonVCardRole:
        return QVariant::fromValue<AbstractContact::Ptr>(person);
    case PersonsModel::ContactsVCardRole:
        return QVariant::fromValue<AbstractContact::List>(metacontacts[personIndex[personUri].row()].contacts());
    case PersonsModel::GroupsRole:
        return person->customProperty(QStringLiteral("all-groups"));
    }
    return QVariant();
}

int PersonsModel::columnCount(const QModelIndex &parent) const
{
    Q_UNUSED(parent);

    return 1;
}

int PersonsModel::rowCount(const QModelIndex &parent) const
{
    Q_D(const PersonsModel);

    if (!parent.isValid()) {
        return d->metacontacts.size();
    }

    if (parent.isValid() && !parent.parent().isValid()) {
        return d->metacontacts.at(parent.row()).contacts().count();
    }

    return 0;
}

bool PersonsModel::isInitialized() const
{
    Q_D(const PersonsModel);

    return d->isInitialized;
}

QModelIndex PersonsModel::index(int row, int column, const QModelIndex &parent) const
{
    if (row < 0 || column < 0 || row >= rowCount(parent)) {
        return QModelIndex();
    }
    //top level items have internalId -1. Anything >=0 is the row of the top level item
    if (!parent.isValid()) {
        return createIndex(row, column, -1);
    }

    return createIndex(row, column, parent.row());
}

QModelIndex PersonsModel::parent(const QModelIndex &childIndex) const
{
    if (childIndex.internalId() == -1 || !childIndex.isValid()) {
        return QModelIndex();
    }

    return index(childIndex.internalId(), 0, QModelIndex());
}

void PersonsModelPrivate::onMonitorInitialFetchComplete(bool success)
{
    initialFetchesDoneCount++;
    if (!success) {
        hasError = true;
    }
    Q_ASSERT(initialFetchesDoneCount <= m_sourceMonitors.count());
    if (initialFetchesDoneCount == m_sourceMonitors.count()) {
        isInitialized = true;
        Q_EMIT q->modelInitialized(!hasError);
    }
}

void PersonsModelPrivate::onContactsFetched()
{
    QMap<QString, AbstractContact::Ptr> addresseeMap;

    //fetch all already loaded contacts from plugins
    Q_FOREACH (const AllContactsMonitorPtr &contactWatcher, m_sourceMonitors) {
        addresseeMap.unite(contactWatcher->contacts());
    }

    //add metacontacts
    const QMultiHash<QString, QString> contactMapping = PersonManager::instance()->allPersons();

    Q_FOREACH (const QString &key, contactMapping.uniqueKeys()) {
        QMap<QString, AbstractContact::Ptr> contacts;
        Q_FOREACH (const QString &contact, contactMapping.values(key)) {
            contactToPersons[contact] = key;
            if (addresseeMap.contains(contact)) {
                contacts[contact] = addresseeMap.take(contact);
            }
        }
        if (!contacts.isEmpty()) {
            addPerson(MetaContact(key, contacts));
        }
    }

    //add remaining contacts
    QMap<QString, AbstractContact::Ptr>::const_iterator i;
    for (i = addresseeMap.constBegin(); i != addresseeMap.constEnd(); ++i) {
        addPerson(MetaContact(i.key(), i.value()));
    }

    Q_FOREACH (const AllContactsMonitorPtr monitor, m_sourceMonitors) {
        connect(monitor.data(), &AllContactsMonitor::contactAdded, this, &PersonsModelPrivate::onContactAdded);
        connect(monitor.data(), &AllContactsMonitor::contactChanged, this, &PersonsModelPrivate::onContactChanged);
        connect(monitor.data(), &AllContactsMonitor::contactRemoved, this, &PersonsModelPrivate::onContactRemoved);
    }
}

void PersonsModelPrivate::onContactAdded(const QString &contactUri, const AbstractContact::Ptr &contact)
{
    const QString &personUri = personUriForContact(contactUri);

    if (personIndex.contains(personUri)) {
        int personRow = personIndex[personUri].row();
        MetaContact &mc = metacontacts[personRow];

        //if the MC object already contains this object, we want to update the row, not do an insert
        if (mc.contactUris().contains(contactUri)) {
            qWarning() << "Source emitted contactAdded for a contact we already know about " << contactUri;
            onContactChanged(contactUri, contact);
        } else {
            int newContactPos = mc.contacts().size();
            q->beginInsertRows(q->index(personRow), newContactPos, newContactPos);
            mc.insertContact(contactUri, contact);
            q->endInsertRows();
            personChanged(personUri);
        }
    } else { //new contact -> new person
        QMap<QString, AbstractContact::Ptr> map;
        map[contactUri] = contact;
        addPerson(MetaContact(personUri, map));
    }
}

void PersonsModelPrivate::onContactChanged(const QString &contactUri, const AbstractContact::Ptr &contact)
{
    const QString &personUri = personUriForContact(contactUri);
    int personRow = personIndex[personUri].row();
    int contactRow = metacontacts[personRow].updateContact(contactUri, contact);

    const QModelIndex contactIndex = q->index(contactRow,
                                     0,
                                     q->index(personRow));

    Q_EMIT q->dataChanged(contactIndex, contactIndex);

    personChanged(personUri);
}

void PersonsModelPrivate::onContactRemoved(const QString &contactUri)
{
    const QString &personUri = personUriForContact(contactUri);

    int personRow = personIndex[personUri].row();

    MetaContact &mc = metacontacts[personRow];
    int contactPosition = mc.contactUris().indexOf(contactUri);
    q->beginRemoveRows(q->index(personRow, 0), contactPosition, contactPosition);
    mc.removeContact(contactUri);
    q->endRemoveRows();

    //if MC object is now invalid remove the person from the list
    if (!mc.isValid()) {
        removePerson(personUri);
    }
    personChanged(personUri);
}

void PersonsModelPrivate::onAddContactToPerson(const QString &contactUri, const QString &newPersonUri)
{
    const QString oldPersonUri = personUriForContact(contactUri);

    contactToPersons.insert(contactUri, newPersonUri);

    int oldPersonRow = personIndex[oldPersonUri].row();

    if (oldPersonRow < 0) {
        return;
    }

    MetaContact &oldMc = metacontacts[oldPersonRow];

    //get contact already in the model, remove it from the previous contact
    int contactPosition = oldMc.contactUris().indexOf(contactUri);
    const AbstractContact::Ptr contact = oldMc.contacts().at(contactPosition);

    q->beginRemoveRows(q->index(oldPersonRow), contactPosition, contactPosition);
    oldMc.removeContact(contactUri);
    q->endRemoveRows();

    if (!oldMc.isValid()) {
        removePerson(oldPersonUri);
    } else {
        personChanged(oldPersonUri);
    }

    //if the new person is already in the model, add the contact to it
    if (personIndex.contains(newPersonUri)) {
        int newPersonRow = personIndex[newPersonUri].row();
        MetaContact &newMc = metacontacts[newPersonRow];
        int newContactPos = newMc.contacts().size();
        q->beginInsertRows(q->index(newPersonRow), newContactPos, newContactPos);
        newMc.insertContact(contactUri, contact);
        q->endInsertRows();
        personChanged(newPersonUri);
    } else { //if the person is not in the model, create a new person and insert it
        QMap<QString, AbstractContact::Ptr> contacts;
        contacts[contactUri] = contact;
        addPerson(MetaContact(newPersonUri, contacts));
    }
}

void PersonsModelPrivate::onRemoveContactsFromPerson(const QString &contactUri)
{
    const QString personUri = personUriForContact(contactUri);
    int personRow = personIndex[personUri].row();
    MetaContact &mc = metacontacts[personRow];

    const AbstractContact::Ptr &contact = mc.contact(contactUri);
    mc.removeContact(contactUri);
    contactToPersons.remove(contactUri);

    //if we don't want the person object anymore
    if (!mc.isValid()) {
        removePerson(personUri);
    } else {
        personChanged(personUri);
    }

    //now re-insert as a new contact
    //we know it's not part of a metacontact anymore so reinsert as a contact
    addPerson(MetaContact(contactUri, contact));
}

void PersonsModelPrivate::addPerson(const KPeople::MetaContact &mc)
{
    const QString &id = mc.id();

    int row = metacontacts.size();
    q->beginInsertRows(QModelIndex(), row, row);
    metacontacts.append(mc);
    personIndex[id] = q->index(row);
    q->endInsertRows();
}

void PersonsModelPrivate::removePerson(const QString &id)
{
    QPersistentModelIndex index = personIndex.value(id);
    if (!index.isValid()) { //item not found
        return;
    }

    q->beginRemoveRows(QModelIndex(), index.row(), index.row());
    personIndex.remove(id);
    metacontacts.removeAt(index.row());
    q->endRemoveRows();
}

void PersonsModelPrivate::personChanged(const QString &personUri)
{
    int row = personIndex[personUri].row();
    if (row >= 0) {
        const QModelIndex personIndex = q->index(row);
        Q_EMIT q->dataChanged(personIndex, personIndex);
    }
}

QString PersonsModelPrivate::personUriForContact(const QString &contactUri) const
{
    QHash<QString, QString>::const_iterator it = contactToPersons.constFind(contactUri);
    if (it != contactToPersons.constEnd()) {
        return *it;
    } else {
        return contactUri;
    }
}

QModelIndex PersonsModel::indexForPersonUri(const QString &personUri) const
{
    Q_D(const PersonsModel);
    return d->personIndex.value(personUri);
}

QVariant PersonsModel::get(int row, int role)
{
    return index(row, 0).data(role);
}

QVariant PersonsModel::contactCustomProperty(const QModelIndex &index, const QString &key) const
{
    Q_D(const PersonsModel);
    if (index.parent().isValid()) {
        const MetaContact &mc = d->metacontacts.at(index.parent().row());

        return mc.contacts().at(index.row())->customProperty(key);
    } else {
        const MetaContact &mc = d->metacontacts.at(index.row());
        return mc.personAddressee()->customProperty(key);
    }
}

#include "personsmodel.moc"