Merge lp:~renatofilho/qtorganizer5-eds/recurrence into lp:~ubuntu-sdk-team/qtorganizer5-eds/trunk

[Renato Araujo Oliveira Filho]

- Implemented recurrence support;
- Implemented support for different collection type.
- Implemented Reminder support;

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:24
http://jenkins.qa.ubuntu.com/job/qtorganizer5-eds-ci/1/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtorganizer5-eds-saucy-amd64-ci/1/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtorganizer5-eds-saucy-armhf-ci/1/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtorganizer5-eds-saucy-i386-ci/1/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/qtorganizer5-eds-ci/1/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:25
http://jenkins.qa.ubuntu.com/job/qtorganizer5-eds-ci/2/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtorganizer5-eds-saucy-amd64-ci/2
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtorganizer5-eds-saucy-armhf-ci/2
        deb: http://jenkins.qa.ubuntu.com/job/qtorganizer5-eds-saucy-armhf-ci/2/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtorganizer5-eds-saucy-i386-ci/2

Click here to trigger a rebuild:
http://s-jenkins:8080/job/qtorganizer5-eds-ci/2/rebuild

review: Approve (continuous-integration)

[Gustavo Pichorim Boiko (boiko)]

Looks good.

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
Unapproved changes made after approval.
http://jenkins.qa.ubuntu.com/job/qtorganizer5-eds-autolanding/2/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtorganizer5-eds-saucy-amd64-autolanding/2
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtorganizer5-eds-saucy-armhf-autolanding/2
        deb: http://jenkins.qa.ubuntu.com/job/qtorganizer5-eds-saucy-armhf-autolanding/2/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtorganizer5-eds-saucy-i386-autolanding/2

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'qorganizer/CMakeLists.txt'
--- qorganizer/CMakeLists.txt	2013-08-14 21:23:01 +0000
+++ qorganizer/CMakeLists.txt	2013-09-09 21:01:24 +0000
@@ -7,8 +7,10 @@
     qorganizer-eds-fetchrequestdata.cpp
     qorganizer-eds-engine.cpp
     qorganizer-eds-engineid.cpp
+    qorganizer-eds-removecollectionrequestdata.cpp
     qorganizer-eds-removerequestdata.cpp
     qorganizer-eds-requestdata.cpp
+    qorganizer-eds-savecollectionrequestdata.cpp
     qorganizer-eds-saverequestdata.cpp
 )
 
@@ -17,8 +19,10 @@
     qorganizer-eds-fetchrequestdata.h
     qorganizer-eds-engine.h
     qorganizer-eds-engineid.h
+    qorganizer-eds-removecollectionrequestdata.h
     qorganizer-eds-removerequestdata.h
     qorganizer-eds-requestdata.h
+    qorganizer-eds-savecollectionrequestdata.h
     qorganizer-eds-saverequestdata.h
 )
 
@@ -53,7 +57,6 @@
     ${EDATASERVER_LIBRARIES}
 )
 
-
 qt5_use_modules(${QORGANIZER_BACKEND}-lib Core Organizer)
 qt5_use_modules(${QORGANIZER_BACKEND} Core Organizer)
 
 
=== modified file 'qorganizer/qorganizer-eds-collection-engineid.cpp'
--- qorganizer/qorganizer-eds-collection-engineid.cpp	2013-08-14 21:23:01 +0000
+++ qorganizer/qorganizer-eds-collection-engineid.cpp	2013-09-09 21:01:24 +0000
@@ -18,12 +18,24 @@
 
 #include "qorganizer-eds-collection-engineid.h"
 
+
+
 QOrganizerEDSCollectionEngineId::QOrganizerEDSCollectionEngineId(ESource *source,
                                                                  const QString &managerUri)
     : m_managerUri(managerUri), m_esource(source)
 {
     g_object_ref(m_esource);
     m_collectionId = QString::fromUtf8(e_source_get_uid(m_esource));
+    if (e_source_has_extension(m_esource, E_SOURCE_EXTENSION_CALENDAR)) {
+        m_sourceType = E_CAL_CLIENT_SOURCE_TYPE_EVENTS;
+    } else if (e_source_has_extension(m_esource, E_SOURCE_EXTENSION_TASK_LIST)) {
+        m_sourceType = E_CAL_CLIENT_SOURCE_TYPE_TASKS;
+    } else if (e_source_has_extension(m_esource, E_SOURCE_EXTENSION_MEMO_LIST)) {
+        m_sourceType = E_CAL_CLIENT_SOURCE_TYPE_MEMOS;
+    } else {
+        qWarning() << "Source extension not supported";
+        Q_ASSERT(false);
+    }
 }
 
 QOrganizerEDSCollectionEngineId::QOrganizerEDSCollectionEngineId()
 
=== modified file 'qorganizer/qorganizer-eds-collection-engineid.h'
--- qorganizer/qorganizer-eds-collection-engineid.h	2013-08-14 21:23:01 +0000
+++ qorganizer/qorganizer-eds-collection-engineid.h	2013-09-09 21:01:24 +0000
@@ -22,6 +22,7 @@
 #include <QtOrganizer/QOrganizerCollectionEngineId>
 
 #include <libedataserver/libedataserver.h>
+#include <libecal/libecal.h>
 
 class QOrganizerEDSCollectionEngineId : public QtOrganizer::QOrganizerCollectionEngineId
 {
@@ -39,6 +40,7 @@
 
     QString toString() const;
 
+
     uint hash() const;
 
 #ifndef QT_NO_DEBUG_STREAM
@@ -49,6 +51,7 @@
     QString m_collectionId;
     QString m_managerUri;
     ESource *m_esource;
+    ECalClientSourceType m_sourceType;
 
     QOrganizerEDSCollectionEngineId(ESource *source, const QString &managerUri);
 
 
=== modified file 'qorganizer/qorganizer-eds-engine.cpp'
--- qorganizer/qorganizer-eds-engine.cpp	2013-08-16 02:22:42 +0000
+++ qorganizer/qorganizer-eds-engine.cpp	2013-09-09 21:01:24 +0000
@@ -23,11 +23,14 @@
 #include "qorganizer-eds-fetchrequestdata.h"
 #include "qorganizer-eds-saverequestdata.h"
 #include "qorganizer-eds-removerequestdata.h"
+#include "qorganizer-eds-savecollectionrequestdata.h"
+#include "qorganizer-eds-removecollectionrequestdata.h"
 
 #include <QtCore/qdebug.h>
 #include <QtCore/QPointer>
 #include <QtCore/qstringbuilder.h>
 #include <QtCore/quuid.h>
+#include <QtCore/QCoreApplication>
 
 #include <QtOrganizer/QOrganizerEventAttendee>
 #include <QtOrganizer/QOrganizerItemLocation>
@@ -36,11 +39,18 @@
 #include <QtOrganizer/QOrganizerItemSaveRequest>
 #include <QtOrganizer/QOrganizerItemRemoveRequest>
 #include <QtOrganizer/QOrganizerCollectionFetchRequest>
+#include <QtOrganizer/QOrganizerCollectionSaveRequest>
+#include <QtOrganizer/QOrganizerCollectionRemoveRequest>
 #include <QtOrganizer/QOrganizerEvent>
 #include <QtOrganizer/QOrganizerTodo>
 #include <QtOrganizer/QOrganizerTodoTime>
 #include <QtOrganizer/QOrganizerJournal>
 #include <QtOrganizer/QOrganizerJournalTime>
+#include <QtOrganizer/QOrganizerItemIdFetchRequest>
+#include <QtOrganizer/QOrganizerItemIdFilter>
+#include <QtOrganizer/QOrganizerItemReminder>
+#include <QtOrganizer/QOrganizerItemAudibleReminder>
+#include <QtOrganizer/QOrganizerItemVisualReminder>
 
 #include <glib.h>
 #include <libecal/libecal.h>
@@ -95,7 +105,7 @@
     QOrganizerEDSCollectionEngineId *collection = data->nextCollection();
     if (collection) {
         e_cal_client_connect(collection->m_esource,
-                             E_CAL_CLIENT_SOURCE_TYPE_EVENTS,
+                             collection->m_sourceType,
                              data->cancellable(),
                              (GAsyncReadyCallback) QOrganizerEDSEngine::itemsAsyncConnected,
                              data);
@@ -115,7 +125,7 @@
     EClient *client = e_cal_client_connect_finish(res, &gError);
 
     if (gError) {
-        qWarning() << "Fail to open calendar" << gError->message;
+        qWarning() << "Fail to open calendar:" << gError->message;
         g_error_free(gError);
         gError = 0;
         data->finish(QOrganizerManager::InvalidCollectionError);
@@ -150,26 +160,36 @@
         delete data;
         return;
     } else {
-        qDebug() << "Query size:" << g_slist_length(events);
         data->appendResults(parseEvents(data->collection(), events));
     }
     itemsAsyncStart(data);
 }
 
-
-
 QList<QOrganizerItem> QOrganizerEDSEngine::items(const QList<QOrganizerItemId> &itemIds,
                                                  const QOrganizerItemFetchHint &fetchHint,
                                                  QMap<int, QOrganizerManager::Error> *errorMap,
                                                  QOrganizerManager::Error *error)
 {
     qDebug() << Q_FUNC_INFO;
-    Q_UNUSED(fetchHint)
-    Q_UNUSED(itemIds);
-    Q_UNUSED(errorMap);
-
-    QList<QOrganizerItem> items;
-    return items;
+    QOrganizerItemIdFilter filter;
+    filter.setIds(itemIds);
+
+    QOrganizerItemFetchRequest *req = new QOrganizerItemFetchRequest(this);
+    req->setFilter(filter);
+    req->setFetchHint(fetchHint);
+
+    startRequest(req);
+    waitForRequestFinished(req, -1);
+
+    if (error) {
+        *error = req->error();
+    }
+    // TODO implement correct reply for errorMap
+    if (errorMap) {
+        *errorMap = QMap<int, QOrganizerManager::Error>();
+    }
+    req->deleteLater();
+    return req->items();
 }
 
 QList<QOrganizerItem> QOrganizerEDSEngine::items(const QOrganizerItemFilter &filter,
@@ -181,12 +201,25 @@
                                                  QOrganizerManager::Error *error)
 {
     qDebug() << Q_FUNC_INFO;
-    QList<QOrganizerItem> list;
-    return list;
+
+    QOrganizerItemFetchRequest *req = new QOrganizerItemFetchRequest(this);
+    req->setFilter(filter);
+    req->setStartDate(startDateTime);
+    req->setEndDate(endDateTime);
+    req->setMaxCount(maxCount);
+    req->setSorting(sortOrders);
+    req->setFetchHint(fetchHint);
+
+    startRequest(req);
+    waitForRequestFinished(req, -1);
+
+    if (error) {
+        *error = req->error();
+    }
+    req->deleteLater();
+    return req->items();
 }
 
-
-
 QList<QOrganizerItemId> QOrganizerEDSEngine::itemIds(const QOrganizerItemFilter &filter,
                                                      const QDateTime &startDateTime,
                                                      const QDateTime &endDateTime,
@@ -224,6 +257,7 @@
 {
     qDebug() << Q_FUNC_INFO;
     if (req->items().count() == 0) {
+        qWarning() << "Items count is " << req->items().count();
         QOrganizerManagerEngine::updateItemSaveRequest(req,
                                                        QList<QOrganizerItem>(),
                                                        QOrganizerManager::NoError,
@@ -248,7 +282,7 @@
 
     SaveRequestData *data = new SaveRequestData(this, req, collectionId);
     e_cal_client_connect(collectionEngineId->m_esource,
-                         E_CAL_CLIENT_SOURCE_TYPE_EVENTS,
+                         collectionEngineId->m_sourceType,
                          data->cancellable(),
                          (GAsyncReadyCallback) QOrganizerEDSEngine::saveItemsAsyncConnected,
                          data);
@@ -258,6 +292,7 @@
                                                   GAsyncResult *res,
                                                   SaveRequestData *data)
 {
+    qDebug() << Q_FUNC_INFO;
     Q_UNUSED(source_object);
 
     GError *gError = 0;
@@ -271,7 +306,7 @@
     } else {
         data->setClient(client);
 
-        GSList *comps = parseItems(data->request<QOrganizerItemSaveRequest>()->items());
+        GSList *comps = parseItems(data->client(), data->request<QOrganizerItemSaveRequest>()->items());
         if (comps) {
             if (data->isNew()) {
                 e_cal_client_create_objects(E_CAL_CLIENT(client),
@@ -300,6 +335,7 @@
                                                 GAsyncResult *res,
                                                 SaveRequestData *data)
 {
+    qDebug() << Q_FUNC_INFO;
     Q_UNUSED(source_object);
 
     GError *gError = 0;
@@ -324,6 +360,7 @@
                                                 GAsyncResult *res,
                                                 SaveRequestData *data)
 {
+    qDebug() << Q_FUNC_INFO;
     Q_UNUSED(source_object);
 
     GError *gError = 0;
@@ -334,7 +371,7 @@
                                        &gError);
 
     if (gError) {
-        qWarning() << "Fail to create items" << gError->message;
+        qWarning() << "Fail to create items:" << gError->message;
         g_error_free(gError);
         gError = 0;
         data->finish(QOrganizerManager::InvalidDetailError);
@@ -367,7 +404,24 @@
 
 {
     qDebug() << Q_FUNC_INFO;
-    *error = QOrganizerManager::NoError;
+
+    QOrganizerItemSaveRequest *req = new QOrganizerItemSaveRequest(this);
+    req->setItems(*items);
+    req->setDetailMask(detailMask);
+
+    startRequest(req);
+    waitForRequestFinished(req, -1);
+
+    *errorMap = req->errorMap();
+    *error = req->error();
+
+    if (*error == QOrganizerManager::NoError) {
+        *items = req->items();
+        return true;
+    } else {
+        return false;
+    }
+
     return true;
 }
 
@@ -392,9 +446,8 @@
     QOrganizerCollectionId collection = data->begin();
     if (!collection.isNull()) {
         QOrganizerEDSCollectionEngineId *collectionEngineId = data->parent()->m_collectionsMap[collection.toString()];
-        qDebug() << "REmove items from sourcE: " << e_source_get_display_name(collectionEngineId->m_esource);
         e_cal_client_connect(collectionEngineId->m_esource,
-                             E_CAL_CLIENT_SOURCE_TYPE_EVENTS,
+                             collectionEngineId->m_sourceType,
                              data->cancellable(),
                              (GAsyncReadyCallback) QOrganizerEDSEngine::removeItemsAsyncConnected,
                              data);
@@ -447,7 +500,6 @@
         data->finish(QOrganizerManager::InvalidCollectionError);
         delete data;
     } else {
-        qDebug() << "Item removed";
         data->commit();
         removeItemsAsyncStart(data);
     }
@@ -479,23 +531,164 @@
 QList<QOrganizerCollection> QOrganizerEDSEngine::collections(QOrganizerManager::Error* error)
 {
     qDebug() << Q_FUNC_INFO;
-    *error = QOrganizerManager::NoError;
-    return m_collections;
+
+    QOrganizerCollectionFetchRequest *req = new QOrganizerCollectionFetchRequest(this);
+
+    startRequest(req);
+    waitForRequestFinished(req, -1);
+
+    *error = req->error();
+
+    if (*error == QOrganizerManager::NoError) {
+        return req->collections();
+    } else {
+        return QList<QOrganizerCollection>();
+    }
 }
 
 bool QOrganizerEDSEngine::saveCollection(QOrganizerCollection* collection, QOrganizerManager::Error* error)
 {
     qDebug() << Q_FUNC_INFO;
-    *error = QOrganizerManager::NoError;
-    return true;
-
+    QOrganizerCollectionSaveRequest *req = new QOrganizerCollectionSaveRequest(this);
+    req->setCollection(*collection);
+
+    startRequest(req);
+    waitForRequestFinished(req, -1);
+
+    *error = req->error();
+    if ((*error == QOrganizerManager::NoError) &&
+        (req->collections().count())) {
+        *collection = req->collections()[0];
+        return true;
+    } else {
+        return false;
+    }
+}
+
+void QOrganizerEDSEngine::saveCollectionAsync(QOrganizerCollectionSaveRequest *req)
+{
+    qDebug() << Q_FUNC_INFO;
+
+    if (req->collections().count() == 0) {
+        QOrganizerManagerEngine::updateCollectionSaveRequest(req,
+                                                             QList<QOrganizerCollection>(),
+                                                             QOrganizerManager::NoError,
+                                                             QMap<int, QOrganizerManager::Error>(),
+                                                             QOrganizerAbstractRequest::FinishedState);
+        return;
+    }
+
+    GError *gError = 0;
+    ESourceRegistry *registry = e_source_registry_new_sync(0, &gError);
+    if (gError) {
+        qWarning() << "Fail to create sourge registry:" << gError->message;
+        g_error_free(gError);
+        QOrganizerManagerEngine::updateCollectionSaveRequest(req,
+                                                             QList<QOrganizerCollection>(),
+                                                             QOrganizerManager::UnspecifiedError,
+                                                             QMap<int, QOrganizerManager::Error>(),
+                                                             QOrganizerAbstractRequest::FinishedState);
+        return;
+    }
+    SaveCollectionRequestData *requestData = new SaveCollectionRequestData(this, req);
+    saveCollectionAsyncStart(registry, requestData);
+}
+
+void QOrganizerEDSEngine::saveCollectionAsyncStart(ESourceRegistry *registry, SaveCollectionRequestData *data)
+{
+    qDebug() << Q_FUNC_INFO;
+
+    ESource *source = data->begin();
+    if (source) {
+        e_source_registry_commit_source(registry,
+                                        source,
+                                        data->cancellable(),
+                                        (GAsyncReadyCallback) QOrganizerEDSEngine::saveCollectionAsyncCommited,
+                                        data);
+    } else {
+        data->finish();
+        delete data;
+    }
+}
+
+void QOrganizerEDSEngine::saveCollectionAsyncCommited(GObject *source_object,
+                                                      GAsyncResult *res,
+                                                      SaveCollectionRequestData *data)
+{
+    qDebug() << Q_FUNC_INFO;
+    GError *gError = 0;
+    e_source_registry_commit_source_finish(E_SOURCE_REGISTRY(source_object), res, &gError);
+    if (gError) {
+        qWarning() << "Fail to commit source:" << gError->message;
+        g_error_free(gError);
+        data->commit(QOrganizerManager::InvalidCollectionError);
+    } else {
+        data->commit();
+    }
+
+    saveCollectionAsyncStart(E_SOURCE_REGISTRY(source_object), data);
 }
 
 bool QOrganizerEDSEngine::removeCollection(const QOrganizerCollectionId& collectionId, QOrganizerManager::Error* error)
 {
     qDebug() << Q_FUNC_INFO;
-    *error = QOrganizerManager::NoError;
-    return true;
+
+    QOrganizerCollectionRemoveRequest *req = new QOrganizerCollectionRemoveRequest(this);
+    req->setCollectionId(collectionId);
+
+    startRequest(req);
+    waitForRequestFinished(req, -1);
+
+    *error = req->error();
+    return(*error == QOrganizerManager::NoError);
+}
+
+void QOrganizerEDSEngine::removeCollectionAsync(QtOrganizer::QOrganizerCollectionRemoveRequest *req)
+{
+    qDebug() << Q_FUNC_INFO;
+
+    if (req->collectionIds().count() == 0) {
+        QOrganizerManagerEngine::updateCollectionRemoveRequest(req,
+                                                             QOrganizerManager::NoError,
+                                                             QMap<int, QOrganizerManager::Error>(),
+                                                             QOrganizerAbstractRequest::FinishedState);
+        return;
+    }
+
+    RemoveCollectionRequestData *requestData = new RemoveCollectionRequestData(this, req);
+    removeCollectionAsyncStart(0, 0, requestData);
+}
+
+void QOrganizerEDSEngine::removeCollectionAsyncStart(GObject *source_object,
+                                                     GAsyncResult *res,
+                                                     RemoveCollectionRequestData *data)
+{
+    if (source_object && res) {
+        GError *gError = 0;
+        e_source_remove_finish(E_SOURCE(source_object), res, &gError);
+        if (gError) {
+            qWarning() << "Fail to remove collection" << gError->message;
+            g_error_free(gError);
+            data->commit(QOrganizerManager::InvalidCollectionError);
+        } else {
+            data->commit();
+        }
+    }
+
+    ESource *source = data->begin();
+    if (source) {
+        if (e_source_get_removable(source)) {
+            e_source_remove(source, data->cancellable(),
+                            (GAsyncReadyCallback) QOrganizerEDSEngine::removeCollectionAsyncStart,
+                            data);
+        } else {
+            qWarning() << "Source not removable";
+            data->commit(QOrganizerManager::InvalidCollectionError);
+        }
+    } else {
+        data->finish();
+        delete data;
+    }
 }
 
 void QOrganizerEDSEngine::requestDestroyed(QOrganizerAbstractRequest* req)
@@ -511,7 +704,7 @@
     if (!req)
         return false;
 
-
+    updateRequestState(req, QOrganizerAbstractRequest::ActiveState);
     switch (req->type())
     {
         case QOrganizerAbstractRequest::ItemFetchRequest:
@@ -529,7 +722,14 @@
         case QOrganizerAbstractRequest::ItemRemoveRequest:
             removeItemsAsync(qobject_cast<QOrganizerItemRemoveRequest*>(req));
             break;
+        case QOrganizerAbstractRequest::CollectionSaveRequest:
+            saveCollectionAsync(qobject_cast<QOrganizerCollectionSaveRequest*>(req));
+            break;
+        case QOrganizerAbstractRequest::CollectionRemoveRequest:
+            removeCollectionAsync(qobject_cast<QOrganizerCollectionRemoveRequest*>(req));
+            break;
         default:
+            updateRequestState(req, QOrganizerAbstractRequest::FinishedState);
             qDebug() << "No implemented request" << req->type();
             break;
     }
@@ -540,16 +740,20 @@
 bool QOrganizerEDSEngine::cancelRequest(QOrganizerAbstractRequest* req)
 {
     qDebug() << Q_FUNC_INFO;
-    Q_UNUSED(req); // we can't cancel since we complete immediately
+    Q_UNUSED(req);
+    //TODO
+    Q_ASSERT(false);
     return false;
 }
 
 bool QOrganizerEDSEngine::waitForRequestFinished(QOrganizerAbstractRequest* req, int msecs)
 {
     qDebug() << Q_FUNC_INFO;
-    // in our implementation, we always complete any operation we start.
     Q_UNUSED(msecs);
-    Q_UNUSED(req);
+
+    while(req->state() == QOrganizerAbstractRequest::ActiveState) {
+        QCoreApplication::processEvents();
+    }
 
     return true;
 }
@@ -641,6 +845,23 @@
                          << QOrganizerItemType::TypeTodoOccurrence;
 }
 
+void QOrganizerEDSEngine::registerCollection(const QOrganizerCollection &collection, QOrganizerEDSCollectionEngineId *edsId)
+{
+    m_collections << collection;
+    m_collectionsMap.insert(collection.id().toString(), edsId);
+}
+
+void QOrganizerEDSEngine::unregisterCollection(const QOrganizerCollectionId &collectionId)
+{
+    Q_FOREACH(QOrganizerCollection col, m_collections) {
+        if (col.id() == collectionId) {
+            m_collections.removeAll(col);
+        }
+    }
+
+    m_collectionsMap.remove(collectionId.toString());
+}
+
 void QOrganizerEDSEngine::loadCollections()
 {
     m_collections.clear();
@@ -655,21 +876,24 @@
     }
 
     ESource *defaultSource = e_source_registry_ref_default_address_book(registry);
-    GList *sources = e_source_registry_list_sources(registry, E_SOURCE_EXTENSION_CALENDAR);
+    GList *sources = e_source_registry_list_sources(registry, 0);
     for(int i=0, iMax=g_list_length(sources); i < iMax; i++) {
         ESource *source = E_SOURCE(g_list_nth_data(sources, i));
-        QOrganizerCollection collection;
-        QOrganizerEDSCollectionEngineId *edsId = new QOrganizerEDSCollectionEngineId(source, managerUri());
-        QOrganizerCollectionId id(edsId);
-        collection.setId(id);
-        collection.setMetaData(QOrganizerCollection::KeyName,
-                               QString::fromUtf8(e_source_get_display_name(source)));
-        //TODO get metadata (color, etc..)
-        m_collections << collection;
-        m_collectionsMap.insert(id.toString(), edsId);
-
-        if (e_source_compare_by_display_name(source, defaultSource) == 0) {
-            m_defaultCollection = collection;
+
+        if (e_source_has_extension(source, E_SOURCE_EXTENSION_CALENDAR) ||
+            e_source_has_extension(source, E_SOURCE_EXTENSION_TASK_LIST) ||
+            e_source_has_extension(source, E_SOURCE_EXTENSION_MEMO_LIST))
+        {
+            //TODO get metadata (color, etc..)
+            QOrganizerEDSCollectionEngineId *edsId = 0;
+            QOrganizerCollection collection = parseSource(source, managerUri(), &edsId);
+
+            registerCollection(collection, edsId);
+
+            if (e_source_compare_by_display_name(source, defaultSource) == 0) {
+                qDebug() << "Default Source" << e_source_get_display_name(source);
+                m_defaultCollection = collection;
+            }
         }
     }
 
@@ -681,35 +905,117 @@
     qDebug() << m_collections.count() << "Collection loaded";
 }
 
+ESource *QOrganizerEDSEngine::findSource(const QtOrganizer::QOrganizerCollectionId &id) const
+{
+    if (!id.isNull() && m_collectionsMap.contains(id.toString())) {
+        QOrganizerEDSCollectionEngineId *edsId = m_collectionsMap[id.toString()];
+        Q_ASSERT(edsId);
+        return edsId->m_esource;
+    } else {
+        return 0;
+    }
+}
+
+QOrganizerCollection QOrganizerEDSEngine::parseSource(ESource *source,
+                                                      const QString &managerUri,
+                                                      QOrganizerEDSCollectionEngineId **edsId)
+{
+    *edsId = new QOrganizerEDSCollectionEngineId(source, managerUri);
+    QOrganizerCollectionId id(*edsId);
+    QOrganizerCollection collection;
+
+    collection.setId(id);
+    collection.setMetaData(QOrganizerCollection::KeyName,
+                           QString::fromUtf8(e_source_get_display_name(source)));
+
+    return collection;
+}
+
+QOrganizerCollection QOrganizerEDSEngine::parseSource(ESource *source, const QString &managerUri)
+{
+    QOrganizerEDSCollectionEngineId *edsId = 0;
+    return parseSource(source, managerUri, &edsId);
+}
+
 QDateTime QOrganizerEDSEngine::fromIcalTime(struct icaltimetype value)
 {
-    struct tm tmTime = icaltimetype_to_tm(&value);
-    g_date_time_new_from_unix_local(mktime(&tmTime));
-    return QDateTime::fromTime_t(mktime(&tmTime));
+    uint tmTime = icaltime_as_timet(value);
+    return QDateTime::fromTime_t(tmTime);
 }
 
 void QOrganizerEDSEngine::parseStartTime(ECalComponent *comp, QOrganizerItem *item)
 {
-    ECalComponentDateTime dt;
-    e_cal_component_get_dtstart(comp, &dt);
-    if (dt.value) {
+    ECalComponentDateTime *dt = g_new0(ECalComponentDateTime, 1);
+    e_cal_component_get_dtstart(comp, dt);
+    if (dt->value) {
         QOrganizerEventTime etr = item->detail(QOrganizerItemDetail::TypeEventTime);
-        etr.setStartDateTime(fromIcalTime(*dt.value));
+        etr.setStartDateTime(fromIcalTime(*dt->value));
         item->saveDetail(&etr);
     }
-    e_cal_component_free_datetime(&dt);
+    e_cal_component_free_datetime(dt);
 }
 
 void QOrganizerEDSEngine::parseEndTime(ECalComponent *comp, QOrganizerItem *item)
 {
-    ECalComponentDateTime dt;
-    e_cal_component_get_dtend(comp, &dt);
-    if (dt.value) {
+    ECalComponentDateTime *dt = g_new0(ECalComponentDateTime, 1);
+    e_cal_component_get_dtend(comp, dt);
+    if (dt->value) {
         QOrganizerEventTime etr = item->detail(QOrganizerItemDetail::TypeEventTime);
-        etr.setEndDateTime(fromIcalTime(*dt.value));
+        etr.setEndDateTime(fromIcalTime(*dt->value));
         item->saveDetail(&etr);
     }
-    e_cal_component_free_datetime(&dt);
+    e_cal_component_free_datetime(dt);
+}
+
+void QOrganizerEDSEngine::parseWeekRecurrence(struct icalrecurrencetype *rule, QtOrganizer::QOrganizerRecurrenceRule *qRule)
+{
+    qRule->setFrequency(QOrganizerRecurrenceRule::Weekly);
+
+    QSet<Qt::DayOfWeek> daysOfWeek;
+    for (int d=0; d < Qt::Sunday; d++) {
+        short day = rule->by_day[d];
+        if (day != ICAL_RECURRENCE_ARRAY_MAX) {
+            daysOfWeek.insert(static_cast<Qt::DayOfWeek>(icalrecurrencetype_day_day_of_week(rule->by_day[d]) - 1));
+        }
+    }
+    qRule->setDaysOfWeek(daysOfWeek);
+}
+
+void QOrganizerEDSEngine::parseMonthRecurrence(struct icalrecurrencetype *rule, QtOrganizer::QOrganizerRecurrenceRule *qRule)
+{
+    qRule->setFrequency(QOrganizerRecurrenceRule::Monthly);
+
+    QSet<int> daysOfMonth;
+    for (int d=0; d < ICAL_BY_MONTHDAY_SIZE; d++) {
+        short day = rule->by_month_day[d];
+        if (day != ICAL_RECURRENCE_ARRAY_MAX) {
+            daysOfMonth.insert(day);
+        }
+    }
+    qRule->setDaysOfMonth(daysOfMonth);
+}
+
+void QOrganizerEDSEngine::parseYearRecurrence(struct icalrecurrencetype *rule, QtOrganizer::QOrganizerRecurrenceRule *qRule)
+{
+    qRule->setFrequency(QOrganizerRecurrenceRule::Yearly);
+
+    QSet<int> daysOfYear;
+    for (int d=0; d < ICAL_BY_YEARDAY_SIZE; d++) {
+        short day = rule->by_year_day[d];
+        if (day != ICAL_RECURRENCE_ARRAY_MAX) {
+            daysOfYear.insert(day);
+        }
+    }
+    qRule->setDaysOfYear(daysOfYear);
+
+    QSet<QOrganizerRecurrenceRule::Month> monthOfYear;
+    for (int d=0; d < ICAL_BY_MONTH_SIZE; d++) {
+        short month = rule->by_month[d];
+        if (month != ICAL_RECURRENCE_ARRAY_MAX) {
+            monthOfYear.insert(static_cast<QOrganizerRecurrenceRule::Month>(month));
+        }
+    }
+    qRule->setMonthsOfYear(monthOfYear);
 }
 
 void QOrganizerEDSEngine::parseRecurrence(ECalComponent *comp, QOrganizerItem *item)
@@ -735,6 +1041,7 @@
     if (e_cal_component_has_exdates(comp)) {
         QSet<QDate> dates;
         GSList *exdateList = 0;
+
         e_cal_component_get_exdate_list(comp, &exdateList);
         for(GSList *i = exdateList; i != 0; i = i->next) {
             ECalComponentDateTime* dateTime = (ECalComponentDateTime*) i->data;
@@ -748,6 +1055,69 @@
         item->saveDetail(&irec);
     }
 
+    // rules
+    GSList *ruleList = 0;
+    e_cal_component_get_rrule_list(comp, &ruleList);
+    if (ruleList) {
+        QSet<QOrganizerRecurrenceRule> qRules;
+
+        for(GSList *i = ruleList; i != 0; i = i->next) {
+            struct icalrecurrencetype *rule = (struct icalrecurrencetype*) i->data;
+            QOrganizerRecurrenceRule qRule;
+            switch (rule->freq) {
+                case ICAL_SECONDLY_RECURRENCE:
+                case ICAL_MINUTELY_RECURRENCE:
+                case ICAL_HOURLY_RECURRENCE:
+                    qWarning() << "Recurrence frequency not supported";
+                    break;
+                case ICAL_DAILY_RECURRENCE:
+                    qRule.setFrequency(QOrganizerRecurrenceRule::Daily);
+                    break;
+                case ICAL_WEEKLY_RECURRENCE:
+                    parseWeekRecurrence(rule, &qRule);
+                    break;
+                case ICAL_MONTHLY_RECURRENCE:
+                    parseMonthRecurrence(rule, &qRule);
+                    break;
+                case ICAL_YEARLY_RECURRENCE:
+                    parseYearRecurrence(rule, &qRule);
+                    break;
+                case ICAL_NO_RECURRENCE:
+                    break;
+            }
+
+
+            if (rule->count > 0) {
+                qRule.setLimit(rule->count);
+            } else {
+                QDateTime dt = fromIcalTime(rule->until);
+                if (dt.isValid()) {
+                    qRule.setLimit(dt.date());
+                } else {
+                    qRule.clearLimit();
+                }
+            }
+            qRule.setInterval(rule->interval);
+
+            QSet<int> positions;
+            for (int d=0; d < ICAL_BY_SETPOS_SIZE; d++) {
+                short day = rule->by_set_pos[d];
+                if (day != ICAL_RECURRENCE_ARRAY_MAX) {
+                    positions.insert(day);
+                }
+            }
+            qRule.setPositions(positions);
+
+            qRules << qRule;
+        }
+
+        if (!qRules.isEmpty()) {
+            QOrganizerItemRecurrence irec = item->detail(QOrganizerItemDetail::TypeRecurrence);
+            irec.setRecurrenceRules(qRules);
+            item->saveDetail(&irec);
+        }
+    }
+    // TODO: free ruleList;
     // TODO: exeptions rules
 }
 
@@ -866,6 +1236,143 @@
     return journal;
 }
 
+void QOrganizerEDSEngine::parseSummary(ECalComponent *comp, QtOrganizer::QOrganizerItem *item)
+{
+    ECalComponentText summary;
+    e_cal_component_get_summary(comp, &summary);
+    if (summary.value) {
+        item->setDisplayLabel(QString::fromUtf8(summary.value));
+    }
+}
+
+void QOrganizerEDSEngine::parseDescription(ECalComponent *comp, QtOrganizer::QOrganizerItem *item)
+{
+
+    GSList *descriptions = 0;
+    e_cal_component_get_description_list(comp, &descriptions);
+
+    QStringList itemDescription;
+
+    for(GSList *descList = descriptions; descList != 0; descList = descList->next) {
+        ECalComponentText *description = static_cast<ECalComponentText*>(descList->data);
+        if (description) {
+            itemDescription.append(QString::fromUtf8(description->value));
+        }
+    }
+
+    item->setDescription(itemDescription.join("\n"));
+}
+
+void QOrganizerEDSEngine::parseComments(ECalComponent *comp, QtOrganizer::QOrganizerItem *item)
+{
+    GSList *comments = 0;
+    e_cal_component_get_comment_list(comp, &comments);
+    for(int ci=0, ciMax=g_slist_length(comments); ci < ciMax; ci++) {
+        ECalComponentText *txt = static_cast<ECalComponentText*>(g_slist_nth_data(comments, ci));
+        item->addComment(QString::fromUtf8(txt->value));
+    }
+    e_cal_component_free_text_list(comments);
+}
+
+void QOrganizerEDSEngine::parseTags(ECalComponent *comp, QtOrganizer::QOrganizerItem *item)
+{
+    GSList *categories = 0;
+    e_cal_component_get_categories_list(comp, &categories);
+    for(GSList *tag=categories; tag != 0; tag = tag->next) {
+        item->addTag(QString::fromUtf8(static_cast<gchar*>(tag->data)));
+    }
+    e_cal_component_free_categories_list(categories);
+}
+
+QByteArray QOrganizerEDSEngine::dencodeAttachment(ECalComponentAlarm *alarm)
+{
+    QByteArray attachment;
+
+    icalattach *attach = 0;
+    e_cal_component_alarm_get_attach(alarm, &attach);
+    if (attach) {
+        attachment = QByteArray::fromBase64(icalattach_get_url(attach));
+        icalattach_unref(attach);
+    }
+
+    return attachment;
+}
+
+
+void QOrganizerEDSEngine::parseVisualReminderAttachment(ECalComponentAlarm *alarm, QOrganizerItemReminder *aDetail)
+{
+    QByteArray attach = dencodeAttachment(alarm);
+    if (!attach.isEmpty()) {
+        QUrl url;
+        QString txt;
+
+        QDataStream attachStream(&attach, QIODevice::ReadOnly);
+
+        attachStream >> url;
+        attachStream >> txt;
+
+        aDetail->setValue(QOrganizerItemVisualReminder::FieldDataUrl, QVariant(url));
+        aDetail->setValue(QOrganizerItemVisualReminder::FieldMessage, QVariant(txt));
+    }
+}
+
+
+void QOrganizerEDSEngine::parseAudibleReminderAttachment(ECalComponentAlarm *alarm, QOrganizerItemReminder *aDetail)
+{
+    QByteArray attach = dencodeAttachment(alarm);
+    if (!attach.isEmpty()) {
+        QUrl url;
+
+        QDataStream attachStream(&attach, QIODevice::ReadOnly);
+
+        attachStream >> url;
+
+        aDetail->setValue(QOrganizerItemAudibleReminder::FieldDataUrl, QVariant(url));
+    }
+}
+
+void QOrganizerEDSEngine::parseReminders(ECalComponent *comp, QtOrganizer::QOrganizerItem *item)
+{
+    GList *alarms = e_cal_component_get_alarm_uids(comp);
+    for(GList *a = alarms; a != 0; a = a->next) {
+        QOrganizerItemReminder *aDetail = 0;
+
+        ECalComponentAlarm *alarm = e_cal_component_get_alarm(comp, static_cast<const gchar*>(a->data));
+        if (!alarm) {
+            continue;
+        }
+        ECalComponentAlarmAction aAction;
+
+        e_cal_component_alarm_get_action(alarm, &aAction);
+        switch(aAction)
+        {
+            case E_CAL_COMPONENT_ALARM_DISPLAY:
+                aDetail = new QOrganizerItemVisualReminder();
+                parseVisualReminderAttachment(alarm, aDetail);
+                break;
+            case E_CAL_COMPONENT_ALARM_AUDIO:
+            // use audio as fallback
+            default:
+                aDetail = new QOrganizerItemAudibleReminder();
+                parseAudibleReminderAttachment(alarm, aDetail);
+                break;
+        }
+
+        ECalComponentAlarmTrigger trigger;
+        e_cal_component_alarm_get_trigger(alarm, &trigger);
+        if (trigger.type == E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_START) {
+            aDetail->setSecondsBeforeStart(icaldurationtype_as_int(trigger.u.rel_duration) * -1);
+        }
+
+        ECalComponentAlarmRepeat aRepeat;
+        e_cal_component_alarm_get_repeat(alarm, &aRepeat);
+        aDetail->setRepetition(aRepeat.repetitions, icaldurationtype_as_int(aRepeat.duration));
+
+        item->saveDetail(aDetail);
+        delete aDetail;
+    }
+}
+
 QList<QOrganizerItem> QOrganizerEDSEngine::parseEvents(QOrganizerEDSCollectionEngineId *collection, GSList *events)
 {
     QList<QOrganizerItem> items;
@@ -905,32 +1412,11 @@
                                                                collection->managerUri());
         item->setId(QOrganizerItemId(eid));
         item->setCollectionId(cId);
-        qDebug() << ">>>>>>>>>>>>>>>>>>Loaded item id: " << item->id().toString();
-
-        //summary
-        ECalComponentText summary;
-        e_cal_component_get_summary(comp, &summary);
-        if (summary.value) {
-            item->setDisplayLabel(QString::fromUtf8(summary.value));
-        }
-
-        //comments
-        GSList *comments = 0;
-        e_cal_component_get_comment_list(comp, &comments);
-        for(int ci=0, ciMax=g_slist_length(comments); ci < ciMax; ci++) {
-            ECalComponentText *txt = static_cast<ECalComponentText*>(g_slist_nth_data(comments, ci));
-            item->addComment(QString::fromUtf8(txt->value));
-        }
-        e_cal_component_free_text_list(comments);
-
-        //tags
-        GSList *categories = 0;
-        e_cal_component_get_categories_list(comp, &categories);
-        for(int ci=0, ciMax=g_slist_length(comments); ci < ciMax; ci++) {
-            item->addTag(QString::fromUtf8(static_cast<gchar*>(g_slist_nth_data(categories, ci))));
-        }
-        e_cal_component_free_categories_list(categories);
-
+        parseDescription(comp, item);
+        parseSummary(comp, item);
+        parseComments(comp, item);
+        parseTags(comp, item);
+        parseReminders(comp, item);
 
 //        //Attendee
 //        GList *attendeeList = 0;
@@ -958,10 +1444,12 @@
 {
     QOrganizerEventTime etr = item.detail(QOrganizerItemDetail::TypeEventTime);
     if (!etr.isEmpty()) {
-        ECalComponentDateTime dt;
-        struct icaltimetype itt = icaltime_from_timet(etr.startDateTime().toTime_t(), FALSE);
-        dt.value = &itt;
-        e_cal_component_set_dtstart(comp, &dt);
+        ECalComponentDateTime *dt = g_new0(ECalComponentDateTime, 1);
+        dt->value = g_new0(struct icaltimetype, 1);
+        *dt->value = icaltime_from_timet(etr.startDateTime().toTime_t(), FALSE);
+
+        e_cal_component_set_dtstart(comp, dt);
+        e_cal_component_free_datetime(dt);
     }
 }
 
@@ -969,12 +1457,98 @@
 {
     QOrganizerEventTime etr = item.detail(QOrganizerItemDetail::TypeEventTime);
     if (!etr.isEmpty()) {
-        ECalComponentDateTime dt;
-        struct icaltimetype itt = icaltime_from_timet(etr.endDateTime().toTime_t(), FALSE);
-        dt.value = &itt;
-        e_cal_component_set_dtend(comp, &dt);;
-    }
-}
+        ECalComponentDateTime *dt = g_new0(ECalComponentDateTime, 1);
+        dt->value = g_new0(struct icaltimetype, 1);
+        *dt->value = icaltime_from_timet(etr.endDateTime().toTime_t(), FALSE);
+        e_cal_component_set_dtend(comp, dt);
+        e_cal_component_free_datetime(dt);
+    }
+}
+
+void QOrganizerEDSEngine::parseTodoStartTime(const QOrganizerItem &item, ECalComponent *comp)
+{
+    QOrganizerTodoTime etr = item.detail(QOrganizerItemDetail::TypeTodoTime);
+    if (!etr.isEmpty()) {
+        ECalComponentDateTime *dt = g_new0(ECalComponentDateTime, 1);
+        dt->value = g_new0(struct icaltimetype, 1);
+        *dt->value = icaltime_from_timet(etr.startDateTime().toTime_t(), FALSE);
+
+        e_cal_component_set_dtstart(comp, dt);
+        e_cal_component_free_datetime(dt);
+    }
+}
+
+void QOrganizerEDSEngine::parseWeekRecurrence(const QOrganizerRecurrenceRule &qRule, struct icalrecurrencetype *rule)
+{
+    static QMap<Qt::DayOfWeek, icalrecurrencetype_weekday>  daysOfWeekMap;
+    if (daysOfWeekMap.isEmpty()) {
+        daysOfWeekMap.insert(Qt::Monday, ICAL_MONDAY_WEEKDAY);
+        daysOfWeekMap.insert(Qt::Thursday, ICAL_THURSDAY_WEEKDAY);
+        daysOfWeekMap.insert(Qt::Wednesday, ICAL_WEDNESDAY_WEEKDAY);
+        daysOfWeekMap.insert(Qt::Tuesday, ICAL_TUESDAY_WEEKDAY);
+        daysOfWeekMap.insert(Qt::Friday, ICAL_FRIDAY_WEEKDAY);
+        daysOfWeekMap.insert(Qt::Saturday, ICAL_SATURDAY_WEEKDAY);
+        daysOfWeekMap.insert(Qt::Sunday, ICAL_SUNDAY_WEEKDAY);
+    }
+
+    QList<Qt::DayOfWeek> daysOfWeek = qRule.daysOfWeek().toList();
+    int c = 0;
+
+    rule->freq = ICAL_WEEKLY_RECURRENCE;
+    for(int d=Qt::Monday; d <= Qt::Sunday; d++) {
+        if (daysOfWeek.contains(static_cast<Qt::DayOfWeek>(d))) {
+            rule->by_day[c++] = daysOfWeekMap[static_cast<Qt::DayOfWeek>(d)];
+        }
+    }
+    for (int d = c; d < ICAL_BY_DAY_SIZE; d++) {
+        rule->by_day[d] = ICAL_RECURRENCE_ARRAY_MAX;
+    }
+}
+
+void QOrganizerEDSEngine::parseMonthRecurrence(const QOrganizerRecurrenceRule &qRule, struct icalrecurrencetype *rule)
+{
+    rule->freq = ICAL_MONTHLY_RECURRENCE;
+
+    QList<int> daysOfMonth = qRule.daysOfMonth().toList();
+    int c = 0;
+    for (int d=1; d < ICAL_BY_MONTHDAY_SIZE; d++) {
+        if (daysOfMonth.contains(d)) {
+            rule->by_month_day[c++] = d;
+        }
+    }
+    for (int d = c; d < ICAL_BY_MONTHDAY_SIZE; d++) {
+        rule->by_month_day[d] = ICAL_RECURRENCE_ARRAY_MAX;
+    }
+}
+
+void QOrganizerEDSEngine::parseYearRecurrence(const QOrganizerRecurrenceRule &qRule, struct icalrecurrencetype *rule)
+{
+    rule->freq = ICAL_YEARLY_RECURRENCE;
+
+    QList<int> daysOfYear = qRule.daysOfYear().toList();
+    int c = 0;
+    for (int d=1; d < ICAL_BY_YEARDAY_SIZE; d++) {
+        if (daysOfYear.contains(d)) {
+            rule->by_year_day[c++] = d;
+        }
+    }
+    for (int d = c; d < ICAL_BY_YEARDAY_SIZE; d++) {
+        rule->by_year_day[d] = ICAL_RECURRENCE_ARRAY_MAX;
+    }
+
+    c = 0;
+    QList<QOrganizerRecurrenceRule::Month> monthOfYear = qRule.monthsOfYear().toList();
+    for (int d=1; d < ICAL_BY_MONTH_SIZE; d++) {
+        if (monthOfYear.contains(static_cast<QOrganizerRecurrenceRule::Month>(d))) {
+            rule->by_month[c++] = d;
+        }
+    }
+    for (int d = c; d < ICAL_BY_YEARDAY_SIZE; d++) {
+        rule->by_month[d] = ICAL_RECURRENCE_ARRAY_MAX;
+    }
+}
+
+
 
 void QOrganizerEDSEngine::parseRecurrence(const QOrganizerItem &item, ECalComponent *comp)
 {
@@ -983,7 +1557,7 @@
         GSList *periodList = 0;
         Q_FOREACH(QDate dt, rec.recurrenceDates()) {
             ECalComponentPeriod *period = g_new0(ECalComponentPeriod, 1);
-            period->start = icaltime_from_timet(QDateTime(dt).toTime_t(), TRUE);
+            period->start = icaltime_from_timet(QDateTime(dt).toTime_t(), FALSE);
             periodList = g_slist_append(periodList, period);
             //TODO: period.end, period.duration
         }
@@ -992,15 +1566,58 @@
 
         GSList *exdateList = 0;
         Q_FOREACH(QDate dt, rec.exceptionDates()) {
-            ECalComponentDateTime dateTime;
-            struct icaltimetype itt = icaltime_from_timet(QDateTime(dt).toTime_t(), TRUE);
-            dateTime.value = &itt;
-            exdateList = g_slist_append(exdateList, &dateTime);
+            ECalComponentDateTime *dateTime = g_new0(ECalComponentDateTime, 1);
+            struct icaltimetype *itt = g_new0(struct icaltimetype, 1);
+            *itt = icaltime_from_timet(QDateTime(dt).toTime_t(), FALSE);
+            dateTime->value = itt;
+            exdateList = g_slist_append(exdateList, dateTime);
         }
         e_cal_component_set_exdate_list(comp, exdateList);
         e_cal_component_free_exdate_list(exdateList);
+
+        GSList *ruleList = 0;
+        Q_FOREACH(QOrganizerRecurrenceRule qRule, rec.recurrenceRules()) {
+            struct icalrecurrencetype *rule = g_new0(struct icalrecurrencetype, 1);
+            switch(qRule.frequency()) {
+                case QOrganizerRecurrenceRule::Daily:
+                    rule->freq = ICAL_DAILY_RECURRENCE;
+                    break;
+                case QOrganizerRecurrenceRule::Weekly:
+                    parseWeekRecurrence(qRule, rule);
+                    break;
+                case QOrganizerRecurrenceRule::Monthly:
+                    parseMonthRecurrence(qRule, rule);
+                    break;
+                case QOrganizerRecurrenceRule::Yearly:
+                    parseYearRecurrence(qRule, rule);
+                    break;
+                case QOrganizerRecurrenceRule::Invalid:
+                    rule->freq = ICAL_NO_RECURRENCE;
+                    break;
+            }
+
+            if (qRule.limitDate().isValid()) {
+                rule->until = icaltime_from_timet(QDateTime(qRule.limitDate()).toTime_t(), TRUE);
+                rule->count = ICAL_RECURRENCE_ARRAY_MAX;
+            } else {
+                rule->count = qRule.limitCount();
+            }
+
+            QSet<int> positions = qRule.positions();
+            for (int d=1; d < ICAL_BY_SETPOS_SIZE; d++) {
+                if (positions.contains(d)) {
+                    rule->by_set_pos[d] = d;
+                } else {
+                    rule->by_set_pos[d] = ICAL_RECURRENCE_ARRAY_MAX;
+                }
+            }
+
+            rule->interval = qRule.interval();
+            ruleList = g_slist_append(ruleList, rule);
+        }
+        e_cal_component_set_rrule_list(comp, ruleList);
+        //TODO: free ruleList
     }
-    // TODO: exeptions rules
 }
 
 void QOrganizerEDSEngine::parsePriority(const QOrganizerItem &item, ECalComponent *comp)
@@ -1008,6 +1625,7 @@
     QOrganizerItemPriority priority = item.detail(QOrganizerItemDetail::TypePriority);
     if (!priority.isEmpty()) {
         gint iPriority = (gint) priority.priority();
+        qDebug() << "Priority" << iPriority;
         e_cal_component_set_priority(comp, &iPriority);
     }
 }
@@ -1024,10 +1642,14 @@
 {
     QOrganizerTodoTime ttr = item.detail(QOrganizerItemDetail::TypeTodoTime);
     if (!ttr.isEmpty()) {
-        ECalComponentDateTime due;
+        qDebug() << "Due date" << ttr.dueDateTime();
+        ECalComponentDateTime *due = g_new0(ECalComponentDateTime, 1);
+        due->value = g_new0(struct icaltimetype, 1);
+
         struct icaltimetype itt = icaltime_from_timet(ttr.dueDateTime().toTime_t(), FALSE);
-        due.value = &itt;
-        e_cal_component_set_due(comp, &due);
+        *due->value = itt;
+        e_cal_component_set_due(comp, due);
+        e_cal_component_free_datetime(due);
     }
 }
 
@@ -1035,6 +1657,7 @@
 {
     QOrganizerTodoProgress tp = item.detail(QOrganizerItemDetail::TypeTodoProgress);
     if (!tp.isEmpty()) {
+        qDebug() << "Progress" << tp.percentageComplete();
         e_cal_component_set_percent_as_int(comp, tp.percentageComplete());
     }
 }
@@ -1048,22 +1671,45 @@
                 e_cal_component_set_status(comp, ICAL_STATUS_NONE);
                 break;
             case QOrganizerTodoProgress::StatusInProgress:
+                qDebug() << "Set status in progress";
                 e_cal_component_set_status(comp, ICAL_STATUS_INPROCESS);
                 break;
             case QOrganizerTodoProgress::StatusComplete:
                 e_cal_component_set_status(comp, ICAL_STATUS_COMPLETED);
                 break;
             default:
+                qDebug() << "Set status cancelled";
                 e_cal_component_set_status(comp, ICAL_STATUS_CANCELLED);
                 break;
         }
     }
 }
 
-ECalComponent *QOrganizerEDSEngine::parseEventItem(const QOrganizerItem &item)
-{
-    ECalComponent *comp = e_cal_component_new();
-    e_cal_component_set_new_vtype(comp, E_CAL_COMPONENT_EVENT);
+ECalComponent *QOrganizerEDSEngine::createDefaultComponent(ECalClient *client,
+                                                           icalcomponent_kind iKind,
+                                                           ECalComponentVType eType)
+{
+    ECalComponent *comp;
+    icalcomponent *icalcomp = 0;
+
+    if (client && !e_cal_client_get_default_object_sync(client, &icalcomp, NULL, NULL)) {
+        icalcomp = icalcomponent_new(iKind);
+    }
+
+    comp = e_cal_component_new();
+    if (icalcomp && !e_cal_component_set_icalcomponent(comp, icalcomp)) {
+        icalcomponent_free(icalcomp);
+    }
+
+    e_cal_component_set_new_vtype(comp, eType);
+
+    return comp;
+}
+
+ECalComponent *QOrganizerEDSEngine::parseEventItem(ECalClient *client, const QOrganizerItem &item)
+{
+    qDebug() << Q_FUNC_INFO;
+    ECalComponent *comp = createDefaultComponent(client, ICAL_VEVENT_COMPONENT, E_CAL_COMPONENT_EVENT);
 
     parseStartTime(item, comp);
     parseEndTime(item, comp);
@@ -1074,12 +1720,12 @@
 
 }
 
-ECalComponent *QOrganizerEDSEngine::parseTodoItem(const QOrganizerItem &item)
+ECalComponent *QOrganizerEDSEngine::parseTodoItem(ECalClient *client, const QOrganizerItem &item)
 {
-    ECalComponent *comp = e_cal_component_new();
-    e_cal_component_set_new_vtype(comp, E_CAL_COMPONENT_TODO);
+    qDebug() << Q_FUNC_INFO;
+    ECalComponent *comp = createDefaultComponent(client, ICAL_VTODO_COMPONENT, E_CAL_COMPONENT_TODO);
 
-    parseStartTime(item, comp);
+    parseTodoStartTime(item, comp);
     parseDueDate(item, comp);
     parseRecurrence(item, comp);
     parsePriority(item, comp);
@@ -1089,10 +1735,10 @@
     return comp;
 }
 
-ECalComponent *QOrganizerEDSEngine::parseJournalItem(const QOrganizerItem &item)
+ECalComponent *QOrganizerEDSEngine::parseJournalItem(ECalClient *client, const QOrganizerItem &item)
 {
-    ECalComponent *comp = e_cal_component_new();
-    e_cal_component_set_new_vtype(comp, E_CAL_COMPONENT_JOURNAL);
+    qDebug() << Q_FUNC_INFO;
+    ECalComponent *comp = createDefaultComponent(client, ICAL_VJOURNAL_COMPONENT, E_CAL_COMPONENT_JOURNAL);
 
     QOrganizerJournalTime jtime = item.detail(QOrganizerItemDetail::TypeJournalTime);
     if (!jtime.isEmpty()) {
@@ -1105,7 +1751,147 @@
     return comp;
 }
 
-GSList *QOrganizerEDSEngine::parseItems(QList<QOrganizerItem> items)
+void QOrganizerEDSEngine::parseSummary(const QOrganizerItem &item, ECalComponent *comp)
+{
+    //summary
+    if (!item.displayLabel().isEmpty()) {
+        ECalComponentText txt;
+        QByteArray str = item.displayLabel().toUtf8();
+        txt.altrep = 0;
+        txt.value = str.constData();
+        e_cal_component_set_summary(comp, &txt);
+    }
+}
+
+void QOrganizerEDSEngine::parseDescription(const QOrganizerItem &item, ECalComponent *comp)
+{
+    //description
+    if (item.description().isEmpty()) {
+        GSList *descriptions = 0;
+        QByteArray str = item.description().toUtf8();
+        ECalComponentText *txt = g_new0(ECalComponentText, 1);
+
+        txt->value = str.constData();
+        descriptions = g_slist_append(descriptions, txt);
+
+        e_cal_component_set_description_list(comp, descriptions);
+        e_cal_component_free_text_list(descriptions);
+    }
+}
+
+void QOrganizerEDSEngine::parseComments(const QOrganizerItem &item, ECalComponent *comp)
+{
+    //comments
+    GSList *comments = 0;
+    Q_FOREACH(QString comment, item.comments()) {
+        QByteArray str = comment.toUtf8();
+        ECalComponentText *txt = g_new0(ECalComponentText, 1);
+        txt->value = str.constData();
+        comments = g_slist_append(comments, txt);
+    }
+
+    if (comments) {
+        e_cal_component_set_comment_list(comp, comments);
+        e_cal_component_free_text_list(comments);
+    }
+}
+
+void QOrganizerEDSEngine::parseTags(const QOrganizerItem &item, ECalComponent *comp)
+{
+    //tags
+    GSList *categories = 0;
+    Q_FOREACH(QString tag, item.tags()) {
+        QByteArray str = tag.toUtf8();
+        ECalComponentText *txt = g_new0(ECalComponentText, 1);
+        txt->value = str.constData();
+        categories = g_slist_append(categories, txt);
+    }
+
+    if (categories) {
+        e_cal_component_set_categories_list(comp, categories);
+        e_cal_component_free_text_list(categories);
+    }
+}
+
+void QOrganizerEDSEngine::encodeAttachment(QByteArray data, ECalComponentAlarm *alarm)
+{
+    gchar *b64Bytes = strdup(data.toBase64());
+    icalattach *attach = icalattach_new_from_url(b64Bytes);
+
+    e_cal_component_alarm_set_attach(alarm, attach);
+
+    icalattach_unref(attach);
+}
+
+void QOrganizerEDSEngine::parseVisualReminderAttachment(const QOrganizerItemDetail &detail, ECalComponentAlarm *alarm)
+{
+    QByteArray attachBytes;
+
+    {
+        QDataStream attachData(&attachBytes, QIODevice::WriteOnly);
+
+        attachData << detail.value(QOrganizerItemVisualReminder::FieldDataUrl).toUrl();
+        attachData << detail.value(QOrganizerItemVisualReminder::FieldMessage).toString();
+    }
+
+    encodeAttachment(attachBytes, alarm);
+}
+
+void QOrganizerEDSEngine::parseAudibleReminderAttachment(const QOrganizerItemDetail &detail, ECalComponentAlarm *alarm)
+{
+    QByteArray attachBytes;
+
+    {
+        QDataStream attachData(&attachBytes, QIODevice::WriteOnly);
+        attachData << detail.value(QOrganizerItemAudibleReminder::FieldDataUrl).toUrl();
+    }
+
+    encodeAttachment(attachBytes, alarm);
+}
+
+void QOrganizerEDSEngine::parseReminders(const QOrganizerItem &item, ECalComponent *comp)
+{
+    //reminders
+    QList<QOrganizerItemDetail> reminders = item.details(QOrganizerItemDetail::TypeAudibleReminder);
+    reminders += item.details(QOrganizerItemDetail::TypeVisualReminder);
+
+    Q_FOREACH(const QOrganizerItemDetail &detail, reminders) {
+        const QOrganizerItemReminder *reminder = static_cast<const QOrganizerItemReminder*>(&detail);
+
+        ECalComponentAlarm *alarm = e_cal_component_alarm_new();
+        switch(reminder->type())
+        {
+            case QOrganizerItemReminder::TypeVisualReminder:
+                e_cal_component_alarm_set_action(alarm, E_CAL_COMPONENT_ALARM_DISPLAY);
+                parseVisualReminderAttachment(detail, alarm);
+                break;
+            case QOrganizerItemReminder::TypeAudibleReminder:
+            default:
+                // use audio as fallback
+                e_cal_component_alarm_set_action(alarm, E_CAL_COMPONENT_ALARM_AUDIO);
+                parseAudibleReminderAttachment(detail, alarm);
+                break;
+        }
+
+        if (reminder->secondsBeforeStart() > 0) {
+            ECalComponentAlarmTrigger trigger;
+            trigger.type = E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_START;
+            trigger.u.rel_duration = icaldurationtype_from_int(- reminder->secondsBeforeStart());
+            e_cal_component_alarm_set_trigger(alarm, trigger);
+        }
+
+        ECalComponentAlarmRepeat aRepeat;
+        // TODO: check if this is really necessary
+        aRepeat.repetitions = reminder->repetitionCount(); //qMax(reminder->repetitionCount(), 1);
+        aRepeat.duration = icaldurationtype_from_int(reminder->repetitionDelay());
+        e_cal_component_alarm_set_repeat(alarm, aRepeat);
+
+        e_cal_component_add_alarm(comp, alarm);
+        e_cal_component_alarm_free(alarm);
+    }
+}
+
+GSList *QOrganizerEDSEngine::parseItems(ECalClient *client, QList<QOrganizerItem> items)
 {
     GSList *comps = 0;
 
@@ -1114,13 +1900,13 @@
 
         switch(item.type()) {
             case QOrganizerItemType::TypeEvent:
-                comp = parseEventItem(item);
+                comp = parseEventItem(client, item);
                 break;
             case QOrganizerItemType::TypeTodo:
-                comp = parseTodoItem(item);
+                comp = parseTodoItem(client, item);
                 break;
             case QOrganizerItemType::TypeJournal:
-                comp = parseJournalItem(item);
+                comp = parseJournalItem(client, item);
                 break;
             case QOrganizerItemType::TypeEventOccurrence:
                 qWarning() << "Component TypeEventOccurrence not supported;";
@@ -1136,41 +1922,26 @@
 
         // id
         if (!item.id().isNull()) {
-           QOrganizerItemId id = item.id();
-           QString cId = QOrganizerEDSEngineId::toComponentId(id);
-           e_cal_component_set_uid(comp, cId.toUtf8().data());
-        }
-
-        //summary
-        if (!item.displayLabel().isEmpty()) {
-            ECalComponentText txt;
-            txt.altrep = "";
-            txt.value = item.displayLabel().toUtf8().data();
-            e_cal_component_set_summary(comp, &txt);
-        }
-
-        //comments
-        GSList *comments = 0;
-        Q_FOREACH(QString comment, item.comments()) {
-            ECalComponentText *txt = g_new0(ECalComponentText, 1);
-            txt->value = comment.toUtf8().data();
-            comments = g_slist_append(comments, txt);
-        }
-        e_cal_component_set_comment_list(comp, comments);
-        e_cal_component_free_text_list(comments);
-
-        //tags
-        GSList *categories = 0;
-        Q_FOREACH(QString tag, item.tags()) {
-            ECalComponentText *txt = g_new0(ECalComponentText, 1);
-            txt->value = tag.toUtf8().data();
-            categories = g_slist_append(categories, txt);
-        }
-        e_cal_component_set_categories_list(comp, categories);
-        e_cal_component_free_text_list(categories);
+            QOrganizerItemId id = item.id();
+            QString cId = QOrganizerEDSEngineId::toComponentId(id);
+            e_cal_component_set_uid(comp, cId.toUtf8().data());
+        }
+
+        parseSummary(item, comp);
+        parseDescription(item, comp);
+        parseComments(item, comp);
+        parseTags(item, comp);
+        parseReminders(item, comp);
+
+        if (!item.id().isNull()) {
+            e_cal_component_commit_sequence(comp);
+        } else {
+            e_cal_component_abort_sequence(comp);
+        }
 
         comps = g_slist_append(comps,
                                icalcomponent_new_clone(e_cal_component_get_icalcomponent(comp)));
+
         g_object_unref(comp);
     }
 
 
=== modified file 'qorganizer/qorganizer-eds-engine.h'
--- qorganizer/qorganizer-eds-engine.h	2013-08-16 02:22:42 +0000
+++ qorganizer/qorganizer-eds-engine.h	2013-09-09 21:01:24 +0000
@@ -29,11 +29,15 @@
 #include <QtOrganizer/QOrganizerItemFilter>
 #include <QtOrganizer/QOrganizerItemChangeSet>
 #include <QtOrganizer/QOrganizerCollectionId>
+#include <QtOrganizer/QOrganizerItemReminder>
 
 #include <libecal/libecal.h>
+
 class FetchRequestData;
 class SaveRequestData;
 class RemoveRequestData;
+class SaveCollectionRequestData;
+class RemoveCollectionRequestData;
 
 class QOrganizerEDSEngine : public QtOrganizer::QOrganizerManagerEngine
 {
@@ -135,36 +139,68 @@
     QList<FetchRequestData*> m_pendingFetchRequest;
 
     void loadCollections();
+    void registerCollection(const QtOrganizer::QOrganizerCollection &collection, QOrganizerEDSCollectionEngineId *edsId);
+    void unregisterCollection(const QtOrganizer::QOrganizerCollectionId &collectionId);
+
+    ESource *findSource(const QtOrganizer::QOrganizerCollectionId &id) const;
+
+    static QtOrganizer::QOrganizerCollection parseSource(ESource *source, const QString &managerUri);
+    static QtOrganizer::QOrganizerCollection parseSource(ESource *source, const QString &managerUri, QOrganizerEDSCollectionEngineId **edsId);
     static QList<QtOrganizer::QOrganizerItem> parseEvents(QOrganizerEDSCollectionEngineId *collection, GSList *events);
-    static GSList *parseItems(QList<QtOrganizer::QOrganizerItem> items);
-
-    static QDateTime fromIcalTime(struct icaltimetype value);
+    static GSList *parseItems(ECalClient *client, QList<QtOrganizer::QOrganizerItem> items);
+
+    // QOrganizerItem -> ECalComponent
+    static void parseSummary(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
+    static void parseDescription(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
+    static void parseComments(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
+    static void parseTags(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
+    static void parseReminders(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
+    static void encodeAttachment(QByteArray data, ECalComponentAlarm *alarm);
+    static void parseVisualReminderAttachment(const QtOrganizer::QOrganizerItemDetail &detail, ECalComponentAlarm *alarm);
+    static void parseAudibleReminderAttachment(const QtOrganizer::QOrganizerItemDetail &detail, ECalComponentAlarm *alarm);
+    static void parseStartTime(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
+    static void parseEndTime(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
+    static void parseTodoStartTime(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
+    static void parseRecurrence(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
+    static void parseWeekRecurrence(const QtOrganizer::QOrganizerRecurrenceRule &qRule, struct icalrecurrencetype *rule);
+    static void parseMonthRecurrence(const QtOrganizer::QOrganizerRecurrenceRule &qRule, struct icalrecurrencetype *rule);
+    static void parseYearRecurrence(const QtOrganizer::QOrganizerRecurrenceRule &qRule, struct icalrecurrencetype *rule);
+    static void parsePriority(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
+    static void parseLocation(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
+    static void parseDueDate(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
+    static void parseProgress(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
+    static void parseStatus(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
+
+    // ECalComponent -> QOrganizerItem
+    static void parseSummary(ECalComponent *comp, QtOrganizer::QOrganizerItem *item);
+    static void parseDescription(ECalComponent *comp, QtOrganizer::QOrganizerItem *item);
+    static void parseComments(ECalComponent *comp, QtOrganizer::QOrganizerItem *item);
+    static void parseTags(ECalComponent *comp, QtOrganizer::QOrganizerItem *item);
+    static void parseReminders(ECalComponent *comp, QtOrganizer::QOrganizerItem *item);
+    static QByteArray dencodeAttachment(ECalComponentAlarm *alarm);
+    static void parseAudibleReminderAttachment(ECalComponentAlarm *alarm, QtOrganizer::QOrganizerItemReminder *aDetail);
+    static void parseVisualReminderAttachment(ECalComponentAlarm *alarm, QtOrganizer::QOrganizerItemReminder *aDetail);
     static void parseStartTime(ECalComponent *comp, QtOrganizer::QOrganizerItem *item);
     static void parseEndTime(ECalComponent *comp, QtOrganizer::QOrganizerItem *item);
     static void parseRecurrence(ECalComponent *comp, QtOrganizer::QOrganizerItem *item);
+    static void parseWeekRecurrence(struct icalrecurrencetype *rule, QtOrganizer::QOrganizerRecurrenceRule *qRule);
+    static void parseMonthRecurrence(struct icalrecurrencetype *rule, QtOrganizer::QOrganizerRecurrenceRule *qRule);
+    static void parseYearRecurrence(struct icalrecurrencetype *rule, QtOrganizer::QOrganizerRecurrenceRule *qRule);
     static void parsePriority(ECalComponent *comp, QtOrganizer::QOrganizerItem *item);
     static void parseLocation(ECalComponent *comp, QtOrganizer::QOrganizerItem *item);
     static void parseDueDate(ECalComponent *comp, QtOrganizer::QOrganizerItem *item);
     static void parseProgress(ECalComponent *comp, QtOrganizer::QOrganizerItem *item);
     static void parseStatus(ECalComponent *comp, QtOrganizer::QOrganizerItem *item);
 
+    static QDateTime fromIcalTime(struct icaltimetype value);
     static QtOrganizer::QOrganizerItem *parseEvent(ECalComponent *comp);
     static QtOrganizer::QOrganizerItem *parseToDo(ECalComponent *comp);
     static QtOrganizer::QOrganizerItem *parseJournal(ECalComponent *comp);
 
-
-    static void parseStartTime(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
-    static void parseEndTime(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
-    static void parseRecurrence(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
-    static void parsePriority(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
-    static void parseLocation(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
-    static void parseDueDate(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
-    static void parseProgress(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
-    static void parseStatus(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp);
-
-    static ECalComponent *parseEventItem(const QtOrganizer::QOrganizerItem &item);
-    static ECalComponent *parseTodoItem(const QtOrganizer::QOrganizerItem &item);
-    static ECalComponent *parseJournalItem(const QtOrganizer::QOrganizerItem &item);
+    static ECalComponent *createDefaultComponent(ECalClient *client, icalcomponent_kind iKind, ECalComponentVType eType);
+    static ECalComponent *parseEventItem(ECalClient *client, const QtOrganizer::QOrganizerItem &item);
+    static ECalComponent *parseTodoItem(ECalClient *client, const QtOrganizer::QOrganizerItem &item);
+    static ECalComponent *parseJournalItem(ECalClient *client, const QtOrganizer::QOrganizerItem &item);
 
     // glib callback
     void itemsAsync(QtOrganizer::QOrganizerItemFetchRequest *req);
@@ -181,6 +217,13 @@
     static void removeItemsAsyncStart(RemoveRequestData *data);
     static void removeItemsAsyncConnected(GObject *source_object, GAsyncResult *res, RemoveRequestData *data);
     static void removeItemsAsyncRemoved(GObject *source_object, GAsyncResult *res, RemoveRequestData *data);
+
+    void saveCollectionAsync(QtOrganizer::QOrganizerCollectionSaveRequest *req);
+    static void saveCollectionAsyncStart(ESourceRegistry *registry, SaveCollectionRequestData *data);
+    static void saveCollectionAsyncCommited(GObject *source_object, GAsyncResult *res, SaveCollectionRequestData *data);
+
+    void removeCollectionAsync(QtOrganizer::QOrganizerCollectionRemoveRequest *req);
+    static void removeCollectionAsyncStart(GObject *source_object, GAsyncResult *res, RemoveCollectionRequestData *data);
 /*
     QList<QtOrganizer::QOrganizerItem> internalItemOccurrences(const QtOrganizer::QOrganizerItem& parentItem,
                                                                const QDateTime& periodStart,
@@ -200,7 +243,9 @@
                                                      bool forExport) const;
     QtOrganizer::QOrganizerItem item(const QtOrganizer::QOrganizerItemId& organizeritemId) const;
     */
-        friend class FetchRequestData;
+    friend class FetchRequestData;
+    friend class SaveCollectionRequestData;
+    friend class RemoveCollectionRequestData;
 };
 
 #endif
 
=== modified file 'qorganizer/qorganizer-eds-fetchrequestdata.cpp'
--- qorganizer/qorganizer-eds-fetchrequestdata.cpp	2013-08-14 21:23:01 +0000
+++ qorganizer/qorganizer-eds-fetchrequestdata.cpp	2013-09-09 21:01:24 +0000
@@ -60,14 +60,30 @@
 
 void FetchRequestData::appendResults(QList<QOrganizerItem> results)
 {
-    m_results += results;
+    QOrganizerItemFetchRequest *req = request<QOrganizerItemFetchRequest>();
+    Q_FOREACH(QOrganizerItem item, results) {
+        if (QOrganizerManagerEngine::testFilter(req->filter(), item)) {
+            m_results << item;
+        }
+    }
 }
 
 QString FetchRequestData::dateFilter()
 {
+    QDateTime startDate = request<QOrganizerItemFetchRequest>()->startDate();
+    QDateTime endDate = request<QOrganizerItemFetchRequest>()->endDate();
+
+    if (!startDate.isValid()) {
+        startDate.setMSecsSinceEpoch(0);
+    }
+
+    if (!endDate.isValid()) {
+        endDate.setMSecsSinceEpoch(std::numeric_limits<qint64>::max());
+    }
+
     QString query = QString("(occur-in-time-range? "
                             "(make-time \"%1\") (make-time \"%2\"))")
-            .arg(isodate_from_time_t(request<QOrganizerItemFetchRequest>()->startDate().toTime_t()))
-            .arg(isodate_from_time_t(request<QOrganizerItemFetchRequest>()->endDate().toTime_t()));
+            .arg(isodate_from_time_t(startDate.toTime_t()))
+            .arg(isodate_from_time_t(endDate.toTime_t()));
     return query;
 }
 
=== added file 'qorganizer/qorganizer-eds-removecollectionrequestdata.cpp'
--- qorganizer/qorganizer-eds-removecollectionrequestdata.cpp	1970-01-01 00:00:00 +0000
+++ qorganizer/qorganizer-eds-removecollectionrequestdata.cpp	2013-09-09 21:01:24 +0000
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of ubuntu-pim-service.
+ *
+ * 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 "qorganizer-eds-removecollectionrequestdata.h"
+#include "qorganizer-eds-engineid.h"
+
+#include <QtOrganizer/QOrganizerManagerEngine>
+#include <QtOrganizer/QOrganizerCollectionRemoveRequest>
+
+using namespace QtOrganizer;
+
+RemoveCollectionRequestData::RemoveCollectionRequestData(QOrganizerEDSEngine *engine, QtOrganizer::QOrganizerAbstractRequest *req)
+    : RequestData(engine, req),
+      m_currentCollection(0)
+{
+    m_pendingCollections = request<QOrganizerCollectionRemoveRequest>()->collectionIds();
+}
+
+RemoveCollectionRequestData::~RemoveCollectionRequestData()
+{
+}
+
+void RemoveCollectionRequestData::finish(QtOrganizer::QOrganizerManager::Error error)
+{
+    QOrganizerManagerEngine::updateCollectionRemoveRequest(request<QOrganizerCollectionRemoveRequest>(),
+                                                           error,
+                                                           m_errorMap,
+                                                           QOrganizerAbstractRequest::FinishedState);
+
+    // emit collection removed signal
+    QList<QOrganizerCollectionId> removedIds = m_pendingCollections;
+    Q_FOREACH(int index, m_errorMap.keys()) {
+        removedIds.removeAt(index);
+    }
+
+    // remove source from engine
+    Q_FOREACH(QOrganizerCollectionId id, removedIds) {
+        parent()->unregisterCollection(id);
+    }
+
+    Q_EMIT parent()->collectionsRemoved(removedIds);
+}
+
+void RemoveCollectionRequestData::commit(QtOrganizer::QOrganizerManager::Error error)
+{
+    if (error != QOrganizerManager::NoError) {
+        m_errorMap.insert(m_currentCollection, error);
+    }
+
+    m_currentCollection++;
+}
+
+ESource *RemoveCollectionRequestData::begin()
+{
+    if (m_pendingCollections.count() > m_currentCollection) {
+        QOrganizerCollectionId cId = m_pendingCollections.at(m_currentCollection);
+        return parent()->findSource(cId);
+    } else {
+        return 0;
+    }
+}
 
=== added file 'qorganizer/qorganizer-eds-removecollectionrequestdata.h'
--- qorganizer/qorganizer-eds-removecollectionrequestdata.h	1970-01-01 00:00:00 +0000
+++ qorganizer/qorganizer-eds-removecollectionrequestdata.h	2013-09-09 21:01:24 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of ubuntu-pim-service.
+ *
+ * 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/>.
+ */
+
+#ifndef __QORGANIZER_EDS_REMOVECOLLECTIONQUESTDATA_H__
+#define __QORGANIZER_EDS_REMOVECOLLECTIONQUESTDATA_H__
+
+#include "qorganizer-eds-requestdata.h"
+
+#include <glib.h>
+
+class RemoveCollectionRequestData : public RequestData
+{
+public:
+    RemoveCollectionRequestData(QOrganizerEDSEngine *engine, QtOrganizer::QOrganizerAbstractRequest *req);
+    ~RemoveCollectionRequestData();
+
+    void finish(QtOrganizer::QOrganizerManager::Error error = QtOrganizer::QOrganizerManager::NoError);
+
+    ESource* begin();
+    void commit(QtOrganizer::QOrganizerManager::Error error = QtOrganizer::QOrganizerManager::NoError);
+
+private:
+    QList<QtOrganizer::QOrganizerCollectionId> m_pendingCollections;
+    QMap<int, QtOrganizer::QOrganizerManager::Error> m_errorMap;
+    int m_currentCollection;
+
+};
+
+#endif
 
=== modified file 'qorganizer/qorganizer-eds-removerequestdata.cpp'
--- qorganizer/qorganizer-eds-removerequestdata.cpp	2013-08-14 21:23:01 +0000
+++ qorganizer/qorganizer-eds-removerequestdata.cpp	2013-09-09 21:01:24 +0000
@@ -56,7 +56,6 @@
             ECalComponentId *id = g_new0(ECalComponentId, 1);
 
             id->uid = g_strdup(QOrganizerEDSEngineId::toComponentId(item.id()).toUtf8().data());
-            qDebug() << "Remove item:" << id->uid;
             ids = g_slist_append(ids, id);
 
             m_pendingItems.removeAll(item);
@@ -102,9 +101,7 @@
         QSet<QtOrganizer::QOrganizerCollectionId>::const_iterator i = m_pendingCollections.constBegin();
         m_pendingCollections.remove(*i);
         m_currentCollectionId = *i;
-        qDebug() << "Will get item for sourcE:" << m_currentCollectionId.isNull() << m_currentCollectionId;
         m_currentCompIds = takeItemsIds(m_currentCollectionId);
-        qDebug() << "DONE Will get item for sourcE:" << m_currentCollectionId.isNull() << m_currentCollectionId;
         return m_currentCollectionId;
     }
     return QOrganizerCollectionId();
 
=== modified file 'qorganizer/qorganizer-eds-requestdata.cpp'
--- qorganizer/qorganizer-eds-requestdata.cpp	2013-08-14 21:23:01 +0000
+++ qorganizer/qorganizer-eds-requestdata.cpp	2013-09-09 21:01:24 +0000
@@ -51,9 +51,9 @@
     return !m_req.isNull();
 }
 
-EClient *RequestData::client() const
+ECalClient *RequestData::client() const
 {
-    return m_client;
+    return E_CAL_CLIENT(m_client);
 }
 
 QOrganizerEDSEngine *RequestData::parent() const
 
=== modified file 'qorganizer/qorganizer-eds-requestdata.h'
--- qorganizer/qorganizer-eds-requestdata.h	2013-08-14 21:23:01 +0000
+++ qorganizer/qorganizer-eds-requestdata.h	2013-09-09 21:01:24 +0000
@@ -35,7 +35,7 @@
     GCancellable* cancellable() const;
     bool isLive() const;
     void setClient(EClient *client);
-    EClient *client() const;
+    ECalClient *client() const;
     virtual void finish(QtOrganizer::QOrganizerManager::Error error = QtOrganizer::QOrganizerManager::NoError) = 0;
     QOrganizerEDSEngine *parent() const;
     virtual void cancel();
 
=== added file 'qorganizer/qorganizer-eds-savecollectionrequestdata.cpp'
--- qorganizer/qorganizer-eds-savecollectionrequestdata.cpp	1970-01-01 00:00:00 +0000
+++ qorganizer/qorganizer-eds-savecollectionrequestdata.cpp	2013-09-09 21:01:24 +0000
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of ubuntu-pim-service.
+ *
+ * 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 "qorganizer-eds-savecollectionrequestdata.h"
+
+#include <QtOrganizer/QOrganizerManagerEngine>
+#include <QtOrganizer/QOrganizerCollectionSaveRequest>
+
+using namespace QtOrganizer;
+
+#define COLLECTION_CALLENDAR_TYPE_METADATA "collection-type"
+
+SaveCollectionRequestData::SaveCollectionRequestData(QOrganizerEDSEngine *engine,
+                                                     QtOrganizer::QOrganizerAbstractRequest *req)
+    : RequestData(engine, req),
+      m_sources(0),
+      m_currentSource(0)
+{
+    parseCollections();
+}
+
+SaveCollectionRequestData::~SaveCollectionRequestData()
+{
+}
+
+
+void SaveCollectionRequestData::finish(QtOrganizer::QOrganizerManager::Error error)
+{
+    qDebug() << "update request collections" << m_results;
+
+    QOrganizerManagerEngine::updateCollectionSaveRequest(request<QOrganizerCollectionSaveRequest>(),
+                                                         m_results,
+                                                         error,
+                                                         m_errorMap,
+                                                         QOrganizerAbstractRequest::FinishedState);
+
+    QList<QOrganizerCollectionId> added;
+    Q_FOREACH(QOrganizerCollection col, m_results) {
+        added.append(col.id());
+    }
+    Q_EMIT parent()->collectionsAdded(added);
+}
+
+void SaveCollectionRequestData::commit(QtOrganizer::QOrganizerManager::Error error)
+{
+    if (error != QOrganizerManager::NoError) {
+        m_errorMap.insert(m_currentSource, error);
+    } else {
+        ESource *source = E_SOURCE(g_list_nth_data(m_sources, m_currentSource));
+        QOrganizerEDSCollectionEngineId *edsId = 0;
+
+        QOrganizerCollection collection = QOrganizerEDSEngine::parseSource(source, parent()->managerUri(), &edsId);
+        parent()->registerCollection(collection, edsId);
+
+        m_results.append(collection);
+    }
+    m_currentSource++;
+}
+
+GList *SaveCollectionRequestData::sources() const
+{
+    return m_sources;
+}
+
+QList<QOrganizerCollection> SaveCollectionRequestData::results() const
+{
+    return m_results;
+}
+
+void SaveCollectionRequestData::parseCollections()
+{
+    if (m_sources) {
+        g_list_free_full(m_sources, g_object_unref);
+        m_sources = 0;
+    }
+
+    m_errorMap.clear();
+    int index = 0;
+    Q_FOREACH(QOrganizerCollection collection, request<QOrganizerCollectionSaveRequest>()->collections()) {
+        ESource *source = 0;
+        if (collection.id().isNull()) {
+            GError *gError = 0;
+            source = e_source_new(0, 0, &gError);
+            if (gError) {
+                m_errorMap.insert(index, QOrganizerManager::UnspecifiedError);
+                qWarning() << "Fail to create source:" << gError->message;
+                g_error_free(gError);
+            }
+        } else {
+            qDebug() << "Collection update not implemented";
+            Q_ASSERT(FALSE);
+        }
+
+        QString name = collection.metaData(QOrganizerCollection::KeyName).toString();
+        e_source_set_display_name(source, name.toUtf8().data());
+        e_source_set_parent(source,  "local-stub");
+
+        QVariant callendarType = collection.extendedMetaData(COLLECTION_CALLENDAR_TYPE_METADATA);
+        ESourceBackend *extCalendar = 0;
+
+        if (callendarType.toString() == E_SOURCE_EXTENSION_TASK_LIST) {
+            extCalendar = E_SOURCE_BACKEND(e_source_get_extension(source, E_SOURCE_EXTENSION_TASK_LIST));
+        } else if (callendarType.toString() == E_SOURCE_EXTENSION_MEMO_LIST) {
+            extCalendar = E_SOURCE_BACKEND(e_source_get_extension(source, E_SOURCE_EXTENSION_MEMO_LIST));
+        } else {
+            extCalendar = E_SOURCE_BACKEND(e_source_get_extension(source, E_SOURCE_EXTENSION_CALENDAR));
+        }
+
+        if (extCalendar) {
+            e_source_backend_set_backend_name(extCalendar, "local");
+        } else {
+            qWarning() << "Fail to get source callendar";
+        }
+        m_sources = g_list_append(m_sources, source);
+        index++;
+    }
+
+    qDebug() << "Request with" << g_list_length(m_sources) << "sources";
+}
+
+ESource *SaveCollectionRequestData::begin() const
+{
+    return E_SOURCE(g_list_nth_data(m_sources, m_currentSource));
+}
 
=== added file 'qorganizer/qorganizer-eds-savecollectionrequestdata.h'
--- qorganizer/qorganizer-eds-savecollectionrequestdata.h	1970-01-01 00:00:00 +0000
+++ qorganizer/qorganizer-eds-savecollectionrequestdata.h	2013-09-09 21:01:24 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of ubuntu-pim-service.
+ *
+ * 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/>.
+ */
+
+#ifndef __QORGANIZER_EDS_SAVECOLLECTIONREQUESTDATA_H__
+#define __QORGANIZER_EDS_SAVECOLLECTIONREQUESTDATA_H__
+
+#include "qorganizer-eds-requestdata.h"
+
+class SaveCollectionRequestData : public RequestData
+{
+public:
+    SaveCollectionRequestData(QOrganizerEDSEngine *engine,
+                              QtOrganizer::QOrganizerAbstractRequest *req);
+    ~SaveCollectionRequestData();
+
+    void finish(QtOrganizer::QOrganizerManager::Error error = QtOrganizer::QOrganizerManager::NoError);
+    bool isNew(int index) const;
+
+    GList *sources() const;
+    QList<QtOrganizer::QOrganizerCollection> results() const;
+    ESource *begin() const;
+    void commit(QtOrganizer::QOrganizerManager::Error error = QtOrganizer::QOrganizerManager::NoError);
+
+private:
+    QMap<int, QtOrganizer::QOrganizerManager::Error> m_errorMap;
+    QList<QtOrganizer::QOrganizerCollection> m_results;
+    GList *m_sources;
+    int m_currentSource;
+
+    void parseCollections();
+
+};
+
+#endif
 
=== modified file 'tests/unittest/CMakeLists.txt'
--- tests/unittest/CMakeLists.txt	2013-08-14 21:23:01 +0000
+++ tests/unittest/CMakeLists.txt	2013-09-09 21:01:24 +0000
@@ -39,3 +39,8 @@
 endif()
 
 declare_test(itemid-test)
+declare_test(parseecal-test)
+# Jenkins will not be able to run these tests because they need EDS running
+# FIXME: Mock EDS to run the tests bellow
+#declare_test(collections-test)
+#declare_test(event-test)
 
=== added file 'tests/unittest/collections-test.cpp'
--- tests/unittest/collections-test.cpp	1970-01-01 00:00:00 +0000
+++ tests/unittest/collections-test.cpp	2013-09-09 21:01:24 +0000
@@ -0,0 +1,191 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of qtorganizer5-eds.
+ *
+ * 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 <QObject>
+#include <QtTest>
+#include <QDebug>
+
+#include <QtOrganizer>
+
+#include "qorganizer-eds-engine.h"
+
+
+using namespace QtOrganizer;
+
+class CollectionTest : public QObject
+{
+    Q_OBJECT
+private:
+    static const QString defaultCollectionName;
+    static const QString defaultTaskCollectionName;
+    static const QString collectionTypePropertyName;
+    static const QString taskListTypeName;
+private Q_SLOTS:
+    void testCreateCollection()
+    {
+        QOrganizerEDSEngine *engine = QOrganizerEDSEngine::createEDSEngine(QMap<QString, QString>());
+
+        QOrganizerCollection collection;
+        QtOrganizer::QOrganizerManager::Error error;
+        collection.setMetaData(QOrganizerCollection::KeyName, defaultCollectionName);
+
+        QVERIFY(engine->saveCollection(&collection, &error));
+        QCOMPARE(error, QOrganizerManager::NoError);
+        QVERIFY(!collection.id().isNull());
+    }
+
+    void testCreateTaskList()
+    {
+        QOrganizerEDSEngine *engine = QOrganizerEDSEngine::createEDSEngine(QMap<QString, QString>());
+
+        QOrganizerCollection collection;
+        QtOrganizer::QOrganizerManager::Error error;
+        collection.setMetaData(QOrganizerCollection::KeyName, defaultTaskCollectionName);
+        collection.setExtendedMetaData(collectionTypePropertyName, taskListTypeName);
+
+        QSignalSpy createdCollection(engine, SIGNAL(collectionsAdded(QList<QOrganizerCollectionId>)));
+        QVERIFY(engine->saveCollection(&collection, &error));
+        QCOMPARE(error, QOrganizerManager::NoError);
+        QVERIFY(!collection.id().isNull());
+
+        //verify signal
+        QCOMPARE(createdCollection.count(), 1);
+        QList<QVariant> args = createdCollection.takeFirst();
+        QCOMPARE(args.count(), 1);
+
+        QVERIFY(engine->collections(&error).contains(collection));
+        delete engine;
+
+        // recreate and check if the new collection is listed
+        engine = QOrganizerEDSEngine::createEDSEngine(QMap<QString, QString>());
+        QVERIFY(engine->collections(&error).contains(collection));
+    }
+
+    void testCreateTask()
+    {
+        static QString displayLabelValue = QStringLiteral("Todo test");
+        static QString descriptionValue = QStringLiteral("Todo description");
+
+        QOrganizerEDSEngine *engine = QOrganizerEDSEngine::createEDSEngine(QMap<QString, QString>());
+
+        QOrganizerCollection collection;
+        QtOrganizer::QOrganizerManager::Error error;
+        collection.setMetaData(QOrganizerCollection::KeyName, defaultTaskCollectionName + "2");
+        collection.setExtendedMetaData(collectionTypePropertyName, taskListTypeName);
+        QVERIFY(engine->saveCollection(&collection, &error));
+
+        QOrganizerTodo todo;
+        todo.setCollectionId(collection.id());
+        todo.setStartDateTime(QDateTime(QDate(2013, 9, 3), QTime(0,30,0)));
+        todo.setDisplayLabel(displayLabelValue);
+        todo.setDescription(descriptionValue);
+
+        QMap<int, QtOrganizer::QOrganizerManager::Error> errorMap;
+        QList<QOrganizerItem> items;
+        QSignalSpy createdItem(engine, SIGNAL(itemsAdded(QList<QOrganizerItemId>)));
+        items << todo;
+        bool saveResult = engine->saveItems(&items,
+                                            QList<QtOrganizer::QOrganizerItemDetail::DetailType>(),
+                                            &errorMap,
+                                            &error);
+        QVERIFY(saveResult);
+        QCOMPARE(error, QOrganizerManager::NoError);
+        QVERIFY(errorMap.isEmpty());
+        QVERIFY(!items[0].id().isNull());
+
+        //verify signal
+        QCOMPARE(createdItem.count(), 1);
+        QList<QVariant> args = createdItem.takeFirst();
+        QCOMPARE(args.count(), 1);
+
+        // check if the item is listead inside the correct collection
+        QOrganizerItemSortOrder sort;
+        QOrganizerItemFetchHint hint;
+        QOrganizerItemCollectionFilter filter;
+
+        filter.setCollectionId(collection.id());
+
+        items = engine->items(filter,
+                      QDateTime(),
+                      QDateTime(),
+                      10,
+                      sort,
+                      hint,
+                      &error);
+
+        QCOMPARE(items.count(), 1);
+        QOrganizerTodo result = static_cast<QOrganizerTodo>(items[0]);
+        todo = items[0];
+        QCOMPARE(result.id(), todo.id());
+        QCOMPARE(result.startDateTime(), todo.startDateTime());
+        QCOMPARE(result.displayLabel(), todo.displayLabel());
+        QCOMPARE(result.description(), todo.description());
+
+
+        // check if the item is listead by id
+        QList<QOrganizerItemId> ids;
+        ids << todo.id();
+
+        items = engine->items(ids, hint, &errorMap, &error);
+        QCOMPARE(items.count(), 1);
+        result = static_cast<QOrganizerTodo>(items[0]);
+        todo = items[0];
+        QCOMPARE(result.id(), todo.id());
+        QCOMPARE(result.startDateTime(), todo.startDateTime());
+        QCOMPARE(result.displayLabel(), todo.displayLabel());
+        QCOMPARE(result.description(), todo.description());
+
+        delete engine;
+    }
+
+    void testRemoveCollection()
+    {
+        static QString removableCollectionName = defaultTaskCollectionName + QStringLiteral("_REMOVABLE");
+
+        QOrganizerEDSEngine *engine = QOrganizerEDSEngine::createEDSEngine(QMap<QString, QString>());
+
+        // Create a collection
+        QOrganizerCollection collection;
+        QtOrganizer::QOrganizerManager::Error error;
+        collection.setMetaData(QOrganizerCollection::KeyName, removableCollectionName);
+        QVERIFY(engine->saveCollection(&collection, &error));
+        delete engine;
+
+        QTest::qSleep(1000);
+
+        engine = QOrganizerEDSEngine::createEDSEngine(QMap<QString, QString>());
+        // remove recent created collection
+        QVERIFY(engine->removeCollection(collection.id(), &error));
+
+        // Check if collection is not listed anymore
+        QTest::qSleep(1000);
+        QList<QOrganizerCollection> collections = engine->collections(&error);
+        QVERIFY(!collections.contains(collection));
+    }
+};
+
+const QString CollectionTest::defaultCollectionName = QStringLiteral("TEST COLLECTION");
+const QString CollectionTest::defaultTaskCollectionName = QStringLiteral("TEST COLLECTION TASK LIST");
+const QString CollectionTest::collectionTypePropertyName = QStringLiteral("collection-type");
+const QString CollectionTest::taskListTypeName = QStringLiteral("Task List");
+
+
+QTEST_MAIN(CollectionTest)
+
+#include "collections-test.moc"
 
=== added file 'tests/unittest/event-test.cpp'
--- tests/unittest/event-test.cpp	1970-01-01 00:00:00 +0000
+++ tests/unittest/event-test.cpp	2013-09-09 21:01:24 +0000
@@ -0,0 +1,138 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of qtorganizer5-eds.
+ *
+ * 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 <QObject>
+#include <QtTest>
+#include <QDebug>
+
+#include <QtOrganizer>
+
+#include "qorganizer-eds-engine.h"
+
+
+using namespace QtOrganizer;
+
+class EventTest : public QObject
+{
+    Q_OBJECT
+private:
+    static const QString defaultCollectionName;
+    static const QString defaultTaskCollectionName;
+    static const QString collectionTypePropertyName;
+    static const QString taskListTypeName;
+
+private Q_SLOTS:
+    void testCreateEventWithReminder()
+    {
+        static QString displayLabelValue = QStringLiteral("Todo test");
+        static QString descriptionValue = QStringLiteral("Todo description");
+
+        QOrganizerEDSEngine *engine = QOrganizerEDSEngine::createEDSEngine(QMap<QString, QString>());
+
+        QOrganizerCollection collection;
+        QtOrganizer::QOrganizerManager::Error error;
+        collection.setMetaData(QOrganizerCollection::KeyName, defaultCollectionName);
+        collection.setExtendedMetaData(collectionTypePropertyName, taskListTypeName);
+
+        engine->saveCollection(&collection, &error);
+
+        QOrganizerTodo todo;
+        todo.setCollectionId(collection.id());
+        todo.setStartDateTime(QDateTime(QDate(2013, 9, 3), QTime(0,30,0)));
+        todo.setDisplayLabel(displayLabelValue);
+        todo.setDescription(descriptionValue);
+
+        QOrganizerItemVisualReminder vReminder;
+        vReminder.setDataUrl(QUrl("http://www.alarms.com"));
+        vReminder.setMessage("Test visual reminder");
+
+        QOrganizerItemAudibleReminder aReminder;
+        aReminder.setSecondsBeforeStart(10);
+        aReminder.setRepetition(10, 20);
+        aReminder.setDataUrl(QUrl("file://home/user/My Musics/play as alarm.wav"));
+
+
+        todo.saveDetail(&aReminder);
+        todo.saveDetail(&vReminder);
+
+        QMap<int, QtOrganizer::QOrganizerManager::Error> errorMap;
+        QList<QOrganizerItem> items;
+        items << todo;
+        bool saveResult = engine->saveItems(&items,
+                                            QList<QtOrganizer::QOrganizerItemDetail::DetailType>(),
+                                            &errorMap,
+                                            &error);
+        QVERIFY(saveResult);
+
+        // delete engine to make sure the new engine will be loaded from scratch
+        delete engine;
+
+        engine = QOrganizerEDSEngine::createEDSEngine(QMap<QString, QString>());
+
+        QOrganizerItemSortOrder sort;
+        QOrganizerItemFetchHint hint;
+        QOrganizerItemIdFilter filter;
+
+        QList<QOrganizerItemId> ids;
+        ids << items[0].id();
+        filter.setIds(ids);
+
+        items = engine->items(filter,
+                      QDateTime(),
+                      QDateTime(),
+                      10,
+                      sort,
+                      hint,
+                      &error);
+        QCOMPARE(items.count(), 1);
+
+        // audible
+        QList<QOrganizerItemDetail> reminders = items[0].details(QOrganizerItemDetail::TypeAudibleReminder);
+        QCOMPARE(reminders.size(), 1);
+
+        QOrganizerItemAudibleReminder aReminder2 = reminders[0];
+        QCOMPARE(aReminder2.secondsBeforeStart(), aReminder.secondsBeforeStart());
+        QCOMPARE(aReminder2.repetitionCount(), aReminder.repetitionCount());
+        QCOMPARE(aReminder2.repetitionDelay(), aReminder.repetitionDelay());
+        QCOMPARE(aReminder2.dataUrl(), aReminder.dataUrl());
+        //QCOMPARE(aReminder2, aReminder);
+
+        // visual
+        reminders = items[0].details(QOrganizerItemDetail::TypeVisualReminder);
+        QCOMPARE(reminders.size(), 1);
+
+        QOrganizerItemVisualReminder vReminder2 = reminders[0];
+        //vReminder.setRepetition(1, 0);
+        QCOMPARE(vReminder2.secondsBeforeStart(), vReminder.secondsBeforeStart());
+        QCOMPARE(vReminder2.repetitionCount(), vReminder.repetitionCount());
+        QCOMPARE(vReminder2.repetitionDelay(), vReminder.repetitionDelay());
+        QCOMPARE(vReminder2.dataUrl(), vReminder.dataUrl());
+        QCOMPARE(vReminder2.message(), vReminder.message());
+    }
+};
+
+const QString EventTest::defaultCollectionName = QStringLiteral("TEST_EVENT_COLLECTION");
+const QString EventTest::defaultTaskCollectionName = QStringLiteral("TEST_EVENT_COLLECTION TASK LIST");
+const QString EventTest::collectionTypePropertyName = QStringLiteral("collection-type");
+const QString EventTest::taskListTypeName = QStringLiteral("Task List");
+
+
+QTEST_MAIN(EventTest)
+
+#include "event-test.moc"
 
=== added file 'tests/unittest/parseecal-test.cpp'
--- tests/unittest/parseecal-test.cpp	1970-01-01 00:00:00 +0000
+++ tests/unittest/parseecal-test.cpp	2013-09-09 21:01:24 +0000
@@ -0,0 +1,366 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of qtorganizer5-eds.
+ *
+ * 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/>.
+ */
+
+//ugly hack but this allow us to test the engine without mock EDS
+#define private public
+#include "qorganizer-eds-engine.h"
+#undef private
+
+#include <QObject>
+#include <QtTest>
+#include <QDebug>
+
+#include <QtOrganizer>
+
+#include <libecal/libecal.h>
+
+using namespace QtOrganizer;
+
+class ParseEcalTest : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void testParseStartTime()
+    {
+        QDateTime startTime = QDateTime::currentDateTime();
+        QDateTime endTime(startTime);
+        endTime = endTime.addDays(2);
+
+        ECalComponent *comp = e_cal_component_new();
+        e_cal_component_set_new_vtype(comp, E_CAL_COMPONENT_EVENT);
+
+        ECalComponentDateTime dt;
+
+        struct icaltimetype itt = icaltime_from_timet(startTime.toTime_t(), FALSE);
+        dt.value = &itt;
+        dt.tzid = "";
+        e_cal_component_set_dtstart(comp, &dt);
+
+        QOrganizerEvent item;
+        QOrganizerEDSEngine::parseStartTime(comp, &item);
+        QCOMPARE(item.startDateTime().toTime_t(), startTime.toTime_t());
+
+        itt = icaltime_from_timet(endTime.toTime_t(), FALSE);
+        dt.value = &itt;
+        e_cal_component_set_dtend(comp, &dt);
+
+        QOrganizerEDSEngine::parseEndTime(comp, &item);
+        QCOMPARE(item.endDateTime().toTime_t(), endTime.toTime_t());
+    }
+
+    void testParseRemindersQOrganizerEvent2ECalComponent()
+    {
+        QOrganizerEvent event;
+        QOrganizerItemAudibleReminder aReminder;
+
+        // Check audible reminder
+        aReminder.setRepetition(10, 30);
+        aReminder.setSecondsBeforeStart(10);
+        QCOMPARE(aReminder.secondsBeforeStart(), 10);
+        event.saveDetail(&aReminder);
+
+        ECalComponent *comp = e_cal_component_new();
+        e_cal_component_set_new_vtype(comp, E_CAL_COMPONENT_EVENT);
+
+        QOrganizerEDSEngine::parseReminders(event, comp);
+
+        GList *aIds = e_cal_component_get_alarm_uids(comp);
+        QCOMPARE(g_list_length(aIds), (guint) 1);
+
+        ECalComponentAlarm *alarm = e_cal_component_get_alarm(comp, (const gchar*)aIds->data);
+        QVERIFY(alarm);
+
+        ECalComponentAlarmAction aAction;
+        e_cal_component_alarm_get_action(alarm, &aAction);
+        QCOMPARE(aAction, E_CAL_COMPONENT_ALARM_AUDIO);
+
+        ECalComponentAlarmTrigger trigger;
+        e_cal_component_alarm_get_trigger(alarm, &trigger);
+        QCOMPARE(trigger.type, E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_START);
+        QCOMPARE(icaldurationtype_as_int(trigger.u.rel_duration) * -1, aReminder.secondsBeforeStart());
+
+        ECalComponentAlarmRepeat aRepeat;
+        e_cal_component_alarm_get_repeat(alarm, &aRepeat);
+        QCOMPARE(aRepeat.repetitions, aReminder.repetitionCount());
+        QCOMPARE(icaldurationtype_as_int(aRepeat.duration), aReminder.repetitionDelay());
+
+        g_object_unref(comp);
+    }
+
+    void testParseRemindersECalComponent2QOrganizerEvent()
+    {
+        ECalComponent *comp = e_cal_component_new();
+        e_cal_component_set_new_vtype(comp, E_CAL_COMPONENT_EVENT);
+
+        ECalComponentAlarm *alarm = e_cal_component_alarm_new();
+        e_cal_component_alarm_set_action(alarm, E_CAL_COMPONENT_ALARM_DISPLAY);
+
+        ECalComponentAlarmTrigger trigger;
+        trigger.type = E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_START;
+        trigger.u.rel_duration = icaldurationtype_from_int(-10);
+        e_cal_component_alarm_set_trigger(alarm, trigger);
+
+        ECalComponentAlarmRepeat aRepeat;
+        aRepeat.repetitions = 5;
+        aRepeat.duration = icaldurationtype_from_int(100);
+        e_cal_component_alarm_set_repeat(alarm, aRepeat);
+
+        e_cal_component_add_alarm(comp, alarm);
+        e_cal_component_alarm_free(alarm);
+
+        QOrganizerItem alarmItem;
+        QOrganizerEDSEngine::parseReminders(comp, &alarmItem);
+
+        QOrganizerItemVisualReminder vReminder = alarmItem.detail(QOrganizerItemDetail::TypeVisualReminder);
+        QCOMPARE(vReminder.repetitionCount(), 5);
+        QCOMPARE(vReminder.repetitionDelay(), 100);
+        QCOMPARE(vReminder.secondsBeforeStart(), 10);
+
+        g_object_unref(comp);
+    }
+
+    void testParseRecurenceQOrganizerEvent2ECalComponent()
+    {
+        // by date
+        QOrganizerEvent event;
+        QOrganizerItemRecurrence rec;
+
+        QList<QDate> rDates;
+        rDates << QDate(2010, 1, 20)
+               << QDate(2011, 2, 21)
+               << QDate(2012, 3, 22);
+
+        rec.setRecurrenceDates(rDates.toSet());
+
+        QList<QDate> rExeptDates;
+        rExeptDates << QDate(2013, 4, 23)
+                    << QDate(2014, 5, 24)
+                    << QDate(2015, 6, 25);
+        rec.setExceptionDates(rExeptDates.toSet());
+
+        QOrganizerRecurrenceRule dailyRule;
+        QList<QOrganizerRecurrenceRule> rrules;
+
+        dailyRule.setFrequency(QOrganizerRecurrenceRule::Daily);
+        dailyRule.setLimit(1000);
+        rrules << dailyRule;
+
+        QOrganizerRecurrenceRule weeklyRule;
+        weeklyRule.setFrequency(QOrganizerRecurrenceRule::Weekly);
+        weeklyRule.setLimit(1001);
+        QList<Qt::DayOfWeek> daysOfWeek;
+        daysOfWeek << Qt::Monday
+                   << Qt::Tuesday
+                   << Qt::Wednesday
+                   << Qt::Thursday
+                   << Qt::Friday;
+        weeklyRule.setDaysOfWeek(daysOfWeek.toSet());
+        weeklyRule.setFirstDayOfWeek(Qt::Sunday);
+        rrules << weeklyRule;
+
+        QOrganizerRecurrenceRule monthlyRule;
+        monthlyRule.setFrequency(QOrganizerRecurrenceRule::Monthly);
+        monthlyRule.setLimit(1002);
+
+        QList<int> daysOfMonth;
+        daysOfMonth << 1
+                    << 15
+                    << 30;
+        monthlyRule.setDaysOfMonth(daysOfMonth.toSet());
+        rrules << monthlyRule;
+
+        QOrganizerRecurrenceRule yearlyRule;
+        yearlyRule.setFrequency(QOrganizerRecurrenceRule::Yearly);
+        yearlyRule.setLimit(1003);
+        QList<int> daysOfYear;
+        daysOfYear << 1
+                    << 10
+                    << 20
+                    << 50
+                    << 300;
+        yearlyRule.setDaysOfYear(daysOfYear.toSet());
+
+
+        QList<QOrganizerRecurrenceRule::Month> monthsOfYear;
+        monthsOfYear << QOrganizerRecurrenceRule::January
+                     << QOrganizerRecurrenceRule::March
+                     << QOrganizerRecurrenceRule::December;
+        yearlyRule.setMonthsOfYear(monthsOfYear.toSet());
+        rrules << yearlyRule;
+
+        rec.setRecurrenceRules(rrules.toSet());
+
+        // save recurrence
+        event.saveDetail(&rec);
+
+        ECalComponent *comp = e_cal_component_new();
+        e_cal_component_set_new_vtype(comp, E_CAL_COMPONENT_EVENT);
+        QOrganizerEDSEngine::parseRecurrence(event, comp);
+
+        // recurrence dates
+        GSList *periodList = 0;
+        e_cal_component_get_rdate_list(comp, &periodList);
+
+        QCOMPARE(g_slist_length(periodList), (guint)3);
+
+        for(GSList *pIter = periodList; pIter != 0; pIter = pIter->next) {
+            ECalComponentPeriod *period = static_cast<ECalComponentPeriod*>(pIter->data);
+            QDate periodDate = QDateTime::fromTime_t(icaltime_as_timet(period->start)).date();
+
+            QVERIFY(rDates.contains(periodDate));
+        }
+        e_cal_component_free_period_list(periodList);
+
+        // exception dates
+        GSList *exDateList = 0;
+        e_cal_component_get_exdate_list(comp, &exDateList);
+        for(GSList *pIter = exDateList; pIter != 0; pIter = pIter->next) {
+            ECalComponentDateTime *exDate = static_cast<ECalComponentDateTime*>(pIter->data);
+            QDate exDateValue = QDateTime::fromTime_t(icaltime_as_timet(*exDate->value)).date();
+            QVERIFY(rExeptDates.contains(exDateValue));
+        }
+        e_cal_component_free_exdate_list(exDateList);
+
+
+        // rules
+        GSList *recurList = 0;
+        e_cal_component_get_rrule_list(comp, &recurList);
+        QCOMPARE(g_slist_length(recurList), (guint) rrules.count());
+
+        for(GSList *recurListIter = recurList; recurListIter != 0; recurListIter = recurListIter->next) {
+            struct icalrecurrencetype *rule = static_cast<struct icalrecurrencetype*>(recurListIter->data);
+
+            switch(rule->freq)
+            {
+            case ICAL_DAILY_RECURRENCE:
+                QCOMPARE(rule->count, dailyRule.limitCount());
+                break;
+            case ICAL_WEEKLY_RECURRENCE:
+                QCOMPARE(rule->count, weeklyRule.limitCount());
+                for (int d = Qt::Monday; d <= Qt::Sunday; d++) {
+                    if (daysOfWeek.contains(static_cast<Qt::DayOfWeek>(d))) {
+                        QVERIFY(rule->by_day[(d-1)] != ICAL_RECURRENCE_ARRAY_MAX);
+                    } else {
+                        QVERIFY(rule->by_day[d-1] == ICAL_RECURRENCE_ARRAY_MAX);
+                    }
+                }
+                break;
+            case ICAL_MONTHLY_RECURRENCE:
+            {
+                QCOMPARE(rule->count, monthlyRule.limitCount());
+
+                QList<int> ruleDays;
+                for (int d=0; d < ICAL_BY_MONTHDAY_SIZE; d++) {
+                    if (rule->by_month_day[d] != ICAL_RECURRENCE_ARRAY_MAX) {
+                        ruleDays << rule->by_month_day[d];
+                    }
+                }
+                QCOMPARE(ruleDays.count(), daysOfMonth.count());
+                Q_FOREACH(int day, ruleDays) {
+                    QVERIFY(daysOfMonth.contains(day));
+                }
+                break;
+            }
+            case ICAL_YEARLY_RECURRENCE:
+            {
+                QCOMPARE(rule->count, yearlyRule.limitCount());
+                QList<int> ruleDays;
+
+                for (int d=0; d < ICAL_BY_YEARDAY_SIZE; d++) {
+                    if (rule->by_year_day[d] != ICAL_RECURRENCE_ARRAY_MAX) {
+
+                        ruleDays << rule->by_year_day[d];
+                    }
+                }
+                QCOMPARE(ruleDays.count(), daysOfYear.count());
+                Q_FOREACH(int day, ruleDays) {
+                    QVERIFY(daysOfYear.contains(day));
+                }
+
+                QList<int> ruleMonths;
+                for (int d=0; d < ICAL_BY_MONTH_SIZE; d++) {
+                    if (rule->by_month[d] != ICAL_RECURRENCE_ARRAY_MAX) {
+                        ruleMonths << rule->by_month[d];
+                    }
+                }
+                QCOMPARE(ruleMonths.count(), monthsOfYear.count());
+                Q_FOREACH(int month, ruleMonths) {
+                    QVERIFY(monthsOfYear.contains(static_cast<QOrganizerRecurrenceRule::Month>(month)));
+                }
+            }
+            default:
+                break;
+            }
+        }
+
+        // invert
+        QOrganizerEvent event2;
+        QOrganizerEDSEngine::parseRecurrence(comp, &event2);
+
+        QCOMPARE(event2.recurrenceDates(), event.recurrenceDates());
+        QCOMPARE(event2.exceptionDates(), event.exceptionDates());
+
+        QList<QOrganizerRecurrenceRule> rrules2 = event2.recurrenceRules().toList();
+        QCOMPARE(rrules2.count(), rrules.count());
+
+        Q_FOREACH(QOrganizerRecurrenceRule rule2, rrules2) {
+            switch(rule2.frequency()) {
+            case QOrganizerRecurrenceRule::Daily:
+                QCOMPARE(rule2.limitCount(), dailyRule.limitCount());
+                break;
+            case QOrganizerRecurrenceRule::Weekly:
+            {
+                QCOMPARE(rule2.limitCount(), weeklyRule.limitCount());
+                QList<Qt::DayOfWeek> daysOfWeek2 = rule2.daysOfWeek().toList();
+                qSort(daysOfWeek2);
+                QCOMPARE(daysOfWeek2, daysOfWeek);
+                break;
+            }
+            case QOrganizerRecurrenceRule::Monthly:
+            {
+                QCOMPARE(rule2.limitCount(), monthlyRule.limitCount());
+                QList<int> daysOfMonth2 = rule2.daysOfMonth().toList();
+                qSort(daysOfMonth2);
+                QCOMPARE(daysOfMonth2, daysOfMonth);
+                break;
+            }
+            case QOrganizerRecurrenceRule::Yearly:
+            {
+                QCOMPARE(rule2.limitCount(), yearlyRule.limitCount());
+                QList<int> daysOfYear2 = rule2.daysOfYear().toList();
+                qSort(daysOfYear2);
+                QCOMPARE(daysOfYear2, daysOfYear);
+
+                QList<QOrganizerRecurrenceRule::Month> monthsOfYear2 = rule2.monthsOfYear().toList();
+                qSort(monthsOfYear2);
+                QCOMPARE(monthsOfYear2, monthsOfYear);
+                break;
+            }
+            default:
+                QVERIFY(false);
+            }
+        }
+
+        g_object_unref(comp);
+    }
+};
+
+QTEST_MAIN(ParseEcalTest)
+
+#include "parseecal-test.moc"
 
=== added file 'tests/unittest/parseitem-test.cpp'