ServerMailMgr Class Reference

#include "ServerMailMgr.h"

Public Member Functions
void	LoadMailServerTemplates ()
	Loads all server mail templates from the database into memory.
void	LoadMailServerTemplatesItems ()
	Loads all items associated with server mail templates.
void	LoadMailServerTemplatesConditions ()
	Loads all conditions associated with server mail templates.
ServerMailConditionType	GetServerMailConditionType (std::string_view conditionTypeStr) const
	Convert DB value of conditionType to ServerMailConditionType.
bool	ConditionTypeUsesConditionState (ServerMailConditionType type) const
	Check if ConditionType should use ConditionState.
void	SendServerMail (Player *player, uint32 id, uint32 money, std::vector< ServerMailItems > const &items, std::vector< ServerMailCondition > const &conditions, std::string const &subject, std::string const &body) const
	Sends a server mail to a player if the template is active and the player is eligible.
ServerMailContainer const &	GetAllServerMailStore () const
	Retrieves the entire server mail store.

Static Public Member Functions
static ServerMailMgr *	instance ()

Private Member Functions
	ServerMailMgr ()=default
	~ServerMailMgr ()=default

Private Attributes
ServerMailContainer	_serverMailStore

Detailed Description

Constructor & Destructor Documentation

ServerMailMgr()

ServerMailMgr::ServerMailMgr ( )

privatedefault

~ServerMailMgr()

ServerMailMgr::~ServerMailMgr ( )

privatedefault

Member Function Documentation

ConditionTypeUsesConditionState()

bool ServerMailMgr::ConditionTypeUsesConditionState

(

ServerMailConditionType

type

)

const

Check if ConditionType should use ConditionState.

Returns

True if the ConditionType is allowed to use ConditionState, otherwise False.

{
    switch (type)
    {
    case ServerMailConditionType::Quest:
    case ServerMailConditionType::Reputation:
        return true;
    default:
        return false;
    }
}

References Quest, and Reputation.

Referenced by LoadMailServerTemplatesConditions().

GetAllServerMailStore()

ServerMailContainer const & ServerMailMgr::GetAllServerMailStore ( ) const

inline

Retrieves the entire server mail store.

This function returns a constant reference to the internal _serverMailStore container, which holds all server mail data.

Returns

A constant reference to the ServerMailContainer containing all stored server mail.

{ return _serverMailStore; }

References _serverMailStore.

GetServerMailConditionType()

ServerMailConditionType ServerMailMgr::GetServerMailConditionType

(

std::string_view

conditionTypeStr

)

const

Convert DB value of conditionType to ServerMailConditionType.

Lookup the corresponding SeverMailConditionType enum for the provided string by DB. If the string is not found we return internal default value ServerMailConditionType::Invalid

Parameters

conditionTypeStr

string value from DB of conditionType

Returns

ServerMailConditionType The corresponding value (see ServerMailConditionType) or default to ServerMailConditionType::Invalid

{
    for (auto const& pair : ServerMailConditionTypePairs)
        if (pair.first == conditionTypeStr)
            return pair.second;
 
    return ServerMailConditionType::Invalid;
}

References Invalid, and ServerMailConditionTypePairs.

Referenced by LoadMailServerTemplatesConditions().

instance()

ServerMailMgr * ServerMailMgr::instance ( )

static

{
    static ServerMailMgr instance;
    return &instance;
}

References instance().

Referenced by instance().

LoadMailServerTemplates()

void ServerMailMgr::LoadMailServerTemplates

(

)

Loads all server mail templates from the database into memory.

Queries the mail_server_template table and loads all rows into memory. This method is intended to be called during server startup.

{
    uint32 oldMSTime = getMSTime();
 
    _serverMailStore.clear(); // for reload case
 
    //                                                    0     1         2         3          4       5
    QueryResult result = CharacterDatabase.Query("SELECT `id`, `moneyA`, `moneyH`, `subject`, `body`, `active` FROM `mail_server_template`");
    if (!result)
    {
        LOG_INFO("server.loading", ">> Loaded 0 server mail rewards. DB table `mail_server_template` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    _serverMailStore.reserve(result->GetRowCount());
 
    do
    {
        Field* fields = result->Fetch();
 
        uint32 id = fields[0].Get<uint32>();
 
        ServerMail& servMail = _serverMailStore[id];
        servMail.id          = id;
        servMail.moneyA      = fields[1].Get<uint32>();
        servMail.moneyH      = fields[2].Get<uint32>();
        servMail.subject     = fields[3].Get<std::string>();
        servMail.body        = fields[4].Get<std::string>();
        servMail.active      = fields[5].Get<uint8>();
 
        // Skip non-activated entries
        if (!servMail.active)
            continue;
 
        if (servMail.moneyA > MAX_MONEY_AMOUNT || servMail.moneyH > MAX_MONEY_AMOUNT)
        {
            LOG_ERROR("sql.sql", "Table `mail_server_template` has moneyA {} or moneyH {} larger than MAX_MONEY_AMOUNT {} for id {}, skipped.", servMail.moneyA, servMail.moneyH, MAX_MONEY_AMOUNT, servMail.id);
            continue;
        }
    } while (result->NextRow());
 
    LoadMailServerTemplatesItems();
    LoadMailServerTemplatesConditions();
 
    LOG_INFO("server.loading", ">> Loaded {} Mail Server definitions in {} ms", _serverMailStore.size(), GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References _serverMailStore, CharacterDatabase, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), ServerMail::id, LoadMailServerTemplatesConditions(), LoadMailServerTemplatesItems(), LOG_ERROR, LOG_INFO, and MAX_MONEY_AMOUNT.

LoadMailServerTemplatesConditions()

void ServerMailMgr::LoadMailServerTemplatesConditions

(

)

Loads all conditions associated with server mail templates.

Queries the mail_server_template_conditions table and loads all conditions into memory, linking them to their corresponding templates by template ID. This method is intended to be called during server startup.

{
    //                                                    0             1                2                 3
    QueryResult result = CharacterDatabase.Query("SELECT `templateID`, `conditionType`, `conditionValue`, `conditionState` FROM `mail_server_template_conditions`");
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 server mail conditions. DB table `mail_server_template_conditions` is empty.");
        return;
    }
 
    do
    {
        Field* fields = result->Fetch();
 
        uint32 templateID                 = fields[0].Get<uint32>();
        std::string_view conditionTypeStr = fields[1].Get<std::string_view>();
        uint32 conditionValue             = fields[2].Get<uint32>();
        uint32 conditionState             = fields[3].Get<uint32>();
 
        if (_serverMailStore.find(templateID) == _serverMailStore.end())
        {
            LOG_ERROR("sql.sql", "Table `mail_server_template_conditions` has an invalid templateID {}, skipped.", templateID);
            continue;
        }
 
        // Get conditiontype from ServerMailConditionTypePairs
        ServerMailConditionType conditionType;
        conditionType = GetServerMailConditionType(conditionTypeStr);
        if (conditionType == ServerMailConditionType::Invalid) [[unlikely]]
        {
            LOG_ERROR("sql.sql", "Table `mail_server_template_conditions` has unknown conditionType '{}', skipped.", conditionTypeStr);
            continue;
        }
 
        if (conditionState && !ConditionTypeUsesConditionState(conditionType))
            LOG_WARN("sql.sql", "Table `mail_server_template_conditions` has conditionState value ({}) for conditionType ({}) which does not use conditionState.", conditionState, conditionTypeStr);
 
        switch (conditionType)
        {
        case ServerMailConditionType::Level:
            if (conditionValue > sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL))
            {
                LOG_ERROR("sql.sql", "Table `mail_server_template_conditions` has conditionType 'Level' with invalid conditionValue ({}), max level is ({}) for templateID {}, skipped.", conditionValue, sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL), templateID);
                continue;
            }
            break;
        case ServerMailConditionType::Quest:
        {
            Quest const* qInfo = sObjectMgr->GetQuestTemplate(conditionValue);
            if (!qInfo)
            {
                LOG_ERROR("sql.sql", "Table `mail_server_template_conditions` has conditionType 'Quest' with invalid quest in conditionValue ({}) for templateID {}, skipped.", conditionValue, templateID);
                continue;
            }
            if (conditionState < QUEST_STATUS_NONE || conditionState >= MAX_QUEST_STATUS ||
                /*2 and 4 not defined and should not be used*/ conditionState == 2 || conditionState == 4)
            {
                LOG_ERROR("sql.sql", "Table `mail_server_template_conditions` has conditionType 'Quest' with invalid conditionState ({}) for templateID {}, skipped.", conditionState, templateID);
                continue;
            }
            break;
        }
        case ServerMailConditionType::Achievement:
        {
            AchievementEntry const* achievement = sAchievementStore.LookupEntry(conditionValue);
            if (!achievement)
            {
                LOG_ERROR("sql.sql", "Table `mail_server_template_conditions` has conditionType 'Achievement' with invalid achievement in conditionValue ({}) for templateID {}, skipped.", conditionValue, templateID);
                continue;
            }
            break;
        }
        case ServerMailConditionType::Reputation:
        {
            FactionEntry const* faction = sFactionStore.LookupEntry(conditionValue);
            if (!faction)
            {
                LOG_ERROR("sql.sql", "Table `mail_server_template_conditions` has conditionType 'Reputation' with invalid faction in conditionValue ({}) for templateID {}, skipped.", conditionValue, templateID);
                continue;
            }
            if (conditionState < REP_HATED || conditionState > REP_EXALTED)
            {
                LOG_ERROR("sql.sql", "Table `mail_server_template_conditions` has conditionType 'Reputation' with invalid conditionState ({}) for templateID {}, skipped.", conditionState, templateID);
                continue;
            }
            break;
        }
        case ServerMailConditionType::Faction:
            if (conditionValue < TEAM_ALLIANCE || conditionValue > TEAM_HORDE)
            {
                LOG_ERROR("sql.sql", "Table `mail_server_template_conditions` has conditionType 'Faction' with invalid conditionValue ({}) for templateID {}, skipped.", conditionValue, templateID);
                continue;
            }
            break;
        case ServerMailConditionType::Race:
            if (conditionValue & ~sRaceMgr->GetPlayableRaceMask())
            {
                LOG_ERROR("sql.sql", "Table `mail_server_template_conditions` has conditionType 'Race' with invalid conditionValue ({}) for templateID {}, skipped.", conditionValue, templateID);
                continue;
            }
            break;
        case ServerMailConditionType::Class:
            if (conditionValue & ~CLASSMASK_ALL_PLAYABLE)
            {
                LOG_ERROR("sql.sql", "Table `mail_server_template_conditions` has conditionType 'Class' with invalid conditionValue ({}) for templateID {}, skipped.", conditionValue, templateID);
                continue;
            }
            break;
        case ServerMailConditionType::AccountFlags:
            if ((conditionValue & ~ACCOUNT_FLAGS_ALL) != 0)
            {
                LOG_ERROR("sql.sql", "Table `mail_server_template_conditions` has conditionType 'AccountFlags' with invalid conditionValue ({}) for templateID {}, skipped.", conditionValue, templateID);
                continue;
            }
            break;
        default:
            break;
        }
 
        ServerMailCondition condition;
        condition.type = conditionType;
        condition.value = conditionValue;
        condition.state = conditionState;
        _serverMailStore[templateID].conditions.push_back(condition);
 
    } while (result->NextRow());
}

References _serverMailStore, ACCOUNT_FLAGS_ALL, AccountFlags, Achievement, CharacterDatabase, Class, CLASSMASK_ALL_PLAYABLE, ConditionTypeUsesConditionState(), CONFIG_MAX_PLAYER_LEVEL, Faction, Field::Get(), GetServerMailConditionType(), Invalid, Level, LOG_ERROR, LOG_WARN, MAX_QUEST_STATUS, Quest, Race, REP_EXALTED, Reputation, sAchievementStore, sFactionStore, sObjectMgr, sRaceMgr, ServerMailCondition::state, sWorld, TEAM_HORDE, ServerMailCondition::type, and ServerMailCondition::value.

Referenced by LoadMailServerTemplates().

LoadMailServerTemplatesItems()

void ServerMailMgr::LoadMailServerTemplatesItems

(

)

Loads all items associated with server mail templates.

Queries the mail_server_template_items table and loads all items into memory, linking them to their corresponding templates by template ID. This method is intended to be called during server startup.

{
    //                                                    0             1          2       3
    QueryResult result = CharacterDatabase.Query("SELECT `templateID`, `faction`, `item`, `itemCount` FROM `mail_server_template_items`");
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 server mail items. DB table `mail_server_template_items` is empty.");
        return;
    }
 
    do
    {
        Field* fields = result->Fetch();
 
        uint32 templateID        = fields[0].Get<uint32>();
        std::string_view faction = fields[1].Get<std::string_view>();
        uint32 item              = fields[2].Get<uint32>();
        uint32 itemCount         = fields[3].Get<uint32>();
 
        if (_serverMailStore.find(templateID) == _serverMailStore.end())
        {
            LOG_ERROR("sql.sql", "Table `mail_server_template_items` has an invalid templateID {}, skipped.", templateID);
            continue;
        }
 
        ItemTemplate const* itemTemplate = sObjectMgr->GetItemTemplate(item);
        if (!itemTemplate)
        {
            LOG_ERROR("sql.sql", "Table `mail_server_template_items` has an invalid item {} for templateID {}, skipped.", item, templateID);
            continue;
        }
 
        if (!itemCount)
        {
            LOG_ERROR("sql.sql", "Table `mail_server_template_items` has itemCount 0 for item {}, skipped.", item);
            continue;
        }
 
        uint32 stackable = itemTemplate->Stackable;
        if (itemCount > stackable)
        {
            LOG_ERROR("sql.sql", "Table `mail_server_template_items` has itemCount {} exceeding item_template.Stackable {} for item {}, skipped.", itemCount, stackable, item);
            continue;
        }
 
        uint32 maxCount = itemTemplate->MaxCount;
        if (maxCount && itemCount > maxCount)
        {
            LOG_ERROR("sql.sql", "Table `mail_server_template_items` has itemCount {} exceeding item_template.MaxCount {} for item {}, skipped", itemCount, maxCount, item);
            continue;
        }
 
        ServerMailItems mailItem;
        mailItem.item      = item;
        mailItem.itemCount = itemCount;
 
        if (faction == "Alliance")
            _serverMailStore[templateID].itemsA.push_back(mailItem);
        else if (faction == "Horde")
            _serverMailStore[templateID].itemsH.push_back(mailItem);
        else [[unlikely]]
        {
            LOG_ERROR("sql.sql", "Table `mail_server_template_items` has invalid faction value '{}' for templateID {}, skipped.", faction, templateID);
            continue;
        }
 
    } while (result->NextRow());
}

References _serverMailStore, CharacterDatabase, Field::Get(), ServerMailItems::item, ServerMailItems::itemCount, LOG_ERROR, LOG_WARN, ItemTemplate::MaxCount, sObjectMgr, and ItemTemplate::Stackable.

Referenced by LoadMailServerTemplates().

SendServerMail()

void ServerMailMgr::SendServerMail	(	Player *	player,
		uint32	id,
		uint32	money,
		std::vector< ServerMailItems > const &	items,
		std::vector< ServerMailCondition > const &	conditions,
		std::string const &	subject,
		std::string const &	body
	)		const

Sends a server mail to a player if the template is active and the player is eligible.

This method handles the creation of the mail, adding money and items, and saving the mail to the database. It also records that the player received the mail to prevent duplicate delivery.

Parameters

player	The recipient player.
id	The template ID.
money	Money reward.
items	List of items to include in the mail.
conditions	List of the conditions for the mail.
subject	Mail subject.
body	Mail body.
active	Whether the mail template is active.

{
    for (ServerMailCondition const& condition : conditions)
        if (!condition.CheckCondition(player))
            return;
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
    MailSender sender(MAIL_NORMAL, player->GetGUID().GetCounter(), MAIL_STATIONERY_GM);
    MailDraft draft(subject, body);
 
    draft.AddMoney(money);
    // Loop through all items and attach them to the mail
    for (auto const& mailItem : items)
        if (Item* newItem = Item::CreateItem(mailItem.item, mailItem.itemCount))
        {
            newItem->SaveToDB(trans);
            draft.AddItem(newItem);
        }
 
    draft.SendMailTo(trans, MailReceiver(player), sender);
    CharacterDatabase.CommitTransaction(trans);
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_MAIL_SERVER_CHARACTER);
    stmt->SetData(0, player->GetGUID().GetCounter());
    stmt->SetData(1, id);
    CharacterDatabase.Execute(stmt);
}

References MailDraft::AddItem(), MailDraft::AddMoney(), CHAR_REP_MAIL_SERVER_CHARACTER, CharacterDatabase, Item::CreateItem(), ObjectGuid::GetCounter(), Object::GetGUID(), MAIL_NORMAL, MAIL_STATIONERY_GM, MailDraft::SendMailTo(), and PreparedStatementBase::SetData().

Member Data Documentation

_serverMailStore

ServerMailContainer ServerMailMgr::_serverMailStore

private

Referenced by GetAllServerMailStore(), LoadMailServerTemplates(), LoadMailServerTemplatesConditions(), and LoadMailServerTemplatesItems().

---

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

• azerothcore-wotlk/src/server/game/Mails/ServerMailMgr.h
• azerothcore-wotlk/src/server/game/Mails/ServerMailMgr.cpp