Core/PacketIO: CalendarPackets:

CMSG_CALENDAR_GET
CMSG_CALENDAR_GET_EVENT
CMSG_CALENDAR_GUILD_FILTER
CMSG_CALENDAR_ADD_EVENT
CMSG_CALENDAR_UPDATE_EVENT
CMSG_CALENDAR_REMOVE_EVENT
CMSG_CALENDAR_COPY_EVENT
CMSG_CALENDAR_GET_NUM_PENDING
CMSG_CALENDAR_EVENT_SIGN_UP
CMSG_CALENDAR_REMOVE_INVITE
CMSG_CALENDAR_EVENT_STATUS
CMSG_SET_SAVED_INSTANCE_EXTEND
CMSG_CALENDAR_EVENT_MODERATOR_STATUS

SMSG_CALENDAR_EVENT_INVITE
SMSG_CALENDAR_SEND_CALENDAR
SMSG_CALENDAR_SEND_EVENT
SMSG_CALENDAR_EVENT_INVITE_ALERT
SMSG_CALENDAR_EVENT_INVITE_STATUS
SMSG_CALENDAR_EVENT_INVITE_REMOVED
SMSG_CALENDAR_EVENT_INVITE_MODERATOR_STATUS
SMSG_CALENDAR_EVENT_INVITE_REMOVED_ALERT
SMSG_CALENDAR_CLEAR_PENDING_ACTION
SMSG_CALENDAR_EVENT_UPDATED_ALERT
SMSG_CALENDAR_EVENT_REMOVED_ALERT
SMSG_CALENDAR_SEND_NUM_PENDING
SMSG_CALENDAR_COMMAND_RESULT
SMSG_CALENDAR_RAID_LOCKOUT_UPDATED
SMSG_CALENDAR_EVENT_INITIAL_INVITES
SMSG_CALENDAR_EVENT_INVITE_STATUS_ALERT // NYI
SMSG_CALENDAR_EVENT_INVITE_NOTES_ALERT // NYI
SMSG_CALENDAR_EVENT_INVITE_NOTES // NYI

2 files changed, 1023 insertions, 0 deletions

diff --git a/src/server/game/Server/Packets/CalendarPackets.cpp b/src/server/game/Server/Packets/CalendarPackets.cpp
new file mode 100644
index 00000000000..655d33da73d
--- /dev/null
+++ b/src/server/game/Server/Packets/CalendarPackets.cpp
@@ -0,0 +1,461 @@
+/*
+ * Copyright (C) 2008-2015 TrinityCore <http://www.trinitycore.org/>
+ *
+ * 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/>.
+ */
+
+#include "CalendarPackets.h"
+#include "CalendarMgr.h"
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Calendar::CalendarSendCalendarEventInfo const& eventInfo)
+{
+    data << uint64(eventInfo.EventID);
+    data << uint8(eventInfo.EventType);
+    data.AppendPackedTime(eventInfo.Date);
+    data << uint32(eventInfo.Flags);
+    data << int32(eventInfo.TextureID);
+    data << eventInfo.EventGuildID;
+    data << eventInfo.OwnerGuid;
+
+    data.WriteBits(eventInfo.EventName.size(), 8);
+    data.FlushBits();
+    data.WriteString(eventInfo.EventName);
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Calendar::CalendarSendCalendarRaidResetInfo const& resetInfo)
+{
+    data << int32(resetInfo.MapID);
+    data << uint32(resetInfo.Duration);
+    data << int32(resetInfo.Offset);
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Calendar::CalendarSendCalendarRaidLockoutInfo const& lockoutInfo)
+{
+    data << uint64(lockoutInfo.InstanceID);
+    data << int32(lockoutInfo.MapID);
+    data << uint32(lockoutInfo.DifficultyID);
+    data << uint32(lockoutInfo.ExpireTime);
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Calendar::CalendarSendCalendarInviteInfo const& inviteInfo)
+{
+    data << uint64(inviteInfo.EventID);
+    data << uint64(inviteInfo.InviteID);
+    data << uint8(inviteInfo.Status);
+    data << uint8(inviteInfo.Moderator);
+    data << uint8(inviteInfo.InviteType);
+    data << inviteInfo.InviterGuid;
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Calendar::CalendarEventInviteInfo const& inviteInfo)
+{
+    data << inviteInfo.Guid;
+    data << uint64(inviteInfo.InviteID);
+
+    data << uint8(inviteInfo.Level);
+    data << uint8(inviteInfo.Status);
+    data << uint8(inviteInfo.Moderator);
+    data << uint8(inviteInfo.InviteType);
+
+    data.AppendPackedTime(inviteInfo.ResponseTime);
+
+    data.WriteBits(inviteInfo.Notes.size(), 8);
+    data.FlushBits();
+    data.WriteString(inviteInfo.Notes);
+
+    return data;
+}
+
+void WorldPackets::Calendar::CalendarGetEvent::Read()
+{
+    _worldPacket >> EventID;
+}
+
+void WorldPackets::Calendar::CalendarGuildFilter::Read()
+{
+    _worldPacket >> MinLevel;
+    _worldPacket >> MaxLevel;
+    _worldPacket >> MaxRankOrder;
+}
+
+void WorldPackets::Calendar::CalendarAddEvent::Read()
+{
+    uint8 titleLength = _worldPacket.ReadBits(8);
+    uint16 descriptionLength = _worldPacket.ReadBits(11);
+
+    _worldPacket >> EventInfo.EventType;
+    _worldPacket >> EventInfo.TextureID;
+    EventInfo.Time = _worldPacket.ReadPackedTime();
+    _worldPacket >> EventInfo.Flags;
+    uint32 count = _worldPacket.read<uint32>();
+
+    EventInfo.Title = _worldPacket.ReadString(titleLength);
+    EventInfo.Description = _worldPacket.ReadString(descriptionLength);
+
+    for (uint32 i = 0; i < count && i < CALENDAR_MAX_INVITES; i++)
+    {
+        WorldPackets::Calendar::CalendarAddEventInviteInfo invite;
+        _worldPacket >> invite.Guid;
+        _worldPacket >> invite.Status;
+        _worldPacket >> invite.Moderator;
+
+        EventInfo.Invites.push_back(invite);
+    }
+
+    _worldPacket >> MaxSize;
+}
+
+void WorldPackets::Calendar::CalendarUpdateEvent::Read()
+{
+    _worldPacket >> EventInfo.EventID;
+    _worldPacket >> EventInfo.ModeratorID;
+    _worldPacket >> EventInfo.EventType;
+    _worldPacket >> EventInfo.TextureID;
+    EventInfo.Time = _worldPacket.ReadPackedTime();
+    _worldPacket >> EventInfo.Flags;
+
+    uint8 titleLen = _worldPacket.ReadBits(8);
+    uint16 descLen = _worldPacket.ReadBits(11);
+
+    EventInfo.Title = _worldPacket.ReadString(titleLen);
+    EventInfo.Description = _worldPacket.ReadString(descLen);
+    _worldPacket >> MaxSize;
+}
+
+void WorldPackets::Calendar::CalendarRemoveEvent::Read()
+{
+    _worldPacket >> EventID;
+    _worldPacket >> ModeratorID;
+    _worldPacket >> Flags;
+}
+
+void WorldPackets::Calendar::CalendarCopyEvent::Read()
+{
+    _worldPacket >> EventID;
+    _worldPacket >> ModeratorID;
+    Date = _worldPacket.ReadPackedTime();
+}
+
+void WorldPackets::Calendar::CalendarEventRSVP::Read()
+{
+    _worldPacket >> EventID;
+    _worldPacket >> InviteID;
+    _worldPacket >> Status;
+}
+
+void WorldPackets::Calendar::CalendarEventInvite::Read()
+{
+    _worldPacket >> EventID;
+    _worldPacket >> ModeratorID;
+
+    uint16 nameLen = _worldPacket.ReadBits(9);
+    Creating = _worldPacket.ReadBit();
+    IsSignUp = _worldPacket.ReadBit();
+
+    Name = _worldPacket.ReadString(nameLen);
+}
+
+void WorldPackets::Calendar::CalendarEventSignUp::Read()
+{
+    _worldPacket >> EventID;
+    Tentative = _worldPacket.ReadBit();
+}
+
+void WorldPackets::Calendar::CalendarRemoveInvite::Read()
+{
+    _worldPacket >> Guid;
+    _worldPacket >> InviteID;
+    _worldPacket >> ModeratorID;
+    _worldPacket >> EventID;
+}
+
+void WorldPackets::Calendar::CalendarEventStatus::Read()
+{
+    _worldPacket >> Guid;
+    _worldPacket >> EventID;
+    _worldPacket >> InviteID;
+    _worldPacket >> ModeratorID;
+    _worldPacket >> Status;
+}
+
+void WorldPackets::Calendar::SetSavedInstanceExtend::Read()
+{
+    _worldPacket >> MapID;
+    _worldPacket >> DifficultyID;
+    Extend = _worldPacket.ReadBit();
+}
+
+void WorldPackets::Calendar::CalendarEventModeratorStatus::Read()
+{
+    _worldPacket >> Guid;
+    _worldPacket >> EventID;
+    _worldPacket >> InviteID;
+    _worldPacket >> ModeratorID;
+    _worldPacket >> Status;
+}
+
+WorldPacket const* WorldPackets::Calendar::SCalendarEventInvite::Write()
+{
+    _worldPacket << InviteGuid;
+    _worldPacket << uint64(EventID);
+    _worldPacket << uint64(InviteID);
+    _worldPacket << uint8(Level);
+    _worldPacket << uint8(Status);
+    _worldPacket << uint8(Type);
+    _worldPacket.AppendPackedTime(ResponseTime);
+
+    _worldPacket.WriteBit(ClearPending);
+    _worldPacket.FlushBits();
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Calendar::CalendarSendCalendar::Write()
+{
+    _worldPacket << uint32(ServerNow);
+    _worldPacket.AppendPackedTime(ServerTime);
+    _worldPacket << uint32(RaidOrigin);
+    _worldPacket << uint32(Invites.size());
+    _worldPacket << uint32(Events.size());
+    _worldPacket << uint32(RaidLockouts.size());
+    _worldPacket << uint32(RaidResets.size());
+
+    for (auto const& invite : Invites)
+        _worldPacket << invite;
+
+    for (auto const& event : Events)
+        _worldPacket << event;
+
+    for (auto const& lockout : RaidLockouts)
+        _worldPacket << lockout;
+
+    for (auto const& reset : RaidResets)
+        _worldPacket << reset;
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Calendar::CalendarSendEvent::Write()
+{
+    _worldPacket << uint8(EventType);
+    _worldPacket << OwnerGuid;
+    _worldPacket << uint64(EventID);
+    _worldPacket << uint8(GetEventType);
+    _worldPacket << int32(TextureID);
+    _worldPacket << uint32(Flags);
+    _worldPacket.AppendPackedTime(Date);
+    _worldPacket << uint32(LockDate);
+    _worldPacket << EventGuildID;
+
+    _worldPacket << uint32(Invites.size());
+    for (auto const& invite : Invites)
+        _worldPacket << invite;
+
+    _worldPacket.WriteBits(EventName.size(), 8);
+    _worldPacket.WriteBits(Description.size(), 11);
+    _worldPacket.FlushBits();
+
+    _worldPacket.WriteString(EventName);
+    _worldPacket.WriteString(Description);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Calendar::CalendarEventInviteAlert::Write()
+{
+    _worldPacket << uint64(EventID);
+    _worldPacket.AppendPackedTime(Date);
+    _worldPacket << uint32(Flags);
+    _worldPacket << uint8(EventType);
+    _worldPacket << int32(TextureID);
+    _worldPacket << EventGuildID;
+    _worldPacket << uint64(InviteID);
+    _worldPacket << uint8(Status);
+    _worldPacket << uint8(ModeratorStatus);
+
+    // Todo: check order
+    _worldPacket << InvitedByGuid;
+    _worldPacket << OwnerGuid;
+
+    _worldPacket.WriteBits(EventName.size(), 8);
+    _worldPacket.FlushBits();
+    _worldPacket.WriteString(EventName);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Calendar::CalendarEventInviteStatus::Write()
+{
+    _worldPacket << InviteGuid;
+    _worldPacket << uint64(EventID);
+    _worldPacket.AppendPackedTime(Date);
+    _worldPacket << uint32(Flags);
+    _worldPacket << uint8(Status);
+    _worldPacket.AppendPackedTime(ResponseTime);
+
+    _worldPacket.WriteBit(ClearPending);
+    _worldPacket.FlushBits();
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Calendar::CalendarEventInviteRemoved::Write()
+{
+    _worldPacket << InviteGuid;
+    _worldPacket << uint64(EventID);
+    _worldPacket << uint32(Flags);
+
+    _worldPacket.WriteBit(ClearPending);
+    _worldPacket.FlushBits();
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Calendar::CalendarEventInviteModeratorStatus::Write()
+{
+    _worldPacket << InviteGuid;
+    _worldPacket << uint64(EventID);
+    _worldPacket << uint8(Status);
+
+    _worldPacket.WriteBit(ClearPending);
+    _worldPacket.FlushBits();
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Calendar::CalendarEventInviteRemovedAlert::Write()
+{
+    _worldPacket << uint64(EventID);
+    _worldPacket.AppendPackedTime(Date);
+    _worldPacket << uint32(Flags);
+    _worldPacket << uint8(Status);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Calendar::CalendarEventUpdatedAlert::Write()
+{
+    _worldPacket << uint64(EventID);
+
+    _worldPacket.AppendPackedTime(OriginalDate);
+    _worldPacket.AppendPackedTime(Date);
+    _worldPacket << uint32(LockDate);
+    _worldPacket << uint32(Flags);
+    _worldPacket << uint32(TextureID);
+    _worldPacket << uint8(EventType);
+
+    _worldPacket.WriteBits(EventName.size(), 8);
+    _worldPacket.WriteBits(Description.size(), 11);
+    _worldPacket.WriteBit(ClearPending);
+    _worldPacket.FlushBits();
+
+    _worldPacket.WriteString(EventName);
+    _worldPacket.WriteString(Description);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Calendar::CalendarEventRemovedAlert::Write()
+{
+    _worldPacket << uint64(EventID);
+    _worldPacket.AppendPackedTime(Date);
+
+    _worldPacket.WriteBit(ClearPending);
+    _worldPacket.FlushBits();
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Calendar::CalendarSendNumPending::Write()
+{
+    _worldPacket << uint32(NumPending);
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Calendar::CalendarCommandResult::Write()
+{
+    _worldPacket << uint8(Command);
+    _worldPacket << uint8(Result);
+
+    _worldPacket.WriteBits(Name.size(), 9);
+    _worldPacket.FlushBits();
+    _worldPacket.WriteString(Name);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Calendar::CalendarRaidLockoutUpdated::Write()
+{
+    _worldPacket << uint32(ServerTime);
+    _worldPacket << int32(MapID);
+    _worldPacket << uint32(DifficultyID);
+    _worldPacket << int32(NewTimeRemaining);
+    _worldPacket << int32(OldTimeRemaining);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Calendar::CalendarEventInitialInvites::Write()
+{
+    _worldPacket << uint32(Invites.size());
+    for (auto const& invite : Invites)
+    {
+        _worldPacket << invite.InviteGuid;
+        _worldPacket << uint8(invite.Level);
+    }
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Calendar::CalendarEventInviteStatusAlert::Write()
+{
+    _worldPacket << uint64(EventID);
+    _worldPacket.AppendPackedTime(Date);
+    _worldPacket << uint32(Flags);
+    _worldPacket << uint8(Status);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Calendar::CalendarEventInviteNotesAlert::Write()
+{
+    _worldPacket << uint64(EventID);
+
+    _worldPacket.WriteBits(Notes.size(), 8);
+    _worldPacket.FlushBits();
+    _worldPacket.WriteString(Notes);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Calendar::CalendarEventInviteNotes::Write()
+{
+    _worldPacket << InviteGuid;
+    _worldPacket << uint64(EventID);
+
+    _worldPacket.WriteBits(Notes.size(), 8);
+    _worldPacket.WriteBit(ClearPending);
+    _worldPacket.FlushBits();
+    _worldPacket.WriteString(Notes);
+
+    return &_worldPacket;
+}
diff --git a/src/server/game/Server/Packets/CalendarPackets.h b/src/server/game/Server/Packets/CalendarPackets.h
new file mode 100644
index 00000000000..023041d427f
--- /dev/null
+++ b/src/server/game/Server/Packets/CalendarPackets.h
@@ -0,0 +1,562 @@
+/*
+ * Copyright (C) 2008-2015 TrinityCore <http://www.trinitycore.org/>
+ *
+ * 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/>.
+ */
+/*
+ * Copyright (C) 2008-2015 TrinityCore <http://www.trinitycore.org/>
+ *
+ * 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 CalendarPackets_h__
+#define CalendarPackets_h__
+
+#include "ObjectGuid.h"
+#include "Packet.h"
+
+namespace WorldPackets
+{
+    namespace Calendar
+    {
+        class CalendarGetCalendar final : public ClientPacket
+        {
+        public:
+            CalendarGetCalendar(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_GET, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class CalendarGetEvent final : public ClientPacket
+        {
+        public:
+            CalendarGetEvent(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_GET_EVENT, std::move(packet)) { }
+
+            void Read() override;
+
+            uint64 EventID = 0;
+        };
+
+        class CalendarGuildFilter final : public ClientPacket
+        {
+        public:
+            CalendarGuildFilter(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_GUILD_FILTER, std::move(packet)) { }
+
+            void Read() override;
+
+            uint8 MinLevel = 1;
+            uint8 MaxLevel = 100;
+            uint8 MaxRankOrder = 0;
+        };
+
+        struct CalendarAddEventInviteInfo
+        {
+            ObjectGuid Guid;
+            uint8 Status = 0;
+            uint8 Moderator = 0;
+        };
+
+        struct CalendarAddEventInfo
+        {
+            std::string Title;
+            std::string Description;
+            uint8 EventType = 0;
+            int32 TextureID = 0;
+            time_t Time = time_t(0);
+            uint32 Flags = 0;
+            std::vector<CalendarAddEventInviteInfo> Invites;
+        };
+
+        class CalendarAddEvent final : public ClientPacket
+        {
+        public:
+            CalendarAddEvent(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_ADD_EVENT, std::move(packet)) { }
+
+            void Read() override;
+
+            uint32 MaxSize = 100;
+            CalendarAddEventInfo EventInfo;
+        };
+
+        struct CalendarUpdateEventInfo
+        {
+            uint64 EventID = 0;
+            uint64 ModeratorID = 0;
+            std::string Title;
+            std::string Description;
+            uint8 EventType = 0;
+            uint32 TextureID = 0;
+            time_t Time = time_t(0);
+            uint32 Flags = 0;
+        };
+
+        class CalendarUpdateEvent final : public ClientPacket
+        {
+        public:
+            CalendarUpdateEvent(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_UPDATE_EVENT, std::move(packet)) { }
+
+            void Read() override;
+
+            uint32 MaxSize = 0;
+            CalendarUpdateEventInfo EventInfo;
+        };
+
+        class CalendarRemoveEvent final : public ClientPacket
+        {
+        public:
+            CalendarRemoveEvent(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_REMOVE_EVENT, std::move(packet)) { }
+
+            void Read() override;
+
+            uint64 ModeratorID = 0;
+            uint64 EventID = 0;
+            uint32 Flags = 0;
+        };
+
+        class CalendarCopyEvent final : public ClientPacket
+        {
+        public:
+            CalendarCopyEvent(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_COPY_EVENT, std::move(packet)) { }
+
+            void Read() override;
+
+            uint64 ModeratorID = 0;
+            uint64 EventID = 0;
+            time_t Date = time_t(0);
+        };
+
+        class SCalendarEventInvite final : public ServerPacket
+        {
+        public:
+            SCalendarEventInvite() : ServerPacket(SMSG_CALENDAR_EVENT_INVITE, 43) { }
+
+            WorldPacket const* Write() override;
+
+            uint64 InviteID = 0;
+            time_t ResponseTime = time_t(0);
+            uint8 Level = 100;
+            ObjectGuid InviteGuid;
+            uint64 EventID = 0;
+            uint8 Type = 0;
+            bool ClearPending = false;
+            uint8 Status = 0;
+        };
+
+        struct CalendarSendCalendarInviteInfo
+        {
+            uint64 EventID = 0;
+            uint64 InviteID = 0;
+            ObjectGuid InviterGuid;
+            uint8 Status = 0;
+            uint8 Moderator = 0;
+            uint8 InviteType = 0;
+        };
+
+        struct CalendarSendCalendarRaidLockoutInfo
+        {
+            uint64 InstanceID = 0;
+            int32 MapID = 0;
+            uint32 DifficultyID = 0;
+            time_t ExpireTime = time_t(0);
+        };
+
+        struct CalendarSendCalendarRaidResetInfo
+        {
+            int32 MapID = 0;
+            uint32 Duration = 0;
+            int32 Offset = 0;
+        };
+
+        struct CalendarSendCalendarEventInfo
+        {
+            uint64 EventID = 0;
+            std::string EventName;
+            uint8 EventType = 0;
+            time_t Date = time_t(0);
+            uint32 Flags = 0;
+            int32 TextureID = 0;
+            ObjectGuid EventGuildID;
+            ObjectGuid OwnerGuid;
+        };
+
+        class CalendarSendCalendar final : public ServerPacket
+        {
+        public:
+            CalendarSendCalendar() : ServerPacket(SMSG_CALENDAR_SEND_CALENDAR, 338) { }
+
+            WorldPacket const* Write() override;
+
+            time_t RaidOrigin = time_t(0);
+            time_t ServerTime = time_t(0);
+            time_t ServerNow = time_t(0);
+            std::vector<CalendarSendCalendarInviteInfo> Invites;
+            std::vector<CalendarSendCalendarRaidLockoutInfo> RaidLockouts;
+            std::vector<CalendarSendCalendarRaidResetInfo> RaidResets;
+            std::vector<CalendarSendCalendarEventInfo> Events;
+        };
+
+        struct CalendarEventInviteInfo
+        {
+            ObjectGuid Guid;
+            uint64 InviteID = 0;
+            time_t ResponseTime = time_t(0);
+            uint8 Level = 1;
+            uint8 Status = 0;
+            uint8 Moderator = 0;
+            uint8 InviteType = 0;
+            std::string Notes;
+        };
+
+        class CalendarSendEvent final : public ServerPacket
+        {
+        public:
+            CalendarSendEvent() : ServerPacket(SMSG_CALENDAR_SEND_EVENT, 93) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid OwnerGuid;
+            ObjectGuid EventGuildID;
+            uint64 EventID = 0;
+            time_t Date = time_t(0);
+            time_t LockDate = time_t(0);
+            uint32 Flags = 0;
+            int32 TextureID = 0;
+            uint8 GetEventType = 0;
+            uint8 EventType = 0;
+            std::string Description;
+            std::string EventName;
+            std::vector<CalendarEventInviteInfo> Invites;
+        };
+
+        class CalendarEventInviteAlert final : public ServerPacket
+        {
+        public:
+            CalendarEventInviteAlert() : ServerPacket(SMSG_CALENDAR_EVENT_INVITE_ALERT, 80) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid OwnerGuid;
+            ObjectGuid EventGuildID;
+            ObjectGuid InvitedByGuid;
+            uint64 InviteID = 0;
+            uint64 EventID = 0;
+            uint32 Flags = 0;
+            time_t Date = time_t(0);
+            int32 TextureID = 0;
+            uint8 Status = 0;
+            uint8 EventType = 0;
+            uint8 ModeratorStatus = 0;
+            std::string EventName;
+        };
+
+        class CalendarEventInvite final : public ClientPacket
+        {
+        public:
+            CalendarEventInvite(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_EVENT_INVITE, std::move(packet)) { }
+
+            void Read() override;
+
+            uint64 ModeratorID = 0;
+            bool IsSignUp = false;
+            bool Creating = true;
+            uint64 EventID = 0;
+            std::string Name;
+        };
+
+        class CalendarEventRSVP final : public ClientPacket
+        {
+        public:
+            CalendarEventRSVP(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_EVENT_RSVP, std::move(packet)) { }
+
+            void Read() override;
+
+            uint64 InviteID = 0;
+            uint64 EventID = 0;
+            uint8 Status = 0;
+        };
+
+        class CalendarEventInviteStatus final : public ServerPacket
+        {
+        public:
+            CalendarEventInviteStatus() : ServerPacket(SMSG_CALENDAR_EVENT_INVITE_STATUS, 41) { }
+
+            WorldPacket const* Write() override;
+
+            uint32 Flags = 0;
+            uint64 EventID = 0;
+            uint8 Status = 0;
+            bool ClearPending = false;
+            time_t ResponseTime = time_t(0);
+            time_t Date = time_t(0);
+            ObjectGuid InviteGuid;
+        };
+
+        class CalendarEventInviteRemoved final : public ServerPacket
+        {
+        public:
+            CalendarEventInviteRemoved() : ServerPacket(SMSG_CALENDAR_EVENT_INVITE_REMOVED, 29) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid InviteGuid;
+            uint64 EventID = 0;
+            uint32 Flags = 0;
+            bool ClearPending = false;
+        };
+
+        class CalendarEventInviteModeratorStatus final : public ServerPacket
+        {
+        public:
+            CalendarEventInviteModeratorStatus() : ServerPacket(SMSG_CALENDAR_EVENT_INVITE_MODERATOR_STATUS, 26) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid InviteGuid;
+            uint64 EventID = 0;
+            uint8 Status = 0;
+            bool ClearPending = false;
+        };
+
+        class CalendarEventInviteRemovedAlert final : public ServerPacket
+        {
+        public:
+            CalendarEventInviteRemovedAlert() : ServerPacket(SMSG_CALENDAR_EVENT_INVITE_REMOVED_ALERT, 17) { }
+
+            WorldPacket const* Write() override;
+
+            uint64 EventID = 0;
+            time_t Date = time_t(0);
+            uint32 Flags = 0;
+            uint8 Status = 0;
+        };
+
+        class CalendarClearPendingAction final : public ServerPacket
+        {
+        public:
+            CalendarClearPendingAction() : ServerPacket(SMSG_CALENDAR_CLEAR_PENDING_ACTION, 0) { }
+
+            WorldPacket const* Write() override { return &_worldPacket; }
+        };
+
+        class CalendarEventUpdatedAlert final : public ServerPacket
+        {
+        public:
+            CalendarEventUpdatedAlert() : ServerPacket(SMSG_CALENDAR_EVENT_UPDATED_ALERT, 32) { }
+
+            WorldPacket const* Write() override;
+
+            uint64 EventID = 0;
+            time_t Date = time_t(0);
+            uint32 Flags = 0;
+            time_t LockDate = time_t(0);
+            time_t OriginalDate = time_t(0);
+            int32 TextureID = 0;
+            uint8 EventType = 0;
+            bool ClearPending = false;
+            std::string Description;
+            std::string EventName;
+        };
+
+        class CalendarEventRemovedAlert final : public ServerPacket
+        {
+        public:
+            CalendarEventRemovedAlert() : ServerPacket(SMSG_CALENDAR_EVENT_REMOVED_ALERT, 13) { }
+
+            WorldPacket const* Write() override;
+
+            uint64 EventID = 0;
+            time_t Date = time_t(0);
+            bool ClearPending = false;
+        };
+
+        class CalendarSendNumPending final : public ServerPacket
+        {
+        public:
+            CalendarSendNumPending() : ServerPacket(SMSG_CALENDAR_SEND_NUM_PENDING, 4) { }
+            CalendarSendNumPending(uint32 numPending) : ServerPacket(SMSG_CALENDAR_SEND_NUM_PENDING, 4), NumPending(numPending) { }
+
+            WorldPacket const* Write() override;
+
+            uint32 NumPending = 0;
+        };
+
+        class CalendarGetNumPending final : public ClientPacket
+        {
+        public:
+            CalendarGetNumPending(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_GET_NUM_PENDING, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class CalendarEventSignUp final : public ClientPacket
+        {
+        public:
+            CalendarEventSignUp(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_EVENT_SIGN_UP, std::move(packet)) { }
+
+            void Read() override;
+
+            bool Tentative = false;
+            uint64 EventID = 0;
+        };
+
+        class CalendarRemoveInvite final : public ClientPacket
+        {
+        public:
+            CalendarRemoveInvite(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_REMOVE_INVITE, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Guid;
+            uint64 EventID = 0;
+            uint64 ModeratorID = 0;
+            uint64 InviteID = 0;
+        };
+
+        class CalendarEventStatus final : public ClientPacket
+        {
+        public:
+            CalendarEventStatus(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_EVENT_STATUS, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Guid;
+            uint64 EventID = 0;
+            uint64 ModeratorID = 0;
+            uint64 InviteID = 0;
+            uint8 Status = 0;
+        };
+
+        class SetSavedInstanceExtend final : public ClientPacket
+        {
+        public:
+            SetSavedInstanceExtend(WorldPacket&& packet) : ClientPacket(CMSG_SET_SAVED_INSTANCE_EXTEND, std::move(packet)) { }
+
+            void Read() override;
+
+            int32 MapID = 0;
+            bool Extend = false;
+            uint32 DifficultyID = 0;
+        };
+
+        class CalendarEventModeratorStatus final : public ClientPacket
+        {
+        public:
+            CalendarEventModeratorStatus(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_EVENT_MODERATOR_STATUS, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Guid;
+            uint64 EventID = 0;
+            uint64 InviteID = 0;
+            uint64 ModeratorID = 0;
+            uint8 Status = 0;
+        };
+
+        class CalendarCommandResult final : public ServerPacket
+        {
+        public:
+            CalendarCommandResult() : ServerPacket(SMSG_CALENDAR_COMMAND_RESULT, 3) { }
+            CalendarCommandResult(uint8 command, uint8 result, std::string const& name) : ServerPacket(SMSG_CALENDAR_COMMAND_RESULT, 3), Command(command), Result(result), Name(name) { }
+
+            WorldPacket const* Write() override;
+
+            uint8 Command = 0;
+            uint8 Result = 0;
+            std::string Name;
+        };
+
+        class CalendarRaidLockoutUpdated final : public ServerPacket
+        {
+        public:
+            CalendarRaidLockoutUpdated() : ServerPacket(SMSG_CALENDAR_RAID_LOCKOUT_UPDATED, 20) { }
+
+            WorldPacket const* Write() override;
+
+            int32 MapID = 0;
+            int32 OldTimeRemaining = 0;
+            time_t ServerTime = 0;
+            uint32 DifficultyID = 0;
+            int32 NewTimeRemaining = 0;
+        };
+
+        struct CalendarEventInitialInviteInfo
+        {
+            CalendarEventInitialInviteInfo(ObjectGuid inviteGuid, uint8 level) : InviteGuid(inviteGuid), Level(level) { }
+
+            ObjectGuid InviteGuid;
+            uint8 Level = 100;
+        };
+
+        class CalendarEventInitialInvites final : public ServerPacket
+        {
+        public:
+            CalendarEventInitialInvites() : ServerPacket(SMSG_CALENDAR_EVENT_INITIAL_INVITES, 17) { }
+
+            WorldPacket const* Write() override;
+
+            std::vector<CalendarEventInitialInviteInfo> Invites;
+        };
+
+        class CalendarEventInviteStatusAlert final : public ServerPacket
+        {
+        public:
+            CalendarEventInviteStatusAlert() : ServerPacket(SMSG_CALENDAR_EVENT_INVITE_STATUS_ALERT, 5) { }
+
+            WorldPacket const* Write() override;
+
+            uint64 EventID = 0;
+            uint32 Flags = 0;
+            time_t Date = time_t(0);
+            uint8 Status = 0;
+        };
+
+        class CalendarEventInviteNotesAlert final : public ServerPacket
+        {
+        public:
+            CalendarEventInviteNotesAlert() : ServerPacket(SMSG_CALENDAR_EVENT_INVITE_NOTES_ALERT, 9) { }
+            CalendarEventInviteNotesAlert(uint64 eventID, std::string const& notes) : ServerPacket(SMSG_CALENDAR_EVENT_INVITE_NOTES_ALERT, 8 + notes.size()), EventID(eventID), Notes(notes) { }
+
+            WorldPacket const* Write() override;
+
+            uint64 EventID = 0;
+            std::string Notes;
+        };
+
+        class CalendarEventInviteNotes final : public ServerPacket
+        {
+        public:
+            CalendarEventInviteNotes() : ServerPacket(SMSG_CALENDAR_EVENT_INVITE_NOTES, 26) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid InviteGuid;
+            uint64 EventID = 0;
+            std::string Notes;
+            bool ClearPending = false;
+        };
+    }
+}
+
+#endif // CalendarPackets_h__