void ChatsManager::handleUserLeftMUC(MUCController* mucController) {

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

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

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

foreach (ChatListWindow::Chat& chat, recentChats_) {

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

chat.statusType = StatusShow::None;

chatListWindow_->setRecents(recentChats_);

break;

}

}

mucControllers_.erase(it);

delete mucController;

return;

}

}

}

void ChatsManager::handleUIEvent(boost::shared_ptr<UIEvent> event) {

boost::shared_ptr<RequestChatUIEvent> chatEvent = boost::dynamic_pointer_cast<RequestChatUIEvent>(event);

if (chatEvent) {

handleChatRequest(chatEvent->getContact());

return;

}

boost::shared_ptr<RemoveMUCBookmarkUIEvent> removeMUCBookmarkEvent = boost::dynamic_pointer_cast<RemoveMUCBookmarkUIEvent>(event);

if (removeMUCBookmarkEvent) {

mucBookmarkManager_->removeBookmark(removeMUCBookmarkEvent->getBookmark());

return;

}

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

if (addMUCBookmarkEvent) {

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

return;

}

return;

}

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

if (editMUCBookmarkEvent) {

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

}

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

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

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

}

else if (boost::shared_ptr<RequestJoinMUCUIEvent> joinEvent = boost::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();

}

}

/**

* If a resource goes offline, release bound chatdialog to that resource.

*/

void ChatsManager::handlePresenceChange(boost::shared_ptr<Presence> newPresence) {

if (mucRegistry_->isMUC(newPresence->getFrom().toBare())) return;

foreach (ChatListWindow::Chat& chat, recentChats_) {

if (newPresence->getFrom().toBare() == chat.jid.toBare() && !chat.isMUC) {

Presence::ref presence = presenceOracle_->getHighestPriorityPresence(chat.jid.toBare());

chat.setStatusType(presence ? presence->getShow() : StatusShow::None);

chatListWindow_->setRecents(recentChats_);

break;

}

jid2Offline->setFrom(JID(messageJID2));

jid2Offline->setType(Presence::Unavailable);

presenceOracle_->onPresenceChange(jid2Offline);

JID messageJID3("testling@test.com/resource3");

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

message3->setFrom(messageJID3);

std::string body3("This is a legible message3.");

message3->setBody(body3);

manager_->handleIncomingMessage(message3);

CPPUNIT_ASSERT_EQUAL(body3, window1->lastMessageBody_);

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

message2b->setFrom(messageJID2);

std::string body2b("This is a legible message2b.");

message2b->setBody(body2b);

manager_->handleIncomingMessage(message2b);

CPPUNIT_ASSERT_EQUAL(body2b, window1->lastMessageBody_);

}

/**

* Test that ChatController doesn't send receipts anymore after removal of the contact from the roster.

*/

void testChatControllerPresenceAccessUpdatedOnRemoveFromRoster() {

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

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

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

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

uiEventStream_->send(boost::shared_ptr<UIEvent>(new ToggleRequestDeliveryReceiptsUIEvent(true)));

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

manager_->handleIncomingMessage(message);

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

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

xmppRoster_->removeContact(messageJID);

message->setID("2");

manager_->handleIncomingMessage(message);

}

/**

* Test that ChatController sends receipts after the contact has been added to the roster.

*/

void testChatControllerPresenceAccessUpdatedOnAddToRoster() {

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

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

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

uiEventStream_->send(boost::shared_ptr<UIEvent>(new ToggleRequestDeliveryReceiptsUIEvent(true)));

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

manager_->handleIncomingMessage(message);

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

message->setID("2");

manager_->handleIncomingMessage(message);

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

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

}

/**

* Test that ChatController sends receipts if requested after change from subscription state To to subscription state Both.

*/

void testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToBoth() {

testhelperChatControllerPresenceAccessUpdatedOnSubscriptionChangeReceiptsAllowed(RosterItemPayload::To, RosterItemPayload::Both);

}

/**

* Test that ChatController sends receipts if requested after change from subscription state To to subscription state From.

*/

void testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToFrom() {

testhelperChatControllerPresenceAccessUpdatedOnSubscriptionChangeReceiptsAllowed(RosterItemPayload::To, RosterItemPayload::From);

}

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

uiEventStream_->send(boost::shared_ptr<UIEvent>(new ToggleRequestDeliveryReceiptsUIEvent(true)));

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

manager_->handleIncomingMessage(message);

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

message->setID("2");

manager_->handleIncomingMessage(message);

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->addPayload(boost::make_shared<DeliveryReceiptRequest>());

return message;

}

private:

JID jid_;

ChatsManager* manager_;

DummyStanzaChannel* stanzaChannel_;

IQChannel* iqChannel_;

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_;

MUCSearchWindowFactory* mucSearchWindowFactory_;

MUCRegistry* mucRegistry_;

DirectedPresenceSender* directedPresenceSender_;

EntityCapsManager* entityCapsManager_;

CapsProvider* capsProvider_;

MUCManager* mucManager_;

DummySettingsProvider* settings_;

ProfileSettingsProvider* profileSettings_;

ChatListWindow* chatListWindow_;

FileTransferOverview* ftOverview_;

FileTransferManager* ftManager_;

};

CPPUNIT_TEST_SUITE_REGISTRATION(ChatsManagerTest);