/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/Controllers/Chat/ChatControllerBase.h>

#include <map>

#include <sstream>

#include <boost/algorithm/string.hpp>

#include <boost/bind.hpp>

#include <boost/date_time/posix_time/posix_time.hpp>

#include <boost/numeric/conversion/cast.hpp>

#include <boost/shared_ptr.hpp>

#include <boost/smart_ptr/make_shared.hpp>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Base/Path.h>

#include <Swiften/Base/String.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Base/format.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/Disco/EntityCapsProvider.h>

#include <Swiften/Elements/Delay.h>

#include <Swiften/Elements/MUCInvitationPayload.h>

#include <Swiften/Elements/MUCUserPayload.h>

#include <Swiften/Queries/Requests/GetSecurityLabelsCatalogRequest.h>

#include <Swift/Controllers/Chat/AutoAcceptMUCInviteDecider.h>

#include <Swift/Controllers/Chat/ChatMessageParser.h>

}

}

void ChatControllerBase::setCanStartImpromptuChats(bool supportsImpromptu) {

if (chatWindow_) {

chatWindow_->setCanInitiateImpromptuChats(supportsImpromptu);

}

}

void ChatControllerBase::createDayChangeTimer() {

if (timerFactory_) {

boost::posix_time::ptime now = boost::posix_time::second_clock::local_time();

boost::posix_time::ptime midnight(now.date() + boost::gregorian::days(1));

int millisecondsUntilMidnight = boost::numeric_cast<int>((midnight - now).total_milliseconds());

dateChangeTimer_ = boost::shared_ptr<Timer>(timerFactory_->createTimer(millisecondsUntilMidnight));

dateChangeTimer_->onTick.connect(boost::bind(&ChatControllerBase::handleDayChangeTick, this));

dateChangeTimer_->start();

}

}

void ChatControllerBase::handleDayChangeTick() {

dateChangeTimer_->stop();

boost::posix_time::ptime now = boost::posix_time::second_clock::local_time();

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "The day is now %1%")) % std::string(boost::posix_time::to_iso_extended_string(now)).substr(0,10))), ChatWindow::DefaultDirection);

dayTicked();

createDayChangeTimer();

}

void ChatControllerBase::setEnabled(bool enabled) {

chatWindow_->setOnline(enabled);

}

void ChatControllerBase::setOnline(bool online) {

setEnabled(online);

}

JID ChatControllerBase::getBaseJID() {

return JID(toJID_.toBare());

}

void ChatControllerBase::setAvailableServerFeatures(boost::shared_ptr<DiscoInfo> info) {

if (iqRouter_->isAvailable() && info->hasFeature(DiscoInfo::SecurityLabelsCatalogFeature)) {

GetSecurityLabelsCatalogRequest::ref request = GetSecurityLabelsCatalogRequest::create(getBaseJID(), iqRouter_);

request->onResponse.connect(boost::bind(&ChatControllerBase::handleSecurityLabelsCatalogResponse, this, _1, _2));

request->send();

} else {

chatWindow_->setSecurityLabelsEnabled(false);

labelsEnabled_ = false;

}

}

void ChatControllerBase::handleAllMessagesRead() {

if (!unreadMessages_.empty()) {

targetedUnreadMessages_.clear();

foreach (boost::shared_ptr<StanzaEvent> stanzaEvent, unreadMessages_) {

stanzaEvent->conclude();

}

unreadMessages_.clear();

chatWindow_->setUnreadMessageCount(0);

onUnreadCountChanged();

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/Controllers/Chat/ChatsManager.h>

#include <boost/algorithm/string.hpp>

#include <boost/archive/text_iarchive.hpp>

#include <boost/archive/text_oarchive.hpp>

#include <boost/bind.hpp>

#include <boost/serialization/map.hpp>

#include <boost/serialization/optional.hpp>

#include <boost/serialization/split_free.hpp>

#include <boost/serialization/string.hpp>

#include <boost/serialization/vector.hpp>

#include <boost/smart_ptr/make_shared.hpp>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Client/ClientBlockListManager.h>

#include <Swiften/Client/NickResolver.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/Disco/DiscoServiceWalker.h>

#include <Swiften/Elements/ChatState.h>

#include <Swiften/Elements/DeliveryReceipt.h>

#include <Swiften/Elements/DeliveryReceiptRequest.h>

#include <Swiften/Elements/MUCInvitationPayload.h>

#include <Swiften/Elements/MUCUserPayload.h>

#include <Swiften/MUC/MUCBookmarkManager.h>

}

}

void ChatsManager::setServerDiscoInfo(boost::shared_ptr<DiscoInfo> info) {

serverDiscoInfo_ = info;

foreach (JIDChatControllerPair pair, chatControllers_) {

pair.second->setAvailableServerFeatures(info);

}

foreach (JIDMUCControllerPair pair, mucControllers_) {

pair.second->setAvailableServerFeatures(info);

}

}

/**

* This is to be called on connect/disconnect.

*/

void ChatsManager::setOnline(bool enabled) {

foreach (JIDChatControllerPair controllerPair, chatControllers_) {

controllerPair.second->setOnline(enabled);

}

foreach (JIDMUCControllerPair controllerPair, mucControllers_) {

controllerPair.second->setOnline(enabled);

if (enabled) {

controllerPair.second->rejoin();

}

}

if (!enabled) {

markAllRecentsOffline();

} else {

setupBookmarks();

localMUCServiceFinderWalker_ = boost::make_shared<DiscoServiceWalker>(jid_.getDomain(), iqRouter_);

localMUCServiceFinderWalker_->onServiceFound.connect(boost::bind(&ChatsManager::handleLocalServiceFound, this, _1, _2));

localMUCServiceFinderWalker_->onWalkAborted.connect(boost::bind(&ChatsManager::handleLocalServiceWalkFinished, this));

localMUCServiceFinderWalker_->onWalkComplete.connect(boost::bind(&ChatsManager::handleLocalServiceWalkFinished, this));

localMUCServiceFinderWalker_->beginWalk();

}

if (chatListWindow_) {

chatListWindow_->setBookmarksEnabled(enabled);

}

}

void ChatsManager::handleChatRequest(const std::string &contact) {

ChatController* controller = getChatControllerOrFindAnother(JID(contact));

controller->activateChatWindow();

}

ChatController* ChatsManager::getChatControllerOrFindAnother(const JID &contact) {

ChatController* controller = getChatControllerIfExists(contact);

if (!controller && !mucRegistry_->isMUC(contact.toBare())) {

foreach (JIDChatControllerPair pair, chatControllers_) {

if (pair.first.toBare() == contact.toBare()) {

controller = pair.second;

break;

}

}

}

return controller ? controller : createNewChatController(contact);

}

std::vector<JID> inviteJIDs;

foreach(StringJIDPair pair, chat.impromptuJIDs) {

inviteJIDs.push_back(pair.second);

}

uiEventStream_->send(boost::make_shared<CreateImpromptuMUCUIEvent>(inviteJIDs, chat.jid, ""));

}

else if (chat.isMUC) {

/* FIXME: This means that recents requiring passwords will just flat-out not work */

uiEventStream_->send(boost::make_shared<JoinMUCUIEvent>(chat.jid, boost::optional<std::string>(), chat.nick));

}

else {

uiEventStream_->send(boost::make_shared<RequestChatUIEvent>(chat.jid));

}

}

void ChatsManager::handleLocalServiceFound(const JID& service, boost::shared_ptr<DiscoInfo> info) {

foreach (DiscoInfo::Identity identity, info->getIdentities()) {

if ((identity.getCategory() == "directory"

&& identity.getType() == "chatroom")

|| (identity.getCategory() == "conference"

&& identity.getType() == "text")) {

localMUCServiceJID_ = service;

localMUCServiceFinderWalker_->endWalk();

SWIFT_LOG(debug) << "Use following MUC service for impromptu chats: " << localMUCServiceJID_ << std::endl;

break;

}

}

}

void ChatsManager::handleLocalServiceWalkFinished() {

}

std::vector<ChatListWindow::Chat> ChatsManager::getRecentChats() const {

return std::vector<ChatListWindow::Chat>(recentChats_.begin(), recentChats_.end());

}

std::vector<Contact::ref> Swift::ChatsManager::getContacts(bool withMUCNicks) {

std::vector<Contact::ref> result;

foreach (ChatListWindow::Chat chat, recentChats_) {

if (!chat.isMUC) {

result.push_back(boost::make_shared<Contact>(chat.chatName.empty() ? chat.jid.toString() : chat.chatName, chat.jid, chat.statusType, chat.avatarPath));

}

}

if (withMUCNicks) {

/* collect MUC nicks */

typedef std::map<JID, MUCController*>::value_type Item;

foreach (const Item& item, mucControllers_) {

JID mucJID = item.second->getToJID();

std::map<std::string, JID> participants = item.second->getParticipantJIDs();

typedef std::map<std::string, JID>::value_type ParticipantType;

foreach (const ParticipantType& participant, participants) {

const JID nickJID = JID(mucJID.getNode(), mucJID.getDomain(), participant.first);

Presence::ref presence = presenceOracle_->getLastPresence(nickJID);

const boost::filesystem::path avatar = avatarManager_->getAvatarPath(nickJID);

result.push_back(boost::make_shared<Contact>(participant.first, JID(), presence->getShow(), avatar));

}

}

}

return result;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <boost/bind.hpp>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <hippomocks.h>

#include <Swiften/Avatars/AvatarMemoryStorage.h>

#include <Swiften/Avatars/NullAvatarManager.h>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Client/Client.h>

#include <Swiften/Client/ClientBlockListManager.h>

#include <Swiften/Client/DummyStanzaChannel.h>

#include <Swiften/Client/NickResolver.h>

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/Crypto/PlatformCryptoProvider.h>

#include <Swiften/Disco/DummyEntityCapsProvider.h>

#include <Swiften/Elements/DeliveryReceipt.h>

#include <Swiften/Elements/DeliveryReceiptRequest.h>

#include <Swiften/FileTransfer/UnitTest/DummyFileTransferManager.h>

#include <Swiften/Jingle/JingleSessionManager.h>

#include <Swiften/MUC/MUCManager.h>

#include <Swiften/Presence/DirectedPresenceSender.h>

#include <Swiften/Presence/PresenceOracle.h>

#include <Swiften/Presence/StanzaChannelPresenceSender.h>

#include <Swiften/Queries/DummyIQChannel.h>

#include <Swiften/Roster/XMPPRosterImpl.h>

#include <Swift/Controllers/UIEvents/UIEventStream.h>

#include <Swift/Controllers/UIInterfaces/ChatListWindowFactory.h>

#include <Swift/Controllers/UIInterfaces/ChatWindow.h>

#include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>

#include <Swift/Controllers/UIInterfaces/JoinMUCWindowFactory.h>

#include <Swift/Controllers/UIInterfaces/MUCSearchWindowFactory.h>

#include <Swift/Controllers/UIInterfaces/WhiteboardWindowFactory.h>

#include <Swift/Controllers/UnitTest/MockChatWindow.h>

#include <Swift/Controllers/WhiteboardManager.h>

#include <Swift/Controllers/XMPPEvents/EventController.h>

using namespace Swift;

class ChatsManagerTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(ChatsManagerTest);

CPPUNIT_TEST(testFirstOpenWindowIncoming);

CPPUNIT_TEST(testSecondOpenWindowIncoming);

CPPUNIT_TEST(testFirstOpenWindowOutgoing);

CPPUNIT_TEST(testFirstOpenWindowBareToFull);

CPPUNIT_TEST(testSecondWindow);

CPPUNIT_TEST(testUnbindRebind);

CPPUNIT_TEST(testNoDuplicateUnbind);

CPPUNIT_TEST(testThreeMUCWindows);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnRemoveFromRoster);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnAddToRoster);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToBoth);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToFrom);

CPPUNIT_TEST(testChatControllerFullJIDBindingOnMessageAndNotReceipt);

CPPUNIT_TEST(testChatControllerFullJIDBindingOnTypingAndNotActive);

CPPUNIT_TEST(testChatControllerPMPresenceHandling);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

mocks_ = new MockRepository();

jid_ = JID("test@test.com/resource");

stanzaChannel_ = new DummyStanzaChannel();

iqChannel_ = new DummyIQChannel();

iqRouter_ = new IQRouter(iqChannel_);

// capsProvider_ = new DummyCapsProvider();

eventController_ = new EventController();

chatWindowFactory_ = mocks_->InterfaceMock<ChatWindowFactory>();

joinMUCWindowFactory_ = mocks_->InterfaceMock<JoinMUCWindowFactory>();

xmppRoster_ = new XMPPRosterImpl();

mucRegistry_ = new MUCRegistry();

nickResolver_ = new NickResolver(jid_.toBare(), xmppRoster_, NULL, mucRegistry_);

presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);

serverDiscoInfo_ = boost::make_shared<DiscoInfo>();

presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);

directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);

mucManager_ = new MUCManager(stanzaChannel_, iqRouter_, directedPresenceSender_, mucRegistry_);

uiEventStream_ = new UIEventStream();

// entityCapsManager_ = new EntityCapsManager(capsProvider_, stanzaChannel_);

entityCapsProvider_ = new DummyEntityCapsProvider();

chatListWindowFactory_ = mocks_->InterfaceMock<ChatListWindowFactory>();

mucSearchWindowFactory_ = mocks_->InterfaceMock<MUCSearchWindowFactory>();

settings_ = new DummySettingsProvider();

profileSettings_ = new ProfileSettingsProvider("a", settings_);

chatListWindow_ = new MockChatListWindow();

ftManager_ = new DummyFileTransferManager();

ftOverview_ = new FileTransferOverview(ftManager_);

avatarManager_ = new NullAvatarManager();

void testChatControllerPMPresenceHandling() {

JID participantA = JID("test@rooms.test.com/participantA");

JID participantB = JID("test@rooms.test.com/participantB");

mucRegistry_->addMUC("test@rooms.test.com");

MockChatWindow* window = new MockChatWindow();

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(participantA, uiEventStream_).Return(window);

uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(JID(participantA))));

Presence::ref presence = Presence::create();

presence->setFrom(participantA);

presence->setShow(StatusShow::Online);

stanzaChannel_->onPresenceReceived(presence);

CPPUNIT_ASSERT_EQUAL(std::string("participantA has become available."), MockChatWindow::bodyFromMessage(window->lastAddedPresence_));

presence = Presence::create();

presence->setFrom(participantB);

presence->setShow(StatusShow::Away);

stanzaChannel_->onPresenceReceived(presence);

presence = Presence::create();

presence->setFrom(participantA);

presence->setShow(StatusShow::None);

presence->setType(Presence::Unavailable);

stanzaChannel_->onPresenceReceived(presence);

CPPUNIT_ASSERT_EQUAL(std::string("participantA has gone offline."), MockChatWindow::bodyFromMessage(window->lastReplacedMessage_));

}

void testhelperChatControllerPresenceAccessUpdatedOnSubscriptionChangeReceiptsAllowed(RosterItemPayload::Subscription from, RosterItemPayload::Subscription to) {

JID messageJID("testling@test.com/resource1");

xmppRoster_->addContact(messageJID, "foo", std::vector<std::string>(), from);

MockChatWindow* window = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);

settings_->storeSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS, true);

boost::shared_ptr<Message> message = makeDeliveryReceiptTestMessage(messageJID, "1");

manager_->handleIncomingMessage(message);

CPPUNIT_ASSERT_EQUAL(st(0), stanzaChannel_->sentStanzas.size());

xmppRoster_->addContact(messageJID, "foo", std::vector<std::string>(), to);

message->setID("2");

manager_->handleIncomingMessage(message);

CPPUNIT_ASSERT_EQUAL(st(1), stanzaChannel_->sentStanzas.size());

Stanza::ref stanzaContactOnRoster = stanzaChannel_->getStanzaAtIndex<Stanza>(0);

CPPUNIT_ASSERT(stanzaContactOnRoster->getPayload<DeliveryReceipt>() != 0);

}

private:

boost::shared_ptr<Message> makeDeliveryReceiptTestMessage(const JID& from, const std::string& id) {

boost::shared_ptr<Message> message = boost::make_shared<Message>();

message->setFrom(from);

message->setID(id);

message->setBody("This will cause the window to open");

message->addPayload(boost::make_shared<DeliveryReceiptRequest>());

return message;

}

size_t st(int i) {

return static_cast<size_t>(i);

}

private:

JID jid_;

ChatsManager* manager_;

DummyStanzaChannel* stanzaChannel_;

IQRouter* iqRouter_;

EventController* eventController_;

ChatWindowFactory* chatWindowFactory_;

JoinMUCWindowFactory* joinMUCWindowFactory_;

NickResolver* nickResolver_;

PresenceOracle* presenceOracle_;

AvatarManager* avatarManager_;

boost::shared_ptr<DiscoInfo> serverDiscoInfo_;

XMPPRosterImpl* xmppRoster_;

PresenceSender* presenceSender_;

MockRepository* mocks_;

UIEventStream* uiEventStream_;

ChatListWindowFactory* chatListWindowFactory_;

WhiteboardWindowFactory* whiteboardWindowFactory_;

MUCSearchWindowFactory* mucSearchWindowFactory_;

MUCRegistry* mucRegistry_;

DirectedPresenceSender* directedPresenceSender_;

DummyEntityCapsProvider* entityCapsProvider_;

MUCManager* mucManager_;

DummySettingsProvider* settings_;

ProfileSettingsProvider* profileSettings_;

ChatListWindow* chatListWindow_;

FileTransferOverview* ftOverview_;

FileTransferManager* ftManager_;

WhiteboardSessionManager* wbSessionManager_;

WhiteboardManager* wbManager_;

HighlightManager* highlightManager_;

ClientBlockListManager* clientBlockListManager_;

VCardManager* vcardManager_;

CryptoProvider* crypto_;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/foreach.h>

#include <Swift/Controllers/UIInterfaces/ChatWindow.h>

namespace Swift {

class MockChatWindow : public ChatWindow {

public:

virtual ~MockChatWindow();

virtual std::string addMessage(const ChatMessage& message, const std::string& /*senderName*/, bool /*senderIsSelf*/, boost::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/) {

lastMessageBody_ = bodyFromMessage(message);

return "id";

}

virtual std::string addAction(const ChatMessage& /*message*/, const std::string& /*senderName*/, bool /*senderIsSelf*/, boost::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/) {return "id";}

virtual std::string addSystemMessage(const ChatMessage& /*message*/, Direction /*direction*/) {

return "id";

}

virtual void addPresenceMessage(const ChatMessage& message, Direction /*direction*/) {

lastAddedPresence_ = message;

}

virtual void addErrorMessage(const ChatMessage& /*message*/) {}

virtual void replaceMessage(const ChatMessage& /*message*/, const std::string& /*id*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/) {}

virtual void replaceWithAction(const ChatMessage& /*message*/, const std::string& /*id*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/) {}

virtual void replaceLastMessage(const ChatMessage& message, const TimestampBehaviour /*timestampBehaviour*/) {

lastReplacedMessage_ = message;

}

virtual void replaceSystemMessage(const ChatMessage& /*message*/, const std::string& /*id*/, const TimestampBehaviour /*timestampBehaviour*/) {}

// File transfer related stuff

virtual std::string addFileTransfer(const std::string& /*senderName*/, bool /*senderIsSelf*/,const std::string& /*filename*/, const boost::uintmax_t /*sizeInBytes*/, const std::string& /*description*/) { return 0; }

virtual void setFileTransferProgress(std::string /*id*/, const int /*alreadyTransferedBytes*/) { }

virtual void setFileTransferStatus(std::string /*id*/, const FileTransferState /*state*/, const std::string& /*msg*/) { }

virtual void activate() {}

virtual void setAvailableSecurityLabels(const std::vector<SecurityLabelsCatalog::Item>& labels) {labels_ = labels;}

virtual void setSecurityLabelsEnabled(bool enabled) {labelsEnabled_ = enabled;}

virtual void setUnreadMessageCount(int /*count*/) {}

virtual void convertToMUC(MUCType /*mucType*/) {}

virtual void setSecurityLabelsError() {}

virtual SecurityLabelsCatalog::Item getSelectedSecurityLabel() {return label_;}

virtual void setOnline(bool /*online*/) {}

virtual void setRosterModel(Roster* roster) { roster_ = roster; }

Roster* getRosterModel() { return roster_; }

virtual void setTabComplete(TabComplete*) {}

void setAckState(const std::string& /*id*/, AckState /*state*/) {}

virtual void flash() {}

virtual AlertID addAlert(const std::string& /*alertText*/) { return 0; }

virtual void removeAlert(const AlertID /*id*/) {}

virtual void setCorrectionEnabled(Tristate /*enabled*/) {}

virtual void setFileTransferEnabled(Tristate /*enabled*/) {}

void setAvailableOccupantActions(const std::vector<OccupantAction>&/* actions*/) {}

void setSubject(const std::string& /*subject*/) {}

virtual void showRoomConfigurationForm(Form::ref) {}

virtual void addMUCInvitation(const std::string& /*senderName*/, const JID& /*jid*/, const std::string& /*reason*/, const std::string& /*password*/, bool = true, bool = false, bool = false) {}

virtual std::string addWhiteboardRequest(bool) {return "";}

virtual void setWhiteboardSessionStatus(std::string, const ChatWindow::WhiteboardSessionState){}

virtual void setAffiliations(MUCOccupant::Affiliation, const std::vector<JID>&) {}

virtual void setAvailableRoomActions(const std::vector<RoomAction> &) {}

virtual void setBlockingState(BlockingState) {}

virtual void showBookmarkWindow(const MUCBookmark& /*bookmark*/) {}

virtual void setBookmarkState(RoomBookmarkState) {}

static std::string bodyFromMessage(const ChatMessage& message) {

boost::shared_ptr<ChatTextMessagePart> text;

foreach (boost::shared_ptr<ChatMessagePart> part, message.getParts()) {

if ((text = boost::dynamic_pointer_cast<ChatTextMessagePart>(part))) {

return text->text;

}

}

return "";

}

std::string name_;

std::string lastMessageBody_;

ChatMessage lastAddedPresence_;

ChatMessage lastReplacedMessage_;

std::vector<SecurityLabelsCatalog::Item> labels_;

bool labelsEnabled_;

SecurityLabelsCatalog::Item label_;

Roster* roster_;

};

}