nim_msglog_helper.h

浏览该文件的文档.

 
#ifndef _NIM_SDK_CPP_MSGLOG_HELPER_H_
#define _NIM_SDK_CPP_MSGLOG_HELPER_H_
 
#include <functional>
#include <list>
#include <string>
#include "nim_cpp_wrapper/helper/nim_talk_helper.h"
#include "nim_cpp_wrapper/nim_sdk_cpp_wrapper.h"
namespace nim {
 
struct NIM_SDK_CPPWRAPPER_DLL_API QueryMsglogResult {
    int count_;
    NIMMsglogQuerySource source_;
    std::list<IMMessage> msglogs_;
 
    QueryMsglogResult()
        : count_(0)
        , source_(kNIMMsglogQuerySourceLocal) {}
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value values;
        for (auto& it : msglogs_) {
            nim_cpp_wrapper_util::Json::Value value = it.ToJsonObject(false);
            values.append(value);
        }
        return nim::GetJsonStringWithNoStyled(values);
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API GetMessagesResult {
    NIMResCode rescode{kNIMResSuccess};
    std::string session_id;
    NIMSessionType session_type{kNIMSessionTypeP2P};
    bool reliable{true};
    std::vector<IMMessage> messages;
    GetMessagesResult() = default;
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API DeleteMsglogSelfNotifyItemInfo {
    std::string session_id_; /*会话id */
    std::string client_id_;  /*消息ID */
    std::string ext_;        /*自定义字段 */
};
struct NIM_SDK_CPPWRAPPER_DLL_API DeleteMsglogSelfNotifyParam {
    std::list<DeleteMsglogSelfNotifyItemInfo> item_list;
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API MessageStatusChanged {
    NIMMsgLogStatus status_;
    std::string talk_id_;
    int64_t msg_timetag_;
 
    MessageStatusChanged()
        : msg_timetag_(0) {}
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API MessageStatusChangedResult {
    NIMResCode rescode_;
    std::list<MessageStatusChanged> results_;
 
    MessageStatusChangedResult(int rescode, std::string& result) {
        rescode_ = (NIMResCode)rescode;
        nim_cpp_wrapper_util::Json::Value values;
        if (nim::ParseJsonValue(result, values) && values.isArray()) {
            int size = values.size();
            for (int i = 0; i < size; i++) {
                MessageStatusChanged changed;
                changed.status_ = (NIMMsgLogStatus)values[i][kNIMMsglogStatusChangedKeyStatus].asUInt();
                changed.talk_id_ = values[i][kNIMMsglogStatusChangedKeyTalkID].asString();
                changed.msg_timetag_ = values[i][kNIMMsglogStatusChangedKeyMsgTimetag].asInt64();
                results_.push_back(changed);
            }
        }
    }
};
class NIM_SDK_CPPWRAPPER_DLL_API LogsBackupExportInfo : protected NIMLogsBackupExportInfo {
public:
    LogsBackupExportInfo()
        : cloned_(false) {
        ExportBackupToRemotePackageCallback = [](const std::string& file_path, void* user_data) {
            return file_path;
        };
        ExportBackupToRemoteEncryptCallback = [](const std::string& file_path, const std::string& encrypt_key, void* user_data) {
            return file_path;
        };
        ExportBackupToRemoteLogFiter = [](const IMMessage& msg, void* user_data) {
            return true;
        };
        LogsBackupProgressCallback = [](LogsBackupRemoteOperate, float, void* user_data) {};
        LogsBackupCompleteCallback = [](LogsBackupRemoteOperate, LogsBackupRemoteState state, void* user_data) {
            if (state >= LogsBackupRemoteState::LogsBackupRemoteState_FinalState_Begin)
                delete CastToCPP(user_data);
        };
    }
 
public:
    void SetEncryptKey(const std::string& encrypt_key) { encrypt_key_ = encrypt_key; }
    std::string GetEncryptKey() const { return encrypt_key_; }
    void SetUserData(void* user_data) { NIMLogsBackupExportInfo::user_data_ = user_data; }
    void* GetUserData() const { return NIMLogsBackupExportInfo::user_data_; }
    NIMLogsBackupExportInfo* ToCStruct() const {
        LogsBackupExportInfo* temp = new LogsBackupExportInfo(*this);
        temp->SetUserData(GetUserData());
        temp->cloned_ = true;
        return temp->ToCStruct_i();
    }
 
private:
    static inline LogsBackupExportInfo* CastToCPP(void* data) { return ((LogsBackupExportInfo*)(data)); }
    NIMLogsBackupExportInfo* ToCStruct_i();
 
public:
    std::function<std::string(const std::string& file_path, void* user_data)> ExportBackupToRemotePackageCallback;
 
    std::function<std::string(const std::string& file_path, const std::string& encrypt_key, void* user_data)> ExportBackupToRemoteEncryptCallback;
 
    std::function<bool(const IMMessage& msg, void* user_data)> ExportBackupToRemoteLogFiter;
    std::function<void(LogsBackupRemoteOperate op, float progress, void* user_data)> LogsBackupProgressCallback;
    std::function<void(LogsBackupRemoteOperate op, LogsBackupRemoteState state, void* user_data)> LogsBackupCompleteCallback;
 
    std::string encrypt_key_;
    void* src_user_data_;
    bool cloned_;
};
 
class NIM_SDK_CPPWRAPPER_DLL_API LogsBackupImportInfo : public NIMLogsBackupImportInfo {
public:
    LogsBackupImportInfo() {
        ImportBackupFromRemoteUnPackageCallback = [](const std::string& file_path, void* user_data) {
            return file_path;
        };
        ImportBackupFromRemoteDecryptCallback = [](const std::string& file_path, const std::string& encrypt_key, void* user_data) {
            return file_path;
        };
        LogsBackupProgressCallback = [](LogsBackupRemoteOperate, float, void* user_data) {};
        LogsBackupCompleteCallback = [](LogsBackupRemoteOperate, LogsBackupRemoteState state, void* user_data) {
            if (state >= LogsBackupRemoteState::LogsBackupRemoteState_FinalState_Begin)
                delete CastToCPP(user_data);
        };
    }
 
public:
    void SetUserData(void* user_data) { NIMLogsBackupImportInfo::user_data_ = user_data; }
    void* GetUserData() const { return NIMLogsBackupImportInfo::user_data_; }
    NIMLogsBackupImportInfo* ToCStruct() const {
        LogsBackupImportInfo* temp = new LogsBackupImportInfo(*this);
        temp->SetUserData(GetUserData());
        temp->cloned_ = true;
        return temp->ToCStruct_i();
    }
 
private:
    NIMLogsBackupImportInfo* ToCStruct_i();
    static inline LogsBackupImportInfo* CastToCPP(void* data) { return ((LogsBackupImportInfo*)(data)); }
 
public:
    std::function<std::string(const std::string& file_path, void* user_data)> ImportBackupFromRemoteUnPackageCallback;
 
    std::function<std::string(const std::string& file_path, const std::string& encrypt_key, void* user_data)> ImportBackupFromRemoteDecryptCallback;
 
    std::function<void(LogsBackupRemoteOperate, float, void* user_data)> LogsBackupProgressCallback;
 
    std::function<void(LogsBackupRemoteOperate, LogsBackupRemoteState, void* user_data)> LogsBackupCompleteCallback;
 
    bool cloned_;
    void* src_user_data_;
};
NIM_SDK_CPPWRAPPER_DLL_API bool ParseMsglogs(const std::string& msgs_json, QueryMsglogResult& res);
 
}  // namespace nim
 
#endif  //_NIM_SDK_CPP_MSGLOG_HELPER_H_