/*

* Copyright (c) 2010-2014 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

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

#include <boost/bind.hpp>

#include <boost/algorithm/string.hpp>

#include <boost/smart_ptr/make_shared.hpp>

#include <boost/archive/text_oarchive.hpp>

#include <boost/archive/text_iarchive.hpp>

#include <boost/serialization/vector.hpp>

#include <boost/serialization/map.hpp>

#include <boost/serialization/string.hpp>

#include <boost/serialization/split_free.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Presence/PresenceSender.h>

#include <Swiften/Client/NickResolver.h>

#include <Swiften/MUC/MUCManager.h>

#include <Swiften/Elements/ChatState.h>

#include <Swiften/Elements/MUCUserPayload.h>

#include <Swiften/Elements/DeliveryReceipt.h>

#include <Swiften/Elements/DeliveryReceiptRequest.h>

#include <Swiften/MUC/MUCBookmarkManager.h>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Elements/MUCInvitationPayload.h>

#include <Swiften/Roster/XMPPRoster.h>

#include <Swiften/Client/ClientBlockListManager.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/VCards/VCardManager.h>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#include <Swift/Controllers/ProfileSettingsProvider.h>

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

#include <Swift/Controllers/SettingConstants.h>

#include <Swift/Controllers/WhiteboardManager.h>

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

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

#include <Swiften/Disco/DiscoServiceWalker.h>

#include <Swiften/Client/ClientBlockListManager.h>

#include <Swiften/StringCodecs/Base64.h>

#include <Swiften/Base/Log.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);

}

ar & chat.jid;

ar & chat.chatName;

ar & chat.activity;

ar & chat.isMUC;

ar & chat.nick;

ar & chat.impromptuJIDs;

}

}

}

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,

XMPPRoster* roster,

bool eagleMode,

SettingsProvider* settings,

HistoryController* historyController,

WhiteboardManager* whiteboardManager,

HighlightManager* highlightManager,

ClientBlockListManager* clientBlockListManager,

const std::map<std::string, std::string>& emoticons,

UserSearchController* inviteUserSearchController,

VCardManager* vcardManager) :

jid_(jid),

joinMUCWindowFactory_(joinMUCWindowFactory),

useDelayForLatency_(useDelayForLatency),

mucRegistry_(mucRegistry),

entityCapsProvider_(entityCapsProvider),

mucManager(mucManager),

ftOverview_(ftOverview),

roster_(roster),

eagleMode_(eagleMode),

settings_(settings),

historyController_(historyController),

whiteboardManager_(whiteboardManager),

highlightManager_(highlightManager),

clientBlockListManager_(clientBlockListManager),

inviteUserSearchController_(inviteUserSearchController),

vcardManager_(vcardManager) {

timerFactory_ = timerFactory;

eventController_ = eventController;

stanzaChannel_ = stanzaChannel;

iqRouter_ = iqRouter;

chatWindowFactory_ = chatWindowFactory;

nickResolver_ = nickResolver;

presenceOracle_ = presenceOracle;

avatarManager_ = NULL;

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

presenceSender_ = presenceSender;

uiEventStream_ = uiEventStream;

mucBookmarkManager_ = NULL;

profileSettings_ = profileSettings;

chatMessageParser_ = new ChatMessageParser(emoticons);

presenceOracle_->onPresenceChange.connect(boost::bind(&ChatsManager::handlePresenceChange, this, _1));

uiEventConnection_ = uiEventStream_->onUIEvent.connect(boost::bind(&ChatsManager::handleUIEvent, this, _1));

chatListWindow_ = chatListWindowFactory->createChatListWindow(uiEventStream_);

chatListWindow_->onMUCBookmarkActivated.connect(boost::bind(&ChatsManager::handleMUCBookmarkActivated, this, _1));

chatListWindow_->onRecentActivated.connect(boost::bind(&ChatsManager::handleRecentActivated, this, _1));

chatListWindow_->onClearRecentsRequested.connect(boost::bind(&ChatsManager::handleClearRecentsRequested, this));

joinMUCWindow_ = NULL;

mucSearchController_ = new MUCSearchController(jid_, mucSearchWindowFactory, iqRouter, profileSettings_);

mucSearchController_->onMUCSelected.connect(boost::bind(&ChatsManager::handleMUCSelectedAfterSearch, this, _1));

ftOverview_->onNewFileTransferController.connect(boost::bind(&ChatsManager::handleNewFileTransferController, this, _1));

whiteboardManager_->onSessionRequest.connect(boost::bind(&ChatsManager::handleWhiteboardSessionRequest, this, _1, _2));

whiteboardManager_->onRequestAccepted.connect(boost::bind(&ChatsManager::handleWhiteboardStateChange, this, _1, ChatWindow::WhiteboardAccepted));

whiteboardManager_->onSessionTerminate.connect(boost::bind(&ChatsManager::handleWhiteboardStateChange, this, _1, ChatWindow::WhiteboardTerminated));

whiteboardManager_->onRequestRejected.connect(boost::bind(&ChatsManager::handleWhiteboardStateChange, this, _1, ChatWindow::WhiteboardRejected));

roster_->onJIDAdded.connect(boost::bind(&ChatsManager::handleJIDAddedToRoster, this, _1));

roster_->onJIDRemoved.connect(boost::bind(&ChatsManager::handleJIDRemovedFromRoster, this, _1));

roster_->onJIDUpdated.connect(boost::bind(&ChatsManager::handleJIDUpdatedInRoster, this, _1));

roster_->onRosterCleared.connect(boost::bind(&ChatsManager::handleRosterCleared, this));

settings_->onSettingChanged.connect(boost::bind(&ChatsManager::handleSettingChanged, this, _1));

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

setupBookmarks();

loadRecents();

autoAcceptMUCInviteDecider_ = new AutoAcceptMUCInviteDecider(jid.getDomain(), roster_, settings_);

}

ChatsManager::~ChatsManager() {

settings_->onSettingChanged.disconnect(boost::bind(&ChatsManager::handleSettingChanged, this, _1));

roster_->onJIDAdded.disconnect(boost::bind(&ChatsManager::handleJIDAddedToRoster, this, _1));

roster_->onJIDRemoved.disconnect(boost::bind(&ChatsManager::handleJIDRemovedFromRoster, this, _1));

roster_->onJIDUpdated.disconnect(boost::bind(&ChatsManager::handleJIDUpdatedInRoster, this, _1));

roster_->onRosterCleared.disconnect(boost::bind(&ChatsManager::handleRosterCleared, this));

delete joinMUCWindow_;

foreach (JIDChatControllerPair controllerPair, chatControllers_) {

delete controllerPair.second;

}

foreach (JIDMUCControllerPair controllerPair, mucControllers_) {

delete controllerPair.second;

}

delete mucBookmarkManager_;

delete mucSearchController_;

delete chatMessageParser_;

delete autoAcceptMUCInviteDecider_;

}

void ChatsManager::saveRecents() {

std::stringstream serializeStream;

boost::archive::text_oarchive oa(serializeStream);

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

if (recentsLimited.size() > 25) {

recentsLimited.erase(recentsLimited.begin() + 25, recentsLimited.end());

}

if (eagleMode_) {

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

chat.activity = "";

}

}

oa << recentsLimited;

std::string serializedStr = Base64::encode(createByteArray(serializeStream.str()));

profileSettings_->storeString(RECENT_CHATS, serializedStr);

}

void ChatsManager::handleClearRecentsRequested() {

recentChats_.clear();

saveRecents();

handleUnreadCountChanged(NULL);

}

void ChatsManager::handleJIDAddedToRoster(const JID &jid) {

updatePresenceReceivingStateOnChatController(jid);

}

void ChatsManager::handleJIDRemovedFromRoster(const JID &jid) {

updatePresenceReceivingStateOnChatController(jid);

}

void ChatsManager::handleJIDUpdatedInRoster(const JID &jid) {

updatePresenceReceivingStateOnChatController(jid);

}

void ChatsManager::handleRosterCleared() {

/* Setting that all chat controllers aren't receiving presence anymore;

including MUC 1-to-1 chats due to the assumtion that this handler

is only called on log out. */

foreach(JIDChatControllerPair pair, chatControllers_) {

pair.second->setContactIsReceivingPresence(false);

}

}

void ChatsManager::updatePresenceReceivingStateOnChatController(const JID &jid) {

ChatController* controller = getChatControllerIfExists(jid);

if (controller) {

if (!mucRegistry_->isMUC(jid.toBare())) {

RosterItemPayload::Subscription subscription = roster_->getSubscriptionStateForJID(jid);

controller->setContactIsReceivingPresence(subscription == RosterItemPayload::From || subscription == RosterItemPayload::Both);

} else {

controller->setContactIsReceivingPresence(true);

}

}

}

ChatListWindow::Chat ChatsManager::updateChatStatusAndAvatarHelper(const ChatListWindow::Chat& chat) const {

ChatListWindow::Chat fixedChat = chat;

if (fixedChat.isMUC) {

if (mucControllers_.find(fixedChat.jid.toBare()) != mucControllers_.end()) {

fixedChat.statusType = StatusShow::Online;

}

} else {

if (avatarManager_) {

fixedChat.avatarPath = avatarManager_->getAvatarPath(fixedChat.jid);

}

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

fixedChat.statusType = presence ? presence->getShow() : StatusShow::None;

}

return fixedChat;

}

void ChatsManager::loadRecents() {

std::string recentsString(profileSettings_->getStringSetting(RECENT_CHATS));

if (recentsString.find("\t") != std::string::npos) {

// old format

std::vector<std::string> recents;

boost::split(recents, recentsString, boost::is_any_of("\n"));

int i = 0;

foreach (std::string recentString, recents) {

if (i++ > 30) {

break;

}

std::vector<std::string> recent;

boost::split(recent, recentString, boost::is_any_of("\t"));

if (recent.size() < 4) {

continue;

}

JID jid(recent[0]);

if (!jid.isValid()) {

continue;

}

std::string activity(recent[1]);

bool isMUC = recent[2] == "true";

std::string nick(recent[3]);

StatusShow::Type type = StatusShow::None;

boost::filesystem::path path;

ChatListWindow::Chat chat(jid, nickResolver_->jidToNick(jid), activity, 0, type, path, isMUC, nick);

chat = updateChatStatusAndAvatarHelper(chat);

prependRecent(chat);

}

} else if (!recentsString.empty()){

// boost searilaize based format

ByteArray debase64 = Base64::decode(recentsString);

std::vector<ChatListWindow::Chat> recentChats;

std::stringstream deserializeStream(std::string(reinterpret_cast<const char*>(vecptr(debase64)), debase64.size()));

try {

boost::archive::text_iarchive ia(deserializeStream);

ia >> recentChats;

} catch (const boost::archive::archive_exception& e) {

SWIFT_LOG(debug) << "Failed to load recents: " << e.what() << std::endl;

return;

}

foreach(ChatListWindow::Chat chat, recentChats) {

chat.statusType = StatusShow::None;

chat = updateChatStatusAndAvatarHelper(chat);

prependRecent(chat);

}

}

handleUnreadCountChanged(NULL);

}

void ChatsManager::setupBookmarks() {

if (!mucBookmarkManager_) {

mucBookmarkManager_ = new MUCBookmarkManager(iqRouter_);

mucBookmarkManager_->onBookmarksReady.connect(boost::bind(&ChatsManager::handleBookmarksReady, this));

mucBookmarkManager_->onBookmarkAdded.connect(boost::bind(&ChatsManager::handleMUCBookmarkAdded, this, _1));

mucBookmarkManager_->onBookmarkRemoved.connect(boost::bind(&ChatsManager::handleMUCBookmarkRemoved, this, _1));

if (chatListWindow_) {

chatListWindow_->setBookmarksEnabled(false);

chatListWindow_->clearBookmarks();

}

}

}

void ChatsManager::handleBookmarksReady() {

if (chatListWindow_) {

chatListWindow_->setBookmarksEnabled(true);

}

}

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

std::map<JID, MUCController*>::iterator it = mucControllers_.find(bookmark.getRoom());

if (it == mucControllers_.end() && bookmark.getAutojoin()) {

handleJoinMUCRequest(bookmark.getRoom(), bookmark.getPassword(), bookmark.getNick(), false, false, false );

}

chatListWindow_->addMUCBookmark(bookmark);

}

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

chatListWindow_->removeMUCBookmark(bookmark);

}

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

int unreadCount = 0;

if (mucRegistry_->isMUC(jid)) {

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

StatusShow::Type type = StatusShow::None;

std::string nick = "";

if (controller) {

unreadCount = controller->getUnreadCount();

if (controller->isJoined()) {

type = StatusShow::Online;

}

nick = controller->getNick();

if (controller->isImpromptu()) {

typedef std::pair<std::string, JID> StringJIDPair;

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

chat.impromptuJIDs = participants;

return chat;

}

}

} else {

ChatController* controller = getChatControllerIfExists(jid, false);

if (controller) {

unreadCount = controller->getUnreadCount();

}

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

Presence::ref presence = presenceOracle_->getHighestPriorityPresence(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);

}

}

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

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

/* Don't include PMs in MUC rooms.*/

return;

}

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

/* FIXME: handle nick changes */

appendRecent(chat);

handleUnreadCountChanged(NULL);

saveRecents();

}

void ChatsManager::handleUnreadCountChanged(ChatControllerBase* controller) {

int unreadTotal = 0;

bool controllerIsMUC = dynamic_cast<MUCController*>(controller);

bool isPM = controller && !controllerIsMUC && mucRegistry_->isMUC(controller->getToJID().toBare());

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

bool match = false;

if (controller) {

/* Matching MUC item */

match |= chatItem.isMUC == controllerIsMUC && chatItem.jid.toBare() == controller->getToJID().toBare();

/* Matching PM */

match |= isPM && chatItem.jid == controller->getToJID();

/* Matching non-PM */

match |= !isPM && !controllerIsMUC && chatItem.jid.toBare() == controller->getToJID().toBare();

}

if (match) {

chatItem.setUnreadCount(controller->getUnreadCount());

}

unreadTotal += chatItem.unreadCount;

}

chatListWindow_->setRecents(recentChats_);

chatListWindow_->setUnreadCount(unreadTotal);

}

boost::optional<ChatListWindow::Chat> ChatsManager::removeExistingChat(const ChatListWindow::Chat& chat) {

std::list<ChatListWindow::Chat>::iterator result = std::find(recentChats_.begin(), recentChats_.end(), chat);

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::appendRecent(const ChatListWindow::Chat& chat) {

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

ChatListWindow::Chat mergedChat = chat;

if (oldChat && !oldChat->impromptuJIDs.empty()) {

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;

if (oldChat && !oldChat->impromptuJIDs.empty()) {

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

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::handleSettingChanged(const std::string& settingPath) {

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

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

return;

}

}

void ChatsManager::finalizeImpromptuJoin(MUC::ref muc, const std::vector<JID>& jidsToInvite, const std::string& reason, const boost::optional<JID>& reuseChatJID) {

// send impromptu invites for the new MUC

std::vector<JID> missingJIDsToInvite = jidsToInvite;

typedef std::pair<std::string, MUCOccupant> StringMUCOccupantPair;

std::map<std::string, MUCOccupant> occupants = muc->getOccupants();

foreach(StringMUCOccupantPair occupant, occupants) {

boost::optional<JID> realJID = occupant.second.getRealJID();

if (realJID) {

missingJIDsToInvite.erase(std::remove(missingJIDsToInvite.begin(), missingJIDsToInvite.end(), realJID->toBare()), missingJIDsToInvite.end());

}

}

if (reuseChatJID) {

muc->invitePerson(reuseChatJID.get(), reason, true, true);

}

foreach(const JID& jid, missingJIDsToInvite) {

muc->invitePerson(jid, reason, true);

}

}

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;

}

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

if (createImpromptuMUCEvent) {

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

// create new muc

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

}

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(), joinEvent->isImpromptu());

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

}

}

void ChatsManager::markAllRecentsOffline() {

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

chat.setStatusType(StatusShow::None);

}

chatListWindow_->setRecents(recentChats_);

}

void ChatsManager::handleTransformChatToMUC(ChatController* chatController, ChatWindow* chatWindow, const std::vector<JID>& jidsToInvite, const std::string& reason) {

JID reuseChatInvite = chatController->getToJID();

chatControllers_.erase(chatController->getToJID());

delete chatController;

// join new impromptu muc

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

// create new muc

JID roomJID = JID(idGenerator_.generateID(), localMUCServiceJID_);

// join muc

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

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

}

/**

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

}

}

//if (newPresence->getType() != Presence::Unavailable) return;

JID fullJID(newPresence->getFrom());

std::map<JID, ChatController*>::iterator it = chatControllers_.find(fullJID);

if (it == chatControllers_.end()) return;

JID bareJID(fullJID.toBare());

//It doesn't make sense to have two unbound dialogs.

if (chatControllers_.find(bareJID) != chatControllers_.end()) return;

rebindControllerJID(fullJID, bareJID);

}

void ChatsManager::setAvatarManager(AvatarManager* avatarManager) {

if (avatarManager_) {

avatarManager_->onAvatarChanged.disconnect(boost::bind(&ChatsManager::handleAvatarChanged, this, _1));

}

avatarManager_ = avatarManager;

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

if (!chat.isMUC) {

chat.setAvatarPath(avatarManager_->getAvatarPath(chat.jid));

}

}

avatarManager_->onAvatarChanged.connect(boost::bind(&ChatsManager::handleAvatarChanged, this, _1));

}

void ChatsManager::handleAvatarChanged(const JID& jid) {

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

if (!chat.isMUC && jid.toBare() == chat.jid.toBare()) {

chat.setAvatarPath(avatarManager_->getAvatarPath(jid));

break;

}

}

}

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

delete mucBookmarkManager_;

mucBookmarkManager_ = NULL;

chatListWindow_->setBookmarksEnabled(false);

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

}

}

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

}

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

assert(chatControllers_.find(contact) == chatControllers_.end());

ChatController* controller = new ChatController(jid_, stanzaChannel_, iqRouter_, chatWindowFactory_, contact, nickResolver_, presenceOracle_, avatarManager_, mucRegistry_->isMUC(contact.toBare()), useDelayForLatency_, uiEventStream_, eventController_, timerFactory_, entityCapsProvider_, userWantsReceipts_, settings_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser_, autoAcceptMUCInviteDecider_);

chatControllers_[contact] = controller;

controller->setAvailableServerFeatures(serverDiscoInfo_);

controller->onActivity.connect(boost::bind(&ChatsManager::handleChatActivity, this, contact, _1, false));

controller->onUnreadCountChanged.connect(boost::bind(&ChatsManager::handleUnreadCountChanged, this, controller));

controller->onConvertToMUC.connect(boost::bind(&ChatsManager::handleTransformChatToMUC, this, controller, _1, _2, _3));

updatePresenceReceivingStateOnChatController(contact);

controller->setCanStartImpromptuChats(!localMUCServiceJID_.toString().empty());

return controller;

}

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

ChatController* controller = getChatControllerIfExists(contact);

return controller ? controller : createNewChatController(contact);

}

ChatController* ChatsManager::getChatControllerIfExists(const JID &contact, bool rebindIfNeeded) {

if (chatControllers_.find(contact) == chatControllers_.end()) {

if (mucRegistry_->isMUC(contact.toBare())) {

return NULL;

}

//Need to look for an unbound window to bind first

JID bare(contact.toBare());

if (chatControllers_.find(bare) != chatControllers_.end()) {

rebindControllerJID(bare, contact);

} else {

foreach (JIDChatControllerPair pair, chatControllers_) {

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

if (rebindIfNeeded) {

rebindControllerJID(pair.first, contact);

return chatControllers_[contact];

} else {

return pair.second;

}

}

}

return NULL;

}

}

return chatControllers_[contact];

}

void ChatsManager::rebindControllerJID(const JID& from, const JID& to) {

chatControllers_[to] = chatControllers_[from];

chatControllers_.erase(from);

chatControllers_[to]->setToJID(to);

}

MUC::ref ChatsManager::handleJoinMUCRequest(const JID &mucJID, const boost::optional<std::string>& password, const boost::optional<std::string>& nickMaybe, bool addAutoJoin, bool createAsReservedIfNew, bool isImpromptu, ChatWindow* reuseChatwindow) {

MUC::ref muc;

if (!stanzaChannel_->isAvailable()) {

/* This is potentially not the optimal solution, but it will avoid consistency issues.*/

return muc;

}

if (addAutoJoin) {

MUCBookmark bookmark(mucJID, mucJID.getNode());

bookmark.setAutojoin(true);

if (nickMaybe) {

bookmark.setNick(*nickMaybe);

}

if (password) {

bookmark.setPassword(*password);

}

mucBookmarkManager_->addBookmark(bookmark);

}

std::map<JID, MUCController*>::iterator it = mucControllers_.find(mucJID);

if (it != mucControllers_.end()) {

it->second->rejoin();

} else {

std::string nick = (nickMaybe && !(*nickMaybe).empty()) ? nickMaybe.get() : nickResolver_->jidToNick(jid_);

muc = mucManager->createMUC(mucJID);

if (createAsReservedIfNew) {

muc->setCreateAsReservedIfNew();

}

if (isImpromptu) {

muc->setCreateAsReservedIfNew();

}

MUCController* controller = NULL;

SingleChatWindowFactoryAdapter* chatWindowFactoryAdapter = NULL;

if (reuseChatwindow) {

chatWindowFactoryAdapter = new SingleChatWindowFactoryAdapter(reuseChatwindow);

}

controller = new MUCController(jid_, muc, password, nick, stanzaChannel_, iqRouter_, reuseChatwindow ? chatWindowFactoryAdapter : chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_, roster_, historyController_, mucRegistry_, highlightManager_, chatMessageParser_, isImpromptu, autoAcceptMUCInviteDecider_, vcardManager_);

if (chatWindowFactoryAdapter) {

/* The adapters are only passed to chat windows, which are deleted in their

* controllers' dtor, which are deleted in ChatManager's dtor. The adapters

* are also deleted there.*/

chatWindowFactoryAdapters_[controller] = chatWindowFactoryAdapter;

}

mucControllers_[mucJID] = controller;

controller->setAvailableServerFeatures(serverDiscoInfo_);

controller->onUserLeft.connect(boost::bind(&ChatsManager::handleUserLeftMUC, this, controller));

controller->onUserJoined.connect(boost::bind(&ChatsManager::handleChatActivity, this, mucJID.toBare(), "", true));

controller->onActivity.connect(boost::bind(&ChatsManager::handleChatActivity, this, mucJID.toBare(), _1, true));

controller->onUnreadCountChanged.connect(boost::bind(&ChatsManager::handleUnreadCountChanged, this, controller));

handleChatActivity(mucJID.toBare(), "", true);

}

mucControllers_[mucJID]->showChatWindow();

return muc;

}

void ChatsManager::handleSearchMUCRequest() {

mucSearchController_->openSearchWindow();

}

void ChatsManager::handleIncomingMessage(boost::shared_ptr<Message> message) {

JID jid = message->getFrom();

boost::shared_ptr<MessageEvent> event(new MessageEvent(message));

bool isInvite = !!message->getPayload<MUCInvitationPayload>();

bool isMediatedInvite = (message->getPayload<MUCUserPayload>() && message->getPayload<MUCUserPayload>()->getInvite());

if (isMediatedInvite) {

jid = (*message->getPayload<MUCUserPayload>()->getInvite()).from;

}

if (!event->isReadable() && !message->getPayload<ChatState>() && !message->getPayload<DeliveryReceipt>() && !message->getPayload<DeliveryReceiptRequest>() && !isInvite && !isMediatedInvite && !message->hasSubject()) {

return;

}

// Try to deliver it to a MUC

if (message->getType() == Message::Groupchat || message->getType() == Message::Error /*|| (isInvite && message->getType() == Message::Normal)*/) {

std::map<JID, MUCController*>::iterator i = mucControllers_.find(jid.toBare());

if (i != mucControllers_.end()) {

i->second->handleIncomingMessage(event);

return;

}

else if (message->getType() == Message::Groupchat) {

//FIXME: Error handling - groupchat messages from an unknown muc.

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

}

} 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.*/

ChatController* controller = getChatControllerIfExists(jid);

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

}

void ChatsManager::handleWhiteboardSessionRequest(const JID& contact, bool senderIsSelf) {

ChatController* chatController = getChatControllerOrCreate(contact);

chatController->handleWhiteboardSessionRequest(senderIsSelf);

chatController->activateChatWindow();

}

void ChatsManager::handleWhiteboardStateChange(const JID& contact, const ChatWindow::WhiteboardSessionState state) {

ChatController* chatController = getChatControllerOrCreate(contact);

chatController->handleWhiteboardStateChange(state);

chatController->activateChatWindow();

if (state == ChatWindow::WhiteboardAccepted) {

boost::filesystem::path path;

JID bareJID = contact.toBare();

if (avatarManager_) {

path = avatarManager_->getAvatarPath(bareJID);

}

ChatListWindow::Chat chat(bareJID, nickResolver_->jidToNick(bareJID), "", 0, StatusShow::None, path, false);

chatListWindow_->addWhiteboardSession(chat);

} else {

chatListWindow_->removeWhiteboardSession(contact.toBare());

}

}

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

if (chat.isMUC && !chat.impromptuJIDs.empty()) {

typedef std::pair<std::string, JID> StringJIDPair;

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

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

}

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

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

}

/*

* Copyright (c) 2010-2014 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

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

#include <boost/bind.hpp>

#include <boost/regex.hpp>

#include <boost/algorithm/string.hpp>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Base/format.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/Disco/EntityCapsProvider.h>

#include <Swiften/Elements/Delay.h>

#include <Swiften/MUC/MUC.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/SetPresence.h>

#include <Swift/Controllers/Roster/ItemOperations/SetMUC.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/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>

#define MUC_JOIN_WARNING_TIMEOUT_MILLISECONDS 60000

namespace Swift {

/**

* The controller does not gain ownership of the stanzaChannel, nor the factory.

*/

MUCController::MUCController (

const JID& self,

MUC::ref muc,

const boost::optional<std::string>& password,

const std::string &nick,

StanzaChannel* stanzaChannel,

IQRouter* iqRouter,

ChatWindowFactory* chatWindowFactory,

PresenceOracle* presenceOracle,

AvatarManager* avatarManager,

UIEventStream* uiEventStream,

bool useDelayForLatency,

TimerFactory* timerFactory,

EventController* eventController,

EntityCapsProvider* entityCapsProvider,

XMPPRoster* roster,

HistoryController* historyController,

MUCRegistry* mucRegistry,

HighlightManager* highlightManager,

ChatMessageParser* chatMessageParser,

bool isImpromptu,

AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider,

VCardManager* vcardManager) :

ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, timerFactory, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider), muc_(muc), nick_(nick), desiredNick_(nick), password_(password), renameCounter_(0), isImpromptu_(isImpromptu), isImpromptuAlreadyConfigured_(false) {

parting_ = true;

joined_ = false;

lastWasPresence_ = false;

shouldJoinOnReconnect_ = true;

doneGettingHistory_ = false;

events_ = uiEventStream;

xmppRoster_ = roster;

roster_ = new Roster(false, true);

rosterVCardProvider_ = new RosterVCardProvider(roster_, vcardManager, JID::WithResource);

completer_ = new TabComplete();

chatWindow_->setRosterModel(roster_);

chatWindow_->setTabComplete(completer_);

chatWindow_->onClosed.connect(boost::bind(&MUCController::handleWindowClosed, this));

chatWindow_->onOccupantSelectionChanged.connect(boost::bind(&MUCController::handleWindowOccupantSelectionChanged, this, _1));

chatWindow_->onOccupantActionSelected.connect(boost::bind(&MUCController::handleActionRequestedOnOccupant, this, _1, _2));

chatWindow_->onChangeSubjectRequest.connect(boost::bind(&MUCController::handleChangeSubjectRequest, this, _1));

chatWindow_->onBookmarkRequest.connect(boost::bind(&MUCController::handleBookmarkRequest, this));

chatWindow_->onConfigureRequest.connect(boost::bind(&MUCController::handleConfigureRequest, this, _1));

chatWindow_->onConfigurationFormCancelled.connect(boost::bind(&MUCController::handleConfigurationCancelled, this));

chatWindow_->onDestroyRequest.connect(boost::bind(&MUCController::handleDestroyRoomRequest, this));

chatWindow_->onInviteToChat.connect(boost::bind(&MUCController::handleInvitePersonToThisMUCRequest, this, _1));

chatWindow_->onGetAffiliationsRequest.connect(boost::bind(&MUCController::handleGetAffiliationsRequest, this));

chatWindow_->onChangeAffiliationsRequest.connect(boost::bind(&MUCController::handleChangeAffiliationsRequest, this, _1));

muc_->onJoinComplete.connect(boost::bind(&MUCController::handleJoinComplete, this, _1));

muc_->onJoinFailed.connect(boost::bind(&MUCController::handleJoinFailed, this, _1));

muc_->onOccupantJoined.connect(boost::bind(&MUCController::handleOccupantJoined, this, _1));

muc_->onOccupantPresenceChange.connect(boost::bind(&MUCController::handleOccupantPresenceChange, this, _1));

muc_->onOccupantLeft.connect(boost::bind(&MUCController::handleOccupantLeft, this, _1, _2, _3));

muc_->onRoleChangeFailed.connect(boost::bind(&MUCController::handleOccupantRoleChangeFailed, this, _1, _2, _3));

muc_->onAffiliationListReceived.connect(boost::bind(&MUCController::handleAffiliationListReceived, this, _1, _2));

muc_->onConfigurationFailed.connect(boost::bind(&MUCController::handleConfigurationFailed, this, _1));

muc_->onConfigurationFormReceived.connect(boost::bind(&MUCController::handleConfigurationFormReceived, this, _1));

highlighter_->setMode(isImpromptu_ ? Highlighter::ChatMode : Highlighter::MUCMode);

highlighter_->setNick(nick_);

if (timerFactory) {

loginCheckTimer_ = boost::shared_ptr<Timer>(timerFactory->createTimer(MUC_JOIN_WARNING_TIMEOUT_MILLISECONDS));

loginCheckTimer_->onTick.connect(boost::bind(&MUCController::handleJoinTimeoutTick, this));

loginCheckTimer_->start();

}

if (isImpromptu) {

muc_->onUnlocked.connect(boost::bind(&MUCController::handleRoomUnlocked, this));

chatWindow_->convertToMUC(ChatWindow::ImpromptuMUC);

} else {

muc_->onOccupantRoleChanged.connect(boost::bind(&MUCController::handleOccupantRoleChanged, this, _1, _2, _3));

muc_->onOccupantAffiliationChanged.connect(boost::bind(&MUCController::handleOccupantAffiliationChanged, this, _1, _2, _3));

chatWindow_->convertToMUC(ChatWindow::StandardMUC);

chatWindow_->setName(muc->getJID().getNode());

}

setOnline(true);

if (avatarManager_ != NULL) {

avatarChangedConnection_ = (avatarManager_->onAvatarChanged.connect(boost::bind(&MUCController::handleAvatarChanged, this, _1)));

}

handleBareJIDCapsChanged(muc->getJID());

eventStream_->onUIEvent.connect(boost::bind(&MUCController::handleUIEvent, this, _1));

}

MUCController::~MUCController() {

eventStream_->onUIEvent.disconnect(boost::bind(&MUCController::handleUIEvent, this, _1));

chatWindow_->setRosterModel(NULL);

delete rosterVCardProvider_;

delete roster_;

if (loginCheckTimer_) {

loginCheckTimer_->stop();

}

chatWindow_->setTabComplete(NULL);

delete completer_;

}

void MUCController::cancelReplaces() {

lastWasPresence_ = false;

}

void MUCController::handleWindowOccupantSelectionChanged(ContactRosterItem* item) {

std::vector<ChatWindow::OccupantAction> actions;

if (item) {

MUCOccupant::Affiliation affiliation = muc_->getOccupant(getNick()).getAffiliation();

MUCOccupant::Role role = muc_->getOccupant(getNick()).getRole();

if (role == MUCOccupant::Moderator && !isImpromptu_)

{

if (affiliation == MUCOccupant::Admin || affiliation == MUCOccupant::Owner) {

actions.push_back(ChatWindow::Ban);

}

actions.push_back(ChatWindow::Kick);

actions.push_back(ChatWindow::MakeModerator);

actions.push_back(ChatWindow::MakeParticipant);

actions.push_back(ChatWindow::MakeVisitor);

}

// Add contact is available only if the real JID is also available

if (muc_->getOccupant(item->getJID().getResource()).getRealJID()) {

actions.push_back(ChatWindow::AddContact);

}

actions.push_back(ChatWindow::ShowProfile);

}

chatWindow_->setAvailableOccupantActions(actions);

}

void MUCController::handleActionRequestedOnOccupant(ChatWindow::OccupantAction action, ContactRosterItem* item) {

JID mucJID = item->getJID();

MUCOccupant occupant = muc_->getOccupant(mucJID.getResource());

JID realJID;

if (occupant.getRealJID()) {

realJID = occupant.getRealJID().get();

}

switch (action) {

case ChatWindow::Kick: muc_->kickOccupant(mucJID);break;

case ChatWindow::Ban: muc_->changeAffiliation(realJID, MUCOccupant::Outcast);break;

case ChatWindow::MakeModerator: muc_->changeOccupantRole(mucJID, MUCOccupant::Moderator);break;

case ChatWindow::MakeParticipant: muc_->changeOccupantRole(mucJID, MUCOccupant::Participant);break;

case ChatWindow::MakeVisitor: muc_->changeOccupantRole(mucJID, MUCOccupant::Visitor);break;

case ChatWindow::AddContact: if (occupant.getRealJID()) events_->send(boost::make_shared<RequestAddUserDialogUIEvent>(realJID, occupant.getNick()));break;

case ChatWindow::ShowProfile: events_->send(boost::make_shared<ShowProfileForRosterItemUIEvent>(mucJID));break;

}

}

void MUCController::handleBareJIDCapsChanged(const JID& /*jid*/) {

ChatWindow::Tristate support = ChatWindow::Yes;

bool any = false;

foreach (const std::string& nick, currentOccupants_) {

DiscoInfo::ref disco = entityCapsProvider_->getCaps(toJID_.toBare().toString() + "/" + nick);

if (disco && disco->hasFeature(DiscoInfo::MessageCorrectionFeature)) {

any = true;

} else {

support = ChatWindow::Maybe;

}

}

if (!any) {

support = ChatWindow::No;

}

chatWindow_->setCorrectionEnabled(support);

}

/**

* Join the MUC if not already in it.

*/

void MUCController::rejoin() {

if (parting_) {

joined_ = false;

parting_ = false;

if (password_) {

muc_->setPassword(*password_);

}

//FIXME: check for received activity

#ifdef SWIFT_EXPERIMENTAL_HISTORY

if (lastActivity_ == boost::posix_time::not_a_date_time && historyController_) {

lastActivity_ = historyController_->getLastTimeStampFromMUC(selfJID_, toJID_);

}

#endif

if (lastActivity_ == boost::posix_time::not_a_date_time) {

muc_->joinAs(nick_);

}

else {

muc_->joinWithContextSince(nick_, lastActivity_);

}

}

}

bool MUCController::isJoined() {

return joined_;

}

const std::string& MUCController::getNick() {

return nick_;

}

bool MUCController::isImpromptu() const {

return isImpromptu_;

}

std::map<std::string, JID> MUCController::getParticipantJIDs() const {

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

typedef std::pair<std::string, MUCOccupant> MUCOccupantPair;

std::map<std::string, MUCOccupant> occupants = muc_->getOccupants();

foreach(const MUCOccupantPair& occupant, occupants) {

if (occupant.first != nick_) {

participants[occupant.first] = occupant.second.getRealJID().is_initialized() ? occupant.second.getRealJID().get().toBare() : JID();

}

}

return participants;

}

void MUCController::sendInvites(const std::vector<JID>& jids, const std::string& reason) const {

foreach (const JID& jid, jids) {

muc_->invitePerson(jid, reason, isImpromptu_);

}

}

void MUCController::handleJoinTimeoutTick() {

receivedActivity();

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "Room %1% is not responding. This operation may never complete.")) % toJID_.toString())), ChatWindow::DefaultDirection);

}

void MUCController::receivedActivity() {

if (loginCheckTimer_) {

loginCheckTimer_->stop();

}

}

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wswitch-enum"

void MUCController::handleJoinFailed(boost::shared_ptr<ErrorPayload> error) {

receivedActivity();

std::string errorMessage = QT_TRANSLATE_NOOP("", "Unable to enter this room");

std::string rejoinNick;

if (error) {

switch (error->getCondition()) {

case ErrorPayload::Conflict:

rejoinNick = nick_ + "_";

errorMessage = str(format(QT_TRANSLATE_NOOP("", "Unable to enter this room as %1%, retrying as %2%")) % nick_ % rejoinNick);

break;

case ErrorPayload::JIDMalformed:

errorMessage += ": ";

errorMessage += QT_TRANSLATE_NOOP("", "No nickname specified");

break;

case ErrorPayload::NotAuthorized:

errorMessage += ": ";

errorMessage += QT_TRANSLATE_NOOP("", "The correct room password is needed");

break;

case ErrorPayload::RegistrationRequired:

errorMessage += ": ";

errorMessage += QT_TRANSLATE_NOOP("", "Only members may enter");

break;

case ErrorPayload::Forbidden:

errorMessage += ": ";

errorMessage += QT_TRANSLATE_NOOP("", "You are banned from the room");

break;

case ErrorPayload::ServiceUnavailable:

errorMessage += ": ";

errorMessage += QT_TRANSLATE_NOOP("", "The room is full");

break;

case ErrorPayload::ItemNotFound:

errorMessage += ": ";

errorMessage += QT_TRANSLATE_NOOP("", "The room does not exist");

break;

default: break;

}

}

errorMessage = str(format(QT_TRANSLATE_NOOP("", "Couldn't join room: %1%.")) % errorMessage);

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

parting_ = true;

if (!rejoinNick.empty() && renameCounter_ < 10) {

renameCounter_++;

setNick(rejoinNick);

rejoin();

}

}

#pragma clang diagnostic pop

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

receivedActivity();

renameCounter_ = 0;

joined_ = true;

std::string joinMessage;

if (isImpromptu_) {

joinMessage = str(format(QT_TRANSLATE_NOOP("", "You have joined the chat as %1%.")) % nick);

} else {

joinMessage = str(format(QT_TRANSLATE_NOOP("", "You have entered room %1% as %2%.")) % toJID_.toString() % nick);

}

setNick(nick);

chatWindow_->replaceLastMessage(chatMessageParser_->parseMessageBody(joinMessage));

#ifdef SWIFT_EXPERIMENTAL_HISTORY

addRecentLogs();

#endif

clearPresenceQueue();

shouldJoinOnReconnect_ = true;

setEnabled(true);

if (isImpromptu_) {

setAvailableRoomActions(MUCOccupant::NoAffiliation, MUCOccupant::Participant);

} else {

MUCOccupant occupant = muc_->getOccupant(nick);

setAvailableRoomActions(occupant.getAffiliation(), occupant.getRole());

}

onUserJoined();

if (isImpromptu_) {

setImpromptuWindowTitle();

}

}

void MUCController::handleAvatarChanged(const JID& jid) {

if (parting_ || !jid.equals(toJID_, JID::WithoutResource)) {

return;

}

roster_->applyOnItems(SetAvatar(jid, avatarManager_->getAvatarPath(jid), JID::WithResource));

}

void MUCController::handleWindowClosed() {

parting_ = true;

shouldJoinOnReconnect_ = false;

muc_->part();

onUserLeft();

}

void MUCController::handleOccupantJoined(const MUCOccupant& occupant) {

if (nick_ != occupant.getNick()) {

completer_->addWord(occupant.getNick());

}

receivedActivity();

JID jid(nickToJID(occupant.getNick()));

JID realJID;

if (occupant.getRealJID()) {

realJID = occupant.getRealJID().get();

}

currentOccupants_.insert(occupant.getNick());

NickJoinPart event(occupant.getNick(), Join);

appendToJoinParts(joinParts_, event);

MUCOccupant::Role role = MUCOccupant::Participant;

MUCOccupant::Affiliation affiliation = MUCOccupant::NoAffiliation;

if (!isImpromptu_) {

role = occupant.getRole();

affiliation = occupant.getAffiliation();

}

std::string groupName(roleToGroupName(role));

roster_->addContact(jid, realJID, occupant.getNick(), groupName, avatarManager_->getAvatarPath(jid));

roster_->applyOnItems(SetMUC(jid, role, affiliation));

roster_->getGroup(groupName)->setManualSort(roleToSortName(role));

if (joined_) {

std::string joinString;

if (role != MUCOccupant::NoRole && role != MUCOccupant::Participant) {

joinString = str(format(QT_TRANSLATE_NOOP("", "%1% has entered the %3% as a %2%.")) % occupant.getNick() % roleToFriendlyName(role) % (isImpromptu_ ? QT_TRANSLATE_NOOP("", "chat") : QT_TRANSLATE_NOOP("", "room")));

}

else {

joinString = str(format(QT_TRANSLATE_NOOP("", "%1% has entered the %2%.")) % occupant.getNick() % (isImpromptu_ ? QT_TRANSLATE_NOOP("", "chat") : QT_TRANSLATE_NOOP("", "room")));

}

if (shouldUpdateJoinParts()) {

updateJoinParts();

} else {

addPresenceMessage(joinString);

}

if (isImpromptu_) {

setImpromptuWindowTitle();

onActivity("");

}

}

if (avatarManager_ != NULL) {

handleAvatarChanged(jid);

}

}

void MUCController::addPresenceMessage(const std::string& message) {

lastWasPresence_ = true;

chatWindow_->addPresenceMessage(chatMessageParser_->parseMessageBody(message), ChatWindow::DefaultDirection);

}

void MUCController::setAvailableRoomActions(const MUCOccupant::Affiliation& affiliation, const MUCOccupant::Role& role)

{

std::vector<ChatWindow::RoomAction> actions;

if (role <= MUCOccupant::Participant) {

actions.push_back(ChatWindow::ChangeSubject);

}

if (affiliation == MUCOccupant::Owner) {

actions.push_back(ChatWindow::Configure);

}

if (affiliation <= MUCOccupant::Admin) {

actions.push_back(ChatWindow::Affiliations);

}

if (affiliation == MUCOccupant::Owner) {

actions.push_back(ChatWindow::Destroy);

}

if (role <= MUCOccupant::Visitor) {

actions.push_back(ChatWindow::Invite);

}

chatWindow_->setAvailableRoomActions(actions);

}

void MUCController::clearPresenceQueue() {

lastWasPresence_ = false;

joinParts_.clear();

}

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 JID(toJID_.getNode(), toJID_.getDomain(), nick);

}

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

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

boost::regex myRegexp(stringRegexp);

return boost::regex_match(boost::to_lower_copy(message->getBody()), myRegexp);

}

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;

if (message->hasSubject() && message->getBody().empty()) {

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

if (!messageEvent->getConcluded()) {

highlighter_->handleHighlightAction(highlight);

}

}

}

}

void MUCController::handleOccupantRoleChanged(const std::string& nick, const MUCOccupant& occupant, const MUCOccupant::Role& oldRole) {

clearPresenceQueue();

receivedActivity();

JID jid(nickToJID(nick));

roster_->removeContactFromGroup(jid, roleToGroupName(oldRole));

JID realJID;

if (occupant.getRealJID()) {

realJID = occupant.getRealJID().get();

}

std::string group(roleToGroupName(occupant.getRole()));

roster_->addContact(jid, realJID, nick, group, avatarManager_->getAvatarPath(jid));

roster_->getGroup(group)->setManualSort(roleToSortName(occupant.getRole()));

roster_->applyOnItems(SetMUC(jid, occupant.getRole(), occupant.getAffiliation()));

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "%1% is now a %2%")) % nick % roleToFriendlyName(occupant.getRole()))), ChatWindow::DefaultDirection);

if (nick == nick_) {

setAvailableRoomActions(occupant.getAffiliation(), occupant.getRole());

}

}

void MUCController::handleOccupantAffiliationChanged(const std::string& nick, const MUCOccupant::Affiliation& affiliation, const MUCOccupant::Affiliation& /*oldAffiliation*/)

{

if (nick == nick_) {

setAvailableRoomActions(affiliation, muc_->getOccupant(nick_).getRole());

}

JID jid(nickToJID(nick));

MUCOccupant occupant = muc_->getOccupant(nick);

roster_->applyOnItems(SetMUC(jid, occupant.getRole(), affiliation));

}

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

std::string result;

switch (role) {

case MUCOccupant::Moderator: result = QT_TRANSLATE_NOOP("", "Moderators"); break;

case MUCOccupant::Participant: result = QT_TRANSLATE_NOOP("", "Participants"); break;

case MUCOccupant::Visitor: result = QT_TRANSLATE_NOOP("", "Visitors"); break;

case MUCOccupant::NoRole: result = QT_TRANSLATE_NOOP("", "Occupants"); break;

}

return result;

}

void MUCController::setOnline(bool online) {

ChatControllerBase::setOnline(online);

if (!online) {

muc_->part();

parting_ = true;

processUserPart();

} else {

if (shouldJoinOnReconnect_) {

renameCounter_ = 0;

if (isImpromptu_) {

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(QT_TRANSLATE_NOOP("", "Trying to join chat")), ChatWindow::DefaultDirection);

} else {

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "Trying to enter room %1%")) % toJID_.toString())), ChatWindow::DefaultDirection);

}

if (loginCheckTimer_) {

loginCheckTimer_->start();

}

setNick(desiredNick_);

rejoin();

}

}

}

void MUCController::processUserPart() {

roster_->removeAll();

/* handleUserLeft won't throw a part back up unless this is called

when it doesn't yet know we've left - which only happens on

disconnect, so call with disconnect here so if the signal does

bubble back up, it'll be with the right type.*/

muc_->handleUserLeft(MUC::Disconnect);

setEnabled(false);

}

bool MUCController::shouldUpdateJoinParts() {

return lastWasPresence_;

}

void MUCController::handleOccupantLeft(const MUCOccupant& occupant, MUC::LeavingType type, const std::string& reason) {

NickJoinPart event(occupant.getNick(), Part);

appendToJoinParts(joinParts_, event);

currentOccupants_.erase(occupant.getNick());

completer_->removeWord(occupant.getNick());

std::string partMessage;

bool clearAfter = false;

if (occupant.getNick() != nick_) {

std::string partType;

switch (type) {

case MUC::LeaveKick: clearPresenceQueue(); clearAfter = true; partType = " (kicked)"; break;

case MUC::LeaveBan: clearPresenceQueue(); clearAfter = true; partType = " (banned)"; break;

case MUC::LeaveNotMember: clearPresenceQueue(); clearAfter = true; partType = " (no longer a member)"; break;

case MUC::LeaveDestroy:

case MUC::Disconnect:

case MUC::LeavePart: break;

}

if (isImpromptu_) {

partMessage = str(format(QT_TRANSLATE_NOOP("", "%1% has left the chat%2%")) % occupant.getNick() % partType);

} else {

partMessage = str(format(QT_TRANSLATE_NOOP("", "%1% has left the room%2%")) % occupant.getNick() % partType);

}

}

else if (isImpromptu_) {

switch (type) {

case MUC::LeaveKick:

case MUC::LeaveBan: clearPresenceQueue(); clearAfter = true; partMessage = QT_TRANSLATE_NOOP("", "You have been removed from this chat"); break;

case MUC::LeaveNotMember: clearPresenceQueue(); clearAfter = true; partMessage = QT_TRANSLATE_NOOP("", "You have been removed from this chat"); break;

case MUC::LeaveDestroy: clearPresenceQueue(); clearAfter = true; partMessage = QT_TRANSLATE_NOOP("", "This chat has ended"); break;

case MUC::Disconnect:

case MUC::LeavePart: partMessage = QT_TRANSLATE_NOOP("", "You have left the chat");

}

}

else {

switch (type) {

case MUC::LeaveKick: clearPresenceQueue(); clearAfter = true; partMessage = QT_TRANSLATE_NOOP("", "You have been kicked out of the room"); break;

case MUC::LeaveBan: clearPresenceQueue(); clearAfter = true; partMessage = QT_TRANSLATE_NOOP("", "You have been banned from the room"); break;

case MUC::LeaveNotMember: clearPresenceQueue(); clearAfter = true; partMessage = QT_TRANSLATE_NOOP("", "You are no longer a member of the room and have been removed"); break;

case MUC::LeaveDestroy: clearPresenceQueue(); clearAfter = true; partMessage = QT_TRANSLATE_NOOP("", "The room has been destroyed"); break;

case MUC::Disconnect:

case MUC::LeavePart: partMessage = QT_TRANSLATE_NOOP("", "You have left the room");

}

}

if (!reason.empty()) {

partMessage += " (" + reason + ")";

}

partMessage += ".";

if (occupant.getNick() != nick_) {

if (shouldUpdateJoinParts()) {

updateJoinParts();

} else {

addPresenceMessage(partMessage);

}

roster_->removeContact(JID(toJID_.getNode(), toJID_.getDomain(), occupant.getNick()));

} else {

addPresenceMessage(partMessage);

parting_ = true;

processUserPart();

}

if (clearAfter) {

clearPresenceQueue();

}

if (isImpromptu_) {

setImpromptuWindowTitle();

}

}

void MUCController::handleOccupantPresenceChange(boost::shared_ptr<Presence> presence) {

receivedActivity();

roster_->applyOnItems(SetPresence(presence, JID::WithResource));

}

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

JID from = message->getFrom();

return nick_ == from.getResource();

}

std::string MUCController::senderDisplayNameFromMessage(const JID& from) {

return from.getResource();

}

void MUCController::preSendMessageRequest(boost::shared_ptr<Message> message) {

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

}

boost::optional<boost::posix_time::ptime> MUCController::getMessageTimestamp(boost::shared_ptr<Message> message) const {

return message->getTimestampFrom(toJID_);

}

void MUCController::updateJoinParts() {

chatWindow_->replaceLastMessage(chatMessageParser_->parseMessageBody(generateJoinPartString(joinParts_, isImpromptu())));

}

void MUCController::appendToJoinParts(std::vector<NickJoinPart>& joinParts, const NickJoinPart& newEvent) {

std::vector<NickJoinPart>::iterator it = joinParts.begin();

bool matched = false;

for (; it != joinParts.end(); ++it) {

if ((*it).nick == newEvent.nick) {

matched = true;

JoinPart type = (*it).type;

switch (newEvent.type) {

case Join: type = (type == Part) ? PartThenJoin : Join; break;

case Part: type = (type == Join) ? JoinThenPart : Part; break;

case PartThenJoin: break;

case JoinThenPart: break;

}

(*it).type = type;

break;

}

}

if (!matched) {

joinParts.push_back(newEvent);

}

}

std::string MUCController::concatenateListOfNames(const std::vector<NickJoinPart>& joinParts) {

std::string result;

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

if (i > 0) {

if (i < joinParts.size() - 1) {

result += ", ";

} else {

result += QT_TRANSLATE_NOOP("", " and ");

}

}

NickJoinPart event = joinParts[i];

result += event.nick;

}

return result;

}

std::string MUCController::generateJoinPartString(const std::vector<NickJoinPart>& joinParts, bool isImpromptu) {

std::vector<NickJoinPart> sorted[4];

std::string eventStrings[4];

foreach (NickJoinPart event, joinParts) {

sorted[event.type].push_back(event);

}

std::string result;

std::vector<JoinPart> populatedEvents;

for (size_t i = 0; i < 4; i++) {

std::string names = concatenateListOfNames(sorted[i]);

if (!names.empty()) {

std::string eventString;

switch (i) {

case Join:

if (sorted[i].size() > 1) {

eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% have joined the chat") : QT_TRANSLATE_NOOP("", "%1% have entered the room"));

}

else {

eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% has joined the chat") : QT_TRANSLATE_NOOP("", "%1% has entered the room"));

}

break;

case Part:

if (sorted[i].size() > 1) {

eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% have left the chat") : QT_TRANSLATE_NOOP("", "%1% have left the room"));

}

else {

eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% have left the chat") : QT_TRANSLATE_NOOP("", "%1% has left the room"));

}

break;

case JoinThenPart:

if (sorted[i].size() > 1) {

eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% have joined then left the chat") : QT_TRANSLATE_NOOP("", "%1% have entered then left the room"));

}

else {

eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% has joined then left the chat") : QT_TRANSLATE_NOOP("", "%1% has entered then left the room"));

/*

* Copyright (c) 2010-2014 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <set>

#include <string>

#include <map>

#include <boost/shared_ptr.hpp>

#include <boost/signals/connection.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Network/Timer.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/JID/JID.h>

#include <Swiften/MUC/MUC.h>

#include <Swiften/Elements/MUCOccupant.h>

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

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

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

namespace Swift {

class StanzaChannel;

class IQRouter;

class ChatWindowFactory;

class Roster;

class AvatarManager;

class UIEventStream;

class TimerFactory;

class TabComplete;

class XMPPRoster;

class HighlightManager;

class UIEvent;

class VCardManager;

class RosterVCardProvider;

enum JoinPart {Join, Part, JoinThenPart, PartThenJoin};

struct NickJoinPart {

NickJoinPart(const std::string& nick, JoinPart type) : nick(nick), type(type) {}

std::string nick;

JoinPart type;

};

class MUCController : public ChatControllerBase {

public:

MUCController(const JID& self, MUC::ref muc, const boost::optional<std::string>& password, const std::string &nick, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, XMPPRoster* roster, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ChatMessageParser* chatMessageParser, bool isImpromptu, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, VCardManager* vcardManager);

virtual ~MUCController();

boost::signal<void ()> onUserLeft;

boost::signal<void ()> onUserJoined;

boost::signal<void ()> onImpromptuConfigCompleted;

virtual void setOnline(bool online);

void rejoin();

static void appendToJoinParts(std::vector<NickJoinPart>& joinParts, const NickJoinPart& newEvent);

static std::string generateJoinPartString(const std::vector<NickJoinPart>& joinParts, bool isImpromptu);

static std::string concatenateListOfNames(const std::vector<NickJoinPart>& joinParts);

bool isJoined();

const std::string& getNick();

bool isImpromptu() const;

std::map<std::string, JID> getParticipantJIDs() const;

void sendInvites(const std::vector<JID>& jids, const std::string& reason) const;

protected:

void preSendMessageRequest(boost::shared_ptr<Message> message);

bool isIncomingMessageFromMe(boost::shared_ptr<Message> message);

std::string senderDisplayNameFromMessage(const JID& from);

boost::optional<boost::posix_time::ptime> getMessageTimestamp(boost::shared_ptr<Message> message) const;

void preHandleIncomingMessage(boost::shared_ptr<MessageEvent>);

void postHandleIncomingMessage(boost::shared_ptr<MessageEvent>, const HighlightAction&);

void cancelReplaces();

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

private:

void setAvailableRoomActions(const MUCOccupant::Affiliation& affiliation, const MUCOccupant::Role& role);

void clearPresenceQueue();

void addPresenceMessage(const std::string& message);

void handleWindowOccupantSelectionChanged(ContactRosterItem* item);

void handleActionRequestedOnOccupant(ChatWindow::OccupantAction, ContactRosterItem* item);

void handleWindowClosed();

void handleAvatarChanged(const JID& jid);

void handleOccupantJoined(const MUCOccupant& occupant);

void handleOccupantLeft(const MUCOccupant& occupant, MUC::LeavingType type, const std::string& reason);

void handleOccupantPresenceChange(boost::shared_ptr<Presence> presence);

void handleOccupantRoleChanged(const std::string& nick, const MUCOccupant& occupant,const MUCOccupant::Role& oldRole);

void handleOccupantAffiliationChanged(const std::string& nick, const MUCOccupant::Affiliation& affiliation,const MUCOccupant::Affiliation& oldAffiliation);

void handleJoinComplete(const std::string& nick);

void handleJoinFailed(boost::shared_ptr<ErrorPayload> error);

void handleJoinTimeoutTick();

void handleChangeSubjectRequest(const std::string&);

void handleBookmarkRequest();

std::string roleToGroupName(MUCOccupant::Role role);

std::string roleToSortName(MUCOccupant::Role role);

JID nickToJID(const std::string& nick);

std::string roleToFriendlyName(MUCOccupant::Role role);

void receivedActivity();

bool messageTargetsMe(boost::shared_ptr<Message> message);

void updateJoinParts();

bool shouldUpdateJoinParts();

void dayTicked() {clearPresenceQueue();}

void processUserPart();

void handleBareJIDCapsChanged(const JID& jid);

void handleConfigureRequest(Form::ref);

void handleConfigurationFailed(ErrorPayload::ref);

void handleConfigurationFormReceived(Form::ref);

void handleDestroyRoomRequest();

void handleInvitePersonToThisMUCRequest(const std::vector<JID>& jidsToInvite);

void handleConfigurationCancelled();

void handleOccupantRoleChangeFailed(ErrorPayload::ref, const JID&, MUCOccupant::Role);

void handleGetAffiliationsRequest();

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

void handleChangeAffiliationsRequest(const std::vector<std::pair<MUCOccupant::Affiliation, JID> >& changes);

void handleInviteToMUCWindowDismissed();

void handleInviteToMUCWindowCompleted();

void handleUIEvent(boost::shared_ptr<UIEvent> event);

void addRecentLogs();

void checkDuplicates(boost::shared_ptr<Message> newMessage);

void setNick(const std::string& nick);

void setImpromptuWindowTitle();

void handleRoomUnlocked();

void configureAsImpromptuRoom(Form::ref form);

Form::ref buildImpromptuRoomConfiguration(Form::ref roomConfigurationForm);

private:

MUC::ref muc_;

UIEventStream* events_;

std::string nick_;

std::string desiredNick_;

Roster* roster_;

TabComplete* completer_;

bool parting_;

bool joined_;

bool lastWasPresence_;

bool shouldJoinOnReconnect_;

bool doneGettingHistory_;

boost::bsignals::scoped_connection avatarChangedConnection_;

boost::shared_ptr<Timer> loginCheckTimer_;

std::set<std::string> currentOccupants_;

std::vector<NickJoinPart> joinParts_;

boost::posix_time::ptime lastActivity_;

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

XMPPRoster* xmppRoster_;

std::vector<HistoryMessage> joinContext_;

size_t renameCounter_;

bool isImpromptu_;

bool isImpromptuAlreadyConfigured_;

RosterVCardProvider* rosterVCardProvider_;

};

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <list>

#include <set>

#include <map>

#include <boost/shared_ptr.hpp>

#include <Swiften/MUC/MUCBookmark.h>

#include <Swiften/Elements/StatusShow.h>

#include <boost/filesystem/path.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Base/boost_bsignals.h>

namespace Swift {

class ChatListWindow {

public:

class Chat {

public:

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

/** 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 */

typedef std::map<std::string, JID> JIDMap;

foreach (const JIDMap::value_type& jid, impromptuJIDs) {

bool found = false;

foreach (const JIDMap::value_type& otherJID, other.impromptuJIDs) {

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

found = true;

break;

}

}

if (!found) {

return false;

}

}

return true;

}

}

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 {

typedef std::pair<std::string, JID> StringJIDPair;

std::string title;

foreach(StringJIDPair pair, impromptuJIDs) {

if (title.empty()) {

title += pair.first;

} else {

title += ", " + pair.first;

}

}

return title;

}

JID jid;

std::string chatName;

std::string activity;

StatusShow::Type statusType;

bool isMUC;

std::string nick;

int unreadCount;

boost::filesystem::path avatarPath;

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

};

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;

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

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

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

boost::signal<void ()> onClearRecentsRequested;

};

}

/*

* Copyright (c) 2010-2014 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include "Swift/QtUI/ChatList/QtChatListWindow.h"

#include <boost/bind.hpp>

#include <QContextMenuEvent>

#include <QMenu>

#include <QMimeData>

#include <QUrl>

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

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

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

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

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

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

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

#include <Swift/QtUI/ChatList/ChatListMUCItem.h>

#include <Swift/QtUI/ChatList/ChatListRecentItem.h>

#include <Swift/QtUI/ChatList/ChatListWhiteboardItem.h>

#include <Swift/QtUI/QtAddBookmarkWindow.h>

#include <Swift/QtUI/QtEditBookmarkWindow.h>

#include <Swift/QtUI/QtUISettingConstants.h>

namespace Swift {

QtChatListWindow::QtChatListWindow(UIEventStream *uiEventStream, SettingsProvider* settings, QWidget* parent) : QTreeView(parent) {

eventStream_ = uiEventStream;

settings_ = settings;

bookmarksEnabled_ = false;

model_ = new ChatListModel();

setModel(model_);

delegate_ = new ChatListDelegate(settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));

setItemDelegate(delegate_);

setHeaderHidden(true);

#ifdef SWIFT_PLATFORM_MACOSX

setAlternatingRowColors(true);

#endif

expandAll();

setAnimated(true);

setIndentation(0);

setDragEnabled(true);

setRootIsDecorated(true);

setupContextMenus();

connect(this, SIGNAL(activated(const QModelIndex&)), this, SLOT(handleItemActivated(const QModelIndex&)));

connect(this, SIGNAL(clicked(const QModelIndex&)), this, SLOT(handleClicked(const QModelIndex&)));

settings_->onSettingChanged.connect(boost::bind(&QtChatListWindow::handleSettingChanged, this, _1));

}

QtChatListWindow::~QtChatListWindow() {

settings_->onSettingChanged.disconnect(boost::bind(&QtChatListWindow::handleSettingChanged, this, _1));

delete model_;

delete delegate_;

delete mucMenu_;

delete emptyMenu_;

}

void QtChatListWindow::handleSettingChanged(const std::string& setting) {

if (setting == QtUISettingConstants::COMPACT_ROSTER.getKey()) {

delegate_->setCompact(settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));

repaint();

}

}

void QtChatListWindow::setBookmarksEnabled(bool enabled) {

bookmarksEnabled_ = enabled;

}

void QtChatListWindow::handleClicked(const QModelIndex& index) {

ChatListGroupItem* item = dynamic_cast<ChatListGroupItem*>(static_cast<ChatListItem*>(index.internalPointer()));

if (item) {

setExpanded(index, !isExpanded(index));

}

}

void QtChatListWindow::setupContextMenus() {

mucMenu_ = new QMenu();

mucMenu_->addAction(tr("Add New Bookmark"), this, SLOT(handleAddBookmark()));

mucMenu_->addAction(tr("Edit Bookmark"), this, SLOT(handleEditBookmark()));

mucMenu_->addAction(tr("Remove Bookmark"), this, SLOT(handleRemoveBookmark()));

emptyMenu_ = new QMenu();

emptyMenu_->addAction(tr("Add New Bookmark"), this, SLOT(handleAddBookmark()));

}

void QtChatListWindow::handleItemActivated(const QModelIndex& index) {

ChatListItem* item = model_->getItemForIndex(index);

if (ChatListMUCItem* mucItem = dynamic_cast<ChatListMUCItem*>(item)) {

if (bookmarksEnabled_) {

onMUCBookmarkActivated(mucItem->getBookmark());

}

}

else if (ChatListRecentItem* recentItem = dynamic_cast<ChatListRecentItem*>(item)) {

if (!recentItem->getChat().isMUC || bookmarksEnabled_) {

onRecentActivated(recentItem->getChat());

}

}

else if (ChatListWhiteboardItem* whiteboardItem = dynamic_cast<ChatListWhiteboardItem*>(item)) {

if (!whiteboardItem->getChat().isMUC || bookmarksEnabled_) {

eventStream_->send(boost::make_shared<ShowWhiteboardUIEvent>(whiteboardItem->getChat().jid));

}

}

}

void QtChatListWindow::clearBookmarks() {

model_->clearBookmarks();

}

void QtChatListWindow::addMUCBookmark(const MUCBookmark& bookmark) {

model_->addMUCBookmark(bookmark);

}

void QtChatListWindow::removeMUCBookmark(const MUCBookmark& bookmark) {

model_->removeMUCBookmark(bookmark);

}

void QtChatListWindow::addWhiteboardSession(const ChatListWindow::Chat& chat) {

model_->addWhiteboardSession(chat);

}

void QtChatListWindow::removeWhiteboardSession(const JID& jid) {

model_->removeWhiteboardSession(jid);

}

void QtChatListWindow::setRecents(const std::list<ChatListWindow::Chat>& recents) {

model_->setRecents(recents);

}

void QtChatListWindow::setUnreadCount(int unread) {

emit onCountUpdated(unread);

}

void QtChatListWindow::handleRemoveBookmark() {

ChatListMUCItem* mucItem = dynamic_cast<ChatListMUCItem*>(contextMenuItem_);

if (!mucItem) return;

eventStream_->send(boost::shared_ptr<UIEvent>(new RemoveMUCBookmarkUIEvent(mucItem->getBookmark())));

}

void QtChatListWindow::handleAddBookmark() {

(new QtAddBookmarkWindow(eventStream_))->show();

}

void QtChatListWindow::handleEditBookmark() {

ChatListMUCItem* mucItem = dynamic_cast<ChatListMUCItem*>(contextMenuItem_);

if (!mucItem) return;

QtEditBookmarkWindow* window = new QtEditBookmarkWindow(eventStream_, mucItem->getBookmark());

window->show();

}

void QtChatListWindow::dragEnterEvent(QDragEnterEvent *event) {

if (event->mimeData()->hasUrls() && event->mimeData()->urls().size() == 1) {

event->acceptProposedAction();

}

}

void QtChatListWindow::contextMenuEvent(QContextMenuEvent* event) {

QModelIndex index = indexAt(event->pos());

ChatListItem* baseItem = index.isValid() ? static_cast<ChatListItem*>(index.internalPointer()) : NULL;

contextMenuItem_ = baseItem;

if (!baseItem) {

emptyMenu_->exec(QCursor::pos());

return;

}

ChatListMUCItem* mucItem = dynamic_cast<ChatListMUCItem*>(baseItem);

if (mucItem) {

if (!bookmarksEnabled_) {

return;

}

mucMenu_->exec(QCursor::pos());

}

}

}

}

}

/*

* Copyright (c) 2010-2014 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <QTreeView>

#include "Swift/Controllers/UIInterfaces/ChatListWindow.h"

#include "Swift/Controllers/UIEvents/UIEventStream.h"

#include "Swift/QtUI/ChatList/ChatListModel.h"

#include "Swift/QtUI/ChatList/ChatListDelegate.h"

namespace Swift {

class SettingsProvider;

class QtChatListWindow : public QTreeView, public ChatListWindow {

Q_OBJECT

public:

QtChatListWindow(UIEventStream *uiEventStream, SettingsProvider* settings, QWidget* parent = NULL);

virtual ~QtChatListWindow();

void addMUCBookmark(const MUCBookmark& bookmark);

void removeMUCBookmark(const MUCBookmark& bookmark);

void addWhiteboardSession(const ChatListWindow::Chat& chat);

void removeWhiteboardSession(const JID& jid);

void setBookmarksEnabled(bool enabled);

void setRecents(const std::list<ChatListWindow::Chat>& recents);

void setUnreadCount(int unread);

void clearBookmarks();

signals:

void onCountUpdated(int count);

private slots:

void handleItemActivated(const QModelIndex&);

void handleAddBookmark();

void handleEditBookmark();

void handleRemoveBookmark();

void handleClicked(const QModelIndex& index);

void handleSettingChanged(const std::string& setting);

protected:

void dragEnterEvent(QDragEnterEvent* event);

void contextMenuEvent(QContextMenuEvent* event);

private:

void setupContextMenus();

bool bookmarksEnabled_;

UIEventStream* eventStream_;

ChatListModel* model_;

ChatListDelegate* delegate_;

QMenu* mucMenu_;

QMenu* emptyMenu_;

ChatListItem* contextMenuItem_;

SettingsProvider* settings_;

};

}