nim_super_team_helper.h

浏览该文件的文档.

 
#ifndef _NIM_SDK_CPP_SUPERTEAM_HELPER_H_
#define _NIM_SDK_CPP_SUPERTEAM_HELPER_H_
 
#include <functional>
#include <list>
#include <set>
#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"
namespace nim {
struct NIM_SDK_CPPWRAPPER_DLL_API SuperTeamInfo {
public:
    SuperTeamInfo(const std::string& team_id) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyID] = team_id; }
 
    SuperTeamInfo() {}
 
public:
    void operator=(const SuperTeamInfo& new_info) { Update(new_info); }
 
    void Update(const SuperTeamInfo& new_info) {
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyName))
            SetName(new_info.GetName());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyCreator))
            SetOwnerID(new_info.GetOwnerID());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyLevel))
            SetLevel(new_info.GetLevel());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyProperty))
            SetProperty(new_info.GetProperty());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyIntro))
            SetIntro(new_info.GetIntro());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyAnnouncement))
            SetAnnouncement(new_info.GetAnnouncement());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyJoinMode))
            SetJoinMode(new_info.GetJoinMode());
        // 群属性,开发者无需关注 20161011 by Oleg
        // if (new_info.ExistValue(kSuperTeamInfoKeyConfigBits))
        //    SetConfigBits(new_info.GetConfigBits());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyCustom))
            SetCustom(new_info.GetCustom());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyIcon))
            SetIcon(new_info.GetIcon());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyBeInviteMode))
            SetBeInviteMode(new_info.GetBeInviteMode());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyInviteMode))
            SetInviteMode(new_info.GetInviteMode());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyUpdateInfoMode))
            SetUpdateInfoMode(new_info.GetUpdateInfoMode());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyUpdateCustomMode))
            SetUpdateCustomMode(new_info.GetUpdateCustomMode());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyID))
            SetSuperTeamID(new_info.GetSuperTeamID());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyValidFlag))
            SetValid(new_info.IsValid());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyMemberValid))
            SetMemberValid(new_info.IsMemberValid());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyMemberCount))
            SetMemberCount(new_info.GetMemberCount());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyListTime))
            SetMemberListTimetag(new_info.GetMemberListTimetag());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyCreateTime))
            SetCreateTimetag(new_info.GetCreateTimetag());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyUpdateTime))
            SetUpdateTimetag(new_info.GetUpdateTimetag());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyServerCustom))
            SetServerCustom(new_info.GetServerCustom());
        if (new_info.ExistValue(kNIMSuperTeamInfoKeyMuteAll) || new_info.ExistValue(kNIMSuperTeamInfoKeyMuteType))
            SetMute(new_info.GetMuteType());
    }
 
public:
    void SetSuperTeamID(const std::string& id) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyID] = id; }
 
    std::string GetSuperTeamID() const { return team_info_json_value_[nim::kNIMSuperTeamInfoKeyID].asString(); }
 
    void SetName(const std::string& name) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyName] = name; }
 
    std::string GetName() const { return team_info_json_value_[nim::kNIMSuperTeamInfoKeyName].asString(); }
 
    void SetOwnerID(const std::string& id) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyCreator] = id; }
 
    std::string GetOwnerID() const { return team_info_json_value_[nim::kNIMSuperTeamInfoKeyCreator].asString(); }
    void SetMemberMaxCount(int count) {
        team_info_json_value_[nim::kNIMSuperTeamInfoKeyMemberMaxCount] = count;
        team_info_json_value_[nim::kNIMSuperTeamInfoKeyLevel] = count;
    }
 
    int GetMemberMaxCount() const { return team_info_json_value_[nim::kNIMSuperTeamInfoKeyMemberMaxCount].asUInt(); }
    void SetProperty(const std::string& prop) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyProperty] = prop; }
 
    std::string GetProperty() const { return team_info_json_value_[nim::kNIMSuperTeamInfoKeyProperty].asString(); }
 
    void SetValid(bool valid) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyValidFlag] = valid ? 1 : 0; }
 
    bool IsValid() const { return team_info_json_value_[nim::kNIMSuperTeamInfoKeyValidFlag].asUInt() == 1; }
 
    void SetMemberCount(int count) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyMemberCount] = count; }
 
    int GetMemberCount() const { return team_info_json_value_[nim::kNIMSuperTeamInfoKeyMemberCount].asUInt(); }
 
    void SetMemberListTimetag(int64_t timetag) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyListTime] = timetag; }
 
    int64_t GetMemberListTimetag() const { return team_info_json_value_[nim::kNIMSuperTeamInfoKeyListTime].asUInt64(); }
 
    void SetCreateTimetag(int64_t timetag) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyCreateTime] = timetag; }
 
    int64_t GetCreateTimetag() const { return team_info_json_value_[nim::kNIMSuperTeamInfoKeyCreateTime].asUInt64(); }
 
    void SetUpdateTimetag(int64_t timetag) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyUpdateTime] = timetag; }
 
    int64_t GetUpdateTimetag() const { return team_info_json_value_[nim::kNIMSuperTeamInfoKeyUpdateTime].asUInt64(); }
 
    void SetMemberValid(bool valid) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyMemberValid] = valid ? 1 : 0; }
 
    bool IsMemberValid() const { return team_info_json_value_[nim::kNIMSuperTeamInfoKeyMemberValid].asUInt() == 1; }
 
    void SetIntro(const std::string& intro) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyIntro] = intro; }
 
    std::string GetIntro() const { return team_info_json_value_[nim::kNIMSuperTeamInfoKeyIntro].asString(); }
 
    void SetAnnouncement(const std::string& announcement) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyAnnouncement] = announcement; }
 
    std::string GetAnnouncement() const { return team_info_json_value_[nim::kNIMSuperTeamInfoKeyAnnouncement].asString(); }
 
    void SetJoinMode(nim::NIMSuperTeamJoinMode mode) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyJoinMode] = mode; }
 
    nim::NIMSuperTeamJoinMode GetJoinMode() const { return (NIMSuperTeamJoinMode)team_info_json_value_[nim::kNIMSuperTeamInfoKeyJoinMode].asUInt(); }
 
    void SetCustom(const std::string& custom) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyCustom] = custom; }
 
    std::string GetCustom() const { return team_info_json_value_[nim::kNIMSuperTeamInfoKeyCustom].asString(); }
 
    void SetServerCustom(const std::string& custom) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyServerCustom] = custom; }
 
    std::string GetServerCustom() const { return team_info_json_value_[nim::kNIMSuperTeamInfoKeyServerCustom].asString(); }
 
    void SetIcon(const std::string& icon) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyIcon] = icon; }
 
    std::string GetIcon() const { return team_info_json_value_[nim::kNIMSuperTeamInfoKeyIcon].asString(); }
 
    void SetBeInviteMode(int be_invite_mode) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyBeInviteMode] = be_invite_mode; }
 
    int GetBeInviteMode() const { return team_info_json_value_[nim::kNIMSuperTeamInfoKeyBeInviteMode].asUInt(); }
 
    void SetInviteMode(NIMSuperTeamInviteMode mode) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyInviteMode] = mode; }
 
    NIMSuperTeamInviteMode GetInviteMode() const {
        return (NIMSuperTeamInviteMode)team_info_json_value_[nim::kNIMSuperTeamInfoKeyInviteMode].asUInt();
    }
 
    void SetUpdateInfoMode(NIMSuperTeamUpdateInfoMode mode) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyUpdateInfoMode] = mode; }
 
    NIMSuperTeamUpdateInfoMode GetUpdateInfoMode() const {
        return (NIMSuperTeamUpdateInfoMode)team_info_json_value_[nim::kNIMSuperTeamInfoKeyUpdateInfoMode].asUInt();
    }
 
    void SetUpdateCustomMode(NIMSuperTeamUpdateCustomMode mode) { team_info_json_value_[nim::kNIMSuperTeamInfoKeyUpdateCustomMode] = mode; }
 
    NIMSuperTeamUpdateCustomMode GetUpdateCustomMode() const {
        return (NIMSuperTeamUpdateCustomMode)team_info_json_value_[nim::kNIMSuperTeamInfoKeyUpdateCustomMode].asUInt();
    }
    void SetMute(NIMSuperTeamMuteType mute_type) { team_info_json_value_[nim::kNIMTeamInfoKeyMuteType] = mute_type; }
 
    NIMSuperTeamMuteType GetMuteType() const {
        if (team_info_json_value_.isMember(nim::kNIMSuperTeamInfoKeyMuteAll) &&
            team_info_json_value_[nim::kNIMSuperTeamInfoKeyMuteType].asUInt() == 1)
            return kNIMSuperTeamMuteTypeNomalMute;
        return (NIMSuperTeamMuteType)team_info_json_value_[nim::kNIMSuperTeamInfoKeyMuteType].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::kNIMSuperTeamInfoKeyLevel] = level; }
 
    int GetLevel() const { return team_info_json_value_[nim::kNIMSuperTeamInfoKeyLevel].asUInt(); }
 
public:
    nim_cpp_wrapper_util::Json::Value team_info_json_value_;
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SuperTeamMemberProperty {
public:
    SuperTeamMemberProperty(const std::string& team_id, const std::string& accid, const nim::NIMSuperTeamUserType type) {
        member_info_json_value_[kNIMSuperTeamUserKeyID] = team_id;
        member_info_json_value_[kNIMSuperTeamUserKeyAccID] = accid;
        member_info_json_value_[kNIMSuperTeamUserKeyType] = type;
    }
 
    SuperTeamMemberProperty() {}
 
public:
    void SetSuperTeamID(const std::string& id) { member_info_json_value_[kNIMSuperTeamUserKeyID] = id; }
 
    std::string GetSuperTeamID() const { return member_info_json_value_[kNIMSuperTeamUserKeyID].asString(); }
 
    void SetAccountID(const std::string& id) { member_info_json_value_[kNIMSuperTeamUserKeyAccID] = id; }
 
    std::string GetAccountID() const { return member_info_json_value_[kNIMSuperTeamUserKeyAccID].asString(); }
 
    void SetUserType(nim::NIMSuperTeamUserType type) { member_info_json_value_[kNIMSuperTeamUserKeyType] = type; }
 
    nim::NIMSuperTeamUserType GetUserType() const { return (nim::NIMSuperTeamUserType)member_info_json_value_[kNIMSuperTeamUserKeyType].asUInt(); }
 
    void SetNick(const std::string& nick) { member_info_json_value_[kNIMSuperTeamUserKeyNick] = nick; }
 
    std::string GetNick() const { return member_info_json_value_[kNIMSuperTeamUserKeyNick].asString(); }
 
    void SetBits(int64_t bit) { member_info_json_value_[kNIMSuperTeamUserKeyBits] = bit; }
 
    int64_t GetBits() const { return member_info_json_value_[kNIMSuperTeamUserKeyBits].asUInt64(); }
 
    void SetValid(bool valid) { member_info_json_value_[kNIMSuperTeamUserKeyValidFlag] = valid ? 1 : 0; }
 
    bool IsValid() const { return member_info_json_value_[kNIMSuperTeamUserKeyValidFlag].asUInt() == 1; }
 
    void SetCreateTimetag(int64_t timetag) { member_info_json_value_[kNIMSuperTeamUserKeyCreateTime] = timetag; }
 
    int64_t GetCreateTimetag() const { return member_info_json_value_[kNIMSuperTeamUserKeyCreateTime].asUInt64(); }
 
    void SetUpdateTimetag(int64_t timetag) { member_info_json_value_[kNIMSuperTeamUserKeyUpdateTime] = timetag; }
 
    int64_t GetUpdateTimetag() const { return member_info_json_value_[kNIMSuperTeamUserKeyUpdateTime].asUInt64(); }
 
    void SetMute(bool mute) { member_info_json_value_[kNIMSuperTeamUserKeyMute] = mute ? 1 : 0; }
 
    bool IsMute() const { return member_info_json_value_[kNIMSuperTeamUserKeyMute].asUInt() == 1; }
 
    void SetCustom(const std::string& custom) { member_info_json_value_[kNIMSuperTeamUserKeyCustom] = custom; }
 
    std::string GetCustom() const { return member_info_json_value_[kNIMSuperTeamUserKeyCustom].asString(); }
    void SetFollowMember(const std::string& follow_member) {
        nim_cpp_wrapper_util::Json::Value follow_member_array(nim_cpp_wrapper_util::Json::arrayValue);
        nim_cpp_wrapper_util::Json::Reader reader;
        reader.parse(follow_member, follow_member_array);
        member_info_json_value_[kNIMTeamUserKeyFollowMember] = follow_member_array;
    }
    std::vector<std::string> GetFollowMember() const {
        nim_cpp_wrapper_util::Json::Value follow_member_array = member_info_json_value_[kNIMTeamUserKeyFollowMember];
        std::vector<std::string> follow_member;
        for (auto& it : follow_member_array) {
            follow_member.push_back(it.asString());
        }
        return follow_member;
    }
 
    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_; }
 
public:
    nim_cpp_wrapper_util::Json::Value member_info_json_value_;
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SuperTeamEvent {
    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_;
    SuperTeamInfo team_info_;
    SuperTeamMemberProperty member_property_;
    bool opt_;
    std::string attach_;
    nim_cpp_wrapper_util::Json::Value src_data_;
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SuperTeamMemberSerachResult {
    std::list<SuperTeamMemberProperty> team_member_propertys_;
    uint32_t offset_{0};
    bool finished_{false};
};
 
enum SuperTeamQueryOrder {
    kSuperTeamQueryOrderDesc = 0,
    kSuperTeamQueryOrderAsc = 1,
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SuperTeamMemberKeywordSearchOption {
    std::string team_id_;
    std::string keyword_;
    uint32_t offset_{0};
    SuperTeamQueryOrder order_{kSuperTeamQueryOrderDesc};
    uint32_t limit_{10};
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API SuperTeamMemberRoleTypeSearchOption {
    std::set<nim::NIMSuperTeamUserType> role_types_;
    uint32_t offset_{0};
    SuperTeamQueryOrder order_{kSuperTeamQueryOrderDesc};
    uint32_t limit_{10};
};
 
NIM_SDK_CPPWRAPPER_DLL_API void ParseSuperTeamEvent(int rescode,
    const std::string& team_id,
    const NIMNotificationId notification_id,
    const std::string& team_event_json,
    SuperTeamEvent& team_event);
 
NIM_SDK_CPPWRAPPER_DLL_API void ParseSuperTeamInfoJson(const nim_cpp_wrapper_util::Json::Value& team_info_json, SuperTeamInfo& team_info);
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseSuperTeamInfoJson(const std::string& team_info_json, SuperTeamInfo& team_info);
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseSuperTeamInfosJson(const std::string& team_infos_json, std::list<SuperTeamInfo>& team_infos);
 
NIM_SDK_CPPWRAPPER_DLL_API void ParseSuperTeamMemberPropertyJson(const nim_cpp_wrapper_util::Json::Value& team_member_prop_json,
    SuperTeamMemberProperty& team_member_property);
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseSuperTeamMemberPropertyJson(const std::string& team_member_prop_json,
    SuperTeamMemberProperty& team_member_property);
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseSuperTeamMemberPropertysJson(const std::string& team_member_props_json,
    std::list<SuperTeamMemberProperty>& team_member_propertys);
}  // namespace nim
 
#endif  //_NIM_SDK_CPP_SUPERTEAM_HELPER_H_