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 ()
std::string const &	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 (char const *name)
Protected Member Functions inherited from ScriptObject
	ScriptObject (char const *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,   rbac::RBAC_PERM_COMMAND_MAIL_LIST,   Console::Yes },
            { "return", HandleMailReturnCommand, rbac::RBAC_PERM_COMMAND_MAIL_RETURN, Console::Yes }
        };
 
        static ChatCommandTable commandTable =
        {
            { "mail", mailCommandTable }
        };
 
        return commandTable;
    }

References HandleMailListCommand(), HandleMailReturnCommand(), rbac::RBAC_PERM_COMMAND_MAIL_LIST, and rbac::RBAC_PERM_COMMAND_MAIL_RETURN.

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();
 
        CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
        // Collect attachments before the script-hook check and any deletion, so a hook
        // veto can still abort the command with nothing changed.
        // mail_items is flushed to the DB on every item take, so it is authoritative even
        // for online players; mails the session never loaded (expired at login, delivered
        // mid-login, inserted externally) are returned with their items too. Same query
        // shape as CHAR_SEL_MAILITEMS (LEFT JOIN to handle dangling mail_items) and same
        // logic as Player::_LoadMailedItem. Items the session already has loaded are
        // reused and stay owned by the session; the bool marks objects loaded (and owned)
        // here.
        std::vector<std::pair<Item*, bool /*loadedFromDb*/>> attachments;
 
        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>();
 
                // Prefer the item object the session already has loaded over creating a duplicate
                if (Item* item = player ? player->GetMItem(itemGuid) : nullptr)
                {
                    attachments.emplace_back(item, false);
                    continue;
                }
 
                // 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);
 
                    // The mail is going away, so drop the unloadable item_instance row too
                    Item::DeleteFromDB(trans, itemGuid);
                    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);
 
                    // Queue the row cleanup on the shared transaction instead of executing it
                    // immediately; SaveToDB in ITEM_REMOVED state also frees the object
                    item->FSetState(ITEM_REMOVED);
                    item->SaveToDB(trans);
                    continue;
                }
 
                attachments.emplace_back(item, true);
            } while (itemResult->NextRow());
        }
 
        // Run the same script hook as the client return handler for online targets,
        // covering DB-loaded attachments as well, before any deletion
        if (player)
        {
            ObjectGuid senderGuid = ObjectGuid(HighGuid::Player, sender);
            bool blocked = false;
 
            if (attachments.empty())
                blocked = !sScriptMgr->OnPlayerCanSendMail(player, senderGuid, ObjectGuid::Empty, subject, body, money, 0, nullptr);
 
            for (auto const& [item, loadedFromDb] : attachments)
            {
                if (blocked)
                    break;
 
                blocked = !sScriptMgr->OnPlayerCanSendMail(player, senderGuid, ObjectGuid::Empty, subject, body, money, 0, item);
            }
 
            if (blocked)
            {
                for (auto const& [item, loadedFromDb] : attachments)
                    if (loadedFromDb)
                        delete item;
 
                handler->SendErrorMessage(LANG_MAIL_RETURN_HOOK_BLOCKED);
                return true;
            }
        }
 
        // Same logic as WorldSession::HandleReturnToSender
        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)
        {
            // Drop the mail from the session's loaded state if present.
            // RemoveMail only erases from the deque, it does not delete the object.
            Mail* m = player->GetMail(mailId);
            player->RemoveMail(mailId);
            delete m;
        }
 
        for (auto const& [item, loadedFromDb] : attachments)
        {
            if (!loadedFromDb)
                player->RemoveMItem(item->GetGUID().GetCounter());
 
            draft.AddItem(item);
        }
 
        uint32 accountId = sCharacterCache->GetCharacterAccountIdByGuid(ObjectGuid(HighGuid::Player, receiver));
        draft.AddMoney(money).SendReturnToSender(accountId, receiver, sender, trans);
 
        CharacterDatabase.CommitTransaction(trans);
 
        sMailMgr->OnMailDeleted(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, Item::DeleteFromDB(), 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(), ITEM_REMOVED, 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(), sMailMgr, 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