std::string newStatusChangeString = getStatusChangeString(newPresence);

if (newStatusChangeString != lastStatusChangeString_) {

if (lastWasPresence_) {

chatWindow_->replaceLastMessage(chatMessageParser_->parseMessageBody(newStatusChangeString), ChatWindow::UpdateTimestamp);

} else {

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

}

lastStatusChangeString_ = newStatusChangeString;

lastWasPresence_ = true;

}

}

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

return message->getTimestamp();

}

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

HistoryMessage::Type type;

if (mucRegistry_->isMUC(fromJID.toBare()) || mucRegistry_->isMUC(toJID.toBare())) {

type = HistoryMessage::PrivateMessage;

}

else {

type = HistoryMessage::Chat;

}

if (historyController_) {

historyController_->addMessage(message, fromJID, toJID, type, timeStamp);

}

}

ChatWindow* ChatController::detachChatWindow() {

chatWindow_->onUserTyping.disconnect(boost::bind(&ChatStateNotifier::setUserIsTyping, chatStateNotifier_));

chatWindow_->onUserCancelsTyping.disconnect(boost::bind(&ChatStateNotifier::userCancelledNewMessage, chatStateNotifier_));

return ChatControllerBase::detachChatWindow();

}

}

class ChatStateNotifier;

class ChatStateTracker;

class ClientBlockListManager;

class EntityCapsProvider;

class FileTransferController;

class HighlightManager;

class HistoryController;

class NickResolver;

class SettingsProvider;

class TimerFactory;

class UIEvent;

class ChatController : public ChatControllerBase {

public:

ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, SettingsProvider* settings, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider);

virtual ~ChatController();

virtual void setToJID(const JID& jid) SWIFTEN_OVERRIDE;

virtual void setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) SWIFTEN_OVERRIDE;

virtual void setOnline(bool online) SWIFTEN_OVERRIDE;

virtual void handleNewFileTransferController(FileTransferController* ftc);

virtual void handleWhiteboardSessionRequest(bool senderIsSelf);

virtual void handleWhiteboardStateChange(const ChatWindow::WhiteboardSessionState state);

virtual void setContactIsReceivingPresence(bool /*isReceivingPresence*/) SWIFTEN_OVERRIDE;

virtual ChatWindow* detachChatWindow() SWIFTEN_OVERRIDE;

virtual void handleIncomingOwnMessage(std::shared_ptr<Message> message) SWIFTEN_OVERRIDE;

protected:

virtual void cancelReplaces() SWIFTEN_OVERRIDE;

virtual JID getBaseJID() SWIFTEN_OVERRIDE;

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

private:

void handlePresenceChange(std::shared_ptr<Presence> newPresence);

std::string getStatusChangeString(std::shared_ptr<Presence> presence);

virtual bool isIncomingMessageFromMe(std::shared_ptr<Message> message) SWIFTEN_OVERRIDE;

virtual void postSendMessage(const std::string &body, std::shared_ptr<Stanza> sentStanza) SWIFTEN_OVERRIDE;

virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent) SWIFTEN_OVERRIDE;

virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent, const ChatWindow::ChatMessage& chatMessage) SWIFTEN_OVERRIDE;

virtual void preSendMessageRequest(std::shared_ptr<Message>) SWIFTEN_OVERRIDE;

virtual std::string senderHighlightNameFromMessage(const JID& from) SWIFTEN_OVERRIDE;

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

virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(std::shared_ptr<Message>) const SWIFTEN_OVERRIDE;

void handleStanzaAcked(std::shared_ptr<Stanza> stanza);

virtual void dayTicked() SWIFTEN_OVERRIDE { lastWasPresence_ = false; }

void handleContactNickChanged(const JID& jid, const std::string& /*oldNick*/);

virtual void handleBareJIDCapsChanged(const JID& jid) SWIFTEN_OVERRIDE;

void handleFileTransferCancel(std::string /* id */);

void handleFileTransferStart(std::string /* id */, std::string /* description */);

void handleFileTransferAccept(std::string /* id */, std::string /* filename */);

void handleSendFileRequest(std::string filename);

void handleWhiteboardSessionAccept();

void handleWhiteboardSessionCancel();

void handleWhiteboardWindowShow();

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

void checkForDisplayingDisplayReceiptsAlert();

void handleBlockingStateChanged();

void handleBlockUserRequest();

void handleUnblockUserRequest();

void handleInviteToChat(const std::vector<JID>& droppedJIDs);

void handleWindowClosed();

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

private:

NickResolver* nickResolver_;

ChatStateNotifier* chatStateNotifier_;

ChatStateTracker* chatStateTracker_;

std::string myLastMessageUIID_;

bool isInMUC_;

std::string lastStatusChangeString_;

std::map<std::shared_ptr<Stanza>, std::string> unackedStanzas_;

std::map<std::string, std::string> requestedReceipts_;

StatusShow::Type lastShownStatus_;

Tristate contactSupportsReceipts_;

bool receivingPresenceFromUs_ = false;

bool userWantsReceipts_;

std::map<std::string, FileTransferController*> ftControllers;

SettingsProvider* settings_;

std::string lastWbID_;

ClientBlockListManager* clientBlockListManager_;

boost::signals2::scoped_connection blockingOnStateChangedConnection_;

boost::signals2::scoped_connection blockingOnItemAddedConnection_;

boost::signals2::scoped_connection blockingOnItemRemovedConnection_;

boost::optional<ChatWindow::AlertID> deliveryReceiptAlert_;

boost::optional<ChatWindow::AlertID> blockedContactAlert_;

};

}

}

void ChatControllerBase::updateMessageCount() {

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

onUnreadCountChanged();

}

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

if (chatMessage.isMeCommand()) {

return chatWindow_->addAction(chatMessage, senderName, senderIsSelf, label, pathToString(avatarPath), time);

}

else {

return chatWindow_->addMessage(chatMessage, senderName, senderIsSelf, label, pathToString(avatarPath), time);

}

}

void ChatControllerBase::replaceMessage(const ChatWindow::ChatMessage& chatMessage, const std::string& id, const boost::posix_time::ptime& time) {

if (chatMessage.isMeCommand()) {

chatWindow_->replaceWithAction(chatMessage, id, time);

}

else {

chatWindow_->replaceMessage(chatMessage, id, time);

}

}

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

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

}

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

preHandleIncomingMessage(messageEvent);

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

unreadMessages_.push_back(messageEvent);

if (messageEvent->targetsMe()) {

targetedUnreadMessages_.push_back(messageEvent);

}

}

ChatWindow::ChatMessage chatMessage;

boost::optional<std::string> optionalBody = message->getBody();

std::string body = optionalBody.get_value_or("");

if (message->isError()) {

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

std::string errorMessage;

if (message->getPayload<Swift::ErrorPayload>()->getCondition() == ErrorPayload::ItemNotFound) {

errorMessage = QT_TRANSLATE_NOOP("", "This user could not be found in the room.");

}

else {

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

}

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

}

}

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

handleMUCInvitation(messageEvent->getStanza());

return;

}

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

handleMediatedMUCInvitation(messageEvent->getStanza());

return;

}

else {

if (!messageEvent->isReadable()) {

return;

}

showChatWindow();

JID from = message->getFrom();

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

void setCanStartImpromptuChats(bool supportsImpromptu);

virtual ChatWindow* detachChatWindow();

boost::signals2::signal<void(ChatWindow* /*window to reuse*/, const std::vector<JID>& /*invite people*/, const std::string& /*reason*/)> onConvertToMUC;

protected:

ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider);

/**

* Pass the Message appended, and the stanza used to send it.

*/

virtual void postSendMessage(const std::string&, std::shared_ptr<Stanza>) {}

virtual std::string senderDisplayNameFromMessage(const JID& from) = 0;

virtual std::string senderHighlightNameFromMessage(const JID& from) = 0;

virtual bool isIncomingMessageFromMe(std::shared_ptr<Message>) = 0;

virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent>) {}

virtual void addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time);

virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent>, const ChatWindow::ChatMessage&) {}

virtual void preSendMessageRequest(std::shared_ptr<Message>) {}

virtual bool isFromContact(const JID& from);

virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(std::shared_ptr<Message>) const = 0;

virtual void dayTicked() {}

virtual void handleBareJIDCapsChanged(const JID& jid) = 0;

std::string getErrorMessage(std::shared_ptr<ErrorPayload>);

virtual void setContactIsReceivingPresence(bool /* isReceivingPresence */) {}

virtual void cancelReplaces() = 0;

/** JID any iq for account should go to - bare except for PMs */

virtual JID getBaseJID();

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

ChatWindow::ChatMessage buildChatWindowChatMessage(const std::string& message, const std::string& senderName, bool senderIsSelf);

void updateMessageCount();

private:

IDGenerator idGenerator_;

std::string lastSentMessageStanzaID_;

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

void handleAllMessagesRead();

void handleSecurityLabelsCatalogResponse(std::shared_ptr<SecurityLabelsCatalog>, ErrorPayload::ref error);

void handleMUCInvitation(Message::ref message);

void handleMediatedMUCInvitation(Message::ref message);

void handleGeneralMUCInvitation(MUCInviteEvent::ref event);

void handleContinuationsBroken();

protected:

JID selfJID_;

std::vector<std::shared_ptr<StanzaEvent> > unreadMessages_;

std::vector<std::shared_ptr<StanzaEvent> > targetedUnreadMessages_;

StanzaChannel* stanzaChannel_;

IQRouter* iqRouter_;

ChatWindowFactory* chatWindowFactory_;

ChatWindow* chatWindow_;

JID toJID_;

bool labelsEnabled_;

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

PresenceOracle* presenceOracle_;

AvatarManager* avatarManager_;

bool useDelayForLatency_;

EventController* eventController_;

EntityCapsProvider* entityCapsProvider_;

SecurityLabelsCatalog::Item lastLabel_;

CPPUNIT_TEST(testSecondWindow);

CPPUNIT_TEST(testUnbindRebind);

CPPUNIT_TEST(testNoDuplicateUnbind);

CPPUNIT_TEST(testThreeMUCWindows);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnRemoveFromRoster);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnAddToRoster);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToBoth);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToFrom);

CPPUNIT_TEST(testChatControllerFullJIDBindingOnMessageAndNotReceipt);

CPPUNIT_TEST(testChatControllerFullJIDBindingOnTypingAndNotActive);

CPPUNIT_TEST(testLocalMUCServiceDiscoveryResetOnDisconnect);

CPPUNIT_TEST(testPresenceChangeDoesNotReplaceMUCInvite);

CPPUNIT_TEST(testNotSplittingMUCPresenceJoinLeaveLinesOnChatStateNotifications);

// MUC PM Tests

CPPUNIT_TEST(testChatControllerPMPresenceHandling);

CPPUNIT_TEST(testChatControllerMucPmUnavailableErrorHandling);

// Highlighting tests

CPPUNIT_TEST(testChatControllerHighlightingNotificationTesting);

CPPUNIT_TEST(testChatControllerHighlightingNotificationDeduplicateSounds);

CPPUNIT_TEST(testChatControllerHighlightingNotificationKeyword);

CPPUNIT_TEST(testChatControllerMeMessageHandling);

CPPUNIT_TEST(testRestartingMUCComponentCrash);

CPPUNIT_TEST(testChatControllerMeMessageHandlingInMUC);

// Carbons tests

CPPUNIT_TEST(testCarbonsForwardedIncomingMessageToSecondResource);

CPPUNIT_TEST(testCarbonsForwardedOutgoingMessageFromSecondResource);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

mocks_ = new MockRepository();

notifier_ = std::unique_ptr<DummyNotifier>(new DummyNotifier());

jid_ = JID("test@test.com/resource");

stanzaChannel_ = new DummyStanzaChannel();

iqRouter_ = new IQRouter(stanzaChannel_);

eventController_ = new EventController();

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

joinMUCWindowFactory_ = mocks_->InterfaceMock<JoinMUCWindowFactory>();

xmppRoster_ = new XMPPRosterImpl();

mucRegistry_ = new MUCRegistry();

nickResolver_ = new NickResolver(jid_.toBare(), xmppRoster_, nullptr, mucRegistry_);

presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);

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

presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);

directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);

mucManager_ = new MUCManager(stanzaChannel_, iqRouter_, directedPresenceSender_, mucRegistry_);

uiEventStream_ = new UIEventStream();

entityCapsProvider_ = new DummyEntityCapsProvider();

chatListWindowFactory_ = mocks_->InterfaceMock<ChatListWindowFactory>();

mucSearchWindowFactory_ = mocks_->InterfaceMock<MUCSearchWindowFactory>();

settings_ = new DummySettingsProvider();

profileSettings_ = new ProfileSettingsProvider("a", settings_);

chatListWindow_ = new MockChatListWindow();

ftManager_ = new DummyFileTransferManager();

ftOverview_ = new FileTransferOverview(ftManager_);

originalMessage->setBody(forwardedBody);

originalMessage->addPayload(std::make_shared<DeliveryReceiptRequest>());

auto messageWrapper = createCarbonsMessage(std::make_shared<CarbonsSent>(), originalMessage);

manager_->handleIncomingMessage(messageWrapper);

CPPUNIT_ASSERT_EQUAL(forwardedBody, MockChatWindow::bodyFromMessage(window->lastAddedMessage_));

CPPUNIT_ASSERT_EQUAL(true, window->lastAddedMessageSenderIsSelf_);

CPPUNIT_ASSERT_EQUAL(size_t(1), window->receiptChanges_.size());

CPPUNIT_ASSERT_EQUAL(ChatWindow::ReceiptRequested, window->receiptChanges_[0].second);

}

// incoming carbons message for the received delivery receipt to the other resource

{

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

originalMessage->setFrom(messageJID);

originalMessage->setTo(jid2);

originalMessage->setType(Message::Chat);

originalMessage->addPayload(std::make_shared<DeliveryReceipt>("abcdefg123456"));

auto messageWrapper = createCarbonsMessage(std::make_shared<CarbonsReceived>(), originalMessage);

manager_->handleIncomingMessage(messageWrapper);

CPPUNIT_ASSERT_EQUAL(size_t(2), window->receiptChanges_.size());

CPPUNIT_ASSERT_EQUAL(ChatWindow::ReceiptReceived, window->receiptChanges_[1].second);

}

}

private:

std::shared_ptr<Message> makeDeliveryReceiptTestMessage(const JID& from, const std::string& id) {

std::shared_ptr<Message> message = std::make_shared<Message>();

message->setFrom(from);

message->setID(id);

message->setBody("This will cause the window to open");

message->addPayload(std::make_shared<DeliveryReceiptRequest>());

return message;

}

size_t st(int i) {

return static_cast<size_t>(i);

}

void handleHighlightAction(const HighlightAction& action) {

handledHighlightActions_++;

if (action.getSoundFilePath()) {

soundsPlayed_.insert(action.getSoundFilePath().get_value_or(""));

}

}

private:

JID jid_;

std::unique_ptr<DummyNotifier> notifier_;

ChatsManager* manager_;

DummyStanzaChannel* stanzaChannel_;

IQRouter* iqRouter_;

EventController* eventController_;

ChatWindowFactory* chatWindowFactory_;

JoinMUCWindowFactory* joinMUCWindowFactory_;

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

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

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

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

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

for (const auto& alteration : alterations) {

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

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

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

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

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

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

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

testRoleAffiliationStatesVerify(occupants);

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

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

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

testRoleAffiliationStatesVerify(occupants);

}

}

void testSubjectChangeCorrect() {

joinCompleted();

{

Message::ref message = std::make_shared<Message>();

message->setType(Message::Groupchat);

message->setTo(self_);

message->setFrom(mucJID_.withResource("SomeNickname"));

message->setSubject("New Room Subject");

controller_->handleIncomingMessage(std::make_shared<MessageEvent>(message));

CPPUNIT_ASSERT_EQUAL(std::string("The room subject is now: New Room Subject"), std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(window_->lastAddedSystemMessage_.getParts()[0])->text);

}

}

/*

* Test that message stanzas with subject element and non-empty body element do not cause a subject change.

*/

void testSubjectChangeIncorrectA() {

joinCompleted();

{

Message::ref message = std::make_shared<Message>();

message->setType(Message::Groupchat);

message->setTo(self_);

message->setFrom(mucJID_.withResource("SomeNickname"));

message->setID(iqChannel_->getNewIQID());

message->setSubject("New Room Subject");

message->setBody("Some body text that prevents this stanza from being a subject change.");

controller_->handleIncomingMessage(std::make_shared<MessageEvent>(message));

CPPUNIT_ASSERT_EQUAL(std::string("Trying to enter room teaparty@rooms.wonderland.lit"), std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(window_->lastAddedSystemMessage_.getParts()[0])->text);

}

}

/*

* Test that message stanzas with subject element and thread element do not cause a subject change.

*/