ChannelMgr Class Reference

#include "ChannelMgr.h"

Inheritance diagram for ChannelMgr:

Public Member Functions
	ChannelMgr (TeamId teamId)
	~ChannelMgr ()
Channel *	GetJoinChannel (std::string const &name, uint32 channel_id)
Channel *	GetChannel (std::string const &name, Player *p, bool pkt=true)

Static Public Member Functions
static ChannelMgr *	forTeam (TeamId teamId)
static void	LoadChannels ()
static void	LoadChannelRights ()
static const ChannelRights &	GetChannelRightsFor (const std::string &name)
static void	SetChannelRightsFor (const std::string &name, const uint32 &flags, const uint32 &speakDelay, const std::string &joinmessage, const std::string &speakmessage, const std::set< uint32 > &moderators)

Static Public Attributes
static uint32	_channelIdMax = 0

Private Types
typedef std::unordered_map< std::wstring, Channel * >	ChannelMap
typedef std::map< std::string, ChannelRights >	ChannelRightsMap

Private Member Functions
void	MakeNotOnPacket (WorldPacket *data, std::string const &name)

Private Attributes
ChannelMap	channels
TeamId	_teamId

Static Private Attributes
static ChannelRightsMap	channels_rights
static ChannelRights	channelRightsEmpty

Detailed Description

Member Typedef Documentation

ChannelMap

typedef std::unordered_map<std::wstring, Channel*> ChannelMgr::ChannelMap

private

ChannelRightsMap

typedef std::map<std::string, ChannelRights> ChannelMgr::ChannelRightsMap

private

Constructor & Destructor Documentation

ChannelMgr()

ChannelMgr::ChannelMgr ( TeamId  teamId )

inline

                              : _teamId(teamId)
    { }

~ChannelMgr()

ChannelMgr::~ChannelMgr

(

)

{
    for (ChannelMap::iterator itr = channels.begin(); itr != channels.end(); ++itr)
        delete itr->second;
 
    channels.clear();
}

References channels.

Member Function Documentation

forTeam()

ChannelMgr * ChannelMgr::forTeam ( TeamId  teamId )

static

{
    static ChannelMgr allianceChannelMgr(TEAM_ALLIANCE);
    static ChannelMgr hordeChannelMgr(TEAM_HORDE);
 
    if (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL))
        return &allianceChannelMgr;        // cross-faction
 
    if (teamId == TEAM_ALLIANCE)
        return &allianceChannelMgr;
 
    if (teamId == TEAM_HORDE)
        return &hordeChannelMgr;
 
    return nullptr;
}

References CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL, sWorld, TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by WorldSession::HandleChannelAnnouncements(), WorldSession::HandleChannelBan(), WorldSession::HandleChannelInvite(), WorldSession::HandleChannelKick(), WorldSession::HandleChannelList(), WorldSession::HandleChannelModerateOpcode(), WorldSession::HandleChannelModerator(), WorldSession::HandleChannelMute(), WorldSession::HandleChannelOwner(), WorldSession::HandleChannelPassword(), WorldSession::HandleChannelSetOwner(), WorldSession::HandleChannelUnban(), WorldSession::HandleChannelUnmoderator(), WorldSession::HandleChannelUnmute(), WorldSession::HandleClearChannelWatch(), WorldSession::HandleGetChannelMemberCount(), WorldSession::HandleJoinChannel(), WorldSession::HandleLeaveChannel(), WorldSession::HandleMessagechatOpcode(), WorldSession::HandleSetChannelWatch(), LoadChannels(), and Player::UpdateLocalChannels().

GetChannel()

Channel * ChannelMgr::GetChannel	(	std::string const &	name,
		Player *	p,
		bool	pkt = true
	)

{
    std::wstring wname;
    Utf8toWStr(name, wname);
    wstrToLower(wname);
 
    ChannelMap::const_iterator i = channels.find(wname);
 
    if (i == channels.end())
    {
        if (pkt)
        {
            WorldPacket data;
            MakeNotOnPacket(&data, name);
            player->GetSession()->SendPacket(&data);
        }
 
        return nullptr;
    }
 
    return i->second;
}

References channels, Player::GetSession(), MakeNotOnPacket(), WorldSession::SendPacket(), Utf8toWStr(), and wstrToLower().

GetChannelRightsFor()

const ChannelRights & ChannelMgr::GetChannelRightsFor ( const std::string &  name )

static

{
    std::string nameStr = name;
    std::transform(nameStr.begin(), nameStr.end(), nameStr.begin(), ::tolower);
    ChannelRightsMap::const_iterator itr = channels_rights.find(nameStr);
    if (itr != channels_rights.end())
        return itr->second;
    return channelRightsEmpty;
}

References channelRightsEmpty, and channels_rights.

Referenced by Channel::Channel().

GetJoinChannel()

Channel * ChannelMgr::GetJoinChannel	(	std::string const &	name,
		uint32	channel_id
	)

{
    std::wstring wname;
    Utf8toWStr(name, wname);
    wstrToLower(wname);
 
    ChannelMap::const_iterator i = channels.find(wname);
 
    if (i == channels.end())
    {
        Channel* nchan = new Channel(name, channelId, 0, _teamId);
        channels[wname] = nchan;
        return nchan;
    }
 
    return i->second;
}

References _teamId, channels, Utf8toWStr(), and wstrToLower().

Referenced by Player::UpdateLocalChannels().

LoadChannelRights()

void ChannelMgr::LoadChannelRights ( )

static

{
    uint32 oldMSTime = getMSTime();
    channels_rights.clear();
 
    QueryResult result = CharacterDatabase.Query("SELECT name, flags, speakdelay, joinmessage, delaymessage, moderators FROM channels_rights");
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 Channel Rights!");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
    do
    {
        Field* fields = result->Fetch();
        std::set<uint32> moderators;
        auto moderatorList = fields[5].Get<std::string_view>();
 
        if (!moderatorList.empty())
        {
            for (auto const& itr : Acore::Tokenize(moderatorList, ' ', false))
            {
                uint64 moderator_acc = Acore::StringTo<uint64>(itr).value_or(0);
 
                if (moderator_acc && ((uint32)moderator_acc) == moderator_acc)
                {
                    moderators.insert((uint32)moderator_acc);
                }
            }
        }
 
        SetChannelRightsFor(fields[0].Get<std::string>(), fields[1].Get<uint32>(), fields[2].Get<uint32>(), fields[3].Get<std::string>(), fields[4].Get<std::string>(), moderators);
 
        ++count;
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} Channel Rights in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References channels_rights, CharacterDatabase, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_INFO, LOG_WARN, SetChannelRightsFor(), and Acore::Tokenize().

Referenced by World::SetInitialWorldSettings().

LoadChannels()

void ChannelMgr::LoadChannels ( )

static

{
    uint32 oldMSTime = getMSTime();
    uint32 count = 0;
 
    //                                                    0          1     2     3         4          5
    QueryResult result = CharacterDatabase.Query("SELECT channelId, name, team, announce, ownership, password FROM channels ORDER BY channelId ASC");
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 channels. DB table `channels` is empty.");
        return;
    }
 
    std::vector<std::pair<std::string, uint32>> toDelete;
    do
    {
        Field* fields = result->Fetch();
 
        uint32 channelDBId = fields[0].Get<uint32>();
        std::string channelName = fields[1].Get<std::string>();
        TeamId team = TeamId(fields[2].Get<uint32>());
        std::string password = fields[5].Get<std::string>();
 
        std::wstring channelWName;
        if (!Utf8toWStr(channelName, channelWName))
        {
            LOG_ERROR("server.loading", "Failed to load channel '{}' from database - invalid utf8 sequence? Deleted.", channelName);
            toDelete.push_back({ channelName, team });
            continue;
        }
 
        ChannelMgr* mgr = forTeam(team);
        if (!mgr)
        {
            LOG_ERROR("server.loading", "Failed to load custom chat channel '{}' from database - invalid team {}. Deleted.", channelName, team);
            toDelete.push_back({ channelName, team });
            continue;
        }
 
        Channel* newChannel = new Channel(channelName, 0, channelDBId, team, fields[3].Get<uint8>(), fields[4].Get<uint8>());
        newChannel->SetPassword(password);
        mgr->channels[channelWName] = newChannel;
 
        if (QueryResult banResult = CharacterDatabase.Query("SELECT playerGUID, banTime FROM channels_bans WHERE channelId = {}", channelDBId))
        {
            do
            {
                Field* banFields = banResult->Fetch();
                if (!banFields)
                    break;
                newChannel->AddBan(ObjectGuid::Create<HighGuid::Player>(banFields[0].Get<uint32>()), banFields[1].Get<uint32>());
            } while (banResult->NextRow());
        }
 
        if (channelDBId > ChannelMgr::_channelIdMax)
            ChannelMgr::_channelIdMax = channelDBId;
        ++count;
    } while (result->NextRow());
 
    for (auto& pair : toDelete)
    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHANNEL);
        stmt->SetData(0, pair.first);
        stmt->SetData(1, pair.second);
        CharacterDatabase.Execute(stmt);
    }
 
    LOG_INFO("server.loading", ">> Loaded {} channels in {}ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References _channelIdMax, Channel::AddBan(), channels, CHAR_DEL_CHANNEL, CharacterDatabase, forTeam(), Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, LOG_WARN, PreparedStatementBase::SetData(), Channel::SetPassword(), and Utf8toWStr().

Referenced by World::SetInitialWorldSettings().

MakeNotOnPacket()

void ChannelMgr::MakeNotOnPacket ( WorldPacket *  data, std::string const &  name  )

private

{
    data->Initialize(SMSG_CHANNEL_NOTIFY, 1 + name.size());
    (*data) << uint8(5) << name;
}

References WorldPacket::Initialize(), and SMSG_CHANNEL_NOTIFY.

Referenced by GetChannel().

SetChannelRightsFor()

void ChannelMgr::SetChannelRightsFor ( const std::string &  name, const uint32 &  flags, const uint32 &  speakDelay, const std::string &  joinmessage, const std::string &  speakmessage, const std::set< uint32 > &  moderators  )

static

{
    std::string nameStr = name;
    std::transform(nameStr.begin(), nameStr.end(), nameStr.begin(), ::tolower);
    channels_rights[nameStr] = ChannelRights(flags, speakDelay, joinmessage, speakmessage, moderators);
}

References channels_rights.

Referenced by LoadChannelRights().

Member Data Documentation

_channelIdMax

uint32 ChannelMgr::_channelIdMax = 0

static

Referenced by Channel::Channel(), and LoadChannels().

_teamId

TeamId ChannelMgr::_teamId

private

Referenced by GetJoinChannel().

channelRightsEmpty

ChannelRights ChannelMgr::channelRightsEmpty

staticprivate

Referenced by GetChannelRightsFor().

channels

ChannelMap ChannelMgr::channels

private

Referenced by GetChannel(), GetJoinChannel(), LoadChannels(), and ~ChannelMgr().

channels_rights

ChannelMgr::ChannelRightsMap ChannelMgr::channels_rights

staticprivate

Referenced by GetChannelRightsFor(), LoadChannelRights(), and SetChannelRightsFor().