CalendarMgr.h

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef TRINITY_CALENDARMGR_H
#define TRINITY_CALENDARMGR_H
 
#include "Common.h"
#include "DatabaseEnvFwd.h"
#include "ObjectGuid.h"
#include <deque>
#include <map>
#include <set>
#include <vector>
 
class Player;
class WorldPacket;
 
enum CalendarMailAnswers
{
    // else
    CALENDAR_EVENT_REMOVED_MAIL_SUBJECT     = 0,
    // if ( *(_DWORD *)(a1 + 8292) & 0x100 )
    CALENDAR_INVITE_REMOVED_MAIL_SUBJECT    = 0x100
};
 
enum CalendarFlags
{
    CALENDAR_FLAG_ALL_ALLOWED       = 0x001,
    CALENDAR_FLAG_INVITES_LOCKED    = 0x010,
    CALENDAR_FLAG_WITHOUT_INVITES   = 0x040,
    CALENDAR_FLAG_GUILD_EVENT       = 0x400
};
 
enum CalendarModerationRank
{
    CALENDAR_RANK_PLAYER            = 0,
    CALENDAR_RANK_MODERATOR         = 1,
    CALENDAR_RANK_OWNER             = 2
};
 
enum CalendarSendEventType
{
    CALENDAR_SENDTYPE_GET           = 0,
    CALENDAR_SENDTYPE_ADD           = 1,
    CALENDAR_SENDTYPE_COPY          = 2
};
 
enum CalendarEventType
{
    CALENDAR_TYPE_RAID              = 0,
    CALENDAR_TYPE_DUNGEON           = 1,
    CALENDAR_TYPE_PVP               = 2,
    CALENDAR_TYPE_MEETING           = 3,
    CALENDAR_TYPE_OTHER             = 4,
    CALENDAR_TYPE_HEROIC            = 5
};
 
enum CalendarRepeatType
{
    CALENDAR_REPEAT_NEVER           = 0,
    CALENDAR_REPEAT_WEEKLY          = 1,
    CALENDAR_REPEAT_BIWEEKLY        = 2,
    CALENDAR_REPEAT_MONTHLY         = 3
};
 
enum CalendarInviteStatus
{
    CALENDAR_STATUS_INVITED         = 0,
    CALENDAR_STATUS_ACCEPTED        = 1,
    CALENDAR_STATUS_DECLINED        = 2,
    CALENDAR_STATUS_CONFIRMED       = 3,
    CALENDAR_STATUS_OUT             = 4,
    CALENDAR_STATUS_STANDBY         = 5,
    CALENDAR_STATUS_SIGNED_UP       = 6,
    CALENDAR_STATUS_NOT_SIGNED_UP   = 7,
    CALENDAR_STATUS_TENTATIVE       = 8,
    CALENDAR_STATUS_REMOVED         = 9     // correct name?
};
 
enum CalendarError
{
    CALENDAR_OK                                 = 0,
    CALENDAR_ERROR_GUILD_EVENTS_EXCEEDED        = 1,
    CALENDAR_ERROR_EVENTS_EXCEEDED              = 2,
    CALENDAR_ERROR_SELF_INVITES_EXCEEDED        = 3,
    CALENDAR_ERROR_OTHER_INVITES_EXCEEDED       = 4,
    CALENDAR_ERROR_PERMISSIONS                  = 5,
    CALENDAR_ERROR_EVENT_INVALID                = 6,
    CALENDAR_ERROR_NOT_INVITED                  = 7,
    CALENDAR_ERROR_INTERNAL                     = 8,
    CALENDAR_ERROR_GUILD_PLAYER_NOT_IN_GUILD    = 9,
    CALENDAR_ERROR_ALREADY_INVITED_TO_EVENT_S   = 10,
    CALENDAR_ERROR_PLAYER_NOT_FOUND             = 11,
    CALENDAR_ERROR_NOT_ALLIED                   = 12,
    CALENDAR_ERROR_IGNORING_YOU_S               = 13,
    CALENDAR_ERROR_INVITES_EXCEEDED             = 14,
    CALENDAR_ERROR_INVALID_DATE                 = 16,
    CALENDAR_ERROR_INVALID_TIME                 = 17,
 
    CALENDAR_ERROR_NEEDS_TITLE                  = 19,
    CALENDAR_ERROR_EVENT_PASSED                 = 20,
    CALENDAR_ERROR_EVENT_LOCKED                 = 21,
    CALENDAR_ERROR_DELETE_CREATOR_FAILED        = 22,
    CALENDAR_ERROR_SYSTEM_DISABLED              = 24,
    CALENDAR_ERROR_RESTRICTED_ACCOUNT           = 25,
    CALENDAR_ERROR_ARENA_EVENTS_EXCEEDED        = 26,
    CALENDAR_ERROR_RESTRICTED_LEVEL             = 27,
    CALENDAR_ERROR_USER_SQUELCHED               = 28,
    CALENDAR_ERROR_NO_INVITE                    = 29,
 
    CALENDAR_ERROR_EVENT_WRONG_SERVER           = 36,
    CALENDAR_ERROR_INVITE_WRONG_SERVER          = 37,
    CALENDAR_ERROR_NO_GUILD_INVITES             = 38,
    CALENDAR_ERROR_INVALID_SIGNUP               = 39,
    CALENDAR_ERROR_NO_MODERATOR                 = 40
};
 
enum CalendarLimits
{
    CALENDAR_MAX_EVENTS = 30,
    CALENDAR_MAX_GUILD_EVENTS = 100,
    CALENDAR_MAX_INVITES = 100,
    CALENDAR_CREATE_EVENT_COOLDOWN = 5,
    CALENDAR_OLD_EVENTS_DELETION_TIME = 1 * MONTH,
};
 
#define CALENDAR_DEFAULT_RESPONSE_TIME  946684800 // 01/01/2000 00:00:00
 
struct TC_GAME_API CalendarInvite
{
    public:
        CalendarInvite(CalendarInvite const& calendarInvite, uint64 inviteId, uint64 eventId) : _inviteId(inviteId), _eventId(eventId),
            _invitee(calendarInvite.GetInviteeGUID()), _senderGUID(calendarInvite.GetSenderGUID()), _responseTime(calendarInvite.GetResponseTime()),
            _status(calendarInvite.GetStatus()), _rank(calendarInvite.GetRank()), _note(calendarInvite.GetNote())
        {
        }
 
        CalendarInvite();
 
        CalendarInvite(uint64 inviteId, uint64 eventId, ObjectGuid invitee, ObjectGuid senderGUID, time_t responseTime,
            CalendarInviteStatus status, CalendarModerationRank rank, std::string note) :
            _inviteId(inviteId), _eventId(eventId), _invitee(invitee), _senderGUID(senderGUID), _responseTime(responseTime),
            _status(status), _rank(rank), _note(std::move(note)) { }
 
        CalendarInvite(CalendarInvite const&) = delete;
        CalendarInvite(CalendarInvite&&) = delete;
 
        CalendarInvite& operator=(CalendarInvite const&) = delete;
        CalendarInvite& operator=(CalendarInvite&&) = delete;
 
        ~CalendarInvite();
 
        void SetInviteId(uint64 inviteId) { _inviteId = inviteId; }
        uint64 GetInviteId() const { return _inviteId; }
 
        void SetEventId(uint64 eventId) { _eventId = eventId; }
        uint64 GetEventId() const { return _eventId; }
 
        void SetSenderGUID(ObjectGuid guid) { _senderGUID = guid; }
        ObjectGuid GetSenderGUID() const { return _senderGUID; }
 
        void SetInvitee(ObjectGuid guid) { _invitee = guid; }
        ObjectGuid GetInviteeGUID() const { return _invitee; }
 
        void SetResponseTime(time_t responseTime) { _responseTime = responseTime; }
        time_t GetResponseTime() const { return _responseTime; }
 
        void SetNote(std::string const& note) { _note = note; }
        std::string GetNote() const { return _note; }
 
        void SetStatus(CalendarInviteStatus status) { _status = status; }
        CalendarInviteStatus GetStatus() const { return _status; }
 
        void SetRank(CalendarModerationRank rank) { _rank = rank; }
        CalendarModerationRank GetRank() const { return _rank; }
 
    private:
        uint64 _inviteId;
        uint64 _eventId;
        ObjectGuid _invitee;
        ObjectGuid _senderGUID;
        time_t _responseTime;
        CalendarInviteStatus _status;
        CalendarModerationRank _rank;
        std::string _note;
};
 
struct TC_GAME_API CalendarEvent
{
    public:
        CalendarEvent(CalendarEvent const& calendarEvent, uint64 eventId) : _eventId(eventId), _ownerGUID(calendarEvent.GetOwnerGUID()),
            _eventGuildId(calendarEvent.GetGuildId()), _eventType(calendarEvent.GetType()), _textureId(calendarEvent.GetTextureId()),
            _date(calendarEvent.GetDate()), _flags(calendarEvent.GetFlags()), _title(calendarEvent.GetTitle()), _description(calendarEvent.GetDescription()),
            _lockDate(calendarEvent.GetLockDate()) { }
 
        CalendarEvent(uint64 eventId, ObjectGuid ownerGUID, ObjectGuid::LowType guildId, CalendarEventType type, int32 textureId,
            time_t date, uint32 flags, std::string title, std::string description, time_t lockDate) :
            _eventId(eventId), _ownerGUID(ownerGUID), _eventGuildId(guildId), _eventType(type), _textureId(textureId),
            _date(date), _flags(flags), _title(std::move(title)), _description(std::move(description)), _lockDate(lockDate) { }
 
        CalendarEvent() : _eventId(1), _ownerGUID(), _eventGuildId(UI64LIT(0)), _eventType(CALENDAR_TYPE_OTHER), _textureId(-1), _date(0),
            _flags(0), _title(), _description(), _lockDate(0) { }
 
        CalendarEvent(CalendarEvent const&) = delete;
        CalendarEvent(CalendarEvent&&) = delete;
 
        CalendarEvent& operator=(CalendarEvent const&) = delete;
        CalendarEvent& operator=(CalendarEvent&&) = delete;
 
        ~CalendarEvent();
 
        void SetEventId(uint64 eventId) { _eventId = eventId; }
        uint64 GetEventId() const { return _eventId; }
 
        void SetOwnerGUID(ObjectGuid guid) { _ownerGUID = guid; }
        ObjectGuid GetOwnerGUID() const { return _ownerGUID; }
 
        void SetGuildId(ObjectGuid::LowType guildId) { _eventGuildId = guildId; }
        ObjectGuid::LowType GetGuildId() const { return _eventGuildId; }
 
        void SetTitle(std::string const& title) { _title = title; }
        std::string GetTitle() const { return _title; }
 
        void SetDescription(std::string const& description) { _description = description; }
        std::string GetDescription() const { return _description; }
 
        void SetType(CalendarEventType eventType) { _eventType = eventType; }
        CalendarEventType GetType() const { return _eventType; }
 
        void SetTextureId(int32 textureId) { _textureId = textureId; }
        int32 GetTextureId() const { return _textureId; }
 
        void SetDate(time_t date) { _date = date; }
        time_t GetDate() const { return _date; }
 
        void SetFlags(uint32 flags) { _flags = flags; }
        uint32 GetFlags() const { return _flags; }
 
        bool IsGuildEvent() const { return (_flags & CALENDAR_FLAG_GUILD_EVENT) != 0; }
        bool IsGuildAnnouncement() const { return (_flags & CALENDAR_FLAG_WITHOUT_INVITES) != 0; }
        bool IsLocked() const { return (_flags & CALENDAR_FLAG_INVITES_LOCKED) != 0; }
 
        void SetLockDate(time_t lockDate) { _lockDate = lockDate; }
        time_t GetLockDate() const { return _lockDate; }
 
        static bool IsGuildEvent(uint32 flags) { return (flags & CALENDAR_FLAG_GUILD_EVENT) != 0; }
        static bool IsGuildAnnouncement(uint32 flags) { return (flags & CALENDAR_FLAG_WITHOUT_INVITES) != 0; }
 
        std::string BuildCalendarMailSubject(ObjectGuid remover) const;
        std::string BuildCalendarMailBody(Player const* invitee) const;
 
    private:
        uint64 _eventId;
        ObjectGuid _ownerGUID;
        ObjectGuid::LowType _eventGuildId;
        CalendarEventType _eventType;
        int32 _textureId;
        time_t _date;
        uint32 _flags;
        std::string _title;
        std::string _description;
        time_t _lockDate;
};
typedef std::vector<CalendarInvite*> CalendarInviteStore;
typedef std::set<CalendarEvent*> CalendarEventStore;
typedef std::map<uint64 /* eventID */, CalendarInviteStore > CalendarEventInviteStore;
 
class TC_GAME_API CalendarMgr
{
    private:
        CalendarMgr();
        ~CalendarMgr();
 
        CalendarEventStore _events;
        CalendarEventInviteStore _invites;
 
        std::deque<uint64> _freeEventIds;
        std::deque<uint64> _freeInviteIds;
        uint64 _maxEventId;
        uint64 _maxInviteId;
 
    public:
        CalendarMgr(CalendarMgr const&) = delete;
        CalendarMgr(CalendarMgr&&) = delete;
 
        CalendarMgr& operator=(CalendarMgr const&) = delete;
        CalendarMgr& operator=(CalendarMgr&&) = delete;
 
        static CalendarMgr* instance();
 
        void LoadFromDB();
 
        CalendarEvent* GetEvent(uint64 eventId) const;
        CalendarEventStore const& GetEvents() const { return _events; }
        CalendarEventStore GetEventsCreatedBy(ObjectGuid guid, bool includeGuildEvents = false) const;
        CalendarEventStore GetPlayerEvents(ObjectGuid guid) const;
        CalendarEventStore GetGuildEvents(ObjectGuid::LowType guildId) const;
 
        CalendarInvite* GetInvite(uint64 inviteId) const;
        CalendarEventInviteStore const& GetInvites() const { return _invites; }
        CalendarInviteStore GetEventInvites(uint64 eventId) const;
        CalendarInviteStore GetPlayerInvites(ObjectGuid guid) const;
 
        void FreeEventId(uint64 id);
        uint64 GetFreeEventId();
        void FreeInviteId(uint64 id);
        uint64 GetFreeInviteId();
 
        void DeleteOldEvents();
 
        uint32 GetPlayerNumPending(ObjectGuid guid);
 
        void AddEvent(CalendarEvent* calendarEvent, CalendarSendEventType sendType);
        void RemoveEvent(uint64 eventId, ObjectGuid remover);
        void RemoveEvent(CalendarEvent* calendarEvent, ObjectGuid remover);
        void UpdateEvent(CalendarEvent* calendarEvent);
 
        void AddInvite(CalendarEvent* calendarEvent, CalendarInvite* invite, CharacterDatabaseTransaction trans = nullptr);
        void RemoveInvite(uint64 inviteId, uint64 eventId, ObjectGuid remover);
        void UpdateInvite(CalendarInvite* invite, CharacterDatabaseTransaction trans = nullptr);
 
        void RemoveAllPlayerEventsAndInvites(ObjectGuid guid);
        void RemovePlayerGuildEventsAndSignups(ObjectGuid guid, ObjectGuid::LowType guildId);
 
        void SendCalendarEvent(ObjectGuid guid, CalendarEvent const& calendarEvent, CalendarSendEventType sendType) const;
        void SendCalendarEventInvite(CalendarInvite const& invite) const;
        void SendCalendarEventInviteAlert(CalendarEvent const& calendarEvent, CalendarInvite const& invite) const;
        void SendCalendarEventInviteRemove(CalendarEvent const& calendarEvent, CalendarInvite const& invite, uint32 flags) const;
        void SendCalendarEventInviteRemoveAlert(ObjectGuid guid, CalendarEvent const& calendarEvent, CalendarInviteStatus status) const;
        void SendCalendarEventUpdateAlert(CalendarEvent const& calendarEvent, time_t originalDate) const;
        void SendCalendarEventStatus(CalendarEvent const& calendarEvent, CalendarInvite const& invite) const;
        void SendCalendarEventRemovedAlert(CalendarEvent const& calendarEvent) const;
        void SendCalendarEventModeratorStatusAlert(CalendarEvent const& calendarEvent, CalendarInvite const& invite) const;
        void SendCalendarClearPendingAction(ObjectGuid guid) const;
        void SendCalendarCommandResult(ObjectGuid guid, CalendarError err, char const* param = nullptr) const;
 
        void SendPacketToAllEventRelatives(WorldPacket const* packet, CalendarEvent const& calendarEvent) const;
        std::vector<Player*> GetAllEventRelatives(CalendarEvent const& calendarEvent) const;
};
 
#define sCalendarMgr CalendarMgr::instance()
 
#endif