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:
    typedef std::function<void(NIMResCode res_code, const std::string& id, nim::NIMSessionType to_type, const QueryMsglogResult& result)>
        QueryMsgCallback;
    typedef std::function<void(const GetMessagesResult& result)> GetMessagesDynamicallyCallback;
    typedef std::function<void(NIMResCode res_code, const std::string& msg_id, const IMMessage& msg)>
        QuerySingleMsgCallback;
    typedef std::function<void(NIMResCode res_code, const std::string& uid, nim::NIMSessionType to_type)>
        ModifyMultipleMsglogCallback;
    typedef ModifyMultipleMsglogCallback BatchStatusReadCallback;
    typedef ModifyMultipleMsglogCallback BatchStatusDeleteCallback;
    typedef ModifyMultipleMsglogCallback DeleteBySessionTypeCallback;
    typedef std::function<void(NIMResCode res_code, const std::string& msg_id)> ModifySingleMsglogCallback;
    typedef ModifySingleMsglogCallback SetStatusCallback;
    typedef ModifySingleMsglogCallback SetSubStatusCallback;
    typedef ModifySingleMsglogCallback UpdateLocalExtCallback;
    typedef ModifySingleMsglogCallback WriteMsglogCallback;
    typedef ModifySingleMsglogCallback DeleteCallback;
    typedef std::function<void(const DeleteMsglogSelfNotifyParam&)> DeleteMsglogSelfNotifyCallback;
 
    typedef std::function<void(NIMResCode res_code)> DBFunctionCallback;
    typedef std::function<void(NIMResCode res_code)> DeleteMsglogSelfCallback;
 
    typedef DBFunctionCallback DeleteAllCallback;
 
    typedef DBFunctionCallback DeleteMsgByTimeCallback;
 
    typedef std::function<void(int64_t imported_count, int64_t total_count)> ImportDbPrgCallback;
 
    typedef std::function<void(const MessageStatusChangedResult&)> MessageStatusChangedCallback;
 
    typedef std::function<void(const NIMResCode, const std::string&)>
        DeleteHistoryOnLineAsyncCallback;
    typedef std::function<void(const NIMResCode, const std::string&, nim::NIMSessionType, uint64_t, const std::string&)>
        DeleteHistoryOnLineAsyncExCallback;
    typedef std::function<void(const std::list<NIMDeleteSessionHistoryMessagesNotifyInfo>& info_list)>
        DeleteHistoryOnLineNotifyCallback;
    typedef std::function<void(const NIMResCode res_code, const std::string& client_id, bool is_root, int reply_count)>
        QueryMessageIsThreadRootAsyncCallback;
    typedef std::function<void(const NIMResCode res_code, const std::string& client_id, const IMMessage& msg)>
        QueryMessageOnlineCallback;
    typedef std::function<
        void(const NIMResCode res_code, const IMMessage& root_msg, int total, uint64_t last_msg_time, const std::list<IMMessage>& msg_list)>
        QueryThreadHistoryMsgCallback;
 
    using FullTextSearchOnlineAsyncCallback =
        std::function<void(NIMResCode res_code, const QueryMsglogResult& message_list)>;
 
    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 auto_download_attachment_;
        std::vector<nim::NIMMessageType> msg_type_list_;
        bool is_exclusion_type_;
 
    private:
        bool FormatParam();
 
    private:
        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:
        bool FormatParam() { return true; };
 
    private:
        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 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_