/*

* 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;

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/QtUI/UserSearch/QtUserSearchFirstMultiJIDPage.h>

#include <QMessageBox>

#include <QMimeData>

#include <QUrl>

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

#include <Swift/QtUI/QtSwiftUtil.h>

#include <Swift/QtUI/UserSearch/QtContactListWidget.h>

#include <Swift/QtUI/UserSearch/QtSuggestingJIDInput.h>

namespace Swift {

QtUserSearchFirstMultiJIDPage::QtUserSearchFirstMultiJIDPage(UserSearchWindow::Type type, const QString& title, SettingsProvider* settings) {

setupUi(this);

setTitle(title);

QString introText = "";

switch (type) {

introText = tr("Add another user to your contact list");

break;

introText = tr("Chat to another user");

break;

introText = tr("Invite contact to chat");

break;

}

setSubTitle(QString(tr("%1. If you know their address you can enter it directly, or you can search for them.")).arg(introText));

contactList_ = new QtContactListWidget(this, settings);

horizontalLayout_5->addWidget(contactList_);

jid_ = new QtSuggestingJIDInput(this, settings);

horizontalLayout_6->insertWidget(0, jid_);

connect(contactList_, SIGNAL(onListChanged(std::vector<Contact::ref>)), this, SLOT(emitCompletenessCheck()));

connect(jid_, SIGNAL(editingDone()), this, SLOT(handleEditingDone()));

setAcceptDrops(true);

}

bool QtUserSearchFirstMultiJIDPage::isComplete() const {

return !contactList_->getList().empty();

}

void QtUserSearchFirstMultiJIDPage::reset() {

jid_->clear();

reason_->clear();

}

void QtUserSearchFirstMultiJIDPage::emitCompletenessCheck() {

emit completeChanged();

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/QtUI/UserSearch/QtUserSearchFirstPage.h>

#include <Swiften/Base/Log.h>

#include <Swift/QtUI/QtSwiftUtil.h>

namespace Swift {

QtUserSearchFirstPage::QtUserSearchFirstPage(UserSearchWindow::Type type, const QString& title, SettingsProvider* settings) {

setupUi(this);

setTitle(title);

jid_ = new QtSuggestingJIDInput(this, settings);

horizontalLayout_2->addWidget(jid_);

jidWarning_ = new QLabel(this);

jidWarning_->setPixmap(QPixmap(":icons/warn.png"));

jidWarning_->hide();

horizontalLayout_2->addWidget(jidWarning_);

setTabOrder(byJID_, jid_);

setTabOrder(jid_, byLocalSearch_);

setTabOrder(byLocalSearch_, byRemoteSearch_);

connect(jid_, SIGNAL(textChanged(const QString&)), this, SLOT(emitCompletenessCheck()));

connect(jid_, SIGNAL(editingDone()), this, SLOT(emitCompletenessCheck()));

connect(service_->lineEdit(), SIGNAL(textChanged(const QString&)), this, SLOT(emitCompletenessCheck()));

}

bool QtUserSearchFirstPage::isComplete() const {

bool complete = false;

if (byJID_->isChecked()) {

complete = JID(Q2PSTRING(jid_->text().trimmed())).isValid() && jidWarning_->toolTip().isEmpty();

} else if (byLocalSearch_->isChecked()) {

complete = true;

} else if (byRemoteSearch_->isChecked()) {

complete = JID(Q2PSTRING(service_->currentText().trimmed())).isValid();

}

return complete;

}

void QtUserSearchFirstPage::emitCompletenessCheck() {

emit completeChanged();

}

#include <Swift/QtUI/UserSearch/QtUserSearchWindow.h>

#include <memory>

#include <boost/bind.hpp>

#include <QItemDelegate>

#include <QModelIndex>

#include <QMovie>

#include <QWizardPage>

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

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

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

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

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

#include <Swift/QtUI/QtFormResultItemModel.h>

#include <Swift/QtUI/QtSwiftUtil.h>

#include <Swift/QtUI/UserSearch/QtContactListWidget.h>

#include <Swift/QtUI/UserSearch/QtUserSearchDetailsPage.h>

#include <Swift/QtUI/UserSearch/QtUserSearchFieldsPage.h>

#include <Swift/QtUI/UserSearch/QtUserSearchFirstMultiJIDPage.h>

#include <Swift/QtUI/UserSearch/QtUserSearchFirstPage.h>

#include <Swift/QtUI/UserSearch/QtUserSearchResultsPage.h>

#include <Swift/QtUI/UserSearch/UserSearchDelegate.h>

#include <Swift/QtUI/UserSearch/UserSearchModel.h>

namespace Swift {

setupUi(this);

#ifndef Q_OS_MAC

#ifdef Q_OS_WIN32

setWindowIcon(QIcon(":/logo-icon-16-win.png"));

#else

setWindowIcon(QIcon(":/logo-icon-16.png"));

#endif

#endif

QString title;

switch(type) {

title = tr("Add Contact");

break;

title = tr("Chat to Users");

break;

title = tr("Add Users to Chat");

break;

}

setWindowTitle(title);

delegate_ = new UserSearchDelegate(this);

setFirstPage(title);

setSecondPage();

setThirdPage();

detailsPage_ = new QtUserSearchDetailsPage(groups);

setPage(4, detailsPage_);

connect(this, SIGNAL(currentIdChanged(int)), this, SLOT(handleCurrentChanged(int)));

connect(this, SIGNAL(accepted()), this, SLOT(handleAccepted()));

clear();

}

QtUserSearchWindow::~QtUserSearchWindow() {

delete model_;

}

void QtUserSearchWindow::handleCurrentChanged(int page) {

searchNext_ = false;

firstMultiJIDPage_->reset();

}

resultsPage_->emitCompletenessCheck();

addSearchedJIDToList(getContact());

setSecondPage();

}

else if (page == 2 && lastPage_ == 1) {

setError("");

/* next won't be called if JID is selected */

JID server = getServerToSearch();

clearForm();

onFormRequested(server);

setThirdPage();

}

else if (page == 3 && lastPage_ == 2) {

JID server = getServerToSearch();

handleSearch();

bool remote = firstPage_->byRemoteSearch_->isChecked();

firstPage_->byRemoteSearch_->setChecked(remote);

firstPage_->service_->setEditText(P2QSTRING(server.toString()));

} else {

bool remote = firstMultiJIDPage_->byRemoteSearch_->isChecked();

setFirstPage();

firstMultiJIDPage_->byRemoteSearch_->setChecked(remote);

if (remote) {

firstMultiJIDPage_->service_->setEditText(P2QSTRING(server.toString()));

}

}

}

else if (page == 4) {

detailsPage_->clear();

detailsPage_->setJID(getContactJID());

onNameSuggestionRequested(getContactJID());

}

lastPage_ = page;

}

JID QtUserSearchWindow::getServerToSearch() {

return firstPage_->byRemoteSearch_->isChecked() ? JID(Q2PSTRING(firstPage_->service_->currentText().trimmed())) : myServer_;

}

else {

return firstMultiJIDPage_->byRemoteSearch_->isChecked() ? JID(Q2PSTRING(firstMultiJIDPage_->service_->currentText().trimmed())) : myServer_;

}

}

void QtUserSearchWindow::handleAccepted() {

JID jid;

std::vector<JID> jids;

switch(type_) {

jid = getContactJID();

eventStream_->send(std::make_shared<AddContactUIEvent>(jid, detailsPage_->getName(), detailsPage_->getSelectedGroups()));

break;

if (contactVector_.size() == 1) {

std::shared_ptr<UIEvent> event(new RequestChatUIEvent(contactVector_[0]->jid));

eventStream_->send(event);

break;

}

for (Contact::ref contact : contactVector_) {

jids.push_back(contact->jid);

}

eventStream_->send(std::make_shared<CreateImpromptuMUCUIEvent>(jids, Q2PSTRING(firstMultiJIDPage_->reason_->text())));

break;

for (Contact::ref contact : contactVector_) {

jids.push_back(contact->jid);

}

eventStream_->send(std::make_shared<InviteToMUCUIEvent>(originatorJID_, jids, Q2PSTRING(firstMultiJIDPage_->reason_->text())));

break;

}

}

void QtUserSearchWindow::handleContactSuggestionRequested(const QString& text) {

std::string stdText = Q2PSTRING(text);

onContactSuggestionsRequested(stdText);

}

void QtUserSearchWindow::addContact() {

auto contactToAdd = firstMultiJIDPage_->jid_->getContact();

if (!!contactToAdd) {

contactVector_.push_back(contactToAdd);

firstMultiJIDPage_->jid_->clear();

}

firstMultiJIDPage_->contactList_->setList(contactVector_);

firstMultiJIDPage_->emitCompletenessCheck();

firstMultiJIDPage_->groupBox->setEnabled(supportsImpromptu_ ? 1 : (contactVector_.size() < 1));

}

if (!!contactToAdd && contactToAdd->jid.isValid() && contactToAdd->statusType == StatusShow::None) {

onJIDUpdateRequested({contactToAdd->jid});

}

}

void QtUserSearchWindow::setWarning(const boost::optional<std::string>& message) {

if (message) {

firstPage_->jidWarning_->setToolTip(P2QSTRING((*message)));

firstPage_->jidWarning_->setAccessibleDescription(P2QSTRING((*message)));

firstPage_->jidWarning_->show();

}

else {

firstPage_->jidWarning_->setToolTip("");

firstPage_->jidWarning_->setAccessibleDescription("");

firstPage_->jidWarning_->hide();

}

firstPage_->emitCompletenessCheck();

}

int QtUserSearchWindow::nextId() const {

switch (currentId()) {

case 2: return 3;

case 4: return -1;

default: return -1;

}

} else {

switch (currentId()) {

case 1: return searchNext_ ? 2 : -1;

case 2: return 3;

case 3: return 1;

case 4: return -1;

default: return -1;

}

}

}

void QtUserSearchWindow::handleFirstPageRadioChange() {

if (firstPage_->byJID_->isChecked()) {

firstPage_->jid_->setText("");

firstPage_->jid_->setEnabled(true);

firstPage_->service_->setEnabled(false);

restart();

}

else if (firstPage_->byRemoteSearch_->isChecked()) {

firstPage_->service_->setEditText("");

firstPage_->jid_->setEnabled(false);

firstPage_->service_->setEnabled(true);

//firstPage_->jid_->setText("");

restart();

}

else {

firstPage_->jid_->setEnabled(false);

restart();

}

}

void QtUserSearchWindow::handleSearch() {

std::shared_ptr<SearchPayload> search(new SearchPayload());

if (fieldsPage_->getFormWidget()) {

search->setForm(fieldsPage_->getFormWidget()->getCompletedForm());

search->getForm()->clearEmptyTextFields();

} else {

if (fieldsPage_->nickInput_->isEnabled() && !fieldsPage_->nickInput_->text().isEmpty()) {

search->setNick(Q2PSTRING(fieldsPage_->nickInput_->text()));

}

if (fieldsPage_->firstInput_->isEnabled() && !fieldsPage_->firstInput_->text().isEmpty()) {

search->setFirst(Q2PSTRING(fieldsPage_->firstInput_->text()));

}

if (fieldsPage_->lastInput_->isEnabled() && !fieldsPage_->lastInput_->text().isEmpty()) {

search->setLast(Q2PSTRING(fieldsPage_->lastInput_->text()));

}

if (fieldsPage_->emailInput_->isEnabled() && !fieldsPage_->emailInput_->text().isEmpty()) {

search->setEMail(Q2PSTRING(fieldsPage_->emailInput_->text()));

}

}

onSearchRequested(search, getServerToSearch());

}

JID QtUserSearchWindow::getContactJID() const {

JID jid;

bool useSearchResult;

useSearchResult = !firstPage_->byJID_->isChecked();

} else {

useSearchResult = true;

}

if (useSearchResult) {

if (dynamic_cast<UserSearchModel*>(model_)) {

UserSearchResult* userItem = static_cast<UserSearchResult*>(resultsPage_->results_->currentIndex().internalPointer());

if (userItem) { /* Remember to leave this if we change to dynamic cast */

jid = userItem->getJID();

}

} else if (dynamic_cast<QtFormResultItemModel*>(model_)) {

int row = resultsPage_->results_->currentIndex().row();

Form::FormItem item = dynamic_cast<QtFormResultItemModel*>(model_)->getForm()->getItems().at(row);

JID fallbackJid;

for (FormField::ref field : item) {

if (field->getType() == FormField::JIDSingleType) {

jid = JID(field->getJIDSingleValue());

break;

}

if (field->getName() == "jid") {

fallbackJid = field->getValues()[0];

}

}

if (!jid.isValid()) {

jid = fallbackJid;

}

}

}

else {

jid = JID(Q2PSTRING(firstPage_->jid_->text().trimmed()));

}

return jid;

}

Contact::ref QtUserSearchWindow::getContact() const {

return std::make_shared<Contact>("", getContactJID(), StatusShow::None, "");

}

void QtUserSearchWindow::addSearchedJIDToList(const Contact::ref& contact) {

std::vector<JID> jids;

jids.push_back(contact->jid);

handleJIDsAdded(jids);

firstMultiJIDPage_->jid_->clear();

}

void QtUserSearchWindow::handleOnSearchedJIDSelected(const Contact::ref& contact) {

firstPage_->jid_->setText(P2QSTRING(contact->jid.toString()));

}

void QtUserSearchWindow::show() {

clear();

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

}

QWidget::show();

raise();

}

void QtUserSearchWindow::addSavedServices(const std::vector<JID>& services) {

firstPage_->service_->clear();

for (auto&& jid : services) {

firstPage_->service_->addItem(P2QSTRING(jid.toString()));

}

firstPage_->service_->clearEditText();

} else {

firstMultiJIDPage_->service_->clear();

for (auto&& jid : services) {

firstMultiJIDPage_->service_->addItem(P2QSTRING(jid.toString()));

}

firstMultiJIDPage_->service_->clearEditText();

}

}

void QtUserSearchWindow::setSearchFields(std::shared_ptr<SearchPayload> fields) {

fieldsPage_->fetchingThrobber_->hide();

fieldsPage_->fetchingThrobber_->movie()->stop();

fieldsPage_->fetchingLabel_->hide();

fieldsPage_->instructionsLabel_->setText(fields->getInstructions() ? P2QSTRING(fields->getInstructions().get()) : "Enter search terms");

if (fields->getForm()) {

fieldsPage_->setFormWidget(new QtFormWidget(fields->getForm(), fieldsPage_));

} else {

fieldsPage_->setFormWidget(nullptr);

bool enabled[8] = {!!fields->getNick(), !!fields->getNick(), !!fields->getFirst(), !!fields->getFirst(), !!fields->getLast(), !!fields->getLast(), !!fields->getEMail(), !!fields->getEMail()};

QWidget* legacySearchWidgets[8] = {fieldsPage_->nickInputLabel_, fieldsPage_->nickInput_, fieldsPage_->firstInputLabel_, fieldsPage_->firstInput_, fieldsPage_->lastInputLabel_, fieldsPage_->lastInput_, fieldsPage_->emailInputLabel_, fieldsPage_->emailInput_};

for (int i = 0; i < 8; i++) {

legacySearchWidgets[i]->setVisible(enabled[i]);

legacySearchWidgets[i]->setEnabled(enabled[i]);

}

}

fieldsPage_->emitCompletenessCheck();

}

void QtUserSearchWindow::setNameSuggestions(const std::vector<std::string>& suggestions) {

if (detailsPage_) {

detailsPage_->setNameSuggestions(suggestions);

}

}

void QtUserSearchWindow::prepopulateJIDAndName(const JID& jid, const std::string& name) {

firstPage_->jid_->setText(P2QSTRING(jid.toBare().toString()));

detailsPage_->setJID(jid);

lastPage_ = 1;

restart();

next();

detailsPage_->setName(name);

}

void QtUserSearchWindow::setContactSuggestions(const std::vector<Contact::ref>& suggestions) {

firstPage_->jid_->setSuggestions(suggestions);

} else {

firstMultiJIDPage_->jid_->setSuggestions(suggestions);

}

}

void QtUserSearchWindow::setJIDs(const std::vector<JID> &jids) {

for (auto&& jid : jids) {

addSearchedJIDToList(std::make_shared<Contact>("", jid, StatusShow::None, ""));

}

onJIDUpdateRequested(jids);

}

void QtUserSearchWindow::setOriginator(const JID& originator) {

originatorJID_ = originator;

}

void QtUserSearchWindow::setRoomJID(const JID& roomJID) {

roomJID_ = roomJID;

}

std::string QtUserSearchWindow::getReason() const {

return Q2PSTRING(firstMultiJIDPage_->reason_->text());

}

std::vector<JID> QtUserSearchWindow::getJIDs() const {

std::vector<JID> jids;

for (Contact::ref contact : contactVector_) {

jids.push_back(contact->jid);

}

return jids;

}

void QtUserSearchWindow::setCanStartImpromptuChats(bool supportsImpromptu) {

supportsImpromptu_ = supportsImpromptu;

firstMultiJIDPage_->contactList_->setMaximumNoOfContactsToOne(!supportsImpromptu_);

}

}

void QtUserSearchWindow::updateContacts(const std::vector<Contact::ref>& contacts) {

firstMultiJIDPage_->contactList_->updateContacts(contacts);

}

}

void QtUserSearchWindow::addContacts(const std::vector<Contact::ref>& contacts) {

/* prevent duplicate JIDs from appearing in the contact list */

for (Contact::ref newContact : contacts) {

bool found = false;

for (Contact::ref oldContact : contactVector_) {

if (newContact->jid == oldContact->jid) {

found = true;

break;

}

}

if (!found) {

contactVector_.push_back(newContact);

}

}

contactVector_.resize(1); /* can't chat with more than one user */

}

firstMultiJIDPage_->contactList_->setList(contactVector_);

firstMultiJIDPage_->emitCompletenessCheck();

firstMultiJIDPage_->groupBox->setEnabled(supportsImpromptu_ ? true : (contactVector_.size() < 1));

}

}

}

void QtUserSearchWindow::setCanSupplyDescription(bool allowed) {

firstMultiJIDPage_->label->setVisible(allowed);

firstMultiJIDPage_->reason_->setVisible(allowed);

}

void QtUserSearchWindow::handleAddViaSearch() {

searchNext_ = true;

next();

}

void QtUserSearchWindow::handleListChanged(std::vector<Contact::ref> list) {

contactVector_ = list;

firstMultiJIDPage_->groupBox->setEnabled(supportsImpromptu_ ? 1 : (contactVector_.size() < 1));

}

}

void QtUserSearchWindow::handleJIDsAdded(std::vector<JID> jids) {

onJIDAddRequested(jids);

}

void QtUserSearchWindow::setResults(const std::vector<UserSearchResult>& results) {

UserSearchModel *newModel = new UserSearchModel();

newModel->setResults(results);

resultsPage_->results_->setModel(newModel);

resultsPage_->results_->setItemDelegate(delegate_);

resultsPage_->results_->setHeaderHidden(true);

delete model_;

model_ = newModel;

resultsPage_->setNoResults(model_->rowCount() == 0);

resultsPage_->emitCompletenessCheck();

}

void QtUserSearchWindow::setResultsForm(Form::ref results) {

QtFormResultItemModel *newModel = new QtFormResultItemModel(this);

newModel->setForm(results);

resultsPage_->results_->setModel(newModel);

resultsPage_->results_->setItemDelegate(new QItemDelegate());

resultsPage_->results_->setHeaderHidden(false);

#if QT_VERSION >= 0x050000

resultsPage_->results_->header()->setSectionResizeMode(QHeaderView::ResizeToContents);

#else

resultsPage_->results_->header()->setResizeMode(QHeaderView::ResizeToContents);

#endif

delete model_;

model_ = newModel;

resultsPage_->setNoResults(model_->rowCount() == 0);

resultsPage_->emitCompletenessCheck();

}

void QtUserSearchWindow::setSelectedService(const JID& jid) {

myServer_ = jid;

}

void QtUserSearchWindow::handleJIDEditingDone() {

onJIDEditFieldChanged(JID(Q2PSTRING(firstPage_->jid_->text())));

}

void QtUserSearchWindow::setFirstPage(QString title) {

if (page(1) != nullptr) {

removePage(1);

}

firstPage_ = new QtUserSearchFirstPage(type_, title.isEmpty() ? firstPage_->title() : title, settings_);

connect(firstPage_->jid_, SIGNAL(textEdited(QString)), this, SLOT(handleContactSuggestionRequested(QString)));

connect(firstPage_->jid_, SIGNAL(textEdited(QString)), this, SLOT(handleJIDEditingDone()), Qt::UniqueConnection);

firstPage_->jid_->onUserSelected.connect(boost::bind(&QtUserSearchWindow::handleOnSearchedJIDSelected, this, _1));

connect(firstPage_->byJID_, SIGNAL(toggled(bool)), this, SLOT(handleFirstPageRadioChange()));

connect(firstPage_->byLocalSearch_, SIGNAL(toggled(bool)), this, SLOT(handleFirstPageRadioChange()));

connect(firstPage_->byRemoteSearch_, SIGNAL(toggled(bool)), this, SLOT(handleFirstPageRadioChange()));

#if QT_VERSION >= 0x040700

firstPage_->jid_->setPlaceholderText(tr("alice@wonderland.lit"));

#endif

firstPage_->service_->setEnabled(false);

setPage(1, firstPage_);

} else {

firstMultiJIDPage_ = new QtUserSearchFirstMultiJIDPage(type_, title.isEmpty() ? firstMultiJIDPage_->title() : title, settings_);

connect(firstMultiJIDPage_->addContactButton_, SIGNAL(clicked()), this, SLOT(addContact()));

connect(firstMultiJIDPage_->jid_, SIGNAL(textEdited(QString)), this, SLOT(handleContactSuggestionRequested(QString)));

firstMultiJIDPage_->jid_->onUserSelected.connect(boost::bind(&QtUserSearchWindow::addSearchedJIDToList, this, _1));

connect(firstMultiJIDPage_->addViaSearchButton_, SIGNAL(clicked()), this, SLOT(handleAddViaSearch()));

connect(firstMultiJIDPage_->contactList_, SIGNAL(onListChanged(std::vector<Contact::ref>)), this, SLOT(handleListChanged(std::vector<Contact::ref>)));

connect(firstMultiJIDPage_->contactList_, SIGNAL(onJIDsAdded(std::vector<JID>)), this, SLOT(handleJIDsAdded(std::vector<JID>)));

connect(firstMultiJIDPage_, SIGNAL(onJIDsDropped(std::vector<JID>)), this, SLOT(handleJIDsAdded(std::vector<JID>)));

setPage(1, firstMultiJIDPage_);

}

}

void QtUserSearchWindow::setSecondPage() {

if (page(2) != nullptr) {

removePage(2);

}

fieldsPage_ = new QtUserSearchFieldsPage();

fieldsPage_->fetchingThrobber_->setMovie(new QMovie(":/icons/throbber.gif", QByteArray(), this));

fieldsPage_->fetchingThrobber_->movie()->stop();

setPage(2, fieldsPage_);

}

void QtUserSearchWindow::setThirdPage() {

if (page(3) != nullptr) {

removePage(3);

}

resultsPage_ = new QtUserSearchResultsPage();

#ifdef SWIFT_PLATFORM_MACOSX

resultsPage_->results_->setAlternatingRowColors(true);

#endif

connect(resultsPage_, SIGNAL(onUserTriggersContinue()), this, SLOT(next()));

}

else {

connect(resultsPage_, SIGNAL(onUserTriggersContinue()), this, SLOT(next()));

}

setPage(3, resultsPage_);

}

void QtUserSearchWindow::clearForm() {

fieldsPage_->fetchingThrobber_->show();

fieldsPage_->fetchingThrobber_->movie()->start();

fieldsPage_->fetchingLabel_->show();

QWidget* legacySearchWidgets[8] = {fieldsPage_->nickInputLabel_, fieldsPage_->nickInput_, fieldsPage_->firstInputLabel_, fieldsPage_->firstInput_, fieldsPage_->lastInputLabel_, fieldsPage_->lastInput_, fieldsPage_->emailInputLabel_, fieldsPage_->emailInput_};

for (auto&& legacySearchWidget : legacySearchWidgets) {

legacySearchWidget->hide();

if (QLineEdit* edit = qobject_cast<QLineEdit*>(legacySearchWidget)) {

edit->clear();

}

}

fieldsPage_->emitCompletenessCheck();

}

void QtUserSearchWindow::clear() {

QString howText;

firstPage_->errorLabel_->setVisible(false);

howText = QString(tr("How would you like to find the user to add?"));

firstPage_->howLabel_->setText(howText);

firstPage_->byJID_->setChecked(true);

handleFirstPageRadioChange();

} else {

contactVector_.clear();

firstMultiJIDPage_->contactList_->setList(contactVector_);

firstMultiJIDPage_->errorLabel_->setVisible(false);

howText = QString(tr("List of participants:"));

howText = QString(tr("Who do you want to invite to the chat?"));

}

firstMultiJIDPage_->howLabel_->setText(howText);

}

clearForm();

resultsPage_->results_->setModel(nullptr);

delete model_;

model_ = nullptr;

restart();

lastPage_ = 1;

}

void QtUserSearchWindow::setError(const QString& error) {

if (error.isEmpty()) {

firstPage_->errorLabel_->hide();

} else {

firstMultiJIDPage_->errorLabel_->hide();

}

}

else {

firstPage_->errorLabel_->setText(QString("<font color='red'>%1</font>").arg(error));

firstPage_->errorLabel_->show();

} else {

firstMultiJIDPage_->errorLabel_->setText(QString("<font color='red'>%1</font>").arg(error));

firstMultiJIDPage_->errorLabel_->show();

}

restart();

lastPage_ = 1;

}

}

void QtUserSearchWindow::setSearchError(bool error) {

if (error) {

setError(tr("Error while searching"));

}

}

void QtUserSearchWindow::setServerSupportsSearch(bool support) {

if (!support) {

setError(tr("This server doesn't support searching for users."));

}

}

}