ban_commandscript Class Reference

Inheritance diagram for ban_commandscript:

Public Member Functions
	ban_commandscript ()
ChatCommandTable	GetCommands () const override
virtual std::vector< Acore::ChatCommands::ChatCommandBuilder >	GetCommands () const =0
Public Member Functions inherited from ScriptObject
virtual bool	IsDatabaseBound () const
virtual bool	isAfterLoadScript () const
virtual void	checkValidity ()
const std::string &	GetName () const
uint16	GetTotalAvailableHooks ()

Static Public Member Functions
static bool	HandleBanAccountCommand (ChatHandler *handler, char const *args)
static bool	HandleBanCharacterCommand (ChatHandler *handler, char const *args)
static bool	HandleBanAccountByCharCommand (ChatHandler *handler, char const *args)
static bool	HandleBanIPCommand (ChatHandler *handler, char const *args)
static bool	HandleBanHelper (BanMode mode, char const *args, ChatHandler *handler)
static bool	HandleBanInfoAccountCommand (ChatHandler *handler, char const *args)
static bool	HandleBanInfoHelper (uint32 accountId, char const *accountName, ChatHandler *handler)
static bool	HandleBanInfoCharacterCommand (ChatHandler *handler, char const *args)
static bool	HandleBanInfoIPCommand (ChatHandler *handler, char const *args)
static bool	HandleBanListAccountCommand (ChatHandler *handler, char const *args)
static bool	HandleBanListHelper (PreparedQueryResult result, ChatHandler *handler)
static bool	HandleBanListCharacterCommand (ChatHandler *handler, char const *args)
static bool	HandleBanListIPCommand (ChatHandler *handler, char const *args)
static bool	HandleUnBanAccountCommand (ChatHandler *handler, char const *args)
static bool	HandleUnBanCharacterCommand (ChatHandler *handler, char const *args)
static bool	HandleUnBanAccountByCharCommand (ChatHandler *handler, char const *args)
static bool	HandleUnBanIPCommand (ChatHandler *handler, char const *args)
static bool	HandleUnBanHelper (BanMode mode, char const *args, ChatHandler *handler)

Additional Inherited Members
Protected Member Functions inherited from CommandScript
	CommandScript (const char *name)
Protected Member Functions inherited from ScriptObject
	ScriptObject (const char *name, uint16 totalAvailableHooks=0)
virtual	~ScriptObject ()=default

Detailed Description

Constructor & Destructor Documentation

ban_commandscript()

ban_commandscript::ban_commandscript ( )

inline

: CommandScript("ban_commandscript") { }

Member Function Documentation

GetCommands()

ChatCommandTable ban_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

    {
        static ChatCommandTable unbanCommandTable =
        {
            { "account",       HandleUnBanAccountCommand,       SEC_ADMINISTRATOR, Console::Yes },
            { "character",     HandleUnBanCharacterCommand,     SEC_ADMINISTRATOR, Console::Yes },
            { "playeraccount", HandleUnBanAccountByCharCommand, SEC_ADMINISTRATOR, Console::Yes },
            { "ip",            HandleUnBanIPCommand,            SEC_ADMINISTRATOR, Console::Yes }
        };
 
        static ChatCommandTable banlistCommandTable =
        {
            { "account",      HandleBanListAccountCommand,   SEC_GAMEMASTER, Console::Yes },
            { "character",    HandleBanListCharacterCommand, SEC_GAMEMASTER, Console::Yes },
            { "ip",           HandleBanListIPCommand,        SEC_GAMEMASTER, Console::Yes }
        };
 
        static ChatCommandTable baninfoCommandTable =
        {
            { "account",      HandleBanInfoAccountCommand,   SEC_GAMEMASTER, Console::Yes },
            { "character",    HandleBanInfoCharacterCommand, SEC_GAMEMASTER, Console::Yes },
            { "ip",           HandleBanInfoIPCommand,        SEC_GAMEMASTER, Console::Yes }
        };
 
        static ChatCommandTable banCommandTable =
        {
            { "account",      HandleBanAccountCommand,       SEC_GAMEMASTER, Console::Yes },
            { "character",    HandleBanCharacterCommand,     SEC_GAMEMASTER, Console::Yes },
            { "playeraccount",HandleBanAccountByCharCommand, SEC_GAMEMASTER, Console::Yes },
            { "ip",           HandleBanIPCommand,            SEC_GAMEMASTER, Console::Yes }
        };
 
        static ChatCommandTable commandTable =
        {
            { "ban",     banCommandTable },
            { "baninfo", baninfoCommandTable },
            { "banlist", banlistCommandTable },
            { "unban",   unbanCommandTable }
        };
 
        return commandTable;
    }

References HandleBanAccountByCharCommand(), HandleBanAccountCommand(), HandleBanCharacterCommand(), HandleBanInfoAccountCommand(), HandleBanInfoCharacterCommand(), HandleBanInfoIPCommand(), HandleBanIPCommand(), HandleBanListAccountCommand(), HandleBanListCharacterCommand(), HandleBanListIPCommand(), HandleUnBanAccountByCharCommand(), HandleUnBanAccountCommand(), HandleUnBanCharacterCommand(), HandleUnBanIPCommand(), SEC_ADMINISTRATOR, and SEC_GAMEMASTER.

HandleBanAccountByCharCommand()

static bool ban_commandscript::HandleBanAccountByCharCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        return HandleBanHelper(BAN_CHARACTER, args, handler);
    }

References BAN_CHARACTER, and HandleBanHelper().

Referenced by GetCommands().

HandleBanAccountCommand()

static bool ban_commandscript::HandleBanAccountCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        return HandleBanHelper(BAN_ACCOUNT, args, handler);
    }

References BAN_ACCOUNT, and HandleBanHelper().

Referenced by GetCommands().

HandleBanCharacterCommand()

static bool ban_commandscript::HandleBanCharacterCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        if (!*args)
            return false;
 
        char* nameStr = strtok((char*)args, " ");
        if (!nameStr)
            return false;
 
        std::string name = nameStr;
 
        char* durationStr = strtok(nullptr, " ");
        if (!durationStr || !atoi(durationStr))
            return false;
 
        char* reasonStr = strtok(nullptr, "");
        if (!reasonStr)
            return false;
 
        if (!normalizePlayerName(name))
        {
            handler->SendErrorMessage(LANG_PLAYER_NOT_FOUND);
            return false;
        }
 
        switch (sBan->BanCharacter(name, durationStr, reasonStr, handler->GetSession() ? handler->GetSession()->GetPlayerName() : ""))
        {
            case BAN_SUCCESS:
                if (atoi(durationStr) > 0)
                {
                    if (!sWorld->getBoolConfig(CONFIG_SHOW_BAN_IN_WORLD))
                        handler->PSendSysMessage(LANG_BAN_YOUBANNED, name, secsToTimeString(TimeStringToSecs(durationStr), true), reasonStr);
                }
                else
                {
                    if (!sWorld->getBoolConfig(CONFIG_SHOW_BAN_IN_WORLD))
                        handler->PSendSysMessage(LANG_BAN_YOUPERMBANNED, name, reasonStr);
                }
                break;
            case BAN_NOTFOUND:
                {
                    handler->SendErrorMessage(LANG_BAN_NOTFOUND, "character", name);
                    return false;
                }
            default:
                break;
        }
 
        return true;
    }

References BAN_NOTFOUND, BAN_SUCCESS, CONFIG_SHOW_BAN_IN_WORLD, WorldSession::GetPlayerName(), ChatHandler::GetSession(), LANG_BAN_NOTFOUND, LANG_BAN_YOUBANNED, LANG_BAN_YOUPERMBANNED, LANG_PLAYER_NOT_FOUND, normalizePlayerName(), ChatHandler::PSendSysMessage(), sBan, secsToTimeString(), ChatHandler::SendErrorMessage(), sWorld, and TimeStringToSecs().

Referenced by GetCommands().

HandleBanHelper()

static bool ban_commandscript::HandleBanHelper ( BanMode  mode, char const *  args, ChatHandler *  handler  )

inlinestatic

    {
        if (!*args)
            return false;
 
        char* cnameOrIP = strtok((char*)args, " ");
        if (!cnameOrIP)
            return false;
 
        std::string nameOrIP = cnameOrIP;
 
        char* durationStr = strtok(nullptr, " ");
        if (!durationStr || !atoi(durationStr))
            return false;
 
        char* reasonStr = strtok(nullptr, "");
        if (!reasonStr)
            return false;
 
        switch (mode)
        {
            case BAN_ACCOUNT:
                if (!Utf8ToUpperOnlyLatin(nameOrIP))
                {
                    handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, nameOrIP);
                    return false;
                }
                break;
            case BAN_CHARACTER:
                if (!normalizePlayerName(nameOrIP))
                {
                    handler->SendErrorMessage(LANG_PLAYER_NOT_FOUND);
                    return false;
                }
                break;
            case BAN_IP:
                if (!IsIPAddress(nameOrIP.c_str()))
                    return false;
                break;
        }
 
        BanReturn banReturn;
 
        switch (mode)
        {
            case BAN_ACCOUNT:
                banReturn = sBan->BanAccount(nameOrIP, durationStr, reasonStr, handler->GetSession() ? handler->GetSession()->GetPlayerName() : "");
                break;
            case BAN_CHARACTER:
                banReturn = sBan->BanAccountByPlayerName(nameOrIP, durationStr, reasonStr, handler->GetSession() ? handler->GetSession()->GetPlayerName() : "");
                break;
            case BAN_IP:
            default:
                banReturn = sBan->BanIP(nameOrIP, durationStr, reasonStr, handler->GetSession() ? handler->GetSession()->GetPlayerName() : "");
                break;
        }
 
        switch (banReturn)
        {
            case BAN_SUCCESS:
                if (atoi(durationStr) > 0)
                {
                    if (!sWorld->getBoolConfig(CONFIG_SHOW_BAN_IN_WORLD))
                        handler->PSendSysMessage(LANG_BAN_YOUBANNED, nameOrIP, secsToTimeString(TimeStringToSecs(durationStr), true), reasonStr);
                }
                else
                {
                    if (!sWorld->getBoolConfig(CONFIG_SHOW_BAN_IN_WORLD))
                        handler->PSendSysMessage(LANG_BAN_YOUPERMBANNED, nameOrIP, reasonStr);
                }
                break;
            case BAN_SYNTAX_ERROR:
                return false;
            case BAN_NOTFOUND:
                switch (mode)
                {
                    default:
                        handler->SendErrorMessage(LANG_BAN_NOTFOUND, "account", nameOrIP);
                        break;
                    case BAN_CHARACTER:
                        handler->SendErrorMessage(LANG_BAN_NOTFOUND, "character", nameOrIP);
                        break;
                    case BAN_IP:
                        handler->SendErrorMessage(LANG_BAN_NOTFOUND, "ip", nameOrIP);
                        break;
                }
                return false;
            case BAN_LONGER_EXISTS:
                handler->PSendSysMessage("Unsuccessful! A longer ban is already present on this account!");
                break;
            default:
                break;
        }
 
        return true;
    }

References BAN_ACCOUNT, BAN_CHARACTER, BAN_IP, BAN_LONGER_EXISTS, BAN_NOTFOUND, BAN_SUCCESS, BAN_SYNTAX_ERROR, CONFIG_SHOW_BAN_IN_WORLD, WorldSession::GetPlayerName(), ChatHandler::GetSession(), IsIPAddress(), LANG_ACCOUNT_NOT_EXIST, LANG_BAN_NOTFOUND, LANG_BAN_YOUBANNED, LANG_BAN_YOUPERMBANNED, LANG_PLAYER_NOT_FOUND, normalizePlayerName(), ChatHandler::PSendSysMessage(), sBan, secsToTimeString(), ChatHandler::SendErrorMessage(), sWorld, TimeStringToSecs(), and Utf8ToUpperOnlyLatin().

Referenced by HandleBanAccountByCharCommand(), HandleBanAccountCommand(), and HandleBanIPCommand().

HandleBanInfoAccountCommand()

static bool ban_commandscript::HandleBanInfoAccountCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        if (!*args)
            return false;
 
        char* nameStr = strtok((char*)args, "");
        if (!nameStr)
            return false;
 
        std::string accountName = nameStr;
        if (!Utf8ToUpperOnlyLatin(accountName))
        {
            handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
            return false;
        }
 
        uint32 accountId = AccountMgr::GetId(accountName);
        if (!accountId)
        {
            handler->PSendSysMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
            return true;
        }
 
        return HandleBanInfoHelper(accountId, accountName.c_str(), handler);
    }

References AccountMgr::GetId(), HandleBanInfoHelper(), LANG_ACCOUNT_NOT_EXIST, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), and Utf8ToUpperOnlyLatin().

Referenced by GetCommands().

HandleBanInfoCharacterCommand()

static bool ban_commandscript::HandleBanInfoCharacterCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        if (!*args)
            return false;
 
        Player* target = ObjectAccessor::FindPlayerByName(args, false);
        ObjectGuid targetGuid;
        std::string name(args);
 
        if (!target)
        {
            targetGuid = sCharacterCache->GetCharacterGuidByName(name);
            if (!targetGuid)
            {
                handler->PSendSysMessage(LANG_BANINFO_NOCHARACTER);
                return false;
            }
        }
        else
            targetGuid = target->GetGUID();
 
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_BANINFO);
        stmt->SetData(0, targetGuid.GetCounter());
 
        PreparedQueryResult result = CharacterDatabase.Query(stmt);
        if (!result)
        {
            handler->PSendSysMessage(LANG_CHAR_NOT_BANNED, name);
            return true;
        }
 
        handler->PSendSysMessage(LANG_BANINFO_BANHISTORY, name);
        do
        {
            Field* fields = result->Fetch();
            time_t unbanDate = time_t(fields[3].Get<uint32>());
            bool active = false;
            if (fields[2].Get<uint8>() && (!fields[1].Get<uint32>() || unbanDate >= GameTime::GetGameTime().count()))
                active = true;
            bool permanent = (fields[1].Get<uint32>() == uint32(0));
            std::string banTime = permanent ? handler->GetAcoreString(LANG_BANINFO_INFINITE) : secsToTimeString(fields[1].Get<uint64>(), true);
            handler->PSendSysMessage(LANG_BANINFO_HISTORYENTRY,
                fields[0].Get<std::string>(), banTime, active ? handler->GetAcoreString(LANG_YES) : handler->GetAcoreString(LANG_NO), fields[4].Get<std::string>(), fields[5].Get<std::string>());
        } while (result->NextRow());
 
        return true;
    }

References CHAR_SEL_BANINFO, CharacterDatabase, ObjectAccessor::FindPlayerByName(), Field::Get(), ChatHandler::GetAcoreString(), ObjectGuid::GetCounter(), GameTime::GetGameTime(), Object::GetGUID(), LANG_BANINFO_BANHISTORY, LANG_BANINFO_HISTORYENTRY, LANG_BANINFO_INFINITE, LANG_BANINFO_NOCHARACTER, LANG_CHAR_NOT_BANNED, LANG_NO, LANG_YES, ChatHandler::PSendSysMessage(), sCharacterCache, secsToTimeString(), and PreparedStatementBase::SetData().

Referenced by GetCommands().

HandleBanInfoHelper()

static bool ban_commandscript::HandleBanInfoHelper ( uint32  accountId, char const *  accountName, ChatHandler *  handler  )

inlinestatic

    {
        QueryResult result = LoginDatabase.Query("SELECT FROM_UNIXTIME(bandate, '%Y-%m-%d..%H:%i:%s') as bandate, unbandate-bandate, active, unbandate, banreason, bannedby FROM account_banned WHERE id = '{}' ORDER BY bandate ASC", accountId);
        if (!result)
        {
            handler->PSendSysMessage(LANG_BANINFO_NOACCOUNTBAN, accountName);
            return true;
        }
 
        handler->PSendSysMessage(LANG_BANINFO_BANHISTORY, accountName);
        do
        {
            Field* fields = result->Fetch();
 
            time_t unbanDate = time_t(fields[3].Get<uint32>());
            bool active = false;
            if (fields[2].Get<bool>() && (fields[1].Get<uint64>() == uint64(0) || unbanDate >= GameTime::GetGameTime().count()))
                active = true;
            bool permanent = (fields[1].Get<uint64>() == uint64(0));
            std::string banTime = permanent ? handler->GetAcoreString(LANG_BANINFO_INFINITE) : secsToTimeString(fields[1].Get<uint64>(), true);
            handler->PSendSysMessage(LANG_BANINFO_HISTORYENTRY,
                fields[0].Get<std::string>(), banTime, active ? handler->GetAcoreString(LANG_YES) : handler->GetAcoreString(LANG_NO), fields[4].Get<std::string>(), fields[5].Get<std::string>());
        } while (result->NextRow());
 
        return true;
    }

References Field::Get(), ChatHandler::GetAcoreString(), GameTime::GetGameTime(), LANG_BANINFO_BANHISTORY, LANG_BANINFO_HISTORYENTRY, LANG_BANINFO_INFINITE, LANG_BANINFO_NOACCOUNTBAN, LANG_NO, LANG_YES, LoginDatabase, ChatHandler::PSendSysMessage(), and secsToTimeString().

Referenced by HandleBanInfoAccountCommand().

HandleBanInfoIPCommand()

static bool ban_commandscript::HandleBanInfoIPCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        if (!*args)
            return false;
 
        char* ipStr = strtok((char*)args, "");
        if (!ipStr)
            return false;
 
        if (!IsIPAddress(ipStr))
            return false;
 
        std::string IP = ipStr;
 
        LoginDatabase.EscapeString(IP);
        QueryResult result = LoginDatabase.Query("\
            SELECT \
                ip, FROM_UNIXTIME(bandate, '%Y-%m-%d %H:%i:%s'), FROM_UNIXTIME(unbandate, '%Y-%m-%d %H:%i:%s'), \
                IF (unbandate > UNIX_TIMESTAMP(), unbandate - UNIX_TIMESTAMP(), 0) AS timeRemaining, \
                banreason, bannedby, unbandate - bandate = 0 AS permanent \
            FROM ip_banned \
            WHERE ip = '{}' \
        ", IP);
        if (!result)
        {
            handler->PSendSysMessage(LANG_BANINFO_NOIP);
            return true;
        }
 
        Field* fields = result->Fetch();
        bool permanent = fields[6].Get<uint64>() == 1;
        handler->PSendSysMessage(LANG_BANINFO_IPENTRY,
            fields[0].Get<std::string>(), fields[1].Get<std::string>(), permanent ? handler->GetAcoreString(LANG_BANINFO_NEVER) : fields[2].Get<std::string>(),
            permanent ? handler->GetAcoreString(LANG_BANINFO_INFINITE) : secsToTimeString(fields[3].Get<uint64>(), true), fields[4].Get<std::string>(), fields[5].Get<std::string>());
 
        return true;
    }

References Field::Get(), ChatHandler::GetAcoreString(), IsIPAddress(), LANG_BANINFO_INFINITE, LANG_BANINFO_IPENTRY, LANG_BANINFO_NEVER, LANG_BANINFO_NOIP, LoginDatabase, ChatHandler::PSendSysMessage(), and secsToTimeString().

Referenced by GetCommands().

HandleBanIPCommand()

static bool ban_commandscript::HandleBanIPCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        return HandleBanHelper(BAN_IP, args, handler);
    }

References BAN_IP, and HandleBanHelper().

Referenced by GetCommands().

HandleBanListAccountCommand()

static bool ban_commandscript::HandleBanListAccountCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_EXPIRED_IP_BANS);
        LoginDatabase.Execute(stmt);
 
        char* filterStr = strtok((char*)args, " ");
        std::string filter = filterStr ? filterStr : "";
 
        PreparedQueryResult result;
 
        if (filter.empty())
        {
            LoginDatabasePreparedStatement* stmt2 = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_BANNED_ALL);
            result = LoginDatabase.Query(stmt2);
        }
        else
        {
            LoginDatabasePreparedStatement* stmt2 = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_BANNED_BY_USERNAME);
            stmt2->SetData(0, filter);
            result = LoginDatabase.Query(stmt2);
        }
 
        if (!result)
        {
            handler->PSendSysMessage(LANG_BANLIST_NOACCOUNT);
            return true;
        }
 
        return HandleBanListHelper(result, handler);
    }

References HandleBanListHelper(), LANG_BANLIST_NOACCOUNT, LOGIN_DEL_EXPIRED_IP_BANS, LOGIN_SEL_ACCOUNT_BANNED_ALL, LOGIN_SEL_ACCOUNT_BANNED_BY_USERNAME, LoginDatabase, ChatHandler::PSendSysMessage(), and PreparedStatementBase::SetData().

Referenced by GetCommands().

HandleBanListCharacterCommand()

static bool ban_commandscript::HandleBanListCharacterCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        if (!*args)
            return false;
 
        char* filterStr = strtok((char*)args, " ");
        if (!filterStr)
            return false;
 
        std::string filter(filterStr);
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GUID_BY_NAME_FILTER);
        stmt->SetData(0, filter);
        PreparedQueryResult result = CharacterDatabase.Query(stmt);
        if (!result)
        {
            handler->PSendSysMessage(LANG_BANLIST_NOCHARACTER);
            return true;
        }
 
        handler->PSendSysMessage(LANG_BANLIST_MATCHINGCHARACTER);
 
        // Chat short output
        if (handler->GetSession())
        {
            do
            {
                Field* fields = result->Fetch();
                CharacterDatabasePreparedStatement* stmt2 = CharacterDatabase.GetPreparedStatement(CHAR_SEL_BANNED_NAME);
                stmt2->SetData(0, fields[0].Get<uint32>());
 
                PreparedQueryResult banResult = CharacterDatabase.Query(stmt2);
                if (banResult)
                    handler->PSendSysMessage("%s", (*banResult)[0].Get<std::string>());
            } while (result->NextRow());
        }
        // Console wide output
        else
        {
            handler->SendSysMessage(LANG_BANLIST_CHARACTERS);
            handler->SendSysMessage(" =============================================================================== ");
            handler->SendSysMessage(LANG_BANLIST_CHARACTERS_HEADER);
            do
            {
                handler->SendSysMessage("-------------------------------------------------------------------------------");
 
                Field* fields = result->Fetch();
 
                std::string char_name = fields[1].Get<std::string>();
 
                CharacterDatabasePreparedStatement* stmt2 = CharacterDatabase.GetPreparedStatement(CHAR_SEL_BANINFO_LIST);
                stmt2->SetData(0, fields[0].Get<uint32>());
 
                PreparedQueryResult banInfo = CharacterDatabase.Query(stmt2);
                if (banInfo)
                {
                    Field* banFields = banInfo->Fetch();
                    do
                    {
                        tm tmBan = Acore::Time::TimeBreakdown(banFields[0].Get<uint32>());
 
                        if (banFields[0].Get<uint32>() == banFields[1].Get<uint32>())
                        {
                            handler->PSendSysMessage("|%-15.15s|%02d-%02d-%02d %02d:%02d|   permanent  |%-15.15s|%-15.15s|",
                                                     char_name, tmBan.tm_year % 100, tmBan.tm_mon + 1, tmBan.tm_mday, tmBan.tm_hour, tmBan.tm_min,
                                                     banFields[2].Get<std::string>(), banFields[3].Get<std::string>());
                        }
                        else
                        {
                            tm tmUnban = Acore::Time::TimeBreakdown(banFields[1].Get<uint32>());
                            handler->PSendSysMessage("|%-15.15s|%02d-%02d-%02d %02d:%02d|%02d-%02d-%02d %02d:%02d|%-15.15s|%-15.15s|",
                                                     char_name, tmBan.tm_year % 100, tmBan.tm_mon + 1, tmBan.tm_mday, tmBan.tm_hour, tmBan.tm_min,
                                                     tmUnban.tm_year % 100, tmUnban.tm_mon + 1, tmUnban.tm_mday, tmUnban.tm_hour, tmUnban.tm_min,
                                                     banFields[2].Get<std::string>(), banFields[3].Get<std::string>());
                        }
                    } while (banInfo->NextRow());
                }
            } while (result->NextRow());
            handler->SendSysMessage(" =============================================================================== ");
        }
 
        return true;
    }

References CHAR_SEL_BANINFO_LIST, CHAR_SEL_BANNED_NAME, CHAR_SEL_GUID_BY_NAME_FILTER, CharacterDatabase, Field::Get(), ChatHandler::GetSession(), LANG_BANLIST_CHARACTERS, LANG_BANLIST_CHARACTERS_HEADER, LANG_BANLIST_MATCHINGCHARACTER, LANG_BANLIST_NOCHARACTER, ChatHandler::PSendSysMessage(), ChatHandler::SendSysMessage(), PreparedStatementBase::SetData(), and Acore::Time::TimeBreakdown().

Referenced by GetCommands().

HandleBanListHelper()

static bool ban_commandscript::HandleBanListHelper ( PreparedQueryResult  result, ChatHandler *  handler  )

inlinestatic

    {
        handler->PSendSysMessage(LANG_BANLIST_MATCHINGACCOUNT);
 
        // Chat short output
        if (handler->GetSession())
        {
            do
            {
                Field* fields = result->Fetch();
                uint32 accountid = fields[0].Get<uint32>();
 
                QueryResult banResult = LoginDatabase.Query("SELECT account.username FROM account, account_banned WHERE account_banned.id='{}' AND account_banned.id=account.id", accountid);
                if (banResult)
                {
                    Field* fields2 = banResult->Fetch();
                    handler->PSendSysMessage("%s", fields2[0].Get<std::string>());
                }
            } while (result->NextRow());
        }
        // Console wide output
        else
        {
            handler->SendSysMessage(LANG_BANLIST_ACCOUNTS);
            handler->SendSysMessage(" ===============================================================================");
            handler->SendSysMessage(LANG_BANLIST_ACCOUNTS_HEADER);
            do
            {
                handler->SendSysMessage("-------------------------------------------------------------------------------");
                Field* fields = result->Fetch();
                uint32 accountId = fields[0].Get<uint32>();
 
                std::string accountName;
 
                // "account" case, name can be get in same query
                if (result->GetFieldCount() > 1)
                    accountName = fields[1].Get<std::string>();
                // "character" case, name need extract from another DB
                else
                    AccountMgr::GetName(accountId, accountName);
 
                // No SQL injection. id is uint32.
                QueryResult banInfo = LoginDatabase.Query("SELECT bandate, unbandate, bannedby, banreason FROM account_banned WHERE id = {} ORDER BY unbandate", accountId);
                if (banInfo)
                {
                    Field* fields2 = banInfo->Fetch();
                    do
                    {
                        tm tmBan = Acore::Time::TimeBreakdown(fields2[0].Get<uint32>());
 
                        if (fields2[0].Get<uint32>() == fields2[1].Get<uint32>())
                        {
                            handler->PSendSysMessage("|%-15.15s|%02d-%02d-%02d %02d:%02d|   permanent  |%-15.15s|%-15.15s|",
                                                     accountName, tmBan.tm_year % 100, tmBan.tm_mon + 1, tmBan.tm_mday, tmBan.tm_hour, tmBan.tm_min,
                                                     fields2[2].Get<std::string>(), fields2[3].Get<std::string>());
                        }
                        else
                        {
                            tm tmUnban = Acore::Time::TimeBreakdown(fields2[1].Get<uint32>());
                            handler->PSendSysMessage("|%-15.15s|%02d-%02d-%02d %02d:%02d|%02d-%02d-%02d %02d:%02d|%-15.15s|%-15.15s|",
                                                     accountName, tmBan.tm_year % 100, tmBan.tm_mon + 1, tmBan.tm_mday, tmBan.tm_hour, tmBan.tm_min,
                                                     tmUnban.tm_year % 100, tmUnban.tm_mon + 1, tmUnban.tm_mday, tmUnban.tm_hour, tmUnban.tm_min,
                                                     fields2[2].Get<std::string>(), fields2[3].Get<std::string>());
                        }
                    } while (banInfo->NextRow());
                }
            } while (result->NextRow());
 
            handler->SendSysMessage(" ===============================================================================");
        }
 
        return true;
    }

References Field::Get(), AccountMgr::GetName(), ChatHandler::GetSession(), LANG_BANLIST_ACCOUNTS, LANG_BANLIST_ACCOUNTS_HEADER, LANG_BANLIST_MATCHINGACCOUNT, LoginDatabase, ChatHandler::PSendSysMessage(), ChatHandler::SendSysMessage(), and Acore::Time::TimeBreakdown().

Referenced by HandleBanListAccountCommand().

HandleBanListIPCommand()

static bool ban_commandscript::HandleBanListIPCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_EXPIRED_IP_BANS);
        LoginDatabase.Execute(stmt);
 
        char* filterStr = strtok((char*)args, " ");
        std::string filter = filterStr ? filterStr : "";
        LoginDatabase.EscapeString(filter);
 
        PreparedQueryResult result;
 
        if (filter.empty())
        {
            LoginDatabasePreparedStatement* stmt2 = LoginDatabase.GetPreparedStatement(LOGIN_SEL_IP_BANNED_ALL);
            result = LoginDatabase.Query(stmt2);
        }
        else
        {
            LoginDatabasePreparedStatement* stmt2 = LoginDatabase.GetPreparedStatement(LOGIN_SEL_IP_BANNED_BY_IP);
            stmt2->SetData(0, filter);
            result = LoginDatabase.Query(stmt2);
        }
 
        if (!result)
        {
            handler->PSendSysMessage(LANG_BANLIST_NOIP);
            return true;
        }
 
        handler->PSendSysMessage(LANG_BANLIST_MATCHINGIP);
        // Chat short output
        if (handler->GetSession())
        {
            do
            {
                Field* fields = result->Fetch();
                handler->PSendSysMessage("%s", fields[0].Get<std::string>());
            } while (result->NextRow());
        }
        // Console wide output
        else
        {
            handler->SendSysMessage(LANG_BANLIST_IPS);
            handler->SendSysMessage(" ===============================================================================");
            handler->SendSysMessage(LANG_BANLIST_IPS_HEADER);
            do
            {
                handler->SendSysMessage("-------------------------------------------------------------------------------");
                Field* fields = result->Fetch();
                tm tmBan = Acore::Time::TimeBreakdown(fields[1].Get<uint32>());
                if (fields[1].Get<uint32>() == fields[2].Get<uint32>())
                {
                    handler->PSendSysMessage("|%-15.15s|%02d-%02d-%02d %02d:%02d|   permanent  |%-15.15s|%-15.15s|",
                                             fields[0].Get<std::string>(), tmBan.tm_year % 100, tmBan.tm_mon + 1, tmBan.tm_mday, tmBan.tm_hour, tmBan.tm_min,
                                             fields[3].Get<std::string>(), fields[4].Get<std::string>());
                }
                else
                {
                    tm tmUnban = Acore::Time::TimeBreakdown(fields[2].Get<uint32>());
                    handler->PSendSysMessage("|%-15.15s|%02d-%02d-%02d %02d:%02d|%02d-%02d-%02d %02d:%02d|%-15.15s|%-15.15s|",
                                             fields[0].Get<std::string>(), tmBan.tm_year % 100, tmBan.tm_mon + 1, tmBan.tm_mday, tmBan.tm_hour, tmBan.tm_min,
                                             tmUnban.tm_year % 100, tmUnban.tm_mon + 1, tmUnban.tm_mday, tmUnban.tm_hour, tmUnban.tm_min,
                                             fields[3].Get<std::string>(), fields[4].Get<std::string>());
                }
            } while (result->NextRow());
 
            handler->SendSysMessage(" ===============================================================================");
        }
 
        return true;
    }

References Field::Get(), ChatHandler::GetSession(), LANG_BANLIST_IPS, LANG_BANLIST_IPS_HEADER, LANG_BANLIST_MATCHINGIP, LANG_BANLIST_NOIP, LOGIN_DEL_EXPIRED_IP_BANS, LOGIN_SEL_IP_BANNED_ALL, LOGIN_SEL_IP_BANNED_BY_IP, LoginDatabase, ChatHandler::PSendSysMessage(), ChatHandler::SendSysMessage(), PreparedStatementBase::SetData(), and Acore::Time::TimeBreakdown().

Referenced by GetCommands().

HandleUnBanAccountByCharCommand()

static bool ban_commandscript::HandleUnBanAccountByCharCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        return HandleUnBanHelper(BAN_CHARACTER, args, handler);
    }

References BAN_CHARACTER, and HandleUnBanHelper().

Referenced by GetCommands().

HandleUnBanAccountCommand()

static bool ban_commandscript::HandleUnBanAccountCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        return HandleUnBanHelper(BAN_ACCOUNT, args, handler);
    }

References BAN_ACCOUNT, and HandleUnBanHelper().

Referenced by GetCommands().

HandleUnBanCharacterCommand()

static bool ban_commandscript::HandleUnBanCharacterCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        if (!*args)
            return false;
 
        char* nameStr = strtok((char*)args, " ");
        if (!nameStr)
            return false;
 
        std::string CharacterName = nameStr;
 
        if (!normalizePlayerName(CharacterName))
        {
            handler->SendErrorMessage(LANG_PLAYER_NOT_FOUND);
            return false;
        }
 
        if (!sBan->RemoveBanCharacter(CharacterName))
        {
            handler->SendErrorMessage(LANG_PLAYER_NOT_FOUND);
            return false;
        }
 
        return true;
    }

References LANG_PLAYER_NOT_FOUND, normalizePlayerName(), sBan, and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

HandleUnBanHelper()

static bool ban_commandscript::HandleUnBanHelper ( BanMode  mode, char const *  args, ChatHandler *  handler  )

inlinestatic

    {
        if (!*args)
            return false;
 
        char* nameOrIPStr = strtok((char*)args, " ");
        if (!nameOrIPStr)
            return false;
 
        std::string nameOrIP = nameOrIPStr;
 
        switch (mode)
        {
            case BAN_ACCOUNT:
                if (!Utf8ToUpperOnlyLatin(nameOrIP))
                {
                    handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, nameOrIP);
                    return false;
                }
                break;
            case BAN_CHARACTER:
                if (!normalizePlayerName(nameOrIP))
                {
                    handler->SendErrorMessage(LANG_PLAYER_NOT_FOUND);
                    return false;
                }
                break;
            case BAN_IP:
                if (!IsIPAddress(nameOrIP.c_str()))
                    return false;
                break;
        }
 
        switch (mode)
        {
            case BAN_ACCOUNT:
                if (sBan->RemoveBanAccount(nameOrIP))
                    handler->PSendSysMessage(LANG_UNBAN_UNBANNED, nameOrIP);
                else
                    handler->PSendSysMessage(LANG_UNBAN_ERROR, nameOrIP);
                break;
            case BAN_CHARACTER:
                if (sBan->RemoveBanAccountByPlayerName(nameOrIP))
                    handler->PSendSysMessage(LANG_UNBAN_UNBANNED, nameOrIP);
                else
                    handler->PSendSysMessage(LANG_UNBAN_ERROR, nameOrIP);
                break;
            case BAN_IP:
                if (sBan->RemoveBanIP(nameOrIP))
                    handler->PSendSysMessage(LANG_UNBAN_UNBANNED, nameOrIP);
                else
                    handler->PSendSysMessage(LANG_UNBAN_ERROR, nameOrIP);
                break;
            default:
                break;
        }
 
        return true;
    }

References BAN_ACCOUNT, BAN_CHARACTER, BAN_IP, IsIPAddress(), LANG_ACCOUNT_NOT_EXIST, LANG_PLAYER_NOT_FOUND, LANG_UNBAN_ERROR, LANG_UNBAN_UNBANNED, normalizePlayerName(), ChatHandler::PSendSysMessage(), sBan, ChatHandler::SendErrorMessage(), and Utf8ToUpperOnlyLatin().

Referenced by HandleUnBanAccountByCharCommand(), HandleUnBanAccountCommand(), and HandleUnBanIPCommand().

HandleUnBanIPCommand()

static bool ban_commandscript::HandleUnBanIPCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        return HandleUnBanHelper(BAN_IP, args, handler);
    }

References BAN_IP, and HandleUnBanHelper().

Referenced by GetCommands().