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 ()
std::string const &	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	HandleAccountInfoCommand (ChatHandler *handler, Optional< AccountIdentifier > account)
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 Optional< uint8 >	ParseAccountFlagBit (std::string_view input)
static bool	HandleAccountFlagListCommand (ChatHandler *handler, Optional< AccountIdentifier > account)
static bool	ChangeAccountFlag (ChatHandler *handler, AccountIdentifier const &account, std::string_view flagArg, bool add)
static bool	HandleAccountFlagAddCommand (ChatHandler *handler, AccountIdentifier account, std::string_view flagArg)
static bool	HandleAccountFlagRemoveCommand (ChatHandler *handler, AccountIdentifier account, std::string_view flagArg)
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 (char const *name)
Protected Member Functions inherited from ScriptObject
	ScriptObject (char const *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

ChangeAccountFlag()

static bool account_commandscript::ChangeAccountFlag ( ChatHandler *  handler, AccountIdentifier const &  account, std::string_view  flagArg, bool  add  )

inlinestatic

    {
        if (handler->HasLowerSecurityAccount(nullptr, account.GetID(), true))
            return false;
 
        Optional<uint8> bit = ParseAccountFlagBit(flagArg);
        if (!bit)
        {
            handler->SendErrorMessage(LANG_ACCOUNT_FLAG_INVALID, flagArg);
            return false;
        }
 
        // ACCOUNT_FLAG_GM is handled by GMLevel and should not be allowed to set manually
        uint32 const flag = uint32(1) << *bit;
        if (flag & ACCOUNT_FLAG_GM)
        {
            handler->SendErrorMessage(LANG_ACCOUNT_FLAG_RESERVED);
            return false;
        }
 
        if (WorldSession* session = sWorldSessionMgr->FindSession(account.GetID()))
            session->UpdateAccountFlag(flag, !add);
        else
            LoginDatabase.Execute("UPDATE account SET Flags = Flags {} {} WHERE id = {}",
                add ? "|" : "& ~", flag, account.GetID());
 
        handler->PSendSysMessage(add ? LANG_ACCOUNT_FLAG_ADDED : LANG_ACCOUNT_FLAG_REMOVED,
            accountFlagNames[*bit].full, account.GetName(), account.GetID());
        return true;
    }

References ACCOUNT_FLAG_GM, accountFlagNames, AccountFlagName::full, Acore::ChatCommands::AccountIdentifier::GetID(), Acore::ChatCommands::AccountIdentifier::GetName(), ChatHandler::HasLowerSecurityAccount(), LANG_ACCOUNT_FLAG_ADDED, LANG_ACCOUNT_FLAG_INVALID, LANG_ACCOUNT_FLAG_REMOVED, LANG_ACCOUNT_FLAG_RESERVED, LoginDatabase, ParseAccountFlagBit(), ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), and sWorldSessionMgr.

Referenced by HandleAccountFlagAddCommand(), and HandleAccountFlagRemoveCommand().

GetCommands()

ChatCommandTable account_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

    {
        static ChatCommandTable accountSetCommandTable =
        {
            { "addon",      HandleAccountSetAddonCommand,     rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_ADDON, Console::Yes },
            { "gmlevel",    HandleAccountSetGmLevelCommand,   rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SECLEVEL, Console::Yes },
            { "password",   HandleAccountSetPasswordCommand,  rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_PASSWORD, Console::Yes },
            { "2fa",        HandleAccountSet2FACommand,       rbac::RBAC_PERM_COMMAND_ACCOUNT_SET, Console::Yes  },
            { "email",      HandleAccountSetEmailCommand,     rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SEC_EMAIL, Console::Yes }
        };
 
        static ChatCommandTable accountLockCommandTable
        {
            { "country",    HandleAccountLockCountryCommand,  rbac::RBAC_PERM_COMMAND_ACCOUNT_LOCK_COUNTRY, Console::Yes  },
            { "ip",         HandleAccountLockIpCommand,       rbac::RBAC_PERM_COMMAND_ACCOUNT_LOCK_IP, Console::Yes  }
        };
 
        static ChatCommandTable account2faCommandTable
        {
            { "setup",      HandleAccount2FASetupCommand,   rbac::RBAC_PERM_COMMAND_ACCOUNT, Console::No  },
            { "remove",     HandleAccount2FARemoveCommand,  rbac::RBAC_PERM_COMMAND_ACCOUNT, Console::No  }
        };
 
        static ChatCommandTable accountRemoveCommandTable
        {
            { "country",    HandleAccountRemoveLockCountryCommand,  rbac::RBAC_PERM_COMMAND_ACCOUNT_LOCK_COUNTRY, Console::Yes },
        };
 
        static ChatCommandTable accountFlagCommandTable
        {
            { "list",       HandleAccountFlagListCommand,    rbac::RBAC_PERM_COMMAND_ACCOUNT_FLAG_LIST,   Console::Yes },
            { "add",        HandleAccountFlagAddCommand,     rbac::RBAC_PERM_COMMAND_ACCOUNT_FLAG_ADD,    Console::Yes },
            { "remove",     HandleAccountFlagRemoveCommand,  rbac::RBAC_PERM_COMMAND_ACCOUNT_FLAG_REMOVE, Console::Yes }
        };
 
        static ChatCommandTable accountCommandTable =
        {
            { "2fa",        account2faCommandTable                                       },
            { "addon",      HandleAccountAddonCommand,       rbac::RBAC_PERM_COMMAND_ACCOUNT_ADDON, Console::No  },
            { "create",     HandleAccountCreateCommand,      rbac::RBAC_PERM_COMMAND_ACCOUNT_CREATE, Console::Yes },
            { "delete",     HandleAccountDeleteCommand,      rbac::RBAC_PERM_COMMAND_ACCOUNT_DELETE, Console::Yes },
            { "flag",       accountFlagCommandTable                                      },
            { "info",       HandleAccountInfoCommand,        rbac::RBAC_PERM_COMMAND_ACCOUNT_INFO, Console::Yes },
            { "onlinelist", HandleAccountOnlineListCommand,  rbac::RBAC_PERM_COMMAND_ACCOUNT_ONLINE_LIST, Console::Yes },
            { "lock",       accountLockCommandTable                                      },
            { "set",        accountSetCommandTable                                       },
            { "password",   HandleAccountPasswordCommand,    rbac::RBAC_PERM_COMMAND_ACCOUNT_PASSWORD, Console::No  },
            { "remove",     accountRemoveCommandTable                                    },
            { "",           HandleAccountCommand,            rbac::RBAC_PERM_COMMAND_ACCOUNT, Console::No  }
        };
 
        static ChatCommandTable commandTable =
        {
            { "account", accountCommandTable }
        };
 
        return commandTable;
    }

References HandleAccount2FARemoveCommand(), HandleAccount2FASetupCommand(), HandleAccountAddonCommand(), HandleAccountCommand(), HandleAccountCreateCommand(), HandleAccountDeleteCommand(), HandleAccountFlagAddCommand(), HandleAccountFlagListCommand(), HandleAccountFlagRemoveCommand(), HandleAccountInfoCommand(), HandleAccountLockCountryCommand(), HandleAccountLockIpCommand(), HandleAccountOnlineListCommand(), HandleAccountPasswordCommand(), HandleAccountRemoveLockCountryCommand(), HandleAccountSet2FACommand(), HandleAccountSetAddonCommand(), HandleAccountSetEmailCommand(), HandleAccountSetGmLevelCommand(), HandleAccountSetPasswordCommand(), rbac::RBAC_PERM_COMMAND_ACCOUNT, rbac::RBAC_PERM_COMMAND_ACCOUNT_ADDON, rbac::RBAC_PERM_COMMAND_ACCOUNT_CREATE, rbac::RBAC_PERM_COMMAND_ACCOUNT_DELETE, rbac::RBAC_PERM_COMMAND_ACCOUNT_FLAG_ADD, rbac::RBAC_PERM_COMMAND_ACCOUNT_FLAG_LIST, rbac::RBAC_PERM_COMMAND_ACCOUNT_FLAG_REMOVE, rbac::RBAC_PERM_COMMAND_ACCOUNT_INFO, rbac::RBAC_PERM_COMMAND_ACCOUNT_LOCK_COUNTRY, rbac::RBAC_PERM_COMMAND_ACCOUNT_LOCK_IP, rbac::RBAC_PERM_COMMAND_ACCOUNT_ONLINE_LIST, rbac::RBAC_PERM_COMMAND_ACCOUNT_PASSWORD, rbac::RBAC_PERM_COMMAND_ACCOUNT_SET, rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_ADDON, rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_PASSWORD, rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SEC_EMAIL, and rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SECLEVEL.

HandleAccount2FARemoveCommand()

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

inlinestatic

    {
        // no error message here: the framework then prints the command help, which names the token argument
        if (!*args)
            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_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

    {
        // no error message here: the framework then prints the command help, which explains how to get the key
        if (!*args)
            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_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));
 
        if (handler->GetSession()->HasPermission(rbac::RBAC_PERM_MAY_CHECK_OWN_EMAIL))
        {
            LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_GET_EMAIL_BY_ID);
            stmt->SetData(0, handler->GetSession()->GetAccountId());
            PreparedQueryResult result = LoginDatabase.Query(stmt);
            if (result)
                handler->PSendSysMessage(LANG_COMMAND_EMAIL_OUTPUT, (*result)[0].Get<std::string>());
        }
 
        return true;
    }

References WorldSession::GetAccountId(), WorldSession::GetSecurity(), ChatHandler::GetSession(), WorldSession::HasPermission(), LANG_ACCOUNT_LEVEL, LANG_COMMAND_EMAIL_OUTPUT, LOGIN_GET_EMAIL_BY_ID, LoginDatabase, ChatHandler::PSendSysMessage(), rbac::RBAC_PERM_MAY_CHECK_OWN_EMAIL, and PreparedStatementBase::SetData().

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, " ");
        char* email = strtok(nullptr, " ");
 
        if (!accountName || !password)
            return false;
 
        // if email is not specified, use empty string
        std::string emailStr = email ? email : "";
 
        AccountOpResult result = sAccountMgr->CreateAccount(std::string(accountName), std::string(password), emailStr);
        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, 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(), sAccountMgr, 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().

HandleAccountFlagAddCommand()

static bool account_commandscript::HandleAccountFlagAddCommand ( ChatHandler *  handler, AccountIdentifier  account, std::string_view  flagArg  )

inlinestatic

    {
        return ChangeAccountFlag(handler, account, flagArg, true);
    }

References ChangeAccountFlag().

Referenced by GetCommands().

HandleAccountFlagListCommand()

static bool account_commandscript::HandleAccountFlagListCommand ( ChatHandler *  handler, Optional< AccountIdentifier >  account  )

inlinestatic

    {
        uint32 accountId;
        std::string accountName;
 
        if (account)
        {
            accountId = account->GetID();
            accountName = account->GetName();
        }
        else if (WorldSession* session = handler->GetSession())
        {
            accountId = session->GetAccountId();
            AccountMgr::GetName(accountId, accountName);
        }
        else
        {
            handler->SendErrorMessage(LANG_CMD_SYNTAX);
            return false;
        }
 
        if (handler->HasLowerSecurityAccount(nullptr, accountId, true))
            return false;
 
        uint32 flags;
        if (WorldSession* targetSession = sWorldSessionMgr->FindSession(accountId))
            flags = targetSession->GetAccountFlags();
        else
        {
            LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_FLAG);
            stmt->SetData(0, accountId);
            PreparedQueryResult result = LoginDatabase.Query(stmt);
            if (!result)
            {
                handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
                return false;
            }
 
            flags = (*result)[0].Get<uint32>();
        }
 
        if (!flags)
        {
            handler->PSendSysMessage(LANG_ACCOUNT_FLAG_LIST_EMPTY, accountName, accountId);
            return true;
        }
 
        handler->PSendSysMessage(LANG_ACCOUNT_FLAG_LIST_HEADER, accountName, accountId);
        for (uint8 i = 0; i < MAX_ACCOUNT_FLAG; ++i)
            if (flags & (uint32(1) << i))
                handler->PSendSysMessage(LANG_SUBCMDS_LIST_ENTRY, accountFlagNames[i].full);
 
        return true;
    }

References accountFlagNames, AccountFlagName::full, AccountMgr::GetName(), ChatHandler::GetSession(), ChatHandler::HasLowerSecurityAccount(), LANG_ACCOUNT_FLAG_LIST_EMPTY, LANG_ACCOUNT_FLAG_LIST_HEADER, LANG_ACCOUNT_NOT_EXIST, LANG_CMD_SYNTAX, LANG_SUBCMDS_LIST_ENTRY, LOGIN_SEL_ACCOUNT_FLAG, LoginDatabase, MAX_ACCOUNT_FLAG, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), PreparedStatementBase::SetData(), and sWorldSessionMgr.

Referenced by GetCommands().

HandleAccountFlagRemoveCommand()

static bool account_commandscript::HandleAccountFlagRemoveCommand ( ChatHandler *  handler, AccountIdentifier  account, std::string_view  flagArg  )

inlinestatic

    {
        return ChangeAccountFlag(handler, account, flagArg, false);
    }

References ChangeAccountFlag().

Referenced by GetCommands().

HandleAccountInfoCommand()

static bool account_commandscript::HandleAccountInfoCommand ( ChatHandler *  handler, Optional< AccountIdentifier >  account  )

inlinestatic

    {
        uint32 accountId;
        std::string accountName;
 
        if (account)
        {
            accountId = account->GetID();
            accountName = account->GetName();
        }
        else if (Player* target = handler->getSelectedPlayerOrSelf())
        {
            accountId = target->GetSession()->GetAccountId();
            AccountMgr::GetName(accountId, accountName);
        }
        else
        {
            handler->SendErrorMessage(LANG_CMD_SYNTAX);
            return false;
        }
 
        // The strong check rejects equal security, so inspecting your own account has to be exempted
        if (handler->GetSession() && handler->GetSession()->GetAccountId() != accountId &&
            handler->HasLowerSecurityAccount(nullptr, accountId, true))
            return false;
 
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_INFO_DETAILED);
        stmt->SetData(0, int32(realm.Id.Realm));
        stmt->SetData(1, accountId);
 
        PreparedQueryResult result = LoginDatabase.Query(stmt);
        if (!result)
        {
            handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
            return false;
        }
 
        Field* fields              = result->Fetch();
        accountName                = fields[0].Get<std::string>();
        uint32 security            = fields[1].Get<uint8>();
        std::string eMail          = fields[2].Get<std::string>();
        std::string regMail        = fields[3].Get<std::string>();
        std::string lastIp         = fields[4].Get<std::string>();
        std::string lastLogin      = fields[5].Get<std::string>();
        int64 muteTime             = fields[6].Get<uint64>();
        std::string muteReason     = fields[7].Get<std::string>();
        std::string muteBy         = fields[8].Get<std::string>();
        uint32 failedLogins        = fields[9].Get<uint32>();
        uint8 locked               = fields[10].Get<uint8>();
        std::string OS             = fields[11].Get<std::string>();
        uint32 expansion           = fields[12].Get<uint8>();
        uint32 accountFlags        = fields[13].Get<uint32>();
        std::string joinDate       = fields[14].Get<std::string>();
        uint32 totalTime           = fields[15].Get<uint32>();
        std::string lockCountry    = fields[16].Get<std::string>();
 
        // Empty unless the account is online, in which case it holds the address of the live connection
        std::string currentIp;
        uint32 latency = 0;
 
        if (WorldSession* targetSession = sWorldSessionMgr->FindSession(accountId))
        {
            latency = targetSession->GetLatency();
            muteTime = targetSession->m_muteTime;
            accountFlags = targetSession->GetAccountFlags();
            currentIp = targetSession->GetRemoteAddress();
        }
 
        if (!handler->GetSession() || handler->GetSession()->GetSecurity() >= AccountTypes(security))
        {
            if (IpLocationRecord const* location = sIPLocation->GetLocationRecord(lastIp))
                lastIp.append(" (").append(location->CountryName).append(")");
 
            if (!currentIp.empty())
                if (IpLocationRecord const* location = sIPLocation->GetLocationRecord(currentIp))
                    currentIp.append(" (").append(location->CountryName).append(")");
        }
        else
        {
            eMail     = handler->GetAcoreString(LANG_UNAUTHORIZED);
            regMail   = handler->GetAcoreString(LANG_UNAUTHORIZED);
            lastIp    = handler->GetAcoreString(LANG_UNAUTHORIZED);
            lastLogin = handler->GetAcoreString(LANG_UNAUTHORIZED);
 
            if (!currentIp.empty())
                currentIp = handler->GetAcoreString(LANG_UNAUTHORIZED);
        }
 
        int64 banTime = -1;
        std::string banReason = handler->GetAcoreString(LANG_NO_REASON);
        std::string bannedBy = handler->GetAcoreString(LANG_UNKNOWN);
 
        LoginDatabasePreparedStatement* banStmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_PINFO_BANS);
        banStmt->SetData(0, accountId);
 
        if (PreparedQueryResult banResult = LoginDatabase.Query(banStmt))
        {
            Field* banFields = banResult->Fetch();
            banTime          = int64(banFields[1].Get<uint64>() ? 0 : banFields[0].Get<uint32>());
            bannedBy         = banFields[2].Get<std::string>();
            banReason        = banFields[3].Get<std::string>();
        }
 
        handler->PSendSysMessage(LANG_PINFO_ACC_ACCOUNT, accountName, accountId, security);
 
        if (accountFlags)
        {
            handler->PSendSysMessage(LANG_ACCOUNT_FLAGS_PINFO);
            for (uint8 i = 0; i < MAX_ACCOUNT_FLAG; ++i)
                if (accountFlags & (uint32(1) << i))
                    handler->PSendSysMessage(LANG_SUBCMDS_LIST_ENTRY, accountFlagNames[i].full);
        }
 
        if (banTime >= 0)
            handler->PSendSysMessage(LANG_ACCOUNT_INFO_BANNED, banReason,
                banTime > 0 ? secsToTimeString(banTime - GameTime::GetGameTime().count(), true) : handler->GetAcoreString(LANG_PERMANENTLY), bannedBy);
 
        // mutetime is only cleared once the muted player logs back in, so an expired mute can still be stored
        if (muteTime > GameTime::GetGameTime().count())
            handler->PSendSysMessage(LANG_PINFO_MUTED, muteReason, secsToTimeString(muteTime - GameTime::GetGameTime().count(), true), muteBy);
 
        handler->PSendSysMessage(LANG_ACCOUNT_INFO_JOINDATE, joinDate);
        handler->PSendSysMessage(LANG_PINFO_ACC_LASTLOGIN, lastLogin, failedLogins);
        handler->PSendSysMessage(LANG_PINFO_ACC_OS, OS, latency);
        handler->PSendSysMessage(LANG_PINFO_ACC_REGMAILS, regMail, eMail);
        handler->PSendSysMessage(LANG_PINFO_ACC_IP, lastIp, locked ? handler->GetAcoreString(LANG_YES) : handler->GetAcoreString(LANG_NO));
 
        if (!currentIp.empty())
            handler->PSendSysMessage(LANG_ACCOUNT_INFO_CURRENT_IP, currentIp);
 
        // "00" is the default value meaning no country lock is set
        if (lockCountry != "00")
            handler->PSendSysMessage(LANG_ACCOUNT_INFO_LOCK_COUNTRY, lockCountry);
 
        handler->PSendSysMessage(LANG_ACCOUNT_INFO_EXPANSION, expansion);
        handler->PSendSysMessage(LANG_PINFO_CHR_PLAYEDTIME, secsToTimeString(totalTime, true));
 
        CharacterDatabasePreparedStatement* charStmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_ACCOUNT_INFO_CHARS);
        charStmt->SetData(0, accountId);
 
        PreparedQueryResult charResult = CharacterDatabase.Query(charStmt);
        if (!charResult)
        {
            handler->PSendSysMessage(LANG_ACCOUNT_INFO_NO_CHARS);
            return true;
        }
 
        handler->PSendSysMessage(LANG_ACCOUNT_INFO_CHARS, uint32(charResult->GetRowCount()));
 
        LocaleConstant locale = handler->GetSessionDbcLocale();
 
        do
        {
            Field* charFields         = charResult->Fetch();
            ObjectGuid::LowType guid  = charFields[0].Get<uint32>();
            std::string name          = charFields[1].Get<std::string>();
            uint8 level               = charFields[2].Get<uint8>();
            uint8 raceId              = charFields[3].Get<uint8>();
            uint8 classId             = charFields[4].Get<uint8>();
            bool online               = charFields[5].Get<bool>();
 
            ChrRacesEntry const* race = sChrRacesStore.LookupEntry(raceId);
            ChrClassesEntry const* cls = sChrClassesStore.LookupEntry(classId);
 
            // Own marker rather than LANG_OFFLINE, whose leading space is missing in some locales
            handler->PSendSysMessage(LANG_ACCOUNT_INFO_CHAR_ENTRY, handler->playerLink(name),
                online ? "" : handler->GetAcoreString(LANG_ACCOUNT_INFO_CHAR_OFFLINE), guid, uint32(level),
                race ? race->name[locale] : handler->GetAcoreString(LANG_UNKNOWN),
                cls ? cls->name[locale] : handler->GetAcoreString(LANG_UNKNOWN));
        } while (charResult->NextRow());
 
        return true;
    }

References accountFlagNames, CHAR_SEL_ACCOUNT_INFO_CHARS, CharacterDatabase, Field::Get(), WorldSession::GetAccountId(), ChatHandler::GetAcoreString(), GameTime::GetGameTime(), AccountMgr::GetName(), WorldSession::GetSecurity(), ChatHandler::getSelectedPlayerOrSelf(), ChatHandler::GetSession(), ChatHandler::GetSessionDbcLocale(), ChatHandler::HasLowerSecurityAccount(), Realm::Id, LANG_ACCOUNT_FLAGS_PINFO, LANG_ACCOUNT_INFO_BANNED, LANG_ACCOUNT_INFO_CHAR_ENTRY, LANG_ACCOUNT_INFO_CHAR_OFFLINE, LANG_ACCOUNT_INFO_CHARS, LANG_ACCOUNT_INFO_CURRENT_IP, LANG_ACCOUNT_INFO_EXPANSION, LANG_ACCOUNT_INFO_JOINDATE, LANG_ACCOUNT_INFO_LOCK_COUNTRY, LANG_ACCOUNT_INFO_NO_CHARS, LANG_ACCOUNT_NOT_EXIST, LANG_CMD_SYNTAX, LANG_NO, LANG_NO_REASON, LANG_PERMANENTLY, LANG_PINFO_ACC_ACCOUNT, LANG_PINFO_ACC_IP, LANG_PINFO_ACC_LASTLOGIN, LANG_PINFO_ACC_OS, LANG_PINFO_ACC_REGMAILS, LANG_PINFO_CHR_PLAYEDTIME, LANG_PINFO_MUTED, LANG_SUBCMDS_LIST_ENTRY, LANG_UNAUTHORIZED, LANG_UNKNOWN, LANG_YES, LOGIN_SEL_ACCOUNT_INFO_DETAILED, LOGIN_SEL_PINFO_BANS, LoginDatabase, MAX_ACCOUNT_FLAG, ChrClassesEntry::name, ChatHandler::playerLink(), ChatHandler::PSendSysMessage(), realm, RealmHandle::Realm, sChrClassesStore, sChrRacesStore, secsToTimeString(), ChatHandler::SendErrorMessage(), PreparedStatementBase::SetData(), sIPLocation, and sWorldSessionMgr.

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 gmRealmID has a negative value other than -1
        if (gmRealmID < -1)
        {
            handler->SendErrorMessage(LANG_INVALID_REALMID);
            return false;
        }
 
        // If gmRealmID is -1, delete access on every realm, else on the requested one and any all-realms row
        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, gmRealmID);
        }
 
        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(), 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(), 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().

ParseAccountFlagBit()

static Optional< uint8 > account_commandscript::ParseAccountFlagBit ( std::string_view  input )

inlinestatic

    {
        for (uint8 i = 0; i < MAX_ACCOUNT_FLAG; ++i)
            if (StringEqualI(input, accountFlagNames[i].full) || StringEqualI(input, accountFlagNames[i].shortName))
                return i;
 
        return std::nullopt;
    }

References accountFlagNames, MAX_ACCOUNT_FLAG, and StringEqualI().

Referenced by ChangeAccountFlag().

---

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

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