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, 189 insertions, 200 deletions

diff --git a/src/server/game/Calendar/CalendarMgr.cpp b/src/server/game/Calendar/CalendarMgr.cpp
index 82c8ced3801..e31b9739654 100644
--- a/src/server/game/Calendar/CalendarMgr.cpp
+++ b/src/server/game/Calendar/CalendarMgr.cpp
@@ -22,6 +22,7 @@
 #include "GuildMgr.h"
 #include "ObjectAccessor.h"
 #include "Opcodes.h"
+#include "CalendarPackets.h"
 
 CalendarInvite::~CalendarInvite()
 {
@@ -51,30 +52,30 @@ void CalendarMgr::LoadFromDB()
     _maxEventId = 0;
     _maxInviteId = 0;
 
-    //                                                       0   1        2      3            4     5        6          7      8
-    if (QueryResult result = CharacterDatabase.Query("SELECT id, creator, title, description, type, dungeon, eventtime, flags, time2 FROM calendar_events"))
+    //                                                       0        1      2      3            4          5          6     7      8
+    if (QueryResult result = CharacterDatabase.Query("SELECT EventID, Owner, Title, Description, EventType, TextureID, Date, Flags, LockDate FROM calendar_events"))
         do
         {
             Field* fields = result->Fetch();
 
-            uint64 eventId          = fields[0].GetUInt64();
-            ObjectGuid creatorGUID  = ObjectGuid::Create<HighGuid::Player>(fields[1].GetUInt64());
+            uint64 eventID          = fields[0].GetUInt64();
+            ObjectGuid ownerGUID    = ObjectGuid::Create<HighGuid::Player>(fields[1].GetUInt64());
             std::string title       = fields[2].GetString();
             std::string description = fields[3].GetString();
             CalendarEventType type  = CalendarEventType(fields[4].GetUInt8());
-            int32 dungeonId         = fields[5].GetInt32();
-            uint32 eventTime        = fields[6].GetUInt32();
+            int32 textureID         = fields[5].GetInt32();
+            uint32 date             = fields[6].GetUInt32();
             uint32 flags            = fields[7].GetUInt32();
-            uint32 timezoneTime     = fields[8].GetUInt32();
-            ObjectGuid::LowType guildId = UI64LIT(0);
+            uint32 lockDate         = fields[8].GetUInt32();
+            ObjectGuid::LowType guildID = UI64LIT(0);
 
             if (flags & CALENDAR_FLAG_GUILD_EVENT || flags & CALENDAR_FLAG_WITHOUT_INVITES)
-                guildId = Player::GetGuildIdFromDB(creatorGUID);
+                guildID = Player::GetGuildIdFromDB(ownerGUID);
 
-            CalendarEvent* calendarEvent = new CalendarEvent(eventId, creatorGUID, guildId, type, dungeonId, time_t(eventTime), flags, time_t(timezoneTime), title, description);
+            CalendarEvent* calendarEvent = new CalendarEvent(eventID, ownerGUID, guildID, type, textureID, time_t(date), flags, title, description, time_t(lockDate));
             _events.insert(calendarEvent);
 
-            _maxEventId = std::max(_maxEventId, eventId);
+            _maxEventId = std::max(_maxEventId, eventID);
 
             ++count;
         }
@@ -83,8 +84,8 @@ void CalendarMgr::LoadFromDB()
     TC_LOG_INFO("server.loading", ">> Loaded %u calendar events", count);
     count = 0;
 
-    //                                                       0   1      2        3       4       5           6     7
-    if (QueryResult result = CharacterDatabase.Query("SELECT id, event, invitee, sender, status, statustime, rank, text FROM calendar_invites"))
+    //                                                       0         1        2        3       4       5             6               7
+    if (QueryResult result = CharacterDatabase.Query("SELECT InviteID, EventID, Invitee, Sender, Status, ResponseTime, ModerationRank, Note FROM calendar_invites"))
         do
         {
             Field* fields = result->Fetch();
@@ -94,11 +95,11 @@ void CalendarMgr::LoadFromDB()
             ObjectGuid invitee          = ObjectGuid::Create<HighGuid::Player>(fields[2].GetUInt64());
             ObjectGuid senderGUID       = ObjectGuid::Create<HighGuid::Player>(fields[3].GetUInt64());
             CalendarInviteStatus status = CalendarInviteStatus(fields[4].GetUInt8());
-            uint32 statusTime           = fields[5].GetUInt32();
+            uint32 responseTime         = fields[5].GetUInt32();
             CalendarModerationRank rank = CalendarModerationRank(fields[6].GetUInt8());
-            std::string text            = fields[7].GetString();
+            std::string note            = fields[7].GetString();
 
-            CalendarInvite* invite = new CalendarInvite(inviteId, eventId, invitee, senderGUID, time_t(statusTime), status, rank, text);
+            CalendarInvite* invite = new CalendarInvite(inviteId, eventId, invitee, senderGUID, time_t(responseTime), status, rank, note);
             _invites[eventId].push_back(invite);
 
             _maxInviteId = std::max(_maxInviteId, inviteId);
@@ -122,7 +123,7 @@ void CalendarMgr::AddEvent(CalendarEvent* calendarEvent, CalendarSendEventType s
 {
     _events.insert(calendarEvent);
     UpdateEvent(calendarEvent);
-    SendCalendarEvent(calendarEvent->GetCreatorGUID(), *calendarEvent, sendType);
+    SendCalendarEvent(calendarEvent->GetOwnerGUID(), *calendarEvent, sendType);
 }
 
 void CalendarMgr::AddInvite(CalendarEvent* calendarEvent, CalendarInvite* invite)
@@ -133,10 +134,10 @@ void CalendarMgr::AddInvite(CalendarEvent* calendarEvent, CalendarInvite* invite
 
 void CalendarMgr::AddInvite(CalendarEvent* calendarEvent, CalendarInvite* invite, SQLTransaction& trans)
 {
-    if (!calendarEvent->IsGuildAnnouncement())
+    if (!calendarEvent->IsGuildAnnouncement() && calendarEvent->GetOwnerGUID() != invite->GetInviteeGUID())
         SendCalendarEventInvite(*invite);
 
-    if (!calendarEvent->IsGuildEvent() || invite->GetInviteeGUID() == calendarEvent->GetCreatorGUID())
+    if (!calendarEvent->IsGuildEvent() || invite->GetInviteeGUID() == calendarEvent->GetOwnerGUID())
         SendCalendarEventInviteAlert(*calendarEvent, *invite);
 
     if (!calendarEvent->IsGuildAnnouncement())
@@ -228,14 +229,14 @@ void CalendarMgr::UpdateEvent(CalendarEvent* calendarEvent)
 {
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_CALENDAR_EVENT);
     stmt->setUInt64(0, calendarEvent->GetEventId());
-    stmt->setUInt64(1, calendarEvent->GetCreatorGUID().GetCounter());
+    stmt->setUInt64(1, calendarEvent->GetOwnerGUID().GetCounter());
     stmt->setString(2, calendarEvent->GetTitle());
     stmt->setString(3, calendarEvent->GetDescription());
     stmt->setUInt8(4, calendarEvent->GetType());
-    stmt->setInt32(5, calendarEvent->GetDungeonId());
-    stmt->setUInt32(6, uint32(calendarEvent->GetEventTime()));
+    stmt->setInt32(5, calendarEvent->GetTextureId());
+    stmt->setUInt32(6, uint32(calendarEvent->GetDate()));
     stmt->setUInt32(7, calendarEvent->GetFlags());
-    stmt->setUInt32(8, calendarEvent->GetTimeZoneTime()); // correct?
+    stmt->setUInt32(8, uint32(calendarEvent->GetLockDate()));
     CharacterDatabase.Execute(stmt);
 }
 
@@ -253,16 +254,16 @@ void CalendarMgr::UpdateInvite(CalendarInvite* invite, SQLTransaction& trans)
     stmt->setUInt64(2, invite->GetInviteeGUID().GetCounter());
     stmt->setUInt64(3, invite->GetSenderGUID().GetCounter());
     stmt->setUInt8(4, invite->GetStatus());
-    stmt->setUInt32(5, uint32(invite->GetStatusTime()));
+    stmt->setUInt32(5, uint32(invite->GetResponseTime()));
     stmt->setUInt8(6, invite->GetRank());
-    stmt->setString(7, invite->GetText());
+    stmt->setString(7, invite->GetNote());
     CharacterDatabase.ExecuteOrAppend(trans, stmt);
 }
 
 void CalendarMgr::RemoveAllPlayerEventsAndInvites(ObjectGuid guid)
 {
     for (CalendarEventStore::const_iterator itr = _events.begin(); itr != _events.end(); ++itr)
-        if ((*itr)->GetCreatorGUID() == guid)
+        if ((*itr)->GetOwnerGUID() == guid)
             RemoveEvent((*itr)->GetEventId(), ObjectGuid::Empty); // don't send mail if removing a character
 
     CalendarInviteStore playerInvites = GetPlayerInvites(guid);
@@ -273,7 +274,7 @@ void CalendarMgr::RemoveAllPlayerEventsAndInvites(ObjectGuid guid)
 void CalendarMgr::RemovePlayerGuildEventsAndSignups(ObjectGuid guid, ObjectGuid::LowType guildId)
 {
     for (CalendarEventStore::const_iterator itr = _events.begin(); itr != _events.end(); ++itr)
-        if ((*itr)->GetCreatorGUID() == guid && ((*itr)->IsGuildEvent() || (*itr)->IsGuildAnnouncement()))
+        if ((*itr)->GetOwnerGUID() == guid && ((*itr)->IsGuildEvent() || (*itr)->IsGuildAnnouncement()))
             RemoveEvent((*itr)->GetEventId(), guid);
 
     CalendarInviteStore playerInvites = GetPlayerInvites(guid);
@@ -411,7 +412,7 @@ std::string CalendarEvent::BuildCalendarMailBody() const
     std::ostringstream strm;
 
     // we are supposed to send PackedTime so i used WorldPacket to pack it
-    data.AppendPackedTime(_eventTime);
+    data.AppendPackedTime(_date);
     data >> time;
     strm << time;
     return strm.str();
@@ -420,130 +421,123 @@ std::string CalendarEvent::BuildCalendarMailBody() const
 void CalendarMgr::SendCalendarEventInvite(CalendarInvite const& invite)
 {
     CalendarEvent* calendarEvent = GetEvent(invite.GetEventId());
-    time_t statusTime = invite.GetStatusTime();
-    bool hasStatusTime = statusTime != 946684800;   // 01/01/2000 00:00:00
 
     ObjectGuid invitee = invite.GetInviteeGUID();
     Player* player = ObjectAccessor::FindConnectedPlayer(invitee);
 
     uint8 level = player ? player->getLevel() : Player::GetLevelFromDB(invitee);
 
-    WorldPacket data(SMSG_CALENDAR_EVENT_INVITE, 8 + 8 + 8 + 1 + 1 + 1 + (statusTime ? 4 : 0) + 1);
-    data << invitee;
-    data << uint64(invite.GetEventId());
-    data << uint64(invite.GetInviteId());
-    data << uint8(level);
-    data << uint8(invite.GetStatus());
-    data << uint8(hasStatusTime);
-    if (hasStatusTime)
-        data.AppendPackedTime(statusTime);
-    data << uint8(invite.GetSenderGUID() != invite.GetInviteeGUID()); // false only if the invite is sign-up
+    WorldPackets::Calendar::SCalendarEventInvite packet;
+    packet.EventID = calendarEvent ? calendarEvent->GetEventId() : 0;
+    packet.InviteGuid = invitee;
+    packet.InviteID = calendarEvent ? invite.GetInviteId() : 0;
+    packet.Level = level;
+    packet.ResponseTime = invite.GetResponseTime();
+    packet.Status = invite.GetStatus();
+    packet.Type = calendarEvent ? calendarEvent->IsGuildEvent() : 0; // Correct ?
+    packet.ClearPending = calendarEvent ? !calendarEvent->IsGuildEvent() : true; // Correct ?
 
     if (!calendarEvent) // Pre-invite
     {
         if (Player* playerSender = ObjectAccessor::FindConnectedPlayer(invite.GetSenderGUID()))
-            playerSender->SendDirectMessage(&data);
+            playerSender->SendDirectMessage(packet.Write());
     }
     else
     {
-        if (calendarEvent->GetCreatorGUID() != invite.GetInviteeGUID()) // correct?
-            SendPacketToAllEventRelatives(data, *calendarEvent);
+        if (calendarEvent->GetOwnerGUID() != invite.GetInviteeGUID()) // correct?
+            SendPacketToAllEventRelatives(packet.Write(), *calendarEvent);
     }
 }
 
-void CalendarMgr::SendCalendarEventUpdateAlert(CalendarEvent const& calendarEvent, time_t oldEventTime)
+void CalendarMgr::SendCalendarEventUpdateAlert(CalendarEvent const& calendarEvent, time_t originalDate)
 {
-    WorldPacket data(SMSG_CALENDAR_EVENT_UPDATED_ALERT, 1 + 8 + 4 + 4 + 4 + 1 + 4 +
-        calendarEvent.GetTitle().size() + calendarEvent.GetDescription().size() + 1 + 4 + 4);
-    data << uint8(1);       // unk
-    data << uint64(calendarEvent.GetEventId());
-    data.AppendPackedTime(oldEventTime);
-    data << uint32(calendarEvent.GetFlags());
-    data.AppendPackedTime(calendarEvent.GetEventTime());
-    data << uint8(calendarEvent.GetType());
-    data << int32(calendarEvent.GetDungeonId());
-    data << calendarEvent.GetTitle();
-    data << calendarEvent.GetDescription();
-    data << uint8(CALENDAR_REPEAT_NEVER);   // repeatable
-    data << uint32(CALENDAR_MAX_INVITES);
-    data << uint32(0);      // unk
+    WorldPackets::Calendar::CalendarEventUpdatedAlert packet;
+    packet.ClearPending = true; // FIXME
+    packet.Date = calendarEvent.GetDate();
+    packet.Description = calendarEvent.GetDescription();
+    packet.EventID = calendarEvent.GetEventId();
+    packet.EventName = calendarEvent.GetTitle();
+    packet.EventType = calendarEvent.GetType();
+    packet.Flags = calendarEvent.GetFlags();
+    packet.LockDate = calendarEvent.GetLockDate(); // Always 0 ?
+    packet.OriginalDate = originalDate;
+    packet.TextureID = calendarEvent.GetTextureId();
 
-    SendPacketToAllEventRelatives(data, calendarEvent);
+    SendPacketToAllEventRelatives(packet.Write(), calendarEvent);
 }
 
 void CalendarMgr::SendCalendarEventStatus(CalendarEvent const& calendarEvent, CalendarInvite const& invite)
 {
-    WorldPacket data(SMSG_CALENDAR_EVENT_INVITE_STATUS, 8 + 8 + 4 + 4 + 1 + 1 + 4);
-    data << invite.GetInviteeGUID();
-    data << uint64(calendarEvent.GetEventId());
-    data.AppendPackedTime(calendarEvent.GetEventTime());
-    data << uint32(calendarEvent.GetFlags());
-    data << uint8(invite.GetStatus());
-    data << uint8(invite.GetRank());
-    data.AppendPackedTime(invite.GetStatusTime());
+    WorldPackets::Calendar::CalendarEventInviteStatus packet;
+    packet.ClearPending = true; // FIXME
+    packet.Date = calendarEvent.GetDate();
+    packet.EventID = calendarEvent.GetEventId();
+    packet.Flags = calendarEvent.GetFlags();
+    packet.InviteGuid = invite.GetInviteeGUID();
+    packet.ResponseTime = invite.GetResponseTime();
+    packet.Status = invite.GetStatus();
 
-    SendPacketToAllEventRelatives(data, calendarEvent);
+    SendPacketToAllEventRelatives(packet.Write(), calendarEvent);
 }
 
 void CalendarMgr::SendCalendarEventRemovedAlert(CalendarEvent const& calendarEvent)
 {
-    WorldPacket data(SMSG_CALENDAR_EVENT_REMOVED_ALERT, 1 + 8 + 1);
-    data << uint8(1); // FIXME: If true does not SignalEvent(EVENT_CALENDAR_ACTION_PENDING)
-    data << uint64(calendarEvent.GetEventId());
-    data.AppendPackedTime(calendarEvent.GetEventTime());
+    WorldPackets::Calendar::CalendarEventRemovedAlert packet;
+    packet.ClearPending = true; // FIXME
+    packet.Date = calendarEvent.GetDate();
+    packet.EventID = calendarEvent.GetEventId();
 
-    SendPacketToAllEventRelatives(data, calendarEvent);
+    SendPacketToAllEventRelatives(packet.Write(), calendarEvent);
 }
 
 void CalendarMgr::SendCalendarEventInviteRemove(CalendarEvent const& calendarEvent, CalendarInvite const& invite, uint32 flags)
 {
-    WorldPacket data(SMSG_CALENDAR_EVENT_INVITE_REMOVED, 8 + 4 + 4 + 1);
-    data << invite.GetInviteeGUID();
-    data << uint64(invite.GetEventId());
-    data << uint32(flags);
-    data << uint8(1); // FIXME
+    WorldPackets::Calendar::CalendarEventInviteRemoved packet;
+    packet.ClearPending = true; // FIXME
+    packet.EventID = calendarEvent.GetEventId();
+    packet.Flags = flags;
+    packet.InviteGuid = invite.GetInviteeGUID();
 
-    SendPacketToAllEventRelatives(data, calendarEvent);
+    SendPacketToAllEventRelatives(packet.Write(), calendarEvent);
 }
 
 void CalendarMgr::SendCalendarEventModeratorStatusAlert(CalendarEvent const& calendarEvent, CalendarInvite const& invite)
 {
-    WorldPacket data(SMSG_CALENDAR_EVENT_INVITE_MODERATOR_STATUS, 8 + 8 + 1 + 1);
-    data << invite.GetInviteeGUID();
-    data << uint64(invite.GetEventId());
-    data << uint8(invite.GetRank());
-    data << uint8(1); // Unk boolean - Display to client?
+    WorldPackets::Calendar::CalendarEventInviteModeratorStatus packet;
+    packet.ClearPending = true; // FIXME
+    packet.EventID = calendarEvent.GetEventId();
+    packet.InviteGuid = invite.GetInviteeGUID();
+    packet.Status = invite.GetStatus();
 
-    SendPacketToAllEventRelatives(data, calendarEvent);
+    SendPacketToAllEventRelatives(packet.Write(), calendarEvent);
 }
 
 void CalendarMgr::SendCalendarEventInviteAlert(CalendarEvent const& calendarEvent, CalendarInvite const& invite)
 {
-    WorldPacket data(SMSG_CALENDAR_EVENT_INVITE_ALERT);
-    data << uint64(calendarEvent.GetEventId());
-    data << calendarEvent.GetTitle();
-    data.AppendPackedTime(calendarEvent.GetEventTime());
-    data << uint32(calendarEvent.GetFlags());
-    data << uint32(calendarEvent.GetType());
-    data << int32(calendarEvent.GetDungeonId());
-    data << uint64(invite.GetInviteId());
+    WorldPackets::Calendar::CalendarEventInviteAlert packet;
+    packet.Date = calendarEvent.GetDate();
+    packet.EventID = calendarEvent.GetEventId();
+    packet.EventName = calendarEvent.GetTitle();
+    packet.EventType = calendarEvent.GetType();
+    packet.Flags = calendarEvent.GetFlags();
+    packet.InviteID = invite.GetInviteId();
+    packet.InvitedByGuid = invite.GetSenderGUID();
+    packet.ModeratorStatus = invite.GetRank();
+    packet.OwnerGuid = calendarEvent.GetOwnerGUID();
+    packet.Status = invite.GetStatus();
+    packet.TextureID = calendarEvent.GetTextureId();
 
     Guild* guild = sGuildMgr->GetGuildById(calendarEvent.GetGuildId());
-    data << (guild ? guild->GetGUID() : ObjectGuid::Empty);
-
-    data << uint8(invite.GetStatus());
-    data << uint8(invite.GetRank());
-    data << calendarEvent.GetCreatorGUID();
-    data << invite.GetSenderGUID();
+    packet.EventGuildID = guild ? guild->GetGUID() : ObjectGuid::Empty;
 
     if (calendarEvent.IsGuildEvent() || calendarEvent.IsGuildAnnouncement())
     {
         if (guild)
-            guild->BroadcastPacket(&data);
+            guild->BroadcastPacket(packet.Write());
     }
     else
         if (Player* player = ObjectAccessor::FindConnectedPlayer(invite.GetInviteeGUID()))
-            player->SendDirectMessage(&data);
+            player->SendDirectMessage(packet.Write());
 }
 
 void CalendarMgr::SendCalendarEvent(ObjectGuid guid, CalendarEvent const& calendarEvent, CalendarSendEventType sendType)
@@ -554,105 +548,99 @@ void CalendarMgr::SendCalendarEvent(ObjectGuid guid, CalendarEvent const& calend
 
     CalendarInviteStore const& eventInviteeList = _invites[calendarEvent.GetEventId()];
 
-    WorldPacket data(SMSG_CALENDAR_SEND_EVENT, 60 + eventInviteeList.size() * 32);
-    data << uint8(sendType);
-    data << calendarEvent.GetCreatorGUID();
-    data << uint64(calendarEvent.GetEventId());
-    data << calendarEvent.GetTitle();
-    data << calendarEvent.GetDescription();
-    data << uint8(calendarEvent.GetType());
-    data << uint8(CALENDAR_REPEAT_NEVER);   // repeatable
-    data << uint32(CALENDAR_MAX_INVITES);
-    data << int32(calendarEvent.GetDungeonId());
-    data << uint32(calendarEvent.GetFlags());
-    data.AppendPackedTime(calendarEvent.GetEventTime());
-    data.AppendPackedTime(calendarEvent.GetTimeZoneTime());
+    WorldPackets::Calendar::CalendarSendEvent packet;
+    packet.Date = calendarEvent.GetDate();
+    packet.Description = calendarEvent.GetDescription();
+    packet.EventID = calendarEvent.GetEventId();
+    packet.EventName = calendarEvent.GetTitle();
+    packet.EventType = sendType;
+    packet.Flags = calendarEvent.GetFlags();
+    packet.GetEventType = calendarEvent.GetType();
+    packet.LockDate = calendarEvent.GetLockDate(); // Always 0 ?
+    packet.OwnerGuid = calendarEvent.GetOwnerGUID();
+    packet.TextureID = calendarEvent.GetTextureId();
 
     Guild* guild = sGuildMgr->GetGuildById(calendarEvent.GetGuildId());
-    data << (guild ? guild->GetGUID() : ObjectGuid::Empty);
+    packet.EventGuildID = (guild ? guild->GetGUID() : ObjectGuid::Empty);
 
-    data << uint32(eventInviteeList.size());
-    for (CalendarInviteStore::const_iterator itr = eventInviteeList.begin(); itr != eventInviteeList.end(); ++itr)
+    for (auto const& calendarInvite : eventInviteeList)
     {
-        CalendarInvite const* calendarInvite = (*itr);
         ObjectGuid inviteeGuid = calendarInvite->GetInviteeGUID();
         Player* invitee = ObjectAccessor::FindPlayer(inviteeGuid);
 
         uint8 inviteeLevel = invitee ? invitee->getLevel() : Player::GetLevelFromDB(inviteeGuid);
         ObjectGuid::LowType inviteeGuildId = invitee ? invitee->GetGuildId() : Player::GetGuildIdFromDB(inviteeGuid);
 
-        data << inviteeGuid;
-        data << uint8(inviteeLevel);
-        data << uint8(calendarInvite->GetStatus());
-        data << uint8(calendarInvite->GetRank());
-        data << uint8(calendarEvent.IsGuildEvent() && calendarEvent.GetGuildId() == inviteeGuildId);
-        data << uint64(calendarInvite->GetInviteId());
-        data.AppendPackedTime(calendarInvite->GetStatusTime());
-        data << calendarInvite->GetText();
+        WorldPackets::Calendar::CalendarEventInviteInfo inviteInfo;
+        inviteInfo.Guid = inviteeGuid;
+        inviteInfo.Level = inviteeLevel;
+        inviteInfo.Status = calendarInvite->GetStatus();
+        inviteInfo.Moderator = calendarInvite->GetRank();
+        inviteInfo.InviteType = calendarEvent.IsGuildEvent() && calendarEvent.GetGuildId() == inviteeGuildId;
+        inviteInfo.InviteID = calendarInvite->GetInviteId();
+        inviteInfo.ResponseTime = calendarInvite->GetResponseTime();
+        inviteInfo.Notes = calendarInvite->GetNote();
+
+        packet.Invites.push_back(inviteInfo);
     }
 
-    player->SendDirectMessage(&data);
+    player->SendDirectMessage(packet.Write());
 }
 
 void CalendarMgr::SendCalendarEventInviteRemoveAlert(ObjectGuid guid, CalendarEvent const& calendarEvent, CalendarInviteStatus status)
 {
     if (Player* player = ObjectAccessor::FindConnectedPlayer(guid))
     {
-        WorldPacket data(SMSG_CALENDAR_EVENT_INVITE_REMOVED_ALERT, 8 + 4 + 4 + 1);
-        data << uint64(calendarEvent.GetEventId());
-        data.AppendPackedTime(calendarEvent.GetEventTime());
-        data << uint32(calendarEvent.GetFlags());
-        data << uint8(status);
+        WorldPackets::Calendar::CalendarEventInviteRemovedAlert packet;
+        packet.Date = calendarEvent.GetDate();
+        packet.EventID = calendarEvent.GetEventId();
+        packet.Flags = calendarEvent.GetFlags();
+        packet.Status = status;
 
-        player->SendDirectMessage(&data);
+        player->SendDirectMessage(packet.Write());
     }
 }
 
 void CalendarMgr::SendCalendarClearPendingAction(ObjectGuid guid)
 {
     if (Player* player = ObjectAccessor::FindConnectedPlayer(guid))
-    {
-        WorldPacket data(SMSG_CALENDAR_CLEAR_PENDING_ACTION, 0);
-        player->SendDirectMessage(&data);
-    }
+        player->SendDirectMessage(WorldPackets::Calendar::CalendarClearPendingAction().Write());
 }
 
 void CalendarMgr::SendCalendarCommandResult(ObjectGuid guid, CalendarError err, char const* param /*= NULL*/)
 {
     if (Player* player = ObjectAccessor::FindConnectedPlayer(guid))
     {
-        WorldPacket data(SMSG_CALENDAR_COMMAND_RESULT, 0);
-        data << uint32(0);
-        data << uint8(0);
+        WorldPackets::Calendar::CalendarCommandResult packet;
+        packet.Command = 1; // FIXME
+        packet.Result = err;
+
         switch (err)
         {
             case CALENDAR_ERROR_OTHER_INVITES_EXCEEDED:
             case CALENDAR_ERROR_ALREADY_INVITED_TO_EVENT_S:
             case CALENDAR_ERROR_IGNORING_YOU_S:
-                data << param;
+                packet.Name = param;
                 break;
             default:
-                data << uint8(0);
                 break;
         }
 
-        data << uint32(err);
-
-        player->SendDirectMessage(&data);
+        player->SendDirectMessage(packet.Write());
     }
 }
 
-void CalendarMgr::SendPacketToAllEventRelatives(WorldPacket& packet, CalendarEvent const& calendarEvent)
+void CalendarMgr::SendPacketToAllEventRelatives(WorldPacket const* packet, CalendarEvent const& calendarEvent)
 {
     // Send packet to all guild members
     if (calendarEvent.IsGuildEvent() || calendarEvent.IsGuildAnnouncement())
         if (Guild* guild = sGuildMgr->GetGuildById(calendarEvent.GetGuildId()))
-            guild->BroadcastPacket(&packet);
+            guild->BroadcastPacket(packet);
 
     // Send packet to all invitees if event is non-guild, in other case only to non-guild invitees (packet was broadcasted for them)
     CalendarInviteStore invites = _invites[calendarEvent.GetEventId()];
     for (CalendarInviteStore::iterator itr = invites.begin(); itr != invites.end(); ++itr)
         if (Player* player = ObjectAccessor::FindConnectedPlayer((*itr)->GetInviteeGUID()))
             if (!calendarEvent.IsGuildEvent() || (calendarEvent.IsGuildEvent() && player->GetGuildId() != calendarEvent.GetGuildId()))
-                player->SendDirectMessage(&packet);
+                player->SendDirectMessage(packet);
 }
diff --git a/src/server/game/Calendar/CalendarMgr.h b/src/server/game/Calendar/CalendarMgr.h
index 8122f41c0f5..5449c9c739f 100644
--- a/src/server/game/Calendar/CalendarMgr.h
+++ b/src/server/game/Calendar/CalendarMgr.h
@@ -123,9 +123,10 @@ enum CalendarError
     CALENDAR_ERROR_NO_MODERATOR                 = 40
 };
 
-#define CALENDAR_MAX_EVENTS         30
-#define CALENDAR_MAX_GUILD_EVENTS   100
-#define CALENDAR_MAX_INVITES        100
+#define CALENDAR_MAX_EVENTS             30
+#define CALENDAR_MAX_GUILD_EVENTS       100
+#define CALENDAR_MAX_INVITES            100
+#define CALENDAR_DEFAULT_RESPONSE_TIME  946684800 // 01/01/2000 00:00:00
 
 struct CalendarInvite
 {
@@ -136,19 +137,19 @@ struct CalendarInvite
             _eventId = eventId;
             _invitee = calendarInvite.GetInviteeGUID();
             _senderGUID = calendarInvite.GetSenderGUID();
-            _statusTime = calendarInvite.GetStatusTime();
+            _responseTime = calendarInvite.GetResponseTime();
             _status = calendarInvite.GetStatus();
             _rank = calendarInvite.GetRank();
-            _text = calendarInvite.GetText();
+            _note = calendarInvite.GetNote();
         }
 
-        CalendarInvite() : _inviteId(1), _eventId(0), _invitee(), _senderGUID(), _statusTime(time(NULL)),
-            _status(CALENDAR_STATUS_INVITED), _rank(CALENDAR_RANK_PLAYER), _text("") { }
+        CalendarInvite() : _inviteId(1), _eventId(0), _invitee(), _senderGUID(), _responseTime(0),
+            _status(CALENDAR_STATUS_INVITED), _rank(CALENDAR_RANK_PLAYER), _note("") { }
 
-        CalendarInvite(uint64 inviteId, uint64 eventId, ObjectGuid invitee, ObjectGuid senderGUID, time_t statusTime,
-            CalendarInviteStatus status, CalendarModerationRank rank, std::string text) :
-            _inviteId(inviteId), _eventId(eventId), _invitee(invitee), _senderGUID(senderGUID), _statusTime(statusTime),
-            _status(status), _rank(rank), _text(text) { }
+        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(note) { }
 
         ~CalendarInvite();
 
@@ -164,11 +165,11 @@ struct CalendarInvite
         void SetInvitee(ObjectGuid guid) { _invitee = guid; }
         ObjectGuid GetInviteeGUID() const { return _invitee; }
 
-        void SetStatusTime(time_t statusTime) { _statusTime = statusTime; }
-        time_t GetStatusTime() const { return _statusTime; }
+        void SetResponseTime(time_t responseTime) { _responseTime = responseTime; }
+        time_t GetResponseTime() const { return _responseTime; }
 
-        void SetText(std::string const& text) { _text = text; }
-        std::string GetText() const { return _text; }
+        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; }
@@ -181,10 +182,10 @@ struct CalendarInvite
         uint64 _eventId;
         ObjectGuid _invitee;
         ObjectGuid _senderGUID;
-        time_t _statusTime;
+        time_t _responseTime;
         CalendarInviteStatus _status;
         CalendarModerationRank _rank;
-        std::string _text;
+        std::string _note;
 };
 
 struct CalendarEvent
@@ -193,36 +194,35 @@ struct CalendarEvent
         CalendarEvent(CalendarEvent const& calendarEvent, uint64 eventId)
         {
             _eventId = eventId;
-            _creatorGUID = calendarEvent.GetCreatorGUID();
-            _guildId = calendarEvent.GetGuildId();
-            _type = calendarEvent.GetType();
-            _dungeonId = calendarEvent.GetDungeonId();
-            _eventTime = calendarEvent.GetEventTime();
+            _ownerGUID = calendarEvent.GetOwnerGUID();
+            _eventGuildId = calendarEvent.GetGuildId();
+            _eventType = calendarEvent.GetType();
+            _textureId = calendarEvent.GetTextureId();
+            _date = calendarEvent.GetDate();
             _flags = calendarEvent.GetFlags();
-            _timezoneTime = calendarEvent.GetTimeZoneTime();
             _title = calendarEvent.GetTitle();
             _description = calendarEvent.GetDescription();
+            _lockDate = calendarEvent.GetLockDate();
         }
 
-        CalendarEvent(uint64 eventId, ObjectGuid creatorGUID, ObjectGuid::LowType guildId, CalendarEventType type, int32 dungeonId,
-            time_t eventTime, uint32 flags, time_t timezoneTime, std::string title, std::string description) :
-            _eventId(eventId), _creatorGUID(creatorGUID), _guildId(guildId), _type(type), _dungeonId(dungeonId),
-            _eventTime(eventTime), _flags(flags), _timezoneTime(timezoneTime), _title(title),
-            _description(description) { }
+        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(title), _description(description), _lockDate(lockDate) { }
 
-        CalendarEvent() : _eventId(1), _creatorGUID(), _guildId(UI64LIT(0)), _type(CALENDAR_TYPE_OTHER), _dungeonId(-1), _eventTime(0),
-            _flags(0), _timezoneTime(0), _title(""), _description("") { }
+        CalendarEvent() : _eventId(1), _ownerGUID(), _eventGuildId(UI64LIT(0)), _eventType(CALENDAR_TYPE_OTHER), _textureId(-1), _date(0),
+            _flags(0), _title(""), _description(""), _lockDate(0) { }
 
         ~CalendarEvent();
 
         void SetEventId(uint64 eventId) { _eventId = eventId; }
         uint64 GetEventId() const { return _eventId; }
 
-        void SetCreatorGUID(ObjectGuid guid) { _creatorGUID = guid; }
-        ObjectGuid GetCreatorGUID() const { return _creatorGUID; }
+        void SetOwnerGUID(ObjectGuid guid) { _ownerGUID = guid; }
+        ObjectGuid GetOwnerGUID() const { return _ownerGUID; }
 
-        void SetGuildId(ObjectGuid::LowType guildId) { _guildId = guildId; }
-        ObjectGuid::LowType GetGuildId() const { return _guildId; }
+        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; }
@@ -230,42 +230,43 @@ struct CalendarEvent
         void SetDescription(std::string const& description) { _description = description; }
         std::string GetDescription() const { return _description; }
 
-        void SetType(CalendarEventType type) { _type = type; }
-        CalendarEventType GetType() const { return _type; }
+        void SetType(CalendarEventType eventType) { _eventType = eventType; }
+        CalendarEventType GetType() const { return _eventType; }
 
-        void SetDungeonId(int32 dungeonId) { _dungeonId = dungeonId; }
-        int32 GetDungeonId() const { return _dungeonId; }
+        void SetTextureId(int32 textureId) { _textureId = textureId; }
+        int32 GetTextureId() const { return _textureId; }
 
-        void SetEventTime(time_t eventTime) { _eventTime = eventTime; }
-        time_t GetEventTime() const { return _eventTime; }
+        void SetDate(time_t date) { _date = date; }
+        time_t GetDate() const { return _date; }
 
         void SetFlags(uint32 flags) { _flags = flags; }
         uint32 GetFlags() const { return _flags; }
 
-        void SetTimeZoneTime(time_t timezoneTime) { _timezoneTime = timezoneTime; }
-        time_t GetTimeZoneTime() const { return _timezoneTime; }
-
         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; }
 
         std::string BuildCalendarMailSubject(ObjectGuid remover) const;
         std::string BuildCalendarMailBody() const;
 
     private:
         uint64 _eventId;
-        ObjectGuid _creatorGUID;
-        ObjectGuid::LowType _guildId;
-        CalendarEventType _type;
-        int32 _dungeonId;
-        time_t _eventTime;
+        ObjectGuid _ownerGUID;
+        ObjectGuid::LowType _eventGuildId;
+        CalendarEventType _eventType;
+        int32 _textureId;
+        time_t _date;
         uint32 _flags;
-        time_t _timezoneTime;
         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;
+typedef std::map<uint64 /* eventID */, CalendarInviteStore > CalendarEventInviteStore;
 
 class CalendarMgr
 {
@@ -324,14 +325,14 @@ class CalendarMgr
         void SendCalendarEventInviteAlert(CalendarEvent const& calendarEvent, CalendarInvite const& invite);
         void SendCalendarEventInviteRemove(CalendarEvent const& calendarEvent, CalendarInvite const& invite, uint32 flags);
         void SendCalendarEventInviteRemoveAlert(ObjectGuid guid, CalendarEvent const& calendarEvent, CalendarInviteStatus status);
-        void SendCalendarEventUpdateAlert(CalendarEvent const& calendarEvent, time_t oldEventTime);
+        void SendCalendarEventUpdateAlert(CalendarEvent const& calendarEvent, time_t originalDate);
         void SendCalendarEventStatus(CalendarEvent const& calendarEvent, CalendarInvite const& invite);
         void SendCalendarEventRemovedAlert(CalendarEvent const& calendarEvent);
         void SendCalendarEventModeratorStatusAlert(CalendarEvent const& calendarEvent, CalendarInvite const& invite);
         void SendCalendarClearPendingAction(ObjectGuid guid);
         void SendCalendarCommandResult(ObjectGuid guid, CalendarError err, char const* param = NULL);
 
-        void SendPacketToAllEventRelatives(WorldPacket& packet, CalendarEvent const& calendarEvent);
+        void SendPacketToAllEventRelatives(WorldPacket const* packet, CalendarEvent const& calendarEvent);
 };
 
 #define sCalendarMgr CalendarMgr::instance()