Fetch missing events

src/Cache.cpp

@@ -1324,6 +1324,17 @@ Cache::getEvent(const std::string &room_id, const std::string &event_id)
 
         return te;
 }
+void
+Cache::storeEvent(const std::string &room_id,
+                  const std::string &event_id,
+                  const mtx::events::collections::TimelineEvent &event)
+{
+        auto txn        = lmdb::txn::begin(env_);
+        auto eventsDb   = getEventsDb(txn, room_id);
+        auto event_json = mtx::accessors::serialize_event(event.data);
+        lmdb::dbi_put(txn, eventsDb, lmdb::val(event_id), lmdb::val(event_json.dump()));
+        txn.commit();
+}
 
 QMap<QString, RoomInfo>
 Cache::roomInfo(bool withInvites)

src/Cache_p.h

@@ -185,6 +185,9 @@ public:
         std::optional<mtx::events::collections::TimelineEvent> getEvent(
           const std::string &room_id,
           const std::string &event_id);
+        void storeEvent(const std::string &room_id,
+                        const std::string &event_id,
+                        const mtx::events::collections::TimelineEvent &event);
         struct TimelineRange
         {
                 int64_t first, last;

src/timeline/EventStore.cpp

@@ -5,6 +5,7 @@
 #include "Cache_p.h"
 #include "EventAccessors.h"
 #include "Logging.h"
+#include "MatrixClient.h"
 #include "Olm.h"
 
 QCache<EventStore::IdIndex, mtx::events::collections::TimelineEvents> EventStore::decryptedEvents_{
@@ -22,6 +23,23 @@ EventStore::EventStore(std::string room_id, QObject *)
                 this->first = range->first;
                 this->last  = range->last;
         }
+
+        connect(
+          this,
+          &EventStore::eventFetched,
+          this,
+          [this](std::string id,
+                 std::string relatedTo,
+                 mtx::events::collections::TimelineEvents timeline) {
+                  cache::client()->storeEvent(room_id_, id, {timeline});
+
+                  if (!relatedTo.empty()) {
+                          auto idx = idToIndex(id);
+                          if (idx)
+                                  emit dataChanged(*idx, *idx);
+                  }
+          },
+          Qt::QueuedConnection);
 }
 
 void
@@ -241,8 +259,23 @@ EventStore::event(std::string_view id, std::string_view related_to, bool decrypt
         if (!event_ptr) {
                 auto event = cache::client()->getEvent(room_id_, index.id);
                 if (!event) {
-                        // fetch
-                        (void)related_to;
+                        http::client()->get_event(
+                          room_id_,
+                          index.id,
+                          [this,
+                           relatedTo = std::string(related_to.data(), related_to.size()),
+                           id = index.id](const mtx::events::collections::TimelineEvents &timeline,
+                                          mtx::http::RequestErr err) {
+                                  if (err) {
+                                          nhlog::net()->error(
+                                            "Failed to retrieve event with id {}, which was "
+                                            "requested to show the replyTo for event {}",
+                                            relatedTo,
+                                            id);
+                                          return;
+                                  }
+                                  emit eventFetched(id, relatedTo, timeline);
+                          });
                         return nullptr;
                 }
                 event_ptr = new mtx::events::collections::TimelineEvents(std::move(event->data));

src/timeline/EventStore.h

@@ -81,6 +81,9 @@ signals:
         void endInsertRows();
         void dataChanged(int from, int to);
         void newEncryptedImage(mtx::crypto::EncryptedFile encryptionInfo);
+        void eventFetched(std::string id,
+                          std::string relatedTo,
+                          mtx::events::collections::TimelineEvents timeline);
 
 private:
         mtx::events::collections::TimelineEvents *decryptEvent(

src/timeline/TimelineModel.cpp

@@ -696,27 +696,6 @@ TimelineModel::internalAddEvents(
                                 emit dataChanged(index(idx, 0), index(idx, 0));
                         continue; // don't insert reaction into timeline
                 }
-
-                // auto replyTo  = mtx::accessors::in_reply_to_event(e);
-                // auto qReplyTo = QString::fromStdString(replyTo);
-                // if (!replyTo.empty() && !events.contains(qReplyTo)) {
-                //        http::client()->get_event(
-                //          this->room_id_.toStdString(),
-                //          replyTo,
-                //          [this, id, replyTo](
-                //            const mtx::events::collections::TimelineEvents &timeline,
-                //            mtx::http::RequestErr err) {
-                //                  if (err) {
-                //                          nhlog::net()->error(
-                //                            "Failed to retrieve event with id {}, which was "
-                //                            "requested to show the replyTo for event {}",
-                //                            replyTo,
-                //                            id.toStdString());
-                //                          return;
-                //                  }
-                //                  emit eventFetched(id, timeline);
-                //          });
-                //}
         }
 }