nim_cpp_msglog.h

浏览该文件的文档.

 
#ifndef _NIM_SDK_CPP_MSGLOG_H_
#define _NIM_SDK_CPP_MSGLOG_H_
 
#include <functional>
#include <string>
#include "nim_cpp_wrapper/helper/nim_msglog_helper.h"
#include "nim_cpp_wrapper/helper/nim_talk_helper.h"
#include "nim_cpp_wrapper/nim_sdk_cpp_wrapper.h"
namespace nim {
class NIM_SDK_CPPWRAPPER_DLL_API MsgLog {
public:
    using QueryMsgCallback = std::function<void(NIMResCode, const std::string&, nim::NIMSessionType, const QueryMsglogResult&)>;
    using GetMessagesDynamicallyCallback = std::function<void(const GetMessagesResult&)>;
    using QuerySingleMsgCallback = std::function<void(NIMResCode, const std::string&, const IMMessage&)>;
    using ModifyMultipleMsglogCallback = std::function<void(NIMResCode, const std::string&, nim::NIMSessionType)>;
    using BatchStatusReadCallback = ModifyMultipleMsglogCallback;
    using BatchStatusDeleteCallback = ModifyMultipleMsglogCallback;
    using DeleteBySessionTypeCallback = ModifyMultipleMsglogCallback;
    using ModifySingleMsglogCallback = std::function<void(NIMResCode, const std::string&)>;
    using SetStatusCallback = ModifySingleMsglogCallback;
    using SetSubStatusCallback = ModifySingleMsglogCallback;
    using UpdateLocalExtCallback = ModifySingleMsglogCallback;
    using WriteMsglogCallback = ModifySingleMsglogCallback;
    using DeleteCallback = ModifySingleMsglogCallback;
    using DeleteMsglogSelfNotifyCallback = std::function<void(const DeleteMsglogSelfNotifyParam&)>;
    using DBFunctionCallback = std::function<void(NIMResCode)>;
    using DeleteMsglogSelfCallback = std::function<void(NIMResCode)>;
    using DeleteAllCallback = DBFunctionCallback;
    using DeleteMsgByTimeCallback = DBFunctionCallback;
    using ImportDbPrgCallback = std::function<void(int64_t, int64_t)>;
    using MessageStatusChangedCallback = std::function<void(const MessageStatusChangedResult&)>;
    using DeleteHistoryOnLineAsyncCallback = std::function<void(const NIMResCode, const std::string&)>;
    using DeleteHistoryOnLineAsyncExCallback =
        std::function<void(const NIMResCode, const std::string&, nim::NIMSessionType, uint64_t, const std::string&)>;
    using DeleteHistoryOnLineNotifyCallback = std::function<void(const std::list<NIMDeleteSessionHistoryMessagesNotifyInfo>&)>;
    using QueryMessageIsThreadRootAsyncCallback = std::function<void(const NIMResCode, const std::string&, bool, int)>;
    using QueryMessageOnlineCallback = std::function<void(const NIMResCode, const std::string&, const IMMessage&)>;
    using QueryThreadHistoryMsgCallback = std::function<void(const NIMResCode, const IMMessage&, int, uint64_t, const std::list<IMMessage>&)>;
    using FullTextSearchOnlineAsyncCallback = std::function<void(NIMResCode res_code, const QueryMsglogResult& message_list)>;
    using HistoryMessageFilter = std::function<bool(const IMMessage&)>;
 
    class NIM_SDK_CPPWRAPPER_DLL_API AllMessageTypeList {
    public:
        AllMessageTypeList();
        std::vector<nim::NIMMessageType> ExclusionType(const std::vector<nim::NIMMessageType>& exclusion_type_list) const;
 
    private:  // judge
        std::vector<nim::NIMMessageType> list_;
    };
 
    class NIM_SDK_CPPWRAPPER_DLL_API QueryMsgOnlineAsyncParam {
        friend class MsgLog;
 
    public:
        QueryMsgOnlineAsyncParam();
        std::string id_;
        nim::NIMSessionType to_type_;
        int limit_count_;
        int64_t from_time_;
        int64_t end_time_;
        int64_t end_msg_id_;
        bool reverse_;
        bool need_save_to_local_;
        bool replace_local_message_;
        bool auto_download_attachment_;
        std::vector<nim::NIMMessageType> msg_type_list_;
        bool is_exclusion_type_;
 
    private:
        bool FormatParam();
        const static AllMessageTypeList AllMsgTypeList;
        std::string json_extension_;
    };
 
    class NIM_SDK_CPPWRAPPER_DLL_API QueryMsgByKeywordOnlineParam {
        friend class MsgLog;
 
    public:
        QueryMsgByKeywordOnlineParam();
        std::string id_;
        std::string keyword_;
        nim::NIMSessionType to_type_;
        int limit_count_;
        int64_t from_time_;
        int64_t end_time_;
        bool reverse_;
 
    private:
        static bool FormatParam() { return true; };
        std::string json_extension_;
    };
 
    class NIM_SDK_CPPWRAPPER_DLL_API QueryMsgByKeywordParam {
    public:
        QueryMsgByKeywordParam() = default;
        std::string keyword_;
        std::string account_id_;
        nim::NIMSessionType to_type_{kNIMSessionTypeP2P};
        std::vector<nim::NIMMessageType> type_;
        uint32_t limit_count_{100};
        time_t from_time_{0};
        time_t end_time_{0};
        NIMMsglogSearchDirection direction_{kForward};
        NIMMsglogSearchSegmentEngine segment_engine_{kSegmentEngineSimple};
        bool enable_pinyin_{true};
    };
 
    class NIM_SDK_CPPWRAPPER_DLL_API QueryMsgAsyncParam {
    public:
        NIMSessionType to_type_;
        std::string from_account;
        std::string to_account;
        int64_t server_id;
        std::string client_id;
        int64_t time;
    };
 
    class NIM_SDK_CPPWRAPPER_DLL_API QueryThreadHistoryMsgAsyncParam {
    public:
        int64_t from_time;
        int64_t to_time;
        int64_t exclude_msg_id;
        int32_t limit;
        int32_t reverse;
    };
 
    class NIM_SDK_CPPWRAPPER_DLL_API QueryMsgByOptionsAsyncParam {
    public:
        QueryMsgByOptionsAsyncParam()
            : limit_count_(100)
            , reverse_(false) {}
 
        NIMMsgLogQueryRange query_range_;
        std::list<std::string> ids_;
        int limit_count_;
        int64_t from_time_;
        int64_t end_time_;
        std::string end_client_msg_id_;
        bool reverse_;
        NIMMessageType msg_type_;
        int32_t msg_sub_type_;
        std::string search_content_;
 
    public:
        std::string ToJsonString() const;
    };
 
    class NIM_SDK_CPPWRAPPER_DLL_API FullTextSearchOnlineAsyncParam {
    public:
        std::string keyword_;
        uint64_t from_time_{0};
        uint64_t to_time_{0};
        uint32_t session_limit_{0};
        uint32_t msglog_limit_{0};
        uint32_t search_rule_{0};
        std::list<std::string> p2p_filter_list_;
        std::list<std::string> team_filter_list_;
        std::list<std::string> sender_filter_list_;
        std::list<nim::NIMMessageType> msg_type_filter_list_;
        std::list<uint32_t> msg_sub_type_filter_list_;
 
        FullTextSearchOnlineAsyncParam()
            : from_time_(0)
            , to_time_(0)
            , session_limit_(20)
            , msglog_limit_(20)
            , search_rule_(0) {}
    };
 
    using IsMessageIndexEstablishedCallback = std::function<void(bool is_built)>;
 
    using BuildMsglogIndexesProgress = std::function<void(uint32_t total, uint32_t built_count)>;
 
    using BuildMsglogIndexesComplete = std::function<void(NIMBuildingMsglogIndexesCompleteReason reason, const std::string& message)>;
 
    static void UnregMsglogCb();
    static void RegDeleteMsglogSelfNotify(const DeleteMsglogSelfNotifyCallback& cb);
 
    static void RegDeleteHistoryMessagesNotify(const DeleteHistoryOnLineNotifyCallback& cb);
 
    static bool QueryMsgByIDAysnc(const std::string& client_msg_id, const QuerySingleMsgCallback& cb, const std::string& json_extension = "");
 
    static bool QueryMsgAsync(const std::string& account_id,
        nim::NIMSessionType to_type,
        int limit_count,
        int64_t anchor_msg_time,
        const QueryMsgCallback& cb,
        const std::string& json_extension = "");
 
    static void GetMessagesDynamically(const std::string& session_id,
        nim::NIMSessionType to_type,
        uint64_t from_time,
        uint64_t to_time,
        uint32_t limit_count,
        const std::string& anchor_client_msg_id,
        uint64_t anchor_server_msg_id,
        NIMMsglogSearchDirection direction,
        const GetMessagesDynamicallyCallback& cb,
        const std::string& json_extension = "");
 
    static bool QueryMsgOnlineAsync(const QueryMsgOnlineAsyncParam& param, const QueryMsgCallback& cb);
    static bool QueryMsgOnlineAsync(const std::string& id,
        nim::NIMSessionType to_type,
        int limit_count,
        int64_t from_time,
        int64_t end_time,
        int64_t end_msg_id,
        bool reverse,
        bool need_save_to_local,
        const QueryMsgCallback& cb,
        const std::string& json_extension = "");
 
    static void QueryMessagesByKeywordAsync(const QueryMsgByKeywordParam& param, const QueryMsgCallback& cb);
 
    static void IsMessageIndexEstablished(const IsMessageIndexEstablishedCallback& cb);
 
    static void BuildMsglogIndexes(uint32_t page_size, const BuildMsglogIndexesProgress& progress, const BuildMsglogIndexesComplete& completion);
 
    static void CancelMsglogIndexesBuilding();
 
    static bool QueryMsgByKeywordOnlineAsync(const MsgLog::QueryMsgByKeywordOnlineParam& param, const QueryMsgCallback& cb);
 
    static bool QueryMsgOfSpecifiedTypeInASessionAsync(nim::NIMSessionType to_type,
        const std::string& id,
        int limit_count,
        int64_t from_time,
        int64_t end_time,
        const std::string& end_client_msg_id,
        bool reverse,
        std::list<NIMMessageType> msg_type,
        const QueryMsgCallback& cb,
        const std::string& json_extension = "");
 
    static bool QueryMsgByOptionsAsync(NIMMsgLogQueryRange query_range,
        const std::list<std::string>& ids,
        int limit_count,
        int64_t from_time,
        int64_t end_time,
        const std::string& end_client_msg_id,
        bool reverse,
        NIMMessageType msg_type,
        const std::string& search_content,
        const QueryMsgCallback& cb,
        const std::string& json_extension = "");
 
    static bool QueryMsgByOptionsAsyncEx(const QueryMsgByOptionsAsyncParam& param, const QueryMsgCallback& cb);
 
    static bool BatchStatusReadAsync(const std::string& account_id,
        nim::NIMSessionType to_type,
        const BatchStatusReadCallback& cb,
        const std::string& json_extension = "");
 
    static bool BatchStatusDeleteAsync(const std::string& account_id,
        nim::NIMSessionType to_type,
        const BatchStatusDeleteCallback& cb,
        const std::string& json_extension = "");
 
    static bool BatchStatusDeleteAsyncEx(const std::string& account_id,
        nim::NIMSessionType to_type,
        bool revert_by_query_online,
        const BatchStatusDeleteCallback& cb,
        const std::string& json_extension = "");
 
    static bool SetStatusAsync(const std::string& msg_id,
        nim::NIMMsgLogStatus msglog_status,
        const SetStatusCallback& cb,
        const std::string& json_extension = "");
 
    static bool SetSubStatusAsync(const std::string& msg_id,
        nim::NIMMsgLogSubStatus msglog_sub_status,
        const SetSubStatusCallback& cb,
        const std::string& json_extension = "");
 
    static bool WriteMsglogToLocalAsync(const std::string& talk_id,
        const IMMessage& msg,
        bool need_update_session,
        const WriteMsglogCallback& cb,
        const std::string& json_extension = "");
 
    static bool WriteMsglogToLocalAsyncEx(const std::string& talk_id,
        const IMMessage& msg,
        bool need_update_session,
        bool compose_last_msg,
        const std::list<NIMMessageType>& exclude_msg_type,
        const WriteMsglogCallback& cb);
 
    static bool DeleteBySessionTypeAsync(bool delete_sessions,
        NIMSessionType to_type,
        const DeleteBySessionTypeCallback& cb,
        const std::string& json_extension = "");
 
    static bool DeleteBySessionTypeAsyncEx(bool delete_sessions,
        NIMSessionType to_type,
        bool revert_by_query_online,
        const DeleteBySessionTypeCallback& cb,
        const std::string& json_extension = "");
 
    static bool DeleteAsync(const std::string& session_id,
        NIMSessionType to_type,
        const std::string& msg_id,
        const DeleteCallback& cb,
        const std::string& json_extension = "");
 
    static bool DeleteAllAsync(bool delete_sessions, const DeleteAllCallback& cb, const std::string& json_extension = "");
 
    static bool DeleteAllAsyncEx(bool delete_sessions,
        bool revert_by_query_online,
        const DeleteAllCallback& cb,
        const std::string& json_extension = "");
 
    static bool DeleteMsgByTimeAsync(const std::string& session_id,
        NIMSessionType to_type,
        uint64_t timestamp1,
        uint64_t timestamp2,
        const DeleteMsgByTimeCallback& cb,
        const std::string& json_extension = "");
 
    static bool DeleteMsgByTimeAsyncEx(const std::string& session_id,
        NIMSessionType to_type,
        bool revert_by_query_online,
        uint64_t timestamp1,
        uint64_t timestamp2,
        const DeleteMsgByTimeCallback& cb,
        const std::string& json_extension = "");
 
    static bool ExportDbAsync(const std::string& dst_path, const DBFunctionCallback& cb, const std::string& json_extension = "");
 
    static bool ImportDbAsync(const std::string& src_path,
        const DBFunctionCallback& cb,
        const ImportDbPrgCallback& prg_cb,
        const std::string& json_extension = "");
 
    static void SendReceiptAsync(const std::string& json_msg, const MessageStatusChangedCallback& cb);
 
    static void SendReceiptAsync(const IMMessage& msg, const MessageStatusChangedCallback& cb);
 
    static bool QuerySentMessageBeReaded(const IMMessage& msg);
 
    static bool QueryReceivedMsgReceiptSent(const IMMessage& msg);
 
    static void RegMessageStatusChangedCb(const MessageStatusChangedCallback& cb, const std::string& json_extension = "");
 
    static void RegHistoryMessageFilterCb(const HistoryMessageFilter& filter);
 
    static bool UpdateLocalExtAsync(const std::string& msg_id,
        const std::string& local_ext,
        const UpdateLocalExtCallback& cb,
        const std::string& json_extension = "");
    static void UnregMsgologCb();
 
    static bool ReadAllAsync(const DBFunctionCallback& cb, const std::string& json_extension = "");
 
    static bool ExportBackupToRemote(const LogsBackupExportInfo& export_info);
 
    static bool ImportBackupFromRemote(const LogsBackupImportInfo& import_info);
 
    static void CancelImportBackupFromRemote();
 
    static void CancelExportBackupToRemote();
 
    static void DeleteHistoryOnlineAsync(const std::string& accid,
        bool delete_roaming,
        const std::string& json_extension,
        const DeleteHistoryOnLineAsyncCallback& cb);
 
    static void DeleteHistoryOnlineAsync(const std::string& accid,
        nim::NIMSessionType to_type,
        bool notify_self,
        const std::string& ext,
        const DeleteHistoryOnLineAsyncExCallback& cb);
 
    static void DeleteMessageSelfAsync(const IMMessage& msg, const std::string ext, const DeleteMsglogSelfCallback& cb);
 
    static void DeleteMessageSelfAsync(const std::list<std::tuple<IMMessage, std::string>>& msgs, const DeleteMsglogSelfCallback& cb);
 
    static void QueryMessageIsThreadRoot(const std::string msg_client_id, const QueryMessageIsThreadRootAsyncCallback& cb);
 
    static void QueryMessageOnline(const QueryMsgAsyncParam& param, const QueryMessageOnlineCallback& cb);
 
    static void QueryThreadHistoryMsg(const IMMessage& msg, const QueryThreadHistoryMsgAsyncParam& param, const QueryThreadHistoryMsgCallback& cb);
 
    static void QueryLocalThreadHistoryMsg(const IMMessage& msg, const QueryMsgCallback& cb);
 
    static void FullTextSearchOnlineAsync(const FullTextSearchOnlineAsyncParam& param, const FullTextSearchOnlineAsyncCallback& cb);
 
    static void QueryUnreadMessages(const std::string& session_id,
        NIMSessionType to_type,
        const QueryMsgCallback& cb,
        const std::string& json_extension = "");
};
}  // namespace nim
 
#endif  //_NIM_SDK_CPP_MSGLOG_H_