+ * Copyright (c) 2010-2014 Kevin Smith

+#include <Swiften/Avatars/AvatarManager.h>

+#include <Swiften/Base/foreach.h>

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

+

+

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

+#include <Swift/Controllers/Highlighter.h>

+#include <Swift/Controllers/Intl.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/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>

+ EntityCapsProvider* entityCapsProvider,

+ XMPPRoster* roster,

+ HistoryController* historyController,

+ MUCRegistry* mucRegistry,

+ HighlightManager* highlightManager,

+ boost::shared_ptr<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) {

+ xmppRoster_ = roster;

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

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

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

+ muc_->onOccupantNicknameChanged.connect(boost::bind(&MUCController::handleOccupantNicknameChanged, 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 (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());

+ }

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

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

+ delete rosterVCardProvider_;

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

+ actions.push_back(ChatWindow::ShowProfile);

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

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

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

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

+ }

+#endif

+ }

+ else {

+const boost::optional<std::string> MUCController::getPassword() const {

+ return password_;

+}

+

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

+ }

+}

+

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

+#pragma clang diagnostic push

+#pragma clang diagnostic ignored "-Wswitch-enum"

+

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

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

+ renameCounter_++;

+ setNick(rejoinNick);

+#pragma clang diagnostic pop

+

+ renameCounter_ = 0;

+ 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), ChatWindow::UpdateTimestamp);

+

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+ addRecentLogs();

+#endif

+

+ if (isImpromptu_) {

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

+ } else {

+ }

+

+ if (isImpromptu_) {

+ setImpromptuWindowTitle();

+ }

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

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

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

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

+ }

+ if (isImpromptu_) {

+ setImpromptuWindowTitle();

+ onActivity("");

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

+ assert(false);

+ assert(false);

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

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

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

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

+ }

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

+ checkDuplicates(message);

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

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

+ if (messageTargetsMe(message) || isImpromptu_) {

+ if (!messageEvent->getConcluded()) {

+ highlighter_->handleHighlightAction(highlight);

+ }

+ }

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

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

+ JID jid(nickToJID(nick));

+ MUCOccupant occupant = muc_->getOccupant(nick);

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

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

+ }

+ setNick(desiredNick_);

+ if (isImpromptu_) {

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

+ } else {

+ }

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

+ }

+ }

+

+ if (isImpromptu_) {

+ setImpromptuWindowTitle();

+ }

+}

+

+void MUCController::handleOccupantNicknameChanged(const std::string& oldNickname, const std::string& newNickname) {

+ addPresenceMessage(generateNicknameChangeString(oldNickname, newNickname));

+ JID oldJID = muc_->getJID().withResource(oldNickname);

+ JID newJID = muc_->getJID().withResource(newNickname);

+

+ // adjust occupants

+ currentOccupants_.erase(oldNickname);

+ currentOccupants_.insert(newNickname);

+

+ // adjust completer

+ completer_->removeWord(oldNickname);

+ completer_->addWord(newNickname);

+

+ // update contact

+ roster_->removeContact(oldJID);

+ MUCOccupant occupant = muc_->getOccupant(newNickname);

+

+ JID realJID;

+ if (occupant.getRealJID()) {

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

+ }

+ 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(newJID, realJID, newNickname, groupName, avatarManager_->getAvatarPath(newJID));

+ roster_->applyOnItems(SetMUC(newJID, role, affiliation));

+ if (avatarManager_ != NULL) {

+ handleAvatarChanged(newJID);

+ }

+

+ clearPresenceQueue();

+ onUserNicknameChanged(oldNickname, newNickname);

+ chatWindow_->replaceLastMessage(chatMessageParser_->parseMessageBody(generateJoinPartString(joinParts_, isImpromptu())), ChatWindow::UpdateTimestamp);

+ case PartThenJoin: break;

+ case JoinThenPart: break;

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

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

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

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

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

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

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

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

+ eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% has left then returned to the chat") : QT_TRANSLATE_NOOP("", "%1% has left then returned to the room"));

+std::string MUCController::generateNicknameChangeString(const std::string& oldNickname, const std::string& newNickname) {

+ return str(boost::format(QT_TRANSLATE_NOOP("", "%1% is now known as %2%.")) % oldNickname % newNickname);

+}

+

+void MUCController::handleBookmarkRequest() {

+ const JID jid = muc_->getJID();

+ MUCBookmark bookmark(jid, jid.toBare().toString());

+ bookmark.setPassword(password_);

+ bookmark.setNick(nick_);

+ chatWindow_->showBookmarkWindow(bookmark);

+}

+

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

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

+}

+

+void MUCController::configureAsImpromptuRoom(Form::ref form) {

+ muc_->configureRoom(buildImpromptuRoomConfiguration(form));

+ isImpromptuAlreadyConfigured_ = true;

+ onImpromptuConfigCompleted();

+ if (isImpromptu_) {

+ if (!isImpromptuAlreadyConfigured_) {

+ configureAsImpromptuRoom(form);

+ }

+ } else {

+}

+void MUCController::handleInvitePersonToThisMUCRequest(const std::vector<JID>& jidsToInvite) {

+ RequestInviteToMUCUIEvent::ImpromptuMode mode = isImpromptu_ ? RequestInviteToMUCUIEvent::Impromptu : RequestInviteToMUCUIEvent::NotImpromptu;

+ boost::shared_ptr<UIEvent> event(new RequestInviteToMUCUIEvent(muc_->getJID(), jidsToInvite, mode));

+ eventStream_->send(event);

+}

+

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

+ boost::shared_ptr<InviteToMUCUIEvent> inviteEvent = boost::dynamic_pointer_cast<InviteToMUCUIEvent>(event);

+ if (inviteEvent && inviteEvent->getRoom() == muc_->getJID()) {

+ foreach (const JID& jid, inviteEvent->getInvites()) {

+ muc_->invitePerson(jid, inviteEvent->getReason(), isImpromptu_);

+ }

+ }

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

+ // log only incoming messages

+ if (isIncoming && historyController_) {

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

+ }

+}

+

+void MUCController::addRecentLogs() {

+ if (!historyController_) {

+ return;

+ }

+

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

+

+ foreach (const HistoryMessage& message, joinContext_) {

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

+

+ // the chatWindow uses utc timestamps

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

+ }

+}

+

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

+ std::string body = newMessage->getBody();

+ JID jid = newMessage->getFrom();

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

+

+ reverse_foreach (const HistoryMessage& message, joinContext_) {

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

+ if (time && time < messageTime) {

+ break;

+ }

+ if (time && time != messageTime) {

+ continue;

+ }

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

+ continue;

+ }

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

+ continue;

+ }

+

+ // Mark the message as unreadable

+ newMessage->setBody("");

+ }

+}

+

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

+ nick_ = nick;

+ highlighter_->setNick(nick_);

+}

+

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

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

+ std::string impromptuConfigs[] = { "muc#roomconfig_enablelogging", "muc#roomconfig_persistentroom", "muc#roomconfig_publicroom", "muc#roomconfig_whois"};

+ std::set<std::string> impromptuConfigsMissing(impromptuConfigs, impromptuConfigs + 4);

+ foreach (boost::shared_ptr<FormField> field, roomConfigurationForm->getFields()) {

+ boost::shared_ptr<FormField> resultField;

+ if (field->getName() == "muc#roomconfig_enablelogging") {

+ resultField = boost::make_shared<FormField>(FormField::BooleanType, "0");

+ }

+ if (field->getName() == "muc#roomconfig_persistentroom") {

+ resultField = boost::make_shared<FormField>(FormField::BooleanType, "0");

+ }

+ if (field->getName() == "muc#roomconfig_publicroom") {

+ resultField = boost::make_shared<FormField>(FormField::BooleanType, "0");

+ }

+ if (field->getName() == "muc#roomconfig_whois") {

+ resultField = boost::make_shared<FormField>(FormField::ListSingleType, "anyone");

+ }

+

+ if (field->getName() == "FORM_TYPE") {

+ resultField = boost::make_shared<FormField>(FormField::HiddenType, "http://jabber.org/protocol/muc#roomconfig");

+ }

+

+ if (resultField) {

+ impromptuConfigsMissing.erase(field->getName());

+ resultField->setName(field->getName());

+ result->addField(resultField);

+ }

+ }

+

+ foreach (const std::string& config, impromptuConfigsMissing) {

+ if (config == "muc#roomconfig_publicroom") {

+ chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(QT_TRANSLATE_NOOP("", "This server doesn't support hiding your chat from other users.")), ChatWindow::DefaultDirection);

+ } else if (config == "muc#roomconfig_whois") {

+ chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(QT_TRANSLATE_NOOP("", "This server doesn't support sharing people's real identity in this chat.")), ChatWindow::DefaultDirection);

+ }

+ }

+

+ return result;

+}

+

+void MUCController::setImpromptuWindowTitle() {

+ std::string title;

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

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

+ if (occupants.size() <= 1) {

+ title = QT_TRANSLATE_NOOP("", "Empty Chat");

+ } else {

+ foreach (StringMUCOccupantPair pair, occupants) {

+ if (pair.first != nick_) {

+ title += (title.empty() ? "" : ", ") + pair.first;

+ }

+ }

+ }

+ chatWindow_->setName(title);

+}

+

+void MUCController::handleRoomUnlocked() {

+ // Handle buggy MUC implementations where the joined room already exists and is unlocked.

+ // Configure the room again in this case.

+ if (!isImpromptuAlreadyConfigured_) {

+ if (isImpromptu_ && (muc_->getOccupant(nick_).getAffiliation() == MUCOccupant::Owner)) {

+ muc_->requestConfigurationForm();

+ } else if (isImpromptu_) {

+ onImpromptuConfigCompleted();

+ }

+ }

+}

+