#include <Swiften/StringCodecs/Base64.h>

#include <Swiften/VCards/VCardManager.h>

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

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

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

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

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

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

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

#include <Swift/Controllers/FileTransfer/FileTransferController.h>

#include <Swift/Controllers/FileTransfer/FileTransferOverview.h>

#include <Swift/Controllers/ProfileSettingsProvider.h>

#include <Swift/Controllers/SettingConstants.h>

#include <Swift/Controllers/Settings/SettingsProvider.h>

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

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

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

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

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

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

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

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

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

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

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

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

#include <Swift/Controllers/WhiteboardManager.h>

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

namespace boost {

namespace serialization {

template<class Archive> void save(Archive& ar, const Swift::JID& jid, const unsigned int /*version*/) {

std::string jidStr = jid.toString();

ar << jidStr;

}

template<class Archive> void load(Archive& ar, Swift::JID& jid, const unsigned int /*version*/) {

std::string stringJID;

ar >> stringJID;

jid = Swift::JID(stringJID);

}

template<class Archive> inline void serialize(Archive& ar, Swift::JID& t, const unsigned int file_version){

split_free(ar, t, file_version);

}

template<class Archive> void serialize(Archive& ar, Swift::ChatListWindow::Chat& chat, const unsigned int version) {

ar & chat.jid;

ar & chat.chatName;

ar & chat.activity;

ar & chat.isMUC;

ar & chat.nick;

ar & chat.impromptuJIDs;

if (version > 0) {

ar & chat.password;

}

}

}

}

namespace Swift {

typedef std::pair<JID, ChatController*> JIDChatControllerPair;

typedef std::pair<JID, MUCController*> JIDMUCControllerPair;

#define RECENT_CHATS "recent_chats"

ChatsManager::ChatsManager(

JID jid, StanzaChannel* stanzaChannel,

IQRouter* iqRouter,

EventController* eventController,

ChatWindowFactory* chatWindowFactory,

JoinMUCWindowFactory* joinMUCWindowFactory,

NickResolver* nickResolver,

PresenceOracle* presenceOracle,

PresenceSender* presenceSender,

UIEventStream* uiEventStream,

ChatListWindowFactory* chatListWindowFactory,

bool useDelayForLatency,

TimerFactory* timerFactory,

MUCRegistry* mucRegistry,

EntityCapsProvider* entityCapsProvider,

MUCManager* mucManager,

MUCSearchWindowFactory* mucSearchWindowFactory,

ProfileSettingsProvider* profileSettings,

FileTransferOverview* ftOverview,

}

chatListWindow_->addMUCBookmark(bookmark);

}

void ChatsManager::handleMUCBookmarkRemoved(const MUCBookmark& bookmark) {

chatListWindow_->removeMUCBookmark(bookmark);

}

ChatListWindow::Chat ChatsManager::createChatListChatItem(const JID& jid, const std::string& activity, bool privateMessage) {

int unreadCount = 0;

if (mucRegistry_->isMUC(jid)) {

MUCController* controller = mucControllers_[jid.toBare()];

StatusShow::Type type = StatusShow::None;

std::string nick = "";

std::string password = "";

if (controller) {

unreadCount = controller->getUnreadCount();

if (controller->isJoined()) {

type = StatusShow::Online;

}

nick = controller->getNick();

if (controller->getPassword()) {

password = *controller->getPassword();

}

if (controller->isImpromptu()) {

ChatListWindow::Chat chat = ChatListWindow::Chat(jid, jid.toString(), activity, unreadCount, type, boost::filesystem::path(), true, privateMessage, nick, password);

std::map<std::string, JID> participants = controller->getParticipantJIDs();

chat.impromptuJIDs = participants;

return chat;

}

}

return ChatListWindow::Chat(jid, jid.toString(), activity, unreadCount, type, boost::filesystem::path(), true, privateMessage, nick, password);

} else {

ChatController* controller = getChatControllerIfExists(jid, false);

if (controller) {

unreadCount = controller->getUnreadCount();

}

JID bareishJID = mucRegistry_->isMUC(jid.toBare()) ? jid : jid.toBare();

Presence::ref presence = presenceOracle_->getAccountPresence(bareishJID);

StatusShow::Type type = presence ? presence->getShow() : StatusShow::None;

boost::filesystem::path avatarPath = avatarManager_ ? avatarManager_->getAvatarPath(bareishJID) : boost::filesystem::path();

return ChatListWindow::Chat(bareishJID, nickResolver_->jidToNick(bareishJID), activity, unreadCount, type, avatarPath, false, privateMessage);

}

}

void ChatsManager::handleChatActivity(const JID& jid, const std::string& activity, bool isMUC) {

const bool privateMessage = mucRegistry_->isMUC(jid.toBare()) && !isMUC;

ChatListWindow::Chat chat = createChatListChatItem(jid, activity, privateMessage);

/* FIXME: handle nick changes */

appendRecent(chat);

handleUnreadCountChanged(nullptr);

saveRecents();

}

void ChatsManager::handleChatClosed(const JID& /*jid*/) {

cleanupPrivateMessageRecents();

chatListWindow_->setRecents(recentChats_);

}

if (result != recentChats_.end()) {

ChatListWindow::Chat existingChat = *result;

recentChats_.erase(std::remove(recentChats_.begin(), recentChats_.end(), chat), recentChats_.end());

return boost::optional<ChatListWindow::Chat>(existingChat);

} else {

return boost::optional<ChatListWindow::Chat>();

}

}

void ChatsManager::cleanupPrivateMessageRecents() {

/* if we leave a MUC and close a PM, remove it's recent chat entry */

const std::list<ChatListWindow::Chat> chats = recentChats_;

for (const ChatListWindow::Chat& chat : chats) {

if (chat.isPrivateMessage) {

typedef std::map<JID, MUCController*> ControllerMap;

ControllerMap::iterator muc = mucControllers_.find(chat.jid.toBare());

if (muc == mucControllers_.end() || !muc->second->isJoined()) {

ChatController* chatController = getChatControllerIfExists(chat.jid);

if (!chatController || !chatController->hasOpenWindow()) {

removeExistingChat(chat);

break;

}

}

}

}

}

void ChatsManager::appendRecent(const ChatListWindow::Chat& chat) {

boost::optional<ChatListWindow::Chat> oldChat = removeExistingChat(chat);

ChatListWindow::Chat mergedChat = chat;

mergedChat.impromptuJIDs.insert(oldChat->impromptuJIDs.begin(), oldChat->impromptuJIDs.end());

}

recentChats_.push_front(mergedChat);

}

void ChatsManager::prependRecent(const ChatListWindow::Chat& chat) {

boost::optional<ChatListWindow::Chat> oldChat = removeExistingChat(chat);

ChatListWindow::Chat mergedChat = chat;

mergedChat.impromptuJIDs.insert(oldChat->impromptuJIDs.begin(), oldChat->impromptuJIDs.end());

}

recentChats_.push_back(mergedChat);

}

void ChatsManager::handleUserLeftMUC(MUCController* mucController) {

std::map<JID, MUCController*>::iterator it;

for (it = mucControllers_.begin(); it != mucControllers_.end(); ++it) {

if ((*it).second == mucController) {

for (ChatListWindow::Chat& chat : recentChats_) {

if (chat.isMUC && chat.jid == (*it).first) {

chat.statusType = StatusShow::None;

}

}

mucControllers_.erase(it);

delete mucController;

break;

}

}

cleanupPrivateMessageRecents();

chatListWindow_->setRecents(recentChats_);

}

void ChatsManager::handleSettingChanged(const std::string& settingPath) {

if (settingPath == SettingConstants::REQUEST_DELIVERYRECEIPTS.getKey()) {

userWantsReceipts_ = settings_->getSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS);

return;

}

}

std::shared_ptr<AddMUCBookmarkUIEvent> addMUCBookmarkEvent = std::dynamic_pointer_cast<AddMUCBookmarkUIEvent>(event);

if (addMUCBookmarkEvent) {

mucBookmarkManager_->addBookmark(addMUCBookmarkEvent->getBookmark());

return;

}

std::shared_ptr<SendFileUIEvent> sendFileEvent = std::dynamic_pointer_cast<SendFileUIEvent>(event);

if (sendFileEvent) {

JID fileReceiver = sendFileEvent->getJID();

if (fileReceiver.isBare()) {

// See if there is a chat controller for a conversation with a bound

// full JID. Check if this JID supports file transfer and use it instead

// of the bare JID.

ChatController* controller = getChatControllerIfExists(fileReceiver, false);

if (controller) {

JID controllerJID = controller->getToJID();

if (!controllerJID.isBare() && (FeatureOracle(entityCapsProvider_, presenceOracle_).isFileTransferSupported(controllerJID) == Yes)) {

fileReceiver = controllerJID;

}

}

}

ftOverview_->sendFile(fileReceiver, sendFileEvent->getFilename());

return;

}

std::shared_ptr<CreateImpromptuMUCUIEvent> createImpromptuMUCEvent = std::dynamic_pointer_cast<CreateImpromptuMUCUIEvent>(event);

if (createImpromptuMUCEvent) {

assert(!localMUCServiceJID_.toString().empty());

// The room JID is random for new impromptu rooms, or a predefined JID for impromptu rooms resumed from the 'Recent chats' list.

JID roomJID = createImpromptuMUCEvent->getRoomJID().toString().empty() ? JID(idGenerator_.generateID(), localMUCServiceJID_) : createImpromptuMUCEvent->getRoomJID();

// join muc

MUC::ref muc = handleJoinMUCRequest(roomJID, boost::optional<std::string>(), nickResolver_->jidToNick(jid_), false, true, true);

mucControllers_[roomJID]->onImpromptuConfigCompleted.connect(boost::bind(&ChatsManager::finalizeImpromptuJoin, this, muc, createImpromptuMUCEvent->getJIDs(), createImpromptuMUCEvent->getReason(), boost::optional<JID>()));

mucControllers_[roomJID]->activateChatWindow();

}

std::shared_ptr<EditMUCBookmarkUIEvent> editMUCBookmarkEvent = std::dynamic_pointer_cast<EditMUCBookmarkUIEvent>(event);

if (editMUCBookmarkEvent) {

mucBookmarkManager_->replaceBookmark(editMUCBookmarkEvent->getOldBookmark(), editMUCBookmarkEvent->getNewBookmark());

}

else if (JoinMUCUIEvent::ref joinEvent = std::dynamic_pointer_cast<JoinMUCUIEvent>(event)) {

handleJoinMUCRequest(joinEvent->getJID(), joinEvent->getPassword(), joinEvent->getNick(), joinEvent->getShouldJoinAutomatically(), joinEvent->getCreateAsReservedRoomIfNew(), joinEvent->isImpromptu());

mucControllers_[joinEvent->getJID()]->activateChatWindow();

}

else if (std::shared_ptr<RequestJoinMUCUIEvent> joinEvent = std::dynamic_pointer_cast<RequestJoinMUCUIEvent>(event)) {

if (!joinMUCWindow_) {

joinMUCWindow_ = joinMUCWindowFactory_->createJoinMUCWindow(uiEventStream_);

joinMUCWindow_->onSearchMUC.connect(boost::bind(&ChatsManager::handleSearchMUCRequest, this));

}

joinMUCWindow_->setMUC(joinEvent->getRoom());

joinMUCWindow_->setNick(nickResolver_->jidToNick(jid_));

joinMUCWindow_->show();

}

}

void ChatsManager::markAllRecentsOffline() {

for (ChatListWindow::Chat& chat : recentChats_) {

chat.setStatusType(StatusShow::None);

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <map>

#include <memory>

#include <string>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/JID/JID.h>

#include <Swiften/MUC/MUC.h>

#include <Swiften/MUC/MUCBookmark.h>

#include <Swiften/MUC/MUCRegistry.h>

#include <Swift/Controllers/ContactProvider.h>

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

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

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

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

namespace Swift {

class EventController;

class ChatController;

class ChatControllerBase;

class MUCController;

class MUCManager;

class JoinMUCWindow;

class JoinMUCWindowFactory;

class NickResolver;

class PresenceOracle;

class AvatarManager;

class StanzaChannel;

class IQRouter;

class PresenceSender;

PresenceSender* presenceSender_;

UIEventStream* uiEventStream_;

MUCBookmarkManager* mucBookmarkManager_;

std::shared_ptr<DiscoInfo> serverDiscoInfo_;

ChatListWindow* chatListWindow_;

JoinMUCWindow* joinMUCWindow_;

boost::signals2::scoped_connection uiEventConnection_;

bool useDelayForLatency_;

TimerFactory* timerFactory_;

MUCRegistry* mucRegistry_;

EntityCapsProvider* entityCapsProvider_;

MUCManager* mucManager;

MUCSearchController* mucSearchController_;

std::list<ChatListWindow::Chat> recentChats_;

ProfileSettingsProvider* profileSettings_;

FileTransferOverview* ftOverview_;

XMPPRoster* roster_;

bool eagleMode_;

bool userWantsReceipts_;

SettingsProvider* settings_;

HistoryController* historyController_;

WhiteboardManager* whiteboardManager_;

HighlightManager* highlightManager_;

std::map<std::string, std::string> emoticons_;

ClientBlockListManager* clientBlockListManager_;

JID localMUCServiceJID_;

std::shared_ptr<DiscoServiceWalker> localMUCServiceFinderWalker_;

AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider_;

IDGenerator idGenerator_;

VCardManager* vcardManager_;

};

}

/*

* Copyright (c) 2010-2017 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <map>

#include <set>

#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/CarbonsReceived.h>

#include <Swiften/Elements/CarbonsSent.h>

#include <Swiften/Elements/DeliveryReceipt.h>

#include <Swiften/Elements/DeliveryReceiptRequest.h>

#include <Swiften/Elements/Forwarded.h>

#include <Swiften/Elements/MUCInvitationPayload.h>

#include <Swiften/Elements/MUCUserPayload.h>

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

#include <Swiften/Jingle/JingleSessionManager.h>

#include <Swiften/MUC/MUCManager.h>

#include <Swiften/Network/DummyTimerFactory.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 <Swiften/VCards/VCardManager.h>

#include <Swiften/VCards/VCardMemoryStorage.h>

#include <Swiften/Whiteboard/WhiteboardSessionManager.h>

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

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

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

#include <Swift/Controllers/Chat/UnitTest/MockChatListWindow.h>

#include <Swift/Controllers/EventNotifier.h>

#include <Swift/Controllers/FileTransfer/FileTransferOverview.h>

#include <Swift/Controllers/ProfileSettingsProvider.h>

#include <Swift/Controllers/SettingConstants.h>

#include <Swift/Controllers/Settings/DummySettingsProvider.h>

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

#include <Swift/Controllers/UIEvents/RequestChatUIEvent.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>

#include <SwifTools/Notifier/Notifier.h>

using namespace Swift;

class DummyNotifier : public Notifier {

public:

virtual void showMessage(

Type type,

const std::string& subject,

const std::string& description,

const boost::filesystem::path& picture,

boost::function<void()> callback) {

notifications.push_back({type, subject, description, picture, callback});

}

/** Remove any pending callbacks. */

virtual void purgeCallbacks() {

}

public:

struct Notification {

Type type;

std::string subject;

std::string description;

boost::filesystem::path picture;

boost::function<void()> callback;

};

public:

std::vector<Notification> notifications;

};

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(testLocalMUCServiceDiscoveryResetOnDisconnect);

CPPUNIT_TEST(testPresenceChangeDoesNotReplaceMUCInvite);

CPPUNIT_TEST(testNotSplittingMUCPresenceJoinLeaveLinesOnChatStateNotifications);

// MUC PM Tests

CPPUNIT_TEST(testChatControllerPMPresenceHandling);

CPPUNIT_TEST(testChatControllerMucPmUnavailableErrorHandling);

// Highlighting tests

CPPUNIT_TEST(testChatControllerHighlightingNotificationTesting);

CPPUNIT_TEST(testChatControllerHighlightingNotificationDeduplicateSounds);

CPPUNIT_TEST(testChatControllerHighlightingNotificationKeyword);

CPPUNIT_TEST(testChatControllerMeMessageHandling);

CPPUNIT_TEST(testRestartingMUCComponentCrash);

CPPUNIT_TEST(testChatControllerMeMessageHandlingInMUC);

// Carbons tests

CPPUNIT_TEST(testCarbonsForwardedIncomingMessageToSecondResource);

CPPUNIT_TEST(testCarbonsForwardedOutgoingMessageFromSecondResource);

CPPUNIT_TEST(testCarbonsForwardedIncomingDuplicates);

// Message correction tests

CPPUNIT_TEST(testChatControllerMessageCorrectionCorrectReplaceID);

CPPUNIT_TEST(testChatControllerMessageCorrectionIncorrectReplaceID);

CPPUNIT_TEST(testChatControllerMessageCorrectionReplaceBySameResource);

CPPUNIT_TEST(testChatControllerMessageCorrectionReplaceByOtherResource);

CPPUNIT_TEST(testMUCControllerMessageCorrectionNoIDMatchRequired);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

mocks_ = new MockRepository();

notifier_ = std::unique_ptr<DummyNotifier>(new DummyNotifier());

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

stanzaChannel_ = new DummyStanzaChannel();

iqRouter_ = new IQRouter(stanzaChannel_);

eventController_ = new EventController();

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

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

xmppRoster_ = new XMPPRosterImpl();

mucRegistry_ = new MUCRegistry();

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

presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);

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

presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);

directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);

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

uiEventStream_ = new UIEventStream();

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();

userPayload->addItem(MUCItem(MUCOccupant::Member, JID("foo@bar.com"), MUCOccupant::Moderator));

presence->addPayload(userPayload);

stanzaChannel_->onPresenceReceived(presence);

}

{

Message::ref mucMirrored = std::make_shared<Message>();

mucMirrored->setFrom(mucJID.withResource(nickname));

mucMirrored->setTo(jid_);

mucMirrored->setType(Message::Groupchat);

mucMirrored->setID("fooBlaID_1");

mucMirrored->setBody("Some misssssspelled message.");

manager_->handleIncomingMessage(mucMirrored);

}

CPPUNIT_ASSERT_EQUAL(std::string("Some misssssspelled message."), window->bodyFromMessage(window->lastAddedMessage_));

// Replace message with non-matching ID

{

Message::ref mucMirrored = std::make_shared<Message>();

mucMirrored->setFrom(mucJID.withResource(nickname));

mucMirrored->setTo(jid_);

mucMirrored->setType(Message::Groupchat);

mucMirrored->setID("fooBlaID_3");

mucMirrored->setBody("Some correctly spelled message.");

mucMirrored->addPayload(std::make_shared<Replace>("fooBlaID_2"));

manager_->handleIncomingMessage(mucMirrored);

}

CPPUNIT_ASSERT_EQUAL(std::string("Some correctly spelled message."), window->bodyFromMessage(window->lastReplacedMessage_));

}

private:

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

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

message->setFrom(from);

message->setID(id);

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

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

return message;

}

size_t st(int i) {

return static_cast<size_t>(i);

}

void handleHighlightAction(const HighlightAction& action) {

handledHighlightActions_++;

if (action.getSoundFilePath()) {

soundsPlayed_.insert(action.getSoundFilePath().get_value_or(""));

}

}

private:

JID jid_;

std::unique_ptr<DummyNotifier> notifier_;

ChatsManager* manager_;

DummyStanzaChannel* stanzaChannel_;

IQRouter* iqRouter_;

EventController* eventController_;

ChatWindowFactory* chatWindowFactory_;

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <list>

#include <map>

#include <memory>

#include <set>

#include <boost/filesystem/path.hpp>

#include <boost/signals2.hpp>

#include <Swiften/Elements/StatusShow.h>

#include <Swiften/MUC/MUCBookmark.h>

namespace Swift {

class ChatListWindow {

public:

class Chat {

public:

Chat() : statusType(StatusShow::None), isMUC(false), unreadCount(0), isPrivateMessage(false) {}

Chat(const JID& jid, const std::string& chatName, const std::string& activity, int unreadCount, StatusShow::Type statusType, const boost::filesystem::path& avatarPath, bool isMUC, bool isPrivateMessage = false, const std::string& nick = "", const boost::optional<std::string> password = boost::optional<std::string>())

: jid(jid), chatName(chatName), activity(activity), statusType(statusType), isMUC(isMUC), nick(nick), password(password), unreadCount(unreadCount), avatarPath(avatarPath), isPrivateMessage(isPrivateMessage) {}

/** Assume that nicks and other transient features aren't important for equality */

bool operator==(const Chat& other) const {

if (impromptuJIDs.empty()) {

return jid.toBare() == other.jid.toBare()

&& isMUC == other.isMUC;

}

else { /* compare the chat occupant lists */

for (const auto& jid : impromptuJIDs) {

bool found = false;

for (const auto& otherJID : other.impromptuJIDs) {

if (jid.second.toBare() == otherJID.second.toBare()) {

found = true;

break;

}

}

if (!found) {

return false;

}

}

}

}

void setUnreadCount(int unread) {

unreadCount = unread;

}

void setStatusType(StatusShow::Type type) {

statusType = type;

}

void setAvatarPath(const boost::filesystem::path& path) {

avatarPath = path;

}

std::string getImpromptuTitle() const {

}

}

}

JID jid;

std::string chatName;

std::string activity;

StatusShow::Type statusType;

bool isMUC;

std::string nick;

boost::optional<std::string> password;

int unreadCount;

boost::filesystem::path avatarPath;

std::map<std::string, JID> impromptuJIDs;

bool isPrivateMessage;

};

virtual ~ChatListWindow();

virtual void setBookmarksEnabled(bool enabled) = 0;

virtual void addMUCBookmark(const MUCBookmark& bookmark) = 0;

virtual void addWhiteboardSession(const ChatListWindow::Chat& chat) = 0;

virtual void removeWhiteboardSession(const JID& jid) = 0;

virtual void removeMUCBookmark(const MUCBookmark& bookmark) = 0;

virtual void setRecents(const std::list<Chat>& recents) = 0;

virtual void setUnreadCount(int unread) = 0;

virtual void clearBookmarks() = 0;

virtual void setOnline(bool isOnline) = 0;

boost::signals2::signal<void (const MUCBookmark&)> onMUCBookmarkActivated;

boost::signals2::signal<void (const Chat&)> onRecentActivated;

boost::signals2::signal<void (const JID&)> onWhiteboardActivated;

boost::signals2::signal<void ()> onClearRecentsRequested;

};

}