room.hpp

Go to the documentation of this file.

/*
 * This file is part of libkazv.
 * SPDX-FileCopyrightText: 2020-2023 tusooa <tusooa@kazv.moe>
 * SPDX-License-Identifier: AGPL-3.0-or-later
 */
 
#pragma once
#include <libkazv-config.hpp>
 
#include <lager/reader.hpp>
#include <lager/context.hpp>
#include <lager/with.hpp>
#include <lager/constant.hpp>
#include <lager/lenses/optional.hpp>
#include <zug/transducer/map.hpp>
#include <zug/transducer/filter.hpp>
#include <zug/sequence.hpp>
#include <immer/flex_vector_transient.hpp>
 
#include "debug.hpp"
 
#include "sdk-model.hpp"
#include "client-model.hpp"
#include "room-model.hpp"
#include <cursorutil.hpp>
#include "sdk-model-cursor-tag.hpp"
#include "random-generator.hpp"
#include "power-levels-desc.hpp"
 
namespace Kazv
{
    class Room
    {
    public:
        using PromiseT = SingleTypePromise<DefaultRetType>;
        using DepsT = lager::deps<SdkModelCursorKey, RandomInterface &
#ifdef KAZV_USE_THREAD_SAFETY_HELPER
                                  , EventLoopThreadIdKeeper &
#endif
                                  >;
        using ContextT = Context<ClientAction>;
 
        struct InEventLoopTag {};
 
        Room(lager::reader<SdkModel> sdk,
             lager::reader<std::string> roomId,
             ContextT ctx);
 
        Room(lager::reader<SdkModel> sdk,
             lager::reader<std::string> roomId,
             ContextT ctx, DepsT deps);
 
        Room(InEventLoopTag, std::string roomId, ContextT ctx, DepsT deps);
 
        Room toEventLoop() const;
 
        /* lager::reader<MapT<KeyOfState, Event>> */
        inline auto stateEvents() const {
            return roomCursor()
                [&RoomModel::stateEvents];
        }
 
        auto inviteState() const -> lager::reader<immer::map<KeyOfState, Event>>;
 
        /* lager::reader<std::optional<Event>> */
        inline auto stateOpt(KeyOfState k) const {
            return stateEvents()
                [std::move(k)];
        }
 
        /* lager::reader<Event> */
        inline auto state(KeyOfState k) const {
            return stateOpt(k)
                [lager::lenses::or_default];
        }
 
        auto timelineEventIds() const -> lager::reader<immer::flex_vector<std::string>>;
 
        auto messagesMap() const -> lager::reader<immer::map<std::string, Event>>;
 
        auto timelineEvents() const -> lager::reader<immer::flex_vector<Event>>;
 
        auto message(lager::reader<std::string> eventId) const -> lager::reader<Event>;
 
        auto localEcho(lager::reader<std::string> txnId) const -> lager::reader<LocalEchoDesc>;
 
        auto heroMemberEvents() const -> lager::reader<immer::flex_vector<Event>>;
 
        auto heroDisplayNames() const -> lager::reader<immer::flex_vector<std::string>>;
 
        auto nameOpt() const -> lager::reader<std::optional<std::string>>;
 
        auto name() const -> lager::reader<std::string>;
 
        auto avatarMxcUri() const -> lager::reader<std::string>;
 
        auto members() const -> lager::reader<immer::flex_vector<std::string>>;
 
        auto invitedMembers() const -> lager::reader<immer::flex_vector<std::string>>;
 
        auto knockedMembers() const -> lager::reader<immer::flex_vector<std::string>>;
 
        auto leftMembers() const -> lager::reader<immer::flex_vector<std::string>>;
 
        auto bannedMembers() const -> lager::reader<immer::flex_vector<std::string>>;
 
        auto joinedMemberEvents() const -> lager::reader<EventList>;
 
        auto invitedMemberEvents() const -> lager::reader<EventList>;
 
        auto knockedMemberEvents() const -> lager::reader<EventList>;
 
        auto leftMemberEvents() const -> lager::reader<EventList>;
 
        auto bannedMemberEvents() const -> lager::reader<EventList>;
 
        auto memberEventByCursor(lager::reader<std::string> userId) const -> lager::reader<Event>;
 
        auto memberEventFor(std::string userId) const -> lager::reader<Event>;
 
        lager::reader<bool> encrypted() const;
 
        /*lager::reader<std::string>*/
        KAZV_WRAP_ATTR(RoomModel, roomCursor(), roomId);
        /*lager::reader<RoomMembership>*/
        KAZV_WRAP_ATTR(RoomModel, roomCursor(), membership);
        /*lager::reader<immer::flex_vector<Kazv::LocalDraft>>*/
        KAZV_WRAP_ATTR(RoomModel, roomCursor(), localDrafts);
        /* lager::reader<bool> */
        KAZV_WRAP_ATTR(RoomModel, roomCursor(), membersFullyLoaded);
 
        auto localReadMarker() const -> lager::reader<std::string>;
 
        auto heroIds() const -> lager::reader<immer::flex_vector<std::string>>;
 
        auto joinedMemberCount() const -> lager::reader<std::size_t>;
 
        auto invitedMemberCount() const -> lager::reader<std::size_t>;
 
        PromiseT setLocalDraft(std::string localDraft) const;
 
        PromiseT setLocalDraft(std::string text,
            std::string relType, std::string relatedEventId) const;
 
        PromiseT setLocalDraftRel(std::string relType,
            std::string relatedEventId) const;
 
        PromiseT pushLocalDraft(std::string text,
            std::string relType, std::string relatedEventId) const;
 
        PromiseT popLocalDraft() const;
 
        PromiseT sendMessage(Event msg) const;
 
        PromiseT sendTextMessage(std::string text) const;
 
        PromiseT resendMessage(std::string txnId) const;
 
        PromiseT redactEvent(std::string eventId, std::optional<std::string> reason) const;
 
        PromiseT sendPendingKeyEvent(std::string txnId) const;
 
        PromiseT sendAllPendingKeyEvents() const;
 
        PromiseT refreshRoomState() const;
 
        PromiseT getStateEvent(std::string type, std::string stateKey) const;
 
        PromiseT sendStateEvent(Event state) const;
 
        PromiseT setName(std::string name) const;
 
        // lager::reader<std::string>
        inline auto topic() const {
            using namespace lager::lenses;
            return stateEvents()
                [KeyOfState{"m.room.topic", ""}]
                [or_default]
                .xform(eventContent
                       | jsonAtOr("topic"s, ""s));
        }
 
        PromiseT setTopic(std::string topic) const;
 
        PromiseT invite(std::string userId) const;
 
        /* lager::reader<MapT<std::string, Event>> */
        inline auto ephemeralEvents() const {
            return roomCursor()
                [&RoomModel::ephemeral];
        }
 
        /* lager::reader<std::optional<Event>> */
        inline auto ephemeralOpt(std::string type) const {
            return roomCursor()
                [&RoomModel::ephemeral]
                [type];
        }
 
        /* lager::reader<Event> */
        inline auto ephemeral(std::string type) const {
            return roomCursor()
                [&RoomModel::ephemeral]
                [type]
                [lager::lenses::or_default];
        }
 
        auto typingUsers() const -> lager::reader<immer::flex_vector<std::string>>;
 
        auto typingMemberEvents() const -> lager::reader<EventList>;
 
        PromiseT setTyping(bool typing, std::optional<int> timeoutMs) const;
 
        /* lager::reader<MapT<std::string, Event>> */
        inline auto accountDataEvents() const {
            return roomCursor()
                [&RoomModel::accountData];
        }
 
        /* lager::reader<std::optional<Event>> */
        inline auto accountDataOpt(std::string type) const {
            return roomCursor()
                [&RoomModel::accountData]
                [type];
        }
 
        /* lager::reader<Event> */
        inline auto accountData(std::string type) const {
            return roomCursor()
                [&RoomModel::accountData]
                [type]
                [lager::lenses::or_default];
        }
 
        /* lager::reader<std::string> */
        inline auto readMarker() const {
            using namespace lager::lenses;
            return accountData("m.fully_read")
                .xform(eventContent
                       | jsonAtOr("event_id", std::string{}));
        }
 
        PromiseT setAccountData(Event accountDataEvent) const;
 
        auto tags() const -> lager::reader<immer::map<std::string, double>>;
 
        PromiseT addOrSetTag(std::string tagId, std::optional<double> order = std::nullopt) const;
 
        PromiseT removeTag(std::string tagId) const;
 
        PromiseT leave() const;
 
        PromiseT forget() const;
 
        PromiseT kick(std::string userId, std::optional<std::string> reason = std::nullopt) const;
 
        PromiseT ban(std::string userId, std::optional<std::string> reason = std::nullopt) const;
 
        // TODO: v1.1 adds reason field
        PromiseT unban(std::string userId/*, std::optional<std::string> reason = std::nullopt*/) const;
 
        /* lager::reader<JsonWrap> */
        inline auto avatar() const {
            return state(KeyOfState{"m.room.avatar", ""})
                .xform(eventContent);
        }
 
        auto pinnedEvents() const -> lager::reader<immer::flex_vector<std::string>>;
 
        PromiseT setPinnedEvents(immer::flex_vector<std::string> eventIds) const;
 
        PromiseT pinEvents(immer::flex_vector<std::string> eventIds) const;
 
        PromiseT unpinEvents(immer::flex_vector<std::string> eventIds) const;
 
        lager::reader<immer::map<std::string /* eventId */, std::string /* prevBatch */>> timelineGaps() const;
 
        PromiseT paginateBackFromEvent(std::string eventId) const;
 
        auto localEchoes() const -> lager::reader<immer::flex_vector<LocalEchoDesc>>;
 
        PromiseT removeLocalEcho(std::string txnId) const;
 
        auto pendingRoomKeyEvents() const -> lager::reader<immer::flex_vector<PendingRoomKeyEvent>>;
 
        auto powerLevels() const -> lager::reader<PowerLevelsDesc>;
 
        auto relatedEvents(lager::reader<std::string> eventId, std::string relType) const -> lager::reader<EventList>;
 
        auto eventReaders(lager::reader<std::string> eventId) const -> lager::reader<immer::flex_vector<EventReader>>;
 
        PromiseT postReceipt(std::string eventId) const;
 
        auto unreadNotificationEventIds() const -> lager::reader<immer::flex_vector<std::string>>;
 
        bool isReadBy(const std::string &eventId, const std::string &userId) const;
 
    private:
        const lager::reader<SdkModel> &sdkCursor() const;
        const lager::reader<RoomModel> &roomCursor() const;
        lager::reader<RoomModel> makeRoomCursor() const;
        std::string currentRoomId() const;
        lager::reader<immer::map<KeyOfState, Event>> inviteStateOrState() const;
        lager::reader<Event> inviteStateOrStateEvent(lager::reader<KeyOfState> key) const;
 
        std::optional<lager::reader<SdkModel>> m_sdk;
        std::variant<lager::reader<std::string>, std::string> m_roomId;
 
        ContextT m_ctx;
        std::optional<DepsT> m_deps;
        lager::reader<RoomModel> m_roomCursor;
        KAZV_DECLARE_THREAD_ID();
        KAZV_DECLARE_EVENT_LOOP_THREAD_ID_KEEPER(m_deps.has_value() ? &lager::get<EventLoopThreadIdKeeper &>(m_deps.value()) : 0);
    };
}