CalendarMgr Class Reference

#include "CalendarMgr.h"

Public Member Functions
void	LoadFromDB ()
CalendarEvent *	GetEvent (uint64 eventId, CalendarEventStore::iterator *it=nullptr)
CalendarEventStore const &	GetEvents () const
CalendarEventStore	GetEventsCreatedBy (ObjectGuid guid, bool includeGuildEvents=false)
CalendarEventStore	GetPlayerEvents (ObjectGuid guid)
CalendarEventStore	GetGuildEvents (uint32 guildId)
CalendarInvite *	GetInvite (uint64 inviteId) const
CalendarEventInviteStore const &	GetInvites () const
CalendarInviteStore const &	GetEventInvites (uint64 eventId)
CalendarInviteStore	GetPlayerInvites (ObjectGuid guid)
void	FreeEventId (uint64 id)
uint64	GetFreeEventId ()
void	FreeInviteId (uint64 id)
uint64	GetFreeInviteId ()
void	DeleteOldEvents ()
uint32	GetPlayerNumPending (ObjectGuid guid)
void	AddEvent (CalendarEvent *calendarEvent, CalendarSendEventType sendType)
CalendarEventStore::iterator	RemoveEvent (uint64 eventId, ObjectGuid remover)
CalendarEventStore::iterator	RemoveEvent (CalendarEvent *calendarEvent, ObjectGuid remover, CalendarEventStore::const_iterator *currIt=nullptr)
void	UpdateEvent (CalendarEvent *calendarEvent)
void	AddInvite (CalendarEvent *calendarEvent, CalendarInvite *invite, CharacterDatabaseTransaction trans=nullptr)
void	RemoveInvite (uint64 inviteId, uint64 eventId, ObjectGuid remover)
void	RemoveInvite (uint64 inviteId, uint64 eventId, uint64 remover)
void	UpdateInvite (CalendarInvite *invite, CharacterDatabaseTransaction trans=nullptr)
void	RemoveAllPlayerEventsAndInvites (ObjectGuid guid)
void	RemovePlayerGuildEventsAndSignups (ObjectGuid guid, uint32 guildId)
void	SendCalendarEvent (ObjectGuid guid, CalendarEvent const &calendarEvent, CalendarSendEventType sendType)
void	SendCalendarEventInvite (CalendarInvite const &invite)
void	SendCalendarEventInviteAlert (CalendarEvent const &calendarEvent, CalendarInvite const &invite)
void	SendCalendarEventInviteRemove (CalendarEvent const &calendarEvent, CalendarInvite const &invite, uint32 flags)
void	SendCalendarEventInviteRemoveAlert (ObjectGuid guid, CalendarEvent const &calendarEvent, CalendarInviteStatus status)
void	SendCalendarEventUpdateAlert (CalendarEvent const &calendarEvent, time_t oldEventTime)
void	SendCalendarEventStatus (CalendarEvent const &calendarEvent, CalendarInvite const &invite)
void	SendCalendarEventRemovedAlert (CalendarEvent const &calendarEvent)
void	SendCalendarEventModeratorStatusAlert (CalendarEvent const &calendarEvent, CalendarInvite const &invite)
void	SendCalendarClearPendingAction (ObjectGuid guid)
void	SendCalendarCommandResult (ObjectGuid guid, CalendarError err, char const *param=nullptr)
void	SendPacketToAllEventRelatives (WorldPacket packet, CalendarEvent const &calendarEvent)

Static Public Member Functions
static CalendarMgr *	instance ()

Private Member Functions
	CalendarMgr ()
	~CalendarMgr ()

Private Attributes
CalendarEventStore	_events
CalendarEventInviteStore	_invites
std::deque< uint64 >	_freeEventIds
std::deque< uint64 >	_freeInviteIds
uint64	_maxEventId
uint64	_maxInviteId

Detailed Description

Constructor & Destructor Documentation

CalendarMgr()

CalendarMgr::CalendarMgr ( )

private

: _maxEventId(0), _maxInviteId(0) { }

~CalendarMgr()

CalendarMgr::~CalendarMgr ( )

private

{
    for (CalendarEventStore::iterator itr = _events.begin(); itr != _events.end(); ++itr)
        delete *itr;
 
    for (CalendarEventInviteStore::iterator itr = _invites.begin(); itr != _invites.end(); ++itr)
        for (CalendarInviteStore::iterator itr2 = itr->second.begin(); itr2 != itr->second.end(); ++itr2)
            delete *itr2;
}

References _events, and _invites.

Member Function Documentation

AddEvent()

void CalendarMgr::AddEvent	(	CalendarEvent *	calendarEvent,
		CalendarSendEventType	sendType
	)

{
    _events.insert(calendarEvent);
    UpdateEvent(calendarEvent);
    SendCalendarEvent(calendarEvent->GetCreatorGUID(), *calendarEvent, sendType);
}

References _events, CalendarEvent::GetCreatorGUID(), SendCalendarEvent(), and UpdateEvent().

AddInvite()

void CalendarMgr::AddInvite	(	CalendarEvent *	calendarEvent,
		CalendarInvite *	invite,
		CharacterDatabaseTransaction	trans = nullptr
	)

{
    if (!calendarEvent->IsGuildAnnouncement())
        SendCalendarEventInvite(*invite);
 
    if (!calendarEvent->IsGuildEvent() || invite->GetInviteeGUID() == calendarEvent->GetCreatorGUID())
        SendCalendarEventInviteAlert(*calendarEvent, *invite);
 
    if (!calendarEvent->IsGuildAnnouncement())
    {
        _invites[invite->GetEventId()].push_back(invite);
        UpdateInvite(invite, trans);
    }
}

References _invites, CalendarEvent::GetCreatorGUID(), CalendarInvite::GetEventId(), CalendarInvite::GetInviteeGUID(), CalendarEvent::IsGuildAnnouncement(), CalendarEvent::IsGuildEvent(), SendCalendarEventInvite(), SendCalendarEventInviteAlert(), and UpdateInvite().

DeleteOldEvents()

void CalendarMgr::DeleteOldEvents

(

)

{
    time_t oldEventsTime = GameTime::GetGameTime().count() - CALENDAR_OLD_EVENTS_DELETION_TIME;
 
    for (CalendarEventStore::const_iterator itr = _events.begin(); itr != _events.end();)
    {
        if (CalendarEvent* event = *itr; event->GetEventTime() < oldEventsTime)
        {
            itr = RemoveEvent(event, ObjectGuid::Empty, &itr);
            continue;
        }
        ++itr;
    }
}

References _events, CALENDAR_OLD_EVENTS_DELETION_TIME, ObjectGuid::Empty, CalendarEvent::GetEventTime(), GameTime::GetGameTime(), and RemoveEvent().

FreeEventId()

void CalendarMgr::FreeEventId

(

uint64

id

)

{
    if (id == _maxEventId)
        --_maxEventId;
    else
        _freeEventIds.push_back(id);
}

References _freeEventIds, and _maxEventId.

FreeInviteId()

void CalendarMgr::FreeInviteId

(

uint64

id

)

{
    if (id == _maxInviteId)
        --_maxInviteId;
    else
        _freeInviteIds.push_back(id);
}

References _freeInviteIds, and _maxInviteId.

GetEvent()

CalendarEvent * CalendarMgr::GetEvent	(	uint64	eventId,
		CalendarEventStore::iterator *	it = nullptr
	)

{
    for (CalendarEventStore::iterator itr = _events.begin(); itr != _events.end(); ++itr)
        if ((*itr)->GetEventId() == eventId)
        {
            if (it)
                *it = itr;
 
            return *itr;
        }
 
    return nullptr;
}

References _events.

Referenced by GetPlayerEvents(), LoadFromDB(), RemoveEvent(), RemoveInvite(), RemovePlayerGuildEventsAndSignups(), and SendCalendarEventInvite().

GetEventInvites()

CalendarInviteStore const & CalendarMgr::GetEventInvites

(

uint64

eventId

)

{
    return _invites[eventId];
}

References _invites.

GetEvents()

CalendarEventStore const & CalendarMgr::GetEvents ( ) const

inline

{ return _events; }

References _events.

GetEventsCreatedBy()

CalendarEventStore CalendarMgr::GetEventsCreatedBy	(	ObjectGuid	guid,
		bool	includeGuildEvents = false
	)

{
    CalendarEventStore result;
    for (CalendarEventStore::const_iterator itr = _events.begin(); itr != _events.end(); ++itr)
        if ((*itr)->GetCreatorGUID() == guid && (includeGuildEvents || (!(*itr)->IsGuildEvent() && !(*itr)->IsGuildAnnouncement())))
            result.insert(*itr);
 
    return result;
}

References _events.

GetFreeEventId()

uint64 CalendarMgr::GetFreeEventId

(

)

{
    if (_freeEventIds.empty())
        return ++_maxEventId;
 
    uint64 eventId = _freeEventIds.front();
    _freeEventIds.pop_front();
    return eventId;
}

References _freeEventIds, and _maxEventId.

GetFreeInviteId()

uint64 CalendarMgr::GetFreeInviteId

(

)

{
    if (_freeInviteIds.empty())
        return ++_maxInviteId;
 
    uint64 inviteId = _freeInviteIds.front();
    _freeInviteIds.pop_front();
    return inviteId;
}

References _freeInviteIds, and _maxInviteId.

GetGuildEvents()

CalendarEventStore CalendarMgr::GetGuildEvents

(

uint32

guildId

)

{
    CalendarEventStore result;
 
    if (!guildId)
        return result;
 
    for (CalendarEventStore::const_iterator itr = _events.begin(); itr != _events.end(); ++itr)
        if ((*itr)->IsGuildEvent() || (*itr)->IsGuildAnnouncement())
            if ((*itr)->GetGuildId() == guildId)
                result.insert(*itr);
 
    return result;
}

References _events.

GetInvite()

CalendarInvite * CalendarMgr::GetInvite

(

uint64

inviteId

)

const

{
    for (CalendarEventInviteStore::const_iterator itr = _invites.begin(); itr != _invites.end(); ++itr)
        for (CalendarInviteStore::const_iterator itr2 = itr->second.begin(); itr2 != itr->second.end(); ++itr2)
            if ((*itr2)->GetInviteId() == inviteId)
                return *itr2;
 
    LOG_DEBUG("entities.unit", "CalendarMgr::GetInvite: [{}] not found!", inviteId);
    return nullptr;
}

References _invites, and LOG_DEBUG.

Referenced by LoadFromDB().

GetInvites()

CalendarEventInviteStore const & CalendarMgr::GetInvites ( ) const

inline

{ return _invites; }

References _invites.

GetPlayerEvents()

CalendarEventStore CalendarMgr::GetPlayerEvents

(

ObjectGuid

guid

)

{
    CalendarEventStore events;
 
    for (CalendarEventInviteStore::const_iterator itr = _invites.begin(); itr != _invites.end(); ++itr)
        for (CalendarInviteStore::const_iterator itr2 = itr->second.begin(); itr2 != itr->second.end(); ++itr2)
            if ((*itr2)->GetInviteeGUID() == guid)
                if (CalendarEvent* event = GetEvent(itr->first)) // nullptr check added as attempt to fix #11512
                    events.insert(event);
 
    if (Player* player = ObjectAccessor::FindConnectedPlayer(guid))
        if (player->GetGuildId())
            for (CalendarEventStore::const_iterator itr = _events.begin(); itr != _events.end(); ++itr)
                if ((*itr)->GetGuildId() == player->GetGuildId())
                    events.insert(*itr);
 
    return events;
}

References _events, _invites, ObjectAccessor::FindConnectedPlayer(), and GetEvent().

GetPlayerInvites()

CalendarInviteStore CalendarMgr::GetPlayerInvites

(

ObjectGuid

guid

)

{
    CalendarInviteStore invites;
 
    for (CalendarEventInviteStore::const_iterator itr = _invites.begin(); itr != _invites.end(); ++itr)
        for (CalendarInviteStore::const_iterator itr2 = itr->second.begin(); itr2 != itr->second.end(); ++itr2)
            if ((*itr2)->GetInviteeGUID() == guid)
                invites.push_back(*itr2);
 
    return invites;
}

References _invites.

Referenced by GetPlayerNumPending(), RemoveAllPlayerEventsAndInvites(), and RemovePlayerGuildEventsAndSignups().

GetPlayerNumPending()

uint32 CalendarMgr::GetPlayerNumPending

(

ObjectGuid

guid

)

{
    CalendarInviteStore const& invites = GetPlayerInvites(guid);
 
    uint32 pendingNum = 0;
    for (CalendarInviteStore::const_iterator itr = invites.begin(); itr != invites.end(); ++itr)
    {
        switch ((*itr)->GetStatus())
        {
            case CALENDAR_STATUS_INVITED:
            case CALENDAR_STATUS_TENTATIVE:
            case CALENDAR_STATUS_NOT_SIGNED_UP:
                ++pendingNum;
                break;
            default:
                break;
        }
    }
 
    return pendingNum;
}

References CALENDAR_STATUS_INVITED, CALENDAR_STATUS_NOT_SIGNED_UP, CALENDAR_STATUS_TENTATIVE, and GetPlayerInvites().

instance()

CalendarMgr * CalendarMgr::instance ( )

static

{
    static CalendarMgr instance;
    return &instance;
}

References instance().

Referenced by instance().

LoadFromDB()

void CalendarMgr::LoadFromDB

(

)

{
    uint32 count = 0;
    _maxEventId = 0;
    _maxInviteId = 0;
 
    //                                                       0   1        2      3            4     5        6          7      8
    if (QueryResult result = CharacterDatabase.Query("SELECT id, creator, title, description, type, dungeon, eventtime, flags, time2 FROM calendar_events"))
        do
        {
            Field* fields = result->Fetch();
 
            uint64 eventId          = fields[0].Get<uint64>();
            ObjectGuid creatorGUID  = ObjectGuid::Create<HighGuid::Player>(fields[1].Get<uint32>());
            std::string title       = fields[2].Get<std::string>();
            std::string description = fields[3].Get<std::string>();
            CalendarEventType type  = CalendarEventType(fields[4].Get<uint8>());
            int32 dungeonId         = fields[5].Get<int32>();
            uint32 eventTime        = fields[6].Get<uint32>();
            uint32 flags            = fields[7].Get<uint32>();
            uint32 timezoneTime     = fields[8].Get<uint32>();
            uint32 guildId = 0;
 
            if (flags & CALENDAR_FLAG_GUILD_EVENT || flags & CALENDAR_FLAG_WITHOUT_INVITES)
            {
                guildId = sCharacterCache->GetCharacterGuildIdByGuid(creatorGUID);
            }
 
            CalendarEvent* calendarEvent = new CalendarEvent(eventId, creatorGUID, guildId, type, dungeonId, time_t(eventTime), flags, time_t(timezoneTime), title, description);
            _events.insert(calendarEvent);
 
            _maxEventId = std::max(_maxEventId, eventId);
 
            ++count;
        } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} calendar events", count);
    count = 0;
 
    //                                                       0   1      2        3       4       5            6      7
    if (QueryResult result = CharacterDatabase.Query("SELECT id, event, invitee, sender, status, statustime, `rank`, text FROM calendar_invites"))
        do
        {
            Field* fields = result->Fetch();
 
            uint64 inviteId             = fields[0].Get<uint64>();
            uint64 eventId              = fields[1].Get<uint64>();
            ObjectGuid invitee          = ObjectGuid::Create<HighGuid::Player>(fields[2].Get<uint32>());
            ObjectGuid senderGUID       = ObjectGuid::Create<HighGuid::Player>(fields[3].Get<uint32>());
            CalendarInviteStatus status = CalendarInviteStatus(fields[4].Get<uint8>());
            uint32 statusTime           = fields[5].Get<uint32>();
            CalendarModerationRank rank = CalendarModerationRank(fields[6].Get<uint8>());
            std::string text            = fields[7].Get<std::string>();
 
            CalendarInvite* invite = new CalendarInvite(inviteId, eventId, invitee, senderGUID, time_t(statusTime), status, rank, text);
            _invites[eventId].push_back(invite);
 
            _maxInviteId = std::max(_maxInviteId, inviteId);
 
            ++count;
        } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} calendar invites", count);
    LOG_INFO("server.loading", " ");
 
    for (uint64 i = 1; i < _maxEventId; ++i)
        if (!GetEvent(i))
            _freeEventIds.push_back(i);
 
    for (uint64 i = 1; i < _maxInviteId; ++i)
        if (!GetInvite(i))
            _freeInviteIds.push_back(i);
}

References _events, _freeEventIds, _freeInviteIds, _invites, _maxEventId, _maxInviteId, CALENDAR_FLAG_GUILD_EVENT, CALENDAR_FLAG_WITHOUT_INVITES, CharacterDatabase, Field::Get(), GetEvent(), GetInvite(), LOG_INFO, and sCharacterCache.

RemoveAllPlayerEventsAndInvites()

void CalendarMgr::RemoveAllPlayerEventsAndInvites

(

ObjectGuid

guid

)

{
    for (CalendarEventStore::const_iterator itr = _events.begin(); itr != _events.end();)
    {
        if (CalendarEvent* event = *itr; event->GetCreatorGUID() == guid)
        {
            itr = RemoveEvent(event, ObjectGuid::Empty, &itr);
            continue;
        }
        ++itr;
    }
 
    CalendarInviteStore playerInvites = GetPlayerInvites(guid);
    for (CalendarInviteStore::const_iterator itr = playerInvites.begin(); itr != playerInvites.end(); ++itr)
        RemoveInvite((*itr)->GetInviteId(), (*itr)->GetEventId(), guid);
}

References _events, ObjectGuid::Empty, CalendarEvent::GetCreatorGUID(), GetPlayerInvites(), RemoveEvent(), and RemoveInvite().

RemoveEvent() [1/2]

CalendarEventStore::iterator CalendarMgr::RemoveEvent	(	CalendarEvent *	calendarEvent,
		ObjectGuid	remover,
		CalendarEventStore::const_iterator *	currIt = nullptr
	)

                                                                                                                                              {
    if (!calendarEvent)
    {
        SendCalendarCommandResult(remover, CALENDAR_ERROR_EVENT_INVALID);
        return _events.end();
    }
 
    SendCalendarEventRemovedAlert(*calendarEvent);
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
    CharacterDatabasePreparedStatement* stmt;
    MailDraft mail(calendarEvent->BuildCalendarMailSubject(remover), calendarEvent->BuildCalendarMailBody());
 
    CalendarInviteStore& eventInvites = _invites[calendarEvent->GetEventId()];
    for (std::size_t i = 0; i < eventInvites.size(); ++i)
    {
        CalendarInvite* invite = eventInvites[i];
        stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CALENDAR_INVITE);
        stmt->SetData(0, invite->GetInviteId());
        trans->Append(stmt);
 
        // guild events only? check invite status here?
        // When an event is deleted, all invited (accepted/declined? - verify) guildies are notified via in-game mail. (wowwiki)
        if (remover && invite->GetInviteeGUID() != remover)
            mail.SendMailTo(trans, MailReceiver(invite->GetInviteeGUID().GetCounter()), calendarEvent, MAIL_CHECK_MASK_COPIED);
 
        delete invite;
    }
 
    _invites.erase(calendarEvent->GetEventId());
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CALENDAR_EVENT);
    stmt->SetData(0, calendarEvent->GetEventId());
    trans->Append(stmt);
    CharacterDatabase.CommitTransaction(trans);
 
    if (currIt)
    {
        delete calendarEvent;
        return _events.erase(*currIt);
    }
 
    if (auto it = _events.find(calendarEvent); it != _events.end())
    {
        delete calendarEvent;
        return _events.erase(it);
    }
 
    delete calendarEvent;
    return _events.end();
}

References _events, _invites, CalendarEvent::BuildCalendarMailBody(), CalendarEvent::BuildCalendarMailSubject(), CALENDAR_ERROR_EVENT_INVALID, CHAR_DEL_CALENDAR_EVENT, CHAR_DEL_CALENDAR_INVITE, CharacterDatabase, ObjectGuid::GetCounter(), CalendarEvent::GetEventId(), CalendarInvite::GetInviteeGUID(), CalendarInvite::GetInviteId(), MAIL_CHECK_MASK_COPIED, SendCalendarCommandResult(), SendCalendarEventRemovedAlert(), MailDraft::SendMailTo(), and PreparedStatementBase::SetData().

RemoveEvent() [2/2]

CalendarEventStore::iterator CalendarMgr::RemoveEvent	(	uint64	eventId,
		ObjectGuid	remover
	)

{
    CalendarEventStore::iterator current;
    CalendarEvent* calendarEvent = GetEvent(eventId, &current);
 
    if (!calendarEvent)
    {
        SendCalendarCommandResult(remover, CALENDAR_ERROR_EVENT_INVALID);
        return _events.end();
    }
 
    CalendarEventStore::const_iterator constItr(current);
    return RemoveEvent(calendarEvent, remover, &constItr);
}

References _events, CALENDAR_ERROR_EVENT_INVALID, GetEvent(), RemoveEvent(), and SendCalendarCommandResult().

Referenced by DeleteOldEvents(), RemoveAllPlayerEventsAndInvites(), RemoveEvent(), and RemovePlayerGuildEventsAndSignups().

RemoveInvite() [1/2]

void CalendarMgr::RemoveInvite	(	uint64	inviteId,
		uint64	eventId,
		ObjectGuid	remover
	)

{
    CalendarEvent* calendarEvent = GetEvent(eventId);
 
    if (!calendarEvent)
        return;
 
    CalendarInviteStore::iterator itr = _invites[eventId].begin();
    for (; itr != _invites[eventId].end(); ++itr)
        if ((*itr)->GetInviteId() == inviteId)
            break;
 
    if (itr == _invites[eventId].end())
        return;
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CALENDAR_INVITE);
    stmt->SetData(0, (*itr)->GetInviteId());
    trans->Append(stmt);
    CharacterDatabase.CommitTransaction(trans);
 
    if (!calendarEvent->IsGuildEvent())
        SendCalendarEventInviteRemoveAlert((*itr)->GetInviteeGUID(), *calendarEvent, CALENDAR_STATUS_REMOVED);
 
    SendCalendarEventInviteRemove(*calendarEvent, **itr, calendarEvent->GetFlags());
 
    // we need to find out how to use CALENDAR_INVITE_REMOVED_MAIL_SUBJECT to force client to display different mail
    //if ((*itr)->GetInviteeGUID() != remover)
    //    MailDraft(calendarEvent->BuildCalendarMailSubject(remover), calendarEvent->BuildCalendarMailBody())
    //        .SendMailTo(trans, MailReceiver((*itr)->GetInvitee()), calendarEvent, MAIL_CHECK_MASK_COPIED);
 
    delete *itr;
    _invites[eventId].erase(itr);
}

References _invites, CALENDAR_STATUS_REMOVED, CHAR_DEL_CALENDAR_INVITE, CharacterDatabase, GetEvent(), CalendarEvent::GetFlags(), CalendarEvent::IsGuildEvent(), SendCalendarEventInviteRemove(), SendCalendarEventInviteRemoveAlert(), and PreparedStatementBase::SetData().

Referenced by RemoveAllPlayerEventsAndInvites(), and RemovePlayerGuildEventsAndSignups().

RemoveInvite() [2/2]

void CalendarMgr::RemoveInvite	(	uint64	inviteId,
		uint64	eventId,
		uint64	remover
	)

RemovePlayerGuildEventsAndSignups()

void CalendarMgr::RemovePlayerGuildEventsAndSignups	(	ObjectGuid	guid,
		uint32	guildId
	)

{
    for (CalendarEventStore::const_iterator itr = _events.begin(); itr != _events.end();)
    {
        if ((*itr)->GetCreatorGUID() == guid && ((*itr)->IsGuildEvent() || (*itr)->IsGuildAnnouncement()))
        {
            itr = RemoveEvent((*itr)->GetEventId(), guid);
            continue;
        }
        ++itr;
    }
 
    CalendarInviteStore playerInvites = GetPlayerInvites(guid);
    for (CalendarInviteStore::const_iterator itr = playerInvites.begin(); itr != playerInvites.end(); ++itr)
        if (CalendarEvent* calendarEvent = GetEvent((*itr)->GetEventId(), nullptr))
            if (calendarEvent->IsGuildEvent() && calendarEvent->GetGuildId() == guildId)
                RemoveInvite((*itr)->GetInviteId(), (*itr)->GetEventId(), guid);
}

References _events, GetEvent(), GetPlayerInvites(), RemoveEvent(), and RemoveInvite().

SendCalendarClearPendingAction()

void CalendarMgr::SendCalendarClearPendingAction

(

ObjectGuid

guid

)

{
    if (Player* player = ObjectAccessor::FindConnectedPlayer(guid))
    {
        WorldPacket data(SMSG_CALENDAR_CLEAR_PENDING_ACTION, 0);
        player->SendDirectMessage(&data);
    }
}

References ObjectAccessor::FindConnectedPlayer(), and SMSG_CALENDAR_CLEAR_PENDING_ACTION.

SendCalendarCommandResult()

void CalendarMgr::SendCalendarCommandResult	(	ObjectGuid	guid,
		CalendarError	err,
		char const *	param = nullptr
	)

{
    if (Player* player = ObjectAccessor::FindConnectedPlayer(guid))
    {
        WorldPacket data(SMSG_CALENDAR_COMMAND_RESULT, 0);
        data << uint32(0);
        data << uint8(0);
        switch (err)
        {
            case CALENDAR_ERROR_OTHER_INVITES_EXCEEDED:
            case CALENDAR_ERROR_ALREADY_INVITED_TO_EVENT_S:
            case CALENDAR_ERROR_IGNORING_YOU_S:
                data << param;
                break;
            default:
                data << uint8(0);
                break;
        }
 
        data << uint32(err);
 
        player->SendDirectMessage(&data);
    }
}

References CALENDAR_ERROR_ALREADY_INVITED_TO_EVENT_S, CALENDAR_ERROR_IGNORING_YOU_S, CALENDAR_ERROR_OTHER_INVITES_EXCEEDED, ObjectAccessor::FindConnectedPlayer(), and SMSG_CALENDAR_COMMAND_RESULT.

Referenced by RemoveEvent(), and RemoveEvent().

SendCalendarEvent()

void CalendarMgr::SendCalendarEvent	(	ObjectGuid	guid,
		CalendarEvent const &	calendarEvent,
		CalendarSendEventType	sendType
	)

{
    Player* player = ObjectAccessor::FindConnectedPlayer(guid);
    if (!player)
        return;
 
    CalendarInviteStore const& eventInviteeList = _invites[calendarEvent.GetEventId()];
 
    WorldPacket data(SMSG_CALENDAR_SEND_EVENT, 60 + eventInviteeList.size() * 32);
    data << uint8(sendType);
    data << calendarEvent.GetCreatorGUID().WriteAsPacked();
    data << uint64(calendarEvent.GetEventId());
    data << calendarEvent.GetTitle();
    data << calendarEvent.GetDescription();
    data << uint8(calendarEvent.GetType());
    data << uint8(CALENDAR_REPEAT_NEVER);   // repeatable
    data << uint32(CALENDAR_MAX_INVITES);
    data << int32(calendarEvent.GetDungeonId());
    data << uint32(calendarEvent.GetFlags());
    data.AppendPackedTime(calendarEvent.GetEventTime());
    data.AppendPackedTime(calendarEvent.GetTimeZoneTime());
    data << uint32(calendarEvent.GetGuildId());
 
    data << uint32(eventInviteeList.size());
    for (CalendarInviteStore::const_iterator itr = eventInviteeList.begin(); itr != eventInviteeList.end(); ++itr)
    {
        CalendarInvite const* calendarInvite = (*itr);
        ObjectGuid inviteeGuid = calendarInvite->GetInviteeGUID();
        Player* invitee = ObjectAccessor::FindConnectedPlayer(inviteeGuid);
 
        uint8 inviteeLevel = invitee ? invitee->GetLevel() : sCharacterCache->GetCharacterLevelByGuid(inviteeGuid);
        uint32 inviteeGuildId = invitee ? invitee->GetGuildId() : sCharacterCache->GetCharacterGuildIdByGuid(inviteeGuid);
 
        data << inviteeGuid.WriteAsPacked();
        data << uint8(inviteeLevel);
        data << uint8(calendarInvite->GetStatus());
        data << uint8(calendarInvite->GetRank());
        data << uint8(calendarEvent.IsGuildEvent() && calendarEvent.GetGuildId() == inviteeGuildId);
        data << uint64(calendarInvite->GetInviteId());
        data.AppendPackedTime(calendarInvite->GetStatusTime());
        data << calendarInvite->GetText();
    }
 
    player->SendDirectMessage(&data);
}

References _invites, ByteBuffer::AppendPackedTime(), CALENDAR_MAX_INVITES, CALENDAR_REPEAT_NEVER, ObjectAccessor::FindConnectedPlayer(), CalendarEvent::GetCreatorGUID(), CalendarEvent::GetDescription(), CalendarEvent::GetDungeonId(), CalendarEvent::GetEventId(), CalendarEvent::GetEventTime(), CalendarEvent::GetFlags(), CalendarEvent::GetGuildId(), Player::GetGuildId(), CalendarInvite::GetInviteeGUID(), CalendarInvite::GetInviteId(), Unit::GetLevel(), CalendarInvite::GetRank(), CalendarInvite::GetStatus(), CalendarInvite::GetStatusTime(), CalendarInvite::GetText(), CalendarEvent::GetTimeZoneTime(), CalendarEvent::GetTitle(), CalendarEvent::GetType(), CalendarEvent::IsGuildEvent(), sCharacterCache, Player::SendDirectMessage(), SMSG_CALENDAR_SEND_EVENT, and ObjectGuid::WriteAsPacked().

Referenced by AddEvent().

SendCalendarEventInvite()

void CalendarMgr::SendCalendarEventInvite

(

CalendarInvite const &

invite

)

{
    CalendarEvent* calendarEvent = GetEvent(invite.GetEventId());
    time_t statusTime = invite.GetStatusTime();
    bool hasStatusTime = statusTime != 946684800;   // 01/01/2000 00:00:00
 
    ObjectGuid invitee = invite.GetInviteeGUID();
    Player* player = ObjectAccessor::FindConnectedPlayer(invitee);
 
    uint8 level = player ? player->GetLevel() : sCharacterCache->GetCharacterLevelByGuid(invitee);
 
    WorldPacket data(SMSG_CALENDAR_EVENT_INVITE, 8 + 8 + 8 + 1 + 1 + 1 + (statusTime ? 4 : 0) + 1);
    data << invitee.WriteAsPacked();
    data << uint64(invite.GetEventId());
    data << uint64(invite.GetInviteId());
    data << uint8(level);
    data << uint8(invite.GetStatus());
    data << uint8(hasStatusTime);
    if (hasStatusTime)
        data.AppendPackedTime(statusTime);
    data << uint8(invite.GetSenderGUID() != invite.GetInviteeGUID()); // false only if the invite is sign-up
 
    if (!calendarEvent) // Pre-invite
    {
        if (Player* player = ObjectAccessor::FindConnectedPlayer(invite.GetSenderGUID()))
            player->SendDirectMessage(&data);
    }
    else
    {
        if (calendarEvent->GetCreatorGUID() != invite.GetInviteeGUID()) // correct?
            SendPacketToAllEventRelatives(data, *calendarEvent);
    }
}

References ByteBuffer::AppendPackedTime(), ObjectAccessor::FindConnectedPlayer(), CalendarEvent::GetCreatorGUID(), GetEvent(), CalendarInvite::GetEventId(), CalendarInvite::GetInviteeGUID(), CalendarInvite::GetInviteId(), Unit::GetLevel(), CalendarInvite::GetSenderGUID(), CalendarInvite::GetStatus(), CalendarInvite::GetStatusTime(), sCharacterCache, Player::SendDirectMessage(), SendPacketToAllEventRelatives(), SMSG_CALENDAR_EVENT_INVITE, and ObjectGuid::WriteAsPacked().

Referenced by AddInvite().

SendCalendarEventInviteAlert()

void CalendarMgr::SendCalendarEventInviteAlert	(	CalendarEvent const &	calendarEvent,
		CalendarInvite const &	invite
	)

{
    WorldPacket data(SMSG_CALENDAR_EVENT_INVITE_ALERT);
    data << uint64(calendarEvent.GetEventId());
    data << calendarEvent.GetTitle();
    data.AppendPackedTime(calendarEvent.GetEventTime());
    data << uint32(calendarEvent.GetFlags());
    data << uint32(calendarEvent.GetType());
    data << int32(calendarEvent.GetDungeonId());
    data << uint64(invite.GetInviteId());
    data << uint8(invite.GetStatus());
    data << uint8(invite.GetRank());
    data << calendarEvent.GetCreatorGUID().WriteAsPacked();
    data << invite.GetSenderGUID().WriteAsPacked();
 
    if (calendarEvent.IsGuildEvent() || calendarEvent.IsGuildAnnouncement())
    {
        if (Guild* guild = sGuildMgr->GetGuildById(calendarEvent.GetGuildId()))
            guild->BroadcastPacket(&data);
    }
    else if (Player* player = ObjectAccessor::FindConnectedPlayer(invite.GetInviteeGUID()))
        player->SendDirectMessage(&data);
}

References ByteBuffer::AppendPackedTime(), ObjectAccessor::FindConnectedPlayer(), CalendarEvent::GetCreatorGUID(), CalendarEvent::GetDungeonId(), CalendarEvent::GetEventId(), CalendarEvent::GetEventTime(), CalendarEvent::GetFlags(), CalendarEvent::GetGuildId(), CalendarInvite::GetInviteeGUID(), CalendarInvite::GetInviteId(), CalendarInvite::GetRank(), CalendarInvite::GetSenderGUID(), CalendarInvite::GetStatus(), CalendarEvent::GetTitle(), CalendarEvent::GetType(), CalendarEvent::IsGuildAnnouncement(), CalendarEvent::IsGuildEvent(), sGuildMgr, SMSG_CALENDAR_EVENT_INVITE_ALERT, and ObjectGuid::WriteAsPacked().

Referenced by AddInvite().

SendCalendarEventInviteRemove()

void CalendarMgr::SendCalendarEventInviteRemove	(	CalendarEvent const &	calendarEvent,
		CalendarInvite const &	invite,
		uint32	flags
	)

{
    WorldPacket data(SMSG_CALENDAR_EVENT_INVITE_REMOVED, 8 + 4 + 4 + 1);
    data<< invite.GetInviteeGUID().WriteAsPacked();
    data << uint64(invite.GetEventId());
    data << uint32(flags);
    data << uint8(1); // FIXME
 
    SendPacketToAllEventRelatives(data, calendarEvent);
}

References CalendarInvite::GetEventId(), CalendarInvite::GetInviteeGUID(), SendPacketToAllEventRelatives(), SMSG_CALENDAR_EVENT_INVITE_REMOVED, and ObjectGuid::WriteAsPacked().

Referenced by RemoveInvite().

SendCalendarEventInviteRemoveAlert()

void CalendarMgr::SendCalendarEventInviteRemoveAlert	(	ObjectGuid	guid,
		CalendarEvent const &	calendarEvent,
		CalendarInviteStatus	status
	)

{
    if (Player* player = ObjectAccessor::FindConnectedPlayer(guid))
    {
        WorldPacket data(SMSG_CALENDAR_EVENT_INVITE_REMOVED_ALERT, 8 + 4 + 4 + 1);
        data << uint64(calendarEvent.GetEventId());
        data.AppendPackedTime(calendarEvent.GetEventTime());
        data << uint32(calendarEvent.GetFlags());
        data << uint8(status);
 
        player->SendDirectMessage(&data);
    }
}

References ByteBuffer::AppendPackedTime(), ObjectAccessor::FindConnectedPlayer(), CalendarEvent::GetEventId(), CalendarEvent::GetEventTime(), CalendarEvent::GetFlags(), and SMSG_CALENDAR_EVENT_INVITE_REMOVED_ALERT.

Referenced by RemoveInvite().

SendCalendarEventModeratorStatusAlert()

void CalendarMgr::SendCalendarEventModeratorStatusAlert	(	CalendarEvent const &	calendarEvent,
		CalendarInvite const &	invite
	)

{
    WorldPacket data(SMSG_CALENDAR_EVENT_MODERATOR_STATUS_ALERT, 8 + 8 + 1 + 1);
    data << invite.GetInviteeGUID().WriteAsPacked();
    data << uint64(invite.GetEventId());
    data << uint8(invite.GetRank());
    data << uint8(1); // Unk boolean - Display to client?
 
    SendPacketToAllEventRelatives(data, calendarEvent);
}

References CalendarInvite::GetEventId(), CalendarInvite::GetInviteeGUID(), CalendarInvite::GetRank(), SendPacketToAllEventRelatives(), SMSG_CALENDAR_EVENT_MODERATOR_STATUS_ALERT, and ObjectGuid::WriteAsPacked().

SendCalendarEventRemovedAlert()

void CalendarMgr::SendCalendarEventRemovedAlert

(

CalendarEvent const &

calendarEvent

)

{
    WorldPacket data(SMSG_CALENDAR_EVENT_REMOVED_ALERT, 1 + 8 + 1);
    data << uint8(1); // FIXME: If true does not SignalEvent(EVENT_CALENDAR_ACTION_PENDING)
    data << uint64(calendarEvent.GetEventId());
    data.AppendPackedTime(calendarEvent.GetEventTime());
 
    SendPacketToAllEventRelatives(data, calendarEvent);
}

References ByteBuffer::AppendPackedTime(), CalendarEvent::GetEventId(), CalendarEvent::GetEventTime(), SendPacketToAllEventRelatives(), and SMSG_CALENDAR_EVENT_REMOVED_ALERT.

Referenced by RemoveEvent().

SendCalendarEventStatus()

void CalendarMgr::SendCalendarEventStatus	(	CalendarEvent const &	calendarEvent,
		CalendarInvite const &	invite
	)

{
    WorldPacket data(SMSG_CALENDAR_EVENT_STATUS, 8 + 8 + 4 + 4 + 1 + 1 + 4);
    data << invite.GetInviteeGUID().WriteAsPacked();
    data << uint64(calendarEvent.GetEventId());
    data.AppendPackedTime(calendarEvent.GetEventTime());
    data << uint32(calendarEvent.GetFlags());
    data << uint8(invite.GetStatus());
    data << uint8(invite.GetRank());
    data.AppendPackedTime(invite.GetStatusTime());
 
    SendPacketToAllEventRelatives(data, calendarEvent);
}

References ByteBuffer::AppendPackedTime(), CalendarEvent::GetEventId(), CalendarEvent::GetEventTime(), CalendarEvent::GetFlags(), CalendarInvite::GetInviteeGUID(), CalendarInvite::GetRank(), CalendarInvite::GetStatus(), CalendarInvite::GetStatusTime(), SendPacketToAllEventRelatives(), SMSG_CALENDAR_EVENT_STATUS, and ObjectGuid::WriteAsPacked().

SendCalendarEventUpdateAlert()

void CalendarMgr::SendCalendarEventUpdateAlert	(	CalendarEvent const &	calendarEvent,
		time_t	oldEventTime
	)

{
    WorldPacket data(SMSG_CALENDAR_EVENT_UPDATED_ALERT, 1 + 8 + 4 + 4 + 4 + 1 + 4 +
                     calendarEvent.GetTitle().size() + calendarEvent.GetDescription().size() + 1 + 4 + 4);
    data << uint8(1);       // unk
    data << uint64(calendarEvent.GetEventId());
    data.AppendPackedTime(oldEventTime);
    data << uint32(calendarEvent.GetFlags());
    data.AppendPackedTime(calendarEvent.GetEventTime());
    data << uint8(calendarEvent.GetType());
    data << int32(calendarEvent.GetDungeonId());
    data << calendarEvent.GetTitle();
    data << calendarEvent.GetDescription();
    data << uint8(CALENDAR_REPEAT_NEVER);   // repeatable
    data << uint32(CALENDAR_MAX_INVITES);
    data << uint32(0);      // unk
 
    SendPacketToAllEventRelatives(data, calendarEvent);
}

References ByteBuffer::AppendPackedTime(), CALENDAR_MAX_INVITES, CALENDAR_REPEAT_NEVER, CalendarEvent::GetDescription(), CalendarEvent::GetDungeonId(), CalendarEvent::GetEventId(), CalendarEvent::GetEventTime(), CalendarEvent::GetFlags(), CalendarEvent::GetTitle(), CalendarEvent::GetType(), SendPacketToAllEventRelatives(), and SMSG_CALENDAR_EVENT_UPDATED_ALERT.

SendPacketToAllEventRelatives()

void CalendarMgr::SendPacketToAllEventRelatives	(	WorldPacket	packet,
		CalendarEvent const &	calendarEvent
	)

{
    // Send packet to all guild members
    if (calendarEvent.IsGuildEvent() || calendarEvent.IsGuildAnnouncement())
        if (Guild* guild = sGuildMgr->GetGuildById(calendarEvent.GetGuildId()))
            guild->BroadcastPacket(&packet);
 
    // Send packet to all invitees if event is non-guild, in other case only to non-guild invitees (packet was broadcasted for them)
    CalendarInviteStore invites = _invites[calendarEvent.GetEventId()];
    for (CalendarInviteStore::iterator itr = invites.begin(); itr != invites.end(); ++itr)
        if (Player* player = ObjectAccessor::FindConnectedPlayer((*itr)->GetInviteeGUID()))
            if (!calendarEvent.IsGuildEvent() || player->GetGuildId() != calendarEvent.GetGuildId())
                player->SendDirectMessage(&packet);
}

References _invites, ObjectAccessor::FindConnectedPlayer(), CalendarEvent::GetEventId(), CalendarEvent::GetGuildId(), CalendarEvent::IsGuildAnnouncement(), CalendarEvent::IsGuildEvent(), and sGuildMgr.

Referenced by SendCalendarEventInvite(), SendCalendarEventInviteRemove(), SendCalendarEventModeratorStatusAlert(), SendCalendarEventRemovedAlert(), SendCalendarEventStatus(), and SendCalendarEventUpdateAlert().

UpdateEvent()

void CalendarMgr::UpdateEvent

(

CalendarEvent *

calendarEvent

)

{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_CALENDAR_EVENT);
    stmt->SetData(0, calendarEvent->GetEventId());
    stmt->SetData(1, calendarEvent->GetCreatorGUID().GetCounter());
    stmt->SetData(2, calendarEvent->GetTitle());
    stmt->SetData(3, calendarEvent->GetDescription());
    stmt->SetData(4, calendarEvent->GetType());
    stmt->SetData(5, calendarEvent->GetDungeonId());
    stmt->SetData(6, uint32(calendarEvent->GetEventTime()));
    stmt->SetData(7, calendarEvent->GetFlags());
    stmt->SetData(8, (int64)calendarEvent->GetTimeZoneTime()); // correct?
    CharacterDatabase.Execute(stmt);
}

References CHAR_REP_CALENDAR_EVENT, CharacterDatabase, ObjectGuid::GetCounter(), CalendarEvent::GetCreatorGUID(), CalendarEvent::GetDescription(), CalendarEvent::GetDungeonId(), CalendarEvent::GetEventId(), CalendarEvent::GetEventTime(), CalendarEvent::GetFlags(), CalendarEvent::GetTimeZoneTime(), CalendarEvent::GetTitle(), CalendarEvent::GetType(), and PreparedStatementBase::SetData().

Referenced by AddEvent().

UpdateInvite()

void CalendarMgr::UpdateInvite	(	CalendarInvite *	invite,
		CharacterDatabaseTransaction	trans = nullptr
	)

{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_CALENDAR_INVITE);
    stmt->SetData(0, invite->GetInviteId());
    stmt->SetData(1, invite->GetEventId());
    stmt->SetData(2, invite->GetInviteeGUID().GetCounter());
    stmt->SetData(3, invite->GetSenderGUID().GetCounter());
    stmt->SetData(4, invite->GetStatus());
    stmt->SetData(5, uint32(invite->GetStatusTime()));
    stmt->SetData(6, invite->GetRank());
    stmt->SetData(7, invite->GetText());
    CharacterDatabase.ExecuteOrAppend(trans, stmt);
}

References CHAR_REP_CALENDAR_INVITE, CharacterDatabase, ObjectGuid::GetCounter(), CalendarInvite::GetEventId(), CalendarInvite::GetInviteeGUID(), CalendarInvite::GetInviteId(), CalendarInvite::GetRank(), CalendarInvite::GetSenderGUID(), CalendarInvite::GetStatus(), CalendarInvite::GetStatusTime(), CalendarInvite::GetText(), and PreparedStatementBase::SetData().

Referenced by AddInvite().

Member Data Documentation

_events

CalendarEventStore CalendarMgr::_events

private

Referenced by AddEvent(), DeleteOldEvents(), GetEvent(), GetEvents(), GetEventsCreatedBy(), GetGuildEvents(), GetPlayerEvents(), LoadFromDB(), RemoveAllPlayerEventsAndInvites(), RemoveEvent(), RemoveEvent(), RemovePlayerGuildEventsAndSignups(), and ~CalendarMgr().

_freeEventIds

std::deque<uint64> CalendarMgr::_freeEventIds

private

Referenced by FreeEventId(), GetFreeEventId(), and LoadFromDB().

_freeInviteIds

std::deque<uint64> CalendarMgr::_freeInviteIds

private

Referenced by FreeInviteId(), GetFreeInviteId(), and LoadFromDB().

_invites

CalendarEventInviteStore CalendarMgr::_invites

private

Referenced by AddInvite(), GetEventInvites(), GetInvite(), GetInvites(), GetPlayerEvents(), GetPlayerInvites(), LoadFromDB(), RemoveEvent(), RemoveInvite(), SendCalendarEvent(), SendPacketToAllEventRelatives(), and ~CalendarMgr().

_maxEventId

uint64 CalendarMgr::_maxEventId

private

Referenced by FreeEventId(), GetFreeEventId(), and LoadFromDB().

_maxInviteId

uint64 CalendarMgr::_maxInviteId

private

Referenced by FreeInviteId(), GetFreeInviteId(), and LoadFromDB().

---

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

• azerothcore-wotlk/src/server/game/Calendar/CalendarMgr.h
• azerothcore-wotlk/src/server/game/Calendar/CalendarMgr.cpp