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

4 files changed, 1090 insertions, 47 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__
diff --git a/src/server/game/Server/Protocol/Opcodes.cpp b/src/server/game/Server/Protocol/Opcodes.cpp
index fd7b00301b2..814a40a037d 100644
--- a/src/server/game/Server/Protocol/Opcodes.cpp
+++ b/src/server/game/Server/Protocol/Opcodes.cpp
@@ -23,6 +23,7 @@
 #include "Packets/BankPackets.h"
 #include "Packets/BattlegroundPackets.h"
 #include "Packets/BlackMarketPackets.h"
+#include "Packets/CalendarPackets.h"
 #include "Packets/ChannelPackets.h"
 #include "Packets/CharacterPackets.h"
 #include "Packets/ChatPackets.h"
@@ -230,21 +231,21 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_BUY_WOW_TOKEN_CONFIRM,                              STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_BUY_WOW_TOKEN_START,                                STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_CAGE_BATTLE_PET,                                    STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_ADD_EVENT,                      STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarAddEvent          );
+    DEFINE_HANDLER(CMSG_CALENDAR_ADD_EVENT,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarAddEvent, &WorldSession::HandleCalendarAddEvent);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_COMPLAIN,                       STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarComplain          );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_COPY_EVENT,                     STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarCopyEvent         );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_EVENT_INVITE,                   STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarEventInvite       );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_EVENT_MODERATOR_STATUS,         STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarEventModeratorStatus);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_EVENT_RSVP,                     STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarEventRsvp         );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_EVENT_SIGN_UP,                  STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarEventSignup       );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_EVENT_STATUS,                   STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarEventStatus       );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_GET,                            STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarGetCalendar       );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_GET_EVENT,                      STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarGetEvent          );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_GET_NUM_PENDING,                STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarGetNumPending     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_GUILD_FILTER,                   STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarGuildFilter       );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_REMOVE_EVENT,                   STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarRemoveEvent       );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_REMOVE_INVITE,                  STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarEventRemoveInvite );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_UPDATE_EVENT,                   STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarUpdateEvent       );
+    DEFINE_HANDLER(CMSG_CALENDAR_COPY_EVENT,                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarCopyEvent, &WorldSession::HandleCalendarCopyEvent);
+    DEFINE_HANDLER(CMSG_CALENDAR_EVENT_INVITE,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarEventInvite, &WorldSession::HandleCalendarEventInvite);
+    DEFINE_HANDLER(CMSG_CALENDAR_EVENT_MODERATOR_STATUS,                    STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarEventModeratorStatus, &WorldSession::HandleCalendarEventModeratorStatus);
+    DEFINE_HANDLER(CMSG_CALENDAR_EVENT_RSVP,                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarEventRSVP, &WorldSession::HandleCalendarEventRsvp);
+    DEFINE_HANDLER(CMSG_CALENDAR_EVENT_SIGN_UP,                             STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarEventSignUp, &WorldSession::HandleCalendarEventSignup);
+    DEFINE_HANDLER(CMSG_CALENDAR_EVENT_STATUS,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarEventStatus, &WorldSession::HandleCalendarEventStatus);
+    DEFINE_HANDLER(CMSG_CALENDAR_GET,                                       STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarGetCalendar, &WorldSession::HandleCalendarGetCalendar);
+    DEFINE_HANDLER(CMSG_CALENDAR_GET_EVENT,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarGetEvent, &WorldSession::HandleCalendarGetEvent);
+    DEFINE_HANDLER(CMSG_CALENDAR_GET_NUM_PENDING,                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarGetNumPending, &WorldSession::HandleCalendarGetNumPending);
+    DEFINE_HANDLER(CMSG_CALENDAR_GUILD_FILTER,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarGuildFilter, &WorldSession::HandleCalendarGuildFilter);
+    DEFINE_HANDLER(CMSG_CALENDAR_REMOVE_EVENT,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarRemoveEvent, &WorldSession::HandleCalendarRemoveEvent);
+    DEFINE_HANDLER(CMSG_CALENDAR_REMOVE_INVITE,                             STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarRemoveInvite, &WorldSession::HandleCalendarEventRemoveInvite);
+    DEFINE_HANDLER(CMSG_CALENDAR_UPDATE_EVENT,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarUpdateEvent, &WorldSession::HandleCalendarUpdateEvent);
     DEFINE_HANDLER(CMSG_CANCEL_AURA,                                        STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Spells::CancelAura, &WorldSession::HandleCancelAuraOpcode);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_CANCEL_AUTO_REPEAT_SPELL,                STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCancelAutoRepeatSpellOpcode);
     DEFINE_HANDLER(CMSG_CANCEL_CAST,                                        STATUS_LOGGEDIN,  PROCESS_THREADSAFE,   WorldPackets::Spells::CancelCast, &WorldSession::HandleCancelCastOpcode);
@@ -735,7 +736,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_SET_PVP,                                            STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SET_RAID_DIFFICULTY,                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Misc::SetRaidDifficulty, &WorldSession::HandleSetRaidDifficultyOpcode);
     DEFINE_HANDLER(CMSG_SET_ROLE,                                           STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Party::SetRole, &WorldSession::HandleSetRoleOpcode);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_SAVED_INSTANCE_EXTEND,               STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleSetSavedInstanceExtend    );
+    DEFINE_HANDLER(CMSG_SET_SAVED_INSTANCE_EXTEND,                          STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Calendar::SetSavedInstanceExtend, &WorldSession::HandleSetSavedInstanceExtend);
     DEFINE_HANDLER(CMSG_SET_SELECTION,                                      STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Misc::SetSelection, &WorldSession::HandleSetSelectionOpcode);
     DEFINE_HANDLER(CMSG_SET_SHEATHED,                                       STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Combat::SetSheathed, &WorldSession::HandleSetSheathedOpcode);
     DEFINE_HANDLER(CMSG_SET_SORT_BAGS_RIGHT_TO_LEFT,                        STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
@@ -947,26 +948,26 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BUY_FAILED,                              STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BUY_SUCCEEDED,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CACHE_VERSION,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_CLEAR_PENDING_ACTION,           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_COMMAND_RESULT,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INITIAL_INVITES,          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE,                   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_ALERT,             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_MODERATOR_STATUS,  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_NOTES,             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_NOTES_ALERT,       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_REMOVED,           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_REMOVED_ALERT,     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_STATUS,            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_STATUS_ALERT,      STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_REMOVED_ALERT,            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_UPDATED_ALERT,            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_CLEAR_PENDING_ACTION,           STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_COMMAND_RESULT,                 STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INITIAL_INVITES,          STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE,                   STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_ALERT,             STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_MODERATOR_STATUS,  STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_NOTES,             STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_NOTES_ALERT,       STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_REMOVED,           STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_REMOVED_ALERT,     STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_STATUS,            STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_STATUS_ALERT,      STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_REMOVED_ALERT,            STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_UPDATED_ALERT,            STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_RAID_LOCKOUT_ADDED,             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_RAID_LOCKOUT_REMOVED,           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_RAID_LOCKOUT_UPDATED,           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_SEND_CALENDAR,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_SEND_EVENT,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_SEND_NUM_PENDING,               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_SEND_CALENDAR,                  STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_SEND_EVENT,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_SEND_NUM_PENDING,               STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CAMERA_SHAKE,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CANCEL_AUTO_REPEAT,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CANCEL_COMBAT,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
diff --git a/src/server/game/Server/WorldSession.h b/src/server/game/Server/WorldSession.h
index 9c092ec98a1..9b9e8f93f55 100644
--- a/src/server/game/Server/WorldSession.h
+++ b/src/server/game/Server/WorldSession.h
@@ -122,6 +122,25 @@ namespace WorldPackets
         class BlackMarketOpen;
     }
 
+    namespace Calendar
+    {
+        class CalendarAddEvent;
+        class CalendarCopyEvent;
+        class CalendarEventInvite;
+        class CalendarEventModeratorStatus;
+        class CalendarEventRSVP;
+        class CalendarEventSignUp;
+        class CalendarEventStatus;
+        class CalendarGetCalendar;
+        class CalendarGetEvent;
+        class CalendarGetNumPending;
+        class CalendarGuildFilter;
+        class CalendarRemoveEvent;
+        class CalendarRemoveInvite;
+        class CalendarUpdateEvent;
+        class SetSavedInstanceExtend;
+    }
+
     namespace Character
     {
         struct CharacterCreateInfo;
@@ -1460,25 +1479,25 @@ class WorldSession
         void HandleAcceptGrantLevel(WorldPackets::RaF::AcceptLevelGrant& acceptLevelGrant);
 
         // Calendar
-        void HandleCalendarGetCalendar(WorldPacket& recvData);
-        void HandleCalendarGetEvent(WorldPacket& recvData);
-        void HandleCalendarGuildFilter(WorldPacket& recvData);
-        void HandleCalendarAddEvent(WorldPacket& recvData);
-        void HandleCalendarUpdateEvent(WorldPacket& recvData);
-        void HandleCalendarRemoveEvent(WorldPacket& recvData);
-        void HandleCalendarCopyEvent(WorldPacket& recvData);
-        void HandleCalendarEventInvite(WorldPacket& recvData);
-        void HandleCalendarEventRsvp(WorldPacket& recvData);
-        void HandleCalendarEventRemoveInvite(WorldPacket& recvData);
-        void HandleCalendarEventStatus(WorldPacket& recvData);
-        void HandleCalendarEventModeratorStatus(WorldPacket& recvData);
+        void HandleCalendarGetCalendar(WorldPackets::Calendar::CalendarGetCalendar& calendarGetCalendar);
+        void HandleCalendarGetEvent(WorldPackets::Calendar::CalendarGetEvent& calendarGetEvent);
+        void HandleCalendarGuildFilter(WorldPackets::Calendar::CalendarGuildFilter& calendarGuildFilter);
+        void HandleCalendarAddEvent(WorldPackets::Calendar::CalendarAddEvent& calendarAddEvent);
+        void HandleCalendarUpdateEvent(WorldPackets::Calendar::CalendarUpdateEvent& calendarUpdateEvent);
+        void HandleCalendarRemoveEvent(WorldPackets::Calendar::CalendarRemoveEvent& calendarRemoveEvent);
+        void HandleCalendarCopyEvent(WorldPackets::Calendar::CalendarCopyEvent& calendarCopyEvent);
+        void HandleCalendarEventInvite(WorldPackets::Calendar::CalendarEventInvite& calendarEventInvite);
+        void HandleCalendarEventRsvp(WorldPackets::Calendar::CalendarEventRSVP& calendarEventRSVP);
+        void HandleCalendarEventRemoveInvite(WorldPackets::Calendar::CalendarRemoveInvite& calendarRemoveInvite);
+        void HandleCalendarEventStatus(WorldPackets::Calendar::CalendarEventStatus& calendarEventStatus);
+        void HandleCalendarEventModeratorStatus(WorldPackets::Calendar::CalendarEventModeratorStatus& calendarEventModeratorStatus);
         void HandleCalendarComplain(WorldPacket& recvData);
-        void HandleCalendarGetNumPending(WorldPacket& recvData);
-        void HandleCalendarEventSignup(WorldPacket& recvData);
+        void HandleCalendarGetNumPending(WorldPackets::Calendar::CalendarGetNumPending& calendarGetNumPending);
+        void HandleCalendarEventSignup(WorldPackets::Calendar::CalendarEventSignUp& calendarEventSignUp);
 
         void SendCalendarRaidLockout(InstanceSave const* save, bool add);
         void SendCalendarRaidLockoutUpdated(InstanceSave const* save);
-        void HandleSetSavedInstanceExtend(WorldPacket& recvData);
+        void HandleSetSavedInstanceExtend(WorldPackets::Calendar::SetSavedInstanceExtend& setSavedInstanceExtend);
 
         // Void Storage
         void HandleVoidStorageUnlock(WorldPackets::VoidStorage::UnlockVoidStorage& unlockVoidStorage);