conversationrepository.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2004-2025 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 <optional>
#include <git2.h>
#include <memory>
#include <opendht/default_types.h>
#include <string>
#include <vector>
 
#include "def.h"
 
using GitPackBuilder = std::unique_ptr<git_packbuilder, decltype(&git_packbuilder_free)>;
using GitRepository = std::unique_ptr<git_repository, decltype(&git_repository_free)>;
using GitRevWalker = std::unique_ptr<git_revwalk, decltype(&git_revwalk_free)>;
using GitCommit = std::unique_ptr<git_commit, decltype(&git_commit_free)>;
using GitAnnotatedCommit
    = std::unique_ptr<git_annotated_commit, decltype(&git_annotated_commit_free)>;
using GitIndex = std::unique_ptr<git_index, decltype(&git_index_free)>;
using GitTree = std::unique_ptr<git_tree, decltype(&git_tree_free)>;
using GitRemote = std::unique_ptr<git_remote, decltype(&git_remote_free)>;
using GitReference = std::unique_ptr<git_reference, decltype(&git_reference_free)>;
using GitSignature = std::unique_ptr<git_signature, decltype(&git_signature_free)>;
using GitObject = std::unique_ptr<git_object, decltype(&git_object_free)>;
using GitDiff = std::unique_ptr<git_diff, decltype(&git_diff_free)>;
using GitDiffStats = std::unique_ptr<git_diff_stats, decltype(&git_diff_stats_free)>;
using GitIndexConflictIterator
    = std::unique_ptr<git_index_conflict_iterator, decltype(&git_index_conflict_iterator_free)>;
 
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 };
 
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
    #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::unique_ptr<ConversationRepository> cloneConversation(
        const std::shared_ptr<JamiAccount>& account,
        const std::string& deviceId,
        const std::string& conversationId,
        std::function<void(std::vector<ConversationCommit>)>&& checkCommitCb = {});
 
    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::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;
    std::optional<ConversationCommit> getCommit(const std::string& commitId,
                                                bool logIfNotFound = true) 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 mergeBase(const std::string& from, const std::string& to) const;
 
    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;
    bool validClone(std::function<void(std::vector<ConversationCommit>)>&& checkCommitCb) 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(
        std::map<std::string, std::string>&& 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);