/*

* All rights reserved.

* See the COPYING file for more information.

*/

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

#include <algorithm>

#include <cassert>

#include <memory>

#include <boost/bind.hpp>

#include <boost/regex.hpp>

#include <boost/algorithm/string.hpp>

#include <boost/range/adaptor/reversed.hpp>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/format.h>

#include <Swiften/Base/Tristate.h>

#include <Swiften/Client/BlockList.h>

#include <Swiften/Client/ClientBlockListManager.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/Disco/EntityCapsProvider.h>

#include <Swiften/Elements/Delay.h>

#include <Swiften/Elements/Thread.h>

#include <Swiften/MUC/MUC.h>

#include <Swiften/MUC/MUCBookmark.h>

#include <Swiften/MUC/MUCBookmarkManager.h>

#include <Swiften/Network/Timer.h>

#include <Swiften/Network/TimerFactory.h>

#include <Swiften/Roster/XMPPRoster.h>

#include <SwifTools/TabComplete.h>

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

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

#include <Swift/Controllers/Intl.h>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

for (const auto& nick : currentOccupants_) {

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

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

any = true;

} else {

support = Maybe;

}

}

if (!any) {

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

}

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;

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

for (const auto& occupant : occupants) {

if (occupant.first != nick_) {

else {

chatWindow_->setBookmarkState(ChatWindow::RoomBookmarked);

}

}

else {

chatWindow_->setBookmarkState(ChatWindow::RoomNotBookmarked);

}

}

void MUCController::displaySubjectIfChanged(const std::string& subject) {

if (subject_ != subject) {

if (!subject.empty()) {

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

}

else {

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "The room subject has been removed")))), ChatWindow::DefaultDirection);

}

subject_ = subject;

}

}

void MUCController::addChatSystemMessage() {

lastJoinMessageUID_ = chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(lastStartMessage_), ChatWindow::DefaultDirection);

}

void MUCController::setChatWindowTitle(const std::string& title) {

chatWindowTitle_ = title;

chatWindow_->setName(chatWindowTitle_);

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <map>

#include <memory>

#include <set>

#include <string>

#include <boost/signals2.hpp>

#include <boost/signals2/connection.hpp>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/MUCOccupant.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/JID/JID.h>

#include <Swiften/MUC/MUC.h>

#include <Swiften/Network/Timer.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;

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(std::shared_ptr<UIEvent> event);

void addRecentLogs();

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

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

void handleRoomUnlocked();

void configureAsImpromptuRoom(Form::ref form);

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

void handleUnblockUserRequest();

void handleBlockingStateChanged();

void handleMUCBookmarkAdded(const MUCBookmark& bookmark);

void handleMUCBookmarkRemoved(const MUCBookmark& bookmark);

void updateChatWindowBookmarkStatus(const boost::optional<MUCBookmark>& bookmark);

void displaySubjectIfChanged(const std::string& sucject);

void addChatSystemMessage();

private:

MUC::ref muc_;

std::string nick_;

std::string desiredNick_;

TabComplete* completer_;

bool parting_;

bool joined_;

bool shouldJoinOnReconnect_;

bool doneGettingHistory_;

boost::signals2::scoped_connection avatarChangedConnection_;

std::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::unique_ptr<Roster> roster_;

std::vector<HistoryMessage> joinContext_;

size_t renameCounter_;

bool isImpromptu_;

bool isImpromptuAlreadyConfigured_;

RosterVCardProvider* rosterVCardProvider_;

std::string lastJoinMessageUID_;

std::string lastStartMessage_;

ClientBlockListManager* clientBlockListManager_;

boost::signals2::scoped_connection blockingOnStateChangedConnection_;

boost::signals2::scoped_connection blockingOnItemAddedConnection_;

boost::signals2::scoped_connection blockingOnItemRemovedConnection_;

presence->setShow(StatusShow::None);

presence->setType(Presence::Unavailable);

stanzaChannel_->onPresenceReceived(presence);

CPPUNIT_ASSERT_EQUAL(std::string("participantA has gone offline."), MockChatWindow::bodyFromMessage(window->lastReplacedLastMessage_));

}

void testChatControllerMucPmUnavailableErrorHandling() {

auto mucJID = JID("test@rooms.test.com");

auto participantA = mucJID.withResource("participantA");

auto participantB = mucJID.withResource("participantB");

auto mucWindow = new MockChatWindow();

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

uiEventStream_->send(std::make_shared<JoinMUCUIEvent>(mucJID, participantB.getResource()));

CPPUNIT_ASSERT_EQUAL(true, mucWindow->mucType_.is_initialized());

auto window = new MockChatWindow();

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

uiEventStream_->send(std::make_shared<RequestChatUIEvent>(participantA));

CPPUNIT_ASSERT_EQUAL(false, window->mucType_.is_initialized());

Presence::ref presence = Presence::create();

presence->setFrom(participantA);

presence->setShow(StatusShow::Online);

stanzaChannel_->onPresenceReceived(presence);

CPPUNIT_ASSERT_EQUAL(std::string("participantA has become available."), MockChatWindow::bodyFromMessage(window->lastAddedPresence_));

// send message to participantA

auto messageBody = std::string("message body to send");

window->onSendMessageRequest(messageBody, false);

CPPUNIT_ASSERT_EQUAL(messageBody, *sendMessageStanza->getBody());

// receive reply with error

auto messageErrorReply = std::make_shared<Message>();

messageErrorReply->setID(stanzaChannel_->getNewIQID());

messageErrorReply->setType(Message::Error);

messageErrorReply->setFrom(participantA);

messageErrorReply->setTo(jid_);

messageErrorReply->addPayload(std::make_shared<ErrorPayload>(ErrorPayload::ItemNotFound, ErrorPayload::Cancel, "Recipient not in room"));

auto lastMUCWindowErrorMessageBeforeError = MockChatWindow::bodyFromMessage(mucWindow->lastAddedErrorMessage_);

manager_->handleIncomingMessage(messageErrorReply);

// assert that error is not routed to MUC window

CPPUNIT_ASSERT_EQUAL(lastMUCWindowErrorMessageBeforeError, MockChatWindow::bodyFromMessage(mucWindow->lastAddedErrorMessage_));

// assert that error is routed to PM

CPPUNIT_ASSERT_EQUAL(std::string("This user could not be found in the room."), MockChatWindow::bodyFromMessage(window->lastAddedErrorMessage_));

}

void testLocalMUCServiceDiscoveryResetOnDisconnect() {

JID ownJID("test@test.com/resource");

JID sender("foo@test.com");

manager_->setOnline(true);

// Open chat window to a sender.

MockChatWindow* window = new MockChatWindow();

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

uiEventStream_->send(std::make_shared<RequestChatUIEvent>(sender));

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

manager_->handleIncomingMessage(mucMirrored);

}

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

}

void impromptuChatSetup(MockChatWindow* window) {

stanzaChannel_->uniqueIDs_ = true;

JID mucJID("795B7BBE-9099-4A0D-81BA-C816F78E275C@test.com");

manager_->setOnline(true);

std::shared_ptr<IQ> infoRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[1]);

CPPUNIT_ASSERT(infoRequest);

std::shared_ptr<IQ> infoResponse = IQ::createResult(infoRequest->getFrom(), infoRequest->getTo(), infoRequest->getID());

DiscoInfo info;

info.addIdentity(DiscoInfo::Identity("Shakespearean Chat Service", "conference", "text"));

info.addFeature("http://jabber.org/protocol/muc");

infoResponse->addPayload(std::make_shared<DiscoInfo>(info));

stanzaChannel_->onIQReceived(infoResponse);

std::vector<JID> jids;

jids.emplace_back("foo@test.com");

jids.emplace_back("bar@test.com");

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

uiEventStream_->send(std::make_shared<CreateImpromptuMUCUIEvent>(jids, mucJID, ""));

CPPUNIT_ASSERT_EQUAL(std::string("bar@test.com, foo@test.com"), manager_->getRecentChats()[0].getTitle());

CPPUNIT_ASSERT(mucJoinPresence);

// MUC presence reply

auto mucResponse = Presence::create();

mucResponse->setTo(jid_);

mucResponse->setFrom(mucJoinPresence->getTo());

mucResponse->addPayload([]() {

auto mucUser = std::make_shared<MUCUserPayload>();

mucUser->addItem(MUCItem(MUCOccupant::Member, MUCOccupant::Participant));

mucUser->addStatusCode(MUCUserPayload::StatusCode(110));

mucUser->addStatusCode(MUCUserPayload::StatusCode(210));

return mucUser;

}());

stanzaChannel_->onPresenceReceived(mucResponse);

// Before people join the impromptu room, the title is based on names coming from Roster

CPPUNIT_ASSERT_EQUAL(std::string("bar@test.com, foo@test.com"), manager_->getRecentChats()[0].getTitle());

auto mucParticipantJoined = [&](const JID& jid) {

auto participantJoinedPresence = Presence::create();

participantJoinedPresence->setTo(jid_);

participantJoinedPresence->setFrom(mucJID.withResource(jid.toString()));

auto mucUser = std::make_shared<MUCUserPayload>();

mucUser->addItem(MUCItem(MUCOccupant::Member, MUCOccupant::Participant));

participantJoinedPresence->addPayload(mucUser);

return participantJoinedPresence;

};

for (const auto& participantJID : jids) {

stanzaChannel_->onPresenceReceived(mucParticipantJoined(participantJID));

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

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

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

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

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

using namespace Swift;

class MUCControllerTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(MUCControllerTest);

CPPUNIT_TEST(testJoinPartStringContructionSimple);

CPPUNIT_TEST(testJoinPartStringContructionMixed);

CPPUNIT_TEST(testAppendToJoinParts);

CPPUNIT_TEST(testAddressedToSelf);

CPPUNIT_TEST(testNotAddressedToSelf);

CPPUNIT_TEST(testAddressedToSelfBySelf);

CPPUNIT_TEST(testMessageWithEmptyLabelItem);

CPPUNIT_TEST(testMessageWithLabelItem);

CPPUNIT_TEST(testCorrectMessageWithLabelItem);

CPPUNIT_TEST(testRoleAffiliationStates);

CPPUNIT_TEST(testSubjectChangeCorrect);

CPPUNIT_TEST(testSubjectChangeIncorrectA);

CPPUNIT_TEST(testSubjectChangeIncorrectB);

CPPUNIT_TEST(testSubjectChangeIncorrectC);

CPPUNIT_TEST(testHandleOccupantNicknameChanged);

CPPUNIT_TEST(testHandleOccupantNicknameChangedRoster);

CPPUNIT_TEST(testHandleChangeSubjectRequest);

CPPUNIT_TEST(testNonImpromptuMUCWindowTitle);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

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

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

nick_ = "aLiCe";

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

mocks_ = new MockRepository();

stanzaChannel_ = new DummyStanzaChannel();

iqChannel_ = new DummyIQChannel();

iqRouter_ = new IQRouter(iqChannel_);

eventController_ = new EventController();

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

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

xmppRoster_ = new XMPPRosterImpl();

presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);

presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);

directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);

uiEventStream_ = new UIEventStream();

avatarManager_ = new NullAvatarManager();

TimerFactory* timerFactory = nullptr;

window_ = new MockChatWindow();

mucRegistry_ = new MUCRegistry();

entityCapsProvider_ = new DummyEntityCapsProvider();

settings_ = new DummySettingsProvider();

highlightManager_ = new HighlightManager(settings_);

highlightManager_->resetToDefaultConfiguration();

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

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

}

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

/* verify that the roster is in sync */

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

for (auto rosterItem : group->getChildren()) {

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

CPPUNIT_ASSERT(child);

for (auto childItem : child->getChildren()) {

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

CPPUNIT_ASSERT(item);

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

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

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

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

}

}

}

void testHandleChangeSubjectRequest() {

std::string testStr("New Subject");

CPPUNIT_ASSERT_EQUAL(std::string(""), muc_->newSubjectSet_);

window_->onChangeSubjectRequest(testStr);

CPPUNIT_ASSERT_EQUAL(testStr, muc_->newSubjectSet_);

}

void testNonImpromptuMUCWindowTitle() {

CPPUNIT_ASSERT_EQUAL(muc_->getJID().getNode(), window_->name_);

}

private:

JID self_;

JID mucJID_;

MockMUC::ref muc_;

std::string nick_;

DummyStanzaChannel* stanzaChannel_;

DummyIQChannel* iqChannel_;

IQRouter* iqRouter_;

EventController* eventController_;

ChatWindowFactory* chatWindowFactory_;

UserSearchWindowFactory* userSearchWindowFactory_;

MUCController* controller_;

NickResolver* nickResolver_;

PresenceOracle* presenceOracle_;

AvatarManager* avatarManager_;

StanzaChannelPresenceSender* presenceSender_;

DirectedPresenceSender* directedPresenceSender_;

MockRepository* mocks_;

UIEventStream* uiEventStream_;

MockChatWindow* window_;

MUCRegistry* mucRegistry_;

DummyEntityCapsProvider* entityCapsProvider_;

DummySettingsProvider* settings_;

HighlightManager* highlightManager_;

std::shared_ptr<ChatMessageParser> chatMessageParser_;

std::shared_ptr<CryptoProvider> crypto_;

VCardManager* vcardManager_;

VCardMemoryStorage* vcardStorage_;

ClientBlockListManager* clientBlockListManager_;

MUCBookmarkManager* mucBookmarkManager_;