AccountMgr Namespace Reference

Functions
AccountOpResult	CreateAccount (std::string username, std::string password, std::string email)
AccountOpResult	ChangeEmail (uint32 accountId, std::string newEmail)
AccountOpResult	DeleteAccount (uint32 accountId)
AccountOpResult	ChangeUsername (uint32 accountId, std::string newUsername, std::string newPassword)
AccountOpResult	ChangePassword (uint32 accountId, std::string newPassword)
uint32	GetId (std::string const &username)
uint32	GetSecurity (uint32 accountId)
uint32	GetSecurity (uint32 accountId, int32 realmId)
bool	GetName (uint32 accountId, std::string &name)
bool	CheckPassword (uint32 accountId, std::string password)
uint32	GetCharactersCount (uint32 accountId)
bool	IsPlayerAccount (uint32 gmlevel)
bool	IsGMAccount (uint32 gmlevel)
bool	IsAdminAccount (uint32 gmlevel)
bool	IsConsoleAccount (uint32 gmlevel)

Function Documentation

ChangeEmail()

AccountOpResult AccountMgr::ChangeEmail	(	uint32	accountId,
		std::string	newEmail
	)

    {
        std::string username;
 
        if (!GetName(accountId, username))
        {
            sScriptMgr->OnFailedEmailChange(accountId);
            return AOR_NAME_NOT_EXIST;                          // account doesn't exist
        }
 
        if (utf8length(newEmail) > MAX_EMAIL_STR)
        {
            sScriptMgr->OnFailedEmailChange(accountId);
            return AOR_EMAIL_TOO_LONG;                           // email's too long
        }
 
        Utf8ToUpperOnlyLatin(newEmail);
 
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_EMAIL);
        stmt->SetData(0, newEmail);
        stmt->SetData(1, accountId);
        LoginDatabase.Execute(stmt);
 
        sScriptMgr->OnEmailChange(accountId);
        return AOR_OK;
    }

References AOR_EMAIL_TOO_LONG, AOR_NAME_NOT_EXIST, AOR_OK, GetName(), LOGIN_UPD_EMAIL, LoginDatabase, MAX_EMAIL_STR, PreparedStatementBase::SetData(), sScriptMgr, utf8length(), and Utf8ToUpperOnlyLatin().

Referenced by account_commandscript::HandleAccountSetEmailCommand().

ChangePassword()

AccountOpResult AccountMgr::ChangePassword	(	uint32	accountId,
		std::string	newPassword
	)

    {
        std::string username;
 
        if (!GetName(accountId, username))
        {
            sScriptMgr->OnFailedPasswordChange(accountId);
            return AOR_NAME_NOT_EXIST;                          // account doesn't exist
        }
 
        if (utf8length(newPassword) > MAX_PASS_STR)
        {
            sScriptMgr->OnFailedEmailChange(accountId);
            return AOR_PASS_TOO_LONG;                           // password's too long
        }
 
        Utf8ToUpperOnlyLatin(username);
        Utf8ToUpperOnlyLatin(newPassword);
 
        auto [salt, verifier] = Acore::Crypto::SRP6::MakeRegistrationData(username, newPassword);
 
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_LOGON);
        stmt->SetData(0, salt);
        stmt->SetData(1, verifier);
        stmt->SetData(2, accountId);
        LoginDatabase.Execute(stmt);
 
        sScriptMgr->OnPasswordChange(accountId);
        return AOR_OK;
    }

References AOR_NAME_NOT_EXIST, AOR_OK, AOR_PASS_TOO_LONG, GetName(), LOGIN_UPD_LOGON, LoginDatabase, Acore::Crypto::SRP6::MakeRegistrationData(), MAX_PASS_STR, PreparedStatementBase::SetData(), sScriptMgr, utf8length(), and Utf8ToUpperOnlyLatin().

Referenced by account_commandscript::HandleAccountPasswordCommand(), and account_commandscript::HandleAccountSetPasswordCommand().

ChangeUsername()

AccountOpResult AccountMgr::ChangeUsername	(	uint32	accountId,
		std::string	newUsername,
		std::string	newPassword
	)

    {
        // Check if accounts exists
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_BY_ID);
        stmt->SetData(0, accountId);
        PreparedQueryResult result = LoginDatabase.Query(stmt);
 
        if (!result)
            return AOR_NAME_NOT_EXIST;
 
        if (utf8length(newUsername) > MAX_ACCOUNT_STR)
            return AOR_NAME_TOO_LONG;
 
        if (utf8length(newPassword) > MAX_PASS_STR)
            return AOR_PASS_TOO_LONG;                           // password's too long
 
        Utf8ToUpperOnlyLatin(newUsername);
        Utf8ToUpperOnlyLatin(newPassword);
 
        stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_USERNAME);
        stmt->SetData(0, newUsername);
        stmt->SetData(1, accountId);
        LoginDatabase.Execute(stmt);
 
        auto [salt, verifier] = Acore::Crypto::SRP6::MakeRegistrationData(newUsername, newPassword);
        stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_LOGON);
        stmt->SetData(0, salt);
        stmt->SetData(1, verifier);
        stmt->SetData(2, accountId);
        LoginDatabase.Execute(stmt);
 
        return AOR_OK;
    }

References AOR_NAME_NOT_EXIST, AOR_NAME_TOO_LONG, AOR_OK, AOR_PASS_TOO_LONG, LOGIN_SEL_ACCOUNT_BY_ID, LOGIN_UPD_LOGON, LOGIN_UPD_USERNAME, LoginDatabase, Acore::Crypto::SRP6::MakeRegistrationData(), MAX_ACCOUNT_STR, MAX_PASS_STR, PreparedStatementBase::SetData(), utf8length(), and Utf8ToUpperOnlyLatin().

CheckPassword()

bool AccountMgr::CheckPassword	(	uint32	accountId,
		std::string	password
	)

    {
        std::string username;
 
        if (!GetName(accountId, username))
            return false;
 
        Utf8ToUpperOnlyLatin(username);
        Utf8ToUpperOnlyLatin(password);
 
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_CHECK_PASSWORD);
        stmt->SetData(0, accountId);
        if (PreparedQueryResult result = LoginDatabase.Query(stmt))
        {
            Acore::Crypto::SRP6::Salt salt = (*result)[0].Get<Binary, Acore::Crypto::SRP6::SALT_LENGTH>();
            Acore::Crypto::SRP6::Verifier verifier = (*result)[1].Get<Binary, Acore::Crypto::SRP6::VERIFIER_LENGTH>();
            if (Acore::Crypto::SRP6::CheckLogin(username, password, salt, verifier))
                return true;
        }
 
        return false;
    }

References Acore::Crypto::SRP6::CheckLogin(), GetName(), LOGIN_SEL_CHECK_PASSWORD, LoginDatabase, Acore::Crypto::SRP6::SALT_LENGTH, PreparedStatementBase::SetData(), Utf8ToUpperOnlyLatin(), and Acore::Crypto::SRP6::VERIFIER_LENGTH.

Referenced by account_commandscript::HandleAccountPasswordCommand(), and ns1__executeCommand().

CreateAccount()

AccountOpResult AccountMgr::CreateAccount	(	std::string	username,
		std::string	password,
		std::string	email
	)

    {
        if (utf8length(username) > MAX_ACCOUNT_STR)
            return AOR_NAME_TOO_LONG;                           // username's too long
 
        if (utf8length(password) > MAX_PASS_STR)
            return AOR_PASS_TOO_LONG;                           // password's too long
 
        if (utf8length(email) > MAX_EMAIL_STR)
            return AOR_EMAIL_TOO_LONG;                          // email is too long
 
        Utf8ToUpperOnlyLatin(username);
        Utf8ToUpperOnlyLatin(password);
        Utf8ToUpperOnlyLatin(email);
 
        if (GetId(username))
            return AOR_NAME_ALREADY_EXIST;                      // username does already exist
 
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_ACCOUNT);
 
        stmt->SetData(0, username);
        auto [salt, verifier] = Acore::Crypto::SRP6::MakeRegistrationData(username, password);
        stmt->SetData(1, salt);
        stmt->SetData(2, verifier);
        stmt->SetData(3, uint8(sWorld->getIntConfig(CONFIG_EXPANSION)));
        stmt->SetData(4, email);
        stmt->SetData(5, email);
 
        LoginDatabase.Execute(stmt);
 
        stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_REALM_CHARACTERS_INIT);
 
        LoginDatabase.Execute(stmt);
 
        return AOR_OK;                                          // everything's fine
    }

References AOR_EMAIL_TOO_LONG, AOR_NAME_ALREADY_EXIST, AOR_NAME_TOO_LONG, AOR_OK, AOR_PASS_TOO_LONG, CONFIG_EXPANSION, GetId(), LOGIN_INS_ACCOUNT, LOGIN_INS_REALM_CHARACTERS_INIT, LoginDatabase, Acore::Crypto::SRP6::MakeRegistrationData(), MAX_ACCOUNT_STR, MAX_EMAIL_STR, MAX_PASS_STR, PreparedStatementBase::SetData(), sWorld, utf8length(), and Utf8ToUpperOnlyLatin().

Referenced by account_commandscript::HandleAccountCreateCommand().

DeleteAccount()

AccountOpResult AccountMgr::DeleteAccount

(

uint32

accountId

)

    {
        // Check if accounts exists
        LoginDatabasePreparedStatement* loginStmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_BY_ID);
        loginStmt->SetData(0, accountId);
 
        PreparedQueryResult result = LoginDatabase.Query(loginStmt);
        if (!result)
            return AOR_NAME_NOT_EXIST;
 
        sScriptMgr->OnBeforeAccountDelete(accountId);
 
        // Obtain accounts characters
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARS_BY_ACCOUNT_ID);
        stmt->SetData(0, accountId);
 
        result = CharacterDatabase.Query(stmt);
 
        if (result)
        {
            do
            {
                ObjectGuid guid = ObjectGuid::Create<HighGuid::Player>((*result)[0].Get<uint32>());
 
                // Kick if player is online
                if (Player* p = ObjectAccessor::FindPlayer(guid))
                {
                    WorldSession* s = p->GetSession();
                    s->KickPlayer("Delete account");            // mark session to remove at next session list update
                    s->LogoutPlayer(false);                     // logout player without waiting next session list update
                }
 
                Player::DeleteFromDB(guid.GetCounter(), accountId, false, true);       // no need to update realm characters
            } while (result->NextRow());
        }
 
        // table realm specific but common for all characters of account for realm
        stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_TUTORIALS);
        stmt->SetData(0, accountId);
        CharacterDatabase.Execute(stmt);
 
        stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ACCOUNT_DATA);
        stmt->SetData(0, accountId);
        CharacterDatabase.Execute(stmt);
 
        stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHARACTER_BAN);
        stmt->SetData(0, accountId);
        CharacterDatabase.Execute(stmt);
 
        LoginDatabaseTransaction trans = LoginDatabase.BeginTransaction();
 
        loginStmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_ACCOUNT);
        loginStmt->SetData(0, accountId);
        trans->Append(loginStmt);
 
        loginStmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_ACCOUNT_ACCESS);
        loginStmt->SetData(0, accountId);
        trans->Append(loginStmt);
 
        loginStmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_REALM_CHARACTERS);
        loginStmt->SetData(0, accountId);
        trans->Append(loginStmt);
 
        loginStmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_ACCOUNT_BANNED);
        loginStmt->SetData(0, accountId);
        trans->Append(loginStmt);
 
        loginStmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_ACCOUNT_MUTED);
        loginStmt->SetData(0, accountId);
        trans->Append(loginStmt);
 
        LoginDatabase.CommitTransaction(trans);
 
        return AOR_OK;
    }

References AOR_NAME_NOT_EXIST, AOR_OK, CHAR_DEL_ACCOUNT_DATA, CHAR_DEL_CHARACTER_BAN, CHAR_DEL_TUTORIALS, CHAR_SEL_CHARS_BY_ACCOUNT_ID, CharacterDatabase, Player::DeleteFromDB(), ObjectAccessor::FindPlayer(), ObjectGuid::GetCounter(), WorldSession::KickPlayer(), LOGIN_DEL_ACCOUNT, LOGIN_DEL_ACCOUNT_ACCESS, LOGIN_DEL_ACCOUNT_BANNED, LOGIN_DEL_ACCOUNT_MUTED, LOGIN_DEL_REALM_CHARACTERS, LOGIN_SEL_ACCOUNT_BY_ID, LoginDatabase, WorldSession::LogoutPlayer(), PreparedStatementBase::SetData(), and sScriptMgr.

Referenced by account_commandscript::HandleAccountDeleteCommand().

GetCharactersCount()

uint32 AccountMgr::GetCharactersCount

(

uint32

accountId

)

    {
        // check character count
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_SUM_CHARS);
        stmt->SetData(0, accountId);
        PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
        return (result) ? (*result)[0].Get<uint64>() : 0;
    }

References CHAR_SEL_SUM_CHARS, CharacterDatabase, and PreparedStatementBase::SetData().

Referenced by character_commandscript::HandleCharacterChangeAccountCommand(), character_commandscript::HandleCharacterDeletedRestoreHelper(), and PlayerDumpReader::LoadDump().

GetId()

uint32 AccountMgr::GetId

(

std::string const &

username

)

    {
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_GET_ACCOUNT_ID_BY_USERNAME);
        stmt->SetData(0, username);
        PreparedQueryResult result = LoginDatabase.Query(stmt);
 
        return (result) ? (*result)[0].Get<uint32>() : 0;
    }

References LOGIN_GET_ACCOUNT_ID_BY_USERNAME, LoginDatabase, and PreparedStatementBase::SetData().

Referenced by BanMgr::BanAccount(), CreateAccount(), account_commandscript::HandleAccountDeleteCommand(), account_commandscript::HandleAccountRemoveLockCountryCommand(), account_commandscript::HandleAccountSet2FACommand(), account_commandscript::HandleAccountSetAddonCommand(), account_commandscript::HandleAccountSetGmLevelCommand(), account_commandscript::HandleAccountSetPasswordCommand(), ban_commandscript::HandleBanInfoAccountCommand(), character_commandscript::HandleCharacterChangeAccountCommand(), misc_commandscript::HandleMuteInfoCommand(), ns1__executeCommand(), BanMgr::RemoveBanAccount(), and Acore::ChatCommands::AccountIdentifier::TryConsume().

GetName()

bool AccountMgr::GetName	(	uint32	accountId,
		std::string &	name
	)

    {
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_GET_USERNAME_BY_ID);
        stmt->SetData(0, accountId);
        PreparedQueryResult result = LoginDatabase.Query(stmt);
 
        if (result)
        {
            name = (*result)[0].Get<std::string>();
            return true;
        }
 
        return false;
    }

References LOGIN_GET_USERNAME_BY_ID, LoginDatabase, and PreparedStatementBase::SetData().

Referenced by Warden::ApplyPenalty(), BanMgr::BanAccountByPlayerName(), ChangeEmail(), ChangePassword(), CheckPassword(), WorldSession::DosProtection::EvaluateOpcode(), character_commandscript::GetDeletedCharacterInfoList(), account_commandscript::HandleAccountSetAddonCommand(), ban_commandscript::HandleBanListHelper(), character_commandscript::HandleCharacterChangeAccountCommand(), character_commandscript::HandleCharacterEraseCommand(), go_ulduar_pure_saronite_deposit::OnGossipHello(), and Acore::ChatCommands::AccountIdentifier::TryConsume().

GetSecurity() [1/2]

uint32 AccountMgr::GetSecurity

(

uint32

accountId

)

    {
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_GET_ACCOUNT_ACCESS_GMLEVEL);
        stmt->SetData(0, accountId);
        PreparedQueryResult result = LoginDatabase.Query(stmt);
 
        return (result) ? (*result)[0].Get<uint8>() : uint32(SEC_PLAYER);
    }

References LOGIN_GET_ACCOUNT_ACCESS_GMLEVEL, LoginDatabase, SEC_PLAYER, and PreparedStatementBase::SetData().

Referenced by account_commandscript::HandleAccountSetGmLevelCommand(), WorldSession::HandleAddFriendOpcode(), ticket_commandscript::HandleGMTicketAssignToCommand(), ticket_commandscript::HandleGMTicketUnAssignCommand(), ChatHandler::HasLowerSecurityAccount(), and ns1__executeCommand().

GetSecurity() [2/2]

uint32 AccountMgr::GetSecurity	(	uint32	accountId,
		int32	realmId
	)

    {
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_GET_GMLEVEL_BY_REALMID);
        stmt->SetData(0, accountId);
        stmt->SetData(1, realmId);
        PreparedQueryResult result = LoginDatabase.Query(stmt);
 
        return (result) ? (*result)[0].Get<uint8>() : uint32(SEC_PLAYER);
    }

References LOGIN_GET_GMLEVEL_BY_REALMID, LoginDatabase, SEC_PLAYER, and PreparedStatementBase::SetData().

IsAdminAccount()

bool AccountMgr::IsAdminAccount

(

uint32

gmlevel

)

    {
        return gmlevel >= SEC_ADMINISTRATOR && gmlevel <= SEC_CONSOLE;
    }

References SEC_ADMINISTRATOR, and SEC_CONSOLE.

Referenced by ticket_commandscript::HandleGMTicketAssignToCommand(), WorldSession::HandleWhoisOpcode(), and WorldSession::HandleWorldTeleportOpcode().

IsConsoleAccount()

bool AccountMgr::IsConsoleAccount

(

uint32

gmlevel

)

    {
        return gmlevel == SEC_CONSOLE;
    }

References SEC_CONSOLE.

Referenced by account_commandscript::HandleAccountSetGmLevelCommand().

IsGMAccount()

bool AccountMgr::IsGMAccount

(

uint32

gmlevel

)

    {
        return gmlevel >= SEC_GAMEMASTER;
    }

References SEC_GAMEMASTER.

IsPlayerAccount()

bool AccountMgr::IsPlayerAccount

(

uint32

gmlevel

)

    {
        return gmlevel == SEC_PLAYER;
    }

References SEC_PLAYER.

Referenced by ChatHandler::_ParseCommands(), WorldSessionMgr::AddSession_(), SocialMgr::BroadcastToFriendListers(), AchievementMgr::CompletedAchievement(), Player::Create(), Channel::FlagsNotify(), SocialMgr::GetFriendInfo(), WorldSession::HandleAddFriendOpcode(), WorldSession::HandleCharCreateOpcode(), WorldSession::HandleCharFactionOrRaceChangeCallback(), misc_commandscript::HandleCommentatorCommand(), misc_commandscript::HandleDevCommand(), gm_commandscript::HandleGMChatCommand(), gm_commandscript::HandleGMListIngameCommand(), ticket_commandscript::HandleGMTicketAssignToCommand(), group_commandscript::HandleGroupReviveCommand(), WorldSession::HandleMessagechatOpcode(), WorldSocket::HandlePing(), misc_commandscript::HandleReviveCommand(), WorldSession::HandleSendMail(), misc_commandscript::HandleUnstuckCommand(), WorldSession::HandleWhoOpcode(), ChatHandler::HasLowerSecurityAccount(), Player::IsVisibleGloballyFor(), Channel::JoinNotify(), Channel::LeaveNotify(), Channel::List(), Player::LoadFromDB(), LogCommandUsage(), Player::Player(), WorldSessionMgr::SendGlobalGMMessage(), ChatHandler::SendGMText(), Player::TeleportTo(), and Player::UpdateSpeakTime().