/*

* All rights reserved.

* See the COPYING file for more information.

*/

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

#include <memory>

#include <boost/bind.hpp>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Base/String.h>

#include <Swiften/Disco/DiscoServiceWalker.h>

#include <Swiften/Disco/GetDiscoInfoRequest.h>

#include <Swiften/Disco/GetDiscoItemsRequest.h>

#include <Swiften/Presence/PresenceOracle.h>

#include <Swiften/VCards/VCardManager.h>

#include <Swift/Controllers/ContactEditController.h>

#include <Swift/Controllers/ContactSuggester.h>

#include <Swift/Controllers/Intl.h>

#include <Swift/Controllers/ProfileSettingsProvider.h>

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

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

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

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

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

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

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

window_->onJIDAddRequested.disconnect(boost::bind(&UserSearchController::handleJIDAddRequested, this, _1));

window_->onJIDEditFieldChanged.disconnect(boost::bind(&UserSearchController::handleJIDEditingFinished, this, _1));

delete window_;

}

presenceOracle_->onPresenceChange.disconnect(boost::bind(&UserSearchController::handlePresenceChanged, this, _1));

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

vcardManager_->onVCardChanged.disconnect(boost::bind(&UserSearchController::handleVCardChanged, this, _1, _2));

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

}

UserSearchWindow* UserSearchController::getUserSearchWindow() {

initializeUserWindow();

assert(window_);

return window_;

}

void UserSearchController::setCanInitiateImpromptuMUC(bool supportsImpromptu) {

if (!window_) {

initializeUserWindow();

}

if (window_) {

window_->setCanStartImpromptuChats(supportsImpromptu);

} // Else doesn't support search

}

void UserSearchController::handleUIEvent(std::shared_ptr<UIEvent> event) {

bool handle = false;

std::shared_ptr<RequestAddUserDialogUIEvent> addUserRequest = std::shared_ptr<RequestAddUserDialogUIEvent>();

auto inviteToMUCRequest = RequestInviteToMUCUIEvent::ref();

switch (type_) {

if ((addUserRequest = std::dynamic_pointer_cast<RequestAddUserDialogUIEvent>(event))) {

handle = true;

}

break;

if (std::dynamic_pointer_cast<RequestChatWithUserDialogUIEvent>(event)) {

handle = true;

}

break;

if ((inviteToMUCRequest = std::dynamic_pointer_cast<RequestInviteToMUCUIEvent>(event))) {

handle = true;

}

break;

}

if (handle) {

initializeUserWindow();

window_->show();

window_->addSavedServices(savedDirectories_);

if (addUserRequest) {

const std::string& name = addUserRequest->getPredefinedName();

const JID& jid = addUserRequest->getPredefinedJID();

if (!name.empty() && jid.isValid()) {

window_->prepopulateJIDAndName(jid, name);

}

}

else if (inviteToMUCRequest) {

window_->setCanSupplyDescription(!inviteToMUCRequest->isImpromptu());

window_->setJIDs(inviteToMUCRequest->getInvites());

window_->setOriginator(inviteToMUCRequest->getOriginator());

}

return;

}

}

void UserSearchController::handleFormRequested(const JID& service) {

window_->setSearchError(false);

window_->setServerSupportsSearch(true);

//Abort a previous search if is active

if (rosterController_->getItem(jid)) {

window_->setWarning(QT_TRANSLATE_NOOP("", "This contact is already on your contact list."));

}

else if (jid.getNode().empty()) {

window_->setWarning(QT_TRANSLATE_NOOP("", "Part of the address you have entered is missing. An address has a structure of 'user@example.com'."));

}

else {

window_->setWarning(boost::optional<std::string>());

}

}

else {

window_->setWarning(QT_TRANSLATE_NOOP("", "The address you have entered is invalid."));

}

}

void UserSearchController::handleContactSuggestionsRequested(std::string text) {

const std::vector<JID> existingJIDs = window_->getJIDs();

std::vector<Contact::ref> suggestions = contactSuggester_->getSuggestions(text, false);

/* do not suggest contacts that have already been added to the chat list */

std::vector<Contact::ref>::iterator i = suggestions.begin();

while (i != suggestions.end()) {

bool found = false;

for (const auto& jid : existingJIDs) {

if ((*i)->jid == jid) {

found = true;

break;

}

}

// remove contact suggestions which are already on the contact list in add-contact-mode

if (!found && !!rosterController_->getItem((*i)->jid)) {

found = true;

}

}

if (found) {

i = suggestions.erase(i);

} else {

i++;

}

}

window_->setContactSuggestions(suggestions);

}

void UserSearchController::handleVCardChanged(const JID& jid, VCard::ref vcard) {

if (jid == suggestionsJID_) {

window_->setNameSuggestions(ContactEditController::nameSuggestionsFromVCard(vcard));

suggestionsJID_ = JID();

}

handleJIDUpdateRequested(std::vector<JID>(1, jid));

}

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

handleJIDUpdateRequested(std::vector<JID>(1, jid));

}

void UserSearchController::handlePresenceChanged(Presence::ref presence) {

handleJIDUpdateRequested(std::vector<JID>(1, presence->getFrom().toBare()));

}

contact->name = rosterItem->getName();

} else {

VCard::ref vcard = vcardManager_->getVCard(jid);

if (vcard && !vcard->getFullName().empty()) {

contact->name = vcard->getFullName();

} else {

contact->name = jid.toString();

}

}

// presence lookup

Presence::ref presence = presenceOracle_->getAccountPresence(jid);

if (presence) {

contact->statusType = presence->getShow();

} else {

contact->statusType = StatusShow::None;

}

// avatar lookup

contact->avatarPath = avatarManager_->getAvatarPath(jid);

return contact;

}

void UserSearchController::handleDiscoWalkFinished() {

window_->setServerSupportsSearch(false);

endDiscoWalker();

}

void UserSearchController::initializeUserWindow() {

if (!window_) {

switch(type_) {

break;

break;

break;

}

window_ = factory_->createUserSearchWindow(windowType, uiEventStream_, rosterController_->getGroups());

if (!window_) {

// UI Doesn't support user search

return;

}

window_->onNameSuggestionRequested.connect(boost::bind(&UserSearchController::handleNameSuggestionRequest, this, _1));

window_->onFormRequested.connect(boost::bind(&UserSearchController::handleFormRequested, this, _1));

window_->onSearchRequested.connect(boost::bind(&UserSearchController::handleSearch, this, _1, _2));

window_->onContactSuggestionsRequested.connect(boost::bind(&UserSearchController::handleContactSuggestionsRequested, this, _1));

window_->onJIDUpdateRequested.connect(boost::bind(&UserSearchController::handleJIDUpdateRequested, this, _1));

window_->onJIDAddRequested.connect(boost::bind(&UserSearchController::handleJIDAddRequested, this, _1));

window_->onJIDEditFieldChanged.connect(boost::bind(&UserSearchController::handleJIDEditingFinished, this, _1));

window_->setSelectedService(JID(jid_.getDomain()));

window_->clear();

}

}

void UserSearchController::loadSavedDirectories() {

savedDirectories_.clear();

for (auto&& stringItem : String::split(settings_->getStringSetting(SEARCHED_DIRECTORIES), '\n')) {

if(!stringItem.empty()) {

savedDirectories_.push_back(JID(stringItem));

}

}

}

void UserSearchController::addToSavedDirectories(const JID& jid) {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <map>

#include <memory>

#include <string>

#include <vector>

#include <boost/signals2.hpp>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/DiscoItems.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Elements/SearchPayload.h>

#include <Swiften/Elements/VCard.h>

#include <Swiften/JID/JID.h>

#include <Swift/Controllers/Contact.h>

namespace Swift {

class UIEventStream;

class UIEvent;

class UserSearchWindow;

class UserSearchWindowFactory;

class IQRouter;

class DiscoServiceWalker;

class RosterController;

class VCardManager;

class ContactSuggester;

class AvatarManager;

class PresenceOracle;

class ProfileSettingsProvider;

class UserSearchResult {

public:

UserSearchResult(const JID& jid, const std::map<std::string, std::string>& fields) : jid_(jid), fields_(fields) {}

const JID& getJID() const {return jid_;}

const std::map<std::string, std::string>& getFields() const {return fields_;}

private:

JID jid_;

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

};

class UserSearchController {

public:

UserSearchController(Type type, const JID& jid, UIEventStream* uiEventStream, VCardManager* vcardManager, UserSearchWindowFactory* userSearchWindowFactory, IQRouter* iqRouter, RosterController* rosterController, ContactSuggester* contactSuggester, AvatarManager* avatarManager, PresenceOracle* presenceOracle, ProfileSettingsProvider* settings);

~UserSearchController();

UserSearchWindow* getUserSearchWindow();

void setCanInitiateImpromptuMUC(bool supportsImpromptu);

private:

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

void handleFormRequested(const JID& service);

void handleDiscoServiceFound(const JID& jid, std::shared_ptr<DiscoInfo> info);

void handleDiscoWalkFinished();

void handleFormResponse(std::shared_ptr<SearchPayload> items, ErrorPayload::ref error);

void handleSearch(std::shared_ptr<SearchPayload> fields, const JID& jid);

void handleSearchResponse(std::shared_ptr<SearchPayload> results, ErrorPayload::ref error);

void handleNameSuggestionRequest(const JID& jid);

void handleContactSuggestionsRequested(std::string text);

void handleVCardChanged(const JID& jid, VCard::ref vcard);

void handleAvatarChanged(const JID& jid);

void handlePresenceChanged(Presence::ref presence);

void handleJIDUpdateRequested(const std::vector<JID>& jids);

void handleJIDAddRequested(const std::vector<JID>& jids);

void handleJIDEditingFinished(const JID& jid);

Contact::ref convertJIDtoContact(const JID& jid);

void endDiscoWalker();

void initializeUserWindow();

void loadSavedDirectories();

void addToSavedDirectories(const JID& jid);

private:

if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

purgeCachedCredentials();

}

bool freshLogin = rosterController_ == nullptr;

myStatusLooksOnline_ = true;

if (freshLogin) {

profileController_ = new ProfileController(client_->getVCardManager(), uiFactory_, uiEventStream_);

showProfileController_ = new ShowProfileController(client_->getVCardManager(), uiFactory_, uiEventStream_);

ftOverview_ = new FileTransferOverview(client_->getFileTransferManager());

fileTransferListController_->setFileTransferOverview(ftOverview_);

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

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

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

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

blockListController_ = new BlockListController(client_->getClientBlockListManager(), uiEventStream_, uiFactory_, eventController_);

contactEditController_ = new ContactEditController(rosterController_, client_->getVCardManager(), uiFactory_, uiEventStream_);

whiteboardManager_ = new WhiteboardManager(uiFactory_, uiEventStream_, client_->getNickResolver(), client_->getWhiteboardSessionManager());

/* Doing this early as an ordering fix. Various things later will

* want to have the user's nick available and this means it will

* be before they receive stanzas that need it (e.g. bookmarks).*/

client_->getVCardManager()->requestOwnVCard();

contactSuggesterWithoutRoster_ = new ContactSuggester();

contactSuggesterWithRoster_ = new ContactSuggester();

#ifdef SWIFT_EXPERIMENTAL_HISTORY

historyController_ = new HistoryController(storages_->getHistoryStorage());

historyViewController_ = new HistoryViewController(jid_, uiEventStream_, historyController_, client_->getNickResolver(), client_->getAvatarManager(), client_->getPresenceOracle(), uiFactory_);

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_, historyController_, whiteboardManager_, highlightManager_, client_->getClientBlockListManager(), emoticons_, client_->getVCardManager());

#else

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

#endif

contactsFromRosterProvider_ = new ContactsFromXMPPRoster(client_->getRoster(), client_->getAvatarManager(), client_->getPresenceOracle());

contactSuggesterWithoutRoster_->addContactProvider(chatsManager_);

contactSuggesterWithRoster_->addContactProvider(chatsManager_);

contactSuggesterWithRoster_->addContactProvider(contactsFromRosterProvider_);

highlightEditorController_->setContactSuggester(contactSuggesterWithoutRoster_);

client_->onMessageReceived.connect(boost::bind(&ChatsManager::handleIncomingMessage, chatsManager_, _1));

chatsManager_->setAvatarManager(client_->getAvatarManager());

eventWindowController_ = new EventWindowController(eventController_, uiFactory_);

loginWindow_->morphInto(rosterController_->getWindow());

DiscoInfo discoInfo;

discoInfo.addIdentity(DiscoInfo::Identity(CLIENT_NAME, "client", "pc"));

discoInfo.addFeature(DiscoInfo::ChatStatesFeature);

discoInfo.addFeature(DiscoInfo::SecurityLabelsFeature);

discoInfo.addFeature(DiscoInfo::MessageCorrectionFeature);

#ifdef SWIFT_EXPERIMENTAL_FT

discoInfo.addFeature(DiscoInfo::JingleFeature);

discoInfo.addFeature(DiscoInfo::JingleFTFeature);

discoInfo.addFeature(DiscoInfo::JingleTransportsIBBFeature);

discoInfo.addFeature(DiscoInfo::JingleTransportsS5BFeature);

#endif

#ifdef SWIFT_EXPERIMENTAL_WB

discoInfo.addFeature(DiscoInfo::WhiteboardFeature);

#endif

discoInfo.addFeature(DiscoInfo::MessageDeliveryReceiptsFeature);

client_->getDiscoManager()->setCapsNode(CLIENT_NODE);

client_->getDiscoManager()->setDiscoInfo(discoInfo);

adHocManager_ = new AdHocManager(JID(boundJID_.getDomain()), uiFactory_, client_->getIQRouter(), uiEventStream_, rosterController_->getWindow());

chatsManager_->onImpromptuMUCServiceDiscovered.connect(boost::bind(&UserSearchController::setCanInitiateImpromptuMUC, userSearchControllerChat_, _1));

}

loginWindow_->setIsLoggingIn(false);

client_->requestRoster();

GetDiscoInfoRequest::ref discoInfoRequest = GetDiscoInfoRequest::create(JID(boundJID_.getDomain()), client_->getIQRouter());

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

discoInfoRequest->send();

client_->getVCardManager()->requestOwnVCard();

rosterController_->setJID(boundJID_);

rosterController_->setEnabled(true);

rosterController_->getWindow()->setStreamEncryptionStatus(client_->isStreamEncrypted());

profileController_->setAvailable(true);

contactEditController_->setAvailable(true);

/* Send presence later to catch all the incoming presences. */

sendPresence(statusTracker_->getNextPresence());

/* Enable chats last of all, so rejoining MUCs has the right sent presence */

assert(chatsManager_);

chatsManager_->setOnline(true);

adHocManager_->setOnline(true);

}

void MainController::handleEventQueueLengthChange(int count) {

dock_->setNumberOfPendingMessages(count);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <string>

#include <vector>

#include <boost/signals2.hpp>

#include <Swiften/JID/JID.h>

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

#include <Swift/Controllers/Contact.h>

namespace Swift {

class UserSearchWindow {

public:

virtual ~UserSearchWindow() {}

virtual void clear() = 0;

virtual void setResults(const std::vector<UserSearchResult>& results) = 0;

virtual void setResultsForm(const Form::ref results) = 0;

virtual void addSavedServices(const std::vector<JID>& services) = 0;

virtual void setSelectedService(const JID& service) = 0;

virtual void setServerSupportsSearch(bool support) = 0;

virtual void setSearchError(bool support) = 0;

virtual void setSearchFields(std::shared_ptr<SearchPayload> fields) = 0;

virtual void setNameSuggestions(const std::vector<std::string>& suggestions) = 0;

virtual void prepopulateJIDAndName(const JID& jid, const std::string& name) = 0;

virtual void setContactSuggestions(const std::vector<Contact::ref>& suggestions) = 0;

virtual void setJIDs(const std::vector<JID>&) = 0;

virtual void setOriginator(const JID& originator) = 0;

virtual void setRoomJID(const JID& roomJID) = 0;

virtual std::string getReason() const = 0;

virtual std::vector<JID> getJIDs() const = 0;

virtual void setCanStartImpromptuChats(bool supportsImpromptu) = 0;

virtual void updateContacts(const std::vector<Contact::ref>& contacts) = 0;

virtual void addContacts(const std::vector<Contact::ref>& contacts) = 0;

virtual void setCanSupplyDescription(bool allowed) = 0;

virtual void setWarning(const boost::optional<std::string>& message) = 0;

virtual void show() = 0;

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

boost::signals2::signal<void (std::shared_ptr<SearchPayload>, const JID&)> onSearchRequested;

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

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