nim_user_helper.h

Go to the documentation of this file.

 
#ifndef _NIM_SDK_CPP_USER_HELPER_H_
#define _NIM_SDK_CPP_USER_HELPER_H_
 
#include <assert.h>
#include <list>
#include <string>
#include "nim_define_include.h"
#include "nim_cpp_wrapper/nim_sdk_cpp_wrapper.h"
#include "nim_wrapper_util/nim_json_util.h"
#include "public_defines.h"
namespace nim {
NIM_SDK_CPPWRAPPER_DLL_API enum UserNameCardValueKey {
    kUserNameCardKeyNone = 0,           
    kUserNameCardKeyName = 1,           
    kUserNameCardKeyIconUrl = 1 << 1,   
    kUserNameCardKeyGender = 1 << 2,    
    kUserNameCardKeyBirthday = 1 << 3,  
    kUserNameCardKeyMobile = 1 << 4,    
    kUserNameCardKeyEmail = 1 << 5,     
    kUserNameCardKeySignature = 1 << 6, 
    kUserNameCardKeyEx = 1 << 7,        
    kUserNameCardKeyAll = (1 << 8) - 1  
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API UserNameCard {
    UserNameCard(const std::string& accid)
        : value_available_flag_(0)
        , create_timetag_(0)
        , update_timetag_(0)
        , gender_(0) {
        accid_ = accid;
    }
 
    UserNameCard()
        : value_available_flag_(0)
        , create_timetag_(0)
        , update_timetag_(0)
        , gender_(0) {}
 
public:
    void SetAccId(const std::string& id) { accid_ = id; }
 
    std::string GetAccId() const { return accid_; }
 
    void SetName(const std::string& name) {
        nickname_ = name;
        value_available_flag_ |= kUserNameCardKeyName;
    }
 
    std::string GetName() const { return nickname_; }
 
    void SetIconUrl(const std::string& url) {
        icon_url_ = url;
        value_available_flag_ |= kUserNameCardKeyIconUrl;
    }
 
    std::string GetIconUrl() const { return icon_url_; }
 
    void SetSignature(const std::string& sign) {
        signature_ = sign;
        value_available_flag_ |= kUserNameCardKeySignature;
    }
 
    std::string GetSignature() const { return signature_; }
 
    void SetGender(int gender) {
        gender_ = gender;
        value_available_flag_ |= kUserNameCardKeyGender;
    }
 
    int GetGender() const { return gender_; }
 
    void SetEmail(const std::string& email) {
        email_ = email;
        value_available_flag_ |= kUserNameCardKeyEmail;
    }
 
    std::string GetEmail() const { return email_; }
 
    void SetBirth(const std::string& birth) {
        birth_ = birth;
        value_available_flag_ |= kUserNameCardKeyBirthday;
    }
 
    std::string GetBirth() const { return birth_; }
 
    void SetMobile(const std::string& mobile) {
        mobile_ = mobile;
        value_available_flag_ |= kUserNameCardKeyMobile;
    }
 
    std::string GetMobile() const { return mobile_; }
 
    void SetExpand(const nim_cpp_wrapper_util::Json::Value& expand) {
        expand_ = expand;
        value_available_flag_ |= kUserNameCardKeyEx;
    }
 
    nim_cpp_wrapper_util::Json::Value GetExpand() const { return expand_; }
 
    void SetCreateTimetag(int64_t timetag) { create_timetag_ = timetag; }
 
    int64_t GetCreateTimetag() const { return create_timetag_; }
 
    void SetUpdateTimetag(int64_t timetag) { update_timetag_ = timetag; }
 
    int64_t GetUpdateTimetag() const { return update_timetag_; }
 
    void Update(const UserNameCard& namecard) {
        assert(namecard.GetAccId() == accid_);
        if (namecard.GetAccId() != accid_)
            return;
 
        if (namecard.ExistValue(kUserNameCardKeyName))
            SetName(namecard.GetName());
        if (namecard.ExistValue(kUserNameCardKeyIconUrl))
            SetIconUrl(namecard.GetIconUrl());
        if (namecard.ExistValue(kUserNameCardKeySignature))
            SetSignature(namecard.GetSignature());
        if (namecard.ExistValue(kUserNameCardKeyGender))
            SetGender(namecard.GetGender());
        if (namecard.ExistValue(kUserNameCardKeyEmail))
            SetEmail(namecard.GetEmail());
        if (namecard.ExistValue(kUserNameCardKeyBirthday))
            SetBirth(namecard.GetBirth());
        if (namecard.ExistValue(kUserNameCardKeyMobile))
            SetMobile(namecard.GetMobile());
        if (namecard.ExistValue(kUserNameCardKeyEx))
            SetExpand(namecard.GetExpand());
        if (namecard.GetCreateTimetag() > 0)
            create_timetag_ = namecard.GetCreateTimetag();
        if (namecard.GetUpdateTimetag() > 0)
            update_timetag_ = namecard.GetUpdateTimetag();
    }
 
    bool ExistValue(UserNameCardValueKey value_key) const { return (value_available_flag_ & value_key) != 0; }
 
    std::string ToJsonString() const {
        nim_cpp_wrapper_util::Json::Value values;
        values[kNIMNameCardKeyAccid] = GetAccId();
        if (ExistValue(kUserNameCardKeyName))
            values[kNIMNameCardKeyName] = GetName();
        if (ExistValue(kUserNameCardKeyIconUrl))
            values[kNIMNameCardKeyIcon] = GetIconUrl();
        if (ExistValue(kUserNameCardKeySignature))
            values[kNIMNameCardKeySign] = GetSignature();
        if (ExistValue(kUserNameCardKeyGender))
            values[kNIMNameCardKeyGender] = GetGender();
        if (ExistValue(kUserNameCardKeyEmail))
            values[kNIMNameCardKeyEmail] = GetEmail();
        if (ExistValue(kUserNameCardKeyBirthday))
            values[kNIMNameCardKeyBirth] = GetBirth();
        if (ExistValue(kUserNameCardKeyMobile))
            values[kNIMNameCardKeyMobile] = GetMobile();
        if (ExistValue(kUserNameCardKeyEx))
            values[kNIMNameCardKeyEx] = GetJsonStringWithNoStyled(GetExpand());
 
        return GetJsonStringWithNoStyled(values);
    }
 
private:
    std::string accid_;                        
    std::string nickname_;                     
    std::string icon_url_;                     
    std::string signature_;                    
    int gender_;                               
    std::string email_;                        
    std::string birth_;                        
    std::string mobile_;                       
    nim_cpp_wrapper_util::Json::Value expand_; 
    int64_t create_timetag_;                   
    int64_t update_timetag_;                   
    unsigned int value_available_flag_;
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API BlackMuteListInfo {
    std::string accid_;      
    bool set_black_;         
    bool set_mute_;          
    int64_t create_timetag_; 
    int64_t update_timetag_; 
    BlackMuteListInfo()
        : set_black_(false)
        , set_mute_(false)
        , create_timetag_(0)
        , update_timetag_(0) {}
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SpecialRelationshipChangeEvent {
    NIMUserSpecialRelationshipChangeType type_; 
    std::string content_; 
};
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseNameCards(const std::string& namecards_json, std::list<UserNameCard>& namecards);
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseNameCards(const nim_cpp_wrapper_util::Json::Value& namecards_json, std::list<UserNameCard>& namecards);
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseNameCard(const std::string& namecard_json, UserNameCard& namecard);
 
NIM_SDK_CPPWRAPPER_DLL_API void ParseNameCard(const nim_cpp_wrapper_util::Json::Value& namecard_json, UserNameCard& namecard);
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseSpecialListInfo(const std::string& list_json, std::list<BlackMuteListInfo>& black_mute_list);
}  // namespace nim
 
#endif  //_NIM_SDK_CPP_USER_HELPER_H_