+ * Copyright (c) 2010-2018 Isode Limited.

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

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

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

+AccountController::AccountController(

+ emoticons_(emoticons),

+ fdpFormSubmitController_(nullptr) {

+ eventController_->onEventQueueLengthChange.connect(boost::bind(&AccountController::handleEventQueueLengthChange, this, _1));

+ loginWindow_->onLoginRequest.connect(boost::bind(&AccountController::handleLoginRequest, this, _1, _2, _3, _4, _5, _6, _7));

+ loginWindow_->onPurgeSavedLoginRequest.connect(boost::bind(&AccountController::handlePurgeSavedLoginRequest, this, _1));

+ loginWindow_->onCancelLoginRequest.connect(boost::bind(&AccountController::handleCancelLoginRequest, this));

+ loginWindow_->onQuitRequest.connect(boost::bind(&AccountController::handleQuitRequest, this));

+ idleDetector_->onIdleChanged.connect(boost::bind(&AccountController::handleInputIdleChanged, this, _1));

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

+AccountController::~AccountController() {

+ idleDetector_->onIdleChanged.disconnect(boost::bind(&AccountController::handleInputIdleChanged, this, _1));

+void AccountController::purgeCachedCredentials() {

+void AccountController::resetClient() {

+ chattables_.reset();

+void AccountController::handleSettingChanged(const std::string& settingPath) {

+void AccountController::resetPendingReconnects() {

+void AccountController::resetCurrentError() {

+void AccountController::handleConnected() {

+ chattables_ = std::make_unique<Chattables>();

+ rosterController_ = new RosterController(boundJID_, client_->getRoster(), client_->getAvatarManager(), uiFactory_, client_->getNickManager(), client_->getNickResolver(), client_->getPresenceOracle(), client_->getSubscriptionManager(), eventController_, uiEventStream_, client_->getIQRouter(), settings_, client_->getEntityCapsProvider(), client_->getClientBlockListManager(), client_->getVCardManager(), *chattables_);

+ rosterController_->onChangeStatusRequest.connect(boost::bind(&AccountController::handleChangeStatusRequest, this, _1, _2));

+ rosterController_->onSignOutRequest.connect(boost::bind(&AccountController::signOut, this));

+ rosterController_->getWindow()->onShowCertificateRequest.connect(boost::bind(&AccountController::handleShowCertificateRequest, this));

+ chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_, ftOverview_, client_->getRoster(), !settings_->getSetting(SettingConstants::REMEMBER_RECENT_CHATS), settings_, nullptr, whiteboardManager_, highlightManager_, client_->getClientBlockListManager(), emoticons_, client_->getVCardManager(), *chattables_);

+ discoInfoRequest->onResponse.connect(boost::bind(&AccountController::handleServerDiscoInfoResponse, this, _1, _2));

+void AccountController::handleEventQueueLengthChange(size_t count) {

+void AccountController::reconnectAfterError() {

+void AccountController::handleChangeStatusRequest(StatusShow::Type show, const std::string &statusText) {

+void AccountController::sendPresence(std::shared_ptr<Presence> presence) {

+void AccountController::handleInputIdleChanged(bool idle) {

+void AccountController::handleShowCertificateRequest() {

+void AccountController::handleLoginRequest(const std::string &username, const std::string &password, const std::string& certificatePath, CertificateWithKey::ref certificate, const ClientOptions& options, bool remember, bool loginAutomatically) {

+ profileSettings_->storeInt("enabled", 1);

+void AccountController::handlePurgeSavedLoginRequest(const std::string& username) {

+void AccountController::performLoginFromCachedCredentials() {

+ client_->onDisconnected.connect(boost::bind(&AccountController::handleDisconnected, this, _1));

+ client_->onConnected.connect(boost::bind(&AccountController::handleConnected, this));

+ client_->getVCardManager()->onVCardChanged.connect(boost::bind(&AccountController::handleVCardReceived, this, _1, _2));

+ presenceNotifier_->onNotificationActivated.connect(boost::bind(&AccountController::handleNotificationClicked, this, _1));

+ eventNotifier_->onNotificationActivated.connect(boost::bind(&AccountController::handleNotificationClicked, this, _1));

+ fdpFormSubmitController_ = std::make_unique<FdpFormSubmitController>(jid_, client_->getIQRouter(), uiEventStream_, uiFactory_);

+void AccountController::handleDisconnected(const boost::optional<ClientError>& error) {

+ message = str(format(QT_TRANSLATE_NOOP("", "Reconnect to %1% failed: %2%. Will retry in %3% seconds.")) % jid_.getDomain() % message % std::to_string(timeBeforeNextReconnect_));

+void AccountController::setReconnectTimer() {

+ reconnectTimer_->onTick.connect(boost::bind(&AccountController::reconnectAfterError, this));

+void AccountController::handleCancelLoginRequest() {

+void AccountController::signOut() {

+ profileSettings_->storeInt("enabled", 0);

+void AccountController::logout() {

+void AccountController::setManagersOffline() {

+void AccountController::handleServerDiscoInfoResponse(std::shared_ptr<DiscoInfo> info, ErrorPayload::ref error) {

+void AccountController::enableMessageCarbons() {

+void AccountController::handleVCardReceived(const JID& jid, VCard::ref vCard) {

+void AccountController::handleNotificationClicked(const JID& jid) {

+void AccountController::handleQuitRequest() {

+//FIXME: Switch all this to boost::serialise

+

+std::string AccountController::serializeClientOptions(const ClientOptions& options) {

+ SERIALIZE_BOOL(singleSignOn);

+ * Copyright (c) 2010-2018 Isode Limited.

+ class Chattables;

+ class FdpFormSubmitController;

+ class AccountController {

+ AccountController(

+ ~AccountController();

+ void handleEventQueueLengthChange(size_t count);

+ ProfileSettingsProvider* profileSettings_ = nullptr;

+ std::unique_ptr<Chattables> chattables_;

+ std::unique_ptr<FdpFormSubmitController> fdpFormSubmitController_;

+ * Copyright (c) 2010-2018 Isode Limited.

+ChatController::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, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables)

+ : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, nickResolver, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider, settings, chattables), userWantsReceipts_(userWantsReceipts), clientBlockListManager_(clientBlockListManager) {

+ failedStanzas_[stanzaIdPair.second] = stanzaIdPair.first;

+ * Copyright (c) 2010-2018 Isode Limited.

+ 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, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables);

+ virtual ~ChatController() override;

+ virtual void setToJID(const JID& jid) override;

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

+ virtual void setOnline(bool online) override;

+ virtual void setContactIsReceivingPresence(bool /*isReceivingPresence*/) override;

+ virtual ChatWindow* detachChatWindow() override;

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

+ virtual void cancelReplaces() override;

+ virtual JID getBaseJID() override;

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

+ virtual bool shouldIgnoreMessage(std::shared_ptr<Message> message) override;

+ virtual JID messageCorrectionJID(const JID& fromJID) override;

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

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

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

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

+ virtual void handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) override;

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

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

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

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

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

+ virtual void dayTicked() override { lastWasPresence_ = false; }

+ virtual void handleBareJIDCapsChanged(const JID& jid) override;

+ * Copyright (c) 2010-2018 Isode Limited.

+#include <Swiften/Elements/DeliveryReceipt.h>

+#include <Swiften/Elements/DeliveryReceiptRequest.h>

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

+ChatControllerBase::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, SettingsProvider* settings, Chattables& chattables) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), entityCapsProvider_(entityCapsProvider), historyController_(historyController), mucRegistry_(mucRegistry), chatMessageParser_(chatMessageParser), autoAcceptMUCInviteDecider_(autoAcceptMUCInviteDecider), eventStream_(eventStream), roomSecurityMarking_(""), previousMessageSecurityMarking_(""), settings_(settings), chattables_(chattables) {

+ scopedConnectionResendMessage_ = chatWindow_->onResendMessageRequest.connect(boost::bind(&ChatControllerBase::handleResendMessageRequest, this, _1));

+ scopedConnectionResendMessage_.disconnect();

+size_t ChatControllerBase::getUnreadCount() {

+ return targetedUnreadMessages_.size();

+ auto baseJID = getBaseJID();

+ auto state = chattables_.getState(baseJID);

+ state.unreadCount = unreadMessages_.size();

+ chatWindow_->setUnreadMessageCount(state.unreadCount);

+ chattables_.setState(baseJID, state);

+#ifndef NOT_YET

+#endif

+ auto displayedLabel = label;

+

+ if (settings_->getSetting(SettingConstants::MUC_MARKING_ELISION)) {

+ if (roomSecurityMarking_ != "") {

+

+ if (label && label->getDisplayMarking() == roomSecurityMarking_) {

+ if (label->getDisplayMarking() == previousMessageSecurityMarking_) {

+ displayedLabel = std::make_shared<SecurityLabel>();

+ }

+ previousMessageSecurityMarking_ = label->getDisplayMarking();

+ }

+ else if (!label || label->getDisplayMarking().empty()) {

+ displayedLabel = std::make_shared<SecurityLabel>();

+ displayedLabel->setDisplayMarking("Unmarked");

+ previousMessageSecurityMarking_ = "Unmarked";

+ }

+ else {

+ previousMessageSecurityMarking_ = displayedLabel->getDisplayMarking();

+ }

+ }

+ }

+

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

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

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+#endif

+ eventStream_->send(std::make_shared<JoinMUCUIEvent>(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, true));

+void ChatControllerBase::handleResendMessageRequest(const std::string& id) {

+ if (failedStanzas_.find(id) != failedStanzas_.end()) {

+ if (auto resendMsg = std::dynamic_pointer_cast<Message>(failedStanzas_[id])) {

+ stanzaChannel_->sendMessage(resendMsg);

+ if (stanzaChannel_->getStreamManagementEnabled()) {

+ chatWindow_->setAckState(id, ChatWindow::Pending);

+ unackedStanzas_[failedStanzas_[id]] = id;

+ }

+ if (resendMsg->getPayload<DeliveryReceiptRequest>()) {

+ requestedReceipts_[resendMsg->getID()] = id;

+ chatWindow_->setMessageReceiptState(id, ChatWindow::ReceiptRequested);

+ }

+ lastWasPresence_ = false;

+ failedStanzas_.erase(id);

+ }

+ }

+}

+

+ * Copyright (c) 2010-2018 Isode Limited.

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

+ class Chattables;

+ class HighlightManager;

+ size_t getUnreadCount();

+ 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, SettingsProvider* settings, Chattables& chattables);

+ virtual void handleResendMessageRequest(const std::string& id);

+ std::string roomSecurityMarking_;

+ std::string previousMessageSecurityMarking_;

+ SettingsProvider* settings_;

+ boost::signals2::scoped_connection scopedConnectionResendMessage_;

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

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

+ std::map<std::string, std::shared_ptr<Stanza>> failedStanzas_;

+ Chattables& chattables_;

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

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ VCardManager* vcardManager,

+ Chattables& chattables) :

+ vcardManager_(vcardManager),

+ chattables_(chattables) {

+#ifndef NOT_YET

+#endif

+ chattables_.onActivated.connect(boost::bind(&ChatsManager::handleChattableActivated, this, _1));

+

+#ifndef NOT_YET

+#endif

+ chattables_.onActivated.disconnect(boost::bind(&ChatsManager::handleChattableActivated, this, _1));

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

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

+#ifndef NOT_YET

+ //Only one entry of the bookmark should exist

+ chatListWindow_->removeMUCBookmark(bookmark);

+#endif

+ chattables_.addJID(bookmark.getRoom(), Chattables::State::Type::Room);

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+ size_t unreadCount = 0;

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+

+ size_t unreadTotal = 0;

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ const auto& jid = it->first;

+ auto state = chattables_.getState(jid);

+ state.status = StatusShow::None;

+ chattables_.setState(jid, state);

+ //If user deletes bookmark from chatListWindow_ and then decides to leave the room, or if the server doesn't support bookmarks, the bookmark will not exist.

+ if (auto bookmarkFound = mucBookmarkManager_->lookupBookmark(jid)) {

+ MUCBookmark newBookmark(bookmarkFound.get());

+ newBookmark.setAutojoin(false);

+ mucBookmarkManager_->replaceBookmark(bookmarkFound.get(), newBookmark);

+ }

+#ifndef NOT_YET

+#endif

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

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

+#ifndef NOT_YET

+#endif

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

+#ifndef NOT_YET

+#endif

+

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

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

+#ifndef NOT_YET

+#endif

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

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

+ chattables_.addJID(muc->getJID(), Chattables::State::Type::Room);

+ auto state = chattables_.getState(muc->getJID());

+ state.status = StatusShow::Online;

+ chattables_.setState(muc->getJID(), state);

+#ifndef NOT_YET

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

+#endif

+#ifndef NOT_YET

+#endif

+ if (auto existingBookmark = mucBookmarkManager_->lookupBookmark(mucJID)) {

+ if (!existingBookmark->getAutojoin()) {

+ MUCBookmark newbookmark(existingBookmark.get());

+ newbookmark.setAutojoin(true);

+ mucBookmarkManager_->replaceBookmark(*existingBookmark, newbookmark);

+ }

+ }

+ else {

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

+ bookmark.setAutojoin(true);

+ if (nickMaybe) {

+ bookmark.setNick(*nickMaybe);

+ }

+ if (password) {

+ bookmark.setPassword(*password);

+ }

+ mucBookmarkManager_->addBookmark(bookmark);

+ }

+ handleJoinMUCRequest(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, true, window);

+ handleJoinMUCRequest(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, true);

+#ifndef NOT_YET

+ uiEventStream_->send(std::make_shared<JoinMUCUIEvent>(chat.jid, boost::optional<std::string>(), chat.nick, false, isImpromptu));

+#endif

+

+void ChatsManager::handleChattableActivated(const JID& jid) {

+ auto state = chattables_.getState(jid);

+ if (state.type == Chattables::State::Type::Person) {

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

+ }

+ else if (state.type == Chattables::State::Type::Room) {

+ if (auto foundBookmark = mucBookmarkManager_->lookupBookmark(jid)) {

+ handleMUCBookmarkActivated(foundBookmark.get());

+ }

+ else {

+ uiEventStream_->send(std::make_shared<JoinMUCUIEvent>(jid, boost::optional<std::string>(), boost::optional<std::string>())); // Just a quick hack to reuse already open MUCs

+ }

+ }

+}

+

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ * Copyright (c) 2010-2018 Isode Limited.

+ class AutoAcceptMUCInviteDecider;

+ class AvatarManager;

+ class ChatListWindowFactory;

+ class ChatMessageParser;

+ class Chattables;

+ class ClientBlockListManager;

+ class DirectedPresenceSender;

+ class DiscoServiceWalker;

+ class EntityCapsProvider;

+ class EventController;

+ class FileTransferController;

+ class FileTransferOverview;

+ class HighlightManager;

+ class HistoryController;

+ class IQRouter;

+ class MUCBookmarkManager;

+ class MUCController;

+ class MUCManager;

+ class MUCSearchController;

+ class MUCSearchWindowFactory;

+ class StanzaChannel;

+ class TimerFactory;

+ class WhiteboardManager;

+ class XMPPRoster;

+ 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, VCardManager* vcardManager, Chattables& chattables);

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ MUC::ref handleJoinMUCRequest(const JID& muc, const boost::optional<std::string>& password, const boost::optional<std::string>& nick, bool createAsReservedIfNew, bool isImpromptu, ChatWindow* reuseChatwindow = nullptr);

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ void handleChattableActivated(const JID& jid);

+#ifndef NOT_YET

+#endif

+

+ protected:

+ MUCBookmarkManager* mucBookmarkManager_;

+

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ Chattables& chattables_;

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

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

+

+namespace Swift {

+

+const std::vector<JID>& Chattables::get() const {

+ return list_;

+}

+

+const Chattables::State& Chattables::getState(const JID& jid) const {

+ auto it = states_.find(jid);

+ return it != states_.end() ? it->second : unknown_;

+}

+

+void Chattables::addJID(const JID& jid, State::Type type) {

+ if (states_.find(jid) != states_.end()) {

+ return;

+ }

+ State state;

+ state.type = type;

+ state.jid = jid;

+ onBeginAdd(static_cast<int>(list_.size()));

+ list_.push_back(jid);

+ states_[jid] = state;

+ onAdded();

+}

+

+void Chattables::setState(const JID& jid, State state) {

+ auto stateIter = states_.find(jid);

+ if (stateIter == states_.end()) {

+ return;

+ }

+ stateIter->second = state;

+ auto listPos = static_cast<int>(std::distance(list_.begin(), std::find(list_.begin(), list_.end(), jid)));

+ onChanged(jid, listPos);

+}

+

+}

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <map>

+#include <vector>

+

+#include <boost/signals2.hpp>

+

+#include <Swiften/Elements/StatusShow.h>

+#include <Swiften/JID/JID.h>

+

+namespace Swift {

+class Chattables {

+ public:

+ struct State {

+ enum class Type {Room, Person};

+ JID jid;

+ /// Empty for no name

+ std::string name;

+ size_t unreadCount = 0;

+ Type type;

+ StatusShow::Type status = StatusShow::None;

+ //avatar

+ //status

+ };

+ const std::vector<JID>& get() const;

+ const State& getState(const JID& jid) const;

+

+ void addJID(const JID& jid, State::Type type);

+ void setState(const JID& jid, State state);

+

+ boost::signals2::signal<void (int)> onBeginAdd;

+ boost::signals2::signal<void ()> onAdded;

+ boost::signals2::signal<void (const JID&, int)> onChanged;

+ /// The UI has activated a chattable item (e.g. clicked in the roster)

+ boost::signals2::signal<void (const JID&)> onActivated;

+ private:

+ std::vector<JID> list_;

+ std::map<JID, State> states_;

+ State unknown_;

+};

+}

+ * Copyright (c) 2010-2018 Isode Limited.

+#include <Swiften/Disco/GetDiscoInfoRequest.h>

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

+ MUCBookmarkManager* mucBookmarkManager,

+ SettingsProvider* settings,

+ Chattables& chattables) :

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

+ roster_ = std::make_unique<Roster>(false, true);

+ updateChatWindowBookmarkStatus(mucBookmarkManager_->lookupBookmark(muc->getJID()));

+

+ requestSecurityMarking();

+

+ actions.push_back(ChatWindow::Leave);

+void MUCController::requestSecurityMarking() {

+ auto discoInfoRequest = GetDiscoInfoRequest::create(muc_->getJID(), iqRouter_);

+ discoInfoRequest->onResponse.connect(

+ [this](std::shared_ptr<DiscoInfo> discoInfoRef, ErrorPayload::ref errorPayloadRef) {

+ if (!discoInfoRef || errorPayloadRef) {

+ return;

+ }

+ const std::vector<Form::ref>& extensionsList = discoInfoRef->getExtensions();

+ if (extensionsList.empty()) {

+ return;

+ }

+ // Get the correct form if it exists

+ Form::ref roomInfoForm;

+ for (const auto& form : extensionsList) {

+ if (form->getFormType() == "http://jabber.org/protocol/muc#roominfo") {

+ roomInfoForm = form;

+ break;

+ }

+ }

+ if (!roomInfoForm) {

+ return;

+ }

+ // It exists, now examine the security marking data

+ auto marking = roomInfoForm->getField("x-isode#roominfo_marking");

+ if (!marking) {

+ return;

+ }

+ // Now we know the marking is valid

+ auto markingValue = marking->getTextSingleValue();

+ if (markingValue == "") {

+ setMUCSecurityMarkingDefault();

+ return;

+ }

+ auto markingForegroundColor = roomInfoForm->getField("x-isode#roominfo_marking_fg_color");

+ auto markingBackgroundColor = roomInfoForm->getField("x-isode#roominfo_marking_bg_color");

+ std::string markingForegroundColorValue = "Black";

+ std::string markingBackgroundColorValue = "White";

+ if (markingForegroundColor && markingForegroundColor->getTextSingleValue() != "") {

+ markingForegroundColorValue = markingForegroundColor->getTextSingleValue();

+ }

+ if (markingBackgroundColor && markingBackgroundColor->getTextSingleValue() != "") {

+ markingBackgroundColorValue = markingBackgroundColor->getTextSingleValue();

+ }

+ setMUCSecurityMarking(markingValue, markingForegroundColorValue, markingBackgroundColorValue);

+ }

+ );

+ discoInfoRequest->send();

+}

+

+void MUCController::setMUCSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue) {

+ roomSecurityMarking_ = markingValue;

+ chatWindow_->setChatSecurityMarking(markingValue, markingForegroundColorValue, markingBackgroundColorValue);

+}

+

+void MUCController::setMUCSecurityMarkingDefault() {

+ roomSecurityMarking_ = "";

+ chatWindow_->removeChatSecurityMarking();

+}

+

+ * Copyright (c) 2010-2018 Isode Limited.

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

+ virtual ~MUCController() override;

+ virtual void setOnline(bool online) override;

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

+ virtual void preSendMessageRequest(std::shared_ptr<Message> message) override;

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

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

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

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

+ virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent>) override;

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

+ virtual void handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) override;

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

+ virtual void cancelReplaces() override;

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

+ virtual JID messageCorrectionJID(const JID& fromJID) override;

+ virtual void dayTicked() override { clearPresenceQueue(); }

+ virtual void handleBareJIDCapsChanged(const JID& jid) override;

+ void requestSecurityMarking();

+ void setMUCSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue);

+ void setMUCSecurityMarkingDefault();

+

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <memory>

+#include <string>

+

+#include <gtest/gtest.h>

+#include <hippomocks.h>

+

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

+#include <Swiften/Client/ClientBlockListManager.h>

+#include <Swiften/Client/DummyStanzaChannel.h>

+#include <Swiften/Client/NickResolver.h>

+#include <Swiften/Disco/DummyEntityCapsProvider.h>

+#include <Swiften/Network/DummyTimerFactory.h>

+#include <Swiften/Queries/DummyIQChannel.h>

+#include <Swiften/Roster/XMPPRoster.h>

+#include <Swiften/Roster/XMPPRosterImpl.h>

+#include <Swiften/VCards/VCardManager.h>

+#include <Swiften/VCards/VCardMemoryStorage.h>

+

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

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

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

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

+#include <Swift/Controllers/Settings/DummySettingsProvider.h>

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

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

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

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

+

+using namespace Swift;

+

+/**

+ * Most of the ChatController tests are in ChatsManagerTest.

+ * New tests related with ChatController should be added here,

+ * and old tests should be migrated when possible.

+ */

+

+class ExtendedChatController : public ChatController {

+public:

+ ExtendedChatController(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, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables) :

+ ChatController(self, stanzaChannel, iqRouter, chatWindowFactory, contact, nickResolver, presenceOracle, avatarManager, isInMUC, useDelayForLatency, eventStream, timerFactory, eventController, entityCapsProvider, userWantsReceipts, historyController, mucRegistry, highlightManager, clientBlockListManager, chatMessageParser, autoAcceptMUCInviteDecider, settings, chattables) {

+ }

+

+ std::map<std::shared_ptr<Stanza>, std::string> getUnackedStanzas() { return unackedStanzas_; }

+ std::map<std::string, std::shared_ptr<Stanza>> getFailedStanzas() { return failedStanzas_; }

+};

+

+class ChatControllerTest : public ::testing::Test {

+protected:

+ virtual void SetUp() {

+ self_ = JID("alice@wonderland.lit");

+ other_ = JID("whiterabbit@wonderland.lit");

+ stanzaChannel_ = new DummyStanzaChannel();

+ iqChannel_ = new DummyIQChannel();

+ iqRouter_ = new IQRouter(iqChannel_);

+ eventController_ = new EventController();

+ xmppRoster_ = new XMPPRosterImpl();

+ vCardManager_ = new VCardManager(self_, iqRouter_, vCardMemoryStorage_);

+ mucRegistry_ = new MUCRegistry();

+ nickResolver_ = new NickResolver(self_, xmppRoster_, vCardManager_, mucRegistry_);

+ presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);

+ avatarManager_ = new NullAvatarManager();

+ uiEventStream_ = new UIEventStream();

+ timerFactory_ = new DummyTimerFactory();

+ entityCapsProvider_ = new DummyEntityCapsProvider();

+ settings_ = new DummySettingsProvider();

+ highlightManager_ = new HighlightManager(settings_);

+ highlightManager_->resetToDefaultConfiguration();

+ clientBlockListManager_ = new ClientBlockListManager(iqRouter_);

+ autoAcceptMUCInviteDecider_ = new AutoAcceptMUCInviteDecider(self_.getDomain(), xmppRoster_, settings_);

+ chatMessageParser_ = std::make_shared<ChatMessageParser>(std::map<std::string, std::string>(), highlightManager_->getConfiguration(), ChatMessageParser::Mode::GroupChat);

+ mocks_ = new MockRepository();

+ window_ = new MockChatWindow();

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

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

+ chattables_ = std::make_unique<Chattables>();

+

+ controller_ = new ExtendedChatController(self_, stanzaChannel_, iqRouter_, chatWindowFactory_, other_, nickResolver_, presenceOracle_, avatarManager_, false, false, uiEventStream_, timerFactory_, eventController_, entityCapsProvider_, false, nullptr, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser_, nullptr, settings_, *chattables_);

+ }

+ virtual void TearDown() {

+ delete controller_;

+ chattables_.reset();

+ chatMessageParser_.reset();

+ delete autoAcceptMUCInviteDecider_;

+ delete clientBlockListManager_;

+ delete highlightManager_;

+ delete settings_;

+ delete entityCapsProvider_;

+ delete timerFactory_;

+ delete uiEventStream_;

+ delete avatarManager_;

+ delete presenceOracle_;

+ delete nickResolver_;

+ delete mucRegistry_;

+ delete vCardManager_;

+ delete xmppRoster_;

+ delete eventController_;

+ delete iqRouter_;

+ delete iqChannel_;

+ delete stanzaChannel_;

+ }

+

+ JID self_, other_;

+ AvatarManager* avatarManager_ = nullptr;

+ ExtendedChatController* controller_ = nullptr;

+ ChatWindowFactory* chatWindowFactory_;

+ ClientBlockListManager* clientBlockListManager_;

+ EventController* eventController_ = nullptr;

+ EntityCapsProvider* entityCapsProvider_ = nullptr;

+ IQChannel* iqChannel_ = nullptr;

+ IQRouter* iqRouter_ = nullptr;

+ MockRepository* mocks_;

+ MockChatWindow* window_;

+ MUCRegistry* mucRegistry_ = nullptr;

+ NickResolver* nickResolver_ = nullptr;

+ PresenceOracle* presenceOracle_ = nullptr;

+ DummyStanzaChannel* stanzaChannel_ = nullptr;

+ TimerFactory* timerFactory_;

+ XMPPRosterImpl* xmppRoster_ = nullptr;

+ UIEventStream* uiEventStream_;

+ VCardManager* vCardManager_ = nullptr;

+ VCardMemoryStorage* vCardMemoryStorage_ = nullptr;

+ DummySettingsProvider* settings_;

+ HighlightManager* highlightManager_;

+ std::shared_ptr<ChatMessageParser> chatMessageParser_;

+ AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider_;

+ std::unique_ptr<Chattables> chattables_;

+

+};

+

+TEST_F(ChatControllerTest, testResendMessage) {

+ std::string msgBody("TestMsg");

+ stanzaChannel_->setStreamManagementEnabled(true);

+ window_->onSendMessageRequest(msgBody, false);

+ {

+ auto failedStanzas = controller_->getFailedStanzas();

+ auto unackedStanzas = controller_->getUnackedStanzas();

+ ASSERT_EQ(failedStanzas.size(), 0);

+ ASSERT_EQ(unackedStanzas.size(), 1);

+ }

+ //Disconnecting to fail the stanza

+ controller_->setOnline(false);

+ controller_->setOnline(true);

+ {

+ auto failedStanzas = controller_->getFailedStanzas();

+ auto unackedStanzas = controller_->getUnackedStanzas();

+ ASSERT_EQ(failedStanzas.size(), 1);

+ ASSERT_EQ(unackedStanzas.size(), 0);

+ }

+ window_->onResendMessageRequest("id");

+ {

+ auto failedStanzas = controller_->getFailedStanzas();

+ auto unackedStanzas = controller_->getUnackedStanzas();

+ ASSERT_EQ(failedStanzas.size(), 0);

+ ASSERT_EQ(unackedStanzas.size(), 1);

+ }

+}

+#include <Swiften/MUC/MUCBookmarkManager.h>

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

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

+class ExtendedChatsManager : public ChatsManager {

+public:

+ ExtendedChatsManager(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, VCardManager* vcardManager, Chattables& chattables) :

+ ChatsManager(jid, stanzaChannel, iqRouter, eventController, chatWindowFactory, joinMUCWindowFactory, nickResolver, presenceOracle, presenceSender, uiEventStream, chatListWindowFactory, useDelayForLatency, timerFactory, mucRegistry, entityCapsProvider, mucManager, mucSearchWindowFactory, profileSettings, ftOverview, roster, eagleMode, settings, historyController_, whiteboardManager, highlightManager, clientBlockListManager, emoticons, vcardManager, chattables) {

+ }

+ MUCBookmarkManager* getBookmarkManager() {

+ return mucBookmarkManager_;

+ }

+};

+

+ CPPUNIT_TEST(testAutoJoinBookmarksAndChattables);

+ CPPUNIT_TEST(testJoinNoAutojoinBookmark);

+ CPPUNIT_TEST(testJoinAndBookmarkMUC);

+ CPPUNIT_TEST(testReceivingNoBookmarks);

+ CPPUNIT_TEST(testReceivingNullBookmarks);

+ CPPUNIT_TEST(testReceivingBookmarksError);

+ notifier_ = std::make_unique<DummyNotifier>();

+ chattables_ = std::make_unique<Chattables>();

+ manager_ = new ExtendedChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, joinMUCWindowFactory_, nickResolver_, presenceOracle_, directedPresenceSender_, uiEventStream_, chatListWindowFactory_, true, timerFactory_, mucRegistry_, entityCapsProvider_, mucManager_, mucSearchWindowFactory_, profileSettings_, ftOverview_, xmppRoster_, false, settings_, nullptr, wbManager_, highlightManager_, clientBlockListManager_, emoticons_, vcardManager_, *chattables_);

+ auto sendMessageStanza = stanzaChannel_->getStanzaAtIndex<Message>(3);

+ // Check the MUC security marking request

+ auto mucInfoRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[2]);

+ CPPUNIT_ASSERT(mucInfoRequest);

+

+ auto mucJoinPresence = std::dynamic_pointer_cast<Presence>(stanzaChannel_->sentStanzas[3]);

+ std::shared_ptr<Storage> createBookmarkStorageWithJID(std::shared_ptr<IQ> bookmarkRequest, const JID& jid, const bool autojoin) {

+ auto roomsStorage = std::make_shared<Storage>();

+ if (jid.isValid()) {

+ auto room = Storage::Room();

+ room.jid = jid;

+ room.autoJoin = autojoin;

+ roomsStorage->addRoom(room);

+ }

+ return roomsStorage;

+ }

+

+ void testReceivingBookmarksWithDomainJID() {

+ auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ std::make_shared<PrivateStorage>(createBookmarkStorageWithJID(bookmarkRequest, "montague.lit", true))

+ auto response = IQ::createResult(

+ bookmarkRequest->getFrom(),

+ bookmarkRequest->getTo(),

+ bookmarkRequest->getID(),

+ std::make_shared<PrivateStorage>(createBookmarkStorageWithJID(bookmarkRequest, "example@montague.lit", true))

+ );

+ stanzaChannel_->onIQReceived(response);

+ }

+ void testReceivingNoBookmarks() {

+ auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ std::make_shared<PrivateStorage>()

+ );

+ stanzaChannel_->onIQReceived(response);

+ }

+

+ void testReceivingNullBookmarks() {

+ auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ auto response = IQ::createResult(

+ bookmarkRequest->getFrom(),

+ bookmarkRequest->getTo(),

+ bookmarkRequest->getID(),

+ nullptr

+ );

+ stanzaChannel_->onIQReceived(response);

+ }

+

+ void testReceivingBookmarksError() {

+ auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ auto response = IQ::createError(

+ bookmarkRequest->getFrom(),

+ bookmarkRequest->getTo(),

+ bookmarkRequest->getID(),

+ ErrorPayload::Condition::ServiceUnavailable,

+ ErrorPayload::Type::Cancel,

+ nullptr

+ auto response = IQ::createResult(

+ bookmarkRequest->getFrom(),

+ bookmarkRequest->getTo(),

+ bookmarkRequest->getID(),

+ std::make_shared<PrivateStorage>(createBookmarkStorageWithJID(bookmarkRequest, "example@montague.lit/someresource", true))

+ );

+ stanzaChannel_->onIQReceived(response);

+ }

+ void testAutoJoinBookmarksAndChattables() {

+ auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ auto roomsStorage = createBookmarkStorageWithJID(bookmarkRequest, "autojoin@bookmark.lit", true);

+ auto room = Storage::Room();

+ room.jid = "noAutojoin@bookmark.lit";

+ roomsStorage->addRoom(room);

+

+ //Only autojoin@bookmark.lit window should open.

+ MockChatWindow* autojoinBookmarkWindow = new MockChatWindow();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID("autojoin@bookmark.lit"), uiEventStream_).Return(autojoinBookmarkWindow);

+ std::make_shared<PrivateStorage>(roomsStorage)

+ //Both bookmarks should be added to the chattables.

+ CPPUNIT_ASSERT_EQUAL(size_t(2), chattables_->get().size());

+ auto autoJoinState = chattables_->getState("autojoin@bookmark.lit");

+ CPPUNIT_ASSERT(autoJoinState.type == Chattables::State::Type::Room);

+ CPPUNIT_ASSERT_EQUAL(autoJoinState.status, StatusShow::Online);

+ auto noAutoJoinState = chattables_->getState("noAutojoin@bookmark.lit");

+ CPPUNIT_ASSERT(noAutoJoinState.type == Chattables::State::Type::Room);

+ CPPUNIT_ASSERT_EQUAL(noAutoJoinState.status, StatusShow::None);

+ }

+

+ void testJoinNoAutojoinBookmark() {

+

+ auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ auto roomsStorage = createBookmarkStorageWithJID(bookmarkRequest, "example@montague.lit", false);

+

+ auto response = IQ::createResult(

+ bookmarkRequest->getFrom(),

+ bookmarkRequest->getTo(),

+ bookmarkRequest->getID(),

+ std::make_shared<PrivateStorage>(roomsStorage)

+ );

+ stanzaChannel_->onIQReceived(response);

+

+ //Join previous bookmarked room, expecting no increase in chattables and change of autojoin in bookmark to true

+ MockChatWindow* newExampleChatWindow = new MockChatWindow();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID("example@montague.lit"), uiEventStream_).Return(newExampleChatWindow);

+ uiEventStream_->send(std::make_shared<JoinMUCUIEvent>("example@montague.lit", boost::optional<std::string>(), boost::optional<std::string>()));

+ CPPUNIT_ASSERT_EQUAL(size_t(1), chattables_->get().size());

+ auto state = chattables_->getState("example@montague.lit");

+ CPPUNIT_ASSERT(state.type == Chattables::State::Type::Room);

+ CPPUNIT_ASSERT_EQUAL(state.status, StatusShow::Online);

+

+ auto bookmarks = manager_->getBookmarkManager()->getBookmarks();

+ CPPUNIT_ASSERT_EQUAL(bookmarks.size(), size_t(1));

+ CPPUNIT_ASSERT(bookmarks[0].getRoom() == JID("example@montague.lit"));

+ CPPUNIT_ASSERT(bookmarks[0].getAutojoin());

+ }

+

+ void testJoinAndBookmarkMUC() {

+ auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ auto roomsStorage = createBookmarkStorageWithJID(bookmarkRequest, "", true);

+ auto response = IQ::createResult(

+ bookmarkRequest->getFrom(),

+ bookmarkRequest->getTo(),

+ bookmarkRequest->getID(),

+ std::make_shared<PrivateStorage>(roomsStorage)

+ );

+ stanzaChannel_->onIQReceived(response);

+

+ //Join non-bookmarked room expecting for the room to get bookmarked with autojoin to true

+ MockChatWindow* exampleChatWindow = new MockChatWindow();

+ mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With("example@montague.lit", uiEventStream_).Return(exampleChatWindow);

+ uiEventStream_->send(std::make_shared<JoinMUCUIEvent>("example@montague.lit", boost::optional<std::string>(), boost::optional<std::string>()));

+ {

+ CPPUNIT_ASSERT_EQUAL(size_t(1), chattables_->get().size());

+ auto state = chattables_->getState("example@montague.lit");

+ CPPUNIT_ASSERT(state.type == Chattables::State::Type::Room);

+ CPPUNIT_ASSERT_EQUAL(state.status, StatusShow::Online);

+

+ auto bookmarks = manager_->getBookmarkManager()->getBookmarks();

+ CPPUNIT_ASSERT_EQUAL(bookmarks.size(), size_t(1));

+ CPPUNIT_ASSERT(bookmarks[0].getRoom() == JID("example@montague.lit"));

+ CPPUNIT_ASSERT(bookmarks[0].getAutojoin());

+

+ }

+ //Exiting room that is bookmarked, expecting chattable to stay but bookmark autojoin change to false.

+ exampleChatWindow->onClosed();

+ {

+ CPPUNIT_ASSERT_EQUAL(size_t(1), chattables_->get().size());

+ auto bookmarks = manager_->getBookmarkManager()->getBookmarks();

+ CPPUNIT_ASSERT_EQUAL(bookmarks.size(), size_t(1));

+ CPPUNIT_ASSERT(bookmarks[0].getRoom() == JID("example@montague.lit"));

+ CPPUNIT_ASSERT(!bookmarks[0].getAutojoin());

+ }

+ ExtendedChatsManager* manager_;

+ std::unique_ptr<Chattables> chattables_;

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <gtest/gtest.h>

+#include <hippomocks.h>

+

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

+

+// Clang wrongly things that tests for 0 are using 0 as null.

+#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"

+

+using namespace Swift;

+

+class ChattablesTest : public ::testing::Test {

+ protected:

+ void SetUp() {

+ beginListSize_ = 0;

+ endListSize_ = 0;

+ callsToBegin_ = 0;

+ callsToEnd_ = 0;

+ }

+

+ void TearDown() {

+ }

+

+ void updateBeginListSize(int listSize);

+ void updateEndListSize();

+

+ Chattables chattables_;

+ int beginListSize_;

+ int endListSize_;

+ int callsToBegin_;

+ int callsToEnd_;

+};

+

+void ChattablesTest::updateBeginListSize(int listSize) {

+ beginListSize_ = listSize;

+ callsToBegin_++;

+}

+

+void ChattablesTest::updateEndListSize() {

+ endListSize_ = chattables_.get().size();

+ callsToEnd_++;

+}

+

+TEST_F(ChattablesTest, testAddJID) {

+ chattables_.onBeginAdd.connect([this](int listSize){ updateBeginListSize(listSize); });

+ chattables_.onAdded.connect([this](){ updateEndListSize(); });

+ JID jid("user@swift.jid");

+

+ chattables_.addJID(jid, Chattables::State::Type::Person);

+ ASSERT_EQ(0, beginListSize_);

+ ASSERT_EQ(1, endListSize_);

+ ASSERT_EQ(1, callsToBegin_);

+ ASSERT_EQ(1, callsToEnd_);

+

+ ASSERT_EQ(jid, chattables_.get()[0]);

+ Chattables::State state = chattables_.getState(jid);

+ ASSERT_EQ(jid, state.jid);

+ ASSERT_EQ(Chattables::State::Type::Person, state.type);

+}

+

+TEST_F(ChattablesTest, testAddMultipleJIDs) {

+ chattables_.onBeginAdd.connect([this](int listSize){ updateBeginListSize(listSize); });

+ chattables_.onAdded.connect([this](){ updateEndListSize(); });

+ JID jid0("user0@swift.jid");

+ JID jid1("user1@swift.jid");

+ JID jid2("user2@swift.jid");

+

+ chattables_.addJID(jid0, Chattables::State::Type::Person);

+ ASSERT_EQ(0, beginListSize_);

+ ASSERT_EQ(1, endListSize_);

+ ASSERT_EQ(1, callsToBegin_);

+ ASSERT_EQ(1, callsToEnd_);

+ chattables_.addJID(jid1, Chattables::State::Type::Person);

+ ASSERT_EQ(1, beginListSize_);

+ ASSERT_EQ(2, endListSize_);

+ ASSERT_EQ(2, callsToBegin_);

+ ASSERT_EQ(2, callsToEnd_);

+ chattables_.addJID(jid2, Chattables::State::Type::Person);

+ ASSERT_EQ(2, beginListSize_);

+ ASSERT_EQ(3, endListSize_);

+ ASSERT_EQ(3, callsToBegin_);

+ ASSERT_EQ(3, callsToEnd_);

+}

+

+TEST_F(ChattablesTest, testAddRoomJID) {

+ chattables_.onBeginAdd.connect([this](int listSize){ updateBeginListSize(listSize); });

+ chattables_.onAdded.connect([this](){ updateEndListSize(); });

+ JID jid("room@swift.jid");

+

+ chattables_.addJID(jid, Chattables::State::Type::Room);

+ ASSERT_EQ(0, beginListSize_);

+ ASSERT_EQ(1, endListSize_);

+ ASSERT_EQ(1, callsToBegin_);

+ ASSERT_EQ(1, callsToEnd_);

+

+ ASSERT_EQ(jid, chattables_.get()[0]);

+ Chattables::State state = chattables_.getState(jid);

+ ASSERT_EQ(jid, state.jid);

+ ASSERT_EQ(Chattables::State::Type::Room, state.type);

+}

+

+TEST_F(ChattablesTest, testSetState) {

+ JID jid("user@swift.jid");

+ chattables_.addJID(jid, Chattables::State::Type::Person);

+ ASSERT_EQ(1, chattables_.get().size());

+ ASSERT_EQ(jid, chattables_.get()[0]);

+ ASSERT_EQ(Chattables::State::Type::Person, chattables_.getState(jid).type);

+ ASSERT_EQ(StatusShow::None, chattables_.getState(jid).status);

+

+ JID returnedJID;

+ int returnedIndex;

+ int callsToChanged = 0;

+ chattables_.onChanged.connect([&returnedJID, &returnedIndex, &callsToChanged](const JID& jid, int index){

+ returnedJID = jid;

+ returnedIndex = index;

+ callsToChanged++;

+ });

+

+ Chattables::State newState;

+ newState.jid = jid;

+ newState.type = Chattables::State::Type::Room;

+ newState.status = StatusShow::Online;

+ chattables_.setState(jid, newState);

+

+ auto storedState = chattables_.getState(jid);

+

+ ASSERT_EQ(1, chattables_.get().size());

+ ASSERT_EQ(jid, chattables_.get()[0]);

+ ASSERT_EQ(jid, returnedJID);

+ ASSERT_EQ(0, returnedIndex);

+ ASSERT_EQ(1, callsToChanged);

+ ASSERT_EQ(jid, storedState.jid);

+ ASSERT_EQ(Chattables::State::Type::Room, storedState.type);

+ ASSERT_EQ(StatusShow::Online, storedState.status);

+}

+ * Copyright (c) 2010-2018 Isode Limited.

+#include <memory>

+

+#include <gtest/gtest.h>

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

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

+// Clang wrongly things that tests for 0 are using 0 as null.

+#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"

+

+class MUCControllerTest : public ::testing::Test {

+

+ protected:

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

+ chatMessageParser_ = std::make_shared<ChatMessageParser>(std::map<std::string, std::string>(), highlightManager_->getConfiguration(), ChatMessageParser::Mode::GroupChat);

+ vcardStorage_ = new VCardMemoryStorage(crypto_.get());

+ vcardManager_ = new VCardManager(self_, iqRouter_, vcardStorage_);

+ nickResolver_ = new NickResolver(self_, xmppRoster_, vcardManager_, mucRegistry_);

+ clientBlockListManager_ = new ClientBlockListManager(iqRouter_);

+ mucBookmarkManager_ = new MUCBookmarkManager(iqRouter_);

+ chattables_ = std::make_unique<Chattables>();

+ controller_ = new MUCController (self_, muc_, boost::optional<std::string>(), nick_, stanzaChannel_, iqRouter_, chatWindowFactory_, nickResolver_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory, eventController_, entityCapsProvider_, nullptr, nullptr, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser_, false, nullptr, vcardManager_, mucBookmarkManager_, settings_, *chattables_);

+ }

+ void TearDown() {

+ delete controller_;

+ delete mucBookmarkManager_;

+ delete clientBlockListManager_;

+ delete nickResolver_;

+ delete vcardManager_;

+ delete vcardStorage_;

+ delete highlightManager_;

+ delete settings_;

+ delete entityCapsProvider_;

+ delete eventController_;

+ delete presenceOracle_;

+ delete xmppRoster_;

+ delete mocks_;

+ delete uiEventStream_;

+ delete stanzaChannel_;

+ delete presenceSender_;

+ delete directedPresenceSender_;

+ delete iqRouter_;

+ delete iqChannel_;

+ delete mucRegistry_;

+ delete avatarManager_;

+ }

+ void finishJoin() {

+ Presence::ref presence(new Presence());

+ presence->setFrom(JID(muc_->getJID().toString() + "/" + nick_));

+ MUCUserPayload::ref status(new MUCUserPayload());

+ MUCUserPayload::StatusCode code;

+ code.code = 110;

+ status->addStatusCode(code);

+ presence->addPayload(status);

+ stanzaChannel_->onPresenceReceived(presence);

+ }

+ void joinCompleted() {

+ std::string messageBody("test message");

+ window_->onSendMessageRequest(messageBody, false);

+ std::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ Message::ref message = std::dynamic_pointer_cast<Message>(rawStanza);

+ ASSERT_TRUE(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */

+ ASSERT_TRUE(message);

+ ASSERT_EQ(messageBody, message->getBody().get_value_or(""));

+

+ {

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

+

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

+ }

+ }

+ void checkEqual(const std::vector<NickJoinPart>& expected, const std::vector<NickJoinPart>& actual) {

+ ASSERT_EQ(expected.size(), actual.size());

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

+ ASSERT_EQ(expected[i].nick, actual[i].nick);

+ ASSERT_EQ(expected[i].type, actual[i].type);

+ }

+ }

+

+ JID jidFromOccupant(const MUCOccupant& occupant) {

+ return JID(mucJID_.toString()+"/"+occupant.getNick());

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

+ ASSERT_TRUE(child);

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

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

+ ASSERT_TRUE(item);

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

+ ASSERT_TRUE(occupant != occupants.end());

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

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

+ }

+ }

+ }

+ void setMUCSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue, const bool includeFormTypeField = true) {

+ auto form = std::make_shared<Form>(Form::Type::ResultType);

+ if (includeFormTypeField) {

+ std::shared_ptr<FormField> formTypeField = std::make_shared<FormField>(FormField::Type::HiddenType, "http://jabber.org/protocol/muc#roominfo");

+ formTypeField->setName("FORM_TYPE");

+ form->addField(formTypeField);

+ }

+ auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, markingValue);

+ auto markingForegroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, markingForegroundColorValue);

+ auto markingBackgroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, markingBackgroundColorValue);

+ markingField->setName("x-isode#roominfo_marking");

+ markingForegroundColorField->setName("x-isode#roominfo_marking_fg_color");

+ markingBackgroundColorField->setName("x-isode#roominfo_marking_bg_color");

+ form->addField(markingField);

+ form->addField(markingForegroundColorField);

+ form->addField(markingBackgroundColorField);

+ auto discoInfoRef = std::make_shared<DiscoInfo>();

+ discoInfoRef->addExtension(form);

+ auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);

+ iqChannel_->onIQReceived(infoResponse);

+ }

+

+ Message::ref createTestMessageWithoutSecurityLabel() {

+ auto message = std::make_shared<Message>();

+ message->setType(Message::Type::Groupchat);

+ message->setID("test-id");

+ message->setTo(self_);

+ message->setFrom(mucJID_.withResource("TestNickname"));

+ message->setBody("Do Not Read This Message");

+ return message;

+ }

+

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

+ XMPPRoster* xmppRoster_;

+ std::unique_ptr<Chattables> chattables_;

+};

+

+TEST_F(MUCControllerTest, testAddressedToSelf) {

+ finishJoin();

+ Message::ref message(new Message());

+

+ message = Message::ref(new Message());

+ message->setFrom(JID(muc_->getJID().toString() + "/otherperson"));

+ message->setBody("basic " + nick_ + " test.");

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

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+ ASSERT_EQ(1, eventController_->getEvents().size());

+

+ message = Message::ref(new Message());

+ message->setFrom(JID(muc_->getJID().toString() + "/otherperson"));

+ message->setBody(nick_ + ": hi there");

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

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+ ASSERT_EQ(2, eventController_->getEvents().size());

+

+ message->setFrom(JID(muc_->getJID().toString() + "/other"));

+ message->setBody("Hi there " + nick_);

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

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+ ASSERT_EQ(3, eventController_->getEvents().size());

+

+ message = Message::ref(new Message());

+ message->setFrom(JID(muc_->getJID().toString() + "/other2"));

+ message->setBody("Hi " + boost::to_lower_copy(nick_) + ".");

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

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+

+ // The last message is ignored because self-mention highlights are matched case

+ // sensitive against the nickname.

+ ASSERT_EQ(3, eventController_->getEvents().size());

+

+ message = Message::ref(new Message());

+ message->setFrom(JID(muc_->getJID().toString() + "/other3"));

+ message->setBody("Hi bert.");

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

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+ ASSERT_EQ(3, eventController_->getEvents().size());

+

+ message = Message::ref(new Message());

+ message->setFrom(JID(muc_->getJID().toString() + "/other2"));

+ message->setBody("Hi " + boost::to_lower_copy(nick_) + "ie.");

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

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+ ASSERT_EQ(3, eventController_->getEvents().size());

+}

+

+TEST_F(MUCControllerTest, testNotAddressedToSelf) {

+ finishJoin();

+ Message::ref message(new Message());

+ message->setFrom(JID(muc_->getJID().toString() + "/other3"));

+ message->setBody("Hi there Hatter");

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

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+ ASSERT_EQ(0, eventController_->getEvents().size());

+}

+

+TEST_F(MUCControllerTest, testAddressedToSelfBySelf) {

+ finishJoin();

+ Message::ref message(new Message());

+ message->setFrom(JID(muc_->getJID().toString() + "/" + nick_));

+ message->setBody("Hi there " + nick_);

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

+ controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

+ ASSERT_EQ(0, eventController_->getEvents().size());

+}

+

+TEST_F(MUCControllerTest, testMessageWithEmptyLabelItem) {

+ SecurityLabelsCatalog::Item label;

+ label.setSelector("Bob");

+ window_->label_ = label;

+ std::shared_ptr<DiscoInfo> features = std::make_shared<DiscoInfo>();

+ features->addFeature(DiscoInfo::SecurityLabelsCatalogFeature);

+ controller_->setAvailableServerFeatures(features);

+ IQ::ref iq = iqChannel_->iqs_[iqChannel_->iqs_.size() - 1];

+ SecurityLabelsCatalog::ref labelPayload = std::make_shared<SecurityLabelsCatalog>();

+ labelPayload->addItem(label);

+ IQ::ref result = IQ::createResult(self_, iq->getID(), labelPayload);

+ iqChannel_->onIQReceived(result);

+ std::string messageBody("agamemnon");

+ window_->onSendMessageRequest(messageBody, false);

+ std::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ Message::ref message = std::dynamic_pointer_cast<Message>(rawStanza);

+ ASSERT_EQ(iq->getTo(), result->getFrom());

+ ASSERT_TRUE(window_->labelsEnabled_);

+ ASSERT_TRUE(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */

+ ASSERT_TRUE(message);

+ ASSERT_EQ(messageBody, message->getBody().get());

+ ASSERT_FALSE(message->getPayload<SecurityLabel>());

+}

+

+TEST_F(MUCControllerTest, testMessageWithLabelItem) {

+ std::shared_ptr<SecurityLabel> label = std::make_shared<SecurityLabel>();

+ label->setLabel("a");

+ SecurityLabelsCatalog::Item labelItem;

+ labelItem.setSelector("Bob");

+ labelItem.setLabel(label);

+ window_->label_ = labelItem;

+ std::shared_ptr<DiscoInfo> features = std::make_shared<DiscoInfo>();

+ features->addFeature(DiscoInfo::SecurityLabelsCatalogFeature);

+ controller_->setAvailableServerFeatures(features);

+ IQ::ref iq = iqChannel_->iqs_[iqChannel_->iqs_.size() - 1];

+ SecurityLabelsCatalog::ref labelPayload = std::make_shared<SecurityLabelsCatalog>();

+ labelPayload->addItem(labelItem);

+ IQ::ref result = IQ::createResult(self_, iq->getID(), labelPayload);

+ iqChannel_->onIQReceived(result);

+ std::string messageBody("agamemnon");

+ window_->onSendMessageRequest(messageBody, false);

+ std::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ Message::ref message = std::dynamic_pointer_cast<Message>(rawStanza);

+ ASSERT_EQ(iq->getTo(), result->getFrom());

+ ASSERT_TRUE(window_->labelsEnabled_);

+ ASSERT_TRUE(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */

+ ASSERT_TRUE(message);

+ ASSERT_EQ(messageBody, message->getBody().get());

+ ASSERT_EQ(label, message->getPayload<SecurityLabel>());

+}

+

+TEST_F(MUCControllerTest, testCorrectMessageWithLabelItem) {

+ std::shared_ptr<SecurityLabel> label = std::make_shared<SecurityLabel>();

+ label->setLabel("a");

+ SecurityLabelsCatalog::Item labelItem;

+ labelItem.setSelector("Bob");

+ labelItem.setLabel(label);

+ std::shared_ptr<SecurityLabel> label2 = std::make_shared<SecurityLabel>();

+ label->setLabel("b");

+ SecurityLabelsCatalog::Item labelItem2;

+ labelItem2.setSelector("Charlie");

+ labelItem2.setLabel(label2);

+ window_->label_ = labelItem;

+ std::shared_ptr<DiscoInfo> features = std::make_shared<DiscoInfo>();

+ features->addFeature(DiscoInfo::SecurityLabelsCatalogFeature);

+ controller_->setAvailableServerFeatures(features);

+ IQ::ref iq = iqChannel_->iqs_[iqChannel_->iqs_.size() - 1];

+ SecurityLabelsCatalog::ref labelPayload = std::make_shared<SecurityLabelsCatalog>();

+ labelPayload->addItem(labelItem);

+ IQ::ref result = IQ::createResult(self_, iq->getID(), labelPayload);

+ iqChannel_->onIQReceived(result);

+ std::string messageBody("agamemnon");

+ window_->onSendMessageRequest(messageBody, false);

+ std::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ Message::ref message = std::dynamic_pointer_cast<Message>(rawStanza);

+ ASSERT_EQ(iq->getTo(), result->getFrom());

+ ASSERT_TRUE(window_->labelsEnabled_);

+ ASSERT_TRUE(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */

+ ASSERT_TRUE(message);

+ ASSERT_EQ(messageBody, message->getBody().get());

+ ASSERT_EQ(label, message->getPayload<SecurityLabel>());

+ window_->label_ = labelItem2;

+ window_->onSendMessageRequest(messageBody, true);

+ rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ message = std::dynamic_pointer_cast<Message>(rawStanza);

+ ASSERT_EQ(messageBody, message->getBody().get());

+ ASSERT_EQ(label, message->getPayload<SecurityLabel>());

+}

+

+TEST_F(MUCControllerTest, testAppendToJoinParts) {

+ std::vector<NickJoinPart> list;

+ std::vector<NickJoinPart> gold;

+ MUCController::appendToJoinParts(list, NickJoinPart("Kev", Join));

+ gold.push_back(NickJoinPart("Kev", Join));

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Remko", Join));

+ gold.push_back(NickJoinPart("Remko", Join));

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Bert", Join));

+ gold.push_back(NickJoinPart("Bert", Join));

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Bert", Part));

+ gold[2].type = JoinThenPart;

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Kev", Part));

+ gold[0].type = JoinThenPart;

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Remko", Part));

+ gold[1].type = JoinThenPart;

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Ernie", Part));

+ gold.push_back(NickJoinPart("Ernie", Part));

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Ernie", Join));

+ gold[3].type = PartThenJoin;

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Kev", Join));

+ gold[0].type = Join;

+ checkEqual(gold, list);

+ MUCController::appendToJoinParts(list, NickJoinPart("Ernie", Part));

+ gold[3].type = Part;

+ checkEqual(gold, list);

+

+}

+

+TEST_F(MUCControllerTest, testJoinPartStringContructionSimple) {

+ std::vector<NickJoinPart> list;

+ list.push_back(NickJoinPart("Kev", Join));

+ ASSERT_EQ(std::string("Kev has entered the room"), MUCController::generateJoinPartString(list, false));

+ list.push_back(NickJoinPart("Remko", Part));

+ ASSERT_EQ(std::string("Kev has entered the room and Remko has left the room"), MUCController::generateJoinPartString(list, false));

+ list.push_back(NickJoinPart("Bert", Join));

+ ASSERT_EQ(std::string("Kev and Bert have entered the room and Remko has left the room"), MUCController::generateJoinPartString(list, false));

+ list.push_back(NickJoinPart("Ernie", Join));

+ ASSERT_EQ(std::string("Kev, Bert and Ernie have entered the room and Remko has left the room"), MUCController::generateJoinPartString(list, false));

+}

+

+TEST_F(MUCControllerTest, testJoinPartStringContructionMixed) {

+ std::vector<NickJoinPart> list;

+ list.push_back(NickJoinPart("Kev", JoinThenPart));

+ ASSERT_EQ(std::string("Kev has entered then left the room"), MUCController::generateJoinPartString(list, false));

+ list.push_back(NickJoinPart("Remko", Part));

+ ASSERT_EQ(std::string("Remko has left the room and Kev has entered then left the room"), MUCController::generateJoinPartString(list, false));

+ list.push_back(NickJoinPart("Bert", PartThenJoin));

+ ASSERT_EQ(std::string("Remko has left the room, Kev has entered then left the room and Bert has left then returned to the room"), MUCController::generateJoinPartString(list, false));

+ list.push_back(NickJoinPart("Ernie", JoinThenPart));

+ ASSERT_EQ(std::string("Remko has left the room, Kev and Ernie have entered then left the room and Bert has left then returned to the room"), MUCController::generateJoinPartString(list, false));

+}

+

+TEST_F(MUCControllerTest, testRoleAffiliationStates) {

+

+ typedef std::map<std::string, MUCOccupant> occupant_map;

+ occupant_map occupants;

+ occupants.insert(occupant_map::value_type("Kev", MUCOccupant("Kev", MUCOccupant::Participant, MUCOccupant::Owner)));

+ occupants.insert(occupant_map::value_type("Remko", MUCOccupant("Remko", MUCOccupant::Participant, MUCOccupant::Owner)));

+ occupants.insert(occupant_map::value_type("Bert", MUCOccupant("Bert", MUCOccupant::Participant, MUCOccupant::Owner)));

+ occupants.insert(occupant_map::value_type("Ernie", MUCOccupant("Ernie", MUCOccupant::Participant, MUCOccupant::Owner)));

+

+ /* populate the MUC with fake users */

+ for (auto&& occupant : occupants) {

+ muc_->insertOccupant(occupant.second);

+ std::vector<MUCOccupant> alterations;

+ alterations.push_back(MUCOccupant("Kev", MUCOccupant::Visitor, MUCOccupant::Admin));

+ alterations.push_back(MUCOccupant("Remko", MUCOccupant::Moderator, MUCOccupant::Member));

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

+ alterations.push_back(MUCOccupant("Ernie", MUCOccupant::NoRole, MUCOccupant::Member));

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

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

+}

+

+TEST_F(MUCControllerTest, testSubjectChangeCorrect) {

+ joinCompleted();

+ {

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

+ message->setTo(self_);

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

+ message->setID("3FB99C56-7C92-4755-91B0-9C0098BC7AE0");

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

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

+ ASSERT_EQ(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.

+ */

+TEST_F(MUCControllerTest, 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));

+ ASSERT_EQ(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.

+ */

+TEST_F(MUCControllerTest, testSubjectChangeIncorrectB) {

+ 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->addPayload(std::make_shared<Thread>("Thread that prevents the subject change."));

+

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

+ ASSERT_EQ(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 empty body element do not cause a subject change.

+ */

+TEST_F(MUCControllerTest, testSubjectChangeIncorrectC) {

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

+

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

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

+}

+

+TEST_F(MUCControllerTest, testHandleOccupantNicknameChanged) {

+ const auto occupantCount = [&](const std::string & nick) {

+ auto roster = window_->getRosterModel();

+ const auto currentOccupantsJIDs = roster->getJIDs();

+ int count = 0;

+ for (auto & p : currentOccupantsJIDs) {

+ if (p.getResource() == nick) {

+ ++count;

+ }

+ }

+ return count;

+ };

+

+ muc_->insertOccupant(MUCOccupant("TestUserOne", MUCOccupant::Participant, MUCOccupant::Owner));

+ muc_->insertOccupant(MUCOccupant("TestUserTwo", MUCOccupant::Participant, MUCOccupant::Owner));

+ muc_->insertOccupant(MUCOccupant("TestUserThree", MUCOccupant::Participant, MUCOccupant::Owner));

+

+ muc_->onOccupantNicknameChanged("TestUserOne", "TestUserTwo");

+

+ ASSERT_EQ(0, occupantCount("TestUserOne"));

+ ASSERT_EQ(1, occupantCount("TestUserTwo"));

+ ASSERT_EQ(1, occupantCount("TestUserThree"));

+}

+

+TEST_F(MUCControllerTest, testHandleOccupantNicknameChangedRoster) {

+ const auto occupantCount = [&](const std::string & nick) {

+ auto roster = window_->getRosterModel();

+ const auto participants = roster->getGroup("Participants");

+ const auto displayedParticipants = participants->getDisplayedChildren();

+ int count = 0;

+ for (auto & p : displayedParticipants) {

+ if (p->getDisplayName() == nick) {

+ ++count;

+ }

+ }

+ return count;

+ };

+

+ muc_->insertOccupant(MUCOccupant("TestUserOne", MUCOccupant::Participant, MUCOccupant::Owner));

+ muc_->insertOccupant(MUCOccupant("TestUserTwo", MUCOccupant::Participant, MUCOccupant::Owner));

+ muc_->insertOccupant(MUCOccupant("TestUserThree", MUCOccupant::Participant, MUCOccupant::Owner));

+ ASSERT_EQ(1, occupantCount("TestUserOne"));

+ ASSERT_EQ(1, occupantCount("TestUserTwo"));

+ ASSERT_EQ(1, occupantCount("TestUserThree"));

+

+ muc_->onOccupantNicknameChanged("TestUserOne", "TestUserTwo");

+

+ ASSERT_EQ(0, occupantCount("TestUserOne"));

+ ASSERT_EQ(1, occupantCount("TestUserTwo"));

+ ASSERT_EQ(1, occupantCount("TestUserThree"));

+}

+

+TEST_F(MUCControllerTest, testHandleChangeSubjectRequest) {

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

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

+ window_->onChangeSubjectRequest(testStr);

+ ASSERT_EQ(testStr, muc_->newSubjectSet_);

+}

+

+TEST_F(MUCControllerTest, testNonImpromptuMUCWindowTitle) {

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

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingRequestCompleteMarking) {

+ setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red", true);

+

+ ASSERT_EQ(std::string("Test|Highest Possible Security"), window_->markingValue_);

+ ASSERT_EQ(std::string("Black"), window_->markingForegroundColorValue_);

+ ASSERT_EQ(std::string("Red"), window_->markingBackgroundColorValue_);

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingRequestCompleteMarkingWithExtraForm) {

+ auto formTypeField = std::make_shared<FormField>(FormField::Type::HiddenType, "http://jabber.org/protocol/muc#roominfo");

+ auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Test|Highest Possible Security");

+ auto markingForegroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Black");

+ auto markingBackgroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Red");

+ formTypeField->setName("FORM_TYPE");

+ markingField->setName("x-isode#roominfo_marking");

+ markingForegroundColorField->setName("x-isode#roominfo_marking_fg_color");

+ markingBackgroundColorField->setName("x-isode#roominfo_marking_bg_color");

+

+ auto extraForm = std::make_shared<Form>(Form::Type::ResultType);

+ auto form = std::make_shared<Form>(Form::Type::ResultType);

+ form->addField(formTypeField);

+ form->addField(markingField);

+ form->addField(markingForegroundColorField);

+ form->addField(markingBackgroundColorField);

+

+ auto discoInfoRef = std::make_shared<DiscoInfo>();

+ discoInfoRef->addExtension(extraForm);

+ discoInfoRef->addExtension(form);

+

+ auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);

+ iqChannel_->onIQReceived(infoResponse);

+ ASSERT_EQ(std::string("Test|Highest Possible Security"), window_->markingValue_);

+ ASSERT_EQ(std::string("Black"), window_->markingForegroundColorValue_);

+ ASSERT_EQ(std::string("Red"), window_->markingBackgroundColorValue_);

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingRequestNoColorsInMarking) {

+ auto formTypeField = std::make_shared<FormField>(FormField::Type::HiddenType, "http://jabber.org/protocol/muc#roominfo");

+ auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Test|Highest Possible Security");

+ auto markingForegroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "");

+ auto markingBackgroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "");

+ formTypeField->setName("FORM_TYPE");

+ markingField->setName("x-isode#roominfo_marking");

+ markingForegroundColorField->setName("x-isode#roominfo_marking_fg_color");

+ markingBackgroundColorField->setName("x-isode#roominfo_marking_bg_color");

+

+ auto form = std::make_shared<Form>(Form::Type::ResultType);

+ form->addField(formTypeField);

+ form->addField(markingField);

+ form->addField(markingForegroundColorField);

+ form->addField(markingBackgroundColorField);

+

+ auto discoInfoRef = std::make_shared<DiscoInfo>();

+ discoInfoRef->addExtension(form);

+

+ auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);

+ iqChannel_->onIQReceived(infoResponse);

+ ASSERT_EQ(std::string("Test|Highest Possible Security"), window_->markingValue_);

+ ASSERT_EQ(std::string("Black"), window_->markingForegroundColorValue_);

+ ASSERT_EQ(std::string("White"), window_->markingBackgroundColorValue_);

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingRequestEmptyMarking) {

+ setMUCSecurityMarking("", "", "", true);

+

+ ASSERT_EQ(std::string(""), window_->markingValue_);

+ ASSERT_EQ(std::string(""), window_->markingForegroundColorValue_);

+ ASSERT_EQ(std::string(""), window_->markingBackgroundColorValue_);

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingRequestWithMarkingNoFormType) {

+ setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red", false);

+

+ ASSERT_EQ(std::string(""), window_->markingValue_);

+ ASSERT_EQ(std::string(""), window_->markingForegroundColorValue_);

+ ASSERT_EQ(std::string(""), window_->markingBackgroundColorValue_);

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingRequestNoMarking) {

+ auto form = std::make_shared<Form>(Form::Type::ResultType);

+

+ auto discoInfoRef = std::make_shared<DiscoInfo>();

+ discoInfoRef->addExtension(form);

+

+ auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);

+ iqChannel_->onIQReceived(infoResponse);

+ ASSERT_EQ(std::string(""), window_->markingValue_);

+ ASSERT_EQ(std::string(""), window_->markingForegroundColorValue_);

+ ASSERT_EQ(std::string(""), window_->markingBackgroundColorValue_);

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingRequestNoForm) {

+ auto discoInfoRef = std::make_shared<DiscoInfo>();

+

+ auto infoResponse = IQ::createResult( self_, mucJID_, "test-id", discoInfoRef);

+ iqChannel_->onIQReceived(infoResponse);

+ ASSERT_EQ(std::string(""), window_->markingValue_);

+ ASSERT_EQ(std::string(""), window_->markingForegroundColorValue_);

+ ASSERT_EQ(std::string(""), window_->markingBackgroundColorValue_);

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingRequestError) {

+ auto errorPayload = std::make_shared<ErrorPayload>(ErrorPayload::Condition::NotAuthorized, ErrorPayload::Type::Auth);

+

+ auto infoResponse = IQ::createResult( self_, mucJID_, "test-id", errorPayload);

+ iqChannel_->onIQReceived(infoResponse);

+ ASSERT_EQ(std::string(""), window_->markingValue_);

+ ASSERT_EQ(std::string(""), window_->markingForegroundColorValue_);

+ ASSERT_EQ(std::string(""), window_->markingBackgroundColorValue_);

+}

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_Elision_NoRoomMarkingA) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ setMUCSecurityMarking("", "Black", "Red");

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("Test|Highest Possible Security");

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+ ASSERT_EQ(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string("Test|Highest Possible Security"), storedSecurityLabel->getDisplayMarking());

+}

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_Elision_NoRoomMarkingB) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ setMUCSecurityMarking("", "Black", "Red");

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("");

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+ ASSERT_EQ(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string(""), storedSecurityLabel->getDisplayMarking());

+}

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingA) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red");

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("Test|Highest Possible Security");

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+ // Test the first message matching MUC marking. This message SHOULD have a marking

+ auto sentMessageEvent1 = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent1);

+ auto storedSecurityLabel1 = window_->lastAddedMessageSecurityLabel_;

+ ASSERT_EQ(false, storedSecurityLabel1 == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string("Test|Highest Possible Security"), storedSecurityLabel1->getDisplayMarking());

+ // Test a consecutive message matching MUC marking. This message SHOULD NOT have a marking

+ auto sentMessageEvent2 = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent2);

+ auto storedSecurityLabel2 = window_->lastAddedMessageSecurityLabel_;

+ ASSERT_EQ(false, storedSecurityLabel2 == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string(""), storedSecurityLabel2->getDisplayMarking());

+}

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingB) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ setMUCSecurityMarking("Test|Lower Security Marking", "Black", "Red");

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("Test|Highest Possible Security");

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+ ASSERT_EQ(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string("Test|Highest Possible Security"), storedSecurityLabel->getDisplayMarking());

+}

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingC) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red");

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("");

+

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+

+ ASSERT_EQ(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string("Unmarked"), storedSecurityLabel->getDisplayMarking());

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_NoElision_NoRoomMarkingA) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);

+ setMUCSecurityMarking("", "Black", "Red");

+

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("Test|Highest Possible Security");

+

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+

+ ASSERT_EQ(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string("Test|Highest Possible Security"), storedSecurityLabel->getDisplayMarking());

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_NoElision_NoRoomMarkingB) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);

+ setMUCSecurityMarking("", "Black", "Red");

+

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("");

+

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+

+ ASSERT_EQ(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string(""), storedSecurityLabel->getDisplayMarking());

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_NoElision_WithRoomMarkingA) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);

+ setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red");

+

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("Test|Highest Possible Security");

+

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+

+ // Test the first message matching MUC marking. This message SHOULD have a marking

+

+ auto sentMessageEvent1 = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent1);

+

+ auto storedSecurityLabel1 = window_->lastAddedMessageSecurityLabel_;

+

+ ASSERT_EQ(false, storedSecurityLabel1 == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string("Test|Highest Possible Security"), storedSecurityLabel1->getDisplayMarking());

+

+ // Test a consecutive message matching MUC marking. This message SHOULD ALSO have a marking

+

+ auto sentMessageEvent2 = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent2);

+

+ auto storedSecurityLabel2 = window_->lastAddedMessageSecurityLabel_;

+

+ ASSERT_EQ(false, storedSecurityLabel2 == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string("Test|Highest Possible Security"), storedSecurityLabel2->getDisplayMarking());

+}

+

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_NoElision_WithRoomMarkingB) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);

+ setMUCSecurityMarking("", "Black", "Red");

+

+ auto messageLabel = std::make_shared<SecurityLabel>();

+ messageLabel->setDisplayMarking("");

+

+ auto sentMessage = createTestMessageWithoutSecurityLabel();

+ sentMessage->addPayload(messageLabel);

+

+ auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);

+ controller_->handleIncomingMessage(sentMessageEvent);

+ auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;

+ ASSERT_EQ(false, storedSecurityLabel == nullptr);

+ // This is the potentially altered security label that is displayed on the screen

+ ASSERT_EQ(std::string(""), storedSecurityLabel->getDisplayMarking());

+}

+ void setUnreadCount(size_t /*unread*/) {}

+ * Copyright (c) 2014-2018 Isode Limited.

+ results.erase(std::remove_if(results.begin(), results.end(), [&](const Contact::ref contact) {

+ return !matchContact(search, contact);

+ }), results.end());

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

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

+

+#include <Swiften/Disco/GetDiscoItemsRequest.h>

+#include <Swiften/Elements/DiscoItems.h>

+#include <Swiften/Queries/IQRouter.h>

+#include <Swiften/Queries/PubSubRequest.h>

+

+#include <Swift/Controllers/UIEvents/FdpFormSubmitWindowOpenUIEvent.h>

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

+#include <Swift/Controllers/UIInterfaces/FdpFormSubmitWindow.h>

+#include <Swift/Controllers/UIInterfaces/FdpFormSubmitWindowFactory.h>

+

+namespace Swift {

+

+FdpFormSubmitController::FdpFormSubmitController(const JID& self, IQRouter* iqRouter, UIEventStream* uiEventStream, FdpFormSubmitWindowFactory* factory) : selfJID_(self), iqRouter_(iqRouter), uiEventStream_(uiEventStream), factory_(factory), formSubmitWindow_(nullptr) {

+ fdpFormSubmitWindowOpenUIEventConnection_= uiEventStream_->onUIEvent.connect( [this](const std::shared_ptr<UIEvent>& uiEvent){ handleUIEvent(uiEvent); });

+}

+

+FdpFormSubmitController::~FdpFormSubmitController() {

+}

+

+void FdpFormSubmitController::handleUIEvent(const std::shared_ptr<UIEvent>& uiEvent) {

+ if (auto openEvent = std::dynamic_pointer_cast<FdpFormSubmitWindowOpenUIEvent>(uiEvent)) {

+ if (formSubmitWindow_) {

+ formSubmitWindow_->raise();

+ }

+ else {

+ createFormSubmitWindow();

+ }

+ }

+}

+

+void FdpFormSubmitController::createFormSubmitWindow() {

+ formSubmitWindow_ = factory_->createFdpFormSubmitWindow();

+ formSubmitWindow_->onCloseEvent.connect([this](){ closeFormSubmitWindow(); });

+ formSubmitWindow_->onRequestPubSubNodeData.connect([this](const std::string& string){ requestPubSubNodeData(string); });

+ formSubmitWindow_->onRequestTemplateForm.connect([this](const std::string& fdpTemplateNodeName){ requestTemplateForm(fdpTemplateNodeName); });

+ formSubmitWindow_->onSubmitForm.connect([this](const std::shared_ptr<Form>& form){ submitForm(form); });

+ formSubmitWindow_->show();

+}

+

+void FdpFormSubmitController::closeFormSubmitWindow() {

+ formSubmitWindow_.reset();

+}

+

+void FdpFormSubmitController::requestPubSubNodeData(const std::string& domainName) {

+ JID domainJID(domainName);

+ auto discoItemsRequest = GetDiscoItemsRequest::create(domainJID, iqRouter_);

+ discoItemsRequest->onResponse.connect(

+ [this, domainName](std::shared_ptr<DiscoItems> discoItems, ErrorPayload::ref errorPayloadRef) {

+ if (!discoItems || errorPayloadRef) {

+ formSubmitWindow_->showNodePlaceholder(FdpFormSubmitWindow::NodeError::DomainNotFound);

+ return;

+ }

+ currentDomain_ = domainName;

+

+ bool templateNodeAdded = false;

+ formSubmitWindow_->clearNodeData();

+ auto discoItemList = discoItems->getItems();

+ for (auto discoItem : discoItemList) {

+ auto node = discoItem.getNode();

+ if (node.substr(0, 13) != "fdp/template/") {

+ continue;

+ }

+

+ std::string nodeName = discoItem.getName().empty() ? node : discoItem.getName();

+

+ formSubmitWindow_->addNode(node, nodeName);

+ templateNodeAdded = true;

+ }

+ if (!templateNodeAdded) {

+ formSubmitWindow_->showNodePlaceholder(FdpFormSubmitWindow::NodeError::NoFdpNodesInDomain);

+ }

+ }

+ );

+ discoItemsRequest->send();

+}

+

+void FdpFormSubmitController::requestTemplateForm(const std::string& nodeName) {

+ auto pubSubItems = std::make_shared<PubSubItems>(nodeName);

+ pubSubItems->setMaximumItems(1);

+ auto formRequest = std::make_shared<PubSubRequest<PubSubItems>>(IQ::Type::Get, selfJID_, currentDomain_, pubSubItems, iqRouter_);

+

+ formRequest->onResponse.connect(

+ [this, nodeName](std::shared_ptr<PubSubItems> response, ErrorPayload::ref errorPayload) {

+ if (!response || errorPayload) {

+ formSubmitWindow_->showFormPlaceholder(FdpFormSubmitWindow::TemplateError::RequestFailed);

+ return;

+ }

+ auto pubSubItemList = response->getItems();

+ if (pubSubItemList.empty()) {

+ formSubmitWindow_->showFormPlaceholder(FdpFormSubmitWindow::TemplateError::CannotLocateForm);

+ return;

+ }

+ auto payloadList = pubSubItemList[0]->getData();

+ if (payloadList.empty()) {

+ formSubmitWindow_->showFormPlaceholder(FdpFormSubmitWindow::TemplateError::CannotLocateForm);

+ return;

+ }

+ if (auto form = std::dynamic_pointer_cast<Form>(payloadList[0])) {

+ currentTemplateNode_ = nodeName;

+ formSubmitWindow_->setFormData(form);

+ }

+ else {

+ formSubmitWindow_->showFormPlaceholder(FdpFormSubmitWindow::TemplateError::InvalidPayload);

+ return;

+ }

+ }

+ );

+

+ formRequest->send();

+}

+

+void FdpFormSubmitController::submitForm(const std::shared_ptr<Form>& form) {

+ std::string submittedNode = currentTemplateNode_;

+ submittedNode.replace(submittedNode.find("/template/", 0), 10, "/submitted/");

+ auto pubSubItem = std::make_shared<PubSubItem>();

+ auto pubSubItems = std::make_shared<PubSubItems>(submittedNode);

+ auto pubSubPublish = std::make_shared<PubSubPublish>();

+ pubSubPublish->setNode(submittedNode);

+ pubSubPublish->addItem(pubSubItem);

+ pubSubItem->addData(form);

+ pubSubItems->addItem(pubSubItem);

+ auto formRequest = std::make_shared<PubSubRequest<PubSubPublish>>(IQ::Type::Set, selfJID_, currentDomain_, pubSubPublish, iqRouter_);

+

+ formRequest->onResponse.connect(

+ [this](std::shared_ptr<PubSubPublish> response, ErrorPayload::ref errorPayload) {

+ if (!response || errorPayload) {

+ formSubmitWindow_->handleSubmitServerResponse(false);

+ return;

+ }

+ formSubmitWindow_->handleSubmitServerResponse(true);

+ }

+ );

+

+ formRequest->send();

+}

+

+}

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <memory>

+#include <string>

+

+#include <boost/signals2.hpp>

+

+#include <Swiften/JID/JID.h>

+

+namespace Swift {

+ class FdpFormSubmitWindow;

+ class FdpFormSubmitWindowFactory;

+ class Form;

+ class IQRouter;

+ class UIEvent;

+ class UIEventStream;

+

+ class FdpFormSubmitController {

+ public:

+ FdpFormSubmitController(const JID& self, IQRouter* iqRouter, UIEventStream* uiEventStream, FdpFormSubmitWindowFactory* factory);

+ ~FdpFormSubmitController();

+

+ private:

+ void handleUIEvent(const std::shared_ptr<UIEvent>& uiEvent);

+ void createFormSubmitWindow();

+ void closeFormSubmitWindow();

+ void requestPubSubNodeData(const std::string& domainName);

+ void requestTemplateForm(const std::string& nodeName);

+ void submitForm(const std::shared_ptr<Form>& form);

+

+ JID selfJID_;

+ IQRouter* iqRouter_;

+ UIEventStream* uiEventStream_;

+ FdpFormSubmitWindowFactory* factory_;

+ std::unique_ptr<FdpFormSubmitWindow> formSubmitWindow_;

+ std::string currentDomain_;

+ std::string currentTemplateNode_;

+

+ boost::signals2::scoped_connection fdpFormSubmitWindowOpenUIEventConnection_;

+ };

+}

+ * Copyright (c) 2016-2018 Isode Limited.

+FileTransferProgressInfo::FileTransferProgressInfo(size_t completeBytes) : completeBytes(completeBytes), completedBytes(0), percentage(0) {

+void FileTransferProgressInfo::setBytesProcessed(size_t processedBytes) {

+ completedBytes += processedBytes;

+ * Copyright (c) 2016-2018 Isode Limited.

+#include <cstddef>

+

+ FileTransferProgressInfo(size_t completeBytes);

+ void setBytesProcessed(size_t processedBytes);

+ size_t completeBytes;

+ size_t completedBytes;

+ * Copyright (c) 2011-2018 Isode Limited.

+ result[i + j*width] = predicate(*(xBegin + static_cast<long long>(i)-1), *(yBegin + static_cast<long long>(j)-1)) ? result[(i-1) + (j-1)*width] + 1 : std::max(result[i + (j-1)*width], result[i-1 + (j*width)]);

+Roster::Roster(bool sortByStatus, bool fullJIDMapping) : fullJIDMapping_(fullJIDMapping), sortByStatus_(sortByStatus), root_(std::make_unique<GroupRosterItem>("Dummy-Root", nullptr, sortByStatus_)) {

+ * Copyright (c) 2010-2018 Isode Limited.

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

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

+RosterController::RosterController(const JID& jid, XMPPRoster* xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickManager* nickManager, NickResolver* nickResolver, PresenceOracle* presenceOracle, SubscriptionManager* subscriptionManager, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter, SettingsProvider* settings, EntityCapsProvider* entityCapsManager, ClientBlockListManager* clientBlockListManager, VCardManager* vcardManager, Chattables& chattables)

+ : myJID_(jid), xmppRoster_(xmppRoster), mainWindowFactory_(mainWindowFactory), mainWindow_(mainWindowFactory_->createMainWindow(chattables, uiEventStream)), roster_(new Roster()), offlineFilter_(new OfflineRosterFilter()), vcardManager_(vcardManager), avatarManager_(avatarManager), nickManager_(nickManager), nickResolver_(nickResolver), presenceOracle_(presenceOracle), uiEventStream_(uiEventStream), entityCapsManager_(entityCapsManager), clientBlockListManager_(clientBlockListManager), chattables_(chattables) {

+#ifndef NOT_YET

+#endif

+ featureOracle_ = std::make_unique<FeatureOracle>(entityCapsManager_, presenceOracle_);

+

+ chattables_.addJID(jid, Chattables::State::Type::Person);

+ auto state = chattables_.getState(jid);

+ state.name = name;

+ chattables_.setState(jid, state);

+ auto bareFrom = newPresence->getFrom().toBare();

+ Presence::ref accountPresence = presenceOracle_->getAccountPresence(bareFrom);

+ auto state = chattables_.getState(bareFrom);

+ state.status = accountPresence->getShow();

+ chattables_.setState(bareFrom, state);

+ * Copyright (c) 2010-2018 Isode Limited.

+ class Chattables;

+ RosterController(const JID& jid, XMPPRoster* xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickManager* nickManager, NickResolver* nickResolver, PresenceOracle* presenceOracle, SubscriptionManager* subscriptionManager, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter, SettingsProvider* settings, EntityCapsProvider* entityCapsProvider, ClientBlockListManager* clientBlockListManager, VCardManager* vcardManager, Chattables& chattables);

+ Chattables& chattables_;

+ * Copyright (c) 2011-2018 Isode Limited.

+ try {

+ size_t end = update.insertedRows.size();

+ update.insertedRows.resize(update.insertedRows.size() + itemInserts.size());

+ std::transform(itemInserts.begin(), itemInserts.end(), update.insertedRows.begin() + boost::numeric_cast<long long>(end), CreateIndexForSection(sectionPostUpdates[i]));

+ end = update.deletedRows.size();

+ update.deletedRows.resize(update.deletedRows.size() + itemRemoves.size());

+ std::transform(itemRemoves.begin(), itemRemoves.end(), update.deletedRows.begin() + boost::numeric_cast<long long>(end), CreateIndexForSection(sectionUpdates[i]));

+ end = update.updatedRows.size();

+ update.updatedRows.resize(update.updatedRows.size() + itemUpdates.size());

+ std::transform(itemUpdates.begin(), itemUpdates.end(), update.updatedRows.begin() + boost::numeric_cast<long long>(end), CreateIndexForSection(sectionPostUpdates[i]));

+ }

+ catch (const boost::numeric::bad_numeric_cast&) {

+ // If any container claims it has more than long long max items, we have bigger issues, so letting this pass

+ }

+ * Copyright (c) 2010-2018 Isode Limited.

+#include <memory>

+

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

+ //FIXME: All needs rewriting for new roster

+ storages_ = std::make_unique<MemoryStorages>(crypto_);

+ capsManager_ = std::make_unique<CapsManager>(storages_->getCapsStorage(), stanzaChannel_, router_, crypto_);

+ chattables_ = std::make_unique<Chattables>();

+ rosterController_ = new RosterController(jid_, xmppRoster_, avatarManager_, mainWindowFactory_, nickManager_, nickResolver_, presenceOracle_, subscriptionManager_, eventController_, uiEventStream_, router_, settings_, entityCapsManager_, clientBlockListManager_, vcardManager_, *chattables_);

+ capsInfoGenerator_ = std::make_unique<CapsInfoGenerator>("", crypto_);

+ std::unique_ptr<Chattables> chattables_;

+ roster_ = std::make_unique<Roster>();

+ timerFactory = std::make_unique<DummyTimerFactory>();

+ roster = std::make_unique<Roster>();

+ "Chat/Chattables.cpp",

+ "FdpFormSubmitController.cpp",

+ "AccountController.cpp",

+ "UIInterfaces/FdpFormSubmitWindow.cpp",

+ File("Chat/UnitTest/ChatControllerTest.cpp"),

+ File("Chat/UnitTest/ChattablesTest.cpp"),

+ File("UnitTest/FdpFormSubmitControllerTest.cpp"),

+ * Copyright (c) 2012-2018 Isode Limited.

+const SettingsProvider::Setting<bool> SettingConstants::MUC_MARKING_ELISION("mucMarkingElision", true);

+const SettingsProvider::Setting<bool> SettingConstants::FUTURE("future", false);

+ * Copyright (c) 2012-2018 Isode Limited.

+ * The #MUC_MARKING_ELISION setting

+ * specifies whether or not messages with the default muc

+ * marking display their marking, and whether unmarked messages

+ * are marked as such.

+ * If set true, unmarked messages will be marked with the marking

+ * "unmarked", and messages with the room default marking will

+ * have their markings stripped.

+ static const SettingsProvider::Setting<bool> MUC_MARKING_ELISION;

+

+ /**

+ * The #FUTURE setting enables use of experimental features

+ * planned for future releases.

+ */

+ static const SettingsProvider::Setting<bool> FUTURE;

+ * Copyright (c) 2010-2018 Isode Limited.

+ try {

+ boost::filesystem::ofstream file(certificatePath, boost::filesystem::ofstream::binary|boost::filesystem::ofstream::out);

+ ByteArray data = certificate->toDER();

+ file.write(reinterpret_cast<const char*>(vecptr(data)), boost::numeric_cast<std::streamsize>(data.size()));

+ file.close();

+ }

+ catch (...) {

+ SWIFT_LOG(warning) << "Failed to store certificate to " << certificatePath << std::endl;

+ }

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <Swift/Controllers/UIEvents/UIEvent.h>

+

+namespace Swift {

+ class FdpFormSubmitWindowOpenUIEvent : public UIEvent {

+ public:

+ FdpFormSubmitWindowOpenUIEvent() {

+ }

+ };

+}

+ JoinMUCUIEvent(const JID& jid, const boost::optional<std::string>& password = boost::optional<std::string>(), const boost::optional<std::string>& nick = boost::optional<std::string>(), bool createAsReservedRoomIfNew = false, bool isImpromptu = false, bool isContinuation = false) : jid_(jid), nick_(nick), createAsReservedRoomIfNew_(createAsReservedRoomIfNew), password_(password), isImpromptuMUC_(isImpromptu), isContinuation_(isContinuation) {}

+ Chat(const JID& jid, const std::string& chatName, const std::string& activity, size_t unreadCount, StatusShow::Type statusType, const boost::filesystem::path& avatarPath, bool isMUC, bool isPrivateMessage = false, const std::string& nick = "", const boost::optional<std::string> password = boost::optional<std::string>())

+ void setUnreadCount(size_t unread) {

+ size_t unreadCount;

+ virtual void setUnreadCount(size_t unread) = 0;

+ * Copyright (c) 2010-2018 Isode Limited.

+ class DiscoInfo;

+ class ErrorPayload;

+ enum RoomAction {ChangeSubject, Configure, Affiliations, Destroy, Invite, Leave};

+ virtual void setUnreadMessageCount(size_t count) = 0;

+ virtual void setChatSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue) = 0;

+ virtual void removeChatSecurityMarking() = 0;

+

+ boost::signals2::signal<void (const std::string&)> onResendMessageRequest;

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/Controllers/UIInterfaces/FdpFormSubmitWindow.h>

+

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

+

+namespace Swift {

+

+std::string FdpFormSubmitWindow::getNodeErrorText(NodeError nodeError) const {

+ switch(nodeError) {

+ case NodeError::DomainNotFound: return QT_TRANSLATE_NOOP("", "Error: No pubsub domain found");

+ case NodeError::NoFdpNodesInDomain: return QT_TRANSLATE_NOOP("", "Error: Domain does not contain an FDP template node");

+ case NodeError::NoError: return "";

+ }

+ return "";

+}

+

+std::string FdpFormSubmitWindow::getTemplateErrorText(TemplateError templateError) const {

+ switch(templateError) {

+ case TemplateError::CannotLocateForm: return QT_TRANSLATE_NOOP("", "Error: Could not locate template form");

+ case TemplateError::InvalidPayload: return QT_TRANSLATE_NOOP("", "Error: Invalid payload returned from node");

+ case TemplateError::RequestFailed: return QT_TRANSLATE_NOOP("", "Error: Pubsub request failed");

+ case TemplateError::NoError: return "";

+ }

+ return "";

+}

+

+}

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <memory>

+#include <string>

+

+#include <boost/signals2.hpp>

+

+namespace Swift {

+

+ class Form;

+

+ class FdpFormSubmitWindow {

+

+ public:

+ enum class NodeError {

+ DomainNotFound,

+ NoFdpNodesInDomain,

+ NoError,

+ };

+ enum class TemplateError {

+ CannotLocateForm,

+ InvalidPayload,

+ RequestFailed,

+ NoError,

+ };

+

+ virtual ~FdpFormSubmitWindow() {}

+

+ virtual void show() = 0;

+ virtual void raise() = 0;

+ virtual void addNode(const std::string& node, const std::string& nodeName) = 0;

+ virtual void clearNodeData() = 0;

+ virtual void setFormData(const std::shared_ptr<Form>& form) = 0;

+ virtual void showNodePlaceholder(NodeError nodeError) = 0;

+ virtual void showFormPlaceholder(TemplateError templateError) = 0;

+ virtual void handleSubmitServerResponse(bool submissionSuccess) = 0;

+

+ boost::signals2::signal<void ()> onCloseEvent;

+ boost::signals2::signal<void (const std::string&)> onRequestPubSubNodeData;

+ boost::signals2::signal<void (const std::string&)> onRequestTemplateForm;

+ boost::signals2::signal<void (const std::shared_ptr<Form>&)> onSubmitForm;

+

+ protected:

+

+ std::string getNodeErrorText(NodeError nodeError) const;

+ std::string getTemplateErrorText(TemplateError templateError) const;

+ };

+}

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <memory>

+

+namespace Swift {

+ class FdpFormSubmitWindow;

+

+ class FdpFormSubmitWindowFactory {

+ public:

+ virtual ~FdpFormSubmitWindowFactory() {}

+ virtual std::unique_ptr<FdpFormSubmitWindow> createFdpFormSubmitWindow() = 0;

+ };

+}

+ * Copyright (c) 2010-2018 Isode Limited.

+ class JID;

+ * Copyright (c) 2010-2018 Isode Limited.

+#pragma once

+ class Chattables;

+ class UIEventStream;

+ virtual MainWindow* createMainWindow(Chattables&, UIEventStream*) = 0;

+ * Copyright (c) 2010-2018 Isode Limited.

+#include <Swift/Controllers/UIInterfaces/FdpFormSubmitWindowFactory.h>

+ public BlockListEditorWidgetFactory,

+ public FdpFormSubmitWindowFactory {

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <memory>

+#include <string>

+

+#include <gtest/gtest.h>

+

+#include <Swiften/Client/DummyStanzaChannel.h>

+#include <Swiften/Elements/DiscoItems.h>

+#include <Swiften/Elements/Form.h>

+#include <Swiften/Elements/FormField.h>

+#include <Swiften/Elements/IQ.h>

+#include <Swiften/Elements/Payload.h>

+#include <Swiften/Elements/PubSub.h>

+#include <Swiften/Elements/PubSubItems.h>

+#include <Swiften/Elements/PubSubPublish.h>

+#include <Swiften/JID/JID.h>

+#include <Swiften/Queries/IQRouter.h>

+

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

+#include <Swift/Controllers/UIEvents/FdpFormSubmitWindowOpenUIEvent.h>

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

+#include <Swift/Controllers/UnitTest/MockFdpFormSubmitWindowFactory.h>

+#include <Swift/Controllers/UnitTest/MockFdpFormSubmitWindow.h>

+

+namespace Swift {

+

+class FdpFormSubmitControllerTest : public ::testing::Test {

+

+ protected:

+ void SetUp() {

+ clientJid_ = JID(clientJIDString_);

+ stanzaChannel_ = std::make_unique<DummyStanzaChannel>();

+ iqRouter_ = std::make_unique<IQRouter>(stanzaChannel_.get());

+ uiEventStream_ = std::make_unique<UIEventStream>();

+ fdpWindowFactory_ = std::make_unique<MockFdpFormSubmitWindowFactory>();

+ fdpController_ = std::make_unique<FdpFormSubmitController>(clientJid_, iqRouter_.get(), uiEventStream_.get(), fdpWindowFactory_.get());

+ auto fdpWindowOpenUIEvent = std::make_shared<FdpFormSubmitWindowOpenUIEvent>();

+ uiEventStream_->send(fdpWindowOpenUIEvent);

+ fdpWindow_ = fdpWindowFactory_->getMockFdpFormSubmitWindow();

+ }

+

+ void TearDown() {

+ }

+

+ std::shared_ptr<DiscoItems> createDiscoItemsResult();

+ std::shared_ptr<PubSub> createTemplatePubSubResult(const std::shared_ptr<Form>& form);

+ std::shared_ptr<PubSub> createSubmittedPubSubResult();

+

+ std::string clientJIDString_ = "testjid@test.im/swift";

+ JID clientJid_;

+ std::unique_ptr<DummyStanzaChannel> stanzaChannel_;

+ std::unique_ptr<IQRouter> iqRouter_;

+ std::unique_ptr<UIEventStream> uiEventStream_;

+ std::unique_ptr<MockFdpFormSubmitWindowFactory> fdpWindowFactory_;

+ std::unique_ptr<FdpFormSubmitController> fdpController_;

+ MockFdpFormSubmitWindow* fdpWindow_;

+};

+

+std::shared_ptr<DiscoItems> FdpFormSubmitControllerTest::createDiscoItemsResult() {

+ auto discoItems = std::make_shared<DiscoItems>();

+ discoItems->addItem(DiscoItems::Item("node0", JID(), "fdp/template/testNode0"));

+ discoItems->addItem(DiscoItems::Item("node1", JID(), "fdp/template/testNode1"));

+ discoItems->addItem(DiscoItems::Item("node2", JID(), "fdp/template/testNode2"));

+ return discoItems;

+}

+

+std::shared_ptr<PubSub> FdpFormSubmitControllerTest::createTemplatePubSubResult(const std::shared_ptr<Form>& form) {

+ auto pubSubItem = std::make_shared<PubSubItem>();

+ pubSubItem->addData(form);

+ auto pubSubItems = std::make_shared<PubSubItems>();

+ pubSubItems->addItem(pubSubItem);

+ auto pubSub = std::make_shared<PubSub>();

+ pubSub->setPayload(pubSubItems);

+ return pubSub;

+}

+

+std::shared_ptr<PubSub> FdpFormSubmitControllerTest::createSubmittedPubSubResult() {

+ auto pubSubItem = std::make_shared<PubSubItem>();

+ pubSubItem->setID("testID");

+ auto pubSubPublish = std::make_shared<PubSubPublish>();

+ pubSubPublish->addItem(pubSubItem);

+ pubSubPublish->setNode("fdp/submitted/test");

+ auto pubSub = std::make_shared<PubSub>();

+ pubSub->setPayload(pubSubPublish);

+ return pubSub;

+}

+

+TEST_F(FdpFormSubmitControllerTest, testRequestPubSubNodeData) {

+ std::string domainName = "fdp.example.test";

+ fdpWindow_->onRequestPubSubNodeData(domainName);

+ ASSERT_EQ(1, stanzaChannel_->sentStanzas.size());

+ auto requestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ ASSERT_EQ(domainName, requestIq->getTo());

+ auto discoItemsPayloads = requestIq->getPayloads<DiscoItems>();

+ ASSERT_EQ(1, discoItemsPayloads.size());

+

+ auto discoItemsResult = createDiscoItemsResult();

+ auto resultIq = IQ::createResult(clientJid_, domainName, requestIq->getID(), discoItemsResult);

+ stanzaChannel_->onIQReceived(resultIq);

+

+ auto discoItemsList = discoItemsResult->getItems();

+ ASSERT_EQ(discoItemsList.size(), fdpWindow_->nodeData.size());

+ for (unsigned int i = 0; i < fdpWindow_->nodeData.size(); i++) {

+ auto nodeItem = fdpWindow_->nodeData[i];

+ auto discoItem = discoItemsList[i];

+ ASSERT_EQ(discoItem.getNode(), nodeItem.first);

+ ASSERT_EQ(discoItem.getName(), nodeItem.second);

+ }

+ ASSERT_EQ(FdpFormSubmitWindow::NodeError::NoError, fdpWindow_->nodeError_);

+}

+

+TEST_F(FdpFormSubmitControllerTest, testRequestPubSubNodeDataError) {

+ std::string domainName = "fdp.example.test";

+ fdpWindow_->onRequestPubSubNodeData(domainName);

+ ASSERT_EQ(1, stanzaChannel_->sentStanzas.size());

+ auto requestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ ASSERT_EQ(domainName, requestIq->getTo());

+

+ auto resultIq = IQ::createError(clientJid_, domainName, requestIq->getID());

+ stanzaChannel_->onIQReceived(resultIq);

+

+ ASSERT_EQ(true, fdpWindow_->nodeData.empty());

+ ASSERT_EQ(FdpFormSubmitWindow::NodeError::DomainNotFound, fdpWindow_->nodeError_);

+}

+

+TEST_F(FdpFormSubmitControllerTest, testRequestTemplateForm) {

+ std::string domainName = "fdp.example.test";

+ fdpWindow_->onRequestPubSubNodeData(domainName);

+ auto nodeDataRequestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ auto discoItemsResult = createDiscoItemsResult();

+ auto discoItemsResultIq = IQ::createResult(clientJid_, domainName, nodeDataRequestIq->getID(), discoItemsResult);

+ stanzaChannel_->onIQReceived(discoItemsResultIq);

+

+ std::string templateNodeName = "fdp/template/test";

+ fdpWindow_->onRequestTemplateForm(templateNodeName);

+ ASSERT_EQ(2, stanzaChannel_->sentStanzas.size());

+ auto requestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[1]);

+ ASSERT_EQ(domainName, requestIq->getTo());

+ auto pubSubPayloads = requestIq->getPayloads<PubSub>();

+ ASSERT_EQ(1, pubSubPayloads.size());

+

+ std::string value0("value0");

+ std::string value1("value1@example.test");

+ auto field0 = std::make_shared<FormField>(FormField::TextSingleType, value0);

+ auto field1 = std::make_shared<FormField>(FormField::JIDSingleType, value1);

+ auto form = std::make_shared<Form>();

+ form->addField(field0);

+ form->addField(field1);

+ auto pubSubResult = createTemplatePubSubResult(form);

+ auto resultIq = IQ::createResult(clientJid_, domainName, requestIq->getID(), pubSubResult);

+ stanzaChannel_->onIQReceived(resultIq);

+

+ ASSERT_EQ(form, fdpWindow_->templateForm_);

+ auto fields = fdpWindow_->templateForm_->getFields();

+ ASSERT_EQ(2, fields.size());

+ ASSERT_EQ(field0, fields[0]);

+ ASSERT_EQ(field1, fields[1]);

+ ASSERT_EQ(value0, fields[0]->getTextSingleValue());

+ ASSERT_EQ(value1, fields[1]->getJIDSingleValue());

+ ASSERT_EQ(FdpFormSubmitWindow::TemplateError::NoError, fdpWindow_->templateError_);

+}

+

+TEST_F(FdpFormSubmitControllerTest, testRequestTemplateFormError) {

+ std::string domainName = "fdp.example.test";

+ fdpWindow_->onRequestPubSubNodeData(domainName);

+ auto nodeDataRequestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ auto discoItemsResult = createDiscoItemsResult();

+ auto discoItemsResultIq = IQ::createResult(clientJid_, domainName, nodeDataRequestIq->getID(), discoItemsResult);

+ stanzaChannel_->onIQReceived(discoItemsResultIq);

+

+ std::string templateNodeName = "fdp/template/test";

+ fdpWindow_->onRequestTemplateForm(templateNodeName);

+ ASSERT_EQ(2, stanzaChannel_->sentStanzas.size());

+ auto requestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[1]);

+ ASSERT_EQ(domainName, requestIq->getTo());

+

+ auto resultIq = IQ::createError(clientJid_, domainName, requestIq->getID());

+ stanzaChannel_->onIQReceived(resultIq);

+

+ ASSERT_EQ(nullptr, fdpWindow_->templateForm_);

+ ASSERT_EQ(FdpFormSubmitWindow::TemplateError::RequestFailed, fdpWindow_->templateError_);

+}

+

+TEST_F(FdpFormSubmitControllerTest, testSubmitForm) {

+ std::string domainName = "fdp.example.test";

+ std::string templateNodeName = "fdp/template/test";

+ fdpWindow_->onRequestPubSubNodeData(domainName);

+ auto nodeDataRequestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ auto discoItemsResult = createDiscoItemsResult();

+ auto discoItemsResultIq = IQ::createResult(clientJid_, domainName, nodeDataRequestIq->getID(), discoItemsResult);

+ stanzaChannel_->onIQReceived(discoItemsResultIq);

+ fdpWindow_->onRequestTemplateForm(templateNodeName);

+ auto templateFormRequestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[1]);

+ auto templateForm = std::make_shared<Form>();

+ auto templatePubSubResult = createTemplatePubSubResult(templateForm);

+ auto templatePubSubResultIq = IQ::createResult(clientJid_, domainName, templateFormRequestIq->getID(), templatePubSubResult);

+ stanzaChannel_->onIQReceived(templatePubSubResultIq);

+

+ std::string value0("value0");

+ std::string value1("value1@example.test");

+ auto field0 = std::make_shared<FormField>(FormField::TextSingleType, value0);

+ auto field1 = std::make_shared<FormField>(FormField::JIDSingleType, value1);

+ auto form = std::make_shared<Form>();

+ form->addField(field0);

+ form->addField(field1);

+ fdpWindow_->onSubmitForm(form);

+

+ ASSERT_EQ(3, stanzaChannel_->sentStanzas.size());

+ auto requestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[2]);

+ ASSERT_EQ(domainName, requestIq->getTo());

+ auto pubSubPayloads = requestIq->getPayloads<PubSub>();

+ ASSERT_EQ(1, pubSubPayloads.size());

+ auto pubSubPayload = pubSubPayloads[0];

+ auto pubSubPublishPayload = std::dynamic_pointer_cast<PubSubPublish>(pubSubPayload->getPayload());

+ ASSERT_TRUE(pubSubPublishPayload);

+ auto pubSubItems = pubSubPublishPayload->getItems();

+ ASSERT_EQ(1, pubSubItems.size());

+ auto dataList = pubSubItems[0]->getData();

+ ASSERT_EQ(1, dataList.size());

+ auto submittedForm = std::dynamic_pointer_cast<Form>(dataList[0]);

+ ASSERT_TRUE(submittedForm);

+ ASSERT_EQ(form, submittedForm);

+ auto fields = submittedForm->getFields();

+ ASSERT_EQ(2, fields.size());

+ ASSERT_EQ(field0, fields[0]);

+ ASSERT_EQ(field1, fields[1]);

+ ASSERT_EQ(value0, fields[0]->getTextSingleValue());

+ ASSERT_EQ(value1, fields[1]->getJIDSingleValue());

+

+ auto pubSubResult = createSubmittedPubSubResult();

+ auto resultIq = IQ::createResult(clientJid_, domainName, requestIq->getID(), pubSubResult);

+ stanzaChannel_->onIQReceived(resultIq);

+

+ ASSERT_EQ(true, fdpWindow_->submissionSuccess_);

+}

+

+TEST_F(FdpFormSubmitControllerTest, testSubmitFormError) {

+ std::string domainName = "fdp.example.test";

+ std::string templateNodeName = "fdp/template/test";

+ fdpWindow_->onRequestPubSubNodeData(domainName);

+ auto nodeDataRequestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

+ auto discoItemsResult = createDiscoItemsResult();

+ auto discoItemsResultIq = IQ::createResult(clientJid_, domainName, nodeDataRequestIq->getID(), discoItemsResult);

+ stanzaChannel_->onIQReceived(discoItemsResultIq);

+ fdpWindow_->onRequestTemplateForm(templateNodeName);

+ auto templateFormRequestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[1]);

+ auto templateForm = std::make_shared<Form>();

+ auto templatePubSubResult = createTemplatePubSubResult(templateForm);

+ auto templatePubSubResultIq = IQ::createResult(clientJid_, domainName, templateFormRequestIq->getID(), templatePubSubResult);

+ stanzaChannel_->onIQReceived(templatePubSubResultIq);

+

+ auto form = std::make_shared<Form>();

+ fdpWindow_->onSubmitForm(form);

+ ASSERT_EQ(3, stanzaChannel_->sentStanzas.size());

+ auto requestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[2]);

+ ASSERT_EQ(domainName, requestIq->getTo());

+

+ auto resultIq = IQ::createError(clientJid_, domainName, requestIq->getID());

+ stanzaChannel_->onIQReceived(resultIq);

+

+ ASSERT_EQ(false, fdpWindow_->submissionSuccess_);

+}

+

+}

+ virtual std::string addMessage(const ChatMessage& message, const std::string& senderName, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const std::string& /*avatarPath*/, const boost::posix_time::ptime& /*time*/) {

+ lastAddedMessageSecurityLabel_ = label;

+ virtual void setUnreadMessageCount(size_t /*count*/) {}

+ void setChatSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue) {

+ markingValue_ = markingValue;

+ markingForegroundColorValue_ = markingForegroundColorValue;

+ markingBackgroundColorValue_ = markingBackgroundColorValue;

+ }

+

+ void removeChatSecurityMarking() {}

+

+ std::shared_ptr<SecurityLabel> lastAddedMessageSecurityLabel_ = nullptr;

+ std::string markingValue_;

+ std::string markingForegroundColorValue_;

+ std::string markingBackgroundColorValue_;

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <memory>

+#include <string>

+

+#include <Swift/Controllers/UIInterfaces/FdpFormSubmitWindow.h>

+

+namespace Swift {

+

+ class Form;

+

+ class MockFdpFormSubmitWindow : public FdpFormSubmitWindow {

+ public:

+ MockFdpFormSubmitWindow() : FdpFormSubmitWindow() {}

+ virtual void show() override {}

+ virtual void raise() override {}

+ virtual void addNode(const std::string& node, const std::string& nodeName) override { nodeData.push_back(std::pair<std::string, std::string>(node, nodeName)); }

+ virtual void clearNodeData() override { nodeData.clear(); }

+ virtual void setFormData(const std::shared_ptr<Form>& form) override { templateForm_ = form; }

+ virtual void showNodePlaceholder(NodeError nodeError) override { nodeError_ = nodeError; }

+ virtual void showFormPlaceholder(TemplateError templateError) override { templateError_ = templateError; }

+ virtual void handleSubmitServerResponse(bool submissionSuccess) override { submissionSuccess_ = submissionSuccess; }

+

+ std::vector<std::pair<std::string, std::string>> nodeData;

+ std::shared_ptr<Form> templateForm_ = nullptr;

+ NodeError nodeError_ = NodeError::NoError;

+ TemplateError templateError_ = TemplateError::NoError;

+ bool submissionSuccess_ = false;

+ };

+

+}

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <memory>

+

+#include <Swift/Controllers/UIInterfaces/FdpFormSubmitWindowFactory.h>

+#include <Swift/Controllers/UnitTest/MockFdpFormSubmitWindow.h>

+

+namespace Swift {

+

+ class MockFdpFormSubmitWindowFactory : public FdpFormSubmitWindowFactory {

+ public:

+ MockFdpFormSubmitWindowFactory() : FdpFormSubmitWindowFactory() {}

+

+ virtual std::unique_ptr<FdpFormSubmitWindow> createFdpFormSubmitWindow() override {

+ std::unique_ptr<FdpFormSubmitWindow> fdpFormSubmitWindow = std::make_unique<MockFdpFormSubmitWindow>();

+ mockFdpFormSubmitWindow_ = static_cast<MockFdpFormSubmitWindow*>(fdpFormSubmitWindow.get());

+ return fdpFormSubmitWindow;

+ }

+

+ MockFdpFormSubmitWindow* getMockFdpFormSubmitWindow() { return mockFdpFormSubmitWindow_; }

+

+ private:

+ MockFdpFormSubmitWindow* mockFdpFormSubmitWindow_;

+ };

+}

+ * Copyright (c) 2010-2018 Isode Limited.

+ virtual void openFdpFormSubmitDialog(const JID& /*self*/, IQRouter* /*iqRouter*/) {}

+ virtual MainWindow* createMainWindow(Chattables&, UIEventStream*) {last = new MockMainWindow();return last;}

+ * Copyright (c) 2010-2018 Isode Limited.

+ onEventQueueLengthChange(events_.size());

+ onEventQueueLengthChange(events_.size());

+ * Copyright (c) 2010-2018 Isode Limited.

+#include <cstddef>

+ boost::signals2::signal<void (size_t)> onEventQueueLengthChange;

+ print("Enabled help2man but help2man is not in the PATH of the current environment.")

+ <Package Id='*' Keywords='Installer' Description="Swift Installer" Comments="Swift is available under the GPL version 3" Manufacturer="Swift.im" InstallerVersion='500' Languages='1033' Compressed='yes' SummaryCodepage='1252' />

+ <Property Id="ALLUSERS" Value="2" />

+ <Property Id="MSIINSTALLPERUSER" Value="1" />

+ <Property Id="WIXUIVCREDISTINSTALL" Value="0" />

+

+ <Property Id="VCREDISTINSTALLED">

+ <RegistrySearch Id="VCREDISTINSTALLED"

+ Root="HKLM"

+ Key="SOFTWARE\Wow6432Node\Microsoft\VisualStudio\$(var.MsvcDotVersion)\VC\Runtimes\$(sys.BUILDARCH)"

+ Name="Installed"

+ Type="raw" />

+

+ </Property>

+ have the same GUID (do not run heat.exe with -gg flag) or else when MSI removes the components

+ <Directory Id="APPLICATIONFOLDER" Name="Swift">

+ </Directory>

+

+ <Property Id="WixAppFolder" Value="WixPerUserFolder" />

+

+ <ComponentGroupRef Id='VCFiles' />

+ <!--UIRef Id="WixUI_Mondo"/-->

+ <UIRef Id="WixUI_Swift"/>

+

+ <!--

+ VC Redistributable

+ <InstallUISequence>

+ <!-- Suppress FindRelatedProducts untill the user selects the scope of the install -->

+ <FindRelatedProducts Suppress="yes" />

+ </InstallUISequence>

+ <Custom Action='CRTAction' After='InstallInitialize'>(NOT VCREDISTINSTALLED AND ALLUSERS = 1) OR WIXUIVCREDISTINSTALL = 1</Custom>

+ <Fragment>

+ <DirectoryRef Id="INSTALLDIR">

+ <Component Id="msvcp.dll" Guid="*">

+ <Condition>(NOT (VCREDISTINSTALLED OR ALLUSERS = 1)) AND WIXUIVCREDISTINSTALL = 0 </Condition>

+ <File Id="msvcp$(var.MsvcVersion).dll" KeyPath="yes" Source="$(var.VCCRTPath)\msvcp$(var.MsvcVersion).dll" />

+ </Component>

+ <Component Id="vcruntime.dll" Guid="*">

+ <Condition>(NOT (VCREDISTINSTALLED OR ALLUSERS = 1)) AND WIXUIVCREDISTINSTALL = 0 </Condition>

+ <?if $(var.MsvcVersion) > "120"?>

+ <File Id="vcruntime$(var.MsvcVersion).dll" KeyPath="yes" Source="$(var.VCCRTPath)\vcruntime$(var.MsvcVersion).dll" />

+ <?else?>

+ <File Id="msvcr$(var.MsvcVersion).dll" KeyPath="yes" Source="$(var.VCCRTPath)\msvcr$(var.MsvcVersion).dll" />

+ <?endif?>

+ </Component>

+ </DirectoryRef>

+ </Fragment>

+ <Fragment>

+ <ComponentGroup Id="VCFiles">

+ <ComponentRef Id="msvcp.dll" />

+ <ComponentRef Id="vcruntime.dll" />

+ </ComponentGroup>

+ </Fragment>

+ <Fragment>

+

+ <WixVariable Id="WixUISupportPerUser" Value="1" Overridable="yes" />

+ <WixVariable Id="WixUISupportPerMachine" Value="1" Overridable="yes" />

+

+ <!-- This is Based on WixUI_Mondo, but it adds an InstallScopeDlg dialog -->

+ <UI Id="WixUI_Swift">

+ <TextStyle Id="WixUI_Font_Normal" FaceName="Tahoma" Size="8" />

+ <TextStyle Id="WixUI_Font_Bigger" FaceName="Tahoma" Size="12" />

+ <TextStyle Id="WixUI_Font_Title" FaceName="Tahoma" Size="9" Bold="yes" />

+

+ <Property Id="DefaultUIFont" Value="WixUI_Font_Normal" />

+ <Property Id="WixUI_Mode" Value="Mondo" />

+

+ <DialogRef Id="ErrorDlg" />

+ <DialogRef Id="FatalError" />

+ <DialogRef Id="FilesInUse" />

+ <DialogRef Id="MsiRMFilesInUse" />

+ <DialogRef Id="PrepareDlg" />

+ <DialogRef Id="ProgressDlg" />

+ <DialogRef Id="ResumeDlg" />

+ <DialogRef Id="UserExit" />

+

+ <Publish Dialog="ExitDialog" Control="Finish" Event="EndDialog" Value="Return" Order="999">1</Publish>

+

+ <Publish Dialog="WelcomeDlg" Control="Next" Event="NewDialog" Value="LicenseAgreementDlg">NOT Installed AND NOT PATCH</Publish>

+ <Publish Dialog="WelcomeDlg" Control="Next" Event="NewDialog" Value="VerifyReadyDlg">Installed AND PATCH</Publish>

+

+ <Publish Dialog="LicenseAgreementDlg" Control="Back" Event="NewDialog" Value="WelcomeDlg">1</Publish>

+ <Publish Dialog="LicenseAgreementDlg" Control="Next" Event="NewDialog" Value="InstallScopeDlg" Order="2">LicenseAccepted = "1"</Publish>

+

+ <Publish Dialog="InstallScopeDlg" Control="Back" Event="NewDialog" Value="LicenseAgreementDlg">1</Publish>

+ <!-- override default WixAppFolder of WixPerMachineFolder as standard user won't be shown the radio group to set WixAppFolder -->

+ <Publish Dialog="InstallScopeDlg" Control="Next" Property="WixAppFolder" Value="WixPerUserFolder" Order="1">!(wix.WixUISupportPerUser) AND NOT Privileged</Publish>

+ <Publish Dialog="InstallScopeDlg" Control="Next" Property="ALLUSERS" Value="{}" Order="2">WixAppFolder = "WixPerUserFolder"</Publish>

+ <Publish Dialog="InstallScopeDlg" Control="Next" Property="ALLUSERS" Value="1" Order="3">WixAppFolder = "WixPerMachineFolder"</Publish>

+ <Publish Dialog="InstallScopeDlg" Control="Next" Property="APPLICATIONFOLDER" Value="[WixPerUserFolder]" Order="4">WixAppFolder = "WixPerUserFolder"</Publish>

+ <Publish Dialog="InstallScopeDlg" Control="Next" Property="APPLICATIONFOLDER" Value="[WixPerMachineFolder]" Order="5">WixAppFolder = "WixPerMachineFolder"</Publish>

+ <Publish Dialog="InstallScopeDlg" Control="Next" Event="NewDialog" Value="SetupTypeDlg">1</Publish>

+ <!-- After selecting the scope of the installation, run FindRelatedProducts to find previous versions that needs upgrading -->

+ <Publish Dialog="InstallScopeDlg" Control="Next" Event="DoAction" Value="FindRelatedProducts" Order="6">1</Publish>

+

+ <Publish Dialog="SetupTypeDlg" Control="Back" Event="NewDialog" Value="InstallScopeDlg">1</Publish>

+ <Publish Dialog="SetupTypeDlg" Control="TypicalButton" Event="NewDialog" Value="VCResdistDialog">NOT VCREDISTINSTALLED AND NOT ALLUSERS </Publish>

+ <Publish Dialog="SetupTypeDlg" Control="CustomButton" Event="NewDialog" Value="CustomizeDlg">NOT VCREDISTINSTALLED AND NOT ALLUSERS </Publish>

+ <Publish Dialog="SetupTypeDlg" Control="CompleteButton" Event="NewDialog" Value="VCResdistDialog">NOT VCREDISTINSTALLED AND NOT ALLUSERS </Publish>

+ <Publish Dialog="SetupTypeDlg" Control="TypicalButton" Event="NewDialog" Value="VerifyReadyDlg">VCREDISTINSTALLED OR ALLUSERS = 1</Publish>

+ <Publish Dialog="SetupTypeDlg" Control="CustomButton" Event="NewDialog" Value="CustomizeDlg">VCREDISTINSTALLED OR ALLUSERS = 1</Publish>

+ <Publish Dialog="SetupTypeDlg" Control="CompleteButton" Event="NewDialog" Value="VerifyReadyDlg">VCREDISTINSTALLED OR ALLUSERS = 1</Publish>

+

+ <Dialog Id="VCResdistDialog" Width="260" Height="85" Title="[ProductName] Setup">

+ <Control Id="VcRredistNo" Type="PushButton" X="132" Y="57" Width="56" Height="17" Default="yes" Cancel="yes" Text="!(loc.WixUINo)">

+ <Publish Property="WIXUIVCREDISTINSTALL" Value="0">1</Publish>

+ <Publish Event="NewDialog" Value="VerifyReadyDlg">1</Publish>

+ </Control>

+ <Control Id="VcRredistYes" Type="PushButton" X="72" Y="57" Width="56" Height="17" Text="!(loc.WixUIYes)">

+ <Publish Property="WIXUIVCREDISTINSTALL" Value="1">1</Publish>

+ <Publish Event="NewDialog" Value="VerifyReadyDlg">1</Publish>

+ </Control>

+ <Control Id="Text" Type="Text" X="48" Y="15" Width="194" Height="30" NoPrefix="yes" Text="Visual Studio redistributables installation was not found on your computer. Would you like Swift to install them?" />

+ <Control Id="Icon" Type="Icon" X="15" Y="15" Width="24" Height="24" ToolTip="!(loc.CancelDlgIconTooltip)" FixedSize="yes" IconSize="32" Text="!(loc.CancelDlgIcon)" />

+ </Dialog>

+

+ <Publish Dialog="CustomizeDlg" Control="Back" Event="NewDialog" Value="MaintenanceTypeDlg" Order="1">WixUI_InstallMode = "Change"</Publish>

+ <Publish Dialog="CustomizeDlg" Control="Back" Event="NewDialog" Value="SetupTypeDlg" Order="2">WixUI_InstallMode = "InstallCustom"</Publish>

+ <Publish Dialog="CustomizeDlg" Control="Next" Event="NewDialog" Value="VCResdistDialog" Order="1">NOT VCREDISTINSTALLED AND NOT ALLUSERS</Publish>

+ <Publish Dialog="CustomizeDlg" Control="Next" Event="NewDialog" Value="VerifyReadyDlg" Order="2">VCREDISTINSTALLED OR ALLUSERS = 1</Publish>

+

+ <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="CustomizeDlg" Order="1">WixUI_InstallMode = "InstallCustom"</Publish>

+ <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="SetupTypeDlg" Order="2">WixUI_InstallMode = "InstallTypical" OR WixUI_InstallMode = "InstallComplete"</Publish>

+ <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="CustomizeDlg" Order="3">WixUI_InstallMode = "Change"</Publish>

+ <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="MaintenanceTypeDlg" Order="4">WixUI_InstallMode = "Repair" OR WixUI_InstallMode = "Remove"</Publish>

+ <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="WelcomeDlg" Order="2">WixUI_InstallMode = "Update"</Publish>

+

+ <Publish Dialog="MaintenanceWelcomeDlg" Control="Next" Event="NewDialog" Value="MaintenanceTypeDlg">1</Publish>

+

+ <Publish Dialog="MaintenanceTypeDlg" Control="ChangeButton" Event="NewDialog" Value="CustomizeDlg">1</Publish>

+ <Publish Dialog="MaintenanceTypeDlg" Control="RepairButton" Event="NewDialog" Value="VerifyReadyDlg">1</Publish>

+ <Publish Dialog="MaintenanceTypeDlg" Control="RemoveButton" Event="NewDialog" Value="VerifyReadyDlg">1</Publish>

+ <Publish Dialog="MaintenanceTypeDlg" Control="Back" Event="NewDialog" Value="MaintenanceWelcomeDlg">1</Publish>

+ </UI>

+ <UIRef Id="WixUI_Common" />

+ </Fragment>

+<?xml version="1.0" encoding="utf-8"?>

+<WixLocalization Culture="en-us" xmlns="http://schemas.microsoft.com/wix/2006/localization">

+ <String Id="InstallScopeDlgPerUserDescription">[ProductName] will be installed in a user folder and auto-updates will be enabled. The application be installed only for your user and you do not need to be an Administrator. </String>

+</WixLocalization>

+void QtChatListWindow::setUnreadCount(size_t unread) {

+ bookmarkAction->setEnabled(isOnline_);

+ void setUnreadCount(size_t unread);

+ void onCountUpdated(size_t count);

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/QtUI/ChattablesModel.h>

+

+#include <QDebug>

+

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

+

+#include <Swift/QtUI/QtSwiftUtil.h>

+

+namespace Swift {

+

+ChattablesModel::ChattablesModel(Chattables& chattables, QObject* parent) : QAbstractListModel(parent), chattables_(chattables) {

+ using scoped_connection = boost::signals2::scoped_connection;

+ connectionList_.emplace_back(std::make_unique<scoped_connection>(

+ chattables_.onBeginAdd.connect([this](int index) {beginInsertRows(QModelIndex(), index, index);})

+ ));

+ connectionList_.emplace_back(std::make_unique<scoped_connection>(

+ chattables_.onAdded.connect([this]() {endInsertRows();})

+ ));

+ connectionList_.emplace_back(std::make_unique<scoped_connection>(

+ chattables_.onChanged.connect(

+ [this](const JID& jid, int index) {

+ auto modelIndex = createIndex(index, 0, const_cast<JID*>(&jid));

+ dataChanged(modelIndex, modelIndex, {});

+ }

+ )

+ ));

+}

+

+int ChattablesModel::rowCount(const QModelIndex& /*parent*/) const {

+ return chattables_.get().size();

+}

+

+QVariant ChattablesModel::data(const QModelIndex& index, int role) const {

+ //FIXME: Check validity

+ auto state = chattables_.getState(chattables_.get()[index.row()]);

+ if (role == Qt::DisplayRole) {

+ return P2QSTRING((state.name.empty() ? state.jid.toString() : state.name));

+ }

+ if (role == UnreadCountRole) {

+ return QString::number(state.unreadCount);

+ }

+ if (role == TypeRole) {

+ switch (state.type) {

+ case Chattables::State::Type::Room: return "ROOM";

+ case Chattables::State::Type::Person: return "PERSON";

+ }

+ }

+ if (role == StatusRole) {

+ return QVariant(static_cast<int>(state.status));

+ }

+ if (role == JIDRole) {

+ return P2QSTRING(state.jid.toString());

+ }

+ return QVariant();

+}

+

+}

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <memory>

+#include <vector>

+

+#include <boost/signals2/connection.hpp>

+

+#include <QAbstractListModel>

+

+namespace Swift {

+class Chattables;

+class ChattablesModel : public QAbstractListModel {

+ public:

+ enum ChattablesRoles {

+ UnreadCountRole = Qt::UserRole,

+ TypeRole = Qt::UserRole + 1,

+ StatusRole = Qt::UserRole + 2,

+ JIDRole = Qt::UserRole + 3

+ };

+ ChattablesModel(Chattables& chattables, QObject* parent);

+ int rowCount(const QModelIndex& parent = QModelIndex()) const;

+ QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;

+ private:

+ Chattables& chattables_;

+ std::vector<std::unique_ptr<boost::signals2::scoped_connection>> connectionList_;

+};

+

+}

+ return nullptr;

+ return nullptr;

+ return pw->style()->pixelMetric(pm, nullptr, pw);

+ ~FlowLayout() override;

+ bookmark.setAutojoin(true);

+ std::string suffix = "." + std::to_string(size);

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/QtUI/QtChatOverview.h>

+

+#include <QHBoxLayout>

+#include <QLabel>

+#include <QPalette>

+#include <QVBoxLayout>

+

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

+

+#include <Swift/QtUI/ChattablesModel.h>

+#include <Swift/QtUI/QtChatOverviewBundle.h>

+

+namespace Swift {

+

+QtChatOverview::QtChatOverview(Chattables& chattables, QWidget* parent) : QWidget(parent), chattables_(chattables) {

+ QPalette newPalette = palette();

+ newPalette.setColor(QPalette::Background, {38, 81, 112});

+ setAutoFillBackground(true);

+ newPalette.setColor(QPalette::Foreground, {255, 255, 255});

+ setPalette(newPalette);

+

+ auto mainLayout = new QVBoxLayout();

+ setLayout(mainLayout);

+

+ auto headerLayout = new QHBoxLayout();

+ mainLayout->addLayout(headerLayout);

+ auto allLabel = new QLabel(tr("All"), this);

+ allLabel->setStyleSheet("color: white;");

+ auto peopleLabel = new QLabel(tr("People"), this);

+ peopleLabel->setStyleSheet("color: white;");

+ auto roomsLabel = new QLabel(tr("Rooms"), this);

+ roomsLabel->setStyleSheet("color: white;");

+ headerLayout->addWidget(allLabel);

+ headerLayout->addWidget(peopleLabel);

+ headerLayout->addWidget(roomsLabel);

+

+ rootModel_ = new ChattablesModel(chattables_, this);

+

+ auto unreadBundle = new QtChatOverviewBundle(rootModel_, "UNREAD", true, this);

+ connect(unreadBundle, SIGNAL(clicked(JID)), this, SLOT(handleItemClicked(JID)));

+ mainLayout->addWidget(unreadBundle);

+

+ auto peopleBundle = new QtChatOverviewBundle(rootModel_, "PEOPLE", false, this);

+ connect(peopleBundle, SIGNAL(clicked(JID)), this, SLOT(handleItemClicked(JID)));

+ mainLayout->addWidget(peopleBundle);

+

+ auto roomsBundle = new QtChatOverviewBundle(rootModel_, "ROOMS", false, this);

+ connect(roomsBundle, SIGNAL(clicked(JID)), this, SLOT(handleItemClicked(JID)));

+ mainLayout->addWidget(roomsBundle);

+

+ mainLayout->addStretch();

+}

+

+QtChatOverview::~QtChatOverview() {}

+

+void QtChatOverview::handleItemClicked(JID jid) {

+ chattables_.onActivated(jid);

+}

+

+} // namespace Swift

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <QWidget>

+

+#include <Swiften/JID/JID.h>

+

+namespace Swift {

+ class Chattables;

+ class ChattablesModel;

+ class QtChatOverview : public QWidget {

+ Q_OBJECT

+ public:

+ QtChatOverview(Chattables&, QWidget* parent);

+ ~QtChatOverview() override;

+

+ private slots:

+ void handleItemClicked(JID jid);

+ private:

+ Chattables& chattables_;

+ ChattablesModel* rootModel_;

+ };

+}

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/QtUI/QtChatOverviewBundle.h>

+

+#include <QHBoxLayout>

+#include <QLabel>

+#include <QPalette>

+#include <QSortFilterProxyModel>

+#include <QVBoxLayout>

+

+#include <Swiften/Elements/StatusShow.h>

+

+#include <Swift/QtUI/ChattablesModel.h>

+#include <Swift/QtUI/QtChatOverviewDelegate.h>

+#include <Swift/QtUI/QtClickableLabel.h>

+#include <Swift/QtUI/QtExpandedListView.h>

+#include <Swift/QtUI/QtSwiftUtil.h>

+

+namespace Swift {

+

+BundleFilter::BundleFilter(QObject* parent) : QSortFilterProxyModel(parent) {

+ sort(0, Qt::AscendingOrder);

+ setDynamicSortFilter(true);

+ setSortCaseSensitivity(Qt::CaseSensitivity::CaseInsensitive);

+}

+

+void BundleFilter::addFilter(Filter filter) {

+ filters_.emplace(filter);

+ invalidateFilter();

+}

+

+bool BundleFilter::hasFilter(Filter filter) {

+ return filters_.count(filter) > 0;

+}

+

+void BundleFilter::removeFilter(Filter filter) {

+ filters_.erase(filter);

+ invalidateFilter();

+}

+

+bool BundleFilter::filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const {

+ auto row = sourceModel()->index(sourceRow, 0, sourceParent);

+ if (filters_.count(Filter::Unread)) {

+ if (row.data(ChattablesModel::UnreadCountRole).toInt() == 0) {

+ return false;

+ }

+ }

+ if (filters_.count(Filter::People)) {

+ if (row.data(ChattablesModel::TypeRole).toString() != "PERSON") {

+ return false;

+ }

+ }

+ if (filters_.count(Filter::Rooms)) {

+ if (row.data(ChattablesModel::TypeRole).toString() != "ROOM") {

+ return false;

+ }

+ }

+ if (filters_.count(Filter::Online)) {

+ if (static_cast<StatusShow::Type>(row.data(ChattablesModel::StatusRole).toInt()) == StatusShow::None) {

+ return false;

+ }

+ }

+ return true;

+}

+

+QtChatOverviewBundle::QtChatOverviewBundle(ChattablesModel* rootModel, QString name, bool hideWhenEmpty, QWidget* parent) : QWidget(parent), rootModel_(rootModel), hideWhenEmpty_(hideWhenEmpty) {

+ proxyModel_ = new BundleFilter(this);

+ if (name == "UNREAD") { // FIXME: Obviously needs a better approach

+ proxyModel_->addFilter(BundleFilter::Filter::Unread);

+ }

+ if (name == "PEOPLE") {

+ proxyModel_->addFilter(BundleFilter::Filter::People);

+ proxyModel_->addFilter(BundleFilter::Filter::Online);

+ }

+ if (name == "ROOMS") {

+ proxyModel_->addFilter(BundleFilter::Filter::Rooms);

+ proxyModel_->addFilter(BundleFilter::Filter::Online);

+ }

+ proxyModel_->setSourceModel(rootModel);

+

+

+ auto mainLayout = new QVBoxLayout();

+ setLayout(mainLayout);

+

+ auto headerLayout = new QHBoxLayout();

+ mainLayout->addLayout(headerLayout);

+ auto nameLabel = new QLabel(name, this);

+ nameLabel->setStyleSheet("color: white;");

+ headerLayout->addWidget(nameLabel);

+ headerLayout->addStretch();

+ if (!hideWhenEmpty_) {

+ filterLabel_ = new QtClickableLabel(this);

+ filterLabel_->setText(tr("Online"));

+ filterLabel_->setStyleSheet("color: white;");

+ headerLayout->addWidget(filterLabel_);

+ connect(filterLabel_, SIGNAL(clicked()), this, SLOT(handleFilterClicked()));

+ }

+ listView_ = new QtExpandedListView(this);

+ listView_->setModel(proxyModel_);

+ listView_->setFrameStyle(QFrame::NoFrame);

+ listView_->setItemDelegate(new QtChatOverviewDelegate(this));

+ connect(listView_, SIGNAL(clicked(const QModelIndex&)), this, SLOT(handleItemClicked(const QModelIndex&)));

+ mainLayout->addWidget(listView_);

+

+ if (hideWhenEmpty_) {

+ connect(proxyModel_, &QAbstractItemModel::modelReset, this, [&](){

+ updateVisibility();

+ });

+ connect(proxyModel_, &QAbstractItemModel::rowsInserted, this, [&](){

+ updateVisibility();

+ });

+ connect(proxyModel_, &QAbstractItemModel::rowsRemoved, this, [&](){

+ updateVisibility();

+ });

+ updateVisibility();

+ }

+}

+

+QtChatOverviewBundle::~QtChatOverviewBundle() {}

+

+void QtChatOverviewBundle::handleFilterClicked() {

+ if (proxyModel_->hasFilter(BundleFilter::Filter::Online)) {

+ proxyModel_->removeFilter(BundleFilter::Filter::Online);

+ filterLabel_->setText(tr("All"));

+ }

+ else {

+ proxyModel_->addFilter(BundleFilter::Filter::Online);

+ filterLabel_->setText(tr("Online"));

+ }

+}

+

+void QtChatOverviewBundle::updateVisibility() {

+ auto shouldBeVisible = (proxyModel_->rowCount(listView_->rootIndex()) > 0);

+ setVisible(shouldBeVisible);

+}

+

+

+void QtChatOverviewBundle::handleItemClicked(const QModelIndex& index) {

+ clicked(JID(Q2PSTRING(index.data(ChattablesModel::JIDRole).toString())));

+}

+

+} // namespace Swift

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <set>

+

+#include <QSortFilterProxyModel>

+#include <QString>

+#include <QWidget>

+

+#include <Swiften/JID/JID.h>

+

+class QListView;

+

+namespace Swift {

+ class ChattablesModel;

+ class QtClickableLabel;

+ class QtExpandedListView;

+

+ class BundleFilter : public QSortFilterProxyModel {

+ Q_OBJECT

+ public:

+ enum class Filter {Unread, People, Rooms, Online};

+ BundleFilter(QObject* parent);

+ void addFilter(Filter);

+ bool hasFilter(Filter);

+ void removeFilter(Filter);

+ protected:

+ bool filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const;

+ private:

+ std::set<Filter> filters_;

+ };

+

+ class QtChatOverviewBundle : public QWidget {

+ Q_OBJECT

+ public:

+ QtChatOverviewBundle(ChattablesModel*, QString name, bool hideWhenEmpty, QWidget* parent);

+ ~QtChatOverviewBundle() override;

+

+ signals:

+ void clicked(JID jid);

+

+ private slots:

+ void handleFilterClicked();

+ void handleItemClicked(const QModelIndex&);

+

+ private:

+ void updateVisibility();

+

+ private:

+ ChattablesModel* rootModel_;

+ QtExpandedListView* listView_;

+ BundleFilter* proxyModel_;

+ bool hideWhenEmpty_;

+ QtClickableLabel* filterLabel_ = nullptr;

+ };

+}

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/QtUI/QtChatOverviewDelegate.h>

+

+#include <Swiften/Elements/StatusShow.h>

+

+#include <Swift/QtUI/ChattablesModel.h>

+#include <Swift/QtUI/Roster/DelegateCommons.h>

+

+namespace Swift {

+

+QtChatOverviewDelegate::QtChatOverviewDelegate(QObject* parent) : QItemDelegate(parent), nameFont(QApplication::font()) {

+

+}

+

+QtChatOverviewDelegate::~QtChatOverviewDelegate() {}

+

+QSize QtChatOverviewDelegate::sizeHint(const QStyleOptionViewItem& /*option*/, const QModelIndex& /*index*/) const {

+ int heightByAvatar = DelegateCommons::avatarSize + DelegateCommons::verticalMargin * 2;

+ QFontMetrics nameMetrics(nameFont);

+ int sizeByText = 2 * DelegateCommons::verticalMargin + nameMetrics.height();

+ return QSize(150, sizeByText > heightByAvatar ? sizeByText : heightByAvatar);

+}

+

+void QtChatOverviewDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const {

+ painter->save();

+ QRect fullRegion(option.rect);

+ const int statusCircleRadius = 3;

+ const int horizontalMargin = 4;

+

+ QColor bgColor(38, 81, 112);

+ QPen fontPen("white"); // FIXME

+

+ if (option.state & QStyle::State_Selected) {

+ //FIXME

+ }

+ painter->fillRect(fullRegion, bgColor);

+ painter->setPen(fontPen);

+

+ QFontMetrics nameMetrics(nameFont);

+ painter->setFont(nameFont);

+ QRect nameRegion(fullRegion.adjusted((horizontalMargin + statusCircleRadius) * 2, DelegateCommons::verticalMargin, 0, 0));

+ DelegateCommons::drawElidedText(painter, nameRegion, index.data(Qt::DisplayRole).toString());

+

+ const auto green = QColor(124, 243, 145);

+ const auto yellow = QColor(243, 243, 0);

+ const auto red = QColor(255, 45, 71);

+ const auto grey = QColor(159,159,159);

+ auto circleColour = grey;

+ auto status = static_cast<StatusShow::Type>(index.data(ChattablesModel::StatusRole).toInt());

+ switch (status) {

+ case StatusShow::Online: circleColour = green; break;

+ case StatusShow::FFC: circleColour = green; break;

+ case StatusShow::Away: circleColour = yellow; break;

+ case StatusShow::XA: circleColour = yellow; break;

+ case StatusShow::DND: circleColour = red; break;

+ case StatusShow::None: circleColour = grey; break;

+ }

+

+ painter->setRenderHint(QPainter::Antialiasing, true);

+

+ int unreadCount = index.data(ChattablesModel::UnreadCountRole).toInt();

+ if (unreadCount > 0) {

+ int unreadCountSize = 16;

+ QRect unreadRect(fullRegion.right() - unreadCountSize - horizontalMargin, fullRegion.top() + (fullRegion.height() - unreadCountSize) / 2, unreadCountSize, unreadCountSize);

+ QPen pen(QColor("white"));

+ pen.setWidth(1);

+ painter->setRenderHint(QPainter::Antialiasing, true);

+ painter->setPen(pen);

+ painter->drawEllipse(unreadRect);

+ painter->setBackgroundMode(Qt::TransparentMode);

+ painter->setPen(QColor("white"));

+ DelegateCommons::drawElidedText(painter, unreadRect, QString("%1").arg(unreadCount), Qt::AlignCenter);

+ }

+

+ painter->setPen(circleColour);

+ painter->setBrush(circleColour);

+ painter->drawEllipse(fullRegion.topLeft() + QPointF(horizontalMargin + 4, fullRegion.height() / 2), statusCircleRadius, statusCircleRadius);

+

+

+ painter->restore();

+}

+

+} // namespace Swift

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <QItemDelegate>

+#include <QFont>

+

+namespace Swift {

+ class QtChatOverviewDelegate : public QItemDelegate {

+ Q_OBJECT

+ public:

+ QtChatOverviewDelegate(QObject* parent);

+ ~QtChatOverviewDelegate() override;

+ QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const override;

+ void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const override;

+ private:

+ QFont nameFont;

+ };

+}

+ * Copyright (c) 2010-2018 Isode Limited.

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

+QtChatTabs::QtChatTabs(SettingsProvider* settingsProvider, bool trellisMode) : QWidget(), settingsProvider_(settingsProvider), trellisMode_(trellisMode), dynamicGrid_(nullptr), gridSelectionDialog_(nullptr) {

+ dynamicGrid_ = new QtDynamicGridLayout(settingsProvider->getSetting(SettingConstants::FUTURE), this, trellisMode);

+ setWindowTitle("");

+ onTitleChanged("");

+QSize QtChatTabs::sizeHint() const {

+ return QSize(600, 600);

+}

+

+ * Copyright (c) 2010-2018 Isode Limited.

+ QtChatTabs(SettingsProvider* settingsProvider, bool trellisMode);

+ QSize sizeHint() const;

+ * Copyright (c) 2010-2018 Isode Limited.

+ messageLog_ = new QtWebKitChatView(this, eventStream_, theme, this, settings); // I accept that passing the ChatWindow in so that the view can call the signals is somewhat inelegant, but it saves a lot of boilerplate. This patch is unpleasant enough already. So let's fix this soon (it at least needs fixing by the time history is sorted), but not now.

+ // When used with QSplitter and setChildrenCollapsible(false), the following prevents

+ // this widget to be hidden, i.e. resized to zero width.

+ messageLog_->setMinimumWidth(20);

+

+#if defined(SWIFTEN_PLATFORM_WINDOWS) || defined(SWIFTEN_PLATFORM_LINUX)

+ //Using a emoji glyph instead of an image makes the button sizes inequal in windows & linux,

+ //so we set fixed size for both buttons, the one that is hinted for actionButton_

+ emojisButton_->setMaximumWidth(actionButton_->sizeHint().width());

+ emojisButton_->setMaximumHeight(actionButton_->sizeHint().height());

+ actionButton_->setMaximumWidth(actionButton_->sizeHint().width());

+ actionButton_->setMaximumHeight(actionButton_->sizeHint().height());

+#ifdef SWIFTEN_PLATFORM_MACOSX

+ logRosterSplitter_->setHandleWidth(0);

+#endif

+ logRosterSplitter_->setChildrenCollapsible(false);

+void QtChatWindow::setUnreadMessageCount(size_t count) {

+size_t QtChatWindow::getCount() {

+ emojisMenu_ = std::make_unique<QMenu>();

+ if (focusTimer_) {

+ focusTimer_->stop();

+ }

+ else {

+ focusTimer_ = std::make_unique<QTimer>(this);

+ focusTimer_->setSingleShot(true);

+ focusTimer_->setTimerType(Qt::CoarseTimer);

+ connect(focusTimer_.get(), &QTimer::timeout, this, &QtChatWindow::handleFocusTimerTick);

+ }

+ focusTimer_->setInterval(1000);

+ focusTimer_->start();

+ QAction* leave = nullptr;

+ case ChatWindow::Leave:

+ leave = contextMenu.addAction(tr("Leave room"));

+ leave->setEnabled(isOnline_);

+ break;

+ else if (result == leave) {

+ close();

+ }

+ if (roomBookmarkState_ != RoomNotBookmarked) {

+ QtEditBookmarkWindow* window = new QtEditBookmarkWindow(eventStream_, bookmark);

+#ifndef NOT_YET

+ QtAddBookmarkWindow* window = new QtAddBookmarkWindow(eventStream_, bookmark);

+#endif // ! NOT_YET

+void QtChatWindow::setChatSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue) {

+ auto layout = static_cast<QBoxLayout*>(this->layout());

+

+ if (securityMarkingLayout_) {

+ layout->removeItem(securityMarkingLayout_);

+ securityMarkingLayout_->removeWidget(securityMarkingDisplay_);

+ delete securityMarkingLayout_;

+ }

+ delete securityMarkingDisplay_;

+

+ securityMarkingLayout_ = new QHBoxLayout();

+ securityMarkingDisplay_ = new QLabel(P2QSTRING(markingValue));

+

+ securityMarkingLayout_->addWidget(securityMarkingDisplay_);

+ layout->insertLayout(1, securityMarkingLayout_);

+

+ auto palette = securityMarkingDisplay_->palette();

+ palette.setColor(securityMarkingDisplay_->foregroundRole(), P2QSTRING(markingForegroundColorValue));

+ palette.setColor(securityMarkingDisplay_->backgroundRole(), P2QSTRING(markingBackgroundColorValue));

+

+ securityMarkingDisplay_->setPalette(palette);

+ securityMarkingDisplay_->setContentsMargins(4,4,4,4);

+ securityMarkingDisplay_->setAutoFillBackground(true);

+ securityMarkingDisplay_->setAlignment(Qt::AlignCenter);

+}

+

+void QtChatWindow::removeChatSecurityMarking() {

+ if (!securityMarkingLayout_) {

+ return;

+ }

+

+ auto layout = static_cast<QBoxLayout*>(this->layout());

+

+ layout->removeItem(securityMarkingLayout_);

+ securityMarkingLayout_->removeWidget(securityMarkingDisplay_);

+

+ delete securityMarkingDisplay_;

+ delete securityMarkingLayout_;

+ securityMarkingDisplay_ = nullptr;

+ securityMarkingLayout_ = nullptr;

+}

+

+void QtChatWindow::handleFocusTimerTick() {

+ if (hasFocus()) {

+ onAllMessagesRead();

+ }

+ focusTimer_.reset();

+}

+

+void QtChatWindow::resendMessage(const std::string& id) {

+ if (!isOnline_ || (blockingState_ == IsBlocked)) {

+ return;

+ }

+ onResendMessageRequest(id);

+}

+

+ * Copyright (c) 2010-2018 Isode Limited.

+class QTimer;

+ void resendMessage(const std::string& id);