No OneTemporary
Actions

Size

25 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/client/room/room-model.cpp b/src/client/room/room-model.cpp
	index 659052a..a3fa232 100644
	--- a/src/client/room/room-model.cpp
	+++ b/src/client/room/room-model.cpp
	@@ -1,313 +1,339 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2020 Tusooa Zhu
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

	#include <libkazv-config.hpp>


	#include <lager/util.hpp>
	#include <zug/sequence.hpp>
	#include <zug/transducer/map.hpp>
	#include <zug/transducer/filter.hpp>

	#include "debug.hpp"

	#include "room-model.hpp"
	#include "cursorutil.hpp"


	namespace Kazv
	{
	RoomModel RoomModel::update(RoomModel r, Action a)
	{
	return lager::match(std::move(a))(
	[&](AddStateEventsAction a) {
	r.stateEvents = merge(std::move(r.stateEvents), a.stateEvents, keyOfState);

	// If m.room.encryption state event appears,
	// configure the room to use encryption.
	if (r.stateEvents.find(KeyOfState{"m.room.encryption", ""})) {
	auto newRoom = update(std::move(r), SetRoomEncryptionAction{});
	r = std::move(newRoom);
	}
	return r;
	},
	[&](AppendTimelineAction a) {
	auto eventIds = intoImmer(immer::flex_vector<std::string>(),
	zug::map(keyOfTimeline), a.events);
	r.timeline = r.timeline + eventIds;
	r.messages = merge(std::move(r.messages), a.events, keyOfTimeline);
	return r;
	},
	[&](PrependTimelineAction a) {
	auto eventIds = intoImmer(immer::flex_vector<std::string>(),
	zug::map(keyOfTimeline), a.events);
	r.timeline = eventIds + r.timeline;
	r.messages = merge(std::move(r.messages), a.events, keyOfTimeline);
	r.paginateBackToken = a.paginateBackToken;
	// if there are no more events we should not allow further paginating
	r.canPaginateBack = a.events.size() != 0;
	return r;
	},
	[&](AddToTimelineAction a) {
	auto eventIds = intoImmer(immer::flex_vector<std::string>(),
	zug::map(keyOfTimeline), a.events);

	auto oldMessages = r.messages;
	r.messages = merge(std::move(r.messages), a.events, keyOfTimeline);
	auto exists =
	[=](auto eventId) -> bool {
	return !! oldMessages.find(eventId);
	};
	auto key =
	[=](auto eventId) {
	// sort first by timestamp, then by id
	return std::make_tuple(r.messages[eventId].originServerTs(), eventId);
	};

	auto handleRedaction =
	[&r](const auto &event) {
	if (event.type() == "m.room.redaction") {
	auto origJson = event.originalJson().get();
	if (origJson.contains("redacts") && origJson.at("redacts").is_string()) {
	auto redactedEventId = origJson.at("redacts").template get<std::string>();
	if (r.messages.find(redactedEventId)) {
	r.messages = std::move(r.messages).update(redactedEventId, [&origJson](const auto &eventToBeRedacted) {
	auto newJson = eventToBeRedacted.originalJson().get();
	newJson.merge_patch(json{
	{"unsigned", {{"redacted_because", std::move(origJson)}}},
	});
	newJson["content"] = json::object();
	return Event(newJson);
	});
	}
	}
	}
	return event;
	};

	immer::for_each(a.events, handleRedaction);

	r.timeline = sortedUniqueMerge(r.timeline, eventIds, exists, key);

	// TODO need other way to determine whether it is limited
	// in a pagination request (/messages does not have that field)
	if ((! a.limited.has_value() \|\| a.limited.value())
	&& a.prevBatch.has_value()) {
	// this sync is limited, add a Gap here
	if (!eventIds.empty()) {
	r.timelineGaps = std::move(r.timelineGaps).set(eventIds[0], a.prevBatch.value());
	}
	}

	// remove the original Gap, as it is resolved
	if (a.gapEventId.has_value()) {
	r.timelineGaps = std::move(r.timelineGaps).erase(a.gapEventId.value());
	}

	// remove all Gaps between the gapped event and the first event in this batch
	if (!eventIds.empty() && a.gapEventId.has_value()) {
	auto cmp = [=](auto a, auto b) {
	return key(a) < key(b);
	};
	auto thisBatchStart = std::equal_range(r.timeline.begin(), r.timeline.end(), eventIds[0], cmp).first;
	auto origBatchStart = std::equal_range(thisBatchStart, r.timeline.end(), a.gapEventId.value(), cmp).first;

	std::for_each(thisBatchStart + 1, origBatchStart,
	[&](auto eventId) {
	r.timelineGaps = std::move(r.timelineGaps).erase(eventId);
	});
	}

	// remove all local echoes that are received
	for (const auto &e : a.events) {
	const auto &json = e.originalJson().get();
	if (json.contains("unsigned")
	&& json["unsigned"].contains("transaction_id")
	&& json["unsigned"]["transaction_id"].is_string()) {
	r = update(std::move(r), RemoveLocalEchoAction{json["unsigned"]["transaction_id"].template get<std::string>()});
	}
	}

	return r;
	},
	[&](AddAccountDataAction a) {
	r.accountData = merge(std::move(r.accountData), a.events, keyOfAccountData);
	return r;
	},
	[&](ChangeMembershipAction a) {
	r.membership = a.membership;
	return r;
	},
	[&](ChangeInviteStateAction a) {
	r.inviteState = merge(immer::map<KeyOfState, Event>{}, a.events, keyOfState);
	return r;
	},
	[&](AddEphemeralAction a) {
	r.ephemeral = merge(std::move(r.ephemeral), a.events, keyOfEphemeral);
	return r;
	},
	[&](SetLocalDraftAction a) {
	r.localDraft = a.localDraft;
	return r;
	},
	[&](SetRoomEncryptionAction) {
	r.encrypted = true;
	return r;
	},
	[&](MarkMembersFullyLoadedAction) {
	r.membersFullyLoaded = true;
	return r;
	},
	[&](SetHeroIdsAction a) {
	r.heroIds = a.heroIds;
	return r;
	},
	[&](AddLocalEchoAction a) {
	auto it = std::find_if(r.localEchoes.begin(), r.localEchoes.end(), [a](const auto &desc) {
	return desc.txnId == a.localEcho.txnId;
	});
	if (it == r.localEchoes.end()) {
	r.localEchoes = std::move(r.localEchoes).push_back(a.localEcho);
	} else {
	r.localEchoes = std::move(r.localEchoes).set(it.index(), a.localEcho);
	}
	return r;
	},
	[&](RemoveLocalEchoAction a) {
	auto it = std::find_if(r.localEchoes.begin(), r.localEchoes.end(), [a](const auto &desc) {
	return desc.txnId == a.txnId;
	});
	if (it != r.localEchoes.end()) {
	r.localEchoes = std::move(r.localEchoes).erase(it.index());
	}
	return r;
	},
	[&](AddPendingRoomKeyAction a) {
	auto it = std::find_if(r.pendingRoomKeyEvents.begin(), r.pendingRoomKeyEvents.end(), [a](const auto &p) {
	return p.txnId == a.pendingRoomKeyEvent.txnId;
	});
	if (it == r.pendingRoomKeyEvents.end()) {
	r.pendingRoomKeyEvents = std::move(r.pendingRoomKeyEvents).push_back(a.pendingRoomKeyEvent);
	} else {
	r.pendingRoomKeyEvents = std::move(r.pendingRoomKeyEvents).set(it.index(), a.pendingRoomKeyEvent);
	}
	return r;
	},
	[&](RemovePendingRoomKeyAction a) {
	auto it = std::find_if(r.pendingRoomKeyEvents.begin(), r.pendingRoomKeyEvents.end(), [a](const auto &desc) {
	return desc.txnId == a.txnId;
	});
	if (it != r.pendingRoomKeyEvents.end()) {
	r.pendingRoomKeyEvents = std::move(r.pendingRoomKeyEvents).erase(it.index());
	}
	return r;
	}
	);
	}

	RoomListModel RoomListModel::update(RoomListModel l, Action a)
	{
	return lager::match(std::move(a))(
	[&](UpdateRoomAction a) {
	l.rooms = std::move(l.rooms)
	.update(a.roomId,
	[=](RoomModel oldRoom) {
	oldRoom.roomId = a.roomId; // in case it is a new room
	return RoomModel::update(std::move(oldRoom), a.roomAction);
	});
	return l;
	}
	);
	}

	immer::flex_vector<std::string> RoomModel::joinedMemberIds() const
	{
	using MemberNode = std::pair<std::string, Kazv::Event>;

	auto memberNameTransducer =
	zug::filter(
	[](auto val) {
	auto [k, v] = val;
	auto [type, stateKey] = k;
	return type == "m.room.member"s;
	})
	\| zug::map(
	[](auto val) {
	auto [k, v] = val;
	auto [type, stateKey] = k;
	return MemberNode{stateKey, v};
	})
	\| zug::filter(
	[](auto val) {
	auto [stateKey, ev] = val;
	return ev.content().get()
	.at("membership"s) == "join"s;
	})
	\| zug::map(
	[](auto val) {
	auto [stateKey, ev] = val;
	return stateKey;
	});

	return intoImmer(
	immer::flex_vector<std::string>{},
	memberNameTransducer,
	stateEvents);
	}

	static Timestamp defaultRotateMs = 604800000;
	static int defaultRotateMsgs = 100;

	MegOlmSessionRotateDesc RoomModel::sessionRotateDesc() const
	{
	auto k = KeyOfState{"m.room.encryption", ""};
	auto content = stateEvents[k].content().get();
	auto ms = content.contains("rotation_period_ms")
	? content["rotation_period_ms"].get<Timestamp>()
	: defaultRotateMs;
	auto msgs = content.contains("rotation_period_msgs")
	? content["rotation_period_msgs"].get<int>()
	: defaultRotateMsgs;
	return MegOlmSessionRotateDesc{ ms, msgs };
	}

	bool RoomModel::hasUser(std::string userId) const
	{
	try {
	auto ev = stateEvents.at(KeyOfState{"m.room.member", userId});
	if (ev.content().get().at("membership") == "join") {
	return true;
	}
	} catch (const std::exception &) {
	return false;
	}
	return false;
	}

	std::optional<LocalEchoDesc> RoomModel::getLocalEchoByTxnId(std::string txnId) const
	{
	auto it = std::find_if(localEchoes.begin(), localEchoes.end(), [txnId](const auto &desc) {
	return txnId == desc.txnId;
	});
	if (it != localEchoes.end()) {
	return *it;
	} else {
	return std::nullopt;
	}
	}

	std::optional<PendingRoomKeyEvent> RoomModel::getPendingRoomKeyEventByTxnId(std::string txnId) const
	{
	auto it = std::find_if(pendingRoomKeyEvents.begin(), pendingRoomKeyEvents.end(), [txnId](const auto &desc) {
	return txnId == desc.txnId;
	});
	if (it != pendingRoomKeyEvents.end()) {
	return *it;
	} else {
	return std::nullopt;
	}
	}
	+
	+ static double getTagOrder(const json &tag)
	+ {
	+ // https://spec.matrix.org/v1.7/client-server-api/#events-12
	+ // If a room has a tag without an order key then it should appear after the rooms with that tag that have an order key.
	+ return tag.contains("order") && tag["order"].is_number()
	+ ? tag["order"].template get<double>()
	+ : 2;
	+ }
	+
	+ immer::map<std::string, double> RoomModel::tags() const
	+ {
	+ auto content = accountData["m.tag"].content().get();
	+ if (!content.contains("tags") \|\| !content["tags"].is_object()) {
	+ return {};
	+ }
	+
	+ auto tagsObject = content["tags"];
	+ auto tagsItems = tagsObject.items();
	+ return std::accumulate(tagsItems.begin(), tagsItems.end(), immer::map<std::string, double>(),
	+ [=](auto acc, const auto &cur) {
	+ auto [id, tag] = cur;
	+ return std::move(acc).set(id, getTagOrder(tag));
	+ }
	+ );
	+ }
	}
	diff --git a/src/client/room/room-model.hpp b/src/client/room/room-model.hpp
	index f68d961..d85e69a 100644
	--- a/src/client/room/room-model.hpp
	+++ b/src/client/room/room-model.hpp
	@@ -1,304 +1,306 @@
	/*
	* This file is part of libkazv.
	- * SPDX-FileCopyrightText: 2021 Tusooa Zhu <tusooa@kazv.moe>
	+ * SPDX-FileCopyrightText: 2021-2023 tusooa <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/


	#pragma once
	#include <libkazv-config.hpp>

	#include <string>
	#include <variant>
	#include <immer/flex_vector.hpp>
	#include <immer/map.hpp>

	#include <serialization/immer-flex-vector.hpp>
	#include <serialization/immer-box.hpp>
	#include <serialization/immer-map.hpp>
	#include <serialization/immer-array.hpp>

	#include <csapi/sync.hpp>
	#include <event.hpp>

	#include <crypto.hpp>

	#include "local-echo.hpp"
	#include "clientutil.hpp"

	namespace Kazv
	{
	struct PendingRoomKeyEvent
	{
	std::string txnId;
	Event event;
	immer::map<std::string, immer::flex_vector<std::string>> devices;
	};

	struct AddStateEventsAction
	{
	immer::flex_vector<Event> stateEvents;
	};

	struct AppendTimelineAction
	{
	immer::flex_vector<Event> events;
	};

	struct PrependTimelineAction
	{
	immer::flex_vector<Event> events;
	std::string paginateBackToken;
	};

	struct AddToTimelineAction
	{
	/// Events from oldest to latest
	immer::flex_vector<Event> events;
	std::optional<std::string> prevBatch;
	std::optional<bool> limited;
	std::optional<std::string> gapEventId;
	};

	struct AddAccountDataAction
	{
	immer::flex_vector<Event> events;
	};

	struct ChangeMembershipAction
	{
	RoomMembership membership;
	};

	struct ChangeInviteStateAction
	{
	immer::flex_vector<Event> events;
	};

	struct AddEphemeralAction
	{
	EventList events;
	};

	struct SetLocalDraftAction
	{
	std::string localDraft;
	};

	struct SetRoomEncryptionAction
	{
	};

	struct MarkMembersFullyLoadedAction
	{
	};

	struct SetHeroIdsAction
	{
	immer::flex_vector<std::string> heroIds;
	};

	struct AddLocalEchoAction
	{
	LocalEchoDesc localEcho;
	};

	struct RemoveLocalEchoAction
	{
	std::string txnId;
	};

	struct AddPendingRoomKeyAction
	{
	PendingRoomKeyEvent pendingRoomKeyEvent;
	};

	struct RemovePendingRoomKeyAction
	{
	std::string txnId;
	};

	inline bool operator==(const PendingRoomKeyEvent &a, const PendingRoomKeyEvent &b)
	{
	return a.txnId == b.txnId && a.event == b.event && a.devices == b.devices;
	}

	inline bool operator!=(const PendingRoomKeyEvent &a, const PendingRoomKeyEvent &b)
	{
	return !(a == b);
	}

	template<class Archive>
	void serialize(Archive &ar, PendingRoomKeyEvent &e, std::uint32_t const version)
	{
	ar & e.txnId & e.event & e.devices;
	}

	struct RoomModel
	{
	using Membership = RoomMembership;

	std::string roomId;
	immer::map<KeyOfState, Event> stateEvents;
	immer::map<KeyOfState, Event> inviteState;
	// Smaller indices mean earlier events
	// (oldest) 0 --------> n (latest)
	immer::flex_vector<std::string> timeline;
	immer::map<std::string, Event> messages;
	immer::map<std::string, Event> accountData;
	Membership membership{};
	std::string paginateBackToken;
	/// whether this room has earlier events to be fetched
	bool canPaginateBack{true};

	immer::map<std::string /* eventId /, std::string / prevBatch */> timelineGaps;

	immer::map<std::string, Event> ephemeral;

	std::string localDraft;

	bool encrypted{false};
	/// a marker to indicate whether we need to rotate
	/// the session key earlier than it expires
	/// (e.g. when a user in the room's device list changed
	/// or when someone joins or leaves)
	bool shouldRotateSessionKey{true};

	bool membersFullyLoaded{false};
	immer::flex_vector<std::string> heroIds;

	immer::flex_vector<LocalEchoDesc> localEchoes;

	immer::flex_vector<PendingRoomKeyEvent> pendingRoomKeyEvents;

	immer::flex_vector<std::string> joinedMemberIds() const;

	MegOlmSessionRotateDesc sessionRotateDesc() const;

	bool hasUser(std::string userId) const;

	std::optional<LocalEchoDesc> getLocalEchoByTxnId(std::string txnId) const;
	std::optional<PendingRoomKeyEvent> getPendingRoomKeyEventByTxnId(std::string txnId) const;

	+ immer::map<std::string, double> tags() const;
	+
	using Action = std::variant<
	AddStateEventsAction,
	AppendTimelineAction,
	PrependTimelineAction,
	AddToTimelineAction,
	AddAccountDataAction,
	ChangeMembershipAction,
	ChangeInviteStateAction,
	AddEphemeralAction,
	SetLocalDraftAction,
	SetRoomEncryptionAction,
	MarkMembersFullyLoadedAction,
	SetHeroIdsAction,
	AddLocalEchoAction,
	RemoveLocalEchoAction,
	AddPendingRoomKeyAction,
	RemovePendingRoomKeyAction
	>;

	static RoomModel update(RoomModel r, Action a);
	};

	using RoomAction = RoomModel::Action;

	inline bool operator==(RoomModel a, RoomModel b)
	{
	return a.roomId == b.roomId
	&& a.stateEvents == b.stateEvents
	&& a.inviteState == b.inviteState
	&& a.timeline == b.timeline
	&& a.messages == b.messages
	&& a.accountData == b.accountData
	&& a.membership == b.membership
	&& a.paginateBackToken == b.paginateBackToken
	&& a.canPaginateBack == b.canPaginateBack
	&& a.timelineGaps == b.timelineGaps
	&& a.ephemeral == b.ephemeral
	&& a.localDraft == b.localDraft
	&& a.encrypted == b.encrypted
	&& a.shouldRotateSessionKey == b.shouldRotateSessionKey
	&& a.membersFullyLoaded == b.membersFullyLoaded
	&& a.heroIds == b.heroIds
	&& a.localEchoes == b.localEchoes
	&& a.pendingRoomKeyEvents == b.pendingRoomKeyEvents;
	}

	struct UpdateRoomAction
	{
	std::string roomId;
	RoomAction roomAction;
	};

	struct RoomListModel
	{
	immer::map<std::string, RoomModel> rooms;

	inline auto at(std::string id) const { return rooms.at(id); }
	inline auto operator[](std::string id) const { return rooms[id]; }
	inline bool has(std::string id) const { return rooms.find(id); }

	using Action = std::variant<
	UpdateRoomAction
	>;
	static RoomListModel update(RoomListModel l, Action a);
	};

	using RoomListAction = RoomListModel::Action;

	inline bool operator==(RoomListModel a, RoomListModel b)
	{
	return a.rooms == b.rooms;
	}

	template<class Archive>
	void serialize(Archive &ar, RoomModel &r, std::uint32_t const version)
	{
	ar
	& r.roomId
	& r.stateEvents
	& r.inviteState

	& r.timeline
	& r.messages
	& r.accountData
	& r.membership
	& r.paginateBackToken
	& r.canPaginateBack

	& r.timelineGaps
	& r.ephemeral

	& r.localDraft

	& r.encrypted
	& r.shouldRotateSessionKey

	& r.membersFullyLoaded
	;

	if (version >= 1) {
	ar
	& r.heroIds
	;
	}
	if (version >= 2) {
	ar & r.localEchoes;
	}
	if (version >= 3) {
	ar & r.pendingRoomKeyEvents;
	}
	}

	template<class Archive>
	void serialize(Archive &ar, RoomListModel &l, std::uint32_t const /version/)
	{
	ar & l.rooms;
	}
	}

	BOOST_CLASS_VERSION(Kazv::PendingRoomKeyEvent, 0)
	BOOST_CLASS_VERSION(Kazv::RoomModel, 3)
	BOOST_CLASS_VERSION(Kazv::RoomListModel, 0)
	diff --git a/src/tests/client/tagging-test.cpp b/src/tests/client/tagging-test.cpp
	index beaa307..3138d94 100644
	--- a/src/tests/client/tagging-test.cpp
	+++ b/src/tests/client/tagging-test.cpp
	@@ -1,50 +1,100 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2020-2023 tusooa <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

	#include <libkazv-config.hpp>

	#include <catch2/catch_test_macros.hpp>

	#include <boost/asio.hpp>
	#include <asio-promise-handler.hpp>

	#include <sdk.hpp>

	#include "client-test-util.hpp"

	using namespace Kazv;

	-json mDirectEvent = R"({
	+static json mDirectEvent = R"({
	"content": {
	"@foo:example.com": ["!foo:tusooa.xyz"],
	"@bar:example.com": ["!bar:tusooa.xyz", "!bar2:tusooa.xyz"],
	"@somethingelse": "xxx"
	}
	})"_json;

	+static json mTag = R"({
	+ "content": {
	+ "tags": {
	+ "u.work": {
	+ "order": 0.9
	+ },
	+ "m.favourite": {
	+ "order": 0.5
	+ }
	+ }
	+ }
	+})"_json;
	+
	+static json mTag2 = R"({
	+ "content": {
	+ "tags": {
	+ "m.favourite": {
	+ "order": 0.6
	+ },
	+ "u.something": {}
	+ }
	+ }
	+})"_json;
	+
	TEST_CASE("ClientModel::directRoomMap", "[client][tagging]")
	{
	boost::asio::io_context io;
	AsioPromiseHandler ph{io.get_executor()};

	ClientModel m = createTestClientModel();
	m.accountData = m.accountData.set("m.direct", Event(mDirectEvent));

	auto store = createTestClientStoreFrom(m, ph);

	auto expected = immer::map<std::string, std::string>{
	{"!foo:tusooa.xyz", "@foo:example.com"},
	{"!bar:tusooa.xyz", "@bar:example.com"},
	{"!bar2:tusooa.xyz", "@bar:example.com"},
	};

	REQUIRE(m.directRoomMap() == expected);

	auto client = Client(store.reader().map([](auto c) { return SdkModel{c}; }), store,
	std::nullopt);

	REQUIRE(client.directRoomMap().make().get() == expected);
	}
	+
	+TEST_CASE("RoomModel::tags", "[client][tagging]")
	+{
	+ RoomModel r;
	+ REQUIRE(r.tags() == immer::map<std::string, double>{});
	+
	+ r.accountData = r.accountData.set("m.tag", Event(mTag));
	+
	+ immer::map<std::string, double> expected{
	+ {"u.work", 0.9},
	+ {"m.favourite", 0.5}
	+ };
	+ REQUIRE(r.tags() == expected);
	+}
	+
	+TEST_CASE("RoomModel::tags: without order", "[client][tagging]")
	+{
	+ RoomModel r;
	+ r.accountData = r.accountData.set("m.tag", Event(mTag2));
	+
	+ immer::map<std::string, double> expected{
	+ {"u.something", 2},
	+ {"m.favourite", 0.6}
	+ };
	+ REQUIRE(r.tags() == expected);
	+}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Jan 22, 1:20 AM (1 d, 14 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 55780
Default Alt Text: (25 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions