No OneTemporary
Actions

Size

28 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/client/actions/auth.cpp b/src/client/actions/auth.cpp
	index 28ef194..7020800 100644
	--- a/src/client/actions/auth.cpp
	+++ b/src/client/actions/auth.cpp
	@@ -1,157 +1,158 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2020-2022 Tusooa Zhu <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

	#include <libkazv-config.hpp>

	#include <debug.hpp>
	#include <jobinterface.hpp>
	#include <eventinterface.hpp>

	#include "auth.hpp"
	#include "status-utils.hpp"

	namespace Kazv
	{
	ClientResult updateClient(ClientModel m, LoginAction a)
	{
	m.addJob(LoginJob{a.serverUrl,
	"m.login.password"s, // type
	UserIdentifier{ "m.id.user"s, json{{"user", a.username}} }, // identifier
	a.password,
	{}, // token, not used
	{}, // device id, not used
	a.deviceName.value_or("libkazv")}
	.withData(json{
	{"serverUrl", a.serverUrl},
	}));
	return { m, lager::noop };
	}

	ClientResult processResponse(ClientModel m, LoginResponse r)
	{
	if (! r.success()) {
	m.addTrigger(LoginFailed{r.errorCode(), r.errorMessage()});
	return { std::move(m), failWithResponse(r) };
	}

	kzo.client.dbg() << "Job success" << std::endl;
	- const json &j = r.jsonBody().get();
	+ auto jw = r.jsonBody();
	+ auto const &j = jw.get();
	// TODO: replace this with r.wellKnown()
	std::string serverUrl = j.contains("well_known")
	? j.at("well_known").at("m.homeserver").at("base_url").get<std::string>()
	: r.dataStr("serverUrl");

	// Synapse will return the server url with trailing slash
	// and not recognize double slashes in the middle
	while (serverUrl.back() == '/') {
	serverUrl.pop_back();
	}

	m.serverUrl = serverUrl;
	m.userId = r.userId().value_or(DEFVAL);
	m.token = r.accessToken().value_or(DEFVAL);
	m.deviceId = r.deviceId().value_or(DEFVAL);
	m.loggedIn = true;

	m.addTrigger(LoginSuccessful{});

	return { std::move(m), lager::noop };
	}

	ClientResult updateClient(ClientModel m, TokenLoginAction a)
	{
	m.serverUrl = a.serverUrl;
	m.userId = a.username;
	m.token = a.token;
	m.deviceId = a.deviceId;
	m.loggedIn = true;

	m.addTrigger(LoginSuccessful{});
	return { std::move(m), lager::noop };
	}


	ClientResult updateClient(ClientModel m, LogoutAction)
	{
	// Note: this only performs a soft-logout.
	m.serverUrl = "";
	m.userId = "";
	m.token = "";
	m.deviceId = "";
	m.loggedIn = false;

	return { std::move(m), lager::noop };
	}

	ClientResult updateClient(ClientModel m, GetWellknownAction a)
	{
	auto pos = a.userId.find(':');
	if (pos == std::string::npos \|\| pos == a.userId.size() - 1) {
	return { std::move(m), simpleFail };
	}

	auto serverUrl = "https://" + a.userId.substr(pos + 1);

	m.addJob(GetWellknownJob{serverUrl}
	.withData(json{{"serverUrl", serverUrl}}));
	return { m, lager::noop };
	}

	ClientResult processResponse(ClientModel m, GetWellknownResponse r)
	{
	auto success = r.success() \|\| r.statusCode == 404;
	auto error = std::string();

	std::string serverUrl = r.dataStr("serverUrl");

	if (r.success()) {
	auto data = r.data();
	if (data.homeserver.baseUrl.empty()) {
	success = false;
	error = "FAIL_PROMPT";
	} else {
	serverUrl = data.homeserver.baseUrl;
	}
	} else {
	error = "FAIL_PROMPT";
	}

	return {
	std::move(m),
	[success, serverUrl, error, r](auto &&) {
	auto data = json{
	{"homeserverUrl", serverUrl},
	{"error", error},
	{"errorCode", r.errorCode()},
	};
	return EffectStatus(success, data);
	}
	};
	}

	ClientResult updateClient(ClientModel m, GetVersionsAction a)
	{
	m.addJob(GetVersionsJob{a.serverUrl});
	return { std::move(m), lager::noop };
	}

	ClientResult processResponse(ClientModel m, GetVersionsResponse r)
	{
	return {
	std::move(m),
	[r](auto &&ctx) {
	if (r.success()) {
	return EffectStatus(r.success(), json{
	{"versions", r.versions()},
	});
	} else {
	return failWithResponse(r)(std::forward<decltype(ctx)>(ctx));
	}
	}
	};
	}

	}
	diff --git a/src/client/room/room-model.cpp b/src/client/room/room-model.cpp
	index 3412bf8..e18068b 100644
	--- a/src/client/room/room-model.cpp
	+++ b/src/client/room/room-model.cpp
	@@ -1,575 +1,576 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2020-2023 tusooa
	* 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"
	#include "immer-utils.hpp"

	inline const auto receiptTypes = immer::flex_vector<std::string>{"m.read", "m.read.private"};

	namespace Kazv
	{
	PendingRoomKeyEvent makePendingRoomKeyEventV0(std::string txnId, Event event, immer::map<std::string, immer::flex_vector<std::string>> devices)
	{
	immer::map<std::string, immer::map<std::string, Event>> messages;
	for (auto [userId, deviceIds] : devices) {
	messages = setIn(std::move(messages), immer::map<std::string, Event>(), userId);
	for (auto deviceId : deviceIds) {
	messages = setIn(
	std::move(messages),
	event,
	userId, deviceId
	);
	}
	}
	return PendingRoomKeyEvent{txnId, messages};
	}

	bool operator==(const ReadReceipt &a, const ReadReceipt &b)
	{
	return a.eventId == b.eventId && a.timestamp == b.timestamp;
	}

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

	bool operator==(const EventReader &a, const EventReader &b)
	{
	return a.userId == b.userId && a.timestamp == b.timestamp;
	}

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

	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;

	// Safety assert: we do not want to execute the for_each if the range is empty,
	// or it will go out of bounds.
	if (thisBatchStart.index() < origBatchStart.index()) {
	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();
	+ auto jw = e.originalJson();
	+ const auto &json = jw.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>()});
	}
	}

	// calculate event relationships
	r.generateRelationships(a.events);

	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) {
	auto processReceipt = [&](Event e) {
	const auto content = e.content().get();
	for (auto [eventId, receipts] : content.items()) {
	if (!receipts.is_object()) {
	continue;
	}
	for (auto receiptType : receiptTypes) {
	if (!(receipts.contains(receiptType)
	&& receipts[receiptType].is_object())) {
	continue;
	}

	for (auto [user, receipt]: receipts[receiptType].items()) {
	ReadReceipt readReceipt{
	eventId,
	0,
	};

	if (receipt.is_object() && receipt.contains("ts")
	&& receipt["ts"].is_number()) {
	readReceipt.timestamp = receipt["ts"].template get<Timestamp>();
	}

	// Remove old receipts
	if (r.readReceipts.count(user)) {
	auto oldReceiptEventId = r.readReceipts[user].eventId;
	if (r.eventReadUsers.count(oldReceiptEventId)) {
	auto remaining =
	intoImmer(
	immer::flex_vector<std::string>{},
	zug::filter([user=user](auto userId) {
	return userId != user;
	}),
	r.eventReadUsers[oldReceiptEventId]
	);

	if (remaining.empty()) {
	r.eventReadUsers = std::move(r.eventReadUsers).erase(oldReceiptEventId);
	} else {
	r.eventReadUsers = std::move(r.eventReadUsers).set(oldReceiptEventId, remaining);
	}
	}
	}

	// Add new receipt
	r.readReceipts = std::move(r.readReceipts).set(user, readReceipt);
	auto oldReadUsers = r.eventReadUsers[eventId];
	r.eventReadUsers = std::move(r.eventReadUsers).set(eventId, oldReadUsers.push_back(user));
	}
	}
	}
	};

	for (auto e : a.events) {
	if (e.type() == "m.receipt") {
	processReceipt(e);
	}
	}
	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;
	},
	[&](UpdateJoinedMemberCountAction a) {
	r.joinedMemberCount = a.joinedMemberCount;
	return r;
	},
	[&](UpdateInvitedMemberCountAction a) {
	r.invitedMemberCount = a.invitedMemberCount;
	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;
	}
	);
	}

	static auto membershipTransducer(const std::string &membership)
	{
	return 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 std::pair<std::string, Kazv::Event>{stateKey, v};
	})
	\| zug::filter([&membership](auto val) {
	auto [stateKey, ev] = val;
	return ev.content().get()
	.at("membership"s) == membership;
	});
	}

	static auto memberIdsByMembership(immer::map<KeyOfState, Event> stateEvents, const std::string &membership)
	{
	return intoImmer(
	immer::flex_vector<std::string>{},
	membershipTransducer(membership)
	\| zug::map([](auto val) {
	auto [stateKey, ev] = val;
	return stateKey;
	}),
	stateEvents);
	}

	auto memberEventsByMembership(immer::map<KeyOfState, Event> stateEvents, const std::string &membership)
	{
	return intoImmer(
	EventList{},
	membershipTransducer(membership)
	\| zug::map([](auto val) {
	auto [stateKey, ev] = val;
	return ev;
	}),
	stateEvents);
	}

	immer::flex_vector<std::string> RoomModel::joinedMemberIds() const
	{
	return memberIdsByMembership(stateEvents, "join"s);
	}

	immer::flex_vector<std::string> RoomModel::invitedMemberIds() const
	{
	return memberIdsByMembership(stateEvents, "invite"s);
	}

	immer::flex_vector<std::string> RoomModel::knockedMemberIds() const
	{
	return memberIdsByMembership(stateEvents, "knock"s);
	}

	immer::flex_vector<std::string> RoomModel::leftMemberIds() const
	{
	return memberIdsByMembership(stateEvents, "leave"s);
	}

	immer::flex_vector<std::string> RoomModel::bannedMemberIds() const
	{
	return memberIdsByMembership(stateEvents, "ban"s);
	}

	EventList RoomModel::joinedMemberEvents() const
	{
	return memberEventsByMembership(stateEvents, "join"s);
	}

	EventList RoomModel::invitedMemberEvents() const
	{
	return memberEventsByMembership(stateEvents, "invite"s);
	}

	EventList RoomModel::knockedMemberEvents() const
	{
	return memberEventsByMembership(stateEvents, "knock"s);
	}

	EventList RoomModel::leftMemberEvents() const
	{
	return memberEventsByMembership(stateEvents, "leave"s);
	}

	EventList RoomModel::bannedMemberEvents() const
	{
	return memberEventsByMembership(stateEvents, "ban"s);
	}

	EventList RoomModel::heroMemberEvents() const
	{
	return intoImmer(
	EventList{},
	zug::filter([heroIds=heroIds](auto val) {
	auto [k, ev] = val;
	auto [type, stateKey] = k;
	return type == "m.room.member"s &&
	std::find(heroIds.begin(), heroIds.end(), stateKey) != heroIds.end();
	})
	\| zug::map([](auto val) {
	auto [_, ev] = val;
	return ev;
	}),
	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>()
	: ROOM_TAG_DEFAULT_ORDER;
	}

	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));
	}
	);
	}

	static auto normalizeTagEventJson(Event e)
	{
	auto content = e.content().get();
	if (!content.contains("tags") \|\| !content["tags"].is_object()) {
	content["tags"] = json::object();
	}
	return json{
	{"content", content},
	{"type", "m.tag"},
	};
	}

	Event RoomModel::makeAddTagEvent(std::string tagId, std::optional<double> order) const
	{
	auto eventJson = normalizeTagEventJson(accountData["m.tag"]);
	auto tag = json::object();
	if (order.has_value()) {
	tag["order"] = order.value();
	}

	eventJson["content"]["tags"][tagId] = tag;
	return Event(eventJson);
	}

	Event RoomModel::makeRemoveTagEvent(std::string tagId) const
	{
	auto eventJson = normalizeTagEventJson(accountData["m.tag"]);
	eventJson["content"]["tags"].erase(tagId);
	return Event(eventJson);
	}

	void RoomModel::generateRelationships(EventList newEvents)
	{
	for (const auto &event: newEvents) {
	auto [relType, eventId] = event.relationship();
	if (!relType.empty()) {
	reverseEventRelationships = updateIn(std::move(reverseEventRelationships), [event](auto &&evs) {
	return evs.push_back(event.id());
	}, eventId, relType);
	}
	}
	}

	void RoomModel::regenerateRelationships()
	{
	generateRelationships(intoImmer(EventList{}, zug::map([](const auto &kv) {
	return kv.second;
	}), messages));
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 8, 6:18 AM (14 h, 33 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1722938
Default Alt Text: (28 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions