diff --git a/src/timeline/EventStore.cpp b/src/timeline/EventStore.cpp
index 881fd5bb..7144424a 100644
--- a/src/timeline/EventStore.cpp
+++ b/src/timeline/EventStore.cpp
@@ -28,393 +28,373 @@ QCache<EventStore::Index, mtx::events::collections::TimelineEvents> EventStore::
EventStore::EventStore(std::string room_id, QObject *)
: room_id_(std::move(room_id))
{
- static auto reactionType = qRegisterMetaType<Reaction>();
- (void)reactionType;
-
- auto range = cache::client()->getTimelineRange(room_id_);
-
- if (range) {
- 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(relatedTo);
- if (idx)
- emit dataChanged(*idx, *idx);
- }
- },
- Qt::QueuedConnection);
-
- connect(
- this,
- &EventStore::oldMessagesRetrieved,
- this,
- [this](const mtx::responses::Messages &res) {
- if (res.end.empty() || cache::client()->previousBatchToken(room_id_) == res.end) {
- noMoreMessages = true;
- emit fetchedMore();
- return;
+ static auto reactionType = qRegisterMetaType<Reaction>();
+ (void)reactionType;
+
+ auto range = cache::client()->getTimelineRange(room_id_);
+
+ if (range) {
+ 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(relatedTo);
+ if (idx)
+ emit dataChanged(*idx, *idx);
+ }
+ },
+ Qt::QueuedConnection);
+
+ connect(
+ this,
+ &EventStore::oldMessagesRetrieved,
+ this,
+ [this](const mtx::responses::Messages &res) {
+ if (res.end.empty() || cache::client()->previousBatchToken(room_id_) == res.end) {
+ noMoreMessages = true;
+ emit fetchedMore();
+ return;
+ }
+
+ uint64_t newFirst = cache::client()->saveOldMessages(room_id_, res);
+ if (newFirst == first)
+ fetchMore();
+ else {
+ if (this->last != std::numeric_limits<uint64_t>::max()) {
+ auto oldFirst = this->first;
+ emit beginInsertRows(toExternalIdx(newFirst), toExternalIdx(this->first - 1));
+ this->first = newFirst;
+ emit endInsertRows();
+ emit fetchedMore();
+ emit dataChanged(toExternalIdx(oldFirst), toExternalIdx(oldFirst));
+ } else {
+ auto range = cache::client()->getTimelineRange(room_id_);
+
+ if (range && range->last - range->first != 0) {
+ emit beginInsertRows(0, int(range->last - range->first));
+ this->first = range->first;
+ this->last = range->last;
+ emit endInsertRows();
+ emit fetchedMore();
+ } else {
+ fetchMore();
}
+ }
+ }
+ },
+ Qt::QueuedConnection);
+
+ connect(this, &EventStore::processPending, this, [this]() {
+ if (!current_txn.empty()) {
+ nhlog::ui()->debug("Already processing {}", current_txn);
+ return;
+ }
- uint64_t newFirst = cache::client()->saveOldMessages(room_id_, res);
- if (newFirst == first)
- fetchMore();
- else {
- if (this->last != std::numeric_limits<uint64_t>::max()) {
- auto oldFirst = this->first;
- emit beginInsertRows(toExternalIdx(newFirst),
- toExternalIdx(this->first - 1));
- this->first = newFirst;
- emit endInsertRows();
- emit fetchedMore();
- emit dataChanged(toExternalIdx(oldFirst),
- toExternalIdx(oldFirst));
- } else {
- auto range = cache::client()->getTimelineRange(room_id_);
-
- if (range && range->last - range->first != 0) {
- emit beginInsertRows(0, int(range->last - range->first));
- this->first = range->first;
- this->last = range->last;
- emit endInsertRows();
- emit fetchedMore();
- } else {
- fetchMore();
- }
- }
- }
- },
- Qt::QueuedConnection);
+ auto event = cache::client()->firstPendingMessage(room_id_);
- connect(this, &EventStore::processPending, this, [this]() {
- if (!current_txn.empty()) {
- nhlog::ui()->debug("Already processing {}", current_txn);
- return;
- }
+ if (!event) {
+ nhlog::ui()->debug("No event to send");
+ return;
+ }
- auto event = cache::client()->firstPendingMessage(room_id_);
+ std::visit(
+ [this](auto e) {
+ auto txn_id = e.event_id;
+ this->current_txn = txn_id;
- if (!event) {
- nhlog::ui()->debug("No event to send");
- return;
- }
+ if (txn_id.empty() || txn_id[0] != 'm') {
+ nhlog::ui()->debug("Invalid txn id '{}'", txn_id);
+ cache::client()->removePendingStatus(room_id_, txn_id);
+ return;
+ }
+
+ if constexpr (mtx::events::message_content_to_type<decltype(e.content)> !=
+ mtx::events::EventType::Unsupported)
+ http::client()->send_room_message(
+ room_id_,
+ txn_id,
+ e.content,
+ [this, txn_id, e](const mtx::responses::EventId &event_id,
+ mtx::http::RequestErr err) {
+ if (err) {
+ const int status_code = static_cast<int>(err->status_code);
+ nhlog::net()->warn("[{}] failed to send message: {} {}",
+ txn_id,
+ err->matrix_error.error,
+ status_code);
+ emit messageFailed(txn_id);
+ return;
+ }
- std::visit(
- [this](auto e) {
- auto txn_id = e.event_id;
- this->current_txn = txn_id;
-
- if (txn_id.empty() || txn_id[0] != 'm') {
- nhlog::ui()->debug("Invalid txn id '{}'", txn_id);
- cache::client()->removePendingStatus(room_id_, txn_id);
- return;
- }
-
- if constexpr (mtx::events::message_content_to_type<decltype(e.content)> !=
- mtx::events::EventType::Unsupported)
- http::client()->send_room_message(
- room_id_,
- txn_id,
- e.content,
- [this, txn_id, e](const mtx::responses::EventId &event_id,
- mtx::http::RequestErr err) {
- if (err) {
- const int status_code =
- static_cast<int>(err->status_code);
- nhlog::net()->warn(
- "[{}] failed to send message: {} {}",
- txn_id,
- err->matrix_error.error,
- status_code);
- emit messageFailed(txn_id);
- return;
- }
-
- emit messageSent(txn_id, event_id.event_id.to_string());
- if constexpr (std::is_same_v<
- decltype(e.content),
- mtx::events::msg::Encrypted>) {
- auto event =
- decryptEvent({room_id_, e.event_id}, e);
- if (event->event) {
- if (auto dec = std::get_if<
- mtx::events::RoomEvent<
- mtx::events::msg::
- KeyVerificationRequest>>(
- &event->event.value())) {
- emit updateFlowEventId(
- event_id.event_id
- .to_string());
- }
- }
- }
- });
- },
- event->data);
- });
-
- connect(
- this,
- &EventStore::messageFailed,
- this,
- [this](std::string txn_id) {
- if (current_txn == txn_id) {
- current_txn_error_count++;
- if (current_txn_error_count > 10) {
- nhlog::ui()->debug("failing txn id '{}'", txn_id);
- cache::client()->removePendingStatus(room_id_, txn_id);
- current_txn_error_count = 0;
- }
- }
- QTimer::singleShot(1000, this, [this]() {
- nhlog::ui()->debug("timeout");
- this->current_txn = "";
- emit processPending();
- });
+ emit messageSent(txn_id, event_id.event_id.to_string());
+ if constexpr (std::is_same_v<decltype(e.content),
+ mtx::events::msg::Encrypted>) {
+ auto event = decryptEvent({room_id_, e.event_id}, e);
+ if (event->event) {
+ if (auto dec = std::get_if<mtx::events::RoomEvent<
+ mtx::events::msg::KeyVerificationRequest>>(
+ &event->event.value())) {
+ emit updateFlowEventId(event_id.event_id.to_string());
+ }
+ }
+ }
+ });
},
- Qt::QueuedConnection);
-
- connect(
- this,
- &EventStore::messageSent,
- this,
- [this](std::string txn_id, std::string event_id) {
- nhlog::ui()->debug("sent {}", txn_id);
-
- // Replace the event_id in pending edits/replies/redactions with the actual
- // event_id of this event. This allows one to edit and reply to events that are
- // currently pending.
-
- // FIXME (introduced by balsoft): this doesn't work for encrypted events, but
- // allegedly it's hard to fix so I'll leave my first contribution at that
- for (auto related_event_id : cache::client()->relatedEvents(room_id_, txn_id)) {
- if (cache::client()->getEvent(room_id_, related_event_id)) {
- auto related_event =
- cache::client()->getEvent(room_id_, related_event_id).value();
- auto relations = mtx::accessors::relations(related_event.data);
-
- // Replace the blockquote in fallback reply
- auto related_text =
- std::get_if<mtx::events::RoomEvent<mtx::events::msg::Text>>(
- &related_event.data);
- if (related_text && relations.reply_to() == txn_id) {
- size_t index =
- related_text->content.formatted_body.find(txn_id);
- if (index != std::string::npos) {
- related_text->content.formatted_body.replace(
- index, event_id.length(), event_id);
- }
- }
+ event->data);
+ });
+
+ connect(
+ this,
+ &EventStore::messageFailed,
+ this,
+ [this](std::string txn_id) {
+ if (current_txn == txn_id) {
+ current_txn_error_count++;
+ if (current_txn_error_count > 10) {
+ nhlog::ui()->debug("failing txn id '{}'", txn_id);
+ cache::client()->removePendingStatus(room_id_, txn_id);
+ current_txn_error_count = 0;
+ }
+ }
+ QTimer::singleShot(1000, this, [this]() {
+ nhlog::ui()->debug("timeout");
+ this->current_txn = "";
+ emit processPending();
+ });
+ },
+ Qt::QueuedConnection);
+
+ connect(
+ this,
+ &EventStore::messageSent,
+ this,
+ [this](std::string txn_id, std::string event_id) {
+ nhlog::ui()->debug("sent {}", txn_id);
+
+ // Replace the event_id in pending edits/replies/redactions with the actual
+ // event_id of this event. This allows one to edit and reply to events that are
+ // currently pending.
+
+ // FIXME (introduced by balsoft): this doesn't work for encrypted events, but
+ // allegedly it's hard to fix so I'll leave my first contribution at that
+ for (auto related_event_id : cache::client()->relatedEvents(room_id_, txn_id)) {
+ if (cache::client()->getEvent(room_id_, related_event_id)) {
+ auto related_event =
+ cache::client()->getEvent(room_id_, related_event_id).value();
+ auto relations = mtx::accessors::relations(related_event.data);
+
+ // Replace the blockquote in fallback reply
+ auto related_text = std::get_if<mtx::events::RoomEvent<mtx::events::msg::Text>>(
+ &related_event.data);
+ if (related_text && relations.reply_to() == txn_id) {
+ size_t index = related_text->content.formatted_body.find(txn_id);
+ if (index != std::string::npos) {
+ related_text->content.formatted_body.replace(
+ index, event_id.length(), event_id);
+ }
+ }
- for (mtx::common::Relation &rel : relations.relations) {
- if (rel.event_id == txn_id)
- rel.event_id = event_id;
- }
+ for (mtx::common::Relation &rel : relations.relations) {
+ if (rel.event_id == txn_id)
+ rel.event_id = event_id;
+ }
- mtx::accessors::set_relations(related_event.data, relations);
+ mtx::accessors::set_relations(related_event.data, relations);
- cache::client()->replaceEvent(
- room_id_, related_event_id, related_event);
+ cache::client()->replaceEvent(room_id_, related_event_id, related_event);
- auto idx = idToIndex(related_event_id);
+ auto idx = idToIndex(related_event_id);
- events_by_id_.remove({room_id_, related_event_id});
- events_.remove({room_id_, toInternalIdx(*idx)});
- }
- }
+ events_by_id_.remove({room_id_, related_event_id});
+ events_.remove({room_id_, toInternalIdx(*idx)});
+ }
+ }
- http::client()->read_event(
- room_id_, event_id, [this, event_id](mtx::http::RequestErr err) {
- if (err) {
- nhlog::net()->warn(
- "failed to read_event ({}, {})", room_id_, event_id);
- }
- });
+ http::client()->read_event(
+ room_id_, event_id, [this, event_id](mtx::http::RequestErr err) {
+ if (err) {
+ nhlog::net()->warn("failed to read_event ({}, {})", room_id_, event_id);
+ }
+ });
- auto idx = idToIndex(event_id);
+ auto idx = idToIndex(event_id);
- if (idx)
- emit dataChanged(*idx, *idx);
+ if (idx)
+ emit dataChanged(*idx, *idx);
- cache::client()->removePendingStatus(room_id_, txn_id);
- this->current_txn = "";
- this->current_txn_error_count = 0;
- emit processPending();
- },
- Qt::QueuedConnection);
+ cache::client()->removePendingStatus(room_id_, txn_id);
+ this->current_txn = "";
+ this->current_txn_error_count = 0;
+ emit processPending();
+ },
+ Qt::QueuedConnection);
}
void
EventStore::addPending(mtx::events::collections::TimelineEvents event)
{
- if (this->thread() != QThread::currentThread())
- nhlog::db()->warn("{} called from a different thread!", __func__);
+ if (this->thread() != QThread::currentThread())
+ nhlog::db()->warn("{} called from a different thread!", __func__);
- cache::client()->savePendingMessage(this->room_id_, {event});
- mtx::responses::Timeline events;
- events.limited = false;
- events.events.emplace_back(event);
- handleSync(events);
+ cache::client()->savePendingMessage(this->room_id_, {event});
+ mtx::responses::Timeline events;
+ events.limited = false;
+ events.events.emplace_back(event);
+ handleSync(events);
- emit processPending();
+ emit processPending();
}
void
EventStore::clearTimeline()
{
- emit beginResetModel();
-
- cache::client()->clearTimeline(room_id_);
- auto range = cache::client()->getTimelineRange(room_id_);
- if (range) {
- nhlog::db()->info("Range {} {}", range->last, range->first);
- this->last = range->last;
- this->first = range->first;
- } else {
- this->first = std::numeric_limits<uint64_t>::max();
- this->last = std::numeric_limits<uint64_t>::max();
- }
- nhlog::ui()->info("Range {} {}", this->last, this->first);
-
- decryptedEvents_.clear();
- events_.clear();
-
- emit endResetModel();
+ emit beginResetModel();
+
+ cache::client()->clearTimeline(room_id_);
+ auto range = cache::client()->getTimelineRange(room_id_);
+ if (range) {
+ nhlog::db()->info("Range {} {}", range->last, range->first);
+ this->last = range->last;
+ this->first = range->first;
+ } else {
+ this->first = std::numeric_limits<uint64_t>::max();
+ this->last = std::numeric_limits<uint64_t>::max();
+ }
+ nhlog::ui()->info("Range {} {}", this->last, this->first);
+
+ decryptedEvents_.clear();
+ events_.clear();
+
+ emit endResetModel();
}
void
EventStore::receivedSessionKey(const std::string &session_id)
{
- if (!pending_key_requests.count(session_id))
- return;
+ if (!pending_key_requests.count(session_id))
+ return;
- auto request = pending_key_requests.at(session_id);
+ auto request = pending_key_requests.at(session_id);
- // Don't request keys again until Nheko is restarted (for now)
- pending_key_requests[session_id].events.clear();
+ // Don't request keys again until Nheko is restarted (for now)
+ pending_key_requests[session_id].events.clear();
- if (!request.events.empty())
- olm::send_key_request_for(request.events.front(), request.request_id, true);
+ if (!request.events.empty())
+ olm::send_key_request_for(request.events.front(), request.request_id, true);
- for (const auto &e : request.events) {
- auto idx = idToIndex(e.event_id);
- if (idx) {
- decryptedEvents_.remove({room_id_, e.event_id});
- events_by_id_.remove({room_id_, e.event_id});
- events_.remove({room_id_, toInternalIdx(*idx)});
- emit dataChanged(*idx, *idx);
- }
+ for (const auto &e : request.events) {
+ auto idx = idToIndex(e.event_id);
+ if (idx) {
+ decryptedEvents_.remove({room_id_, e.event_id});
+ events_by_id_.remove({room_id_, e.event_id});
+ events_.remove({room_id_, toInternalIdx(*idx)});
+ emit dataChanged(*idx, *idx);
}
+ }
}
void
EventStore::handleSync(const mtx::responses::Timeline &events)
{
- if (this->thread() != QThread::currentThread())
- nhlog::db()->warn("{} called from a different thread!", __func__);
-
- auto range = cache::client()->getTimelineRange(room_id_);
- if (!range) {
- emit beginResetModel();
- this->first = std::numeric_limits<uint64_t>::max();
- this->last = std::numeric_limits<uint64_t>::max();
-
- decryptedEvents_.clear();
- events_.clear();
- emit endResetModel();
- return;
- }
+ if (this->thread() != QThread::currentThread())
+ nhlog::db()->warn("{} called from a different thread!", __func__);
- if (events.limited) {
- emit beginResetModel();
- this->last = range->last;
- this->first = range->first;
-
- decryptedEvents_.clear();
- events_.clear();
- emit endResetModel();
- } else if (range->last > this->last) {
- emit beginInsertRows(toExternalIdx(this->last + 1), toExternalIdx(range->last));
- this->last = range->last;
- emit endInsertRows();
- }
+ auto range = cache::client()->getTimelineRange(room_id_);
+ if (!range) {
+ emit beginResetModel();
+ this->first = std::numeric_limits<uint64_t>::max();
+ this->last = std::numeric_limits<uint64_t>::max();
- for (const auto &event : events.events) {
- std::set<std::string> relates_to;
- if (auto redaction =
- std::get_if<mtx::events::RedactionEvent<mtx::events::msg::Redaction>>(
- &event)) {
- // fixup reactions
- auto redacted = events_by_id_.object({room_id_, redaction->redacts});
- if (redacted) {
- auto id = mtx::accessors::relations(*redacted);
- if (id.annotates()) {
- auto idx = idToIndex(id.annotates()->event_id);
- if (idx) {
- events_by_id_.remove(
- {room_id_, redaction->redacts});
- events_.remove({room_id_, toInternalIdx(*idx)});
- emit dataChanged(*idx, *idx);
- }
- }
- }
+ decryptedEvents_.clear();
+ events_.clear();
+ emit endResetModel();
+ return;
+ }
- relates_to.insert(redaction->redacts);
- } else {
- for (const auto &r : mtx::accessors::relations(event).relations)
- relates_to.insert(r.event_id);
- }
+ if (events.limited) {
+ emit beginResetModel();
+ this->last = range->last;
+ this->first = range->first;
- for (const auto &relates_to_id : relates_to) {
- auto idx = cache::client()->getTimelineIndex(room_id_, relates_to_id);
- if (idx) {
- events_by_id_.remove({room_id_, relates_to_id});
- decryptedEvents_.remove({room_id_, relates_to_id});
- events_.remove({room_id_, *idx});
- emit dataChanged(toExternalIdx(*idx), toExternalIdx(*idx));
- }
+ decryptedEvents_.clear();
+ events_.clear();
+ emit endResetModel();
+ } else if (range->last > this->last) {
+ emit beginInsertRows(toExternalIdx(this->last + 1), toExternalIdx(range->last));
+ this->last = range->last;
+ emit endInsertRows();
+ }
+
+ for (const auto &event : events.events) {
+ std::set<std::string> relates_to;
+ if (auto redaction =
+ std::get_if<mtx::events::RedactionEvent<mtx::events::msg::Redaction>>(&event)) {
+ // fixup reactions
+ auto redacted = events_by_id_.object({room_id_, redaction->redacts});
+ if (redacted) {
+ auto id = mtx::accessors::relations(*redacted);
+ if (id.annotates()) {
+ auto idx = idToIndex(id.annotates()->event_id);
+ if (idx) {
+ events_by_id_.remove({room_id_, redaction->redacts});
+ events_.remove({room_id_, toInternalIdx(*idx)});
+ emit dataChanged(*idx, *idx);
+ }
}
+ }
- if (auto txn_id = mtx::accessors::transaction_id(event); !txn_id.empty()) {
- auto idx = cache::client()->getTimelineIndex(
- room_id_, mtx::accessors::event_id(event));
- if (idx) {
- Index index{room_id_, *idx};
- events_.remove(index);
- emit dataChanged(toExternalIdx(*idx), toExternalIdx(*idx));
- }
- }
+ relates_to.insert(redaction->redacts);
+ } else {
+ for (const auto &r : mtx::accessors::relations(event).relations)
+ relates_to.insert(r.event_id);
+ }
- // decrypting and checking some encrypted messages
- if (auto encrypted =
- std::get_if<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(
- &event)) {
- auto d_event = decryptEvent({room_id_, encrypted->event_id}, *encrypted);
- if (d_event->event &&
- std::visit(
- [](auto e) { return (e.sender != utils::localUser().toStdString()); },
- *d_event->event)) {
- handle_room_verification(*d_event->event);
- }
- }
+ for (const auto &relates_to_id : relates_to) {
+ auto idx = cache::client()->getTimelineIndex(room_id_, relates_to_id);
+ if (idx) {
+ events_by_id_.remove({room_id_, relates_to_id});
+ decryptedEvents_.remove({room_id_, relates_to_id});
+ events_.remove({room_id_, *idx});
+ emit dataChanged(toExternalIdx(*idx), toExternalIdx(*idx));
+ }
+ }
+
+ if (auto txn_id = mtx::accessors::transaction_id(event); !txn_id.empty()) {
+ auto idx = cache::client()->getTimelineIndex(room_id_, mtx::accessors::event_id(event));
+ if (idx) {
+ Index index{room_id_, *idx};
+ events_.remove(index);
+ emit dataChanged(toExternalIdx(*idx), toExternalIdx(*idx));
+ }
}
+
+ // decrypting and checking some encrypted messages
+ if (auto encrypted =
+ std::get_if<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&event)) {
+ auto d_event = decryptEvent({room_id_, encrypted->event_id}, *encrypted);
+ if (d_event->event &&
+ std::visit([](auto e) { return (e.sender != utils::localUser().toStdString()); },
+ *d_event->event)) {
+ handle_room_verification(*d_event->event);
+ }
+ }
+ }
}
namespace {
template<class... Ts>
struct overloaded : Ts...
{
- using Ts::operator()...;
+ using Ts::operator()...;
};
template<class... Ts>
overloaded(Ts...) -> overloaded<Ts...>;
@@ -423,462 +403,451 @@ overloaded(Ts...) -> overloaded<Ts...>;
void
EventStore::handle_room_verification(mtx::events::collections::TimelineEvents event)
{
- std::visit(
- overloaded{
- [this](const mtx::events::RoomEvent<mtx::events::msg::KeyVerificationRequest> &msg) {
- nhlog::db()->debug("handle_room_verification: Request");
- emit startDMVerification(msg);
- },
- [](const mtx::events::RoomEvent<mtx::events::msg::KeyVerificationCancel> &msg) {
- nhlog::db()->debug("handle_room_verification: Cancel");
- ChatPage::instance()->receivedDeviceVerificationCancel(msg.content);
- },
- [](const mtx::events::RoomEvent<mtx::events::msg::KeyVerificationAccept> &msg) {
- nhlog::db()->debug("handle_room_verification: Accept");
- ChatPage::instance()->receivedDeviceVerificationAccept(msg.content);
- },
- [](const mtx::events::RoomEvent<mtx::events::msg::KeyVerificationKey> &msg) {
- nhlog::db()->debug("handle_room_verification: Key");
- ChatPage::instance()->receivedDeviceVerificationKey(msg.content);
- },
- [](const mtx::events::RoomEvent<mtx::events::msg::KeyVerificationMac> &msg) {
- nhlog::db()->debug("handle_room_verification: Mac");
- ChatPage::instance()->receivedDeviceVerificationMac(msg.content);
- },
- [](const mtx::events::RoomEvent<mtx::events::msg::KeyVerificationReady> &msg) {
- nhlog::db()->debug("handle_room_verification: Ready");
- ChatPage::instance()->receivedDeviceVerificationReady(msg.content);
- },
- [](const mtx::events::RoomEvent<mtx::events::msg::KeyVerificationDone> &msg) {
- nhlog::db()->debug("handle_room_verification: Done");
- ChatPage::instance()->receivedDeviceVerificationDone(msg.content);
- },
- [](const mtx::events::RoomEvent<mtx::events::msg::KeyVerificationStart> &msg) {
- nhlog::db()->debug("handle_room_verification: Start");
- ChatPage::instance()->receivedDeviceVerificationStart(msg.content, msg.sender);
- },
- [](const auto &) {},
- },
- event);
+ std::visit(
+ overloaded{
+ [this](const mtx::events::RoomEvent<mtx::events::msg::KeyVerificationRequest> &msg) {
+ nhlog::db()->debug("handle_room_verification: Request");
+ emit startDMVerification(msg);
+ },
+ [](const mtx::events::RoomEvent<mtx::events::msg::KeyVerificationCancel> &msg) {
+ nhlog::db()->debug("handle_room_verification: Cancel");
+ ChatPage::instance()->receivedDeviceVerificationCancel(msg.content);
+ },
+ [](const mtx::events::RoomEvent<mtx::events::msg::KeyVerificationAccept> &msg) {
+ nhlog::db()->debug("handle_room_verification: Accept");
+ ChatPage::instance()->receivedDeviceVerificationAccept(msg.content);
+ },
+ [](const mtx::events::RoomEvent<mtx::events::msg::KeyVerificationKey> &msg) {
+ nhlog::db()->debug("handle_room_verification: Key");
+ ChatPage::instance()->receivedDeviceVerificationKey(msg.content);
+ },
+ [](const mtx::events::RoomEvent<mtx::events::msg::KeyVerificationMac> &msg) {
+ nhlog::db()->debug("handle_room_verification: Mac");
+ ChatPage::instance()->receivedDeviceVerificationMac(msg.content);
+ },
+ [](const mtx::events::RoomEvent<mtx::events::msg::KeyVerificationReady> &msg) {
+ nhlog::db()->debug("handle_room_verification: Ready");
+ ChatPage::instance()->receivedDeviceVerificationReady(msg.content);
+ },
+ [](const mtx::events::RoomEvent<mtx::events::msg::KeyVerificationDone> &msg) {
+ nhlog::db()->debug("handle_room_verification: Done");
+ ChatPage::instance()->receivedDeviceVerificationDone(msg.content);
+ },
+ [](const mtx::events::RoomEvent<mtx::events::msg::KeyVerificationStart> &msg) {
+ nhlog::db()->debug("handle_room_verification: Start");
+ ChatPage::instance()->receivedDeviceVerificationStart(msg.content, msg.sender);
+ },
+ [](const auto &) {},
+ },
+ event);
}
std::vector<mtx::events::collections::TimelineEvents>
EventStore::edits(const std::string &event_id)
{
- auto event_ids = cache::client()->relatedEvents(room_id_, event_id);
-
- auto original_event = get(event_id, "", false, false);
- if (!original_event)
- return {};
-
- auto original_sender = mtx::accessors::sender(*original_event);
- auto original_relations = mtx::accessors::relations(*original_event);
-
- std::vector<mtx::events::collections::TimelineEvents> edits;
- for (const auto &id : event_ids) {
- auto related_event = get(id, event_id, false, false);
- if (!related_event)
- continue;
-
- auto related_ev = *related_event;
-
- auto edit_rel = mtx::accessors::relations(related_ev);
- if (edit_rel.replaces() == event_id &&
- original_sender == mtx::accessors::sender(related_ev)) {
- if (edit_rel.synthesized && original_relations.reply_to() &&
- !edit_rel.reply_to()) {
- edit_rel.relations.push_back(
- {mtx::common::RelationType::InReplyTo,
- original_relations.reply_to().value()});
- mtx::accessors::set_relations(related_ev, std::move(edit_rel));
- }
- edits.push_back(std::move(related_ev));
- }
+ auto event_ids = cache::client()->relatedEvents(room_id_, event_id);
+
+ auto original_event = get(event_id, "", false, false);
+ if (!original_event)
+ return {};
+
+ auto original_sender = mtx::accessors::sender(*original_event);
+ auto original_relations = mtx::accessors::relations(*original_event);
+
+ std::vector<mtx::events::collections::TimelineEvents> edits;
+ for (const auto &id : event_ids) {
+ auto related_event = get(id, event_id, false, false);
+ if (!related_event)
+ continue;
+
+ auto related_ev = *related_event;
+
+ auto edit_rel = mtx::accessors::relations(related_ev);
+ if (edit_rel.replaces() == event_id &&
+ original_sender == mtx::accessors::sender(related_ev)) {
+ if (edit_rel.synthesized && original_relations.reply_to() && !edit_rel.reply_to()) {
+ edit_rel.relations.push_back(
+ {mtx::common::RelationType::InReplyTo, original_relations.reply_to().value()});
+ mtx::accessors::set_relations(related_ev, std::move(edit_rel));
+ }
+ edits.push_back(std::move(related_ev));
}
-
- auto c = cache::client();
- std::sort(edits.begin(),
- edits.end(),
- [this, c](const mtx::events::collections::TimelineEvents &a,
- const mtx::events::collections::TimelineEvents &b) {
- return c->getArrivalIndex(this->room_id_, mtx::accessors::event_id(a)) <
- c->getArrivalIndex(this->room_id_, mtx::accessors::event_id(b));
- });
-
- return edits;
+ }
+
+ auto c = cache::client();
+ std::sort(edits.begin(),
+ edits.end(),
+ [this, c](const mtx::events::collections::TimelineEvents &a,
+ const mtx::events::collections::TimelineEvents &b) {
+ return c->getArrivalIndex(this->room_id_, mtx::accessors::event_id(a)) <
+ c->getArrivalIndex(this->room_id_, mtx::accessors::event_id(b));
+ });
+
+ return edits;
}
QVariantList
EventStore::reactions(const std::string &event_id)
{
- auto event_ids = cache::client()->relatedEvents(room_id_, event_id);
-
- struct TempReaction
- {
- int count = 0;
- std::vector<std::string> users;
- std::string reactedBySelf;
- };
- std::map<std::string, TempReaction> aggregation;
- std::vector<Reaction> reactions;
-
- auto self = http::client()->user_id().to_string();
- for (const auto &id : event_ids) {
- auto related_event = get(id, event_id);
- if (!related_event)
- continue;
-
- if (auto reaction = std::get_if<mtx::events::RoomEvent<mtx::events::msg::Reaction>>(
- related_event);
- reaction && reaction->content.relations.annotates() &&
- reaction->content.relations.annotates()->key) {
- auto key = reaction->content.relations.annotates()->key.value();
- auto &agg = aggregation[key];
-
- if (agg.count == 0) {
- Reaction temp{};
- temp.key_ = QString::fromStdString(key);
- reactions.push_back(temp);
- }
-
- agg.count++;
- agg.users.push_back(cache::displayName(room_id_, reaction->sender));
- if (reaction->sender == self)
- agg.reactedBySelf = reaction->event_id;
- }
+ auto event_ids = cache::client()->relatedEvents(room_id_, event_id);
+
+ struct TempReaction
+ {
+ int count = 0;
+ std::vector<std::string> users;
+ std::string reactedBySelf;
+ };
+ std::map<std::string, TempReaction> aggregation;
+ std::vector<Reaction> reactions;
+
+ auto self = http::client()->user_id().to_string();
+ for (const auto &id : event_ids) {
+ auto related_event = get(id, event_id);
+ if (!related_event)
+ continue;
+
+ if (auto reaction =
+ std::get_if<mtx::events::RoomEvent<mtx::events::msg::Reaction>>(related_event);
+ reaction && reaction->content.relations.annotates() &&
+ reaction->content.relations.annotates()->key) {
+ auto key = reaction->content.relations.annotates()->key.value();
+ auto &agg = aggregation[key];
+
+ if (agg.count == 0) {
+ Reaction temp{};
+ temp.key_ = QString::fromStdString(key);
+ reactions.push_back(temp);
+ }
+
+ agg.count++;
+ agg.users.push_back(cache::displayName(room_id_, reaction->sender));
+ if (reaction->sender == self)
+ agg.reactedBySelf = reaction->event_id;
}
-
- QVariantList temp;
- for (auto &reaction : reactions) {
- const auto &agg = aggregation[reaction.key_.toStdString()];
- reaction.count_ = agg.count;
- reaction.selfReactedEvent_ = QString::fromStdString(agg.reactedBySelf);
-
- bool firstReaction = true;
- for (const auto &user : agg.users) {
- if (firstReaction)
- firstReaction = false;
- else
- reaction.users_ += ", ";
-
- reaction.users_ += QString::fromStdString(user);
- }
-
- nhlog::db()->debug("key: {}, count: {}, users: {}",
- reaction.key_.toStdString(),
- reaction.count_,
- reaction.users_.toStdString());
- temp.append(QVariant::fromValue(reaction));
+ }
+
+ QVariantList temp;
+ for (auto &reaction : reactions) {
+ const auto &agg = aggregation[reaction.key_.toStdString()];
+ reaction.count_ = agg.count;
+ reaction.selfReactedEvent_ = QString::fromStdString(agg.reactedBySelf);
+
+ bool firstReaction = true;
+ for (const auto &user : agg.users) {
+ if (firstReaction)
+ firstReaction = false;
+ else
+ reaction.users_ += ", ";
+
+ reaction.users_ += QString::fromStdString(user);
}
- return temp;
+ nhlog::db()->debug("key: {}, count: {}, users: {}",
+ reaction.key_.toStdString(),
+ reaction.count_,
+ reaction.users_.toStdString());
+ temp.append(QVariant::fromValue(reaction));
+ }
+
+ return temp;
}
mtx::events::collections::TimelineEvents *
EventStore::get(int idx, bool decrypt)
{
- if (this->thread() != QThread::currentThread())
- nhlog::db()->warn("{} called from a different thread!", __func__);
-
- Index index{room_id_, toInternalIdx(idx)};
- if (index.idx > last || index.idx < first)
- return nullptr;
-
- auto event_ptr = events_.object(index);
- if (!event_ptr) {
- auto event_id = cache::client()->getTimelineEventId(room_id_, index.idx);
- if (!event_id)
- return nullptr;
-
- std::optional<mtx::events::collections::TimelineEvent> event;
- auto edits_ = edits(*event_id);
- if (edits_.empty())
- event = cache::client()->getEvent(room_id_, *event_id);
- else
- event = {edits_.back()};
-
- if (!event)
- return nullptr;
- else
- event_ptr =
- new mtx::events::collections::TimelineEvents(std::move(event->data));
- events_.insert(index, event_ptr);
- }
+ if (this->thread() != QThread::currentThread())
+ nhlog::db()->warn("{} called from a different thread!", __func__);
+
+ Index index{room_id_, toInternalIdx(idx)};
+ if (index.idx > last || index.idx < first)
+ return nullptr;
+
+ auto event_ptr = events_.object(index);
+ if (!event_ptr) {
+ auto event_id = cache::client()->getTimelineEventId(room_id_, index.idx);
+ if (!event_id)
+ return nullptr;
+
+ std::optional<mtx::events::collections::TimelineEvent> event;
+ auto edits_ = edits(*event_id);
+ if (edits_.empty())
+ event = cache::client()->getEvent(room_id_, *event_id);
+ else
+ event = {edits_.back()};
- if (decrypt) {
- if (auto encrypted =
- std::get_if<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(
- event_ptr)) {
- auto decrypted = decryptEvent({room_id_, encrypted->event_id}, *encrypted);
- if (decrypted->event)
- return &*decrypted->event;
- }
+ if (!event)
+ return nullptr;
+ else
+ event_ptr = new mtx::events::collections::TimelineEvents(std::move(event->data));
+ events_.insert(index, event_ptr);
+ }
+
+ if (decrypt) {
+ if (auto encrypted =
+ std::get_if<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(event_ptr)) {
+ auto decrypted = decryptEvent({room_id_, encrypted->event_id}, *encrypted);
+ if (decrypted->event)
+ return &*decrypted->event;
}
+ }
- return event_ptr;
+ return event_ptr;
}
std::optional<int>
EventStore::idToIndex(std::string_view id) const
{
- if (this->thread() != QThread::currentThread())
- nhlog::db()->warn("{} called from a different thread!", __func__);
-
- auto idx = cache::client()->getTimelineIndex(room_id_, id);
- if (idx)
- return toExternalIdx(*idx);
- else
- return std::nullopt;
+ if (this->thread() != QThread::currentThread())
+ nhlog::db()->warn("{} called from a different thread!", __func__);
+
+ auto idx = cache::client()->getTimelineIndex(room_id_, id);
+ if (idx)
+ return toExternalIdx(*idx);
+ else
+ return std::nullopt;
}
std::optional<std::string>
EventStore::indexToId(int idx) const
{
- if (this->thread() != QThread::currentThread())
- nhlog::db()->warn("{} called from a different thread!", __func__);
+ if (this->thread() != QThread::currentThread())
+ nhlog::db()->warn("{} called from a different thread!", __func__);
- return cache::client()->getTimelineEventId(room_id_, toInternalIdx(idx));
+ return cache::client()->getTimelineEventId(room_id_, toInternalIdx(idx));
}
olm::DecryptionResult *
EventStore::decryptEvent(const IdIndex &idx,
const mtx::events::EncryptedEvent<mtx::events::msg::Encrypted> &e)
{
- if (auto cachedEvent = decryptedEvents_.object(idx))
- return cachedEvent;
-
- MegolmSessionIndex index(room_id_, e.content);
-
- auto asCacheEntry = [&idx](olm::DecryptionResult &&event) {
- auto event_ptr = new olm::DecryptionResult(std::move(event));
- decryptedEvents_.insert(idx, event_ptr);
- return event_ptr;
- };
-
- auto decryptionResult = olm::decryptEvent(index, e);
-
- if (decryptionResult.error) {
- switch (decryptionResult.error) {
- case olm::DecryptionErrorCode::MissingSession:
- case olm::DecryptionErrorCode::MissingSessionIndex: {
- nhlog::crypto()->info("Could not find inbound megolm session ({}, {}, {})",
- index.room_id,
- index.session_id,
- e.sender);
-
- requestSession(e, false);
- break;
- }
- case olm::DecryptionErrorCode::DbError:
- nhlog::db()->critical(
- "failed to retrieve megolm session with index ({}, {}, {})",
- index.room_id,
- index.session_id,
- index.sender_key,
- decryptionResult.error_message.value_or(""));
- break;
- case olm::DecryptionErrorCode::DecryptionFailed:
- nhlog::crypto()->critical(
- "failed to decrypt message with index ({}, {}, {}): {}",
- index.room_id,
- index.session_id,
- index.sender_key,
- decryptionResult.error_message.value_or(""));
- break;
- case olm::DecryptionErrorCode::ParsingFailed:
- break;
- case olm::DecryptionErrorCode::ReplayAttack:
- nhlog::crypto()->critical(
- "Reply attack while decryptiong event {} in room {} from {}!",
- e.event_id,
- room_id_,
- index.sender_key);
- break;
- case olm::DecryptionErrorCode::NoError:
- // unreachable
- break;
- }
- return asCacheEntry(std::move(decryptionResult));
- }
+ if (auto cachedEvent = decryptedEvents_.object(idx))
+ return cachedEvent;
+
+ MegolmSessionIndex index(room_id_, e.content);
+
+ auto asCacheEntry = [&idx](olm::DecryptionResult &&event) {
+ auto event_ptr = new olm::DecryptionResult(std::move(event));
+ decryptedEvents_.insert(idx, event_ptr);
+ return event_ptr;
+ };
- auto encInfo = mtx::accessors::file(decryptionResult.event.value());
- if (encInfo)
- emit newEncryptedImage(encInfo.value());
+ auto decryptionResult = olm::decryptEvent(index, e);
+ if (decryptionResult.error) {
+ switch (decryptionResult.error) {
+ case olm::DecryptionErrorCode::MissingSession:
+ case olm::DecryptionErrorCode::MissingSessionIndex: {
+ nhlog::crypto()->info("Could not find inbound megolm session ({}, {}, {})",
+ index.room_id,
+ index.session_id,
+ e.sender);
+
+ requestSession(e, false);
+ break;
+ }
+ case olm::DecryptionErrorCode::DbError:
+ nhlog::db()->critical("failed to retrieve megolm session with index ({}, {}, {})",
+ index.room_id,
+ index.session_id,
+ index.sender_key,
+ decryptionResult.error_message.value_or(""));
+ break;
+ case olm::DecryptionErrorCode::DecryptionFailed:
+ nhlog::crypto()->critical("failed to decrypt message with index ({}, {}, {}): {}",
+ index.room_id,
+ index.session_id,
+ index.sender_key,
+ decryptionResult.error_message.value_or(""));
+ break;
+ case olm::DecryptionErrorCode::ParsingFailed:
+ break;
+ case olm::DecryptionErrorCode::ReplayAttack:
+ nhlog::crypto()->critical("Reply attack while decryptiong event {} in room {} from {}!",
+ e.event_id,
+ room_id_,
+ index.sender_key);
+ break;
+ case olm::DecryptionErrorCode::NoError:
+ // unreachable
+ break;
+ }
return asCacheEntry(std::move(decryptionResult));
+ }
+
+ auto encInfo = mtx::accessors::file(decryptionResult.event.value());
+ if (encInfo)
+ emit newEncryptedImage(encInfo.value());
+
+ return asCacheEntry(std::move(decryptionResult));
}
void
EventStore::requestSession(const mtx::events::EncryptedEvent<mtx::events::msg::Encrypted> &ev,
bool manual)
{
- // we may not want to request keys during initial sync and such
- if (suppressKeyRequests)
- return;
-
- // TODO: Look in key backup
- auto copy = ev;
- copy.room_id = room_id_;
- if (pending_key_requests.count(ev.content.session_id)) {
- auto &r = pending_key_requests.at(ev.content.session_id);
- r.events.push_back(copy);
-
- // automatically request once every 10 min, manually every 1 min
- qint64 delay = manual ? 60 : (60 * 10);
- if (r.requested_at + delay < QDateTime::currentSecsSinceEpoch()) {
- r.requested_at = QDateTime::currentSecsSinceEpoch();
- olm::lookup_keybackup(room_id_, ev.content.session_id);
- olm::send_key_request_for(copy, r.request_id);
- }
- } else {
- PendingKeyRequests request;
- request.request_id = "key_request." + http::client()->generate_txn_id();
- request.requested_at = QDateTime::currentSecsSinceEpoch();
- request.events.push_back(copy);
- olm::lookup_keybackup(room_id_, ev.content.session_id);
- olm::send_key_request_for(copy, request.request_id);
- pending_key_requests[ev.content.session_id] = request;
+ // we may not want to request keys during initial sync and such
+ if (suppressKeyRequests)
+ return;
+
+ // TODO: Look in key backup
+ auto copy = ev;
+ copy.room_id = room_id_;
+ if (pending_key_requests.count(ev.content.session_id)) {
+ auto &r = pending_key_requests.at(ev.content.session_id);
+ r.events.push_back(copy);
+
+ // automatically request once every 10 min, manually every 1 min
+ qint64 delay = manual ? 60 : (60 * 10);
+ if (r.requested_at + delay < QDateTime::currentSecsSinceEpoch()) {
+ r.requested_at = QDateTime::currentSecsSinceEpoch();
+ olm::lookup_keybackup(room_id_, ev.content.session_id);
+ olm::send_key_request_for(copy, r.request_id);
}
+ } else {
+ PendingKeyRequests request;
+ request.request_id = "key_request." + http::client()->generate_txn_id();
+ request.requested_at = QDateTime::currentSecsSinceEpoch();
+ request.events.push_back(copy);
+ olm::lookup_keybackup(room_id_, ev.content.session_id);
+ olm::send_key_request_for(copy, request.request_id);
+ pending_key_requests[ev.content.session_id] = request;
+ }
}
void
EventStore::enableKeyRequests(bool suppressKeyRequests_)
{
- if (!suppressKeyRequests_) {
- for (const auto &key : decryptedEvents_.keys())
- if (key.room == this->room_id_)
- decryptedEvents_.remove(key);
- suppressKeyRequests = false;
- } else
- suppressKeyRequests = true;
+ if (!suppressKeyRequests_) {
+ for (const auto &key : decryptedEvents_.keys())
+ if (key.room == this->room_id_)
+ decryptedEvents_.remove(key);
+ suppressKeyRequests = false;
+ } else
+ suppressKeyRequests = true;
}
mtx::events::collections::TimelineEvents *
EventStore::get(std::string id, std::string_view related_to, bool decrypt, bool resolve_edits)
{
- if (this->thread() != QThread::currentThread())
- nhlog::db()->warn("{} called from a different thread!", __func__);
-
- if (id.empty())
- return nullptr;
-
- IdIndex index{room_id_, std::move(id)};
- if (resolve_edits) {
- auto edits_ = edits(index.id);
- if (!edits_.empty()) {
- index.id = mtx::accessors::event_id(edits_.back());
- auto event_ptr =
- new mtx::events::collections::TimelineEvents(std::move(edits_.back()));
- events_by_id_.insert(index, event_ptr);
- }
- }
+ if (this->thread() != QThread::currentThread())
+ nhlog::db()->warn("{} called from a different thread!", __func__);
- auto event_ptr = events_by_id_.object(index);
- if (!event_ptr) {
- auto event = cache::client()->getEvent(room_id_, index.id);
- if (!event) {
- http::client()->get_event(
- room_id_,
- index.id,
- [this, relatedTo = std::string(related_to), 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));
- events_by_id_.insert(index, event_ptr);
+ if (id.empty())
+ return nullptr;
+
+ IdIndex index{room_id_, std::move(id)};
+ if (resolve_edits) {
+ auto edits_ = edits(index.id);
+ if (!edits_.empty()) {
+ index.id = mtx::accessors::event_id(edits_.back());
+ auto event_ptr = new mtx::events::collections::TimelineEvents(std::move(edits_.back()));
+ events_by_id_.insert(index, event_ptr);
}
+ }
+
+ auto event_ptr = events_by_id_.object(index);
+ if (!event_ptr) {
+ auto event = cache::client()->getEvent(room_id_, index.id);
+ if (!event) {
+ http::client()->get_event(room_id_,
+ index.id,
+ [this, relatedTo = std::string(related_to), 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));
+ events_by_id_.insert(index, event_ptr);
+ }
- if (decrypt) {
- if (auto encrypted =
- std::get_if<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(
- event_ptr)) {
- auto decrypted = decryptEvent(index, *encrypted);
- if (decrypted->event)
- return &*decrypted->event;
- }
+ if (decrypt) {
+ if (auto encrypted =
+ std::get_if<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(event_ptr)) {
+ auto decrypted = decryptEvent(index, *encrypted);
+ if (decrypted->event)
+ return &*decrypted->event;
}
+ }
- return event_ptr;
+ return event_ptr;
}
olm::DecryptionErrorCode
EventStore::decryptionError(std::string id)
{
- if (this->thread() != QThread::currentThread())
- nhlog::db()->warn("{} called from a different thread!", __func__);
+ if (this->thread() != QThread::currentThread())
+ nhlog::db()->warn("{} called from a different thread!", __func__);
- if (id.empty())
- return olm::DecryptionErrorCode::NoError;
-
- IdIndex index{room_id_, std::move(id)};
- auto edits_ = edits(index.id);
- if (!edits_.empty()) {
- index.id = mtx::accessors::event_id(edits_.back());
- auto event_ptr =
- new mtx::events::collections::TimelineEvents(std::move(edits_.back()));
- events_by_id_.insert(index, event_ptr);
- }
+ if (id.empty())
+ return olm::DecryptionErrorCode::NoError;
- auto event_ptr = events_by_id_.object(index);
- if (!event_ptr) {
- auto event = cache::client()->getEvent(room_id_, index.id);
- if (!event) {
- return olm::DecryptionErrorCode::NoError;
- }
- event_ptr = new mtx::events::collections::TimelineEvents(std::move(event->data));
- events_by_id_.insert(index, event_ptr);
+ IdIndex index{room_id_, std::move(id)};
+ auto edits_ = edits(index.id);
+ if (!edits_.empty()) {
+ index.id = mtx::accessors::event_id(edits_.back());
+ auto event_ptr = new mtx::events::collections::TimelineEvents(std::move(edits_.back()));
+ events_by_id_.insert(index, event_ptr);
+ }
+
+ auto event_ptr = events_by_id_.object(index);
+ if (!event_ptr) {
+ auto event = cache::client()->getEvent(room_id_, index.id);
+ if (!event) {
+ return olm::DecryptionErrorCode::NoError;
}
+ event_ptr = new mtx::events::collections::TimelineEvents(std::move(event->data));
+ events_by_id_.insert(index, event_ptr);
+ }
- if (auto encrypted =
- std::get_if<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(event_ptr)) {
- auto decrypted = decryptEvent(index, *encrypted);
- return decrypted->error;
- }
+ if (auto encrypted =
+ std::get_if<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(event_ptr)) {
+ auto decrypted = decryptEvent(index, *encrypted);
+ return decrypted->error;
+ }
- return olm::DecryptionErrorCode::NoError;
+ return olm::DecryptionErrorCode::NoError;
}
void
EventStore::fetchMore()
{
- if (noMoreMessages)
- return;
-
- mtx::http::MessagesOpts opts;
- opts.room_id = room_id_;
- opts.from = cache::client()->previousBatchToken(room_id_);
-
- nhlog::ui()->debug("Paginating room {}, token {}", opts.room_id, opts.from);
-
- http::client()->messages(
- opts, [this, opts](const mtx::responses::Messages &res, mtx::http::RequestErr err) {
- if (cache::client()->previousBatchToken(room_id_) != opts.from) {
- nhlog::net()->warn("Cache cleared while fetching more messages, dropping "
- "/messages response");
- if (!opts.to.empty())
- emit fetchedMore();
- return;
- }
- if (err) {
- nhlog::net()->error("failed to call /messages ({}): {} - {} - {}",
- opts.room_id,
- mtx::errors::to_string(err->matrix_error.errcode),
- err->matrix_error.error,
- err->parse_error);
- emit fetchedMore();
- return;
- }
-
- emit oldMessagesRetrieved(std::move(res));
- });
+ if (noMoreMessages)
+ return;
+
+ mtx::http::MessagesOpts opts;
+ opts.room_id = room_id_;
+ opts.from = cache::client()->previousBatchToken(room_id_);
+
+ nhlog::ui()->debug("Paginating room {}, token {}", opts.room_id, opts.from);
+
+ http::client()->messages(
+ opts, [this, opts](const mtx::responses::Messages &res, mtx::http::RequestErr err) {
+ if (cache::client()->previousBatchToken(room_id_) != opts.from) {
+ nhlog::net()->warn("Cache cleared while fetching more messages, dropping "
+ "/messages response");
+ if (!opts.to.empty())
+ emit fetchedMore();
+ return;
+ }
+ if (err) {
+ nhlog::net()->error("failed to call /messages ({}): {} - {} - {}",
+ opts.room_id,
+ mtx::errors::to_string(err->matrix_error.errcode),
+ err->matrix_error.error,
+ err->parse_error);
+ emit fetchedMore();
+ return;
+ }
+
+ emit oldMessagesRetrieved(std::move(res));
+ });
}
|
