nim_team_helper.h

Go to the documentation of this file.

 
#ifndef _NIM_SDK_CPP_TEAM_HELPER_H_
#define _NIM_SDK_CPP_TEAM_HELPER_H_
 
#include <functional>
#include <list>
#include <string>
#include "nim_cpp_wrapper/helper/nim_sdk_loader_helper.h"
#include "nim_cpp_wrapper/helper/nim_user_helper.h"
#include "nim_cpp_wrapper/nim_sdk_cpp_wrapper.h"
#include "nim_define_include.h"
#include "nim_wrapper_util/nim_json_util.h"
namespace nim {
struct NIM_SDK_CPPWRAPPER_DLL_API TeamInfo {
public:
    TeamInfo(const std::string& team_id, const nim::NIMTeamType type) {
        team_info_json_value_[nim::kNIMTeamInfoKeyID] = team_id;
        team_info_json_value_[nim::kNIMTeamInfoKeyType] = type;
    }
 
    TeamInfo() {}
 
public:
    void operator=(const TeamInfo& new_info) { Update(new_info); }
 
    void Update(const TeamInfo& new_info) {
        if (new_info.ExistValue(kNIMTeamInfoKeyName))
            SetName(new_info.GetName());
        if (new_info.ExistValue(kNIMTeamInfoKeyType))
            SetType(new_info.GetType());
        if (new_info.ExistValue(kNIMTeamInfoKeyCreator))
            SetOwnerID(new_info.GetOwnerID());
        if (new_info.ExistValue(kNIMTeamInfoKeyLevel))
            SetLevel(new_info.GetLevel());
        if (new_info.ExistValue(kNIMTeamInfoKeyProperty))
            SetProperty(new_info.GetProperty());
        if (new_info.ExistValue(kNIMTeamInfoKeyIntro))
            SetIntro(new_info.GetIntro());
        if (new_info.ExistValue(kNIMTeamInfoKeyAnnouncement))
            SetAnnouncement(new_info.GetAnnouncement());
        if (new_info.ExistValue(kNIMTeamInfoKeyJoinMode))
            SetJoinMode(new_info.GetJoinMode());
        // 群属性,开发者无需关注 20161011 by Oleg
        // if (new_info.ExistValue(kTeamInfoKeyConfigBits))
        //    SetConfigBits(new_info.GetConfigBits());
        if (new_info.ExistValue(kNIMTeamInfoKeyCustom))
            SetCustom(new_info.GetCustom());
        if (new_info.ExistValue(kNIMTeamInfoKeyIcon))
            SetIcon(new_info.GetIcon());
        if (new_info.ExistValue(kNIMTeamInfoKeyBeInviteMode))
            SetBeInviteMode(new_info.GetBeInviteMode());
        if (new_info.ExistValue(kNIMTeamInfoKeyInviteMode))
            SetInviteMode(new_info.GetInviteMode());
        if (new_info.ExistValue(kNIMTeamInfoKeyUpdateInfoMode))
            SetUpdateInfoMode(new_info.GetUpdateInfoMode());
        if (new_info.ExistValue(kNIMTeamInfoKeyUpdateCustomMode))
            SetUpdateCustomMode(new_info.GetUpdateCustomMode());
        if (new_info.ExistValue(kNIMTeamInfoKeyID))
            SetTeamID(new_info.GetTeamID());
        if (new_info.ExistValue(kNIMTeamInfoKeyValidFlag))
            SetValid(new_info.IsValid());
        if (new_info.ExistValue(kNIMTeamInfoKeyMemberValid))
            SetMemberValid(new_info.IsMemberValid());
        if (new_info.ExistValue(kNIMTeamInfoKeyMemberCount))
            SetMemberCount(new_info.GetMemberCount());
        if (new_info.ExistValue(kNIMTeamInfoKeyListTime))
            SetMemberListTimetag(new_info.GetMemberListTimetag());
        if (new_info.ExistValue(kNIMTeamInfoKeyCreateTime))
            SetCreateTimetag(new_info.GetCreateTimetag());
        if (new_info.ExistValue(kNIMTeamInfoKeyUpdateTime))
            SetUpdateTimetag(new_info.GetUpdateTimetag());
        if (new_info.ExistValue(kNIMTeamInfoKeyServerCustom))
            SetServerCustom(new_info.GetServerCustom());
        if (new_info.ExistValue(kNIMTeamInfoKeyMuteAll) || new_info.ExistValue(kNIMTeamInfoKeyMuteType))
            SetMute(new_info.GetMuteType());
    }
 
public:
    void SetTeamID(const std::string& id) { team_info_json_value_[nim::kNIMTeamInfoKeyID] = id; }
 
    std::string GetTeamID() const { return team_info_json_value_[nim::kNIMTeamInfoKeyID].asString(); }
 
    void SetName(const std::string& name) { team_info_json_value_[nim::kNIMTeamInfoKeyName] = name; }
 
    std::string GetName() const { return team_info_json_value_[nim::kNIMTeamInfoKeyName].asString(); }
 
    void SetType(nim::NIMTeamType type) { team_info_json_value_[nim::kNIMTeamInfoKeyType] = type; }
 
    nim::NIMTeamType GetType() const { return (NIMTeamType)team_info_json_value_[nim::kNIMTeamInfoKeyType].asUInt(); }
 
    void SetOwnerID(const std::string& id) { team_info_json_value_[nim::kNIMTeamInfoKeyCreator] = id; }
 
    std::string GetOwnerID() const { return team_info_json_value_[nim::kNIMTeamInfoKeyCreator].asString(); }
    void SetMemberMaxCount(int count) {
        team_info_json_value_[nim::kNIMTeamInfoKeyMemberMaxCount] = count;
        team_info_json_value_[nim::kNIMTeamInfoKeyLevel] = count;
    }
 
    int GetMemberMaxCount() const { return team_info_json_value_[nim::kNIMTeamInfoKeyMemberMaxCount].asUInt(); }
    void SetProperty(const std::string& prop) { team_info_json_value_[nim::kNIMTeamInfoKeyProperty] = prop; }
 
    std::string GetProperty() const { return team_info_json_value_[nim::kNIMTeamInfoKeyProperty].asString(); }
 
    void SetValid(bool valid) { team_info_json_value_[nim::kNIMTeamInfoKeyValidFlag] = valid ? 1 : 0; }
 
    bool IsValid() const { return team_info_json_value_[nim::kNIMTeamInfoKeyValidFlag].asUInt() == 1; }
 
    void SetMemberCount(int count) { team_info_json_value_[nim::kNIMTeamInfoKeyMemberCount] = count; }
 
    int GetMemberCount() const { return team_info_json_value_[nim::kNIMTeamInfoKeyMemberCount].asUInt(); }
 
    void SetMemberListTimetag(int64_t timetag) { team_info_json_value_[nim::kNIMTeamInfoKeyListTime] = timetag; }
 
    int64_t GetMemberListTimetag() const { return team_info_json_value_[nim::kNIMTeamInfoKeyListTime].asUInt64(); }
 
    void SetCreateTimetag(int64_t timetag) { team_info_json_value_[nim::kNIMTeamInfoKeyCreateTime] = timetag; }
 
    int64_t GetCreateTimetag() const { return team_info_json_value_[nim::kNIMTeamInfoKeyCreateTime].asUInt64(); }
 
    void SetUpdateTimetag(int64_t timetag) { team_info_json_value_[nim::kNIMTeamInfoKeyUpdateTime] = timetag; }
 
    int64_t GetUpdateTimetag() const { return team_info_json_value_[nim::kNIMTeamInfoKeyUpdateTime].asUInt64(); }
 
    void SetMemberValid(bool valid) { team_info_json_value_[nim::kNIMTeamInfoKeyMemberValid] = valid ? 1 : 0; }
 
    bool IsMemberValid() const { return team_info_json_value_[nim::kNIMTeamInfoKeyMemberValid].asUInt() == 1; }
 
    void SetIntro(const std::string& intro) { team_info_json_value_[nim::kNIMTeamInfoKeyIntro] = intro; }
 
    std::string GetIntro() const { return team_info_json_value_[nim::kNIMTeamInfoKeyIntro].asString(); }
 
    void SetAnnouncement(const std::string& announcement) { team_info_json_value_[nim::kNIMTeamInfoKeyAnnouncement] = announcement; }
 
    std::string GetAnnouncement() const { return team_info_json_value_[nim::kNIMTeamInfoKeyAnnouncement].asString(); }
 
    void SetJoinMode(nim::NIMTeamJoinMode mode) { team_info_json_value_[nim::kNIMTeamInfoKeyJoinMode] = mode; }
 
    nim::NIMTeamJoinMode GetJoinMode() const { return (NIMTeamJoinMode)team_info_json_value_[nim::kNIMTeamInfoKeyJoinMode].asUInt(); }
 
    // void SetConfigBits(int64_t bit)
    //{
    //    team_info_json_value_[nim::kNIMTeamInfoKeyBits] = bit;
    //}
 
    // int64_t GetConfigBits() const
    //{
    //    return team_info_json_value_[nim::kNIMTeamInfoKeyBits].asUInt64();
    //}
 
    void SetCustom(const std::string& custom) { team_info_json_value_[nim::kNIMTeamInfoKeyCustom] = custom; }
 
    std::string GetCustom() const { return team_info_json_value_[nim::kNIMTeamInfoKeyCustom].asString(); }
 
    void SetServerCustom(const std::string& custom) { team_info_json_value_[nim::kNIMTeamInfoKeyServerCustom] = custom; }
 
    std::string GetServerCustom() const { return team_info_json_value_[nim::kNIMTeamInfoKeyServerCustom].asString(); }
 
    void SetIcon(const std::string& icon) { team_info_json_value_[nim::kNIMTeamInfoKeyIcon] = icon; }
 
    std::string GetIcon() const { return team_info_json_value_[nim::kNIMTeamInfoKeyIcon].asString(); }
 
    void SetBeInviteMode(NIMTeamBeInviteMode mode) { team_info_json_value_[nim::kNIMTeamInfoKeyBeInviteMode] = mode; }
 
    NIMTeamBeInviteMode GetBeInviteMode() const { return (NIMTeamBeInviteMode)team_info_json_value_[nim::kNIMTeamInfoKeyBeInviteMode].asUInt(); }
 
    void SetInviteMode(NIMTeamInviteMode mode) { team_info_json_value_[nim::kNIMTeamInfoKeyInviteMode] = mode; }
 
    NIMTeamInviteMode GetInviteMode() const { return (NIMTeamInviteMode)team_info_json_value_[nim::kNIMTeamInfoKeyInviteMode].asUInt(); }
 
    void SetUpdateInfoMode(NIMTeamUpdateInfoMode mode) { team_info_json_value_[nim::kNIMTeamInfoKeyUpdateInfoMode] = mode; }
 
    NIMTeamUpdateInfoMode GetUpdateInfoMode() const {
        return (NIMTeamUpdateInfoMode)team_info_json_value_[nim::kNIMTeamInfoKeyUpdateInfoMode].asUInt();
    }
 
    void SetUpdateCustomMode(NIMTeamUpdateCustomMode mode) { team_info_json_value_[nim::kNIMTeamInfoKeyUpdateCustomMode] = mode; }
 
    NIMTeamUpdateCustomMode GetUpdateCustomMode() const {
        return (NIMTeamUpdateCustomMode)team_info_json_value_[nim::kNIMTeamInfoKeyUpdateCustomMode].asUInt();
    }
    void SetMute(NIMTeamMuteType mute_type) { team_info_json_value_[nim::kNIMTeamInfoKeyMuteType] = mute_type; }
 
    NIMTeamMuteType GetMuteType() const {
        if (team_info_json_value_.isMember(nim::kNIMTeamInfoKeyMuteAll) && team_info_json_value_[nim::kNIMTeamInfoKeyMuteAll].asUInt() == 1)
            return kNIMTeamMuteTypeNomalMute;
        return (NIMTeamMuteType)team_info_json_value_[nim::kNIMTeamInfoKeyMuteType].asUInt();
    }
 
    bool ExistValue(const std::string& nim_team_info_key) const { return team_info_json_value_.isMember(nim_team_info_key); }
 
    std::string ToJsonString() const { return GetJsonStringWithNoStyled(team_info_json_value_); }
 
    nim_cpp_wrapper_util::Json::Value ToJsonValue() const { return team_info_json_value_; }
 
private:
    void SetLevel(int level) { team_info_json_value_[nim::kNIMTeamInfoKeyLevel] = level; }
 
    int GetLevel() const { return team_info_json_value_[nim::kNIMTeamInfoKeyLevel].asUInt(); }
 
private:
    nim_cpp_wrapper_util::Json::Value team_info_json_value_;
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API TeamMemberProperty {
public:
    TeamMemberProperty(const std::string& team_id, const std::string& accid, const nim::NIMTeamUserType type) {
        member_info_json_value_[kNIMTeamUserKeyID] = team_id;
        member_info_json_value_[kNIMTeamUserKeyAccID] = accid;
        member_info_json_value_[kNIMTeamUserKeyType] = type;
    }
 
    TeamMemberProperty() {}
 
public:
    void SetTeamID(const std::string& id) { member_info_json_value_[kNIMTeamUserKeyID] = id; }
 
    std::string GetTeamID() const { return member_info_json_value_[kNIMTeamUserKeyID].asString(); }
 
    void SetAccountID(const std::string& id) { member_info_json_value_[kNIMTeamUserKeyAccID] = id; }
 
    std::string GetAccountID() const { return member_info_json_value_[kNIMTeamUserKeyAccID].asString(); }
 
    void SetUserType(nim::NIMTeamUserType type) { member_info_json_value_[kNIMTeamUserKeyType] = type; }
 
    nim::NIMTeamUserType GetUserType() const { return (nim::NIMTeamUserType)member_info_json_value_[kNIMTeamUserKeyType].asUInt(); }
 
    void SetNick(const std::string& nick) { member_info_json_value_[kNIMTeamUserKeyNick] = nick; }
 
    std::string GetNick() const { return member_info_json_value_[kNIMTeamUserKeyNick].asString(); }
 
    void SetBits(int64_t bit) { member_info_json_value_[kNIMTeamUserKeyBits] = bit; }
 
    int64_t GetBits() const { return member_info_json_value_[kNIMTeamUserKeyBits].asUInt64(); }
 
    void SetValid(bool valid) { member_info_json_value_[kNIMTeamUserKeyValidFlag] = valid ? 1 : 0; }
 
    bool IsValid() const { return member_info_json_value_[kNIMTeamUserKeyValidFlag].asUInt() == 1; }
 
    void SetCreateTimetag(int64_t timetag) { member_info_json_value_[kNIMTeamUserKeyCreateTime] = timetag; }
 
    int64_t GetCreateTimetag() const { return member_info_json_value_[kNIMTeamUserKeyCreateTime].asUInt64(); }
 
    void SetUpdateTimetag(int64_t timetag) { member_info_json_value_[kNIMTeamUserKeyUpdateTime] = timetag; }
 
    int64_t GetUpdateTimetag() const { return member_info_json_value_[kNIMTeamUserKeyUpdateTime].asUInt64(); }
 
    void SetMute(bool mute) { member_info_json_value_[kNIMTeamUserKeyMute] = mute ? 1 : 0; }
 
    bool IsMute() const { return member_info_json_value_[kNIMTeamUserKeyMute].asUInt() == 1; }
 
    void SetCustom(const std::string& custom) { member_info_json_value_[kNIMTeamUserKeyCustom] = custom; }
    std::string GetCustom() const { return member_info_json_value_[kNIMTeamUserKeyCustom].asString(); }
    void SetInvitorAccID(const std::string& invitor_accid) { member_info_json_value_[kNIMTeamUserKeyInvitorAccID] = invitor_accid; }
    std::string GetInvitorAccID() const { return member_info_json_value_[kNIMTeamUserKeyInvitorAccID].asString(); }
    bool ExistValue(const std::string& nim_team_user_key) const { return member_info_json_value_.isMember(nim_team_user_key); }
 
    std::string ToJsonString() const { return GetJsonStringWithNoStyled(member_info_json_value_); }
 
    nim_cpp_wrapper_util::Json::Value ToJsonValue() const { return member_info_json_value_; }
 
private:
    nim_cpp_wrapper_util::Json::Value member_info_json_value_;
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API TeamEvent {
    NIMResCode res_code_;               
    NIMNotificationId notification_id_; 
    std::string team_id_;               
    std::list<std::string> ids_;        
    std::list<std::string> invalid_ids_; 
    std::list<UserNameCard> namecards_;          
    TeamInfo team_info_;                         
    TeamMemberProperty member_property_;         
    bool opt_;                                   
    std::string attach_;                         
    nim_cpp_wrapper_util::Json::Value src_data_; 
};
 
NIM_SDK_CPPWRAPPER_DLL_API void ParseTeamEvent(int rescode,
                                               const std::string& team_id,
                                               const NIMNotificationId notification_id,
                                               const std::string& team_event_json,
                                               TeamEvent& team_event);
 
NIM_SDK_CPPWRAPPER_DLL_API void ParseTeamInfoJson(const nim_cpp_wrapper_util::Json::Value& team_info_json, TeamInfo& team_info);
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseTeamInfoJson(const std::string& team_info_json, TeamInfo& team_info);
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseTeamInfosJson(const std::string& team_infos_json, std::list<TeamInfo>& team_infos);
 
NIM_SDK_CPPWRAPPER_DLL_API void ParseTeamMemberPropertyJson(const nim_cpp_wrapper_util::Json::Value& team_member_prop_json,
                                                            TeamMemberProperty& team_member_property);
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseTeamMemberPropertyJson(const std::string& team_member_prop_json, TeamMemberProperty& team_member_property);
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseTeamMemberPropertysJson(const std::string& team_member_props_json,
                                                             std::list<TeamMemberProperty>& team_member_propertys);
}  // namespace nim
 
#endif  //_NIM_SDK_CPP_TEAM_HELPER_H_