Exemple #1
0
void WorldSession::SendExternalMails()
{
    sLog->outCommand(0, "EXTERNAL MAIL> Sending mails in queue...");

    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_GET_EXTERNAL_MAIL);
    PreparedQueryResult result = CharacterDatabase.Query(stmt);
    if (!result)
    {
        sLog->outCommand(0, "EXTERNAL MAIL> No mails in queue...");
        return;
    }

    SQLTransaction trans = CharacterDatabase.BeginTransaction();

    MailDraft* mail = NULL;

    do
    {
        Field *fields = result->Fetch();
        uint32 id = fields[0].GetUInt32();
        uint32 receiver_guid = fields[1].GetUInt32();
		ObjectGuid receiverGuid(HIGHGUID_PLAYER, receiver_guid);
        std::string subject = fields[2].GetString();
        std::string body = fields[3].GetString();
        uint32 money = fields[4].GetUInt32();
        uint32 itemId = fields[5].GetUInt32();
        uint32 itemCount = fields[6].GetUInt32();

		Player *receiver = ObjectAccessor::FindPlayer(receiverGuid);

        mail = new MailDraft(subject, body);

        if (money)
        {
            sLog->outCommand(0, "EXTERNAL MAIL> Adding money");
            mail->AddMoney(money);
        }

        if (itemId)
        {
            sLog->outCommand(0, "EXTERNAL MAIL> Adding %u of item with id %u", itemCount, itemId);
            Item* mailItem = Item::CreateItem(itemId, itemCount);
            mailItem->SaveToDB(trans);
            mail->AddItem(mailItem);
        }

        mail->SendMailTo(trans, receiver ? receiver : MailReceiver(receiver_guid), MailSender(MAIL_NORMAL, 0, MAIL_STATIONERY_GM), MAIL_CHECK_MASK_RETURNED);
        delete mail;

        stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_EXTERNAL_MAIL);
        stmt->setUInt32(0, id);
        trans->Append(stmt);

        sLog->outCommand(0, "EXTERNAL MAIL> Mail sent");
    }
    while (result->NextRow());

    CharacterDatabase.CommitTransaction(trans);
    sLog->outCommand(0, "EXTERNAL MAIL> All Mails Sent...");
}
Exemple #2
0
void WorldSession::SendExternalMails()
{
    sLog.outDebug("External Mail - Send Mails from Queue...");
    QueryResult* result = CharacterDatabase.Query("SELECT id,receiver,subject,message,money,item,item_count FROM mail_external");
    if (!result)
    {
        sLog.outDebug("External Mail - No Mails in Queue...");
        return;
    }
    else
    {
        do
        {
            Field *fields = result->Fetch();
            uint32 id = fields[0].GetUInt32();
            Player *pReceiver = sObjectMgr.GetPlayer(fields[1].GetUInt64());
            std::string subject = fields[2].GetString();
            std::string message = fields[3].GetString();
            uint32 money = fields[4].GetUInt32();
            uint32 ItemID = fields[5].GetUInt32();
            uint32 ItemCount = fields[6].GetUInt32();

            if (pReceiver)
            {
                MailDraft draft;
                draft.SetSubjectAndBody(subject, message);
                MailSender sender(MAIL_NORMAL, pReceiver ? pReceiver->GetObjectGuid().GetCounter() : 0, MAIL_STATIONERY_GM);
                MailReceiver reciever(pReceiver, pReceiver->GetObjectGuid());

                sLog.outDebug("External Mail - Sending mail to %u, Item:%u", pReceiver->GetObjectGuid().GetCounter(), ItemID);
                uint32 itemTextId = !message.empty() ? sObjectMgr.CreateItemText(message) : 0;
                if (ItemID != 0)
                {
                    Item* ToMailItem = Item::CreateItem(ItemID, ItemCount, pReceiver);
                    if (ToMailItem)
                    {
                        ToMailItem->SaveToDB();
                        draft.AddItem(ToMailItem);
                    }
                    draft.SetMoney(money);
                }
                else
                    draft.SetMoney(money);

                draft.SendMailTo(reciever,sender,MAIL_CHECK_MASK_RETURNED);
                CharacterDatabase.PExecute("DELETE FROM mail_external WHERE id=%u", id);
            }
            else
                sLog.outDebug("External Mail - Mail with unknown player GUID %u in mail_external",fields[1].GetUInt32());
        }
        while(result->NextRow());
    }
    sLog.outDebug("External Mail - All Mails Sent...");
}
Exemple #3
0
void WorldSession::SendExternalMails()
{

    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_GET_EXTERNAL_MAIL);
    PreparedQueryResult result = CharacterDatabase.Query(stmt);
    if (!result)
    {
        return;
    }

    SQLTransaction trans = CharacterDatabase.BeginTransaction();

    MailDraft* mail = NULL;

    do
    {
        Field *fields = result->Fetch();
        uint32 id = fields[0].GetUInt32();
        uint32 receiver_guid = fields[1].GetUInt32();
        std::string subject = fields[2].GetString();
        std::string body = fields[3].GetString();
        uint32 money = fields[4].GetUInt32();
        uint32 itemId = fields[5].GetUInt32();
        uint32 itemCount = fields[6].GetUInt32();

        Player *receiver = sObjectMgr->GetPlayerByLowGUID(receiver_guid);

        mail = new MailDraft(subject, body);

        if (money)
        {
            mail->AddMoney(money);
        }

        if (itemId)
        {
            Item* mailItem = Item::CreateItem(itemId, itemCount);
            mailItem->SaveToDB(trans);
            mail->AddItem(mailItem);
        }

        mail->SendMailTo(trans, receiver ? receiver : MailReceiver(receiver_guid), MailSender(MAIL_NORMAL, 0, MAIL_STATIONERY_GM), MAIL_CHECK_MASK_RETURNED);
        delete mail;

        stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_EXTERNAL_MAIL);
        stmt->setUInt32(0, id);
        trans->Append(stmt);

    }
    while (result->NextRow());

    CharacterDatabase.CommitTransaction(trans);
}
    void SendExternalMails()
    {
        QueryResult result = CharacterDatabase.PQuery(CHAR_GET_EXTERNAL_MAIL);
        if (!result)
            return;

        SQLTransaction trans = CharacterDatabase.BeginTransaction();

        MailDraft* mail = NULL;

        do
        {
            Field *fields = result->Fetch();
            uint32 id = fields[0].GetUInt32();
            uint32 receiver_guid = fields[1].GetUInt32();
            std::string subject = fields[2].GetString();
            std::string body = fields[3].GetString();
            uint32 money = fields[4].GetUInt32();
            uint32 itemId = fields[5].GetUInt32();
            uint32 itemCount = fields[6].GetUInt32();

            Player* receiver = ObjectAccessor::FindPlayer(receiver_guid);

            mail = new MailDraft(subject, body);

            if (money)
                mail->AddMoney(money);

            if (itemId)
            {
                ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(itemId);
                if (pProto)
                {
                    Item* mailItem = Item::CreateItem(itemId, itemCount);
                    mailItem->SaveToDB(trans);
                    mail->AddItem(mailItem);
                }
                else
                    sLog->outError(LOG_FILTER_GENERAL, "EXTERNAL MAIL> Tried to add non-existing item with id %u, aborted", itemId);
            }

            mail->SendMailTo(trans, receiver ? receiver : MailReceiver(receiver_guid), MailSender(MAIL_NORMAL, 0, MAIL_STATIONERY_GM), MAIL_CHECK_MASK_RETURNED);
            delete mail;

            CharacterDatabase.PExecute(CHAR_DEL_EXTERNAL_MAIL, id);
        }
        while (result->NextRow());

        CharacterDatabase.CommitTransaction(trans);
    }
void MassMailMgr::Update(bool sendall /*= false*/)
{
    if (m_massMails.empty())
        { return; }

    uint32 maxcount = sWorld.getConfig(CONFIG_UINT32_MASS_MAILER_SEND_PER_TICK);

    do
    {
        MassMail& task = m_massMails.front();

        while (!task.m_receivers.empty() && (sendall || maxcount > 0))
        {
            uint32 receiver_lowguid = *task.m_receivers.begin();
            task.m_receivers.erase(task.m_receivers.begin());

            ObjectGuid receiver_guid = ObjectGuid(HIGHGUID_PLAYER, receiver_lowguid);
            Player* receiver = sObjectMgr.GetPlayer(receiver_guid);

            // last case. can be just send
            if (task.m_receivers.empty())
            {
                // prevent mail return
                task.m_protoMail->SendMailTo(MailReceiver(receiver, receiver_guid), task.m_sender, MAIL_CHECK_MASK_RETURNED);

                if (!sendall)
                    { --maxcount; }
                break;
            }

            // need clone draft
            MailDraft draft;
            draft.CloneFrom(*task.m_protoMail);

            // prevent mail return
            draft.SendMailTo(MailReceiver(receiver, receiver_guid), task.m_sender, MAIL_CHECK_MASK_RETURNED);

            if (!sendall)
                { --maxcount; }
        }

        if (task.m_receivers.empty())
            { m_massMails.pop_front(); }
    }
    while (!m_massMails.empty() && (sendall || maxcount > 0));
}
Exemple #6
0
void WorldSession::SendExternalMails()
{
    sLog->outString("EXTERNAL MAIL> Sending mails in queue...");
    QueryResult result = CharacterDatabase.Query("SELECT id,receiver,subject,message,money,item,item_count FROM mail_external");
    SQLTransaction trans = CharacterDatabase.BeginTransaction();
    if(!result)
    {
        sLog->outString("EXTERNAL MAIL> No mails in queue...");
//        delete result;
        return;
    }
    else
    {
        uint32 last_id = 0;
        MailDraft* mail = NULL;
        uint32 last_receiver_guid;

        do
        {
            Field *fields = result->Fetch();
            uint32 id = fields[0].GetUInt32();
            uint64 receiver_guid = fields[1].GetUInt64();
            std::string subject = fields[2].GetString();
            std::string body = fields[3].GetString();
            uint32 money = fields[4].GetUInt32();
            uint32 itemId = fields[5].GetUInt32();
            uint32 itemCount = fields[6].GetUInt32();

            Player *receiver = sObjectMgr->GetPlayer( receiver_guid );

            if (id != last_id)
            {
                // send mail
                if (last_id != 0)
                {
                    sLog->outString("EXTERNAL MAIL> Sending mail to character with guid %d", last_receiver_guid);
                    mail->SendMailTo(trans,MailReceiver(last_receiver_guid), MailSender(MAIL_NORMAL, 0, MAIL_STATIONERY_GM), MAIL_CHECK_MASK_RETURNED);
                    delete mail;
                    CharacterDatabase.PExecute("DELETE FROM mail_external WHERE id=%u", last_id);
                    sLog->outString("EXTERNAL MAIL> Mail sent");
                }

                //Create the maildraft
                mail = new MailDraft( subject, body );

                if(money)
                {
                    sLog->outString("EXTERNAL MAIL> Adding money");
                    mail->AddMoney(money);
                }
            }

            if (itemId)
            {
                sLog->outString("EXTERNAL MAIL> Adding %u of item with id %u", itemCount, itemId);
                Item* mailItem = Item::CreateItem( itemId, itemCount, receiver );
                mailItem->SaveToDB(trans);
                mail->AddItem(mailItem);
            }

            last_id = id;
            last_receiver_guid = receiver_guid;

        }
        while( result->NextRow() );

        // we only send a mail when mail_id!=last_mail_id, so we need to send the very last mail here:
        if (last_id != 0)
        {
            // send last mail
            sLog->outString("EXTERNAL MAIL> Sending mail to character with guid %d", last_receiver_guid);

            mail->SendMailTo(trans,MailReceiver(last_receiver_guid), MailSender(MAIL_NORMAL, 0, MAIL_STATIONERY_GM), MAIL_CHECK_MASK_RETURNED);
            delete mail;
            CharacterDatabase.PExecute("DELETE FROM mail_external WHERE id=%u", last_id);
            sLog->outString("EXTERNAL MAIL> Mail sent");
        }
    }

    CharacterDatabase.CommitTransaction(trans);
    sLog->outString("EXTERNAL MAIL> All Mails Sent...");
}