Changes: ID fetch request: Forward error code in emulated mode

[qtcontacts-tracker:qtcontacts-tracker.git] / src / engine / contactidfetchrequest.cpp

/*********************************************************************************
 ** This file is part of QtContacts tracker storage plugin
 **
 ** Copyright (c) 2010-2011 Nokia Corporation and/or its subsidiary(-ies).
 **
 ** Contact:  Nokia Corporation (info@qt.nokia.com)
 **
 ** GNU Lesser General Public License Usage
 ** This file may be used under the terms of the GNU Lesser General Public License
 ** version 2.1 as published by the Free Software Foundation and appearing in the
 ** file LICENSE.LGPL included in the packaging of this file.  Please review the
 ** following information to ensure the GNU Lesser General Public License version
 ** 2.1 requirements will be met:
 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
 ** In addition, as a special exception, Nokia gives you certain additional rights.
 ** These rights are described in the Nokia Qt LGPL Exception version 1.1, included
 ** in the file LGPL_EXCEPTION.txt in this package.
 **
 ** Other Usage
 ** Alternatively, this file may be used in accordance with the terms and
 ** conditions contained in a signed written agreement between you and Nokia.
 *********************************************************************************/

#include "contactidfetchrequest.h"

#include "dao/contactdetailschema.h"
#include "dao/scalarquerybuilder.h"
#include "dao/sparqlconnectionmanager.h"
#include "engine/contactfetchrequest.h"
#include "engine/engine.h"

#include <ontologies/rdf.h>
#include <QtSparql>

///////////////////////////////////////////////////////////////////////////////////////////////////

CUBI_USE_NAMESPACE

///////////////////////////////////////////////////////////////////////////////////////////////////

QTrackerContactIdFetchRequest::QTrackerContactIdFetchRequest(QContactAbstractRequest *request,
                                                             QContactTrackerEngine *engine,
                                                             QObject *parent)
    : QTrackerBaseRequest<QContactLocalIdFetchRequest>(engine, parent)
    , m_filter(staticCast(request)->filter())
    , m_sorting(staticCast(request)->sorting())
{
}

QTrackerContactIdFetchRequest::~QTrackerContactIdFetchRequest()
{
}

QString
QTrackerContactIdFetchRequest::buildQuery(QContactManager::Error &error)
{
    Select select;
    PatternBase base;

    Variable contact = Variable(QLatin1String("contact"));
    select.addProjection(Functions::trackerId.apply(contact));

    foreach(const QString &contactType, engine()->supportedContactTypes()) {
        PatternGroup group;
        Filter filter;
        const QTrackerContactDetailSchema &schema = engine()->schema(contactType);

        // add restrictions from request filters
        QTrackerScalarContactQueryBuilder queryBuilder(schema, engine()->managerUri());

        error = queryBuilder.bindFilter(m_filter, filter);

        if (error != QContactManager::NoError) {
            return QString();
        }

        foreach(const QString &classIri, schema.contactClassIris()) {
            ResourceValue iri = ResourceValue(classIri);
            group.addPattern(contact, Resources::rdf::type::resource(), iri);
        }

        group.setFilter(filter);

        if (not base.isValid()) {
            base = group;
        } else {
            base = Union(base, group);
        }
    }

    error = QContactManager::NoError;
    select.addRestriction(base);

    return select.sparql();
}

void
QTrackerContactIdFetchRequest::run()
{
    if (isCanceled()) {
        return;
    }

    if (m_sorting.isEmpty()) {
        runNative();
    } else {
        runEmulated();
    }
}

void
QTrackerContactIdFetchRequest::runNative()
{
    // build the SPARQL query
    QContactManager::Error error = QContactManager::UnspecifiedError;
    const QString queryString = buildQuery(error);

    if (error != QContactManager::NoError) {
        setLastError(error);
        return;
    }

    QScopedPointer<QSparqlResult> result(runQuery(QSparqlQuery(queryString), SyncQueryOptions));

    if (result.isNull()) {
        // runQuery() called reportError()
        return;
    }

    // We use a QSet since we want to ensure there are no duplicates
    QSet<QContactLocalId> localIds;

    // We use a QSet because we want to eliminate duplicates.
    // In case of unioned QContactDetailFilter (for instance), the same localId
    // may be included multiple times; this is undesirable.
    while(not isCanceled() && result->next()) {
        if (engine()->hasDebugFlag(QContactTrackerEngine::ShowModels)) {
            qDebug() << result->current();
        }

        localIds.insert(result->value(0).toUInt());
    }

    m_localIds = localIds.toList();
}

void
QTrackerContactIdFetchRequest::runEmulated()
{
    // We only use emulated version for sorting
    Q_ASSERT(not m_sorting.isEmpty());

    if (engine()->hasDebugFlag(QContactTrackerEngine::ShowNotes)) {
        qctWarn(QString::fromLatin1("Warning, using emulated localId fetch request"));
    }


    QContactFetchHint hint;
    // An empty hint means "all details", therefore we pass at least one detail name here
    hint.setDetailDefinitionsHint(QStringList() << m_sorting.first().detailDefinitionName());

    QContactFetchRequest request;
    request.setFetchHint(hint);
    request.setSorting(m_sorting);
    request.setFilter(m_filter);

    QScopedPointer<QTrackerAbstractRequest>(engine()->createRequestWorker(&request))->exec();

    if (request.error() != QContactManager::NoError) {
        setLastError(request.error());
        return;
    }

    foreach(const QContact &contact, request.contacts()) {
        if (engine()->hasDebugFlag(QContactTrackerEngine::ShowModels)) {
            qDebug() << contact.localId();
        }

        // Here we do not need to check for duplicate ids, since the fetch request
        // already does that
        m_localIds.append(contact.localId());
    }
}

void
QTrackerContactIdFetchRequest::updateRequest(QContactManager::Error error)
{
    engine()->updateContactLocalIdFetchRequest(staticCast(engine()->request(this).data()),
                                               m_localIds, error,
                                               QContactAbstractRequest::FinishedState);
}

///////////////////////////////////////////////////////////////////////////////////////////////////

#include "moc_contactidfetchrequest.cpp"