account_commandscript Class Reference

Inheritance diagram for account_commandscript:

Public Member Functions
	account_commandscript ()
ChatCommandTable	GetCommands () const override
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	HandleAccount2FASetupCommand (ChatHandler *handler, char const *args)
static bool	HandleAccount2FARemoveCommand (ChatHandler *handler, char const *args)
static bool	HandleAccountAddonCommand (ChatHandler *handler, char const *args)
static bool	HandleAccountCreateCommand (ChatHandler *handler, char const *args)
	Create an account.
static bool	HandleAccountDeleteCommand (ChatHandler *handler, char const *args)
static bool	HandleAccountOnlineListCommand (ChatHandler *handler, char const *)
	Display info on users currently in the realm.
static bool	HandleAccountRemoveLockCountryCommand (ChatHandler *handler, char const *args)
static bool	HandleAccountLockCountryCommand (ChatHandler *handler, char const *args)
static bool	HandleAccountLockIpCommand (ChatHandler *handler, char const *args)
static bool	HandleAccountPasswordCommand (ChatHandler *handler, char const *args)
static bool	HandleAccountSet2FACommand (ChatHandler *handler, char const *args)
static bool	HandleAccountCommand (ChatHandler *handler, char const *)
static bool	HandleAccountSetAddonCommand (ChatHandler *handler, char const *args)
	Set/Unset the expansion level for an account.
static bool	HandleAccountSetGmLevelCommand (ChatHandler *handler, char const *args)
static bool	HandleAccountSetPasswordCommand (ChatHandler *handler, char const *args)
	Set password for account.
static bool	HandleAccountSetEmailCommand (ChatHandler *handler, AccountIdentifier account, std::string email, std::string emailConfirmation)
	Set email for account.

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

account_commandscript()

account_commandscript::account_commandscript ( )

inline

: CommandScript("account_commandscript") { }

Member Function Documentation

GetCommands()

ChatCommandTable account_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

    {
        static ChatCommandTable accountSetCommandTable =
        {
            { "addon",      HandleAccountSetAddonCommand,     SEC_GAMEMASTER, Console::Yes },
            { "gmlevel",    HandleAccountSetGmLevelCommand,   SEC_ADMINISTRATOR, Console::Yes },
            { "password",   HandleAccountSetPasswordCommand,  SEC_ADMINISTRATOR, Console::Yes },
            { "2fa",        HandleAccountSet2FACommand,       SEC_PLAYER,    Console::Yes  },
            { "email",      HandleAccountSetEmailCommand,     SEC_ADMINISTRATOR, Console::Yes }
        };
 
        static ChatCommandTable accountLockCommandTable
        {
            { "country",    HandleAccountLockCountryCommand,  SEC_PLAYER,    Console::Yes  },
            { "ip",         HandleAccountLockIpCommand,       SEC_PLAYER,    Console::Yes  }
        };
 
        static ChatCommandTable account2faCommandTable
        {
            { "setup",      HandleAccount2FASetupCommand,   SEC_PLAYER,    Console::No  },
            { "remove",     HandleAccount2FARemoveCommand,  SEC_PLAYER,    Console::No  }
        };
 
        static ChatCommandTable accountRemoveCommandTable
        {
            { "country",    HandleAccountRemoveLockCountryCommand,  SEC_ADMINISTRATOR, Console::Yes },
        };
 
        static ChatCommandTable accountCommandTable =
        {
            { "2fa",        account2faCommandTable                                       },
            { "addon",      HandleAccountAddonCommand,       SEC_MODERATOR, Console::No  },
            { "create",     HandleAccountCreateCommand,      SEC_CONSOLE,   Console::Yes },
            { "delete",     HandleAccountDeleteCommand,      SEC_CONSOLE,   Console::Yes },
            { "onlinelist", HandleAccountOnlineListCommand,  SEC_CONSOLE,   Console::Yes },
            { "lock",       accountLockCommandTable                                      },
            { "set",        accountSetCommandTable                                       },
            { "password",   HandleAccountPasswordCommand,    SEC_PLAYER,    Console::No  },
            { "remove",     accountRemoveCommandTable                                    },
            { "",           HandleAccountCommand,            SEC_PLAYER,    Console::No  }
        };
 
        static ChatCommandTable commandTable =
        {
            { "account", accountCommandTable }
        };
 
        return commandTable;
    }

References HandleAccount2FARemoveCommand(), HandleAccount2FASetupCommand(), HandleAccountAddonCommand(), HandleAccountCommand(), HandleAccountCreateCommand(), HandleAccountDeleteCommand(), HandleAccountLockCountryCommand(), HandleAccountLockIpCommand(), HandleAccountOnlineListCommand(), HandleAccountPasswordCommand(), HandleAccountRemoveLockCountryCommand(), HandleAccountSet2FACommand(), HandleAccountSetAddonCommand(), HandleAccountSetEmailCommand(), HandleAccountSetGmLevelCommand(), HandleAccountSetPasswordCommand(), SEC_ADMINISTRATOR, SEC_CONSOLE, SEC_GAMEMASTER, SEC_MODERATOR, and SEC_PLAYER.

HandleAccount2FARemoveCommand()

static bool account_commandscript::HandleAccount2FARemoveCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        if (!*args)
        {
            handler->SendErrorMessage(LANG_CMD_SYNTAX);
            return false;
        }
 
        auto token = Acore::StringTo<uint32>(args);
 
        auto const& masterKey = sSecretMgr->GetSecret(SECRET_TOTP_MASTER_KEY);
        if (!masterKey.IsAvailable())
        {
            handler->SendErrorMessage(LANG_2FA_COMMANDS_NOT_SETUP);
            return false;
        }
 
        uint32 const accountId = handler->GetSession()->GetAccountId();
        Acore::Crypto::TOTP::Secret secret;
        { // get current TOTP secret
            auto* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_TOTP_SECRET);
            stmt->SetData(0, accountId);
            PreparedQueryResult result = LoginDatabase.Query(stmt);
 
            if (!result)
            {
                LOG_ERROR("misc", "Account {} not found in login database when processing .account 2fa setup command.", accountId);
                handler->SendErrorMessage(LANG_UNKNOWN_ERROR);
                return false;
            }
 
            Field* field = result->Fetch();
            if (field->IsNull())
            { // 2FA not enabled
                handler->SendErrorMessage(LANG_2FA_NOT_SETUP);
                return false;
            }
 
            secret = field->Get<Binary>();
        }
 
        if (token)
        {
            if (masterKey)
            {
                bool success = Acore::Crypto::AEDecrypt<Acore::Crypto::AES>(secret, *masterKey);
                if (!success)
                {
                    LOG_ERROR("misc", "Account {} has invalid ciphertext in TOTP token.", accountId);
                    handler->SendErrorMessage(LANG_UNKNOWN_ERROR);
                    return false;
                }
            }
 
            if (Acore::Crypto::TOTP::ValidateToken(secret, *token))
            {
                auto* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_ACCOUNT_TOTP_SECRET);
                stmt->SetData(0);
                stmt->SetData(1, accountId);
                LoginDatabase.Execute(stmt);
                handler->SendSysMessage(LANG_2FA_REMOVE_COMPLETE);
                return true;
            }
            else
                handler->SendSysMessage(LANG_2FA_INVALID_TOKEN);
        }
 
        handler->SendErrorMessage(LANG_2FA_REMOVE_NEED_TOKEN);
        return false;
    }

References Field::Get(), WorldSession::GetAccountId(), ChatHandler::GetSession(), Field::IsNull(), LANG_2FA_COMMANDS_NOT_SETUP, LANG_2FA_INVALID_TOKEN, LANG_2FA_NOT_SETUP, LANG_2FA_REMOVE_COMPLETE, LANG_2FA_REMOVE_NEED_TOKEN, LANG_CMD_SYNTAX, LANG_UNKNOWN_ERROR, LOG_ERROR, LOGIN_SEL_ACCOUNT_TOTP_SECRET, LOGIN_UPD_ACCOUNT_TOTP_SECRET, LoginDatabase, SECRET_TOTP_MASTER_KEY, ChatHandler::SendErrorMessage(), ChatHandler::SendSysMessage(), sSecretMgr, and Acore::Crypto::TOTP::ValidateToken().

Referenced by GetCommands().

HandleAccount2FASetupCommand()

static bool account_commandscript::HandleAccount2FASetupCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        if (!*args)
        {
            handler->SendErrorMessage(LANG_CMD_SYNTAX);
            return false;
        }
 
        auto token = Acore::StringTo<uint32>(args);
 
        auto const& masterKey = sSecretMgr->GetSecret(SECRET_TOTP_MASTER_KEY);
        if (!masterKey.IsAvailable())
        {
            handler->SendErrorMessage(LANG_2FA_COMMANDS_NOT_SETUP);
            return false;
        }
 
        uint32 const accountId = handler->GetSession()->GetAccountId();
 
        { // check if 2FA already enabled
            auto* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_TOTP_SECRET);
            stmt->SetData(0, accountId);
            PreparedQueryResult result = LoginDatabase.Query(stmt);
 
            if (!result)
            {
                LOG_ERROR("misc", "Account {} not found in login database when processing .account 2fa setup command.", accountId);
                handler->SendErrorMessage(LANG_UNKNOWN_ERROR);
                return false;
            }
 
            if (!result->Fetch()->IsNull())
            {
                handler->SendErrorMessage(LANG_2FA_ALREADY_SETUP);
                return false;
            }
        }
 
        // store random suggested secrets
        static std::unordered_map<uint32, Acore::Crypto::TOTP::Secret> suggestions;
        auto pair = suggestions.emplace(std::piecewise_construct, std::make_tuple(accountId), std::make_tuple(Acore::Crypto::TOTP::RECOMMENDED_SECRET_LENGTH)); // std::vector 1-argument std::size_t constructor invokes resize
 
        if (pair.second) // no suggestion yet, generate random secret
            Acore::Crypto::GetRandomBytes(pair.first->second);
 
        if (!pair.second && token) // suggestion already existed and token specified - validate
        {
            if (Acore::Crypto::TOTP::ValidateToken(pair.first->second, *token))
            {
                if (masterKey)
                    Acore::Crypto::AEEncryptWithRandomIV<Acore::Crypto::AES>(pair.first->second, *masterKey);
 
                auto* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_ACCOUNT_TOTP_SECRET);
                stmt->SetData(0, pair.first->second);
                stmt->SetData(1, accountId);
                LoginDatabase.Execute(stmt);
 
                suggestions.erase(pair.first);
                handler->SendSysMessage(LANG_2FA_SETUP_COMPLETE);
                return true;
            }
            else
                handler->SendSysMessage(LANG_2FA_INVALID_TOKEN);
        }
 
        // new suggestion, or no token specified, output TOTP parameters
        handler->SendErrorMessage(LANG_2FA_SECRET_SUGGESTION, Acore::Encoding::Base32::Encode(pair.first->second).c_str());
        return false;
    }

References Acore::Encoding::Base32::Encode(), WorldSession::GetAccountId(), Acore::Crypto::GetRandomBytes(), ChatHandler::GetSession(), LANG_2FA_ALREADY_SETUP, LANG_2FA_COMMANDS_NOT_SETUP, LANG_2FA_INVALID_TOKEN, LANG_2FA_SECRET_SUGGESTION, LANG_2FA_SETUP_COMPLETE, LANG_CMD_SYNTAX, LANG_UNKNOWN_ERROR, LOG_ERROR, LOGIN_SEL_ACCOUNT_TOTP_SECRET, LOGIN_UPD_ACCOUNT_TOTP_SECRET, LoginDatabase, Acore::Crypto::TOTP::RECOMMENDED_SECRET_LENGTH, SECRET_TOTP_MASTER_KEY, ChatHandler::SendErrorMessage(), ChatHandler::SendSysMessage(), sSecretMgr, and Acore::Crypto::TOTP::ValidateToken().

Referenced by GetCommands().

HandleAccountAddonCommand()

static bool account_commandscript::HandleAccountAddonCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        if (!*args)
        {
            handler->SendErrorMessage(LANG_CMD_SYNTAX);
            return false;
        }
 
        char* exp = strtok((char*)args, " ");
 
        uint32 accountId = handler->GetSession()->GetAccountId();
 
        auto expansion = Acore::StringTo<uint8>(exp); //get int anyway (0 if error)
        if (!expansion || *expansion > sWorld->getIntConfig(CONFIG_EXPANSION))
        {
            handler->SendErrorMessage(LANG_IMPROPER_VALUE);
            return false;
        }
 
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_EXPANSION);
 
        stmt->SetData(0, *expansion);
        stmt->SetData(1, accountId);
 
        LoginDatabase.Execute(stmt);
 
        handler->PSendSysMessage(LANG_ACCOUNT_ADDON, *expansion);
        return true;
    }

References CONFIG_EXPANSION, WorldSession::GetAccountId(), ChatHandler::GetSession(), LANG_ACCOUNT_ADDON, LANG_CMD_SYNTAX, LANG_IMPROPER_VALUE, LOGIN_UPD_EXPANSION, LoginDatabase, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), PreparedStatementBase::SetData(), and sWorld.

Referenced by GetCommands().

HandleAccountCommand()

static bool account_commandscript::HandleAccountCommand ( ChatHandler *  handler, char const *    )

inlinestatic

    {
        AccountTypes gmLevel = handler->GetSession()->GetSecurity();
        handler->PSendSysMessage(LANG_ACCOUNT_LEVEL, uint32(gmLevel));
        return true;
    }

References WorldSession::GetSecurity(), ChatHandler::GetSession(), LANG_ACCOUNT_LEVEL, and ChatHandler::PSendSysMessage().

Referenced by GetCommands().

HandleAccountCreateCommand()

static bool account_commandscript::HandleAccountCreateCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

Create an account.

• Parse the command line arguments

    {
        if (!*args)
            return false;
 
        char* accountName = strtok((char*)args, " ");
        char* password = strtok(nullptr, " ");
        if (!accountName || !password)
            return false;
 
        AccountOpResult result = AccountMgr::CreateAccount(std::string(accountName), std::string(password));
        switch (result)
        {
            case AOR_OK:
                handler->PSendSysMessage(LANG_ACCOUNT_CREATED, accountName);
                if (handler->GetSession())
                {
                    LOG_DEBUG("warden", "Account: {} (IP: {}) Character:[{}] ({}) Change Password.",
                                   handler->GetSession()->GetAccountId(), handler->GetSession()->GetRemoteAddress(),
                                   handler->GetSession()->GetPlayer()->GetName(), handler->GetSession()->GetPlayer()->GetGUID().ToString());
                }
                break;
            case AOR_NAME_TOO_LONG:
                handler->SendErrorMessage(LANG_ACCOUNT_TOO_LONG);
                return false;
            case AOR_PASS_TOO_LONG:
                handler->SendErrorMessage(LANG_ACCOUNT_PASS_TOO_LONG);
                return false;
            case AOR_NAME_ALREADY_EXIST:
                handler->SendErrorMessage(LANG_ACCOUNT_ALREADY_EXIST);
                return false;
            case AOR_DB_INTERNAL_ERROR:
                handler->SendErrorMessage(LANG_ACCOUNT_NOT_CREATED_SQL_ERROR, accountName);
                return false;
            default:
                handler->SendErrorMessage(LANG_ACCOUNT_NOT_CREATED, accountName);
                return false;
        }
 
        return true;
    }

References AOR_DB_INTERNAL_ERROR, AOR_NAME_ALREADY_EXIST, AOR_NAME_TOO_LONG, AOR_OK, AOR_PASS_TOO_LONG, AccountMgr::CreateAccount(), WorldSession::GetAccountId(), Object::GetGUID(), WorldObject::GetName(), WorldSession::GetPlayer(), WorldSession::GetRemoteAddress(), ChatHandler::GetSession(), LANG_ACCOUNT_ALREADY_EXIST, LANG_ACCOUNT_CREATED, LANG_ACCOUNT_NOT_CREATED, LANG_ACCOUNT_NOT_CREATED_SQL_ERROR, LANG_ACCOUNT_PASS_TOO_LONG, LANG_ACCOUNT_TOO_LONG, LOG_DEBUG, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), and ObjectGuid::ToString().

Referenced by GetCommands().

HandleAccountDeleteCommand()

static bool account_commandscript::HandleAccountDeleteCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

Delete a user account and all associated characters in this realm

Todo:

This function has to be enhanced to respect the login/realm split (delete char, delete account chars in realm then delete account)

• Get the account name from the command line

Commands not recommended call from chat, but support anyway can delete only for account with less security This is also reject self apply in fact

    {
        if (!*args)
            return false;
 
        char* account = strtok((char*)args, " ");
        if (!account)
            return false;
 
        std::string accountName = account;
        if (!Utf8ToUpperOnlyLatin(accountName))
        {
            handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName.c_str());
            return false;
        }
 
        uint32 accountId = AccountMgr::GetId(accountName);
        if (!accountId)
        {
            handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName.c_str());
            return false;
        }
 
        if (handler->HasLowerSecurityAccount(nullptr, accountId, true))
            return false;
 
        AccountOpResult result = AccountMgr::DeleteAccount(accountId);
        switch (result)
        {
            case AOR_OK:
                handler->PSendSysMessage(LANG_ACCOUNT_DELETED, accountName);
                break;
            case AOR_NAME_NOT_EXIST:
                handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName.c_str());
                return false;
            case AOR_DB_INTERNAL_ERROR:
                handler->SendErrorMessage(LANG_ACCOUNT_NOT_DELETED_SQL_ERROR, accountName.c_str());
                return false;
            default:
                handler->SendErrorMessage(LANG_ACCOUNT_NOT_DELETED, accountName.c_str());
                return false;
        }
 
        return true;
    }

References AOR_DB_INTERNAL_ERROR, AOR_NAME_NOT_EXIST, AOR_OK, AccountMgr::DeleteAccount(), AccountMgr::GetId(), ChatHandler::HasLowerSecurityAccount(), LANG_ACCOUNT_DELETED, LANG_ACCOUNT_NOT_DELETED, LANG_ACCOUNT_NOT_DELETED_SQL_ERROR, LANG_ACCOUNT_NOT_EXIST, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), and Utf8ToUpperOnlyLatin().

Referenced by GetCommands().

HandleAccountLockCountryCommand()

static bool account_commandscript::HandleAccountLockCountryCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        if (!*args)
        {
            handler->SendErrorMessage(LANG_USE_BOL);
            return false;
        }
 
        std::string param = (char*)args;
 
        if (!param.empty())
        {
            if (param == "on")
            {
                if (IpLocationRecord const* location = sIPLocation->GetLocationRecord(handler->GetSession()->GetRemoteAddress()))
                {
                    auto* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_ACCOUNT_LOCK_COUNTRY);
                    stmt->SetData(0, location->CountryCode);
                    stmt->SetData(1, handler->GetSession()->GetAccountId());
                    LoginDatabase.Execute(stmt);
                    handler->PSendSysMessage(LANG_COMMAND_ACCLOCKLOCKED);
                }
                else
                {
                    handler->SendErrorMessage("No IP2Location information - account not locked");
                    return false;
                }
            }
            else if (param == "off")
            {
                auto* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_ACCOUNT_LOCK_COUNTRY);
                stmt->SetData(0, "00");
                stmt->SetData(1, handler->GetSession()->GetAccountId());
                LoginDatabase.Execute(stmt);
                handler->PSendSysMessage(LANG_COMMAND_ACCLOCKUNLOCKED);
            }
            return true;
        }
 
        handler->SendErrorMessage(LANG_USE_BOL);
        return false;
    }

References WorldSession::GetAccountId(), WorldSession::GetRemoteAddress(), ChatHandler::GetSession(), LANG_COMMAND_ACCLOCKLOCKED, LANG_COMMAND_ACCLOCKUNLOCKED, LANG_USE_BOL, LOGIN_UPD_ACCOUNT_LOCK_COUNTRY, LoginDatabase, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), and sIPLocation.

Referenced by GetCommands().

HandleAccountLockIpCommand()

static bool account_commandscript::HandleAccountLockIpCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        if (!*args)
        {
            handler->SendErrorMessage(LANG_USE_BOL);
            return false;
        }
 
        std::string param = (char*)args;
 
        if (!param.empty())
        {
            LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_ACCOUNT_LOCK);
 
            if (param == "on")
            {
                stmt->SetData(0, true);                                     // locked
                handler->PSendSysMessage(LANG_COMMAND_ACCLOCKLOCKED);
            }
            else if (param == "off")
            {
                stmt->SetData(0, false);                                    // unlocked
                handler->PSendSysMessage(LANG_COMMAND_ACCLOCKUNLOCKED);
            }
 
            stmt->SetData(1, handler->GetSession()->GetAccountId());
 
            LoginDatabase.Execute(stmt);
            return true;
        }
 
        handler->SendErrorMessage(LANG_USE_BOL);
        return false;
    }

References WorldSession::GetAccountId(), ChatHandler::GetSession(), LANG_COMMAND_ACCLOCKLOCKED, LANG_COMMAND_ACCLOCKUNLOCKED, LANG_USE_BOL, LOGIN_UPD_ACCOUNT_LOCK, LoginDatabase, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), and PreparedStatementBase::SetData().

Referenced by GetCommands().

HandleAccountOnlineListCommand()

static bool account_commandscript::HandleAccountOnlineListCommand ( ChatHandler *  handler, char const *    )

inlinestatic

Display info on users currently in the realm.

• Get the list of accounts ID logged to the realm

• Display the list of account/characters online

• Cycle through accounts

• Get the username, last IP and GM level of each account

    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_ONLINE);
 
        PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
        if (!result)
        {
            handler->SendSysMessage(LANG_ACCOUNT_LIST_EMPTY);
            return true;
        }
 
        handler->SendSysMessage(LANG_ACCOUNT_LIST_BAR_HEADER);
        handler->SendSysMessage(LANG_ACCOUNT_LIST_HEADER);
        handler->SendSysMessage(LANG_ACCOUNT_LIST_BAR);
 
        do
        {
            Field* fieldsDB = result->Fetch();
            std::string name = fieldsDB[0].Get<std::string>();
            uint32 account = fieldsDB[1].Get<uint32>();
 
            // No SQL injection. account is uint32.
            LoginDatabasePreparedStatement* loginStmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_INFO);
            loginStmt->SetData(0, account);
            PreparedQueryResult resultLogin = LoginDatabase.Query(loginStmt);
 
            if (resultLogin)
            {
                Field* fieldsLogin = resultLogin->Fetch();
                handler->PSendSysMessage(LANG_ACCOUNT_LIST_LINE,
                                         fieldsLogin[0].Get<std::string>(), name, fieldsLogin[1].Get<std::string>(),
                                         fieldsDB[2].Get<uint16>(), fieldsDB[3].Get<uint16>(), fieldsLogin[3].Get<uint8>(),
                                         fieldsLogin[2].Get<uint8>());
            }
            else
                handler->PSendSysMessage(LANG_ACCOUNT_LIST_ERROR, name);
        } while (result->NextRow());
 
        handler->SendSysMessage(LANG_ACCOUNT_LIST_BAR);
        return true;
    }

References CHAR_SEL_CHARACTER_ONLINE, CharacterDatabase, Field::Get(), LANG_ACCOUNT_LIST_BAR, LANG_ACCOUNT_LIST_BAR_HEADER, LANG_ACCOUNT_LIST_EMPTY, LANG_ACCOUNT_LIST_ERROR, LANG_ACCOUNT_LIST_HEADER, LANG_ACCOUNT_LIST_LINE, LOGIN_SEL_ACCOUNT_INFO, LoginDatabase, ChatHandler::PSendSysMessage(), ChatHandler::SendSysMessage(), and PreparedStatementBase::SetData().

Referenced by GetCommands().

HandleAccountPasswordCommand()

static bool account_commandscript::HandleAccountPasswordCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        if (!*args)
        {
            handler->SendErrorMessage(LANG_CMD_SYNTAX);
            return false;
        }
 
        char* oldPassword = strtok((char*)args, " ");
        char* newPassword = strtok(nullptr, " ");
        char* passwordConfirmation = strtok(nullptr, " ");
 
        if (!oldPassword || !newPassword || !passwordConfirmation)
        {
            handler->SendErrorMessage(LANG_CMD_SYNTAX);
            return false;
        }
 
        if (!AccountMgr::CheckPassword(handler->GetSession()->GetAccountId(), std::string(oldPassword)))
        {
            handler->SendErrorMessage(LANG_COMMAND_WRONGOLDPASSWORD);
            sScriptMgr->OnFailedPasswordChange(handler->GetSession()->GetAccountId());
            return false;
        }
 
        if (strcmp(newPassword, passwordConfirmation) != 0)
        {
            handler->SendErrorMessage(LANG_NEW_PASSWORDS_NOT_MATCH);
            sScriptMgr->OnFailedPasswordChange(handler->GetSession()->GetAccountId());
            return false;
        }
 
        AccountOpResult result = AccountMgr::ChangePassword(handler->GetSession()->GetAccountId(), std::string(newPassword));
        switch (result)
        {
            case AOR_OK:
                handler->SendSysMessage(LANG_COMMAND_PASSWORD);
                sScriptMgr->OnPasswordChange(handler->GetSession()->GetAccountId());
                break;
            case AOR_PASS_TOO_LONG:
                handler->SendErrorMessage(LANG_PASSWORD_TOO_LONG);
                sScriptMgr->OnFailedPasswordChange(handler->GetSession()->GetAccountId());
                return false;
            default:
                handler->SendErrorMessage(LANG_COMMAND_NOTCHANGEPASSWORD);
                return false;
        }
 
        return true;
    }

References AOR_OK, AOR_PASS_TOO_LONG, AccountMgr::ChangePassword(), AccountMgr::CheckPassword(), WorldSession::GetAccountId(), ChatHandler::GetSession(), LANG_CMD_SYNTAX, LANG_COMMAND_NOTCHANGEPASSWORD, LANG_COMMAND_PASSWORD, LANG_COMMAND_WRONGOLDPASSWORD, LANG_NEW_PASSWORDS_NOT_MATCH, LANG_PASSWORD_TOO_LONG, ChatHandler::SendErrorMessage(), ChatHandler::SendSysMessage(), and sScriptMgr.

Referenced by GetCommands().

HandleAccountRemoveLockCountryCommand()

static bool account_commandscript::HandleAccountRemoveLockCountryCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

• Parse the command line arguments

    {
        if (!*args)
        {
            handler->SendErrorMessage(LANG_CMD_SYNTAX);
            return false;
        }
 
        char* _accountName = strtok((char*)args, " ");
        if (!_accountName)
            return false;
 
        std::string accountName = _accountName;
        if (!Utf8ToUpperOnlyLatin(accountName))
        {
            handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
            return false;
        }
 
        uint32 accountId = AccountMgr::GetId(accountName);
        if (!accountId)
        {
            handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
            return false;
        }
 
        auto* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_ACCOUNT_LOCK_COUNTRY);
        stmt->SetData(0, "00");
        stmt->SetData(1, accountId);
        LoginDatabase.Execute(stmt);
        handler->PSendSysMessage(LANG_COMMAND_ACCLOCKUNLOCKED);
 
        return true;
    }

References AccountMgr::GetId(), LANG_ACCOUNT_NOT_EXIST, LANG_CMD_SYNTAX, LANG_COMMAND_ACCLOCKUNLOCKED, LOGIN_UPD_ACCOUNT_LOCK_COUNTRY, LoginDatabase, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), and Utf8ToUpperOnlyLatin().

Referenced by GetCommands().

HandleAccountSet2FACommand()

static bool account_commandscript::HandleAccountSet2FACommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        if (!*args)
        {
            handler->SendErrorMessage(LANG_CMD_SYNTAX);
            return false;
        }
 
        char* _account = strtok((char*)args, " ");
        char* _secret = strtok(nullptr, " ");
 
        if (!_account || !_secret)
        {
            handler->SendErrorMessage(LANG_CMD_SYNTAX);
            return false;
        }
 
        std::string accountName = _account;
        std::string secret = _secret;
 
        if (!Utf8ToUpperOnlyLatin(accountName))
        {
            handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
            return false;
        }
 
        uint32 targetAccountId = AccountMgr::GetId(accountName);
        if (!targetAccountId)
        {
            handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
            return false;
        }
 
        if (handler->HasLowerSecurityAccount(nullptr, targetAccountId, true))
            return false;
 
        if (secret == "off")
        {
            auto* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_ACCOUNT_TOTP_SECRET);
            stmt->SetData(0);
            stmt->SetData(1, targetAccountId);
            LoginDatabase.Execute(stmt);
            handler->PSendSysMessage(LANG_2FA_REMOVE_COMPLETE);
            return true;
        }
 
        auto const& masterKey = sSecretMgr->GetSecret(SECRET_TOTP_MASTER_KEY);
        if (!masterKey.IsAvailable())
        {
            handler->SendErrorMessage(LANG_2FA_COMMANDS_NOT_SETUP);
            return false;
        }
 
        Optional<std::vector<uint8>> decoded = Acore::Encoding::Base32::Decode(secret);
        if (!decoded)
        {
            handler->SendErrorMessage(LANG_2FA_SECRET_INVALID);
            return false;
        }
 
        if (128 < (decoded->size() + Acore::Crypto::AES::IV_SIZE_BYTES + Acore::Crypto::AES::TAG_SIZE_BYTES))
        {
            handler->SendErrorMessage(LANG_2FA_SECRET_TOO_LONG);
            return false;
        }
 
        if (masterKey)
            Acore::Crypto::AEEncryptWithRandomIV<Acore::Crypto::AES>(*decoded, *masterKey);
 
        auto* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_ACCOUNT_TOTP_SECRET);
        stmt->SetData(0, *decoded);
        stmt->SetData(1, targetAccountId);
        LoginDatabase.Execute(stmt);
 
        handler->PSendSysMessage(LANG_2FA_SECRET_SET_COMPLETE, accountName);
        return true;
    }

References Acore::Encoding::Base32::Decode(), AccountMgr::GetId(), ChatHandler::HasLowerSecurityAccount(), Acore::Crypto::AES::IV_SIZE_BYTES, LANG_2FA_COMMANDS_NOT_SETUP, LANG_2FA_REMOVE_COMPLETE, LANG_2FA_SECRET_INVALID, LANG_2FA_SECRET_SET_COMPLETE, LANG_2FA_SECRET_TOO_LONG, LANG_ACCOUNT_NOT_EXIST, LANG_CMD_SYNTAX, LOGIN_UPD_ACCOUNT_TOTP_SECRET, LoginDatabase, ChatHandler::PSendSysMessage(), SECRET_TOTP_MASTER_KEY, ChatHandler::SendErrorMessage(), sSecretMgr, Acore::Crypto::AES::TAG_SIZE_BYTES, and Utf8ToUpperOnlyLatin().

Referenced by GetCommands().

HandleAccountSetAddonCommand()

static bool account_commandscript::HandleAccountSetAddonCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

Set/Unset the expansion level for an account.

• Get the command line arguments

• Convert Account name to Upper Format

    {
        char* account = strtok((char*)args, " ");
        char* exp = strtok(nullptr, " ");
 
        if (!account)
            return false;
 
        std::string accountName;
        uint32 accountId;
 
        if (!exp)
        {
            Player* player = handler->getSelectedPlayer();
            if (!player)
                return false;
 
            accountId = player->GetSession()->GetAccountId();
            AccountMgr::GetName(accountId, accountName);
            exp = account;
        }
        else
        {
            accountName = account;
            if (!Utf8ToUpperOnlyLatin(accountName))
            {
                handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
                return false;
            }
 
            accountId = AccountMgr::GetId(accountName);
            if (!accountId)
            {
                handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
                return false;
            }
        }
 
        // Let set addon state only for lesser (strong) security level
        // or to self account
        if (handler->GetSession() && handler->GetSession()->GetAccountId() != accountId &&
                handler->HasLowerSecurityAccount(nullptr, accountId, true))
            return false;
 
        auto expansion = Acore::StringTo<uint8>(exp); //get int anyway (0 if error)
        if (!expansion || *expansion > sWorld->getIntConfig(CONFIG_EXPANSION))
            return false;
 
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_EXPANSION);
 
        stmt->SetData(0, *expansion);
        stmt->SetData(1, accountId);
 
        LoginDatabase.Execute(stmt);
 
        handler->PSendSysMessage(LANG_ACCOUNT_SETADDON, accountName, accountId, *expansion);
        return true;
    }

References CONFIG_EXPANSION, WorldSession::GetAccountId(), AccountMgr::GetId(), AccountMgr::GetName(), ChatHandler::getSelectedPlayer(), ChatHandler::GetSession(), Player::GetSession(), ChatHandler::HasLowerSecurityAccount(), LANG_ACCOUNT_NOT_EXIST, LANG_ACCOUNT_SETADDON, LOGIN_UPD_EXPANSION, LoginDatabase, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), PreparedStatementBase::SetData(), sWorld, and Utf8ToUpperOnlyLatin().

Referenced by GetCommands().

HandleAccountSetEmailCommand()

static bool account_commandscript::HandleAccountSetEmailCommand ( ChatHandler *  handler, AccountIdentifier  account, std::string  email, std::string  emailConfirmation  )

inlinestatic

Set email for account.

    {
        if (!account || !email.data() || !emailConfirmation.data())
            return false;
 
        std::string accountName = account.GetName();
        if (!Utf8ToUpperOnlyLatin(accountName))
        {
            handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
            return false;
        }
 
        uint32 targetAccountId = account.GetID();
        if (!targetAccountId)
        {
            handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
            return false;
        }
 
        if (email != emailConfirmation)
        {
            handler->SendErrorMessage(LANG_NEW_EMAILS_NOT_MATCH);
            return false;
        }
 
        AccountOpResult result = AccountMgr::ChangeEmail(targetAccountId, email.data());
 
        switch (result)
        {
            case AOR_OK:
                handler->SendSysMessage(LANG_COMMAND_EMAIL);
                break;
            case AOR_NAME_NOT_EXIST:
                handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
                return false;
            case AOR_EMAIL_TOO_LONG:
                handler->SendErrorMessage(LANG_EMAIL_TOO_LONG);
                return false;
            default:
                handler->SendErrorMessage(LANG_COMMAND_NOTCHANGEEMAIL);
                return false;
        }
        return true;
    }

References AOR_EMAIL_TOO_LONG, AOR_NAME_NOT_EXIST, AOR_OK, AccountMgr::ChangeEmail(), Acore::ChatCommands::AccountIdentifier::GetID(), Acore::ChatCommands::AccountIdentifier::GetName(), LANG_ACCOUNT_NOT_EXIST, LANG_COMMAND_EMAIL, LANG_COMMAND_NOTCHANGEEMAIL, LANG_EMAIL_TOO_LONG, LANG_NEW_EMAILS_NOT_MATCH, ChatHandler::SendErrorMessage(), ChatHandler::SendSysMessage(), and Utf8ToUpperOnlyLatin().

Referenced by GetCommands().

HandleAccountSetGmLevelCommand()

static bool account_commandscript::HandleAccountSetGmLevelCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

    {
        if (!*args)
            return false;
 
        std::string targetAccountName;
        uint32 targetAccountId = 0;
        uint32 targetSecurity = 0;
        uint32 gm = 0;
        char* arg1 = strtok((char*)args, " ");
        char* arg2 = strtok(nullptr, " ");
        char* arg3 = strtok(nullptr, " ");
        bool isAccountNameGiven = true;
 
        if (arg1 && !arg3)
        {
            if (!handler->getSelectedPlayer())
                return false;
            isAccountNameGiven = false;
        }
 
        // Check for second parameter
        if (!isAccountNameGiven && !arg2)
            return false;
 
        // Check for account
        if (isAccountNameGiven)
        {
            targetAccountName = arg1;
            if (!Utf8ToUpperOnlyLatin(targetAccountName))
            {
                handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, targetAccountName);
                return false;
            }
        }
 
        // Check for invalid specified GM level.
        gm = (isAccountNameGiven) ? Acore::StringTo<int32>(arg2).value_or(0) : Acore::StringTo<int32>(arg1).value_or(0);
        if (gm > SEC_CONSOLE)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        // handler->getSession() == nullptr only for console
        targetAccountId = (isAccountNameGiven) ? AccountMgr::GetId(targetAccountName) : handler->getSelectedPlayer()->GetSession()->GetAccountId();
        int32 gmRealmID = (isAccountNameGiven) ? Acore::StringTo<int32>(arg3).value_or(0) : Acore::StringTo<int32>(arg2).value_or(0);
        uint32 playerSecurity;
        if (handler->GetSession())
            playerSecurity = AccountMgr::GetSecurity(handler->GetSession()->GetAccountId(), gmRealmID);
        else
            playerSecurity = SEC_CONSOLE;
 
        // can set security level only for target with less security and to less security that we have
        // This is also reject self apply in fact
        targetSecurity = AccountMgr::GetSecurity(targetAccountId, gmRealmID);
        if (targetSecurity >= playerSecurity || gm >= playerSecurity)
        {
            handler->SendErrorMessage(LANG_YOURS_SECURITY_IS_LOW);
            return false;
        }
 
        // Check and abort if the target gm has a higher rank on one of the realms and the new realm is -1
        if (gmRealmID == -1 && !AccountMgr::IsConsoleAccount(playerSecurity))
        {
            LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_ACCESS_GMLEVEL_TEST);
 
            stmt->SetData(0, targetAccountId);
            stmt->SetData(1, uint8(gm));
 
            PreparedQueryResult result = LoginDatabase.Query(stmt);
 
            if (result)
            {
                handler->SendErrorMessage(LANG_YOURS_SECURITY_IS_LOW);
                return false;
            }
        }
 
        // Check if provided realm.Id.Realm has a negative value other than -1
        if (gmRealmID < -1)
        {
            handler->SendErrorMessage(LANG_INVALID_REALMID);
            return false;
        }
 
        // If gmRealmID is -1, delete all values for the account id, else, insert values for the specific realm.Id.Realm
        LoginDatabasePreparedStatement* stmt;
 
        if (gmRealmID == -1)
        {
            stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_ACCOUNT_ACCESS);
            stmt->SetData(0, targetAccountId);
        }
        else
        {
            stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_ACCOUNT_ACCESS_BY_REALM);
            stmt->SetData(0, targetAccountId);
            stmt->SetData(1, realm.Id.Realm);
        }
 
        LoginDatabase.Execute(stmt);
 
        if (gm != 0)
        {
            stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_ACCOUNT_ACCESS);
 
            stmt->SetData(0, targetAccountId);
            stmt->SetData(1, uint8(gm));
            stmt->SetData(2, gmRealmID);
 
            LoginDatabase.Execute(stmt);
        }
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_SECURITY, targetAccountName, gm);
        return true;
    }

References WorldSession::GetAccountId(), AccountMgr::GetId(), AccountMgr::GetSecurity(), ChatHandler::getSelectedPlayer(), ChatHandler::GetSession(), Player::GetSession(), Realm::Id, AccountMgr::IsConsoleAccount(), LANG_ACCOUNT_NOT_EXIST, LANG_BAD_VALUE, LANG_INVALID_REALMID, LANG_YOU_CHANGE_SECURITY, LANG_YOURS_SECURITY_IS_LOW, LOGIN_DEL_ACCOUNT_ACCESS, LOGIN_DEL_ACCOUNT_ACCESS_BY_REALM, LOGIN_INS_ACCOUNT_ACCESS, LOGIN_SEL_ACCOUNT_ACCESS_GMLEVEL_TEST, LoginDatabase, ChatHandler::PSendSysMessage(), realm, RealmHandle::Realm, SEC_CONSOLE, ChatHandler::SendErrorMessage(), PreparedStatementBase::SetData(), and Utf8ToUpperOnlyLatin().

Referenced by GetCommands().

HandleAccountSetPasswordCommand()

static bool account_commandscript::HandleAccountSetPasswordCommand ( ChatHandler *  handler, char const *  args  )

inlinestatic

Set password for account.

• Get the command line arguments

can set password only for target with less security This is also reject self apply in fact

    {
        if (!*args)
            return false;
 
        char* account = strtok((char*)args, " ");
        char* password = strtok(nullptr, " ");
        char* passwordConfirmation = strtok(nullptr, " ");
 
        if (!account || !password || !passwordConfirmation)
            return false;
 
        std::string accountName = account;
        if (!Utf8ToUpperOnlyLatin(accountName))
        {
            handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
            return false;
        }
 
        uint32 targetAccountId = AccountMgr::GetId(accountName);
        if (!targetAccountId)
        {
            handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
            return false;
        }
 
        if (handler->HasLowerSecurityAccount(nullptr, targetAccountId, true))
            return false;
 
        if (strcmp(password, passwordConfirmation))
        {
            handler->SendErrorMessage(LANG_NEW_PASSWORDS_NOT_MATCH);
            return false;
        }
 
        AccountOpResult result = AccountMgr::ChangePassword(targetAccountId, password);
 
        switch (result)
        {
            case AOR_OK:
                handler->SendSysMessage(LANG_COMMAND_PASSWORD);
                break;
            case AOR_NAME_NOT_EXIST:
                handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
                return false;
            case AOR_PASS_TOO_LONG:
                handler->SendErrorMessage(LANG_PASSWORD_TOO_LONG);
                return false;
            default:
                handler->SendErrorMessage(LANG_COMMAND_NOTCHANGEPASSWORD);
                return false;
        }
        return true;
    }

References AOR_NAME_NOT_EXIST, AOR_OK, AOR_PASS_TOO_LONG, AccountMgr::ChangePassword(), AccountMgr::GetId(), ChatHandler::HasLowerSecurityAccount(), LANG_ACCOUNT_NOT_EXIST, LANG_COMMAND_NOTCHANGEPASSWORD, LANG_COMMAND_PASSWORD, LANG_NEW_PASSWORDS_NOT_MATCH, LANG_PASSWORD_TOO_LONG, ChatHandler::SendErrorMessage(), ChatHandler::SendSysMessage(), and Utf8ToUpperOnlyLatin().

Referenced by GetCommands().

---

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

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