SBDBaseChannel.h

// Copyright (c) 2021 Sendbird, Inc. All rights reserved.
 
#ifndef SENDBIRD_SBDBASECHANNEL_H_
#define SENDBIRD_SBDBASECHANNEL_H_
 
#include "SBDUser.h"
#include "SBDBaseMessage.h"
#include "SBDUserMessage.h"
#include "SBDAdminMessage.h"
#include "SBDFileMessage.h"
#include "SBDUserMessageParams.h"
#include "SBDFileMessageParams.h"
#include "SBDError.h"
#include "SBDTypes.h"
 
#include <mutex>
#include <queue>
 
class SBDPreviousMessageListQuery;
class SBDThumbnailSize;
class SBDThumbnail;
class SBDFileMessage;
class SBDUserMessage;
class SBDGroupChannel;
class SBDOpenChannel;
class SBDOperatorListQuery;
class SBDBaseChannel;
class FSBDBaseChannel;
class SBDFileMessageParams;
 
class SBDChannelHandler {
public:
    virtual void MessageReceived(SBDBaseChannel* channel, SBDBaseMessage* message) {};
 
    virtual void MessageUpdated(SBDBaseChannel* channel, SBDBaseMessage* message) {};
 
    virtual void ReadReceiptUpdated(SBDGroupChannel* channel) {};
 
    virtual void InvitationReceived(SBDGroupChannel* channel, const std::vector<SBDUser>& invitees, SBDUser& inviter) {};
 
    virtual void InvitationDeclined(SBDGroupChannel* channel, SBDUser& invitee, SBDUser& inviter) {};
 
    virtual void UserJoined(SBDGroupChannel* channel, SBDUser& user) {};
 
    virtual void UserLeft(SBDGroupChannel* channel, SBDUser& user) {};
 
    virtual void UserEntered(SBDOpenChannel* channel, SBDUser& user) {};
 
    virtual void UserExited(SBDOpenChannel* channel, SBDUser& user) {};
 
    virtual void UserMuted(SBDOpenChannel* channel, SBDUser& user) {};
 
    virtual void UserUnmuted(SBDOpenChannel* channel, SBDUser& user) {};
 
    virtual void UserBanned(SBDOpenChannel* channel, SBDUser& user) {};
 
    virtual void UserUnbanned(SBDOpenChannel* channel, SBDUser& user) {};
 
    virtual void ChannelFrozen(SBDOpenChannel* channel) {};
 
    virtual void ChannelUnfrozen(SBDOpenChannel* channel) {};
 
    virtual void ChannelChanged(SBDBaseChannel* channel) {};
 
    virtual void ChannelDeleted(const std::wstring& channel_url, SBDChannelType channel_type) {};
 
    virtual void MessageDeleted(SBDBaseChannel* channel, uint64_t message_id) {};
 
    virtual void ChannelMetaDataCreated(SBDBaseChannel* channel, const std::map<std::wstring, std::wstring>& created_meta_data) {};
 
    virtual void ChannelMetaDataUpdated(SBDBaseChannel* channel, const std::map<std::wstring, std::wstring>& updated_meta_data) {};
 
    virtual void ChannelMetaDataDeleted(SBDBaseChannel* channel, const std::vector<std::wstring>& deleted_meta_data) {};
 
    virtual void ChannelMetaCountersCreated(SBDBaseChannel* channel, const std::map<std::wstring, int64_t>& created_meta_counters) {};
 
    virtual void ChannelMetaCountersUpdated(SBDBaseChannel* channel, const std::map<std::wstring, int64_t>& updated_meta_counters) {};
 
    virtual void ChannelMetaCountersDeleted(SBDBaseChannel* channel, const std::vector<std::wstring>& deleted_meta_counters) {};
 
    virtual void MentionReceived(SBDBaseChannel* channel, SBDBaseMessage* message) {};
 
    virtual void ChannelWasHidden(SBDGroupChannel* channel) {};
 
    virtual void OperatorUpdated(SBDBaseChannel* channel) {};
};
 
class SBDBaseChannel {
public:
    std::wstring channel_url;
 
    std::wstring name;
 
    std::wstring cover_url;
 
    int64_t created_at;
 
    std::wstring data;
 
    std::wstring custom_type;
 
    bool is_group_channel;
 
    bool is_open_channel;
 
    SBDUserMessage* SendUserMessage(SBDUserMessageParams& params, std::function<void(SBDUserMessage*, SBDError*)> completion_handler);
 
    SBDFileMessage* SendFileMessage(const char* file_buf, const std::wstring& filename, int64_t size, const std::wstring& type,
        std::vector<SBDThumbnailSize> thumbnail_sizes, const std::wstring& data, const std::wstring& custom_type,
        std::function<void(SBDFileMessage*, SBDError*)> completion_handler);
 
    SBDFileMessage* SendFileMessage(SBDFileMessageParams& params, std::function<void(SBDFileMessage*, SBDError*)> completion_handler);
 
    void DeleteMessage(SBDBaseMessage* message, std::function<void(SBDError*)> completion_handler);
 
    void UpdateUserMessage(SBDUserMessage* message, const std::wstring& message_text, const std::wstring& data, const std::wstring& custom_type,
        std::function<void(SBDUserMessage*, SBDError*)> completion_handler);
 
    void UpdateFileMessage(SBDFileMessage* message, const std::wstring& data, const std::wstring& custom_type, std::function<void(SBDFileMessage*, SBDError*)> completion_handler);
 
    SBDPreviousMessageListQuery* CreatePreviousMessageListQuery();
 
    void CreateMetaCounters(const std::map<std::wstring, int64_t>& meta_counters,
        std::function<void(const std::map<std::wstring, int64_t>& meta_counters, SBDError*)> completion_handler);
 
    void GetMetaCounters(const std::vector<std::wstring>& keys,
        std::function<void(const std::map<std::wstring, int64_t>& meta_counters, SBDError*)> completion_handler);
 
    void GetAllMetaCounters(std::function<void(const std::map<std::wstring, int64_t>& meta_counters, SBDError*)> completion_handler);
 
    void UpdateMetaCounters(const std::map<std::wstring, int64_t>& meta_counters,
        std::function<void(const std::map<std::wstring, int64_t>& meta_counters, SBDError*)> completion_handler);
 
    void IncreaseMetaCounters(const std::map<std::wstring, int64_t>& meta_counters,
        std::function<void(const std::map<std::wstring, int64_t>& meta_counters, SBDError*)> completion_handler);
 
    void DecreaseMetaCounters(const std::map<std::wstring, int64_t>& meta_counters,
        std::function<void(const std::map<std::wstring, int64_t>& meta_counters, SBDError*)> completion_handler);
 
    void DeleteMetaCounter(const std::wstring& key, std::function<void(SBDError*)> completion_handler);
 
    void DeleteAllMetaCounters(std::function<void(SBDError*)> completion_handler);
 
    void CreateMetaData(const std::map<std::wstring, std::wstring>& meta_data,
        std::function<void(const std::map<std::wstring, std::wstring>& meta_data, SBDError*)> completion_handler);
 
    void GetMetaData(const std::vector<std::wstring>& keys,
        std::function<void(const std::map<std::wstring, std::wstring>& meta_data, SBDError* error)> completion_handler);
 
    void GetAllMetaData(std::function<void(const std::map<std::wstring, std::wstring>& meta_data, SBDError* error)> completion_handler);
 
    void UpdateMetaData(const std::map<std::wstring, std::wstring>& meta_data,
        std::function<void(const std::map<std::wstring, std::wstring>& meta_data, SBDError*)> completion_handler);
 
    void DeleteMetaData(const std::wstring& key, std::function<void(SBDError*)> completion_handler);
 
    void DeleteAllMetaData(std::function<void(SBDError*)> completion_handler);
 
    void GetNextMessagesByTimestamp(int64_t timestamp, int64_t next_limit, bool reverse, SBDMessageTypeFilter message_type,
        const std::wstring& custom_type, std::function<void(const std::vector<SBDBaseMessage*>&, SBDError*)> completion_handler);
 
    void GetPreviousMessagesByTimestamp(int64_t timestamp, int64_t prev_limit, bool reverse, SBDMessageTypeFilter message_type,
        const std::wstring& custom_type, std::function<void(const std::vector<SBDBaseMessage*>&, SBDError*)> completion_handler);
 
    void GetMessagesByTimestamp(int64_t timestamp, int64_t prev_limit, int64_t next_limit, bool reverse, SBDMessageTypeFilter message_type,
        const std::wstring& custom_type, std::function<void(const std::vector<SBDBaseMessage*>&, SBDError*)> completion_handler);
 
    void GetNextMessagesByMessageId(int64_t message_id, int64_t next_limit, bool reverse, SBDMessageTypeFilter message_type, const std::wstring& custom_type,
        std::function<void(const std::vector<SBDBaseMessage*>&, SBDError*)> completion_handler);
 
    void GetPreviousMessagesByMessageId(int64_t message_id, int64_t prev_limit, bool reverse, SBDMessageTypeFilter message_type, const std::wstring& custom_type,
        std::function<void(const std::vector<SBDBaseMessage*>&, SBDError*)> completion_handler);
 
    void GetMessagesByMessageId(int64_t message_id, int64_t prev_limit, int64_t next_limit, bool reverse, SBDMessageTypeFilter message_type,
        const std::wstring& custom_type, std::function<void(const std::vector<SBDBaseMessage*>&, SBDError*)> completion_handler);
 
    void AddMessageMetaArrayValues(const std::wstring& channel_url, int64_t message_id, const std::map<std::wstring, std::vector<std::wstring>>& key_value,
        std::function<void(SBDBaseMessage*, SBDError*)> completion_handler);
 
    void AddMessageMetaArrayValues(const std::wstring& channel_url, int64_t message_id, const std::vector<SBDMessageMetaArray>& metaarrays,
        std::function<void(SBDBaseMessage*, SBDError*)> completion_handler);
 
    void RemoveMessageMetaArrayValues(const std::wstring& channel_url, int64_t message_id, const std::map<std::wstring, std::vector<std::wstring>>& key_value,
        std::function<void(SBDBaseMessage*, SBDError*)> completion_handler);
 
    void RemoveMessageMetaArrayValues(const std::wstring& channel_url, int64_t message_id, const std::vector<SBDMessageMetaArray>& metaarrays,
        std::function<void(SBDBaseMessage*, SBDError*)> completion_handler);
 
    void DeleteMessageMetaArrayKeys(const std::wstring& channel_url, int64_t message_id, const std::vector<std::wstring>& metaarray_keys,
        std::function<void(SBDBaseMessage*, SBDError*)> completion_handler);
 
    void CreateMessageMetaArrayKeys(const std::wstring& channel_url, int64_t message_id, const std::vector<std::wstring>& metaarray_keys,
        std::function<void(SBDBaseMessage*, SBDError*)> completion_handler);
 
    SBDUserMessage* CopyUserMessage(SBDUserMessage* message, SBDBaseChannel* target_channel, std::function<void(SBDUserMessage*, SBDError*)> completion_handler);
 
    SBDFileMessage* CopyFileMessage(SBDFileMessage* message, SBDBaseChannel* target_channel, std::function<void(SBDFileMessage*, SBDError*)> completion_handler);
 
    void AddOperators(const std::vector<std::wstring>& user_ids, std::function<void(SBDError*)> completion_handler);
 
    void RemoveOperators(const std::vector<std::wstring>& user_ids, std::function<void(SBDError*)> completion_handler);
 
    void RemoveAllOperators(std::function<void(SBDError*)> completion_handler);
 
    SBDOperatorListQuery* CreateOperatorListQuery();
 
    void Report(SBDReportCategory report_category, std::wstring report_description, std::function<void(SBDError*)> completion_handler);
 
    void ReportUser(SBDUser& offending_user, SBDReportCategory report_category, std::wstring report_description, std::function<void(SBDError*)> completion_handler);
 
    void ReportMessage(SBDBaseMessage* message, SBDReportCategory report_category, std::wstring report_description, std::function<void(SBDError*)> completion_handler);
 
 
protected:
    SBDBaseChannel(const std::string& dict);
    virtual ~SBDBaseChannel() {}
 
private:
    static std::queue<int64_t> message_id_queue;
    static std::queue<std::wstring> message_req_id_queue;
    static std::map<int64_t, std::shared_ptr<SBDBaseMessage>> message_id_map;
    static std::map<std::wstring, std::shared_ptr<SBDBaseMessage>> message_req_id_map;
    static std::mutex message_map_mutex;
    static SBDBaseMessage* UpsertMessage(SBDBaseMessage* msg);
 
    static void DeallocateAllMessages();
 
    SBDUserMessage* SendUserMessage(const std::wstring& message, const std::wstring& data, const std::wstring& custom_type,
        const std::vector<std::wstring>& target_languages, std::function<void(SBDUserMessage*, SBDError*)> completion_handler);
    SBDFileMessage* SendFileMessage(const std::wstring& url, const std::wstring& filename, int64_t size, const std::wstring& type,
        const std::wstring& data, const std::wstring& custom_type, std::function<void(SBDFileMessage*, SBDError*)> completion_handler);
    SBDFileMessage* SendFileMessageWithPath(const std::wstring& file_path, const std::wstring& type,
        std::vector<SBDThumbnailSize> thumbnail_sizes, const std::wstring& data, const std::wstring& custom_type,
        std::function<void(SBDFileMessage*, SBDError*)> completion_handler);
 
    friend FSBDBaseChannel;
};
 
#endif /* SENDBIRD_SBDBASECHANNEL_H_ */