mail_commandscript Class Reference

Inheritance diagram for mail_commandscript:

Public Member Functions
	mail_commandscript ()
ChatCommandTable	GetCommands () const override
Public Member Functions inherited from ScriptObject
virtual bool	IsDatabaseBound () const
virtual bool	isAfterLoadScript () const
virtual void	checkValidity ()
const std::string &	GetName () const
uint16	GetTotalAvailableHooks ()

Static Public Member Functions
static char const *	GetMailTypeString (uint8 messageType)
static char const *	GetMailStationeryString (uint8 stationery)
static std::string	GetItemListString (std::vector< MailItemInfo > const &items)
static bool	HandleMailListCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)
static bool	HandleMailReturnCommand (ChatHandler *handler, PlayerIdentifier target, uint32 mailId)

Additional Inherited Members
Protected Member Functions inherited from CommandScript
	CommandScript (const char *name)
Protected Member Functions inherited from ScriptObject
	ScriptObject (const char *name, uint16 totalAvailableHooks=0)
virtual	~ScriptObject ()=default

Detailed Description

Constructor & Destructor Documentation

mail_commandscript()

mail_commandscript::mail_commandscript ( )

inline

: CommandScript("mail_commandscript") { }

Member Function Documentation

GetCommands()

ChatCommandTable mail_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

    {
        static ChatCommandTable mailCommandTable =
        {
            { "list",   HandleMailListCommand,   SEC_GAMEMASTER, Console::Yes },
            { "return", HandleMailReturnCommand,  SEC_GAMEMASTER, Console::Yes }
        };
 
        static ChatCommandTable commandTable =
        {
            { "mail", mailCommandTable }
        };
 
        return commandTable;
    }

References HandleMailListCommand(), HandleMailReturnCommand(), and SEC_GAMEMASTER.

GetItemListString()

static std::string mail_commandscript::GetItemListString ( std::vector< MailItemInfo > const &  items )

inlinestatic

    {
        if (items.empty())
            return "none";
 
        std::string result;
        for (size_t i = 0; i < items.size(); ++i)
        {
            if (i > 0)
                result += ", ";
 
            result += Acore::StringFormat("{}(guid:{})", items[i].item_template, items[i].item_guid);
        }
        return result;
    }

References Acore::StringFormat().

Referenced by HandleMailListCommand().

GetMailStationeryString()

static char const * mail_commandscript::GetMailStationeryString ( uint8  stationery )

inlinestatic

    {
        switch (stationery)
        {
            case MAIL_STATIONERY_TEST:    return "Test";
            case MAIL_STATIONERY_DEFAULT: return "Default";
            case MAIL_STATIONERY_GM:      return "GM";
            case MAIL_STATIONERY_AUCTION: return "Auction";
            case MAIL_STATIONERY_VAL:     return "Valentine";
            case MAIL_STATIONERY_CHR:     return "Christmas";
            case MAIL_STATIONERY_ORP:     return "Orphan";
            default:                      return "Unknown";
        }
    }

References MAIL_STATIONERY_AUCTION, MAIL_STATIONERY_CHR, MAIL_STATIONERY_DEFAULT, MAIL_STATIONERY_GM, MAIL_STATIONERY_ORP, MAIL_STATIONERY_TEST, and MAIL_STATIONERY_VAL.

Referenced by HandleMailListCommand().

GetMailTypeString()

static char const * mail_commandscript::GetMailTypeString ( uint8  messageType )

inlinestatic

    {
        switch (messageType)
        {
            case MAIL_NORMAL:     return "Normal";
            case MAIL_AUCTION:    return "Auction";
            case MAIL_CREATURE:   return "Creature";
            case MAIL_GAMEOBJECT: return "GameObject";
            case MAIL_CALENDAR:   return "Calendar";
            default:              return "Unknown";
        }
    }

References MAIL_AUCTION, MAIL_CALENDAR, MAIL_CREATURE, MAIL_GAMEOBJECT, and MAIL_NORMAL.

Referenced by HandleMailListCommand().

HandleMailListCommand()

static bool mail_commandscript::HandleMailListCommand ( ChatHandler *  handler, Optional< PlayerIdentifier >  target  )

inlinestatic

    {
        if (!target)
            target = PlayerIdentifier::FromTargetOrSelf(handler);
 
        if (!target)
            return false;
 
        Player* player = target->GetConnectedPlayer();
 
        if (player)
        {
            PlayerMails const& mails = player->GetMails();
 
            if (mails.empty())
            {
                handler->PSendSysMessage(LANG_MAIL_LIST_EMPTY, handler->playerLink(target->GetName()));
                return true;
            }
 
            handler->PSendSysMessage(LANG_MAIL_LIST_HEADER, handler->playerLink(target->GetName()));
 
            for (Mail const* mail : mails)
            {
                std::string senderName;
                if (mail->messageType == MAIL_NORMAL)
                    sCharacterCache->GetCharacterNameByGuid(ObjectGuid(HighGuid::Player, mail->sender), senderName);
 
                std::string expireStr = Acore::Time::TimeToTimestampStr(Seconds(mail->expire_time));
                std::string deliverStr = Acore::Time::TimeToTimestampStr(Seconds(mail->deliver_time));
 
                handler->PSendSysMessage(LANG_MAIL_LIST_ENTRY,
                    mail->messageID, GetMailTypeString(mail->messageType), GetMailStationeryString(mail->stationery),
                    mail->mailTemplateId, mail->sender, senderName, mail->receiver,
                    expireStr, deliverStr, mail->money, mail->COD, mail->checked, GetItemListString(mail->items));
            }
        }
        else
        {
            ObjectGuid::LowType lowGuid = target->GetGUID().GetCounter();
 
            QueryResult result = CharacterDatabase.Query(
                "SELECT id, messageType, sender, receiver, subject, body, expire_time, deliver_time, money, cod, checked, stationery, mailTemplateId"
                " FROM mail WHERE receiver = {} AND deliver_time <= {} ORDER BY id DESC",
                lowGuid, GameTime::GetGameTime().count());
 
            if (!result)
            {
                handler->PSendSysMessage(LANG_MAIL_LIST_EMPTY, handler->playerLink(target->GetName()));
                return true;
            }
 
            handler->PSendSysMessage(LANG_MAIL_LIST_HEADER, handler->playerLink(target->GetName()));
 
            do
            {
                Field* fields = result->Fetch();
                uint32 messageID    = fields[0].Get<uint32>();
                uint8 messageType   = fields[1].Get<uint8>();
                uint32 sender       = fields[2].Get<uint32>();
                uint32 receiver     = fields[3].Get<uint32>();
                // fields[4] = subject (skipped)
                // fields[5] = body (skipped)
                uint32 expireTime   = fields[6].Get<uint32>();
                uint32 deliverTime  = fields[7].Get<uint32>();
                uint32 money        = fields[8].Get<uint32>();
                uint32 cod          = fields[9].Get<uint32>();
                uint32 checked      = fields[10].Get<uint32>();
                uint8 stationery    = fields[11].Get<uint8>();
                uint16 mailTemplate = fields[12].Get<uint16>();
 
                std::string senderName;
                if (messageType == MAIL_NORMAL)
                    sCharacterCache->GetCharacterNameByGuid(ObjectGuid(HighGuid::Player, sender), senderName);
 
                std::string expireStr = Acore::Time::TimeToTimestampStr(Seconds(expireTime));
                std::string deliverStr = Acore::Time::TimeToTimestampStr(Seconds(deliverTime));
 
                // For offline players we don't have item details loaded
                handler->PSendSysMessage(LANG_MAIL_LIST_ENTRY,
                    messageID, GetMailTypeString(messageType), GetMailStationeryString(stationery),
                    mailTemplate, sender, senderName, receiver,
                    expireStr, deliverStr, money, cod, checked, "N/A (offline)");
            } while (result->NextRow());
        }
 
        return true;
    }

References CharacterDatabase, Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), Field::Get(), GameTime::GetGameTime(), GetItemListString(), Player::GetMails(), GetMailStationeryString(), GetMailTypeString(), LANG_MAIL_LIST_EMPTY, LANG_MAIL_LIST_ENTRY, LANG_MAIL_LIST_HEADER, MAIL_NORMAL, Player, ChatHandler::playerLink(), ChatHandler::PSendSysMessage(), sCharacterCache, and Acore::Time::TimeToTimestampStr().

Referenced by GetCommands().

HandleMailReturnCommand()

static bool mail_commandscript::HandleMailReturnCommand ( ChatHandler *  handler, PlayerIdentifier  target, uint32  mailId  )

inlinestatic

    {
        // Query mail data from DB so this works for offline players
        QueryResult result = CharacterDatabase.Query(
            "SELECT messageType, sender, receiver, subject, body, money, mailTemplateId, checked, deliver_time"
            " FROM mail WHERE id = {}", mailId);
 
        if (!result)
        {
            handler->SendErrorMessage(LANG_MAIL_RETURN_NOT_FOUND, mailId);
            return true;
        }
 
        Field* fields       = result->Fetch();
        uint8 messageType   = fields[0].Get<uint8>();
        uint32 sender       = fields[1].Get<uint32>();
        uint32 receiver     = fields[2].Get<uint32>();
        std::string subject = fields[3].Get<std::string>();
        std::string body    = fields[4].Get<std::string>();
        uint32 money        = fields[5].Get<uint32>();
        uint16 mailTemplate = fields[6].Get<uint16>();
        uint32 checked      = fields[7].Get<uint32>();
        uint32 deliverTime  = fields[8].Get<uint32>();
 
        // Reject undelivered mail, same as the core handler
        if (deliverTime > GameTime::GetGameTime().count())
        {
            handler->SendErrorMessage(LANG_MAIL_RETURN_NOT_FOUND, mailId);
            return true;
        }
 
        // Verify the mail belongs to the target player
        if (receiver != target.GetGUID().GetCounter())
        {
            handler->SendErrorMessage(LANG_MAIL_RETURN_NOT_FOUND, mailId);
            return true;
        }
 
        if (messageType != MAIL_NORMAL)
        {
            handler->SendErrorMessage(LANG_MAIL_RETURN_NOT_NORMAL);
            return true;
        }
 
        if (!sender)
        {
            handler->SendErrorMessage(LANG_MAIL_RETURN_NO_SENDER);
            return true;
        }
 
        if (checked & MAIL_CHECK_MASK_RETURNED)
        {
            handler->SendErrorMessage(LANG_MAIL_RETURN_ALREADY_RETURNED);
            return true;
        }
 
        Player* player = target.GetConnectedPlayer();
 
        // Run the same script hook as the client return handler, failing early before any deletions
        if (player)
        {
            Mail* m = player->GetMail(mailId);
            if (m)
            {
                ObjectGuid senderGuid = ObjectGuid(HighGuid::Player, sender);
 
                if (m->HasItems())
                {
                    for (auto const& itemInfo : m->items)
                    {
                        Item* item = player->GetMItem(itemInfo.item_guid);
                        if (item && !sScriptMgr->OnPlayerCanSendMail(player, senderGuid, ObjectGuid::Empty, subject, body, money, 0, item))
                        {
                            handler->SendErrorMessage(LANG_MAIL_RETURN_HOOK_BLOCKED);
                            return true;
                        }
                    }
                }
                else if (!sScriptMgr->OnPlayerCanSendMail(player, senderGuid, ObjectGuid::Empty, subject, body, money, 0, nullptr))
                {
                    handler->SendErrorMessage(LANG_MAIL_RETURN_HOOK_BLOCKED);
                    return true;
                }
            }
        }
 
        // Same logic as WorldSession::HandleReturnToSender
        CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_MAIL_BY_ID);
        stmt->SetData(0, mailId);
        trans->Append(stmt);
 
        stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_MAIL_ITEM_BY_ID);
        stmt->SetData(0, mailId);
        trans->Append(stmt);
 
        MailDraft draft(subject, body);
        if (mailTemplate)
            draft = MailDraft(mailTemplate, false);
 
        if (player)
        {
            // Online: same logic as WorldSession::HandleReturnToSender
            // Get pointer before RemoveMail (which removes from deque but does not delete the object)
            Mail* m = player->GetMail(mailId);
 
            player->RemoveMail(mailId);
 
            if (m && m->HasItems())
            {
                for (auto const& itemInfo : m->items)
                {
                    if (Item* item = player->GetMItem(itemInfo.item_guid))
                        draft.AddItem(item);
 
                    player->RemoveMItem(itemInfo.item_guid);
                }
            }
 
            delete m;
        }
        else
        {
            // Offline: load Item* objects from DB using same query shape as CHAR_SEL_MAILITEMS
            // (LEFT JOIN to handle dangling mail_items) and same logic as Player::_LoadMailedItem
            QueryResult itemResult = CharacterDatabase.Query(
                "SELECT creatorGuid, giftCreatorGuid, count, duration, charges, flags, enchantments,"
                " randomPropertyId, durability, playedTime, text, mi.item_guid, itemEntry, ii.owner_guid"
                " FROM mail_items mi LEFT JOIN item_instance ii ON mi.item_guid = ii.guid"
                " WHERE mi.mail_id = {}", mailId);
 
            if (itemResult)
            {
                do
                {
                    Field* itemFields = itemResult->Fetch();
                    uint32 itemGuid  = itemFields[11].Get<uint32>();
                    uint32 itemEntry = itemFields[12].Get<uint32>();
 
                    // Handle dangling mail_items (missing item_instance)
                    if (!itemEntry)
                    {
                        LOG_ERROR("misc", "cs_mail: Mail #{} has dangling mail_items row for item_guid {}. Cleaning up.", mailId, itemGuid);
 
                        CharacterDatabasePreparedStatement* delStmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_INVALID_MAIL_ITEM);
                        delStmt->SetData(0, itemGuid);
                        trans->Append(delStmt);
                        continue;
                    }
 
                    ItemTemplate const* proto = sObjectMgr->GetItemTemplate(itemEntry);
                    if (!proto)
                    {
                        LOG_ERROR("misc", "cs_mail: Mail #{} has unknown item (entry: {}, guid: {}). Cleaning up.", mailId, itemEntry, itemGuid);
 
                        CharacterDatabasePreparedStatement* delStmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_INVALID_MAIL_ITEM);
                        delStmt->SetData(0, itemGuid);
                        trans->Append(delStmt);
                        continue;
                    }
 
                    Item* item = NewItemOrBag(proto);
                    ObjectGuid ownerGuid = itemFields[13].Get<uint32>()
                        ? ObjectGuid::Create<HighGuid::Player>(itemFields[13].Get<uint32>())
                        : ObjectGuid::Empty;
 
                    if (!item->LoadFromDB(itemGuid, ownerGuid, itemFields, itemEntry))
                    {
                        LOG_ERROR("misc", "cs_mail: Item (GUID: {}) in mail #{} failed to load. Cleaning up.", itemGuid, mailId);
 
                        CharacterDatabasePreparedStatement* delStmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_INVALID_MAIL_ITEM);
                        delStmt->SetData(0, itemGuid);
                        trans->Append(delStmt);
 
                        item->FSetState(ITEM_REMOVED);
                        CharacterDatabaseTransaction nullTrans = CharacterDatabaseTransaction(nullptr);
                        item->SaveToDB(nullTrans);
                        return true;
                    }
 
                    draft.AddItem(item);
                } while (itemResult->NextRow());
            }
        }
 
        uint32 accountId = sCharacterCache->GetCharacterAccountIdByGuid(ObjectGuid(HighGuid::Player, receiver));
        draft.AddMoney(money).SendReturnToSender(accountId, receiver, sender, trans);
 
        CharacterDatabase.CommitTransaction(trans);
 
        sCharacterCache->DecreaseCharacterMailCount(ObjectGuid(HighGuid::Player, receiver));
 
        handler->PSendSysMessage(LANG_MAIL_RETURN_SUCCESS, mailId, handler->playerLink(target.GetName()));
        return true;
    }

References MailDraft::AddItem(), MailDraft::AddMoney(), CHAR_DEL_INVALID_MAIL_ITEM, CHAR_DEL_MAIL_BY_ID, CHAR_DEL_MAIL_ITEM_BY_ID, CharacterDatabase, ObjectGuid::Empty, Item::FSetState(), Field::Get(), Acore::ChatCommands::PlayerIdentifier::GetConnectedPlayer(), ObjectGuid::GetCounter(), GameTime::GetGameTime(), Acore::ChatCommands::PlayerIdentifier::GetGUID(), Player::GetMail(), Player::GetMItem(), Acore::ChatCommands::PlayerIdentifier::GetName(), Mail::HasItems(), ITEM_REMOVED, Mail::items, LANG_MAIL_RETURN_ALREADY_RETURNED, LANG_MAIL_RETURN_HOOK_BLOCKED, LANG_MAIL_RETURN_NO_SENDER, LANG_MAIL_RETURN_NOT_FOUND, LANG_MAIL_RETURN_NOT_NORMAL, LANG_MAIL_RETURN_SUCCESS, Item::LoadFromDB(), LOG_ERROR, MAIL_CHECK_MASK_RETURNED, MAIL_NORMAL, NewItemOrBag(), Player, ChatHandler::playerLink(), ChatHandler::PSendSysMessage(), Player::RemoveMail(), Player::RemoveMItem(), Item::SaveToDB(), sCharacterCache, ChatHandler::SendErrorMessage(), MailDraft::SendReturnToSender(), PreparedStatementBase::SetData(), sObjectMgr, and sScriptMgr.

Referenced by GetCommands().

---

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

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