AzerothCore 3.3.5a
OpenSource WoW Emulator
Loading...
Searching...
No Matches
server_commandscript Class Reference
Inheritance diagram for server_commandscript:
CommandScript ScriptObject

Public Member Functions

 server_commandscript ()
 
ChatCommandTable GetCommands () const override
 
virtual std::vector< Acore::ChatCommands::ChatCommandBuilderGetCommands () const =0
 
- Public Member Functions inherited from ScriptObject
virtual bool IsDatabaseBound () const
 
virtual bool isAfterLoadScript () const
 
virtual void checkValidity ()
 
const std::string & GetName () const
 

Static Public Member Functions

static bool HandleServerCorpsesCommand (ChatHandler *)
 
static bool HandleServerDebugCommand (ChatHandler *handler)
 
static bool HandleServerInfoCommand (ChatHandler *handler)
 
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, std::string realmId, Tail motd)
 
static bool HandleServerSetClosedCommand (ChatHandler *handler, Optional< std::string > args)
 
static bool HandleServerSetLogLevelCommand (ChatHandler *, bool isLogger, std::string const &name, int32 level)
 

Additional Inherited Members

- Protected Member Functions inherited from CommandScript
 CommandScript (const char *name)
 
- Protected Member Functions inherited from ScriptObject
 ScriptObject (const char *name)
 
virtual ~ScriptObject ()=default
 

Detailed Description

Constructor & Destructor Documentation

◆ server_commandscript()

server_commandscript::server_commandscript ( )
inline
51: CommandScript("server_commandscript") { }
Definition: CommandScript.h:25

Member Function Documentation

◆ GetCommands()

ChatCommandTable server_commandscript::GetCommands ( ) const
inlineoverridevirtual

Implements CommandScript.

54 {
55 static ChatCommandTable serverIdleRestartCommandTable =
56 {
57 { "cancel", HandleServerShutDownCancelCommand, SEC_ADMINISTRATOR, Console::Yes },
58 { "", HandleServerIdleRestartCommand, SEC_CONSOLE, Console::Yes }
59 };
60
61 static ChatCommandTable serverIdleShutdownCommandTable =
62 {
63 { "cancel", HandleServerShutDownCancelCommand, SEC_ADMINISTRATOR, Console::Yes },
64 { "", HandleServerIdleShutDownCommand, SEC_CONSOLE, Console::Yes }
65 };
66
67 static ChatCommandTable serverRestartCommandTable =
68 {
69 { "cancel", HandleServerShutDownCancelCommand, SEC_ADMINISTRATOR, Console::Yes },
71 };
72
73 static ChatCommandTable serverShutdownCommandTable =
74 {
75 { "cancel", HandleServerShutDownCancelCommand, SEC_ADMINISTRATOR, Console::Yes },
77 };
78
79 static ChatCommandTable serverSetCommandTable =
80 {
81 { "loglevel", HandleServerSetLogLevelCommand, SEC_CONSOLE, Console::Yes },
82 { "motd", HandleServerSetMotdCommand, SEC_ADMINISTRATOR, Console::Yes },
83 { "closed", HandleServerSetClosedCommand, SEC_CONSOLE, Console::Yes },
84 };
85
86 static ChatCommandTable serverCommandTable =
87 {
88 { "corpses", HandleServerCorpsesCommand, SEC_GAMEMASTER, Console::Yes },
89 { "debug", HandleServerDebugCommand, SEC_ADMINISTRATOR, Console::Yes },
90 { "exit", HandleServerExitCommand, SEC_CONSOLE, Console::Yes },
91 { "idlerestart", serverIdleRestartCommandTable },
92 { "idleshutdown", serverIdleShutdownCommandTable },
93 { "info", HandleServerInfoCommand, SEC_PLAYER, Console::Yes },
94 { "motd", HandleServerMotdCommand, SEC_PLAYER, Console::Yes },
95 { "restart", serverRestartCommandTable },
96 { "shutdown", serverShutdownCommandTable },
97 { "set", serverSetCommandTable }
98 };
99
100 static ChatCommandTable commandTable =
101 {
102 { "server", serverCommandTable }
103 };
104
105 return commandTable;
106 }
@ SEC_PLAYER
Definition: Common.h:59
@ SEC_ADMINISTRATOR
Definition: Common.h:62
@ SEC_GAMEMASTER
Definition: Common.h:61
@ SEC_CONSOLE
Definition: Common.h:63
std::vector< ChatCommandBuilder > ChatCommandTable
Definition: ChatCommand.h:49
static bool HandleServerCorpsesCommand(ChatHandler *)
Definition: cs_server.cpp:109
static bool HandleServerSetLogLevelCommand(ChatHandler *, bool isLogger, std::string const &name, int32 level)
Definition: cs_server.cpp:577
static bool HandleServerSetClosedCommand(ChatHandler *handler, Optional< std::string > args)
Definition: cs_server.cpp:557
static bool HandleServerSetMotdCommand(ChatHandler *handler, std::string realmId, Tail motd)
Definition: cs_server.cpp:519
static bool HandleServerRestartCommand(ChatHandler *handler, std::string time, Optional< int32 > exitCode, Tail reason)
Definition: cs_server.cpp:351
static bool HandleServerShutDownCommand(ChatHandler *handler, std::string time, Optional< int32 > exitCode, Tail reason)
Definition: cs_server.cpp:298
static bool HandleServerInfoCommand(ChatHandler *handler)
Definition: cs_server.cpp:260
static bool HandleServerMotdCommand(ChatHandler *handler)
Definition: cs_server.cpp:285
static bool HandleServerIdleShutDownCommand(ChatHandler *handler, std::string time, Optional< int32 > exitCode, Tail reason)
Definition: cs_server.cpp:457
static bool HandleServerExitCommand(ChatHandler *handler)
Definition: cs_server.cpp:511
static bool HandleServerDebugCommand(ChatHandler *handler)
Definition: cs_server.cpp:115
static bool HandleServerIdleRestartCommand(ChatHandler *handler, std::string time, Optional< int32 > exitCode, Tail reason)
Definition: cs_server.cpp:404
static bool HandleServerShutDownCancelCommand(ChatHandler *)
Definition: cs_server.cpp:291

References HandleServerCorpsesCommand(), HandleServerDebugCommand(), HandleServerExitCommand(), HandleServerIdleRestartCommand(), HandleServerIdleShutDownCommand(), HandleServerInfoCommand(), HandleServerMotdCommand(), HandleServerRestartCommand(), HandleServerSetClosedCommand(), HandleServerSetLogLevelCommand(), HandleServerSetMotdCommand(), HandleServerShutDownCancelCommand(), HandleServerShutDownCommand(), SEC_ADMINISTRATOR, SEC_CONSOLE, SEC_GAMEMASTER, and SEC_PLAYER.

◆ HandleServerCorpsesCommand()

static bool server_commandscript::HandleServerCorpsesCommand ( ChatHandler )
inlinestatic
110 {
111 sWorld->RemoveOldCorpses();
112 return true;
113 }
#define sWorld
Definition: World.h:447

References sWorld.

Referenced by GetCommands().

◆ HandleServerDebugCommand()

static bool server_commandscript::HandleServerDebugCommand ( ChatHandler handler)
inlinestatic
116 {
117 uint16 worldPort = uint16(sWorld->getIntConfig(CONFIG_PORT_WORLD));
118 std::string dbPortOutput;
119
120 {
121 uint16 dbPort = 0;
122 if (QueryResult res = LoginDatabase.Query("SELECT port FROM realmlist WHERE id = {}", realm.Id.Realm))
123 dbPort = (*res)[0].Get<uint16>();
124
125 if (dbPort)
126 dbPortOutput = Acore::StringFormatFmt("Realmlist (Realm Id: {}) configured in port {}", realm.Id.Realm, dbPort);
127 else
128 dbPortOutput = Acore::StringFormat("Realm Id: %u not found in `realmlist` table. Please check your setup", realm.Id.Realm);
129 }
130
132
133 handler->PSendSysMessage("Using SSL version: %s (library: %s)", OPENSSL_VERSION_TEXT, OpenSSL_version(OPENSSL_VERSION));
134 handler->PSendSysMessage("Using Boost version: %i.%i.%i", BOOST_VERSION / 100000, BOOST_VERSION / 100 % 1000, BOOST_VERSION % 100);
135 handler->PSendSysMessage("Using CMake version: %s", GitRevision::GetCMakeVersion());
136
137 handler->PSendSysMessage("Using MySQL version: %u", MySQL::GetLibraryVersion());
138 handler->PSendSysMessage("Found MySQL Executable: %s", GitRevision::GetMySQLExecutable());
139
140 handler->PSendSysMessage("Compiled on: %s", GitRevision::GetHostOSVersion());
141
142 handler->PSendSysMessage("Worldserver listening connections on port %" PRIu16, worldPort);
143 handler->PSendSysMessage("%s", dbPortOutput.c_str());
144
145 bool vmapIndoorCheck = sWorld->getBoolConfig(CONFIG_VMAP_INDOOR_CHECK);
148
149 bool mmapEnabled = sWorld->getBoolConfig(CONFIG_ENABLE_MMAPS);
150
151 std::string dataDir = sWorld->GetDataPath();
152 std::vector<std::string> subDirs;
153 subDirs.emplace_back("maps");
154 if (vmapIndoorCheck || vmapLOSCheck || vmapHeightCheck)
155 {
156 handler->PSendSysMessage("VMAPs status: Enabled. LineOfSight: %i, getHeight: %i, indoorCheck: %i", vmapLOSCheck, vmapHeightCheck, vmapIndoorCheck);
157 subDirs.emplace_back("vmaps");
158 }
159 else
160 handler->SendSysMessage("VMAPs status: Disabled");
161
162 if (mmapEnabled)
163 {
164 handler->SendSysMessage("MMAPs status: Enabled");
165 subDirs.emplace_back("mmaps");
166 }
167 else
168 handler->SendSysMessage("MMAPs status: Disabled");
169
170 for (std::string const& subDir : subDirs)
171 {
172 std::filesystem::path mapPath(dataDir);
173 mapPath /= subDir;
174
175 if (!std::filesystem::exists(mapPath))
176 {
177 handler->PSendSysMessage("%s directory doesn't exist!. Using path: %s", subDir.c_str(), mapPath.generic_string().c_str());
178 continue;
179 }
180
181 auto end = std::filesystem::directory_iterator();
182 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)
183 {
184 if (std::filesystem::is_regular_file(mapFile))
185 val += std::filesystem::file_size(mapFile);
186 return val;
187 });
188
189 handler->PSendSysMessage(Acore::StringFormatFmt("{} directory located in {}. Total size: {} bytes", subDir.c_str(), mapPath.generic_string().c_str(), folderSize).c_str());
190 }
191
192 LocaleConstant defaultLocale = sWorld->GetDefaultDbcLocale();
193 uint32 availableLocalesMask = (1 << defaultLocale);
194
195 for (uint8 i = 0; i < TOTAL_LOCALES; ++i)
196 {
197 LocaleConstant locale = static_cast<LocaleConstant>(i);
198 if (locale == defaultLocale)
199 continue;
200
201 if (sWorld->GetAvailableDbcLocale(locale) != defaultLocale)
202 availableLocalesMask |= (1 << locale);
203 }
204
205 std::string availableLocales;
206 for (uint8 i = 0; i < TOTAL_LOCALES; ++i)
207 {
208 if (!(availableLocalesMask & (1 << i)))
209 continue;
210
211 availableLocales += localeNames[i];
212 if (i != TOTAL_LOCALES - 1)
213 availableLocales += " ";
214 }
215
216 handler->PSendSysMessage("Default DBC locale: %s.\nAll available DBC locales: %s", localeNames[defaultLocale], availableLocales.c_str());
217
218 handler->PSendSysMessage("Using World DB: %s", sWorld->GetDBVersion());
219
220 std::string lldb = "No updates found!";
221 if (QueryResult resL = LoginDatabase.Query("SELECT name FROM updates ORDER BY name DESC LIMIT 1"))
222 {
223 Field* fields = resL->Fetch();
224 lldb = fields[0].Get<std::string>();
225 }
226 std::string lcdb = "No updates found!";
227 if (QueryResult resC = CharacterDatabase.Query("SELECT name FROM updates ORDER BY name DESC LIMIT 1"))
228 {
229 Field* fields = resC->Fetch();
230 lcdb = fields[0].Get<std::string>();
231 }
232 std::string lwdb = "No updates found!";
233 if (QueryResult resW = WorldDatabase.Query("SELECT name FROM updates ORDER BY name DESC LIMIT 1"))
234 {
235 Field* fields = resW->Fetch();
236 lwdb = fields[0].Get<std::string>();
237 }
238
239 handler->PSendSysMessage("Latest LoginDatabase update: %s", lldb.c_str());
240 handler->PSendSysMessage("Latest CharacterDatabase update: %s", lcdb.c_str());
241 handler->PSendSysMessage("Latest WorldDatabase update: %s", lwdb.c_str());
242
243 handler->PSendSysMessage("LoginDatabase queue size: %zu", LoginDatabase.QueueSize());
244 handler->PSendSysMessage("CharacterDatabase queue size: %zu", CharacterDatabase.QueueSize());
245 handler->PSendSysMessage("WorldDatabase queue size: %zu", WorldDatabase.QueueSize());
246
248 handler->SendSysMessage("No modules enabled");
249 else
250 handler->SendSysMessage("> List enable modules:");
251
252 for (auto const& modName : Acore::Module::GetEnableModulesList())
253 {
254 handler->SendSysMessage(Acore::StringFormatFmt("- {}", modName));
255 }
256
257 return true;
258 }
char const * localeNames[TOTAL_LOCALES]
Definition: Common.cpp:20
LocaleConstant
Definition: Common.h:67
@ TOTAL_LOCALES
Definition: Common.h:78
std::uint8_t uint8
Definition: Define.h:110
std::uint32_t uint32
Definition: Define.h:108
std::uint16_t uint16
Definition: Define.h:109
DatabaseWorkerPool< LoginDatabaseConnection > LoginDatabase
Accessor to the realm/login database.
Definition: DatabaseEnv.cpp:22
DatabaseWorkerPool< CharacterDatabaseConnection > CharacterDatabase
Accessor to the character database.
Definition: DatabaseEnv.cpp:21
DatabaseWorkerPool< WorldDatabaseConnection > WorldDatabase
Accessor to the world database.
Definition: DatabaseEnv.cpp:20
std::shared_ptr< ResultSet > QueryResult
Definition: DatabaseEnvFwd.h:28
@ CONFIG_PORT_WORLD
Definition: IWorld.h:215
@ CONFIG_ENABLE_MMAPS
Definition: IWorld.h:146
@ CONFIG_VMAP_INDOOR_CHECK
Definition: IWorld.h:128
Realm realm
Definition: World.cpp:112
std::string StringFormatFmt(FormatString< Args... > fmt, Args &&... args)
Definition: StringFormat.h:48
std::string StringFormat(Format &&fmt, Args &&... args)
Default AC string format function.
Definition: StringFormat.h:30
AC_COMMON_API char const * GetMySQLExecutable()
Definition: GitRevision.cpp:61
AC_COMMON_API char const * GetCMakeVersion()
Definition: GitRevision.cpp:41
AC_COMMON_API char const * GetHostOSVersion()
Definition: GitRevision.cpp:46
AC_DATABASE_API uint32 GetLibraryVersion()
Definition: MySQLThreading.cpp:31
AC_COMMON_API std::vector< std::string_view > GetEnableModulesList()
Definition: ModuleMgr.cpp:31
bool isHeightCalcEnabled() const
Definition: IVMapMgr.h:119
bool isLineOfSightCalcEnabled() const
Definition: IVMapMgr.h:118
static VMapMgr2 * createOrGetVMapMgr()
Definition: VMapFactory.cpp:27
Class used to access individual fields of database query result.
Definition: Field.h:99
std::enable_if_t< std::is_arithmetic_v< T >, T > Get() const
Definition: Field.h:113
void PSendSysMessage(char const *fmt, Args &&... args)
Definition: Chat.h:60
virtual void SendSysMessage(std::string_view str, bool escapeCharacters=false)
Definition: Chat.cpp:101
uint32 Realm
Definition: Realm.h:42
RealmHandle Id
Definition: Realm.h:68

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(), Acore::StringFormat(), Acore::StringFormatFmt(), sWorld, TOTAL_LOCALES, and WorldDatabase.

Referenced by GetCommands().

◆ HandleServerExitCommand()

static bool server_commandscript::HandleServerExitCommand ( ChatHandler handler)
inlinestatic
512 {
515 return true;
516 }
@ LANG_COMMAND_EXIT
Definition: Language.h:837
@ SHUTDOWN_EXIT_CODE
Definition: World.h:54
static void StopNow(uint8 exitcode)
Definition: World.h:259

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
405 {
406 std::wstring wReason = std::wstring();
407 std::string strReason = std::string();
408
409 if (time.empty())
410 {
411 return false;
412 }
413
414 if (Acore::StringTo<int32>(time).value_or(0) < 0)
415 {
417 return false;
418 }
419
420 if (!reason.empty())
421 {
422 if (!Utf8toWStr(reason, wReason))
423 {
424 return false;
425 }
426
427 if (!WStrToUtf8(wReason, strReason))
428 {
429 return false;
430 }
431 }
432
433 int32 delay = TimeStringToSecs(time);
434 if (delay <= 0)
435 {
436 delay = Acore::StringTo<int32>(time).value_or(0);
437 }
438
439 if (delay <= 0)
440 {
442 return false;
443 }
444
445 if (exitCode && *exitCode >= 0 && *exitCode <= 125)
446 {
447 sWorld->ShutdownServ(delay, SHUTDOWN_MASK_RESTART | SHUTDOWN_MASK_IDLE, *exitCode);
448 }
449 else
450 {
451 sWorld->ShutdownServ(delay, SHUTDOWN_MASK_RESTART | SHUTDOWN_MASK_IDLE, RESTART_EXIT_CODE, strReason);
452 }
453
454 return true;
455 }
std::int32_t int32
Definition: Define.h:104
bool WStrToUtf8(wchar_t const *wstr, size_t size, std::string &utf8str)
Definition: Util.cpp:333
uint32 TimeStringToSecs(const std::string &timestring)
Definition: Util.cpp:163
bool Utf8toWStr(char const *utf8str, size_t csize, wchar_t *wstr, size_t &wsize)
Definition: Util.cpp:281
@ LANG_BAD_VALUE
Definition: Language.h:147
@ RESTART_EXIT_CODE
Definition: World.h:56
@ SHUTDOWN_MASK_RESTART
Definition: World.h:48
@ SHUTDOWN_MASK_IDLE
Definition: World.h:49
void SendErrorMessage(uint32 entry)
Definition: Chat.cpp:152

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
458 {
459 std::wstring wReason = std::wstring();
460 std::string strReason = std::string();
461
462 if (time.empty())
463 {
464 return false;
465 }
466
467 if (Acore::StringTo<int32>(time).value_or(0) < 0)
468 {
470 return false;
471 }
472
473 if (!reason.empty())
474 {
475 if (!Utf8toWStr(reason, wReason))
476 {
477 return false;
478 }
479
480 if (!WStrToUtf8(wReason, strReason))
481 {
482 return false;
483 }
484 }
485
486 int32 delay = TimeStringToSecs(time);
487 if (delay <= 0)
488 {
489 delay = Acore::StringTo<int32>(time).value_or(0);
490 }
491
492 if (delay <= 0)
493 {
495 return false;
496 }
497
498 if (exitCode && *exitCode >= 0 && *exitCode <= 125)
499 {
500 sWorld->ShutdownServ(delay, SHUTDOWN_MASK_IDLE, *exitCode);
501 }
502 else
503 {
504 sWorld->ShutdownServ(delay, SHUTDOWN_MASK_IDLE, SHUTDOWN_EXIT_CODE, strReason);
505 }
506
507 return true;
508 }

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

261 {
262 std::string realmName = sWorld->GetRealmName();
263 uint32 playerCount = sWorld->GetPlayerCount();
264 uint32 activeSessionCount = sWorld->GetActiveSessionCount();
265 uint32 queuedSessionCount = sWorld->GetQueuedSessionCount();
266 uint32 connPeak = sWorld->GetMaxActiveSessionCount();
267
269 if (!queuedSessionCount)
270 handler->PSendSysMessage("Connected players: %u. Characters in world: %u.", activeSessionCount, playerCount);
271 else
272 handler->PSendSysMessage("Connected players: %u. Characters in world: %u. Queue: %u.", activeSessionCount, playerCount, queuedSessionCount);
273
274 handler->PSendSysMessage("Connection peak: %u.", connPeak);
276 handler->PSendSysMessage("Update time diff: %ums, average: %ums.", sWorldUpdateTime.GetLastUpdateTime(), sWorldUpdateTime.GetAverageUpdateTime());
277
279 if (sWorld->IsShuttingDown())
280 handler->PSendSysMessage(LANG_SHUTDOWN_TIMELEFT, secsToTimeString(sWorld->GetShutDownTimeLeft()).append(".").c_str());
281
282 return true;
283 }
std::string secsToTimeString(uint64 timeInSecs, bool shortText)
Definition: Util.cpp:73
@ LANG_UPTIME
Definition: Language.h:45
@ LANG_SHUTDOWN_TIMELEFT
Definition: Language.h:52
WorldUpdateTime sWorldUpdateTime
Definition: UpdateTime.cpp:24
AC_COMMON_API char const * GetFullVersion()
Definition: GitRevision.cpp:82
Seconds GetUptime()
Uptime.
Definition: GameTime.cpp:58
uint32 GetAverageUpdateTime() const
Definition: UpdateTime.cpp:38
uint32 GetLastUpdateTime() const
Definition: UpdateTime.cpp:69

References UpdateTime::GetAverageUpdateTime(), GitRevision::GetFullVersion(), UpdateTime::GetLastUpdateTime(), GameTime::GetUptime(), LANG_SHUTDOWN_TIMELEFT, LANG_UPTIME, ChatHandler::PSendSysMessage(), secsToTimeString(), sWorld, and sWorldUpdateTime.

Referenced by GetCommands(), and HandleServerDebugCommand().

◆ HandleServerMotdCommand()

static bool server_commandscript::HandleServerMotdCommand ( ChatHandler handler)
inlinestatic
286 {
287 handler->PSendSysMessage(LANG_MOTD_CURRENT, sMotdMgr->GetMotd());
288 return true;
289 }
@ LANG_MOTD_CURRENT
Definition: Language.h:88
#define sMotdMgr
Definition: MotdMgr.h:44

References LANG_MOTD_CURRENT, ChatHandler::PSendSysMessage(), and sMotdMgr.

Referenced by GetCommands().

◆ HandleServerRestartCommand()

static bool server_commandscript::HandleServerRestartCommand ( ChatHandler handler,
std::string  time,
Optional< int32 exitCode,
Tail  reason 
)
inlinestatic
352 {
353 std::wstring wReason = std::wstring();
354 std::string strReason = std::string();
355
356 if (time.empty())
357 {
358 return false;
359 }
360
361 if (Acore::StringTo<int32>(time).value_or(0) < 0)
362 {
364 return false;
365 }
366
367 if (!reason.empty())
368 {
369 if (!Utf8toWStr(reason, wReason))
370 {
371 return false;
372 }
373
374 if (!WStrToUtf8(wReason, strReason))
375 {
376 return false;
377 }
378 }
379
380 int32 delay = TimeStringToSecs(time);
381 if (delay <= 0)
382 {
383 delay = Acore::StringTo<int32>(time).value_or(0);
384 }
385
386 if (delay <= 0)
387 {
389 return false;
390 }
391
392 if (exitCode && *exitCode >= 0 && *exitCode <= 125)
393 {
394 sWorld->ShutdownServ(delay, SHUTDOWN_MASK_RESTART, *exitCode);
395 }
396 else
397 {
398 sWorld->ShutdownServ(delay, SHUTDOWN_MASK_RESTART, RESTART_EXIT_CODE, strReason);
399 }
400
401 return true;
402 }

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
558 {
559 if (StringStartsWith("on", *args))
560 {
562 sWorld->SetClosed(true);
563 return true;
564 }
565 else if (StringStartsWith("off", *args))
566 {
568 sWorld->SetClosed(false);
569 return true;
570 }
571
573 return false;
574 }
bool StringStartsWith(std::string_view haystack, std::string_view needle)
Definition: Util.h:401
@ LANG_USE_BOL
Definition: Language.h:303
@ LANG_WORLD_CLOSED
Definition: Language.h:1185
@ LANG_WORLD_OPENED
Definition: Language.h:1186

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
578 {
579 sLog->SetLogLevel(name, level, isLogger);
580 return true;
581 }
#define sLog
Definition: Log.h:126

References sLog.

Referenced by GetCommands().

◆ HandleServerSetMotdCommand()

static bool server_commandscript::HandleServerSetMotdCommand ( ChatHandler handler,
std::string  realmId,
Tail  motd 
)
inlinestatic
520 {
521 std::wstring wMotd = std::wstring();
522 std::string strMotd = std::string();
523
524 if (realmId.empty())
525 {
526 return false;
527 }
528
529 if (motd.empty())
530 {
531 return false;
532 }
533
534 if (!Utf8toWStr(motd, wMotd))
535 {
536 return false;
537 }
538
539 if (!WStrToUtf8(wMotd, strMotd))
540 {
541 return false;
542 }
543
544 LoginDatabaseTransaction trans = LoginDatabase.BeginTransaction();
545 LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_REP_MOTD);
546 stmt->SetData(0, Acore::StringTo<int32>(realmId).value());
547 stmt->SetData(1, strMotd);
548 trans->Append(stmt);
549 LoginDatabase.CommitTransaction(trans);
550
551 sMotdMgr->LoadMotd();
552 handler->PSendSysMessage(LANG_MOTD_NEW, Acore::StringTo<int32>(realmId).value(), strMotd);
553 return true;
554 }
SQLTransaction< LoginDatabaseConnection > LoginDatabaseTransaction
Definition: DatabaseEnvFwd.h:71
@ LOGIN_REP_MOTD
Definition: LoginDatabase.h:100
@ LANG_MOTD_NEW
Definition: Language.h:872
Definition: PreparedStatement.h:158
Acore::Types::is_default< T > SetData(const uint8 index, T value)
Definition: PreparedStatement.h:78

References LANG_MOTD_NEW, LOGIN_REP_MOTD, LoginDatabase, ChatHandler::PSendSysMessage(), PreparedStatementBase::SetData(), sMotdMgr, Utf8toWStr(), and WStrToUtf8().

Referenced by GetCommands().

◆ HandleServerShutDownCancelCommand()

static bool server_commandscript::HandleServerShutDownCancelCommand ( ChatHandler )
inlinestatic
292 {
293 sWorld->ShutdownCancel();
294
295 return true;
296 }

References sWorld.

Referenced by GetCommands().

◆ HandleServerShutDownCommand()

static bool server_commandscript::HandleServerShutDownCommand ( ChatHandler handler,
std::string  time,
Optional< int32 exitCode,
Tail  reason 
)
inlinestatic
299 {
300 std::wstring wReason = std::wstring();
301 std::string strReason = std::string();
302
303 if (time.empty())
304 {
305 return false;
306 }
307
308 if (Acore::StringTo<int32>(time).value_or(0) < 0)
309 {
311 return false;
312 }
313
314 if (!reason.empty())
315 {
316 if (!Utf8toWStr(reason, wReason))
317 {
318 return false;
319 }
320
321 if (!WStrToUtf8(wReason, strReason))
322 {
323 return false;
324 }
325 }
326
327 int32 delay = TimeStringToSecs(time);
328 if (delay <= 0)
329 {
330 delay = Acore::StringTo<int32>(time).value_or(0);
331 }
332
333 if (delay <= 0)
334 {
336 return false;
337 }
338
339 if (exitCode && *exitCode >= 0 && *exitCode <= 125)
340 {
341 sWorld->ShutdownServ(delay, 0, *exitCode);
342 }
343 else
344 {
345 sWorld->ShutdownServ(delay, 0, SHUTDOWN_EXIT_CODE, strReason);
346 }
347
348 return true;
349 }

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

Referenced by GetCommands().