}

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

ChatControllerBase::setAvailableServerFeatures(info);

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

boost::shared_ptr<BlockList> blockList = clientBlockListManager_->getBlockList();

blockingOnStateChangedConnection_ = blockList->onStateChanged.connect(boost::bind(&ChatController::handleBlockingStateChanged, this));

blockingOnItemAddedConnection_ = blockList->onItemAdded.connect(boost::bind(&ChatController::handleBlockingStateChanged, this));

blockingOnItemRemovedConnection_ = blockList->onItemRemoved.connect(boost::bind(&ChatController::handleBlockingStateChanged, this));

handleBlockingStateChanged();

}

}

bool ChatController::isIncomingMessageFromMe(boost::shared_ptr<Message>) {

return false;

}

void ChatController::preHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent) {

if (messageEvent->isReadable()) {

chatWindow_->flash();

lastWasPresence_ = false;

}

boost::shared_ptr<Message> message = messageEvent->getStanza();

JID from = message->getFrom();

if (!from.equals(toJID_, JID::WithResource)) {

if (toJID_.equals(from, JID::WithoutResource) && toJID_.isBare()){

// Bind controller to a full JID if message contains body text or is a typing chat state.

ChatState::ref chatState = message->getPayload<ChatState>();

setToJID(from);

}

}

}

chatStateTracker_->handleMessageReceived(message);

chatStateNotifier_->receivedMessageFromContact(!!message->getPayload<ChatState>());

// handle XEP-0184 Message Receipts

// incomming receipts

if (boost::shared_ptr<DeliveryReceipt> receipt = message->getPayload<DeliveryReceipt>()) {

SWIFT_LOG(debug) << "received receipt for id: " << receipt->getReceivedID() << std::endl;

if (requestedReceipts_.find(receipt->getReceivedID()) != requestedReceipts_.end()) {

chatWindow_->setMessageReceiptState(requestedReceipts_[receipt->getReceivedID()], ChatWindow::ReceiptReceived);

requestedReceipts_.erase(receipt->getReceivedID());

}

// incomming errors in response to send out receipts

} else if (message->getPayload<DeliveryReceiptRequest>() && (message->getType() == Message::Error)) {

if (requestedReceipts_.find(message->getID()) != requestedReceipts_.end()) {

chatWindow_->setMessageReceiptState(requestedReceipts_[message->getID()], ChatWindow::ReceiptFailed);

requestedReceipts_.erase(message->getID());

}

// incoming receipt requests

} else if (message->getPayload<DeliveryReceiptRequest>()) {

if (receivingPresenceFromUs_) {

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

receiptMessage->setTo(toJID_);

receiptMessage->addPayload(boost::make_shared<DeliveryReceipt>(message->getID()));

stanzaChannel_->sendMessage(receiptMessage);

}

}

}

void ChatControllerBase::handleSendMessageRequest(const std::string &body, bool isCorrectionMessage) {

if (!stanzaChannel_->isAvailable() || body.empty()) {

return;

}

boost::shared_ptr<Message> message(new Message());

message->setTo(toJID_);

message->setType(Swift::Message::Chat);

message->setBody(body);

if (labelsEnabled_) {

if (!isCorrectionMessage) {

lastLabel_ = chatWindow_->getSelectedSecurityLabel();

}

SecurityLabelsCatalog::Item labelItem = lastLabel_;

if (labelItem.getLabel()) {

message->addPayload(labelItem.getLabel());

}

}

preSendMessageRequest(message);

boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();

if (useDelayForLatency_) {

message->addPayload(boost::make_shared<Delay>(now, selfJID_));

}

if (isCorrectionMessage) {

message->addPayload(boost::shared_ptr<Replace> (new Replace(lastSentMessageStanzaID_)));

}

message->setID(lastSentMessageStanzaID_ = idGenerator_.generateID());

stanzaChannel_->sendMessage(message);

#ifdef SWIFT_EXPERIMENTAL_HISTORY

logMessage(body, selfJID_, toJID_, now, false);

#endif

}

void ChatControllerBase::handleSecurityLabelsCatalogResponse(boost::shared_ptr<SecurityLabelsCatalog> catalog, ErrorPayload::ref error) {

if (catalog && !error) {

if (catalog->getItems().size() == 0) {

chatWindow_->setSecurityLabelsEnabled(false);

labelsEnabled_ = false;

} else {

labelsEnabled_ = true;

chatWindow_->setAvailableSecurityLabels(catalog->getItems());

chatWindow_->setSecurityLabelsEnabled(true);

}

} else {

labelsEnabled_ = false;

chatWindow_->setSecurityLabelsError();

}

}

void ChatControllerBase::showChatWindow() {

chatWindow_->show();

}

void ChatControllerBase::activateChatWindow() {

chatWindow_->activate();

}

std::string ChatControllerBase::addMessage(const std::string& message, const std::string& senderName, bool senderIsSelf, const boost::shared_ptr<SecurityLabel> label, const boost::filesystem::path& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) {

if (boost::starts_with(message, "/me ")) {

return chatWindow_->addAction(chatMessageParser_->parseMessageBody(String::getSplittedAtFirst(message, ' ').second), senderName, senderIsSelf, label, pathToString(avatarPath), time, highlight);

} else {

return chatWindow_->addMessage(chatMessageParser_->parseMessageBody(message,highlighter_->getNick(),senderIsSelf), senderName, senderIsSelf, label, pathToString(avatarPath), time, highlight);

}

}

void ChatControllerBase::replaceMessage(const std::string& message, const std::string& id, bool senderIsSelf, const boost::posix_time::ptime& time, const HighlightAction& highlight) {

if (boost::starts_with(message, "/me ")) {

chatWindow_->replaceWithAction(chatMessageParser_->parseMessageBody(String::getSplittedAtFirst(message, ' ').second), id, time, highlight);

} else {

chatWindow_->replaceMessage(chatMessageParser_->parseMessageBody(message,highlighter_->getNick(),senderIsSelf), id, time, highlight);

}

}

bool ChatControllerBase::isFromContact(const JID& from) {

return from.toBare() == toJID_.toBare();

}

void ChatControllerBase::handleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent) {

preHandleIncomingMessage(messageEvent);

if (messageEvent->isReadable() && !messageEvent->getConcluded()) {

unreadMessages_.push_back(messageEvent);

if (messageEvent->targetsMe()) {

targetedUnreadMessages_.push_back(messageEvent);

}

}

boost::shared_ptr<Message> message = messageEvent->getStanza();

HighlightAction highlight;

if (message->isError()) {

if (!message->getTo().getResource().empty()) {

std::string errorMessage = str(format(QT_TRANSLATE_NOOP("", "Couldn't send message: %1%")) % getErrorMessage(message->getPayload<ErrorPayload>()));

chatWindow_->addErrorMessage(chatMessageParser_->parseMessageBody(errorMessage));

}

}

else if (messageEvent->getStanza()->getPayload<MUCInvitationPayload>()) {

handleMUCInvitation(messageEvent->getStanza());

return;

}

else if (messageEvent->getStanza()->getPayload<MUCUserPayload>() && messageEvent->getStanza()->getPayload<MUCUserPayload>()->getInvite()) {

handleMediatedMUCInvitation(messageEvent->getStanza());

return;

}

else {

if (!messageEvent->isReadable()) {

return;

}

showChatWindow();

JID from = message->getFrom();

std::vector<boost::shared_ptr<Delay> > delayPayloads = message->getPayloads<Delay>();

for (size_t i = 0; useDelayForLatency_ && i < delayPayloads.size(); i++) {

if (!delayPayloads[i]->getFrom()) {

continue;

}

boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();

std::ostringstream s;

s << "The following message took " << (now - delayPayloads[i]->getStamp()).total_milliseconds() / 1000.0 << " seconds to be delivered from " << delayPayloads[i]->getFrom()->toString() << ".";

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(std::string(s.str())), ChatWindow::DefaultDirection);

}

boost::shared_ptr<SecurityLabel> label = message->getPayload<SecurityLabel>();

// Determine the timestamp

boost::posix_time::ptime timeStamp = boost::posix_time::microsec_clock::universal_time();

boost::optional<boost::posix_time::ptime> messageTimeStamp = getMessageTimestamp(message);

if (messageTimeStamp) {

timeStamp = *messageTimeStamp;

}

onActivity(body);

// Highlight

if (!isIncomingMessageFromMe(message)) {

highlight = highlighter_->findAction(body, senderHighlightNameFromMessage(from));

}

boost::shared_ptr<Replace> replace = message->getPayload<Replace>();

if (replace) {

// Should check if the user has a previous message

std::map<JID, std::string>::iterator lastMessage;

lastMessage = lastMessagesUIID_.find(from);

if (lastMessage != lastMessagesUIID_.end()) {

replaceMessage(body, lastMessagesUIID_[from], isIncomingMessageFromMe(message), timeStamp, highlight);

}

}

else {

addMessageHandleIncomingMessage(from, body, isIncomingMessageFromMe(message), label, timeStamp, highlight);

}

logMessage(body, from, selfJID_, timeStamp, true);

}

chatWindow_->show();

chatWindow_->setUnreadMessageCount(boost::numeric_cast<int>(unreadMessages_.size()));

onUnreadCountChanged();

postHandleIncomingMessage(messageEvent, highlight);

}

void ChatControllerBase::addMessageHandleIncomingMessage(const JID& from, const std::string& message, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp, const HighlightAction& highlight) {

lastMessagesUIID_[from] = addMessage(message, senderDisplayNameFromMessage(from), senderIsSelf, label, avatarManager_->getAvatarPath(from), timeStamp, highlight);

}

std::string ChatControllerBase::getErrorMessage(boost::shared_ptr<ErrorPayload> error) {

std::string defaultMessage = QT_TRANSLATE_NOOP("", "Error sending message");

if (!error->getText().empty()) {

return error->getText();

}

else {

switch (error->getCondition()) {

return;

}

}

// check for impromptu invite to potentially auto-accept

MUCInvitationPayload::ref invite = message->getPayload<MUCInvitationPayload>();

if (invite && autoAcceptMUCInviteDecider_->isAutoAcceptedInvite(message->getFrom(), invite)) {

if (invite->getIsContinuation()) {

// check for existing chat controller for the from JID

ChatController* controller = getChatControllerIfExists(jid);

if (controller) {

ChatWindow* window = controller->detachChatWindow();

chatControllers_.erase(jid);

delete controller;

handleJoinMUCRequest(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, false, true, window);

return;

}

} else {

handleJoinMUCRequest(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, false, true);

return;

}

}

//if not a mucroom

if (!event->isReadable() && !isInvite && !isMediatedInvite) {

/* Only route such messages if a window exists, don't open new windows for them.*/

// Do not bind a controller to a full JID, for delivery receipts or chat state notifications.

bool bindControllerToJID = false;

ChatState::ref chatState = message->getPayload<ChatState>();

bindControllerToJID = true;

}

ChatController* controller = getChatControllerIfExists(jid, bindControllerToJID);

if (controller) {

controller->handleIncomingMessage(event);

}

} else {

getChatControllerOrCreate(jid)->handleIncomingMessage(event);

}

}

void ChatsManager::handleMUCSelectedAfterSearch(const JID& muc) {

if (joinMUCWindow_) {

joinMUCWindow_->setMUC(muc.toString());

}

}

void ChatsManager::handleMUCBookmarkActivated(const MUCBookmark& mucBookmark) {

uiEventStream_->send(boost::make_shared<JoinMUCUIEvent>(mucBookmark.getRoom(), mucBookmark.getPassword(), mucBookmark.getNick()));

}

void ChatsManager::handleNewFileTransferController(FileTransferController* ftc) {

ChatController* chatController = getChatControllerOrCreate(ftc->getOtherParty());

chatController->handleNewFileTransferController(ftc);

chatController->activateChatWindow();

if (ftc->isIncoming()) {

eventController_->handleIncomingEvent(boost::make_shared<IncomingFileTransferEvent>(ftc->getOtherParty()));

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

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

#include <algorithm>

#include <boost/bind.hpp>

#include <boost/regex.hpp>

#include <boost/algorithm/string.hpp>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Base/format.h>

#include <Swiften/Base/Tristate.h>

#include <Swiften/Client/BlockList.h>

#include <Swiften/Client/ClientBlockListManager.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/Disco/EntityCapsProvider.h>

#include <Swiften/Elements/Delay.h>

#include <Swiften/MUC/MUC.h>

#include <Swiften/MUC/MUCBookmark.h>

#include <Swiften/MUC/MUCBookmarkManager.h>

#include <Swiften/Network/Timer.h>

#include <Swiften/Network/TimerFactory.h>

#include <Swiften/Roster/XMPPRoster.h>

#include <SwifTools/TabComplete.h>

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

#include <Swift/Controllers/Highlighter.h>

#include <Swift/Controllers/Intl.h>

#include <Swift/Controllers/Roster/ContactRosterItem.h>

#include <Swift/Controllers/Roster/GroupRosterItem.h>

#include <Swift/Controllers/Roster/ItemOperations/SetAvatar.h>

#include <Swift/Controllers/Roster/ItemOperations/SetMUC.h>

#include <Swift/Controllers/Roster/ItemOperations/SetPresence.h>

#include <Swift/Controllers/Roster/Roster.h>

#include <Swift/Controllers/Roster/RosterVCardProvider.h>

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

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

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

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

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

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

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

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

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

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

std::string MUCController::roleToFriendlyName(MUCOccupant::Role role) {

switch (role) {

case MUCOccupant::Moderator: return QT_TRANSLATE_NOOP("", "moderator");

case MUCOccupant::Participant: return QT_TRANSLATE_NOOP("", "participant");

case MUCOccupant::Visitor: return QT_TRANSLATE_NOOP("", "visitor");

case MUCOccupant::NoRole: return "";

}

assert(false);

return "";

}

std::string MUCController::roleToSortName(MUCOccupant::Role role) {

switch (role) {

case MUCOccupant::Moderator: return "1";

case MUCOccupant::Participant: return "2";

case MUCOccupant::Visitor: return "3";

case MUCOccupant::NoRole: return "4";

}

assert(false);

return "5";

}

JID MUCController::nickToJID(const std::string& nick) {

return muc_->getJID().withResource(nick);

}

bool MUCController::messageTargetsMe(boost::shared_ptr<Message> message) {

std::string stringRegexp(".*\\b" + boost::to_lower_copy(nick_) + "\\b.*");

boost::regex myRegexp(stringRegexp);

}

void MUCController::preHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent) {

if (messageEvent->getStanza()->getType() == Message::Groupchat) {

lastActivity_ = boost::posix_time::microsec_clock::universal_time();

}

clearPresenceQueue();

boost::shared_ptr<Message> message = messageEvent->getStanza();

if (joined_ && messageEvent->getStanza()->getFrom().getResource() != nick_ && messageTargetsMe(message) && !message->getPayload<Delay>() && messageEvent->isReadable()) {

chatWindow_->flash();

}

else {

messageEvent->setTargetsMe(false);

}

if (messageEvent->isReadable() && isImpromptu_) {

chatWindow_->flash(); /* behave like a regular char*/

}

if (joined_) {

std::string nick = message->getFrom().getResource();

if (nick != nick_ && currentOccupants_.find(nick) != currentOccupants_.end()) {

completer_->addWord(nick);

}

}

/*Buggy implementations never send the status code, so use an incoming message as a hint that joining's done (e.g. the old ejabberd on psi-im.org).*/

receivedActivity();

joined_ = true;

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "The room subject is now: %1%")) % message->getSubject())), ChatWindow::DefaultDirection);

chatWindow_->setSubject(message->getSubject());

doneGettingHistory_ = true;

}

if (!doneGettingHistory_ && !message->getPayload<Delay>()) {

doneGettingHistory_ = true;

}

if (!doneGettingHistory_) {

checkDuplicates(message);

messageEvent->conclude();

}

}

void MUCController::addMessageHandleIncomingMessage(const JID& from, const std::string& message, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time, const HighlightAction& highlight) {

if (from.isBare()) {

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "%1%")) % message)), ChatWindow::DefaultDirection);

}

else {

ChatControllerBase::addMessageHandleIncomingMessage(from, message, senderIsSelf, label, time, highlight);

}

}

void MUCController::postHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent, const HighlightAction& highlight) {

boost::shared_ptr<Message> message = messageEvent->getStanza();

if (joined_ && messageEvent->getStanza()->getFrom().getResource() != nick_ && !message->getPayload<Delay>()) {

if (messageTargetsMe(message) || isImpromptu_) {

eventController_->handleIncomingEvent(messageEvent);

}

}

}

void MUCController::handleAffiliationListReceived(MUCOccupant::Affiliation affiliation, const std::vector<JID>& jids) {

chatWindow_->setAffiliations(affiliation, jids);

}

void MUCController::logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming) {

// log only incoming messages

if (isIncoming && historyController_) {

historyController_->addMessage(message, fromJID, toJID, HistoryMessage::Groupchat, timeStamp);

}

}

void MUCController::addRecentLogs() {

if (!historyController_) {

return;

}

joinContext_ = historyController_->getMUCContext(selfJID_, toJID_, lastActivity_);

foreach (const HistoryMessage& message, joinContext_) {

bool senderIsSelf = nick_ == message.getFromJID().getResource();

// the chatWindow uses utc timestamps

addMessage(message.getMessage(), senderDisplayNameFromMessage(message.getFromJID()), senderIsSelf, boost::shared_ptr<SecurityLabel>(new SecurityLabel()), avatarManager_->getAvatarPath(message.getFromJID()), message.getTime() - boost::posix_time::hours(message.getOffset()), HighlightAction());

}

}

void MUCController::checkDuplicates(boost::shared_ptr<Message> newMessage) {

JID jid = newMessage->getFrom();

boost::optional<boost::posix_time::ptime> time = newMessage->getTimestamp();

reverse_foreach (const HistoryMessage& message, joinContext_) {

boost::posix_time::ptime messageTime = message.getTime() - boost::posix_time::hours(message.getOffset());

if (time && time < messageTime) {

break;

}

if (time && time != messageTime) {

continue;

}

if (message.getFromJID() != jid) {

continue;

}

if (message.getMessage() != body) {

continue;

}

// Mark the message as unreadable

newMessage->setBody("");

}

}

void MUCController::setNick(const std::string& nick) {

nick_ = nick;

highlighter_->setNick(nick_);

}

Form::ref MUCController::buildImpromptuRoomConfiguration(Form::ref roomConfigurationForm) {

Form::ref result = boost::make_shared<Form>(Form::SubmitType);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <boost/algorithm/string.hpp>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <hippomocks.h>

#include <Swiften/Avatars/NullAvatarManager.h>

#include <Swiften/Base/foreach.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/MUCUserPayload.h>

#include <Swiften/MUC/MUCBookmarkManager.h>

#include <Swiften/MUC/UnitTest/MockMUC.h>

#include <Swiften/Network/TimerFactory.h>

#include <Swiften/Presence/DirectedPresenceSender.h>

#include <Swiften/Presence/PresenceOracle.h>

#include <Swiften/Presence/StanzaChannelPresenceSender.h>

#include <Swiften/Queries/DummyIQChannel.h>

#include <Swiften/Roster/XMPPRoster.h>

#include <Swiften/Roster/XMPPRosterImpl.h>

#include <Swiften/VCards/VCardManager.h>

#include <Swiften/VCards/VCardMemoryStorage.h>

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

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

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

#include <Swift/Controllers/Roster/GroupRosterItem.h>

#include <Swift/Controllers/Roster/Roster.h>

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

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

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

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

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

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

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

using namespace Swift;

class MUCControllerTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(MUCControllerTest);

CPPUNIT_TEST(testJoinPartStringContructionSimple);

CPPUNIT_TEST(testJoinPartStringContructionMixed);

CPPUNIT_TEST(testAppendToJoinParts);

CPPUNIT_TEST(testAddressedToSelf);

CPPUNIT_TEST(testNotAddressedToSelf);

CPPUNIT_TEST(testAddressedToSelfBySelf);

CPPUNIT_TEST(testMessageWithEmptyLabelItem);

CPPUNIT_TEST(testMessageWithLabelItem);

CPPUNIT_TEST(testCorrectMessageWithLabelItem);

CPPUNIT_TEST(testRoleAffiliationStates);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

crypto_ = boost::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

self_ = JID("girl@wonderland.lit/rabbithole");

nick_ = "aLiCe";

mucJID_ = JID("teaparty@rooms.wonderland.lit");

mocks_ = new MockRepository();

stanzaChannel_ = new DummyStanzaChannel();

iqChannel_ = new DummyIQChannel();

iqRouter_ = new IQRouter(iqChannel_);

eventController_ = new EventController();

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

userSearchWindowFactory_ = mocks_->InterfaceMock<UserSearchWindowFactory>();

xmppRoster_ = new XMPPRosterImpl();

presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);

presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);

directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);

uiEventStream_ = new UIEventStream();

avatarManager_ = new NullAvatarManager();

TimerFactory* timerFactory = NULL;

window_ = new MockChatWindow();

mucRegistry_ = new MUCRegistry();

entityCapsProvider_ = new DummyEntityCapsProvider();

settings_ = new DummySettingsProvider();

highlightManager_ = new HighlightManager(settings_);

muc_ = boost::make_shared<MockMUC>(mucJID_);

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(muc_->getJID(), uiEventStream_).Return(window_);

chatMessageParser_ = boost::make_shared<ChatMessageParser>(std::map<std::string, std::string>(), highlightManager_->getRules(), true);

void testAddressedToSelfBySelf() {

finishJoin();

Message::ref message(new Message());

message->setFrom(JID(muc_->getJID().toString() + "/" + nick_));

message->setBody("Hi there " + nick_);

message->setType(Message::Groupchat);

controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

CPPUNIT_ASSERT_EQUAL((size_t)0, eventController_->getEvents().size());

}

void testMessageWithEmptyLabelItem() {

SecurityLabelsCatalog::Item label;

label.setSelector("Bob");

window_->label_ = label;

boost::shared_ptr<DiscoInfo> features = boost::make_shared<DiscoInfo>();

features->addFeature(DiscoInfo::SecurityLabelsCatalogFeature);

controller_->setAvailableServerFeatures(features);

IQ::ref iq = iqChannel_->iqs_[iqChannel_->iqs_.size() - 1];

SecurityLabelsCatalog::ref labelPayload = boost::make_shared<SecurityLabelsCatalog>();

labelPayload->addItem(label);

IQ::ref result = IQ::createResult(self_, iq->getID(), labelPayload);

iqChannel_->onIQReceived(result);

std::string messageBody("agamemnon");

window_->onSendMessageRequest(messageBody, false);

boost::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

Message::ref message = boost::dynamic_pointer_cast<Message>(rawStanza);

CPPUNIT_ASSERT_EQUAL(iq->getTo(), result->getFrom());

CPPUNIT_ASSERT(window_->labelsEnabled_);

CPPUNIT_ASSERT(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */

CPPUNIT_ASSERT(message);

CPPUNIT_ASSERT(!message->getPayload<SecurityLabel>());

}

void testMessageWithLabelItem() {

boost::shared_ptr<SecurityLabel> label = boost::make_shared<SecurityLabel>();

label->setLabel("a");

SecurityLabelsCatalog::Item labelItem;

labelItem.setSelector("Bob");

labelItem.setLabel(label);

window_->label_ = labelItem;

boost::shared_ptr<DiscoInfo> features = boost::make_shared<DiscoInfo>();

features->addFeature(DiscoInfo::SecurityLabelsCatalogFeature);

controller_->setAvailableServerFeatures(features);

IQ::ref iq = iqChannel_->iqs_[iqChannel_->iqs_.size() - 1];

SecurityLabelsCatalog::ref labelPayload = boost::make_shared<SecurityLabelsCatalog>();

labelPayload->addItem(labelItem);

IQ::ref result = IQ::createResult(self_, iq->getID(), labelPayload);

iqChannel_->onIQReceived(result);

std::string messageBody("agamemnon");

window_->onSendMessageRequest(messageBody, false);

boost::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

Message::ref message = boost::dynamic_pointer_cast<Message>(rawStanza);

CPPUNIT_ASSERT_EQUAL(iq->getTo(), result->getFrom());

CPPUNIT_ASSERT(window_->labelsEnabled_);

CPPUNIT_ASSERT(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */

CPPUNIT_ASSERT(message);

CPPUNIT_ASSERT_EQUAL(label, message->getPayload<SecurityLabel>());

}

void testCorrectMessageWithLabelItem() {

boost::shared_ptr<SecurityLabel> label = boost::make_shared<SecurityLabel>();

label->setLabel("a");

SecurityLabelsCatalog::Item labelItem;

labelItem.setSelector("Bob");

labelItem.setLabel(label);

boost::shared_ptr<SecurityLabel> label2 = boost::make_shared<SecurityLabel>();

label->setLabel("b");

SecurityLabelsCatalog::Item labelItem2;

labelItem2.setSelector("Charlie");

labelItem2.setLabel(label2);

window_->label_ = labelItem;

boost::shared_ptr<DiscoInfo> features = boost::make_shared<DiscoInfo>();

features->addFeature(DiscoInfo::SecurityLabelsCatalogFeature);

controller_->setAvailableServerFeatures(features);

IQ::ref iq = iqChannel_->iqs_[iqChannel_->iqs_.size() - 1];

SecurityLabelsCatalog::ref labelPayload = boost::make_shared<SecurityLabelsCatalog>();

labelPayload->addItem(labelItem);

IQ::ref result = IQ::createResult(self_, iq->getID(), labelPayload);

iqChannel_->onIQReceived(result);

std::string messageBody("agamemnon");

window_->onSendMessageRequest(messageBody, false);

boost::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

Message::ref message = boost::dynamic_pointer_cast<Message>(rawStanza);

CPPUNIT_ASSERT_EQUAL(iq->getTo(), result->getFrom());

CPPUNIT_ASSERT(window_->labelsEnabled_);

CPPUNIT_ASSERT(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */

CPPUNIT_ASSERT(message);

CPPUNIT_ASSERT_EQUAL(label, message->getPayload<SecurityLabel>());

window_->label_ = labelItem2;

window_->onSendMessageRequest(messageBody, true);

rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

message = boost::dynamic_pointer_cast<Message>(rawStanza);

CPPUNIT_ASSERT_EQUAL(label, message->getPayload<SecurityLabel>());

}

void checkEqual(const std::vector<NickJoinPart>& expected, const std::vector<NickJoinPart>& actual) {

CPPUNIT_ASSERT_EQUAL(expected.size(), actual.size());

for (size_t i = 0; i < expected.size(); i++) {

CPPUNIT_ASSERT_EQUAL(expected[i].nick, actual[i].nick);

CPPUNIT_ASSERT_EQUAL(expected[i].type, actual[i].type);

}

}

void testAppendToJoinParts() {

std::vector<NickJoinPart> list;

std::vector<NickJoinPart> gold;

MUCController::appendToJoinParts(list, NickJoinPart("Kev", Join));

gold.push_back(NickJoinPart("Kev", Join));

checkEqual(gold, list);

MUCController::appendToJoinParts(list, NickJoinPart("Remko", Join));

gold.push_back(NickJoinPart("Remko", Join));

checkEqual(gold, list);

MUCController::appendToJoinParts(list, NickJoinPart("Bert", Join));

gold.push_back(NickJoinPart("Bert", Join));

checkEqual(gold, list);

MUCController::appendToJoinParts(list, NickJoinPart("Bert", Part));

gold[2].type = JoinThenPart;

checkEqual(gold, list);

MUCController::appendToJoinParts(list, NickJoinPart("Kev", Part));

gold[0].type = JoinThenPart;

checkEqual(gold, list);

MUCController::appendToJoinParts(list, NickJoinPart("Remko", Part));

muc_->insertOccupant(occupant.second);

}

std::vector<MUCOccupant> alterations;

alterations.push_back(MUCOccupant("Kev", MUCOccupant::Visitor, MUCOccupant::Admin));

alterations.push_back(MUCOccupant("Remko", MUCOccupant::Moderator, MUCOccupant::Member));

alterations.push_back(MUCOccupant("Bert", MUCOccupant::Visitor, MUCOccupant::Outcast));

alterations.push_back(MUCOccupant("Ernie", MUCOccupant::NoRole, MUCOccupant::Member));

alterations.push_back(MUCOccupant("Bert", MUCOccupant::Moderator, MUCOccupant::Owner));

alterations.push_back(MUCOccupant("Kev", MUCOccupant::Participant, MUCOccupant::Outcast));

alterations.push_back(MUCOccupant("Bert", MUCOccupant::Visitor, MUCOccupant::NoAffiliation));

alterations.push_back(MUCOccupant("Remko", MUCOccupant::NoRole, MUCOccupant::NoAffiliation));

alterations.push_back(MUCOccupant("Ernie", MUCOccupant::Visitor, MUCOccupant::Outcast));

foreach(const MUCOccupant& alteration, alterations) {

/* perform an alteration to a user's role and affiliation */

occupant_map::iterator occupant = occupants.find(alteration.getNick());

CPPUNIT_ASSERT(occupant != occupants.end());

const JID jid = jidFromOccupant(occupant->second);

/* change the affiliation, leave the role in place */

muc_->changeAffiliation(jid, alteration.getAffiliation());

occupant->second = MUCOccupant(occupant->first, occupant->second.getRole(), alteration.getAffiliation());

testRoleAffiliationStatesVerify(occupants);

/* change the role, leave the affiliation in place */

muc_->changeOccupantRole(jid, alteration.getRole());

occupant->second = MUCOccupant(occupant->first, alteration.getRole(), occupant->second.getAffiliation());

testRoleAffiliationStatesVerify(occupants);

}

}

void testRoleAffiliationStatesVerify(const std::map<std::string, MUCOccupant> &occupants) {

/* verify that the roster is in sync */

GroupRosterItem* group = window_->getRosterModel()->getRoot();

foreach(RosterItem* rosterItem, group->getChildren()) {

GroupRosterItem* child = dynamic_cast<GroupRosterItem*>(rosterItem);

CPPUNIT_ASSERT(child);

foreach(RosterItem* childItem, child->getChildren()) {

ContactRosterItem* item = dynamic_cast<ContactRosterItem*>(childItem);

CPPUNIT_ASSERT(item);

std::map<std::string, MUCOccupant>::const_iterator occupant = occupants.find(item->getJID().getResource());

CPPUNIT_ASSERT(occupant != occupants.end());

CPPUNIT_ASSERT(item->getMUCRole() == occupant->second.getRole());

CPPUNIT_ASSERT(item->getMUCAffiliation() == occupant->second.getAffiliation());

}

}

}

private:

JID self_;

JID mucJID_;

MockMUC::ref muc_;

std::string nick_;

DummyStanzaChannel* stanzaChannel_;

DummyIQChannel* iqChannel_;

IQRouter* iqRouter_;

EventController* eventController_;

ChatWindowFactory* chatWindowFactory_;

UserSearchWindowFactory* userSearchWindowFactory_;

MUCController* controller_;

// NickResolver* nickResolver_;