[nemo-qml-plugin-calendar] Handle events changing notebooks. Contribu…

…tes to JB#60800 When an event change notebook, its instanceId is changing also. Properly propage instanceId changes to occurence and event objects.
sailfishos · Jun 6, 2023 · 1f58937 · 1f58937
1 parent 3a0a5be
commit 1f58937
Show file tree

Hide file tree

Showing 10 changed files with 58 additions and 59 deletions.
diff --git a/src/calendarevent.cpp b/src/calendarevent.cpp
@@ -225,8 +225,8 @@ CalendarStoredEvent::CalendarStoredEvent(CalendarManager *manager, const Calenda
 {
     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()
@@ -239,13 +239,15 @@ 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->instanceId == oldUid) {
-        mData->instanceId = newUid;
+    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();
     }
 }
 

diff --git a/src/calendarevent.h b/src/calendarevent.h
@@ -225,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;

diff --git a/src/calendareventoccurrence.cpp b/src/calendareventoccurrence.cpp
@@ -49,8 +49,8 @@ CalendarEventOccurrence::CalendarEventOccurrence(const CalendarData::EventOccurr
     , mStartTime(occurrence.startTime)
     , mEndTime(occurrence.endTime)
 {
-    connect(CalendarManager::instance(), SIGNAL(eventUidChanged(QString,QString)),
-            this, SLOT(eventUidChanged(QString,QString)));
+    connect(CalendarManager::instance(), &CalendarManager::instanceIdChanged,
+            this, &CalendarEventOccurrence::instanceIdChanged);
 }
 
 CalendarEventOccurrence::~CalendarEventOccurrence()
@@ -77,10 +77,12 @@ CalendarStoredEvent *CalendarEventOccurrence::eventObject() const
     return CalendarManager::instance()->eventObject(mInstanceId);
 }
 
-void CalendarEventOccurrence::eventUidChanged(QString oldUid, QString newUid)
+void CalendarEventOccurrence::instanceIdChanged(QString oldId, QString newId, QString notebookUid)
 {
-    if (mInstanceId == oldUid)
-        mInstanceId = newUid;
+    Q_UNUSED(notebookUid);
+
+    if (mInstanceId == oldId)
+        mInstanceId = newId;
 }
 
 static QDateTime toEventDateTime(const QDateTime &dateTime,

diff --git a/src/calendareventoccurrence.h b/src/calendareventoccurrence.h
@@ -70,7 +70,7 @@ class CalendarEventOccurrence : public QObject
     void endTimeChanged();
 
 private slots:
-    void eventUidChanged(QString oldUid, QString newUid);
+    void instanceIdChanged(QString oldId, QString newId, QString notebookUid);
 
 private:
     QString mInstanceId;

diff --git a/src/calendareventquery.cpp b/src/calendareventquery.cpp
@@ -46,8 +46,8 @@ CalendarEventQuery::CalendarEventQuery()
     connect(CalendarManager::instance(), &CalendarManager::timezoneChanged,
             this, &CalendarEventQuery::onTimezoneChanged);
 
-    connect(CalendarManager::instance(), SIGNAL(eventUidChanged(QString,QString)),
-            this, SLOT(eventUidChanged(QString,QString)));
+    connect(CalendarManager::instance(), &CalendarManager::instanceIdChanged,
+            this, &CalendarEventQuery::instanceIdNotified);
 }
 
 CalendarEventQuery::~CalendarEventQuery()
@@ -228,10 +228,17 @@ void CalendarEventQuery::onTimezoneChanged()
     }
 }
 
-void CalendarEventQuery::eventUidChanged(QString oldUid, QString newUid)
+void CalendarEventQuery::instanceIdNotified(QString oldId, QString newId, QString notebookUid)
 {
-    if (mInstanceId == oldUid) {
-        emit newUniqueId(newUid);
-        refresh();
+    if (mInstanceId == oldId) {
+        mInstanceId = newId;
+        emit instanceIdChanged();
+
+        if (mEvent.isValid()) {
+            mEvent.instanceId = newId;
+            mEvent.calendarUid = notebookUid;
+        } else {
+            refresh();
+        }
     }
 }
diff --git a/src/calendareventquery.h b/src/calendareventquery.h
@@ -137,15 +137,10 @@ class CalendarEventQuery : public QObject, public QQmlParserStatus
     void startTimeChanged();
     void eventErrorChanged();
 
-    // Indicates that the event UID has changed in database, event has been moved between notebooks.
-    // The property instanceId will not be changed, the data pointer properties event and occurrence
-    // will reset to null pointers.
-    void newUniqueId(QString newUid);
-
 private slots:
     void refresh();
     void onTimezoneChanged();
-    void eventUidChanged(QString oldUid, QString newUid);
+    void instanceIdNotified(QString oldId, QString newId, QString notebookUid);
 
 private:
     bool mIsComplete;

diff --git a/src/calendarmanager.cpp b/src/calendarmanager.cpp
@@ -633,39 +633,23 @@ void CalendarManager::calendarTimezoneChangedSlot()
     emit timezoneChanged();
 }
 
-void CalendarManager::eventNotebookChanged(const QString &oldEventUid, const QString &newEventUid,
+void CalendarManager::eventNotebookChanged(const QString &oldInstanceId,
+                                           const QString &newInstanceId,
                                            const QString &notebookUid)
 {
-    // FIXME: adapt to multihash + recurrenceId.
-#if 0
-    if (mEvents.contains(oldEventUid)) {
-        mEvents.insert(newEventUid, mEvents.value(oldEventUid));
-        mEvents[newEventUid].calendarUid = notebookUid;
-        mEvents.remove(oldEventUid);
+    if (mEvents.contains(oldInstanceId)) {
+        mEvents.insert(newInstanceId, mEvents.value(oldInstanceId));
+        mEvents[newInstanceId].calendarUid = notebookUid;
+        mEvents.remove(oldInstanceId);
     }
-    if (mEventObjects.contains(oldEventUid)) {
-        mEventObjects.insert(newEventUid, mEventObjects.value(oldEventUid));
-        mEventObjects.remove(oldEventUid);
+    // newInstanceId points to the same object than oldInstanceId
+    // to avoid CalendarEventQuery or CalendarEventOccurrence to
+    // emit object changed.
+    if (mEventObjects.contains(oldInstanceId)) {
+        mEventObjects.insert(newInstanceId, mEventObjects.value(oldInstanceId));
+        mEventObjects.remove(oldInstanceId);
     }
-    foreach (QString occurrenceUid, mEventOccurrences.keys()) {
-        if (mEventOccurrences.value(occurrenceUid).instanceId == oldEventUid)
-            mEventOccurrences[occurrenceUid].instanceId = newEventUid;
-    }
-
-    emit eventUidChanged(oldEventUid, newEventUid);
-
-    // Event uid is changed when events are moved between notebooks, the notebook color
-    // associated with this event has changed. Emit color changed after emitting eventUidChanged,
-    // so that data models have the correct event uid to use when querying for CalendarEvent
-    // instances, see CalendarEventOccurrence::eventObject(), used by CalendarAgendaModel.
-    CalendarEvent *eventObject = mEventObjects.value(newEventUid);
-    if (eventObject)
-        emit eventObject->colorChanged();
-#else
-    Q_UNUSED(oldEventUid)
-    Q_UNUSED(newEventUid)
-    Q_UNUSED(notebookUid)
-#endif
+    emit instanceIdChanged(oldInstanceId, newInstanceId, notebookUid);
 }
 
 void CalendarManager::excludedNotebooksChangedSlot(const QStringList &excludedNotebooks)

diff --git a/src/calendarmanager.h b/src/calendarmanager.h
@@ -119,7 +119,9 @@ class CalendarManager : public QObject
 private slots:
     void storageModifiedSlot();
     void calendarTimezoneChangedSlot();
-    void eventNotebookChanged(const QString &oldEventUid, const QString &newEventUid, const QString &notebookUid);
+    void eventNotebookChanged(const QString &oldInstanceId,
+                              const QString &newInstanceId,
+                              const QString &notebookUid);
     void excludedNotebooksChangedSlot(const QStringList &excludedNotebooks);
     void notebooksChangedSlot(const QList<CalendarData::Notebook> &notebooks);
     void dataLoadedSlot(const QList<CalendarData::Range> &ranges,
@@ -142,7 +144,7 @@ private slots:
     void storageModified();
     void timezoneChanged();
     void dataUpdated();
-    void eventUidChanged(QString oldUid, QString newUid);
+    void instanceIdChanged(QString oldId, QString newId, QString notebookUid);
 
 private:
     friend class tst_CalendarManager;

diff --git a/src/calendarworker.cpp b/src/calendarworker.cpp
@@ -309,12 +309,19 @@ void CalendarWorker::saveEvent(const CalendarData::Event &eventData, bool update
         }
     } else {
         if (!notebookUid.isEmpty() && mCalendar->notebook(event) != notebookUid) {
-            // mkcal does funny things when moving event between notebooks, work around by changing uid
             KCalendarCore::Event::Ptr newEvent(event->clone());
-            newEvent->setUid(KCalendarCore::CalFormat::createUniqueId().toUpper());
-            emit eventNotebookChanged(event->uid(), newEvent->uid(), notebookUid);
+#if 0
+            // mkcal does not support keeping the same UID for events
+            // in different notebooks. One should keep the same UID
+            // for the deleted event and the new event not to confuse
+            // sync processes, if the event has been uploaded to a server
+            // already.
+            // So this code is currently broken and requires mKCal
+            // to support multi-notebook incidences sharing the same UID.
+            emit eventNotebookChanged(eventData.instanceId, newEvent->instanceIdentifier(), notebookUid);
             mCalendar->deleteEvent(event);
             mCalendar->addEvent(newEvent, notebookUid);
+#endif
             event = newEvent;
         } else {
             event->setRevision(event->revision() + 1);

diff --git a/src/calendarworker.h b/src/calendarworker.h
@@ -99,7 +99,7 @@ public slots:
     void storageModifiedSignal();
     void calendarTimezoneChanged();
 
-    void eventNotebookChanged(const QString &oldEventUid, const QString &newEventUid, const QString &notebookUid);
+    void eventNotebookChanged(const QString &oldInstanceId, const QString &newInstanceId, const QString &notebookUid);
 
     void excludedNotebooksChanged(const QStringList &excludedNotebooks);
     void notebookColorChanged(const CalendarData::Notebook &notebook);