Merge pull request #54 from dcaliste/uid

Make Event::uniqueId sole identifier for events.

lightweight/calendardataservice/calendardataservice.cpp

@@ -105,8 +105,7 @@ void CalendarDataService::updated()
             }
             eventStruct.allDay = event->allDay();
             eventStruct.color = event->color();
-            eventStruct.recurrenceId = event->recurrenceIdString();
-            eventStruct.uniqueId = event->uniqueId();
+            eventStruct.instanceId = event->instanceId();
             eventStruct.cancelled = event->status() == CalendarEvent::StatusCancelled;
             reply << eventStruct;
         }

lightweight/calendareventsmodel/calendareventsmodel.cpp

@@ -233,16 +233,14 @@ QVariant CalendarEventsModel::data(const QModelIndex &index, int role) const
         } else {
             return QDateTime::fromString(eventData.endTime, Qt::ISODate);
         }
-    case RecurrenceIdRole:
-        return eventData.recurrenceId;
     case AllDayRole:
         return eventData.allDay;
     case LocationRole:
         return eventData.location;
     case CalendarUidRole:
         return eventData.calendarUid;
-    case UidRole:
-        return eventData.uniqueId;
+    case InstanceIdRole:
+        return eventData.instanceId;
     case ColorRole:
         return QColor(eventData.color);
     case CancelledRole:
@@ -362,11 +360,10 @@ QHash<int, QByteArray> CalendarEventsModel::roleNames() const
     roleNames[DescriptionRole] = "description";
     roleNames[StartTimeRole] = "startTime";
     roleNames[EndTimeRole] = "endTime";
-    roleNames[RecurrenceIdRole] = "recurrenceId";
     roleNames[AllDayRole] = "allDay";
     roleNames[LocationRole] = "location";
     roleNames[CalendarUidRole] = "calendarUid";
-    roleNames[UidRole] = "uid";
+    roleNames[InstanceIdRole] = "instanceId";
     roleNames[ColorRole] = "color";
     roleNames[CancelledRole] = "cancelled";
 

lightweight/calendareventsmodel/calendareventsmodel.h

@@ -77,11 +77,10 @@ class CalendarEventsModel : public QAbstractListModel
         DescriptionRole,
         StartTimeRole,
         EndTimeRole,
-        RecurrenceIdRole,
         AllDayRole,
         LocationRole,
         CalendarUidRole,
-        UidRole,
+        InstanceIdRole,
         ColorRole,
         CancelledRole
     };

lightweight/common/eventdata.cpp

@@ -4,8 +4,7 @@ QDBusArgument &operator<<(QDBusArgument &argument, const EventData &eventData)
 {
     argument.beginStructure();
     argument << eventData.calendarUid
-             << eventData.uniqueId
-             << eventData.recurrenceId
+             << eventData.instanceId
              << eventData.startTime
              << eventData.endTime
              << eventData.allDay
@@ -22,8 +21,7 @@ const QDBusArgument &operator>>(const QDBusArgument &argument, EventData &eventD
 {
     argument.beginStructure();
     argument >> eventData.calendarUid
-             >> eventData.uniqueId
-             >> eventData.recurrenceId
+             >> eventData.instanceId
              >> eventData.startTime
              >> eventData.endTime
              >> eventData.allDay

lightweight/common/eventdata.h

@@ -7,8 +7,7 @@
 
 struct EventData {
     QString calendarUid;
-    QString uniqueId;
-    QString recurrenceId;
+    QString instanceId;
     QString startTime;
     QString endTime;
     bool allDay;

rpm/nemo-qml-plugin-calendar-qt5.spec

@@ -1,7 +1,7 @@
 Name:       nemo-qml-plugin-calendar-qt5
 
 Summary:    Calendar plugin for Nemo Mobile
-Version:    0.6.56
+Version:    0.7.0
 Release:    1
 License:    BSD
 URL:        https://github.com/sailfishos/nemo-qml-plugin-calendar

src/calendaragendamodel.cpp

@@ -118,8 +118,7 @@ static bool eventsEqual(const CalendarEventOccurrence *e1,
     CalendarEvent *eventObject2 = e2->eventObject();
 
     return eventObject1 && eventObject2 &&
-           eventObject1->uniqueId() == eventObject2->uniqueId() &&
-           eventObject1->recurrenceId() == eventObject2->recurrenceId();
+           eventObject1->instanceId() == eventObject2->instanceId();
 }
 
 static bool eventsLessThan(const CalendarEventOccurrence *e1,
@@ -130,7 +129,7 @@ static bool eventsLessThan(const CalendarEventOccurrence *e1,
                                    e2->eventObject()->displayLabel(),
                                    Qt::CaseInsensitive);
         if (cmp == 0)
-            return QString::compare(e1->eventObject()->uniqueId(), e2->eventObject()->uniqueId()) < 0;
+            return QString::compare(e1->eventObject()->instanceId(), e2->eventObject()->instanceId()) < 0;
         else
             return cmp < 0;
     } else {

src/calendarapi.cpp

@@ -58,18 +58,17 @@ CalendarEventModification * CalendarApi::createModification(CalendarStoredEvent
     return new CalendarEventModification(sourceEvent, occurrence);
 }
 
-void CalendarApi::remove(const QString &uid, const QString &recurrenceId, const QDateTime &time)
+void CalendarApi::remove(const QString &instanceId, const QDateTime &time)
 {
-    QDateTime recurrenceTime = QDateTime::fromString(recurrenceId, Qt::ISODate);
-    CalendarManager::instance()->deleteEvent(uid, recurrenceTime, time);
+    CalendarManager::instance()->deleteEvent(instanceId, time);
 
     // TODO: this sucks
     CalendarManager::instance()->save();
 }
 
-void CalendarApi::removeAll(const QString &uid)
+void CalendarApi::removeAll(const QString &instanceId)
 {
-    CalendarManager::instance()->deleteAll(uid);
+    CalendarManager::instance()->deleteAll(instanceId);
     CalendarManager::instance()->save();
 }
 

src/calendarapi.h

@@ -56,9 +56,9 @@ class CalendarApi : public QObject
     Q_INVOKABLE CalendarEventModification *createModification(CalendarStoredEvent *sourceEvent,
                                                               CalendarEventOccurrence *occurrence = nullptr);
 
-    Q_INVOKABLE void remove(const QString &uid, const QString &recurrenceId = QString(),
+    Q_INVOKABLE void remove(const QString &instanceId,
                             const QDateTime &time = QDateTime());
-    Q_INVOKABLE void removeAll(const QString &uid); // remove all instances an event, all recurrenceIds
+    Q_INVOKABLE void removeAll(const QString &instanceId); // remove all instances of an event, including exceptions
 
     QStringList excludedNotebooks() const;
     void setExcludedNotebooks(const QStringList &);

src/calendardata.h

@@ -45,15 +45,14 @@
 namespace CalendarData {
 
 struct EventOccurrence {
-    QString eventUid;
-    QDateTime recurrenceId;
+    QString instanceId;
     QDateTime startTime;
     QDateTime endTime;
     bool eventAllDay;
 
     QString getId() const
     {
-        return QString("%1-%2").arg(eventUid).arg(startTime.toMSecsSinceEpoch());
+        return QString("%1-%2").arg(instanceId).arg(startTime.toMSecsSinceEpoch());
     }
 };
 
@@ -71,11 +70,12 @@ struct Event {
     CalendarEvent::Days recurWeeklyDays;
     int reminder = -1; // seconds; 15 minutes before event = +900, at time of event = 0, no reminder = negative value.
     QDateTime reminderDateTime; // Valid when reminder is at a given date and time.
-    QString uniqueId;
-    QDateTime recurrenceId;
+    QString instanceId; // A unique ID, used to identify an instance (incidence or exception) throughout calendars
+    QString incidenceUid; // The uid of the incidence, shared between parent and exceptions
+    QDateTime recurrenceId; // An id identifying an exception
+    QString calendarUid; // The uid of the calendar the instance belong to
     QString location;
     CalendarEvent::Secrecy secrecy = CalendarEvent::SecrecyPublic;
-    QString calendarUid;
     CalendarEvent::Response ownerStatus = CalendarEvent::ResponseUnspecified;
     CalendarEvent::Status status = CalendarEvent::StatusNone;
     CalendarEvent::SyncFailure syncFailure = CalendarEvent::NoSyncFailure;
@@ -88,12 +88,12 @@ struct Event {
 
     bool operator==(const Event& other) const
     {
-        return uniqueId == other.uniqueId;
+        return instanceId == other.instanceId;
     }
 
     bool isValid() const
     {
-        return !uniqueId.isEmpty();
+        return !instanceId.isEmpty();
     }
 
 private:

src/calendarevent.cpp

@@ -36,6 +36,8 @@
 #include <QDateTime>
 #include <QTimeZone>
 
+#include <KCalendarCore/Event>
+
 #include "calendarutils.h"
 #include "calendarmanager.h"
 #include "calendareventoccurrence.h"
@@ -157,9 +159,14 @@ QDateTime CalendarEvent::reminderDateTime() const
     return mData->reminderDateTime;
 }
 
-QString CalendarEvent::uniqueId() const
+QString CalendarEvent::instanceId() const
 {
-    return mData->uniqueId;
+    return mData->instanceId;
+}
+
+bool CalendarEvent::isException() const
+{
+    return mData->recurrenceId.isValid();
 }
 
 bool CalendarEvent::readOnly() const
@@ -212,28 +219,14 @@ bool CalendarEvent::externalInvitation() const
     return mData->externalInvitation;
 }
 
-QDateTime CalendarEvent::recurrenceId() const
-{
-    return mData->recurrenceId;
-}
-
-QString CalendarEvent::recurrenceIdString() const
-{
-    if (mData->recurrenceId.isValid()) {
-        return CalendarUtils::recurrenceIdToString(mData->recurrenceId);
-    } else {
-        return QString();
-    }
-}
-
 CalendarStoredEvent::CalendarStoredEvent(CalendarManager *manager, const CalendarData::Event *data)
     : CalendarEvent(data, manager)
     , mManager(manager)
 {
     connect(mManager, SIGNAL(notebookColorChanged(QString)),
             this, SLOT(notebookColorChanged(QString)));
-    connect(mManager, SIGNAL(eventUidChanged(QString,QString)),
-            this, SLOT(eventUidChanged(QString,QString)));
+    connect(mManager, &CalendarManager::instanceIdChanged,
+            this, &CalendarStoredEvent::instanceIdNotified);
 }
 
 CalendarStoredEvent::~CalendarStoredEvent()
@@ -246,19 +239,21 @@ void CalendarStoredEvent::notebookColorChanged(QString notebookUid)
         emit colorChanged();
 }
 
-void CalendarStoredEvent::eventUidChanged(QString oldUid, QString newUid)
+void CalendarStoredEvent::instanceIdNotified(QString oldId, QString newId, QString notebookUid)
 {
-    if (mData->uniqueId == oldUid) {
-        mData->uniqueId = newUid;
-        emit uniqueIdChanged();
+    if (mData->instanceId == oldId) {
+        mData->instanceId = newId;
+        emit instanceIdChanged();
         // Event uid changes when the event is moved between notebooks, calendar uid has changed
+        mData->calendarUid = notebookUid;
         emit calendarUidChanged();
+        emit colorChanged();
     }
 }
 
 bool CalendarStoredEvent::sendResponse(int response)
 {
-    if (mManager->sendResponse(mData->uniqueId, mData->recurrenceId, (Response)response)) {
+    if (mManager->sendResponse(mData->instanceId, (Response)response)) {
         mManager->save();
         return true;
     } else {
@@ -268,21 +263,32 @@ bool CalendarStoredEvent::sendResponse(int response)
 
 void CalendarStoredEvent::deleteEvent()
 {
-    mManager->deleteEvent(mData->uniqueId, mData->recurrenceId, QDateTime());
+    mManager->deleteEvent(mData->instanceId, QDateTime());
     mManager->save();
 }
 
 // Returns the event as a iCalendar string
 QString CalendarStoredEvent::iCalendar(const QString &prodId) const
 {
     Q_UNUSED(prodId);
-    if (mData->uniqueId.isEmpty()) {
+    if (mData->instanceId.isEmpty()) {
         qWarning() << "Event has no uid, returning empty iCalendar string."
                    << "Save event before calling this function";
         return QString();
     }
 
-    return mManager->convertEventToICalendarSync(mData->uniqueId, prodId);
+    return mManager->convertEventToICalendarSync(mData->instanceId, prodId);
+}
+
+CalendarStoredEvent* CalendarStoredEvent::parent() const
+{
+    if (isException()) {
+        KCalendarCore::Event event;
+        event.setUid(mData->incidenceUid);
+        return mManager->eventObject(event.instanceIdentifier());
+    } else {
+        return nullptr;
+    }
 }
 
 QString CalendarStoredEvent::color() const
@@ -332,5 +338,5 @@ void CalendarStoredEvent::setEvent(const CalendarData::Event *data)
 
 CalendarData::Event CalendarStoredEvent::dissociateSingleOccurrence(const CalendarEventOccurrence *occurrence) const
 {
-    return occurrence ? mManager->dissociateSingleOccurrence(mData->uniqueId, occurrence->startTime()) : CalendarData::Event();
+    return occurrence ? mManager->dissociateSingleOccurrence(mData->instanceId, occurrence->startTime()) : CalendarData::Event();
 }

src/calendarevent.h

@@ -62,8 +62,8 @@ class CalendarEvent : public QObject
     Q_PROPERTY(CalendarEvent::Days recurWeeklyDays READ recurWeeklyDays NOTIFY recurWeeklyDaysChanged)
     Q_PROPERTY(int reminder READ reminder NOTIFY reminderChanged)
     Q_PROPERTY(QDateTime reminderDateTime READ reminderDateTime NOTIFY reminderDateTimeChanged)
-    Q_PROPERTY(QString uniqueId READ uniqueId NOTIFY uniqueIdChanged)
-    Q_PROPERTY(QString recurrenceId READ recurrenceIdString CONSTANT)
+    Q_PROPERTY(QString instanceId READ instanceId NOTIFY instanceIdChanged)
+    Q_PROPERTY(bool isException READ isException CONSTANT)
     Q_PROPERTY(bool readOnly READ readOnly CONSTANT)
     Q_PROPERTY(QString calendarUid READ calendarUid NOTIFY calendarUidChanged)
     Q_PROPERTY(QString location READ location NOTIFY locationChanged)
@@ -160,12 +160,11 @@ class CalendarEvent : public QObject
     Days recurWeeklyDays() const;
     int reminder() const;
     QDateTime reminderDateTime() const;
-    QString uniqueId() const;
+    QString instanceId() const;
+    bool isException() const;
     virtual bool readOnly() const;
     QString calendarUid() const;
     QString location() const;
-    QDateTime recurrenceId() const;
-    QString recurrenceIdString() const;
     Secrecy secrecy() const;
     Status status() const;
     SyncFailure syncFailure() const;
@@ -183,7 +182,7 @@ class CalendarEvent : public QObject
     void recurChanged();
     void reminderChanged();
     void reminderDateTimeChanged();
-    void uniqueIdChanged();
+    void instanceIdChanged();
     void calendarUidChanged();
     void locationChanged();
     void recurEndDateChanged();
@@ -207,12 +206,14 @@ class CalendarStoredEvent : public CalendarEvent
 {
     Q_OBJECT
     Q_PROPERTY(QString color READ color NOTIFY colorChanged)
+    Q_PROPERTY(CalendarStoredEvent *recurringParent READ parent CONSTANT)
 public:
     CalendarStoredEvent(CalendarManager *manager, const CalendarData::Event *data);
     ~CalendarStoredEvent();
 
     CalendarData::Event dissociateSingleOccurrence(const CalendarEventOccurrence *occurrence) const;
     void setEvent(const CalendarData::Event *event);
+    CalendarStoredEvent* parent() const;
     QString color() const;
 
     Q_INVOKABLE bool sendResponse(int response);
@@ -224,7 +225,7 @@ class CalendarStoredEvent : public CalendarEvent
 
 private slots:
     void notebookColorChanged(QString notebookUid);
-    void eventUidChanged(QString oldUid, QString newUid);
+    void instanceIdNotified(QString oldId, QString newId, QString notebookUid);
 
 private:
     CalendarManager *mManager;

src/calendareventlistmodel.cpp

@@ -153,7 +153,7 @@ void CalendarEventListModel::doRefresh()
         if (event.isValid()) {
             CalendarEventOccurrence *occurrence =
                 CalendarManager::instance()->getNextOccurrence
-                (event.uniqueId, event.recurrenceId, mStartTime);
+                (event.instanceId, mStartTime);
             if (occurrence->startTime().isValid()) {
                 occurrence->setProperty("identifier", id);
                 mEvents.append(occurrence);