void CalDavClient::startQuickSync()
{
    FUNCTION_CALL_TRACE;

    mKCal::ExtendedCalendar::Ptr calendar = mKCal::ExtendedCalendar::Ptr(new mKCal::ExtendedCalendar(KDateTime::Spec::UTC()));
    mKCal::ExtendedStorage::Ptr storage = calendar->defaultStorage(calendar);

    storage->open();
    storage->load(QDateTime::currentDateTime().toUTC().addMonths(-6).date(),
                  QDateTime::currentDateTime().toUTC().addMonths(12).date());

    // we add 2 seconds to ensure that the timestamp doesn't
    // fall prior to when the calendar db commit fs sync finalises.
    KDateTime fromDate(lastSyncTime().addSecs(2));
    LOG_DEBUG("\n\nLAST SYNC TIME = " << fromDate.toString() << "\n\n");

    KCalCore::Incidence::List inserted;
    KCalCore::Incidence::List modified;
    KCalCore::Incidence::List deleted;
    QString errorString;
    if (!loadStorageChanges(storage, fromDate, &inserted, &modified, &deleted, &errorString)) {
        storage->close();
        calendar->close();
        syncFinished(Buteo::SyncResults::INTERNAL_ERROR, errorString);
        return;
    }
    LOG_DEBUG("Changes: inserted = " << inserted.count()
              << "modified = " << modified.count()
              << "deleted = " << deleted.count());
    if (inserted.isEmpty() && modified.isEmpty() && deleted.isEmpty()) {
        // no local changes to send, just do a REPORT to pull updates from server
        retrieveETags();
    } else {
        for (int i=0; i<inserted.count(); i++) {
            Put *put = new Put(mNAManager, &mSettings);
            mRequests.insert(put);
            connect(put, SIGNAL(finished()), this, SLOT(nonReportRequestFinished()));
            put->createEvent(inserted[i]);
        }
        for (int i=0; i<modified.count(); i++) {
            Put *put = new Put(mNAManager, &mSettings);
            mRequests.insert(put);
            connect(put, SIGNAL(finished()), this, SLOT(nonReportRequestFinished()));
            put->updateEvent(modified[i]);
        }
        for (int i=0; i<deleted.count(); i++) {
            Delete *del = new Delete(mNAManager, &mSettings);
            mRequests.insert(del);
            connect(del, SIGNAL(finished()), this, SLOT(nonReportRequestFinished()));
            del->deleteEvent(deleted[i]);
        }
    }
    storage->close();
    calendar->close();
}
void
GContactClient::changedLocalContactIds ()
{
    FUNCTION_CALL_TRACE;

    /**
     o Get last sync time
     o Fetch added/modified/deleted contact ids
     */

    QDateTime syncTime = lastSyncTime ();

    mAddedContactIds = mContactBackend->getAllNewContactIds (syncTime);
    mModifiedContactIds = mContactBackend->getAllModifiedContactIds (syncTime);
    mDeletedContactIds = mContactBackend->getAllDeletedContactIds (syncTime);
}
bool
GContactClient::init() {
    FUNCTION_CALL_TRACE;

    if (lastSyncTime ().isNull ())
        mSlowSync = true;
    else
        mSlowSync = false;

    mContactBackend = new GContactsBackend ();
    if (initConfig () && initTransport ()) {
        return true;
    } else {
        // Uninitialize everything that was initialized before failure.
        uninit();

        return false;
    }
}
bool CalDavClient::init()
{
    FUNCTION_CALL_TRACE;

    if (lastSyncTime().isNull()) {
        mSlowSync = true;
    } else {
        mSlowSync = false;
    }

    mNAManager = new QNetworkAccessManager;

    if (initConfig()) {
        return true;
    } else {
        // Uninitialize everything that was initialized before failure.
        uninit();
        return false;
    }
}
void
GContactClient::fetchRemoteContacts (const int startIndex)
{
    FUNCTION_CALL_TRACE;

    /**
     o Get last sync time
     o Get etag value from local file system (this is a soft etag)
     o Connect finishedRequest to parseResults & network error slots
     o Use mTransport to perform network fetch
    */
    QDateTime syncTime = lastSyncTime ();
    if (!syncTime.isNull ())
        mTransport->setUpdatedMin (syncTime);

    if (startIndex != 1)
    {
        mTransport->setStartIndex (startIndex);
    }
    mTransport->setMaxResults (GConfig::MAX_RESULTS);
    if (mSlowSync == false)
        mTransport->setShowDeleted ();

    // FIXME: Fetching contacts using etag value as described in Google
    // data API does not seem to work
    // https://developers.google.com/gdata/docs/2.0/reference

    QString token = authToken ();
    if (token.isNull () || token.isEmpty ())
    {
        LOG_CRITICAL ("Auth token is null");
        // Better error would be SYNC_CONFIG_ERROR
        emit syncFinished (Sync::SYNC_ERROR);
        return;
    }
    mTransport->setGDataVersionHeader ();
    mTransport->addHeader (QByteArray ("Authorization"),
                           QString ("Bearer " + token).toUtf8());

    mTransport->request (GTransport::GET);
}
void
GContactClient::fetchRemoteContacts ()
{
    FUNCTION_CALL_TRACE;

    /**
     o Get last sync time
     o Get etag value from local file system (this is a soft etag)
     o Connect finishedRequest to parseResults & network error slots
     o Use mTransport to perform network fetch
    */
    QDateTime syncTime = lastSyncTime ();
    if (!syncTime.isNull ())
        mTransport->setUpdatedMin (syncTime);

    // FIXME: Fetching contacts using etag value as described in Google
    // data API does not seem to work
    // https://developers.google.com/gdata/docs/2.0/reference
    // The etag value has to be handled later

    QString token = authToken ();
    if (token.isNull () || token.isEmpty ())
    {
        LOG_CRITICAL ("Auth token is null");
        return;
    }
    LOG_DEBUG ("++ Auth token" << token);
    mTransport->setAuthToken (token);

    connect (mTransport, SIGNAL (finishedRequest ()),
             this, SLOT (networkRequestFinished ()));

    connect (mTransport, SIGNAL (error (QNetworkReply::NetworkError)),
             this, SLOT (networkError (QNetworkReply::NetworkError)));

    mTransport->request (GTransport::GET);
}