Core/Support: Update the support/ticket system to 6.x

Core/Mail: fix a logic error introduced in 829e11b6623f967672143d79cd8d31772f54866d

6 files changed, 607 insertions, 12 deletions

diff --git a/src/server/game/Server/Packets/LFGPackets.cpp b/src/server/game/Server/Packets/LFGPackets.cpp
new file mode 100644
index 00000000000..4e7bc35b55a
--- /dev/null
+++ b/src/server/game/Server/Packets/LFGPackets.cpp
@@ -0,0 +1,28 @@
+/*
+ * 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 "LFGPackets.h"
+
+ByteBuffer& operator>>(ByteBuffer& data, WorldPackets::LFG::RideTicket& ticket)
+{
+    data >> ticket.RequesterGuid;
+    data >> ticket.Id;
+    data >> ticket.Type;
+    data >> ticket.Time;
+
+    return data;
+}
diff --git a/src/server/game/Server/Packets/LFGPackets.h b/src/server/game/Server/Packets/LFGPackets.h
new file mode 100644
index 00000000000..e62cb47b41a
--- /dev/null
+++ b/src/server/game/Server/Packets/LFGPackets.h
@@ -0,0 +1,39 @@
+/*
+ * 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 LFGPackets_h__
+#define LFGPackets_h__
+
+#include "ObjectGuid.h"
+
+namespace WorldPackets
+{
+    namespace LFG
+    {
+        struct RideTicket
+        {
+            ObjectGuid RequesterGuid;
+            int32 Id = 0;
+            int32 Type = 0;
+            time_t Time = 0;
+        };
+    }
+}
+
+ByteBuffer& operator>>(ByteBuffer& data, WorldPackets::LFG::RideTicket& ticket);
+
+#endif // LFGPackets_h__
diff --git a/src/server/game/Server/Packets/SystemPackets.cpp b/src/server/game/Server/Packets/SystemPackets.cpp
index 1a01c2d28c6..a88895fb35c 100644
--- a/src/server/game/Server/Packets/SystemPackets.cpp
+++ b/src/server/game/Server/Packets/SystemPackets.cpp
@@ -39,18 +39,20 @@ WorldPacket const* WorldPackets::System::FeatureSystemStatus::Write()
     _worldPacket.WriteBit(SessionAlert.HasValue);
     _worldPacket.WriteBit(RecruitAFriendSendingEnabled);
     _worldPacket.WriteBit(CharUndeleteEnabled);
-    _worldPacket.WriteBit(UnkBit21);
-    _worldPacket.WriteBit(UnkBit22);
+    _worldPacket.WriteBit(RestrictedAccount);
+    _worldPacket.WriteBit(TutorialsEnabled);
     _worldPacket.WriteBit(UnkBit90);
     _worldPacket.WriteBit(TwitterEnabled);
     _worldPacket.WriteBit(UnkBit61);
 
+    _worldPacket.FlushBits();
+
     if (EuropaTicketSystemStatus.HasValue)
     {
-        _worldPacket.WriteBit(EuropaTicketSystemStatus.Value.UnkBit0);
-        _worldPacket.WriteBit(EuropaTicketSystemStatus.Value.UnkBit1);
-        _worldPacket.WriteBit(EuropaTicketSystemStatus.Value.TicketSystemEnabled);
-        _worldPacket.WriteBit(EuropaTicketSystemStatus.Value.SubmitBugEnabled);
+        _worldPacket.WriteBit(EuropaTicketSystemStatus.Value.TicketsEnabled);
+        _worldPacket.WriteBit(EuropaTicketSystemStatus.Value.BugsEnabled);
+        _worldPacket.WriteBit(EuropaTicketSystemStatus.Value.ComplaintsEnabled);
+        _worldPacket.WriteBit(EuropaTicketSystemStatus.Value.SuggestionsEnabled);
 
         _worldPacket << uint32(EuropaTicketSystemStatus.Value.ThrottleState.MaxTries);
         _worldPacket << uint32(EuropaTicketSystemStatus.Value.ThrottleState.PerMilliseconds);
diff --git a/src/server/game/Server/Packets/SystemPackets.h b/src/server/game/Server/Packets/SystemPackets.h
index 897726575a4..d20d35649fb 100644
--- a/src/server/game/Server/Packets/SystemPackets.h
+++ b/src/server/game/Server/Packets/SystemPackets.h
@@ -37,10 +37,10 @@ namespace WorldPackets
 
             struct EuropaTicketConfig
             {
-                bool UnkBit0             = false;
-                bool UnkBit1             = false;
-                bool TicketSystemEnabled = false;
-                bool SubmitBugEnabled    = false;
+                bool TicketsEnabled     = false;
+                bool BugsEnabled        = false;
+                bool ComplaintsEnabled  = false;
+                bool SuggestionsEnabled = false;
 
                 SavedThrottleObjectState ThrottleState;
             };
@@ -76,8 +76,8 @@ namespace WorldPackets
             bool BpayStoreDisabledByParentalControls = false;
             bool TwitterEnabled                      = false;
 
-            bool UnkBit21                            = false;
-            bool UnkBit22                            = false;
+            bool RestrictedAccount                   = false;
+            bool TutorialsEnabled                    = false;
             bool UnkBit90                            = false;
             bool UnkBit61                            = false;
         };
diff --git a/src/server/game/Server/Packets/TicketPackets.cpp b/src/server/game/Server/Packets/TicketPackets.cpp
index 8567cebd736..1a4d4d00c0a 100644
--- a/src/server/game/Server/Packets/TicketPackets.cpp
+++ b/src/server/game/Server/Packets/TicketPackets.cpp
@@ -15,8 +15,21 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "LFGPackets.h"
+#include "PacketUtilities.h"
 #include "TicketPackets.h"
 
+using namespace WorldPackets;
+
+ByteBuffer& operator>>(ByteBuffer& data, WorldPackets::Ticket::SupportTicketHeader& header)
+{
+    data >> header.MapID;
+    data >> header.Position;
+    data >> header.Facing;
+
+    return data;
+}
+
 WorldPacket const* WorldPackets::Ticket::GMTicketSystemStatus::Write()
 {
     _worldPacket << int32(Status);
@@ -80,3 +93,281 @@ WorldPacket const* WorldPackets::Ticket::GMTicketGetTicketResponse::Write()
 
     return &_worldPacket;
 }
+
+void WorldPackets::Ticket::GMTicketCreate::Read()
+{
+    _worldPacket >> Map;
+    _worldPacket >> Pos;
+    _worldPacket >> Flags;
+
+    uint16 descLength = _worldPacket.ReadBits(11);
+    Description = _worldPacket.ReadString(descLength);
+    _worldPacket.ResetBitPos();
+
+    NeedMoreHelp = _worldPacket.ReadBit();
+    NeedResponse = _worldPacket.ReadBit();
+    _worldPacket >> DataLength;
+
+    if (DataLength > 0)
+    {
+        _worldPacket >> ChatHistoryData.TextCount;
+        for (uint8 i = 0; i < ChatHistoryData.TextCount; ++i)
+            ChatHistoryData.Sent.push_back(_worldPacket.read<uint32>());
+        
+        _worldPacket >> ChatHistoryData.DecompressedSize;
+
+        //Note: don't ask why, but it works...
+        uint32 realLength = DataLength - ((ChatHistoryData.TextCount * 4) + 5);
+        ChatHistoryData.Data.resize(realLength);
+        _worldPacket.read(ChatHistoryData.Data.contents(), realLength);
+    }
+}
+
+void WorldPackets::Ticket::GMTicketUpdateText::Read()
+{
+    uint16 descLength = _worldPacket.ReadBits(11);
+    Description = _worldPacket.ReadString(descLength);
+}
+
+WorldPacket const* WorldPackets::Ticket::GMTicketUpdate::Write()
+{
+    _worldPacket << uint8(Result);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Ticket::GMTicketStatusUpdate::Write()
+{
+    _worldPacket << int32(StatusInt);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Ticket::GMTicketResponse::Write()
+{
+    _worldPacket << uint32(TicketID);
+    _worldPacket << uint32(ResponseID);
+
+    _worldPacket.WriteBits(Description.size(), 11);
+    _worldPacket.WriteBits(ResponseText.size(), 14);
+    _worldPacket.FlushBits();
+
+    _worldPacket.WriteString(Description);
+    _worldPacket.WriteString(ResponseText);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Ticket::GMTicketResolveResponse::Write()
+{
+    _worldPacket.WriteBit(ShowSurvey);
+
+    _worldPacket.FlushBits();
+    return &_worldPacket;
+}
+
+void WorldPackets::Ticket::GMSurveySubmit::Read()
+{
+    _worldPacket >> SurveyID;
+
+    SurveyQuestion.resize(_worldPacket.ReadBits(4));
+    uint16 commentLength = _worldPacket.ReadBits(11);
+
+    for (auto& q : SurveyQuestion)
+    {
+        _worldPacket >> q.QuestionID;
+        _worldPacket >> q.Answer;
+        q.AnswerComment = _worldPacket.ReadString(_worldPacket.ReadBits(11));
+    }
+
+    Comment = _worldPacket.ReadString(commentLength);
+}
+
+void WorldPackets::Ticket::SupportTicketSubmitBug::Read()
+{  
+    _worldPacket >> Header;
+    Note = _worldPacket.ReadString(_worldPacket.ReadBits(10));
+}
+
+void WorldPackets::Ticket::SupportTicketSubmitSuggestion::Read()
+{
+    _worldPacket >> Header;
+    Note = _worldPacket.ReadString(_worldPacket.ReadBits(10));
+}
+
+WorldPackets::Ticket::SupportTicketSubmitComplaint::SupportTicketChatLine::SupportTicketChatLine(ByteBuffer& data)
+{
+    data >> Timestamp;
+    uint16 textLength = data.ReadBits(12);
+    data.ResetBitPos();
+    Text = data.ReadString(textLength);
+}
+
+WorldPackets::Ticket::SupportTicketSubmitComplaint::SupportTicketChatLine::SupportTicketChatLine(uint32 timestamp, std::string const& text)
+{
+    Timestamp = timestamp;
+    Text = text;
+}
+
+ByteBuffer& operator>>(ByteBuffer& data, WorldPackets::Ticket::SupportTicketSubmitComplaint::SupportTicketChatLine& line)
+{
+    data >> line.Timestamp;
+    uint16 textLength = data.ReadBits(12);
+    data.ResetBitPos();
+    line.Text = data.ReadString(textLength);
+
+    return data;
+}
+
+ByteBuffer& operator>>(ByteBuffer& data, WorldPackets::Ticket::SupportTicketSubmitComplaint::SupportTicketChatLog& chatlog)
+{
+    uint32 linesCount = data.read<uint32>();
+
+    for (uint32 i = 0; i < linesCount; i++)
+        chatlog.Lines.emplace_back(data);
+
+    bool hasReportLineIndex = data.ReadBit();
+    if (hasReportLineIndex)
+        chatlog.ReportLineIndex.Set(data.read<uint32>());
+
+    data.ResetBitPos();
+
+    return data;
+}
+
+ByteBuffer& operator>>(ByteBuffer& data, WorldPackets::Ticket::SupportTicketSubmitComplaint::SupportTicketMailInfo& mail)
+{
+    data >> mail.MailID;
+    uint16 bodyLength = data.ReadBits(13);
+    uint16 subjectLength = data.ReadBits(9);
+
+    mail.MailBody = data.ReadString(bodyLength);
+    mail.MailSubject = data.ReadString(subjectLength);
+
+    return data;
+}
+
+ByteBuffer& operator>>(ByteBuffer& data, WorldPackets::Ticket::SupportTicketSubmitComplaint::SupportTicketCalendarEventInfo& event)
+{
+    data >> event.EventID;
+    data >> event.InviteID;
+    uint8 titleLength = data.ReadBits(8);
+
+    event.EventTitle = data.ReadString(titleLength);
+
+    return data;
+}
+
+ByteBuffer& operator>>(ByteBuffer& data, WorldPackets::Ticket::SupportTicketSubmitComplaint::SupportTicketPetInfo& pet)
+{
+    data >> pet.PetID;
+    uint8 nameLength = data.ReadBits(8);
+
+    pet.PetName = data.ReadString(nameLength);
+
+    return data;
+}
+
+ByteBuffer& operator>>(ByteBuffer& data, WorldPackets::Ticket::SupportTicketSubmitComplaint::SupportTicketGuildInfo& guild)
+{
+    data >> guild.GuildID;
+    uint8 nameLength = data.ReadBits(8);
+
+    guild.GuildName = data.ReadString(nameLength);
+
+    return data;
+}
+
+ByteBuffer& operator>>(ByteBuffer& data, WorldPackets::Ticket::SupportTicketSubmitComplaint::Struct5E4383& str)
+{
+    data >> str.RideTicket;
+    data >> str._40;
+    data >> str._56;
+    data >> str._72;
+
+    uint8 _88Length = data.ReadBits(8);
+    uint8 _217Length = data.ReadBits(8);
+    uint8 _1242Length = data.ReadBits(8);
+
+    str._88 = data.ReadString(_88Length);
+    str._217 = data.ReadString(_217Length);
+    str._1242 = data.ReadString(_1242Length);
+
+    return data;
+}
+
+ByteBuffer& operator>>(ByteBuffer& data, WorldPackets::Ticket::SupportTicketSubmitComplaint::Struct5E3DFB& str)
+{
+    data >> str.RideTicket;
+
+    uint16 _32Length = data.ReadBits(9);
+    data.ResetBitPos();
+
+    str._32 = data.ReadString(_32Length);
+
+    return data;
+}
+
+void WorldPackets::Ticket::SupportTicketSubmitComplaint::Read()
+{
+    _worldPacket >> Header;
+    _worldPacket >> ChatLog;
+    _worldPacket >> TargetCharacterGUID;
+    ComplaintType = _worldPacket.ReadBits(5);
+    
+    uint16 noteLength = _worldPacket.ReadBits(10);
+    bool hasMailInfo = _worldPacket.ReadBit();
+    bool hasCalendarInfo = _worldPacket.ReadBit();
+    bool hasPetInfo = _worldPacket.ReadBit();
+    bool hasGuildInfo = _worldPacket.ReadBit();
+    bool has5E4383 = _worldPacket.ReadBit();
+    bool has5E3DFB = _worldPacket.ReadBit();
+
+    _worldPacket.ResetBitPos();
+
+    Note = _worldPacket.ReadString(noteLength);
+
+    if (hasMailInfo)
+    {
+        _worldPacket >> MailInfo.Value;
+        MailInfo.HasValue = true;
+    }
+
+    if (hasCalendarInfo)
+    {
+        _worldPacket >> CalenderInfo.Value;
+        CalenderInfo.HasValue = true;
+    }
+
+    if (hasPetInfo)
+    {
+        _worldPacket >> PetInfo.Value;
+        PetInfo.HasValue = true;
+    }
+
+    if (hasGuildInfo)
+    {
+        _worldPacket >> GuildInfo.Value;
+        GuildInfo.HasValue = true;
+    }
+
+    if (has5E4383)
+    {
+        _worldPacket >> _5E4383.Value;
+        _5E4383.HasValue = true;
+    }
+
+    if (has5E3DFB)
+    {
+        _worldPacket >> _5E3DFB.Value;
+        _5E3DFB.HasValue = true;
+    }
+}
+
+WorldPacket const* WorldPackets::Ticket::ComplaintResult::Write()
+{
+    _worldPacket << uint32(ComplaintType);
+    _worldPacket << uint8(Result);
+
+    return &_worldPacket;
+}
diff --git a/src/server/game/Server/Packets/TicketPackets.h b/src/server/game/Server/Packets/TicketPackets.h
index 8a5ae862f84..e11adf912ed 100644
--- a/src/server/game/Server/Packets/TicketPackets.h
+++ b/src/server/game/Server/Packets/TicketPackets.h
@@ -19,11 +19,20 @@
 #define TicketPackets_h__
 
 #include "Packet.h"
+#include "LFGPackets.h"
+#include <G3D/Vector3.h>
 
 namespace WorldPackets
 {
     namespace Ticket
     {
+        struct SupportTicketHeader
+        {
+            int32 MapID = 0;
+            G3D::Vector3 Position;
+            float Facing = 0.0f;
+        };
+
         class GMTicketGetSystemStatus final : public ClientPacket
         {
         public:
@@ -107,6 +116,120 @@ namespace WorldPackets
             Optional<GMTicketInfo> Info;
         };
 
+        class GMTicketCreate final : public ClientPacket
+        {
+        public:
+            struct ChatHistoryData
+            {
+                uint8 TextCount = 0;
+                std::vector<uint32> Sent;
+                uint32 DecompressedSize = 0;
+                ByteBuffer Data;
+            };
+
+            GMTicketCreate(WorldPacket&& packet) : ClientPacket(CMSG_GM_TICKET_CREATE, std::move(packet)) { }
+
+            void Read() override;
+
+            int32 Map = 0;
+            G3D::Vector3 Pos;
+            uint8 Flags = 0;
+            std::string Description;
+            bool NeedMoreHelp = false;
+            bool NeedResponse = false;
+            uint32 DataLength = 0;
+            ChatHistoryData ChatHistoryData; ///< Compressed Data
+        };
+
+        class GMTicketUpdateText final : public ClientPacket
+        {
+        public:
+            GMTicketUpdateText(WorldPacket&& packet) : ClientPacket(CMSG_GM_TICKET_UPDATE_TEXT, std::move(packet)) { }
+
+            void Read() override;
+
+            std::string Description;
+        };
+
+        class GMTicketUpdate final : public ServerPacket
+        {
+        public:
+            GMTicketUpdate() : ServerPacket(SMSG_GM_TICKET_UPDATE, 1) { }
+
+            WorldPacket const* Write() override;
+
+            uint8 Result = 0;
+        };
+
+        class GMTicketStatusUpdate final : public ServerPacket
+        {
+        public:
+            GMTicketStatusUpdate() : ServerPacket(SMSG_GM_TICKET_STATUS_UPDATE, 4) { }
+
+            WorldPacket const* Write() override;
+
+            int32 StatusInt = 0;
+        };
+
+        class GMTicketDelete final : public ClientPacket
+        {
+        public:
+            GMTicketDelete(WorldPacket&& packet) : ClientPacket(CMSG_GM_TICKET_DELETE_TICKET, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class GMTicketResponse final : public ServerPacket
+        {
+        public:
+            GMTicketResponse() : ServerPacket(SMSG_GM_TICKET_RESPONSE, 12) { }
+
+            WorldPacket const* Write() override;
+
+            uint32 TicketID = 0;
+            uint32 ResponseID = 0;
+            std::string Description;
+            std::string ResponseText;
+        };
+
+        class GMTicketResponseResolve final : public ClientPacket
+        {
+        public:
+            GMTicketResponseResolve(WorldPacket&& packet) : ClientPacket(CMSG_GM_TICKET_RESPONSE_RESOLVE, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class GMTicketResolveResponse final : public ServerPacket
+        {
+        public:
+            GMTicketResolveResponse() : ServerPacket(SMSG_GM_TICKET_RESOLVE_RESPONSE, 1) { }
+
+            WorldPacket const* Write() override;
+
+            bool ShowSurvey = false;
+        };
+
+        class GMSurveySubmit final : public ClientPacket
+        {
+        public:
+            struct GMSurveyQuestion
+            {
+                int32 QuestionID = 0;
+                uint8 Answer = 0;
+                std::string AnswerComment;
+            };
+
+            GMSurveySubmit(WorldPacket&& packet) : ClientPacket(CMSG_GM_SURVEY_SUBMIT, std::move(packet)) { }
+
+            void Read() override;
+
+            int32 SurveyID = 0;
+            std::vector<GMSurveyQuestion> SurveyQuestion;
+            std::string Comment;
+
+        };
+
         class GMTicketAcknowledgeSurvey final : public ClientPacket
         {
         public:
@@ -124,6 +247,118 @@ namespace WorldPackets
 
             WorldPacket const* Write() { return &_worldPacket; }
         };
+
+        class SupportTicketSubmitBug final : public ClientPacket
+        {
+        public:
+            SupportTicketSubmitBug(WorldPacket&& packet) : ClientPacket(CMSG_SUPPORT_TICKET_SUBMIT_BUG, std::move(packet)) { }
+
+            void Read() override;
+
+            SupportTicketHeader Header;
+            std::string Note;
+        };
+
+        class SupportTicketSubmitSuggestion final : public ClientPacket
+        {
+        public:
+            SupportTicketSubmitSuggestion(WorldPacket&& packet) : ClientPacket(CMSG_SUPPORT_TICKET_SUBMIT_SUGGESTION, std::move(packet)) { }
+
+            void Read() override;
+
+            SupportTicketHeader Header;
+            std::string Note;
+        };
+
+        class SupportTicketSubmitComplaint final : public ClientPacket
+        {
+        public:
+            struct SupportTicketChatLine
+            {
+                SupportTicketChatLine(ByteBuffer& data);
+                SupportTicketChatLine(uint32 timestamp, std::string const& text);
+
+                uint32 Timestamp = 0;
+                std::string Text;
+            };
+
+            struct SupportTicketChatLog
+            {
+                std::vector<SupportTicketChatLine> Lines;
+                Optional<uint32> ReportLineIndex;
+            };
+
+            struct SupportTicketMailInfo
+            {
+                int32 MailID = 0;
+                std::string MailSubject;
+                std::string MailBody;
+            };
+
+            struct SupportTicketCalendarEventInfo
+            {
+                ObjectGuid EventID;
+                ObjectGuid InviteID;
+                std::string EventTitle;
+            };
+
+            struct SupportTicketPetInfo
+            {
+                ObjectGuid PetID;
+                std::string PetName;
+            };
+
+            struct SupportTicketGuildInfo
+            {
+                ObjectGuid GuildID;
+                std::string GuildName;
+            };
+
+            struct Struct5E4383
+            {
+                WorldPackets::LFG::RideTicket RideTicket;
+                ObjectGuid _40;
+                ObjectGuid _56;
+                ObjectGuid _72;
+                std::string _88;
+                std::string _217;
+                std::string _1242;
+            };
+
+            struct Struct5E3DFB
+            {
+                WorldPackets::LFG::RideTicket RideTicket;
+                std::string _32;
+            };
+
+            SupportTicketSubmitComplaint(WorldPacket&& packet) : ClientPacket(CMSG_SUPPORT_TICKET_SUBMIT_COMPLAINT, std::move(packet)) { }
+
+            void Read() override;
+
+            SupportTicketHeader Header;
+            SupportTicketChatLog ChatLog;
+            ObjectGuid TargetCharacterGUID;
+            uint8 ComplaintType = 0;
+            std::string Note;
+            Optional<SupportTicketMailInfo> MailInfo;
+            Optional<SupportTicketCalendarEventInfo> CalenderInfo;
+            Optional<SupportTicketPetInfo> PetInfo;
+            Optional<SupportTicketGuildInfo> GuildInfo;
+            Optional<Struct5E4383> _5E4383;
+            Optional<Struct5E3DFB> _5E3DFB;
+
+        };
+
+        class ComplaintResult final : public ServerPacket
+        {
+        public:
+            ComplaintResult() : ServerPacket(SMSG_COMPLAINT_RESULT, 9) { }
+
+            WorldPacket const* Write() override;
+
+            uint32 ComplaintType = 0;
+            uint8 Result = 0;
+        };
     }
 }