server_commandscript Class Reference

Inheritance diagram for server_commandscript:

Public Member Functions
	server_commandscript ()
ChatCommandTable	GetCommands () const override
Public Member Functions inherited from ScriptObject
virtual bool	IsDatabaseBound () const
virtual bool	isAfterLoadScript () const
virtual void	checkValidity ()
std::string const &	GetName () const
uint16	GetTotalAvailableHooks ()

Static Public Member Functions
static bool	HandleServerCorpsesCommand (ChatHandler *)
static bool	HandleServerDebugCommand (ChatHandler *handler)
static bool	HandleServerInfoCommand (ChatHandler *handler)
static void	SendPreviousSessionInfo (ChatHandler *handler)
static AcoreStrings	GetShutdownTypeString (SessionShutdownType type)
static bool	HandleServerMotdCommand (ChatHandler *handler)
static bool	HandleServerShutDownCancelCommand (ChatHandler *)
static bool	HandleServerShutDownCommand (ChatHandler *handler, std::string time, Optional< int32 > exitCode, Tail reason)
static bool	HandleServerRestartCommand (ChatHandler *handler, std::string time, Optional< int32 > exitCode, Tail reason)
static bool	HandleServerIdleRestartCommand (ChatHandler *handler, std::string time, Optional< int32 > exitCode, Tail reason)
static bool	HandleServerIdleShutDownCommand (ChatHandler *handler, std::string time, Optional< int32 > exitCode, Tail reason)
static bool	HandleServerExitCommand (ChatHandler *handler)
static bool	HandleServerSetMotdCommand (ChatHandler *handler, Optional< int32 > realmId, std::string locale, Tail motd)
static bool	HandleServerSetClosedCommand (ChatHandler *handler, Optional< std::string > args)
static bool	HandleServerSetSecurityCommand (ChatHandler *handler, uint8 level)
static bool	HandleServerSetLogLevelCommand (ChatHandler *, bool isLogger, std::string const &name, int32 level)

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

Detailed Description

Constructor & Destructor Documentation

server_commandscript()

server_commandscript::server_commandscript ( )

inline

: CommandScript("server_commandscript") { }

Member Function Documentation

GetCommands()

ChatCommandTable server_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

    {
        static ChatCommandTable serverIdleRestartCommandTable =
        {
            { "cancel",       HandleServerShutDownCancelCommand, rbac::RBAC_PERM_COMMAND_SERVER_IDLERESTART_CANCEL, Console::Yes },
            { "",             HandleServerIdleRestartCommand,    rbac::RBAC_PERM_COMMAND_SERVER_IDLERESTART,        Console::Yes }
        };
 
        static ChatCommandTable serverIdleShutdownCommandTable =
        {
            { "cancel",       HandleServerShutDownCancelCommand, rbac::RBAC_PERM_COMMAND_SERVER_IDLESHUTDOWN_CANCEL, Console::Yes },
            { "",             HandleServerIdleShutDownCommand,   rbac::RBAC_PERM_COMMAND_SERVER_IDLESHUTDOWN,        Console::Yes }
        };
 
        static ChatCommandTable serverRestartCommandTable =
        {
            { "cancel",       HandleServerShutDownCancelCommand, rbac::RBAC_PERM_COMMAND_SERVER_RESTART_CANCEL, Console::Yes },
            { "",             HandleServerRestartCommand,        rbac::RBAC_PERM_COMMAND_SERVER_RESTART,        Console::Yes }
        };
 
        static ChatCommandTable serverShutdownCommandTable =
        {
            { "cancel",       HandleServerShutDownCancelCommand, rbac::RBAC_PERM_COMMAND_SERVER_SHUTDOWN_CANCEL, Console::Yes },
            { "",             HandleServerShutDownCommand,       rbac::RBAC_PERM_COMMAND_SERVER_SHUTDOWN,        Console::Yes }
        };
 
        static ChatCommandTable serverSetCommandTable =
        {
            { "loglevel",     HandleServerSetLogLevelCommand,    rbac::RBAC_PERM_COMMAND_SERVER_SET_LOGLEVEL, Console::Yes },
            { "motd",         HandleServerSetMotdCommand,        rbac::RBAC_PERM_COMMAND_SERVER_SET_MOTD,     Console::Yes },
            { "closed",       HandleServerSetClosedCommand,      rbac::RBAC_PERM_COMMAND_SERVER_SET_CLOSED,   Console::Yes },
            { "security",     HandleServerSetSecurityCommand,    rbac::RBAC_PERM_COMMAND_SERVER_SET_SECURITY, Console::Yes },
        };
 
        static ChatCommandTable serverCommandTable =
        {
            { "corpses",      HandleServerCorpsesCommand,        rbac::RBAC_PERM_COMMAND_SERVER_CORPSES,  Console::Yes },
            { "debug",        HandleServerDebugCommand,          rbac::RBAC_PERM_COMMAND_SERVER_DEBUG,    Console::Yes },
            { "exit",         HandleServerExitCommand,           rbac::RBAC_PERM_COMMAND_SERVER_EXIT,     Console::Yes },
            { "idlerestart",  serverIdleRestartCommandTable },
            { "idleshutdown", serverIdleShutdownCommandTable },
            { "info",         HandleServerInfoCommand,           rbac::RBAC_PERM_COMMAND_SERVER_INFO,     Console::Yes },
            { "motd",         HandleServerMotdCommand,           rbac::RBAC_PERM_COMMAND_SERVER_MOTD,     Console::Yes },
            { "restart",      serverRestartCommandTable },
            { "shutdown",     serverShutdownCommandTable },
            { "set",          serverSetCommandTable }
        };
 
        static ChatCommandTable commandTable =
        {
            { "server", serverCommandTable }
        };
 
        return commandTable;
    }

References HandleServerCorpsesCommand(), HandleServerDebugCommand(), HandleServerExitCommand(), HandleServerIdleRestartCommand(), HandleServerIdleShutDownCommand(), HandleServerInfoCommand(), HandleServerMotdCommand(), HandleServerRestartCommand(), HandleServerSetClosedCommand(), HandleServerSetLogLevelCommand(), HandleServerSetMotdCommand(), HandleServerSetSecurityCommand(), HandleServerShutDownCancelCommand(), HandleServerShutDownCommand(), rbac::RBAC_PERM_COMMAND_SERVER_CORPSES, rbac::RBAC_PERM_COMMAND_SERVER_DEBUG, rbac::RBAC_PERM_COMMAND_SERVER_EXIT, rbac::RBAC_PERM_COMMAND_SERVER_IDLERESTART, rbac::RBAC_PERM_COMMAND_SERVER_IDLERESTART_CANCEL, rbac::RBAC_PERM_COMMAND_SERVER_IDLESHUTDOWN, rbac::RBAC_PERM_COMMAND_SERVER_IDLESHUTDOWN_CANCEL, rbac::RBAC_PERM_COMMAND_SERVER_INFO, rbac::RBAC_PERM_COMMAND_SERVER_MOTD, rbac::RBAC_PERM_COMMAND_SERVER_RESTART, rbac::RBAC_PERM_COMMAND_SERVER_RESTART_CANCEL, rbac::RBAC_PERM_COMMAND_SERVER_SET_CLOSED, rbac::RBAC_PERM_COMMAND_SERVER_SET_LOGLEVEL, rbac::RBAC_PERM_COMMAND_SERVER_SET_MOTD, rbac::RBAC_PERM_COMMAND_SERVER_SET_SECURITY, rbac::RBAC_PERM_COMMAND_SERVER_SHUTDOWN, and rbac::RBAC_PERM_COMMAND_SERVER_SHUTDOWN_CANCEL.

GetShutdownTypeString()

static AcoreStrings server_commandscript::GetShutdownTypeString ( SessionShutdownType  type )

inlinestatic

    {
        switch (type)
        {
            case SHUTDOWN_TYPE_RESTART:
                return LANG_COMMAND_SERVER_INFO_TYPE_RESTART;
            case SHUTDOWN_TYPE_ERROR:
                return LANG_COMMAND_SERVER_INFO_TYPE_ERROR;
            default:
                return LANG_COMMAND_SERVER_INFO_TYPE_SHUTDOWN;
        }
    }

References LANG_COMMAND_SERVER_INFO_TYPE_ERROR, LANG_COMMAND_SERVER_INFO_TYPE_RESTART, LANG_COMMAND_SERVER_INFO_TYPE_SHUTDOWN, SHUTDOWN_TYPE_ERROR, and SHUTDOWN_TYPE_RESTART.

Referenced by SendPreviousSessionInfo().

HandleServerCorpsesCommand()

static bool server_commandscript::HandleServerCorpsesCommand ( ChatHandler *  )

inlinestatic

    {
        sMapMgr->DoForAllMaps([](Map* map)
        {
            map->RemoveOldCorpses();
        });
        return true;
    }

References Map::RemoveOldCorpses(), and sMapMgr.

Referenced by GetCommands().

HandleServerDebugCommand()

static bool server_commandscript::HandleServerDebugCommand ( ChatHandler *  handler )

inlinestatic

    {
        uint16 worldPort = uint16(sWorld->getIntConfig(CONFIG_PORT_WORLD));
        std::string dbPortOutput;
 
        {
            uint16 dbPort = 0;
            if (QueryResult res = LoginDatabase.Query("SELECT port FROM realmlist WHERE id = {}", realm.Id.Realm))
                dbPort = (*res)[0].Get<uint16>();
 
            if (dbPort)
                dbPortOutput = Acore::StringFormat("Realmlist (Realm Id: {}) configured in port {}", realm.Id.Realm, dbPort);
            else
                dbPortOutput = Acore::StringFormat("Realm Id: {} not found in `realmlist` table. Please check your setup", realm.Id.Realm);
        }
 
        HandleServerInfoCommand(handler);
 
        handler->PSendSysMessage("Using SSL version: {} (library: {})", OPENSSL_VERSION_TEXT, OpenSSL_version(OPENSSL_VERSION));
        handler->PSendSysMessage("Using Boost version: {}.{}.{}", BOOST_VERSION / 100000, BOOST_VERSION / 100 % 1000, BOOST_VERSION % 100);
        handler->PSendSysMessage("Using CMake version: {}", GitRevision::GetCMakeVersion());
 
        handler->PSendSysMessage("Using MySQL version: {}", MySQL::GetLibraryVersion());
        handler->PSendSysMessage("Found MySQL Executable: {}", GitRevision::GetMySQLExecutable());
 
        handler->PSendSysMessage("Compiled on: {}", GitRevision::GetHostOSVersion());
 
        handler->PSendSysMessage("Worldserver listening connections on port {}", worldPort);
        handler->PSendSysMessage("{}", dbPortOutput);
 
        bool vmapIndoorCheck = sWorld->getBoolConfig(CONFIG_VMAP_INDOOR_CHECK);
        bool vmapLOSCheck = VMAP::VMapFactory::createOrGetVMapMgr()->isLineOfSightCalcEnabled();
        bool vmapHeightCheck = VMAP::VMapFactory::createOrGetVMapMgr()->isHeightCalcEnabled();
 
        bool mmapEnabled = sWorld->getBoolConfig(CONFIG_ENABLE_MMAPS);
 
        std::string dataDir = sWorld->GetDataPath();
        std::vector<std::string> subDirs;
        subDirs.emplace_back("maps");
        if (vmapIndoorCheck || vmapLOSCheck || vmapHeightCheck)
        {
            handler->PSendSysMessage("VMAPs status: Enabled. LineOfSight: {}, getHeight: {}, indoorCheck: {}", vmapLOSCheck, vmapHeightCheck, vmapIndoorCheck);
            subDirs.emplace_back("vmaps");
        }
        else
            handler->SendSysMessage("VMAPs status: Disabled");
 
        if (mmapEnabled)
        {
            handler->SendSysMessage("MMAPs status: Enabled");
            subDirs.emplace_back("mmaps");
        }
        else
            handler->SendSysMessage("MMAPs status: Disabled");
 
        for (std::string const& subDir : subDirs)
        {
            std::filesystem::path mapPath(dataDir);
            mapPath /= subDir;
 
            if (!std::filesystem::exists(mapPath))
            {
                handler->PSendSysMessage("{} directory doesn't exist!. Using path: {}", subDir, mapPath.generic_string());
                continue;
            }
 
            auto end = std::filesystem::directory_iterator();
            std::size_t folderSize = std::accumulate(std::filesystem::directory_iterator(mapPath), end, std::size_t(0), [](std::size_t val, std::filesystem::path const& mapFile)
            {
                if (std::filesystem::is_regular_file(mapFile))
                    val += std::filesystem::file_size(mapFile);
                return val;
            });
 
            handler->PSendSysMessage("{} directory located in {}. Total size: {} bytes", subDir, mapPath.generic_string(), folderSize);
        }
 
        LocaleConstant defaultLocale = sWorld->GetDefaultDbcLocale();
        uint32 availableLocalesMask = (1 << defaultLocale);
 
        for (uint8 i = 0; i < TOTAL_LOCALES; ++i)
        {
            LocaleConstant locale = static_cast<LocaleConstant>(i);
            if (locale == defaultLocale)
                continue;
 
            if (sWorld->GetAvailableDbcLocale(locale) != defaultLocale)
                availableLocalesMask |= (1 << locale);
        }
 
        std::string availableLocales;
        for (uint8 i = 0; i < TOTAL_LOCALES; ++i)
        {
            if (!(availableLocalesMask & (1 << i)))
                continue;
 
            availableLocales += localeNames[i];
            if (i != TOTAL_LOCALES - 1)
                availableLocales += " ";
        }
 
        handler->PSendSysMessage("Default DBC locale: {}.\nAll available DBC locales: {}", localeNames[defaultLocale], availableLocales);
 
        handler->PSendSysMessage("Using World DB: {}", sWorld->GetDBVersion());
 
        std::map<std::string, std::string> moduleDBRevisions;
        sScriptMgr->OnDatabaseGetDBRevision(moduleDBRevisions);
        for (auto const& [moduleName, revision] : moduleDBRevisions)
            handler->PSendSysMessage("Using {} DB Revision: {}", moduleName, revision);
 
        std::string lldb = "No updates found!";
        if (QueryResult resL = LoginDatabase.Query("SELECT name FROM updates ORDER BY name DESC LIMIT 1"))
        {
            Field* fields = resL->Fetch();
            lldb = fields[0].Get<std::string>();
        }
        std::string lcdb = "No updates found!";
        if (QueryResult resC = CharacterDatabase.Query("SELECT name FROM updates ORDER BY name DESC LIMIT 1"))
        {
            Field* fields = resC->Fetch();
            lcdb = fields[0].Get<std::string>();
        }
        std::string lwdb = "No updates found!";
        if (QueryResult resW = WorldDatabase.Query("SELECT name FROM updates ORDER BY name DESC LIMIT 1"))
        {
            Field* fields = resW->Fetch();
            lwdb = fields[0].Get<std::string>();
        }
 
        handler->PSendSysMessage("Latest LoginDatabase update: {}", lldb);
        handler->PSendSysMessage("Latest CharacterDatabase update: {}", lcdb);
        handler->PSendSysMessage("Latest WorldDatabase update: {}", lwdb);
 
        handler->PSendSysMessage("LoginDatabase queue size: {}", LoginDatabase.QueueSize());
        handler->PSendSysMessage("CharacterDatabase queue size: {}", CharacterDatabase.QueueSize());
        handler->PSendSysMessage("WorldDatabase queue size: {}", WorldDatabase.QueueSize());
 
        if (Acore::Module::GetEnableModulesList().empty())
            handler->PSendSysMessage("No modules are enabled");
        else
            handler->PSendSysMessage("List of enabled modules:");
 
        for (auto const& modName : Acore::Module::GetEnableModulesList())
        {
            handler->PSendSysMessage("|- {}", modName);
        }
 
        return true;
    }

References CharacterDatabase, CONFIG_ENABLE_MMAPS, CONFIG_PORT_WORLD, CONFIG_VMAP_INDOOR_CHECK, VMAP::VMapFactory::createOrGetVMapMgr(), Field::Get(), GitRevision::GetCMakeVersion(), Acore::Module::GetEnableModulesList(), GitRevision::GetHostOSVersion(), MySQL::GetLibraryVersion(), GitRevision::GetMySQLExecutable(), HandleServerInfoCommand(), Realm::Id, VMAP::IVMapMgr::isHeightCalcEnabled(), VMAP::IVMapMgr::isLineOfSightCalcEnabled(), localeNames, LoginDatabase, ChatHandler::PSendSysMessage(), realm, RealmHandle::Realm, ChatHandler::SendSysMessage(), sScriptMgr, Acore::StringFormat(), sWorld, TOTAL_LOCALES, and WorldDatabase.

Referenced by GetCommands().

HandleServerExitCommand()

static bool server_commandscript::HandleServerExitCommand ( ChatHandler *  handler )

inlinestatic

    {
        handler->SendSysMessage(LANG_COMMAND_EXIT);
        World::StopNow(SHUTDOWN_EXIT_CODE);
        return true;
    }

References LANG_COMMAND_EXIT, ChatHandler::SendSysMessage(), SHUTDOWN_EXIT_CODE, and World::StopNow().

Referenced by GetCommands().

HandleServerIdleRestartCommand()

static bool server_commandscript::HandleServerIdleRestartCommand ( ChatHandler *  handler, std::string  time, Optional< int32 >  exitCode, Tail  reason  )

inlinestatic

    {
        std::wstring wReason   = std::wstring();
        std::string  strReason = std::string();
 
        if (time.empty())
        {
            return false;
        }
 
        if (Acore::StringTo<int32>(time).value_or(0) < 0)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        if (!reason.empty())
        {
            if (!Utf8toWStr(reason, wReason))
            {
                return false;
            }
 
            if (!WStrToUtf8(wReason, strReason))
            {
                return false;
            }
        }
 
        int32 delay = TimeStringToSecs(time);
        if (delay <= 0)
        {
            delay = Acore::StringTo<int32>(time).value_or(0);
        }
 
        if (delay <= 0)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        if (exitCode && *exitCode >= 0 && *exitCode <= 125)
        {
            sWorld->ShutdownServ(delay, SHUTDOWN_MASK_RESTART | SHUTDOWN_MASK_IDLE, *exitCode, strReason);
        }
        else
        {
            sWorld->ShutdownServ(delay, SHUTDOWN_MASK_RESTART | SHUTDOWN_MASK_IDLE, RESTART_EXIT_CODE, strReason);
        }
 
        return true;
    }

References LANG_BAD_VALUE, RESTART_EXIT_CODE, ChatHandler::SendErrorMessage(), SHUTDOWN_MASK_IDLE, SHUTDOWN_MASK_RESTART, sWorld, TimeStringToSecs(), Utf8toWStr(), and WStrToUtf8().

Referenced by GetCommands().

HandleServerIdleShutDownCommand()

static bool server_commandscript::HandleServerIdleShutDownCommand ( ChatHandler *  handler, std::string  time, Optional< int32 >  exitCode, Tail  reason  )

inlinestatic

    {
        std::wstring wReason   = std::wstring();
        std::string  strReason = std::string();
 
        if (time.empty())
        {
            return false;
        }
 
        if (Acore::StringTo<int32>(time).value_or(0) < 0)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        if (!reason.empty())
        {
            if (!Utf8toWStr(reason, wReason))
            {
                return false;
            }
 
            if (!WStrToUtf8(wReason, strReason))
            {
                return false;
            }
        }
 
        int32 delay = TimeStringToSecs(time);
        if (delay <= 0)
        {
            delay = Acore::StringTo<int32>(time).value_or(0);
        }
 
        if (delay <= 0)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        if (exitCode && *exitCode >= 0 && *exitCode <= 125)
        {
            sWorld->ShutdownServ(delay, SHUTDOWN_MASK_IDLE, *exitCode, strReason);
        }
        else
        {
            sWorld->ShutdownServ(delay, SHUTDOWN_MASK_IDLE, SHUTDOWN_EXIT_CODE, strReason);
        }
 
        return true;
    }

References LANG_BAD_VALUE, ChatHandler::SendErrorMessage(), SHUTDOWN_EXIT_CODE, SHUTDOWN_MASK_IDLE, sWorld, TimeStringToSecs(), Utf8toWStr(), and WStrToUtf8().

Referenced by GetCommands().

HandleServerInfoCommand()

static bool server_commandscript::HandleServerInfoCommand ( ChatHandler *  handler )

inlinestatic

Can't use sWorld->ShutdownMsg here in case of console command

    {
        std::string realmName = sWorld->GetRealmName();
        uint32 playerCount = sWorldSessionMgr->GetPlayerCount();
        uint32 activeSessionCount = sWorldSessionMgr->GetActiveSessionCount();
        uint32 queuedSessionCount = sWorldSessionMgr->GetQueuedSessionCount();
        uint32 connPeak = sWorldSessionMgr->GetMaxActiveSessionCount();
 
        handler->PSendSysMessage("{}", GitRevision::GetFullVersion());
        if (!queuedSessionCount)
            handler->PSendSysMessage(LANG_COMMAND_SERVER_INFO_CONNECTED, activeSessionCount, connPeak);
        else
            handler->PSendSysMessage(LANG_COMMAND_SERVER_INFO_CONNECTED_QUEUE, activeSessionCount, connPeak, queuedSessionCount);
 
        handler->PSendSysMessage(LANG_COMMAND_SERVER_INFO_CHARACTERS_IN_WORLD, playerCount, sWorldSessionMgr->GetMaxPlayerCount(), sWorld->GetLifetimeMaxPlayerCount());
        handler->PSendSysMessage(LANG_COMMAND_SERVER_INFO_SECURITY, uint32(sWorld->GetPlayerSecurityLimit()));
        handler->PSendSysMessage(LANG_UPTIME, secsToTimeString(GameTime::GetUptime().count()));
        handler->PSendSysMessage(LANG_COMMAND_SERVER_INFO_UPDATE_DIFF, sWorldUpdateTime.GetLastUpdateTime(), sWorldUpdateTime.GetDatasetSize());
        handler->PSendSysMessage(LANG_COMMAND_SERVER_INFO_UPDATE_MEAN, sWorldUpdateTime.GetAverageUpdateTime());
        handler->PSendSysMessage(LANG_COMMAND_SERVER_INFO_UPDATE_MEDIAN, sWorldUpdateTime.GetPercentile(50));
        handler->PSendSysMessage(LANG_COMMAND_SERVER_INFO_UPDATE_PERCENTILES,
                                 sWorldUpdateTime.GetPercentile(95),
                                 sWorldUpdateTime.GetPercentile(99),
                                 sWorldUpdateTime.GetPercentile(100));
 
        if (sWorld->IsShuttingDown())
            handler->PSendSysMessage(LANG_SHUTDOWN_TIMELEFT, secsToTimeString(sWorld->GetShutDownTimeLeft()).append("."));
 
        SendPreviousSessionInfo(handler);
 
        return true;
    }

References UpdateTime::GetAverageUpdateTime(), UpdateTime::GetDatasetSize(), GitRevision::GetFullVersion(), UpdateTime::GetLastUpdateTime(), UpdateTime::GetPercentile(), GameTime::GetUptime(), LANG_COMMAND_SERVER_INFO_CHARACTERS_IN_WORLD, LANG_COMMAND_SERVER_INFO_CONNECTED, LANG_COMMAND_SERVER_INFO_CONNECTED_QUEUE, LANG_COMMAND_SERVER_INFO_SECURITY, LANG_COMMAND_SERVER_INFO_UPDATE_DIFF, LANG_COMMAND_SERVER_INFO_UPDATE_MEAN, LANG_COMMAND_SERVER_INFO_UPDATE_MEDIAN, LANG_COMMAND_SERVER_INFO_UPDATE_PERCENTILES, LANG_SHUTDOWN_TIMELEFT, LANG_UPTIME, ChatHandler::PSendSysMessage(), secsToTimeString(), SendPreviousSessionInfo(), sWorld, sWorldSessionMgr, and sWorldUpdateTime.

Referenced by GetCommands(), and HandleServerDebugCommand().

HandleServerMotdCommand()

static bool server_commandscript::HandleServerMotdCommand ( ChatHandler *  handler )

inlinestatic

    {
        handler->PSendSysMessage(LANG_MOTD_CURRENT);
        for (uint32 i = 0; i < TOTAL_LOCALES; ++i)
        {
            if (!IsLocaleRegistered(LocaleConstant(i)))
                continue;
 
            handler->PSendSysMessage(LANG_GENERIC_TWO_CURLIES_WITH_COLON, GetNameByLocaleConstant(LocaleConstant(i)), sMotdMgr->GetMotd(LocaleConstant(i)));
        }
 
        return true;
    }

References GetNameByLocaleConstant(), IsLocaleRegistered(), LANG_GENERIC_TWO_CURLIES_WITH_COLON, LANG_MOTD_CURRENT, ChatHandler::PSendSysMessage(), sMotdMgr, and TOTAL_LOCALES.

Referenced by GetCommands().

HandleServerRestartCommand()

static bool server_commandscript::HandleServerRestartCommand ( ChatHandler *  handler, std::string  time, Optional< int32 >  exitCode, Tail  reason  )

inlinestatic

    {
        std::wstring wReason = std::wstring();
        std::string strReason    = std::string();
 
        if (time.empty())
        {
            return false;
        }
 
        if (Acore::StringTo<int32>(time).value_or(0) < 0)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        if (!reason.empty())
        {
            if (!Utf8toWStr(reason, wReason))
            {
                return false;
            }
 
            if (!WStrToUtf8(wReason, strReason))
            {
                return false;
            }
        }
 
        int32 delay = TimeStringToSecs(time);
        if (delay <= 0)
        {
            delay = Acore::StringTo<int32>(time).value_or(0);
        }
 
        if (delay <= 0)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        if (exitCode && *exitCode >= 0 && *exitCode <= 125)
        {
            sWorld->ShutdownServ(delay, SHUTDOWN_MASK_RESTART, *exitCode, strReason);
        }
        else
        {
            sWorld->ShutdownServ(delay, SHUTDOWN_MASK_RESTART, RESTART_EXIT_CODE, strReason);
        }
 
        return true;
    }

References LANG_BAD_VALUE, RESTART_EXIT_CODE, ChatHandler::SendErrorMessage(), SHUTDOWN_MASK_RESTART, sWorld, TimeStringToSecs(), Utf8toWStr(), and WStrToUtf8().

Referenced by GetCommands().

HandleServerSetClosedCommand()

static bool server_commandscript::HandleServerSetClosedCommand ( ChatHandler *  handler, Optional< std::string >  args  )

inlinestatic

    {
        if (StringStartsWith("on", *args))
        {
            handler->SendSysMessage(LANG_WORLD_CLOSED);
            sWorld->SetClosed(true);
            return true;
        }
        else if (StringStartsWith("off", *args))
        {
            handler->SendSysMessage(LANG_WORLD_OPENED);
            sWorld->SetClosed(false);
            return true;
        }
 
        handler->SendErrorMessage(LANG_USE_BOL);
        return false;
    }

References LANG_USE_BOL, LANG_WORLD_CLOSED, LANG_WORLD_OPENED, ChatHandler::SendErrorMessage(), ChatHandler::SendSysMessage(), StringStartsWith(), and sWorld.

Referenced by GetCommands().

HandleServerSetLogLevelCommand()

static bool server_commandscript::HandleServerSetLogLevelCommand ( ChatHandler *  , bool  isLogger, std::string const &  name, int32  level  )

inlinestatic

    {
        sLog->SetLogLevel(name, level, isLogger);
        return true;
    }

References sLog.

Referenced by GetCommands().

HandleServerSetMotdCommand()

static bool server_commandscript::HandleServerSetMotdCommand ( ChatHandler *  handler, Optional< int32 >  realmId, std::string  locale, Tail  motd  )

inlinestatic

    {
        std::wstring wMotd = std::wstring();
        std::string strMotd = std::string();
 
        // Default realmId to the current realm if not provided
        if (!realmId)
            realmId = static_cast<int32>(realm.Id.Realm);
 
        // Determine the locale; default to "enUS" if not provided
        LocaleConstant localeConstant;
        if (IsLocaleValid(locale))
            localeConstant = GetLocaleByName(locale);
        else
        {
            handler->SendErrorMessage("locale ({}) is not valid. Valid locales: enUS, koKR, frFR, deDE, zhCN, zhTW, esES, esMX, ruRU.", locale);
            return false;
        }
 
        if (motd.empty())
            return false;
 
        // Convert the concatenated motdString to UTF-8 and ensure encoding consistency
        if (!Utf8toWStr(motd, wMotd))
            return false;
 
        if (!WStrToUtf8(wMotd, strMotd))
            return false;
 
        // Start a transaction for the database operations
        LoginDatabaseTransaction trans = LoginDatabase.BeginTransaction();
 
        if (localeConstant == LOCALE_enUS)
        {
            // Insert or update in the main motd table for enUS
            LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_REP_MOTD);
            stmt->SetData(0, realmId.value());  // realmId for insertion
            stmt->SetData(1, strMotd);          // motd text for insertion
            trans->Append(stmt);
        }
        else
        {
            // Insert or update in the motd_localized table for other locales
            LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_REP_MOTD_LOCALE);
            stmt->SetData(0, realmId.value());  // realmId for insertion
            stmt->SetData(1, locale);           // locale for insertion
            stmt->SetData(2, strMotd);          // motd text for insertion
            trans->Append(stmt);
        }
 
        // Commit the transaction & update db
        LoginDatabase.CommitTransaction(trans);
 
        sMotdMgr->SetMotd(strMotd, localeConstant);
        handler->PSendSysMessage(LANG_MOTD_NEW, realmId.value(), locale, strMotd);
        return true;
    }

References GetLocaleByName(), Realm::Id, IsLocaleValid(), LANG_MOTD_NEW, LOCALE_enUS, LOGIN_REP_MOTD, LOGIN_REP_MOTD_LOCALE, LoginDatabase, ChatHandler::PSendSysMessage(), realm, RealmHandle::Realm, ChatHandler::SendErrorMessage(), PreparedStatementBase::SetData(), sMotdMgr, Utf8toWStr(), and WStrToUtf8().

Referenced by GetCommands().

HandleServerSetSecurityCommand()

static bool server_commandscript::HandleServerSetSecurityCommand ( ChatHandler *  handler, uint8  level  )

inlinestatic

    {
        if (level > SEC_ADMINISTRATOR)
        {
            handler->SendErrorMessage(LANG_COMMAND_SERVER_SET_SECURITY_ERROR, SEC_PLAYER, SEC_ADMINISTRATOR);
            return false;
        }
 
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_REALMLIST_SECURITY_LEVEL);
        stmt->SetData(0, level);
        stmt->SetData(1, realm.Id.Realm);
        LoginDatabase.Execute(stmt);
 
        // Apply live; raising the limit kicks any now-disallowed sessions.
        sWorld->SetPlayerSecurityLimit(AccountTypes(level));
 
        handler->PSendSysMessage(LANG_COMMAND_SERVER_SET_SECURITY, level);
        return true;
    }

References Realm::Id, LANG_COMMAND_SERVER_SET_SECURITY, LANG_COMMAND_SERVER_SET_SECURITY_ERROR, LOGIN_UPD_REALMLIST_SECURITY_LEVEL, LoginDatabase, ChatHandler::PSendSysMessage(), realm, RealmHandle::Realm, SEC_ADMINISTRATOR, SEC_PLAYER, ChatHandler::SendErrorMessage(), PreparedStatementBase::SetData(), and sWorld.

Referenced by GetCommands().

HandleServerShutDownCancelCommand()

static bool server_commandscript::HandleServerShutDownCancelCommand ( ChatHandler *  )

inlinestatic

    {
        sWorld->ShutdownCancel();
 
        return true;
    }

References sWorld.

Referenced by GetCommands().

HandleServerShutDownCommand()

static bool server_commandscript::HandleServerShutDownCommand ( ChatHandler *  handler, std::string  time, Optional< int32 >  exitCode, Tail  reason  )

inlinestatic

    {
        std::wstring wReason   = std::wstring();
        std::string  strReason = std::string();
 
        if (time.empty())
        {
            return false;
        }
 
        if (Acore::StringTo<int32>(time).value_or(0) < 0)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        if (!reason.empty())
        {
            if (!Utf8toWStr(reason, wReason))
            {
                return false;
            }
 
            if (!WStrToUtf8(wReason, strReason))
            {
                return false;
            }
        }
 
        int32 delay = TimeStringToSecs(time);
        if (delay <= 0)
        {
            delay = Acore::StringTo<int32>(time).value_or(0);
        }
 
        if (delay <= 0)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        if (exitCode && *exitCode >= 0 && *exitCode <= 125)
        {
            sWorld->ShutdownServ(delay, 0, *exitCode, strReason);
        }
        else
        {
            sWorld->ShutdownServ(delay, 0, SHUTDOWN_EXIT_CODE, strReason);
        }
 
        return true;
    }

References LANG_BAD_VALUE, ChatHandler::SendErrorMessage(), SHUTDOWN_EXIT_CODE, sWorld, TimeStringToSecs(), Utf8toWStr(), and WStrToUtf8().

Referenced by GetCommands().

SendPreviousSessionInfo()

static void server_commandscript::SendPreviousSessionInfo ( ChatHandler *  handler )

inlinestatic

    {
        Optional<PreviousSessionInfo> const& previous = sWorld->GetPreviousSessionInfo();
        if (!previous)
            return;
 
        std::string uptime = secsToTimeString(previous->Uptime.count());
 
        if (previous->Crashed)
        {
            std::string lastSeen = Acore::Time::TimeToTimestampStr(previous->StartTime + previous->Uptime);
 
            // A crash with a type set happened after the world loop had already stopped
            if (previous->Type == SHUTDOWN_TYPE_UNKNOWN)
                handler->PSendSysMessage(LANG_COMMAND_SERVER_INFO_CRASH_RECOVERED, uptime, lastSeen);
            else
                handler->PSendSysMessage(LANG_COMMAND_SERVER_INFO_CRASH_DURING, handler->GetAcoreString(GetShutdownTypeString(previous->Type)), uptime, lastSeen);
        }
        else if (previous->Type == SHUTDOWN_TYPE_UNKNOWN)
            handler->PSendSysMessage(LANG_COMMAND_SERVER_INFO_PREVIOUS_RAN, uptime);
        else
            handler->PSendSysMessage(LANG_COMMAND_SERVER_INFO_PREVIOUS_ENDED, handler->GetAcoreString(GetShutdownTypeString(previous->Type)), uptime);
 
        if (!previous->Reason.empty())
            handler->PSendSysMessage(LANG_COMMAND_SERVER_INFO_SHUTDOWN_REASON, previous->Reason);
    }

References ChatHandler::GetAcoreString(), GetShutdownTypeString(), LANG_COMMAND_SERVER_INFO_CRASH_DURING, LANG_COMMAND_SERVER_INFO_CRASH_RECOVERED, LANG_COMMAND_SERVER_INFO_PREVIOUS_ENDED, LANG_COMMAND_SERVER_INFO_PREVIOUS_RAN, LANG_COMMAND_SERVER_INFO_SHUTDOWN_REASON, ChatHandler::PSendSysMessage(), secsToTimeString(), SHUTDOWN_TYPE_UNKNOWN, sWorld, and Acore::Time::TimeToTimestampStr().

Referenced by HandleServerInfoCommand().

---

The documentation for this class was generated from the following file:

• azerothcore-wotlk/src/server/scripts/Commands/cs_server.cpp