client.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 <immer/box.hpp>
#include <immer/map.hpp>
#include <immer/flex_vector.hpp>
#include <immer/flex_vector_transient.hpp>
 
#include "sdk-model.hpp"
#include "client/client-model.hpp"
#include "client/actions/content.hpp"
#include "sdk-model-cursor-tag.hpp"
#include "get-content-job-v1.hpp"
 
#include "room/room.hpp"
#include "notification-handler.hpp"
#include <verification-tracker.hpp>
 
namespace Kazv
{
    class Client
    {
    public:
        using ActionT = ClientAction;
 
        using DepsT = lager::deps<JobInterface &, EventInterface &, SdkModelCursorKey, RandomInterface &, VerificationTracker &
#ifdef KAZV_USE_THREAD_SAFETY_HELPER
                                  , EventLoopThreadIdKeeper &
#endif
 
                                  >;
        using ContextT = Context<ActionT>;
        using ContextWithDepsT = Context<ActionT, DepsT>;
 
        using PromiseT = SingleTypePromise<DefaultRetType>;
 
        struct InEventLoopTag {};
        Client(lager::reader<SdkModel> sdk,
               ContextT ctx, std::nullopt_t);
 
        Client(lager::reader<SdkModel> sdk,
               ContextWithDepsT ctx);
 
        Client(InEventLoopTag,
               ContextWithDepsT ctx);
 
        Client(InEventLoopTag, ContextT ctx, DepsT deps);
 
 
        Client toEventLoop() const;
 
        /* lager::reader<immer::map<std::string, Room>> */
        inline auto rooms() const {
            return clientCursor()
                [&ClientModel::roomList]
                [&RoomListModel::rooms];
        }
 
        /* lager::reader<RangeT<std::string>> */
        inline auto roomIds() const {
            return rooms().xform(
                zug::map([](auto m) {
                             return intoImmer(
                                 immer::flex_vector<std::string>{},
                                 zug::map([](auto val) { return val.first; }),
                                 m);
                         }));
        }
 
        auto roomIdsUnderTag(std::string tagId) const -> lager::reader<immer::map<std::string, double>>;
 
        auto roomIdsByTagId() const -> lager::reader<immer::map<std::string, immer::map<std::string, double>>>;
 
        KAZV_WRAP_ATTR(ClientModel, clientCursor(), serverUrl)
        KAZV_WRAP_ATTR(ClientModel, clientCursor(), loggedIn)
        KAZV_WRAP_ATTR(ClientModel, clientCursor(), userId)
        KAZV_WRAP_ATTR(ClientModel, clientCursor(), token)
        KAZV_WRAP_ATTR(ClientModel, clientCursor(), deviceId)
        KAZV_WRAP_ATTR(ClientModel, clientCursor(), toDevice)
 
        Room room(std::string id) const;
 
        Room roomByCursor(lager::reader<std::string> id) const;
 
        PromiseT passwordLogin(std::string homeserver, std::string username,
                               std::string password, std::string deviceName) const;
 
        PromiseT tokenLogin(std::string homeserver, std::string username,
                            std::string token, std::string deviceId) const;
 
        PromiseT mLoginTokenLogin(
            std::string homeserver,
            std::string loginToken,
            std::optional<std::string> deviceName
        ) const;
 
        auto shouldSync() const -> lager::reader<bool>;
 
        PromiseT logout() const;
 
        PromiseT autoDiscover(std::string userId) const;
 
        PromiseT createRoom(
            RoomVisibility v,
            std::optional<std::string> name = {},
            std::optional<std::string> alias = {},
            immer::array<std::string> invite = {},
            std::optional<bool> isDirect = {},
            bool allowFederate = true,
            std::optional<std::string> topic = {},
            JsonWrap powerLevelContentOverride = json::object(),
            std::optional<CreateRoomPreset> preset = std::nullopt,
            immer::array<Event> initialState = immer::array<Event>()
        ) const;
 
        PromiseT joinRoomById(std::string roomId) const;
 
        PromiseT joinRoom(std::string roomId, immer::array<std::string> serverName) const;
 
        PromiseT uploadContent(immer::box<Bytes> content,
                               std::string uploadId,
                               std::optional<std::string> filename = std::nullopt,
                               std::optional<std::string> contentType = std::nullopt) const;
 
        PromiseT uploadContent(FileDesc file) const;
 
 
        inline std::string mxcUriToHttp(std::string mxcUri) const {
            using namespace CursorOp;
            auto [serverName, mediaId] = mxcUriToMediaDesc(mxcUri);
            return (+clientCursor())
                .template job<GetContentJob>()
                .make(serverName, mediaId).url();
        }
 
        std::string mxcUriToHttpV1(std::string mxcUri) const;
 
        PromiseT downloadContent(std::string mxcUri,
                                 std::optional<FileDesc> downloadTo = std::nullopt) const;
 
        PromiseT downloadThumbnail(std::string mxcUri,
                                   int width,
                                   int height,
                                   std::optional<ThumbnailResizingMethod> method = std::nullopt,
                                   std::optional<FileDesc> downloadTo = std::nullopt) const;
 
        PromiseT getProfile(std::string userId) const;
 
        PromiseT setAvatarUrl(std::optional<std::string> avatarUrl) const;
 
        PromiseT setDisplayName(std::optional<std::string> displayName) const;
 
        // lager::reader<bool>
        inline auto syncing() const {
            return clientCursor()[&ClientModel::syncing];
        }
 
        PromiseT startSyncing() const;
 
        PromiseT stopSyncing() const;
 
        auto devicesOfUser(std::string userId) const -> lager::reader<immer::flex_vector<DeviceKeyInfo>>;
 
        PromiseT setDeviceTrustLevel(std::string userId, std::string deviceId, DeviceTrustLevel trustLevel) const;
 
        auto trustLevelNeededToSendKeys() const -> lager::reader<DeviceTrustLevel>;
 
        PromiseT setTrustLevelNeededToSendKeys(DeviceTrustLevel trustLevel) const;
 
        auto directRoomMap() const -> lager::reader<immer::map<std::string, std::string>>;
 
        auto accountData() const -> lager::reader<immer::map<std::string, Event>>;
 
        PromiseT setAccountData(Event accountDataEvent) const;
 
        NotificationHandler notificationHandler() const;
 
        template<class Archive>
        void serializeTo(Archive &ar) const {
            ar << sdkCursor().get();
        }
 
        PromiseT getVersions(std::string homeserver) const;
 
        auto supportVersions() const -> lager::reader<immer::array<std::string>>;
 
        PromiseT addDirectRoom(std::string userId, std::string roomId) const;
 
        BaseJob getRoomIdByAliasJob(std::string roomAlias) const;
 
        PromiseT purgeRoomEvents(immer::map<std::string, std::size_t> roomIdToMaxToKeepMap) const;
 
        PromiseT loadEventsFromStorage(immer::map<std::string, EventList> timelineEvents, immer::map<std::string, EventList> relatedEvents) const;
 
        PromiseT importFromKeyBackupFile(std::string fileContent, std::string password) const;
 
        PromiseT processVerificationEventsFromSync(EventList toDeviceEvents) const;
 
        PromiseT requestOutgoingToDeviceVerification(std::string userId, std::string deviceId) const;
 
        PromiseT readyForVerification(std::string userId, std::string deviceId) const;
 
        PromiseT cancelVerification(std::string userId, std::string deviceId) const;
 
        PromiseT confirmVerificationSasMatch(std::string userId, std::string deviceId) const;
 
        PromiseT denyVerificationSasMatch(std::string userId, std::string deviceId) const;
 
        PromiseT ensureInitVerificationTracker() const;
 
    private:
        void syncForever(std::optional<int> retryTime = std::nullopt) const;
 
        const lager::reader<SdkModel> &sdkCursor() const;
        lager::reader<ClientModel> clientCursor() const;
 
        std::optional<lager::reader<SdkModel>> m_sdk;
        std::optional<lager::reader<ClientModel>> m_client;
        ContextT m_ctx;
        std::optional<DepsT> m_deps;
        KAZV_DECLARE_THREAD_ID();
        KAZV_DECLARE_EVENT_LOOP_THREAD_ID_KEEPER(m_deps.has_value() ? &lager::get<EventLoopThreadIdKeeper &>(m_deps.value()) : 0);
    };
 
}