conversationrepository.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2004-2026 Savoir-faire Linux Inc.
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
#pragma once
#include "def.h"
#include "vcard.h"
#include "git_def.h"
 
#include <opendht/default_types.h>
 
#include <optional>
#include <memory>
#include <string>
#include <vector>
 
namespace jami {
 
using DeviceId = dht::PkId;
 
constexpr auto EFETCH = 1;
constexpr auto EINVALIDMODE = 2;
constexpr auto EVALIDFETCH = 3;
constexpr auto EUNAUTHORIZED = 4;
constexpr auto ECOMMIT = 5;
 
class JamiAccount;
 
struct LogOptions
{
    std::string from {};
    std::string to {};
    uint64_t nbOfCommits {0};  // maximum number of commits wanted
    bool skipMerge {false};    // Do not include merge commits in the log. Used by the module to get
                               // last interaction without potential merges
    bool includeTo {false};    // If we want or not the "to" commit [from-to] or [from-to)
    bool fastLog {false};      // Do not parse content, used mostly to count
    bool logIfNotFound {true}; // Add a warning in the log if commit is not found
 
    std::string authorUri {}; // filter commits from author
};
 
struct Filter
{
    std::string author;
    std::string lastId;
    std::string regexSearch;
    std::string type;
    int64_t after {0};
    int64_t before {0};
    uint32_t maxResult {0};
    bool caseSensitive {false};
};
 
struct GitAuthor
{
    std::string name {};
    std::string email {};
};
 
enum class ConversationMode : int { ONE_TO_ONE = 0, ADMIN_INVITES_ONLY, INVITES_ONLY, PUBLIC };
 
struct ConversationCommit
{
    std::string id {};
    std::vector<std::string> parents {};
    GitAuthor author {};
    std::vector<uint8_t> signed_content {};
    std::vector<uint8_t> signature {};
    std::string commit_msg {};
    std::string linearized_parent {};
    int64_t timestamp {0};
};
 
enum class MemberRole { ADMIN = 0, MEMBER, INVITED, BANNED, LEFT };
 
namespace MemberPath {
 
static const std::filesystem::path ADMINS {"admins"};
static const std::filesystem::path MEMBERS {"members"};
static const std::filesystem::path INVITED {"invited"};
static const std::filesystem::path BANNED {"banned"};
static const std::filesystem::path DEVICES {"devices"};
 
} // namespace MemberPath
 
struct ConversationMember
{
    std::string uri;
    MemberRole role;
 
    std::map<std::string, std::string> map() const
    {
        std::string rolestr;
        if (role == MemberRole::ADMIN) {
            rolestr = "admin";
        } else if (role == MemberRole::MEMBER) {
            rolestr = "member";
        } else if (role == MemberRole::INVITED) {
            rolestr = "invited";
        } else if (role == MemberRole::BANNED) {
            rolestr = "banned";
        } else if (role == MemberRole::LEFT) {
            rolestr = "left"; // For one to one
        }
 
        return {{"uri", uri}, {"role", rolestr}};
    }
    MSGPACK_DEFINE(uri, role)
};
 
enum class CallbackResult { Skip, Break, Ok };
 
using PreConditionCb = std::function<CallbackResult(const std::string&, const GitAuthor&, const GitCommit&)>;
using PostConditionCb = std::function<bool(const std::string&, const GitAuthor&, ConversationCommit&)>;
using OnMembersChanged = std::function<void(const std::set<std::string>&)>;
 
class LIBJAMI_TEST_EXPORT ConversationRepository
{
public:
#ifdef LIBJAMI_TEST
    static bool DISABLE_RESET; // Some tests inject bad files so resetHard() will break the test
 
    // If true, clone and fetch operations will be performed directly using the target repo's path,
    // avoiding the need for setting up a GitServer and a DHTNet connection.
    static bool FETCH_FROM_LOCAL_REPOS;
#endif
    static LIBJAMI_TEST_EXPORT std::unique_ptr<ConversationRepository> createConversation(
        const std::shared_ptr<JamiAccount>& account,
        ConversationMode mode = ConversationMode::INVITES_ONLY,
        const std::string& otherMember = "");
 
    static LIBJAMI_TEST_EXPORT std::pair<std::unique_ptr<ConversationRepository>, std::vector<ConversationCommit>>
    cloneConversation(const std::shared_ptr<JamiAccount>& account,
                      const std::string& deviceId,
                      const std::string& conversationId);
 
    ConversationRepository(const std::shared_ptr<JamiAccount>& account, const std::string& id);
    ~ConversationRepository();
 
    std::string addMember(const std::string& uri);
 
    bool fetch(const std::string& remoteDeviceId);
 
    std::vector<std::map<std::string, std::string>> mergeHistory(
        const std::string& uri, std::function<void(const std::string&)>&& disconnectFromPeerCb = {});
 
    std::string remoteHead(const std::string& remoteDeviceId, const std::string& branch = "main") const;
 
    const std::string& id() const;
 
    std::string commitMessage(const std::string& msg, bool verifyDevice = true);
 
    std::vector<std::string> commitMessages(const std::vector<std::string>& msgs);
 
    std::string amend(const std::string& id, const std::string& msg);
 
    std::vector<ConversationCommit> log(const LogOptions& options = {}) const;
    void log(PreConditionCb&& preCondition,
             std::function<void(ConversationCommit&&)>&& emplaceCb,
             PostConditionCb&& postCondition,
             const std::string& from = "",
             bool logIfNotFound = true) const;
 
    bool hasCommit(const std::string& commitId) const;
    std::optional<ConversationCommit> getCommit(const std::string& commitId) const;
 
    std::optional<std::string> linearizedParent(const std::string& commitId) const;
 
    std::pair<bool, std::string> merge(const std::string& merge_id, bool force = false);
 
    std::string diffStats(const std::string& newId, const std::string& oldId = "") const;
 
    static std::vector<std::string> changedFiles(std::string_view diffStats);
 
    std::string join();
 
    std::string leave();
 
    void erase();
 
    ConversationMode mode() const;
 
    std::string voteKick(const std::string& uri, const std::string& type);
    std::string voteUnban(const std::string& uri, const std::string_view type);
    std::string resolveVote(const std::string& uri, const std::string_view type, const std::string& voteType);
 
    std::pair<std::vector<ConversationCommit>, bool> validFetch(const std::string& remoteDevice) const;
 
    std::pair<std::vector<ConversationCommit>, bool> validClone() const;
 
    bool isValidUserAtCommit(const std::string& userDevice,
                             const std::string& commitId,
                             const git_buf& sig,
                             const git_buf& sig_data) const;
 
    bool validCommits(const std::vector<ConversationCommit>& commitsToValidate) const;
 
    void removeBranchWith(const std::string& remoteDevice);
 
    std::vector<std::string> getInitialMembers() const;
 
    std::vector<ConversationMember> members() const;
 
    std::map<std::string, std::vector<DeviceId>> devices(bool ignoreExpired = true) const;
 
    std::set<std::string> memberUris(std::string_view filter, const std::set<MemberRole>& filteredRoles) const;
 
    void refreshMembers() const;
 
    void onMembersChanged(OnMembersChanged&& cb);
 
    void pinCertificates(bool blocking = false);
    std::string uriFromDevice(const std::string& deviceId) const;
 
    std::string updateInfos(const std::map<std::string, std::string>& map);
 
    std::map<std::string, std::string> infos() const;
    static std::map<std::string, std::string> infosFromVCard(vCard::utils::VCardData&& details);
 
    std::vector<std::map<std::string, std::string>> convCommitsToMap(
        const std::vector<ConversationCommit>& commits) const;
    std::optional<std::map<std::string, std::string>> convCommitToMap(const ConversationCommit& commit) const;
 
    std::string getHead() const;
 
private:
    ConversationRepository() = delete;
    class Impl;
    std::unique_ptr<Impl> pimpl_;
};
 
} // namespace jami
MSGPACK_ADD_ENUM(jami::MemberRole);
MSGPACK_ADD_ENUM(jami::ConversationMode);