nim_sysmsg_helper.h

Go to the documentation of this file.

 
#ifndef _NIM_SDK_CPP_SYSMSG_HELPER_H_
#define _NIM_SDK_CPP_SYSMSG_HELPER_H_
 
#include <functional>
#include <list>
#include <string>
#include "nim_define_include.h"
#include "nim_cpp_wrapper/helper/nim_sdk_loader_helper.h"
#include "nim_cpp_wrapper/nim_sdk_cpp_wrapper.h"
#include "nim_wrapper_util/nim_json_util.h"
namespace nim {
struct NIM_SDK_CPPWRAPPER_DLL_API SysMessageSetting {
    BoolStatus need_push_;                           
    BoolStatus push_need_badge_;                     
    BoolStatus push_need_prefix_;                    
    BoolStatus need_offline_;                        
    nim_cpp_wrapper_util::Json::Value push_payload_; 
    std::string push_content_;                       
    BoolStatus anti_spam_enable_;                    
    std::string anti_spam_content_;                  
    std::string env_config_;                         
    SysMessageSetting()
        : need_push_(BS_NOT_INIT)
        , push_need_badge_(BS_NOT_INIT)
        , push_need_prefix_(BS_NOT_INIT)
        , need_offline_(BS_NOT_INIT)
        , anti_spam_enable_(BS_NOT_INIT) {}
 
    void ToJsonValue(nim_cpp_wrapper_util::Json::Value& message) const {
        if (push_need_badge_ != BS_NOT_INIT)
            message[kNIMSysMsgKeyPushNeedBadge] = push_need_badge_;
        if (need_push_ != BS_NOT_INIT)
            message[kNIMSysMsgKeyPushEnable] = need_push_;
        if (push_need_prefix_ != BS_NOT_INIT)
            message[kNIMSysMsgKeyPushNeedPrefix] = push_need_prefix_;
        if (need_offline_ != BS_NOT_INIT)
            message[kNIMSysMsgKeyCustomSaveFlag] = need_offline_;
        if (!push_payload_.empty())
            message[kNIMSysMsgKeyPushPayload] = GetJsonStringWithNoStyled(push_payload_);
        if (!push_content_.empty())
            message[kNIMSysMsgKeyCustomApnsText] = push_content_;
        if (anti_spam_enable_ != BS_NOT_INIT)
            message[kNIMSysMsgKeyAntiSpamEnable] = anti_spam_enable_ == BS_TRUE ? 1 : 0;
        if (!anti_spam_content_.empty())
            message[kNIMSysMsgKeyAntiSpamContent] = anti_spam_content_;
        if (!env_config_.empty())
            message[kNIMSysMsgKeyEnvConfig] = env_config_;
    }
 
    void ParseMessageSetting(const nim_cpp_wrapper_util::Json::Value& message) {
        if (message.isMember(kNIMSysMsgKeyPushNeedBadge))
            push_need_badge_ = (BoolStatus)message[kNIMSysMsgKeyPushNeedBadge].asInt() == 1 ? BS_TRUE : BS_FALSE;
        if (message.isMember(kNIMSysMsgKeyPushEnable))
            need_push_ = (BoolStatus)message[kNIMSysMsgKeyPushEnable].asInt() == 1 ? BS_TRUE : BS_FALSE;
        if (message.isMember(kNIMSysMsgKeyPushNeedPrefix))
            push_need_prefix_ = (BoolStatus)message[kNIMSysMsgKeyPushNeedPrefix].asInt() == 1 ? BS_TRUE : BS_FALSE;
        if (message.isMember(kNIMSysMsgKeyCustomSaveFlag))
            need_offline_ = (BoolStatus)message[kNIMSysMsgKeyCustomSaveFlag].asInt() == 1 ? BS_TRUE : BS_FALSE;
        nim_cpp_wrapper_util::Json::Reader reader;
        if (!reader.parse(message[kNIMSysMsgKeyPushPayload].asString(), push_payload_) || !push_payload_.isObject())
            // assert(0);
            push_content_ = message[kNIMSysMsgKeyCustomApnsText].asString();
        if (message.isMember(kNIMSysMsgKeyAntiSpamEnable))
            anti_spam_enable_ = message[kNIMSysMsgKeyAntiSpamEnable].asInt() == 1 ? BS_TRUE : BS_FALSE;
        anti_spam_content_ = message[kNIMSysMsgKeyAntiSpamContent].asString();
        if (message.isMember(kNIMSysMsgKeyEnvConfig))
            env_config_ = message[kNIMSysMsgKeyEnvConfig].asString();
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SysMessage {
    int64_t timetag_;               
    NIMSysMsgType type_;            
    std::string receiver_accid_;    
    std::string sender_accid_;      
    std::string content_;           
    std::string attach_;            
    int64_t id_;                    
    NIMSysMsgStatus status_;        
    SysMessageSetting msg_setting_; 
    NIMResCode rescode_;        
    NIMMessageFeature feature_; 
    int total_unread_count_;    
    std::string client_msg_id_; 
    std::string callbac_ext_;   
    SysMessage()
        : timetag_(0)
        , id_(0)
        , total_unread_count_(0)
        , type_(kNIMSysMsgTypeUnknown)
        , status_(kNIMSysMsgStatusNone)
        , feature_(kNIMMessageFeatureDefault) {}
 
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value values;
        values[kNIMSysMsgKeyToAccount] = receiver_accid_;
        values[kNIMSysMsgKeyFromAccount] = sender_accid_;
        values[kNIMSysMsgKeyType] = type_;
        values[kNIMSysMsgKeyAttach] = attach_;
        values[kNIMSysMsgKeyMsg] = content_;
        values[kNIMSysMsgKeyLocalClientMsgId] = client_msg_id_;
        values[kNIMSysMsgKeyTime] = timetag_;
        values[kNIMSysMsgKeyMsgId] = id_;
        values[kNIMSysMsgKeyLocalStatus] = status_;
        msg_setting_.ToJsonValue(values);
        return GetJsonStringWithNoStyled(values);
    }
};
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseSysMessage(const std::string& sysmsg_json, SysMessage& msg);
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseSysMessages(const std::string& sysmsgs_json, std::list<SysMessage>& msgs, int* unread);
 
NIM_SDK_CPPWRAPPER_DLL_API void ParseSysMessageContent(const nim_cpp_wrapper_util::Json::Value& content_json, SysMessage& msg);
}  // namespace nim
 
#endif  //_NIM_SDK_CPP_SYSMSG_HELPER_H_