client-model.hpp

Go to the documentation of this file.

/*
 * This file is part of libkazv.
 * SPDX-FileCopyrightText: 2020-2024 tusooa <tusooa@kazv.moe>
 * SPDX-License-Identifier: AGPL-3.0-or-later
 */
 
 
#pragma once
#include <libkazv-config.hpp>
 
#include <tuple>
#include <variant>
#include <string>
#include <optional>
 
#include <lager/context.hpp>
#include <boost/hana.hpp>
#include <serialization/std-optional.hpp>
 
 
#include <csapi/sync.hpp>
 
#include <file-desc.hpp>
#include <crypto.hpp>
#include <verification-tracker.hpp>
#include <serialization/immer-flex-vector.hpp>
#include <serialization/immer-box.hpp>
#include <serialization/immer-map.hpp>
#include <serialization/immer-array.hpp>
 
#include "clientfwd.hpp"
#include "device-list-tracker.hpp"
#include "room/room-model.hpp"
 
namespace Kazv
{
    inline const std::string DEFTXNID{"0"};
 
    enum RoomVisibility
    {
        Private,
        Public,
    };
 
    enum CreateRoomPreset
    {
        PrivateChat,
        PublicChat,
        TrustedPrivateChat,
    };
 
    enum ThumbnailResizingMethod
    {
        Crop,
        Scale,
    };
 
    struct ClientModel
    {
        std::string serverUrl;
        std::string userId;
        std::string token;
        std::string deviceId;
        bool loggedIn{false};
 
        bool syncing{false};
        bool shouldSync{true};
        int firstRetryMs{1000};
        int retryTimeFactor{2};
        int maxRetryMs{30 * 1000};
        int syncTimeoutMs{20000};
        std::string initialSyncFilterId;
        std::string incrementalSyncFilterId;
        std::optional<std::string> syncToken;
 
        RoomListModel roomList;
        immer::map<std::string /* sender */, Event> presence;
        immer::map<std::string /* type */, Event> accountData;
 
        std::string nextTxnId{DEFTXNID};
        immer::flex_vector<BaseJob> nextJobs;
        immer::flex_vector<KazvTrigger> nextTriggers;
 
        EventList toDevice;
        std::optional<immer::box<Crypto>> crypto;
        bool identityKeysUploaded{false};
 
        DeviceListTracker deviceLists;
        DeviceTrustLevel trustLevelNeededToSendKeys{DeviceTrustLevel::Unseen};
 
        immer::array<std::string /* version */> versions;
 
        immer::flex_vector<std::string /* deviceId */> devicesToSendKeys(std::string userId) const;
 
        void maybeRotateSessions(ClientModel oldClient);
 
        std::pair<Event, std::optional<std::string> /* sessionKey */>
        megOlmEncrypt(Event e, std::string roomId, Timestamp timeMs, RandomData random);
 
        immer::map<std::string, immer::map<std::string, Event>> olmEncryptSplit(Event e, immer::map<std::string, immer::flex_vector<std::string>> userIdToDeviceIdMap, RandomData random);
 
        std::size_t numOneTimeKeysNeeded() const;
 
        auto directRoomMap() const -> immer::map<std::string, std::string>;
 
        auto roomIdsUnderTag(std::string tagId) const -> immer::map<std::string, double>;
 
        auto roomIdsByTagId() const -> immer::map<std::string, immer::map<std::string, double>>;
 
        const Crypto &constCrypto() const;
 
        template<class Func>
        auto withCrypto(Func &&func) -> std::decay_t<std::invoke_result_t<Func &&, Crypto &>>
        {
            using ResT = std::decay_t<std::invoke_result_t<Func &&, Crypto &>>;
            if constexpr (std::is_same_v<ResT, void>) {
                crypto = std::move(crypto).value()
                    .update([f=std::forward<Func>(func)](Crypto c) mutable {
                        std::forward<Func>(f)(c);
                        return c;
                    });
            } else {
                std::optional<ResT> res;
                crypto = std::move(crypto).value()
                    .update([f=std::forward<Func>(func), &res](Crypto c) mutable {
                        res = std::forward<Func>(f)(c);
                        return c;
                    });
                return std::move(res).value();
            }
        }
 
        // helpers
        template<class Job>
        struct MakeJobT
        {
            template<class ...Args>
            constexpr auto make(Args &&...args) const {
                if constexpr (Job::needsAuth()) {
                    return Job(
                        serverUrl,
                        token,
                        std::forward<Args>(args)...);
                } else {
                    return Job(
                        serverUrl,
                        std::forward<Args>(args)...);
                }
            }
 
            std::string serverUrl;
            std::string token;
        };
 
        template<class Job>
        constexpr auto job() const {
            return MakeJobT<Job>{serverUrl, token};
        }
 
        inline void addJob(BaseJob j) {
            nextJobs = std::move(nextJobs).push_back(std::move(j));
        }
 
        inline auto popAllJobs() {
            auto jobs = std::move(nextJobs);
            nextJobs = DEFVAL;
            return jobs;
        };
 
        inline void addTrigger(KazvTrigger t) {
            addTriggers({t});
        }
 
        inline void addTriggers(immer::flex_vector<KazvTrigger> c) {
            nextTriggers = std::move(nextTriggers) + c;
        }
 
        inline auto popAllTriggers() {
            auto triggers = std::move(nextTriggers);
            nextTriggers = DEFVAL;
            return triggers;
        }
 
        void maybeAddSaveEventsTrigger(const ClientModel &old);
 
        using Action = ClientAction;
        using Effect = ClientEffect;
        using Result = ClientResult;
 
        static Result update(ClientModel m, Action a);
    };
 
    // actions:
    struct LoginAction {
        std::string serverUrl;
        std::string username;
        std::string password;
        std::optional<std::string> deviceName;
    };
 
    struct TokenLoginAction
    {
        std::string serverUrl;
        std::string username;
        std::string token;
        std::string deviceId;
    };
 
    struct MLoginTokenLoginAction
    {
        std::string serverUrl;
        std::string loginToken;
        std::optional<std::string> deviceName;
    };
 
    struct LogoutAction {};
    struct HardLogoutAction {};
 
    struct GetWellknownAction
    {
        std::string userId;
    };
 
    struct GetVersionsAction
    {
        std::string serverUrl;
    };
 
    struct SyncAction {};
 
    struct SetShouldSyncAction
    {
        bool shouldSync;
    };
 
    struct PaginateTimelineAction
    {
        std::string roomId;
        std::string fromEventId;
        std::optional<int> limit;
    };
 
    struct SendMessageAction
    {
        std::string roomId;
        Event event;
        std::optional<std::string> txnId{std::nullopt};
    };
 
    struct SendStateEventAction
    {
        std::string roomId;
        Event event;
    };
 
    struct SaveLocalEchoAction
    {
        std::string roomId;
        Event event;
        std::optional<std::string> txnId{std::nullopt};
    };
 
    struct UpdateLocalEchoStatusAction
    {
        std::string roomId;
        std::string txnId;
        LocalEchoDesc::Status status;
    };
 
    struct RedactEventAction
    {
        std::string roomId;
        std::string eventId;
        std::optional<std::string> reason;
    };
 
    struct CreateRoomAction
    {
        using Visibility = RoomVisibility;
        using Preset = CreateRoomPreset;
        Visibility visibility;
        std::optional<std::string> roomAliasName;
        std::optional<std::string> name;
        std::optional<std::string> topic;
        immer::array<std::string> invite;
        //immer::array<Invite3pid> invite3pid;
        std::optional<std::string> roomVersion;
        JsonWrap creationContent;
        immer::array<Event> initialState;
        std::optional<Preset> preset;
        std::optional<bool> isDirect;
        JsonWrap powerLevelContentOverride;
    };
 
    struct GetRoomStatesAction
    {
        std::string roomId;
    };
 
    struct GetStateEventAction
    {
        std::string roomId;
        std::string type;
        std::string stateKey;
    };
 
    struct InviteToRoomAction
    {
        std::string roomId;
        std::string userId;
    };
 
    struct JoinRoomByIdAction
    {
        std::string roomId;
    };
 
    struct JoinRoomAction
    {
        std::string roomIdOrAlias;
        immer::array<std::string> serverName;
    };
 
    struct LeaveRoomAction
    {
        std::string roomId;
    };
 
    struct ForgetRoomAction
    {
        std::string roomId;
    };
 
    struct KickAction
    {
        std::string roomId;
        std::string userId;
        std::optional<std::string> reason;
    };
 
    struct BanAction
    {
        std::string roomId;
        std::string userId;
        std::optional<std::string> reason;
    };
 
    struct UnbanAction
    {
        std::string roomId;
        std::string userId;
    };
 
    struct SetAccountDataPerRoomAction
    {
        std::string roomId;
        Event accountDataEvent;
    };
 
    struct SetTypingAction
    {
        std::string roomId;
        bool typing;
        std::optional<int> timeoutMs;
    };
 
    struct PostReceiptAction
    {
        std::string roomId;
        std::string eventId;
    };
 
    struct SetReadMarkerAction
    {
        std::string roomId;
        std::string eventId;
    };
 
    struct UploadContentAction
    {
        FileDesc content;
        std::optional<std::string> filename;
        std::optional<std::string> contentType;
        std::string uploadId; // to be used by library users
    };
 
    struct DownloadContentAction
    {
        std::string mxcUri;
        std::optional<FileDesc> downloadTo;
    };
 
    struct DownloadThumbnailAction
    {
        std::string mxcUri;
        int width;
        int height;
        std::optional<ThumbnailResizingMethod> method;
        std::optional<bool> allowRemote;
        std::optional<FileDesc> downloadTo;
    };
 
    struct ResubmitJobAction
    {
        BaseJob job;
    };
 
    struct ProcessResponseAction
    {
        Response response;
    };
 
    struct PostInitialFiltersAction
    {
    };
 
    struct SetAccountDataAction
    {
        Event accountDataEvent;
    };
 
    struct SendToDeviceMessageAction
    {
        Event event;
        immer::map<std::string, immer::flex_vector<std::string>> devicesToSend;
        std::optional<std::string> txnId{std::nullopt};
    };
 
    struct SendMultipleToDeviceMessagesAction
    {
        immer::map<std::string, immer::map<std::string, Event>> userToDeviceToEventMap;
        std::optional<std::string> txnId{std::nullopt};
    };
 
    struct UploadIdentityKeysAction
    {
    };
 
    struct GenerateAndUploadOneTimeKeysAction
    {
        static std::size_t randomSize(std::size_t numToGen);
        std::size_t numToGen;
        RandomData random;
    };
 
    struct QueryKeysAction
    {
        bool isInitialSync;
    };
 
    struct EnsureKeysFromDevicesAction
    {
        immer::map<
            std::string /* userId */,
            immer::flex_vector<std::string /* deviceId */>> userIdToDeviceIdsMap;
    };
 
    struct ClaimKeysAction
    {
        static std::size_t randomSize(immer::map<std::string, immer::flex_vector<std::string>> devicesToSend);
        std::string roomId;
        std::string sessionId;
        std::string sessionKey;
        immer::map<std::string, immer::flex_vector<std::string>> devicesToSend;
        RandomData random;
    };
 
    struct EncryptMegOlmEventAction
    {
        static std::size_t maxRandomSize();
        static std::size_t minRandomSize();
 
        std::string roomId;
        Event e;
        Timestamp timeMs;
        RandomData random;
    };
 
    struct SetDeviceTrustLevelAction
    {
        std::string userId;
        std::string deviceId;
        DeviceTrustLevel trustLevel;
    };
 
    struct SetDevicesTrustLevelsAction
    {
        immer::map<
            std::string /* userId */,
            immer::map<std::string /* deviceId */, DeviceTrustLevel>> trustLevelMap;
    };
 
    struct SetTrustLevelNeededToSendKeysAction
    {
        DeviceTrustLevel trustLevel;
    };
 
    struct PrepareForSharingRoomKeyAction
    {
        using UserIdToDeviceIdMap = immer::map<std::string, immer::flex_vector<std::string>>;
        static std::size_t randomSize(UserIdToDeviceIdMap devices);
 
        std::string roomId;
        UserIdToDeviceIdMap devices;
        Event e;
        RandomData random;
    };
 
    struct ImportFromKeyBackupFileAction
    {
        std::string fileContent;
        std::string password;
    };
 
    struct NotifyVerificationTrackerModelAction {};
 
    struct GetUserProfileAction
    {
        std::string userId;
    };
 
    struct SetAvatarUrlAction
    {
        std::optional<std::string> avatarUrl;
    };
 
    struct SetDisplayNameAction
    {
        std::optional<std::string> displayName;
    };
 
    struct LoadEventsFromStorageAction
    {
        immer::map<std::string, EventList> timelineEvents;
        immer::map<std::string, EventList> relatedEvents;
    };
 
    struct PurgeRoomTimelineAction
    {
        immer::map<std::string, std::size_t> roomIdToMaxToKeepMap;
    };
 
    template<class Archive>
    void serialize(Archive &ar, ClientModel &m, std::uint32_t const version)
    {
        bool dummySyncing{false};
        ar
            & m.serverUrl
            & m.userId
            & m.token
            & m.deviceId
            & m.loggedIn
 
            & dummySyncing
            & m.firstRetryMs
            & m.retryTimeFactor
            & m.maxRetryMs
            & m.syncTimeoutMs
            & m.initialSyncFilterId
            & m.incrementalSyncFilterId
            & m.syncToken
 
            & m.roomList
            & m.presence
            & m.accountData
 
            & m.nextTxnId
 
            & m.toDevice;
        // version <= 1 uses std::optional<Crypto>
        // while version >= 2 uses std::optional<immer::box<Crypto>>
        if (version >= 2) {
            ar & m.crypto;
        } else {
            if constexpr (typename Archive::is_loading()) {
                std::optional<Crypto> crypto;
                ar >> crypto;
                if (crypto.has_value()) {
                    m.crypto = immer::box<Crypto>(std::move(crypto).value());
                }
            }
            // otherwise is_saving, which will always use the latest version
            // this is unreachable
        }
 
        ar
            & m.identityKeysUploaded
 
            & m.deviceLists
            ;
 
        if (version >= 1) { ar & m.trustLevelNeededToSendKeys; }
    }
}
 
BOOST_CLASS_VERSION(Kazv::ClientModel, 2)